game_2d 0.0.2 → 0.0.3

data/lib/game_2d/serializable.rb

@@ -40,8 +40,8 @@ module Serializable
   def self.from_json(json)
     return nil unless json
     class_name = json[:class]
-    raise "Suspicious class name: #{class_name}" unless
-      (class_name == 'Player') ||
+    fail "No class name in #{json.inspect}" unless class_name
+    fail "Suspicious class name in #{json.inspect}: #{class_name}" unless
       (class_name.start_with? 'Entity::') ||
       (class_name.start_with? 'Move::')
     require "game_2d/#{class_name.pathize}"

data/lib/game_2d/server_connection.rb

@@ -14,11 +14,19 @@ 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}"
+    @authenticated = false
   end
 
-  attr_reader :id, :player_id
+  attr_reader :id, :player_name, :authenticated
+  attr_accessor :player_id
+  def authenticated?; @authenticated; end
 
   def answer_handshake(handshake)
+    if authenticated?
+      warn "#{self} cannot re-handshake"
+      disconnect!
+      return
+    end
     @player_name = handshake[:player_name]
     dh_public_key = handshake[:dh_public_key]
     client_public_key = handshake[:client_public_key]
@@ -32,23 +40,29 @@ class ServerConnection
   end
 
   def answer_login(b64_password_hash, b64_iv)
+    if authenticated?
+      warn "#{self} cannot re-login"
+      disconnect!
+      return
+    end
     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]})"
+        warn "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
+    @authenticated = true
 
+    @port.register_player @player_name, self
     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}>"
 
     # We don't send the registry here.  The Game will do it after
@@ -82,15 +96,11 @@ class ServerConnection
 
   # Not called yet...
   def update_score(player, at_tick)
-    send_record :update_score => { player.registry_id => player.score }, :at_tick => at_tick
+    send_record :update_score => { player.player_name => player.score }, :at_tick => at_tick
   end
 
   def close
-    return unless @player_id
-    @port.deregister_player @player_id
-    toast = player
-    puts "#{toast} -- #{@remote_addr} disconnected at <#{@game.tick}>"
-    @game.delete_entity toast
+    @game.send_player_gone player
   end
 
   def on_packet(data, channel)
@@ -100,18 +110,18 @@ class ServerConnection
       answer_handshake(handshake)
     elsif password_hash = hash.delete(:password_hash)
       answer_login(password_hash, hash.delete(:iv))
-    elsif hash.delete(:save)
-      @game.save
     elsif ping = hash.delete(:ping)
       answer_ping ping
+    elsif !authenticated?
+      warn "Ignoring #{hash.inspect}, not authenticated"
+    elsif hash.delete(:save)
+      @game.save
     else
-      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
+      hash[:player_name] = @player_name
+      hash[:player_id] = @player_id
+      @game.add_player_action hash
+      # TODO: Validate
+      @port.broadcast_player_action hash, channel
     end
   end
 
@@ -133,4 +143,8 @@ class ServerConnection
   def disconnect!
     @server.disconnect_client(@id)
   end
+
+  def to_s
+    "#{@player_name || '??'} ##{@id} from #{@remote_addr}"
+  end
 end

data/lib/game_2d/server_port.rb

@@ -10,7 +10,7 @@ class ServerPort
     puts "ENet server listening on #{port_number}"
 
     @clients = {}
-    @player_connections = {}
+    @player_connections = {} # player_name => ServerConnection
     @new_players = Set.new
 
     @server.on_connection method(:on_connection)
@@ -34,17 +34,26 @@ class ServerPort
   def on_disconnection(id)
     puts "ENet connection #{id} disconnected"
     gone = @clients.delete id
-    gone.close
+    deregister_player(gone)
     puts "Remaining connection IDs: #{@clients.keys.sort.join(', ')}"
   end
 
-  def register_player(player_id, conn)
-    @player_connections[player_id] = conn
-    @new_players << player_id
+  def register_player(player_name, conn)
+    if old_conn = @player_connections[player_name]
+      warn "Disconnecting old connection for #{player_name} (#{old_conn})"
+      old_conn.disconnect!
+    end
+    @player_connections[player_name] = conn
+    @new_players << player_name
   end
 
-  def deregister_player(player_id)
-    @player_connections.delete player_id
+  def deregister_player(conn)
+    player_name = conn.player_name
+    if conn.authenticated? && @player_connections[player_name] == conn
+      puts "Player #{player_name} logged out at <#{@game.tick}>"
+      @player_connections.delete player_name
+      conn.close
+    end
   end
 
   def new_players
@@ -53,17 +62,17 @@ class ServerPort
     copy
   end
 
-  def player_connection(player_id)
-    @player_connections[player_id]
+  def player_name_connection(player_name)
+    @player_connections[player_name]
   end
 
   # Re-broadcast to everyone except the original sender
-  def broadcast_player_action(hash, channel)
-    sender_player_id = hash[:player_id]
-    fail "No player_id in #{hash.inspect}" unless sender_player_id
+  def broadcast_player_action(hash, channel=0)
+    sender_player_name = hash[:player_name]
+    fail "No player_name in #{hash.inspect}" unless sender_player_name
     data = hash.to_json
-    @player_connections.each do |player_id, conn|
-      @server.send_packet(conn.id, data, false, channel) unless player_id == sender_player_id
+    @player_connections.each do |player_name, conn|
+      @server.send_packet(conn.id, data, false, channel) unless player_name == sender_player_name
     end
     @server.flush
   end

data/lib/game_2d/transparency.rb

@@ -1,41 +1,62 @@
 require 'game_2d/entity'
+require 'game_2d/entity/base'
 require 'game_2d/entity/block'
-require 'game_2d/entity/titanium'
+require 'game_2d/entity/destination'
+require 'game_2d/entity/ghost'
+require 'game_2d/entity/hole'
 require 'game_2d/entity/owned_entity'
+require 'game_2d/entity/slime'
 require 'game_2d/entity/teleporter'
-require 'game_2d/entity/destination'
+require 'game_2d/entity/titanium'
 require 'game_2d/wall'
 
 module Transparency
   def transparent?(one, two)
-    # Walls and titanium: transparent to absolutely nothing
+    # Walls: transparent to absolutely nothing
     return false if wall?(one) || wall?(two)
 
-    # Teleporter destinations: transparent to everything
-    return true if destination?(one) || destination?(two)
+    # Ghosts: transparent to everything except a wall
+    return true if ghost?(one) || ghost?(two)
+
+    # Titanium: transparent to nothing except ghosts
+    return false if titanium?(one) || titanium?(two)
+
+    # Holes and teleporter destinations: transparent to
+    # everything except walls and titanium
+    return true if transparent_to_most?(one) || transparent_to_most?(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)
+    # teleporters
+    return teleporter_ok?(two) if teleporter?(one)
+    return teleporter_ok?(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
+    # Bases are transparent to players, only
+    return player?(two) if base?(one)
+    return player?(one) if base?(two)
+
+    # Default case: opaque
+    # Should only get here if both objects are non-ghost players,
+    # or slime
     fail("Huh?  one=#{one}, two=#{two}") unless
-      one.is_a?(Player) && two.is_a?(Player)
+      normal?(one) && normal?(two)
     false
   end
 
   private
   def wall?(entity)
-    entity.is_a?(Wall) || entity.is_a?(Entity::Titanium)
+    entity.is_a?(Wall)
+  end
+
+  def titanium?(entity)
+    entity.is_a?(Entity::Titanium)
   end
 
-  def teleporter_ok?(tp, other)
+  def teleporter_ok?(other)
     !teleporter?(other)
   end
 
@@ -43,8 +64,8 @@ module Transparency
     entity.is_a?(Entity::Teleporter)
   end
 
-  def destination?(entity)
-    entity.is_a?(Entity::Destination)
+  def transparent_to_most?(entity)
+    entity.is_a?(Entity::Destination) || entity.is_a?(Entity::Hole)
   end
 
   def related_by_owner?(o, other)
@@ -56,4 +77,20 @@ module Transparency
   def owned?(entity)
     entity.is_a? Entity::OwnedEntity
   end
-end
+
+  def base?(entity)
+    entity.is_a? Entity::Base
+  end
+
+  def ghost?(entity)
+    entity.is_a? Entity::Ghost
+  end
+
+  def player?(entity)
+    entity.is_a?(Player)
+  end
+
+  def normal?(entity)
+    player?(entity) || entity.is_a?(Entity::Slime)
+  end
+end

data/lib/game_2d/version.rb

@@ -1,3 +1,3 @@
 module Game2d
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/spec/block_spec.rb

@@ -0,0 +1,158 @@
+require 'game_2d/game_space'
+require 'game_2d/entity/block'
+require 'game_2d/entity/titanium'
+
+describe Entity::Block do
+  let(:world) { GameSpace.new(nil).establish_world('lump', nil, 3, 3) }
+
+  subject { world << Entity::Block.new(400, 400) }
+
+  def add_titanium(x, y)
+    world << Entity::Titanium.new(x, y)
+  end
+
+  def expect_new_height(height)
+    expect(subject.y).to eq(height)
+  end
+
+  context "when 5 HP or less" do
+    before(:each) { subject.hp = 1 }
+
+    it "is level 0 (dirt)" do
+      expect(subject.level_name).to eq('dirt')
+      expect(subject.level).to eq(0)
+    end
+    it "falls when nothing underneath" do
+      add_titanium 400, 0   # above
+      add_titanium 0, 400   # on left
+      add_titanium 800, 400 # on right
+      add_titanium 0, 800   # lower-left
+      add_titanium 800, 800   # lower-right
+      world.update; expect_new_height 401
+    end
+    it "doesn't fall when something directly underneath" do
+      add_titanium 400, 800
+      world.update; expect_new_height 400
+    end
+    it "doesn't fall when something slightly underneath" do
+      add_titanium 1, 800
+      world.update; expect_new_height 400
+    end
+  end
+
+  context "when 6 to 10 HP" do
+    before(:each) { subject.hp = 10 }
+
+    it "is level 1 (brick)" do
+      expect(subject.level_name).to eq('brick')
+      expect(subject.level).to eq(1)
+    end
+    it "falls when supported on left only" do
+      add_titanium 400, 0   # above
+      add_titanium 0, 400   # on left
+      world.update; expect_new_height 401
+    end
+    it "falls when supported on right only" do
+      add_titanium 400, 0   # above
+      add_titanium 800, 400   # on right
+      world.update; expect_new_height 401
+    end
+    it "doesn't fall when supported on both sides" do
+      add_titanium 0, 400   # on left
+      add_titanium 800, 400   # on right
+      world.update; expect_new_height 400
+    end
+    it "falls if the supports don't line up with each other" do
+      add_titanium 0, 400   # on left, perfect
+      add_titanium 800, 401   # on right, a bit low
+      world.update; expect_new_height 401
+      world.update; expect_new_height 403
+    end
+    it "falls until the supports line up with it" do
+      add_titanium 0, 402   # on left, a bit below
+      add_titanium 800, 402   # on right, same distance below
+      world.update; expect_new_height 401
+      world.update; expect_new_height 402
+      world.update; expect_new_height 402
+    end
+    it "rises until the supports line up with it" do
+      subject.y_vel = -10
+      add_titanium 0, 385   # on left, a bit above
+      add_titanium 800, 385   # on right, same distance above
+      world.update; expect_new_height 391
+      world.update; expect_new_height 385
+      world.update; expect_new_height 385
+    end
+  end
+
+  context "when 11 to 15 HP" do
+    before(:each) { subject.hp = 11 }
+
+    it "is level 2 (cement)" do
+      expect(subject.level_name).to eq('cement')
+      expect(subject.level).to eq(2)
+    end
+    it "falls when supported on top only" do
+      add_titanium 400, 0   # above
+      world.update; expect_new_height 401
+    end
+    it "doesn't fall when supported on left only" do
+      add_titanium 0, 400   # on left
+      world.update; expect_new_height 400
+    end
+    it "doesn't fall when supported on right only" do
+      add_titanium 800, 400   # on right
+      world.update; expect_new_height 400
+    end
+    it "doesn't fall when supported on both sides" do
+      add_titanium 0, 400   # on left
+      add_titanium 800, 400   # on right
+      world.update; expect_new_height 400
+    end
+    it "falls if the support doesn't line up" do
+      add_titanium 0, 398   # on left, a bit high
+      world.update; expect_new_height 401
+    end
+    it "falls until the support lines up" do
+      add_titanium 0, 402   # on left, a bit below
+      add_titanium 800, 403   # on right, a bit further below
+      world.update; expect_new_height 401
+      world.update; expect_new_height 402
+      world.update; expect_new_height 402
+    end
+  end
+
+  context "when 16 to 20 HP" do
+    before(:each) { subject.hp = 20 }
+
+    it "is level 3 (steel)" do
+      expect(subject.level_name).to eq('steel')
+      expect(subject.level).to eq(3)
+    end
+    it "doesn't fall when supported on top only, directly" do
+      add_titanium 400, 0   # above
+      world.update; expect_new_height 400
+    end
+    it "doesn't fall when supported on top only, slightly touching" do
+      add_titanium 0, 1   # above, far over
+      world.update; expect_new_height 400
+    end
+    it "falls when not touching anything" do
+      add_titanium 0, 0   # upper-left
+      world.update; expect_new_height 401
+    end
+  end
+
+  context "when abve 20 HP" do
+    before(:each) { subject.hp = 21 }
+
+    it "is level 4 (unlikelium)" do
+      expect(subject.level_name).to eq('unlikelium')
+      expect(subject.level).to eq(4)
+    end
+    it "doesn't fall ever" do
+      world.update; expect_new_height 400
+    end
+  end
+
+end