gamebox 0.0.6 → 0.0.7

data/lib/gamebox/physics.rb

@@ -1,8 +1,8 @@
 require 'chipmunk'
 
-require 'numbers_ext'
+#require 'numbers_ext'
 include CP
-ZeroVec2 = vec2(0,0)
+ZERO_VEC_2 = vec2(0,0)
 
 class Space
   alias :add_collision_func_old :add_collision_func

data/lib/gamebox/resource_manager.rb

@@ -18,13 +18,77 @@ class ResourceManager
   end
 
   def load_animation_set(actor, action)
+    actor_dir = Inflector.underscore(actor.class)
+    using_tileset = File.exist?("#{GFX_PATH}#{actor_dir}/#{action}.png")
+    if using_tileset
+      load_tile_set(actor, action)
+    else
+      load_frame_set(actor, action)
+    end
+  end
+
+  #
+  #         --------------- image from @path --------------
+  # :right | [frame#1][frame#2][frame#3][frame#4][frame#5]|
+  #         -----------------------------------------------
+  #
+  # :down  ---image----
+  #       | [frame#1] |
+  #       | [frame#2] |
+  #       | [frame#3] |
+  #       | [frame#4] |
+  #       | [frame#5] |
+  #       -------------
+  #
+  def load_tile_set(actor, action)
+    actor_dir = Inflector.underscore(actor.class)
+    tileset = load_image "#{actor_dir}/#{action}.png"
+
+    action_imgs = []
+    w,h = *tileset.size
+    color = tileset.get_at 0, 0
+
+    if h > w
+      # down
+      num_frames = h/w
+      clip_from = Rubygame::Rect.new(0, 0, w, w)
+      clip_to = Rubygame::Rect.new(0, 0, w, w)
+      num_frames.times do
+        surface = Rubygame::Surface.new(clip_to.size)
+        surface.fill color
+        tileset.blit surface, clip_to, clip_from
+        surface.set_colorkey color
+        surface = surface.to_display_alpha
+        action_imgs << surface
+        clip_from.y += w
+      end
+    else
+      # right
+      num_frames = w/h
+      clip_from = Rubygame::Rect.new(0, 0, h, h)
+      clip_to = Rubygame::Rect.new(0, 0, h, h)
+      num_frames.times do
+        surface = Rubygame::Surface.new(clip_to.size)
+        surface.fill color
+        tileset.blit surface, clip_to, clip_from
+        surface.set_colorkey color
+        surface = surface.to_display_alpha
+        action_imgs << surface
+        clip_from.x += h
+      end
+    end
+
+    action_imgs
+  end
+
+  def load_frame_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)
@@ -36,10 +100,12 @@ class ResourceManager
     cached_img = @loaded_images[file_name]
     if cached_img.nil?
       begin
-        cached_img = Rubygame::Surface.load(File.expand_path(GFX_PATH + file_name))
+        #cached_img = Rubygame::Surface.load(File.expand_path(GFX_PATH + file_name))
+        cached_img = Rubygame::Surface.load(GFX_PATH + file_name)
       rescue Exception => ex
         #check global gamebox location
-        cached_img = Rubygame::Surface.load(File.expand_path(GAMEBOX_GFX_PATH + file_name))
+        #cached_img = Rubygame::Surface.load(File.expand_path(GAMEBOX_GFX_PATH + file_name))
+        cached_img = Rubygame::Surface.load(GAMEBOX_GFX_PATH + file_name)
       end
       @loaded_images[file_name] = cached_img
     end
@@ -73,12 +139,14 @@ class ResourceManager
         TTF.setup
         @ttf_loaded = true
       end
-      full_name = File.expand_path(FONTS_PATH + name)
+      #full_name = File.expand_path(FONTS_PATH + name)
+      full_name = 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)
+        #full_name = File.expand_path(GAMEBOX_FONTS_PATH + name)
+        full_name = GAMEBOX_FONTS_PATH + name
         font = TTF.new(full_name, size)
         @loaded_fonts[name][size] = font
       end
@@ -108,15 +176,16 @@ class ResourceManager
       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")))
+      #cached_svg = SvgDocument.new(File.open(File.expand_path(DATA_PATH + "levels/" + file_name + ".svg")))
+      cached_svg = SvgDocument.new(File.open(DATA_PATH + "levels/" + file_name + ".svg"))
       @loaded_svgs[file_name] = cached_svg
     end
     cached_svg
   end
-  
+
 end

data/lib/gamebox/sound_manager.rb

@@ -1,24 +1,13 @@
+# SoundManager auto loads sounds/music from data/sounds and data/music. It makes them accessible via name.
+# The name is a symbol of the filename without extension. This means that foo.wav and foo.ogg in the sound
+# directory will generate indeterminent behavior.
 class SoundManager
+  attr_accessor :sounds, :music
 
   constructor :resource_manager, :config_manager
+  
+  # checks to see if sdl_mixer is availalbe and preloads the sounds and music directories. 
   def setup
-    # Not in the pygame version - for Rubygame, we need to 
-    # explicitly open the audio device.
-    # Args are:
-    #   Frequency - Sampling frequency in samples per second (Hz).
-    #               22050 is recommended for most games; 44100 is
-    #               CD audio rate. The larger the value, the more
-    #               processing required.
-    #   Format - Output sample format.  This is one of the
-    #            AUDIO_* constants in Rubygame::Mixer
-    #   Channels -output sound channels. Use 2 for stereo,
-    #             1 for mono. (this option does not affect number
-    #             of mixing channels) 
-    #   Samplesize - Bytes per output sample. Specifically, this
-    #                determines the size of the buffer that the
-    #                sounds will be mixed in.
-#    Rubygame::Mixer::open_audio( 22050, Rubygame::Mixer::AUDIO_U8, 2, 1024 )
-    Rubygame::Mixer::open_audio( 22050, nil, 2, 1024 )
 
     puts 'Warning, sound disabled' unless
       (@enabled = (Rubygame::VERSIONS[:sdl_mixer] != nil))
@@ -57,6 +46,8 @@ class SoundManager
     @enabled
   end
 
+  # plays the sound based on the name with the specified volume level.
+  # play_sound :foo # play sound at 100% volume
   def play_sound(what, volume=nil)
     if @enabled && @sounds[what]
       @sound_thread = Thread.new do
@@ -66,6 +57,9 @@ class SoundManager
     end
   end
 
+  # plays the music based on the name with the specified volume level.
+  # will loop until SoundManager#stop_music is called.
+  # play_music :foo, 0.8  # play music at 80% volumne
   def play_music(what, volume=nil)
     if @enabled && @music[what]
       @music_thread = Thread.new do
@@ -75,12 +69,16 @@ class SoundManager
     end
   end
 
+  # stops the music file that is passed in.
+  # stop_music :foo
   def stop_music(what)
     if @enabled
       @music[what].stop if @music[what]
     end
   end
   
+  # stops the sound that is passed in.
+  # stop_sound :foo
   def stop_sound(what)
     if @enabled
       @sounds[what].stop if @sounds[what]

data/lib/gamebox/stage.rb

@@ -0,0 +1,143 @@
+require 'inflector'
+require 'publisher'
+require 'director'
+require 'viewport'
+# Stage is a state that the game is in.  (ie intro stage, multiplayer stage,
+# single player stage).
+class Stage
+  extend Publisher
+  can_fire_anything
+
+  attr_accessor :drawables, :resource_manager, :sound_manager,
+    :director, :opts, :viewport, :input_manager
+
+  def initialize(input_manager, actor_factory, resource_manager, sound_manager, config_manager, opts)
+    @input_manager = input_manager
+
+    @resource_manager = resource_manager
+    @sound_manager = sound_manager
+
+    @config_manager = config_manager
+    res = @config_manager[:screen_resolution]
+    @viewport = Viewport.new res[0], res[1]
+
+    @actor_factory = actor_factory
+    @director = create_director
+    @actor_factory.director = @director
+
+    @opts = opts
+
+    setup
+  end
+
+  def create_director
+    Director.new
+  end
+
+  def setup
+    clear_drawables
+  end
+
+  def create_actor(type, args={})
+    @actor_factory.build type, self, args
+  end
+  alias :spawn :create_actor 
+
+  # extract all the params from a node that are needed to construct an actor
+  def create_actors_from_svg svg_doc
+    float_keys = ["x","y"]
+    dynamic_actors ||= {}
+    layer = svg_doc.find_group_by_label("actors")
+
+    unless layer.nil?
+      # each image in the layer is an actor
+      layer.images.each do |actor_def|
+        klass = actor_def.game_class.to_sym
+        handle = actor_def.game_handle
+        new_opts = {}
+        actor_def.node.attributes.each do |k,v|
+          v = v.to_f if float_keys.include? k
+          new_opts[k.to_sym] = v
+        end
+
+        actor = create_actor klass, new_opts
+        dynamic_actors[handle.to_sym] = actor if handle
+      end
+    end
+    alias :spawn_from_svg :create_actors_from_svg
+
+    dynamic_actors
+  end
+
+  def update(time)
+    @director.update time
+    @viewport.update time
+  end
+
+  def curtain_raising(*args)
+    curtain_up *args
+  end
+
+  def curtain_dropping(*args)
+    curtain_down *args
+  end
+
+  def curtain_up(*args)
+  end
+
+  def curtain_down(*args)
+  end
+
+  def draw(target)
+    @drawables.keys.sort.reverse.each do |parallax_layer|
+
+      drawables_on_parallax_layer = @drawables[parallax_layer]
+
+      unless drawables_on_parallax_layer.nil?
+        drawables_on_parallax_layer.keys.sort.each do |layer|
+
+          trans_x = @viewport.x_offset parallax_layer
+          trans_y = @viewport.y_offset parallax_layer
+
+          drawables_on_parallax_layer[layer].each do |drawable|
+            drawable.draw target, trans_x, trans_y 
+          end
+        end
+      end
+    end
+  end
+
+  def unregister_drawable(drawable)
+    @drawables[drawable.parallax][drawable.layer].delete drawable
+  end
+
+  def clear_drawables
+    @drawables = {}
+  end
+
+  def register_drawable(drawable)
+    layer = drawable.layer
+    parallax = drawable.parallax
+    @drawables[parallax] ||= {}
+    @drawables[parallax][layer] ||= []
+    @drawables[parallax][layer] << drawable
+  end
+
+  # move all actors from one layer to another
+  # note, this will remove all actors in that layer!
+  def move_layer(from_parallax, from_layer, to_parallax, to_layer)
+    drawable_list = @drawables[from_parallax].delete from_layer
+
+    if drawable_list
+      prev_drawable_list = @drawables[to_parallax].delete to_layer
+      @drawables[to_parallax][to_layer] = drawable_list
+      drawable_list.each do |drawable|
+        drawable.parallax = to_parallax
+        drawable.layer = to_layer
+      end
+    end
+    prev_drawable_list
+
+  end
+end
+

data/lib/gamebox/stage_manager.rb

@@ -0,0 +1,110 @@
+require 'inflector'
+require 'stage'
+class StageManager
+
+  constructor :resource_manager, :actor_factory, :input_manager,
+    :sound_manager, :config_manager
+
+  def setup
+    @stages = {}
+
+    @actor_factory.stage_manager = self
+    stages = @resource_manager.load_config('stage_config')[:stages]
+
+    @stage_names = []
+    @stage_opts = []
+    stages.each do |stage|
+      stage_name = stage.keys.first
+      opts = stage.values.first
+      @stage_names << stage_name
+      opts ||= {}
+      @stage_opts << opts
+    end
+  end
+  
+  def lookup_stage_class(stage_name)
+    index = @stage_names.index stage_name
+    opts = @stage_opts[index]
+
+    name = opts[:class]
+    name ||= stage_name
+    stage_klass_name ||= Inflector.camelize name.to_s+"Stage"
+
+    begin
+      require name.to_s+"_stage"
+    rescue LoadError => ex
+      STDERR.puts ex
+      # TODO hrm.. should this get logged
+      # hope it's defined somewhere else
+    end
+    stage_klass = ObjectSpace.const_get stage_klass_name
+  end
+
+  def create_stage(name, opts)
+    stage_instance = lookup_stage_class(name).new(@input_manager, @actor_factory, @resource_manager, @sound_manager, @config_manager, opts)
+
+    stage_instance.when :next_stage do |*args|
+      next_stage *args
+    end
+    stage_instance.when :prev_stage do |*args|
+      prev_stage *args
+    end
+    stage_instance.when :restart_stage do |*args|
+      restart_stage *args
+    end
+    
+    stage_instance
+  end
+
+  def next_stage
+    index = @stage_names.index @stage
+    if index == @stage_names.size-1
+      puts "last stage, exiting"
+      exit
+    end
+    @stages.delete @stage_names[index+1]
+    change_stage_to @stage_names[index+1]
+  end
+
+  def prev_stage
+    index = @stage_names.index @stage
+    if index == 0
+      puts "first stage, exiting"
+      exit
+    end
+    @stages.delete @stage_names[index-1]
+    change_stage_to @stage_names[index-1]
+  end
+
+  def restart_stage(*args)
+    current_stage.curtain_dropping *args
+    index = @stage_names.index @stage
+    @stages.delete @stage_names[index]
+    change_stage_to @stage, *args
+  end
+
+  def change_stage_to(stage, *args)
+    @prev_stage = @stages[@stage]
+    unless @prev_stage.nil?
+      @prev_stage.curtain_dropping *args
+    end
+    @stage = stage
+    @stage_args = args
+    unless @stages[@stage]
+      @stages[@stage] = create_stage(@stage, @stage_opts[@stage_names.index(@stage)])
+    end
+    @stages[@stage].curtain_raising *args
+  end
+
+  def current_stage
+    @stages[@stage]
+  end
+
+  def update(time)
+    @stages[@stage].update time unless @stages[@stage].nil?
+  end
+
+  def draw(target)
+    @stages[@stage].draw target unless @stages[@stage].nil?
+  end
+end