reight 0.1.6 → 0.1.8

data/lib/reight/index.rb

@@ -0,0 +1,87 @@
+using Reight
+
+
+class Reight::Index
+
+  include Reight::Activatable
+  include Reight::Hookable
+  include Reight::HasHelp
+
+  def initialize(index = 0, min: 0, max: nil, &changed)
+    hook :changed
+
+    super()
+    @min, @max = min, max
+
+    self.changed(&changed) if changed
+    self.index = index
+  end
+
+  attr_reader :index
+
+  def index=(index)
+    index = index.clamp(@max ? (@min..@max) : (@min..))
+    return if index == @index
+    @index = index.to_i
+    changed! @index
+  end
+
+  def draw()
+    no_stroke
+
+    sp   = sprite
+    w, h = sp.w, sp.h
+    dec  = pressing? && prev?
+    inc  = pressing? && next?
+    decy = dec ? 1 : 0
+    incy = inc ? 1 : 0
+
+    fill 220
+    rect 0,     decy, h, h, 2 if dec
+    rect w - h, incy, h, h, 2 if inc
+
+    text_align CENTER, CENTER
+    fill 220
+    text '<',   0,     decy + 1, h, h
+    text '>',   w - h, incy + 1, h, h
+    text index, 0,     1,        w, h
+    fill 50
+    text '<',   0,     decy,     h, h
+    text '>',   w - h, incy,     h, h
+    text index, 0,     0,        w, h
+  end
+
+  def prev? = sprite.mouse_x < sprite.w / 2
+
+  def next? = !prev?
+
+  def pressed(x, y)
+    @pressing = true
+  end
+
+  def released(x, y)
+    @pressing = false
+  end
+
+  def pressing? = @pressing
+
+  def hover(x, y)
+    r8.flash x < (sprite.w / 2) ? 'Prev' : 'Next'
+  end
+
+  def clicked()
+    self.index += 1 if next?
+    self.index -= 1 if prev?
+  end
+
+  def sprite()
+    @sprite ||= RubySketch::Sprite.new(physics: false).tap do |sp|
+      sp.draw           {draw}
+      sp.mouse_pressed  {pressed  sp.mouse_x, sp.mouse_y}
+      sp.mouse_released {released sp.mouse_x, sp.mouse_y}
+      sp.mouse_moved    {hover    sp.mouse_x, sp.mouse_y}
+      sp.mouse_clicked  {clicked}
+    end
+  end
+
+end# Index

data/lib/reight/map.rb

@@ -12,10 +12,32 @@ class Reight::Map
     raise ArgumentError, "Invalid chunk_size: #{chunk_size}" if
       chunk_size.to_i != chunk_size || chunk_size % chip_size != 0
 
-    @chip_size, @chunk_size = [chip_size, chunk_size].map &:to_i
+    @chip_size, @chunk_size = [chip_size, chunk_size].map(&:to_i)
     @chunks                 = {}
   end
 
+  def activate(x, y, w, h, world = nil, &activated)
+    @sprites   = nil if !activated && @sprites && @sprites.world != world
+    @sprites ||= SpriteArray.new(world: world) {|*a, &b| each_chunk(*a, &b)}
+    @sprites.activate(x, y, w, h, &activated)
+    @sprites
+  end
+
+  def to_sprites()
+    map(&:to_sprite)
+  end
+
+  def sprites()
+    @sprites ||= SpriteArray.new(sprites: to_sprites)
+  end
+
+  alias sprites_at activate
+
+  def clear_sprites()
+    @chunks.each_value {_1&.clear_sprites}
+    @sprites = nil
+  end
+
   def put(x, y, chip)
     return unless chip
     each_chunk x, y, chip.w, chip.h, create: true do |chunk|
@@ -23,16 +45,16 @@ class Reight::Map
     end
   end
 
-  def delete(x, y)
+  def remove(x, y)
     chip           = self[x, y] or return
     cx, cy, cw, ch = chip.then {[_1.pos.x, _1.pos.y, _1.w, _1.h]}
     each_chunk cx, cy, cw, ch, create: false do |chunk|
-      each_chip_pos(cx, cy, cw, ch) {|xx, yy| chunk.delete xx, yy}
+      each_chip_pos(cx, cy, cw, ch) {|xx, yy| chunk.remove xx, yy}
     end
   end
 
-  def delete_chip(chip)
-    delete chip.pos.x, chip.pos.y
+  def remove_chip(chip)
+    remove chip.pos.x, chip.pos.y
   end
 
   def each_chip(x = nil, y = nil, w = nil, h = nil, clip_by_chunk: false, &block)
@@ -62,18 +84,34 @@ class Reight::Map
     chunk_at(x, y)&.[](x, y)
   end
 
-  def <=>(o)
+  def inspect()
+    "#<#{self.class.name}:0x#{object_id}>"
+  end
+
+  # @private
+  def cmp__(o)
     a =                  [@chip_size, @chunk_size, @chunks]
     b = o.instance_eval {[@chip_size, @chunk_size, @chunks]}
     a <=> b
   end
 
+  # @private
+  def drawSprite__(context)
+    if @sprites
+      @sprites.drawSprite__ context
+    else
+      @chunks.each_value {_1.drawSprite__ context}
+    end
+  end
+
   def self.restore(hash, source_chips)
-    hash => {chip_size:, chunk_size:, chunks:}
+    chip_size, chunk_size, chunks = hash.values_at :chip_size, :chunk_size, :chunks
+    #hash => {chip_size:, chunk_size:, chunks:}
     new(chip_size: chip_size, chunk_size: chunk_size).tap do |obj|
       obj.instance_eval do
         @chunks = chunks.each.with_object({}) do |chunk_hash, result|
-          chunk_hash => {x:, y:}
+          x, y = chunk_hash.values_at :x, :y
+          #chunk_hash => {x:, y:}
           result[[x, y]] = Chunk.restore chunk_hash, source_chips
         end
       end
@@ -135,8 +173,10 @@ class Reight::Map
 end# Map
 
 
+# @private
 class Reight::Map::Chunk
 
+  include Enumerable
   include Comparable
 
   def initialize(x, y, w, h, chip_size: 8)
@@ -150,6 +190,14 @@ class Reight::Map::Chunk
 
   attr_reader :x, :y, :w, :h
 
+  def sprites()
+    @sprites ||= map(&:sprite).each {_1.map_chunk = self}
+  end
+
+  def clear_sprites()
+    @sprites = nil
+  end
+
   def put(x, y, chip)
     x, y = align_chip_pos x, y
     raise "Invalid chip size" if
@@ -162,15 +210,17 @@ class Reight::Map::Chunk
     each_chip_pos x, y, chip.w, chip.h do |xx, yy|
       @chips[pos2index xx, yy] = get_chip.call
     end
+    invalidate_cache__
   end
 
-  def delete(x, y)
+  def remove(x, y)
     chip = self[x, y] or return
     each_chip_pos chip.pos.x, chip.pos.y, chip.w, chip.h do |xx, yy|
       index         = pos2index xx, yy
       @chips[index] = nil if @chips[index]&.id == chip.id
     end
     delete_last_nils
+    invalidate_cache__
   end
 
   def each_chip(x = nil, y = nil, w = nil, h = nil, include_hidden: false, &block)
@@ -201,6 +251,8 @@ class Reight::Map::Chunk
     end
   end
 
+  def each(&block) = each_chip {block.call _1}
+
   def frame = [@x, @y, @w, @h]
 
   def to_hash()
@@ -216,14 +268,44 @@ class Reight::Map::Chunk
     @chips[index]
   end
 
-  def <=>(o)
+  def inspect()
+    "#<#{self.class.name}:0x#{object_id}>"
+  end
+
+  # @private
+  def cmp__(o)
     a =                  [@x, @y, @w, @h, @chip_size, @chips]
     b = o.instance_eval {[@x, @y, @w, @h, @chip_size, @chips]}
     a <=> b
   end
 
+  # @private
+  def invalidate_cache__()
+    @cached = false
+  end
+
+  # @private
+  def drawSprite__(context)
+    @cached ||= true.tap do
+      @cache ||= create_graphics @w, @h
+      @cache.begin_draw do |g|
+        g.background 0, 0
+        g.translate -@x, -@y
+        sprites.each {_1.drawSprite__ g}
+      end
+    end
+    context.image @cache, @x, @y
+  end
+
+  # @private
+  def delete_sprite__(sprite)
+    @sprites.delete sprite
+    invalidate_cache__
+  end
+
   def self.restore(hash, source_chips)
-    hash      => {x:, y:, w:, h:, chip_size: chip_size, chips: chip_ids}
+    x, y, w, h, chip_size, chip_ids = hash.values_at :x, :y, :w, :h, :chip_size, :chips
+    #hash      => {x:, y:, w:, h:, chip_size: chip_size, chips: chip_ids}
     tmp_chips = {}
     get_chip  = -> id, x, y {
       tmp_chips[[id, x, y]] ||= source_chips[id].with(pos: create_vector(x, y))
@@ -262,3 +344,51 @@ class Reight::Map::Chunk
   end
 
 end# Chunk
+
+
+# @private
+class Reight::Map::SpriteArray < Array
+
+  def initialize(world: nil, sprites: [], &each_chunk)
+    @world, @each_chunk = world, each_chunk
+    super(sprites)
+  end
+
+  attr_reader :world
+
+  def activate(x, y, w, h, &activated)
+    raise ArgumentError, "missing 'activated' block" if !@world && !activated
+
+    bounds, old_bounds = [x, y, w, h], @bounds
+    return if bounds == old_bounds
+
+    chunks, old_chunks = @each_chunk.call(x, y, w, h).to_a, @chunks || []
+    return if chunks == old_chunks
+
+    activateds, deactivateds = [chunks - old_chunks, old_chunks - chunks]
+      .map {|chunks| chunks.map(&:sprites).flatten.compact}
+    if activated
+      activated.call activateds, deactivateds
+    elsif @world
+        activateds.each {@world   .add_sprite _1}
+      deactivateds.each {@world.remove_sprite _1}
+    end
+
+    @bounds, @chunks = bounds, chunks
+    clear.concat @chunks.map(&:sprites).flatten.compact
+  end
+
+  def delete(sprite)
+    sprite.map_chunk&.delete_sprite__ sprite
+    super
+  end
+
+  def inspect()
+    "#<#{self.class.name}:0x#{object_id}>"
+  end
+
+  def drawSprite__(context)
+    (@chunks&.each || each).each {_1.drawSprite__ context}
+  end
+
+end# SpriteArray

data/lib/reight/project.rb

@@ -3,6 +3,8 @@ using Reight
 
 class Reight::Project
 
+  include Xot::Inspectable
+
   def initialize(project_dir)
     raise 'the project directory is required' unless project_dir
     @project_dir = project_dir
@@ -17,7 +19,9 @@ class Reight::Project
   def code_paths   = settings[__method__]&.then {[_1].flatten} || ['game.rb']
 
   def codes()
-    code_paths.map {File.read _1 rescue nil}
+    code_paths
+      .map {File.expand_path _1, project_dir}
+      .map {File.read _1 rescue nil}
   end
 
   def chips_json_name   = settings[__method__] || 'chips.json'
@@ -39,7 +43,7 @@ class Reight::Project
   def chips_image()
     @chips_image ||= -> {
       create_graphics(chips_image_width, chips_image_height).tap do |g|
-        g.begin_draw {g.background 0, 0, 0}
+        g.begin_draw {g.background 0, 0, 0, 0}
         img = load_image chips_image_path
         g.begin_draw {g.image img, 0, 0}
       rescue Rays::RaysError
@@ -47,6 +51,17 @@ class Reight::Project
     }.call
   end
 
+  def chips_page_width  = settings[__method__] || 256
+
+  def chips_page_height = settings[__method__] || 256
+
+  def chips_npages()
+    w = chips_image_width  / chips_page_width .to_f
+    h = chips_image_height / chips_page_height.to_f
+    raise unless w == w.to_i && h == h.to_i
+    (w * h).to_i
+  end
+
   def maps_json_name = settings[__method__] || 'maps.json'
 
   def maps_json_path = "#{project_dir}/#{maps_json_name}"
@@ -55,19 +70,30 @@ class Reight::Project
     @maps ||= load_maps
   end
 
+  def sounds_json_name = settings[__method__] || 'sounds.json'
+
+  def sounds_json_path = "#{project_dir}/#{sounds_json_name}"
+
+  def sounds()
+    @sounds ||= load_sounds
+  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 palette_colors = Reight::App::PALETTE_COLORS.dup
+
+  def clear_all_sprites()
+    chips.each(&:clear_sprite)
+    maps.each(&:clear_sprites)
+  end
 
   def save()
     File.write project_path, to_json_string(@settings)
     save_chips
     save_maps
+    save_sounds
   end
 
   private
@@ -104,6 +130,19 @@ class Reight::Project
     end
   end
 
+  def save_sounds()
+    File.write sounds_json_path, to_json_string(sounds.map {_1.to_hash})
+  end
+
+  def load_sounds()
+    if File.file? sounds_json_path
+      json = JSON.parse File.read(sounds_json_path), symbolize_names: true
+      json.map {Reight::Sound.restore _1}
+    else
+      [Reight::Sound.new]
+    end
+  end
+
   def to_json_string(obj, readable: true)
     if readable
       JSON.pretty_generate obj

data/lib/reight/reight.rb

@@ -3,32 +3,29 @@ using Reight
 
 class Reight::R8
 
-  def initialize(path)
+  def initialize(path, edit: false)
     raise if $r8__
     $r8__ = self
 
-    @path        = path
+    @path, @edit = path, edit
     self.current = apps.first
   end
 
   attr_reader :current
 
-  def version()
-    '0.1'
-  end
+  def edit? = @edit
 
   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)
-    ]
+    @apps ||= [].tap {|a|
+      a << Reight::Runner      .new(project)
+      a << Reight::SpriteEditor.new(project) if edit?
+      a << Reight::MapEditor   .new(project) if edit?
+      a << Reight::SoundEditor .new(project) if edit?
+    }
   end
 
   def flash(...) = current.flash(...)
@@ -43,16 +40,15 @@ class Reight::R8
   end
 
   def current=(app)
-    return if app == @current
     @current&.deactivated
     @current = app
     @current.activated
 
     set_title [
       self.class.name.split('::').first,
-      version,
+      Reight::Extension.version,
       '|',
-      current.class.name.split('::').last
+      current.label
     ].join ' '
   end