reight 0.1.5 → 0.1.7

data/lib/reight/context.rb

@@ -0,0 +1,168 @@
+module Reight::Context
+
+  include Processing::GraphicsContext
+  include RubySketch::GraphicsContext
+
+  TIMER_PREFIX__ = '__r8__'
+
+  # @private
+  def initialize(rootContext, project)
+    @rootContext__, @project__ = rootContext, project
+    init__ Rays::Image.new(@rootContext__.width, @rootContext__.height)
+  end
+
+  # Returns the project object.
+  #
+  def project()
+    @project__
+  end
+
+  # @private
+  def screenOffset(*args)
+    unless args.empty?
+      args    = args.flatten
+      x, y, z =
+        case arg = args.first
+        when Vector  then [arg.x,   arg.y,        arg.z]
+        when Numeric then [args[0], args[1] || 0, args[2] || 0]
+        when nil     then [0,       0,            0]
+        else raise ArgumentError
+        end
+      cx, cy, = @canvasFrame__
+      if cx && cy
+        zoom = spriteWorld__.zoom
+        x   += cx / zoom
+        y   += cy / zoom
+      end
+      spriteWorld__.offset = [x, y, z]
+    end
+    spriteWorld__.offset
+  end
+
+  # @see https://rubydoc.info/gems/rubysketch/RubySketch/Context#size-instance_method
+  def size(width, height, **)
+    return if width == self.width || height == self.height
+    @resizeCanvas__ = [width, height]
+  end
+
+  # @see https://rubydoc.info/gems/rubysketch/RubySketch/Context#createCanvas-instance_method
+  alias createCanvas size
+
+  # @see https://www.rubydoc.info/gems/processing/Processing/Context#mouseX-instance_method
+  def mouseX()
+    x, (cx, _) = @rootContext__.mouseX,  @canvasFrame__
+    cx ? (x - cx) / spriteWorld__.zoom : x
+  end
+
+  # @see https://www.rubydoc.info/gems/processing/Processing/Context#mouseY-instance_method
+  def mouseY()
+    y, (_, cy) = @rootContext__.mouseY,  @canvasFrame__
+    cy ? (y - cy) / spriteWorld__.zoom : y
+  end
+
+  # @see https://www.rubydoc.info/gems/processing/Processing/Context#pmouseX-instance_method
+  def pmouseX()
+    x, (cx, _) = @rootContext__.pmouseX, @canvasFrame__
+    cx ? (x - cx) / spriteWorld__.zoom : x
+  end
+
+  # @see https://www.rubydoc.info/gems/processing/Processing/Context#pmouseY-instance_method
+  def pmouseY()
+    y, (_, cy) = @rootContext__.pmouseY, @canvasFrame__
+    cy ? (y - cy) / spriteWorld__.zoom : y
+  end
+
+  # @see https://rubydoc.info/gems/rubysketch/RubySketch/Context#createSprite-instance_method
+  def createSprite(*args, klass: nil, **kwargs, &block)
+    klass ||= Reight::Sprite
+    spriteWorld__.createSprite(*args, klass: klass, **kwargs, &block)
+  end
+
+  # @see https://rubydoc.info/gems/rubysketch/RubySketch/Context#addSprite-instance_method
+  def addSprite(...)
+    spriteWorld__.addSprite(...)
+  end
+
+  # @see https://rubydoc.info/gems/rubysketch/RubySketch/Context#removeSprite-instance_method
+  def removeSprite(...)
+    spriteWorld__.removeSprite(...)
+  end
+
+  # @see https://rubydoc.info/gems/rubysketch/RubySketch/Context#gravity-instance_method
+  def gravity(...)
+    spriteWorld__.gravity(...)
+  end
+
+  # @see https://rubydoc.info/gems/rubysketch/RubySketch/Context#setTimeout-instance_method
+  def setTimeout( *a, id: @rootContext__.nextTimerID__, **k, &b)
+    id = [TIMER_PREFIX__, id]
+    @rootContext__.setTimeout(*a, id: id, **k, &b)
+  end
+
+  # @see https://rubydoc.info/gems/rubysketch/RubySketch/Context#setInterval-instance_method
+  def setInterval(*a, id: @rootContext__.nextTimerID__, **k, &b)
+    id = [TIMER_PREFIX__, id]
+    @rootContext__.setInterval(*a, id: id, **k, &b)
+  end
+
+  # @see https://rubydoc.info/gems/rubysketch/RubySketch/Context#clearTimer-instance_method
+  def clearTimer(id)
+    @rootContext__.clearTimer [TIMER_PREFIX__, id]
+  end
+
+  # @see https://rubydoc.info/gems/rubysketch/RubySketch/Context#clearTimeout-instance_method
+  def clearTimeout(id)
+    @rootContext__.clearTimeout [TIMER_PREFIX__, id]
+  end
+
+  # @see https://rubydoc.info/gems/rubysketch/RubySketch/Context#clearInterval-instance_method
+  def clearInterval(id)
+    @rootContext__.clearInterval [TIMER_PREFIX__, id]
+  end
+
+  # @private
+  def beginDraw__()
+    super
+    @painter__.__send__ :begin_paint
+  end
+
+  # @private
+  def endDraw__()
+    @painter__.__send__ :end_paint
+    super
+    resizeCanvas__
+  end
+
+  # @private
+  def spriteWorld__()
+    @spriteWorld__ ||= SpriteWorld.new(pixelsPerMeter: 8)
+  end
+
+  # @private
+  def resizeCanvas__()
+    w, h            = @resizeCanvas__ || return
+    @resizeCanvas__ = nil
+    updateCanvas__ Rays::Image.new(w.to_i, h.to_i)
+
+    rootw, rooth = @rootContext__.width, @rootContext__.height
+    if w == rootw && h == rooth
+      @canvasFrame__ = nil
+    else
+      wide           = w.to_f / h >= rootw.to_f / rooth
+      canvasw        = wide ? rootw                : rooth * (w.to_f / h)
+      canvash        = wide ? rootw * (h.to_f / w) : rooth
+      @canvasFrame__ = [
+        (rootw - canvasw) / 2,
+        (rooth - canvash) / 2,
+        canvasw,
+        canvash
+      ].map(&:to_i)
+    end
+
+    spriteWorld__.zoom = wide ? rootw.to_f / w : rooth.to_f / h
+  end
+
+  # @private
+  attr_reader :canvasFrame__
+
+end# Context

data/lib/reight/helpers.rb

@@ -33,8 +33,8 @@ module Reight::Hookable
         @hookable_hooks ||= {}
         (@hookable_hooks[name] ||= []).push block
       end
-      singleton_class.__send__ :define_method, "#{name}!" do |*args|
-        @hookable_hooks&.[](name)&.each {|block| block.call(*args)}
+      singleton_class.__send__ :define_method, "#{name}!" do |*args, &block|
+        @hookable_hooks&.[](name)&.each {_1.call(*args, &block)}
       end
     end
   end

data/lib/reight/index.rb

@@ -0,0 +1,76 @@
+using Reight
+
+
+class Reight::Index
+
+  include Reight::Activatable
+  include Reight::Hookable
+  include Reight::HasHelp
+
+  def initialize(index = 0, &changed)
+    super()
+    @index = index
+
+    hook :changed
+    self.changed(&changed) if changed
+  end
+
+  attr_reader :index
+
+  def draw()
+    sp                 = sprite
+    button_w, button_h = sp.h, sp.h
+
+    no_stroke
+
+    fill 230
+    if pressing? && prev?
+      rect 0,        0, sp.w / 2, button_h
+    elsif pressing? && next?
+      rect sp.w / 2, 0, sp.w / 2, button_h
+    end
+
+    fill 50
+    text_align CENTER, CENTER
+    text '<',   0,               0, button_w, button_h
+    text '>',   sp.w - button_w, 0, button_w, button_h
+    text index, 0,               0, sp.w,     sp.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()
+    old     = @index
+    @index += 1 if next?
+    @index -= 1 if prev?
+    @index  = 0 if @index < 0
+    changed! @index if @index != old
+  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,30 @@ class Reight::Map
     chunk_at(x, y)&.[](x, y)
   end
 
-  def <=>(o)
+  # @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 +169,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 +186,16 @@ class Reight::Map::Chunk
 
   attr_reader :x, :y, :w, :h
 
+  def sprites()
+    @sprites ||= map {|chip|
+      chip.to_sprite.tap {|sp| sp.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 +208,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 +249,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 +266,40 @@ class Reight::Map::Chunk
     @chips[index]
   end
 
-  def <=>(o)
+  # @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 +338,47 @@ 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 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
@@ -55,19 +59,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 +119,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

@@ -26,8 +26,7 @@ class Reight::R8
       Reight::Runner.new(project),
       Reight::SpriteEditor.new(project),
       Reight::MapEditor.new(project),
-      Reight::SoundEditor.new(project),
-      Reight::MusicEditor.new(project)
+      Reight::SoundEditor.new(project)
     ]
   end
 
@@ -43,7 +42,6 @@ class Reight::R8
   end
 
   def current=(app)
-    return if app == @current
     @current&.deactivated
     @current = app
     @current.activated