gemini 1.0.0

data/src/game_objects/triangle_trail.rb

@@ -0,0 +1,85 @@
+class Gemini::TriangleTrail < Gemini::GameObject
+  #has_behavior :Movable2d
+  has_behavior :Spatial
+  attr_accessor :radius, :alpha
+  
+  def load
+    @trail = []
+    @trail_poly_size = 10
+    @trail_size = 50
+    @radius = 10
+    @alpha = 0.5
+    @flip = false
+    #TODO: Remove message when the callback stuff is checked in
+    @first_move = true
+    listen_for(:after_move) do |message|
+      if @first_move
+        @first_move = false
+        next
+      end
+      @trail.pop if @trail.size >= @trail_size
+      @trail.unshift([x, y])
+    end
+  end
+  
+  def draw(graphics)
+    if @trail.size > 3
+      gl = Java::org::newdawn::slick::opengl::renderer::Renderer.get
+
+      #Java::org::newdawn::slick::opengl::SlickCallable.new do
+      callable_class = Java::org::newdawn::slick::opengl::SlickCallable
+      callable_class.enter_safe_block
+        # use LWJGL's const directly, Slick's wrapper does not have the triangle strip const
+        triangle_strip_enum = Java::org::lwjgl::opengl::GL11::GL_TRIANGLE_STRIP
+          gl.gl_begin triangle_strip_enum
+          gl.gl_color4f(0.0, 1.0, 1.0, @alpha)
+
+          origin_x, origin_y = calculate_point_on_trail_edge(@trail[1], @trail[0], @radius, @flip)
+          gl.gl_vertex2f(origin_x, origin_y)
+
+          flipped_origin_x, flipped_origin_y = calculate_point_on_trail_edge(@trail[1], @trail[0], @radius, !@flip)
+          gl.gl_vertex2f(flipped_origin_x, flipped_origin_y)
+          
+          last_trail_vector = @trail[1]
+          #gl.gl_color4f(0.0, 1.0, 1.0, alpha)
+          @trail[2..-1].each_with_index do |trail_vector, index|
+            next if trail_vector == last_trail_vector
+            actual_trail_size = (@trail.size - 1).to_f
+            trail_radius = (@radius) * ((actual_trail_size - (index + 2).to_f) / actual_trail_size)
+            
+            rotated_x, rotated_y = calculate_point_on_trail_edge(trail_vector, last_trail_vector, trail_radius, @flip)
+            gl.gl_vertex2f(rotated_x, rotated_y)
+            rotated_x, rotated_y = calculate_point_on_trail_edge(trail_vector, last_trail_vector, trail_radius, !@flip)
+            gl.gl_vertex2f(rotated_x, rotated_y)
+            
+            last_trail_vector = trail_vector
+          end
+          gl.gl_end
+      callable_class.leave_safe_block
+    end
+  end
+  
+  def calculate_point_on_trail_edge(current_vector, previous_vector, trail_radius, flip)
+    trail_diff = [current_vector[0] - previous_vector[0], current_vector[1] - previous_vector[1]]
+    diff_angle = Math.atan2(trail_diff[1].to_f, trail_diff[0].to_f)
+
+    rotation_angle = (Math::PI * 1) / 2
+    rotation_angle = -rotation_angle if flip
+    
+    sine = Math.sin(diff_angle + rotation_angle)
+    cosine = Math.cos(diff_angle + rotation_angle)
+    rotated_weight_x = cosine
+    rotated_weight_y = sine
+    
+    rotated_x = (trail_radius * rotated_weight_x) + current_vector[0]
+    rotated_y = (trail_radius * rotated_weight_y) + current_vector[1]
+    
+    [rotated_x, rotated_y]
+  end
+  
+  def normalize_vector(vector)
+    max_value = vector.map{|value| value.abs}.max
+    return Array.new(vector.size, 0) if max_value.zero?
+    vector.map {|value| value / max_value}
+  end
+end

data/src/gemini.rb

@@ -0,0 +1,110 @@
+$LOAD_PATH << File.expand_path(File.dirname(__FILE__) + '/managers').gsub('%20', ' ')
+$LOAD_PATH << File.expand_path(File.dirname(__FILE__) + '/game_objects').gsub('%20', ' ')
+#$LOAD_PATH << File.expand_path(File.dirname(__FILE__) + '/states')
+$LOAD_PATH << File.expand_path(File.dirname(__FILE__) + '/input_helpers').gsub('%20', ' ')
+
+# Because Windows isn't friendly with JRuby
+$LOAD_PATH << 'managers'
+$LOAD_PATH << 'game_objects'
+#$LOAD_PATH << 'states'
+$LOAD_PATH << 'input_helpers'
+
+require 'platform'
+require 'color'
+require 'vector'
+require 'spline'
+require 'inflector'
+
+require 'math'
+require 'proc_enhancement'
+require 'game_object'
+require 'message_queue'
+require 'input_manager'
+require 'base_state'
+require 'inflector'
+require 'basic_game_object_manager'
+require 'basic_update_manager'
+require 'basic_render_manager'
+
+module Gemini
+  class Main < Java::org::newdawn::slick::BasicGame
+    include_class 'org.newdawn.slick.AppGameContainer'
+    attr_accessor :screen_width, :screen_height, :initial_state
+    
+    def self.start_app(screen_title, screen_width, screen_height, initial_state, fullscreen=false)
+      puts "in start app"
+      main = Main.new(screen_title, initial_state)
+      main.screen_width  = screen_width
+      main.screen_height = screen_height
+      container = AppGameContainer.new(main, screen_width, screen_height, fullscreen)
+      container.vsync = false
+      container.maximum_logic_update_interval = 60
+      container.smooth_deltas = false #true
+      #main.container = container
+      container.start
+    end
+    
+    def self.create_canvas(screen_title, screen_width, screen_height, initial_state)
+      main = Main.new screen_title, initial_state
+      main.screen_width  = screen_width
+      main.screen_height = screen_height
+      puts "creating canvas"
+      $canvas = Java::org::newdawn::slick::CanvasGameContainer.new(main)
+      puts "setting size to #{screen_width}, #{screen_height}"
+      $canvas.set_size(screen_width, screen_height)
+      puts "done setting size"
+      container = $canvas.container
+      container.vsync = true
+      container.maximum_logic_update_interval = 60
+      #container.start
+      $canvas
+    end
+    
+    def initialize(screen_title=nil, initial_state=:MainState)
+      super(screen_title)
+      @initial_state = initial_state
+      @fresh_state = true
+    end
+    
+    def init(container)
+      @container = container
+      BaseState.active_state = load_state(@initial_state)
+      BaseState.active_state.load
+    end
+    
+    def update(container, delta)
+      #don't tell the new state that it now has to update load time worth of a delta
+      if @fresh_state
+        delta = 0
+        @fresh_state = false
+      end
+      # Workaround for image loading with Slick.
+      # Must be done in game init or game loop (instead of immediately in the event).
+      if @queued_state
+        @queued_state.load(*@state_args)
+        BaseState.active_state = @queued_state
+        @queued_state = nil
+        @fresh_state = true
+        return
+      end
+      BaseState.active_state.manager(:input).poll(@screen_width, @screen_height, delta)
+      BaseState.active_state.manager(:message_queue).process_messages(delta)
+      BaseState.active_state.manager(:update).update(delta)
+      BaseState.active_state.manager(:game_object).__process_pending_game_objects
+    end
+
+    def render(container, graphics)
+      BaseState.active_state.manager(:render).render(graphics)
+    end
+    
+    def load_state(state_name, args = [])
+      require "states/#{state_name.underscore}" unless Object.const_defined? state_name.camelize
+      @state_args = args
+      state_name.camelize.constantize.new @container, self
+    end
+    
+    def queue_state(state)
+      @queued_state = state
+    end
+  end
+end

data/src/gemini_version.rb

@@ -0,0 +1,3 @@
+module Gemini
+  VERSION = "1.0.0"
+end

data/src/inflector.rb

@@ -0,0 +1,68 @@
+# This code is a modified version of the Inflector class
+# from the Ruby on Rails project (http://www.rubyonrails.com)
+
+module Monkeybars
+  module Inflector
+    # The reverse of +camelize+. Makes an underscored form from the expression in the string.
+    #
+    # Changes '::' to '/' to convert namespaces to paths.
+    #
+    # Examples
+    #   "ActiveRecord".underscore #=> "active_record"
+    #   "ActiveRecord::Errors".underscore #=> active_record/errors
+    def underscore()
+      self.to_s.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+    end
+
+    # Constantize tries to find a declared constant with the name specified
+    # in the string. It raises a NameError when the name is not in CamelCase
+    # or is not initialized.
+    #
+    # Examples
+    #   "Module".constantize #=> Module
+    #   "Class".constantize #=> Class
+    def constantize()
+      unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ self.to_s
+        raise NameError, "#{self.inspect} is not a valid constant name!"
+      end
+
+      Object.module_eval("::#{$1}", __FILE__, __LINE__)
+    end
+
+    # By default, camelize converts strings to UpperCamelCase. If the argument to camelize
+    # is set to ":lower" then camelize produces lowerCamelCase.
+    #
+    # camelize will also convert '/' to '::' which is useful for converting paths to namespaces
+    #
+    # Examples
+    #   "active_record".camelize #=> "ActiveRecord"
+    #   "active_record".camelize(:lower) #=> "activeRecord"
+    #   "active_record/errors".camelize #=> "ActiveRecord::Errors"
+    #   "active_record/errors".camelize(:lower) #=> "activeRecord::Errors"
+    def camelize(first_letter_in_uppercase = true)
+      if first_letter_in_uppercase
+        self.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+      else
+        self.to_s[0..0] + camelize(self.to_s)[1..-1]
+      end
+    end
+  end
+end
+
+class String
+  include Monkeybars::Inflector
+end
+
+class Symbol
+  include Monkeybars::Inflector
+end
+
+class Class
+  def constantize
+    self
+  end
+end

data/src/input_helpers/joystick_dead_zone_filter.rb

@@ -0,0 +1,9 @@
+module JoystickDeadZoneFilter
+  def filter_dead_zone(dead_zone, value)
+    if dead_zone > value.abs
+      0.0
+    else
+      value
+    end
+  end
+end

data/src/listenable_mixin.rb

@@ -0,0 +1,15 @@
+module Gemini
+  module ListenableMixin
+    def __added_listener_for(target, method_name, callback)
+      @__methods_registered ||= {}
+      @__methods_registered[target] = [method_name, callback]
+    end
+    
+    def __remove_listeners
+      return if @__methods_registered.nil?
+      @__methods_registered.each do |target, listener_method_name_and_callback|
+        target.send("remove_#{listener_method_name_and_callback.first}", self, listener_method_name_and_callback.last)
+      end
+    end
+  end
+end

data/src/managers/basic_game_object_manager.rb

@@ -0,0 +1,81 @@
+class BasicGameObjectManager < Gemini::GameObject
+  attr_reader :layers
+  FRONT_LAYER = 'front'
+  BACK_LAYER = 'back'
+  
+  def load
+    enable_listeners_for :before_add_game_object, :after_add_game_object, :before_remove_game_object, :after_remove_game_object
+    #@layers = Hash.new{|h,k| h[k] = []}
+    @layer_order = [:default]
+    @layers = {:default => []}
+    @game_objects_to_remove = []
+    @game_objects_to_add = []
+  end
+  
+  def __process_pending_game_objects
+    @game_objects_to_remove.pop.__destroy until @game_objects_to_remove.empty?
+    until @game_objects_to_add.empty?
+      layer, game_object = @game_objects_to_add.pop 
+      @layers[layer] << game_object
+    end
+  end
+  
+  def add_game_object(game_object)
+    notify :before_add_game_object, game_object, :default
+    @layers[:default] << game_object
+    notify :after_add_game_object, game_object, :default
+  end
+  
+  def remove_game_object(game_object)
+    owning_layer = @layers.values.find {|layer| layer.include? game_object}
+    return if owning_layer.nil? #NOTE: Not sure if this is the right thing to do, but at least no exception is thrown
+    notify :before_remove_game_object, game_object
+    owning_layer.delete game_object
+    game_object.unload
+    notify :after_remove_game_object, game_object
+    @game_objects_to_remove.push game_object
+    #game_object.unload
+  end
+  
+  def add_game_object_to_layer(game_object, layer)
+    notify :before_add_game_object, game_object, layer
+    @layers[layer] << game_object
+    #@game_objects_to_add.push [layer, game_object]
+    notify :after_add_game_object, game_object
+  end
+  
+  def move_game_object_to_layer(game_object, layer_name)
+    owning_layer = @layers.values.find {|layer| layer.include? game_object}
+    owning_layer.delete game_object
+    @layers[layer_name] << game_object
+  end
+  
+  def game_objects
+    game_objects = []
+    @layers.values.each do |layer|
+      layer.each do |game_object|
+        game_objects << game_object
+      end
+    end
+    game_objects
+  end
+  
+  def layers_by_order
+    @layer_order.map {|layer_name| @layers[layer_name]}.compact
+  end
+  
+  def add_layer_at(layer_name, location)
+    if location.kind_of? Numeric
+      @layer_order.delete_at(location) if @layer_order[location].nil?
+      @layer_order.insert(location, layer_name)
+    else # string/symbol
+      case location.to_s
+      when FRONT_LAYER
+        @layer_order << layer_name
+      when BACK_LAYER
+        @layer_order.unshift(layer_name)
+      end
+    end
+    @layers[layer_name] = []
+  end
+end

data/src/managers/basic_physics_manager.rb

@@ -0,0 +1,97 @@
+require 'behaviors/physical'
+
+class BasicPhysicsManager < Gemini::GameObject
+  INTERPOLATION_THESHOLD = 6.0
+  MILLISECONDS_PER_UPDATE = 6 # 6000/ 1000
+  DELTA_FACTOR = 0.01
+  include_class 'net.phys2d.math.Vector2f'
+  include_class 'net.phys2d.raw.World'
+  include_class 'net.phys2d.raw.strategies.QuadSpaceStrategy'
+  include_class 'net.phys2d.raw.strategies.BruteCollisionStrategy'
+  has_behavior :ReceivesEvents
+  
+  def load
+    @delta_debt = 0
+    @world = World.new(Vector2f.new(0, 0), 5, QuadSpaceStrategy.new(20, 5))
+#    @world = World.new(Vector2f.new(0, 0), 10, BruteCollisionStrategy.new)
+    @world.add_listener self
+    @game_state.manager(:update).on_update do |delta|
+      update delta
+    end
+    
+    @game_state.manager(:game_object).on_after_add_game_object do |game_object|
+      add_to_world game_object if game_object.kind_of? Physical
+    end
+    
+    @game_state.manager(:game_object).on_after_remove_game_object do |game_object|
+      game_object.remove_from_world(@world) if game_object.kind_of? Physical
+    end
+    
+    handle_event :toggle_debug_mode, :toggle_debug_mode
+  end
+
+  def update(delta)
+    delta += @delta_debt
+    @delta_debt = 0
+    if delta == MILLISECONDS_PER_UPDATE
+      step
+    else
+      temp_delta = delta
+      until temp_delta <= 0
+        new_delta = temp_delta > MILLISECONDS_PER_UPDATE ? MILLISECONDS_PER_UPDATE : temp_delta
+        if new_delta < MILLISECONDS_PER_UPDATE
+          @delta_debt = new_delta
+          return #don't step, we'll try again next update
+        else
+          step
+          temp_delta -= new_delta
+        end
+      end
+    end
+  end
+  
+  # there's a typo in the API, I swears it.
+  def collision_occured(event)
+    event.body_a.user_data.notify :physical_collided, PhysicsMessage.new(event, event.body_b.user_data)
+    event.body_b.user_data.notify :physical_collided, PhysicsMessage.new(event, event.body_a.user_data)
+  end
+  
+  def toggle_debug_mode(message)
+    @debug_mode = !@debug_mode
+    @game_state.manager(:game_object).game_objects.each do |game_object|
+      game_object.set_physical_debug_mode(@debug_mode) if game_object.kind_of? Physical
+    end
+  end
+  
+  def gravity=(gravity_or_x)
+    if gravity_or_x.kind_of? Numeric
+      @world.set_gravity(0, gravity_or_x)
+    else
+      raise "Not implemented yet"
+#      @world.set_gravity(gravity_or_x)
+    end
+  end
+
+private
+  def step
+    @world.step # must step at fixed rate (1/60f) or results are unpredictable
+  end
+
+  def add_to_world(game_object)
+    game_object.add_to_world(@world) 
+    game_object.set_physical_debug_mode(true) if @debug_mode
+  end
+#  def colliding?(body)
+#    0 < @world.get_contacts(body).size
+#  end
+
+  #TODO: Make subclass of Message
+  class PhysicsMessage
+    attr_reader :other, :event
+    
+    def initialize(slick_event, other)
+      @event = slick_event
+      @other = other
+    end
+  end
+end