game_2d 0.0.2 → 0.0.3

data/lib/game_2d/entity/base.rb

@@ -0,0 +1,38 @@
+require 'game_2d/entity'
+require 'game_2d/player'
+require 'game_2d/entity/ghost'
+
+class Entity
+
+class Base < Entity
+  def should_fall?; underfoot.empty?; end
+
+  def update
+    if should_fall?
+      self.a = (direction || 180) + 180
+    else
+      slow_by 1
+    end
+    super
+  end
+
+  def available?
+    return false unless space
+
+    # Can't use entity.entities_obstructing() here, as that only
+    # returns objects opaque to the receiver (the base).  Players
+    # aren't opaque to bases.  We need to ensure there are no
+    # solid (non-ghost) players occupying the space.
+    #
+    # This logic depends on the fact that anything transparent
+    # to a base is also transparent to a player.  If we ever allow
+    # a base to go somewhere a player can't be, that's a problem.
+    space.entities_overlapping(x, y).find_all do |e|
+      e.is_a?(Player) && !e.is_a?(Entity::Ghost)
+    end.empty?
+  end
+
+  def image_filename; "base.png"; end
+end
+
+end

data/lib/game_2d/entity/block.rb

@@ -26,9 +26,9 @@ class Block < OwnedEntity
       when 0
         true
       when 1
-        empty_on_left? || empty_on_right?
+        !(supported_on_left && supported_on_right)
       when 2
-        empty_on_left? && empty_on_right?
+        !(supported_on_left || supported_on_right)
       when 3
         empty_on_left? && empty_on_right? && empty_above?
       when 4
@@ -36,18 +36,87 @@ class Block < OwnedEntity
     end
   end
 
+  def supported_on_left
+    opaque(space.entities_exactly_at_point(x - WIDTH, y)).any?
+  end
+
+  def supported_on_right
+    right_support = opaque(space.entities_exactly_at_point(x + WIDTH, y)).any?
+  end
+
   def update
     if should_fall?
-      accelerate(0, 1)
+      # applies acceleration, but that's all
+      space.fall(self)
     else
       self.x_vel = self.y_vel = 0
     end
+    # Reduce velocity if necessary, to exactly line up with
+    # an upcoming source of support (so we don't move past it)
+    if x_vel == 0 && y_vel != 0
+      case level
+        when 1
+          new_y = look_ahead_for_support_both_sides
+          self.y_vel = new_y - y if new_y
+        when 2
+          new_y = look_ahead_for_support_either_side
+          self.y_vel = new_y - y if new_y
+      end
+    end
+
     move
   end
 
-  def harmed_by(other)
-    puts "#{self}: Ouch!"
-    self.hp -= 1
+  # Need a source of support at the exact same
+  # height on both sides
+  def look_ahead_for_support_both_sides
+    look_ahead_for_support do |left, right|
+      left & right
+    end
+  end
+
+  # Any source of support will do, either side
+  # or both
+  def look_ahead_for_support_either_side
+    look_ahead_for_support do |left, right|
+      left + right
+    end
+  end
+
+  # Find the highest (if dropping) or lowest (if rising) height that meets
+  # the requirements for support
+  def look_ahead_for_support
+    support_heights = yield *possible_sources_of_support
+
+    (y_vel > 0) ? support_heights.min : support_heights.max
+  end
+
+  # Sources of support must intersect with the points next
+  # to us, and be:
+  # - Level with our lower edge, if dropping
+  # - A point above our upper edge, if rising
+  # - Close enough that our current velocity will
+  # take us past that point during this tick
+  #
+  # This just returns the heights at which we might find support
+  def possible_sources_of_support
+    target_height = if y_vel > 0 # dropping
+      y + HEIGHT - 1
+    else # rising
+      y - 1
+    end
+
+    left_support = opaque(space.entities_at_point(x - 1, target_height)).collect(&:y)
+    right_support = opaque(space.entities_at_point(x + WIDTH, target_height)).collect(&:y)
+
+    # Filter out heights we aren't going to reach this tick with
+    # our current velocity
+    not_too_far = lambda {|its_y| (its_y - y).abs <= y_vel.abs }
+    [left_support.find_all(&not_too_far), right_support.find_all(&not_too_far)]
+  end
+
+  def harmed_by(other, damage=1)
+    self.hp -= damage
     @space.doom(self) if hp <= 0
   end
 

data/lib/game_2d/entity/destination.rb

@@ -6,12 +6,18 @@ class Destination < OwnedEntity
 
   def should_fall?; false; end
 
+  def teleportable?; false; end
+
   def update; end
 
   def image_filename; "destination.png"; end
 
   def draw_zorder; ZOrder::Destination; end
   def draw_angle; space.game.tick % 360; end
+
+  def destroy!
+    space.doom owner
+  end
 end
 
 end

data/lib/game_2d/entity/gecko.rb

@@ -0,0 +1,237 @@
+require 'facets/kernel/try'
+require 'game_2d/entity'
+require 'game_2d/entity/pellet'
+require 'game_2d/entity/block'
+require 'game_2d/move/rise_up'
+require 'game_2d/player'
+
+# A player object that can stick to walls and slide around corners
+# Calling update() causes a move to be dequeued and executed, applying forces
+# to the game object
+class Entity
+
+class Gecko < Entity
+  include Player
+  include Comparable
+
+  MAX_HP = 1
+
+  # Game ticks it takes before a block's HP is raised by 1
+  BUILD_TIME = 7
+
+  # Amount to decelerate each tick when braking
+  BRAKE_SPEED = 4
+
+  MOVES_FOR_KEY_HELD = {
+    Gosu::KbLeft         => :slide_left,
+    Gosu::KbA            => :slide_left,
+    Gosu::KbRight        => :slide_right,
+    Gosu::KbD            => :slide_right,
+    Gosu::KbRightControl => :brake,
+    Gosu::KbLeftControl  => :brake,
+    Gosu::KbDown         => :build,
+    Gosu::KbS            => :build,
+  }
+
+  attr_reader :hp, :build_block_id
+
+  def initialize(player_name = "<unknown>")
+    super
+    initialize_player
+    @player_name = player_name
+    @score = 0
+    @hp = MAX_HP
+    @build_block_id = nil
+    @build_level = 0
+  end
+
+  def hp=(p); @hp = [[p, MAX_HP].min, 0].max; end
+
+  def sleep_now?; false; end
+
+  def should_fall?; 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 harmed_by(other, damage=1)
+    self.hp -= damage
+    die if hp <= 0
+  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
+
+    return if perform_complex_move
+
+    if falling = should_fall?
+      self.a = 0
+      space.fall(self)
+    end
+
+    args = next_move
+    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
+
+    # Only go around corner if sitting on exactly one object
+    blocks_underfoot = underfoot
+    if blocks_underfoot.size == 1
+      # Slide around if we're at the corner; otherwise, move normally
+      slide_around(blocks_underfoot.first) or move
+    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; slow_by 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
+      if @space << bb # generates an ID
+        @build_block_id = bb.registry_id
+        @build_level = 0
+      end
+    end
+  end
+
+  def disown_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
+    self.complex_move = Move::RiseUp.new(self)
+  end
+
+  # Called by GameWindow
+  # Should return the move to be sent via ClientConnection
+  # (or nil)
+  def generate_move_from_click(x, y)
+    if y < cy # Firing up
+      y_vel = -Math.sqrt(2 * (cy - y)).round
+      x_vel = (cx - x) / y_vel
+    else
+      y_vel = 0
+      if y == cy
+        return if x == cx
+        x_vel = (x <=> cx) * MAX_VELOCITY
+      else
+        range = x - cx
+        x_vel = (Math.sqrt(1.0 / (2.0 * (y - cy))) * range).round
+      end
+    end
+    [:fire, {:x_vel => x_vel, :y_vel => y_vel}]
+  end
+
+  # Called by GameWindow
+  # Should return the move to be sent via ClientConnection
+  # (or nil)
+  # This is for queued keypresses, i.e. those that happen
+  # on key-down only (just once for a press), not continuously
+  # for as long as held down
+  def move_for_keypress(keypress)
+    case keypress
+      when Gosu::KbUp, Gosu::KbW
+        return building? ? :rise_up : :flip
+    end
+  end
+
+  # Called by GameWindow
+  # Should return a map where the keys are... keys, and the
+  # values are the corresponding moves to be sent via
+  # ClientConnection
+  # This is for non-queued keypresses, i.e. those that happen
+  # continuously for as long as held down
+  def moves_for_key_held
+    MOVES_FOR_KEY_HELD
+  end
+
+  def all_state
+    # Player name goes first, so we can sort on that
+    super.unshift(player_name).push(
+      score, @hp, build_block_id, @complex_move)
+  end
+
+  def as_json
+    super.merge!(
+      :player_name => player_name,
+      :score => score,
+      :hp => @hp,
+      :build_block => @build_block_id,
+      :complex_move => @complex_move.as_json
+    )
+  end
+
+  def update_from_json(json)
+    @player_name = json[:player_name] if json[:player_name]
+    @score = json[:score] if json[:score]
+    @hp = json[:hp] if json[:hp]
+    @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
+  end
+
+  def image_filename; "gecko.png"; end
+end
+
+end

data/lib/game_2d/entity/ghost.rb

@@ -0,0 +1,126 @@
+require 'game_2d/entity'
+require 'game_2d/move/spawn'
+require 'game_2d/player'
+
+# A player object that represents the player when between corporeal
+# incarnations
+#
+# Ghost can fly around and look at things, but can't touch or affect
+# anything
+class Entity
+
+class Ghost < Entity
+  include Player
+  include Comparable
+
+  MOVES_FOR_KEY_HELD = {
+    Gosu::KbLeft  => :left,
+    Gosu::KbA     => :left,
+    Gosu::KbRight => :right,
+    Gosu::KbD     => :right,
+    Gosu::KbUp    => :up,
+    Gosu::KbW     => :up,
+    Gosu::KbDown  => :down,
+    Gosu::KbS     => :down,
+  }
+
+  def initialize(player_name = "<unknown>")
+    super
+    initialize_player
+    @player_name = player_name
+    @score = 0
+  end
+
+  def sleep_now?; false; end
+
+  def should_fall?; false; end
+
+  def teleportable?; false; end
+
+  def update
+    fail "No space set for #{self}" unless @space
+
+    return if perform_complex_move
+
+    if args = next_move
+      case (current_move = args.delete(:move).to_sym)
+        when :left, :right, :up, :down
+          send current_move
+        when :spawn
+          spawn args[:x], args[:y]
+        else
+          puts "Invalid move for #{self}: #{current_move}, #{args.inspect}"
+      end
+    else
+      slow_by 1
+    end
+    super
+  end
+
+  def left; accelerate(-1, 0); end
+  def right; accelerate(1, 0); end
+  def up; accelerate(0, -1); end
+  def down; accelerate(0, 1); end
+
+  def spawn(x, y)
+    if base = @space.available_base_near(x, y)
+      warn "#{self} spawning at #{base.x}, #{base.y}"
+      self.complex_move = Move::Spawn.new
+      self.complex_move.target_id = base.registry_id
+    end
+  end
+
+  # Called by GameWindow
+  # Should return a map where the keys are... keys, and the
+  # values are the corresponding moves to be sent via
+  # ClientConnection
+  # This is for non-queued keypresses, i.e. those that happen
+  # continuously for as long as held down
+  def moves_for_key_held
+    MOVES_FOR_KEY_HELD
+  end
+
+  # Called by GameWindow
+  # Should return the move to be sent via ClientConnection
+  # (or nil)
+  # This is for queued keypresses, i.e. those that happen
+  # on key-down only (just once for a press), not continuously
+  # for as long as held down
+  def move_for_keypress(keypress); nil; end
+
+  # Called by GameWindow
+  # Should return the move to be sent via ClientConnection
+  # (or nil)
+  def generate_move_from_click(x, y)
+    [:spawn, {:x => x, :y => y}]
+  end
+
+  def all_state
+    # Player name goes first, so we can sort on that
+    super.unshift(player_name).push(score, @complex_move)
+  end
+
+  def as_json
+    super.merge!(
+      :player_name => player_name,
+      :score => score,
+      :complex_move => @complex_move.as_json
+    )
+  end
+
+  def update_from_json(json)
+    @player_name = json[:player_name] if json[:player_name]
+    @score = json[:score] if json[:score]
+    @complex_move = Serializable.from_json(json[:complex_move]) if json[:complex_move]
+    super
+  end
+
+  def image_filename; "ghost.png"; end
+
+  def draw_image(anim)
+    # Usually frame 0, occasionally frame 1
+    anim[((Gosu::milliseconds / 100) % 63) / 62]
+  end
+end
+
+end