game_machine 0.0.8

data/lib/game_machine/handlers/game.rb

@@ -0,0 +1,63 @@
+module GameMachine
+  module Handlers
+    class Game < Actor::Base 
+      include Commands
+
+      attr_reader :destinations
+      def post_init(*args)
+        @destinations = {}
+      end
+
+
+      def on_receive(message)
+        if message.is_a?(MessageLib::ClientMessage)
+          if message.get_entity_list
+            dispatch_entities(message.get_entity_list)
+          end
+        else
+          unhandled(message)
+        end
+      end
+
+      private
+
+      def dispatch_entities(entities)
+        entities.each do |entity|
+          if entity.save
+            entity = GameSystems::ObjectDbProxy.save_entity(entity)
+          end
+
+          if entity.has_destination
+            unless actor_ref = destinations.fetch(entity.destination,nil)
+              destination = entity.destination.gsub('/','::')
+              actor_ref = Actor::Base.find(destination)
+              destinations[entity.destination] = actor_ref
+            end
+            entity.set_destination(nil)
+            actor_ref.tell(entity)
+            GameMachine.logger.debug("RouteToDestination: #{entity.id} #{destination}")
+            next
+          end
+
+          # TODO: Optimize this
+          component_names = entity.component_names
+          GameMachine.logger.debug("Dispatch: #{entity} #{component_names.to_a.inspect}")
+          next if component_names.empty?
+          Application.registered.each do |klass|
+            dispatched = false
+            klass.aspects.each do |aspect|
+              next if dispatched
+              if (aspect & component_names).size == aspect.size
+                GameMachine.logger.debug "Routing #{entity} via #{aspect} #{component_names} to #{klass}"
+                klass.find.tell(entity)
+                dispatched = true
+              end
+            end
+          end
+        end
+      end
+
+    end
+  end
+end
+

data/lib/game_machine/handlers/request.rb

@@ -0,0 +1,80 @@
+module GameMachine
+  module Handlers
+    class Request < Actor::Base
+      include Commands
+
+      def post_init(*args)
+        @auth_handler = Authentication.new
+      end
+
+      def on_receive(message)
+        if message.is_a?(MessageLib::ClientMessage)
+          if message.has_player_logout
+            if Authentication.authenticated?(message.player)
+              unregister_client(message)
+              commands.misc.player_status_change(message.player.id,:unregistered)
+            end
+          elsif message.has_player
+            update_entities(message)
+            if Authentication.authenticated?(message.player)
+              game_handler.tell(message)
+            else
+              if @auth_handler.authenticate!(message.player)
+                register_client(message)
+                commands.misc.player_status_change(message.player.id,:registered)
+                game_handler.tell(message)
+              end
+            end
+          else
+            unhandled(message)
+          end
+        else
+          unhandled(message)
+        end
+      end
+
+      private
+
+      def register_client(message)
+        GameMachine.logger.info "Register #{message.player.id}"
+        player_id = message.player.id
+        client_id = message.client_connection.id
+        #GameMachine.logger.info "player_id=#{message.player.id} client_id=#{client_id}"
+        register = MessageLib::ClientManagerRegister.new.
+          set_register_type('client').set_name(client_id)
+        entity = MessageLib::Entity.new.set_id(client_id).
+          set_client_manager_register(register).set_client_connection(
+          message.client_connection
+        )
+        entity.set_player(message.player)
+        ClientManager.find.ask(entity,5000)
+      end
+
+      def unregister_client(message)
+        GameMachine.logger.info "Unregister #{message.player.id}"
+        player_id = message.player.id
+        client_id = message.client_connection.id
+        Authentication.unregister_player(player_id)
+        entity = MessageLib::Entity.new.set_id(client_id).set_client_manager_unregister(
+          MessageLib::ClientManagerUnregister.new.set_register_type('client').
+            set_name(client_id)
+        ).set_client_connection(message.client_connection)
+        entity.set_player(message.player)
+        ClientManager.find.tell(entity)
+      end
+
+      def game_handler
+        @game_handler ||= Handlers::Game.find
+      end
+
+      def update_entities(message)
+        if message.get_entity_list
+          message.get_entity_list.each do |entity|
+            entity.set_player(message.player)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/game_machine/hashring.rb

@@ -0,0 +1,48 @@
+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/helpers/game_message.rb

@@ -0,0 +1,159 @@
+module GameMachine
+  module Helpers
+    class GameMessage
+      CHARS = [*('a'..'z'),*('0'..'9')].flatten
+      STR = Array.new(100) {|i| CHARS.sample}.join
+      STR2 = Array.new(1000) {|i| CHARS.sample}.join
+
+      attr_reader :player_id, :client_message
+
+      def initialize(player_id,default_entity_id=nil)
+        @player_id = player_id
+        @current_entity_id = default_entity_id || 'default'
+        @client_message = create_client_message(@player_id)
+      end
+
+      def to_byte_array
+        client_message.to_byte_array
+      end
+
+      def send_to_player
+        client_message.send_to_player
+      end
+
+      def entities
+        client_message.get_entity_list.to_a
+      end
+
+      def has_entity?(id)
+        entities.select {|entity| entity.id == id}.first ? true : false
+      end
+
+      def current_entity
+        unless has_entity?(@current_entity_id)
+          add_entity(@current_entity_id)
+        end
+        entities.select {|entity| entity.id == @current_entity_id}.first
+      end
+
+      def entity(id)
+        @current_entity_id = id
+        current_entity
+      end
+
+      def to_entity
+        current_entity.set_player(client_message.player)
+      end
+
+      def error_message(code,message)
+        client_message.set_error_message(
+          MessageLib::ErrorMessage.new.set_code(code).set_message(message)
+        )
+      end
+
+      def client_disconnect(client_id,gateway)
+        client_message.set_client_disconnect(
+          MessageLib::ClientDisconnect.new.set_client_connection(
+            client_connection(client_id,gateway)
+          )
+        )
+      end
+
+      def player_logout
+        client_message.set_player_logout(
+          MessageLib::PlayerLogout.new.set_player_id(@player_id)
+        )
+      end
+
+      def track_entity
+        current_entity.set_track_entity(
+          MessageLib::TrackEntity.new.set_value(true)
+        )
+      end
+
+      def get_neighbors(search_radius=nil)
+          component = MessageLib::GetNeighbors.new
+          component.set_value(true)
+          if search_radius
+            component.set_search_radius(search_radius)
+          end
+        current_entity.set_get_neighbors(component)
+      end
+
+      def neighbors(players,npcs)
+        current_entity.set_neighbors(
+          MessageLib::Neighbors.new.set_player_list(players).set_npc_list(npcs)
+        )
+      end
+
+      def player_move(x,y)
+        current_entity.set_player_move(
+          MessageLib::PlayerMove.new.set_target(
+            MessageLib::Target.new.set_x(x).set_y(y)
+          )
+        )
+      end
+
+      def client_connection(client_id,gateway)
+        MessageLib::ClientConnection.new.set_id(client_id).set_gateway(gateway)
+      end
+
+      def chat_channels(names)
+        channels = MessageLib::ChatChannels.new
+        names.each do |name|
+          channels.add_chat_channel(chat_channel(name))
+        end
+        current_entity.set_chat_channels(channels)
+      end
+
+      def chat_channel(topic,flags='')
+        MessageLib::ChatChannel.new.set_name(topic).set_flags(flags)
+      end
+
+      def chat_message(type,message_text,topic)
+        message = MessageLib::ChatMessage.new
+        message.set_chat_channel(
+          chat_channel(topic)
+        )
+        message.set_message(message_text)
+        message.set_type(type)
+        current_entity.set_chat_message(message)
+      end
+
+      def join_chat(topic,flags='')
+        current_entity.set_join_chat(
+          MessageLib::JoinChat.new.add_chat_channel(chat_channel(topic,flags))
+        )
+      end
+
+      def leave_chat(topic)
+        current_entity.set_leave_chat(
+          MessageLib::LeaveChat.new.add_chat_channel(chat_channel(topic))
+        )
+      end
+
+      def echo_test(value)
+        current_entity.set_echo_test(MessageLib::EchoTest.new.set_message(value))
+      end
+
+      private
+
+      def create_client_message(player_id)
+        client_message = MessageLib::ClientMessage.new
+        client_message.set_player(player(player_id))
+      end
+
+      def add_entity(id)
+        client_message.add_entity(MessageLib::Entity.new.set_id(id))
+      end
+
+      def player(player_id)
+        player = MessageLib::Player.new.
+          set_id(player_id).
+          set_name(player_id).
+          set_authtoken('authorized')
+      end
+
+    end
+  end
+end

data/lib/game_machine/helpers/state_machine.rb

@@ -0,0 +1,29 @@
+module GameMachine
+  module Helpers
+    module StateMachine
+
+      def load_state(id, &block)
+        @actor_states[id] ||= @initial_state
+        self.state = @actor_states[id]
+        if block_given?
+          yield
+          save_state(id)
+        end
+      end
+
+      def save_state(id)
+        @actor_states[id] = self.state
+      end
+
+      def destroy_state(id)
+        @actor_states.delete(id)
+      end
+
+      def initialize_states
+        @actor_states = {}
+        initialize_state_machines
+        @initial_state = self.state.dup
+      end
+    end
+  end
+end

data/lib/game_machine/java_lib.rb

@@ -0,0 +1,51 @@
+module GameMachine
+
+  module MessageLib
+    include_package 'GameMachine.Messages'
+  end
+
+  module RedisLib
+    include_package 'redis.clients.jedis'
+    include_package 'redis.clients.jedis.exceptions'
+    include_package 'redis.clients.util'
+  end
+
+  module ZeromqLib
+    include_package 'akka.zeromq'
+  end
+
+  module ProtoLib
+    include_package 'com.dyuproject.protostuff'
+  end
+
+  module JavaLib
+    java_import 'akka.cluster.ClusterEvent'
+    java_import 'akka.contrib.pattern.ClusterSingletonManager'
+    java_import 'akka.contrib.pattern.ClusterSingletonProxy'
+    include_package 'akka.serialization'
+    include_package 'com.typesafe.config'
+    include_package 'akka.actor'
+    include_package 'akka.io'
+    include_package 'akka.util'
+    include_package 'akka.pattern'
+    include_package 'akka.testkit'
+    include_package 'akka.cluster'
+    include_package 'akka.routing'
+    include_package 'akka.serialization'
+    include_package 'akka.contrib.pattern'
+    include_package 'akka.event'
+    include_package 'akka.camel.javaapi'
+    include_package 'akka.camel'
+    java_import 'com.game_machine.core.Grid'
+    include_package 'com.game_machine.core'
+    include_package 'java.net'
+    include_package 'java.util.concurrent.atomic'
+    include_package 'scala.concurrent.duration'
+    include_package 'scala.concurrent'
+    include_package 'java.io.Serializable'
+    include_package 'java.util'
+    include_package 'java.io'
+    include_package 'com.couchbase.client'
+    include_package 'io.netty.channel'
+  end
+end

data/lib/game_machine/logger.rb

@@ -0,0 +1,39 @@
+require 'rjack-logback'
+
+module GameMachine
+  module Logger
+
+    LOGGER = RJack::SLF4J[ 'game_machine' ]
+
+    def stdout(message)
+      unless ENV['GAME_ENV'] == 'test'
+        print "#{message}\n"
+      end
+    end
+
+    def logfile
+      File.join(ENV['APP_ROOT'], 'log',"#{ENV['GAME_ENV']}.log")
+    end
+
+    def configure_logging
+      RJack::Logback.configure do
+        console = RJack::Logback::ConsoleAppender.new do |a|
+        end
+
+        file = RJack::Logback::FileAppender.new(logfile) do |a|
+        end
+
+        RJack::Logback.root.add_appender( file )
+        RJack::Logback.root.level = RJack::Logback::INFO
+      end
+    end
+
+    def logger
+      LOGGER
+    end
+
+  end
+end
+
+GameMachine.send(:extend, GameMachine::Logger)
+GameMachine.configure_logging