game_2d 0.0.1 → 0.0.2

data/lib/game_2d/game_space.rb

@@ -1,9 +1,12 @@
 require 'securerandom'
 require 'delegate'
 require 'set'
+require 'facets/kernel/try'
 require 'game_2d/wall'
 require 'game_2d/player'
 require 'game_2d/serializable'
+require 'game_2d/entity_constants'
+require 'game_2d/entity/owned_entity'
 
 # Common code between the server and client for maintaining the world.
 # This is a bounded space (walls on all sides).
@@ -50,6 +53,8 @@ end
 
 
 class GameSpace
+  include EntityConstants
+
   attr_reader :world_name, :world_id, :players, :npcs, :cell_width, :cell_height, :game
   attr_accessor :storage, :highest_id
 
@@ -60,6 +65,13 @@ class GameSpace
 
     @registry = {}
 
+    # Ownership registry needs to be here too.  Each copy of the space must be
+    # separate.  Otherwise you get duplicate entries whenever ClientEngine copies
+    # the GameSpace.
+    #
+    # owner.registry_id => [registry_id, ...]
+    @ownership = Hash.new {|h,k| h[k] = Array.new}
+
     # I create a @doomed array so we can remove entities after all collisions
     # have been processed, to avoid confusion
     @doomed = []
@@ -144,10 +156,10 @@ class GameSpace
     self
   end
 
-  def pixel_width; @cell_width * Entity::CELL_WIDTH_IN_PIXELS; end
-  def pixel_height; @cell_height * Entity::CELL_WIDTH_IN_PIXELS; end
-  def width; @cell_width * Entity::WIDTH; end
-  def height; @cell_height * Entity::HEIGHT; end
+  def pixel_width; @cell_width * CELL_WIDTH_IN_PIXELS; end
+  def pixel_height; @cell_height * CELL_WIDTH_IN_PIXELS; end
+  def width; @cell_width * WIDTH; end
+  def height; @cell_height * HEIGHT; end
 
   def next_id
     "R#{@highest_id += 1}".to_sym
@@ -189,6 +201,7 @@ class GameSpace
     end
     @registry[reg_id] = entity
     entity_list(entity) << entity
+    register_with_owner(entity)
     nil
   end
 
@@ -201,10 +214,34 @@ class GameSpace
 
   def deregister(entity)
     fail "#{entity} not registered" unless registered?(entity)
+    deregister_ownership(entity)
     entity_list(entity).delete entity
     @registry.delete entity.registry_id
   end
 
+  def register_with_owner(owned)
+    return unless owned.is_a?(Entity::OwnedEntity) && owned.owner_id
+    @ownership[owned.owner_id] << owned.registry_id
+  end
+
+  def deregister_ownership(entity)
+    if entity.is_a?(Entity::OwnedEntity) && entity.owner_id
+      @ownership[entity.owner_id].delete entity.registry_id
+    end
+    @ownership.delete entity.registry_id
+  end
+
+  def owner_change(owned_id, old_owner_id, new_owner_id)
+    return unless owned_id
+    return if old_owner_id == new_owner_id
+    @ownership[old_owner_id].delete(owned_id) if old_owner_id
+    @ownership[new_owner_id] << owned_id if new_owner_id
+  end
+
+  def possessions(entity)
+    @ownership[entity.registry_id].collect {|id| self[id]}
+  end
+
   # We can safely look up cell_x == -1, cell_x == @cell_width, cell_y == -1,
   # and/or cell_y == @cell_height -- any of these returns a Wall instance
   def assert_ok_coords(cell_x, cell_y)
@@ -234,14 +271,14 @@ class GameSpace
   end
 
   # Translate a subpixel point (X, Y) to a cell coordinate (cell_x, cell_y)
-  def cell_at_point(x, y)
-    [x / Entity::WIDTH, y / Entity::HEIGHT ]
+  def cell_location_at_point(x, y)
+    [x / WIDTH, y / HEIGHT ]
   end
 
   # Translate multiple subpixel points (X, Y) to a set of cell coordinates
   # (cell_x, cell_y)
-  def cells_at_points(coords)
-    coords.collect {|x, y| cell_at_point(x, y) }.to_set
+  def cell_locations_at_points(coords)
+    coords.collect {|x, y| cell_location_at_point(x, y) }.to_set
   end
 
   # Given the (X, Y) position of a theoretical entity, return the list of all
@@ -249,20 +286,32 @@ class GameSpace
   def corner_points_of_entity(x, y)
     [
       [x, y],
-      [x + Entity::WIDTH - 1, y],
-      [x, y + Entity::HEIGHT - 1],
-      [x + Entity::WIDTH - 1, y + Entity::HEIGHT - 1],
+      [x + WIDTH - 1, y],
+      [x, y + HEIGHT - 1],
+      [x + WIDTH - 1, y + HEIGHT - 1],
     ]
   end
 
   # Return a list of the entities (if any) at a subpixel point (X, Y)
   def entities_at_point(x, y)
-    at(*cell_at_point(x, y)).find_all do |e|
-      e.x <= x && e.x > (x - Entity::WIDTH) &&
-      e.y <= y && e.y > (y - Entity::HEIGHT)
+    at(*cell_location_at_point(x, y)).find_all do |e|
+      e.x <= x && e.x > (x - WIDTH) &&
+      e.y <= y && e.y > (y - HEIGHT)
     end
   end
 
+  # 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]
+    end.sort {|(d1, e1), (d2, e2)| d1 <=> d2}.first.try(:last)
+  end
+
   # Accepts a collection of (x, y)
   # Returns a Set of entities
   def entities_at_points(coords)
@@ -274,8 +323,8 @@ class GameSpace
   # This includes the coordinates of eight points just beyond the entity's
   # borders
   def entities_bordering_entity_at(x, y)
-    r = x + Entity::WIDTH - 1
-    b = y + Entity::HEIGHT - 1
+    r = x + WIDTH - 1
+    b = y + HEIGHT - 1
     entities_at_points([
       [x - 1, y], [x, y - 1], # upper-left corner
       [r + 1, y], [r, y - 1], # upper-right corner
@@ -290,10 +339,16 @@ class GameSpace
     entities_at_points(corner_points_of_entity(x, y))
   end
 
+  # Retrieve list of cell-coordinates (expressed as [cell_x, cell_y]
+  # arrays), coinciding with position [x, y] (expressed in subpixels).
+  def cell_locations_overlapping(x, y)
+    cell_locations_at_points(corner_points_of_entity(x, y))
+  end
+
   # Retrieve list of cells that overlap with a theoretical entity
   # at position [x, y] (in subpixels).
   def cells_overlapping(x, y)
-    cells_at_points(corner_points_of_entity(x, y)).collect {|cx, cy| at(cx, cy) }
+    cell_locations_overlapping(x, y).collect {|cx, cy| at(cx, cy) }
   end
 
   # Add the entity to the grid
@@ -368,6 +423,29 @@ class GameSpace
     end
   end
 
+  def snap_to_grid(entity_id)
+    unless entity = self[entity_id]
+      $stderr.puts "Can't snap #{entity_id}, doesn't exist"
+      return
+    end
+
+    candidates = cell_locations_overlapping(entity.x, entity.y).collect do |cell_x, cell_y|
+      [cell_x * WIDTH, cell_y * HEIGHT]
+    end
+    sorted = candidates.to_a.sort do |(ax, ay), (bx, by)|
+      ((entity.x - ax).abs + (entity.y - ay).abs) <=>
+      ((entity.x - bx).abs + (entity.y - by).abs)
+    end
+    sorted.each do |dx, dy|
+      if entity.entities_obstructing(dx, dy).empty?
+        entity.warp(dx, dy)
+        entity.wake!
+        return
+      end
+    end
+    $stderr.puts "Couldn't snap #{entity} to grid"
+  end
+
   # Doom an entity (mark it to be deleted but don't remove it yet)
   def doom(entity); @doomed << entity; end
 
@@ -393,7 +471,15 @@ class GameSpace
   end
 
   def update
-    @registry.values.find_all(&:moving?).each(&:update)
+    @registry.values.each do |ent|
+      if ent.grabbed?
+        ent.move
+        ent.release!
+        ent.x_vel = ent.y_vel = 0
+      elsif ent.moving?
+        ent.update
+      end
+    end
     purge_doomed_entities
   end
 

data/lib/game_2d/game_window.rb

@@ -2,41 +2,23 @@
 ## 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/player'
-require 'game_2d/menu'
-require 'game_2d/zorder'
-
-SCREEN_WIDTH = 640  # in pixels
-SCREEN_HEIGHT = 480 # in pixels
-
-DEFAULT_PORT = 4321
+require 'game_2d/game_client'
 
 # The Gosu::Window is always the "environment" of our game
 # It also provides the pulse of our game
 class GameWindow < Gosu::Window
-  attr_reader :animation, :font
-  attr_accessor :player_id
-
-  def initialize(player_name, hostname, port=DEFAULT_PORT, profile=false)
-    @conn_update_total = @engine_update_total = 0.0
-    @conn_update_count = @engine_update_count = 0
-    @profile = profile
+  include GameClient
 
+  def initialize(opts = {})
     super(SCREEN_WIDTH, SCREEN_HEIGHT, false, 16)
-    self.caption = "Ruby Gosu Game"
-
-    @pressed_buttons = []
 
     @background_image = Gosu::Image.new(self, media("Space.png"), true)
     @animation = Hash.new do |h, k|
       h[k] = Gosu::Image::load_tiles(
-        self, k, Entity::CELL_WIDTH_IN_PIXELS, Entity::CELL_WIDTH_IN_PIXELS, false)
+        self, k, CELL_WIDTH_IN_PIXELS, CELL_WIDTH_IN_PIXELS, false)
     end
 
     @cursor_anim = @animation[media("crosshair.gif")]
@@ -45,109 +27,14 @@ class GameWindow < Gosu::Window
 
     @font = Gosu::Font.new(self, Gosu::default_font_name, 20)
 
-    # Local settings
-    @local = {
-      :create_npc => {
-        :type => 'Entity::Block',
-        :hp   => 5,
-        :snap => false,
-      },
-    }
-    snap_text = lambda do |item|
-      @local[:create_npc][:snap] ? "Turn snap off" : "Turn snap on"
-    end
-
-    object_type_submenus = [
-      ['Dirt',       'Entity::Block',    5],
-      ['Brick',      'Entity::Block',    10],
-      ['Cement',     'Entity::Block',    15],
-      ['Steel',      'Entity::Block',    20],
-      ['Unlikelium', 'Entity::Block',    25],
-      ['Titanium',   'Entity::Titanium', 0]
-    ].collect do |type_name, class_name, hp|
-      MenuItem.new(type_name, self, @font) do |item|
-        @local[:create_npc][:type] = class_name
-        @local[:create_npc][:hp] = hp
-      end
-    end
-    object_type_menu = Menu.new('Object type', self, @font,
-      *object_type_submenus)
-
-    object_creation_menu = Menu.new('Object creation', self, @font,
-      MenuItem.new('Object type', self, @font) { object_type_menu },
-      MenuItem.new(snap_text, self, @font) do
-        @local[:create_npc][:snap] = !@local[:create_npc][:snap]
-      end,
-      MenuItem.new('Save!', self, @font) { @conn.send_save }
-    )
-    main_menu = Menu.new('Main menu', self, @font,
-      MenuItem.new('Object creation', self, @font) { object_creation_menu },
-      MenuItem.new('Quit!', self, @font) { shutdown }
-    )
-    @menu = @top_menu = MenuItem.new('Click for menu', self, @font) { main_menu }
-
-    # Connect to server and kick off handshaking
-    # We will create our player object only after we've been accepted by the server
-    # and told our starting position
-    @conn = ClientConnection.new(hostname, port, self, player_name)
-    @engine = @conn.engine = ClientEngine.new(self)
-    @run_start = Time.now.to_f
-    @update_count = 0
-  end
-
-  def media(filename)
-    "#{File.dirname __FILE__}/../../media/#{filename}"
-  end
-
-  def space
-    @engine.space
-  end
-
-  def player
-    space[@player_id]
-  end
-
-  def update
-    @update_count += 1
-
-    # 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 @conn.online? && @engine
-
-    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
-
-    $stderr.puts "Updates per second: #{@update_count / (Time.now.to_f - @run_start)}" if @profile
+    initialize_from_hash(opts)
   end
 
   def draw
     @background_image.draw(0, 0, ZOrder::Background)
-    return unless @player_id
-    @camera_x, @camera_y = space.good_camera_position_for(player, SCREEN_WIDTH, SCREEN_HEIGHT)
-    translate(-@camera_x, -@camera_y) do
-      (space.players + space.npcs).each {|entity| entity.draw(self) }
-    end
-
-    space.players.sort.each_with_index do |player, num|
-      @font.draw("#{player.player_name}: #{player.score}", 10, 10 * (num * 2 + 1), ZOrder::Text, 1.0, 1.0, Gosu::Color::YELLOW)
-    end
-
-    @menu.draw
+    @dialog.draw if @dialog
+    @message.draw if @message
+    @menu.draw if @menu
 
     cursor_img = @cursor_anim[Gosu::milliseconds / 50 % @cursor_anim.size]
     cursor_img.draw(
@@ -155,106 +42,20 @@ class GameWindow < Gosu::Window
       mouse_y - cursor_img.height / 2.0,
       ZOrder::Cursor,
       1, 1, Gosu::Color::WHITE, :add)
-  end
-
-  def draw_box_at(x1, y1, x2, y2, c)
-    draw_quad(x1, y1, c, x2, y1, c, x2, y2, c, x1, y2, c, ZOrder::Highlight)
-  end
-
-  def button_down(id)
-    case id
-      when Gosu::KbP then @conn.send_ping
-      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
-        send_create_npc
-      else @pressed_buttons << id
-    end
-  end
 
-  def send_fire
     return unless @player_id
-    x, y = mouse_coords
-    x_vel = (x - (player.x + Entity::WIDTH / 2)) / Entity::PIXEL_WIDTH
-    y_vel = (y - (player.y + Entity::WIDTH / 2)) / Entity::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) * Entity::PIXEL_WIDTH,
-      (mouse_y.round + @camera_y) * Entity::PIXEL_WIDTH
-    ]
-  end
 
-  def send_create_npc
-    x, y = mouse_coords
-
-    if @local[:create_npc][:snap]
-      # When snap is on, we want the upper-left corner of the cell we clicked in
-      x = (x / Entity::WIDTH) * Entity::WIDTH
-      y = (y / Entity::HEIGHT) * Entity::HEIGHT
-    else
-      # When snap is off, we want the click to be the new entity's center, not
-      # its upper-left corner
-      x -= Entity::WIDTH / 2
-      y -= Entity::HEIGHT / 2
+    @camera_x, @camera_y = space.good_camera_position_for(player, SCREEN_WIDTH, SCREEN_HEIGHT)
+    translate(-@camera_x, -@camera_y) do
+      (space.players + space.npcs).each {|entity| entity.draw(self) }
     end
 
-    @conn.send_create_npc(
-      :class => @local[:create_npc][:type],
-      :position => [x, y],
-      :velocity => [0, 0],
-      :angle => 0,
-      :moving => true,
-      :hp => @local[:create_npc][:hp]
-    )
-  end
-
-  def shutdown
-    @conn.disconnect
-    close
-  end
-
-  # Dequeue an input event
-  def handle_input
-    return if player.falling?
-    move = move_for_keypress
-    @conn.send_move move # also creates a delta in the engine
-  end
-
-  # Check keyboard, 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
+    space.entities_at_point(*mouse_coords).each_with_index do |entity, line|
+      @font.draw(entity.to_s, 10, 10 * (line * 2 + 1), ZOrder::Text, 1.0, 1.0, Gosu::Color::YELLOW)
     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
+  def draw_box_at(x1, y1, x2, y2, c)
+    draw_quad(x1, y1, c, x2, y1, c, x2, y2, c, x1, y2, c, ZOrder::Highlight)
   end
 end