game_machine 0.0.8

data/script/watch.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+while true
+do
+   ATIME=`stat -c %Z /tmp/restart.txt`
+   if [[ "$ATIME" != "$LTIME" ]]
+   then
+       script/server.sh restart
+       LTIME=$ATIME
+   fi
+   sleep 1
+done

data/spec/actor/actor_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+module GameMachine
+  module Actor
+
+    describe Base do
+
+      let(:aspect) {['one','two']}
+
+      subject do
+        ref = Actor::Builder.new(Actor::Base).test_ref
+        ref.underlying_actor
+      end
+
+      describe "#onReceive" do
+        it "forwards the message to on_receive" do
+          expect(subject).to receive(:on_receive).with('test')
+          subject.onReceive('test')
+        end
+      end
+
+      describe "#aspect" do
+        it "adds the aspects" do
+          Actor::Base.aspect(aspect)
+          expect(Actor::Base.aspects.first).to eq(aspect)
+        end
+
+        it "registeres the class in the system manager" do
+          Actor::Base.aspect(aspect)
+          expect(Application.registered.include?(Actor::Base)).to be_true
+        end
+      end
+
+      describe "#sender" do
+        it "returns an actor ref" do
+          subject.sender.should be_kind_of(Actor::Ref)
+        end
+      end
+
+      describe "#find_distributed" do
+        it "should return ref with correctly formatted path" do
+          Actor::Builder.new(GameSystems::LocalEcho).distributed(1).with_name('echotest').start
+          actor_ref = GameSystems::LocalEcho.find_distributed('testid','echotest')
+          puts actor_ref.path
+          #actor_ref.path.match(/akka.tcp:\/\/cluster@localhost:2551\/user\/echotest[\d]{1,2}/).should be_true
+        end
+      end
+
+      describe "#find_remote" do
+        it "should return ref with correctly formatted path" do
+          actor_ref = GameSystems::LocalEcho.find_remote('default','test')
+          actor_ref.path.match(/akka.tcp:\/\/cluster@localhost:2551\/user\/test/).should be_true
+        end
+      end
+
+      describe "#find" do
+        it "should return ref with correctly formatted path" do
+          actor_ref = GameSystems::LocalEcho.find('test')
+          actor_ref.path.match(/\/user\/test/).should be_true
+        end
+      end
+
+      describe "#add_hashring" do
+        it "adds the hashring and returns it" do
+          expect(Actor::Base.add_hashring('test','ring')).to eq(Actor::Base.hashring('test'))
+          Actor::Base.hashring('test').should == 'ring'
+        end
+      end
+
+    end
+  end
+end
+

data/spec/actor/builder_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+module GameMachine
+  describe Actor::Builder do
+
+    let(:actor_class) {GameSystems::LocalEcho}
+
+    let(:router) {double('Router')}
+
+    subject do
+     Actor::Builder.new(actor_class)
+    end
+
+    describe "#with_name" do
+      it "should set name and return self" do
+        expect(subject.with_name('blah')).to eq(subject)
+        expect(subject.name).to eq('blah')
+      end
+    end
+
+    describe "#with_parent" do
+      it "returns self" do
+        expect(subject.with_parent('blah')).to eq(subject)
+      end
+    end
+
+    describe "#with_router" do
+      it "calls new on router with num_routers and return self" do
+        expect(router).to receive(:new).with(10)
+        expect(subject.with_router(router,10)).to eq(subject)
+      end
+    end
+
+    describe "#distributed" do
+      it "returns self" do
+        expect(subject.distributed(1)).to eq(subject)
+      end
+    end
+
+    describe "#start" do
+      it "creates the actor and returns the actor ref" do
+        expect(subject.with_name('blah').start).to be_kind_of((JavaLib::ActorRef))
+      end
+
+      it "adds a hashring if distributed" do
+        expect(GameSystems::LocalEcho).to receive(:add_hashring).with(
+          GameSystems::LocalEcho.name,kind_of(Hashring)
+        )
+        subject.distributed(1).start
+      end
+    end
+
+  end
+end
+
+

data/spec/actor/ref_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+module GameMachine
+  describe Actor::Ref do
+
+    let(:local_echo) do
+      ref = Actor::Builder.new(GameSystems::LocalEcho).with_name('localecho1').test_ref
+      ref.underlying_actor
+    end
+
+    subject do
+      Actor::Ref.new('test')
+    end
+
+    describe "#initialize" do
+      it "sets the path" do
+        Actor::Ref.new('test').path.should == 'test'
+      end
+    end
+
+    describe "#ask" do
+      it "should accept an actor ref" do
+        ref = Actor::Ref.new(local_echo.get_self)
+        ref.ask('test',1000).should == 'test'
+      end
+
+      it "should accept a path" do
+        Actor::Builder.new(GameSystems::LocalEcho).with_name('echotest3').start
+        ref = GameSystems::LocalEcho.find('echotest3')
+        ref.ask('test',1000).should == 'test'
+      end
+    end
+
+    describe "#tell" do
+      it 'sender argument is optional' do
+        subject.tell('test').should be_true
+      end
+
+      it "should accept a path" do
+        Actor::Builder.new(GameSystems::LocalEcho).with_name('echotest4').start
+        GameSystems::LocalEcho.should_receive_message('test','echotest4') do
+          ref = GameSystems::LocalEcho.find('echotest4')
+          ref.tell('test',nil)
+        end
+      end
+
+    end
+
+    describe "#send_message" do
+
+      it "default should call tell with message and nil sender" do
+        subject.should_receive(:tell).with('test',nil)
+        subject.send_message('test')
+      end
+
+      it "blocking=true should call ask with message and default timeout" do
+        subject.should_receive(:ask).with('test',100)
+        subject.send_message('test', :blocking => true)
+      end
+
+      it "sender option should be passed to tell" do
+        subject.should_receive(:tell).with('test','sender')
+        subject.send_message('test',:sender => 'sender')
+      end
+
+      it "timeout option should be passed to ask" do
+        subject.should_receive(:ask).with('test',2)
+        subject.send_message('test', :timeout => 2, :blocking => true)
+      end
+
+      it "should get returned message" do
+        Actor::Builder.new(GameSystems::LocalEcho).with_name('echotest2').start
+        ref = GameSystems::LocalEcho.find('echotest2')
+        ref.send_message('hi', :blocking => true, :timeout => 1000).should == 'hi'
+      end
+
+      it "should return false on timeout" do
+        ref = GameSystems::LocalEcho.find('blah')
+        ref.send_message('hi', :blocking => true, :timeout => 1).should be_false
+      end
+    end
+  end
+end

data/spec/application_spec.rb

@@ -0,0 +1,7 @@
+require_relative 'spec_helper'
+
+module GameMachine
+  describe Application do
+    
+  end
+end

data/spec/client_manager_spec.rb

@@ -0,0 +1,171 @@
+
+require 'spec_helper'
+module GameMachine
+  describe ClientManager do
+
+    let(:player_id) {'player_test'}
+    let(:actor_name) {'testactor'}
+    let(:client_name) {'testclient'}
+    let(:actor_ref) {double('Actor::Ref')}
+    let(:player) {MessageLib::Player.new.set_id(player_id)}
+
+    let("actor_register") do
+      MessageLib::Entity.new.set_id(client_name).set_client_manager_register(
+        MessageLib::ClientManagerRegister.new.set_register_type('actor').
+          set_name(actor_name)
+      )
+    end
+
+    let("actor_unregister") do
+      MessageLib::Entity.new.set_id(client_name).set_client_manager_unregister(
+        MessageLib::ClientManagerUnregister.new.set_register_type('actor').
+          set_name(actor_name)
+      )
+    end
+
+    let("client_register") do
+      MessageLib::Entity.new.set_id(client_name).set_client_manager_register(
+        MessageLib::ClientManagerRegister.new.set_register_type('client').
+          set_name(client_name)
+      ).set_player(player).set_client_connection(client_connection)
+    end
+
+    let("client_unregister") do
+      MessageLib::Entity.new.set_id(client_name).set_client_manager_unregister(
+        MessageLib::ClientManagerUnregister.new.set_register_type('client').
+          set_name(client_name)
+      ).set_player(player).set_client_connection(client_connection)
+    end
+
+    let('client_disconnected_event') do
+      MessageLib::Entity.new.set_id(client_name).set_client_event(
+        MessageLib::ClientEvent.new.set_event('disconnected').set_client_id(client_name).
+        set_sender_id(sender_id).set_player_id(player_id)
+      )
+    end
+
+    let(:sender_id) {['server2',ClientManager.name].join('|')}
+
+    let('client_connected_event') do
+      MessageLib::Entity.new.set_id(client_name).set_client_event(
+        MessageLib::ClientEvent.new.set_event('connected').set_client_id(client_name).
+        set_sender_id(sender_id).set_player_id(player_id)
+      )
+    end
+
+    let(:client_connection) do
+      MessageLib::ClientConnection.new.set_id(client_name).set_gateway('udp').
+        set_server('server')
+    end
+
+    let('local_player_message') do
+      MessageLib::Entity.new.set_id(client_name).set_player(player).
+        set_send_to_player(true)
+    end
+
+    let('remote_player_message') do
+      MessageLib::Entity.new.set_id(client_name).set_player(player).
+        set_send_to_player(true)
+    end
+
+    subject do
+      ref = Actor::Builder.new(ClientManager).with_name('client_manager_test').test_ref
+      ref.underlying_actor
+    end
+
+    before(:each) do
+      subject.class.local_players.delete(player_id)
+    end
+
+    describe "#on_receive" do
+
+      it "should not process client even if message is from self" do
+        client_connected_event.client_event.set_sender_id("default|me")
+        expect(subject).to_not receive(:process_client_event)
+        subject.on_receive(client_connected_event)
+      end
+    end
+
+    describe "#send_to_player" do
+      it "should send message directly to player if player is local" do
+        subject.local_clients[client_name] = client_connection
+        subject.players[player_id] = client_name
+        subject.class.local_players[player_id] = true
+        actor_ref.stub(:tell)
+        expect(Actor::Base).to receive(:find).with(player_id).and_return(actor_ref)
+        ClientManager.send_to_player(local_player_message)
+      end
+
+      it "should send message to remote manager if player is remote" do
+        subject.remote_clients[client_name] = actor_ref
+        subject.players[player_id] = client_name
+        ClientManager.stub(:find).and_return(actor_ref)
+        expect(actor_ref).to receive(:tell).with(remote_player_message)
+        ClientManager.send_to_player(remote_player_message)
+      end
+    end
+
+    describe "#process_client_event" do
+      it "on connect should set players entry" do
+        subject.on_receive(client_connected_event)
+        expect(subject.players.has_key?(player_id)).to be_true
+      end
+
+      it "on connect should set remote_clients entry" do
+        subject.on_receive(client_connected_event)
+        expect(subject.remote_clients.has_key?(client_name)).to be_true
+      end
+
+      it "on disconnect event should remove remote client reference" do
+        subject.remote_clients[client_name] = true
+        subject.on_receive(client_disconnected_event)
+        expect(subject.remote_clients.has_key?(client_name)).to be_false
+      end
+    end
+
+    describe "#register_sender" do
+      it "should add local client entry if client" do
+        subject.on_receive(client_register)
+        expect(subject.local_clients.has_key?(client_name)).to be_true
+      end
+
+      it "should add local actor entry if actor" do
+        subject.on_receive(actor_register)
+        expect(subject.local_actors.has_key?(actor_name)).to be_true
+      end
+
+      it "client register should call send_client_event" do
+        expect(subject).to receive(:send_client_event).with(client_name,player_id,'connected')
+        subject.on_receive(client_register)
+      end
+
+      it "should not send client event for local connenction" do
+        client_register.client_connection.set_type('local')
+        expect(subject).to_not receive(:send_client_event)
+        subject.on_receive(client_register)
+      end
+    end
+
+    describe "#unregister_sender" do
+      it "sends disconnected message to message queue" do
+        expect(subject).to receive(:send_client_event).with(client_name,player_id,'disconnected')
+        subject.on_receive(client_unregister)
+      end
+
+      it "removes local client reference" do
+        subject.local_clients[client_name] = true
+        subject.on_receive(client_unregister)
+        expect(subject.local_clients.has_key?(client_name)).to be_false
+      end
+
+      it "should not send client event for local connenction" do
+        client_unregister.client_connection.set_type('local')
+        expect(subject).to_not receive(:send_client_event)
+        subject.on_receive(client_unregister)
+      end
+    end
+
+
+  end
+
+end

data/spec/commands/chat_commands_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+module GameMachine
+  module Commands
+    describe ChatCommands do
+
+      let(:actor_ref) {double('Actor::Ref', :tell => true)}
+
+      subject{ChatCommands.new}
+
+      before(:each) do
+        GameSystems::ChatManager.stub(:find).and_return(actor_ref)
+      end
+
+      describe "#send_private_message" do
+        it "sends a private message request to the chat actor" do
+          expect(actor_ref).to receive(:tell)
+          subject.send_private_message('1','blah')
+        end
+      end
+
+      describe "#join" do
+        it "joins a chat group" do
+          expect(actor_ref).to receive(:tell)
+          subject.join('blah','player1')
+        end
+      end
+
+      describe "#leave" do
+        it "leaves a chat group" do
+          expect(actor_ref).to receive(:tell)
+          subject.leave('blah','player1')
+        end
+      end
+
+    end
+  end
+end