gamebox 0.0.1

data/lib/gamebox/template_app/lib/platform.rb

@@ -0,0 +1,16 @@
+# Helper functions for determining platform
+
+# TODO how do I do this in ruby 1.9, since PLATFORM doesn't exist?
+class Platform
+	def self.mac?
+	  return PLATFORM =~ /darwin/
+	end
+	
+	def self.windows?
+	  return PLATFORM =~ /mswin/
+	end
+	
+	def self.linux?
+		return PLATFORM =~ /linux/
+	end
+end

data/lib/gamebox/template_app/src/app.rb

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+$: << "#{File.dirname(__FILE__)}/../config"
+
+require 'environment'
+
+if $0 == __FILE__
+  GameboxApp.run ARGV, ENV
+end

data/lib/gamebox/template_app/src/demo_level.rb

@@ -0,0 +1,20 @@
+require 'level'
+require 'ftor'
+class DemoLevel < Level
+  def setup
+    @my_actor = create_actor :my_actor
+    @my_actor.x = 10
+    @my_actor.y = 10
+
+    @stars = []
+    20.times { @stars << Ftor.new(rand(@width),rand(@height)) }
+  end
+
+  def draw(target, x_off, y_off)
+    target.fill [25,25,25,255]
+    for star in @stars
+      target.draw_circle_s([star.x,star.y],1,[255,255,255,255])
+    end
+  end
+end
+

data/lib/gamebox/template_app/src/game.rb

@@ -0,0 +1,22 @@
+class Game
+
+  constructor :wrapped_screen, :input_manager, :sound_manager,
+    :mode_manager
+
+  def setup
+#    @sound_manager.play :current_rider
+
+    @mode_manager.change_mode_to :default
+  end
+
+  def update(time)
+    @mode_manager.update time
+    draw
+  end
+
+  def draw
+    @mode_manager.draw @wrapped_screen
+    @wrapped_screen.flip
+  end
+
+end

data/lib/gamebox/template_app/src/my_actor.rb

@@ -0,0 +1,17 @@
+require 'actor'
+require 'actor_view'
+
+class MyActorView < ActorView
+  def draw(target, x_off, y_off)
+    target.draw_box [@actor.x,@actor.y], [20,20], [240,45,45,255]
+  end
+end
+
+class MyActor < Actor
+
+  def setup
+    # TODO setup stuff here
+    # subscribe for an event or something?
+  end
+
+end

data/lib/gamebox/version.rb

@@ -0,0 +1,10 @@
+module Gamebox
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 0
+    TINY  = 1
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end
+

data/lib/gamebox/viewport.rb

@@ -0,0 +1,81 @@
+require 'numbers_ext'
+require 'publisher'
+
+# Viewport represents the current "camera" location.  Essensially it translates from
+# world to screen coords and from screen coords to world coords.
+class Viewport
+  extend Publisher
+  can_fire :scrolled
+  
+  attr_accessor :x_offset, :y_offset, :follow_target, :width,
+    :height
+
+  def debug
+    "xoff:#{@x_offset} yoff:#{@y_offset}"
+  end
+
+  def initialize(width, height)
+    @x_offset = 0
+    @y_offset = 0
+
+    @width = width
+    @height = height
+  end
+
+  def x_offset(layer=1)
+    return 0 if layer == Float::Infinity
+    return @x_offset if layer == 1
+    @x_offset / layer
+  end
+
+  def y_offset(layer=1)
+    return 0 if layer == Float::Infinity
+    return @y_offset if layer == 1
+    @y_offset / layer
+  end
+
+  def update(time)
+    scrolled = false
+    if @follow_target
+      x_diff = @width/2 + @follow_offset_x - @follow_target.x - @x_offset
+      if x_diff.abs > @buffer_x
+        # move screen 
+        if x_diff > 0
+          @x_offset += x_diff - @buffer_x 
+          scrolled = true
+        else
+          @x_offset += x_diff + @buffer_x 
+          scrolled = true
+        end
+      end
+
+      y_diff = @height/2 + @follow_offset_y - @follow_target.y - @y_offset
+      if y_diff.abs > @buffer_y
+        # move screen
+        if y_diff > 0
+          @y_offset += y_diff - @buffer_y 
+          scrolled = true
+        else
+          @y_offset += y_diff + @buffer_y 
+          scrolled = true
+        end
+      end
+
+      fire :scrolled if scrolled
+    end
+  end
+
+  def follow(target, off=[0,0], buff=[0,0])
+    @follow_target = target
+    @follow_offset_x = off[0]
+    @follow_offset_y = off[1]
+    @buffer_x = buff[0]
+    @buffer_y = buff[1]
+
+    @x_offset = @width/2 - @follow_target.x + @follow_offset_x
+    @y_offset = @height/2 - @follow_target.y + @follow_offset_y
+    
+    fire :scrolled
+  end
+
+end

data/lib/gamebox/wrapped_screen.rb

@@ -0,0 +1,15 @@
+class WrappedScreen
+  constructor :config_manager
+  attr_accessor :screen
+  def setup
+    w,h = @config_manager[:screen_resolution]
+    flags = []
+    flags << HWSURFACE
+    flags << DOUBLEBUF
+    flags << FULLSCREEN if @config_manager[:fullscreen]
+    @screen = Screen.set_mode [w,h], 0, flags
+  end
+  def method_missing(name,*args)
+    @screen.send name, *args
+  end
+end

data/script/perf_polaris.rb

@@ -0,0 +1,36 @@
+$: << File.dirname(__FILE__)+"/../lib/gamebox"
+
+require 'ai/polaris'
+require 'ai/two_d_grid_map'
+
+@map = TwoDGridMap.new 100, 90
+
+from = TwoDGridLocation.new 0, 0
+to = TwoDGridLocation.new 9, 0
+@pather = Polaris.new @map
+
+require 'benchmark'
+Benchmark.bm do|b|
+  
+  b.report("warm up") do
+    10.times { path = @pather.guide(from,to) }
+  end
+
+  b.report("shorter path") do
+    10.times { path = @pather.guide(from,to) }
+  end
+
+  to = TwoDGridLocation.new 92, 0
+  b.report("longer path") do
+    10.times { path = @pather.guide(from,to) }
+  end
+
+  # put up a wall
+  @map.h.times do |i|
+    @map.place TwoDGridLocation.new(89, i), "ME"
+  end
+
+  b.report("blocked path") do
+    10.times { path = @pather.guide(from,to) }
+  end
+end

data/test/helper.rb

@@ -0,0 +1,25 @@
+$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'gamebox'))
+
+require 'rubygems'
+
+require 'bacon'
+require 'mocha'
+require 'aliasing'
+
+class Bacon::Context
+  include Mocha::Standalone
+  def it_with_mocha description
+    it_without_mocha description do
+      mocha_setup
+      yield
+      mocha_verify
+      mocha_teardown
+    end
+  end
+  alias_method_chain :it, :mocha
+end
+
+
+require 'metaclass'
+require 'actor'
+

data/test/test_actor.rb

@@ -0,0 +1,38 @@
+require 'helper'
+require 'actor'
+
+describe 'A new actor' do
+  before do
+    opts = {:level=>"level", :input=>"input", :resources=>"resource"}
+    @actor = Actor.new opts
+  end
+
+  it 'should be alive' do
+    @actor.alive?.should.equal true
+  end
+
+  it 'should be at (0,0)' do
+    @actor.x.should.equal 0
+    @actor.y.should.equal 0
+  end
+
+  it 'should have atts set' do
+    @actor.level.should.equal "level" 
+    @actor.input_manager.should.equal "input" 
+    @actor.resource_manager.should.equal "resource" 
+    @actor.behaviors.size.should.equal 0
+  end
+
+  it 'should fire anything' do
+    should.not.raise do
+      @actor.when :foofoo_bar do
+        "blah"
+      end
+    end
+  end
+
+  it 'should setup behaviors' do
+    should.flunk 'cannot test easily!'
+  end
+
+end

data/test/test_animated.rb

@@ -0,0 +1,64 @@
+require 'helper'
+require 'animated'
+require 'mocha'
+
+describe 'A new animated behavior' do
+  before do
+    @rm = stub(:load_animation_set => ['1.png_img_obj','2.png_img_obj'])
+
+    opts = {:level=>"level", :input=>"input", :resources=>@rm}
+    @actor = Actor.new opts
+    @animated = Animated.new @actor
+  end
+
+  it 'should define methods on actor' do
+    @actor.should.respond_to? :image
+    @actor.should.respond_to? :start_animating
+    @actor.should.respond_to? :stop_animating
+    @actor.should.respond_to? :action=
+    @actor.should.respond_to? :animated
+  end
+
+  it 'shouldn\'t update frame for non-animating' do
+    @animated.stop_animating
+
+    @animated.update Animated::FRAME_UPDATE_TIME+1
+
+    @animated.frame_time.should.equal 0
+    @animated.frame_num.should.equal 0
+  end
+
+  it 'should update frame for animating' do
+    time_passed = Animated::FRAME_UPDATE_TIME-1
+    @animated.update time_passed
+    @animated.frame_time.should.equal time_passed
+    @animated.frame_num.should.equal 0
+
+    time_passed_again = 2
+    @animated.update time_passed_again
+    # we rolled over the time
+    @animated.frame_time.should.equal 1
+    @animated.frame_num.should.equal 1
+
+    time_passed_again = Animated::FRAME_UPDATE_TIME
+    @animated.update time_passed_again
+    # we rolled over the time
+    @animated.frame_time.should.equal 1
+    @animated.frame_num.should.equal 0
+  end
+
+  it 'should stop animating' do
+    @animated.stop_animating
+    @animated.animating.should.equal false
+  end
+
+  it 'should start animating' do
+    @animated.start_animating
+    @animated.animating.should.equal true
+  end
+
+  it 'should set the action and animate accordingly' do
+    should.flunk 'finish me'
+  end
+
+end

data/test/test_line_of_site.rb

@@ -0,0 +1,14 @@
+require 'helper'
+require 'ai/line_of_site'
+require 'ai/two_d_grid_map'
+
+describe 'A new LineOfSite' do
+  before do
+    @map = TwoDGridMap.new 10, 20
+    @los = LineOfSite.new @map
+  end
+
+  it 'should be sane' do
+    true.should == true
+  end
+end

data/test/test_physical.rb

@@ -0,0 +1,26 @@
+require 'helper'
+require 'physical'
+require 'actor'
+require 'mocha'
+
+class CircleActor < Actor
+  has_behaviors :physical => {:shape => :circle, 
+    :mass => 500,
+    :radius => 10}
+end
+
+describe 'A new physical behavior' do
+  before do
+    @level = stub(:load_animation_set => ['1.png_img_obj','2.png_img_obj'],:register_physical_object => true)
+
+    opts = {:level=>@level, :input=>"input", :resources=>"rm"}
+    @actor = CircleActor.new opts
+    @physical = @actor.physical
+  end
+
+  it 'should add methods to its actor' do
+    @actor.should.respond_to? :x
+    should.flunk 'testing this feels dirty...'
+  end
+
+end

data/test/test_polaris.rb

@@ -0,0 +1,193 @@
+require 'helper'
+require 'ai/polaris'
+require 'ai/two_d_grid_map'
+
+describe 'A new polaris' do
+  before do
+    @map = TwoDGridMap.new 10, 20
+    @pather = Polaris.new @map
+  end
+
+  it 'should return an empty path if destination is not valid' do
+    from = TwoDGridLocation.new @map.w-1, @map.h-1
+    to = TwoDGridLocation.new @map.w, @map.h
+    @pather.guide(from,to).should == nil
+
+    to = TwoDGridLocation.new(-1, -1)
+    @pather.guide(from,to).should == nil
+  end
+
+  it 'should return an empty path if start is not valid' do
+    from = TwoDGridLocation.new @map.w, @map.h
+    to = TwoDGridLocation.new @map.w-1, @map.h-1
+    @pather.guide(from,to).should == nil
+    
+    from = TwoDGridLocation.new -1, -1
+    @pather.guide(from,to).should == nil
+  end
+  
+  it 'should return the path of "to" for accessible neighbor' do
+    from = TwoDGridLocation.new 0, 0
+    to = TwoDGridLocation.new 1, 0
+    
+    path = @pather.guide(from,to)
+    path.should != nil
+    path.size.should == 1
+    
+    path.first.cost_to.should == TwoDGridMap::TRAVEL_COST_STRAIGHT
+    path.first.dist_from.should == 0
+    path.first.location.x.should == to.x
+    path.first.location.y.should == to.y
+  end
+  
+  it 'should return the right horizontal path of length 2' do
+    from = TwoDGridLocation.new 0, 0
+    to = TwoDGridLocation.new 2, 0
+    
+    path = @pather.guide(from,to)
+    
+    path.should != nil
+    path.size.should == 2
+    
+    path.first.location.x.should == 1
+    path.first.location.y.should == 0
+    path.last.location.should == to
+  end
+
+  it 'should return the left horizontal path of length 2' do
+    from = TwoDGridLocation.new 2, 0
+    to = TwoDGridLocation.new 0, 0
+    
+    path = @pather.guide(from,to)
+    
+    path.should != nil
+    path.size.should == 2
+    
+    path.first.location.x.should == 1
+    path.first.location.y.should == 0
+    path.last.location.should == to
+  end  
+  
+
+  it 'should return the left up diag path of length 2' do
+    from = TwoDGridLocation.new 2, 2
+    to = TwoDGridLocation.new 0, 0
+    
+    path = @pather.guide(from,to)
+    
+    path.should != nil
+    path.size.should == 2
+    
+    path.first.location.x.should == 1
+    path.first.location.y.should == 1
+    path.last.location.should == to
+  end  
+  
+  it 'should return the right up diag path of length 2' do
+    from = TwoDGridLocation.new 2, 2
+    to = TwoDGridLocation.new 4, 0
+    
+    path = @pather.guide(from,to)
+    
+    path.should != nil
+    path.size.should == 2
+    
+    path.first.location.x.should == 3
+    path.first.location.y.should == 1
+    path.last.location.should == to
+  end
+  
+  it 'should return the right down diag path of length 2' do
+    from = TwoDGridLocation.new 2, 2
+    to = TwoDGridLocation.new 4, 4
+    
+    path = @pather.guide(from,to)
+    
+    path.should != nil
+    path.size.should == 2
+    
+    path.first.location.x.should == 3
+    path.first.location.y.should == 3
+    path.last.location.should == to
+  end   
+  
+  it 'should return the left down diag path of length 2' do
+    from = TwoDGridLocation.new 2, 2
+    to = TwoDGridLocation.new 0, 4
+    
+    path = @pather.guide(from,to)
+    
+    path.should != nil
+    path.size.should == 2
+    
+    path.first.location.x.should == 1
+    path.first.location.y.should == 3
+    path.last.location.should == to
+  end  
+  
+  it 'should return go around an obstacle' do
+    from = TwoDGridLocation.new 0, 0
+    to = TwoDGridLocation.new 2, 0
+    
+    in_the_way = TwoDGridLocation.new 1, 0
+    @map.place in_the_way, "ME"
+    
+    path = @pather.guide(from,to)
+    
+    path.should != nil
+    path.size.should == 2
+    
+    path.first.location.x.should == 1
+    path.first.location.y.should == 1
+    path.last.location.should == to
+  end
+  
+  it 'should return shortest path of horizontal and diag length 5' do
+    from = TwoDGridLocation.new 0, 0
+    to = TwoDGridLocation.new 5, 4
+    
+    path = @pather.guide(from,to)
+    
+    path.should != nil
+    path.size.should == 5
+    
+    # make sure that all elements of the path are neighbors
+    prev_el = PathElement.new from, nil
+    path.each do |path_el|
+      @map.neighbors(prev_el.location).should.include? path_el.location
+      prev_el = path_el
+    end
+    
+    path.last.location.should == to
+  end
+  
+  it 'should return nil when the shortest path is longer than the max step passed in' do
+    from = TwoDGridLocation.new 0, 0
+    to = TwoDGridLocation.new 5, 4
+    
+    path = @pather.guide(from,to,nil,4)
+    path.should == nil
+  end  
+
+  it 'should return nil when the path does not exist for unit type' do
+    from = TwoDGridLocation.new 0, 0
+    to = TwoDGridLocation.new 2, 0
+    
+    path = @pather.guide(from,to,:blocked)
+    path.should == nil
+  end  
+
+  it 'should return nil when the path does not exist' do
+    from = TwoDGridLocation.new 0, 0
+    to = TwoDGridLocation.new 2, 0
+    
+    # put up a wall
+    @map.h.times do |i|
+      @map.place TwoDGridLocation.new(1, i), "ME"
+    end
+    
+    path = @pather.guide(from,to)
+    path.should == nil
+    @pather.nodes_considered.should == @map.h
+  end
+end