game_2d 0.0.1 → 0.0.2

data/lib/game_2d/entity/block.rb

@@ -45,12 +45,6 @@ class Block < OwnedEntity
     move
   end
 
-  def transparent_to_me?(other)
-    super ||
-    (other.registry_id == owner_id) ||
-    (other.is_a?(Pellet) && other.owner_id == owner_id)
-  end
-
   def harmed_by(other)
     puts "#{self}: Ouch!"
     self.hp -= 1
@@ -68,6 +62,8 @@ class Block < OwnedEntity
   end
 
   def image_filename; "#{level_name}.gif"; end
+
+  def to_s; "#{super} (#{@hp} HP)"; end
 end
 
 end

data/lib/game_2d/entity/destination.rb

@@ -0,0 +1,17 @@
+require 'game_2d/entity'
+
+class Entity
+
+class Destination < OwnedEntity
+
+  def should_fall?; 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
+end
+
+end

data/lib/game_2d/entity/owned_entity.rb

@@ -6,7 +6,8 @@ class OwnedEntity < Entity
   attr_reader :owner_id
 
   def owner_id=(id)
-    @owner_id = id.try(:to_sym)
+    old_owner_id, @owner_id = @owner_id, id.try(:to_sym)
+    space.owner_change(registry_id, old_owner_id, @owner_id) if space && registry_id?
   end
 
   def owner
@@ -21,7 +22,7 @@ class OwnedEntity < Entity
   def all_state; super.push(owner_id); end
   def as_json; super.merge! :owner => owner_id; end
   def update_from_json(json)
-    self.owner_id = json[:owner]
+    self.owner_id = json[:owner] if json[:owner]
     super
   end
 end

data/lib/game_2d/entity/pellet.rb

@@ -7,14 +7,6 @@ class Pellet < OwnedEntity
   def should_fall?; true end
   def sleep_now?; false end
 
-  # Pellets don't hit the originating player, or other
-  # pellets fired by the same player
-  def transparent_to_me?(other)
-    super ||
-    other.registry_id == self.owner_id ||
-    ((other.is_a?(Pellet) || other.is_a?(Block)) && other.owner_id == self.owner_id)
-  end
-
   def i_hit(others)
     puts "#{self}: hit #{others.inspect}.  That's all for me."
     others.each {|other| other.harmed_by(self)}

data/lib/game_2d/entity/teleporter.rb

@@ -0,0 +1,46 @@
+require 'game_2d/entity'
+require 'game_2d/entity/owned_entity'
+
+class Entity
+
+class Teleporter < Entity
+  def should_fall?; false; end
+
+  def update
+    space.entities_overlapping(x, y).each do |overlap|
+      next if overlap == self
+      next if (overlap.x - x).abs > WIDTH/2
+      next if (overlap.y - y).abs > HEIGHT/2
+      dest = space.possessions(self)
+      case dest.size
+        when 1 then
+          dest = dest.first
+          if overlap.entities_obstructing(dest.x, dest.y).empty?
+            overlap.warp(dest.x, dest.y)
+            overlap.wake!
+          end
+        when 0 then
+          $stderr.puts "#{self}: No destination"
+        else
+          $stderr.puts "#{self}: Multiple destinations: #{dest.inspect}"
+      end
+    end
+  end
+
+  def destroy!
+    # destroy destination
+  end
+
+  def image_filename; "tele.gif"; end
+
+  def draw_zorder; ZOrder::Teleporter end
+
+  def to_s
+    destinations = space.possessions(self).collect do |d|
+      "#{d.x}x#{d.y}"
+    end.join(', ')
+    "#{super} => [#{destinations}]"
+  end
+end
+
+end

data/lib/game_2d/game.rb

@@ -27,8 +27,10 @@ DEFAULT_REGISTRY_BROADCAST_EVERY = TICKS_PER_SECOND / 4
 
 class Game
   def initialize(args)
-    @storage = Storage.in_home_dir(args[:storage] || DEFAULT_STORAGE).dir('server')
-    level_storage = @storage[args[:level]]
+    all_storage = Storage.in_home_dir(args[:storage] || DEFAULT_STORAGE)
+    @player_storage = all_storage.dir('players')['players']
+    @levels_storage = all_storage.dir('levels')
+    level_storage = @levels_storage[args[:level]]
 
     if level_storage.empty?
       @space = GameSpace.new(self).establish_world(
@@ -83,6 +85,15 @@ class Game
     @space.save
   end
 
+  def player_data(player_name)
+    @player_storage[player_name]
+  end
+
+  def store_player_data(player_name, data)
+    @player_storage[player_name] = data
+    @player_storage.save
+  end
+
   def add_player(player_name)
     player = Player.new(player_name)
     player.x = (@space.width - Entity::WIDTH) / 2
@@ -101,26 +112,36 @@ class Game
     player_id_connection(player.registry_id)
   end
 
+  def each_player_conn
+    get_all_players.each {|p| yield player_connection(p)}
+  end
+
   def delete_entity(entity)
     puts "Deleting #{entity}"
     @space.doom entity
     @space.purge_doomed_entities
-    @space.players.each {|player| player_connection(player).delete_entity entity, @tick }
+    each_player_conn {|pc| pc.delete_entity entity, @tick }
   end
 
   # Answering request from client
-  def create_npc(json)
-    add_npc(Serializable.from_json(json, :GENERATE_ID))
+  def add_npcs(npcs_json)
+    npcs_json.each {|json| @space << Serializable.from_json(json) }
   end
 
-  def add_npc(npc)
-    @space << npc or return
-    puts "Created #{npc}"
-    @space.players.each {|p| player_connection(p).add_npc npc, @tick }
+  def update_npcs(npcs_json)
+    npcs_json.each do |json|
+      id = json[:registry_id]
+      if entity = @space[id]
+        entity.update_from_json json
+        entity.grab!
+      else
+        $stderr.puts "Can't update #{id}, doesn't exist"
+      end
+    end
   end
 
   def send_updated_entities(*entities)
-    @space.players.each {|p| player_connection(p).update_entities entities, @tick }
+    each_player_conn {|pc| pc.update_entities entities, @tick }
   end
 
   def [](id)
@@ -135,8 +156,8 @@ class Game
     @space.npcs
   end
 
-  def add_player_action(player_id, action)
-    at_tick = action[:at_tick]
+  def add_player_action(action)
+    at_tick, player_id = action[:at_tick], action[:player_id]
     unless at_tick
       $stderr.puts "Received update from #{player_id} without at_tick!"
       at_tick = @tick + 1
@@ -145,12 +166,13 @@ class Game
       $stderr.puts "Received update from #{player_id} #{@tick + 1 - at_tick} ticks late"
       at_tick = @tick + 1
     end
-    @player_actions[at_tick] << [player_id, action]
+    @player_actions[at_tick] << action
   end
 
   def process_player_actions
     if actions = @player_actions.delete(@tick)
-      actions.each do |player_id, action|
+      actions.each do |action|
+        player_id = action.delete :player_id
         player = @space[player_id]
         unless player
           $stderr.puts "No such player #{player_id} -- dropping move"
@@ -158,8 +180,12 @@ class Game
         end
         if (move = action[:move])
           player.add_move move
-        elsif (npc = action[:create_npc])
-          create_npc npc
+        elsif (npcs = action[:add_npcs])
+          add_npcs npcs
+        elsif (entities = action[:update_entities])
+          update_npcs 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}"
         end
@@ -173,7 +199,7 @@ class Game
     # This will:
     # 1) Queue up player actions for existing players
     #    (create_npc included)
-    # 2) Add new players in response to handshake messages
+    # 2) Add new players in response to login messages
     # 3) Remove players in response to disconnections
     @port.update
 
@@ -181,14 +207,13 @@ class Game
     process_player_actions
 
     # Objects that exist by now will be updated
-    # Objects created during this tick won't be updated this tick
+    # Objects created during this update won't be updated
+    # themselves this tick
     @space.update
 
-    @port.broadcast(
-      :registry => @space.all_registered,
-      :highest_id => @space.highest_id,
-      :at_tick => @tick
-    ) if @registry_broadcast_every > 0 && (@tick % @registry_broadcast_every == 0)
+    # Do this at the end, so the update contains all the
+    # latest and greatest news
+    send_full_updates
 
     if @self_check
       @space.check_for_grid_corruption
@@ -196,6 +221,40 @@ class Game
     end
   end
 
+  # New players always get a full update (with some additional
+  # information)
+  # Everyone else gets full registry dump every N ticks, where
+  # N == @registry_broadcast_every
+  def send_full_updates
+    # Set containing brand-new players' IDs
+    new_players = @port.new_players
+
+    each_player_conn do |pc|
+      if new_players.include? pc.player_id
+        response = {
+          :you_are => pc.player_id,
+          :world => {
+            :world_name => world_name,
+            :world_id => world_id,
+            :highest_id => world_highest_id,
+            :cell_width => world_cell_width,
+            :cell_height => world_cell_height,
+          },
+          :add_players => get_all_players,
+          :add_npcs => get_all_npcs,
+          :at_tick => tick,
+        }
+        pc.send_record response, true # answer login reliably
+      elsif @registry_broadcast_every > 0 && (@tick % @registry_broadcast_every == 0)
+        pc.send_record( {
+          :registry => @space.all_registered,
+          :highest_id => @space.highest_id,
+          :at_tick => @tick,
+        }, false, 1 )
+      end
+    end
+  end
+
   def run
     run_start = Time.now.to_r
     loop do

data/lib/game_2d/game_client.rb

@@ -0,0 +1,360 @@
+## Author: Greg Meyers
+## License: Same as for Gosu (MIT)
+
+require 'rubygems'
+require 'facets/kernel/try'
+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/block'
+require 'game_2d/entity/titanium'
+require 'game_2d/entity/teleporter'
+require 'game_2d/entity/destination'
+require 'game_2d/player'
+require 'game_2d/menu'
+require 'game_2d/message'
+require 'game_2d/password_dialog'
+require 'game_2d/zorder'
+
+# We put as many methods here as possible, so we can test them
+# without instantiating an actual Gosu window
+module GameClient
+  # Gosu methods we call:
+  # caption=(text)
+  # width
+  # mouse_x
+  # mouse_y
+  # close
+  # button_down?
+  # text_input=(Gosu::TextInput instance)
+  # draw_quad (from draw only)
+  # translate (from draw only)
+  #
+  # Gosu methods it calls on us:
+  # draw
+  # button_down
+
+  include EntityConstants
+
+  SCREEN_WIDTH = 640  # in pixels
+  SCREEN_HEIGHT = 480 # in pixels
+
+  DEFAULT_PORT = 4321
+  DEFAULT_KEY_SIZE = 1024
+
+  attr_reader :animation, :font, :top_menu
+  attr_accessor :player_id
+
+  def initialize_from_hash(opts = {})
+    player_name = opts[:name]
+    hostname = opts[:hostname]
+    port = opts[:port] || DEFAULT_PORT
+    key_size = opts[:key_size] || DEFAULT_KEY_SIZE
+    profile = opts[:profile] || false
+
+    @conn_update_total = @engine_update_total = 0.0
+    @conn_update_count = @engine_update_count = 0
+    @profile = profile
+
+    self.caption = "Game 2D"
+
+    @pressed_buttons = []
+
+    @snap_to_grid = false
+
+    @create_npc_proc = make_block_npc_proc(5)
+
+    @grabbed_entity_id = nil
+
+    @run_start = Time.now.to_f
+    @update_count = 0
+
+    @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)
+  end
+
+  def _make_client_connection(*args)
+    ClientConnection.new(*args)
+  end
+
+  def display_message(*lines)
+    if @message
+      @message.lines = lines
+    else
+      @message = Message.new(self, @font, lines)
+    end
+  end
+
+  def message_drawn?; @message.try(:drawn?); end
+
+  # Ensure the message is drawn at least once
+  def display_message!(*lines)
+    display_message(*lines)
+    sleep 0.01 until message_drawn?
+  end
+
+  def clear_message
+    @message = nil
+  end
+
+  def build_top_menu
+    @top_menu = MenuItem.new('Click for menu', self, @font) { main_menu }
+  end
+
+  def main_menu
+    Menu.new('Main menu', self, @font,
+      MenuItem.new('Object creation', self, @font) { object_creation_menu },
+      MenuItem.new('Quit!', self, @font) { shutdown }
+    )
+  end
+
+  def object_creation_menu
+    snap_text = lambda do |item|
+      @snap_to_grid ? "Turn snap off" : "Turn snap on"
+    end
+
+    Menu.new('Object creation', self, @font,
+      MenuItem.new('Object type', self, @font) { object_type_menu },
+      MenuItem.new(snap_text, self, @font) do
+        @snap_to_grid = !@snap_to_grid
+      end,
+      MenuItem.new('Save!', self, @font) { @conn.send_save }
+    )
+  end
+
+  def object_type_menu
+    Menu.new('Object type', self, @font, *object_type_submenus)
+  end
+
+  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)],
+      ['Teleporter',  make_teleporter_npc_proc],
+    ].collect do |type_name, p|
+      MenuItem.new(type_name, self, @font) { @create_npc_proc = p }
+    end
+  end
+
+  def media(filename)
+    "#{File.dirname __FILE__}/../../media/#{filename}"
+  end
+
+  def space
+    @engine.space
+  end
+
+  def tick
+    @engine.tick
+  end
+
+  def player
+    space[@player_id]
+  end
+
+  def update
+    @update_count += 1
+
+    return unless @conn.online?
+
+    # Handle any pending ENet events
+    before_t = Time.now.to_f
+    @conn.update
+    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
+    end
+    return unless @engine.world_established?
+
+    before_t = Time.now.to_f
+    @engine.update
+    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
+    end
+
+    # Player at the keyboard queues up a command
+    # @pressed_buttons is emptied by handle_input
+    handle_input if @player_id
+
+    move_grabbed_entity
+
+    $stderr.puts "Updates per second: #{@update_count / (Time.now.to_f - @run_start)}" if @profile
+  end
+
+  def move_grabbed_entity(divide_by = ClientConnection::ACTION_DELAY)
+    return unless @grabbed_entity_id
+    return unless grabbed = space[@grabbed_entity_id]
+    dest_x, dest_y = mouse_entity_location
+    vel_x = Entity.constrain_velocity((dest_x - grabbed.x) / divide_by)
+    vel_y = Entity.constrain_velocity((dest_y - grabbed.y) / divide_by)
+    @conn.send_update_entity(
+      :registry_id => grabbed.registry_id,
+      :velocity => [vel_x, vel_y],
+      :moving => true)
+  end
+
+  def button_down(id)
+    case id
+      when Gosu::KbEnter, Gosu::KbReturn then
+        if @dialog
+          @dialog.enter
+          @conn.start(@dialog.password_hash)
+          @dialog = nil
+        end
+      when Gosu::KbP then
+        @conn.send_ping unless @dialog
+      when Gosu::KbEscape then @menu = @top_menu
+      when Gosu::MsLeft then # left-click
+        if new_menu = @menu.handle_click
+          # 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
+        end
+      when Gosu::MsRight then # right-click
+        if button_down?(Gosu::KbRightShift) || button_down?(Gosu::KbLeftShift)
+          @create_npc_proc.call
+        else
+          toggle_grab
+        end
+      when Gosu::KbB then @create_npc_proc.call
+      when Gosu::Kb1 then @create_npc_proc = make_block_npc_proc( 5).call
+      when Gosu::Kb2 then @create_npc_proc = make_block_npc_proc(10).call
+      when Gosu::Kb3 then @create_npc_proc = make_block_npc_proc(15).call
+      when Gosu::Kb4 then @create_npc_proc = make_block_npc_proc(20).call
+      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
+      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
+  end
+
+  # X/Y position of the mouse (center of the crosshairs), adjusted for camera
+  def mouse_coords
+    # For some reason, Gosu's mouse_x/mouse_y return Floats, so round it off
+    [
+      (mouse_x.round + @camera_x) * PIXEL_WIDTH,
+      (mouse_y.round + @camera_y) * PIXEL_WIDTH
+    ]
+  end
+
+  def mouse_entity_location
+    x, y = mouse_coords
+
+    if @snap_to_grid
+      # When snap is on, we want the upper-left corner of the cell we point at
+      return (x / WIDTH) * WIDTH, (y / HEIGHT) * HEIGHT
+    else
+      # When snap is off, we are pointing at the entity's center, not
+      # its upper-left corner
+      return x - WIDTH / 2, y - HEIGHT / 2
+    end
+  end
+
+  def make_block_npc_proc(hp)
+    type = hp.zero? ? 'Entity::Titanium' : 'Entity::Block'
+    proc { send_create_npc type, :hp => hp }
+  end
+
+  def make_teleporter_npc_proc
+    proc do
+      send_create_npc 'Entity::Teleporter', :on_create => make_destination_npc_proc
+    end
+  end
+
+  def make_destination_npc_proc
+    proc do |teleporter|
+      send_create_npc 'Entity::Destination', :owner => teleporter.registry_id,
+        :on_create => make_grab_destination_proc
+    end
+  end
+
+  def make_grab_destination_proc
+    proc do |destination|
+      grab_specific destination.registry_id
+    end
+  end
+
+  def send_create_npc(type, args)
+    args.merge!(
+      :class => type,
+      :position => mouse_entity_location,
+      :velocity => [0, 0],
+      :angle => 0,
+      :moving => true
+    )
+    @conn.send_create_npc(args)
+  end
+
+  def grab_specific(registry_id)
+    @grabbed_entity_id = registry_id
+  end
+
+  def toggle_grab
+    if @grabbed_entity_id
+      @conn.send_snap_to_grid(space[@grabbed_entity_id]) if @snap_to_grid
+      return @grabbed_entity_id = nil
+    end
+
+    @grabbed_entity_id = space.near_to(*mouse_coords).nullsafe_registry_id
+  end
+
+  def shutdown
+    @conn.disconnect
+    close
+  end
+
+  # Dequeue an input event
+  def handle_input
+    return if player.falling? || @dialog
+    move = move_for_keypress
+    @conn.send_move move # also creates a delta in the engine
+  end
+
+  # Check keyboard, mouse, and pressed-button queue
+  # Return a motion symbol or nil
+  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
+    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
+    end
+  end
+end