reight 0.1.2

data/lib/reight/project.rb

@@ -0,0 +1,115 @@
+using Reight
+
+
+class Reight::Project
+
+  def initialize(project_dir)
+    raise 'the project directory is required' unless project_dir
+    @project_dir = project_dir
+    @settings    = {}
+    load
+  end
+
+  attr_reader :project_dir, :settings
+
+  def project_path = "#{project_dir}/project.json"
+
+  def code_paths   = settings[__method__]&.then {[_1].flatten} || ['game.rb']
+
+  def codes()
+    code_paths.map {File.read _1 rescue nil}
+  end
+
+  def chips_json_name   = settings[__method__] || 'chips.json'
+
+  def chips_json_path   = "#{project_dir}/#{chips_json_name}"
+
+  def chips()
+    @chips ||= load_chips
+  end
+
+  def chips_image_name   = settings[__method__] || 'chips.png'
+
+  def chips_image_path   = "#{project_dir}/#{chips_image_name}"
+
+  def chips_image_width  = settings[__method__] || 1024
+
+  def chips_image_height = settings[__method__] || 1024
+
+  def chips_image()
+    @chips_image ||= -> {
+      create_graphics(chips_image_width, chips_image_height).tap do |g|
+        g.begin_draw {g.background 0, 0, 0}
+        img = load_image chips_image_path
+        g.begin_draw {g.image img, 0, 0}
+      rescue Rays::RaysError
+      end
+    }.call
+  end
+
+  def maps_json_name = settings[__method__] || 'maps.json'
+
+  def maps_json_path = "#{project_dir}/#{maps_json_name}"
+
+  def maps()
+    @maps ||= load_maps
+  end
+
+  def font           = @font ||= create_font(nil, font_size)
+
+  def font_size      = 8
+
+  def palette_colors = %w[
+    #000000 #1D2B53 #7E2553 #008751 #AB5236 #5F574F #C2C3C7 #FFF1E8
+    #FF004D #FFA300 #FFEC27 #00E436 #29ADFF #83769C #FF77A8 #FFCCAA
+  ]
+
+  def save()
+    File.write project_path, to_json_string(@settings)
+    save_chips
+    save_maps
+  end
+
+  private
+
+  def load()
+    @settings = JSON.parse File.read(project_path), symbolize_names: true
+  rescue Errno::ENOENT
+    @settings = {}
+  end
+
+  def save_chips()
+    File.write chips_json_path, to_json_string(chips.to_hash)
+  end
+
+  def load_chips()
+    if File.file? chips_json_path
+      json = JSON.parse File.read(chips_json_path), symbolize_names: true
+      Reight::ChipList.restore json, chips_image
+    else
+      Reight::ChipList.new chips_image
+    end
+  end
+
+  def save_maps()
+    File.write maps_json_path, to_json_string(maps.map {_1.to_hash})
+  end
+
+  def load_maps()
+    if File.file? maps_json_path
+      json = JSON.parse File.read(maps_json_path), symbolize_names: true
+      json.map {Reight::Map.restore _1, chips}
+    else
+      [Reight::Map.new]
+    end
+  end
+
+  def to_json_string(obj, readable: true)
+    if readable
+      JSON.pretty_generate obj
+    else
+      JSON.generate obj
+    end
+  end
+
+end# Project

data/lib/reight/reight.rb

@@ -0,0 +1,83 @@
+using Reight
+
+
+class Reight::R8
+
+  def initialize(path)
+    raise if $r8__
+    $r8__ = self
+
+    @path        = path
+    self.current = apps.first
+  end
+
+  attr_reader :current
+
+  def version()
+    '0.1'
+  end
+
+  def project()
+    @project ||= Reight::Project.new @path
+  end
+
+  def apps()
+    @apps ||= [
+      Reight::Runner.new(project),
+      Reight::SpriteEditor.new(project),
+      Reight::MapEditor.new(project),
+      Reight::SoundEditor.new(project),
+      Reight::MusicEditor.new(project)
+    ]
+  end
+
+  def flash(...) = current.flash(...)
+
+  def icons()
+    @icons ||= loadImage(File.expand_path('../../res/icons.png', __dir__)).tap do |img|
+      transp = color '#FF77A8'
+      img.load_pixels
+      img.pixels.map! {|c| c == transp ? color(0, 0, 0, 0) : c}
+      img.update_pixels
+    end
+  end
+
+  def current=(app)
+    return if app == @current
+    @current&.deactivated
+    @current = app
+    @current.activated
+
+    set_title [
+      self.class.name.split('::').first,
+      version,
+      '|',
+      current.class.name.split('::').last
+    ].join ' '
+  end
+
+  def setup()
+    w, h = Reight::App::SCREEN_WIDTH, Reight::App::SCREEN_HEIGHT
+    createCanvas w, h
+    window_resize(*[w, h].map {_1 * 3})
+    text_font r8.project.font, r8.project.font_size
+  end
+
+  def draw()           = current.draw
+  def key_pressed()    = current.key_pressed
+  def key_released()   = current.key_released
+  def key_typed()      = current.key_typed
+  def mouse_pressed()  = current.mouse_pressed
+  def mouse_released() = current.mouse_released
+  def mouse_moved()    = current.mouse_moved
+  def mouse_dragged()  = current.mouse_dragged
+  def mouse_clicked()  = current.mouse_clicked
+  def double_clicked() = current.double_clicked
+  def mouse_wheel()    = current.mouse_wheel
+  def touch_started()  = current.touch_started
+  def touch_ended()    = current.touch_ended
+  def touch_moved()    = current.touch_moved
+  def window_moved()   = apps.each {_1.window_moved}
+  def window_resized() = apps.each {_1.window_resized}
+
+end# R8

data/lib/reight.rb

@@ -0,0 +1,18 @@
+require 'json'
+require 'rubysketch/all'
+require 'reight/all'
+
+
+begin
+  w, c = Reight::WINDOW__, Reight::CONTEXT__
+
+  c.class.constants.reject {_1 =~ /__$/}.each do |const|
+    self.class.const_set const, c.class.const_get(const)
+  end
+
+  w.__send__ :begin_draw
+  at_exit do
+    w.__send__ :end_draw
+    Processing::App.new {w.show}.start if c.hasUserBlocks__ && !$!
+  end
+end

data/reight.gemspec

@@ -0,0 +1,40 @@
+# -*- mode: ruby -*-
+
+
+require_relative 'lib/reight/extension'
+
+
+Gem::Specification.new do |s|
+  glob = -> *patterns do
+    patterns.map {|pat| Dir.glob(pat).to_a}.flatten
+  end
+
+  ext   = Reight::Extension
+  name  = ext.name.downcase
+  rdocs = glob.call *%w[README]
+
+  s.name        = name
+  s.version     = ext.version
+  s.license     = 'MIT'
+  s.summary     = 'A Retro Game Engine for Ruby.'
+  s.description = 'A Retro Game Engine for Ruby.'
+  s.authors     = %w[xordog]
+  s.email       = 'xordog@gmail.com'
+  s.homepage    = "https://github.com/xord/reight"
+
+  s.platform              = Gem::Platform::RUBY
+  s.required_ruby_version = '>= 3.0.0'
+
+  s.add_dependency 'xot',        '~> 0.3.2', '>= 0.3.2'
+  s.add_dependency 'rucy',       '~> 0.3.2', '>= 0.3.2'
+  s.add_dependency 'beeps',      '~> 0.3.2', '>= 0.3.2'
+  s.add_dependency 'rays',       '~> 0.3.2', '>= 0.3.2'
+  s.add_dependency 'reflexion',  '~> 0.3.2', '>= 0.3.2'
+  s.add_dependency 'processing', '~> 1.1',   '>= 1.1.2'
+  s.add_dependency 'rubysketch', '~> 0.7.2', '>= 0.7.2'
+
+  s.files            = `git ls-files`.split $/
+  s.executables      = s.files.grep(%r{^bin/}) {|f| File.basename f}
+  s.test_files       = s.files.grep %r{^(test|spec|features)/}
+  s.extra_rdoc_files = rdocs.to_a
+end

data/test/helper.rb

@@ -0,0 +1,15 @@
+%w[../xot ../rucy ../beeps ../rays ../reflex ../processing ../rubysketch .]
+  .map  {|s| File.expand_path "../#{s}/lib", __dir__}
+  .each {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
+
+require 'xot/test'
+require 'rubysketch/all'
+require 'reight/all'
+
+require 'test/unit'
+
+include Xot::Test
+
+
+R8 = Reight
+RS = RubySketch

data/test/test_chip.rb

@@ -0,0 +1,108 @@
+require_relative 'helper'
+using Reight
+
+
+class TestChip < Test::Unit::TestCase
+
+  def chip(...)           = R8::Chip.new(...)
+
+  def image(w = 1, h = 1) = create_image w, h
+
+  def vec(...)            = create_vector(...)
+
+  def test_initialize()
+    assert_equal 1,            chip(1, image(2, 3), 4, 5, 6, 7)                .id
+    assert_equal [2, 3],       chip(1, image(2, 3), 4, 5, 6, 7)                .image.size
+    assert_equal [4, 5, 6, 7], chip(1, image(2, 3), 4, 5, 6, 7)                .frame
+    assert_nil                 chip(1, image(2, 3), 4, 5, 6, 7, pos: nil)      .pos
+    assert_equal vec(8, 9),    chip(1, image(2, 3), 4, 5, 6, 7, pos: vec(8, 9)).pos
+    assert_nil                 chip(1, image(2, 3), 4, 5, 6, 7)                .shape
+    assert_nil                 chip(1, image(2, 3), 4, 5, 6, 7, shape: nil)    .shape
+    assert_equal :rect,        chip(1, image(2, 3), 4, 5, 6, 7, shape: :rect)  .shape
+    assert_false               chip(1, image(2, 3), 4, 5, 6, 7)                .sensor?
+    assert_false               chip(1, image(2, 3), 4, 5, 6, 7, sensor: false) .sensor?
+    assert_true                chip(1, image(2, 3), 4, 5, 6, 7, sensor: true)  .sensor?
+  end
+
+  def test_with()
+    i23 = image 2, 3
+    assert_equal 9,           chip(1, i23, 4, 5, 6, 7)                .with(id: 9)             .id
+    assert_equal [8, 9],      chip(1, i23, 4, 5, 6, 7)                .with(image: image(8, 9)).image.size
+    assert_equal 9,           chip(1, i23, 4, 5, 6, 7)                .with(x: 9)              .x
+    assert_equal 9,           chip(1, i23, 4, 5, 6, 7)                .with(y: 9)              .y
+    assert_equal 9,           chip(1, i23, 4, 5, 6, 7)                .with(w: 9)              .w
+    assert_equal 9,           chip(1, i23, 4, 5, 6, 7)                .with(h: 9)              .h
+    assert_equal vec(10, 11), chip(1, i23, 4, 5, 6, 7, pos: nil)      .with(pos: vec(10, 11))  .pos
+    assert_equal vec(10, 11), chip(1, i23, 4, 5, 6, 7, pos: vec(8, 9)).with(pos: vec(10, 11))  .pos
+    assert_equal :rect,       chip(1, i23, 4, 5, 6, 7, shape: nil)    .with(shape: :rect)      .shape
+    assert_nil                chip(1, i23, 4, 5, 6, 7, shape: :rect)  .with(shape: nil)        .shape
+    assert_true               chip(1, i23, 4, 5, 6, 7, sensor: nil)   .with(sensor: true)      .sensor?
+    assert_false              chip(1, i23, 4, 5, 6, 7, sensor: nil)   .with(sensor: false)     .sensor?
+    assert_false              chip(1, i23, 4, 5, 6, 7, sensor: true)  .with(sensor: false)     .sensor?
+    assert_false              chip(1, i23, 4, 5, 6, 7, sensor: true)  .with(sensor: nil)       .sensor?
+
+    i2030 = image 20, 30
+    c1    = chip        1,         i23,      4,     5,     6,     7,  pos: nil,         shape: nil,   sensor: nil
+    c2    = c1.with id: 10, image: i2030, x: 40, y: 50, w: 60, h: 70, pos: vec(80, 90), shape: :rect, sensor: true
+    assert_equal chip(1,  i23,   4,  5,  6,  7,  pos: nil,         shape: nil,   sensor: nil),  c1
+    assert_equal chip(10, i2030, 40, 50, 60, 70, pos: vec(80, 90), shape: :rect, sensor: true), c2
+  end
+
+  def test_to_hash()
+    assert_equal(
+      {id: 1,           x: 4, y: 5, w: 6, h: 7},
+      chip(1, image(2, 3), 4,    5,    6,    7).to_hash)
+    assert_equal(
+      {id: 1,           x: 4, y: 5, w: 6, h: 7, pos:    [8, 9], shape: :rect, sensor: true},
+      chip(1, image(2, 3), 4,    5,    6,    7, pos: vec(8, 9), shape: :rect, sensor: true).to_hash)
+  end
+
+  def test_compare()
+    i = image 8, 9
+    assert_equal(
+      chip(1, i, 2, 3, 4, 5, pos: nil, shape: nil, sensor: false),
+      chip(1, i, 2, 3, 4, 5, pos: nil, shape: nil, sensor: false))
+    assert_equal(
+      chip(1, i, 2, 3, 4, 5, pos: vec(6, 7), shape: :rect, sensor: true),
+      chip(1, i, 2, 3, 4, 5, pos: vec(6, 7), shape: :rect, sensor: true))
+
+    assert_not_equal(
+      chip(1, i, 2, 3, 4, 5),
+      chip(0, i, 2, 3, 4, 5))
+    assert_not_equal(
+      chip(1, i, 2, 3, 4, 5),
+      chip(1, i, 0, 3, 4, 5))
+    assert_not_equal(
+      chip(1, i, 2, 3, 4, 5),
+      chip(1, i, 2, 0, 4, 5))
+    assert_not_equal(
+      chip(1, i, 2, 3, 4, 5),
+      chip(1, i, 2, 3, 0, 5))
+    assert_not_equal(
+      chip(1, i, 2, 3, 4, 5),
+      chip(1, i, 2, 3, 4, 0))
+    assert_not_equal(
+      chip(1, i,           2, 3, 4, 5),
+      chip(1, image(8, 9), 2, 3, 4, 5))
+    assert_not_equal(
+      chip(1, i, 2, 3, 4, 5),
+      chip(1, i, 2, 3, 4, 5, pos: vec(6, 7)))
+    assert_not_equal(
+      chip(1, i, 2, 3, 4, 5),
+      chip(1, i, 2, 3, 4, 5, shape: :rect))
+    assert_not_equal(
+      chip(1, i, 2, 3, 4, 5),
+      chip(1, i, 2, 3, 4, 5, sensor: true))
+  end
+
+  def test_restore()
+    img = image 8, 9
+    assert_equal(
+      chip(                 1, img, 2,    3,    4,    5, pos: nil, shape: nil, sensor: false),
+      R8::Chip.restore({id: 1,   x: 2, y: 3, w: 4, h: 5, pos: nil, shape: nil, sensor: false}, img))
+    assert_equal(
+      chip(                 1, img, 2,    3,    4,    5, pos: vec(6, 7), shape: :rect, sensor: true),
+      R8::Chip.restore({id: 1,   x: 2, y: 3, w: 4, h: 5, pos:    [6, 7], shape: :rect, sensor: true}, img))
+  end
+
+end# TestChip

data/test/test_chip_list.rb

@@ -0,0 +1,68 @@
+require_relative 'helper'
+using Reight
+
+
+class TestChipList < Test::Unit::TestCase
+
+  def chip(...)  = R8::Chip.new(...)
+
+  def chips(...) = R8::ChipList.new(...)
+
+  def image(w = 100, h = 100) = create_image w, h
+
+  def test_initialize()
+    i = image
+    assert_equal i, chips(i).image
+  end
+
+  def test_at()
+    i  = image
+    cs = chips i
+    assert_equal chip(1, i, 1, 2, 3, 4, shape: :rect), cs.at(1, 2, 3, 4)
+    assert_equal chip(2, i, 5, 6, 7, 8, shape: :rect), cs.at(5, 6, 7, 8)
+    assert_equal chip(1, i, 1, 2, 3, 4, shape: :rect), cs.at(1, 2, 3, 4)
+  end
+
+  def test_to_hash()
+    i  = image
+    cs = chips(i).tap do |o|
+      o.at 1, 2, 3, 4
+      o.at 5, 6, 7, 8
+    end
+    assert_equal(
+      {
+        next_id: 3,
+        chips: [
+          {id: 1, x: 1, y: 2, w: 3, h: 4, shape: :rect},
+          {id: 2, x: 5, y: 6, w: 7, h: 8, shape: :rect}
+        ]
+      },
+      cs.to_hash)
+  end
+
+  def test_compare()
+    i  = image
+    cs = chips(i).tap {_1.at 1, 2, 3, 4}
+
+    assert_equal cs, chips(i).tap {_1.at 1, 2, 3, 4}
+
+    assert_not_equal cs, chips(image 8, 9).tap {_1.at 0, 2, 3, 4}
+    assert_not_equal cs, chips(i)
+    assert_not_equal cs, chips(i)         .tap {_1.at 0, 2, 3, 4}
+    assert_not_equal cs, chips(i)         .tap {_1.at 1, 0, 3, 4}
+    assert_not_equal cs, chips(i)         .tap {_1.at 1, 2, 0, 4}
+    assert_not_equal cs, chips(i)         .tap {_1.at 1, 2, 3, 0}
+    assert_not_equal cs, chips(i).tap {
+      _1.at 1, 2, 3, 4
+      _1.at 5, 6, 7, 8
+    }
+  end
+
+  def test_restore()
+    img = image 8, 9
+    assert_equal(
+      chips(img).tap {                               _1.at 2,    3,    4,    5},
+      R8::ChipList.restore({next_id: 2, chips: [{id: 1, x: 2, y: 3, w: 4, h: 5, shape: :rect}]}, img))
+  end
+
+end# TestChipList

data/test/test_map.rb

@@ -0,0 +1,232 @@
+require_relative 'helper'
+using Reight
+
+
+class TestMap < Test::Unit::TestCase
+
+  def map(...)   = R8::Map.new(...)
+
+  def chunk(...) = R8::Map::Chunk.new(...)
+
+  def chip(x, y, w, h, id: 1, image: self.image, pos: nil) =
+    R8::Chip.new id, image, x, y, w, h, pos: pos
+
+  def image(w = 1, h = 1) = create_image w, h
+
+  def vec(...)            = create_vector(...)
+
+  def test_initialize()
+    assert_nothing_raised       {map chip_size: 2,   chunk_size: 6}
+    assert_raise(ArgumentError) {map chip_size: 2,   chunk_size: 7}
+    assert_raise(ArgumentError) {map chip_size: 2.2, chunk_size: 6}
+    assert_raise(ArgumentError) {map chip_size: 2,   chunk_size: 6.6}
+  end
+
+  def test_put()
+    img      = image
+    new_chip = -> id, size, pos: nil {
+      chip 0, 0, size, size, id: id, image: img, pos: pos
+    }
+
+    map(chip_size: 10, chunk_size: 30).tap do |m|
+      assert_equal 0, count_all_chips(m)
+    end
+
+    map(chip_size: 10, chunk_size: 30).tap do |m|
+      m.put 10, 20,     new_chip[1, 10]
+      assert_equal      new_chip[1, 10, pos: vec(10, 20)],   m[10, 20]
+      assert_equal 1, count_all_chips(m)
+    end
+
+    map(chip_size: 10, chunk_size: 30).tap do |m|
+      m.put(-10, -20,   new_chip[1, 10])
+      assert_equal      new_chip[1, 10, pos: vec(-10, -20)], m[-10, -20]
+      assert_equal 1, count_all_chips(m)
+    end
+
+    map(chip_size: 10, chunk_size: 30).tap do |m|
+      m.put 15, 25,     new_chip[2, 10]
+      assert_equal      new_chip[2, 10, pos: vec(10, 20)],   m[15, 25]
+      assert_equal      new_chip[2, 10, pos: vec(10, 20)],   m[10, 20]
+      assert_equal 1, count_all_chips(m)
+    end
+
+    map(chip_size: 10, chunk_size: 30).tap do |m|
+      m.put 10.1, 20.2, new_chip[3, 10]
+      assert_equal      new_chip[3, 10, pos: vec(10, 20)],   m[10.1, 20.2]
+      assert_equal      new_chip[3, 10, pos: vec(10, 20)],   m[10,   20]
+      assert_equal 1, count_all_chips(m)
+    end
+
+    map(chip_size: 10, chunk_size: 30).tap do |m|
+      m.put 15, 25,     new_chip[4, 20]
+      assert_equal      new_chip[4, 20, pos: vec(10, 20)],   m[15, 25]
+      assert_equal      new_chip[4, 20, pos: vec(10, 20)],   m[10, 20]
+      assert_equal      new_chip[4, 20, pos: vec(10, 20)],   m[25, 25]
+      assert_equal      new_chip[4, 20, pos: vec(10, 20)],   m[20, 20]
+      assert_equal      new_chip[4, 20, pos: vec(10, 20)],   m[15, 35]
+      assert_equal      new_chip[4, 20, pos: vec(10, 20)],   m[10, 30]
+      assert_equal      new_chip[4, 20, pos: vec(10, 20)],   m[25, 35]
+      assert_equal      new_chip[4, 20, pos: vec(10, 20)],   m[20, 30]
+      assert_equal 4, count_all_chips(m)
+
+      assert_equal     m[10, 20].object_id, m[20, 20].object_id
+      assert_equal     m[10, 30].object_id, m[20, 30].object_id
+      assert_not_equal m[10, 20].object_id, m[10, 30].object_id
+    end
+
+    map(chip_size: 10, chunk_size: 30).tap do |m|
+      assert_nothing_raised {m.put 10, 20, chip(0, 0, 10, 10)}
+      assert_raise          {m.put 10, 20, chip(0, 0, 10, 10)}
+    end
+  end
+
+  def test_delete()
+    [
+      [0, 0], [10, 20], [90, 90]
+    ].each do |xx, yy|
+      map(chip_size: 10, chunk_size: 30).tap do |m|
+        m.delete xx, yy
+        assert_equal 0, count_all_chips(m)
+      end
+    end
+
+    [
+      [10, 20, 0], [11, 21, 0], [15, 25, 0], [19, 29, 0],
+      [ 9, 19, 1], [20, 30, 1],
+      [19.999, 29.999, 0],
+      [ 9.999, 19.999, 1]
+    ].each do |xx, yy, count|
+      map(chip_size: 10, chunk_size: 30).tap do |m|
+        m.put 10, 20, chip(0, 0, 10, 10)
+        assert_equal 1,     count_all_chips(m)
+        m.delete xx, yy
+        assert_equal count, count_all_chips(m)
+      end
+    end
+
+    [
+      [10, 20, 0], [20, 20, 0], [10, 30, 0], [20, 30, 0],
+      [29, 30, 0], [20, 39, 0], [29, 39, 0],
+      [ 9, 19, 4], [30, 40, 4],
+      [29.999, 39.999, 0], [29.999, 30, 0], [20, 39.999, 0],
+      [ 9.999, 19.999, 4],
+    ].each do |xx, yy, count|
+      map(chip_size: 10, chunk_size: 30).tap do |m|
+        m.put 10, 20, chip(0, 0, 20, 20)
+        assert_equal 4,     count_all_chips(m)
+        m.delete xx, yy
+        assert_equal count, count_all_chips(m)
+      end
+    end
+  end
+
+  def test_delete_chip()
+    map(chip_size: 10, chunk_size: 30).tap do |m|
+      m.put           10, 20, chip(0, 0, 10, 10)
+      assert_equal 1, count_all_chips(m)
+      m.delete_chip m[10, 20]
+      assert_equal 0, count_all_chips(m)
+    end
+  end
+
+  def test_each_chip()
+    m           = map chip_size: 10, chunk_size: 30
+    m.put 10,  20,  chip(0, 0, 10, 10, id: 1)
+    m.put 20,  30,  chip(0, 0, 20, 20, id: 2)
+    m.put 100, 200, chip(0, 0, 10, 10, id: 3)
+
+    assert_equal(
+      [],
+      m.each_chip( 0,  0, 10, 20).map {|chip| [chip.id, chip.pos.x, chip.pos.y]})
+    assert_equal(
+      [[1, 10, 20]],
+      m.each_chip( 0,  0, 11, 21).map {|chip| [chip.id, chip.pos.x, chip.pos.y]})
+    assert_equal(
+      [],
+      m.each_chip(20, 20, 10, 10).map {|chip| [chip.id, chip.pos.x, chip.pos.y]})
+    assert_equal(
+      [[1, 10, 20]],
+      m.each_chip(19, 20, 10, 10).map {|chip| [chip.id, chip.pos.x, chip.pos.y]})
+    assert_equal(
+      [],
+      m.each_chip(10, 30, 10, 10).map {|chip| [chip.id, chip.pos.x, chip.pos.y]})
+    assert_equal(
+      [[1, 10, 20]],
+      m.each_chip(10, 29, 10, 10).map {|chip| [chip.id, chip.pos.x, chip.pos.y]})
+    assert_equal(
+      [[1, 10, 20]],
+      m.each_chip(0, 0, 30, 30).map {|chip| [chip.id, chip.pos.x, chip.pos.y]})
+    assert_equal(
+      [[1, 10, 20], [2, 20, 30]],
+      m.each_chip(0, 0, 31, 31).map {|chip| [chip.id, chip.pos.x, chip.pos.y]})
+    assert_equal(
+      [[1, 10, 20], [2, 20, 30], [3, 100, 200]],
+      m.each_chip              .map {|chip| [chip.id, chip.pos.x, chip.pos.y]})
+  end
+
+  def test_to_hash()
+    assert_equal(
+      {
+        chip_size: 10, chunk_size: 30,
+        chunks: [{x: 30, y: 30, w: 30, h: 30, chip_size: 10, chips: [nil,nil,nil, [1, 30, 40]]}]
+      },
+      map(chip_size: 10, chunk_size: 30).tap {_1.put 30, 40, chip(0, 0, 10, 10, id: 1)}.to_hash)
+  end
+
+  def test_compare()
+    assert_not_equal map(chip_size: 10, chunk_size: 20), map(chip_size: 1,  chunk_size: 20)
+    assert_not_equal map(chip_size: 10, chunk_size: 20), map(chip_size: 10, chunk_size: 10)
+
+    m1, m2 = map(chip_size: 10, chunk_size: 30), map(chip_size: 10, chunk_size: 30)
+    assert_equal m1, m2
+
+    img        = image
+    m1.put    10, 20, chip(0, 0, 10, 10, id: 1, image: img); assert_not_equal m1, m2
+    m2.put    10, 20, chip(0, 0, 10, 10, id: 1, image: img); assert_equal     m1, m2
+    m2.delete 10, 20
+    m2.put    10, 20, chip(0, 0, 10, 10, id: 2, image: img); assert_not_equal m1, m2
+  end
+
+  def test_restore()
+    img      = image
+    chips    = R8::ChipList.restore({
+      next_id: 3, chips: [
+        {id: 1, x: 0, y: 0, w: 10, h: 10},
+        {id: 2, x: 0, y: 0, w: 20, h: 20},
+      ]
+    }, img)
+    restored = R8::Map.restore({
+      chip_size: 10, chunk_size: 30, chunks: [
+        {
+          x: 0,  y: 0, w: 30, h: 30, chip_size: 10,
+          chips: [nil,nil,nil, nil,nil,[2,20,10], nil,[1,10,20],[2,20,10]]
+        },
+        {
+          x: 30, y: 0, w: 30, h: 30, chip_size: 10,
+          chips: [nil,nil,nil, [2,20,10],nil,nil, [2,20,10]]
+        },
+      ]
+    }, chips)
+
+    assert_equal(
+      map(chip_size: 10, chunk_size: 30).tap {
+        _1.put 10, 20, chip(0, 0, 10, 10, id: 1, image: img)
+        _1.put 20, 10, chip(0, 0, 20, 20, id: 2, image: img)
+      },
+      restored)
+    assert_equal     restored[20, 10].object_id, restored[20, 20].object_id
+    assert_equal     restored[30, 10].object_id, restored[30, 20].object_id
+    assert_not_equal restored[20, 10].object_id, restored[30, 10].object_id
+  end
+
+  private
+
+  def count_all_chips(map_, map_size = 90, chip_size: 10)
+    range = (-map_size...map_size).step(chip_size).to_a
+    range.product(range)
+      .map {|x, y| map_[x, y]}
+      .count {_1 != nil}
+  end
+
+end# TestMap