game_machine 0.0.8

data/lib/game_machine/game_systems/local_echo.rb

@@ -0,0 +1,16 @@
+module GameMachine
+  module GameSystems
+    class LocalEcho < Actor::Base
+      
+      # Used in tests to see if actor got the message
+      def self.echo(message)
+      end
+
+      def on_receive(message)
+        GameMachine.logger.debug("LocalEcho got #{message}")
+        self.class.echo(message)
+        sender.tell(message,self)
+      end
+    end
+  end
+end

data/lib/game_machine/game_systems/objectdb_proxy.rb

@@ -0,0 +1,61 @@
+module GameMachine
+  module GameSystems
+    class ObjectDbProxy < Actor::Base
+      include GameMachine::Commands
+
+      aspect %w(ObjectdbGet Player)
+
+      # Generic way for a client to save state.  We scope the id to the
+      # player to prevent hacked clients from writing stuff they shouldn't.
+
+
+      def self.save_entity(entity)
+        scoped_id = scope_entity_id(entity.id,entity.player.id)
+        entity.set_id(scoped_id)
+        entity.set_save(false)
+        ref = ObjectDb.find_distributed(entity.get_id)
+        ref.tell(MessageLib::ObjectdbPut.new.set_entity(entity))
+        entity
+      end
+
+      def self.scope_entity_id(entity_id,player_id)
+        "#{player_id}_#{entity_id}"
+      end
+
+      def self.unscope_entity_id(entity_id,player_id)
+        unscoped_id = entity_id.sub("#{player_id}_",'')
+      end
+
+      def on_receive(message)
+        if message.is_a?(MessageLib::Entity)
+          if message.has_objectdb_get
+            objectdb_get = message.get_objectdb_get
+            entity_id = objectdb_get.get_entity_id
+            player_id = objectdb_get.get_player_id
+
+            response = MessageLib::ObjectdbGetResponse.new
+
+            # Make request with scoped id
+            scoped_id = self.class.scope_entity_id(entity_id,player_id)
+            if entity = commands.datastore.get(scoped_id)
+
+              # Unscope the entity id
+              unscoped_id = self.class.unscope_entity_id(entity.id,player_id)
+              entity.set_id(unscoped_id)
+
+              response.set_entity_found(true)
+            else
+              entity = MessageLib::Entity.new.set_id(entity_id)
+              response.set_entity_found(false)
+            end
+
+
+            entity.set_objectdb_get_response(response)
+            commands.player.send_message(entity,player_id)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/game_machine/game_systems/private_chat.rb

@@ -0,0 +1,20 @@
+module GameMachine
+  module GameSystems
+    class PrivateChat < Actor::Base
+
+      def preStart
+        message = Subscribe.new.set_topic('private')
+        MessageQueuel.find.tell(message,Actor::Ref.new(get_self))
+      end
+
+      def on_receive(message)
+        if message.is_a?(ChatMessage)
+          send_message(message)
+        elsif message.is_a?(JavaLib::DistributedPubSubMediator::SubscribeAck)
+        else
+          unhandled(message)
+        end
+      end
+    end
+  end
+end

data/lib/game_machine/game_systems/region_manager.rb

@@ -0,0 +1,91 @@
+require_relative 'region_settings'
+module GameMachine
+  module GameSystems
+    class RegionManager < Actor::Base
+      include GameMachine::Commands
+      include GameMachine::Models
+
+      attr_reader :regions, :servers
+      def post_init(*args)
+        @regions = {}
+        @servers = {}
+        load_from_config
+        schedule_message('check_regions',2,:seconds)
+      end
+
+      def check_regions
+        unassign_down_servers
+        assign_servers
+        notify_managers
+      end
+
+      def notify_managers
+        regions.each do |name,region|
+          if region.manager && region.server
+            region.manager.constantize.find_by_address(region.server).tell(region)
+          end
+        end
+      end
+
+      def load_from_config
+        RegionSettings.regions.each do |name,manager|
+          unless region = Region.find!(name)
+            region = Region.new(
+              :id => name,
+              :name => name,
+              :manager => manager
+            )
+            region.save!
+          end
+          regions[name] = region
+          if region.server
+            servers[region.server] = name
+          end
+        end
+      end
+
+      def unassign_down_servers
+        regions.each do |name,region|
+          if region.server
+            unless ClusterMonitor.cluster_members.has_key?(region.server)
+              GameMachine.logger.warn "Node #{region.server} no longer in cluster, region #{region.name} dissasociated"
+              servers.delete(region.server)
+              region.server = nil
+              region.save!
+            end
+          end
+        end
+      end
+
+      def assign_servers
+        regions.each do |name,region|
+          if region.server.nil?
+            ClusterMonitor.cluster_members.keys.each do |address|
+              unless servers.has_key?(address)
+                region.server = address
+                servers[address] = name
+                region.save!
+                GameMachine.logger.warn "Region #{region.name} assigned to #{region.server}"
+                break
+              end
+            end
+          end
+        end
+      end
+
+      def on_receive(message)
+        if message.is_a?(String)
+          if message == 'check_regions'
+            check_regions
+          else
+            regions_msg = MessageLib::Regions.new.set_regions(regions_string)
+            entity = MessageLib::Entity.new.set_id(message.player.id).set_regions(regions_msg)
+            commands.player.send_message(entity,message.player.id)
+            #GameMachine.logger.info "#{self.class.name} sent regions to #{message.player.id}"
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/game_machine/game_systems/region_service.rb

@@ -0,0 +1,94 @@
+module GameMachine
+  module GameSystems
+    class RegionService < Actor::Base
+      include GameMachine::Commands
+      include GameMachine::Models
+
+      attr_reader :regions
+
+
+      def self.regions
+        if @regions
+          @regions
+        else
+          @regions = java.util.concurrent.ConcurrentHashMap.new
+        end
+      end
+
+      def self.address
+        @address
+      end
+
+      def self.address=(address)
+        @address = address
+      end
+
+      def self.region
+        @region
+      end
+
+      def self.region=(region)
+        @region = region
+      end
+
+      def post_init(*args)
+        cluster = JavaLib::Cluster.get(getContext.system)
+        self.class.address = cluster.self_address.to_string
+        load_from_config
+        update_regions
+        schedule_message('update_regions',10,:seconds)
+      end
+
+      def update_regions
+        self.class.regions.keys.each do |name|
+          if region = Region.find!(name)
+            self.class.regions[name] = region
+            if region.server == self.class.address
+              self.class.region = name
+            end
+          end
+        end
+      end
+
+      def load_from_config
+        RegionSettings.regions.each do |name,manager|
+
+          # Make sure we set some value here, it will get updated with a valid
+          # region in update_regions
+          if region = Region.find!(name)
+            self.class.regions[name] = region
+          else
+            self.class.regions[name] = false
+          end
+        end
+      end
+
+      def server_hostname(server)
+        server.sub('akka.tcp://cluster@','').split(':').first
+      end
+
+      def regions_string
+        self.class.regions.select{|name,region| region && !region.server.nil?}.map do |name,region|
+          "#{region.name}=#{server_hostname(region.server)}"
+        end.join('|')
+      end
+
+      def on_receive(message)
+        if message.is_a?(String)
+          if message == 'update_regions'
+            update_regions
+          end
+        elsif message.is_a?(MessageLib::Entity)
+          # TODO fix this, leaving for now until we figure out how complex this needs
+          # to be
+          if message.id == 'regions'
+            regions_msg = MessageLib::Regions.new.set_regions(regions_string)
+            entity = MessageLib::Entity.new.set_id(message.player.id).set_regions(regions_msg)
+            commands.player.send_message(entity,message.player.id)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/game_machine/game_systems/region_settings.rb

@@ -0,0 +1,13 @@
+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/game_systems/remote_echo.rb

@@ -0,0 +1,14 @@
+module GameMachine
+  module GameSystems
+    class RemoteEcho < Actor::Base
+      include GameMachine::Commands
+      aspect %w(EchoTest)
+
+      def on_receive(message)
+        #GameMachine.logger.info "#{self.class.name} #{message}"
+        commands.player.send_message(message,message.player.id)
+      end
+    end
+  end
+end
+

data/lib/game_machine/game_systems/stress_test.rb

@@ -0,0 +1,21 @@
+module GameMachine
+  module GameSystems
+    class StressTest < Actor::Base
+      include GameMachine::Commands
+
+      attr_reader :grid
+      def post_init(*args)
+        @grid = Grid.default_grid
+      end
+
+      def on_receive(message)
+        #GameMachine.logger.info "#{self.class.name} #{message}"
+        commands.player.send_message(message,message.player.id)
+
+        grid.set(message.player.id,2.0,1.0,'all')
+        grid.neighbors(1.0,4.0,'all')
+      end
+    end
+  end
+end
+

data/lib/game_machine/grid.rb

@@ -0,0 +1,60 @@
+module GameMachine
+  class Grid
+
+    class << self
+
+      def config
+        if @config
+          return @config
+        else
+          @config = java.util.concurrent.ConcurrentHashMap.new
+        end
+      end
+
+      def update_frequency_for(name)
+        config.fetch(name)[:update_frequency]
+      end
+
+      def load_from_config
+        Application.config.grids.each do |name,value|
+          grid_size,cell_size,update_frequency = value.split(',')
+          config[name] = {
+            :grid_size => grid_size.to_i,
+            :cell_size => cell_size.to_i,
+            :update_frequency => update_frequency.to_i
+          }
+          find_or_create(name)
+        end
+      end
+
+      def reset_grids
+        @grids = java.util.concurrent.ConcurrentHashMap.new
+      end
+
+      def grids
+        if @grids
+          return @grids
+        else
+          reset_grids
+        end
+      end
+
+      def default_grid
+        find_or_create('default')
+      end
+
+      def find_or_create(name)
+        unless grids.containsKey(name)
+          GameMachine.logger.info "CREATING GRID #{name}"
+          grid_config = config.fetch(name)
+          grid = JavaLib::Grid.new(grid_config.fetch(:grid_size),
+                                   grid_config.fetch(:cell_size))
+          grids.put(name,grid)
+        end
+
+        grids.fetch(name)
+      end
+    end
+
+  end
+end

data/lib/game_machine/grid_replicator.rb

@@ -0,0 +1,31 @@
+module GameMachine
+  class GridReplicator < Actor::Base
+
+    def post_init(*args)
+      @paths = {}
+      #schedule_update(80)
+    end
+
+    def on_receive(message)
+      if message.is_a?(String)
+        delta = Grid.default_grid.current_delta
+        return if delta.length == 0
+        GameMachine::ClusterMonitor.remote_members.keys.each do |address|
+          @paths[address] ||= "#{address}#{self.class.local_path(self.class.name)}"
+          Actor::Ref.new(@paths[address],self.class.name).tell(delta)
+        end
+      else
+        Grid.default_grid.update_from_delta(message)
+      end
+      
+    end
+
+    def schedule_update(update_interval)
+      duration = GameMachine::JavaLib::Duration.create(update_interval, java.util.concurrent.TimeUnit::MILLISECONDS)
+      scheduler = get_context.system.scheduler
+      dispatcher = get_context.system.dispatcher
+      scheduler.schedule(duration, duration, get_self, "replicate_grid", dispatcher, nil)
+    end
+
+  end
+end

data/lib/game_machine/handlers/authentication.rb

@@ -0,0 +1,55 @@
+
+module GameMachine
+  module Handlers
+    class Authentication
+      AUTHTOKEN = 'authorized'
+      AUTHENTICATED_USERS = java.util.concurrent.ConcurrentHashMap.new
+
+      def self.authenticated?(player)
+        if authtoken = AUTHENTICATED_USERS.fetch(player.id,nil)
+          return player.authtoken == authtoken
+        end
+        false
+      end
+
+      def self.unregister_player(player_id)
+        AUTHENTICATED_USERS.delete(player_id)
+      end
+
+      def register_player(player_id)
+        AUTHENTICATED_USERS[player_id] =
+          authtoken_for_player(player_id)
+
+      end
+
+      def authtoken_for_player(player_id)
+        Application.auth_handler.authtoken_for(player_id)
+      end
+
+      def valid_authtoken?(player)
+        return true if public?
+        player.authtoken == authtoken_for_player(player.id)
+      end
+
+      def public?
+        Application.config.auth_handler == 'GameMachine::AuthHandlers::Public'
+      end
+
+      def authenticate!(player)
+        if public?
+          AUTHENTICATED_USERS[player.id] = player.authtoken
+          return true
+        end
+        @player = player
+        if valid_authtoken?(player)
+          register_player(player.id)
+          player.set_authenticated(true)
+        else
+          false
+        end
+      end
+
+    end
+
+  end
+end