game_machine 0.0.8

data/lib/game_machine/game_systems/chat.rb

@@ -0,0 +1,256 @@
+module GameMachine
+  module GameSystems
+    class Chat < Actor::Base
+      include GameMachine::Commands
+
+      def self.subscribers_for_topic(topic)
+        datastore = GameMachine::Commands::DatastoreCommands.new
+        if entity = datastore.get("chat_topic_#{topic}")
+          entity.subscribers || MessageLib::Subscribers.new
+        else
+          MessageLib::Subscribers.new
+        end
+      end
+
+      attr_reader :chat_id, :registered_as
+      def post_init(*args)
+        @chat_id = args.first
+        @registered_as = args.last
+        @topic_handlers = {}
+
+        # Update these values from the datastore, as this state needs to
+        # persist between restarts
+        @subscriptions = get_subscriptions
+        @channel_flags = get_flags
+
+        # Make sure we re-create our state from the persisted state if we died
+        load_state
+      end
+
+      def load_state
+        @subscriptions.each do |name|
+          flags = flags_for_channel(name).join('|')
+          join_channel(name,flags)
+        end
+      end
+
+      def on_receive(entity)
+        if entity.has_join_chat
+          join_channels(entity.join_chat.get_chat_channel_list)
+          send_status
+        end
+
+        if entity.has_chat_message
+          send_message(entity.chat_message)
+        end
+
+        if entity.has_leave_chat
+          leave_channels(entity.leave_chat.get_chat_channel_list)
+          send_status
+        end
+
+        if entity.has_chat_status
+          send_status
+        end
+      end
+
+      # flags = subscribers
+      def send_status
+        channels = MessageLib::ChatChannels.new
+        @subscriptions.each do |name|
+          flags = @channel_flags.fetch(name,[])
+          channel = MessageLib::ChatChannel.new.set_name(name)
+          if flags.include?('subscribers')
+            channel.set_subscribers(self.class.subscribers_for_topic(name))
+          end
+          channels.add_chat_channel(channel)
+        end
+        if registered_as == 'player'
+          commands.player.send_message(channels,chat_id)
+        else
+          message = MessageLib::Entity.new.set_id(chat_id).set_chat_channels(channels)
+          Actor::Base.find(registered_as).tell(message,get_self)
+        end
+      end
+
+      def message_queue
+        MessageQueue.find
+      end
+
+      def topic_handler_for(name)
+        @topic_handlers.fetch(name,nil)
+      end
+
+      def create_topic_handler(topic)
+        name = "topic#{chat_id}#{topic}"
+        builder = Actor::Builder.new(GameSystems::ChatTopic,chat_id,registered_as)
+        ref = builder.with_parent(context).with_name(name).start
+        actor_ref = Actor::Ref.new(ref,GameSystems::ChatTopic.name)
+        @topic_handlers[topic] = actor_ref
+      end
+
+      def remove_subscriber(subscriber_id,topic)
+        stored_entity_id = "chat_topic_#{topic}"
+        entity = MessageLib::Entity.new.set_id(subscriber_id)
+        commands.datastore.call_dbproc(:chat_remove_subscriber,stored_entity_id,entity,false)
+      end
+
+      def add_subscriber(subscriber_id,topic)
+        stored_entity_id = "chat_topic_#{topic}"
+        entity = MessageLib::Entity.new.set_id(subscriber_id)
+        commands.datastore.call_dbproc(:chat_add_subscriber,stored_entity_id,entity,false)
+      end
+
+      def save_subscriptions
+        entity_id = "subscriptions_#{chat_id}"
+        channels = MessageLib::ChatChannels.new
+        @subscriptions.each do |name|
+          channel = MessageLib::ChatChannel.new.set_name(name)
+          channels.add_chat_channel(channel)
+        end
+        entity = MessageLib::Entity.new.set_id(entity_id).set_chat_channels(channels)
+        commands.datastore.put(entity)
+      end
+
+      def get_subscriptions
+        subscriptions = Set.new
+        entity_id = "subscriptions_#{chat_id}"
+        if entity = commands.datastore.get(entity_id)
+          if chat_channels = entity.chat_channels.get_chat_channel_list
+            chat_channels.each do |channel|
+              subscriptions.add(channel.name)
+            end
+          end
+        end
+        subscriptions
+      end
+
+      def parse_channel_flags(flags)
+        flags.split('|')
+      end
+
+      def channel_flags_id(name)
+        "channel_flags#{@chat_id}#{name}"
+      end
+
+      def flags_for_channel(channel_name)
+        @channel_flags.fetch(channel_name,[])
+      end
+
+      def get_flags
+        {}.tap do |flags|
+          @subscriptions.each do |name|
+            if entity = commands.datastore.get(channel_flags_id(name))
+              flags[name] = parse_channel_flags(entity.params)
+            end
+          end
+        end
+      end
+
+      def set_channel_flags(name,flags)
+        return if flags.nil?
+        @channel_flags[name] = parse_channel_flags(flags)
+        flags_id = channel_flags_id(name)
+        entity = MessageLib::Entity.new.set_id(flags_id).set_params(flags)
+        commands.datastore.put(entity)
+      end
+
+      def delete_channel_flags(channel_name)
+        flags_id = channel_flags_id(channel_name)
+        commands.datastore.delete(flags_id)
+      end
+
+      def invite_exists?(channel_name,invite_id)
+        key = "invite_#{channel_name}_#{invite_id}"
+        commands.datastore.get(key)
+      end
+
+      def join_channels(chat_channels)
+        chat_channels.each do |channel|
+          if @topic_handlers[channel.name]
+            GameMachine.logger.info "Topic handler exists for #{channel.name}, not creating"
+            next
+          end
+
+          GameMachine.logger.info "Join request #{channel.name}"
+          # Private channels.  format priv_[chat_id]_[channel name]
+          # Players can create private channels with their player id, other
+          # players must have an invite to join someone elses private channel
+          if channel.name.match(/^priv/)
+            if channel.name.match(/^priv_#{chat_id}/)
+              join_channel(channel.name,channel.flags)
+            elsif channel.invite_id
+              if invite_exists?(channel.name,channel.invite_id)
+                join_channel(channel.name,channel.flags)
+              else
+                GameMachine.logger.info "Invite id #{channel.invite_id} not found"
+              end
+            end
+          else
+            join_channel(channel.name,channel.flags)
+          end
+        end
+      end
+
+      def join_channel(name,flags)
+        create_topic_handler(name)
+        message = MessageLib::Subscribe.new.set_topic(name)
+        message_queue.tell(message,topic_handler_for(name).actor)
+        @subscriptions.add(name)
+        save_subscriptions
+        add_subscriber(chat_id,name)
+        set_channel_flags(name,flags)
+        GameMachine.logger.info "Player #{chat_id} Joined channel #{name} with flags #{flags}"
+      end
+
+      def leave_channels(chat_channels)
+        chat_channels.each do |channel|
+          if topic_handler = topic_handler_for(channel.name)
+            message = MessageLib::Unsubscribe.new.set_topic(channel.name)
+            message_queue.tell(message,topic_handler_for(channel.name).actor)
+            @subscriptions.delete_if {|sub| sub == channel.name}
+            save_subscriptions
+            remove_subscriber(chat_id,channel.name)
+            topic_handler.tell(JavaLib::PoisonPill.get_instance)
+            @topic_handlers.delete(channel.name)
+            delete_channel_flags(channel.name)
+          else
+            GameMachine.logger.info "leave_channel: no topic handler found for #{channel.name}"
+          end
+        end
+      end
+
+      def send_private_message(chat_message)
+        GameMachine.logger.info "Sending private chat message #{chat_message.message} to #{chat_message.chat_channel.name}"
+        entity = MessageLib::Entity.new
+        player = MessageLib::Player.new.set_id(chat_message.chat_channel.name)
+        entity.set_id(player.id)
+        entity.set_player(player)
+        entity.set_chat_message(chat_message)
+        entity.set_send_to_player(true)
+        commands.player.send_message(entity)
+      end
+
+      def send_group_message(chat_message)
+        topic = chat_message.chat_channel.name
+        if topic_handler = topic_handler_for(topic)
+          entity = MessageLib::Entity.new.set_id('0').set_chat_message(chat_message)
+          publish = MessageLib::Publish.new
+          publish.set_topic(topic).set_message(entity)
+          message_queue.tell(publish,topic_handler_for(topic).actor)
+        else
+          GameMachine.logger.info "send_message: no topic handler found for #{topic}"
+        end
+      end
+
+      def send_message(chat_message)
+        if chat_message.type == 'group'
+          send_group_message(chat_message)
+        elsif chat_message.type == 'private'
+          send_private_message(chat_message)
+        end
+      end
+
+    end
+  end
+end

data/lib/game_machine/game_systems/chat_manager.rb

@@ -0,0 +1,108 @@
+module GameMachine
+  module GameSystems
+
+    # @note All chat system requests go through the ChatManager
+    #   Chat can be topic based or private player to player messages
+    #   Topics are automatically created by the first player to send a join
+    #   request to a topic that does not already exist.  
+    #   Chat topic channels are distributed across the cluster, and guaranteed
+    #   to be delivered.
+    #
+    # @aspects ChatMessage Player
+    # @aspects JoinChat Player
+    # @aspects LeaveChat Player
+    class ChatManager < Actor::Base
+      include GameMachine::Commands
+
+
+      aspect %w(ChatMessage Player)
+      aspect %w(JoinChat Player)
+      aspect %w(LeaveChat Player)
+      aspect %w(ChatStatus Player)
+      aspect %w(ChatInvite Player)
+
+      def define_update_procs
+        commands.datastore.define_dbproc(:chat_remove_subscriber) do |current_entity,update_entity|
+          if current_entity.has_subscribers
+            if subscriber_id_list = current_entity.subscribers.get_subscriber_id_list.to_a
+              current_entity.subscribers.set_subscriber_id_list(nil)
+              subscriber_id_list.each do |name|
+                unless name == update_entity.id
+                  current_entity.subscribers.add_subscriber_id(name)
+                end
+              end
+            end
+          end
+          current_entity
+        end
+
+        commands.datastore.define_dbproc(:chat_add_subscriber) do |current_entity,update_entity|
+          unless current_entity.has_subscribers
+            current_entity.set_subscribers(MessageLib::Subscribers.new)
+          end
+          current_entity.subscribers.add_subscriber_id(update_entity.id)
+          current_entity
+        end
+      end
+
+      def post_init(*args)
+        @chat_actors = {}
+        define_update_procs
+      end
+
+      def on_receive(message)
+        if message.has_chat_invite
+          send_invite(message.chat_invite)
+        elsif message.has_chat_register
+          unless @chat_actors.has_key?(message.chat_register.chat_id)
+            create_child(message.chat_register.chat_id,message.chat_register.register_as)
+          end
+        else
+          unless @chat_actors.has_key?(message.player.id)
+            create_child(message.player.id)
+          end
+          forward_chat_request(message.player.id,message)
+        end
+      end
+
+      private
+
+      # TODO implement expiring cache store for stuff like this (invites)
+      # We cannot just delete the invite when everyone leaves the channel,
+      # because we have no way of knowing when everyone has left
+      def send_invite(chat_invite)
+        invite_id = Uniqueid.generate_token(chat_invite.inviter)
+        stored_id = "invite_#{chat_invite.channel_name}_#{invite_id}"
+        commands.datastore.put(MessageLib::Entity.new.set_id(stored_id))
+        chat_invite.set_invite_id(invite_id)
+        commands.player.send_message(chat_invite,chat_invite.invitee)
+      end
+
+      def destroy_child(chat_id)
+        if @chat_actors.has_key?(chat_id)
+          forward_chat_request(chat_id,JavaLib::PoisonPill.get_instance)
+          @chat_actors.delete(chat_id)
+          GameMachine.logger.debug "Chat child for #{chat_id} killed"
+        else
+          GameMachine.logger.info "chat actor for chat_id #{chat_id} not found"
+        end
+      end
+
+      def forward_chat_request(chat_id,message)
+        @chat_actors[chat_id].tell(message,nil)
+      end
+
+      def child_name(chat_id)
+        "chat#{chat_id}"
+      end
+
+      def create_child(chat_id,register_as='player')
+        name = child_name(chat_id)
+        builder = Actor::Builder.new(GameSystems::Chat,chat_id,register_as)
+        child = builder.with_parent(context).with_name(name).start
+        @chat_actors[chat_id] = Actor::Ref.new(child,GameSystems::Chat.name)
+        GameMachine.logger.debug "Chat child for #{chat_id} created"
+      end
+    end
+  end
+end

data/lib/game_machine/game_systems/chat_topic.rb

@@ -0,0 +1,36 @@
+module GameMachine
+  module GameSystems
+    class ChatTopic < Actor::Base
+      include Commands
+
+      attr_reader :chat_id, :registered_as
+      def post_init(*args)
+        @chat_id = args.first
+        @registered_as = args.last
+      end
+
+      def on_receive(message)
+        if message.is_a?(MessageLib::Entity) && message.has_chat_message
+          receive_chat_message(message.chat_message)
+        elsif message.is_a?(JavaLib::DistributedPubSubMediator::SubscribeAck)
+        else
+          unhandled(message)
+        end
+      end
+
+      private
+
+      def receive_chat_message(chat_message)
+        GameMachine.logger.debug "Sending chat message #{chat_message.message} to #{chat_id}"
+        if registered_as == 'player'
+          commands.player.send_message(chat_message,chat_id)
+        else
+          message = MessageLib::Entity.new.set_id(chat_id).set_chat_message(chat_message)
+          Actor::Base.find(registered_as).tell(message,get_self)
+        end
+      end
+
+    end
+  end
+end
+

data/lib/game_machine/game_systems/devnull.rb

@@ -0,0 +1,13 @@
+module GameMachine
+  module GameSystems
+    class Devnull < Actor::Base
+      
+      def post_init(*args)
+      end
+
+      def on_receive(message)
+        GameMachine.logger.debug("Devnull got #{message}")
+      end
+    end
+  end
+end

data/lib/game_machine/game_systems/entity_loader.rb

@@ -0,0 +1,12 @@
+module GameMachine
+  module GameSystems
+    class EntityLoader < Actor::Base
+
+      def on_receive(entity_list)
+        entity_list.entity.each do |entity|
+          ObjectDb.put(entity.id,entity)
+        end
+      end
+    end
+  end
+end

data/lib/game_machine/game_systems/entity_tracking.rb

@@ -0,0 +1,133 @@
+module GameMachine
+  module GameSystems
+    # @note Handles player location tracking and neighbor requests.
+    #   The client must explicitly send a TrackEntit component to the server
+    #   to be tracked, it doesn't happen automatically.
+    #
+    # @aspects TrackEntity
+    # @aspects GetNeighbors
+    class EntityTracking < Actor::Base
+      include GameMachine::Commands
+
+      aspect %w(TrackEntity)
+      aspect %w(GetNeighbors)
+
+
+
+      EXTRA = java.util.concurrent.ConcurrentHashMap.new
+      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')
+        @paths = {}
+        @width = grid.get_width
+        @cell_count = grid.get_cell_count
+        commands.misc.client_manager_register(self.class.name)
+      end
+
+      def on_receive(message)
+        if message.is_a?(MessageLib::Entity)
+          if message.get_neighbors
+            send_neighbors(message)
+          end
+
+          # If a tracking handler is defined, it must return true to have
+          # the player location saved
+          if message.track_entity
+            #GameMachine.logger.info "#{message.player.id} tracked"
+            if @tracking_handler && message.entity_type == 'player'
+              if @tracking_handler.verify(message)
+                set_entity_location(message)
+              end
+            else
+              set_entity_location(message)
+            end
+          end
+        elsif message.is_a?(MessageLib::ClientManagerEvent)
+          if message.event == 'disconnected'
+            @grid.remove(message.player_id)
+            @aoe_grid.remove(message.player_id)
+            EXTRA.delete(message.player_id)
+            GameMachine.logger.info "#{message.player_id} removed from grid"
+          end
+        else
+          unhandled(message)
+        end
+      end
+
+      private
+
+      def set_entity_location(entity)
+        vector = entity.vector3
+        @grid.set(entity.id,vector.x,vector.y,vector.z,entity.entity_type)
+        @aoe_grid.set(entity.id,vector.x,vector.y,vector.z,entity.entity_type)
+        if entity.track_entity.has_track_extra
+          track_extra = entity.track_entity.track_extra
+          EXTRA[entity.id] = track_extra
+        end
+      end
+
+      def location_entity(grid_value)
+        entity = MessageLib::Entity.new.set_id(grid_value.id)
+
+        entity.set_vector3(
+          MessageLib::Vector3.new.
+          set_x(grid_value.x).
+          set_y(grid_value.y).
+          set_z(grid_value.z)
+        )
+
+        if EXTRA.has_key?(grid_value.id)
+          track_extra = EXTRA.fetch(grid_value.id)
+          entity.set_track_extra(track_extra)
+        end
+        entity
+      end
+
+      def send_neighbors(message)
+        type = message.get_neighbors.neighbor_type
+        x = message.get_neighbors.vector3.x
+        y = message.get_neighbors.vector3.y
+
+        # Either .net or java protobufs have a bug with 0 floats
+        if x.nil?
+          x = 0
+        end
+        if y.nil?
+          y = 0
+        end
+        search_results = grid.neighbors(x,y,type)
+       
+        neighbors = search_results.map do |grid_value|
+          location_entity(grid_value)
+        end
+ 
+        if neighbors.empty?
+          return
+        end
+
+        if message.has_player
+          send_neighbors_to_player(neighbors,message.player)
+        end
+      end
+
+      def send_neighbors_to_player(neighbors,player)
+        neighbors.each_slice(30) do |group|
+          entity = MessageLib::Entity.new.set_neighbors(
+            MessageLib::Neighbors.new.set_entity_list(group)
+          )
+          entity.set_id(player.id)
+          entity.set_player(player)
+          entity.set_send_to_player(true)
+          commands.player.send_message(entity,player.id)
+        end
+      end
+
+    end
+  end
+end