gameoverseer 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2dd44389a017c5cae455eddabf417b4bae6a37d2
+  data.tar.gz: a6acb2dc8c928b4c213cd6c564bbd4d1feb443d6
+SHA512:
+  metadata.gz: 71e971158f6922753f09215a5d9ab445a070e95debd934094c3c759508b7db265097f26902682133e93abb7cbcbf9dced82215ba86f10b644c489f519f3e49a2
+  data.tar.gz: 85cd07339fc79a9d80a9b73083cb75221cdc128c2c557711e21ccd2ffd3067492042e81cadaf5b756b600feed1c902c09a54090868d6a1c5f962daf26ad5a9c0

data/.gitignore

@@ -0,0 +1,2 @@
+log-*.txt
+protocol.md

data/Gemfile

@@ -0,0 +1,10 @@
+source "https://rubygems.org"
+
+# gemspec
+
+gem "gosu"
+gem "nio4r", git: "https://github.com/MagLev/nio4r.git", branch: "johnnyt/recursive-lock-fix"
+gem "celluloid"
+gem "renet"# use rubygems version for now, git: "https://github.com/jvranish/rENet.git"
+gem "multi_json"
+gem "net-ssh"

data/Gemfile.lock

@@ -0,0 +1,34 @@
+GIT
+  remote: https://github.com/MagLev/nio4r.git
+  revision: d22d0b9da828462f0ab14043f476388888430eb2
+  branch: johnnyt/recursive-lock-fix
+  specs:
+    nio4r (1.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    celluloid (0.16.0)
+      timers (~> 4.0.0)
+    gosu (0.8.7.2)
+    gosu (0.8.7.2-x86-mingw32)
+    hitimes (1.2.2-java)
+    hitimes (1.2.2-x86-mingw32)
+    multi_json (1.10.1)
+    net-ssh (2.9.2)
+    renet (0.1.14)
+    renet (0.1.14-x86-mingw32)
+    timers (4.0.1)
+      hitimes
+
+PLATFORMS
+  java
+  x86-mingw32
+
+DEPENDENCIES
+  celluloid
+  gosu
+  multi_json
+  net-ssh
+  nio4r!
+  renet

data/README.md

@@ -0,0 +1,34 @@
+# GameOverseer
+A game server, designed to be able to play host to up to 4 players in Planet Wars.
+
+This repo is a complete rewrite of  [GameOverseer](https://github.com/cyberarm/gameoverseer).
+
+# Status
+In development.
+Any examples given are subject to be outdated at anytime.
+
+# Install
+
+# Usage
+``` ruby
+require 'gameoverseer'
+
+# Write a service for your game
+class GameWorld < GameOverseer::Service
+  def setup
+    channel_manager.register('game_world')
+  end
+
+  def process(data)
+    # Do stuff with the data hash.
+  end
+
+  def version
+    "1.3.75"
+  end
+end
+
+host = "localhost"
+port = 56789
+GameOverseer.activate(host, port)
+```

data/gameoverseer.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "gameoverseer/version"
+
+Gem::Specification.new do |s|
+  s.name = "gameoverseer"
+  s.version = GameOverseer::VERSION
+  s.authors = ["Cyberarm"]
+  s.email = ["matthewlikesrobots@gmail.com"]
+  s.homepage = "https://github.com/cyberarm/rewrite-gameoverseer"
+  s.summary = "Generic game server."
+  s.description = "GameOverseer is designed to simplify the making of multiplayer games by providing a way to simply and easily write a game server."
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib", "bin"]
+
+  s.add_runtime_dependency "gosu"
+  s.add_runtime_dependency "celluloid"
+  s.add_runtime_dependency "renet"
+  s.add_runtime_dependency "multi_json"
+
+  # s.add_development_dependency "simplecov"
+end

data/lib/gameoverseer/channels/channel_manager.rb

@@ -0,0 +1,40 @@
+module GameOverseer
+  class ChannelManager
+    CHAT = 0
+    WORLD= 1
+    HANDSHAKE = 2
+    FAULT=3
+    def initialize
+      @channels = {}
+      ChannelManager.instance = self # quick and lazy way to remove objectspace
+      # 'chat' => GameOverseer::InternalService::Chat,
+      # 'handshake' => GameOverseer::InternalService::Handshake,
+      # 'broadcast' => GameOverseer::InternalService::Broadcast,
+      # 'environment' => GameOverseer::InternalService::Environment
+    end
+
+    def register_channel(channel, service)
+      _channel = channel.downcase
+      unless @channels[_channel]
+        @channels[_channel] = service
+        GameOverseer::Console.log("ChannelManager> mapped '#{_channel}' to '#{service.class}'.")
+      else
+        raise "Could not map channel '#{_channel}' because '#{@channels[data[_channel]].class}' is already using it."
+      end
+    end
+
+    def send_to_service(data, client_id)
+      GameOverseer::Console.log("ChannelManager> sent '#{data}' to '#{@channels[data['channel']].class}'.")
+      @channels[data['channel']].client_id = client_id
+      @channels[data['channel']].process(data)
+    end
+
+    def self.instance
+      @instance
+    end
+
+    def self.instance=_instance
+      @instance = _instance
+    end
+  end
+end

data/lib/gameoverseer/clients/client_manager.rb

@@ -0,0 +1,40 @@
+module GameOverseer
+  class ClientManager
+    attr_accessor :clients
+
+    def initialize
+      ClientManager.instance = self
+      @clients = []
+    end
+
+    def add(client_id, ip_address)
+      @clients << {client_id: client_id, ip_address: ip_address}
+      GameOverseer::Services.client_connected(client_id, ip_address)
+    end
+
+    def update(client_id, key, value)
+      @clients.each_with_index do |hash, index|
+        if hash[:client_id] == client_id
+          hash[key] = value
+        end
+      end
+    end
+
+    def remove(client_id)
+      @clients.each_with_index do |hash, index|
+        if hash[:client_id] == client_id
+          @clients.delete(hash)
+          GameOverseer::Services.client_disconnected(client_id)
+        end
+      end
+    end
+
+    def self.instance
+      @instance
+    end
+
+    def self.instance=_instance
+      @instance = _instance
+    end
+  end
+end

data/lib/gameoverseer/console/console.rb

@@ -0,0 +1,207 @@
+module GameOverseer
+  class Console < Gosu::Window
+    include Celluloid
+    # TODO: Use Gosu::Window.record to lower number of objects that need to be updated
+
+    PENDING_LOG = []
+    def initialize
+      GameOverseer::Console.instance = self
+      super(720, 480, false)
+      $window = self
+      $window.caption = "GameOverseer Console"
+      $window.text_input = Gosu::TextInput.new
+
+      @default_text_instance = Gosu::Font.new($window, 'Consolas', 18)
+      @messages = []
+      setup_ui
+    end
+
+    def needs_cursor?
+      true
+    end
+
+    def draw
+      @ui_image.draw(0,0,0) if defined?(@ui_image)
+    end
+
+    def update
+      update_ui
+      @ui_image = $window.record(720, 480) {draw_ui}
+    end
+
+    def setup_ui
+      @current_text = text_instance
+      @current_text_x = 4
+
+      # Required first message
+      @messages << {
+        text: '',
+        instance: text_instance,
+        color: Gosu::Color::WHITE,
+        x: 4,
+        y: 480-26-18,
+        z: 1
+      }
+
+      submit_text("#{Time.now.strftime('%c')}", false)
+    end
+
+    def draw_ui
+      draw_rect(0,0, 720, 26, Gosu::Color.rgb(200, 75, 25))
+      draw_rect(0,454, 720, 480, Gosu::Color::WHITE)
+      text_instance.draw("GameOverSeer Console. GameOverseer version #{GameOverSeer::VERSION} #{GameOverSeer::RELEASE_NAME} #{@messages.count}", 4, 4, 3)
+      @current_text.draw("#{$window.text_input.text}", @current_text_x, 458, 3, 1, 1, Gosu::Color::BLACK)
+      draw_rect(@caret+@current_text_x, 456, 2.0+@caret+@current_text_x, 474, Gosu::Color::BLUE, 4) if defined?(@caret) && @render_caret
+
+      @messages.each do |message|
+        message[:instance].draw(message[:text],message[:x],message[:y],message[:z], 1, 1, message[:color])
+        p message[:color] unless message[:color] == Gosu::Color::WHITE
+      end
+    end
+
+    def update_ui
+      PENDING_LOG.each do |log_message|
+        submit_text(log_message, false) if log_message.strip.length > 0
+        PENDING_LOG.delete(log_message)
+      end
+
+      @caret = @current_text.text_width($window.text_input.text[0...$window.text_input.caret_pos])
+
+      @caret_tick = 0 unless defined?(@caret_tick)
+      @render_caret = true if @caret_tick < 15
+      @render_caret = false if @caret_tick > 30
+
+      @caret_tick = 0 unless @caret_tick < 45
+      @caret_tick+=1
+
+      value = @current_text.text_width($window.text_input.text)+@current_text_x
+      if value >= 720
+        @current_text_x-=4
+      elsif value <= 715
+        @current_text_x+=4 unless @current_text_x >= 4
+      end
+    end
+
+    def text_instance
+      @default_text_instance
+    end
+
+    def draw_rect(x1,y1, x2,y2, color = Gosu::Color::GRAY, z = 2)
+      $window.draw_quad(x1, y1, color, x2, y1, color, x1, y2, color, x2, y2, color, z)
+    end
+
+    def scroll(direction)
+      case direction
+      when :down
+        if @messages.last[:y] >= 480 - 26 - 18
+          @messages.each do |message|
+            message[:y]-=18
+          end
+        end
+      when :up
+        if @messages.first[:y] <= 26#<= 480 - 26 - 32
+          @messages.each do |message|
+            message[:y]+=18
+          end
+        end
+      end
+    end
+
+    def clean_messages(count)
+      if @messages.count >= count
+        @messages.delete(@messages.first)
+      end
+    end
+
+    def button_up(id)
+      case id
+      when 41 # Escape
+        # Quit?
+      when 40 # Enter
+        submit_text($window.text_input.text)
+      when 88 # Numpad Enter
+        submit_text($window.text_input.text)
+      when 259 # Mouse wheel
+        scroll(:up)
+      when 260  # Mouse wheel
+        scroll(:down)
+      end
+    end
+
+    def self.instance
+      @instance
+    end
+
+    def self.instance=_instance
+      @instance = _instance
+    end
+
+    def self.log(string)
+      self.log_it(string) if string.strip.length > 0
+      begin
+        GameOverseer::Console.instance.submit_text(string, false)
+      rescue NoMethodError
+        self.defer_log(string)
+      end
+    end
+
+    def self.log_with_color(string, color = Gosu::Color::WHITE)
+      self.log_it(string) if string.strip.length > 0
+      GameOverseer::Console.instance.submit_text(string, false, color)
+    end
+
+    def self.defer_log(string)
+      PENDING_LOG << string
+    end
+
+    def self.log_it(string)
+      puts string
+      retry_limit = 0
+      begin
+        @log_file = File.open("#{Dir.pwd}/logs/log-#{Time.now.strftime('%B-%d-%Y')}.txt", 'a+') unless defined? @log_file
+        @log_file.write "[#{Time.now.strftime('%c')}] #{string}\n"
+      rescue Errno::ENOENT
+        Dir.mkdir("#{Dir.pwd}/logs") unless File.exist?("#{Dir.pwd}/logs") && File.directory?("#{Dir.pwd}/logs")
+        retry_limit+=1
+        retry unless retry_limit >= 2
+      end
+    end
+
+    protected
+    def submit_text(text, from_console = true, color = Gosu::Color::WHITE)
+      if text.strip.length > 0
+        clean_messages(300)
+        text = "Console> #{text}" if from_console
+        GameOverseer::Console.log_it(text)
+        if text.length > 83
+          temp_text = text[0..83]
+          @messages.each do |message|
+            message[:y]-=18
+          end
+          @messages << {
+            text: temp_text,
+            instance: text_instance,
+            color: color,
+            x: 4,
+            y: @messages.last[:y] + 18,
+            z: 1
+          }
+          submit_text(text[83..text.length], false)
+        else
+          @messages.each do |message|
+            message[:y]-=18
+          end
+          @messages << {
+            text: text,
+            instance: text_instance,
+            color: color,
+            x: 4,
+            y: @messages.last[:y] + 18,
+            z: 1
+          }
+        end
+        $window.text_input = Gosu::TextInput.new if from_console
+      end
+    end
+  end
+end

data/lib/gameoverseer/input_handler/input_handler.rb

@@ -0,0 +1,30 @@
+module GameOverseer
+  class InputHandler
+    def self.process_data(data, client_id)
+      @data = data
+      @client_id = client_id
+      forward_to_channel_manager if data_valid?
+    end
+
+    def self.data_valid?
+      if @data["channel"]
+        if @data["mode"]
+          true
+        end
+      end
+    end
+
+    def self.forward_to_channel_manager
+      count = 0
+      begin
+        channel_manager = GameOverseer::ChannelManager.instance
+        channel_manager.send_to_service(@data, @client_id)
+      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

@@ -0,0 +1,36 @@
+module GameOverseer
+  class MessageManager
+    MESSAGES = []
+    BROADCASTS = []
+
+    def initialize
+      MessageManager.instance = self
+    end
+
+    def message(client_id, string, reliable = false, channel = ChannelManager::CHAT)
+      GameOverseer::ENetServer.instance.send(client_id, string, reliable, channel)
+      GameOverseer::Console.log("MessageManager> #{string}-#{client_id}")
+    end
+
+    def broadcast(string, reliable = false, channel = ChannelManager::CHAT)
+      GameOverseer::ENetServer.instance.broadcast(string, reliable, channel)
+      GameOverseer::Console.log("MessageManager> #{string}-#{channel}")
+    end
+
+    def messages
+      MESSAGES
+    end
+
+    def broadcasts
+      BROADCASTS
+    end
+
+    def self.instance
+      @instance
+    end
+
+    def self.instance=_instance
+      @instance = _instance
+    end
+  end
+end

data/lib/gameoverseer/server/handshake.rb

@@ -0,0 +1,19 @@
+module GameOverseer
+  class HandShake
+
+    # OpenSSL Public/Private Key Encryption For Initial Handshaking And Authentication Masking.
+    def self.generate
+      @keys = OpenSSL::PKey::RSA.new 512
+    end
+
+    def self.public_key
+      generate unless defined?(@keys)
+      @keys.public_key.to_pem
+    end
+
+    def self.keys
+      generate unless defined?(@keys)
+      @keys
+    end
+  end
+end

data/lib/gameoverseer/server/renet_server.rb

@@ -0,0 +1,84 @@
+module GameOverseer
+  class ENetServer
+    include Celluloid
+
+    def initialize(host, port)
+      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
+
+      @server = ENet::Server.new(port, 4, 4, 0, 0) # Port, max clients, channels, download bandwidth, upload bandwith
+      @server.use_compression(true)
+
+      @server.on_connection(method(:on_connect))
+      @server.on_packet_receive(method(:on_packet))
+      @server.on_disconnection(method(:on_disconnect))
+
+      async.run
+    end
+
+    def run
+      loop do
+        @server.update(1000)
+      end
+    end
+
+    def on_packet(client_id, data, channel)
+      p "Packet: #{client_id}-#{data}-#{channel}"
+      handle_connection(client_id, data, channel)
+    end
+
+    def on_connect(client_id, ip_address)
+      p "Connect: #{client_id}-#{ip_address}"
+      @client_manager.add(client_id, ip_address)
+    end
+
+    def on_disconnect(client_id)
+      p "Disconnect: #{client_id}"
+      @client_manager.remove(client_id)
+    end
+
+    # send (private packet)
+    def send(client_id, message, reliable = false, channel = ChannelManager::CHAT)
+      @server.send_packet(client_id, message, reliable, channel)
+    end
+
+    # boardcast (global packet)
+    def broadcast(message, reliable = false, channel = ChannelManager::CHAT)
+      @server.broadcast_packet(message, reliable, channel)
+    end
+
+    def process_data(data, client_id)
+      GameOverseer::InputHandler.process_data(data, client_id)
+    end
+
+    def handle_connection(client_id, data, channel)
+      begin
+        data = MultiJson.load(data)
+        process_data(data, client_id)
+      rescue MultiJson::ParseError => e
+        send(client_id, " \"channel\": \"__UNDEFINED__\", \"mode\": \"__UNDEFINED__\", \"data\": {\"code\": 400, \"message\": \"Invalid JSON received.\"}}", true, ChannelManager::FAULT)
+        GameOverseer::Console.log("Server> Parse error: '#{e.to_s}'. Bad data: '#{data}' received from client.")
+      end
+    end
+
+    def self.instance
+      @instance
+    end
+
+    def self.instance=(_instance)
+      @instance = _instance
+    end
+  end
+
+  class ENetServerRunner
+    attr_reader :supervisor
+    def start(host, port)
+      @supervisor = GameOverseer::ENetServer.new(host, port)
+    end
+  end
+end

data/lib/gameoverseer/services/internal/broadcast.rb

@@ -0,0 +1,13 @@
+module GameOverseer
+  class InternalService
+    class Broadcast < GameOverseer::Service
+      def setup
+        channel_manager.register_channel('broadcast', self)
+      end
+
+      def version
+        "0.1.0"
+      end
+    end
+  end
+end

data/lib/gameoverseer/services/internal/chat.rb

@@ -0,0 +1,9 @@
+module GameOverseer
+  class InternalService
+    class Chat < GameOverseer::Service
+      def version
+        "0.1.0"
+      end
+    end
+  end
+end

data/lib/gameoverseer/services/internal/environment.rb

@@ -0,0 +1,9 @@
+module GameOverseer
+  class InternalService
+    class Environment < GameOverseer::Service
+      def version
+        "0.1.0"
+      end
+    end
+  end
+end

data/lib/gameoverseer/services/internal/handshake.rb

@@ -0,0 +1,25 @@
+module GameOverseer
+  class InternalService
+    class Handshake < GameOverseer::Service
+      def setup
+        channel_manager.register_channel('handshake', self)
+      end
+
+      def process(data)
+        data_to_method(data)
+      end
+
+      def extend_hand(data)
+        message = MultiJson.dump({channel: 'handshake', mode: 'public_key', data: {public_key: GameOverseer::HandShake.public_key}})
+        message_manager.message("#{message}", client_id, true, ChannelManager::HANDSHAKE)
+        log("#{self.class}> #{message}.", Gosu::Color::RED)
+      end
+
+
+
+      def version
+        "0.1.0"
+      end
+    end
+  end
+end

data/lib/gameoverseer/services/internal/services.rb

@@ -0,0 +1,3 @@
+require_relative "chat"
+require_relative "handshake"
+require_relative "environment"

data/lib/gameoverseer/services/service.rb

@@ -0,0 +1,63 @@
+module GameOverseer
+  class Service
+    attr_accessor :client_id
+
+    def self.inherited(subclass)
+      GameOverseer::Console.log "Service> added '#{subclass}' to Services::List."
+      Services.register(subclass)
+    end
+
+    def initialize
+      if defined?(self.setup)
+        @client_id = 0
+        setup
+      end
+    end
+
+    # Called before 'enable' there should be no active code here, only setup variables.
+    def setup
+    end
+
+    # Called when services are first initialized, put active code here.
+    def enable
+    end
+
+    # Called when a message is recieved for this channel.
+    def process(data)
+    end
+
+    def version
+      raise "Method 'version' on class '#{self}' not defined, see '#{__FILE__}#version' in GameOverseer source."
+      # Please use the sematic versioning system,
+      # http://semver.org
+      #
+      # e.g.
+      # "1.5.9"
+      # (Major.Minor.Patch)
+    end
+
+    protected
+    def channel_manager
+      @channel_manager = ChannelManager.instance
+      @channel_manager
+    end
+
+    def message_manager
+      @message_manager = MessageManager.instance# ObjectSpace.each_object(GameOverseer::MessageManager).first unless defined?(@message_manager)
+      @message_manager
+    end
+
+    def data_to_method(data)
+      self.send(data['mode'], data)
+      [self.methods - Class.methods].each do |method|
+        if data['mode'] == method.to_s
+          self.send(data['mode'], data)
+        end
+      end
+    end
+
+    def log(string, color = Gosu::Color::RED)
+      GameOverseer::Console.log_with_color(string, color)
+    end
+  end
+end

data/lib/gameoverseer/services/services.rb

@@ -0,0 +1,31 @@
+module GameOverseer
+  module Services
+    LIST = []
+    ACTIVE=[]
+
+    def self.register(klass)
+      LIST << klass
+    end
+
+    def self.enable
+      LIST.each do |service|
+        _service = service.new
+        _service.enable
+        GameOverseer::Console.log "Services> #{_service.class} #{_service.version}"
+        ACTIVE << _service
+      end
+    end
+
+    def self.client_connected(client_id, ip_address)
+      ACTIVE.each do |service|
+        service.client_connected(client_id, ip_address) if defined?(service.client_connected)
+      end
+    end
+
+    def self.client_disconnected(client_id)
+      ACTIVE.each do |service|
+        service.client_disconnected(client_id) if defined?(service.client_disconnected)
+      end
+    end
+  end
+end

data/lib/gameoverseer/version.rb

@@ -0,0 +1,4 @@
+module GameOverseer
+  VERSION = "0.1.0"
+  RELEASE_NAME = "Blank Slate" # 1.0.0 is to be "Ice Crystal"
+end

data/lib/gameoverseer.rb

@@ -0,0 +1,58 @@
+require "set"
+
+require "gosu"
+require "celluloid"
+require "renet"
+require "multi_json"
+
+require_relative "gamoverseer/version"
+
+require_relative "gamoverseer/console/console"
+
+require_relative "gamoverseer/channels/channel_manager"
+
+require_relative "gamoverseer/messages/message_manager"
+
+require_relative "gamoverseer/clients/client_manager"
+
+require_relative "gamoverseer/services/service"
+require_relative "gamoverseer/services/services"
+require_relative "gamoverseer/services/internal/services"
+
+require_relative "gamoverseer/input_handler/input_handler"
+
+require_relative "gamoverseer/server/renet_server"
+require_relative "gamoverseer/server/handshake"
+
+# TEMP
+Thread.abort_on_exception = true
+
+# TODO: Move to own file
+module GameOverseer
+  def self.activate(host, port)
+    GameOverseer::ChannelManager.new
+    GameOverseer::MessageManager.new
+    GameOverseer::ClientManager.new
+
+    # @console = GameOverseer::Console.new
+    @server  = GameOverseer::ENetServerRunner.new
+
+    # Thread.new {@console.show}
+    Thread.new {@server.start(host, port)}
+    sleep
+
+    at_exit do
+      # GameOverseer::Console.instance.close
+      @server.supervisor.terminate if defined?(@server.supervisor.terminate)
+      puts "Server Shutdown"
+    end
+  end
+
+  def self.deactivate
+    puts "ALERT \"CONSOLE CLOSED. LOST CONTROL OF SERVER.\""
+    @server.supervisor.terminate
+  end
+end
+
+# Activate self, remove this before a release.
+# GameOverseer.activate("localhost", 56789)

data/license.md

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2014 cyberarm
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/test-clients/protocol-lib.rb

@@ -0,0 +1,13 @@
+require "multi_json"
+
+PROTOCOLS = {
+  # Client
+  handshake_extend_hand: MultiJson.dump({'channel' => 'handshake', 'mode' => 'extend_hand'}),
+  handshake_authenticate: "{'channel'=> 'handshake', \"mode\": \"authenticate\", \"data\": {\"auth_key\": \"public_key_encrypted_auth_key\"}}",
+
+
+  # Server
+  handshake_public_key: "{\"channel\": \"handshake\", \"mode\": \"public_key\", \"data\": {\"public_key\": \"really_long_string\"}}",
+  handshake_authenticated: "{\"channel\": \"handshake\", \"mode\": \"authenticated\", \"data\": {\"code\": 200, \"message\": \"Successfully authenticated.\"}}",
+  handshake_bad_authentication: "{\"channel\": \"handshake\", \"mode\": \"bad_authentication\", \"data\": {\"code\": 401, \"message\": \"Could not authenticate.\"}}"
+}

data/test-clients/test-client-alpha.rb

@@ -0,0 +1,36 @@
+require "celluloid/io"
+require "multi_json"
+require "net/ssh"
+require_relative "protocol-lib"
+
+class TestClientAlpha
+  include Celluloid::IO
+  finalizer :finish
+
+  def initialize(host, port)
+    @client = UDPSocket.new
+    @client.connect(host, port)
+    run
+  end
+
+  def run
+    @client.send("#{PROTOCOLS[:handshake_extend_hand]}", 0)
+    socket = @client.recvfrom(1024)
+    response = MultiJson.load(socket[0])
+    public_key_pem = response['data']['public_key'] if response['mode'] == 'public_key'
+     public_key = OpenSSL::PKey::RSA.new public_key_pem
+    encrypted_auth_key_response = MultiJson.dump({'channel'=> 'handshake', 'mode' => 'authenticate', 'data' => {'auth_key' => "#{public_key.public_encrypt('HELLO_WORLD')}"}})
+    p encrypted_auth_key_response
+    @client.send("#{encrypted_auth_key_response}", 0)
+  end
+
+  def finish
+    @client.close if @client
+  end
+end
+
+start_time = Time.now
+
+  TestClientAlpha.supervise('localhost', 56789)
+
+puts "Time to complete: #{Time.now-start_time}"

data/test-clients/test-client-beta.rb

@@ -0,0 +1,37 @@
+require "celluloid/io"
+require "multi_json"
+require "net/ssh"
+require 'uri'
+require_relative "protocol-lib"
+
+class TestClientBeta
+  include Celluloid::IO
+  finalizer :finish
+
+  def initialize(host, port)
+    @client = Celluloid::IO::TCPSocket.new(host, port)
+    run
+  end
+
+  def run
+    @client.puts("#{PROTOCOLS[:handshake_extend_hand]}")
+    line = @client.gets
+    p line
+    response = MultiJson.load(line)
+    public_key_pem = response['data']['public_key'] if response['mode'] == 'public_key'
+     public_key = OpenSSL::PKey::RSA.new public_key_pem
+    encrypted_auth_key_response = MultiJson.dump({'channel'=> 'handshake', 'mode' => 'authenticate', 'data' => {'auth_key' => "#{public_key.public_encrypt('HELLO_WORLD')}".force_encoding("utf-8")}})
+    p encrypted_auth_key_response
+    @client.puts("#{encrypted_auth_key_response.inspect}")
+  end
+
+  def finish
+    @client.close if @client
+  end
+end
+
+start_time = Time.now
+
+  TestClientBeta.supervise("127.0.0.1", 56789)
+
+puts "Time to complete: #{Time.now-start_time}"

data/test-clients/test-client-gamma.rb

@@ -0,0 +1,59 @@
+require "multi_json"
+require "net/ssh"
+require 'uri'
+require "renet"
+require_relative "protocol-lib"
+
+class TestClientGamma
+  HANDSHAKE = 2
+  # include Celluloid
+
+  def initialize(host, port)
+    @client = ENet::Connection.new(host, port, 4, 0, 0)
+
+    @client.on_connection(method(:on_connect))
+    @client.on_packet_receive(method(:on_packet))
+    @client.on_disconnection(method(:on_disconnect))
+
+    @client.connect(2000)
+    @client.send_packet("#{PROTOCOLS[:handshake_extend_hand]}", true, HANDSHAKE)
+    run
+  end
+
+  def run
+    loop do
+      @client.update(0)
+    end
+  end
+
+  def on_packet(data, channel)
+    p "P: #{data}-#{channel}"
+    handle_connection(data, channel)
+  end
+
+  def on_connect(data = 0, channel = 0)
+    p "C: #{data}-#{channel}"
+  end
+
+  def on_disconnect(data = 0, channel = 0)
+    p "D: #{data}-#{channel}"
+  end
+
+  def handle_connection(data, channel)
+    response = MultiJson.load(data)
+    case response['channel']
+    when 'handshake'
+      public_key_pem = response['data']['public_key'] if response['mode'] == 'public_key'
+      public_key = OpenSSL::PKey::RSA.new public_key_pem
+      encrypted_auth_key_response = MultiJson.dump({'channel'=> 'handshake', 'mode' => 'authenticate', 'data' => {'auth_key' => "#{public_key.public_encrypt('HELLO_WORLD')}".force_encoding("utf-8")}})
+      @client.send_packet(encrypted_auth_key_response, true, HANDSHAKE)
+      puts "PAST"
+    end
+  end
+end
+
+start_time = Time.now
+
+TestClientGamma.new("localhost", 56789)
+
+puts "Time to complete: #{Time.now-start_time}"

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: gameoverseer
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Cyberarm
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: gosu
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: celluloid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: renet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: GameOverseer is designed to simplify the making of multiplayer games
+  by providing a way to simply and easily write a game server.
+email:
+- matthewlikesrobots@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- README.md
+- gameoverseer.gemspec
+- lib/gameoverseer.rb
+- lib/gameoverseer/channels/channel_manager.rb
+- lib/gameoverseer/clients/client_manager.rb
+- lib/gameoverseer/console/console.rb
+- lib/gameoverseer/input_handler/input_handler.rb
+- lib/gameoverseer/messages/message_manager.rb
+- lib/gameoverseer/server/handshake.rb
+- lib/gameoverseer/server/renet_server.rb
+- lib/gameoverseer/services/internal/broadcast.rb
+- lib/gameoverseer/services/internal/chat.rb
+- lib/gameoverseer/services/internal/environment.rb
+- lib/gameoverseer/services/internal/handshake.rb
+- lib/gameoverseer/services/internal/services.rb
+- lib/gameoverseer/services/service.rb
+- lib/gameoverseer/services/services.rb
+- lib/gameoverseer/version.rb
+- license.md
+- test-clients/protocol-lib.rb
+- test-clients/test-client-alpha.rb
+- test-clients/test-client-beta.rb
+- test-clients/test-client-gamma.rb
+homepage: https://github.com/cyberarm/rewrite-gameoverseer
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- bin
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Generic game server.
+test_files: []
+has_rdoc: