reight 0.1.6 → 0.1.8

data/lib/reight/sound.rb

@@ -0,0 +1,238 @@
+using Reight
+
+
+class Reight::Sound
+
+  include Enumerable
+
+  BPM_MAX = 999
+
+  def initialize(bpm = 120)
+    @bpm      = bpm
+    @sequence = [[]]
+  end
+
+  attr_reader :bpm
+
+  def bpm=(bpm)
+    raise ArgumentError, "Invalid bpm: #{bpm}"                            if bpm <= 0
+    raise ArgumentError, "bpm exceeds the max value (#{BPM_MAX}): #{bpm}" if bpm >  999
+    @bpm = bpm
+  end
+
+  def play(gain: 1.0, &block)
+    return block&.call false if empty?
+    stop
+    @playing = sound = to_sound
+    sound.play gain: gain
+
+    if block
+      id = "__sound_playing_check_#{sound.object_id}"
+      set_interval 0.1, id: id do
+        next if sound.playing? == true
+        block.call true
+        clear_interval id
+      end
+    end
+  end
+
+  def stop()
+    @playing&.stop
+    @playing = nil
+  end
+
+  def clear()
+    @sequence = [[]]
+  end
+
+  def add_note(time_index, note_index, tone)
+    raise 'The note already exists' if note_at time_index, note_index
+    (@sequence[time_index] ||= []) << Note.new(note_index, tone)
+  end
+
+  def remove_note(time_index, note_index)
+    @sequence[time_index]&.delete_if {_1.index == note_index}
+  end
+
+  def note_at(time_index, note_index)
+    @sequence[time_index]&.find {_1.index == note_index}
+  end
+
+  def each_note(time_index: nil, &block)
+    return enum_for :each_note, time_index: time_index unless block
+    if time_index
+      @sequence[time_index]&.each do |note|
+        block.call note, time_index
+      end
+    else
+      @sequence.each.with_index do |notes, time_i|
+        notes&.each do |note|
+          block.call note, time_i
+        end
+      end
+    end
+  end
+
+  alias    add    add_note
+  alias remove remove_note
+  alias     at        note_at
+  alias   each   each_note
+
+  def playing?()
+    @playing = nil if @playing&.playing? == false
+    !!@playing
+  end
+
+  def empty? = @sequence.all? {!_1 || _1.empty?}
+
+  def to_hash()
+    {
+      bpm:      @bpm,
+      sequence: @sequence.map {|notes| notes&.map {_1.to_hash}}
+    }
+  end
+
+  def self.restore(hash)
+    bpm, sequence = hash.values_at :bpm, :sequence
+    #hash => {bpm:, sequence:}
+    new(bpm).tap do |obj|
+      obj.instance_eval do
+        @sequence = sequence.map do |notes|
+          notes&.map {Note.restore _1}
+        end
+      end
+    end
+  end
+
+  private
+
+  def to_sound()
+    RubySketch::Sound.new Beeps::Sound.new(*sequencer)
+  end
+
+  def sequencer()
+    seq   = Beeps::Sequencer.new
+    time  = 0
+    prevs = {}
+    @sequence.each do |notes|
+      sec       = Note.seconds 4, @bpm
+      new_prevs = {}
+      notes&.each do |note|
+        osc       = Note.oscillator note.tone, 32
+        osc.freq  = note.frequency
+        osc.phase = osc.freq * time
+        env       = Note.envelope sec
+        seq.add osc >> env, time, sec
+
+        new_prevs[note.tone] = [note.index, env, sec]
+        pindex, penv, psec   = prevs[note.tone]
+
+        if pindex && pindex == note.index
+           env.attack  = 0
+          penv.release = 0
+          penv.note_off psec * 2# skip release phase
+        end
+      end
+      time += sec
+      prevs = new_prevs
+    end
+    return seq >> Note.gain, time
+  end
+
+end# Sound
+
+
+class Reight::Sound::Note
+
+  MAX   = 127
+
+  TONES = %i[
+    sine triangle square sawtooth pulse12_5 pulse25 noise
+  ]
+
+  def initialize(index, tone = TONES.first)
+    raise "Invalid note index: #{index}" unless (0..MAX).include? index
+    raise "Invalid tone: #{tone}"        unless    TONES.include? tone
+    @index, @tone = index, tone
+  end
+
+  attr_reader :index, :tone
+
+  def play(bpm)
+    to_sound(bpm).play
+  end
+
+  def frequency()
+    440 * (2 ** ((@index - 69).to_f / 12))
+  end
+
+  INDEX2NOTE = -> {
+    notes   = %w[ c c+ d d+ e f f+ g g+ a a+ b ].map {_1.sub '+', '#'}
+    octaves = (-1..9).to_a
+    octaves.product(notes)
+      .each_with_object({}).with_index do |((octave, note), hash), index|
+        hash[index] = "#{note}#{octave}"
+      end
+  }.call
+
+  def to_s()
+    "#{INDEX2NOTE[@index]}:#{@tone}"
+  end
+
+  def to_hash()
+    {index: @index, tone: TONES.index(@tone)}
+  end
+
+  def to_sound(bpm)
+    osc  = self.class.oscillator tone, 32, freq: frequency
+    sec  = self.class.seconds 4, bpm
+    seq  = Beeps::Sequencer.new.tap {_1.add osc, 0, sec}
+    env  = self.class.envelope sec
+    gain = self.class.gain
+    RubySketch::Sound.new Beeps::Sound.new(seq >> env >> gain, sec)
+  end
+
+  def self.oscillator(type, size, **kwargs)
+    case type
+    when :noise then Beeps::Oscillator.new type, **kwargs
+    else
+      samples = (@samples ||= {})[type] ||= create_samples type, size
+      Beeps::Oscillator.new samples: samples, **kwargs
+    end
+  end
+
+  def self.create_samples(type, size)
+    input = size.times.map {_1.to_f / size}
+    duty  = {pulse12_5: 0.125, pulse25: 0.25, pulse75: 0.75}[type] || 0.5
+    case type
+    when :sine     then input.map {Math.sin _1 * Math::PI * 2}
+    when :triangle then input.map {_1 < 0.5 ? _1 * 4 - 1 : 3 - _1 * 4}
+    when :sawtooth then input.map {_1 * 2 - 1}
+    else                input.map {_1 < duty ? 1 : -1}
+    end
+  end
+
+  def self.envelope(seconds)
+    Beeps::Envelope.new release: seconds * 0.05 do
+      note_on
+      note_off seconds * 0.95
+    end
+  end
+
+  def self.gain(gain = 0.2)
+    Beeps::Gain.new gain
+  end
+
+  def self.seconds(length, bpm)
+    raise ArgumentError, "Invalid length: #{length}" if length <= 0
+    raise ArgumentError, "Invalid bpm: #{bpm}"       if bpm    <= 0
+    60.0 / bpm / length
+  end
+
+  def self.restore(hash)
+    index, tone = hash.values_at :index, :tone
+    #hash => {index:, tone:}
+    new index, TONES[tone]
+  end
+
+end# Note

data/lib/reight/sprite.rb

@@ -0,0 +1,42 @@
+class Reight::Sprite < RubySketch::Sprite
+
+  def initialize(*a, chip: nil, **k, &b)
+    @chip, @props = chip, {}
+    super(*a, **k, &b)
+  end
+
+  attr_accessor :map_chunk
+
+  attr_reader :chip, :props
+
+  def prop(name, value = NilClass, **values)
+    @props[name] = value if value != NilClass
+    values.each {|k, v| @props[k] = v} unless values.empty?
+    @props[name]
+  end
+
+  def [](key)
+    @props[key]
+  end
+
+  def []=(key, value)
+    @props[key] = value
+  end
+
+  def respond_to_missing?(name, include_private = false)
+    name = name.to_s.delete_suffix('=').to_sym if name.end_with? '='
+    @props.key?(name) || super
+  end
+
+  def method_missing(name, *args, **kwargs, &block)
+    write = name.end_with? '='
+    key   = write ? name.to_s.delete_suffix('=').to_sym : name
+    return super unless @props.key?(key)
+    if write
+      @props.[]=(key, *args)
+    else
+      @props[key]
+    end
+  end
+
+end# Sprite

data/lib/reight/text.rb

@@ -0,0 +1,124 @@
+using Reight
+
+
+class Reight::Text
+
+  include Reight::Activatable
+  include Reight::Hookable
+  include Reight::HasHelp
+
+  def initialize(text = '', editable: false, align: LEFT, label: nil, regexp: nil, &changed)
+    hook :changed
+
+    super()
+    @editable, @align, @label, @regexp = editable, align, label, regexp
+    @shake                             = 0
+    self.changed(&changed) if changed
+
+    self.value = text
+  end
+
+  attr_accessor :editable, :align, :label
+
+  attr_reader :value
+
+  alias editable? editable
+
+  def revert()
+    self.value = @old_value
+    @shake     = 6
+  end
+
+  def focus=(focus)
+    return if focus && !editable?
+    return if focus == focus?
+    sprite.capture = focus
+    unless focus
+      revert unless valid? value
+      changed! value, self if value != @old_value
+    end
+  end
+
+  def focus?()
+    sprite.capturing?
+  end
+
+  def value=(text)
+    str = text.to_s
+    return if str == @value
+    return unless valid? str
+    @value = str
+  end
+
+  def valid?(value = self.value, ignore_regexp: focus?)
+    case
+    when !value        then false
+    when ignore_regexp then true
+    when !@regexp      then true
+    else value =~ @regexp
+    end
+  end
+
+  def draw()
+    sp = sprite
+    no_stroke
+
+    if @shake != 0
+      translate rand(-@shake.to_f..@shake.to_f), 0
+      @shake *= rand(0.7..0.9)
+      @shake  = 0 if @shake.abs < 0.1
+    end
+
+    fill focus? ? 230 : 200
+    rect 0, 0, sp.w, sp.h, 3
+
+    show_old = value == ''
+    text     = show_old ? @old_value : value
+    text     = label.to_s + text unless focus?
+    x        = 2
+    fill show_old ? 200 : 50
+    text_align @align, CENTER
+    text text, x, 0, sp.w - x * 2, sp.h
+
+    if focus? && (frame_count % 60) < 30
+      fill 100
+      bounds = text_font.text_bounds value
+      xx     = (@align == LEFT ? x + bounds.w : (sp.w + bounds.w) / 2) - 1
+      rect xx, (sp.h - bounds.h) / 2, 2, bounds.h
+    end
+  end
+
+  def key_pressed(key, code)
+    case code
+    when ESC               then self.value  = @old_value; self.focus = false
+    when ENTER             then self.focus  = false
+    when DELETE, BACKSPACE then self.value  = value.split('').tap {_1.pop}.join
+    else                        self.value += key if key && valid?(key)
+    end
+  end
+
+  def clicked(x, y)
+    if focus?
+      return if hit? x, y
+      self.value = @old_value if value == '' && !valid?(ignore_regexp: false)
+      self.focus = false
+    elsif editable?
+      self.focus         = true
+      @old_value, @value = @value.dup, ''
+    end
+  end
+
+  def hit?(x, y)
+    sp = sprite
+    (0...sp.w).include?(x) && (0...sp.h).include?(y)
+  end
+
+  def sprite()
+    @sprite ||= RubySketch::Sprite.new(physics: false).tap do |sp|
+      sp.draw          {draw}
+      sp.key_pressed   {key_pressed sp.key, sp.key_code}
+      sp.mouse_clicked {clicked sp.mouse_x, sp.mouse_y}
+    end
+  end
+
+end# Text

data/lib/reight.rb

@@ -4,9 +4,13 @@ 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
+  reight_classes = %i[Sprite Sound]
+  c.class.constants
+    .reject {_1 =~ /__$/}
+    .reject {reight_classes.include? _1}
+    .each   {self.class.const_set _1, c.class.const_get(_1)}
+  reight_classes
+    .each {self.class.const_set _1, Reight.const_get(_1)}
 
   w.__send__ :begin_draw
   at_exit do

data/reight.gemspec

@@ -25,13 +25,13 @@ Gem::Specification.new do |s|
   s.platform              = Gem::Platform::RUBY
   s.required_ruby_version = '>= 3.0.0'
 
-  s.add_dependency 'xot',        '~> 0.3.3', '>= 0.3.3'
-  s.add_dependency 'rucy',       '~> 0.3.3', '>= 0.3.3'
-  s.add_dependency 'beeps',      '~> 0.3.3', '>= 0.3.3'
-  s.add_dependency 'rays',       '~> 0.3.3', '>= 0.3.3'
-  s.add_dependency 'reflexion',  '~> 0.3.3', '>= 0.3.3'
-  s.add_dependency 'processing', '~> 1.1',   '>= 1.1.5'
-  s.add_dependency 'rubysketch', '~> 0.7.6', '>= 0.7.6'
+  s.add_dependency 'xot',        '~> 0.3.5', '>= 0.3.5'
+  s.add_dependency 'rucy',       '~> 0.3.5', '>= 0.3.5'
+  s.add_dependency 'beeps',      '~> 0.3.5', '>= 0.3.5'
+  s.add_dependency 'rays',       '~> 0.3.5', '>= 0.3.5'
+  s.add_dependency 'reflexion',  '~> 0.3.5', '>= 0.3.5'
+  s.add_dependency 'processing', '~> 1.1',   '>= 1.1.7'
+  s.add_dependency 'rubysketch', '~> 0.7.8', '>= 0.7.8'
 
   s.files            = `git ls-files`.split $/
   s.executables      = s.files.grep(%r{^bin/}) {|f| File.basename f}

data/test/helper.rb

@@ -13,3 +13,19 @@ include Xot::Test
 
 R8 = Reight
 RS = RubySketch
+
+class R8::Chip
+  alias <=> cmp__
+end
+
+class R8::ChipList
+  alias <=> cmp__
+end
+
+class R8::Map
+  alias <=> cmp__
+end
+
+class R8::Map::Chunk
+  alias <=> cmp__
+end

data/test/test_map.rb

@@ -81,12 +81,12 @@ class TestMap < Test::Unit::TestCase
     end
   end
 
-  def test_delete()
+  def test_remove()
     [
       [0, 0], [10, 20], [90, 90]
     ].each do |xx, yy|
       map(chip_size: 10, chunk_size: 30).tap do |m|
-        m.delete xx, yy
+        m.remove xx, yy
         assert_equal 0, count_all_chips(m)
       end
     end
@@ -100,7 +100,7 @@ class TestMap < Test::Unit::TestCase
       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
+        m.remove xx, yy
         assert_equal count, count_all_chips(m)
       end
     end
@@ -115,17 +115,17 @@ class TestMap < Test::Unit::TestCase
       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
+        m.remove xx, yy
         assert_equal count, count_all_chips(m)
       end
     end
   end
 
-  def test_delete_chip()
+  def test_remove_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]
+      m.remove_chip m[10, 20]
       assert_equal 0, count_all_chips(m)
     end
   end
@@ -184,7 +184,7 @@ class TestMap < Test::Unit::TestCase
     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.remove 10, 20
     m2.put    10, 20, chip(0, 0, 10, 10, id: 2, image: img); assert_not_equal m1, m2
   end
 

data/test/test_map_chunk.rb

@@ -77,12 +77,12 @@ class TestMapChunk < Test::Unit::TestCase
     end
   end
 
-  def test_delete()
+  def test_remove()
     [
       [0, 0], [20, 30], [90, 90]
     ].each do |xx, yy|
       chunk(10, 20, 30, 40, chip_size: 10).tap do |c|
-        assert_nothing_raised {c.delete xx, yy}
+        assert_nothing_raised {c.remove xx, yy}
         assert_equal 0, count_all_chips(c)
       end
     end
@@ -96,7 +96,7 @@ class TestMapChunk < Test::Unit::TestCase
       chunk(10, 20, 30, 40, chip_size: 10).tap do |c|
         c.put 20, 30, chip(0, 0, 10, 10)
         assert_equal 1,     count_all_chips(c)
-        assert_nothing_raised {c.delete xx, yy}
+        assert_nothing_raised {c.remove xx, yy}
         assert_equal count, count_all_chips(c)
       end
     end
@@ -111,7 +111,7 @@ class TestMapChunk < Test::Unit::TestCase
       chunk(10, 20, 30, 40, chip_size: 10).tap do |c|
         c.put 20, 30, chip(0, 0, 20, 20)
         assert_equal 4,     count_all_chips(c)
-        assert_nothing_raised {c.delete xx, yy}
+        assert_nothing_raised {c.remove xx, yy}
         assert_equal count, count_all_chips(c)
       end
     end
@@ -123,7 +123,7 @@ class TestMapChunk < Test::Unit::TestCase
       c.put 10, 20, chip(0, 0, 10, 10)
       assert_equal 8, c.to_hash[:chips].size
 
-      c.delete 10, 20
+      c.remove 10, 20
       assert_equal 5, c.to_hash[:chips].size
     end
   end
@@ -191,7 +191,7 @@ class TestMapChunk < Test::Unit::TestCase
     img      = image
     c1.put    10, 20, chip(0, 0, 10, 10, id: 1, image: img); assert_not_equal c1, c2
     c2.put    10, 20, chip(0, 0, 10, 10, id: 1, image: img); assert_equal     c1, c2
-    c2.delete 10, 20
+    c2.remove 10, 20
     c2.put    10, 20, chip(0, 0, 10, 10, id: 2, image: img); assert_not_equal c1, c2
   end
 

data/test/test_sprite.rb

@@ -0,0 +1,28 @@
+require_relative 'helper'
+using Reight
+
+
+class TestSpeite < Test::Unit::TestCase
+
+  def sprite(...) = R8::Sprite.new(...)
+
+  def test_prop()
+    assert_raise(NoMethodError) {sprite.foo}
+    assert_raise(NoMethodError) {sprite.foo = 9}
+
+    sp = sprite
+    assert_nothing_raised {sp[:foo] = 1}
+    assert_nothing_raised {sp .foo}
+    assert_equal 1,        sp[:foo]
+    assert_equal 1,        sp .foo
+
+    assert_nothing_raised {sp .foo = 2}
+    assert_equal 2,        sp[:foo]
+    assert_equal 2,        sp .foo
+
+    assert_nothing_raised {sp .foo = 3, 4}
+    assert_equal [3, 4],   sp[:foo]
+    assert_equal [3, 4],   sp .foo
+  end
+
+end# TestChip