okami 0.1.5 → 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 295ccf3b84880a0c588c7866d965fe28fc97d81e
+  data.tar.gz: 461e0bc923354f20e9866df35e9d18e5c5ac85e3
+SHA512:
+  metadata.gz: 0853a1fe7c4d53134197a6186d774c92c06142b54a4503d4e496d5b7ec2b5618b40248eb813496dacac44d222d6370eaf7d13af2e90759b8b71cd51655a2f025
+  data.tar.gz: d6051de2e84fb531d6d39628f7b00b8c9ff4b7ac96c0d347bfc60657f7f7491a11d444d454b0b22dd4d1f250cc3e7c05497df9d08816f8ce6d879a03ff07906e

data/lib/okami.rb

@@ -4,11 +4,9 @@ module Okami
   require_relative 'okami/window'
   require_relative 'okami/keyboard'
   require_relative 'okami/mouse'
-  require_relative 'okami/mouse_trap'
-  require_relative 'okami/hit_mask'
   require_relative 'okami/image'
-  require_relative 'okami/image_tiles_cache'
-  require_relative 'okami/image_cache'
+  require_relative 'okami/image_tiles'
+  require_relative 'okami/image_attributes'
   require_relative 'okami/sprite'
   
   def self.retrofy

data/lib/okami/image.rb

@@ -1,25 +1,88 @@
-require_relative 'drawable'
+Okami::ImageCache = {}
+Okami::ImageTileCache = {}
 
-class Okami::Image
-  include Okami::Drawable
-  
-  def initialize image_path
-    @image = Okami::ImageCache[image_path]
-    init_drawable
+module Okami::DrawMethods
+  def draw_using image_attributes
+    #draw_rot *image_attributes
+    ## or this?
+    draw_rot \
+    image_attributes.x, 
+    image_attributes.y, 
+    image_attributes.z, 
+    image_attributes.angle, 
+    image_attributes.center_x,
+    image_attributes.center_y,
+    image_attributes.factor_x,
+    image_attributes.factor_y,
+    image_attributes.color,
+    image_attributes.mode
   end
+end
+
+class Okami::Image < Gosu::Image
+  include Okami::DrawMethods
   
-  @tileable = true
-  @load_path = ""
+  @tileable = false
+  @load_path = './'
   
   class << self
-    # Set this for a default value for wether the images should be tileable or not
+    # Default value for wether the images should be tileable or not
     attr_accessor :tileable
     # The directory to load the images from
     attr_accessor :load_path
     
-    def load_path=val
-      val << "/" unless val[-1] == "/"
-      @load_path = val
+    def load_path= directory
+      if @_load_path_set
+        warn "It's best practice that '#{self}.load_path = directory'
+        is set only once since the image is cached by the relative path"
+      end
+      @_load_path_set = true
+      @load_path = directory
+    end
+    
+    ## Character::Will cache the images so they're only loaded once.
+    def require relative_path, options=nil
+      Okami::ImageCache[relative_path] ||
+      load(relative_path, options)
+    end
+    alias [] require
+    
+    ## Character::Will load and cache even if it's already cached
+    def load relative_path, options=nil
+      image_path = File.join(@load_path, relative_path)
+      
+      Okami::ImageCache[relative_path] = 
+        if options
+          new_by_options options
+        else
+          new $window, image_path
+        end
+    end
+    
+    def new_by_options options
+      tileable = options[:tileable] || @tileable
+      src_rect = options[:src_rect]
+      new $window, image_path, tileable, *src_rect
+    end
+    
+    def require_tiles relative_path,
+                      tile_width=nil,
+                      tile_height=nil,
+                      tileable=@tileable
+      Okami::ImageTileCache[relative_path] ||
+      load_tiles(relative_path, tile_width, tile_height, tileable)
+    end
+    
+    ## Character::Will load and cache even if it's already cached
+    def load_tiles relative_path,
+                   tile_width,
+                   tile_height,
+                   tileable=@tileable
+                   
+      image_path = File.join(@load_path, relative_path)
+      tiles = super $window, image_path, tile_width, tile_height, tileable
+      tiles.each { |tile| tile.extend Okami::DrawMethods }
+      Okami::ImageTileCache[relative_path] = tiles
     end
   end
 end

data/lib/okami/image_attributes.rb

@@ -0,0 +1,57 @@
+require_relative 'wrapping_angle'
+
+class Okami::ImageAttributes
+  @default_center_x = 0
+  @default_center_y = 0
+  @default_x = 0
+  @default_y = 0
+  @default_z = 0
+  @default_angle = 0
+  
+  class << self
+    attr_accessor :default_center_x, :default_center_y, :default_x, :default_y, :default_z, :default_angle
+  end
+  
+  attr_accessor :x, :y, :z
+  attr_accessor :factor_x, :factor_y
+  attr_accessor :center_x, :center_y
+  attr_accessor :color, :mode
+  
+  def initialize options
+    @x = options[:x] || self.class.default_x
+    @y = options[:y] || self.class.default_y
+    @z = options[:z] || self.class.default_z
+    
+    @wrapping_angle = Okami::WrappingAngle.new
+    @wrapping_angle.degrees = options[:angle] || self.class.default_angle
+    @degrees = @wrapping_angle.degrees
+    
+    @center_x = options[:center_x] || self.class.default_center_x
+    @center_y = options[:center_y] || self.class.default_center_y
+    @factor_x = options[:factor_x] || 1
+    @factor_y = options[:factor_y] || 1    
+    
+    @color     = options[:color]     || Gosu::Color.argb(255, 255, 255, 255)
+    @mode = options[:mode] || :default
+  end
+  
+  def to_a
+    return @x, @y, @z, @degrees, @center_x, @center_y, @factor_x, @factor_y, @color, @mode
+  end
+  
+  alias :draw_rot_parameters :to_a
+  
+  def rotate_radians  a; @wrapping_angle.rotate_radians  a; @degrees = @wrapping_angle.degrees  end
+  def rotate_fraction a; @wrapping_angle.rotate_fraction a; @degrees = @wrapping_angle.degrees  end
+  def rotate_degrees  a; @wrapping_angle.rotate_degrees  a; @degrees = @wrapping_angle.degrees  end
+  
+  def radians;  @wrapping_angle.radians    end
+  def fraction; @wrapping_angle.fraction   end
+  def degrees;  @wrapping_angle.degrees    end
+  alias :angle :degrees 
+  
+  def radians=  a; @wrapping_angle.radians  = a; @degrees = @wrapping_angle.degrees  end
+  def fraction= a; @wrapping_angle.fraction = a; @degrees = @wrapping_angle.degrees  end
+  def degrees=  a; @wrapping_angle.degrees  = a; @degrees = @wrapping_angle.degrees  end
+  alias :angle= :degrees=
+end

data/lib/okami/image_tiles.rb

@@ -0,0 +1,12 @@
+module Okami::ImageTiles
+  class << self
+    def require *args
+      Okami::Image.require_tiles *args
+    end
+    alias [] require
+  
+    def load *args
+      Okami::Image.load_tiles *args
+    end
+  end
+end

data/lib/okami/keyboard.rb

@@ -1,5 +1,3 @@
-require_relative 'os'
-
 module Okami::Keyboard  
   DefaultKeySymbols = {
     Gosu::KbUp    => :up,
@@ -71,10 +69,13 @@ module Okami::Keyboard
     Gosu::KbZ => :z
   }
   
-  if Okami::OS.mac?
-    DefaultKeySymbols[55] = :left_cmd
-    DefaultKeySymbols[54] = :right_cmd
-  end
+  # Maybe the command key will be used later
+  # Right now it's buggy
+  #require_relative 'os'
+  #if Okami::OS.mac?
+  #  DefaultKeySymbols[55] = :left_cmd
+  #  DefaultKeySymbols[54] = :right_cmd
+  #end
   
   DefaultKeySymbols.freeze
 
@@ -172,16 +173,6 @@ module Okami::Keyboard
       @@key_up_listeners.each { |listener, method| method.call key } if key
     end
     
-    def release_keys
-      call_key_up_on_down_keys
-      Mouse.send :call_key_up_on_down_keys
-    end
-    
-    def call_key_up_on_down_keys
-      @@key_symbols.each do |code, key|
-        call_key_up_listeners key if key_down? key
-      end
-    end
   end
 
 end

data/lib/okami/mouse.rb

@@ -21,34 +21,22 @@ module Okami::Mouse
     def y=value; $window.mouse_y = value end
     
     def onscreen?
-      if x < 0
-        if y < 0
-          if x > $window.width
-            if y > $window.height
-              return true
-            end
-          end
-        end
-      end
-      
-      return false
+      x >= 0             &&
+      y >= 0             &&
+      x <= $window.width &&
+      y <= $window.height
     end
     
     def offscreen?
       not onscreen?
     end
 
-    def show; $window.cursor_visible = true         end
-    def hide; $window.cursor_visible = false        end
-    def visible=bool; $window.cursor_visible = bool end
+    def show;         $window.cursor_visible = true   end
+    def hide;         $window.cursor_visible = false  end
+    def visible=bool; $window.cursor_visible = bool   end
     
-    def add_key_down_listener listener_method
-      @@key_down_listeners[ listener_method.receiver ] = listener_method
-    end
-    
-    def add_key_up_listener listener_method
-      @@key_up_listeners[ listener_method.receiver ] = listener_method
-    end
+    def add_key_down_listener listener_method; @@key_down_listeners[ listener_method.receiver ] = listener_method end
+    def add_key_up_listener   listener_method; @@key_up_listeners[   listener_method.receiver ] = listener_method end
   
     def remove_key_up_listener listener
       case listener
@@ -93,7 +81,7 @@ module Okami::Mouse
   
     def button_down id
       key = @@key_symbols[id]
-      @@key_down_listeners.each { |listener, method| method.call key }
+      @@key_down_listeners.each { |listener, method| method.call key } if key
     end
 
     def button_up id
@@ -101,17 +89,6 @@ module Okami::Mouse
       @@key_up_listeners.each { |listener, method| method.call key } if key
     end
     
-    def release_keys
-      call_key_up_on_down_keys
-      Okami::Keyboard.send :call_key_up_on_down_keys
-    end
-    
-    def call_key_up_on_down_keys
-      @@key_symbols.each do |code, key|
-        button_up key if key_down? key
-      end
-    end
-    
   end
 
 end

data/lib/okami/sprite.rb

@@ -1,31 +1,42 @@
-require_relative 'drawable'
-
 class Okami::Sprite
-  include Okami::Drawable
-  AnimationModes = [:forward, :loop, :backward, :backward_loop, :ping_pong]
-
   attr_reader :image, :images, :last_frame_index
   
+  @@modes = {
+    loop:          {direction: :forward,  update_method: :update_loop},
+    backward_loop: {direction: :backward, update_method: :update_backward_loop},
+    reverse_loop:  {direction: :backward, update_method: :update_backward_loop},
+    forward:       {direction: :forward,  update_method: :update_forward},
+    backward:      {direction: :backward, update_method: :update_backward},
+    reverse:       {direction: :backward, update_method: :update_backward},
+    ping_pong:     {direction: :_forward, update_method: :update_ping_pong}
+  }
+  def self.modes; @@modes end
+    
   def initialize options
     raise_possible_errors options
-    options[:animation_mode] ||= :loop
     
-    options.each do |key, value|
-      send "#{key}=", value
-    end
+    self.images         = options[:images]
+    self.fps            = options[:fps]
+    self.frame_index    = options[:frame_index] if options[:frame_index]
+    self.mode = options[:mode] || :loop
     
     set_initial_frame_index
-    init_drawable
     update_current_image
+    
+    @@default_dt ||= $window.update_interval / 1000.0    
   end
   
+  def draw       *args;            @image.draw       *args            end
+  def draw_rot   *args;            @image.draw_rot   *args            end
+  def draw_using image_attributes; @image.draw_using image_attributes end
+  
   def fps;      @delta_frame_index * 60.0         end
   def fps=fps;  @delta_frame_index = fps / 60.0   end
   
-  def update
+  def update dt=@@default_dt
     case @direction
-    when :forward  then @frame_index += @delta_frame_index*$window.dt*60.0
-    when :backward then @frame_index -= @delta_frame_index*$window.dt*60.0
+    when :forward  then @frame_index += @delta_frame_index * dt * 60.0
+    when :backward then @frame_index -= @delta_frame_index * dt * 60.0
     end
     
     @update_method.call
@@ -34,43 +45,20 @@ class Okami::Sprite
   
   
   def finished?
-    case @animation_mode
+    case @mode
     when :forward;  @frame_index == @last_frame_index
     when :backward; @frame_index == 0
     end
   end
   alias animation_finished? finished?
   
-  attr_reader :animation_mode
-  def animation_mode= symbol
-    case symbol
-    when :loop
-      @direction = :forward
-      use_update method :update_loop
-      
-    when :backward_loop
-      @direction = :backward
-      use_update method :update_backward_loop
-      
-    when :forward
-      @direction = :forward
-      use_update method :update_forward
-      
-    when :backward
-      @direction = :backward
-      use_update method :update_backward
-      
-    when :ping_pong
-      @direction ||= :forward
-      use_update method :update_ping_pong
-      
-    else
-      puts "Supported AnimatedSprite animation modes:"
-      puts AnimationModes
-      raise ArgumentError, "AnimatedSprite, animation_mode #{symbol.inspect} not supported"
-    end
-    
-    @animation_mode = symbol
+  attr_reader :mode
+  def mode= name
+    mode_config = @@modes[name]
+    mode_config or raise_no_mode name
+    self.direction =        mode_config[:direction]
+    @update_method = method mode_config[:update_method]
+    @mode = name
   end
   
   attr_reader :frame_index
@@ -82,60 +70,62 @@ class Okami::Sprite
   end
   
   def random_frame_index
-    (rand()*@images.length)
+    rand * @images.length
   end
   
   protected
   
   def images=images
     @images = images
-    @last_frame_index  = @images.length - 1
+    @last_frame_index = @images.length - 1
   end
   
   def direction=direction
-    @direction = direction
+    case direction
+    when :forward;   @direction   = :forward
+    when :backward;  @direction   = :backward
+    when :_forward;  @direction ||= :forward
+    when :_backward; @direction ||= :backward 
+    end
   end
   
   private
   
   def set_initial_frame_index
     case @direction
-    when :forward  then @frame_index = 0
-    when :backward then @frame_index = @last_frame_index+0.999
+    when :forward  then @frame_index ||= 0
+    when :backward then @frame_index ||= @last_frame_index+0.999
     end
   end
   
-  def use_update method; @update_method = method end
   def update_current_image; @image = @images[@frame_index] end
-    
+  
+  #################
+  ## update_methods
+  
   def update_loop;          @frame_index %= @images.length  end
   def update_backward_loop; @frame_index %= @images.length  end
   
-  def update_backward
-    @frame_index = 0 if @frame_index < 0
-  end
-  
-  def update_forward
-    @frame_index = @last_frame_index if @frame_index > @last_frame_index
-  end
+  def update_backward;  @frame_index = 0                  if @frame_index < 0                 end
+  def update_forward;   @frame_index = @last_frame_index  if @frame_index > @last_frame_index end
     
   def update_ping_pong
     case @direction
     when :forward
       if @frame_index >= @last_frame_index+0.5
-        @direction = :backward
-        @frame_index = @last_frame_index+0.5
+        @direction    = :backward
+        @frame_index  = @last_frame_index+0.5
       end
       
     when :backward
-      if @frame_index < 0.5
-        @frame_index = 0.5
-        @direction = :forward
+      if @frame_index <= 0.5
+        @frame_index  = 0.5
+        @direction    = :forward
       end
-      
     end
   end
   
+  
   def raise_possible_errors options
     raise ArgumentError, "Sprite.new options must contain option :images" unless options[:images]
     raise TypeError, "Sprite.new option :images must be of type Array"    unless options[:images].kind_of? Array
@@ -144,4 +134,10 @@ class Okami::Sprite
     raise ArgumentError, "Sprite.new options must contain option :fps"    unless options[:fps]
     raise TypeError, "Sprite.new option :fps must be of type Numeric"     unless options[:fps].kind_of? Numeric
   end
+  
+  def raise_no_mode symbol
+    puts "Supported AnimatedSprite modes:"
+    puts @@modes.keys
+    raise ArgumentError, "AnimatedSprite, mode #{symbol.inspect} not supported"
+  end
 end # Okami::Sprite

data/lib/okami/window.rb

@@ -1,52 +1,42 @@
 module Okami
   class Window < Gosu::Window
-    attr_reader :dt, :current_time
-    attr_accessor :cursor_visible
     
     def initialize *args
       $window = super *args
     end
-  
+    
+    attr_accessor :cursor_visible
     def show_cursor;   @cursor_visible = true  end
     def hide_cursor;   @cursor_visible = false end
     def needs_cursor?; @cursor_visible         end
   
     def button_down id
-      Okami::Keyboard.button_down id
-      Okami::Mouse.button_down id
+      Okami::Keyboard .button_down  id
+      Okami::Mouse    .button_down  id
     end
 
-    def button_up id
-      Okami::Keyboard.button_up id
-      Okami::Mouse.button_up id
+    def button_up   id
+      Okami::Keyboard .button_up    id
+      Okami::Mouse    .button_up    id
     end
     
-    def fill color, z=0      
+    def fill color, z=0, mode=:default
       draw_quad 0,      0,      color,
                 width,  0,      color,
                 0,      height, color,
                 width,  height, color,
-                z, mode = :default
+                z, mode
     end
     
     def calculate_dt
-      @current_time    = Gosu::milliseconds/1000.0
-      @previous_time ||= @current_time - update_interval/1000.0
-      @dt              = @current_time - @previous_time
-      @previous_time   = @current_time
-    end
-    
-    def self.inherited(subclass)
-      def subclass.method_added(name)
-        if name == :update
-          ## Prevent infinite loop
-          return if caller.first.match(/^(.+?):(\d+)(?::in `(.*)')?/)[1].match /eval/i
-          ## Calculate_dt before update
-          class_eval "def update_hook\n calculate_dt\n update_without_hook\nend"
-          class_eval "alias update_without_hook update"
-          class_eval "alias update update_hook"
-        end
-      end
+      update_interval   = self.update_interval / 1000.0
+      seconds           = Time.now.to_f
+      @_current_time    = seconds
+      @_previous_time ||= @_current_time - update_interval
+      dt                = @_current_time - @_previous_time
+      @_previous_time   = @_current_time
+      dt = update_interval if dt < update_interval
+      return dt, seconds
     end
     
   end # Window

data/lib/okami/wrapping_angle.rb

@@ -1,44 +1,42 @@
-class WrappingAngle  
+class Okami::WrappingAngle  
   Tau = Math::PI * 2
   
-  def initialize
-    @c = Complex(0,1)
+  def initialize options={}
+    self.fraction = options[:fraction]  if options.has_key? :fraction
+    self.degrees  = options[:degrees]   if options.has_key? :degrees
+    self.radians  = options[:radians]   if options.has_key? :radians
+    @radians ||= 0
   end
   
-  def rotate_radians  a; @c *= Complex(0,1)**(a/Tau * 4)  end
-  def rotate_fraction a; @c *= Complex(0,1)**(a*4)        end
-  def rotate_degrees  a; @c *= Complex(0,1)**(a/90.0)     end
+  def radians;  @radians                end
+  def fraction; @radians / Tau          end
+  def degrees;  @radians / Tau * 360.0  end
   
-  def radians;  @c.angle              end
-  def fraction; @c.angle / Tau        end
-  def degrees;  @c.angle / Tau * 360  end
-  
-  def radians=  a; @c = Complex(0,1)**(a/Tau * 4) end
-  def fraction= a; @c = Complex(0,1)**(a*4.0)     end
-  def degrees=  a; @c = Complex(0,1)**(a/90.0)    end
+  def radians=  a; @radians =  a % Tau                    end
+  def fraction= a; @radians = (a % 1.0   ) * Tau          end
+  def degrees=  a; @radians = (a % 360.0 ) / 360.0 * Tau  end
   
   ### Displaying
-  
-  begin
-    require 'fraction'
-    def pretty_angle unit=@standard_unit
-      case unit
-      when :degrees
-        "#{angle(:degrees).round}°"
-      when :fraction, :radians
-        nom, den = angle(:fraction).fraction
-        return "0τ" if nom == 0
-        return "#{nom}/#{den}τ"
-      end
-    end
-  rescue LoadError
-    def pretty_angle unit=@standard_unit
-      case unit
-      when :degrees;  "#{angle(:degrees).round}°"
-      when :radians; "#{angle(:radians)} radians"
-      when :fraction;  "#{angle(:fraction)}"
-      end
-    end
-  end
+  #begin
+  #  require 'fraction'
+  #  def pretty_angle unit=@standard_unit
+  #    case unit
+  #    when :degrees
+  #      "#{angle(:degrees).round}°"
+  #    when :fraction, :radians
+  #      nom, den = angle(:fraction).fraction
+  #      return "0τ" if nom == 0
+  #      return "#{nom}/#{den}τ"
+  #    end
+  #  end
+  #rescue LoadError
+  #  def pretty_angle unit=@standard_unit
+  #    case unit
+  #    when :degrees;  "#{angle(:degrees).round}°"
+  #    when :radians; "#{angle(:radians)} radians"
+  #    when :fraction;  "#{angle(:fraction)}"
+  #    end
+  #  end
+  #end
   
 end

metadata

@@ -1,90 +1,67 @@
 --- !ruby/object:Gem::Specification
 name: okami
 version: !ruby/object:Gem::Version
-  version: 0.1.5
-  prerelease: 
+  version: 0.2.0
 platform: ruby
 authors:
 - Bue Grønlund
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-12 00:00:00.000000000 Z
+date: 2013-10-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gosu
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: texplay
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-description: Gosu Interface with fancy functionality for simplicity.
+description: Different features like simple image loading, input check, input listeners,
+  and using symbols instead of integers for input ids. Eg. :left instead of Gosu::KbLeft
 email: aerotune@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - lib/okami.rb
-- lib/okami/drawable.rb
 - lib/okami/window.rb
 - lib/okami/keyboard.rb
 - lib/okami/mouse.rb
-- lib/okami/mouse_trap.rb
 - lib/okami/image.rb
-- lib/okami/image_cache.rb
-- lib/okami/image_tiles_cache.rb
-- lib/okami/hit_mask.rb
+- lib/okami/image_tiles.rb
+- lib/okami/image_attributes.rb
 - lib/okami/sprite.rb
 - lib/okami/os.rb
 - lib/okami/wrapping_angle.rb
 homepage: https://github.com/Aerotune/Okami
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 2.1.5
 signing_key: 
-specification_version: 3
-summary: Okami minimal Gosu!
+specification_version: 4
+summary: Sugar coated Gosu
 test_files: []
-has_rdoc: 

data/lib/okami/drawable.rb

@@ -1,74 +0,0 @@
-require_relative 'wrapping_angle'
-
-module Okami::Drawable
-  @default_center_x = 0
-  @default_center_y = 0
-  
-  class << self
-    attr_accessor :default_center_x, :default_center_y
-  end
-  
-  attr_accessor :x, :y, :z
-  attr_accessor :factor_x, :factor_y
-  attr_accessor :center_x, :center_y
-  attr_accessor :color, :draw_mode
-  
-  def init_drawable
-    @factor_x = 1
-    @factor_y = 1
-    self.center_x = Okami::Drawable.default_center_x
-    self.center_y = Okami::Drawable.default_center_y
-    @x = 0
-    @y = 0
-    @z = 0
-    @wrapping_angle = WrappingAngle.new
-    @wrapping_angle.degrees = 0
-    @degrees = @wrapping_angle.degrees
-    @color = 0xFFFFFFFF
-    @draw_mode = :default
-    @color = Gosu::Color.argb(255, 255, 255, 255)
-    @alpha = 1.0
-  end
-  
-  def draw
-    @image.draw_rot @x, @y, @z, @degrees, @center_x, @center_y, @factor_x, @factor_y, @color, @draw_mode
-  end
-  
-  def rotate_radians  a; @wrapping_angle.rotate_radians  a; @degrees = @wrapping_angle.degrees  end
-  def rotate_fraction a; @wrapping_angle.rotate_fraction a; @degrees = @wrapping_angle.degrees  end
-  def rotate_degrees  a; @wrapping_angle.rotate_degrees  a; @degrees = @wrapping_angle.degrees  end
-  
-  def radians;  @wrapping_angle.radians    end
-  def fraction; @wrapping_angle.fraction   end
-  def degrees;  @wrapping_angle.degrees    end
-  
-  def radians=  a; @wrapping_angle.radians  = a; @degrees = @wrapping_angle.degrees  end
-  def fraction= a; @wrapping_angle.fraction = a; @degrees = @wrapping_angle.degrees  end
-  def degrees=  a; @wrapping_angle.degrees  = a; @degrees = @wrapping_angle.degrees  end
-    
-  attr_reader :alpha
-  def alpha=a
-    @alpha = a
-    @color.alpha = a*255
-  end
-
-  def argb= a, r, g, b
-    @color.alpha  = a * 255
-    @color.red    = r * 255
-    @color.green  = g * 255
-    @color.blue   = b * 255
-  end
-  
-  def rgba= r, g, b, a
-    @color.red    = r * 255
-    @color.green  = g * 255
-    @color.blue   = b * 255
-    @color.alpha  = a * 255
-  end
-  
-  def rgb= r, g, b
-    @color.red    = r * 255
-    @color.green  = g * 255
-    @color.blue   = b * 255
-  end
-end

data/lib/okami/hit_mask.rb

@@ -1,23 +0,0 @@
-class Okami::HitMask
-  ## white is hitpoints, black is not
-  def initialize image, parent
-    @hit_mask = image
-    @parent = parent
-  end
-  
-  def hit_point? x, y
-    c = @hit_mask.get_pixel( x - @parent.x, y - @parent.y )
-    return false unless c
-    return c[1] > 0.9 # quick 'n dirty
-  end
-  
-  def hit_line? x1, y1, x2, y2
-    !!hit_line( x1, y1, x2, y2 )
-  end
-  
-  # Returns an array with the coordinates of the first hit point [x,y] or nil if it doesn't hit
-  def hit_line x1, y1, x2, y2
-    hit_vertex = @hit_mask.line x1, y1, x2, y2, trace: { :until_color => :white, :tolerance => 0.1 }
-    hit_vertex ? hit_vertex[0..1] : nil
-  end
-end

data/lib/okami/image_cache.rb

@@ -1,18 +0,0 @@
-Okami::Images = {}
-
-class Okami::ImageCache
-  class << self    
-    ## Will cache the images so they're only loaded once.
-    def require path, tileable=Okami::Image.tileable, *src_rect
-      path = Okami::Image.load_path + path
-      Okami::Images[ path + src_rect.to_s ] ||= Gosu::Image.new $window, path, tileable, *src_rect
-    end
-    alias [] require
-    
-    ## Will load and cache even if it's already cached
-    def load path, tileable=Okami::Image.tileable, *src_rect
-      path = Okami::Image.load_path + path
-      Okami::Images[ path + src_rect.to_s ] = Gosu::Image.new $window, path, tileable, *src_rect
-    end
-  end
-end

data/lib/okami/image_tiles_cache.rb

@@ -1,17 +0,0 @@
-Okami::ImageTiles = {}
-
-class Okami::ImageTilesCache
-  class << self        
-    def require path, tile_width, tile_height, tileable=Okami::Image.tileable
-      path = Okami::Image.load_path + path
-      Okami::ImageTiles[ "size:#{tile_width},#{tile_height}&" + path ] ||= Gosu::Image.load_tiles $window, path, tile_width, tile_height, tileable
-    end
-    alias [] require
-    
-    ## Will load and cache even if it's already cached
-    def load path, tile_width, tile_height, tileable=Okami::Image.tileable
-      path = Okami::Image.load_path + path
-      Okami::ImageTiles[ "size:#{tile_width},#{tile_height}&" + path ] = Gosu::Image.load_tiles $window, path, tile_width, tile_height, tileable
-    end
-  end
-end

data/lib/okami/mouse_trap.rb

@@ -1,18 +0,0 @@
-module Okami
-  module MouseTrap
-    class << self
-      def capture
-        @captured ? false : @captured = true
-      end
-    
-      def release
-        @captured = false
-        return true
-      end
-    
-      def captured?
-        @captured
-      end
-    end
-  end
-end