jemini 2009.10.27

data/src/managers/render_support/hardware_cursor.rb

@@ -0,0 +1,13 @@
+module HardwareCursor
+  def use_available_hardware_cursor
+    resource_manager = game_state.manager(:resource)
+    resource_manager.on_resources_loaded do
+      cursor_resource = resource_manager.get_image(:mouse_cursor) rescue nil
+      game_state.container.set_mouse_cursor(cursor_resource, 0, 0) if cursor_resource
+    end
+  end
+
+  def revert_hardware_cursor
+    game_state.container.set_default_mouse_cursor
+  end
+end

data/src/managers/resource_manager.rb

@@ -0,0 +1,167 @@
+require 'resource'
+
+class ResourceManager < Jemini::GameObject
+  java_import 'org.newdawn.slick.Image'
+  java_import 'org.newdawn.slick.Music'
+  java_import 'org.newdawn.slick.Sound'
+  
+  #Sets a default data directory path of "data".
+  def load
+    enable_listeners_for :resources_loaded
+    @images = {}
+    @sounds = {}
+    @songs = {}
+  end
+  
+  #Load resources for the given state.
+  #Uses the current state if none specified.
+  def load_resources(state_name = nil)
+    state_name ||= game_state.name
+    log.debug "Loading resources for state: #{state_name}"
+    subdirectory = File.join(Jemini::Resource.base_path, state_name)
+    log.debug "Looking for subdirectory: #{subdirectory}"
+    load_directory(subdirectory) if File.directory?(subdirectory) || File.in_jar?(subdirectory)
+    load_directory(Jemini::Resource.base_path, true)
+    notify :resources_loaded
+  end
+  
+  #Load the image at the given path, and make it accessible via the given key.
+  def cache_image(key, path)
+    log.debug "Caching image for #{key} with path: #{path}"
+    log.warn "Skipping duplicate image for #{key} with path: #{path}" and return if @images[key]
+    @images[key] = load_resource(path, :image)
+  end
+  
+  #Load the sound at the given path, and make it accessible via the given key.
+  def cache_sound(key, path)
+    log.debug "Caching sound for #{key} with path: #{path}"
+    log.warn "Skipping duplicate sound for #{key} with path: #{path}" and return if @sounds[key]
+    @sounds[key] = load_resource(path, :sound)
+  end
+  
+  #Load the song at the given path, and make it accessible via the given key.
+  def cache_song(key, path)
+    log.debug "Caching song for #{key} with path: #{path}"
+    log.warn "Skipping duplicate song for #{key} with path: #{path}" and return if @songs[key]
+    @songs[key] = load_resource(path, :music)
+  end
+  
+  #Get an image stored previously with cache_image.
+  def get_image(key)
+    @images[key] or raise "Could not find image: #{key} - cached images: #{@images.keys}"
+  end
+  alias_method :image, :get_image
+  
+  #Get all images stored previously with cache_image.
+  def get_all_images
+    @images.values
+  end
+  alias_method :images, :get_all_images
+
+  def image_names
+    @images.keys
+  end
+  
+  #Get a sound stored previously with cache_sound.
+  def get_sound(key)
+    @sounds[key] or raise "Could not find sound: #{key}"
+  end
+  alias_method :sound, :get_sound
+  
+  #Get all sounds stored previously with cache_sound.
+  def get_all_sounds
+    @sounds.values
+  end
+  alias_method :sounds, :get_all_sounds
+  
+  #Get a song stored previously with cache_song.
+  def get_song(key)
+    @songs[key] or raise "Could not find song: #{key}"
+  end
+  alias_method :song, :get_song
+  
+  #Get all songs stored previously with cache_song.
+  def get_all_songs
+    @songs.values
+  end
+  alias_method :songs, :get_all_songs
+
+private
+
+  def load_resource(path, type_name)
+    # due to some JRuby trickery involved with java_import, we can't use metaprogramming tricks here.
+    type  = case type_name
+            when :image
+              Image
+            when :sound
+              Sound
+            when :music
+              Music
+            end
+    type.new(Jemini::Resource.path_of(path))
+  end
+
+  # root dirs can't be skipped
+  def load_directory(directory, root = false)
+    log.debug "Loading contents of #{directory}"
+    begin
+      #Dir.open(directory).each do |file|
+      resources_for(directory).each do |file|
+        next if file =~ /^\./
+#        path = File.join(directory, file)
+        path = File.in_jar?(directory) ? file : File.join(directory, file)
+        log.debug "Dir in jar? #{File.in_jar?(directory)}"
+        log.debug "Using path #{path} for #{file}"
+        # File.file? doesn't work in a jar.
+#        next unless File.file?(path)
+        extension = File.extname(file).downcase
+        key = File.basename(file, extension).downcase.to_sym
+        log.debug "Extension: #{extension}"
+        case extension
+        when '.png', '.gif'
+          cache_image(key, path)
+        when '.wav'
+          cache_sound(key, path)
+        when '.ogg'
+          cache_song(key, path)
+        else
+          log.warn "Skipping unknown file: #{path}"
+        end
+      end
+    rescue Errno::ENOENT => e
+      if root
+        raise
+      else
+        log.debug "#{directory} directory not found. Skipping."
+      end
+    end
+  end
+
+  def resources_for(directory)
+    if File.in_jar?(directory)
+      scan_entire_jar(directory)
+    else
+      log.debug "opening #{directory}"
+      Dir.open(directory)
+    end
+  end
+
+  # globs MUST start at the base dir of the jar, or it won't work.
+  def scan_entire_jar(directory)
+    just_dir = File.basename(directory)
+    log.debug "just dir: #{just_dir}"
+    log.debug "dir:      #{directory}"
+    jar_name = File.jar_of(directory, 'data') # we're always going to get our data from the data jar
+    log.debug "opening jar #{jar_name}"
+    jar_file = java.util.jar.JarFile.new(jar_name)
+    dir_regex = Regexp.new(just_dir)
+    all_entries = jar_file.entries.map {|e| e.name }
+    entries_under_directory = all_entries.select {|e| e =~ dir_regex }
+    # need a shallow resultset
+    entries_directly_under_directory = entries_under_directory.reject {|e| e =~ /#{just_dir}\/.*\//}
+#    log.debug "entries directly under dir"
+#    log.debug entries_directly_under_directory
+#    log.debug "------------"
+    entries_directly_under_directory
+  end 
+end

data/src/managers/sound_manager.rb

@@ -0,0 +1,47 @@
+class SoundManager < Jemini::GameObject
+  #TODO: Raise errors if sounds/music loaded/used when not on the proper thread?
+  #TODO: We can't play oggs as sounds in Windows/Linux. We get an Open AL error: 40963
+  #Wrapper for org.newdawn.slick.Sound.
+  class Sound < Java::org::newdawn::slick::Sound; end
+  class Music < Java::org::newdawn::slick::Music; end
+  
+  def load
+    @sounds = {}
+  end
+  
+  def unload
+    stop_all
+  end
+  
+  #Takes a reference to a sound loaded via the resource manager, and plays it.
+  #volume is 0.0 for silence, 1.0 for normal volume, or higher values for amplified volume.
+  #pitch is 1.0 for original pitch. Lower or higher values will bend the pitch accordingly.
+  def play_sound(reference, volume = 1.0, pitch = 1.0)
+    game_state.manager(:resource).get_sound(reference).play(pitch, volume)
+  end
+  
+  #Stop playback of all sounds.
+  def stop_all
+    @song.stop if @song
+    game_state.manager(:resource).get_all_sounds.each {|s| s.stop if s.playing}
+  end
+  
+  #Takes a reference to a song loaded via the resource manager, and plays it.
+  #volume is 0.0 for silence, 1.0 for normal volume, or higher values for amplified volume.
+  def play_song(reference, volume=1.0)
+    @song.stop if @song
+    @song = game_state.manager(:resource).get_song(reference)
+    @song.play
+    @song.volume = volume if volume != 1.0 #Volume must be set AFTER play is called.
+  end
+  
+  #Takes a reference to a song loaded via the resource manager, and plays it in a loop.
+  #volume is 0.0 for silence, 1.0 for normal volume, or higher values for amplified volume.
+  def loop_song(reference, volume=1.0)
+    @song.stop if @song
+    @song = game_state.manager(:resource).get_song(reference)
+    @song.loop
+    @song.volume = volume if volume != 1.0 #Volume must be set AFTER loop is called.
+  end
+    
+end

data/src/managers/tag_manager.rb

@@ -0,0 +1,47 @@
+#Tracks tags applied to objects.
+class TagManager < Jemini::GameObject
+  def load
+    require 'behaviors/taggable'
+    @tagged_objects = Hash.new { |h,k| h[k] = [] }
+    listen_for(:after_add_game_object, game_state.manager(:game_object)) do |game_object|
+      if game_object.has_behavior? :Taggable
+        game_object.tags.each do |tag|
+          @tagged_objects[tag] << game_object
+        end
+        listen_for(:tag_added, game_object) do |tag|
+          @tagged_objects[tag] << game_object
+        end
+        listen_for(:tag_removed, game_object) do |tag|
+          @tagged_objects[tag].delete game_object
+        end
+      end
+    end
+    
+    listen_for(:after_remove_game_object, game_state.manager(:game_object)) do |game_object|
+      if game_object.has_behavior? :Taggable
+        game_object.tags.each do |tag|
+          @tagged_objects[tag].delete game_object
+        end
+      end
+    end
+  end
+  
+  #Returns all game objects that have all the given tags.
+  def find_by_all_tags(*tags)
+    tags[1..-1].inject(@tagged_objects[tags[0]]) do |results, tag|
+      results & @tagged_objects[tag]
+    end
+  end
+  
+  #Returns all game objects that have any of the given tags.
+  def find_by_any_tags(*tags)
+    tags.inject([]) do |results, tag|
+      results.concat @tagged_objects[tag]
+    end.uniq
+  end
+  
+  #Returns all game objects that have the given tag.
+  def find_by_tag(tag)
+    @tagged_objects[tag]
+  end
+end

data/src/managers/tangible_manager.rb

@@ -0,0 +1,36 @@
+require 'behaviors/tangible'
+require 'events/tangible_collision_event'
+
+class TangibleManager < Jemini::GameObject
+  has_behavior :HandlesEvents
+  has_behavior :Updates
+  
+  def load
+    handle_event :toggle_debug_mode, :toggle_debug_mode
+    on_update :check_for_collisions
+  end
+
+  def check_for_collisions(delta)
+    game_state.manager(:game_object).game_objects.each do |game_object|
+      next unless game_object.has_behavior? :Tangible
+      game_state.manager(:game_object).game_objects.each do |other_game_object|
+        next unless other_game_object.has_behavior? :Tangible
+        next if game_object == other_game_object
+        if game_object.tangibly_collides_with?(other_game_object)
+          game_object.notify :tangible_collision, TangibleCollisionEvent.new(other_game_object, delta)
+          other_game_object.notify :tangible_collision, TangibleCollisionEvent.new(game_object, delta)
+        end
+      end
+    end
+  end
+
+  def toggle_debug_mode(unused_message=nil)
+    @debug_mode = !@debug_mode
+    @game_state.manager(:game_object).game_objects.each do |game_object|
+      game_object.set_tangible_debug_mode(@debug_mode) if game_object.has_behavior? :Tangible
+    end
+  end
+
+private
+
+end

data/src/math.rb

@@ -0,0 +1,23 @@
+module Jemini
+  class Math
+    SQUARE_ROOT_OF_TWO = ::Math::sqrt(2.0)
+
+    def self.degrees_to_radians(degrees)
+      degrees * (::Math::PI/180.0)
+    end
+
+    def self.radians_to_degrees(radians)
+      radians * (180.0/::Math::PI)
+    end
+  end
+
+  module FloatHelpers
+    def near?(numeric, percent)
+      self <= (numeric + numeric * percent) && self >= (numeric - numeric * percent)
+    end
+  end
+end
+
+class Float
+  include Jemini::FloatHelpers
+end

data/src/org/rubyforge/rawr/Main.java

@@ -0,0 +1,67 @@
+package org.rubyforge.rawr;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.io.InputStream;
+import java.io.IOException;
+import java.net.URL;
+
+
+import java.util.ArrayList;
+import org.jruby.Ruby;
+import org.jruby.RubyInstanceConfig;
+import org.jruby.javasupport.JavaEmbedUtils;
+
+public class Main
+{
+  public static void main(String[] args) throws Exception
+  {   
+    RubyInstanceConfig config = new RubyInstanceConfig();
+    config.setArgv(args);
+    Ruby runtime = JavaEmbedUtils.initialize(new ArrayList(0), config);
+    String mainRubyFile = "main";
+   
+    ArrayList<String> config_data = new ArrayList<String>();
+    try{
+      java.io.InputStream ins = Main.class.getClassLoader().getResourceAsStream("run_configuration");
+      if (ins == null ) {
+        System.err.println("Did not find configuration file 'run_configuration', using defaults.");
+      } else {
+        config_data = getConfigFileContents(ins);
+      }
+    }
+    catch(IOException ioe)
+    {
+      System.err.println("Error loading run configuration file 'run_configuration', using defaults: " + ioe);
+    }
+    catch(java.lang.NullPointerException npe)
+    {
+      System.err.println("Error loading run configuration file 'run_configuration', using defaults: " + npe );
+    }
+
+    for(String line : config_data) {
+        String[] parts = line.split(":");
+        if("main_ruby_file".equals(parts[0].replaceAll(" ", ""))) {
+            mainRubyFile = parts[1].replaceAll(" ", "");
+        }
+    }
+
+    runtime.evalScriptlet("require '" + mainRubyFile + "'");
+  }
+
+  public static URL getResource(String path) {
+      return Main.class.getClassLoader().getResource(path);
+  }
+
+  private static ArrayList<String> getConfigFileContents(InputStream input) throws IOException, java.lang.NullPointerException {
+    BufferedReader reader = new BufferedReader(new InputStreamReader(input));
+    String line;
+    ArrayList<String> contents = new ArrayList<String>();
+
+    while ((line = reader.readLine()) != null) {
+      contents.add(line);
+    }
+    reader.close();
+    return(contents);
+  }
+}

data/src/platform.rb

@@ -0,0 +1,28 @@
+require 'rbconfig'
+
+module Platform
+
+  @@operating_system = Config::CONFIG['host_os']
+
+  def using_unix?
+    @using_unix ||= !using_windows?
+  end
+
+  def using_windows?
+    @using_windows ||= (@@operating_system =~ /^win|mswin/i)
+  end
+
+  def using_linux?
+    @using_linux ||= (@@operating_system =~ /linux/)
+  end
+
+  def using_osx?
+    @using_osx ||= (@@operating_system =~ /darwin/)
+  end
+
+  def argument_delimiter
+    using_windows? ? ';' : ':'
+  end
+
+  module_function :using_unix?, :using_windows?, :using_osx?, :argument_delimiter, :using_linux?
+end

data/src/proc_enhancement.rb

@@ -0,0 +1,5 @@
+class Proc
+  def source
+     eval "self", binding   
+  end
+end

data/src/project_generator.rb

@@ -0,0 +1,138 @@
+require 'fileutils'
+#require 'rawr'
+
+module Jemini
+  class ProjectGenerator
+    include FileUtils
+
+    def initialize(options)
+      @project_dir       = options[:project_dir]
+      @project_title     = options[:project_title]
+      @rawr_install_args = options[:rawr_install]
+    end
+
+    def generate_project
+      generate_default_dirs
+      generate_main
+#      generate_main_with_natives
+      copy_libs
+      rawr_install
+      generate_hello_world_state
+      copy_jemini_jar
+    end
+
+    def generate_main
+      mkdir_p File.expand_path(File.join(@project_dir, 'src'))
+      path = File.expand_path(File.join(@project_dir, 'src', 'main.rb'))
+
+      File.open(path, "w") do |f|
+        f << <<-ENDL
+require 'java'
+
+$LOAD_PATH.clear
+$LOAD_PATH << File.expand_path(File.dirname(__FILE__))
+$LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), 'game_objects'))
+$LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), 'managers'))
+$LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), 'states'))
+
+# only when running in non-standalone
+if File.exist? File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'java'))
+  jar_glob = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'java', '*.jar'))
+  Dir.glob(jar_glob).each do |jar|
+    $CLASSPATH << jar
+  end
+end
+%w{behaviors game_objects input_helpers input_mappings states}.each do |dir|
+  $LOAD_PATH << "src/\#{dir}"
+end
+
+require 'jemini'
+
+begin
+  # Change :HelloState to point to the initial state of your game
+  game = Jemini::Game.new :title => 'Jemini Game',
+                          :screen_size => Vector.new(800, 600),
+                          :initial_state => :HelloWorldState,
+                          :fullscreen => false
+  game.app
+rescue => e
+  warn e
+  warn e.backtrace
+end
+        ENDL
+      end
+    end
+
+    def generate_main_with_natives
+      mkdir_p File.expand_path(File.join(@project_dir, 'src'))
+      path = File.expand_path(File.join(@project_dir, 'src', 'main_with_natives.rb'))
+      File.open(path, "w") do |f|
+        f << <<-ENDL
+system("jruby -J-Djava.library.path=lib/native_files \#{File.expand_path(File.join(File.dirname(__FILE__)), 'main.rb')}")
+ENDL
+      end
+    end
+
+    def copy_jemini_jar
+      destination = File.expand_path(File.join(@project_dir, 'lib', 'java'))
+      source      = File.expand_path(File.join(File.dirname(__FILE__), '..', 'package', 'jar', 'jemini.jar'))
+
+      mkdir_p destination
+      cp source, destination
+    end
+
+    #TODO: Implement
+    def build_jemini_jar
+      
+    end
+
+    def generate_default_dirs
+      mkdir_p File.expand_path(File.join(@project_dir, 'data'))
+      mkdir_p File.expand_path(File.join(@project_dir, 'src', 'behaviors'))
+      mkdir_p File.expand_path(File.join(@project_dir, 'src', 'game_objects'))
+      mkdir_p File.expand_path(File.join(@project_dir, 'src', 'inputs'))
+      mkdir_p File.expand_path(File.join(@project_dir, 'src', 'states'))
+    end
+
+    def generate_hello_world_state
+      mkdir_p File.expand_path(File.join(@project_dir, 'src', 'states'))
+      path = File.expand_path(File.join(@project_dir, 'src', 'states', 'hello_world_state.rb'))
+      File.open(path, "w") do |f|
+        f << <<-ENDL
+class HelloWorldState < Jemini::GameState
+  def load
+    create(:Text,
+      "Now, place your own state code in the src/states folder!",
+      :position => Vector.new(screen_width / 2, screen_height / 2)
+    )
+  end
+end
+ENDL
+      end
+    end
+
+    def rawr_install
+      mkdir_p @project_dir
+      # TODO: Replace with equivalent of Rake's FileUtils.sh method
+      puts `rawr install #{@rawr_install_args} #{@project_dir}`
+      build_config_path = File.join(@project_dir, 'build_configuration.rb')
+      build_config = File.read build_config_path
+      build_config.sub!('#c.java_library_path = "lib/java/native"', 'c.java_library_path = "lib/java/native_files"')
+      build_config.sub!('#c.jvm_arguments = "-server"', 'c.jvm_arguments = "-XX:+UseConcMarkSweepGC -Djruby.compile.mode=FORCE -Xms256m -Xmx512m"')
+      build_config.sub!(%Q{#c.jars[:data] = { :directory => 'data/images', :location_in_jar => 'images', :exclude => /bak/}}, %Q{c.jars[:data] = { :directory => 'data', :location_in_jar => 'data', :exclude => /bak/}})
+      build_config.sub!(%Q{#c.files_to_copy = Dir['other_files/dir/**/*']}, %Q{c.files_to_copy = Dir['lib/java/native_files/**/*']})
+      File.open(build_config_path, 'w') {|f| f << build_config}
+    end
+
+    def copy_libs
+      mkdir_p File.expand_path(File.join(@project_dir, 'lib', 'java'))
+      copy_libs = %w{ibxm.jar jinput.jar jogg-0.0.7.jar jorbis-0.0.15.jar lwjgl.jar lwjgl_util_applet.jar natives-linux.jar natives-mac.jar natives-win32.jar phys2d.jar slick.jar}
+      copy_libs.each do |copy_lib|
+        from = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', copy_lib))
+        cp from, File.join(@project_dir, 'lib', 'java')
+      end
+#      mkdir_p File.expand_path(File.join(@project_dir, 'lib', 'java', 'native_libs'))
+      cp_r File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'native_files')) + '/', File.join(@project_dir, 'lib', 'java', 'native_files')
+    end
+  end
+end