dxruby_rp5 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4a6ebc43489270df0e75fbdecebe8ea25eb6b807
+  data.tar.gz: e3d2919a9052992fffb0c534454ffc2c9f204096
+SHA512:
+  metadata.gz: 1d4e875d466d221580da9d44492d6fd399d4956ada14d718f032a57e854c23b1ef2c73c93153cdb118cdee4024992fc104ef0a6a510d449a3d22ec2b47816fde
+  data.tar.gz: eb10b20d45bdbd63d8bce3ddf56a7290d67b0632ba177c62fb5120ea8afc010b0d6c08aaca5ac710325742dcda3d139e8528bc98f497c58204aa5d7b9996b922

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in dxruby_rp5.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Yuki Morohoshi
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,88 @@
+# DXRubyRP5
+
+`dxruby_rp5` is a ruby library for 2D graphics and game. `dxruby_rp5`
+uses `ruby-processing` and has API same as DXRuby.
+
+* https://github.com/jashkenas/ruby-processing
+* http://dxruby.sourceforge.jp/ (in Japanese)
+
+`dxruby-rp5` is inspired by and referring to `dxruby_sdl`.
+
+* https://github.com/takaokouji/dxruby_sdl
+
+## Installation
+
+### Install ruby-processing
+
+see https://github.com/jashkenas/ruby-processing#installation
+
+### Install dxruby_rp5
+
+Add this line to your application's Gemfile:
+
+    gem 'dxruby_rp5'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install dxruby_rp5
+
+## Usage
+
+```bash
+$ dxrp5 --nojruby run my_dxruby_sketch.rb
+```
+
+If `my_dxruby_sketch.rb` is like below,
+
+```ruby
+require 'dxruby'
+
+x = 0
+y = 0
+image = Image.load('./images/test.png')
+
+Window.loop do
+  x = x + Input.x
+  y = y + Input.y
+
+  Window.draw(x, y, image)
+end
+```
+
+`dxrp5` converts the source code as follows.
+
+```ruby
+class Sketch < Processing::App
+  def setup
+    require 'dxruby'
+
+    x = 0
+    y = 0
+    image = Image.load('./images/test.png')
+
+    Window.loop do
+      x = x + Input.x
+      y = y + Input.y
+
+      Window.draw(x, y, image)
+    end
+  end
+
+  def draw
+  end
+end
+```
+
+And in `Window.loop`, `Sketch#draw` method is defined dynamically.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,12 @@
+require "bundler/gem_tasks"
+
+# require "rspec/core/rake_task"
+# RSpec::Core::RakeTask.new(:spec)
+# task :default => :spec
+
+desc 'Test'
+task :spec do
+  ruby "spec/runner.rb"
+end
+
+task :default => :spec

data/bin/dxrp5

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+file = __FILE__
+if test(?l, file)
+  require "pathname"
+  file = Pathname.new(file).realpath
+end
+
+require "ruby-processing"
+require File.expand_path(File.dirname(file) + "/../lib/dxruby")
+Processing::Runner.execute

data/dxruby_rp5.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dxruby_rp5/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "dxruby_rp5"
+  spec.version       = DXRubyRP5::VERSION
+  spec.authors       = ["Yuki Morohoshi"]
+  spec.email         = ["hoshi.sanou@gmail.com"]
+  spec.description   = %q{`dxruby-rp5` is a ruby library for 2D graphics and game. `dxruby-rp5` uses `ruby-processing` and  has API same as DXRuby.}
+  spec.summary       = %q{2D graphics and game library}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+
+  spec.add_runtime_dependency "ruby-processing", ">= 2.0"
+end

data/lib/dxruby.rb

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+require_relative 'dxruby_rp5'
+
+include DXRubyRP5

data/lib/dxruby_rp5/font.rb

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+module DXRubyRP5
+  class Font
+    attr_reader :size
+    attr_reader :native
+
+    @font_cache = {}
+
+    def initialize(size, fontname = '', hash = {})
+      @size = size
+      # TODO: use fontname
+      gothics = PFont.list.grep(/gothic/i)
+      if gothics.any?
+        ipa_gothics = gothics.grep(/ipa/i)
+        if ipa_gothics.any?
+          fontname = ipa_gothics.first
+        else
+          fontname = gothics.first
+        end
+      else
+        fontname = PFont.list.first
+      end
+      @native = $app.create_font(fontname, @size)
+    end
+
+    def get_width(string)
+      # TODO:
+      $app.text_size(@size)
+      return $app.text_width(string);
+    end
+
+    alias_method :getWidth, :get_width
+
+    private
+  end
+end

data/lib/dxruby_rp5/image.rb

@@ -0,0 +1,146 @@
+# -*- coding: utf-8 -*-
+module DXRubyRP5
+  class Image
+    attr_reader :_surface
+
+    def self.load(filename, x = nil, y = nil, width = nil, height = nil)
+      image = self.new(0, 0)
+      surface = $app.load_image(filename)
+      surface.format = Processing::App::ARGB
+      image.instance_variable_set('@_surface', surface)
+      return image
+    end
+
+    def self.load_tiles(filename, xcount, ycount, switch = true)
+      surface = $app.load_image(filename)
+      width = surface.width / xcount
+      height = surface.height / ycount
+      images = []
+      ycount.times do |y|
+        xcount.times do |x|
+          image = new(0, 0)
+          s = $app.create_image(width, height, Processing::App::ARGB)
+          s.copy(surface, x * width, y * height, width, height,
+                                  0,          0, width, height)
+          image.instance_variable_set('@_surface', s)
+          images << image
+        end
+      end
+      return images
+    end
+
+    def initialize(width, height, _color = [0, 0, 0, 0])
+      _color = to_rp5_color(_color)
+      @color = $app.color(*_color)
+
+      if width == 0 && height == 0
+        return
+      end
+
+      @_surface = $app.create_image(width, height, Processing::App::ARGB)
+      @_surface.pixels.each_with_index do |px, i|
+        @_surface.pixels[i] = @color
+      end
+    end
+
+    def width
+      return @_surface.width
+    end
+
+    def height
+      return @_surface.height
+    end
+
+    def [](x, y)
+      px = @_surface.get(x, y)
+      _color = [red(px).to_i, green(px).to_i, blue(px).to_i]
+      if @_surface.format == Processing::App::ARGB
+        _color.unshift(alpha(px).to_i)
+      end
+      return _color
+    end
+
+    def []=(x, y, _color)
+      _color = to_rp5_color(_color)
+      return @_surface.set(x, y, $app.color(*_color))
+    end
+
+    def set_color_key(_color)
+      r, g, b = *_color[-3..-1]
+      alpha = $app.color(r, g, b, 0)
+
+      @_surface.pixels.each_with_index do |px, i|
+        if (r == red(px).to_i) &&
+            (g == green(px).to_i) &&
+            (b == blue(px).to_i)
+          @_surface.pixels[i] = alpha
+        end
+      end
+    end
+
+    def compare(x, y, _color)
+      _color = to_rp5_color(_color)
+      max = _color.size - 1
+      px = @_surface.get(x, y)
+      c = [red(px),  green(px),
+           blue(px), alpha(px)].map(&:to_i)
+      return c[0..max] == _color
+    end
+
+    def slice(x, y, width, height)
+      image = self.class.new(0, 0)
+      s = $app.create_image(width, height, Processing::App::ARGB)
+      s.copy(@_surface, x, y, width, height,
+                        0, 0, width, height)
+      image.instance_variable_set('@_surface', s)
+      return image
+    end
+
+    def slice_tiles(xcount, ycount, switch = true)
+      width = @_surface.width / xcount
+      height = @_surface.height / ycount
+      images = []
+      ycount.times do |y|
+        xcount.times do |x|
+          images << slice(x * width, y * height, width, height)
+        end
+      end
+      return images
+    end
+
+    class << self
+      alias_method :loadTiles, :load_tiles
+      alias_method :load_to_array, :load_tiles
+      alias_method :loadToArray, :load_to_array
+    end
+    alias_method :setColorKey, :set_color_key
+    alias_method :sliceTiles, :slice_tiles
+    alias_method :slice_to_array, :slice_tiles
+    alias_method :sliceToArray, :slice_to_array
+
+    private
+
+    def to_rp5_color(_color)
+      if _color.size > 3
+        _color.push(_color.shift)
+      end
+      return _color
+    end
+
+    def alpha(rgb)
+      return rgb >> 24 & 0xFF
+    end
+
+    def red(rgb)
+      return rgb >> 16 & 0xFF
+    end
+
+    def green(rgb)
+      return rgb >> 8 & 0xFF
+    end
+
+    def blue(rgb)
+      return rgb & 0xFF
+    end
+  end
+end

data/lib/dxruby_rp5/input.rb

@@ -0,0 +1,319 @@
+# -*- coding: utf-8 -*-
+module DXRubyRP5
+  module Input
+    module_function
+
+    def set_repeat(wait, interval)
+      if wait == 0 && interval == 0
+        @repeat_wait = nil
+        @repeat_interval = nil
+      else
+        @repeat_wait = wait
+        @repeat_interval = interval
+      end
+    end
+
+    def x(pad_number = 0)
+      res = 0
+
+      if @pressed_keys
+        cond = lambda { |key| @pressed_keys.include?(to_dxruby_key(key)) }
+      else
+        cond = lambda { |key| rp5_key_press?(key) }
+      end
+
+      if cond.call(Processing::App::LEFT)
+        res -= 1
+      end
+      if cond.call(Processing::App::RIGHT)
+        res += 1
+      end
+      return res
+    end
+
+    def y(pad_number = 0)
+      res = 0
+
+      if @pressed_keys
+        cond = lambda { |key| @pressed_keys.include?(to_dxruby_key(key)) }
+      else
+        cond = lambda { |key| rp5_key_press?(key) }
+      end
+
+      if cond.call(Processing::App::UP)
+        res -= 1
+      end
+      if cond.call(Processing::App::DOWN)
+        res += 1
+      end
+      return res
+    end
+
+    def mouse_pos_x
+      return $app.mouse_x
+    end
+
+    def mouse_pos_y
+      return $app.mouse_y
+    end
+
+    def key_down?(key_code)
+      if @pressed_keys
+        return @pressed_keys.include?(key_code)
+      else
+        return rp5_key_press?(to_rp5_key(key_code))
+      end
+    end
+
+    def key_push?(key_code)
+      if @pushed_keys
+        return @pushed_keys.include?(key_code)
+      else
+        return rp5_key_press?(to_rp5_key(key_code))
+      end
+    end
+
+    def mouse_down?(button)
+      if @pressed_buttons
+        return @pressed_buttons.include?(button)
+      else
+        return rp5_mouse_down?(button)
+      end
+    end
+
+    def mouse_push?(button)
+      if @pushed_buttons
+        return @pushed_buttons.include?(button)
+      else
+        return rp5_mouse_down?(button)
+      end
+    end
+
+    # TODO: support joystick
+    def pad_down?(button_code, pad_number = 0)
+      if button_code == P_BUTTON0 && key_down?(K_Z) ||
+          button_code == P_BUTTON1 && key_down?(K_X) ||
+          button_code == P_BUTTON2 && key_down?(K_C) ||
+          button_code == P_LEFT && key_down?(K_LEFT) ||
+          button_code == P_RIGHT && key_down?(K_RIGHT) ||
+          button_code == P_UP && key_down?(K_UP) ||
+          button_code == P_DOWN && key_down?(K_DOWN)
+        return true
+      end
+      return false
+    end
+
+    # TODO: support joystick
+    def pad_push?(button_code, pad_number = 0)
+      if button_code == P_BUTTON0 && key_push?(K_Z) ||
+          button_code == P_BUTTON1 && key_push?(K_X) ||
+          button_code == P_BUTTON2 && key_push?(K_C) ||
+          button_code == P_LEFT && key_push?(K_LEFT) ||
+          button_code == P_RIGHT && key_push?(K_RIGHT) ||
+          button_code == P_UP && key_push?(K_UP) ||
+          button_code == P_DOWN && key_push?(K_DOWN)
+        return true
+      end
+      return false
+    end
+
+    class << self
+      alias_method :setRepeat, :set_repeat
+      alias_method :padDown?, :pad_down?
+      alias_method :padPush?, :pad_push?
+      alias_method :keyDown?, :key_down?
+      alias_method :keyPush?, :key_push?
+      alias_method :mouseDown?, :mouse_down?
+      alias_method :mousePush?, :mouse_push?
+      alias_method :mousePosX, :mouse_pos_x
+      alias_method :mousePosY, :mouse_pos_y
+
+      private
+
+      RP5_KEY_TABLE = {}
+      replace_table = {
+        'APOSTROPHE' => "'",
+        'AT' => '@',
+        'BACKSPACE' => "\b",
+        'BACKSLASH' => '\\',
+        'CAPSLOCK' => 'CAPS_LOCK',
+        'COLON' => ':',
+        'COMMA' => ',',
+        'EQUALS' => '=',
+        'GRAVE' => 'BACK_QUOTE',
+        'LALT' => 'ALT',
+        'RALT' => 'ALT',
+        'LBRACKET' => '[',
+        'RBRACKET' => ']',
+        'LCONTROL' => 'CONTROL',
+        'RCONTROL' => 'CONTROL',
+        'LSHIFT' => 'SHIFT',
+        'RSHIFT' => 'SHIFT',
+        'LWIN' => 'WINDOWS',
+        'RWIN' => 'WINDOWS',
+        'MINUS' => '-',
+        'MULTIPLY' => '*',
+        'NOCONVERT' => 'NONCONVERT',
+        'NUMLOCK' => 'NUM_LOCK',
+        'PERIOD' => '.',
+        'RETURN' => "\n",
+        'SCROLL' => 'SCROL_LOCK',
+        'SEMICOLON' => ';',
+        'SLASH' => '/',
+        'SPACE' => ' ',
+        'SUBTRACT' => '-',
+        'TAB' => "\t",
+        'UNDERLINE' => '_',
+        'YEN' => '\\',
+      }
+      DXRubyRP5.constants.grep(/^K_/).each do |k|
+        name = k.to_s.sub(/^K_/, '')
+        if replace_table.key?(name)
+          name = replace_table[name]
+        end
+        case name
+        when /^(\S|\s|\\n|\\b|\\t)$/
+          RP5_KEY_TABLE[DXRubyRP5.const_get(k)] = name.downcase
+        else
+          begin
+            RP5_KEY_TABLE[DXRubyRP5.const_get(k)] =
+              Java::JavaAwtEvent::KeyEvent.const_get("VK_#{name}".to_sym)
+          rescue NameError
+          end
+        end
+      end
+      private_constant :RP5_KEY_TABLE
+
+      DXRUBY_KEY_TABLE = RP5_KEY_TABLE.invert
+      private_constant :DXRUBY_KEY_TABLE
+
+      RP5_MBUTTON_TABLE = {
+        M_LBUTTON => Processing::App::LEFT,
+        M_MBUTTON => Processing::App::CENTER,
+        M_RBUTTON => Processing::App::RIGHT,
+      }
+      private_constant :RP5_MBUTTON_TABLE
+
+      DXRUBY_MBUTTON_TABLE = RP5_MBUTTON_TABLE.invert
+      private_constant :DXRUBY_MBUTTON_TABLE
+
+      JAVA_RP5_MBUTTON_TABLE = {
+        Java::JavaAwtEvent::MouseEvent::BUTTON1 => Processing::App::LEFT,
+        Java::JavaAwtEvent::MouseEvent::BUTTON2 => Processing::App::CENTER,
+        Java::JavaAwtEvent::MouseEvent::BUTTON3 => Processing::App::RIGHT,
+      }
+      private_constant :JAVA_RP5_MBUTTON_TABLE
+
+      # TODO: check dxruby supported keycode
+      def rp5_key_press?(key)
+        if $app.key_pressed?
+          if $app.key == Processing::App::CODED
+            return $app.key_code == key
+          else
+            return $app.key == key.chr
+          end
+        end
+        return false
+      end
+
+      def rp5_mouse_down?(button)
+        return if !$app.mouse_pressed?
+        pressed_button = $app.mouse_button
+        rp5_button = to_rp5_button(button)
+        return rp5_button == pressed_button
+      end
+
+      def to_rp5_key(key_code)
+        return RP5_KEY_TABLE[key_code]
+      end
+
+      def to_dxruby_key(key_code)
+        return DXRUBY_KEY_TABLE[key_code]
+      end
+
+      def to_rp5_button(button)
+        return RP5_MBUTTON_TABLE[button]
+      end
+
+      def to_dxruby_button(button)
+        return DXRUBY_MBUTTON_TABLE[button]
+      end
+
+      def key_pressed(key, key_code)
+        @pressed_keys ||= []
+        if key == Processing::App::CODED
+          dkey = to_dxruby_key(key_code)
+        else
+          dkey = to_dxruby_key(key.downcase)
+        end
+        return if @pressed_keys.include?(dkey)
+        @pressed_keys << dkey
+      end
+
+      def key_pushed(key, key_code)
+        @pushed_keys ||= []
+        @checked_keys ||= []
+        if key == Processing::App::CODED
+          dkey = to_dxruby_key(key_code)
+        else
+          dkey = to_dxruby_key(key.downcase)
+        end
+        return if @checked_keys.include?(dkey)
+        @pushed_keys << dkey
+      end
+
+      def key_released(key, key_code)
+        return if @pressed_keys.nil?
+        if key == Processing::App::CODED
+          dkey = to_dxruby_key(key_code)
+        else
+          dkey = to_dxruby_key(key.downcase)
+        end
+        @pressed_keys.delete(dkey)
+        @checked_keys.delete(dkey)
+      end
+
+      def mouse_pressed(button)
+        @pressed_buttons ||= []
+        rp5_button = JAVA_RP5_MBUTTON_TABLE[button]
+        dbutton = to_dxruby_button(rp5_button)
+        @pressed_buttons << dbutton
+      end
+
+      def mouse_pushed(button)
+        @pushed_buttons ||= []
+        @checked_buttons ||= []
+        rp5_button = JAVA_RP5_MBUTTON_TABLE[button]
+        dbutton = to_dxruby_button(rp5_button)
+        return if @checked_buttons.include?(dbutton)
+        @pushed_buttons << dbutton
+      end
+
+      def mouse_released(button)
+        return if @pressed_buttons.nil?
+        rp5_button = JAVA_RP5_MBUTTON_TABLE[button]
+        dbutton = to_dxruby_button(rp5_button)
+        @pressed_buttons.delete(dbutton)
+        @checked_buttons.delete(dbutton)
+      end
+
+      def handle_key_events
+        return if @pushed_keys.nil?
+        @checked_keys |= @pushed_keys
+        @pushed_keys.clear
+
+        # for key repeat
+        # TODO: use `wait`
+        if @repeat_interval &&
+            $app.frame_count % @repeat_interval == 0
+          @pushed_keys |= @pressed_keys
+          @checked_keys -= @pressed_keys
+        end
+
+        return if @pushed_buttons.nil?
+        @checked_buttons = (@checked_buttons || @pushed_buttons)
+        @pushed_buttons.clear
+      end
+    end
+  end
+end