gamebox 0.0.1

data/lib/gamebox/actor_factory.rb

@@ -0,0 +1,64 @@
+require 'actor'
+require 'graphical_actor_view'
+class ActorFactory
+  constructor :input_manager, :sound_manager
+
+  attr_accessor :mode_manager, :director
+  
+  # returns a hash of actor params
+  def cached_actor_def(actor)
+    @actor_cache ||= {}
+    cached_actor = @actor_cache[actor]
+    return cached_actor if cached_actor
+
+    begin
+      require actor.to_s
+      require actor.to_s+"_view"
+    rescue LoadError => ex
+      # maybe its included somewhere else
+    end
+    model_klass_name = Inflector.camelize actor
+    model_klass = Object.const_get model_klass_name
+    
+    begin
+      view_klass = Object.const_get model_klass_name+"View"
+    rescue Exception => ex
+      # hrm...
+    end
+    
+    actor_def = {
+      :model_klass => model_klass,
+      :view_klass => view_klass
+    }
+    @actor_cache[actor] = actor_def
+    actor_def
+  end
+
+  
+  def build(actor, level, opts={})
+    actor_def = cached_actor_def actor
+
+    basic_opts = {
+      :level => level,
+      :input => @input_manager,
+      :sound => @sound_manager,
+      :resources => level.resource_manager
+    }
+    merged_opts = basic_opts.merge(opts)
+
+    model = actor_def[:model_klass].new merged_opts 
+
+    view_klass = opts[:view]
+    view_klass ||= actor_def[:view_klass]
+    
+    if model.is? :animated or model.is? :graphical or model.is? :physical
+      view_klass ||= GraphicalActorView
+    end
+    view_klass.new @mode_manager.current_mode, model if view_klass
+    
+    # Register our new actor with the system
+    @director.add_actor model
+
+    return model
+  end
+end

data/lib/gamebox/actor_view.rb

@@ -0,0 +1,35 @@
+class ActorView
+  attr_accessor :actor, :mode, :layer, :parallax
+  def initialize(mode,actor)
+    @mode = mode
+    @actor = actor
+
+    @layer = 0
+    @parallax = 1
+    if @actor.is? :layered
+      @layer = @actor.layer
+      @parallax = @actor.parallax
+    end
+
+    actor.when :remove_me do
+      @mode.unregister_drawable self
+    end
+    
+    actor.when :hide_me do
+      @mode.unregister_drawable self
+    end
+    
+    actor.when :show_me do
+      @mode.register_drawable self
+    end
+    
+    actor.show
+    
+    setup
+  end
+
+  def setup
+  end
+
+end
+

data/lib/gamebox/ai/line_of_site.rb

@@ -0,0 +1,61 @@
+# LineOfSite is a class for finding neighbors in a map that are visible
+class LineOfSite
+  def initialize(map)
+    @map = map
+  end
+  
+  def losline(x, y, x2, y2)
+    brensenham_line(x, y, x2, y2).each do |i|
+      iterx, itery = *i
+      occ = @map.occupant(loc2(iterx,itery))
+      return unless occ
+      occ.lit = true
+      occ.seen = true
+      
+      return if occ.solid?      
+    end
+  end            
+  
+  # Brensenham line algorithm
+  def brensenham_line(x,y,x2,y2)
+    steep = false
+    coords = []
+    dx = (x2 - x).abs
+    if (x2 - x) > 0
+      sx = 1
+    else 
+      sx = -1
+    end
+    dy = (y2 - y).abs
+    if (y2 - y) > 0
+      sy = 1
+    else
+      sy = -1
+    end
+    if dy > dx
+      steep = true
+      x,y = y,x
+      dx,dy = dy,dx
+      sx,sy = sy,sx
+    end
+    d = (2 * dy) - dx
+
+    dx.times do
+      if steep 
+        coords << [y,x]
+      else
+        coords << [x,y]
+      end
+      while d >= 0
+        y = y + sy
+        d = d - (2 * dx)
+      end
+      x = x + sx
+      d = d + (2 * dy)
+    end
+    coords << [x2,y2]
+    
+    coords             
+  end  
+
+end

data/lib/gamebox/ai/polaris.rb

@@ -0,0 +1,107 @@
+require 'algorithms'
+include Containers
+
+# Polaris is a star that guides, aka "The North Star".  It implements the A* algorithm.
+class Polaris
+  attr_reader :nodes_considered
+  
+  def initialize(map)
+    @map = map
+    @nodes_considered = 0
+  end
+  
+  def guide(from, to, unit_type=nil, max_depth=400)
+    return nil if @map.blocked?(from, unit_type) || @map.blocked?(to, unit_type)
+    from_element = PathElement.new(from)
+    from_element.dist_from = @map.distance(from,to)
+    open = PriorityQueue.new { |x, y| (x <=> y) == -1 }
+    open.push from_element, from_element.rating
+    closed = SplayTreeMap.new
+    step = 0
+    
+    until open.empty? || step > max_depth
+      step += 1
+      
+      current_element = open.pop
+      @nodes_considered += 1
+      
+      loc = current_element.location
+      if @map.cost(loc,to) == 0
+        path = []
+        until current_element.parent.nil?
+          path.unshift current_element
+          current_element = current_element.parent
+        end
+
+        return path
+      else
+        closed.push current_element.location, current_element
+        @map.neighbors(loc).each do |next_door|
+          el = PathElement.new(next_door,current_element)
+          next if closed.has_key? next_door
+          
+          if @map.blocked? next_door, unit_type
+            #closed.push el.location, el
+          else
+            current_rating = current_element.cost_to + @map.cost(loc, next_door)
+            
+            # add to open
+            el.cost_to = current_rating
+            el.dist_from = @map.distance(next_door,to)
+            
+            open.push el, el.rating
+          end
+        end
+      end
+    end
+    nil
+  end
+end
+
+class PathElement
+  include Comparable
+  
+  attr_accessor :location, :parent
+  attr_reader :cost_to, :dist_from, :rating
+  def initialize(location=nil,parent=nil)
+    @location = location
+    @parent = parent
+    @cost_to = 0
+    @dist_from = 0
+    @rating = 99_999
+  end
+  
+  def cost_to=(new_cost)
+    @cost_to = new_cost
+    reset_rating
+  end
+  
+  def dist_from=(new_dist_from)
+    @dist_from = new_dist_from
+    reset_rating
+  end
+  
+  def reset_rating
+    @rating = @cost_to + @dist_from
+  end
+  
+  def to_s
+    "#{@location} at cost of #{@cost_to} and rating of #{@rating}"
+  end
+  
+  def <=>(b)
+    a = self
+    if a.rating < b.rating
+      return -1
+    elsif a.rating > b.rating
+      return 1
+    else
+      0
+    end
+  end
+  
+  def ==(other)
+    return false if other.nil?
+    @location == other.location
+  end
+end

data/lib/gamebox/ai/two_d_grid_location.rb

@@ -0,0 +1,21 @@
+# TwoDGridLocation exibits an x,y,cost location
+class TwoDGridLocation
+  attr_accessor :x,:y
+  def initialize(x,y);@x=x;@y=y;end
+  def ==(other)
+    @x == other.x and @y == other.y
+  end
+  
+  def <=>(b)
+    ret = 1
+    if @x == b.x && @y == b.y  
+      ret = 0
+    end
+    ret = -1 if @x <= b.x && @y < b.y
+    return ret
+  end
+  
+  def to_s
+    "#{@x},#{@y}"
+  end
+end

data/lib/gamebox/ai/two_d_grid_map.rb

@@ -0,0 +1,77 @@
+require 'ai/two_d_grid_location'
+
+# TwoDGridMap exibits the contract that the map requires. 
+# Works on an X,Y grid that uses Ftors for 2D vectors
+class TwoDGridMap
+  attr_accessor :w, :h
+  TRAVEL_COST_DIAG = 14
+  TRAVEL_COST_STRAIGHT = 10
+  
+  def initialize(w,h)
+    @w = w
+    @h = h
+    @grid = {}
+  end
+  
+  # place thing at location. If thing is nil, location will be placed in the map
+  def place(location, thing=nil)
+    thing ||= location
+    @grid[location.x] ||= {}
+    @grid[location.x][location.y] = thing
+  end
+  
+  def occupant(location)
+    @grid[location.x][location.y] if @grid[location.x]
+  end
+  
+  def clear(location)
+    @grid[location.x] ||= {}
+    @grid[location.x][location.y] = nil
+  end
+  
+  # is the location available for the specified type
+  def blocked?(location, type=nil)
+    return true if type == :blocked
+    return true if location.x >= @w || location.y >= @h || location.x < 0 || location.y < 0
+    if @grid[location.x] and @grid[location.x][location.y]
+      return true
+    else
+      return false
+    end
+  end
+  
+  # returns a list of neighbors and their distance
+  def neighbors(location)
+    x = location.x
+    y = location.y
+    [
+      TwoDGridLocation.new(x-1, y-1),
+      TwoDGridLocation.new(x-1, y+1),
+      TwoDGridLocation.new(x+1, y-1),
+      TwoDGridLocation.new(x+1, y+1),
+      TwoDGridLocation.new(x-1, y),
+      TwoDGridLocation.new(x+1, y),
+      TwoDGridLocation.new(x, y-1),
+      TwoDGridLocation.new(x, y+1)
+    ]
+  end
+  
+  def distance(from,to)
+    h_diagonal = [(from.x-to.x).abs, (from.y-to.y).abs].min
+    h_straight = ((from.x-to.x).abs + (from.y-to.y).abs)
+    return TRAVEL_COST_DIAG * h_diagonal + TRAVEL_COST_STRAIGHT * (h_straight - 2*h_diagonal)
+  end
+  
+  # return the cost to go from => to (assuming from and to are neighbors)
+  def cost(from, to)
+    if from.x == to.x or from.y == to.y
+      if from.x == to.x and from.y == to.y
+        0
+      else
+        TRAVEL_COST_STRAIGHT
+      end
+    else
+      TRAVEL_COST_DIAG
+    end
+  end
+end

data/lib/gamebox/aliasing.rb

@@ -0,0 +1,16 @@
+class Module
+  # Encapsulates the common pattern of:
+  #
+  #   alias_method :foo_without_feature, :foo
+  #   alias_method :foo, :foo_with_feature
+  #
+  # With this, you simply do:
+  #
+  #   alias_method_chain :foo, :feature
+  #
+  # And both aliases are set up for you.
+  def alias_method_chain(target, feature)
+    alias_method "#{target}_without_#{feature}", target
+    alias_method target, "#{target}_with_#{feature}"
+  end
+end

data/lib/gamebox/animated.rb

@@ -0,0 +1,84 @@
+require 'behavior'
+# keeps track of an image for you based on the actor's class, and
+# current action, and frame num
+# by default it expects images to be:
+# data/graphics/classname/action/01..n.png
+class Animated < Behavior
+  FRAME_UPDATE_TIME = 60
+
+  attr_accessor :frame_time, :frame_num, :animating
+  def setup
+    @images = {}
+    @frame_time = 0
+    
+    # all animated actors have to have an idle animation
+    # data/graphics/ship/idle/1.png
+    @frame_num = 0
+    self.action = :idle
+
+    animated_obj = self
+
+    @actor.instance_eval do
+      (class << self; self; end).class_eval do
+        define_method :image do 
+          animated_obj.image
+        end
+        define_method :start_animating do
+          animated_obj.start_animating
+        end
+        define_method :stop_animating do
+          animated_obj.stop_animating
+        end
+        define_method :action= do |action_sym|
+          animated_obj.action = action_sym
+        end
+        define_method :animated do 
+          animated_obj
+        end
+      end
+    end
+
+  end
+
+  def update(time)
+    return unless @animating
+    @frame_time += time
+    if @frame_time > FRAME_UPDATE_TIME
+      next_frame
+      @frame_time = @frame_time-FRAME_UPDATE_TIME
+    end
+  end
+
+  def next_frame()
+    @frame_num = (@frame_num + 1) % @images[@action].size
+  end
+
+  # load all the images for this action
+  def load_action(action)
+    @actor.resource_manager.load_animation_set @actor, action 
+  end
+
+  def action=(new_action)
+    @images[new_action] ||= load_action(new_action)
+    if @images[new_action].size > 1
+      start_animating
+    else
+      stop_animating
+    end
+    @frame_num = 0
+    @action = new_action
+  end
+
+  # returns the current image, or nil if no action is defined
+  def image
+    @images[@action][@frame_num]
+  end
+
+  def start_animating
+    @animating = true
+  end
+
+  def stop_animating
+    @animating = false
+  end
+end