game_machine 0.0.8

data/lib/game_machine/endpoints/tcp_handler.rb

@@ -0,0 +1,75 @@
+module GameMachine
+  module Endpoints
+    class TcpHandler < Actor::Base
+
+      attr_reader :game_handler
+      def post_init(*args)
+        @game_handler = Application.config.game_handler
+        @name = args.first
+        @con_ref = nil
+        @client_id = nil
+        @message_buffer = MessageBuffer.new
+      end
+
+      def on_receive(message)
+        if message.kind_of?(JavaLib::Tcp::ConnectionClosed)
+          client_message = client_disconnect_message(@client_id)
+          Actor::Base.find(game_handler).tell(client_message,get_self)
+          get_context.stop(get_self)
+        elsif message.kind_of?(JavaLib::Tcp::Received)
+          handle_incoming(message)
+        elsif message.is_a?(MessageLib::ClientMessage)
+          handle_outgoing(message)
+        elsif message.kind_of?(JavaLib::Tcp::Connected)
+          @con_ref = get_sender
+          @client_id = message.remote_address.to_s
+        else
+          unhandled(message)
+        end
+      end
+
+      private
+
+      def client_connection(client_id)
+        MessageLib::ClientConnection.new.set_id(client_id).
+          set_gateway(@name).set_server(Application.config.name)
+      end
+
+      def client_disconnect_message(client_id)
+        MessageLib::ClientMessage.new.set_client_disconnect(
+          MessageLib::ClientDisconnect.new.set_client_connection(
+            MessageLib::ClientConnection.new.set_id(client_id).set_gateway(@name)
+          )
+        )
+      end
+
+      def handle_outgoing(message)
+        byte_string = JavaLib::ByteString.from_array(message.to_byte_array)
+        tcp_message = JavaLib::TcpMessage.write(byte_string)
+        @con_ref.tell(tcp_message, get_self)
+      rescue Exception => e
+        GameMachine.logger.error "#{self.class.name} #{e.to_s}"
+      end
+
+      def handle_incoming(message)
+        @message_buffer.add_bytes(message.data.to_array)
+        @message_buffer.messages.each do |message_bytes|
+          client_message = create_client_message(
+            message_bytes,@client_id
+          )
+          Actor::Base.find(game_handler).tell(client_message,get_self)
+        end
+      rescue Exception => e
+        GameMachine.logger.error "TcpHandler.handle_incoming: #{@name} #{e.to_s}"
+      end
+
+      def create_client_message(data,client_id)
+        MessageLib::ClientMessage.parse_from(data).set_client_connection(
+          MessageLib::ClientConnection.new.set_id(client_id).set_gateway(@name).
+          set_server(Application.config.name)
+        )
+      end
+
+    end
+  end
+end

data/lib/game_machine/endpoints/udp.rb

@@ -0,0 +1,88 @@
+module GameMachine
+  module Endpoints
+    class Udp < Actor::Base
+
+      # TODO lookup inactive clients, and send a client_disconnected
+      # message to the request handler.  Currently clients that do not
+      # send a logout get left in the world
+      attr_reader :game_handler
+      def post_init(*args)
+        @game_handler = Application.config.game_handler
+        @clients = {}
+        @socket = nil
+      end
+
+      def preStart
+        mgr = JavaLib::Udp.get(getContext.system).getManager
+        inet = JavaLib::InetSocketAddress.new(
+          Application.config.udp_host,
+          Application.config.udp_port
+        )
+        mgr.tell( JavaLib::UdpMessage.bind(getSelf,inet), getSelf)
+      end
+
+      def on_receive(message)
+        if message.kind_of?(JavaLib::Udp::Bound)
+          @socket = getSender
+        elsif message.is_a?(MessageLib::ClientMessage)
+          handle_outgoing(message)
+        elsif message.kind_of?(JavaLib::Udp::Received)
+          echo(message)
+          return
+          handle_incoming(message)
+        elsif message == JavaLib::UdpMessage::unbind
+          @socket.tell(message, get_self)
+        elsif message.kind_of?(JavaLib::Udp::Unbound)
+          get_context.stop(get_self)
+        else
+          unhandled(message)
+        end
+      end
+
+      private
+
+      def handle_outgoing(message)
+        sender = @clients.fetch(message.client_connection.id)
+        byte_string = JavaLib::ByteString.from_array(message.to_byte_array)
+        udp_message = JavaLib::UdpMessage.send(byte_string, sender)
+        @socket.tell(udp_message, get_self)
+      rescue Exception => e
+        GameMachine.logger.error "#{self.class.name} #{e.to_s}"
+      end
+
+      def handle_incoming(message)
+        client_id = message.sender.to_s
+        unless @clients.has_key?(client_id)
+          @clients[client_id] = message.sender
+        end
+
+        client_message = create_client_message(
+          message.data.to_array,client_id
+        )
+        Actor::Base.find(game_handler).send_message(
+          client_message, :sender => get_self
+        )
+      rescue Exception => e
+        GameMachine.logger.error "#{self.class.name} #{e.to_s}"
+      end
+
+      def client_connection(client_id)
+        MessageLib::ClientConnection.new.set_id(client_id).
+          set_gateway(self.class.name).set_server(Application.config.name)
+      end
+
+      def create_client_message(data,client_id)
+        MessageLib::ClientMessage.parse_from(data).set_client_connection(
+          client_connection(client_id)
+        )
+      end
+
+      def echo(message)
+        byte_string = JavaLib::ByteString.from_array(message.data.to_array)
+        udp_message = JavaLib::UdpMessage.send(byte_string, message.sender)
+        @socket.tell(udp_message,get_self)
+      end
+
+    end
+  end
+end

data/lib/game_machine/endpoints/udp_incoming.rb

@@ -0,0 +1,113 @@
+module GameMachine
+  module Endpoints
+    class UdpIncoming < Actor::Base
+
+      def self.clients
+        if @clients
+          @clients
+        else
+          @clients = java.util.concurrent.ConcurrentHashMap.new
+        end
+      end
+
+      attr_reader :game_handler, :server, :clients
+      def post_init(*args)
+        @game_handler = Actor::Base.find(Application.config.game_handler)
+        @server = JavaLib::UdpServer.getUdpServer
+        @server_handler = @server.getHandler
+        @auth_handler = Handlers::Authentication.new
+      end
+
+      def on_receive(message)
+        if message.is_a?(JavaLib::NetMessage)
+          handle_incoming(message)
+        end
+      end
+
+      def client_id_from_message(message)
+        "#{message.host}:#{message.port}"
+      end
+
+      def handle_incoming(message)
+        client_id = client_id_from_message(message)
+        client_message = MessageLib::ClientMessage.parse_from(message.bytes)
+        client_connection = create_client_connection(
+          client_id,client_message.connection_type
+        )
+        client_message.set_client_connection(client_connection)
+
+        # Ensure we kill the player gateway actor on logout or on new connection
+        if client_message.has_player_logout || client_message.has_player_connect
+
+          # Ensure valid authtoken before doing anything
+          unless @auth_handler.valid_authtoken?(client_message.player)
+            if client_message.has_player_logout
+              GameMachine.logger.info "Unauthenticated client #{client_message.player.id} attempting to logout"
+            elsif client_message.has_player_connect
+              GameMachine.logger.info "Unauthenticated client #{client_message.player.id} attempting to login"
+            end
+            return
+          end
+
+          destroy_child(client_message.player.id)
+          self.class.clients.delete(client_message.player.id)
+          
+          if client_message.has_player_connect
+            unless self.class.clients.has_key?(client_message.player.id)
+              client = {
+                :host => message.host,
+                :port => message.port,
+                :ctx => message.ctx,
+                :client_connection => client_connection
+              }
+              GameMachine.logger.info "#{client.inspect}"
+              self.class.clients[client_message.player.id] = client
+              create_child(client_connection,client,@server,client_message.player.id)
+            end
+          end
+        end
+
+        game_handler.send_message(
+          client_message, :sender => get_self
+        )
+      rescue Exception => e
+        GameMachine.logger.error "#{self.class.name} #{e.to_s}"
+      end
+
+      def create_child(client_connection,client,server,player_id)
+        builder = Actor::Builder.new(Endpoints::UdpOutgoing,client_connection,client,server,player_id)
+        builder.with_name(player_id).start
+      end
+
+      def destroy_child(player_id)
+        Actor::Base.find(player_id).tell(JavaLib::PoisonPill.get_instance)
+        GameMachine.logger.info "Player gateway sent poison pill to #{player_id}"
+      end
+
+      # region and cluster connections are for when you have
+      # dedicated region servers.  If you do not the connection type can be
+      # left out by the client and it will default to combined.
+      def client_connection_type(connection_type)
+        if connection_type.nil?
+          'combined'
+        else
+          if connection_type == 1
+            'region'
+          elsif connection_type == 2
+            'cluster'
+          else
+            'combined'
+          end
+        end
+      end
+      
+      def create_client_connection(client_id,connection_type)
+        MessageLib::ClientConnection.new.set_id(client_id).
+          set_gateway(self.class.name).
+          set_server(Application.config.name).
+          set_type(client_connection_type(connection_type))
+      end
+
+    end
+  end
+end

data/lib/game_machine/endpoints/udp_outgoing.rb

@@ -0,0 +1,46 @@
+module GameMachine
+  module Endpoints
+    class UdpOutgoing < Actor::Base
+
+      attr_reader :client_connection, :client, :server, :player_id
+      def post_init(*args)
+        @client_connection = args[0]
+        @client = args[1]
+        @server = args[2]
+        @player_id = args[3]
+        send_connected_message
+        GameMachine.logger.info "Player gateway created #{player_id}"
+      end
+
+      def send_connected_message
+        client_message = create_client_message
+        client_message.set_player_connected(MessageLib::PlayerConnected.new)
+        send_to_client(client_message)
+      end
+
+      def create_client_message
+        client_message = MessageLib::ClientMessage.new
+        client_message.set_client_connection(client_connection)
+      end
+
+      def send_to_client(message)
+        bytes = message.to_byte_array
+        server.sendToClient(
+          bytes,
+          client[:host],
+          client[:port],
+          client[:ctx]
+        )
+
+      end
+
+      def on_receive(message)
+        #GameMachine.logger.info "Sending message to player"
+        client_message = create_client_message
+        message.set_send_to_player(false)
+        client_message.add_entity(message)
+        send_to_client(client_message)
+      end
+    end
+  end
+end

data/lib/game_machine/game_loader.rb

@@ -0,0 +1,46 @@
+require 'pathname'
+module GameMachine
+  class GameLoader
+
+    class << self
+
+      def games_root
+        File.join(GameMachine.app_root,'/games')
+      end
+    end
+
+
+    def game_dirs
+      Pathname.glob("#{self.class.games_root}/*/")
+    end
+
+    def load_from_dir(dir)
+      bootfile = File.join(dir,'boot.rb')
+      if File.exists?(bootfile)
+        load_game(bootfile)
+        GameMachine.logger.info "#{bootfile} loaded"
+        GameMachine.stdout "#{bootfile} loaded"
+      else
+        GameMachine.logger.info "#{bootfile} not found"
+        GameMachine.stdout "#{bootfile} not found"
+      end
+    end
+
+    def load_all
+      return if GameMachine.env == 'test'
+      game_dirs.each do |game_dir|
+        load_from_dir(game_dir)
+      end
+    end
+
+    def start_player_manager
+      if klass = Application.config.player_manager
+        Actor::Builder.new(klass.constantize).start
+      end
+    end
+
+    def load_game(bootfile)
+      require bootfile
+    end
+  end
+end

data/lib/game_machine/game_systems.rb

@@ -0,0 +1,14 @@
+
+require_relative 'game_systems/chat_manager'
+require_relative 'game_systems/chat'
+require_relative 'game_systems/chat_topic'
+require_relative 'game_systems/entity_loader'
+require_relative 'game_systems/entity_tracking'
+require_relative 'game_systems/local_echo'
+require_relative 'game_systems/remote_echo'
+require_relative 'game_systems/stress_test'
+require_relative 'game_systems/devnull'
+require_relative 'game_systems/objectdb_proxy'
+require_relative 'game_systems/agents/controller'
+require_relative 'game_systems/region_manager'
+require_relative 'game_systems/region_service'

data/lib/game_machine/game_systems/agents/controller.rb

@@ -0,0 +1,118 @@
+module GameMachine
+  module GameSystems
+    module Agents
+
+      class Controller < Actor::Base
+
+        attr_reader :agent_config, :current_agents, :address, :children
+        def post_init(*args)
+          @agent_config = args.first
+          @agent_config.load!
+          @address = local_address
+          @current_agents = local_agents
+          @children = {}
+          create_agents(current_agents)
+          schedule_message('agent_tick',100)
+          schedule_message('check_config',10000)
+          ClusterMonitor.find.tell('register_observer',get_self)
+        end
+
+        def on_receive(message)
+
+          if message.is_a?(String)
+            if message == 'agent_tick'
+              @children.each do |name,actor_ref|
+                actor_ref.tell('update',get_self)
+              end
+            elsif message == 'check_config'
+              if agent_config.reload?
+                agent_config.load!
+                update_agents
+              end
+            elsif message == 'cluster_update'
+              update_agents
+            end
+          end
+        end
+
+        def update_agents
+          agents_to_create = {}
+          agents_to_destroy = {}
+          updated_agents = local_agents
+
+          # agents no longer under our control
+          current_agents.each do |name,klass|
+            unless updated_agents.has_key?(name)
+              agents_to_destroy[name] = klass
+            end
+          end
+
+          # new agents that need creating
+          updated_agents.each do |name,klass|
+            unless current_agents.has_key?(name)
+              agents_to_create[name] = klass
+            end
+          end
+
+          @current_agents = updated_agents
+          destroy_agents(agents_to_destroy)
+          create_agents(agents_to_create)
+        end
+
+        def destroy_agents(agents)
+          agents.map {|agent_name,klass| destroy_child(agent_name)}
+        end
+
+        def create_agents(agents)
+          agents.map {|agent_name,klass| create_child(agent_name,klass)}
+        end
+
+        def destroy_child(agent_name)
+          if @children.has_key?(agent_name)
+            tell_child(agent_name,JavaLib::PoisonPill.get_instance)
+            @children.delete(agent_name)
+            GameMachine.logger.info "Agent #{agent_name} killed"
+          else
+            GameMachine.logger.info "Agent #{agent_name} not found, unable to kill"
+          end
+        end
+
+        def create_child(agent_name,klass_name)
+          klass = klass_name.constantize
+          name = child_name(agent_name)
+          builder = Actor::Builder.new(klass,agent_name)
+          child = builder.with_parent(context).with_name(name).start
+          @children[agent_name] = Actor::Ref.new(child,klass.name)
+          GameMachine.logger.info "Agent #{agent_name} created"
+        end
+
+        def tell_child(agent_name,message)
+          name = child_name(agent_name)
+          @children[agent_name].tell(message,nil)
+        end
+
+        def child_name(agent_name)
+          "agent_#{agent_name}"
+        end
+
+        def local_address
+          name = AppConfig.instance.config.name
+          Akka.address_for(name)
+        end
+
+        def local_agents
+          {}.tap do |agents|
+            agent_config.agent_names.each do |name|
+              bucket = Akka.instance.hashring.bucket_for(name)
+              if bucket == address
+                agents[name] = agent_config.klass_for_name(name)
+              end
+            end
+          end
+        end
+
+      end
+
+    end
+  end
+end