gameoverseer 0.1.7 → 0.1.8

data/lib/gameoverseer/console/namespace_creator.rb

@@ -1,4 +1,4 @@
-module Gosu
-  class Window
-  end
-end
+module Gosu
+  class Window
+  end
+end

data/lib/gameoverseer/encryption_handler/encryption_handler.rb

@@ -1,40 +1,40 @@
-module GameOverseer
-  class EncryptionHandler
-
-    def initialize(key_size: 128, keypair_size: 2048)
-      EncryptionHandler.instance = self
-      generate_server_keypair(keypair_size)
-    end
-
-    def generate_server_keypair(keypair_size)
-      @server_keypair = OpenSSL::PKey::RSA.generate(keypair_size)
-    end
-
-    def encrypt_keypair(client_id, string)
-    end
-
-    def decrypt_keypair(string)
-    end
-
-    def encrypt(client_id, string)
-    end
-
-    def decrypt(client_id, string)
-    end
-
-    def set_client_keypair(client_id, public_key_pem)
-    end
-
-    def set_client_key(client_id)
-      ClientManager.instance.update(client_id, '_aes_key', 'In progress, not ready.')
-    end
-
-    def self.instance
-      @instance
-    end
-
-    def self.instance=(_instance)
-      @instance = _instance
-    end
-  end
-end
+module GameOverseer
+  class EncryptionHandler
+
+    def initialize(key_size: 128, keypair_size: 2048)
+      EncryptionHandler.instance = self
+      generate_server_keypair(keypair_size)
+    end
+
+    def generate_server_keypair(keypair_size)
+      @server_keypair = OpenSSL::PKey::RSA.generate(keypair_size)
+    end
+
+    def encrypt_keypair(client_id, string)
+    end
+
+    def decrypt_keypair(string)
+    end
+
+    def encrypt(client_id, string)
+    end
+
+    def decrypt(client_id, string)
+    end
+
+    def set_client_keypair(client_id, public_key_pem)
+    end
+
+    def set_client_key(client_id)
+      ClientManager.instance.update(client_id, '_aes_key', 'In progress, not ready.')
+    end
+
+    def self.instance
+      @instance
+    end
+
+    def self.instance=(_instance)
+      @instance = _instance
+    end
+  end
+end

data/lib/gameoverseer/input_handler/input_handler.rb

@@ -1,36 +1,36 @@
-module GameOverseer
-  class InputHandler
-
-    # @param client_id [Integer]
-    # @param data [Hash]
-    def self.process_data(client_id, data)
-      @data = data
-      @client_id = client_id
-      forward_to_channel_manager if data_valid?
-    end
-
-    # Checks if hash contains 'channel' and 'mode'
-    # @return [Boolean]
-    def self.data_valid?
-      if @data["channel"]
-        if @data["mode"]
-          true
-        end
-      end
-    end
-
-    # Sends data and client_id to {ChannelManager}
-    def self.forward_to_channel_manager
-      count = 0
-      begin
-        channel_manager = GameOverseer::ChannelManager.instance
-        channel_manager.send_to_service(@client_id, @data)
-      rescue NoMethodError => e
-        GameOverseer::Console.log("InputHandler> #{e.to_s}")
-        raise if count >=2
-        count+=1
-        retry unless count >= 2
-      end
-    end
-  end
-end
+module GameOverseer
+  class InputHandler
+
+    # @param client_id [Integer]
+    # @param data [Hash]
+    def self.process_data(client_id, data)
+      @data = data
+      @client_id = client_id
+      forward_to_channel_manager if data_valid?
+    end
+
+    # Checks if hash contains 'channel' and 'mode'
+    # @return [Boolean]
+    def self.data_valid?
+      if @data["channel"]
+        if @data["mode"]
+          true
+        end
+      end
+    end
+
+    # Sends data and client_id to {ChannelManager}
+    def self.forward_to_channel_manager
+      count = 0
+      begin
+        channel_manager = GameOverseer::ChannelManager.instance
+        channel_manager.send_to_service(@client_id, @data)
+      rescue NoMethodError => e
+        GameOverseer::Console.log("InputHandler> #{e.to_s}")
+        raise if count >=2
+        count+=1
+        retry unless count >= 2
+      end
+    end
+  end
+end

data/lib/gameoverseer/messages/message_manager.rb

@@ -1,40 +1,40 @@
-module GameOverseer
-
-  # Handles sending messages to clients on behalf of services
-  class MessageManager
-    MESSAGES = []
-    BROADCASTS = []
-
-    def initialize
-      MessageManager.instance = self
-    end
-
-    # Send a message to a specific client
-    # @param client_id [Integer] ID of client
-    # @param string [String] message to send
-    # @param reliable [Boolean] whether or not packet delivery is reliable
-    # @param channel [Integer] What channel to send on
-    def message(client_id, string, reliable = false, channel = ChannelManager::CHAT)
-      GameOverseer::ENetServer.instance.transmit(client_id, string, reliable, channel)
-    end
-
-
-    # Send a message to all connected clients
-    # @param string [String] message to send
-    # @param reliable [Boolean] whether or not packet delivery is reliable
-    # @param channel [Integer] What channel to send on
-    def broadcast(string, reliable = false, channel = ChannelManager::CHAT)
-      GameOverseer::ENetServer.instance.broadcast(string, reliable, channel)
-    end
-
-    # @return [MessageManager]
-    def self.instance
-      @instance
-    end
-
-    # @param _instance [MessageManager]
-    def self.instance=_instance
-      @instance = _instance
-    end
-  end
-end
+module GameOverseer
+
+  # Handles sending messages to clients on behalf of services
+  class MessageManager
+    MESSAGES = []
+    BROADCASTS = []
+
+    def initialize
+      MessageManager.instance = self
+    end
+
+    # Send a message to a specific client
+    # @param client_id [Integer] ID of client
+    # @param string [String] message to send
+    # @param reliable [Boolean] whether or not packet delivery is reliable
+    # @param channel [Integer] What channel to send on
+    def message(client_id, string, reliable = false, channel = ChannelManager::CHAT)
+      GameOverseer::ENetServer.instance.transmit(client_id, string, reliable, channel)
+    end
+
+
+    # Send a message to all connected clients
+    # @param string [String] message to send
+    # @param reliable [Boolean] whether or not packet delivery is reliable
+    # @param channel [Integer] What channel to send on
+    def broadcast(string, reliable = false, channel = ChannelManager::CHAT)
+      GameOverseer::ENetServer.instance.broadcast(string, reliable, channel)
+    end
+
+    # @return [MessageManager]
+    def self.instance
+      @instance
+    end
+
+    # @param _instance [MessageManager]
+    def self.instance=_instance
+      @instance = _instance
+    end
+  end
+end

data/lib/gameoverseer/packet_handler/json_packet_handler.rb

@@ -1,31 +1,34 @@
-module GameOverseer
-  class JsonPacketHandler < PacketHandler
-
-    def setup
-      begin
-        require "multi_json"
-      rescue LoadError
-        abort "MultiJson is not installed."
-      end
-    end
-
-    def pre_processor(packet, sending)
-      data = nil
-      if sending
-        data = MultiJson.dump(packet)
-      else
-        data = MultiJson.load(packet)
-      end
-
-      return data
-    end
-
-    def receive(client_id, packet)
-      _packet = pre_processor(packet, false)
-    end
-
-    def transmit(client_id, data)
-      _packet = pre_processor(data, true)
-    end
-  end
-end
+module GameOverseer
+  class JsonPacketHandler < PacketHandler
+
+    def setup
+      begin
+        require "multi_json"
+        if defined?(Oj)
+          Oj.default_options={mode: :strict}
+        end
+      rescue LoadError
+        abort "MultiJson is not installed."
+      end
+    end
+
+    def pre_processor(packet, sending)
+      data = nil
+      if sending
+        data = MultiJson.dump(packet)
+      else
+        data = MultiJson.load(packet)
+      end
+
+      return data
+    end
+
+    def receive(client_id, packet)
+      _packet = pre_processor(packet, false)
+    end
+
+    def transmit(client_id, data)
+      _packet = pre_processor(data, true)
+    end
+  end
+end

data/lib/gameoverseer/packet_handler/messagepack_packet_handler.rb

@@ -1,31 +1,31 @@
-module GameOverseer
-  class MessagePackPacketHandler < PacketHandler
-
-    def setup
-      begin
-        require "msgpack"
-      rescue LoadError
-        abort "msgpack is not installed."
-      end
-    end
-
-    def pre_processor(packet, sending)
-      data = nil
-      if sending
-        data = packet.to_msgpack
-      else
-        data = MessagePack.unpack(packet)
-      end
-
-      return data
-    end
-
-    def receive(client_id, packet)
-      _packet = pre_processor(packet, false)
-    end
-
-    def transmit(client_id, data)
-      _packet = pre_processor(data, true)
-    end
-  end
-end
+module GameOverseer
+  class MessagePackPacketHandler < PacketHandler
+
+    def setup
+      begin
+        require "msgpack"
+      rescue LoadError
+        abort "msgpack is not installed."
+      end
+    end
+
+    def pre_processor(packet, sending)
+      data = nil
+      if sending
+        data = packet.to_msgpack
+      else
+        data = MessagePack.unpack(packet)
+      end
+
+      return data
+    end
+
+    def receive(client_id, packet)
+      _packet = pre_processor(packet, false)
+    end
+
+    def transmit(client_id, data)
+      _packet = pre_processor(data, true)
+    end
+  end
+end

data/lib/gameoverseer/packet_handler/packet_handler.rb

@@ -1,29 +1,29 @@
-module GameOverseer
-  class PacketHandler
-
-    def initialize
-      PacketHandler.instance = self
-      setup
-    end
-
-    def setup
-    end
-
-    def pre_processor(packet, sending)
-    end
-
-    def receive(client_id, packet)
-    end
-
-    def transmit(client_id, data)
-    end
-
-    def self.instance
-      @instance
-    end
-
-    def self.instance=(_instance)
-      @instance = _instance
-    end
-  end
-end
+module GameOverseer
+  class PacketHandler
+
+    def initialize
+      PacketHandler.instance = self
+      setup
+    end
+
+    def setup
+    end
+
+    def pre_processor(packet, sending)
+    end
+
+    def receive(client_id, packet)
+    end
+
+    def transmit(client_id, data)
+    end
+
+    def self.instance
+      @instance
+    end
+
+    def self.instance=(_instance)
+      @instance = _instance
+    end
+  end
+end

data/lib/gameoverseer/server/renet_server.rb

@@ -1,126 +1,126 @@
-module GameOverseer
-
-  # GameOverseers' connection to the world
-  #
-  # This server uses the renet library, which is C bindings for the Enet networking library
-  class ENetServer
-    # @param host [String] host or ip for the server to run on
-    # @param port [Integer] port for the server to run on
-    # @param max_clients [Integer] max number of clients that can be connected at one time
-    # @param channels [Integer] number of channels (See Enet documentation)
-    # @param download_bandwidth [Integer] max bandwidth for downloading per-second (0 is unlimited)
-    # @param upload_bandwidth [Integer] max bandwidth for uploading per-second (0 is unlimited)
-    # @return [Thread]
-    def initialize(host, port, packet_handler, encryption_handler, max_clients = 4, channels = 4, download_bandwidth = 0, upload_bandwidth = 0)
-      GameOverseer::Console.log("Server> Started on: #{host}:#{port}.")
-      GameOverseer::Services.enable
-      GameOverseer::ENetServer.instance = self
-
-      @message_manager = GameOverseer::MessageManager.instance
-      @channel_manager = GameOverseer::ChannelManager.instance
-      @client_manager = GameOverseer::ClientManager.instance
-      @packet_handler = packet_handler.new
-      @encryption_handler = encryption_handler.instance if encryption_handler
-
-      @server = ENet::Server.new(port, max_clients, channels, download_bandwidth, upload_bandwidth) # Port, max clients, channels, download bandwidth, upload bandwith
-      @server.use_compression(true)
-      @terminate = false
-
-      @server.on_connection(method(:on_connect))
-      @server.on_packet_receive(method(:on_packet))
-      @server.on_disconnection(method(:on_disconnect))
-
-      run
-    end
-
-    # Runs the server in a Thread,, in a loop, calling update on the server.
-    #
-    # @return [Thread]
-    def run
-      Thread.new {
-        loop do
-          @server.update(1000)
-          break if @terminate
-        end
-      }
-    end
-
-    # Called when a packet is received
-    # @param client_id [Integer] ID of client
-    # @param data [String] data client sent
-    # @param channel [Integer] channel that this was sent to
-    def on_packet(client_id, data, channel)
-      handle_connection(client_id, data, channel)
-    end
-
-    # callled when a client connects
-    # @param client_id [Integer] ID of client
-    # @param ip_address [String] address of client
-    def on_connect(client_id, ip_address)
-      @client_manager.add(client_id, ip_address)
-    end
-
-    # callled when a client disconnects
-    # @param client_id [Integer] ID of client
-    def on_disconnect(client_id)
-      @client_manager.remove(client_id)
-    end
-
-    # send message to a specific client
-    # @param client_id [Integer] ID of client
-    # @param message [String] message to be sent to client
-    # @param reliable [Boolean] whether or not the packet is guaranteed to be received by the client
-    # @param channel [Integer] what channel to send on
-    def transmit(client_id, message, reliable = false, channel = ChannelManager::CHAT)
-      @server.send_packet(client_id, message, reliable, channel)
-    end
-
-    # send message to all connected clients
-    # @param message [String] message to be sent to clients
-    # @param reliable [Boolean] whether or not the packet is guaranteed to be received by the clients
-    # @param channel [Integer] what channel to send on
-    def broadcast(message, reliable = false, channel = ChannelManager::CHAT)
-      @server.broadcast_packet(message, reliable, channel)
-    end
-
-    # send data to the InputHandler for processing
-    # @param data [Hash]
-    # @param client_id [Integer] ID of client that sent the data
-    def process_data(client_id, data)
-      GameOverseer::InputHandler.process_data(client_id, data)
-    end
-
-    # Handles received packets from clients and sends them through the {PacketHandler} for pre-processing, then sends it on to {#process_data}
-    # @param client_id [Integer]
-    # @param data [String] data received from client
-    # @param channel [Integer] channel that this packet was sent along
-    def handle_connection(client_id, data, channel)
-      _data = @packet_handler.receive(client_id, data)
-      if _data
-        process_data(client_id, _data)
-      else
-        # TODO: Better error handling :D
-        transmit(client_id, '{"channel":"_error", "mode":"_error", "data":{"code":400, "message":"something went wrong, likely bad data!"}}', true, ChannelManager::FAULT)
-      end
-    end
-
-    def terminate
-      @terminate = true
-    end
-
-    def self.instance
-      @instance
-    end
-
-    def self.instance=(_instance)
-      @instance = _instance
-    end
-  end
-
-  class ENetServerRunner
-    attr_reader :supervisor
-    def start(host, port, packet_handler = PacketHandler, encryption_handler = nil)
-      @supervisor = GameOverseer::ENetServer.new(host, port, packet_handler, encryption_handler)
-    end
-  end
-end
+module GameOverseer
+
+  # GameOverseers' connection to the world
+  #
+  # This server uses the renet library, which is C bindings for the Enet networking library
+  class ENetServer
+    # @param host [String] host or ip for the server to run on
+    # @param port [Integer] port for the server to run on
+    # @param max_clients [Integer] max number of clients that can be connected at one time
+    # @param channels [Integer] number of channels (See Enet documentation)
+    # @param download_bandwidth [Integer] max bandwidth for downloading per-second (0 is unlimited)
+    # @param upload_bandwidth [Integer] max bandwidth for uploading per-second (0 is unlimited)
+    # @return [Thread]
+    def initialize(host, port, packet_handler, encryption_handler, max_clients = 4, channels = 4, download_bandwidth = 0, upload_bandwidth = 0)
+      GameOverseer::Console.log("Server> Started on: #{host}:#{port}.")
+      GameOverseer::Services.enable
+      GameOverseer::ENetServer.instance = self
+
+      @message_manager = GameOverseer::MessageManager.instance
+      @channel_manager = GameOverseer::ChannelManager.instance
+      @client_manager = GameOverseer::ClientManager.instance
+      @packet_handler = packet_handler.new
+      @encryption_handler = encryption_handler.instance if encryption_handler
+
+      @server = ENet::Server.new(port, max_clients, channels, download_bandwidth, upload_bandwidth) # Port, max clients, channels, download bandwidth, upload bandwith
+      @server.use_compression(true)
+      @terminate = false
+
+      @server.on_connection(method(:on_connect))
+      @server.on_packet_receive(method(:on_packet))
+      @server.on_disconnection(method(:on_disconnect))
+
+      run
+    end
+
+    # Runs the server in a Thread,, in a loop, calling update on the server.
+    #
+    # @return [Thread]
+    def run
+      Thread.new {
+        loop do
+          @server.update(1000)
+          break if @terminate
+        end
+      }
+    end
+
+    # Called when a packet is received
+    # @param client_id [Integer] ID of client
+    # @param data [String] data client sent
+    # @param channel [Integer] channel that this was sent to
+    def on_packet(client_id, data, channel)
+      handle_connection(client_id, data, channel)
+    end
+
+    # callled when a client connects
+    # @param client_id [Integer] ID of client
+    # @param ip_address [String] address of client
+    def on_connect(client_id, ip_address)
+      @client_manager.add(client_id, ip_address)
+    end
+
+    # callled when a client disconnects
+    # @param client_id [Integer] ID of client
+    def on_disconnect(client_id)
+      @client_manager.remove(client_id)
+    end
+
+    # send message to a specific client
+    # @param client_id [Integer] ID of client
+    # @param message [String] message to be sent to client
+    # @param reliable [Boolean] whether or not the packet is guaranteed to be received by the client
+    # @param channel [Integer] what channel to send on
+    def transmit(client_id, message, reliable = false, channel = ChannelManager::CHAT)
+      @server.send_packet(client_id, message, reliable, channel)
+    end
+
+    # send message to all connected clients
+    # @param message [String] message to be sent to clients
+    # @param reliable [Boolean] whether or not the packet is guaranteed to be received by the clients
+    # @param channel [Integer] what channel to send on
+    def broadcast(message, reliable = false, channel = ChannelManager::CHAT)
+      @server.broadcast_packet(message, reliable, channel)
+    end
+
+    # send data to the InputHandler for processing
+    # @param data [Hash]
+    # @param client_id [Integer] ID of client that sent the data
+    def process_data(client_id, data)
+      GameOverseer::InputHandler.process_data(client_id, data)
+    end
+
+    # Handles received packets from clients and sends them through the {PacketHandler} for pre-processing, then sends it on to {#process_data}
+    # @param client_id [Integer]
+    # @param data [String] data received from client
+    # @param channel [Integer] channel that this packet was sent along
+    def handle_connection(client_id, data, channel)
+      _data = @packet_handler.receive(client_id, data)
+      if _data
+        process_data(client_id, _data)
+      else
+        # TODO: Better error handling :D
+        transmit(client_id, '{"channel":"_error", "mode":"_error", "data":{"code":400, "message":"something went wrong, likely bad data!"}}', true, ChannelManager::FAULT)
+      end
+    end
+
+    def terminate
+      @terminate = true
+    end
+
+    def self.instance
+      @instance
+    end
+
+    def self.instance=(_instance)
+      @instance = _instance
+    end
+  end
+
+  class ENetServerRunner
+    attr_reader :supervisor
+    def start(host, port, packet_handler = PacketHandler, encryption_handler = nil)
+      @supervisor = GameOverseer::ENetServer.new(host, port, packet_handler, encryption_handler)
+    end
+  end
+end