gamebox 0.0.1

data/lib/gamebox/template_app/Rakefile

@@ -0,0 +1,20 @@
+libdir = File.dirname(__FILE__)+"/lib"
+$: << libdir
+confdir = File.dirname(__FILE__)+"/config"
+$: << confdir
+
+require 'environment'
+STATS_DIRECTORIES = [
+  %w(Source            src/), 
+  %w(Config            config/), 
+  %w(Maps              maps/), 
+  %w(Unit\ tests       specs/),
+  %w(Libraries         lib/),
+].collect { |name, dir| [ name, "#{APP_ROOT}/#{dir}" ] }.select { |name, dir| File.directory?(dir) }
+
+desc "Report code statistics (KLOCs, etc) from the application"
+task :stats do
+  require 'code_statistics'
+  CodeStatistics.new(*STATS_DIRECTORIES).to_s
+end
+

data/lib/gamebox/template_app/config/boot.rb

@@ -0,0 +1,5 @@
+# Don't change this file!
+# Configure your app in config/environment.rb 
+
+GAMEBOX_ROOT = "#{File.dirname(__FILE__)}/.." unless defined?(GAMEBOX_ROOT)
+

data/lib/gamebox/template_app/config/environment.rb

@@ -0,0 +1,29 @@
+require 'rubygems'
+ADDITIONAL_LOAD_PATHS = []
+ADDITIONAL_LOAD_PATHS.concat %w(
+  src 
+  lib
+  config 
+  ../../lib
+).map { |dir| File.dirname(__FILE__) + "/../" + dir }.select { |dir| File.directory?(dir) }
+
+ADDITIONAL_LOAD_PATHS.each do |path|
+	$:.push path
+end
+
+APP_ROOT = File.dirname(__FILE__) + "/../"
+CONFIG_PATH = APP_ROOT + "config/"
+DATA_PATH =  APP_ROOT + "data/"
+SOUND_PATH =  APP_ROOT + "data/sounds/"
+MUSIC_PATH =  APP_ROOT + "data/music/"
+GFX_PATH =  APP_ROOT + "data/graphics/"
+FONTS_PATH =  APP_ROOT + "data/fonts/"
+
+require 'gamebox'
+
+GAMEBOX_DATA_PATH =  GAMEBOX_PATH + "data/"
+GAMEBOX_SOUND_PATH =  GAMEBOX_PATH + "data/sounds/"
+GAMEBOX_MUSIC_PATH =  GAMEBOX_PATH + "data/music/"
+GAMEBOX_GFX_PATH =  GAMEBOX_PATH + "data/graphics/"
+GAMEBOX_FONTS_PATH =  GAMEBOX_PATH + "data/fonts/"
+

data/lib/gamebox/template_app/config/game.yml

@@ -0,0 +1,6 @@
+--- 
+:sound: true
+:fullscreen: false
+:screen_resolution: 
+- 1024
+- 800

data/lib/gamebox/template_app/config/mode_level_config.yml

@@ -0,0 +1,3 @@
+:modes: 
+  - :default: 
+    - :demo:

data/lib/gamebox/template_app/config/objects.yml

@@ -0,0 +1,29 @@
+game:
+  compose:
+    - wrapped_screen
+    - input_manager
+    - sound_manager
+    - mode_manager
+resource_manager:
+mode_manager:
+  compose:
+    - input_manager
+    - resource_manager
+    - sound_manager
+    - config_manager
+    - actor_factory
+sound_manager:
+  compose:
+    - resource_manager
+    - config_manager
+input_manager:
+wrapped_screen:
+  compose:
+    - config_manager
+actor_factory:
+  compose:
+    - input_manager
+    - sound_manager
+config_manager:
+  compose:
+    - resource_manager

data/lib/gamebox/template_app/doc/README_FOR_APP

@@ -0,0 +1 @@
+This is where you put documentation for your app.

data/lib/gamebox/template_app/lib/code_statistics.rb

@@ -0,0 +1,107 @@
+class CodeStatistics #:nodoc:
+
+  TEST_TYPES = %w(Units Functionals Unit\ tests Functional\ tests Integration\ tests)
+
+  def initialize(*pairs)
+    @pairs      = pairs
+    @statistics = calculate_statistics
+    @total      = calculate_total if pairs.length > 1
+  end
+
+  def to_s
+    print_header
+    @pairs.each { |pair| print_line(pair.first, @statistics[pair.first]) }
+    print_splitter
+  
+    if @total
+      print_line("Total", @total)
+      print_splitter
+    end
+
+    print_code_test_stats
+  end
+
+  private
+    def calculate_statistics
+      @pairs.inject({}) { |stats, pair| stats[pair.first] = calculate_directory_statistics(pair.last); stats }
+    end
+
+    def calculate_directory_statistics(directory, pattern = /.*\.rb$/)
+      stats = { "lines" => 0, "codelines" => 0, "classes" => 0, "methods" => 0 }
+
+      Dir.foreach(directory) do |file_name| 
+        if File.stat(directory + "/" + file_name).directory? and (/^\./ !~ file_name)
+          newstats = calculate_directory_statistics(directory + "/" + file_name, pattern)
+          stats.each { |k, v| stats[k] += newstats[k] }
+        end
+
+        next unless file_name =~ pattern
+
+        f = File.open(directory + "/" + file_name)
+
+        while line = f.gets
+          stats["lines"]     += 1
+          stats["classes"]   += 1 if line =~ /class [A-Z]/
+          stats["methods"]   += 1 if line =~ /def [a-z]/
+          stats["codelines"] += 1 unless line =~ /^\s*$/ || line =~ /^\s*#/
+        end
+      end
+
+      stats
+    end
+
+    def calculate_total
+      total = { "lines" => 0, "codelines" => 0, "classes" => 0, "methods" => 0 }
+      @statistics.each_value { |pair| pair.each { |k, v| total[k] += v } }
+      total
+    end
+
+    def calculate_code
+      code_loc = 0
+      @statistics.each { |k, v| code_loc += v['codelines'] unless TEST_TYPES.include? k }
+      code_loc
+    end
+
+    def calculate_tests
+      test_loc = 0
+      @statistics.each { |k, v| test_loc += v['codelines'] if TEST_TYPES.include? k }
+      test_loc
+    end
+
+    def print_header
+      print_splitter
+      puts "| Name                 | Lines |   LOC | Classes | Methods | M/C | LOC/M |"
+      print_splitter
+    end
+
+    def print_splitter
+      puts "+----------------------+-------+-------+---------+---------+-----+-------+"
+    end
+
+    def print_line(name, statistics)
+      m_over_c   = (statistics["methods"] / statistics["classes"])   rescue m_over_c = 0
+      loc_over_m = (statistics["codelines"] / statistics["methods"]) - 2 rescue loc_over_m = 0
+
+      start = if TEST_TYPES.include? name
+        "|   #{name.ljust(18)} "
+      else
+        "| #{name.ljust(20)} " 
+      end
+
+      puts start + 
+           "| #{statistics["lines"].to_s.rjust(5)} " +
+           "| #{statistics["codelines"].to_s.rjust(5)} " +
+           "| #{statistics["classes"].to_s.rjust(7)} " +
+           "| #{statistics["methods"].to_s.rjust(7)} " +
+           "| #{m_over_c.to_s.rjust(3)} " +
+           "| #{loc_over_m.to_s.rjust(5)} |"
+    end
+
+    def print_code_test_stats
+      code  = calculate_code
+      tests = calculate_tests
+
+      puts "  Code LOC: #{code}     Test LOC: #{tests}     Code to Test Ratio: 1:#{sprintf("%.1f", tests.to_f/code)}"
+      puts ""
+    end
+  end

data/lib/gamebox/template_app/lib/diy.rb

@@ -0,0 +1,371 @@
+require 'yaml'
+require 'set'
+
+#
+# DIY (Dependency Injection in Yaml) is a simple dependency injection library
+# which focuses on declarative composition of objects through setter injection.
+#
+# == Examples
+#
+# === A Simple Context
+#
+# The context is a hash specified in in a yaml file.  Each top-level key identifies
+# an object.  When the context is created and queried for an object, by default, 
+# the context will require a file with the same name:
+#   require 'foo'
+# next, by default, it will call new on a class from the camel-cased name of the key:
+#   Foo.new
+#
+# foo.rb:
+#   class Foo; end
+#
+# context.yml:
+#   ---
+#   foo:
+#   bar:
+#
+#   c = DIY::Context.from_file('context.yml')
+#   c[:foo]   #=> #<Foo:0x81eb0> 
+#
+# === Specifying Class Name
+#
+# If the class name isn't the camel-cased key:
+#
+# foo.rb:
+#   class MyFoo; end
+# 
+# context.yml:
+#   ---
+#   foo:
+#     class: MyFoo
+#   bar:
+#
+# === Specifying Ruby File to Require
+#
+# If the file the class resides in isn't named after they key:
+#
+# fun_stuff.rb:
+#   class Foo; end
+# 
+# context.yml:
+#   ---
+#   foo:
+#     lib: fun_stuff
+#   bar:
+#
+# === Constructor Arguments
+#
+# DIY allows specification of constructor arguments as hash key-value pairs
+# using the <tt>compose</tt> directive.  
+#
+# foo.rb:
+#   class Foo
+#     def initialize(args)
+#       @bar = args[:bar]
+#       @other = args[:other]
+#     end
+#   end
+# 
+# context.yml:
+#   ---
+#   foo:
+#     compose: bar, other
+#   bar:
+#   other:
+#
+# To make constructor definition easier use constructor:
+#
+# foo.rb:
+#   class Foo
+#     constructor :bar, :other
+#   end
+#
+# If the constructor argument names don't match up with the object keys
+# in the context, they can be mapped explicitly.
+#
+# foo.rb:
+#   class Foo
+#     constructor :bar, :other
+#   end
+#
+# context.yml:
+#   ---
+#   foo:
+#     bar: my_bar
+#     other: the_other_one
+#   my_bar:
+#   the_other_one:
+#
+# === Non-singleton objects
+# 
+# Non-singletons will be re-instantiated each time they are needed.
+#
+# context.yml:
+#   ---
+#   foo:
+#     singleton: false
+#
+#   bar:
+#
+#   engine:
+#     compose: foo, bar
+#
+module DIY
+	class Context
+		def initialize(context_hash, extra_inputs={})
+			raise "Nil context hash" unless context_hash
+			raise "Need a hash" unless context_hash.kind_of?(Hash)
+			[ "[]", "keys" ].each do |mname|
+				unless extra_inputs.respond_to?(mname) 
+					raise "Extra inputs must respond to hash-like [] operator and methods #keys and #each" 
+				end
+			end
+
+			# store extra inputs
+			if extra_inputs.kind_of?(Hash)
+				@extra_inputs = {}
+				extra_inputs.each { |k,v| @extra_inputs[k.to_s] = v } # smooth out the names
+			else
+				@extra_inputs = extra_inputs
+			end
+
+			# Collect object and subcontext definitions
+			@defs = {}
+			@sub_context_defs = {}
+			context_hash.each do |name,info|
+				name = name.to_s
+				case name
+				when /^\+/ 
+					# subcontext
+					@sub_context_defs[name.gsub(/^\+/,'')] = info
+					
+				else 
+          # Normal singleton object def
+          if extra_inputs_has(name)
+            raise ConstructionError.new(name, "Object definition conflicts with parent context")
+          end
+          @defs[name] = ObjectDef.new(:name => name, :info => info)
+				end
+			end
+
+
+			# init the cache
+			@cache = {}
+			@cache['this_context'] = self
+		end
+   
+
+		def self.from_yaml(io_or_string, extra_inputs={})
+			raise "nil input to YAML" unless io_or_string
+			Context.new(YAML.load(io_or_string), extra_inputs)
+		end
+
+		def self.from_file(fname, extra_inputs={})
+			raise "nil file name" unless fname
+			self.from_yaml(File.read(fname), extra_inputs)
+		end
+
+		def get_object(obj_name)
+			key = obj_name.to_s
+			obj = @cache[key]
+			unless obj
+				if extra_inputs_has(key)
+					obj = @extra_inputs[key]
+				end
+			end
+			unless obj
+				obj = construct_object(key)
+				@cache[key] = obj if @defs[key].singleton?
+			end
+			obj
+		end
+		alias :[] :get_object
+
+		def set_object(obj_name,obj)
+			key = obj_name.to_s
+			raise "object '#{key}' already exists in context" if @cache.keys.include?(key)
+			@cache[key] = obj
+		end
+		alias :[]= :set_object
+
+		def keys
+			(@defs.keys.to_set + @extra_inputs.keys.to_set).to_a
+		end
+
+		# Instantiate and yield the named subcontext
+		def within(sub_context_name)
+			# Find the subcontext definitaion:
+			context_def = @sub_context_defs[sub_context_name.to_s]
+			raise "No sub-context named #{sub_context_name}" unless context_def
+			# Instantiate a new context using self as parent:
+			context = Context.new( context_def, self )
+
+			yield context
+		end
+
+		def contains_object(obj_name)
+			key = obj_name.to_s
+			@defs.keys.member?(key) or extra_inputs_has(key)
+		end
+
+		def build_everything
+			@defs.keys.each { |k| self[k] }
+		end
+		alias :build_all :build_everything
+		alias :preinstantiate_singletons :build_everything
+
+		private
+
+		def construct_object(key)
+			# Find the object definition
+			obj_def = @defs[key]
+			raise "No object definition for '#{key}'" unless obj_def
+
+			# If object def mentions a library, load it
+			require obj_def.library if obj_def.library
+
+			# Resolve all components for the object
+			arg_hash = {}
+			obj_def.components.each do |name,value|
+				case value
+				when Lookup
+					arg_hash[name.to_sym] = get_object(value.name)
+				when StringValue
+					arg_hash[name.to_sym] = value.literal_value
+				else
+					raise "Cannot cope with component definition '#{value.inspect}'"
+				end
+			end
+
+      if obj_def.code.nil?
+        # Get a reference to the class for the object
+        big_c = get_class_for_name_with_module_delimeters(obj_def.class_name)
+        # Make and return the instance
+        if arg_hash.keys.size > 0
+          return big_c.new(arg_hash)
+        else
+          return big_c.new
+        end
+      else
+        eval_ret = eval(obj_def.code)
+        return eval_ret
+      end
+		rescue Exception => oops
+			cerr = ConstructionError.new(key,oops)
+			cerr.set_backtrace(oops.backtrace)
+			raise cerr
+		end
+
+		def get_class_for_name_with_module_delimeters(class_name)
+			class_name.split(/::/).inject(Object) do |mod,const_name| mod.const_get(const_name) end
+		end
+
+		def extra_inputs_has(key)
+			if key.nil? or key.strip == ''
+				raise ArgumentError.new("Cannot lookup objects with nil keys")
+			end
+			@extra_inputs.keys.member?(key) or @extra_inputs.keys.member?(key.to_sym)
+		end
+	end
+
+	class Lookup #:nodoc:
+		attr_reader :name
+		def initialize(obj_name)
+			@name = obj_name
+		end
+	end
+
+	class ObjectDef #:nodoc:
+		attr_accessor :name, :class_name, :library, :components, :code
+		def initialize(opts)
+      name = opts[:name]
+      raise "Can't make an ObjectDef without a name" if name.nil?
+
+      info = opts[:info] || {}
+      info = info.clone
+
+			@components = {}
+
+			# Object name
+			@name = name
+
+			# Class name
+			@class_name = info.delete 'class'
+			@class_name ||= info.delete 'type'
+			@class_name ||= camelize(@name)
+
+			# Library
+			@library = info.delete 'library'
+			@library ||= info.delete 'lib'
+			@library ||= underscore(@class_name)
+
+      @library = nil if @library == "nil"
+
+			# Code
+			@code = info.delete 'code'
+
+			# Auto-compose
+			compose = info.delete 'compose'
+			if compose
+				case compose
+				when Array
+					auto_names = compose.map { |x| x.to_s }
+				when String
+					auto_names = compose.split(',').map { |x| x.to_s.strip }
+				when Symbol
+					auto_names = [ compose.to_s ]
+				else
+					raise "Cannot auto compose object #{@name}, bad 'compose' format: #{compose.inspect}"
+				end
+			end
+			auto_names ||= []
+			auto_names.each do |cname|
+				@components[cname] = Lookup.new(cname)
+			end
+
+      # Singleton status
+      if info['singleton'].nil?
+        @singleton = true
+      else
+        @singleton = info['singleton']
+      end
+      info.delete 'singleton'
+
+			# Remaining keys
+			info.each do |key,val|
+				@components[key.to_s] = Lookup.new(val.to_s)
+			end
+
+		end
+
+    def singleton?
+      @singleton
+    end
+
+		private
+		# Ganked this from Inflector:
+		def camelize(lower_case_and_underscored_word)
+			lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+		end
+		# Ganked this from Inflector:
+		def underscore(camel_cased_word)
+			camel_cased_word.to_s.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').downcase
+		end
+	end
+
+	# Exception raised when an object can't be created which is defined in the context.
+	class ConstructionError < RuntimeError 
+		def initialize(object_name, cause=nil) #:nodoc:
+			object_name = object_name
+			cause = cause
+			m = "Failed to construct '#{object_name}'"
+			if cause 
+				m << "\n  ...caused by:\n  >>> #{cause}"
+			end
+			super m
+		end
+	end
+end
+
+
+