gamebox 0.0.1

data/lib/gamebox/mode_manager.rb

@@ -0,0 +1,80 @@
+require 'inflector'
+require 'mode'
+class ModeManager
+
+  constructor :resource_manager, :actor_factory, :input_manager,
+    :sound_manager, :config_manager
+
+  def setup
+    @modes = {}
+    @actor_factory.mode_manager = self
+    modes = @resource_manager.load_config('mode_level_config')[:modes]
+
+    @mode_names = []
+    for mode_hash in modes
+      for mode, levels in mode_hash
+        @mode_names << mode
+        mode_klass_name = "Mode"
+        unless mode == :default
+          mode_klass_name = Inflector.camelize mode.to_s+"Mode"
+        end
+        begin
+          require mode.to_s+"_mode"
+        rescue LoadError
+          # hope it's defined somewhere else
+        end
+        mode_klass = ObjectSpace.const_get mode_klass_name
+        mode_instance = mode_klass.new(@input_manager, @actor_factory, @resource_manager, @sound_manager, @config_manager, levels)
+        mode_instance.when :next_mode do
+          next_mode
+        end
+        mode_instance.when :prev_mode do
+          prev_mode
+        end
+        add_mode mode, mode_instance
+      end
+    end
+  end
+
+  def next_mode
+    index = @mode_names.index @mode
+    if index == @mode_names.size-1
+      puts "last mode, exiting"
+      exit
+    end
+    change_mode_to @mode_names[index+1]
+  end
+
+  def prev_mode
+    index = @mode_names.index @mode
+    if index == 0
+      puts "first mode, exiting"
+      exit
+    end
+    change_mode_to @mode_names[index-1]
+  end
+
+  def add_mode(mode_sym, mode_instance)
+    @modes[mode_sym] = mode_instance
+    @mode = mode_sym unless @mode
+    mode_instance
+  end
+
+  def change_mode_to(mode, *args)
+    @modes[@mode].stop unless @modes[@mode].nil?
+    @mode = mode
+    @modes[@mode].start *args
+  end
+
+  def current_mode
+    @modes[@mode]
+  end
+
+  def update(time)
+    @modes[@mode].update time unless @modes[@mode].nil?
+  end
+
+  def draw(target)
+    @modes[@mode].draw target unless @modes[@mode].nil?
+  end
+end

data/lib/gamebox/numbers_ext.rb

@@ -0,0 +1,3 @@
+class Float
+    Infinity = 1.0/0.0
+end

data/lib/gamebox/physical.rb

@@ -0,0 +1,139 @@
+require 'physics'
+require 'behavior'
+require 'inflector'
+require 'publisher'
+class Physical < Behavior
+  attr_accessor :shapes, :body, :opts, :parts
+
+  def shape
+    @shapes.first if @shapes
+  end
+  
+  def setup
+    # TODO add defaults?
+    @mass = @opts[:mass]
+    @mass ||= Float::Infinity
+    @parts = {}
+    @shapes = []
+
+    moment_of_inertia = @opts[:moment]
+
+    case @opts[:shape]
+    when :circle
+      @radius = @opts[:radius]
+
+      moment_of_inertia ||= @opts[:fixed] ? Float::Infinity : moment_for_circle(@mass, @radius, 0, ZeroVec2)
+      @body = Body.new(@mass, moment_of_inertia)
+      @shape = Shape::Circle.new(@body, @radius, ZeroVec2)
+
+    when :poly
+      shape_array = @opts[:verts].collect{|v| vec2(v[0],v[1])}
+
+      moment_of_inertia ||= @opts[:fixed] ? Float::Infinity : moment_for_poly(@mass, shape_array, ZeroVec2)
+      @body = Body.new(@mass, moment_of_inertia)
+      @shape = Shape::Poly.new(@body, shape_array, ZeroVec2)
+    end
+
+    collision_type = @opts[:collision_group]
+    collision_type ||= 
+      Inflector.underscore(@actor.class).to_sym
+      
+    @body.a = @opts[:angle] if @opts[:angle]
+
+    @shape.collision_type = collision_type
+    start_x = @opts[:x]
+    start_y = @opts[:y]
+    start_x ||= @actor.x
+    start_y ||= @actor.y
+    @shape.body.p = vec2(start_x,start_y)
+    @shape.e = 0
+    friction = @opts[:friction]
+    friction ||= 0.4
+    @shape.u = friction
+    
+    @shapes << @shape
+
+    if @opts[:parts]
+      for obj in @opts[:parts]
+        for part_name, part_def in obj
+          # add another shape here
+          part_shape_array = part_def[:verts].collect{|v| vec2(v[0],v[1])}
+          part_shape = Shape::Poly.new(@body, part_shape_array, part_def[:offset])
+          part_shape.collision_type = part_name.to_sym
+          # TODO pass all physics params to parts (ie u and e)
+          part_shape.u = friction
+          @shapes << part_shape
+        end
+      end
+    end
+
+
+    physical_obj = self
+
+    if @actor.level.respond_to? :register_physical_object
+      if @opts[:fixed]
+        @actor.level.register_physical_object physical_obj, true
+      else
+        @actor.level.register_physical_object physical_obj
+      end
+    else
+      raise "physical actor in a non-physical level!"
+    end
+
+    # write code here to keep physics and x,y of actor in sync
+    @actor.instance_eval do
+      (class << self; self; end).class_eval do
+        define_method :x do 
+          physical_obj.body.p.x
+        end
+        define_method :y do 
+          physical_obj.body.p.y
+        end
+        define_method :x= do |new_x|
+          raise "I am physical, you should apply forces"
+        end
+        define_method :y= do |new_y|
+          raise "I am physical, you should apply forces"
+        end
+        define_method :shape do 
+          physical_obj.shape
+        end
+        define_method :body do 
+          physical_obj.body
+        end
+        define_method :parts do 
+          physical_obj.parts
+        end
+        define_method :deg do 
+          # TODO hack!! why do poly's not work the same?
+          if physical_obj.opts[:shape] == :poly
+            -((physical_obj.body.a-1.57) * 180.0 / Math::PI + 90)
+          else
+            -((physical_obj.body.a) * 180.0 / Math::PI + 90)
+          end
+        end
+        define_method :warp do |new_p|
+          physical_obj.body.p = new_p
+          @level.space.rehash_static if physical_obj.opts[:fixed]
+        end
+        define_method :physical do 
+          physical_obj
+        end
+        define_method :image do 
+          old_image = nil
+          rot_deg = deg.round % 360
+
+          if is? :animated
+            old_image = animated.image
+          elsif is? :graphical
+            old_image = graphical.image
+          end
+
+          if old_image
+            old_image.rotozoom(rot_deg,1,true)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gamebox/physical_director.rb

@@ -0,0 +1,17 @@
+require 'director'
+
+class PhysicalDirector < Director
+  def find_physical_obj(shape)
+    @actors.select{|a|a.respond_to?(:shape) && a.shape==shape}.first
+  end
+
+  def remove_physical_obj(shape)
+    act = find_physical_obj shape
+    act.remove_self
+    act
+  end
+
+  def actor_removed(act)
+    act.level.unregister_physical_object act if act.is? :physical
+  end
+end

data/lib/gamebox/physical_level.rb

@@ -0,0 +1,89 @@
+# Levels represent on level of game play.  Some games will likely have only one
+# level. Level is responsible for loading its background, props, and directors.
+# PhysicalLevel adds a physics space to the Level
+require 'level'
+require 'physics'
+require 'physical_director'
+class PhysicalLevel < Level
+  
+  attr_accessor :space
+
+  def initialize(actor_factory, resource_manager, sound_manager, viewport, opts={}) 
+    @actor_factory = actor_factory
+    @director = PhysicalDirector.new
+    @actor_factory.director = @director
+
+    @resource_manager = resource_manager
+    @sound_manager = sound_manager
+    @viewport = viewport
+    @opts = opts
+
+    @space = Space.new
+    @space.iterations = 20
+    @space.elastic_iterations = 0
+
+    setup
+  end
+
+  PHYSICS_STEP = 25.0
+  def update_physics(time)
+    unless @physics_paused
+      steps = (time/PHYSICS_STEP).ceil
+      # from chipmunk demo
+      dt = 1.0/60/steps
+      steps.times do
+        @space.step dt
+      end
+    end
+  end
+  
+  def pause_physics
+    @physics_paused = true
+  end
+  
+  def restart_physics
+    @physics_paused = false
+  end
+
+  def update(time)
+    update_physics time
+    super
+  end
+
+  def register_physical_object(obj,static=false)
+    if static
+      obj.shapes.each do |shape|
+        @space.add_static_shape shape
+      end
+    else
+      @space.add_body(obj.body)
+      
+      obj.shapes.each do |shape|
+        @space.add_shape shape
+      end
+    end
+  end
+
+  def register_physical_constraint(constraint)
+    @space.add_constraint constraint
+  end
+
+  def unregister_physical_constraint(constraint)
+    @space.remove_constraint constraint
+  end
+
+  def unregister_physical_object(obj,static=false)
+    if static
+      obj.physical.shapes.each do |shape|
+        @space.remove_static_shape shape
+      end
+    else
+      @space.remove_body(obj.body)
+      
+      obj.physical.shapes.each do |shape|
+        @space.remove_shape shape
+      end
+    end
+  end
+
+end

data/lib/gamebox/physics.rb

@@ -0,0 +1,27 @@
+require 'chipmunk'
+
+require 'numbers_ext'
+include CP
+ZeroVec2 = vec2(0,0)
+
+class Space
+  alias :add_collision_func_old :add_collision_func
+  
+  # allows for passing arrays of collision types not just single ones
+  # add_collision_func([:foo,:bar], [:baz,:yar]) becomes:
+  # add_collision_func(:foo, :baz)
+  # add_collision_func(:foo, :yar)
+  # add_collision_func(:bar, :baz)
+  # add_collision_func(:bar, :yar)
+  def add_collision_func(first_objs, second_objs, &block)
+    firsts = [first_objs].flatten
+    seconds = [second_objs].flatten
+    
+    firsts.each do |f|
+      seconds.each do |s|
+        add_collision_func_old(f,s,&block)
+      end
+    end
+  end
+
+end

data/lib/gamebox/publisher_ext.rb

@@ -0,0 +1,13 @@
+module Publisher
+  module InstanceMethods
+    def unsubscribe_all(listener)
+      if @subscriptions
+        for event in @subscriptions.keys
+          @subscriptions[event].delete_if do |block|
+            eval('self',block.binding).equal?(listener)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gamebox/resource_manager.rb

@@ -0,0 +1,122 @@
+#!/usr/bin/env ruby
+$: << "#{File.dirname(__FILE__)}/../config"
+require "fileutils"
+require 'inflector'
+require 'svg_document'
+
+class ResourceManager
+  def initialize
+    @loaded_images = {}
+    @loaded_fonts = {}
+    @loaded_svgs = {}
+  end
+
+  def load_actor_image(actor)
+    # use pngs only for now
+    actor_name = Inflector.underscore(actor.class)
+    return load_image("#{actor_name}.png")
+  end
+
+  def load_animation_set(actor, action)
+    # use pngs only for now
+    actor_dir = Inflector.underscore(actor.class)
+    frames = Dir.glob("#{GFX_PATH}#{actor_dir}/#{action}/*.png")
+    action_imgs = []
+
+    frames = frames.sort_by {|f| File.basename(f).to_i }
+    
+    for frame in frames
+      rel_path = frame.slice(GFX_PATH.size,frame.size)
+      action_imgs << load_image(rel_path)
+    end
+    action_imgs
+  end
+
+  def load_image(file_name)
+    cached_img = @loaded_images[file_name]
+    if cached_img.nil?
+      begin
+        cached_img = Rubygame::Surface.load(File.expand_path(GFX_PATH + file_name))
+      rescue Exception => ex
+        #check global gamebox location
+        cached_img = Rubygame::Surface.load(File.expand_path(GAMEBOX_GFX_PATH + file_name))
+      end
+      @loaded_images[file_name] = cached_img
+    end
+    cached_img
+  end
+
+  def load_music(full_name)
+    begin
+      sound = Rubygame::Music.load(full_name)
+      return sound
+    rescue Rubygame::SDLError => ex
+      puts "Cannot load music " + full_name + " : " + ex
+    end
+  end
+
+  def load_sound(full_name)
+    begin
+      sound = Rubygame::Sound.load(full_name)
+      return sound
+    rescue Rubygame::SDLError => ex
+      puts "Cannot load sound " + full_name + " : " + ex
+    end
+  end
+
+  # loads TTF fonts from the fonts dir and caches them for later
+  def load_font(name, size)
+    @loaded_fonts[name] ||= {}
+    return @loaded_fonts[name][size] if @loaded_fonts[name][size]
+    begin
+      unless @ttf_loaded
+        TTF.setup
+        @ttf_loaded = true
+      end
+      full_name = File.expand_path(FONTS_PATH + name)
+      begin
+        font = TTF.new(full_name, size)
+        @loaded_fonts[name][size] = font
+      rescue Exception => ex
+        full_name = File.expand_path(GAMEBOX_FONTS_PATH + name)
+        font = TTF.new(full_name, size)
+        @loaded_fonts[name][size] = font
+      end
+      return font
+    rescue Exception => ex
+      puts "Cannot load font #{full_name}:#{ex}"
+    end
+    return nil
+  end
+
+  # TODO make this path include that app name?
+  def load_config(name)
+    conf = YAML::load_file(CONFIG_PATH + name + ".yml")
+    user_file = "#{ENV['HOME']}/.gamebox/#{name}.yml"
+    if File.exist? user_file
+      user_conf = YAML::load_file user_file
+      conf = conf.merge user_conf
+    end
+    conf
+  end
+
+  def save_settings(name, settings)
+    user_gamebox_dir = "#{ENV['HOME']}/.gamebox"
+    FileUtils.mkdir_p user_gamebox_dir
+    user_file = "#{ENV['HOME']}/.gamebox/#{name}.yml"
+    File.open user_file, "w" do |f|
+      f.write settings.to_yaml
+    end
+  end
+  
+  def load_svg(file_name)
+    # TODO create LEVEL_PATH in environment
+    cached_svg = @loaded_svgs[file_name]
+    if cached_svg.nil?
+      cached_svg = SvgDocument.new(File.open(File.expand_path(DATA_PATH + "levels/" + file_name + ".svg")))
+      @loaded_svgs[file_name] = cached_svg
+    end
+    cached_svg
+  end
+  
+end