game_machine 0.0.8

data/spec/game_systems/agents/test_agent.rb

@@ -0,0 +1,10 @@
+class TestAgent < GameMachine::Actor::Base
+
+  def post_init(*args)
+  end
+
+  def on_receive(message)
+
+  end
+end
+

data/spec/game_systems/agents/test_agent_config.rb

@@ -0,0 +1,29 @@
+class TestAgentConfig
+
+  def reload?
+    true
+  end
+
+  def agent_names
+    data.keys
+  end
+
+  def klass_for_name(name)
+    data.fetch(name,nil)
+  end
+
+  def load!
+  end
+
+  def data
+    {
+      :agent1 => 'TestAgent',
+      :agent2 => 'TestAgent',
+      :agent3 => 'TestAgent',
+      :agent4 => 'TestAgent',
+      :agent5 => 'TestAgent'
+    }
+  end
+
+
+end

data/spec/game_systems/chat_manager_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+module GameMachine
+  module GameSystems
+    
+    describe ChatManager do
+
+      let(:player_id) {'player1'}
+      let(:topic) {'test_topic'}
+      let(:chat_text) {'test text'}
+      let(:client_id) {'player1_id'}
+      let(:gateway) {'blah'}
+
+      let(:game_message) do
+        Helpers::GameMessage.new(player_id)
+      end
+
+      let(:join_request) do
+        game_message.join_chat(topic)
+        game_message.to_entity
+      end
+
+      let(:chat_message) do
+        game_message.chat_message('group',chat_text,topic)
+        game_message.to_entity
+      end
+
+      let(:actor_builder) {mock('Actor::Builder', :with_parent => actor_builder, :start => true)}
+
+      let(:chat_invite) do
+        chat = Commands::ChatCommands.new
+        chat.invite_message('inviter','invitee','test')
+      end
+
+      subject do
+        ref = Actor::Builder.new(GameSystems::ChatManager).with_name('chat_manager').test_ref
+        ref.underlying_actor
+      end
+
+      describe "chat invites" do
+        it "chat manager calls send_invite when it receives a chat invite" do
+          expect(subject).to receive(:send_invite).with(chat_invite.chat_invite)
+          subject.on_receive(chat_invite)
+        end
+
+      end
+
+      describe "multiple players" do
+
+      end
+
+      describe "managing chat messages" do
+
+        it "creates chat actor for player if it does not exist" do
+          expect(subject).to receive(:forward_chat_request)
+          subject.on_receive(chat_message)
+        end
+
+      end
+
+    end
+
+  end
+end
+
+

data/spec/game_systems/chat_spec.rb

@@ -0,0 +1,187 @@
+require 'spec_helper'
+
+module GameMachine
+  module GameSystems
+    describe Chat do
+
+      let(:player_id) {'player1'}
+      let(:topic) {'test_topic'}
+      let(:chat_text) {'test text'}
+      let(:client_id) {'player1_id'}
+      let(:gateway) {'blah'}
+
+      let(:commands) do
+        Commands::Base.new
+      end
+
+      let(:game_message) do
+        Helpers::GameMessage.new(player_id)
+      end
+
+      let(:leave_request) do
+        game_message.leave_chat(topic)
+        game_message.to_entity
+      end
+
+      let(:join_request_with_flags) do
+        flags = 'subscribers|blah'
+        game_message.join_chat(topic,flags)
+        game_message.to_entity
+      end
+
+      let(:join_request) do
+        game_message.join_chat(topic)
+        game_message.to_entity
+      end
+
+      let(:public_chat_request) do
+        game_message.chat_message('group',chat_text,topic)
+        game_message.to_entity
+      end
+
+      let(:private_chat_request) do
+        game_message.chat_message('private',chat_text,topic)
+        game_message.to_entity
+      end
+
+      let(:all_requests) do
+        game_message.join_chat(topic)
+        game_message.chat_message('group',chat_text,topic)
+        game_message.leave_chat(topic)
+        game_message.to_entity
+      end
+
+      let(:actor_ref) {double('Actor::Ref', :tell => true)}
+
+      subject do
+        ref = Actor::Builder.new(GameSystems::Chat,player_id).with_name('chat_test').test_ref
+        actor = ref.underlying_actor
+        actor
+      end
+
+      before(:each) do
+        Chat.any_instance.stub(:load_state)
+        Actor::Builder.new(GameSystems::Chat,player_id).start
+        MessageQueue.stub(:find).and_return(actor_ref)
+        commands.datastore.delete("chat_topic_#{topic}")
+      end
+
+      describe "private channels" do
+
+        it "joining private channel without invite should fail" do
+          channel_name = "priv/otherplayer/test"
+          join_message = commands.chat.join_message(channel_name,player_id)
+          expect(subject).to_not receive(:join_channel)
+          subject.on_receive(join_message)
+        end
+
+        it "joining my own channel should work" do
+          channel_name = "priv/#{player_id}/test"
+          join_message = commands.chat.join_message(channel_name,player_id)
+          expect(subject).to receive(:join_channel)
+          subject.on_receive(join_message)
+        end
+
+        it "joining private channel with invite should work" do
+          channel_name = "priv/otherplayer/test"
+          join_message = commands.chat.join_message(channel_name,player_id,'myinvite')
+          expect(subject).to receive(:join_channel)
+          expect(subject).to receive(:invite_exists?).with(channel_name,'myinvite').and_return(true)
+          subject.on_receive(join_message)
+
+        end
+      end
+
+      describe "#subscribers_for_topic" do
+        it "subscriber id count is zero when no subscribers" do
+          subscribers = Chat.subscribers_for_topic(topic)
+          expect(subscribers.get_subscriber_id_count).to eql(0)
+        end
+      end
+
+      describe "subscribers list updates" do
+        it "joining a channel adds player to subscriber list" do
+          subject.on_receive(join_request)
+          subscribers = Chat.subscribers_for_topic(topic)
+          expect(subscribers.get_subscriber_id_count).to eql(1)
+          expect(subscribers.get_subscriber_id_list.first).to eql(player_id)
+          subject.on_receive(leave_request)
+        end
+
+        it "leaving a channel removes player as subscriber" do
+          subject.on_receive(join_request)
+          subject.on_receive(leave_request)
+          subscribers = Chat.subscribers_for_topic(topic)
+          expect(subscribers.get_subscriber_id_count).to eql(0)
+        end
+      end
+
+      describe "channel flags" do
+        it "joining a channel with flags should persist the flag" do
+          subject.on_receive(join_request_with_flags)
+          topic_flags = subject.get_flags.fetch(topic,[])
+          topic_flags.include?('subscribers').should be_true
+        end
+
+        it "chat status should add subscribers to channel if flag is set" do
+          subject.on_receive(join_request_with_flags)
+          expect_any_instance_of(MessageLib::ChatChannel).to receive(:set_subscribers)
+          entity = MessageLib::Entity.new.set_chat_status(MessageLib::ChatStatus.new)
+          subject.on_receive(entity)
+        end
+      end
+
+      describe "subscriptions" do
+        it "joining a channel should persist subscriptions" do
+          subject.on_receive(join_request_with_flags)
+          subscriptions = subject.get_subscriptions
+          subscriptions.include?(topic).should be_true
+        end
+      end
+
+      describe "joining and leaving channels" do
+        it "processes the entity as a leave channel request" do
+          subject.should_receive(:leave_channels)
+          subject.on_receive(leave_request)
+        end
+
+        it "sends an unsubscribe message to message queue" do
+          subject.on_receive(join_request)
+          actor_ref.should_receive(:tell).with(kind_of(MessageLib::Unsubscribe),anything())
+          subject.on_receive(leave_request)
+        end
+
+        it "processes the entity as a join channel request" do
+          subject.should_receive(:join_channels)
+          subject.on_receive(join_request)
+        end
+
+        it "sends a subscribe message to message queue" do
+          actor_ref.should_receive(:tell).exactly(1).times
+          subject.on_receive(join_request)
+        end
+
+        it "processes multiple requests in a single message" do
+          subject.should_receive(:join_channels).once
+          subject.should_receive(:leave_channels).once
+          subject.should_receive(:send_message).once
+          subject.on_receive(all_requests)
+        end
+
+        it "send a private chat message" do
+          subject.should_receive(:send_private_message).once
+          subject.on_receive(private_chat_request)
+        end
+
+        it "send a group chat message" do
+          subject.should_receive(:send_group_message).once
+          subject.on_receive(public_chat_request)
+        end
+
+      end
+
+    end
+
+  end
+end
+

data/spec/game_systems/entity_tracking_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+module GameMachine
+  module GameSystems
+    describe EntityTracking do
+
+
+      subject do
+        ref = Actor::Builder.new(EntityTracking).with_name('entity_tracking_test').test_ref
+        ref.underlying_actor.post_init
+        ref.underlying_actor
+      end
+
+      let(:track_entity) do
+        MessageLib::TrackEntity.new.set_value(true)
+      end
+
+      let(:vector3) do
+        MessageLib::Vector3.new.set_x(0).set_y(0).set_z(0)
+      end
+
+      let(:get_neighbors) do
+        MessageLib::GetNeighbors.new.set_neighbor_type('player').set_vector3(vector3)
+      end
+
+      let(:player) do
+        MessageLib::Player.new.set_id('1')
+      end
+
+      let(:entity) do
+        MessageLib::Entity.new.set_id('0').
+          set_player(player).
+          set_track_entity(track_entity).
+          set_entity_type('player').
+          set_vector3(vector3)
+      end
+
+      let(:get_neighbors_entity) do
+        MessageLib::Entity.new.set_id('0').set_get_neighbors(get_neighbors)
+      end
+
+      let(:actor_ref) {double('Actor::Ref', :tell => true)}
+
+      describe 'tracking location' do
+
+        it "should call grid.set with player" do
+          expect(subject.grid).to receive(:set).with('0',0.0,0.0,0.0,'player')
+          subject.on_receive(entity)
+        end
+
+      end
+
+      describe 'get neighbors' do
+        it "sends neighbors to player" do
+          expect(subject).to receive(:send_neighbors_to_player)
+          get_neighbors_entity.set_player(player)
+          subject.on_receive(entity)
+          subject.on_receive(get_neighbors_entity)
+        end
+      end
+
+    end
+  end
+end

data/spec/game_systems/region_manager_spec.rb

@@ -0,0 +1,138 @@
+require 'spec_helper'
+
+module GameMachine
+  module GameSystems
+
+    class Zone2Manager < Actor::Base
+      def on_receive(message);end
+    end
+    class Zone1Manager < Actor::Base
+      def on_receive(message);end
+    end
+
+    describe RegionManager do
+
+      let(:zone1_manager) {'GameMachine::GameSystems::Zone1Manager'}
+      let(:zone2_manager) {'GameMachine::GameSystems::Zone2Manager'}
+
+      let(:region1) {double('region1', :name => 'zone1', :server => nil,
+                            :manager => zone1_manager, :save => true)}
+      let(:region2) {double('region2', :name => 'zone2', :server => nil,
+                            :manager => zone2_manager, :save => true)}
+
+      let(:regions) {{'zone1' => region1, 'zone2' => region2}}
+
+      let(:cluster_member) {double('cluster_member')}
+
+      let(:server1_address) {'akka.tcp://cluster@localhost:2551'}
+      let(:server2_address) {'akka.tcp://cluster@localhost:2552'}
+
+      let(:cluster_members) do
+        {server1_address => cluster_member, server2_address => cluster_member}
+      end
+
+      let(:cluster_with_down_members) do
+        {server1_address => cluster_member}
+      end
+
+      let(:actor_ref) {double('Actor::Ref', :tell => true)}
+
+      subject do
+        ref = Actor::Builder.new(RegionManager).with_name('region_manager_test').test_ref
+        ref.underlying_actor
+      end
+
+      describe "#assign_servers" do
+        it "should assign servers to regions that have none" do
+          subject.stub(:regions).and_return(regions)
+          ClusterMonitor.stub(:cluster_members).and_return(cluster_members)
+          expect(region1).to receive(:server=)
+          expect(region2).to receive(:server=)
+          expect(region1).to receive(:save)
+          expect(region2).to receive(:save)
+          subject.assign_servers
+          expect(subject.servers[server1_address]).to eq region1.name
+          expect(subject.servers[server2_address]).to eq region2.name
+        end
+
+      end
+
+      describe "#notify_managers" do
+        it "should send message to manager of each region" do
+          subject.stub(:regions).and_return(regions)
+          region1.stub(:server).and_return(server1_address)
+          region2.stub(:server).and_return(server2_address)
+          expect(GameSystems::Zone1Manager).to receive(:find_by_address).
+            with(server1_address).  and_return(actor_ref)
+          expect(GameSystems::Zone2Manager).to receive(:find_by_address).
+            with(server2_address).  and_return(actor_ref)
+          subject.notify_managers
+        end
+      end
+
+      describe "#load_from_config" do
+        
+        it "should create new regions that do not exist" do
+          expect(Models::Region).to receive(:find).
+            with('zone1',5000).and_return(nil)
+          expect(Models::Region).to receive(:find).
+            with('zone2',5000).and_return(nil)
+
+          expect(Models::Region).to receive(:new).
+            with(:id => 'zone1', :name => 'zone1', :manager => zone1_manager).and_return(region1)
+          expect(Models::Region).to receive(:new).
+            with(:id => 'zone2', :name => 'zone2', :manager => zone2_manager).and_return(region2)
+
+          expect(region1).to receive(:save)
+          expect(region2).to receive(:save)
+          expect(subject.regions['zone1']).to eq region1
+          expect(subject.regions['zone2']).to eq region2
+        end
+        
+        it "should load regions that exist" do
+          expect(Models::Region).to receive(:find).with('zone1',5000).and_return(region1)
+          expect(Models::Region).to receive(:find).with('zone2',5000).and_return(region2)
+          expect(subject.regions['zone1']).to eq region1
+          expect(subject.regions['zone2']).to eq region2
+        end
+      end
+
+      describe "#unassign_down_servers" do
+
+        context "nodes have not changed" do
+          it "should not unassign servers from regions" do
+            ClusterMonitor.stub(:cluster_members).and_return(cluster_members)
+            subject.unassign_down_servers
+            expect(region1).to_not receive(:save)
+            expect(region2).to_not receive(:save)
+          end
+        end
+
+        context "node has been downed" do
+
+          before(:each) do
+            subject.regions['zone1'].server = server2_address
+            subject.servers[server2_address] = 'zone1'
+            ClusterMonitor.stub(:cluster_members).and_return(cluster_with_down_members)
+          end
+
+          it "should set region server to nil" do
+            subject.unassign_down_servers
+            expect(subject.regions['zone1'].server).to be_nil
+          end
+
+          it "should remove servers entry" do
+            subject.unassign_down_servers
+            expect(subject.servers.has_key?(server2_address)).to be_false
+          end
+
+          it "should save region" do
+            expect(subject.regions['zone1']).to receive(:save)
+            subject.unassign_down_servers
+          end
+        end
+      end
+
+    end
+  end
+end