shattered 0.5.0.1 → 0.7.0

data/lib/{tasks → shattered_game/rake_tasks}/framework.rake

@@ -1,43 +1,38 @@
 namespace :shattered do
   namespace :freeze do
-    desc "Lock this application to the current gems (by unpacking them into vendor/rails)"
+    desc "Lock this application to the current gems (by unpacking them into vendor/Shattered)"
     task :gems do
-      deps = %w(shatter shattered_pack shattered_ogre)
       require 'rubygems'
       Gem.manage_gems
-
-      shattered = (version = ENV['VERSION']) ?
-        Gem.cache.search('shattered', "= #{version}").first :
-        Gem.cache.search('shattered').sort_by { |g| g.version }.last
-
-      version ||= shattered.version
-
-      unless shattered
-        puts "No rails gem #{version} is installed.  Do 'gem list rails' to see what you have available."
+      
+      version = ENV['VERSION'] || Gem.cache.search('shattered').sort_by { |g| g.version }[-1].version
+      
+      gems = Gem.cache.search('shattered', "= #{version}")
+      
+      if gems.length == 0
+        puts "No shattered gem #{version} is installed.  Do 'gem list shattered' to see what you have available."
         exit
       end
-
-      puts "Freezing to the gems for Rails #{rails.version}"
+      
+      puts "Freezing to the gems for shattered #{gems[0].version}"
       rm_rf   "vendor/shattered"
       mkdir_p "vendor/shattered"
 
       chdir("vendor/shattered") do
-        shattered.dependencies.select { |g| deps.include? g.name }.each do |g|
-          Gem::GemRunner.new.run(["unpack", "-v", "#{g.version_requirements}", "#{g.name}"])
+        gems.reverse.each do |g|
+          puts g.name
+          Gem::GemRunner.new.run(["unpack", "-v", "#{g.version}", "#{g.name}"])
           mv(Dir.glob("#{g.name}*").first, g.name)
         end
-
-        Gem::GemRunner.new.run(["unpack", "-v", "=#{version}", "rails"])
-        FileUtils.mv(Dir.glob("rails*").first, "railties")
+        mv(Dir.glob("shattered_ruby").first, "shatter")
       end
-    end
-
+    end 
     desc "Lock to latest Shattered Edge or a specific revision with REVISION=X (ex: REVISION=4021) or a tag with TAG=Y (ex: TAG=rel_1-1-0)"
     task :edge do
       $verbose = false
       `svn --version` rescue nil
       unless !$?.nil? && $?.success?
-        $stderr.puts "ERROR: Must have subversion (svn) available in the PATH to lock this application to Edge Rails"
+        $stderr.puts "ERROR: Must have subversion (svn) available in the PATH to lock this application to Edge Shattered"
         exit 1
       end
             
@@ -60,8 +55,8 @@ namespace :shattered do
         touch "vendor/shattered/REVISION_#{ENV['REVISION']}"
       end
       
-      for framework in %w( railties actionpack activerecord actionmailer activesupport actionwebservice )
-        system "svn export #{shattered_svn}/#{framework} vendor/shattered/#{framework}" + (ENV['REVISION'] ? " -r #{ENV['REVISION']}" : "")
+      for framework in %w( shatter shattered_pack shattered_support shattered_ogrerb )
+        system "svn export #{shattered_svn}/trunk/#{framework} vendor/shattered/#{framework}" + (ENV['REVISION'] ? " -r #{ENV['REVISION']}" : "")
       end
     end
   end
@@ -75,7 +70,7 @@ namespace :shattered do
   task :update => [ "update:scripts", "update:javascripts", "update:configs" ]
 
   namespace :update do
-    desc "Update boot/config.rb from your current rails install"
+    desc "Update boot/config.rb from your current Shattered install"
     task :configs do
       require 'railties_path'  
       FileUtils.cp(RAILTIES_PATH + '/environments/boot.rb', SHATTERED_ROOT + '/config/boot.rb')

data/lib/{tasks → shattered_game/rake_tasks}/misc.rake

@@ -1,4 +1,3 @@
-task :default => :test
 task :environment do
   require(File.join(SHATTERED_ROOT, 'config', 'environment'))
-end
+end

data/lib/shattered_game/rake_tasks/spec.rake

@@ -0,0 +1,9 @@
+require 'rubygems'
+require 'spec'
+
+require 'spec/rake/spectask'
+
+Spec::Rake::SpecTask.new do |t|
+  t.warning = true
+  t.rcov = true
+end

data/lib/shattered_game/required.rb

@@ -0,0 +1,2 @@
+require File.dirname(__FILE__)+ '/actor'
+require File.dirname(__FILE__)+ '/game'

data/lib/shattered_game/version.rb

@@ -0,0 +1,9 @@
+module ShatteredRuby #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 7
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/shattered_model/controls.rb

@@ -0,0 +1,67 @@
+module Shattered
+  module Input
+    class ControlsParseError < StandardError; end
+    class FileNotFoundError < StandardError; end
+
+    #Handles parsing and mapping of controls
+    class Controls
+      attr_accessor :actions, :file
+      
+      #Constructor
+      def initialize(file)
+        @file = file
+      end
+      
+      #setter for path, which is static
+      def path=(newpath)
+        @@path = newpath
+      end
+      
+      #getter for path, which is static
+      def path
+        @@path ||= File.join(SHATTERED_ROOT,"config")
+      end
+      
+      #parses the file and sets the action map
+      def parse
+        fullpath = File.join(path, @file)
+        fullpath+= ".controls" unless (File.exists? fullpath) || file.ends_with(".controls")        
+        file = File.open(fullpath, "r")
+        
+        @actions = {}
+        file.readlines.each_with_index do |line, line_number|
+          line = (line.split("#"))[0] #comments
+          next if line.strip.length == 0 #blank lines
+          
+          action_details = line.split("=>").collect {|x| x.strip}
+          if(action_details.length == 2)
+            action, condition = action_details
+          elsif(action_details.length > 2)
+            raise ControlsParseError.new("Error loading '#{line}' in #{fullpath}:#{line_number+1}.  Too many =>'s.")
+          elsif(action_details.length < 2)
+            raise ControlsParseError.new("Problem parsing '#{line}' in #{fullpath}:#{line_number+1}.  Badly formed keymap.") 
+          end
+          @actions[condition] = action
+        end
+        file.close
+      end   
+      
+      # returns true if the controls are on, false otherwise
+      def active?
+        @active ||= false
+      end
+      
+      # turns the controls on
+      def on
+        parse if @actions.nil?
+        @active = true
+      end
+      
+      # turns the controls off
+      def off
+        @active = false
+      end
+    end
+  end
+end
+   

data/lib/shattered_model/input.rb

@@ -0,0 +1,171 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'key_converter'
+require 'controls'
+
+
+class Symbol
+  def to_mouse_id
+    if self == :left
+      return 0
+    elsif self == :right
+      return 1
+    elsif self == :middle
+      return 2
+    end
+    raise Exception.new("Could not convert symbol #{self} to mouse button")
+  end
+end
+
+module Shattered
+  module Input #:nodoc:
+	  def self.append_features(base)
+	    super
+	    base.extend(ClassMethods)
+	    base.send(:include, InstanceMethods)
+	    base.send(:include, PreInitialize)
+	  end
+	  module ClassMethods
+
+	  end
+	
+	  module InstanceMethods
+
+      # Example Usage:
+      # game.rb:
+      #
+      #   class Game < Shattered::Game
+      #     def initialize
+      #       ...
+      #       player = Player.new # Where player includes Shattered::Model
+      #       player.controls.on # this is the same as 'player.controls("player.controls").on'
+      #     end
+      #   end
+      #
+      # player.controls:
+      #   # command => condition
+      #   levitate => hold :a
+      #
+      #   # Note that both the command and the condition are instance_eval'ed
+      #
+      # You can turn off an actor's controls by calling:
+      #   player.controls.off
+      #
+      # Controls default as off.
+      #
+      # Note 1: Controls are only expected to be 'method => action' pairs, they are not meant
+      # logic at all, even though they can.
+      #
+      # Note 2: Controls are meant to be user edittable - a user interface for defining keys.
+      def controls(*args)
+        file = args[0]
+        if(file.nil? && @controls.nil?)
+          file = self.class.to_s.underscore
+        end
+        
+        @controls = Controls.new(file) if @controls.nil? 
+        @controls = Controls.new(file) if !file.nil? && (file != @controls.file)
+        
+        return @controls
+      end
+      
+	    # update_input takes the input object, and sends the actor every key event this frame.
+	    def update_input #:nodoc:
+	      if !@controls.nil? && @controls.active?
+	        @controls.actions.each do |condition, action|
+	          if(keyboard_listener.instance_eval(condition))
+	            instance_eval(action)
+            end
+          end
+        end
+	    end
+	    
+	    # Retrieve the game's keyboard singleton
+	    def keyboard_listener
+	      Game.instance.keyboard_listener
+	    end
+	    
+	    # Simulate a key press, release or hold event
+	    def key_event(params = {})
+	      lookup_reaction, keys = reaction_from(params)
+	      lookup_key = keys[0]
+	      key_actions.each do |reaction, key, action, params|
+	        key_action(reaction, action, 0, params) if key == lookup_key && lookup_reaction == reaction
+	      end
+	    end
+	  end
+	  
+	  # This is a wrapper around OIS's mouse object.
+	  # It will allow us to query the mouse for presses, releases, and holds.
+	  class Mouse #:nodoc:
+	    def initialize( ois_mouse )
+	      @ois_mouse = ois_mouse
+	    end
+	    
+	    def press( mouse_button )
+	      @ois_mouse.pressed? value_of(mouse_button)
+	    end
+	    
+	    def release( mouse_button )
+	      @ois_mouse.released? value_of(mouse_button)
+	    end
+	    
+	    def hold( mouse_button )
+	      @ois_mouse.held? value_of(mouse_button)
+	    end
+	    
+	    def move
+	      return true if((@ois_mouse.x != 0) || (@ois_mouse.y != 0))
+	      return false
+	    end
+	    
+	    def scroll
+	      return true if(@ois_mouse.scrolled != 0)
+	      return false
+	    end
+	    
+	    def value_of(mouse_button)
+	      return mouse_button if mouse_button.is_a? Fixnum
+	      return mouse_button.to_mouse_id
+	    end
+	  end
+	  
+	  # This is a wrapper around Ogre's input listener.
+  	# It allows us to query the status of each device every frame.
+  	class Keyboard #:nodoc:
+
+  		def initialize( keyboard, mouse )
+  			@ogre_input = keyboard
+  			@mouse = Mouse.new mouse
+  		end
+
+      def hold( key_symbol )
+        @ogre_input.key_held?(Converter.convert(key_symbol))
+      end
+
+      def press( key_symbol )
+        pressed = @ogre_input.key_pressed?(Converter.convert(key_symbol))
+        if(pressed)
+          Game.instance.log.debug("#{key_symbol} pressed!")
+          return true
+        else
+          return false
+        end
+      end
+
+      def release( key_symbol )
+        @ogre_input.key_released?(Converter.convert(key_symbol))
+      end
+
+  		def flush
+  			@ogre_input.flush
+  		end
+  		
+  		def mouse
+  		  @mouse
+  		end
+  	end
+    
+	end
+end

data/lib/shattered_model/key_converter.rb

@@ -0,0 +1,44 @@
+module Shattered	
+  module Input  	
+    # Converts from OIS constants to more readable symbols.
+    class Converter
+	
+  		def self.back_conversions
+  		  @@back_conversions ||= nil
+  			if @@back_conversions.nil?
+  			  @@back_conversions = conversions.invert
+			    @@back_conversions[",".to_sym] = OIS::KC_COMMA
+			    @@back_conversions[".".to_sym] = OIS::KC_PERIOD
+			  end
+			  return @@back_conversions
+  		end
+
+  		def self.conversions
+  			begin 
+  				return @@conversions
+  			rescue NameError
+  			end
+  			@@conversions = {}
+  			OIS.constants.each do |constant|
+  				kc_evaled = eval("OIS::#{constant}")
+  				@@conversions[kc_evaled] = symbolize(constant[3..-1].downcase) if constant.to_s =~ /^KC_/
+  			end
+  			return @@conversions
+  		end
+
+  		def self.convert( kc_character )
+  			return self.conversions[kc_character] if kc_character.is_a? Fixnum
+  			return self.back_conversions[kc_character.to_sym]
+  		end
+
+  	private
+
+  		def self.symbolize( name )
+  			exceptions = { 'pgdown' => :page_down,
+  							 'pgup'   => :page_up }
+  			return name.to_sym if exceptions[name] == nil
+  			return exceptions[name]
+  		end
+  	end
+	end
+end

data/lib/shattered_model/required.rb

@@ -0,0 +1,4 @@
+require File.dirname(__FILE__)+ '/input'
+require File.dirname(__FILE__)+ '/timer'
+require File.dirname(__FILE__)+ '/shattered_model'
+

data/lib/shattered_model/shattered_model.rb

@@ -0,0 +1,28 @@
+module Shattered
+    # Models encompass all of the game play logic and the game specific data.
+    #
+    # Models are useful for unit tests and for making game rules.
+    # They are where all logic (AI/collisions/etc) go.
+    #
+    # They can also specify keyboard input.
+  
+  module Model 
+    def self.append_features(base)
+      super
+      base.send(:include, Timer)
+      base.send(:include, Input)
+      base.send(:timer, :every => :frame, :action => :update_input)
+
+      base.send(:include, InstanceMethods)
+      base.send(:timer, :every => :frame, :action => :update_time_elapsed)
+    end
+    
+    module InstanceMethods
+      attr_reader :time_elapsed
+      def update_time_elapsed(te)
+        @time_elapsed = te
+      end
+    end
+  end      
+end
+

data/lib/shattered_model/timed_event.rb

@@ -0,0 +1,120 @@
+module Shattered
+  module Timer #:nodoc:all
+    
+    class Timer
+      attr_reader :events_remaining
+      def initialize(context)
+        @events_remaining = []
+        @context = context
+        @@timers ||= []
+        @@timers << self
+      end
+     
+      def in(seconds, options = {}, &block)
+        event = TimedEvent.new(@context, seconds, options, &block)
+        @events_remaining << event
+        return event
+      end
+      def every(seconds, options = {}, &block)
+        event = ContinuousTimedEvent.new(@context, seconds, options, &block)
+        @events_remaining << event
+        return event
+      end
+      def update(time_elapsed)
+        events_for_update = @events_remaining.dup
+        events_for_update.each do |event|
+          event.update(time_elapsed)
+          @events_remaining.delete(event) if event.processed?
+        end
+      end
+    
+      #Updates all timers
+      def self.update(time_elapsed)
+        @@timers.each do |timer|
+          timer.update time_elapsed
+        end
+      end
+      
+      # Call this to remove a timer
+      def destroy
+        @@timers.delete self
+      end
+    end
+
+    class TimedEvent
+      attr_accessor :time_remaining
+      def initialize(context, seconds, options={}, &block)
+        @context=context
+        @event = block
+        @options = options
+        if(seconds != :frame)
+          @time_remaining = seconds
+          @initial_time = @time_remaining
+        else
+          @time_remaining = 0
+          @initial_time = 0
+        end
+      end
+      def update(time_elapsed)
+        return if processed? || stopped?
+        @time_remaining -= time_elapsed
+        if time_up?
+          process_event
+          @processed=true
+        end
+      end
+      def processed?
+        return @processed == true
+      end
+      def reset
+        @time_remaining = @initial_time
+      end
+      # Stop the timer
+      def stop
+        @stopped = true
+      end
+      def stopped?
+        !@stopped.nil?
+      end
+      private
+      def process_event
+        @event.call(@initial_time - @time_remaining) if satisfies_condition?
+      end
+      def time_up?
+        return @time_remaining <= 0
+      end
+      def satisfies_condition?
+        return true if(@options[:if].nil? && @options[:unless].nil?)
+        unless @options[:if].nil?
+          result=@options[:if]
+          result=@context.send(result) if(result.is_a? Symbol)
+          return result
+        end
+        unless @options[:unless].nil?
+          result=@options[:unless]
+          result=@context.send(result) if(result.is_a? Symbol)
+          return !result
+        end
+      end
+    end
+
+    class ContinuousTimedEvent < TimedEvent
+      def update(time_elapsed)
+        return if stopped?
+        @time_remaining -= time_elapsed
+        if(time_up?)
+          process_event
+          reset
+        end
+      end
+      def reset
+        @time_remaining += @initial_time
+        @time_remaining = 0 if @time_remaining < 0
+      end
+      def processed?
+        false
+      end
+    end
+
+  end
+end