game_2d 0.0.1 → 0.0.2

data/lib/game_2d/menu.rb

@@ -9,7 +9,7 @@ class Menu
     @right = window.width - 1
     @choices.each_with_index do |choice, num|
       choice.x = @right
-      choice.y = (num + 2) * 20
+      choice.y = (num + 2) * @font.height
     end
   end
 
@@ -17,7 +17,7 @@ class Menu
     str = to_s
     @font.draw_rel(str, @window.width - 1, 0, ZOrder::Text, 1.0, 0.0, 1.0, 1.0,
       @main_color)
-    x1, x2, y, c = @right - @font.text_width(str), @right, 20, @main_color
+    x1, x2, y, c = @right - @font.text_width(str), @right, @font.height, @main_color
     @window.draw_box_at(x1, y, x2, y+1, @main_color)
     @choices.each(&:draw)
   end
@@ -53,7 +53,7 @@ class MenuItem
   def left; @x - @font.text_width(to_s); end
   def right; @x; end
   def top; @y; end
-  def bottom; @y + 20; end
+  def bottom; @y + @font.height; end
 
   def draw
     selected = mouse_over?

data/lib/game_2d/message.rb

@@ -0,0 +1,37 @@
+require 'gosu'
+require 'game_2d/zorder'
+
+class Message
+  def initialize(window, font, lines)
+    @window, @font, @lines = window, font, lines
+
+    @fg_color, @bg_color = Gosu::Color::YELLOW, Gosu::Color::BLACK
+    @drawn = false
+  end
+
+  attr_reader :lines
+  def lines=(new_lines)
+    @lines, @drawn = new_lines, false
+  end
+
+  def draw
+    count = @lines.size
+    line_height = @font.height
+    lines_height = line_height * count
+    lines_top = (@window.height - (count * line_height)) / 2
+    x_center = @window.width / 2
+    @lines.each_with_index do |line, n|
+      @font.draw_rel(line, x_center, lines_top + (line_height * n), ZOrder::Text,
+        0.5, 0.0, 1.0, 1.0, @fg_color)
+    end
+    max_width = @lines.collect {|line| @font.text_width(line)}.max
+    lines_bottom = lines_top + (line_height * count)
+    left = x_center - (max_width / 2)
+    right = x_center + (max_width / 2)
+    @window.draw_box_at(left - 1, lines_top - 1, right + 1, lines_bottom + 1, @fg_color)
+    @window.draw_box_at(left, lines_top, right, lines_bottom, @bg_color)
+    @drawn = true
+  end
+
+  def drawn?; @drawn; end
+end

data/lib/game_2d/move/rise_up.rb

@@ -64,8 +64,8 @@ class RiseUp < ComplexMove
       :distance => @distance
   end
   def update_from_json(json)
-    self.stage = json[:stage].to_sym
-    self.distance = json[:distance]
+    self.stage = json[:stage].to_sym if json[:stage]
+    self.distance = json[:distance] if json[:distance]
     super
   end
   def to_s

data/lib/game_2d/password_dialog.rb

@@ -0,0 +1,44 @@
+require 'gosu'
+require 'game_2d/message'
+require 'game_2d/encryption'
+
+class PasswordDialog < Message
+  include Encryption
+
+  PROMPT = 'Enter password:'
+  PRINTABLE_ASCII = (32..126).to_a.pack 'C*'
+
+  def initialize(window, font)
+    super(window, font, [PROMPT, '_'])
+    @text = @window.text_input = Gosu::TextInput.new
+    @draw_count = 0
+  end
+
+  def display_text
+    size = password.size
+    return '_' if size.zero?
+    rand_char = PRINTABLE_ASCII[
+      (@draw_count / 10) * 53 % PRINTABLE_ASCII.size
+    ]
+    rand_char * size
+  end
+
+  def draw
+    @draw_count += 1
+    self.lines = [PROMPT, display_text]
+    super
+  end
+
+  def enter
+    @window.text_input = nil
+  end
+
+  def password
+    @text.text
+  end
+  private :password
+
+  def password_hash
+    make_password_hash password
+  end
+end

data/lib/game_2d/player.rb

@@ -30,7 +30,6 @@ class Player < Entity
     @score = 0
     @moves = []
     @current_move = nil
-    @falling = false
     @build_block_id = nil
     @build_level = 0
     @complex_move = nil
@@ -38,7 +37,12 @@ class Player < Entity
 
   def sleep_now?; false; end
 
-  def falling?; @falling; end
+  def underfoot
+    opaque(next_to(self.a + 180))
+  end
+  def falling?
+    underfoot.empty?
+  end
 
   def build_block_id=(new_id)
     @build_block_id = new_id.try(:to_sym)
@@ -56,13 +60,6 @@ class Player < Entity
     build_block.owner_id = nil if building?
   end
 
-  # Pellets don't hit the originating player
-  def transparent_to_me?(other)
-    super ||
-    (other == build_block) ||
-    (other.is_a?(Pellet) && other.owner == self)
-  end
-
   def update
     fail "No space set for #{self}" unless @space
     check_for_disown_block
@@ -74,8 +71,7 @@ class Player < Entity
       @complex_move = nil
     end
 
-    underfoot = next_to(self.a + 180)
-    if @falling = underfoot.empty?
+    if falling = falling?
       self.a = 0
       accelerate(0, 1)
     end
@@ -83,7 +79,7 @@ class Player < Entity
     args = @moves.shift
     case (current_move = args.delete(:move).to_sym)
       when :slide_left, :slide_right, :brake, :flip, :build, :rise_up
-        send current_move unless @falling
+        send current_move unless falling
       when :fire
         fire args[:x_vel], args[:y_vel]
       else
@@ -91,8 +87,9 @@ class Player < Entity
     end if args
 
     # Only go around corner if sitting on exactly one object
-    if underfoot.size == 1
-      other = underfoot.first
+    blocks_underfoot = underfoot
+    if blocks_underfoot.size == 1
+      other = blocks_underfoot.first
       # Figure out where corner is and whether we're about to reach or pass it
       corner, distance, overshoot, turn = going_past_entity(other.x, other.y)
       if corner
@@ -230,10 +227,10 @@ class Player < Entity
   end
 
   def update_from_json(json)
-    @player_name = json[:player_name]
-    @score = json[:score]
-    @build_block_id = json[:build_block].try(:to_sym)
-    @complex_move = Serializable.from_json(json[:complex_move])
+    @player_name = json[:player_name] if json[:player_name]
+    @score = json[:score] if json[:score]
+    @build_block_id = json[:build_block].try(:to_sym) if json[:build_block]
+    @complex_move = Serializable.from_json(json[:complex_move]) if json[:complex_move]
     super
   end
 

data/lib/game_2d/registerable.rb

@@ -19,7 +19,7 @@ module Registerable
 
   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
+    raise "#{self}: Nil ID" unless id
     @registry_id = id.to_sym
   end
 end

data/lib/game_2d/serializable.rb

@@ -37,10 +37,9 @@ module Serializable
     self.class.name
   end
 
-  def self.from_json(json, generate_id=false)
+  def self.from_json(json)
     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::') ||
@@ -49,18 +48,8 @@ module Serializable
     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")
+      it.registry_id = json[:registry_id] if json[:registry_id]
     end
 
     it.update_from_json(json)

data/lib/game_2d/server_connection.rb

@@ -1,37 +1,59 @@
 require 'json'
+require 'base64'
+require 'openssl'
 require 'game_2d/hash'
+require 'game_2d/encryption'
 
 # An instance of this class is created by ServerPort whenever an
 # incoming connection is accepted.
 
 class ServerConnection
+  include Encryption
+  include Base64
 
   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
+  attr_reader :id, :player_id
 
+  def answer_handshake(handshake)
+    @player_name = handshake[:player_name]
+    dh_public_key = handshake[:dh_public_key]
+    client_public_key = handshake[:client_public_key]
+    dh = OpenSSL::PKey::DH.new(dh_public_key)
+    dh.generate_key!
+    self.key = dh.compute_key(OpenSSL::BN.new client_public_key)
     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,
+      :server_public_key => dh.pub_key.to_s
     }
+    send_record response, true # answer reliably
+  end
+
+  def answer_login(b64_password_hash, b64_iv)
+    password_hash = decrypt(
+      strict_decode64(b64_password_hash),
+      strict_decode64(b64_iv))
+    player_data = @game.player_data(@player_name)
+    if player_data
+      unless password_hash == player_data[:password_hash]
+        $stderr.puts "Wrong password for #{@player_name} (#{password_hash} != #{player_data[:password_hash]})"
+        disconnect!
+        return
+      end
+    else # new player
+      @game.store_player_data @player_name, :password_hash => password_hash
+    end
+
+    player = @game.add_player(@player_name)
+    @player_id = player.registry_id
+    @port.register_player @player_id, self
     puts "#{player} logs in from #{@remote_addr} at <#{@game.tick}>"
-    send_record response, true # answer handshake reliably
+
+    # We don't send the registry here.  The Game will do it after
+    # all logins have been processed and the update has completed.
+    # Otherwise, we're sending an incomplete frame.
   end
 
   def player
@@ -64,6 +86,7 @@ class ServerConnection
   end
 
   def close
+    return unless @player_id
     @port.deregister_player @player_id
     toast = player
     puts "#{toast} -- #{@remote_addr} disconnected at <#{@game.tick}>"
@@ -73,17 +96,22 @@ class ServerConnection
   def on_packet(data, channel)
     hash = JSON.parse(data).fix_keys
     debug_packet('Received', hash)
-    if (handshake = hash[:handshake])
+    if handshake = hash.delete(:handshake)
       answer_handshake(handshake)
-    elsif (hash[:save])
+    elsif password_hash = hash.delete(:password_hash)
+      answer_login(password_hash, hash.delete(:iv))
+    elsif hash.delete(:save)
       @game.save
-    elsif (ping = hash[:ping])
+    elsif ping = hash.delete(:ping)
       answer_ping ping
     else
-      @game.add_player_action @player_id, hash
-      @port.broadcast_player_action @id,
-        hash.merge(:player_id => @player_id),
-        channel
+      if hash[:player_id] = @player_id
+        @game.add_player_action hash
+        # TODO: Validate
+        @port.broadcast_player_action hash, channel
+      else
+        $stderr.puts "Ignoring move #{hash.inspect}, no player_id for this connection"
+      end
     end
   end
 
@@ -101,4 +129,8 @@ class ServerConnection
     keys = hash.keys - [:at_tick]
     puts "#{direction} #{keys.join(', ')} <#{at_tick}>"
   end
+
+  def disconnect!
+    @server.disconnect_client(@id)
+  end
 end

data/lib/game_2d/server_port.rb

@@ -1,3 +1,4 @@
+require 'set'
 require 'renet'
 require 'json'
 require 'game_2d/server_connection'
@@ -10,6 +11,7 @@ class ServerPort
 
     @clients = {}
     @player_connections = {}
+    @new_players = Set.new
 
     @server.on_connection method(:on_connection)
     @server.on_packet_receive method(:on_packet_receive)
@@ -36,28 +38,32 @@ class ServerPort
     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
+    @new_players << player_id
   end
 
   def deregister_player(player_id)
     @player_connections.delete player_id
   end
 
+  def new_players
+    copy = @new_players.dup
+    @new_players.clear
+    copy
+  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)
+  def broadcast_player_action(hash, channel)
+    sender_player_id = hash[:player_id]
+    fail "No player_id in #{hash.inspect}" unless sender_player_id
     data = hash.to_json
-    @clients.keys.each do |id|
-      @server.send_packet(id, data, false, channel) unless id == sender_id
+    @player_connections.each do |player_id, conn|
+      @server.send_packet(conn.id, data, false, channel) unless player_id == sender_player_id
     end
     @server.flush
   end

data/lib/game_2d/transparency.rb

@@ -0,0 +1,59 @@
+require 'game_2d/entity'
+require 'game_2d/entity/block'
+require 'game_2d/entity/titanium'
+require 'game_2d/entity/owned_entity'
+require 'game_2d/entity/teleporter'
+require 'game_2d/entity/destination'
+require 'game_2d/wall'
+
+module Transparency
+  def transparent?(one, two)
+    # Walls and titanium: transparent to absolutely nothing
+    return false if wall?(one) || wall?(two)
+
+    # Teleporter destinations: transparent to everything
+    return true if destination?(one) || destination?(two)
+
+    # Teleporters: transparent to everything except other
+    # teleporters, and destinations
+    return teleporter_ok?(one, two) if teleporter?(one)
+    return teleporter_ok?(two, one) if teleporter?(two)
+
+    # Owned entities are transparent to the owner, and other
+    # objects with the same owner
+    return related_by_owner?(one, two) if owned?(one)
+    return related_by_owner?(two, one) if owned?(two)
+
+    # Should only get here if both objects are players
+    fail("Huh?  one=#{one}, two=#{two}") unless
+      one.is_a?(Player) && two.is_a?(Player)
+    false
+  end
+
+  private
+  def wall?(entity)
+    entity.is_a?(Wall) || entity.is_a?(Entity::Titanium)
+  end
+
+  def teleporter_ok?(tp, other)
+    !teleporter?(other)
+  end
+
+  def teleporter?(entity)
+    entity.is_a?(Entity::Teleporter)
+  end
+
+  def destination?(entity)
+    entity.is_a?(Entity::Destination)
+  end
+
+  def related_by_owner?(o, other)
+    return false unless o.owner
+    other.registry_id == o.owner_id ||
+      (other.is_a?(Entity::OwnedEntity) && other.owner_id == o.owner_id)
+  end
+
+  def owned?(entity)
+    entity.is_a? Entity::OwnedEntity
+  end
+end