game_2d 0.0.2 → 0.0.3

data/lib/game_2d/entity/hole.rb

@@ -0,0 +1,32 @@
+require 'game_2d/entity'
+
+class Entity
+
+class Hole < Entity
+  def should_fall?; false; end
+
+  def apply_gravity_to?(entity)
+    distance = space.distance_between(cx, cy, entity.cx, entity.cy)
+    entity.harmed_by(self, (400 - distance).ceil) if distance < 400
+    force = 10000000.0 / (distance**2)
+    return true if force > 200.0
+    return false if force < 1.0
+    # We could use trig here -- but we have a shortcut.
+    # We know the X/Y proportions of the force must be
+    # the same as the X/Y proportions of the distance.
+    delta_x = cx - entity.cx
+    delta_y = cy - entity.cy
+    force_x = force * (delta_x / distance)
+    force_y = force * (delta_y / distance)
+    entity.accelerate(force_x.truncate, force_y.truncate)
+    true
+  end
+
+  def update; end
+
+  def image_filename; "hole.png"; end
+
+  def draw_zorder; ZOrder::Teleporter end
+end
+
+end

data/lib/game_2d/entity/pellet.rb

@@ -7,7 +7,7 @@ class Pellet < OwnedEntity
   def should_fall?; true end
   def sleep_now?; false end
 
-  def i_hit(others)
+  def i_hit(others, velocity)
     puts "#{self}: hit #{others.inspect}.  That's all for me."
     others.each {|other| other.harmed_by(self)}
     @space.doom(self)

data/lib/game_2d/entity/slime.rb

@@ -0,0 +1,121 @@
+require 'game_2d/entity/owned_entity'
+
+class Entity
+
+# Slime is like a lemming(tm): it either falls, or it walks left
+# or right until forced to reverse direction
+#
+# As it comes into contact with other entities, it gradually
+# increments its slime_count, until it maxes out.  Then it harms
+# whatever it just touched, and resets the count
+class Slime < Entity
+  MAX_HP = 8
+  MAX_SPEED = 18
+  SLEEP_AMOUNT = 180
+  MAX_SLIME_COUNT = 100
+
+  attr_reader :hp, :sleep_count, :slime_count
+
+  def initialize
+    super
+    self.a = 270
+    @hp, @sleep_count, @slime_count = MAX_HP, 0, 0
+  end
+
+  def hp=(p); @hp = [[p, MAX_HP].min, 0].max; end
+
+  def all_state; super.push(hp, sleep_count, slime_count); end
+  def as_json
+    super.merge(
+      :hp => hp,
+      :sleep_count => @sleep_count,
+      :slime_count => @slime_count
+    )
+  end
+
+  def update_from_json(json)
+    self.hp = json[:hp] if json[:hp]
+    @sleep_count = json[:sleep_count] if json[:sleep_count]
+    @slime_count = json[:slime_count] if json[:slime_count]
+    super
+  end
+
+  def should_fall?; empty_underneath?; end
+
+  def trapped?; !(empty_on_left? || empty_on_right?); end
+
+  def sleep_now?; false; end
+
+  def update
+    if should_fall?
+      self.x_vel = @sleep_count = 0
+      space.fall(self)
+      move
+    elsif @sleep_count.zero?
+      slime_them(beneath, 1)
+      if trapped?
+        self.a += 180
+        slime_them((a == 270) ? on_left : on_right, 1)
+        @sleep_count = SLEEP_AMOUNT
+      else
+        self.y_vel = 0
+        accelerate((a == 270) ? -1 : 1, nil, MAX_SPEED)
+        advance
+      end
+    else
+      @sleep_count -= 1
+    end
+  end
+
+  def advance
+    blocks_underfoot = beneath
+    if blocks_underfoot.size == 1
+      # Slide around if we're at the corner; otherwise, move normally
+      # Don't allow slide_around() to adjust our angle
+      slide_around(blocks_underfoot.first, false) or move or turn_around
+    else
+      # Straddling two objects, or falling
+      move or turn_around
+    end
+  end
+
+  def turn_around; self.a += 180; end
+
+  def i_hit(others, velocity)
+    slime_them(others, velocity)
+  end
+
+  def slime_them(others, increment)
+    @slime_count += increment
+    if @slime_count > MAX_SLIME_COUNT
+      @slime_count -= MAX_SLIME_COUNT
+      others.each {|o| o.harmed_by(self) unless o.is_a? Slime}
+    end
+  end
+
+  def harmed_by(other, damage=1)
+    self.hp -= damage
+    @space.doom(self) if hp <= 0
+  end
+
+  def image_filename; "slime.png"; end
+
+  def draw(window)
+    img = draw_image(draw_animation(window))
+
+    # Default image faces left
+    # We don't rotate the slime; we just flip it horizontally
+    img.draw(
+      self.pixel_x + (a == 90 ? CELL_WIDTH_IN_PIXELS : 0), self.pixel_y, draw_zorder,
+      (a == 90 ? -1 : 1) # X scaling factor
+    )
+    # 0.5, 0.5, # rotate around the center
+    # 1, 1, # scaling factor
+    # @color, # modify color
+    # :add) # draw additively
+  end
+
+  def to_s; "#{super} (#{@hp} HP)"; end
+end
+
+end

data/lib/game_2d/entity/teleporter.rb

@@ -6,9 +6,11 @@ class Entity
 class Teleporter < Entity
   def should_fall?; false; end
 
+  def teleportable?; false; end
+
   def update
     space.entities_overlapping(x, y).each do |overlap|
-      next if overlap == self
+      next unless overlap.teleportable?
       next if (overlap.x - x).abs > WIDTH/2
       next if (overlap.y - y).abs > HEIGHT/2
       dest = space.possessions(self)
@@ -20,15 +22,15 @@ class Teleporter < Entity
             overlap.wake!
           end
         when 0 then
-          $stderr.puts "#{self}: No destination"
+          warn "#{self}: No destination"
         else
-          $stderr.puts "#{self}: Multiple destinations: #{dest.inspect}"
+          warn "#{self}: Multiple destinations: #{dest.inspect}"
       end
     end
   end
 
   def destroy!
-    # destroy destination
+    space.possessions(self).each {|p| space.doom p}
   end
 
   def image_filename; "tele.gif"; end
@@ -36,6 +38,7 @@ class Teleporter < Entity
   def draw_zorder; ZOrder::Teleporter end
 
   def to_s
+    return "#{super} [not in a space]" unless space
     destinations = space.possessions(self).collect do |d|
       "#{d.x}x#{d.y}"
     end.join(', ')

data/lib/game_2d/entity_constants.rb

@@ -9,6 +9,6 @@ module EntityConstants
   # The dimensions of a cell, equals the dimensions of an entity
   WIDTH = HEIGHT = CELL_WIDTH_IN_PIXELS * PIXEL_WIDTH
 
-  # Maximum velocity is a full cell per tick, which is a lot
-  MAX_VELOCITY = WIDTH
+  # Maximum velocity is just shy of a full cell per tick, which is a lot
+  MAX_VELOCITY = WIDTH - 1
 end

data/lib/game_2d/game.rb

@@ -9,7 +9,8 @@ require 'game_2d/server_port'
 require 'game_2d/game_space'
 require 'game_2d/serializable'
 require 'game_2d/entity'
-require 'game_2d/player'
+require 'game_2d/entity/gecko'
+require 'game_2d/entity/ghost'
 
 WORLD_WIDTH = 100 # in cells
 WORLD_HEIGHT = 70 # in cells
@@ -38,6 +39,9 @@ class Game
         nil, # level ID
         args[:width] || WORLD_WIDTH,
         args[:height] || WORLD_HEIGHT)
+
+      @space << Entity::Base.new(*@space.center)
+
       @space.storage = level_storage
     else
       @space = GameSpace.load(self, level_storage)
@@ -95,32 +99,49 @@ class Game
   end
 
   def add_player(player_name)
-    player = Player.new(player_name)
-    player.x = (@space.width - Entity::WIDTH) / 2
-    player.y = (@space.height - Entity::HEIGHT) / 2
-    other_players = @space.players.dup
+    if base = @space.available_base
+      player = Entity::Gecko.new(player_name)
+      player.x, player.y, player.a = base.x, base.y, base.a
+    else
+      player = Entity::Ghost.new(player_name)
+      player.x, player.y = @space.center
+    end
     @space << player
-    other_players.each {|p| player_connection(p).add_player(player, @tick) }
+
+    each_player_conn do |c|
+      c.add_player(player, @tick) unless c.player_name == player_name
+    end
     player
   end
 
-  def player_id_connection(player_id)
-    @port.player_connection(player_id)
+  def replace_player_entity(player_name, new_player_id)
+    conn = player_name_connection(player_name)
+    old = conn.player_id
+    conn.player_id = new_player_id
+  end
+
+  def player_name_connection(player_name)
+    @port.player_name_connection(player_name)
   end
 
   def player_connection(player)
-    player_id_connection(player.registry_id)
+    player_name_connection(player.player_name)
   end
 
   def each_player_conn
-    get_all_players.each {|p| yield player_connection(p)}
+    get_all_players.each {|p| pc = player_connection(p) and yield pc}
+  end
+
+  def send_player_gone(toast)
+    @space.doom toast
+    each_player_conn {|pc| pc.delete_entity toast, @tick }
   end
 
-  def delete_entity(entity)
-    puts "Deleting #{entity}"
-    @space.doom entity
+  def delete_entities(entities)
+    entities.each do |registry_id|
+      @space.doom(@space[registry_id])
+    end
     @space.purge_doomed_entities
-    each_player_conn {|pc| pc.delete_entity entity, @tick }
   end
 
   # Answering request from client
@@ -135,7 +156,7 @@ class Game
         entity.update_from_json json
         entity.grab!
       else
-        $stderr.puts "Can't update #{id}, doesn't exist"
+        warn "Can't update #{id}, doesn't exist"
       end
     end
   end
@@ -157,13 +178,13 @@ class Game
   end
 
   def add_player_action(action)
-    at_tick, player_id = action[:at_tick], action[:player_id]
+    at_tick, player_name = action[:at_tick], action[:player_name]
     unless at_tick
-      $stderr.puts "Received update from #{player_id} without at_tick!"
+      warn "Received update from #{player_name} without at_tick!"
       at_tick = @tick + 1
     end
     if at_tick <= @tick
-      $stderr.puts "Received update from #{player_id} #{@tick + 1 - at_tick} ticks late"
+      warn "Received update from #{player_name} #{@tick + 1 - at_tick} ticks late"
       at_tick = @tick + 1
     end
     @player_actions[at_tick] << action
@@ -172,10 +193,16 @@ class Game
   def process_player_actions
     if actions = @player_actions.delete(@tick)
       actions.each do |action|
-        player_id = action.delete :player_id
+        player_name = action.delete :player_name
+        conn = player_name_connection(player_name)
+        unless conn
+          warn "No connection -- dropping move from #{player_name}"
+          next
+        end
+        player_id = conn.player_id
         player = @space[player_id]
         unless player
-          $stderr.puts "No such player #{player_id} -- dropping move"
+          warn "No such player #{player_id} -- dropping move from #{player_name}"
           next
         end
         if (move = action[:move])
@@ -184,10 +211,12 @@ class Game
           add_npcs npcs
         elsif (entities = action[:update_entities])
           update_npcs entities
+        elsif (entities = action[:delete_entities])
+          delete_entities entities
         elsif (entity_id = action[:snap_to_grid])
           @space.snap_to_grid entity_id.to_sym
         else
-          $stderr.puts "IGNORING BAD DATA from #{player}: #{action.inspect}"
+          warn "IGNORING BAD DATA from #{player_name}: #{action.inspect}"
         end
       end
     end
@@ -227,10 +256,11 @@ class Game
   # N == @registry_broadcast_every
   def send_full_updates
     # Set containing brand-new players' IDs
+    # This is cleared after we read it
     new_players = @port.new_players
 
     each_player_conn do |pc|
-      if new_players.include? pc.player_id
+      if new_players.include? pc.player_name
         response = {
           :you_are => pc.player_id,
           :world => {
@@ -264,7 +294,7 @@ class Game
         # This results in something approaching TICKS_PER_SECOND
         @port.update_until(run_start + Rational(@tick, TICKS_PER_SECOND))
 
-        $stderr.puts "Updates per second: #{@tick / (Time.now.to_r - run_start)}" if @profile
+        warn "Updates per second: #{@tick / (Time.now.to_r - run_start)}" if @profile
       end # times
     end # infinite loop
   end # run

data/lib/game_2d/game_client.rb

@@ -7,14 +7,17 @@ require 'gosu'
 
 require 'game_2d/client_connection'
 require 'game_2d/client_engine'
-require 'game_2d/game_space'
 require 'game_2d/entity'
 require 'game_2d/entity_constants'
+require 'game_2d/entity/base'
 require 'game_2d/entity/block'
-require 'game_2d/entity/titanium'
-require 'game_2d/entity/teleporter'
 require 'game_2d/entity/destination'
-require 'game_2d/player'
+require 'game_2d/entity/gecko'
+require 'game_2d/entity/hole'
+require 'game_2d/entity/slime'
+require 'game_2d/entity/teleporter'
+require 'game_2d/entity/titanium'
+require 'game_2d/game_space'
 require 'game_2d/menu'
 require 'game_2d/message'
 require 'game_2d/password_dialog'
@@ -46,11 +49,10 @@ module GameClient
   DEFAULT_PORT = 4321
   DEFAULT_KEY_SIZE = 1024
 
-  attr_reader :animation, :font, :top_menu
-  attr_accessor :player_id
+  attr_reader :animation, :font, :top_menu, :player_name, :player_id
 
   def initialize_from_hash(opts = {})
-    player_name = opts[:name]
+    @player_name = opts[:name]
     hostname = opts[:hostname]
     port = opts[:port] || DEFAULT_PORT
     key_size = opts[:key_size] || DEFAULT_KEY_SIZE
@@ -60,7 +62,7 @@ module GameClient
     @conn_update_count = @engine_update_count = 0
     @profile = profile
 
-    self.caption = "Game 2D"
+    self.caption = "Game 2D - #{@player_name} on #{hostname}"
 
     @pressed_buttons = []
 
@@ -73,7 +75,7 @@ module GameClient
     @run_start = Time.now.to_f
     @update_count = 0
 
-    @conn = _make_client_connection(hostname, port, self, player_name, key_size)
+    @conn = _make_client_connection(hostname, port, self, @player_name, key_size)
     @engine = @conn.engine = ClientEngine.new(self)
     @menu = build_top_menu
     @dialog = PasswordDialog.new(self, @font)
@@ -83,6 +85,8 @@ module GameClient
     ClientConnection.new(*args)
   end
 
+  def player_id=(id); @player_id = id.to_sym; end
+
   def display_message(*lines)
     if @message
       @message.lines = lines
@@ -134,13 +138,16 @@ module GameClient
 
   def object_type_submenus
     [
-      ['Dirt',        make_block_npc_proc( 5)],
-      ['Brick',       make_block_npc_proc(10)],
-      ['Cement',      make_block_npc_proc(15)],
-      ['Steel',       make_block_npc_proc(20)],
-      ['Unlikelium',  make_block_npc_proc(25)],
-      ['Titanium',    make_block_npc_proc( 0)],
+      ['Dirt',        make_block_npc_proc( 5) ],
+      ['Brick',       make_block_npc_proc(10) ],
+      ['Cement',      make_block_npc_proc(15) ],
+      ['Steel',       make_block_npc_proc(20) ],
+      ['Unlikelium',  make_block_npc_proc(25) ],
+      ['Titanium',    make_block_npc_proc( 0) ],
       ['Teleporter',  make_teleporter_npc_proc],
+      ['Hole',        make_hole_npc_proc      ],
+      ['Base',        make_base_npc_proc      ],
+      ['Slime',       make_slime_npc_proc     ],
     ].collect do |type_name, p|
       MenuItem.new(type_name, self, @font) { @create_npc_proc = p }
     end
@@ -159,6 +166,8 @@ module GameClient
   end
 
   def player
+    return unless space
+    warn "GameClient#player(): No such entity #{@player_id}" unless space[@player_id]
     space[@player_id]
   end
 
@@ -173,7 +182,7 @@ module GameClient
     if @profile
       @conn_update_total += (Time.now.to_f - before_t)
       @conn_update_count += 1
-      $stderr.puts "@conn.update() averages #{@conn_update_total / @conn_update_count} seconds each" if (@conn_update_count % 60) == 0
+      warn "@conn.update() averages #{@conn_update_total / @conn_update_count} seconds each" if (@conn_update_count % 60) == 0
     end
     return unless @engine.world_established?
 
@@ -182,7 +191,7 @@ module GameClient
     if @profile
       @engine_update_total += (Time.now.to_f - before_t)
       @engine_update_count += 1
-      $stderr.puts "@engine.update() averages #{@engine_update_total / @engine_update_count} seconds" if (@engine_update_count % 60) == 0
+      warn "@engine.update() averages #{@engine_update_total / @engine_update_count} seconds" if (@engine_update_count % 60) == 0
     end
 
     # Player at the keyboard queues up a command
@@ -191,7 +200,7 @@ module GameClient
 
     move_grabbed_entity
 
-    $stderr.puts "Updates per second: #{@update_count / (Time.now.to_f - @run_start)}" if @profile
+    warn "Updates per second: #{@update_count / (Time.now.to_f - @run_start)}" if @profile
   end
 
   def move_grabbed_entity(divide_by = ClientConnection::ACTION_DELAY)
@@ -222,8 +231,8 @@ module GameClient
           # If handle_click returned anything, the menu consumed the click
           # If it returned a menu, that's the new one we display
           @menu = (new_menu.respond_to?(:handle_click) ? new_menu : @top_menu)
-        else
-          send_fire
+        elsif @player_id
+          generate_move_from_click
         end
       when Gosu::MsRight then # right-click
         if button_down?(Gosu::KbRightShift) || button_down?(Gosu::KbLeftShift)
@@ -239,16 +248,19 @@ module GameClient
       when Gosu::Kb5 then @create_npc_proc = make_block_npc_proc(25).call
       when Gosu::Kb6 then @create_npc_proc = make_block_npc_proc( 0).call
       when Gosu::Kb7 then @create_npc_proc = make_teleporter_npc_proc.call
+      when Gosu::Kb8 then @create_npc_proc = make_hole_npc_proc.call
+      when Gosu::Kb9 then @create_npc_proc = make_base_npc_proc.call
+      when Gosu::Kb0 then @create_npc_proc = make_slime_npc_proc.call
+      when Gosu::KbDelete then send_delete_entity
+      when Gosu::KbBracketLeft then rotate_left
+      when Gosu::KbBracketRight then rotate_right
       else @pressed_buttons << id unless @dialog
     end
   end
 
-  def send_fire
-    return unless @player_id
-    x, y = mouse_coords
-    x_vel = (x - (player.x + WIDTH / 2)) / PIXEL_WIDTH
-    y_vel = (y - (player.y + WIDTH / 2)) / PIXEL_WIDTH
-    @conn.send_move :fire, :x_vel => x_vel, :y_vel => y_vel
+  def generate_move_from_click
+    move = player.generate_move_from_click(*mouse_coords)
+    @conn.send_move(player_id, *move) if move
   end
 
   # X/Y position of the mouse (center of the crosshairs), adjusted for camera
@@ -297,21 +309,41 @@ module GameClient
     end
   end
 
-  def send_create_npc(type, args)
-    args.merge!(
+  def make_simple_npc_proc(type); proc { send_create_npc "Entity::#{type}" }; end
+
+  def make_hole_npc_proc; make_simple_npc_proc 'Hole'; end
+  def make_base_npc_proc; make_simple_npc_proc 'Base'; end
+  def make_slime_npc_proc
+    proc do
+      send_create_npc 'Entity::Slime', :angle => 270
+    end
+  end
+
+  def send_create_npc(type, args={})
+    @conn.send_create_npc({
       :class => type,
       :position => mouse_entity_location,
       :velocity => [0, 0],
       :angle => 0,
       :moving => true
-    )
-    @conn.send_create_npc(args)
+    }.merge(args))
   end
 
   def grab_specific(registry_id)
     @grabbed_entity_id = registry_id
   end
 
+  # Actions that modify or delete an existing entity will affect:
+  # * The grabbed entity, if there is one, or
+  # * The entity under the mouse whose center is closest to the mouse
+  def selected_object
+    if @grabbed_entity_id
+      grabbed = space[@grabbed_entity_id]
+      return grabbed if grabbed
+    end
+    space.near_to(*mouse_coords)
+  end
+
   def toggle_grab
     if @grabbed_entity_id
       @conn.send_snap_to_grid(space[@grabbed_entity_id]) if @snap_to_grid
@@ -321,6 +353,23 @@ module GameClient
     @grabbed_entity_id = space.near_to(*mouse_coords).nullsafe_registry_id
   end
 
+  def adjust_angle(adjustment)
+    return unless target = selected_object
+    @conn.send_update_entity(
+      :registry_id => target.registry_id,
+      :angle => target.a + adjustment,
+      :moving => true # wake it up
+    )
+  end
+
+  def rotate_left; adjust_angle(-90); end
+  def rotate_right; adjust_angle(+90); end
+
+  def send_delete_entity
+    return unless target = selected_object
+    @conn.send_delete_entity target
+  end
+
   def shutdown
     @conn.disconnect
     close
@@ -328,9 +377,10 @@ module GameClient
 
   # Dequeue an input event
   def handle_input
-    return if player.falling? || @dialog
+    return unless player # can happen when spawning
+    return if player.should_fall? || @dialog
     move = move_for_keypress
-    @conn.send_move move # also creates a delta in the engine
+    @conn.send_move player_id, move # also creates a delta in the engine
   end
 
   # Check keyboard, mouse, and pressed-button queue
@@ -338,23 +388,15 @@ module GameClient
   def move_for_keypress
     # Generated once for each keypress
     until @pressed_buttons.empty?
-      button = @pressed_buttons.shift
-      case button
-        when Gosu::KbUp, Gosu::KbW
-          return (player.building?) ? :rise_up : :flip
-      end
+      move = player.move_for_keypress(@pressed_buttons.shift)
+      return move if move
     end
 
     # Continuously-generated when key held down
-    case
-      when button_down?(Gosu::KbLeft), button_down?(Gosu::KbA)
-        :slide_left
-      when button_down?(Gosu::KbRight), button_down?(Gosu::KbD)
-        :slide_right
-      when button_down?(Gosu::KbRightControl), button_down?(Gosu::KbLeftControl)
-        :brake
-      when button_down?(Gosu::KbDown), button_down?(Gosu::KbS)
-        :build
+    player.moves_for_key_held.each do |key, move|
+      return move if button_down?(key)
     end
+
+    nil
   end
 end