game_machine 0.0.11 → 1.0.2

data/lib/game_machine/default_handlers.rb

@@ -0,0 +1,2 @@
+require_relative 'default_handlers/team_handler'
+require_relative 'default_handlers/zone_manager'

data/lib/game_machine/default_handlers/team_handler.rb

@@ -0,0 +1,51 @@
+
+module GameMachine
+  module DefaultHandlers
+    class TeamHandler
+
+      attr_reader :teams
+      def initialize
+        update_teams
+      end
+
+      def update_teams
+        @teams = GameMachine::Models::Teams.find('teams')
+      end
+
+      # Should return a Match object if a match is found, otherwise nil
+      def match!(team_name)
+        GameMachine.logger.info "match! team_name:#{team_name} teams:#{teams}"
+        if team = teams.teams.select {|team| team.name != team_name}.first
+          return GameMachine::Models::StartMatch.new(:team_names => [team_name,team.name])
+        end
+        nil
+      end
+
+      # Called when Game Machine has started the match
+      def match_started(match)
+
+      end
+
+      # Filter you can apply to the teams list sent to clients
+      # You can add whatever extra fields you want to the TeamsRequest
+      # class on the client and they will show up here.
+      def teams_filter(teams,teams_request)
+        teams
+      end
+
+      # return true if member has rights to create team
+      def can_create_team?(team_name,member)
+        true
+      end
+
+      # return true if member has rights to join team
+      def can_add_member?(team_name,member)
+        true
+      end
+
+      def destroy_on_owner_leave?
+        true
+      end
+    end
+  end
+end

data/lib/game_machine/default_handlers/zone_manager.rb

@@ -0,0 +1,30 @@
+# This class is configured in regions.yml, which is a mapping of regions to classes
+# that handle running the region.  In this example we use the same class for both
+# of our regions.  Our example regions only vary in which npc's are spawned.
+module GameMachine
+  module DefaultHandlers
+    class ZoneManager < GameMachine::Actor::Base
+
+      def post_init(*args)
+        @region_up = false
+      end
+
+      def start_zone(zone)
+      end
+
+      def on_receive(message)
+
+        # Region manager pings us every couple of seconds as long as we are alive,
+        # it's up to us to determine if we have started the region or not
+        if message.is_a?(GameMachine::Models::Region)
+          return if @region_up
+          @region_up = true
+
+          zone = message.name
+          GameMachine.logger.info "#{self.class.name} Starting region #{zone}"
+          start_zone(zone)
+        end
+      end
+    end
+  end
+end

data/lib/game_machine/endpoints.rb

@@ -1,6 +1,2 @@
-require_relative 'endpoints/tcp_handler'
-require_relative 'endpoints/udp'
-require_relative 'endpoints/tcp'
-require_relative 'endpoints/mono_gateway'
 require_relative 'endpoints/udp_incoming'
 require_relative 'endpoints/udp_outgoing'

data/lib/game_machine/endpoints/udp_incoming.rb

@@ -12,7 +12,7 @@ module GameMachine
 
       attr_reader :game_handler, :server, :clients
       def post_init(*args)
-        @game_handler = Actor::Base.find(Application.config.game_handler)
+        @game_handler = GameMachine::Handlers::Request.find
         @server = JavaLib::UdpServer.getUdpServer
         @server_handler = @server.getHandler
         @auth_handler = Handlers::Authentication.new
@@ -30,7 +30,14 @@ module GameMachine
 
       def handle_incoming(message)
         client_id = client_id_from_message(message)
-        client_message = MessageLib::ClientMessage.parse_from(message.bytes)
+        if message.protocol == 0
+          client_message = MessageLib::ClientMessage.parse_from(message.bytes)
+        elsif message.protocol == 2
+          client_message = message.clientMessage
+        else
+          raise "Unknown protocol"
+        end
+
         client_connection = create_client_connection(
           client_id,client_message.connection_type
         )
@@ -57,11 +64,12 @@ module GameMachine
               client = {
                 :host => message.host,
                 :port => message.port,
+                :address => message.address,
                 :ctx => message.ctx,
                 :client_connection => client_connection
               }
               self.class.clients[client_message.player.id] = client
-              create_child(client_connection,client,@server,client_message.player.id)
+              create_child(message.protocol,client_connection,client,@server,client_message.player.id)
             end
           end
         end
@@ -73,8 +81,8 @@ module GameMachine
         GameMachine.logger.error "#{self.class.name} #{e.to_s}"
       end
 
-      def create_child(client_connection,client,server,player_id)
-        builder = Actor::Builder.new(Endpoints::UdpOutgoing,client_connection,client,server,player_id)
+      def create_child(protocol,client_connection,client,server,player_id)
+        builder = Actor::Builder.new(Endpoints::UdpOutgoing,client_connection,client,server,player_id,protocol)
         builder.with_name(player_id).start
       end
 

data/lib/game_machine/endpoints/udp_outgoing.rb

@@ -2,12 +2,13 @@ module GameMachine
   module Endpoints
     class UdpOutgoing < Actor::Base
 
-      attr_reader :client_connection, :client, :server, :player_id
+      attr_reader :protocol, :client_connection, :client, :server, :player_id
       def post_init(*args)
         @client_connection = args[0]
         @client = args[1]
         @server = args[2]
         @player_id = args[3]
+        @protocol = args[4]
         send_connected_message
         GameMachine.logger.info "Player gateway created #{player_id}"
       end
@@ -24,14 +25,19 @@ module GameMachine
       end
 
       def send_to_client(message)
-        bytes = message.to_byte_array
-        server.sendToClient(
-          bytes,
-          client[:host],
-          client[:port],
-          client[:ctx]
-        )
-
+        #GameMachine.logger.info("Sending #{message} out via #{protocol}")
+        if protocol == 0
+          bytes = message.to_byte_array
+          server.sendToClient(
+            client[:address],
+            bytes,
+            client[:ctx]
+          )
+        else
+          client[:ctx].write(message)
+          client[:ctx].flush
+          JavaLib::UdpServerHandler.countOut.incrementAndGet
+        end
       end
 
       def on_receive(message)

data/lib/game_machine/game_systems.rb

@@ -2,8 +2,6 @@
 require_relative 'game_systems/chat_manager'
 require_relative 'game_systems/chat'
 require_relative 'game_systems/chat_topic'
-require_relative 'game_systems/entity_loader'
-require_relative 'game_systems/entity_tracking'
 require_relative 'game_systems/local_echo'
 require_relative 'game_systems/remote_echo'
 require_relative 'game_systems/stress_test'

data/lib/game_machine/game_systems/agents/controller.rb

@@ -103,8 +103,8 @@ module GameMachine
         def local_agents
           {}.tap do |agents|
             agent_config.agent_names.each do |name|
-              bucket = Akka.instance.hashring.bucket_for(name)
-              if bucket == address
+              node = Akka.instance.hashring.node_for(name)
+              if node == address
                 agents[name] = agent_config.klass_for_name(name)
               end
             end

data/lib/game_machine/game_systems/entity_tracking.rb

@@ -18,9 +18,6 @@ module GameMachine
       attr_reader :grid, :extra_params, :aoe_grid
 
       def post_init
-        if handler_klass = Application.config.entity_tracking_handler
-         @tracking_handler = handler_klass.constantize.new
-        end
         @entity_updates = []
         @grid = Grid.find_or_create('default')
         @aoe_grid = Grid.find_or_create('aoe')

data/lib/game_machine/game_systems/region_manager.rb

@@ -1,4 +1,3 @@
-require_relative 'region_settings'
 module GameMachine
   module GameSystems
     class RegionManager < Actor::Base
@@ -28,7 +27,9 @@ module GameMachine
       end
 
       def load_from_config
-        RegionSettings.regions.each do |name,manager|
+        Application.config.regions.each do |entry|
+          name = entry[0]
+          manager = entry[1]
           unless region = Region.find!(name)
             region = Region.new(
               :id => name,

data/lib/game_machine/game_systems/region_service.rb

@@ -51,8 +51,8 @@ module GameMachine
       end
 
       def load_from_config
-        RegionSettings.regions.each do |name,manager|
-
+        Application.config.regions.each do |entry|
+          name = entry[0]
           # Make sure we set some value here, it will get updated with a valid
           # region in update_regions
           if region = Region.find!(name)

data/lib/game_machine/game_systems/remote_echo.rb

@@ -4,7 +4,17 @@ module GameMachine
       include GameMachine::Commands
       aspect %w(EchoTest)
 
+      def post_init(*args)
+        chars = [*('a'..'z'),*('0'..'9')].flatten
+        str = Array.new(400) {|i| chars.sample}.join
+        @test_message = MessageLib::Entity.new.set_id(str)
+        #schedule_message('test',10)
+      end
+
       def on_receive(message)
+        if message.is_a?(String) && message == 'test'
+          return
+        end
         #GameMachine.logger.info "#{self.class.name} #{message}"
         commands.player.send_message(message,message.player.id)
       end

data/lib/game_machine/game_systems/team_manager.rb

@@ -6,9 +6,7 @@ module GameMachine
 
       attr_reader :team_handler
       def post_init(*args)
-        if Application.config.team_handler
-          @team_handler = Application.config.team_handler.constantize.new
-        end
+        @team_handler = Application.config.handlers.team.constantize.new
         define_update_procs
         commands.misc.client_manager_register(self.class.name)
       end
@@ -85,37 +83,30 @@ module GameMachine
       end
 
       def can_add_member?(team_name,player_id)
-        return true unless team_handler
         team_handler.can_add_member?(team_name, player_id)
       end
 
       def can_create_team?(team_name,player_id)
-        return true unless team_handler
         team_handler.can_create_team?(team_name, player_id)
       end
 
       def handler_update_teams
-        return true unless team_handler
         team_handler.update_teams
       end
 
       def destroy_on_owner_leave?
-        return true unless team_handler
         team_handler.destroy_on_owner_leave?
       end
 
       def handler_teams_filter(teams,teams_request)
-        return teams unless team_handler
         team_handler.teams_filter(teams,teams_request)
       end
 
       def handler_find_match(team_name)
-        return true unless team_handler
         team_handler.match!(team_name)
       end
 
       def handler_match_started(match)
-        return true unless team_handler
         team_handler.match_started(match)
       end
 
@@ -309,7 +300,7 @@ module GameMachine
           return
         end
 
-        server = Akka.instance.hashring.bucket_for(match_id)
+        server = Akka.instance.hashring.node_for(match_id)
         server = server.sub('akka.tcp://cluster@','').split(':').first
 
         match = Match.new(

data/lib/game_machine/grid.rb

@@ -16,7 +16,8 @@ module GameMachine
       end
 
       def load_from_config
-        Application.config.grids.each do |name,value|
+        ['default','local_chat','aoe'].each do |name|
+           value = Application.config.grids.send(name.to_sym)
           grid_size,cell_size,update_frequency = value.split(',')
           config[name] = {
             :grid_size => grid_size.to_i,
@@ -28,15 +29,7 @@ module GameMachine
       end
 
       def reset_grids
-        @grids = java.util.concurrent.ConcurrentHashMap.new
-      end
-
-      def grids
-        if @grids
-          return @grids
-        else
-          reset_grids
-        end
+        JavaLib::Grid.reset_grids
       end
 
       def default_grid
@@ -44,15 +37,9 @@ module GameMachine
       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 = config.fetch(name)
+        JavaLib::Grid.find_or_create(name,grid_config.fetch(:grid_size),
                                    grid_config.fetch(:cell_size))
-          grids.put(name,grid)
-        end
-
-        grids.fetch(name)
       end
     end
 

data/lib/game_machine/handlers/authentication.rb

@@ -23,23 +23,15 @@ module GameMachine
       end
 
       def authtoken_for_player(player_id)
-        Application.auth_handler.authtoken_for(player_id)
+        Handlers::PlayerAuthentication.instance.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)

data/lib/game_machine/handlers/game.rb

@@ -3,8 +3,9 @@ module GameMachine
     class Game < Actor::Base 
       include Commands
 
-      attr_reader :destinations
+      attr_reader :destinations, :game_message_routes
       def post_init(*args)
+        @game_message_routes = Routes.instance.game_message_routes
         @destinations = {}
       end
 
@@ -27,6 +28,30 @@ module GameMachine
             entity = GameSystems::ObjectDbProxy.save_entity(entity)
           end
 
+          if entity.has_game_messages
+            entity.game_messages.get_game_message_list.each do |game_message|
+              if game_message.has_destination_id
+                destination = game_message.destination_id
+              elsif game_message.has_destination
+                destination = game_message.destination
+              else
+                GameMachine.logger.warn "Unable to find destination for game message, skipping"
+                next 
+              end
+
+              if route = game_message_routes.fetch(destination)
+                game_message.set_player_id(entity.player.id)
+                if route[:distributed]
+                  Actor::Base.find_distributed(entity.player.id,route[:to]).tell(game_message)
+                else
+                  Actor::Base.find(route[:to]).tell(game_message)
+                end
+              else
+                GameMachine.logger.warn "No route for destination #{destination}"
+              end
+            end
+          end
+
           if entity.has_destination
             unless actor_ref = destinations.fetch(entity.destination,nil)
               destination = entity.destination.gsub('/','::')
@@ -39,7 +64,7 @@ module GameMachine
             next
           end
 
-          # TODO: Optimize this
+          # DEPRECATED - convert to named routes as we do for game messages
           component_names = entity.component_names
           GameMachine.logger.debug("Dispatch: #{entity} #{component_names.to_a.inspect}")
           next if component_names.empty?

data/lib/game_machine/handlers/player_authentication.rb

@@ -0,0 +1,87 @@
+
+# This class is set in the configuration.
+
+# This is a simple implementation that works together with the built in
+# user registration and login via http. User data is stored in the object database.
+
+# The minimum necessary to implement is the authtoken_for method.  That method can
+# block as it is only called once when the client first connects and is cached
+# internally after that. So you could make an external http call for example.
+require 'digest/md5'
+module GameMachine
+  module Handlers
+    class PlayerAuthentication
+      include Singleton
+      include Models
+
+      attr_reader :authclass
+      def initialize
+        @sessions = {}
+        java_import "#{AppConfig.instance.config.handlers.auth}"
+        @authclass = AppConfig.instance.config.handlers.auth.split('.').last.constantize
+      end
+
+      def public?
+        AppConfig.instance.config.handlers.auth == "com.game_machine.authentication.PublicAuthenticator"
+      end
+
+      def get_player(username)
+        if public?
+          MessageLib::Player.new.set_id(username)
+        else
+          MessageLib::Player.store_get('players',username,2000)
+        end
+      end
+
+      # Returns true if authorized, false if not
+      def authorize(username,password)
+        GameMachine.logger.info "authorize: #{username}"
+        if player = get_player(username)
+          authenticator = authclass.new(player)
+          if authenticator.authenticate(password)
+            @sessions[username] = authtoken(username,password)
+            player.set_authtoken(@sessions[username])
+            player.store_set('players')
+            return @sessions[username]
+          else
+            GameMachine.logger.info "player: #{player.id} password does not match"
+            false
+          end
+        else
+          GameMachine.logger.info "player: #{username} not found"
+          false
+        end
+        false
+      end
+
+      # Returns a session token for a logged in user.  This must be a string and
+      # should not be too long, as it gets sent with every message.
+      def authtoken_for(username)
+        if authtoken = @sessions.fetch(username,nil)
+          return authtoken
+
+        # user authenticated on different server, we have to look up their authtoken
+        # and save it in the local sessions hash
+        elsif player = get_player(username)
+          if authtoken = player.authtoken
+            @sessions[username] = authtoken
+            return authtoken
+          else
+            GameMachine.logger.info "Authoken for #{username} is nil"
+            nil
+          end
+        else
+          GameMachine.logger.info "User #{username} not found"
+          nil
+        end
+      end
+
+      private
+
+      def authtoken(username,password)
+        Digest::MD5.hexdigest("#{username}#{password}#{rand(10000)}")
+      end
+    end
+  end
+end
+