gemini 1.0.0

data/bin/gemini

@@ -0,0 +1,18 @@
+#!/usr/bin/env jruby
+$LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), '..', 'src'))
+require 'project_generator'
+
+rawr_install_args = ''
+project_dir = nil
+until ARGV.empty?
+  arg = ARGV.shift
+  case arg
+  when /-RI(.+)/
+    rawr_install_args << $1 + ' '
+  else
+    project_dir = arg
+  end
+end
+raise "No project dir provided" if project_dir.nil?
+generator = Gemini::ProjectGenerator.new(:project_dir => project_dir, :rawr_install => rawr_install_args)
+generator.generate_project

data/build_configuration.rb

@@ -0,0 +1,24 @@
+configuration do |c|
+  c.project_name = 'gemini'
+  c.output_dir = 'package'
+#  c.main_ruby_file = 'main'
+#  c.main_java_file = 'org.rubyforge.rawr.Main'
+
+  # Compile all Ruby and Java files recursively
+  # Copy all other files taking into account exclusion filter
+  c.source_dirs = ['src']
+  c.source_exclude_filter = []
+
+  c.jruby_jar = 'lib/jruby-complete.jar'
+  c.compile_ruby_files = false
+  #c.java_lib_files = []  
+  c.java_lib_dirs = ['lib']
+  #c.files_to_copy = Dir.glob('lib/native_files/*')
+
+  c.target_jvm_version = 1.5
+  #c.jars[:data] = { :directory => 'data/images', :location_in_jar => 'images', :exclude => /bak/}
+  #c.jvm_arguments = ""
+
+  # Bundler options
+  # c.do_not_generate_plist = false
+end

data/src/base_state.rb

@@ -0,0 +1,112 @@
+module Gemini
+  class BaseState
+    @@active_state = nil
+    def self.active_state
+      @@active_state
+    end
+    
+    def self.active_state=(state)
+      @@active_state = state
+    end
+        
+    def initialize(container, game)
+      @container = container
+      @game = game
+      
+      game_object_manager = BasicGameObjectManager.new(self)
+      update_manager = BasicUpdateManager.new(self)
+      render_manager = BasicRenderManager.new(self)
+      input_manager = InputManager.new(self, container)
+      message_manager = MessageQueue.new(self)
+      
+      @managers = {:game_object => game_object_manager,
+                   :update => update_manager,
+                   :render => render_manager,
+                   :input => input_manager,
+                   :message_queue => message_manager
+                  }
+      
+      @paused = false
+    end
+    
+    def screen_width
+      @game.screen_width
+    end
+    
+    def screen_height
+      @game.screen_height
+    end
+    
+    def create_on_layer(type, layer_name, *params)
+      game_object_type = begin
+                           type.constantize
+                         rescue NameError
+                           begin
+                             require type.underscore
+                             begin
+                               type.constantize
+                             rescue NameError
+                               "Gemini::#{type}".constantize
+                             end
+                           rescue LoadError
+                             "Gemini::#{type}".constantize
+                           end
+                         end
+      game_object = game_object_type.new(self, *params)
+      add_game_object_to_layer game_object, layer_name
+      game_object
+    end
+    
+    def create(type, *params)
+      create_on_layer(type, :default, *params)
+    end
+
+    def create_game_object(type, *params)
+      warn "create_game_object is deprecated, use create instead"
+      create(type, *params)
+    end
+    
+    def manager(type)
+      @managers[type]
+    end
+    
+    def add_game_object(game_object)
+      @managers[:game_object].add_game_object game_object
+    end
+
+    def add_game_object_to_layer(game_object, layer_name)
+      @managers[:game_object].add_game_object_to_layer game_object, layer_name
+    end
+    
+    def remove(game_object)
+      @managers[:game_object].remove_game_object(game_object)
+    end
+
+    def remove_game_object(game_object)
+      warn "remove_game_object is deprecated, use remove instead"
+      remove(game_object)
+    end
+    
+    def switch_state(state_name, *args)
+      state = @game.load_state state_name, args
+      @game.queue_state state
+      #self.class.active_state = state
+      #state.load
+      state
+    end
+    
+    def load_keymap(keymap)
+      @managers[:input].load_keymap keymap
+    end
+    
+    def load(*args); end
+    
+    def quit_game
+      java.lang.System.exit 0
+    end
+  private
+    def set_manager(type, manager)
+      @managers[type] = manager
+    end
+  end
+end

data/src/behavior.rb

@@ -0,0 +1,230 @@
+require 'listenable_mixin'
+
+module Gemini
+  class MethodExistsError < Exception; end
+  class InvalidWrapWithCallbacksError < Exception; end
+  
+  class ValueChangedEvent
+    attr_accessor :previous_value, :desired_value
+    
+    def initialize(previous_value, desired_value)
+      @previous_value, @desired_value = previous_value, desired_value
+    end
+  end
+  
+  class Behavior
+    include ListenableMixin
+    attr_reader :reference_count, :target
+    
+    def self.method_added(method)
+      if callback_methods_to_wrap.member? method
+        begin
+          return if callback_methods_wrapped.member? method #instance_method(:"wrapped_#{method}") #&& wrapped_methods.member?(method)
+        rescue NameError; end #Intentionally swallow, this section is to prevent infinite recursion
+        callback_methods_wrapped << method
+        alias_method :"wrapped_#{method}", method
+        arity = instance_method(:"wrapped_#{method}").arity
+        if arity.abs > 0
+          args = (1..arity.abs).inject([]){|args, i| args << "arg#{i}" }
+          args[-1].insert(0,"*") if arity < 0
+        end
+        if match = /^(.*)=$/.match(method.to_s)
+          method_name = match[1]
+          code = <<-ENDL
+            def #{method}(#{args})
+              raise Gemini::InvalidWrapWithCallbacksError.new("Cannot wrap #{method} with callbacks without \\"#{method_name}\\"") unless respond_to?(:#{method_name})
+              event = ValueChangedEvent.new(@target.#{method_name}, #{args})
+              callback_abort = CallbackStatus.new
+              @target.notify :before_#{method_name}_changes, event
+              if callback_abort.continue?              
+                self.wrapped_#{method}(#{args})
+                @target.notify :after_#{method_name}_changes, event
+              end
+            end
+          ENDL
+          wrapped_methods << "before_#{method_name}_changes"
+          wrapped_methods << "after_#{method_name}_changes"
+        else
+          code = <<-ENDL
+            def #{method}(#{(args.join(",") + ",") if args} &block)
+              callback_abort = CallbackStatus.new
+              @target.notify :before_#{method}, callback_abort
+              if callback_abort.continue?              
+                self.wrapped_#{method}(#{(args.join(",") + ",") if args} &block)
+                @target.notify :after_#{method}
+              end
+            end
+          ENDL
+          wrapped_methods << "before_#{method}"
+          wrapped_methods << "after_#{method}"
+        end
+        self.class_eval(code, __FILE__, __LINE__)
+      else
+        super
+      end
+    end
+    
+  protected
+  
+    def self.depends_on(behavior)
+      require "behaviors/#{behavior.underscore}"
+      add_dependency(behavior)
+    end
+
+    def self.depends_on_kind_of(behavior)
+      add_kind_of_dependency(behavior)
+    end
+    
+    def self.wrap_with_callbacks(*args)
+      @@callback_methods_to_wrap[self].concat args
+    end
+    
+    @@callback_methods_to_wrap = Hash.new {|h,k| h[k] = []}
+    def self.callback_methods_to_wrap
+      @@callback_methods_to_wrap[self]
+    end
+    
+    @@callback_methods_wrapped = Hash.new {|h,k| h[k] = []}
+    def self.callback_methods_wrapped
+      @@callback_methods_wrapped[self]
+    end
+    
+    @@wrapped_methods = Hash.new {|h,k| h[k] = []}
+    def self.wrapped_methods
+      @@wrapped_methods[self]
+    end
+    
+  private
+    
+    def self.new(*args)
+      super
+    end
+    
+    def self.declared_method_list
+      public_instance_methods - Behavior.public_instance_methods
+    end
+
+    @@behavior_dependencies = Hash.new{|h,k| h[k] = []}
+    def self.dependencies
+      @@behavior_dependencies[self]
+    end
+    
+    def self.add_dependency(behavior)
+      @@behavior_dependencies[self] << behavior
+    end
+    
+    @@kind_of_behavior_dependencies = Hash.new{|h,k| h[k] = []}
+    def self.kind_of_dependencies
+      @@kind_of_behavior_dependencies[self]
+    end
+    
+    def self.add_kind_of_dependency(behavior)
+      @@kind_of_behavior_dependencies[self] << behavior
+    end
+    
+    def initialize(target)
+      @target = target
+      @dependant_behaviors = []
+      @reference_count = 0
+      
+      self.class.dependencies.each do |dependant_behavior|
+        begin
+          dependant_behavior_class = Object.const_get(dependant_behavior)
+        rescue NameError
+          raise "Cannot load dependant behavior '#{dependant_behavior}' in behavior '#{self.class}'"
+        end
+        unless @target.kind_of? dependant_behavior_class
+          @target.add_behavior dependant_behavior_class.to_s 
+          @dependant_behaviors << dependant_behavior
+        end
+      end
+
+      #TODO: Move this to GameObject
+      behavior_list = @target.send(:instance_variable_get, :@__behaviors)
+      return unless behavior_list[self.class.name.to_sym].nil?
+      behavior_list[self.class.name.to_sym] = self 
+
+#      self.class.kind_of_dependencies.each do |dependant_behavior|
+#        dependency = dependant_behavior.constantize
+#        next if behavior_list.find {|behavior| behavior.last.kind_of?(dependency)}
+#        
+#        raise "Dependant behavior '#{dependant_behavior}' was not found on class #{self.class}" 
+#      end
+
+      self.class.declared_method_list.each do |method|
+        #TODO: Tell us which behavior is being overridden
+        #TODO: Allow for overriding
+        raise MethodExistsError.new("Error while adding the behavior #{self.class}. The method #{method} already exists on game object #{@target}.") if @target.respond_to? method
+        if method.to_s =~ /=/
+          code = <<-ENDL
+          def #{method}(arg)
+            @__behaviors[:#{self.class}].#{method}(arg)
+          end
+          ENDL
+        else
+          code = <<-ENDL
+          def #{method}(*args, &blk)
+            @__behaviors[:#{self.class}].#{method}(*args, &blk)
+          end
+          ENDL
+        end
+        @target.send(:instance_eval, code, __FILE__, __LINE__)
+      end
+
+      self.class.wrapped_methods.each do |method|
+        @target.enable_listeners_for method
+      end
+
+      load
+    end
+
+    def delete
+      return if @deleted
+      unload
+      __remove_listeners
+      self.class.declared_method_list.each do |method_name|
+        target_class = class <<@target; self; end
+        target_class.send(:remove_method, method_name)
+      end
+      #TODO: Make sure we don't delete dependent behaviors that still have depending behaviors
+      @dependant_behaviors.each do |dependant| 
+        @target.remove_behavior dependant
+      end
+      @deleted = true
+    end
+    
+  public
+    
+    def set_event_aliases(mappings, block)
+      if mappings.kind_of? Hash
+        mappings.each do |event, event_alias|
+          @target.handle_event(event_alias) do |message|
+            send(event, message)
+          end
+        end
+      else mappings.kind_of? Symbol
+        @target.handle_event(mappings) do |message|
+          message = message.dup
+          send(block.call(message), message)
+        end
+      end
+    end
+    
+    def add_reference_count
+      @reference_count += 1
+    end
+    
+    def remove_reference_count
+      @reference_count -= 1
+    end
+
+    def load; end
+    def unload; end
+  end
+  
+  class CallbackStatus
+    def continue?
+      true
+    end
+  end
+end

data/src/behavior_event.rb

@@ -0,0 +1,23 @@
+#TODO: This appears to be un-used. Use it or drop it.
+
+module Gemini
+  class BehaviorEvent
+    def initialize(*args)
+      @memoizations = Hash.new { |h,k| h[k] = {} }
+      load(*args)
+    end
+    
+    def load(*args); end
+
+    def self.method_added(name)
+      match = /^memoize_(.+)$/.match name.to_s
+      return unless match
+      public_name = match[1]
+      eval <<-ENDL
+        def #{public_name}(*args)
+          @memoizations[:#{public_name}][args] ||= #{name}
+        end
+      ENDL
+    end
+  end
+end