gamebox 0.0.1

data/lib/gamebox/score.rb

@@ -0,0 +1,35 @@
+class ScoreView < ActorView
+  def draw(target,x_off,y_off)
+    text = @actor.score.to_s
+    text = '0'*(6-text.size)+text
+
+    font = @mode.resource_manager.load_font 'Asimov.ttf', 30
+    text_image = font.render text, true, [250,250,250,255]
+
+    x = @actor.x
+    y = @actor.y
+
+    text_image.blit target.screen, [x,y]
+  end
+end
+class Score < Actor
+  attr_accessor :score
+
+  def setup
+    clear
+  end
+
+  def clear
+    @score = 0
+  end
+
+  def +(amount)
+    @score += amount
+    self
+  end
+
+  def -(amount)
+    @score -= amount
+    self
+  end
+end

data/lib/gamebox/sorted_list.rb

@@ -0,0 +1,59 @@
+require 'linked_list'
+
+# Keeps a list of items sorted. Elements must be comparable
+class SortedList
+  attr_reader :list
+  def initialize(initial_list=nil)
+    @list = LinkedList.new
+    unless initial_list.nil?
+      initial_list.each do |item|
+        add item
+      end
+    end
+  end
+  
+  def add(item)
+    added = false
+    @list.each_element do |node|
+      if node.obj > item
+        added = true
+        @list.place item, :before, node
+        break
+      end
+    end
+    @list << item unless added
+    item
+  end
+  alias :<< :add
+  
+  def shift
+    @list.shift
+  end
+  
+  def empty?
+    @list.empty?
+  end
+  
+  def contains?(item)
+    @list.each do |obj|
+      if obj == item
+        return true
+      end
+    end
+    false
+  end
+  
+  def find(item)
+    @list.each do |obj|
+      if obj == item
+        return obj
+      end
+    end
+    nil
+  end
+  
+  def size
+    @list.size
+  end
+  
+end

data/lib/gamebox/sound_manager.rb

@@ -0,0 +1,84 @@
+class SoundManager
+
+  constructor :resource_manager, :config_manager
+  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))
+    @enabled = (@enabled and (@config_manager.settings[:sound].nil? or @config_manager.settings[:sound] == true))
+
+    if @enabled
+      @music = {}
+      files = Dir.glob "#{MUSIC_PATH}**"
+      for f in files
+        name = File.basename(f)
+        begin
+          sym = name.gsub(" ","_").split(".")[0..-2].join(".").to_sym
+          @music[sym] = @resource_manager.load_music(f)
+        rescue;end
+      end if files
+
+      @sounds = {}
+      files = Dir.glob "#{SOUND_PATH}**"
+      for f in files
+        name = File.basename(f)
+        begin
+          sym = name.gsub(" ","_").split(".")[0..-2].join(".").to_sym
+          @sounds[sym] = @resource_manager.load_sound(f)
+        rescue;end
+      end if files
+    end
+  end
+
+  def enabled?
+    @enabled
+  end
+
+  def play_sound(what, volume=nil)
+    if @enabled && @sounds[what]
+      @sound_thread = Thread.new do
+        @sounds[what].volume = volume if volume
+        @sounds[what].play
+      end
+    end
+  end
+
+  def play_music(what, volume=nil)
+    if @enabled && @music[what]
+      @music_thread = Thread.new do
+        @music[what].volume = volume if volume
+        @music[what].play :repeats => -1
+      end
+    end
+  end
+
+  def stop_music(what)
+    if @enabled
+      @music[what].stop if @music[what]
+    end
+  end
+  
+  def stop_sound(what)
+    if @enabled
+      @sounds[what].stop if @sounds[what]
+    end
+  end
+
+end

data/lib/gamebox/surface_ext.rb

@@ -0,0 +1,37 @@
+require 'ftor'
+module Rubygame
+
+  class Surface
+    def draw_line_s(point1, point2, color, thickness)
+      half_thickness = thickness/2.0
+      x1 = point1[0]
+      y1 = point1[1]
+      x2 = point2[0]
+      y2 = point2[1]
+
+      point1_vector = Ftor.new x1, y1
+      point2_vector = Ftor.new x2, y2
+
+      line_vector = point2_vector-point1_vector
+      perp_vector = line_vector.normal.unit
+
+      points = []
+      pvt = perp_vector*half_thickness
+      poly_point1 = Ftor.new(x1,y1)+pvt
+      poly_point2 = Ftor.new(x2,y2)+pvt
+      poly_point3 = Ftor.new(x2,y2)-pvt
+      poly_point4 = Ftor.new(x1,y1)-pvt
+
+      points << [poly_point1.x,poly_point1.y]
+      points << [poly_point2.x,poly_point2.y]
+      points << [poly_point3.x,poly_point3.y]
+      points << [poly_point4.x,poly_point4.y]
+      points << [poly_point1.x,poly_point1.y]
+
+      draw_polygon_s points, color
+      draw_circle_s [x1,y1], half_thickness, color
+      draw_circle_s [x2,y2], half_thickness, color
+    end
+  end
+
+end # module Rubygame

data/lib/gamebox/svg_actor.rb

@@ -0,0 +1,55 @@
+require 'actor'
+require 'actor_view'
+
+require "enumerator"
+
+
+# SvgActor knows how to build himself based on an svg document based on the :name 
+# passed in being the group name in the doc (layer).
+class SvgActor < Actor
+  
+  attr_accessor :segments, :type
+  def setup
+    @name = @opts[:name]
+    @svg_doc = @opts[:svg_doc]
+    
+    my_layer = @svg_doc.find_group_by_label(@name.to_s)
+    build_from_vertices my_layer.path.vertices
+    @visible = my_layer.path.visible?
+  end
+  
+  def build_from_vertices(vertices)
+    
+    moment_of_inertia,mass = Float::Infinity,Float::Infinity
+    terrain_body = CP::Body.new(mass,moment_of_inertia)
+    elasticity = 0
+    friction = 0.7
+    thickness = 6
+    @segments = []
+    vertices.each_cons(2) do |a,b|
+      seg = CP::Shape::Segment.new(terrain_body, a,b, thickness)
+      seg.collision_type = @name
+      seg.e = elasticity
+      seg.u = friction
+      seg.group = :terrain
+      @segments << [a,b]
+      @level.space.add_static_shape(seg)
+    end
+  end
+  
+  def visible?
+    @visible
+  end
+  
+end
+
+class SvgActorView < ActorView
+  def draw(target,x_off,y_off)
+    return unless @actor.visible?
+    @actor.segments.each do |seg|
+      p1 = seg[0]
+      p2 = seg[1]
+      target.draw_line_s [p1.x+x_off,p1.y+y_off], [p2.x+x_off,p2.y+y_off], [25,255,25,255], 6
+    end
+  end
+end

data/lib/gamebox/svg_document.rb

@@ -0,0 +1,160 @@
+require 'rexml/document'
+require 'strscan'
+
+class SvgDocument
+
+  def initialize(xml_string)
+    @document = REXML::Document.new(xml_string)
+    @root = @document.root
+  end
+
+  def find_group_by_label(label)
+    g = REXML::XPath.first(@root, "//g[@inkscape:label='#{label}']")
+    return nil unless g
+    Group.new(g)
+  end
+
+  module HasBounds
+    attr_accessor :bounds
+
+    def translate(vec)
+      @bounds.translate(vec) if @bounds
+    end
+
+    def center
+      @bounds.center if @bounds
+    end
+
+    protected
+
+    def set_bounds_from_attributes
+      x = @node.attributes["x"].to_f
+      y = @node.attributes["y"].to_f
+      width = @node.attributes["width"].to_f
+      height = @node.attributes["height"].to_f
+      @bounds = Rect.new [x,y,width,height]
+    end
+  end
+
+  module HasTranslation
+    def translation
+      transform = @node.attributes["transform"]
+      if transform and transform =~ /translate\(\s*(.+?)\s*,\s*(.+?\)\s*)/
+        vec2($1.to_f, ty = $2.to_f)
+      else
+        ZeroVec2
+      end
+    end
+  end
+
+  class Base
+    include HasTranslation
+    attr_reader :node
+
+    def initialize(node)
+      raise "Can't make #{self.class.name} from nil" if node.nil?
+      @node = node
+    end
+
+    def game_class
+      @node.attributes['game:class']
+    end
+
+    def game_handle
+      @node.attributes['game:handle']
+    end
+    
+    def visible?
+      @node.attributes['visible'] != 'false'
+    end
+  end
+
+  class Group < Base
+    def paths(opts={})
+      inst_from_xpath "path", Path, opts
+    end
+
+    def path(opts={})
+      paths(opts).first
+    end
+
+    def rects(opts={})
+      inst_from_xpath "rect", Rectangle, opts
+    end
+
+    def rect(opts={})
+      rects(opts).first
+    end
+
+    def images(opts={})
+      inst_from_xpath "image", Image, opts
+    end
+
+    def image(opts={})
+      images(opts).first
+    end
+
+    def groups(opts={})
+      inst_from_xpath "g", Group, opts
+    end
+
+    def group(opts={})
+      groups(opts).first
+    end
+
+    private
+
+    def map_from_xpath(xpr, opts={})
+      opts.each do |key,val|
+        xpr << "[@#{key}='#{val}']"
+      end
+      REXML::XPath.match(@node, xpr).map do |n|
+        yield n
+      end
+    end
+
+    def inst_from_xpath(xpr, clazz, opts={})
+      map_from_xpath(xpr,opts) do |n|
+        clazz.new(n)
+      end
+    end
+  end
+
+  class Path < Base
+    # The bezier path object must have all its nodes turned "sharp",
+    # or non-curve-handle-ish, or this parser will not work properly
+    def vertices
+      unless @verts
+        @verts = []
+        data = @node.attributes['d']
+        scanner = StringScanner.new(data)
+        pat = /[ML]\s+([-0-9.,]+)\s*/
+        hit = scanner.scan(pat)
+        while hit
+          x,y = scanner[1].split(/,/).map { |s| s.to_f }
+          @verts << vec2(x,y)
+          hit = scanner.scan(pat)
+        end
+      end
+      @verts
+    end
+  end
+
+  class Rectangle < Base
+    include HasBounds
+
+    def initialize(node)
+      super node
+      set_bounds_from_attributes
+    end
+  end
+
+  class Image < Rectangle
+    attr_reader :image_name
+
+    def initialize(node)
+      super(node)
+      @image_name = @node.attributes["xlink:href"]
+    end
+  end
+end

data/lib/gamebox/template_app/README

@@ -0,0 +1,30 @@
+== Welcome to Gamebox
+Blurb here
+
+== Description of Contents
+
+src
+  Holds all the code that's specific to this particular application.
+
+config
+  Configuration files for the Gamebox environment and other dependencies.
+
+doc
+  This directory is where your application documentation will be stored when generated
+  using <tt>rake doc:app</tt>
+
+lib
+  Application specific libraries. Basically, any kind of custom code that doesn't
+  belong under controllers, models, or helpers. This directory is in the load path.
+
+script
+  Helper scripts for automation and generation.
+
+test
+  Unit and functional tests along with fixtures. When using the script/generate scripts, template
+  test files will be generated for you and placed in this directory.
+
+vendor
+  External libraries that the application depends on. Also includes the plugins subdirectory.
+  If the app has frozen rails, those gems also go here, under vendor/rails/.
+  This directory is in the load path.