game_2d 0.0.1

data/lib/game_2d/entity/owned_entity.rb

@@ -0,0 +1,29 @@
+require 'facets/kernel/try'
+
+class Entity
+
+class OwnedEntity < Entity
+  attr_reader :owner_id
+
+  def owner_id=(id)
+    @owner_id = id.try(:to_sym)
+  end
+
+  def owner
+    fail "Can't look up owner when not in a space" unless @space
+    @space[@owner_id]
+  end
+
+  def owner=(new_owner)
+    self.owner_id = new_owner.nullsafe_registry_id
+  end
+
+  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]
+    super
+  end
+end
+
+end

data/lib/game_2d/entity/pellet.rb

@@ -0,0 +1,27 @@
+require 'game_2d/entity/block'
+require 'game_2d/entity/owned_entity'
+
+class Entity
+
+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)}
+    @space.doom(self)
+  end
+
+  def image_filename; "pellet.png" end
+end
+
+end

data/lib/game_2d/entity/titanium.rb

@@ -0,0 +1,11 @@
+class Entity
+
+class Titanium < Entity
+  def update; end
+
+  def sleep_now?; true; end
+
+  def image_filename; "titanium.gif"; end
+end
+
+end

data/lib/game_2d/entity_constants.rb

@@ -0,0 +1,14 @@
+module EntityConstants
+  # All our drawings are 40x40
+  CELL_WIDTH_IN_PIXELS = 40
+
+  # We track entities at a resolution higher than pixels, called "subpixels"
+  # This is the smallest detectable motion, 1 / PIXEL_WIDTH of a pixel
+  PIXEL_WIDTH = 10
+
+  # 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
+end

data/lib/game_2d/game.rb

@@ -0,0 +1,213 @@
+## Author: Greg Meyers
+## License: Same as for Gosu (MIT)
+
+require 'rubygems'
+require 'gosu'
+
+require 'game_2d/storage'
+require 'game_2d/server_port'
+require 'game_2d/game_space'
+require 'game_2d/serializable'
+require 'game_2d/entity'
+require 'game_2d/player'
+
+WORLD_WIDTH = 100 # in cells
+WORLD_HEIGHT = 70 # in cells
+
+DEFAULT_PORT = 4321
+DEFAULT_STORAGE = '.game_2d'
+MAX_CLIENTS = 32
+
+# By default, Gosu calls update() 60 times per second.
+# We aim to match that.
+TICKS_PER_SECOND = 60
+
+# How many ticks between broadcasts of the registry
+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]]
+
+    if level_storage.empty?
+      @space = GameSpace.new(self).establish_world(
+        args[:level],
+        nil, # level ID
+        args[:width] || WORLD_WIDTH,
+        args[:height] || WORLD_HEIGHT)
+      @space.storage = level_storage
+    else
+      @space = GameSpace.load(self, level_storage)
+    end
+
+    @tick = -1
+    @player_actions = Hash.new {|h,tick| h[tick] = Array.new}
+
+    @self_check, @profile, @registry_broadcast_every = args.values_at(
+    :self_check, :profile, :registry_broadcast_every)
+    @registry_broadcast_every ||= DEFAULT_REGISTRY_BROADCAST_EVERY
+
+    # This should never happen.  It can only happen client-side because a
+    # registry update may create an entity before we get around to it in,
+    # say, add_npc
+    def @space.fire_duplicate_id(old_entity, new_entity)
+      raise "#{old_entity} and #{new_entity} have same ID!"
+    end
+
+    # This should never happen.  It can only happen client-side because a
+    # registry update may delete an entity before we get around to it in
+    # purge_doomed_entities
+    def @space.fire_entity_not_found(entity)
+      raise "Object #{entity} not in registry"
+    end
+
+    @port = _create_server_port(self,
+      args[:port] || DEFAULT_PORT,
+      args[:max_clients] || MAX_CLIENTS)
+  end
+
+  def _create_server_port(*args)
+    ServerPort.new *args
+  end
+
+  attr_reader :tick
+
+  def world_name; @space.world_name; end
+  def world_id; @space.world_id; end
+  def world_highest_id; @space.highest_id; end
+  def world_cell_width; @space.cell_width; end
+  def world_cell_height; @space.cell_height; end
+
+  def save
+    @space.save
+  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
+    @space << player
+    other_players.each {|p| player_connection(p).add_player(player, @tick) }
+    player
+  end
+
+  def player_id_connection(player_id)
+    @port.player_connection(player_id)
+  end
+
+  def player_connection(player)
+    player_id_connection(player.registry_id)
+  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 }
+  end
+
+  # Answering request from client
+  def create_npc(json)
+    add_npc(Serializable.from_json(json, :GENERATE_ID))
+  end
+
+  def add_npc(npc)
+    @space << npc or return
+    puts "Created #{npc}"
+    @space.players.each {|p| player_connection(p).add_npc npc, @tick }
+  end
+
+  def send_updated_entities(*entities)
+    @space.players.each {|p| player_connection(p).update_entities entities, @tick }
+  end
+
+  def [](id)
+    @space[id]
+  end
+
+  def get_all_players
+    @space.players
+  end
+
+  def get_all_npcs
+    @space.npcs
+  end
+
+  def add_player_action(player_id, action)
+    at_tick = action[:at_tick]
+    unless at_tick
+      $stderr.puts "Received update from #{player_id} 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"
+      at_tick = @tick + 1
+    end
+    @player_actions[at_tick] << [player_id, action]
+  end
+
+  def process_player_actions
+    if actions = @player_actions.delete(@tick)
+      actions.each do |player_id, action|
+        player = @space[player_id]
+        unless player
+          $stderr.puts "No such player #{player_id} -- dropping move"
+          next
+        end
+        if (move = action[:move])
+          player.add_move move
+        elsif (npc = action[:create_npc])
+          create_npc npc
+        else
+          $stderr.puts "IGNORING BAD DATA from #{player}: #{action.inspect}"
+        end
+      end
+    end
+  end
+
+  def update
+    @tick += 1
+
+    # This will:
+    # 1) Queue up player actions for existing players
+    #    (create_npc included)
+    # 2) Add new players in response to handshake messages
+    # 3) Remove players in response to disconnections
+    @port.update
+
+    # This will execute player moves, and create NPCs
+    process_player_actions
+
+    # Objects that exist by now will be updated
+    # Objects created during this tick won't be updated 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)
+
+    if @self_check
+      @space.check_for_grid_corruption
+      @space.check_for_registry_leaks
+    end
+  end
+
+  def run
+    run_start = Time.now.to_r
+    loop do
+      TICKS_PER_SECOND.times do |n|
+        update
+
+        # 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
+      end # times
+    end # infinite loop
+  end # run
+
+end

data/lib/game_2d/game_space.rb

@@ -0,0 +1,462 @@
+require 'securerandom'
+require 'delegate'
+require 'set'
+require 'game_2d/wall'
+require 'game_2d/player'
+require 'game_2d/serializable'
+
+# Common code between the server and client for maintaining the world.
+# This is a bounded space (walls on all sides).
+#
+# Maintains a registry of entities.  All game entities must have a registry_id
+# set before they will be accepted.
+#
+# Also maintains a list of entities due to be deleted, to avoid removing them
+# at the wrong time (during collision processing).
+
+# Cell is a portion of the game space, the exact size of one entity.
+# The cell (0,0) contains subpixel coordinates (0,0) through (399,399).
+#
+# The behavior I want from Cells is to consider them all unique objects.
+# I want to be able to say "Subtract this set of cells from that set".  Treating
+# Cells as equal if their contents are equal defeats this purpose.
+#
+# It's also handy if each Cell knows where it lives in the grid.
+#
+# Previously, I was using Set as the superclass.  That seemed to make sense,
+# since this is an unordered collection.  But Set stores everything as hash
+# keys, and hashes get very confused if their keys get mutated without going
+# through the API.
+
+class Cell < DelegateClass(Array)
+  attr_reader :x, :y
+
+  def ==(other)
+    other.class.equal?(self.class) &&
+      other.x == self.x &&
+      other.y == self.y &&
+      other.instance_variable_get(:@a) == @a
+  end
+
+  def initialize(cell_x, cell_y)
+    @a = []
+    @x, @y = cell_x, cell_y
+    super(@a)
+  end
+
+  def to_s; "(#{x}, #{y}) [#{@a.join(', ')}]"; end
+  def inspect; "Cell(#{x}, #{y}) #{@a}"; end
+end
+
+
+class GameSpace
+  attr_reader :world_name, :world_id, :players, :npcs, :cell_width, :cell_height, :game
+  attr_accessor :storage, :highest_id
+
+  def initialize(game=nil)
+    @game = game
+    @grid = @storage = nil
+    @highest_id = 0
+
+    @registry = {}
+
+    # I create a @doomed array so we can remove entities after all collisions
+    # have been processed, to avoid confusion
+    @doomed = []
+
+    @players = []
+    @npcs = []
+  end
+
+  # Width and height, measured in cells
+  def establish_world(name, id, cell_width, cell_height)
+    @world_name = name
+    @world_id = (id || SecureRandom.uuid).to_sym
+    @cell_width, @cell_height = cell_width, cell_height
+
+    # Outer array is X-indexed; inner arrays are Y-indexed
+    # Therefore you can look up @grid[cell_x][cell_y] ...
+    # However, for convenience, we make the grid two cells wider, two cells
+    # taller.  Then we can populate the edge with Wall instances, and treat (0,
+    # 0) as a usable coordinate.  (-1, -1) contains a Wall, for example.  The
+    # at(), put(), and cut() methods do the translation, so only they should
+    # access @grid directly
+    @grid = Array.new(cell_width + 2) do |cx|
+      Array.new(cell_height + 2) do |cy|
+        Cell.new(cx-1, cy-1)
+      end.freeze
+    end.freeze
+
+    # Top and bottom, including corners
+    (-1 .. cell_width).each do |cell_x|
+      put(cell_x, -1, Wall.new(self, cell_x, -1))                   # top
+      put(cell_x, cell_height, Wall.new(self, cell_x, cell_height)) # bottom
+    end
+
+    # Left and right, skipping corners
+    (0 .. cell_height - 1).each do |cell_y|
+      put(-1, cell_y, Wall.new(self, -1, cell_y))                 # left
+      put(cell_width, cell_y, Wall.new(self, cell_width, cell_y)) # right
+    end
+
+    self
+  end
+
+  def copy_from(original)
+    establish_world(original.world_name, original.world_id, original.cell_width, original.cell_height)
+    @highest_id = original.highest_id
+
+    # @game and @storage should point to the same object (no clone)
+    @game, @storage = original.game, original.storage
+
+    # Registry should contain all objects - clone those
+    original.all_registered.each {|ent| self << ent.clone }
+
+    self
+  end
+
+  def self.load(game, storage)
+    name, id, cell_width, cell_height =
+      storage[:world_name], storage[:world_id],
+      storage[:cell_width], storage[:cell_height]
+    space = GameSpace.new(game).establish_world(name, id, cell_width, cell_height)
+    space.storage = storage
+    space.load
+  end
+
+  def save
+    @storage[:world_name] = @world_name
+    @storage[:world_id] = @world_id
+    @storage[:cell_width], @storage[:cell_height] = @cell_width, @cell_height
+    @storage[:highest_id] = @highest_id
+    @storage[:npcs] = @npcs
+    @storage.save
+  end
+
+  # TODO: Handle this while server is running and players are connected
+  # TODO: Handle resizing the space
+  def load
+    @highest_id = @storage[:highest_id]
+    @storage[:npcs].each do |json|
+      puts "Loading #{json.inspect}"
+      self << Serializable.from_json(json)
+    end
+    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 next_id
+    "R#{@highest_id += 1}".to_sym
+  end
+
+  # Retrieve entity by ID
+  def [](registry_id)
+    return nil unless registry_id
+    @registry[registry_id.to_sym]
+  end
+
+  def all_registered
+    @registry.values
+  end
+
+  # List of entities by type matching the specified entity
+  def entity_list(entity)
+    case entity
+    when Player then @players
+    else @npcs
+    end
+  end
+
+  # Override to be informed when trying to add an entity that
+  # we already have (registry ID clash)
+  def fire_duplicate_id(old_entity, new_entity); end
+
+  # Returns nil if registration worked, or the exact same object
+  # was already registered
+  # If another object was registered, calls fire_duplicate_id and
+  # then returns the previously-registered object
+  def register(entity)
+    reg_id = entity.registry_id
+    old = @registry[reg_id]
+    return nil if old.equal? entity
+    if old
+      fire_duplicate_id(old, entity)
+      return old
+    end
+    @registry[reg_id] = entity
+    entity_list(entity) << entity
+    nil
+  end
+
+  def registered?(entity)
+    return false unless old = @registry[entity.registry_id]
+    return true if old.equal? entity
+    fail("Registered entity #{old} has ID #{old.object_id}; " +
+      "passed entity #{entity} has ID #{entity.object_id}")
+  end
+
+  def deregister(entity)
+    fail "#{entity} not registered" unless registered?(entity)
+    entity_list(entity).delete entity
+    @registry.delete entity.registry_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)
+    raise "Illegal coordinate #{cell_x}x#{cell_y}" if (
+      cell_x < -1 ||
+      cell_y < -1 ||
+      cell_x > @cell_width ||
+      cell_y > @cell_height
+    )
+  end
+
+  # Retrieve set of entities falling (partly) within cell coordinates,
+  # zero-based
+  def at(cell_x, cell_y)
+    assert_ok_coords(cell_x, cell_y)
+    @grid[cell_x + 1][cell_y + 1]
+  end
+
+  # Low-level adder
+  def put(cell_x, cell_y, entity)
+    at(cell_x, cell_y) << entity
+  end
+
+  # Low-level remover
+  def cut(cell_x, cell_y, entity)
+    at(cell_x, cell_y).delete entity
+  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 ]
+  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
+  end
+
+  # Given the (X, Y) position of a theoretical entity, return the list of all
+  # the coordinates of its corners
+  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],
+    ]
+  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)
+    end
+  end
+
+  # Accepts a collection of (x, y)
+  # Returns a Set of entities
+  def entities_at_points(coords)
+    coords.collect {|x, y| entities_at_point(x, y) }.flatten.to_set
+  end
+
+  # The set of entities that may be affected by an entity moving to (or from)
+  # the specified (x, y) coordinates
+  # 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
+    entities_at_points([
+      [x - 1, y], [x, y - 1], # upper-left corner
+      [r + 1, y], [r, y - 1], # upper-right corner
+      [x - 1, b], [x, b + 1], # lower-left corner
+      [r + 1, b], [r, b + 1], # lower-right corner
+    ])
+  end
+
+  # Retrieve set of entities that overlap with a theoretical entity created at
+  # position [x, y] (in subpixels)
+  def entities_overlapping(x, y)
+    entities_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) }
+  end
+
+  # Add the entity to the grid
+  def add_entity_to_grid(entity)
+    cells_overlapping(entity.x, entity.y).each {|s| s << entity }
+  end
+
+  # Remove the entity from the grid
+  def remove_entity_from_grid(entity)
+    cells_overlapping(entity.x, entity.y).each do |s|
+      raise "#{entity} not where expected" unless s.delete entity
+    end
+  end
+
+  # Update grid after an entity moves
+  def update_grid_for_moved_entity(entity, old_x, old_y)
+    cells_before = cells_overlapping(old_x, old_y)
+    cells_after = cells_overlapping(entity.x, entity.y)
+
+    (cells_before - cells_after).each do |s|
+      raise "#{entity} not where expected" unless s.delete entity
+    end
+    (cells_after - cells_before).each {|s| s << entity }
+  end
+
+  # Execute a block during which an entity may move
+  # If it did, we will update the grid appropriately, and wake nearby entities
+  #
+  # All entity motion should be passed through this method
+  def process_moving_entity(entity)
+    unless registered?(entity)
+      puts "#{entity} not in registry yet, no move to process"
+      yield
+      return
+    end
+
+    before_x, before_y = entity.x, entity.y
+
+    yield
+
+    if moved = (entity.x != before_x || entity.y != before_y)
+      update_grid_for_moved_entity(entity, before_x, before_y)
+      # Note: Maybe we should only wake entities in either set
+      # and not both.  For now we'll wake them all
+      (
+        entities_bordering_entity_at(before_x, before_y) +
+        entities_bordering_entity_at(entity.x, entity.y)
+      ).each(&:wake!)
+    end
+
+    moved
+  end
+
+  # Add an entity.  Will wake neighboring entities
+  def <<(entity)
+    entity.registry_id = next_id unless entity.registry_id?
+
+    fail "Already registered: #{entity}" if registered?(entity)
+
+    # Need to assign the space before entities_obstructing()
+    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
+    else
+      entity.space = nil
+      # TODO: Convey error to user somehow
+      $stderr.puts "Can't create #{entity}, occupied by #{conflicts.inspect}"
+    end
+  end
+
+  # Doom an entity (mark it to be deleted but don't remove it yet)
+  def doom(entity); @doomed << entity; end
+
+  def doomed?(entity); @doomed.include?(entity); end
+
+  # Override to be informed when trying to purge an entity that
+  # turns out not to exist
+  def fire_entity_not_found(entity); end
+
+  # Actually remove all previously-marked entities.  Wakes neighbors
+  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)
+      else
+        fire_entity_not_found(entity)
+      end
+    end
+    @doomed.clear
+  end
+
+  def update
+    @registry.values.find_all(&:moving?).each(&:update)
+    purge_doomed_entities
+  end
+
+  # Assertion
+  def check_for_grid_corruption
+    0.upto(@cell_height - 1) do |cell_y|
+      0.upto(@cell_width - 1) do |cell_x|
+        cell = at(cell_x, cell_y)
+        cell.each do |entity|
+          ok = cells_overlapping(entity.x, entity.y)
+          unless ok.include? cell
+            raise "#{entity} shouldn't be in cell #{cell}"
+          end
+        end
+      end
+    end
+    @registry.values.each do |entity|
+      cells_overlapping(entity.x, entity.y).each do |cell|
+        unless cell.include? entity
+          raise "Expected #{entity} to be in cell #{cell}"
+        end
+      end
+    end
+  end
+
+  # Assertion.  Useful server-side only
+  def check_for_registry_leaks
+    expected = @players.size + @npcs.size
+    actual = @registry.size
+    if expected != actual
+      raise "We have #{expected} game entities, #{actual} in registry (delta: #{actual - expected})"
+    end
+  end
+
+  # Used client-side only.  Determine an appropriate camera position,
+  # given the specified window size, and preferring that the specified entity
+  # be in the center.  Inputs and outputs are in pixels
+  def good_camera_position_for(entity, screen_width, screen_height)
+    # Given plenty of room, put the entity in the middle of the screen
+    # If doing so would expose the area outside the world, move the camera just enough
+    # to avoid that
+    # If the world is smaller than the window, center it
+
+#   puts "Screen in pixels is #{screen_width}x#{screen_height}; world in pixels is #{pixel_width}x#{pixel_height}"
+    camera_x = if screen_width > pixel_width
+      (pixel_width - screen_width) / 2 # negative
+    else
+      [[entity.pixel_x - screen_width/2, pixel_width - screen_width].min, 0].max
+    end
+    camera_y = if screen_height > pixel_height
+      (pixel_height - screen_height) / 2 # negative
+    else
+      [[entity.pixel_y - screen_height/2, pixel_height - screen_height].min, 0].max
+    end
+
+#   puts "Camera at #{camera_x}x#{camera_y}"
+    [ camera_x, camera_y ]
+  end
+
+  def ==(other)
+    other.class.equal?(self.class) && other.all_state == self.all_state
+  end
+  def all_state
+    [@world_name, @world_id, @registry, @grid, @highest_id]
+  end
+end