game_2d 0.0.1

data/lib/game_2d/registerable.rb

@@ -0,0 +1,25 @@
+class NilClass
+  def nullsafe_registry_id; self; end
+end
+
+module Registerable
+  def registry_id?
+    @registry_id
+  end
+
+  def registry_id
+    @registry_id or raise("No ID set for #{self}")
+  end
+  def nullsafe_registry_id; registry_id; end
+
+  # For use in to_s
+  def registry_id_safe
+    @registry_id || :NO_ID
+  end
+
+  def registry_id=(id)
+    raise "#{self}: Already have ID #{@registry_id}, cannot set to #{id}" if @registry_id
+    raise "#{self}: Invalid ID #{id}" unless id
+    @registry_id = id.to_sym
+  end
+end

data/lib/game_2d/serializable.rb

@@ -0,0 +1,69 @@
+class NilClass
+  def as_json; self end
+end
+
+module Serializable
+  # Flat list of all object state
+  # For sorting purposes, most significant goes first
+  def all_state
+    []
+  end
+
+  # Based on all_state
+  def <=>(other)
+    self.all_state <=> other.all_state
+  end
+  def ==(other)
+    other.class.equal?(self.class) && other.all_state == self.all_state
+  end
+  def hash; self.class.hash ^ all_state.hash; end
+  def eql?(other); self == other; end
+
+  # Returns a hash which becomes the JSON
+  def self.as_json(thing)
+    { :class => thing.class.to_s }
+  end
+
+  # Based on as_json
+  def to_json(*args)
+    as_json.to_json(*args)
+  end
+
+  # Make our state match what's in the hash
+  def update_from_json(hash)
+  end
+
+  def to_s
+    self.class.name
+  end
+
+  def self.from_json(json, generate_id=false)
+    return nil unless json
+    class_name = json[:class]
+    binding.pry unless class_name
+    raise "Suspicious class name: #{class_name}" unless
+      (class_name == 'Player') ||
+      (class_name.start_with? 'Entity::') ||
+      (class_name.start_with? 'Move::')
+    require "game_2d/#{class_name.pathize}"
+    clazz = constant(class_name)
+    it = clazz.new
+
+    # A registry ID must be specified either in the JSON or by the caller, but
+    # not both
+    if it.is_a? Registerable
+      if generate_id
+        fail("Entity #{it} (from #{json.inspect}) already has " +
+          "ID #{it.registry_id}, cannot generate") if it.registry_id?
+        # Leave it nil - it will be populated when added to a space
+      else
+        it.registry_id = json[:registry_id]
+      end
+    elsif generate_id
+      fail("#{clazz} is not Registerable")
+    end
+
+    it.update_from_json(json)
+  end
+
+end

data/lib/game_2d/server_connection.rb

@@ -0,0 +1,104 @@
+require 'json'
+require 'game_2d/hash'
+
+# An instance of this class is created by ServerPort whenever an
+# incoming connection is accepted.
+
+class ServerConnection
+
+  def initialize(port, game, server, id, remote_addr)
+    @port, @game, @server, @id, @remote_addr = port, game, server, id, remote_addr
+    puts "ServerConnection: New connection #{id} from #{remote_addr}"
+  end
+
+  def answer_handshake(handshake)
+    player_name = handshake[:player_name]
+    player = @game.add_player(player_name)
+    @player_id = player.registry_id
+    @port.register_player @player_id, self
+
+    response = {
+      :you_are => @player_id,
+      :world => {
+        :world_name => @game.world_name,
+        :world_id => @game.world_id,
+        :highest_id => @game.world_highest_id,
+        :cell_width => @game.world_cell_width,
+        :cell_height => @game.world_cell_height,
+      },
+      :add_players => @game.get_all_players,
+      :add_npcs => @game.get_all_npcs,
+      :at_tick => @game.tick,
+    }
+    puts "#{player} logs in from #{@remote_addr} at <#{@game.tick}>"
+    send_record response, true # answer handshake reliably
+  end
+
+  def player
+    @game[@player_id]
+  end
+
+  def answer_ping(ping)
+    send_record :pong => ping
+  end
+
+  def add_npc(npc, at_tick)
+    send_record :add_npcs => [ npc ], :at_tick => at_tick
+  end
+
+  def add_player(player, at_tick)
+    send_record :add_players => [ player ], :at_tick => at_tick
+  end
+
+  def delete_entity(entity, at_tick)
+    send_record :delete_entities => [ entity.registry_id ], :at_tick => at_tick
+  end
+
+  def update_entities(entities, at_tick)
+    send_record :update_entities => entities, :at_tick => at_tick
+  end
+
+  # Not called yet...
+  def update_score(player, at_tick)
+    send_record :update_score => { player.registry_id => player.score }, :at_tick => at_tick
+  end
+
+  def close
+    @port.deregister_player @player_id
+    toast = player
+    puts "#{toast} -- #{@remote_addr} disconnected at <#{@game.tick}>"
+    @game.delete_entity toast
+  end
+
+  def on_packet(data, channel)
+    hash = JSON.parse(data).fix_keys
+    debug_packet('Received', hash)
+    if (handshake = hash[:handshake])
+      answer_handshake(handshake)
+    elsif (hash[:save])
+      @game.save
+    elsif (ping = hash[:ping])
+      answer_ping ping
+    else
+      @game.add_player_action @player_id, hash
+      @port.broadcast_player_action @id,
+        hash.merge(:player_id => @player_id),
+        channel
+    end
+  end
+
+  def send_record(hash, reliable=false, channel=0)
+    debug_packet('Sending', hash)
+    send_str = hash.to_json
+    # Send data to the client (client ID, data, reliable or not, channel ID)
+    @server.send_packet(@id, send_str, reliable, channel)
+    @server.flush
+  end
+
+  def debug_packet(direction, hash)
+    return unless $debug_traffic
+    at_tick = hash[:at_tick] || 'NO TICK'
+    keys = hash.keys - [:at_tick]
+    puts "#{direction} #{keys.join(', ')} <#{at_tick}>"
+  end
+end

data/lib/game_2d/server_port.rb

@@ -0,0 +1,74 @@
+require 'renet'
+require 'json'
+require 'game_2d/server_connection'
+
+class ServerPort
+  def initialize(game, port_number, max_clients)
+    @game = game
+    @server = _create_enet_server port_number, max_clients, 2, 0, 0
+    puts "ENet server listening on #{port_number}"
+
+    @clients = {}
+    @player_connections = {}
+
+    @server.on_connection method(:on_connection)
+    @server.on_packet_receive method(:on_packet_receive)
+    @server.on_disconnection method(:on_disconnection)
+  end
+
+  def _create_enet_server(*args)
+    ENet::Server.new *args
+  end
+
+  def on_connection(id, ip)
+    puts "New ENet connection #{id} from #{ip}"
+    @clients[id] = ServerConnection.new(self, @game, @server, id, ip)
+  end
+
+  def on_packet_receive(id, data, channel)
+    @clients[id].on_packet(data, channel)
+  end
+
+  def on_disconnection(id)
+    puts "ENet connection #{id} disconnected"
+    gone = @clients.delete id
+    gone.close
+    puts "Remaining connection IDs: #{@clients.keys.sort.join(', ')}"
+  end
+
+  def broadcast(data, reliable=false, channel=1)
+    @server.broadcast_packet data.to_json, reliable, channel
+    @server.flush
+  end
+
+  def register_player(player_id, conn)
+    @player_connections[player_id] = conn
+  end
+
+  def deregister_player(player_id)
+    @player_connections.delete player_id
+  end
+
+  def player_connection(player_id)
+    @player_connections[player_id]
+  end
+
+  # Re-broadcast to everyone except the original sender
+  def broadcast_player_action(sender_id, hash, channel)
+    data = hash.to_json
+    @clients.keys.each do |id|
+      @server.send_packet(id, data, false, channel) unless id == sender_id
+    end
+    @server.flush
+  end
+
+  def update(timeout=0) # non-blocking by default
+    @server.update(timeout)
+  end
+
+  def update_until(stop_time)
+    while Time.now.to_r < stop_time do
+      update
+    end
+  end
+end

data/lib/game_2d/storage.rb

@@ -0,0 +1,42 @@
+require 'fileutils'
+require 'json'
+require 'game_2d/hash'
+
+class Storage
+  def self.in_home_dir(name)
+    Storage.new "#{Dir.home}/#{name}"
+  end
+
+  def initialize(dir)
+    @dir = dir
+    FileUtils.mkdir_p @dir
+  end
+
+  def dir(subdir)
+    Storage.new("#{@dir}/#{subdir}")
+  end
+
+  def [](name)
+    Settings.new("#{@dir}/#{name}")
+  end
+
+  def to_s; "Storage(#{@dir})"; end
+end
+
+class Settings
+  def initialize(name)
+    @name = name
+    @values = File.exist?(name) ? JSON.parse(IO.read(name)).fix_keys : {}
+  end
+
+  def save
+    puts "Writing to #{self}"
+    File.open(@name, 'w') {|f| f.write(@values.to_json) }
+  end
+
+  def [](key); @values[key]; end
+  def []=(key, value); @values[key] = value; end
+  def empty?; @values.empty?; end
+
+  def to_s; "Settings(#{@name})"; end
+end

data/lib/game_2d/version.rb

@@ -0,0 +1,3 @@
+module Game2d
+  VERSION = "0.0.1"
+end

data/lib/game_2d/wall.rb

@@ -0,0 +1,21 @@
+require 'game_2d/entity'
+
+class Wall < Entity
+  def initialize(space, cell_x, cell_y)
+    super(cell_x * Entity::WIDTH, cell_y * Entity::HEIGHT)
+    self.space = space
+  end
+
+  def moving?; false; end
+  def moving=(moving); end
+
+  def sleep_now?; true; end
+  def wake!; end
+
+  def registry_id; "Wall[#{left_cell_x}x#{top_cell_y}]"; end
+  def to_s
+    "Wall at #{left_cell_x}x#{top_cell_y} (#{x}x#{y})"
+  end
+
+  def all_state; [x, y]; end
+end

data/lib/game_2d/zorder.rb

@@ -0,0 +1,3 @@
+module ZOrder
+  Background, Objects, Pellet, Player, Highlight, Text, Cursor = *0..6
+end

data/spec/client_engine_spec.rb

@@ -0,0 +1,235 @@
+$LOAD_PATH << '.'
+require 'game'
+require 'server_port'
+require 'client_engine'
+require 'client_connection'
+
+IP_ADDRESS = '1.1.1.1'
+CONNECTION_ID = 666
+
+class FakeENetServer
+  def initialize(*args)
+    $stderr.puts "FakeENetServer.new(#{args.inspect})"
+    @queue = []
+  end
+  def broadcast_packet(data, reliable, channel)
+    $stderr.puts "FakeENetServer.broadcast_packet"
+    $fake_client.xmit data, channel
+  end
+  def send_packet(id, data, reliable, channel)
+    $fake_client.xmit data, channel
+  end
+  def update(timeout)
+    $stderr.puts "FakeENetServer.update(#{timeout}) - processing #{@queue.size} packets"
+    @queue.each do |data, channel|
+      $fake_server_port.on_packet_receive(CONNECTION_ID, data, channel)
+    end
+    @queue.clear
+  end
+  def on_connection(a_method) # accepts (id, ip)
+  end
+  def on_packet_receive(a_method) # accepts (id, data, channel)
+  end
+  def on_disconnection(a_method) # accepts (id)
+  end
+  def flush
+    $stderr.puts "FakeENetServer.flush"
+  end
+
+  def xmit(data, channel)
+    $stderr.puts "Client->Server on ##{channel}: #{data}"
+    @queue << [data, channel]
+  end
+end
+
+class FakeServerPort < ServerPort
+  def _create_enet_server(*args)
+    $fake_server_port = self
+    $fake_server = FakeENetServer.new *args
+  end
+end
+
+class FakeGame < Game
+  attr_reader :space
+
+  def _create_server_port(*args)
+    FakeServerPort.new *args
+  end
+end
+
+class FakeENetConnection
+  def initialize(*args)
+    $stderr.puts "FakeENetConnection.new(#{args.inspect})"
+    @queue = []
+  end
+  def connect(timeout)
+    $stderr.puts "FakeENetConnection.connect(#{timeout})"
+    $fake_server_port.on_connection(CONNECTION_ID, IP_ADDRESS)
+    $fake_client_conn.on_connect
+  end
+  def send_packet(data, reliable, channel)
+    $fake_server.xmit data, channel
+  end
+  def update(timeout)
+    $stderr.puts "FakeENetConnection.update(#{timeout}) - processing #{@queue.size} packets"
+    @queue.each do |data, channel|
+      $fake_client_conn.on_packet(data, channel)
+    end
+    @queue.clear
+  end
+  def on_connection(a_method) # accepts no args
+  end
+  def on_packet_receive(a_method) # accepts (data, channel)
+  end
+  def on_disconnection(a_method) # accepts no args
+  end
+  def flush
+    $stderr.puts "FakeENetConnection.flush"
+  end
+
+  def xmit(data, channel)
+    $stderr.puts "Server->Client on ##{channel}: #{data}"
+    @queue << [data, channel]
+  end
+end
+
+class FakeClientConnection < ClientConnection
+  def _create_connection(*args)
+    $fake_client_conn = self
+    $fake_client = FakeENetConnection.new(*args)
+  end
+end
+
+class FakeGameWindow
+  attr_accessor :player_id, :conn, :engine
+
+  def initialize(host, port, player_name)
+    @conn = FakeClientConnection.new(host, port, self, player_name)
+    @conn.engine = @engine = ClientEngine.new(self)
+  end
+
+  def space
+    @engine.space
+  end
+
+  def player
+    space[@player_id]
+  end
+
+  def update
+    @conn.update
+    @engine.update
+  end
+
+  def generate_move(move)
+    @conn.send_move move
+  end
+end
+
+describe FakeGame do
+  let(:hostname) { 'localhost' }
+  let(:port_number) { 9998 }
+  let(:player_name) { 'Ed' }
+  let(:max_clients) { 2 }
+  let(:storage) { '.test' }
+  let(:level) { 'test-level' }
+  let(:cell_width) { 3 }
+  let(:cell_height) { 3 }
+  let(:self_check) { false }
+  let(:profile) { false }
+
+  let(:game) { FakeGame.new(
+    :port                     => port_number,
+    :max_clients              => max_clients,
+    :storage                  => storage,
+    :level                    => level,
+    :width                    => cell_width,
+    :height                   => cell_height,
+    :self_check               => self_check,
+    :profile                  => profile,
+    :registry_broadcast_every => registry_broadcast_every
+  ) }
+  let(:window) { game; FakeGameWindow.new(hostname, port_number, player_name) }
+
+  def update_both
+    game.update
+    window.update
+  end
+
+  def expect_spaces_to_match
+    expect(window.space).to eq(game.space)
+  end
+
+  context "with default registry syncs" do
+    let(:registry_broadcast_every) { nil }
+    it "is in sync after one update" do
+      window
+
+      update_both
+
+      expect_spaces_to_match
+    end
+    it "is in sync after a fall and a build" do
+      window
+
+      expect(game.tick).to eq(-1)
+      expect(window.engine.tick).to be_nil
+
+      28.times do |n|
+        update_both
+        expect(game.tick).to eq(n)
+        expect(window.engine.tick).to eq(n)
+        expect_spaces_to_match
+      end
+
+      expect(game.space.players.size).to eq(1)
+      expect(game.space.npcs.size).to eq(0)
+
+      plr = game.space.players.first
+      expect(plr.y).to eq(800)
+
+      # Command generated at tick 27, scheduled for tick 33
+      window.generate_move :build
+
+      5.times do # ticks 28 - 32
+        update_both
+        expect_spaces_to_match
+        expect(game.space.npcs.size).to eq(0)
+      end
+
+      # tick 33
+      update_both
+      expect(game.tick).to eq(33)
+      expect(game.space.npcs.size).to eq(1)
+
+      expect_spaces_to_match
+
+      # Command generated at tick 33, scheduled for tick 39
+      window.generate_move :rise_up
+      5.times do # ticks 34 - 38
+        update_both
+        $stderr.puts "TICK ##{game.tick}"
+        expect_spaces_to_match
+        expect(plr.y).to eq(800)
+      end
+      41.times do |n| # ticks 39 - 79
+        update_both
+        $stderr.puts "TICK ##{game.tick}"
+        expect(plr.y).to eq(800 - (10 * n))
+        cplr = window.engine.space.players.first
+        binding.pry unless cplr == plr
+        expect(cplr).to eq(plr)
+        expect_spaces_to_match
+      end
+    end
+  end
+  context "with no registry syncs" do
+    let(:registry_broadcast_every) { 0 }
+    it "is in sync after one update" do
+      window
+      update_both
+
+      expect_spaces_to_match
+    end
+  end
+end