game_2d 0.0.2 → 0.0.3

data/lib/game_2d/game_space.rb

@@ -3,9 +3,10 @@ require 'delegate'
 require 'set'
 require 'facets/kernel/try'
 require 'game_2d/wall'
-require 'game_2d/player'
+require 'game_2d/entity/gecko'
 require 'game_2d/serializable'
 require 'game_2d/entity_constants'
+require 'game_2d/entity/base'
 require 'game_2d/entity/owned_entity'
 
 # Common code between the server and client for maintaining the world.
@@ -34,11 +35,12 @@ require 'game_2d/entity/owned_entity'
 class Cell < DelegateClass(Array)
   attr_reader :x, :y
 
+  SORT_BY_REGISTRY = ->(a,b) { a.registry_id <=> b.registry_id }
   def ==(other)
     other.class.equal?(self.class) &&
       other.x == self.x &&
       other.y == self.y &&
-      other.instance_variable_get(:@a) == @a
+      other.instance_variable_get(:@a).sort(&SORT_BY_REGISTRY) == @a.sort(&SORT_BY_REGISTRY)
   end
 
   def initialize(cell_x, cell_y)
@@ -78,6 +80,8 @@ class GameSpace
 
     @players = []
     @npcs = []
+    @bases = []
+    @gravities = []
   end
 
   # Width and height, measured in cells
@@ -122,7 +126,7 @@ class GameSpace
     @game, @storage = original.game, original.storage
 
     # Registry should contain all objects - clone those
-    original.all_registered.each {|ent| self << ent.clone }
+    original.all_registered.each {|ent| add_entity ent.clone }
 
     self
   end
@@ -161,6 +165,9 @@ class GameSpace
   def width; @cell_width * WIDTH; end
   def height; @cell_height * HEIGHT; end
 
+  # Where to place an entity if you want it dead-center
+  def center; [(width - Entity::WIDTH) / 2, (height - Entity::HEIGHT) / 2]; end
+
   def next_id
     "R#{@highest_id += 1}".to_sym
   end
@@ -202,6 +209,8 @@ class GameSpace
     @registry[reg_id] = entity
     entity_list(entity) << entity
     register_with_owner(entity)
+    register_gravity(entity)
+    register_base(entity)
     nil
   end
 
@@ -214,6 +223,8 @@ class GameSpace
 
   def deregister(entity)
     fail "#{entity} not registered" unless registered?(entity)
+    deregister_base(entity)
+    deregister_gravity(entity)
     deregister_ownership(entity)
     entity_list(entity).delete entity
     @registry.delete entity.registry_id
@@ -231,6 +242,40 @@ class GameSpace
     @ownership.delete entity.registry_id
   end
 
+  def register_gravity(entity)
+    return unless entity.respond_to? :apply_gravity_to?
+    @gravities.unshift entity.registry_id
+  end
+
+  def register_base(entity)
+    return unless entity.is_a? Entity::Base
+    @bases.unshift entity.registry_id
+  end
+
+  def deregister_gravity(entity)
+    @gravities.delete entity.registry_id
+  end
+
+  def deregister_base(entity)
+    @bases.delete entity.registry_id
+  end
+
+  # Return a list of available bases, for a player to (re)spawn
+  def available_bases
+    @bases.collect {|id| self[id] }.find_all(&:available?)
+  end
+
+  # Return a "randomly" chosen available base, or nil
+  def available_base
+    choices = available_bases
+    choices.empty? ? nil : choices[game.tick % choices.size]
+  end
+
+  # Return the available base closest to the coordinates, or nil
+  def available_base_near(x, y)
+    nearest_to(available_bases, x, y)
+  end
+
   def owner_change(owned_id, old_owner_id, new_owner_id)
     return unless owned_id
     return if old_owner_id == new_owner_id
@@ -292,7 +337,18 @@ class GameSpace
     ]
   end
 
-  # Return a list of the entities (if any) at a subpixel point (X, Y)
+  # Return a list of the entities (if any) exactly at
+  # the subpixel point (X, Y).  That is, the point is
+  # the entity's upper-left corner
+  def entities_exactly_at_point(x, y)
+    at(*cell_location_at_point(x, y)).find_all do |e|
+      e.x == x && e.y == y
+    end
+  end
+
+  # Return a list of the entities (if any) intersecting with
+  # the subpixel point (X, Y).  That is, the point falls
+  # somewhere within the entity
   def entities_at_point(x, y)
     at(*cell_location_at_point(x, y)).find_all do |e|
       e.x <= x && e.x > (x - WIDTH) &&
@@ -300,15 +356,26 @@ class GameSpace
     end
   end
 
+  def distance_between(x1, y1, x2, y2)
+    delta_x = (x1 - x2).abs
+    delta_y = (y1 - y2).abs
+    Math.sqrt(delta_x**2 + delta_y**2)
+  end
+
+  # Consider a given list of entities
+  # Return whichever entity's center is closest (or ties for closest)
+  # to the given coordinates
+  def nearest_to(entities, x, y)
+    entities.collect do |entity|
+      [distance_between(entity.cx, entity.cy, x, y), entity]
+    end.sort {|(d1, e1), (d2, e2)| d1 <=> d2}.first.try(:last)
+  end
+
+  # Consider all entities intersecting with (x, y)
   # Return whichever entity's center is closest (or ties for closest)
   def near_to(x, y)
     entities_at_point(x, y).collect do |entity|
-      center_x = entity.x + WIDTH/2
-      center_y = entity.y + HEIGHT/2
-      delta_x = (center_x - x).abs
-      delta_y = (center_y - y).abs
-      distance = Math.sqrt(delta_x**2 + delta_y**2)
-      [distance, entity]
+      [distance_between(entity.cx, entity.cy, x, y), entity]
     end.sort {|(d1, e1), (d2, e2)| d1 <=> d2}.first.try(:last)
   end
 
@@ -402,6 +469,16 @@ class GameSpace
     moved
   end
 
+  # Add the entity to the grid, and register it
+  # For use only during copies and registry syncs -- some
+  # checks are skipped, and neighbors aren't woken up
+  def add_entity(entity)
+    entity.space = self
+    register(entity)
+    add_entity_to_grid(entity)
+    entity
+  end
+
   # Add an entity.  Will wake neighboring entities
   def <<(entity)
     entity.registry_id = next_id unless entity.registry_id?
@@ -412,20 +489,18 @@ class GameSpace
     entity.space = self
     conflicts = entity.entities_obstructing(entity.x, entity.y)
     if conflicts.empty?
-      register(entity)
-      add_entity_to_grid(entity)
       entities_bordering_entity_at(entity.x, entity.y).each(&:wake!)
-      entity
+      add_entity(entity)
     else
       entity.space = nil
       # TODO: Convey error to user somehow
-      $stderr.puts "Can't create #{entity}, occupied by #{conflicts.inspect}"
+      warn "Can't create #{entity}, occupied by #{conflicts.inspect}"
     end
   end
 
   def snap_to_grid(entity_id)
     unless entity = self[entity_id]
-      $stderr.puts "Can't snap #{entity_id}, doesn't exist"
+      warn "Can't snap #{entity_id}, doesn't exist"
       return
     end
 
@@ -443,11 +518,21 @@ class GameSpace
         return
       end
     end
-    $stderr.puts "Couldn't snap #{entity} to grid"
+    warn "Couldn't snap #{entity} to grid"
+  end
+
+  def fall(entity)
+    return if @gravities.find {|g| self[g].apply_gravity_to?(entity)}
+    entity.accelerate(0, 1)
   end
 
   # Doom an entity (mark it to be deleted but don't remove it yet)
-  def doom(entity); @doomed << entity; end
+  def doom(entity)
+    return unless entity && registered?(entity)
+    return if doomed?(entity)
+    @doomed << entity
+    entity.destroy!
+  end
 
   def doomed?(entity); @doomed.include?(entity); end
 
@@ -459,10 +544,9 @@ class GameSpace
   def purge_doomed_entities
     @doomed.each do |entity|
       if registered?(entity)
-        entity.destroy!
-        deregister(entity)
-        entities_bordering_entity_at(entity.x, entity.y).each(&:wake!)
         remove_entity_from_grid(entity)
+        entities_bordering_entity_at(entity.x, entity.y).each(&:wake!)
+        deregister(entity)
       else
         fire_entity_not_found(entity)
       end
@@ -471,15 +555,22 @@ class GameSpace
   end
 
   def update
+    grabbed_entities = []
     @registry.values.each do |ent|
       if ent.grabbed?
-        ent.move
-        ent.release!
-        ent.x_vel = ent.y_vel = 0
+        grabbed_entities << ent
       elsif ent.moving?
         ent.update
       end
     end
+    # Update these, and clear their flag, last
+    # Gives other entities (e.g. teleporters) a chance to
+    # consider their grabbed-state
+    grabbed_entities.each do |ent|
+      ent.move
+      ent.release!
+      ent.x_vel = ent.y_vel = 0
+    end
     purge_doomed_entities
   end
 

data/lib/game_2d/game_window.rb

@@ -43,9 +43,9 @@ class GameWindow < Gosu::Window
       ZOrder::Cursor,
       1, 1, Gosu::Color::WHITE, :add)
 
-    return unless @player_id
+    return unless p = player
 
-    @camera_x, @camera_y = space.good_camera_position_for(player, SCREEN_WIDTH, SCREEN_HEIGHT)
+    @camera_x, @camera_y = space.good_camera_position_for(p, SCREEN_WIDTH, SCREEN_HEIGHT)
     translate(-@camera_x, -@camera_y) do
       (space.players + space.npcs).each {|entity| entity.draw(self) }
     end

data/lib/game_2d/move/spawn.rb

@@ -0,0 +1,67 @@
+require 'game_2d/complex_move'
+require 'game_2d/game_client'
+require 'game_2d/entity_constants'
+require 'game_2d/entity/gecko'
+
+module Move
+
+# A move for ghosts.
+class Spawn < ComplexMove
+  include EntityConstants
+
+  SPAWN_TRAVEL_SPEED = 80
+
+  # target_id is registry_id of selected base
+  attr_accessor :target_id
+
+  def on_completion(actor)
+    space = actor.space
+    target = space[target_id]
+    return unless target && target.available?
+
+    gecko = Entity::Gecko.new(actor.player_name)
+    gecko.score = actor.score
+    gecko.x, gecko.y, gecko.a = target.x, target.y, target.a
+    return unless space << gecko
+
+    actor.replace_player_entity(gecko)
+  end
+
+  def update(actor)
+    # It's convenient to set 'self' to the Player
+    # object, here
+    actor.instance_exec(self) do |cm|
+      # Abort if the target gets destroyed, or becomes
+      # occupied
+      target = space[cm.target_id]
+      return false unless target && target.available?
+
+      # We're done
+      if x == target.x && y == target.y
+        @x_vel = @y_vel = 0
+        return false
+      end
+
+      @x_vel = [[target.x - x, -SPAWN_TRAVEL_SPEED].max, SPAWN_TRAVEL_SPEED].min
+      @y_vel = [[target.y - y, -SPAWN_TRAVEL_SPEED].max, SPAWN_TRAVEL_SPEED].min
+      # move returns false: it failed somehow
+      return move
+    end
+  end
+
+  def all_state
+    super.push @target_id
+  end
+  def as_json
+    super.merge! :target => @target_id
+  end
+  def update_from_json(json)
+    self.target_id = json[:target].to_sym if json[:target]
+    super
+  end
+  def to_s
+    "Spawn[#{target_id}]"
+  end
+end
+
+end

data/lib/game_2d/player.rb

@@ -1,205 +1,32 @@
-require 'facets/kernel/try'
 require 'gosu'
-require 'game_2d/entity'
-require 'game_2d/entity/pellet'
-require 'game_2d/entity/block'
-require 'game_2d/move/rise_up'
+require 'game_2d/entity_constants'
 require 'game_2d/zorder'
 
-# The base Player class representing what all Players have in common
+# The base module representing what all Players have in common
 # Moves can be enqueued by calling add_move
-# Calling update() causes a move to be dequeued and executed, applying forces
-# to the game object
-#
-# The server instantiates this class to represent each connected player
-class Player < Entity
-  include Comparable
+# The server instantiates classes that mix in this module, to
+# represent each connected player
+module Player
+  include EntityConstants
 
-  # Game ticks it takes before a block's HP is raised by 1
-  BUILD_TIME = 7
+  attr_accessor :player_name, :score, :complex_move
 
-  # Amount to decelerate each tick when braking
-  BRAKE_SPEED = 4
-
-  attr_accessor :player_name, :score
-  attr_reader :build_block_id
-
-  def initialize(player_name = "<unknown>")
-    super
-    @player_name = player_name
-    @score = 0
+  def initialize_player
     @moves = []
-    @current_move = nil
-    @build_block_id = nil
-    @build_level = 0
     @complex_move = nil
   end
 
-  def sleep_now?; false; end
-
-  def underfoot
-    opaque(next_to(self.a + 180))
-  end
-  def falling?
-    underfoot.empty?
-  end
-
-  def build_block_id=(new_id)
-    @build_block_id = new_id.try(:to_sym)
-  end
-
-  def building?; @build_block_id; end
-
-  def build_block
-    return nil unless building?
-    fail "Can't look up build_block when not in a space" unless @space
-    @space[@build_block_id] or fail "Don't have build_block #{@build_block_id}"
-  end
-
-  def destroy!
-    build_block.owner_id = nil if building?
-  end
-
-  def update
-    fail "No space set for #{self}" unless @space
-    check_for_disown_block
-
-    if @complex_move
-      # returns true if more work to do
-      return if @complex_move.update(self)
-      @complex_move.on_completion(self)
-      @complex_move = nil
-    end
-
-    if falling = falling?
-      self.a = 0
-      accelerate(0, 1)
-    end
-
-    args = @moves.shift
-    case (current_move = args.delete(:move).to_sym)
-      when :slide_left, :slide_right, :brake, :flip, :build, :rise_up
-        send current_move unless falling
-      when :fire
-        fire args[:x_vel], args[:y_vel]
-      else
-        puts "Invalid move for #{self}: #{current_move}, #{args.inspect}"
-    end if args
+  # Returns true if a complex move is in process, and took
+  # some action
+  # Returns nil if the complex move completed, or there isn't one
+  def perform_complex_move
+    return unless @complex_move
 
-    # Only go around corner if sitting on exactly one object
-    blocks_underfoot = underfoot
-    if blocks_underfoot.size == 1
-      other = blocks_underfoot.first
-      # Figure out where corner is and whether we're about to reach or pass it
-      corner, distance, overshoot, turn = going_past_entity(other.x, other.y)
-      if corner
-        original_speed = @x_vel.abs + @y_vel.abs
-        original_dir = vector_to_angle
-        new_dir = original_dir + turn
+    # returns true if more work to do
+    return true if @complex_move.update(self)
 
-        # Make sure nothing occupies any space we're about to move through
-        if opaque(
-          @space.entities_overlapping(*corner) + next_to(new_dir, *corner)
-        ).empty?
-          # Move to the corner
-          self.x_vel, self.y_vel = angle_to_vector(original_dir, distance)
-          move
-
-          # Turn and apply remaining velocity
-          # Make sure we move at least one subpixel so we don't sit exactly at
-          # the corner, and fall
-          self.a += turn
-          overshoot = 1 if overshoot.zero?
-          self.x_vel, self.y_vel = angle_to_vector(new_dir, overshoot)
-          move
-
-          self.x_vel, self.y_vel = angle_to_vector(new_dir, original_speed)
-        else
-          # Something's in the way -- possibly in front of us, or possibly
-          # around the corner
-          move
-        end
-      else
-        # Not yet reaching the corner -- or making a diagonal motion, for which
-        # we can't support going around the corner
-        move
-      end
-    else
-      # Straddling two objects, or falling
-      move
-    end
-
-    # Check again whether we've moved off of a block
-    # we were building
-    check_for_disown_block
-  end
-
-  def slide_left; slide(self.a - 90); end
-  def slide_right; slide(self.a + 90); end
-
-  def slide(dir)
-    if opaque(next_to(dir)).empty?
-      accelerate(*angle_to_vector(dir))
-    else
-      self.a = dir + 180
-    end
-  end
-
-  def brake
-    if @x_vel.zero?
-      self.y_vel = brake_velocity(@y_vel)
-    else
-      self.x_vel = brake_velocity(@x_vel)
-    end
-  end
-
-  def brake_velocity(v)
-    return 0 if v.abs < BRAKE_SPEED
-    sign = v <=> 0
-    sign * (v.abs - BRAKE_SPEED)
-  end
-
-  def flip
-    self.a += 180
-  end
-
-  # Create the actual pellet
-  def fire(x_vel, y_vel)
-    pellet = Entity::Pellet.new(@x, @y, 0, x_vel, y_vel)
-    pellet.owner = self
-    @space << pellet
-  end
-
-  # Create the actual block
-  def build
-    if building?
-      @build_level += 1
-      if @build_level >= BUILD_TIME
-        @build_level = 0
-        build_block.hp += 1
-      end
-    else
-      bb = Entity::Block.new(@x, @y)
-      bb.owner_id = registry_id
-      bb.hp = 1
-      @space << bb # generates an ID
-      @build_block_id = bb.registry_id
-      @build_level = 0
-    end
-  end
-
-  def disown_block; $stderr.puts "#{self} disowning #{build_block}"; @build_block_id, @build_level = nil, 0; end
-
-  def check_for_disown_block
-    return unless building?
-    return if @space.entities_overlapping(@x, @y).include?(build_block)
-    build_block.owner_id = nil
-    build_block.wake!
-    disown_block
-  end
-
-  def rise_up
-    @complex_move = Move::RiseUp.new(self)
+    @complex_move.on_completion(self)
+    @complex_move = nil
   end
 
   # Accepts a hash, with a key :move => move_type
@@ -208,34 +35,26 @@ class Player < Entity
     @moves << new_move
   end
 
-  def to_s
-    "#{player_name} (#{registry_id_safe}) at #{x}x#{y}"
-  end
+  def next_move; @moves.shift; end
 
-  def all_state
-    super.unshift(player_name).push(
-      score, build_block_id, @complex_move)
+  def replace_player_entity(new_entity)
+    if (game = space.game).is_a? GameClient
+      game.player_id = new_entity.registry_id if game.player_id == registry_id
+    else
+      game.replace_player_entity(player_name, new_entity.registry_id)
+    end
+    space.doom(self)
   end
 
-  def as_json
-    super.merge!(
-      :player_name => player_name,
-      :score => score,
-      :build_block => @build_block_id,
-      :complex_move => @complex_move.as_json
-    )
-  end
+  def die
+    ghost = Entity::Ghost.new(player_name)
+    ghost.x, ghost.y, ghost.a, ghost.x_vel, ghost.y_vel, ghost.score =
+      x, y, 0, x_vel, y_vel, score
+    return unless space << ghost # coast to coast
 
-  def update_from_json(json)
-    @player_name = json[:player_name] if json[:player_name]
-    @score = json[:score] if json[:score]
-    @build_block_id = json[:build_block].try(:to_sym) if json[:build_block]
-    @complex_move = Serializable.from_json(json[:complex_move]) if json[:complex_move]
-    super
+    replace_player_entity ghost
   end
 
-  def image_filename; "player.png"; end
-
   def draw_zorder; ZOrder::Player end
 
   def draw(window)
@@ -245,4 +64,8 @@ class Player < Entity
       0.5, 1.0, # Centered X; above Y
       1.0, 1.0, Gosu::Color::YELLOW)
   end
-end
+
+  def to_s
+    "#{player_name} (#{self.class.name} #{registry_id_safe}) at #{x}x#{y}"
+  end
+end