dxruby_rp5 0.0.1

data/lib/dxruby_rp5/render_target.rb

@@ -0,0 +1,109 @@
+# -*- coding: utf-8 -*-
+module DXRubyRP5
+  class RenderTarget
+    attr_reader :bgcolor
+    attr_reader :_surface
+
+    def initialize(width, height, _bgcolor = [0, 0, 0, 0])
+      _bgcolor = to_rp5_color(_bgcolor)
+      @bgcolor = $app.color(*_bgcolor)
+      @_surface = $app.create_graphics(width, height)
+      @queue = []
+    end
+
+    def width
+      return @_surface.width
+    end
+
+    def height
+      return @_surface.height
+    end
+
+    def bgcolor
+      return to_dxr_color(@bgcolor)
+    end
+
+    def bgcolor=(color)
+      color = to_rp5_color(color)
+      @bgcolor = $app.color(*color)
+    end
+
+    def update
+      @_surface.begin_draw()
+      @_surface.background(@bgcolor)
+      @queue.sort { |a, b| a[:z] <=> b[:z] }.each do |task|
+        task[:proc].call
+      end
+      @queue.clear
+      @_surface.end_draw()
+    end
+
+    def draw(x, y, image, z = 0)
+      return if image.nil?
+      draw_task = {
+        :proc => lambda { @_surface.image(image._surface, x, y) },
+        :z => z
+      }
+      @queue << draw_task
+    end
+
+    def draw_tile(basex, basey, map, image_arr, startx, starty, sizex, sizey, z = 0)
+      image_arr = image_arr.flatten
+      first_img = image_arr[0]
+      w, h = first_img.width, first_img.height
+      startx_mod_w = startx % w
+      starty_mod_h = starty % h
+
+      from_i = starty_mod_h < 0 ? -1 : 0
+      to_i   = sizey + (starty_mod_h <= 0 ?  0 : 1)
+      from_j = startx_mod_w < 0 ? -1 : 0
+      to_j   = sizex + (startx_mod_w <= 0 ?  0 : 1)
+
+      y = basey - (starty_mod_h < 0 ? h + starty_mod_h : starty_mod_h)
+      init_x = basex - (startx_mod_w < 0 ? w + startx_mod_w : startx_mod_w)
+
+      (from_i..to_i).each do |i|
+        if (i + starty / h) < 0
+          my = (((i + starty / h) % map.size) + map.size) % map.size
+        else
+          my = (i + starty / h) % map.size
+        end
+        map_row = map[my]
+
+        x = init_x
+        (from_j..to_j).each do |j|
+          if (j + startx / w) < 0
+            mx = (((j + startx / w) % map_row.size) + map_row.size) % map_row.size
+          else
+            mx = (j + startx / w) % map_row.size
+          end
+          idx = map_row[mx]
+
+          map_img = image_arr[idx]
+          self.draw(x, y, map_img, z)
+
+          x += w
+        end
+        y += h
+      end
+    end
+
+    private
+
+    def to_dxr_color(c)
+      dxr_c = [c >> 16 & 0xFF, c >> 8 & 0xFF, c & 0xFF]
+      if @_surface.format == Processing::App::ARGB
+        return dxr_c.unshift(c >> 24 & 0xFF)
+      else
+        return dxr_c
+      end
+    end
+
+    def to_rp5_color(color)
+      if color.size > 3
+        color.push(color.shift)
+      end
+      return color
+    end
+  end
+end

data/lib/dxruby_rp5/runner.rb

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+module Processing
+  class Runner
+    private
+
+    # changed runner path from original.
+    def spin_up(starter_script, sketch, args)
+      runner = "#{DXRUBY_RP5_ROOT}/lib/dxruby_rp5/runners/#{starter_script}"
+      java_args = discover_java_args(sketch)
+      warn("The --jruby flag is no longer required") if @options.jruby
+      command = @options.nojruby ?
+         ['java', java_args, '-cp', jruby_complete, 'org.jruby.Main', runner, sketch, args].flatten :
+         ['jruby', java_args, runner, sketch, args].flatten
+      exec *command
+    end
+  end
+end

data/lib/dxruby_rp5/runners/base.rb

@@ -0,0 +1,89 @@
+# -*- coding: utf-8 -*-
+require 'ruby-processing'
+require "#{RP5_ROOT}/lib/ruby-processing/runners/base.rb"
+
+module Processing
+  KEY_METHODS = <<-EOS
+    def key_pressed
+      Input.send(:key_pressed, key, key_code)
+      Input.send(:key_pushed, key, key_code)
+    end
+
+    def key_released
+      Input.send(:key_released, key, key_code)
+    end
+  EOS
+
+  MOUSE_METHODS = <<-EOS
+    def mouse_pressed(event)
+      Input.send(:mouse_pressed, event.get_button)
+      Input.send(:mouse_pushed, event.get_button)
+    end
+
+    def mouse_released(event)
+      Input.send(:mouse_released, event.get_button)
+    end
+  EOS
+
+  SKETCH_TEMPLATE_FOR_RP5 = <<-EOS
+    class Sketch < Processing::App
+      <% if has_methods %>
+      <%= source %>
+      <% else %>
+      def setup
+        size(DEFAULT_WIDTH, DEFAULT_HEIGHT, JAVA2D)
+        <%= source %>
+        no_loop
+      end
+      <% end %>
+      <% if !has_key_methods %>
+      #{KEY_METHODS}
+      <% end %>
+
+      <% if !has_mouse_methods %>
+      #{MOUSE_METHODS}
+      <% end %>
+    end
+  EOS
+
+  SKETCH_TEMPLATE_FOR_DXRUBY_RP5 = <<-EOS
+    class Sketch < Processing::App
+      def setup
+        <%= source %>
+        size(Window.width, Window.height, JAVA2D)
+      end
+
+      def draw
+      end
+
+      <% if !has_key_methods %>
+      #{KEY_METHODS}
+      <% end %>
+
+      <% if !has_mouse_methods %>
+      #{MOUSE_METHODS}
+      <% end %>
+    end
+  EOS
+
+  def self.load_and_run_sketch
+    source = self.read_sketch_source
+    has_sketch = !!source.match(/^[^#]*< Processing::App/)
+    has_methods = !!source.match(/^[^#]*(def\s+setup|def\s+draw)/)
+    has_window_loop = !!source.match(/^[^#]*(Window\.loop\sdo)/)
+    has_key_methods = !!source.match(/^[^#]*(def\s+(key_pressed|key_typed|key_released))/)
+    has_mouse_methods = !!source.match(/^[^#]*(def\s+(mouse_pressed|mouse_released))/)
+
+    if has_sketch
+      load File.join(SKETCH_ROOT, SKETCH_PATH)
+      Processing::App.sketch_class.new if !$app
+    else
+      require 'erb'
+      code = has_window_loop ?
+        ERB.new(SKETCH_TEMPLATE_FOR_DXRUBY_RP5).result(binding) :
+        ERB.new(SKETCH_TEMPLATE_FOR_RP5).result(binding)
+      Object.class_eval code, SKETCH_PATH, -1
+      Processing::App.sketch_class.new
+    end
+  end
+end

data/lib/dxruby_rp5/runners/run.rb

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+root = File.dirname(__FILE__)
+require "#{root}/base.rb"
+
+Processing.load_and_run_sketch

data/lib/dxruby_rp5/sound.rb

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+module DXRubyRP5
+  class Sound
+    def initialize(filename)
+    end
+
+    def play
+    end
+
+    def set_volume(volume, time = 0)
+    end
+  end
+end

data/lib/dxruby_rp5/sound_effect.rb

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+module DXRubyRP5
+  class SoundEffect
+    def initialize(time, wavetype = WAVE_RECT, resolution = 1000)
+      @time = time
+
+      @time.times { yield }
+    end
+
+    def add(wavetype = WAVE_RECT, resolution = 1000)
+      @time.times { yield }
+    end
+
+    def play
+    end
+
+    def stop
+    end
+  end
+end

data/lib/dxruby_rp5/sprite.rb

@@ -0,0 +1,188 @@
+# -*- coding: utf-8 -*-
+# Includes and uses as reference 'dxruby_sdl'
+# Copyright (c) 2013 TAKAO Kouji
+# Released under the MIT License.
+# see https://github.com/takaokouji/dxruby_sdl
+
+module DXRubyRP5
+  class Sprite
+    attr_accessor :x
+    attr_accessor :y
+    attr_reader :image
+    attr_accessor :z
+    attr_accessor :angle
+    attr_accessor :scale_x
+    attr_accessor :scale_y
+    attr_accessor :center_x
+    attr_accessor :center_y
+    attr_accessor :alpha
+    attr_accessor :blend
+    attr_accessor :shader
+    attr_accessor :target
+    attr_accessor :collision
+    attr_accessor :collision_enable
+    attr_accessor :collision_sync
+    attr_accessor :visible
+
+    class << self
+      def check(o_sprites, d_sprites, shot = :shot, hit = :hit)
+        res = false
+        o_sprites = [o_sprites].flatten.select { |s| s.is_a?(self) }
+        d_sprites = [d_sprites].flatten.select { |s| s.is_a?(self) }
+        discards = []
+        o_sprites.each do |o_sprite|
+          if discards.include?(o_sprite)
+            next
+          end
+          d_sprites.each do |d_sprite|
+            if discards.include?(o_sprite)
+              break
+            end
+            if discards.include?(d_sprite)
+              next
+            end
+            if o_sprite.object_id == d_sprite.object_id
+              next
+            end
+            if o_sprite === d_sprite
+              res = true
+              discard = false
+              if o_sprite.respond_to?(shot) && shot
+                if o_sprite.send(shot, d_sprite) == :discard
+                  discard = true
+                end
+              end
+              if d_sprite.respond_to?(hit) && hit
+                if d_sprite.send(hit, o_sprite) == :discard
+                  discard = true
+                end
+              end
+              if discard
+                discards << o_sprite
+                discards << d_sprite
+              end
+            end
+          end
+        end
+        return res
+      end
+
+      def update(sprites)
+        sprites.flatten.each do |s|
+          if s.respond_to?(:update)
+            s.update
+          end
+        end
+      end
+
+      def draw(sprites)
+        sprites.flatten.each do |s|
+          if s.respond_to?(:draw)
+            s.draw
+          end
+        end
+      end
+
+      def clean(sprites)
+        sprites = [sprites].flatten.select { |s| s.is_a?(self) }.compact
+        return sprites.reject(&:vanished?)
+#        return [sprites].flatten.compact.reject(&:vanished?)
+      end
+    end
+
+    def initialize(x = 0, y = 0, image = nil)
+      @x = x
+      @y = y
+      @image = image
+
+      @collision_enable = true
+      @collision_sync = true
+      @visible = true
+      @vanished = false
+
+      calc_center
+    end
+
+    def image=(val)
+      @image = val
+      calc_center
+    end
+
+    def draw
+      if !@visible || vanished?
+        return
+      end
+      #TODO:
+
+      options = {}
+      if alpha
+        options[:alpha] = alpha
+      end
+      if angle
+        options[:angle] = angle
+      end
+      if scale_x
+        options[:scale_x] = scale_x
+      end
+      if scale_y
+        options[:scale_y] = scale_y
+      end
+      if z
+        options[:z] = z
+      end
+      Window.draw_ex(x, y, image, options)
+    end
+
+    def ===(other)
+      if !@collision_enable || vanished? ||
+          !other.collision_enable || other.vanished? ||
+          !other.image && !other.collision
+        return false
+      end
+      if @collision_enable && @collision
+        x = @collision[0] + @x
+        y = @collision[1] + @y
+        width = @collision[2] - @collision[0]
+        height = @collision[3] - @collision[1]
+      else
+        x, y, width, height =
+          @x, @y, @image.width, @image.height
+      end
+      if other.collision_enable && other.collision
+        other_x = other.x + other.collision[0]
+        other_y = other.y + + other.collision[1]
+        other_width = other.collision[2] - other.collision[0]
+        other_height = other.collision[3] - other.collision[1]
+      else
+        other_x, other_y, other_width, other_height =
+          other.x, other.y, other.image.width, other.image.height
+      end
+      return other_x + other_width > x && other_x < x + width &&
+        other_y + other_height > y && other_y < y + height
+    end
+
+    def check(sprites)
+      return [sprites].flatten.select { |s| self === s }
+    end
+
+    def vanish
+      @vanished = true
+    end
+
+    def vanished?
+      return @vanished
+    end
+
+    private
+
+    def calc_center
+      if @image
+        @center_x = @image.width / 2
+        @center_y = @image.height / 2
+      else
+        @center_x = 0
+        @center_y = 0
+      end
+    end
+  end
+end

data/lib/dxruby_rp5/version.rb

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+module DXRubyRP5
+  VERSION = "0.0.1"
+end

data/lib/dxruby_rp5/window.rb

@@ -0,0 +1,148 @@
+# -*- coding: utf-8 -*-
+module DXRubyRP5
+  module Window
+    module_function
+
+    def width
+      @width ||= DEFAULTS[:width]
+      return @width
+    end
+
+    def height
+      @height ||= DEFAULTS[:height]
+      return @height
+    end
+
+    def width=(_width)
+      @width = _width
+    end
+
+    def height=(_height)
+      @height = _height
+    end
+
+    def caption
+      return $app.frame.get_title
+    end
+
+    def caption=(val)
+      $app.frame.set_title(val)
+    end
+
+    def get_load
+      # TODO:
+      return 0
+    end
+
+    def loop(&block)
+      proc = Proc.new do
+        background(*DEFAULTS[:background_color])
+        block.call
+        Window.send(:exec_draw_tasks)
+        Input.send(:handle_key_events)
+      end
+
+      Processing::App.sketch_class.class_eval { define_method(:draw, proc) }
+      @use_window_loop = true
+      @queue = []
+    end
+
+    def draw(x, y, image, z = 0)
+      if @use_window_loop
+        draw_task = {
+          :proc => lambda { $app.image(image._surface, x, y) },
+          :z => z
+        }
+        @queue << draw_task
+      else
+        $app.image(image._surface, x, y)
+      end
+    end
+
+    def draw_ex(x, y, image, hash = {})
+      if @use_window_loop
+        draw_task = {
+          :z => hash[:z] || 0,
+          :proc => lambda do
+            $app.push_matrix
+            $app.translate(x, y)
+
+            if hash[:scale_x] || hash[:scale_y]
+              $app.scale(hash[:scale_x] || 1, hash[:scale_y] || 1)
+            end
+            if hash[:angle]
+              $app.rotate($app.radians(hash[:angle]))
+            end
+            if hash[:alpha]
+              $app.tint(255, hash[:alpha])
+            end
+
+            $app.image(image._surface, 0, 0)
+            $app.no_tint
+            $app.pop_matrix
+          end,
+        }
+        @queue << draw_task
+      else
+        $app.image(image._surface, x, y)
+      end
+    end
+
+
+    def draw_font(x, y, string, font, hash = {})
+      if string.empty?
+        return
+      end
+      if hash[:color]
+        color = $app.color(*hash[:color])
+      else
+        color = $app.color(255)
+      end
+
+      proc = lambda do
+        $app.text_size(font.size)
+        $app.text_font(font.native)
+        $app.fill(color)
+        string.lines.each.with_index do |line, i|
+          line.chomp!
+          if line.empty?
+            next
+          end
+          $app.text(string, x, y)
+        end
+      end
+
+      if @use_window_loop
+        draw_task = {
+          :proc => proc,
+          :z => hash[:z] || 0,
+        }
+        @queue << draw_task
+      else
+        proc.call
+      end
+    end
+
+    class << self
+      alias_method :drawFont, :draw_font
+
+      private
+
+      def exec_draw_tasks
+        @queue.sort { |a, b| a[:z] <=> b[:z] }.each do |task|
+          task[:proc].call
+        end
+        @queue.clear
+      end
+    end
+
+    private
+
+    DEFAULTS = {
+      width: 640,
+      height: 480,
+      background_color: [0, 0, 0],
+    }
+    private_constant :DEFAULTS
+  end
+end