shattered_ruby 0.5.0.2

data/bin/console

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require "#{File.dirname(__FILE__)}/../config/boot"
+require "commands/console"

data/bin/destroy

@@ -0,0 +1,9 @@
+#!/opt/local/bin/ruby
+
+require File.dirname(__FILE__) + '/../config/boot'
+require File.dirname(__FILE__) + '/../config/environment'
+require 'rails_generator'
+require 'rails_generator/scripts/destroy'
+	
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+Rails::Generator::Scripts::Destroy.new.run(ARGV)

data/bin/generate

@@ -0,0 +1,7 @@
+#!/usr/bin/ruby18
+require File.dirname(__FILE__)+"/../config/boot"
+require 'rails_generator'
+require 'rails_generator/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+Rails::Generator::Scripts::Generate.new.run(ARGV)

data/bin/runner

@@ -0,0 +1,9 @@
+#!/usr/local/bin/ruby
+
+if PLATFORM =~ /powerpc-darwin/
+	path = File.dirname(__FILE__) + "/../config/Mac/"
+	puts `(cd #{path}shattered.app; ./Contents/MacOS/shattered_mac)`
+else
+	require File.dirname(__FILE__)+'/runner'
+	start_game
+end

data/bin/shatter

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby 
+#This file is adapted from the rails command.
+
+min_release  = "1.8.2 (2004-12-25)"
+ruby_release = "#{RUBY_VERSION} (#{RUBY_RELEASE_DATE})"
+
+if ruby_release < min_release
+  abort <<-end_message
+
+    Shattered requires Ruby version #{min_release} or later.
+    You're running #{ruby_release}; please upgrade to continue.
+
+  end_message
+end
+
+Signal.trap("INT") { puts; exit }
+
+
+require File.dirname(__FILE__) + '/../lib/rails_generator'
+require 'rails_generator/scripts/generate'
+Rails::Generator::Base.use_application_sources!
+Rails::Generator::Scripts::Generate.new.run(ARGV, :generator => 'shattered_app')

data/lib/commands/console.rb

@@ -0,0 +1,23 @@
+irb = RUBY_PLATFORM =~ /mswin32/ ? 'irb.bat' : 'irb'
+
+require 'optparse'
+options = { :sandbox => false, :irb => irb }
+OptionParser.new do |opt|
+	opt.banner = "Usage: console [environment] [options]"
+  opt.on('-s', '--sandbox', 'Rollback database modifications on exit.') { |options[:sandbox]| }
+  opt.on("--irb=[#{irb}]", 'Invoke a different irb.') { |options[:irb]| }
+  opt.parse!(ARGV)
+end
+
+libs =  " -r irb/completion"
+libs << " -r #{SHATTERED_ROOT}/config/environment"
+libs << " -r console_sandbox" if options[:sandbox]
+
+ENV['SHATTERED_ENV'] = ARGV.first || ENV['SHATTERED_ENV'] || 'development'
+if options[:sandbox]
+  puts "Loading #{ENV['SHATTER_ENV']} environment in sandbox."
+  puts "Any modifications you make will be rolled back on exit."
+else
+  puts "Loading #{ENV['SHATTER_ENV']} environment."
+end
+exec "#{options[:irb]} #{libs} --simple-prompt"

data/lib/game_loader.rb

@@ -0,0 +1,118 @@
+require 'singleton'
+
+include ShatteredState
+include ShatteredView
+include ShatteredModel
+
+module Shatter #:nodoc:all
+#This class is loads the view, controller, and model.  It then loads
+#and starts the game based on these.
+class GameLoader
+	include Singleton
+	attr_writer :environment
+	attr_reader :media_paths, :render_window, :input_manager, :key_manager, :key_converter
+	attr_accessor :current_state
+	
+	# This will recourse into the app/** directories and load all ruby files 
+	# inside those directories.
+  def load_all_sources(shattered_root)
+    File.find_by_extension(shattered_root+"/app", "rb").each do |file|
+      require(file)
+    end
+  end
+  
+  # start the game
+	def run
+		load_all_sources(SHATTERED_ROOT)
+		load_environment
+		
+		# Create our initial state, as defined by the environment.
+		create_state(@environment[:start_state])
+
+		start_game
+	end
+	
+	# Create a state from the given name
+	# :sample creates a new SampleState object
+	def create_state(state_name)
+		state_class = eval("#{state_name.to_s.camelize}State")
+		raise Error, "#{state_class} is not a class" unless state_class.is_a? Class
+		state = state_class.new
+		unless state.is_a? ShatteredState::Base
+			raise Error, "#{state_class} is an invalid State object (not of ShatteredState::Base)" 
+		end
+		return state
+	end
+	
+	def load_environment
+	  #Setup Ogre and the scene for the state
+    raise Error, "Ogre failed to initialize" if !setup_ogre
+		setup_input
+
+		load_resources(@environment[:media])
+	end
+
+	# Given ['app/media', 'media'], searches those directories, recursively, for OGRE media
+  def load_resources(paths)
+  	@media_paths = paths
+  	# setup our resource paths specified in environment.rb
+    Resources.instance.add_resource_paths(*paths)
+    Resources.instance.setup
+	end    
+	
+	#Load the root, setup the render window
+  #TODO: allow for the user to specify whether the window dialogue pops up
+  #further TODO: allow the user to skin the render window dialogue
+  def setup_ogre
+  	# TODO: create platform loader for other platforms
+  	plugins = SHATTERED_ROOT + "/config/ogre_plugins.windows.cfg"
+  	config_save=SHATTERED_ROOT + "/config/ogrerb_defaults.save"
+  	log=SHATTERED_ROOT + "/log/ogrerb.log"
+  	@root = ShatteredOgre.create_root(plugins, config_save, log)
+  	return false if !@root.show_config_dialog
+  	# TODO: allow application name to be set.
+  	@render_window = @root.initialise(true)
+  	
+  	return true
+  end  
+  
+  #Every time this exits, a game dies.
+  def start_game
+    each_frame do |time_elapsed|
+      current_state.update_timers(time_elapsed)
+      @keyboard.capture
+      #@@environment[:input].flush
+    end
+  end
+
+	# Main game loop
+  def each_frame
+  	timer = Ogre::Timer.new
+    while !@environment[:quit] && Ogre::Root::instance.render_one_frame
+    	seconds = timer.get_microseconds / 1000000.0
+	    yield seconds
+      timer.reset
+		end
+	end
+	
+	# Leave the game
+	def quit!
+		@environment[:quit]=true
+	end
+	
+	# load the input manager, the key manager, etc
+	# TODO: Consider how to make input non-exclusive, as well as mouse, etc.
+	# TODO: Investigate any use cases for non-buffered input
+	def setup_input
+		windowHnd = render_window.get_custom_attribute_unsigned_long("WINDOW")
+		@input_manager = OIS::InputManager.create_input_system(
+	{  "WINDOW" => "#{windowHnd}",
+		 "w32_mouse" => ["DISCL_FOREGROUND", "DISCL_NONEXCLUSIVE"],
+		 "w32_keyboard" => ["DISCL_FOREGROUND", "DISCL_NONEXCLUSIVE"]
+	})
+		@keyboard = @input_manager.create_input_object(OIS::OISKeyboard, true)
+		@key_manager = OIS::KeyManager.new(@keyboard)
+		@key_converter = ShatteredPack::KeyConverter.new(@key_manager)
+	end
+end
+end

data/lib/rails_generator/base.rb

@@ -0,0 +1,203 @@
+require File.dirname(__FILE__) + '/options'
+require File.dirname(__FILE__) + '/manifest'
+require File.dirname(__FILE__) + '/spec'
+
+# Rails::Generator is a code generation platform tailored for the Rails
+# web application framework.  Generators are easily invoked within Rails
+# applications to add and remove components such as models and controllers.
+# New generators are easy to create and may be distributed as RubyGems or
+# tarballs for inclusion system-wide, per-user, or per-application.
+#
+# Generators may subclass other generators to provide variations that
+# require little or no new logic but replace the template files.
+# The postback generator is an example:  it subclasses the scaffold
+# generator and just replaces the code templates with its own.
+#
+# Now go forth and multiply^Wgenerate.
+module Rails
+  module Generator
+    class GeneratorError < StandardError; end
+    class UsageError < GeneratorError; end
+
+
+    # The base code generator is bare-bones.  It sets up the source and
+    # destination paths and tells the logger whether to keep its trap shut.
+    # You're probably looking for NamedBase, a subclass meant for generating
+    # "named" components such as models, controllers, and mailers.
+    #
+    # Generators create a manifest of the actions they perform then hand
+    # the manifest to a command which replay the actions to do the heavy
+    # lifting.  Create, destroy, and list commands are included.  Since a
+    # single manifest may be used by any command, creating new generators is
+    # as simple as writing some code templates and declaring what you'd like
+    # to do with them.
+    #
+    # The manifest method must be implemented by subclasses, returning a
+    # Rails::Generator::Manifest.  The record method is provided as a
+    # convenience for manifest creation.  Example:
+    #   class EliteGenerator < Rails::Generator::Base
+    #     def manifest
+    #       record do |m|
+    #         m.do(some)
+    #         m.things(in) { here }
+    #       end
+    #     end
+    #   end
+    class Base
+      include Options
+
+      # Declare default options for the generator.  These options
+      # are inherited to subclasses.
+      default_options :collision => :ask, :quiet => false
+
+      # A logger instance available everywhere in the generator.
+      cattr_accessor :logger
+
+      # Every generator that is dynamically looked up is tagged with a
+      # Spec describing where it was found.
+      class_inheritable_accessor :spec
+
+      attr_reader :source_root, :destination_root, :args
+
+      def initialize(runtime_args, runtime_options = {})
+        @args = runtime_args
+        parse!(@args, runtime_options)
+
+        # Derive source and destination paths.
+        @source_root = options[:source] || File.join(spec.path, 'templates')
+        if options[:destination]
+          @destination_root = options[:destination]
+        elsif defined? ::SHATTERED_ROOT
+          @destination_root = ::SHATTERED_ROOT
+        end
+
+        # Silence the logger if requested.
+        logger.quiet = options[:quiet]
+
+        # Raise usage error if help is requested.
+        usage if options[:help]
+      end
+
+      # Generators must provide a manifest.  Use the record method to create
+      # a new manifest and record your generator's actions.
+      def manifest
+        raise NotImplementedError, "No manifest for '#{spec.name}' generator."
+      end
+
+      # Return the full path from the source root for the given path.
+      # Example for source_root = '/source':
+      #   source_path('some/path.rb') == '/source/some/path.rb'
+      #
+      # The given path may include a colon ':' character to indicate that
+      # the file belongs to another generator.  This notation allows any
+      # generator to borrow files from another.  Example:
+      #   source_path('model:fixture.yml') = '/model/source/path/fixture.yml'
+      def source_path(relative_source)
+        # Check whether we're referring to another generator's file.
+        name, path = relative_source.split(':', 2)
+
+        # If not, return the full path to our source file.
+        if path.nil?
+          File.join(source_root, name)
+
+        # Otherwise, ask our referral for the file.
+        else
+          # FIXME: this is broken, though almost always true.  Others'
+          # source_root are not necessarily the templates dir.
+          File.join(self.class.lookup(name).path, 'templates', path)
+        end
+      end
+
+      # Return the full path from the destination root for the given path.
+      # Example for destination_root = '/dest':
+      #   destination_path('some/path.rb') == '/dest/some/path.rb'
+      def destination_path(relative_destination)
+        File.join(destination_root, relative_destination)
+      end
+
+      protected
+        # Convenience method for generator subclasses to record a manifest.
+        def record
+          Rails::Generator::Manifest.new(self) { |m| yield m }
+        end
+
+        # Override with your own usage banner.
+        def banner
+          "Usage: #{$0} #{spec.name} [options]"
+        end
+
+        # Read USAGE from file in generator base path.
+        def usage_message
+          File.read(File.join(spec.path, 'USAGE')) rescue ''
+        end
+    end
+
+
+    # The base generator for named components: models, controllers, mailers,
+    # etc.  The target name is taken as the first argument and inflected to
+    # singular, plural, class, file, and table forms for your convenience.
+    # The remaining arguments are aliased to actions for controller and
+    # mailer convenience.
+    #
+    # If no name is provided, the generator raises a usage error with content
+    # optionally read from the USAGE file in the generator's base path.
+    #
+    # See Rails::Generator::Base for a discussion of Manifests and Commands.
+    class NamedBase < Base
+      attr_reader   :name, :class_name, :singular_name, :plural_name, :table_name
+      attr_reader   :class_path, :file_path, :class_nesting, :class_nesting_depth
+      alias_method  :file_name,  :singular_name
+      alias_method  :actions, :args
+
+      def initialize(runtime_args, runtime_options = {})
+        super
+
+        # Name argument is required.
+        usage if runtime_args.empty?
+
+        @args = runtime_args.dup
+        base_name = @args.shift
+        assign_names!(base_name)
+      end
+
+      protected
+        # Override with your own usage banner.
+        def banner
+          "Usage: #{$0} #{spec.name} #{spec.name.camelize}Name [options]"
+        end
+
+      private
+        def assign_names!(name)
+          @name = name
+          base_name, @class_path, @file_path, @class_nesting, @class_nesting_depth = extract_modules(@name)
+          @class_name_without_nesting, @singular_name, @plural_name = inflect_names(base_name)
+          @table_name = singular_name
+          if @class_nesting.empty?
+            @class_name = @class_name_without_nesting
+          else
+            @class_name = "#{@class_nesting}::#{@class_name_without_nesting}"
+          end
+        end
+
+        # Extract modules from filesystem-style or ruby-style path:
+        #   good/fun/stuff
+        #   Good::Fun::Stuff
+        # produce the same results.
+        def extract_modules(name)
+          modules = name.include?('/') ? name.split('/') : name.split('::')
+          name    = modules.pop
+          path    = modules.map { |m| m.underscore }
+          file_path = (path + [name.underscore]).join('/')
+          nesting = modules.map { |m| m.camelize }.join('::')
+          [name, path, file_path, nesting, modules.size]
+        end
+
+        def inflect_names(name)
+          camel  = name.camelize
+          under  = camel.underscore
+          plural = under.pluralize
+          [camel, under, plural]
+        end
+    end
+  end
+end