game_machine 0.0.8

data/java/src/main/resources/logback.xml

@@ -0,0 +1,14 @@
+<configuration>
+
+  <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+    <!-- encoders are assigned the type
+         ch.qos.logback.classic.encoder.PatternLayoutEncoder by default -->
+    <encoder>
+      <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
+    </encoder>
+  </appender>
+
+  <root level="info">
+    <appender-ref ref="STDOUT" />
+  </root>
+</configuration>

data/java/src/main/resources/logging.properties

@@ -0,0 +1,3 @@
+
+handlers = java.util.logging.ConsoleHandler.level
+java.util.logging.ConsoleHandler.level = INFO

data/java/src/main/resources/protostuff.properties

@@ -0,0 +1,7 @@
+ modules = messages
+   messages.source = src/main/resources/messages.proto
+   #java_bean, gwt_overlay, java_v2protoc_schema
+   messages.output = src/main/resources/game_machine.java.stg
+   messages.outputDir = src/main/java
+   #messages.options = some_key,key:value,another_key
+   messages.options = generate_pipe_schema,generate_helper_methods,generate_field_map

data/lib/game_machine.rb

@@ -0,0 +1,85 @@
+
+require 'rbconfig'
+
+require_relative 'game_machine/ruby_extensions/nilclass'
+require_relative 'game_machine/ruby_extensions/string'
+require_relative 'game_machine/securerandom'
+
+module GameMachine
+  def self.env
+    ENV.fetch('GAME_ENV')
+  end
+
+  def self.app_root
+    ENV.fetch('APP_ROOT')
+  end
+
+  def self.java_root
+    ENV.fetch('JAVA_ROOT')
+  end
+end
+require 'java'
+
+jars = Dir[File.join(GameMachine.app_root, 'java/lib', '*.jar')]
+jars.each {|jar| require jar}
+
+#java_import 'com.game_machine.core.net.client.UdtClient'
+#java_import 'com.game_machine.core.net.client.UdtClientHandler'
+
+require_relative 'game_machine/java_lib'
+
+require_relative 'game_machine/protobuf'
+require_relative 'game_machine/version'
+require_relative 'game_machine/grid'
+require_relative 'game_machine/game_loader'
+require_relative 'game_machine/message_buffer'
+require_relative 'game_machine/vector'
+require_relative 'game_machine/logger'
+require_relative 'game_machine/app_config'
+require_relative 'game_machine/helpers/state_machine'
+require_relative 'game_machine/actor'
+require_relative 'game_machine/commands'
+require_relative 'game_machine/model'
+require_relative 'game_machine/models'
+require_relative 'game_machine/handlers/authentication'
+require_relative 'game_machine/hashring'
+require_relative 'game_machine/application'
+require_relative 'game_machine/game_systems'
+require_relative 'game_machine/handlers/request'
+require_relative 'game_machine/handlers/game'
+require_relative 'game_machine/actor/builder'
+require_relative 'game_machine/message_queue'
+require_relative 'game_machine/object_db'
+require_relative 'game_machine/write_behind_cache'
+require_relative 'game_machine/data_store'
+require_relative 'game_machine/auth_handlers/base'
+require_relative 'game_machine/auth_handlers/public'
+require_relative 'game_machine/system_monitor'
+require_relative 'game_machine/cluster_monitor'
+require_relative 'game_machine/system_stats'
+require_relative 'game_machine/reloadable_monitor'
+require_relative 'game_machine/client_manager'
+require_relative 'game_machine/scheduler'
+require_relative 'game_machine/endpoints'
+require_relative 'game_machine/protobuf_extensions/entity_helper'
+require_relative 'game_machine/helpers/game_message'
+require_relative 'game_machine/grid_replicator'
+require_relative 'game_machine/akka'
+require_relative 'game_machine/clients'
+require_relative 'game_machine/mono_server'
+require_relative 'game_machine/restart_watcher'
+require_relative 'game_machine/uniqueid'
+
+if Config::CONFIG['target_os'] == 'linux'
+  require_relative 'game_machine/navigation'
+else
+  GameMachine.logger.info "Pathfinding disabled (windows support not yet available)"
+end
+
+
+java.util.concurrent.TimeUnit::MILLISECONDS
+java.util.concurrent.TimeUnit::SECONDS
+
+
+
+

data/lib/game_machine/actor.rb

@@ -0,0 +1,7 @@
+require_relative 'actor/reloadable'
+require_relative 'actor/system'
+require_relative 'actor/base'
+require_relative 'actor/factory'
+require_relative 'actor/ref'
+require_relative 'actor/mono_actor'
+require_relative 'actor/development'

data/lib/game_machine/actor/base.rb

@@ -0,0 +1,184 @@
+module GameMachine
+  module Actor
+
+    class DuplicateHashringError < StandardError;end
+    class MissingHashringError < StandardError;end
+
+    # @abstract All game actors inherit fromm this class
+    class Base < JavaLib::UntypedActor
+  
+      ON_RECEIVE_HOOKS = {}
+
+      @@player_controller = nil
+
+      class << self
+        alias_method :apply, :new
+        alias_method :create, :new
+
+        # Sets the system wide player controller class.
+        # When a player logs in, a player controller with this class
+        # will be created. The system notifies the player controller when
+        # various player lifecycle events happen.
+        #
+        # This should only be called on subclasses, never on the Actor base
+        # class
+        def set_player_controller
+          @@player_controller = self
+          GameMachine.logger.info("Player controller set to #{self.name}")
+        end
+
+        def player_controller
+          @@player_controller
+        end
+
+
+        def aspects
+          @aspects ||= []
+        end
+        
+        # Sets the message types that this actor knows about. Can be called
+        # multiple times.  If passed an array of more then one message type,
+        # both message types will need to be present on an entity before the
+        # system will route the entity to the actor.
+        #
+        # messages will be routed to actors based on the aspects it has
+        def aspect(new_aspects)
+          aspects << new_aspects
+          unless Application.registered.include?(self)
+            Application.register(self)
+          end
+        end
+
+        def reset_hashrings
+          @@hashrings = nil
+        end
+
+        def hashrings
+          @@hashrings ||= java.util.concurrent.ConcurrentHashMap.new
+        end
+
+        def hashring(name)
+          hashrings.fetch(name,nil)
+        end
+
+        def add_hashring(name,hashring)
+          if hashring(name)
+            raise DuplicateHashringError, "name=#{name}"
+          end
+          hashrings[name] = hashring
+        end
+
+        # Find a local actor by name
+        # @return [Actor::Ref]
+        def find(name=self.name)
+          Actor::Ref.new(local_path(name),name)
+        end
+
+        # find using fully qualified address, ie akka://cluster@ ...
+        def find_by_address(address,name=self.name)
+          path = "#{address}#{local_path(name)}"
+          Actor::Ref.new(path,name)
+        end
+
+        # Find a remote actor by name
+        # @return [Actor::Ref]
+        def find_remote(server,name=self.name)
+          Actor::Ref.new(remote_path(server,name),name)
+        end
+
+        # Returns a local actor ref from the distributed ring of actors based
+        # on a consistent hashing of the id.
+        # @return [Actor::Ref]
+        def find_distributed_local(id,name=self.name)
+          ensure_hashring(name)
+          Actor::Ref.new(local_distributed_path(id, name),name)
+        end
+
+        # Returns an actor ref from the distributed ring of actors based
+        # on a consistent hashing of the id. The actor returned can be from
+        # any server in the cluster
+        # @return [Actor::Ref]
+        def find_distributed(id,name=self.name)
+          ensure_hashring(name)
+          Actor::Ref.new(distributed_path(id, name),name)
+        end
+
+        def local_path(name)
+          "/user/#{name}"
+        end
+
+        def model_filter(message)
+          if message.is_a?(MessageLib::Entity) && message.has_json_entity
+            # Don't convert outgoing messages
+            if message.send_to_player
+              message
+            else
+              message = Model.from_entity(message)
+            end
+          end
+          message
+        end
+
+        private
+
+        def ensure_hashring(name)
+          unless hashring(name)
+            raise MissingHashringError
+          end
+        end
+
+        def remote_path(server,name)
+          "#{Akka.address_for(server)}/user/#{name}"
+        end
+
+        def local_distributed_path(id,name)
+          bucket = hashring(name).bucket_for(id)
+          "/user/#{bucket}"
+        end
+
+        def distributed_path(id,name)
+          server = Akka.instance.hashring.bucket_for(id)
+          bucket = hashring(name).bucket_for(id)
+          "#{server}/user/#{bucket}"
+        end
+
+      end
+
+      # This indirection is primarily because Akka's test actors
+      # hide onReceive, so in tests we need to call receive_message
+      def receive_message(message)
+        message = self.class.model_filter(message)
+        on_receive(message)
+      end
+
+      # So we can hook into message passing for our own filters and the like
+      def onReceive(message)
+        receive_message(message)
+      end
+
+      def on_receive(message)
+        unhandled(message)
+      end
+
+      def sender
+        Actor::Ref.new(get_sender)
+      end
+
+      def schedule_message(message,update_interval,unit=:ms)
+        if unit == :seconds
+          unit = java.util.concurrent.TimeUnit::SECONDS
+        elsif unit == :ms
+          unit = java.util.concurrent.TimeUnit::MILLISECONDS
+        else
+          GameMachine.logger.error "Invalid unit argument for schedule_message (#{unit})"
+          return
+        end
+
+        duration = GameMachine::JavaLib::Duration.create(update_interval, unit)
+        scheduler = get_context.system.scheduler
+        dispatcher = get_context.system.dispatcher
+        scheduler.schedule(duration, duration, get_self, message, dispatcher, nil)
+      end
+    end
+  end
+end

data/lib/game_machine/actor/builder.rb

@@ -0,0 +1,108 @@
+require 'jruby/core_ext'
+module GameMachine
+  module Actor
+
+    class Builder
+
+      attr_reader :name
+
+      # Creates an actor builder instance.  First argument is the actor class
+      # remaining arguments are optional and will be passed to post_init
+      # @param args 
+      # @return self
+      def initialize(*args)
+        @klass = args.shift
+        @name = @klass.name
+        @create_hashring = false
+        @hashring_size = 0
+        factory = Actor::Factory.new(@klass,args)
+        @props = JavaLib::Props.create(
+          JavaLib::ActorFactory.java_class,factory,@klass.name)
+        @actor_system = Akka.instance.actor_system
+      end
+
+      # Special case.  Must be created like so:
+      # Actor::Builder.new(SingletonActorClass).singleton
+      # NO OTHER OPTIONS.  It will fail anyways if you do
+      def singleton
+        @actor_system.actor_of(
+          JavaLib::ClusterSingletonManager.defaultProps(
+            @props,@name,JavaLib::PoisonPill.get_instance,nil),'singleton')
+        @actor_system.actor_of(
+          JavaLib::ClusterSingletonProxy.defaultProps(
+            "user/singleton/#{@name}", nil), @name);
+      end
+
+      def test_ref
+        JavaLib::TestActorRef.create(@actor_system,@props,@name)
+      end
+
+      # Sets the parent actor
+      # @param parent
+      # @return self
+      def with_parent(parent)
+        @actor_system = parent
+        self
+      end
+
+      # Sets the actor's name
+      # @param name
+      # @return self
+      def with_name(name)
+        @name = name
+        self
+      end
+
+      def with_dispatcher(name)
+        @props = @props.with_dispatcher(name)
+        self
+      end
+
+      # Run the actor under a router
+      # @param router_class [Class] num_router [Integer]
+      # @return self
+      def with_router(router_class,num_routers)
+        @props = @props.with_router(
+          router_class.new(num_routers)
+        )
+        self
+      end
+
+      # Creates this router as a distributed router. It will create a group
+      # of actors distributed using consistent hashing.  Suggest a hashring size
+      # of at least 40 up to 160.
+      # @param hashring_size [Integer]
+      # @return self
+      def distributed(hashring_size)
+        @create_hashring = true
+        @hashring_size = hashring_size
+        self
+      end
+
+      # Start the actor(s). If the actor is distributed returns the entire
+      # Array of actor refs in the hash ring, otherwise a single actor ref
+      # @return actor ref
+      def start
+        GameMachine.logger.debug "Game actor #{@name} starting"
+        if @create_hashring
+          hashring = create_hashring(@hashring_size)
+          hashring.buckets.map do |bucket_name|
+            @actor_system.actor_of(@props, bucket_name)
+          end
+        else
+          @actor_system.actor_of(@props, @name)
+        end
+      end
+
+
+      private
+
+      def create_hashring(bucket_count)
+        hashring = Hashring.create_actor_ring(@name,bucket_count)
+        @klass.add_hashring(@name,hashring)
+        hashring
+      end
+
+    end
+  end
+end

data/lib/game_machine/actor/development.rb

@@ -0,0 +1,31 @@
+module GameMachine
+  module Actor
+    module Development
+
+      def self.included(base)
+        Reloadable.register(base.name)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+        def reload_on_change?
+          true
+        end
+      end
+
+      def kill_self(reason)
+        raise "Killing #{self}: #{reason}"
+      end
+
+      def onReceive(message)
+        message = Base.model_filter(message)
+        if message == 'reload_because_changed'
+          kill_self("Actor code change")
+        else
+          on_receive(message)
+        end
+      end
+    end
+  end
+end