game_machine 0.0.8

data/lib/game_machine/clients.rb

@@ -0,0 +1,4 @@
+require_relative 'clients/client'
+require_relative 'clients/udt_client'
+require_relative 'clients/tcp_client'
+require_relative 'clients/udp_client'

data/lib/game_machine/clients/client.rb

@@ -0,0 +1,45 @@
+require 'socket'
+require "uri"
+
+module GameMachine
+  module Clients
+    class Client
+
+      def initialize(server)
+        @host = Settings.servers.send(server).udp_host
+        @port = Settings.servers.send(server).udp_port
+        @socket = UDPSocket.new
+        @socket.connect(@host,@port)
+      end
+
+      def send_message(message)
+        @socket.send(String.from_java_bytes(message),@host,@port)
+      end
+
+      def receive_message
+        @socket.recvfrom(1024)[0]
+      end
+
+      def self.http_post(path,data)
+        uri = URI.parse("http://localhost:8080#{path}")
+        response = Net::HTTP.post_form(uri, data)
+        response.body
+      end
+
+      def self.connect_udt
+        address = JavaLib::InetSocketAddress.new(Settings.servers.seed01.udt_host, Settings.servers.seed01.udt_port)
+        s = JavaLib::SocketUDT.new(JavaLib::TypeUDT::DATAGRAM)
+        s.setBlocking(true)
+        s.connect(address)
+        s
+      end
+
+      def self.send_udt(s,bytes)
+        s.send(bytes)
+        array = Java::byte[4096].new
+        l = s.receive(array)
+        JavaLib::Arrays.copy_of_range(array,0,l)
+      end
+    end
+  end
+end

data/lib/game_machine/clients/tcp_client.rb

@@ -0,0 +1,25 @@
+require 'socket'
+require "uri"
+
+module GameMachine
+  module Clients
+    class TcpClient
+
+      def initialize(host,port)
+        @host = host
+        @port = port
+        @socket = TCPSocket.open(@host,@port)
+      end
+
+      def send_message(message)
+        @socket.send(message,0)
+        #@socket.send(String.from_java_bytes(message))
+      end
+
+      def receive_message
+        @socket.recvfrom(1024)[0]
+      end
+
+    end
+  end
+end

data/lib/game_machine/clients/test_client.rb

@@ -0,0 +1,151 @@
+module GameMachine
+  module Clients
+    class TestClientProxy
+
+      include RSpec::Matchers
+      attr_reader :config
+
+      def initialize(name,client)
+        @data = java.util.concurrent.ConcurrentHashMap.new
+        @data[:name] = name
+        @data[:client] = client
+        @data[:actual] = []
+      end
+
+      def ctx=(ctx)
+        @data[:ctx] = ctx
+      end
+
+      def ctx
+        @data[:ctx]
+      end
+
+      def actual=(actual)
+        @data[:actual] = actual
+      end
+
+      def actual
+        @data[:actual]
+      end
+
+      def client
+        @data[:client]
+      end
+
+      def name
+        @data[:name]
+      end
+
+      def wait_for_ctx
+        loop do
+          @data[:ctx] = TestClient.find(name).ask('ctx',20)
+          return if @data[:ctx]
+        end
+      end
+
+      def ref
+        TestClient.find(name)
+      end
+
+      def stop
+        ref.tell('stop')
+        client.shutdown
+      end
+
+      def send_to_server(client_message)
+        client.send_to_server(client_message.to_byte_array,ctx)
+      end
+
+      def do_expect(found,not_found,component)
+        unless found
+          found = not_found
+        end
+        expect(found).to eq(component)
+        actual.clear
+      end
+
+      def clear
+        actual.clear
+      end
+
+      def entity_with_component(component,wait=0.100,&blk)
+        found = false
+        10.times do
+          actual.each do |entity|
+            if entity.component_names.include?(component)
+              yield entity if block_given?
+              found = entity
+            end
+          end
+          return found if found
+          sleep wait
+        end
+        found
+      end
+
+      def should_receive_component(component,wait=0.20, &blk)
+        actual ||= []
+        blk.call
+        called = false
+        found = nil
+        not_found = []
+        10.times do
+          not_found = []
+          actual.each do |entity|
+            if entity.component_names.include?(component)
+              called = true
+              found = component
+            else
+              not_found += entity.component_names
+            end
+          end
+          if called
+            do_expect(found,not_found,component)
+            return
+          end
+          sleep wait
+        end
+      end
+    end
+
+
+    class TestClient < Actor::Base
+
+      class << self
+        def start(name,port)
+          client = UdtClient.start(name,'localhost',port)
+          proxy = TestClientProxy.new(name,client)
+          Actor::Builder.new(self,name,port,proxy).with_name(name).start
+          proxy.wait_for_ctx
+          proxy
+        end
+      end
+
+
+      def post_init(*args)
+        @name = args[0]
+        @port = args[1]
+        @proxy = args[2]
+        @ctx = nil
+      end
+
+      def on_receive(message)
+        if message.is_a?(JavaLib::DefaultChannelHandlerContext)
+          @ctx = message
+        elsif message == 'ctx'
+          sender.tell(@ctx) if @ctx
+        elsif message == 'stop'
+          context.stop
+        else
+          @proxy.actual ||= []
+          client_message = ClientMessage.parse_from(message.bytes)
+          client_message.get_entity_list.each do |entity|
+            GameMachine.logger.info "GOT #{entity.component_names.join(' | ')}"
+            @proxy.actual << entity
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/game_machine/clients/udp_client.rb

@@ -0,0 +1,25 @@
+require 'socket'
+require "uri"
+
+module GameMachine
+  module Clients
+    class UdpClient
+
+      def initialize(server)
+        @host = Settings.servers.send(server).udp_host
+        @port = Settings.servers.send(server).udp_port
+        @socket = UDPSocket.new
+        @socket.connect(@host,@port)
+      end
+
+      def send_message(message)
+        @socket.send(message,@host,@port)
+      end
+
+      def receive_message
+        @socket.recvfrom(1024)[0]
+      end
+
+    end
+  end
+end

data/lib/game_machine/clients/udt_client.rb

@@ -0,0 +1,34 @@
+module GameMachine
+  module Clients
+    class UdtClient
+
+      def initialize(server)
+        @host = Settings.servers.send(server).udt.host
+        @port = Settings.servers.send(server).udt.port
+      end
+
+      def disconnect
+        @socket.close
+      end
+
+      def connect
+        address = JavaLib::InetSocketAddress.new(@host, @port)
+        @socket = JavaLib::SocketUDT.new(JavaLib::TypeUDT::DATAGRAM)
+        @socket.setBlocking(true)
+        @socket.connect(address)
+        @socket
+      end
+
+      def send_message(bytes)
+        @socket.send(bytes)
+      end
+
+      def receive(timeout=0.100)
+        array = Java::byte[4096].new
+        res = @socket.receive(array)
+        JavaLib::Arrays.copy_of_range(array,0,res)
+      end
+    end
+  end
+end
+

data/lib/game_machine/cluster_monitor.rb

@@ -0,0 +1,115 @@
+module GameMachine
+  class ClusterMonitor < Actor::Base
+
+    def self.cluster_members
+      if @cluster_members
+        @cluster_members
+      else
+        @cluster_members = java.util.concurrent.ConcurrentHashMap.new
+      end
+    end
+
+    def self.remote_members
+      if @remote_members
+        @remote_members
+      else
+        @remote_members = java.util.concurrent.ConcurrentHashMap.new
+      end
+    end
+    
+    def self.add_cluster_member(address,member)
+      cluster_members[address] = member
+    end
+
+    def self.remove_cluster_member(address)
+      cluster_members.delete(address)
+    end
+
+    def self.remove_remote_member(address)
+      remote_members.delete(address)
+    end
+
+    def self.add_remote_member(address,member)
+      remote_members[address] = member
+    end
+
+    def preStart
+      if getContext.system.name == 'cluster'
+        @cluster = JavaLib::Cluster.get(getContext.system)
+        Akka.instance.init_cluster!(@cluster.self_address.to_string)
+        @cluster.subscribe(getSelf,
+                           JavaLib::ClusterEvent::MemberEvent.java_class,
+                           JavaLib::ClusterEvent::UnreachableMember.java_class)
+        GameMachine.logger.info "Cluster address #{@cluster.self_address.to_string}"
+      end
+      @observers = []
+      @notify_on_up_observers = []
+      @notify_on_down_observers = []
+    end
+
+    def notify_member_up
+      @notify_on_up_observers.each {|i| i[1].tell(i[0],get_self)}
+    end
+
+    def notify_member_down
+      @notify_on_down_observers.each {|i| i[1].tell(i[0],get_self)}
+    end
+
+    def notify_observers
+      @observers.each {|observer| observer.tell('cluster_update',get_self)}
+    end
+
+    def on_receive(message)
+      if message.is_a?(String)
+        if message == 'register_observer'
+          @observers << sender
+        elsif message == 'notify_on_up'
+          @notify_on_up_observers << [message,sender]
+        elsif message == 'notify_on_down'
+          @notify_on_down_observers << [message,sender]
+        end
+      elsif message.is_a?(JavaLib::ClusterEvent::SeenChanged)
+
+      elsif message.is_a?(JavaLib::ClusterEvent::MemberRemoved)
+        address = message.member.address.to_string
+        Akka.instance.hashring.remove_bucket(address)
+        self.class.remove_cluster_member(address)
+        self.class.remove_remote_member(address)
+
+        notify_observers
+        notify_member_down
+
+        GameMachine.logger.info "MemberRemoved #{address}"
+      elsif message.is_a?(JavaLib::ClusterEvent::MemberUp)
+        address = message.member.address.to_string
+        self.class.add_cluster_member(address,message.member)
+        Akka.instance.hashring.add_bucket(address)
+
+        unless address == @cluster.self_address.to_string
+          self.class.add_remote_member(address,message.member)
+        end
+
+        notify_member_up
+        notify_observers
+        GameMachine.logger.info "MemberUp #{address}"
+      elsif message.is_a?(JavaLib::ClusterEvent::ClusterMetricsChanged)
+
+      elsif message.is_a?(JavaLib::ClusterEvent::CurrentClusterState)
+        message.get_members.each do |member|
+          address = member.address.to_string
+          self.class.add_cluster_member(address,member)
+          Akka.instance.hashring.add_bucket(address)
+          unless address == @cluster.self_address.to_string
+            self.class.add_remote_member(address,member)
+          end
+        end
+
+        notify_observers
+
+      else
+        #GameMachine.logger.info("Unrecognized message #{message}")
+      end
+    end
+  end
+end
+

data/lib/game_machine/commands.rb

@@ -0,0 +1,23 @@
+require_relative 'commands/message_helper'
+require_relative 'commands/datastore_commands'
+require_relative 'commands/chat_commands'
+require_relative 'commands/player_commands'
+require_relative 'commands/grid_commands'
+require_relative 'commands/misc_commands'
+require_relative 'commands/proxy'
+require_relative 'commands/base'
+
+if Config::CONFIG['target_os'] == 'linux'
+  require_relative 'commands/navigation_commands'
+end
+
+module GameMachine
+  module Commands
+
+    def commands
+      @commands ||= Base.new
+    end
+
+  end
+end
+

data/lib/game_machine/commands/base.rb

@@ -0,0 +1,21 @@
+module GameMachine
+  module Commands
+    class Base
+
+      attr_reader :player, :grid, :chat, :datastore, :navigation, :misc
+
+      def self.commands
+        @commands ||= new
+      end
+
+      def initialize
+        @player = PlayerCommands.new
+        @grid = GridCommands.new
+        @chat = ChatCommands.new
+        @datastore = DatastoreCommands.new
+        @misc = MiscCommands.new
+        #@navigation = NavigationCommands.new
+      end
+    end
+  end
+end