game_machine 0.0.11 → 1.0.2

data/lib/game_machine/endpoints/tcp.rb

@@ -1,51 +0,0 @@
-module GameMachine
-  module Endpoints
-    class Tcp < Actor::Base
-
-      def post_init(*args)
-        @clients = {}
-        @mgr = nil
-      end
-
-      def preStart
-        @mgr = JavaLib::Tcp.get(getContext.system).getManager
-        inet = JavaLib::InetSocketAddress.new(
-          Application.config.tcp_host,
-          Application.config.tcp_port
-        )
-        @mgr.tell( JavaLib::TcpMessage.bind(getSelf,inet,100), getSelf)
-      end
-
-      def sanitize_address(name)
-        name.gsub!('/','')
-        name.gsub!('.','')
-        name.gsub!(':','_')
-        name
-      end
-
-      def on_receive(message)
-        if message.is_a?(MessageLib::ClientMessage)
-          if handler_ref = @clients.fetch(message.client_connection.id,nil)
-            handler_ref.tell(message)
-          else
-            GameMachine.logger.warn("No handler found for #{message.client_connection}")
-          end
-        elsif message.kind_of?(JavaLib::Tcp::Bound)
-          @mgr.tell(message,get_self)
-        elsif message.kind_of?(JavaLib::Tcp::CommandFailed)
-          getContext.stop(get_self)
-        elsif message.kind_of?(JavaLib::Tcp::Connected)
-          @mgr.tell(message,get_self)
-          handler_name = sanitize_address(message.remote_address.to_s)
-          handler_ref = Actor::Builder.new(TcpHandler,handler_name).with_name(handler_name).start
-          @clients[message.remote_address.to_s] = handler_ref
-          handler_ref.tell(message,get_sender)
-          get_sender.tell(JavaLib::TcpMessage.register(handler_ref), get_self)
-        else
-          unhandled(message)
-        end
-      end
-
-    end
-  end
-end

data/lib/game_machine/endpoints/tcp_handler.rb

@@ -1,75 +0,0 @@
-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

@@ -1,88 +0,0 @@
-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/game_loader.rb

@@ -1,46 +0,0 @@
-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/region_settings.rb

@@ -1,13 +0,0 @@
-require 'settingslogic'
-
-module GameMachine
-  module GameSystems
-    class RegionSettings < Settingslogic
-      source  File.expand_path(
-        ENV['CONFIG_FILE'] || File.join(ENV['APP_ROOT'], "config/regions.yml")
-      )
-      namespace ENV['GAME_ENV']
-
-    end 
-  end
-end

data/lib/game_machine/hashring.rb

@@ -1,48 +0,0 @@
-require 'consistent_hashing'
-
-module GameMachine
-  class Hashring
-
-    RING_SIZE = 24
-    REPLICAS = 3
-
-    attr_reader :buckets
-
-    def self.create_actor_ring(name,ring_size=RING_SIZE)
-      buckets = (0..ring_size).map {|r| "#{name}#{r}"}
-      new(buckets)
-    end
-
-    def initialize(buckets)
-      @buckets = buckets
-      @ring = ConsistentHashing::Ring.new(@buckets,REPLICAS)
-    end
-
-    def points
-      @ring.points
-    end
-
-    def nodes
-      @ring.nodes
-    end
-
-    def remove_bucket(bucket)
-      if @buckets.include?(bucket)
-        @buckets.delete_if {|b| b == bucket}
-        @ring.delete(bucket)
-      end
-    end
-
-    def add_bucket(bucket)
-      unless @buckets.include?(bucket)
-        @ring << bucket
-        @buckets << bucket
-      end
-    end
-
-    def bucket_for(value)
-      @ring.node_for(value)
-    end
-
-  end
-end

data/lib/game_machine/settings.rb

@@ -1,11 +0,0 @@
-require 'settingslogic'
-
-module GameMachine
-  class Settings < Settingslogic
-    source  File.expand_path(
-      ENV['CONFIG_FILE'] || File.join(ENV['APP_ROOT'], "config/config.yml")
-    )
-    namespace ENV['GAME_ENV']
-
-  end 
-end

data/mono/server/actor.cs

@@ -1,37 +0,0 @@
-using System.Net;
-using System.Net.Sockets;
-using System;
-using  ProtoBuf;
-using System.Text;
-using System.Collections.Generic;
-using System.IO;
-using System.Threading;
-using Entity = GameMachine.Messages.Entity;
-using GameMachine;
-using System.Collections.Concurrent;
-
-namespace GameMachine
-{
-    public abstract class Actor : IActor
-    {
-        private ProxyClient proxyClient;
-
-        public Actor()
-        {
-        }
-
-        public void PostInit(ProxyClient pc)
-        {
-            proxyClient = pc;
-        }
-
-        public abstract void OnReceive(object message);
-
-        public void Tell(string destination, Entity entity)
-        {
-            entity.destination = destination;
-            byte[] bytes = MessageUtil.EntityToByteArray(entity);
-            proxyClient.Send(bytes);
-        }
-    }
-}

data/mono/server/iactor.cs

@@ -1,11 +0,0 @@
-using GameMachine;
-using Entity = GameMachine.Messages.Entity;
-namespace GameMachine
-{
-    public interface IActor
-    {
-        void OnReceive(object message);
-        void PostInit(ProxyClient proxyClient);
-        void Tell(string destination, Entity entity);
-    }
-}

data/mono/server/message_util.cs

@@ -1,29 +0,0 @@
-using System;
-using System.Text;
-using System.IO;
-using  ProtoBuf;
-using Entity = GameMachine.Messages.Entity;
-
-namespace GameMachine
-{
-    public class MessageUtil
-    {
-        public static Entity ByteArrayToEntity(byte[] bytes)
-        {
-            Entity entity;
-            MemoryStream stream = new MemoryStream(bytes);
-            entity = Serializer.Deserialize<Entity>(stream);
-            return entity;
-        }
-		
-        public static byte[] EntityToByteArray(Entity entity)
-        {
-            byte[] data;
-            MemoryStream stream = new MemoryStream();
-            Serializer.Serialize(stream, entity);
-            data = stream.ToArray();
-            return data;
-        }
-		
-    }
-}

data/mono/server/proxy_client.cs

@@ -1,73 +0,0 @@
-using System;
-using System.Diagnostics;
-using System.Net;
-using System.Net.Sockets;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
-using System.IO;
-using  ProtoBuf;
-using GameMachine;
-using Entity = GameMachine.Messages.Entity;
-
-namespace GameMachine
-{
-    public class ProxyClient
-    {
-        private IPEndPoint udp_ep;
-        private UdpClient udpClient;
-        private int port = 8800;
-        private string host = "127.0.0.1";
-
-        public ProxyClient(int _port)
-        {
-          port = _port;
-        }
-
-        public void Start()
-        {
-            udp_ep = new IPEndPoint(IPAddress.Any, 11000);
-            udpClient = new UdpClient(udp_ep);
-            receiveData();
-			
-            Task.Factory.StartNew(() => {
-                Ping(); });
-        }
-
-        private void Ping()
-        {
-            Entity entity = new Entity();
-            entity.id = "ping";
-            byte[] bytes = MessageUtil.EntityToByteArray(entity);
-            while (true)
-            {
-                Thread.Sleep(1000);
-                Send(bytes);
-            }
-        }
-
-        private void SendCallback(IAsyncResult ar)
-        {
-            UdpClient u = (UdpClient)ar.AsyncState;
-            u.EndSend(ar);
-        }
-		
-        public void Send(byte[] bytes)
-        {
-            udpClient.BeginSend(bytes, bytes.Length, host, port, new AsyncCallback(SendCallback), udpClient);
-        }
-		
-        private void dataReady(IAsyncResult ar)
-        {
-            byte[] bytes = udpClient.EndReceive(ar, ref udp_ep);
-            receiveData();
-            MessageRouter.Route(bytes, this);
-        }
-		
-        private void receiveData()
-        {
-            udpClient.BeginReceive(new AsyncCallback(dataReady), udp_ep);
-        }
-		
-    }
-}