game_2d 0.0.1 → 0.0.2

data/README.md

@@ -11,6 +11,13 @@ There's not much here yet, in terms of actual gameplay.  At this point I'm layin
 * Entity positions and velocities are integers.  Apart from player input, all entities' behaviors are predictable.  This allows the client to make accurate predictions of the server state.
 * New Entities are assigned IDs in order, again, to allow the client to predict which ID will be assigned to each new entity.
 * Clients connect using REnet.  The handshaking process creates a Player object to represent the client.
+* Client and server use Diffie-Hellman key exchange to establish a shared secret.  This is used to encrypt sensitive information, rather like SSH (but over REnet).
+  * Right now, the only sensitive information is the user's password.  This allows the server to remember who's who.
+* On startup, the client prompts the user to enter the password, which is encrypted and then sent to the server along with the player-name.
+* Server keeps a record of each player and their password.
+  * Nothing else interesting here yet, but I fully expect to put an inventory here, once there is anything useful to carry around.
+  * This is also where I plan to put authorization data - who's a god player (level editor) and who isn't.
+  * Player data is persisted in ~/.game_2d/players/players as JSON text.
 * Keyboard commands control the player:
   * A and D, or LeftArrow and RightArrow: Hold down to accelerate.
   * LeftControl or RightControl: Hold down to brake (slow down).
@@ -19,15 +26,19 @@ There's not much here yet, in terms of actual gameplay.  At this point I'm layin
     * When not building: Flip (turn 180 degrees).
     * When building: Rise up (ascend to the top of the built block).
   * Left button: Fire a pellet.  Mouse click determines the direction and speed -- closer to the player means slower speed.
-  * Right button: Build a block where you click.  *(This will eventually become part of a level-editing mode.)*
+  * Right button: Grab an entity and drag it around.  Right-click again to release.  Grab is affected by snap-to-grid.  *(This will eventually become part of a level-editing mode.)*
+  * Shifted right button, or B: Build a block where the mouse points.  *(This will eventually become part of a level-editing mode.)*
+  * 1 through 7: Shortcuts for building Dirt, Brick, Cement, Steel, Unlikelium, Titanium, Teleporter.
+* Mousing over an entity displays some basic information about it.  *(This will eventually become part of a level-editing mode.)*
 * A simple menu system is also available.  Left-click to select.  Esc returns to the top-level.
 * The menus include a Save feature, which tells the server to save the level's state.
-  * Levels are persisted in ~/.game_2d/<level name> as JSON text.
+  * Levels are persisted in ~/.game_2d/levels/<level name> as JSON text.
   * On subsequent startup with the same name, the level is loaded.
 * The client and server communicate using JSON text.  This is undoubtedly inefficient, but aids in debugging at this early stage.
 * Every frame is numbered by the server, and is referred to as a 'tick'.
 * Player actions are both executed locally, and sent to the server.
 * If other players are connected, the server sends everyone's actions to everyone else.
+  * This is obviously insecure.  Validating user data is on my to-do list.
 * Player actions are dated six ticks in the future, to give everyone a chance to get the message early.  That way everyone can execute the action at the same time.
 * The server broadcasts the complete GameSpace four times a second, just in case a client gets out of sync.
 * The client predicts the server state, but treats its own copy as advisory only -- the server's is definitive.
@@ -44,11 +55,13 @@ The physics is (intentionally) pretty simple.  Unsupported objects fall, acceler
 
 When building a block, the longer you hold the S or DownArrow key, the more HP will be awarded to the block.  Hitting a block with a pellet reduces its HP, until it degrades to a lower form.  Dirt blocks with 1 HP will be entirely destroyed when hit.
 
-Whether an object is supported depends exclusively on its immediate surroundings.  That means two objects can support each other, and hang suspended.  For example, a dirt block sitting on a steel block will support each other.  A horizontal row of brick, capped at either end with cement, will also be free-standing.
+Whether a block is supported depends exclusively on its immediate surroundings.  That means two blocks can support each other, and hang suspended.  For example, a dirt block sitting on a steel block will support each other.  A horizontal row of brick, capped at either end with cement, will also be free-standing.
 
-Pellets are fired from the player's center, and are affected by gravity.  They damage whatever they hit first, and disappear.  Pellets won't hit the player who fired them.
+Pellets are fired from the player's center, and are affected by gravity.  They damage whatever they hit first, and disappear.  Pellets won't hit the player who fired them.  So far, only blocks can take damage; players are indestructible (but you know that will change).
 
-There are also Titanium entities, which never fall, and are indestructible.  These are intended for use in designing levels with specific shapes.  They can only be created by using the menu to select Titanium, and then right-clicking.
+There are also Titanium entities, which never fall, and are indestructible.  These are intended for use in designing levels with specific shapes.  They can only be created by using the menu to select Titanium, and then shift-right-clicking.
+
+Teleporters never fall.  Their only action is to transfer their contents (anything close enough to intersect with their center) to their single destination-point.  This transfer affects location but not velocity.  Transfer doesn't happen if there is something blocking the exit point.
 
 A player is considered to be supported if their "feet" are touching a block.  Unsupported players will turn feet-downward and fall, until they land on something.  Supported players may slide left or right, and will follow any edges they reach -- going up and down walls, or hanging under ceilings.  The "flip" maneuver swaps head and feet; this becomes useful if the player's head is exactly touching another block.  At all other times, a flip leads to a fall (which can be useful too).
 

data/bin/game_2d_client.rb

@@ -6,12 +6,13 @@ require 'game_2d/game_window'
 opts = Trollop::options do
   opt :name, "Player name", :type => :string, :required => true
   opt :hostname, "Hostname of server", :type => :string, :required => true
-  opt :port, "Port number", :default => DEFAULT_PORT
+  opt :port, "Port number", :default => GameClient::DEFAULT_PORT
+  opt :key_size, "Key size in bits", :default => 1024
   opt :profile, "Turn on profiling", :type => :boolean
   opt :debug_traffic, "Debug network traffic", :type => :boolean
 end
 
 $debug_traffic = opts[:debug_traffic] || false
 
-window = GameWindow.new( opts[:name], opts[:hostname], opts[:port], opts[:profile] )
+window = GameWindow.new( opts )
 window.show

data/lib/game_2d/client_connection.rb

@@ -1,11 +1,17 @@
 require 'renet'
 require 'json'
+require 'base64'
+require 'openssl'
 require 'game_2d/hash'
+require 'game_2d/encryption'
 
 # The client creates one of these.
 # It is then used for all communication with the server.
 
 class ClientConnection
+  include Encryption
+  include Base64
+
   attr_reader :player_name
   attr_accessor :engine
 
@@ -14,17 +20,31 @@ class ClientConnection
   # the fleet
   ACTION_DELAY = 6 # 1/10 of a second
 
-  def initialize(host, port, game, player_name, timeout=2000)
+  def initialize(host, port, game, player_name, key_size, timeout=2000)
     # remote host address, remote host port, channels, download bandwidth, upload bandwidth
     @socket = _create_connection(host, port, 2, 0, 0)
-    @game = game
-    @player_name = player_name
+    @host, @port, @game, @player_name, @key_size, @timeout =
+     host,  port,  game,  player_name,  key_size,  timeout
 
     @socket.on_connection(method(:on_connect))
     @socket.on_disconnection(method(:on_close))
     @socket.on_packet_receive(method(:on_packet))
 
-    @socket.connect(timeout)
+    @dh = @password_hash = nil
+  end
+
+  def start(password_hash)
+    @password_hash = password_hash
+    Thread.new do
+      @game.display_message! "Establishing encryption (#{@key_size}-bit)..."
+      @dh = OpenSSL::PKey::DH.new(@key_size)
+
+      # 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
+      @game.display_message! "Connecting to #{@host}:#{@port} as #{@player_name}"
+      @socket.connect(@timeout)
+    end
   end
 
   def _create_connection(*args)
@@ -32,9 +52,22 @@ class ClientConnection
   end
 
   def on_connect
-    puts "Connected to server - sending handshake"
-    # send handshake reliably
-    send_record( { :handshake => { :player_name => @player_name } }, true)
+    @game.display_message "Connected, logging in"
+    send_record( { :handshake => {
+      :player_name => @player_name,
+      :dh_public_key => @dh.public_key.to_pem,
+      :client_public_key => @dh.pub_key.to_s
+    } }, true) # send handshake reliably
+  end
+
+  def login(server_public_key)
+    self.key = @dh.compute_key(OpenSSL::BN.new server_public_key)
+    data, iv = encrypt(@password_hash)
+    @password_hash = nil
+    send_record(
+      :password_hash => strict_encode64(data),
+      :iv => strict_encode64(iv)
+    )
   end
 
   def on_close
@@ -46,35 +79,40 @@ class ClientConnection
     hash = JSON.parse(data).fix_keys
     debug_packet('Received', hash)
 
-    pong = hash[:pong]
-    if pong
+    if pong = hash.delete(:pong)
       stop = Time.now.to_f
       puts "Ping took #{stop - pong[:start]} seconds"
     end
 
-    at_tick = hash[:at_tick]
-    fail "No at_tick in #{hash.inspect}" unless at_tick
+    if server_public_key = hash.delete(:server_public_key)
+      login(server_public_key)
+      return
+    end
+
+    # Leave :at_tick intact; add_delta will reuse it
+    fail "No at_tick in #{hash.inspect}" unless at_tick = hash[:at_tick]
 
-    world = hash[:world]
-    if world
+    if world = hash.delete(:world)
+      @game.clear_message
       @engine.establish_world(world, at_tick)
     end
 
+    you_are = hash.delete :you_are
+    registry, highest_id = hash.delete(:registry), hash.delete(:highest_id)
+
     delta_keys = [
       :add_players, :add_npcs, :delete_entities, :update_entities, :update_score, :move
     ]
     @engine.add_delta(hash) if delta_keys.any? {|k| hash.has_key? k}
 
-    you_are = hash[:you_are]
     if you_are
       # The 'world' response includes deltas for add_players and add_npcs
       # Need to process those first, as one of the players is us
-      @engine.apply_all_deltas(at_tick)
+      @engine.apply_deltas(at_tick)
 
       @engine.create_local_player you_are
     end
 
-    registry, highest_id = hash[:registry], hash[:highest_id]
     @engine.sync_registry(registry, highest_id, at_tick) if registry
   end
 
@@ -83,16 +121,32 @@ class ClientConnection
   end
 
   def send_move(move, args={})
-    return unless move
+    return unless move && online?
     args[:move] = move.to_s
     delta = { :at_tick => send_actions_at, :move => args }
     send_record delta
-    delta[:move][:player_id] = @engine.player_id
+    delta[:player_id] = @engine.player_id
     @engine.add_delta delta
   end
 
   def send_create_npc(npc)
-    delta = { :at_tick => send_actions_at, :create_npc => npc }
+    return unless online?
+    # :on_* hooks are for our own use; we don't send them
+    remote_npc = npc.reject {|k,v| k.to_s.start_with? 'on_'}
+    send_record :at_tick => send_actions_at, :add_npcs => [ remote_npc ]
+    @engine.add_delta :at_tick => send_actions_at, :add_npcs => [ npc ]
+  end
+
+  def send_update_entity(entity)
+    return unless online?
+    delta = { :update_entities => [entity], :at_tick => send_actions_at }
+    send_record delta
+    @engine.add_delta delta
+  end
+
+  def send_snap_to_grid(entity)
+    return unless online? && entity
+    delta = { :at_tick => send_actions_at, :snap_to_grid => entity.registry_id }
     send_record delta
     @engine.add_delta delta
   end
@@ -106,6 +160,7 @@ class ClientConnection
   end
 
   def send_record(data, reliable=false)
+    return unless online?
     debug_packet('Sending', data)
     @socket.send_packet(data.to_json, reliable, 0)
     @socket.flush
@@ -123,5 +178,5 @@ class ClientConnection
   end
 
   def online?; @socket.online?; end
-  def disconnect; @socket.disconnect(200); end
+  def disconnect; @socket.disconnect(200) if online?; end
 end

data/lib/game_2d/client_engine.rb

@@ -41,11 +41,15 @@ class ClientEngine
     @width, @height = world[:cell_width], world[:cell_height]
     highest_id = world[:highest_id]
     create_initial_space(at_tick, highest_id)
+    @preprocessed = at_tick
   end
 
+  alias :world_established? :tick
+
   def create_initial_space(at_tick, highest_id)
     @earliest_tick = @tick = at_tick
-    space = @spaces[@tick] = GameSpace.new.establish_world(@world_name, @world_id, @width, @height)
+    space = @spaces[@tick] = GameSpace.new(@game_window).
+      establish_world(@world_name, @world_id, @width, @height)
     space.highest_id = highest_id
     space
   end
@@ -56,20 +60,16 @@ class ClientEngine
     fail "Can't create space at #{tick}; earliest space we know about is #{@earliest_tick}" if tick < @earliest_tick
 
     last_space = space_at(tick - 1)
-    @spaces[tick] = new_space = GameSpace.new.copy_from(last_space)
+    @spaces[tick] = new_space = GameSpace.new(@game_window).copy_from(last_space)
 
-    # Certain deltas, like add_npcs, need to be processed post-update
-    # to match the server's behavior.  An object created during tick T
-    # does not receive its first update until T+1.
-    apply_deltas_before_update(tick)
+    apply_deltas(tick)
     new_space.update
-    apply_deltas_after_update(tick)
 
     new_space
   end
 
   def update
-    return unless @tick # handshake not yet answered
+    return unless world_established?
 
     # Display the frame we received from the server as-is
     if @preprocessed == @tick
@@ -102,6 +102,7 @@ class ClientEngine
 
   def add_delta(delta)
     at_tick = delta.delete :at_tick
+    fail "Received delta without at_tick: #{delta.inspect}" unless at_tick
     if at_tick < @tick
       $stderr.puts "Received delta #{@tick - at_tick} ticks late"
       if at_tick <= @earliest_tick
@@ -114,42 +115,37 @@ class ClientEngine
     @deltas[at_tick] << delta
   end
 
-  def apply_deltas_before_update(at_tick)
+  def apply_deltas(at_tick)
     space = space_at(at_tick)
 
     @deltas[at_tick].each do |hash|
-      players = hash[:add_players]
+      players = hash.delete :add_players
       add_players(space, players) if players
 
-      doomed = hash[:delete_entities]
+      doomed = hash.delete :delete_entities
       delete_entities(space, doomed) if doomed
 
-      updated = hash[:update_entities]
+      updated = hash.delete :update_entities
       update_entities(space, updated) if updated
 
-      move = hash[:move]
-      apply_move(space, move) if move
-
-      score_update = hash[:update_score]
-      update_score(space, score_update) if score_update
-    end
-  end
-
-  def apply_deltas_after_update(at_tick)
-    space = space_at(at_tick)
+      snap = hash.delete :snap_to_grid
+      space.snap_to_grid(snap.to_sym) if snap
 
-    @deltas[at_tick].each do |hash|
-      npcs = hash[:add_npcs]
+      npcs = hash.delete :add_npcs
       add_npcs(space, npcs) if npcs
-    end
 
-    # Any later spaces are now invalid
-    @spaces.delete_if {|key, _| key > at_tick}
-  end
+      move = hash.delete :move
+      player_id = hash.delete :player_id
+      if move
+        fail "No player_id sent with move #{move.inspect}" unless player_id
+        apply_move(space, move, player_id.to_sym)
+      end
 
-  def apply_all_deltas(at_tick)
-    apply_deltas_before_update(at_tick)
-    apply_deltas_after_update(at_tick)
+      score_update = hash.delete :update_score
+      update_score(space, score_update) if score_update
+
+      $stderr.puts "Unprocessed deltas: #{hash.keys.join(', ')}" unless hash.empty?
+    end
   end
 
   def add_player(space, hash)
@@ -163,15 +159,18 @@ class ClientEngine
     players.each {|json| add_player(space, json) }
   end
 
-  def apply_move(space, move)
-    player_id = move[:player_id]
+  def apply_move(space, move, player_id)
     player = space[player_id]
     fail "No such player #{player_id}, can't apply #{move.inspect}" unless player
     player.add_move move
   end
 
   def add_npcs(space, npcs)
-    npcs.each {|json| space << Serializable.from_json(json) }
+    npcs.each do |json|
+      on_create = json.delete :on_create
+      space << (entity = Serializable.from_json(json))
+      on_create.call(entity) if on_create
+    end
   end
 
   def add_entity(space, json)
@@ -188,6 +187,7 @@ class ClientEngine
 
       if my_obj = space[registry_id]
         my_obj.update_from_json(json)
+        my_obj.grab!
       else
         add_entity(space, json)
       end
@@ -215,6 +215,7 @@ class ClientEngine
   # Discard anything we think we know, in favor of the registry
   # we just got from the server
   def sync_registry(server_registry, highest_id, at_tick)
+    return unless world_established?
     @spaces.clear
     # Any older deltas are now irrelevant
     @earliest_tick.upto(at_tick - 1) {|old_tick| @deltas.delete old_tick}

data/lib/game_2d/complex_move.rb

@@ -36,7 +36,7 @@ class ComplexMove
     Serializable.as_json(self).merge!(:actor_id => actor_id)
   end
   def update_from_json(json)
-    self.actor_id = json[:actor_id]
+    self.actor_id = json[:actor_id] if json[:actor_id]
     self
   end
   def to_s

data/lib/game_2d/encryption.rb

@@ -0,0 +1,35 @@
+require 'openssl'
+
+module Encryption
+
+  def key=(key)
+    @symmetric_key = key
+  end
+
+  def make_cipher
+    OpenSSL::Cipher::AES.new(128, :CBC)
+  end
+
+  # Returns [encrypted, iv]
+  def encrypt(data)
+    cipher = make_cipher.encrypt
+    cipher.key = @symmetric_key
+    iv = cipher.random_iv
+    [cipher.update(data) + cipher.final, iv]
+  end
+
+  def decrypt(data, iv)
+    decipher = make_cipher.decrypt
+    decipher.key = @symmetric_key
+    decipher.iv = iv
+    decipher.update(data) + decipher.final
+  end
+
+  # Same sort of thing /etc/passwd uses.
+  # Provides no security against snooping passwords off
+  # the wire, but does make it safer to handle the user
+  # password file.
+  def make_password_hash(password)
+    password.crypt('RB')
+  end
+end

data/lib/game_2d/entity.rb

@@ -3,6 +3,7 @@ require 'facets/kernel/constant'
 require 'game_2d/registerable'
 require 'game_2d/serializable'
 require 'game_2d/entity_constants'
+require 'game_2d/transparency'
 
 class NilClass
   # Ignore this
@@ -10,9 +11,35 @@ class NilClass
 end
 
 class Entity
+  include EntityConstants
+
+  module ClassMethods
+    include EntityConstants
+    # Left-most cell X position occupied
+    def left_cell_x_at(x); x / WIDTH; end
+
+    # Right-most cell X position occupied
+    # If we're exactly within a column (@x is an exact multiple of WIDTH),
+    # then this equals left_cell_x.  Otherwise, it's one higher
+    def right_cell_x_at(x); (x + WIDTH - 1) / WIDTH; end
+
+    # Top-most cell Y position occupied
+    def top_cell_y_at(y); y / HEIGHT; end
+
+    # Bottom-most cell Y position occupied
+    def bottom_cell_y_at(y); (y + HEIGHT - 1) / HEIGHT; end
+
+    # Velocity is constrained to the range -MAX_VELOCITY .. MAX_VELOCITY
+    def constrain_velocity(vel)
+      [[vel, MAX_VELOCITY].min, -MAX_VELOCITY].max
+    end
+  end
+  include ClassMethods
+  extend ClassMethods
+
   include Serializable
   include Registerable
-  include EntityConstants
+  include Transparency
 
   # X and Y position of the top-left corner
   attr_accessor :x, :y, :moving, :space
@@ -27,16 +54,16 @@ class Entity
     @x, @y, self.a = x, y, a
     self.x_vel, self.y_vel = x_vel, y_vel
     @moving = true
+    @grabbed = false
   end
 
   def a=(angle); @a = angle % 360; end
 
-  # Velocity is constrained to the range -MAX_VELOCITY .. MAX_VELOCITY
   def x_vel=(xv)
-    @x_vel = [[xv, MAX_VELOCITY].min, -MAX_VELOCITY].max
+    @x_vel = constrain_velocity xv
   end
   def y_vel=(yv)
-    @y_vel = [[yv, MAX_VELOCITY].min, -MAX_VELOCITY].max
+    @y_vel = constrain_velocity yv
   end
 
   # True if we need to update this entity
@@ -60,6 +87,12 @@ class Entity
     @moving = true
   end
 
+  # Entity is under direct control by a player
+  # This is transitory state (not persisted or copied)
+  def grab!; @grabbed = true; end
+  def release!; @grabbed = false; end
+  def grabbed?; @grabbed; end
+
   # Give this entity a chance to perform clean-up upon destruction
   def destroy!; end
 
@@ -68,24 +101,10 @@ class Entity
   def pixel_x; @x / PIXEL_WIDTH; end
   def pixel_y; @y / PIXEL_WIDTH; end
 
-  # Left-most cell X position occupied
-  def self.left_cell_x_at(x); x / WIDTH; end
-  # TODO: Find a more elegant way to call class methods in Ruby...
-  def left_cell_x(x = @x); self.class.left_cell_x_at(x); end
-
-  # Right-most cell X position occupied
-  # If we're exactly within a column (@x is an exact multiple of WIDTH),
-  # then this equals left_cell_x.  Otherwise, it's one higher
-  def self.right_cell_x_at(x); (x + WIDTH - 1) / WIDTH; end
-  def right_cell_x(x = @x); self.class.right_cell_x_at(x); end
-
-  # Top-most cell Y position occupied
-  def self.top_cell_y_at(y); y / HEIGHT; end
-  def top_cell_y(y = @y); self.class.top_cell_y_at(y); end
-
-  # Bottom-most cell Y position occupied
-  def self.bottom_cell_y_at(y); (y + HEIGHT - 1) / HEIGHT; end
-  def bottom_cell_y(y = @y); self.class.bottom_cell_y_at(y); end
+  def left_cell_x(x = @x); left_cell_x_at(x); end
+  def right_cell_x(x = @x); right_cell_x_at(x); end
+  def top_cell_y(y = @y); top_cell_y_at(y); end
+  def bottom_cell_y(y = @y); bottom_cell_y_at(y); end
 
   # Returns an array of one, two, or four cell-coordinate tuples
   # E.g. [[4, 5], [4, 6], [5, 5], [5, 6]]
@@ -101,13 +120,8 @@ class Entity
     self.y_vel = @y_vel + y_accel
   end
 
-  # Override to make particular entities transparent to each other
-  def transparent_to_me?(other)
-    other == self
-  end
-
   def opaque(others)
-    others.delete_if {|obj| transparent_to_me?(obj)}
+    others.delete_if {|obj| obj.equal?(self) || transparent?(self, obj)}
   end
 
   # Wrapper around @space.entities_overlapping
@@ -193,10 +207,11 @@ class Entity
   end
 
   # Update position/velocity/angle data, and tell the space about it
-  def warp(x, y, x_vel, y_vel, angle=self.a, moving=@moving)
+  def warp(x, y, x_vel=nil, y_vel=nil, angle=nil, moving=nil)
     blk = proc do
       @x, @y, self.x_vel, self.y_vel, self.a, @moving =
-        x, y, x_vel, y_vel, angle, moving
+        (x || @x), (y || @y), (x_vel || @x_vel), (y_vel || @y_vel), (angle || @a),
+        (moving.nil? ? @moving : moving)
     end
     if @space
       @space.process_moving_entity(self, &blk)
@@ -354,12 +369,13 @@ class Entity
     img.draw_rot(
       self.pixel_x + CELL_WIDTH_IN_PIXELS / 2,
       self.pixel_y + CELL_WIDTH_IN_PIXELS / 2,
-      draw_zorder, self.a)
+      draw_zorder, draw_angle)
     # 0.5, 0.5, # rotate around the center
     # 1, 1, # scaling factor
     # @color, # modify color
     # :add) # draw additively
   end
+  def draw_angle; a; end
 
   def to_s
     "#{self.class} (#{registry_id_safe}) at #{x}x#{y}"