game_machine 0.0.11 → 1.0.2

data/pathfinding/pathfinder.cpp

@@ -0,0 +1,117 @@
+
+#include "pathfinder.h"
+
+using namespace std;
+
+static map<int, Crowd*> crowds;
+static map<int, Navmesh*> navmeshes;
+static map<int, Astar*> pathfinders;
+
+// Navmesh externs
+extern "C" EXPORT_API void addNavmesh(int id, const char *file) {
+	if (navmeshes[id] == 0) {
+		Navmesh* navmesh = new Navmesh(id,file);
+		navmeshes[id] = navmesh;
+	}
+}
+
+extern "C" EXPORT_API int findPath(int navmeshId, float startx, float starty,
+    float startz, float endx, float endy, float endz, int find_straight_path,
+    float* resultPath)
+{
+	Navmesh* navmesh = navmeshes[navmeshId];
+	return navmesh->findPath(startx, starty, startz, endx, endy, endz, find_straight_path, resultPath);
+}
+
+extern "C" EXPORT_API void gmapSetPassable(int navmeshId, int a, int b, int radius)
+{
+	Navmesh* navmesh = navmeshes[navmeshId];
+	navmesh->gmapSetPassable(a, b, radius);
+}
+extern "C" EXPORT_API void gmapSetBlocked(int navmeshId, int a, int b, int radius)
+{
+	Navmesh* navmesh = navmeshes[navmeshId];
+	navmesh->gmapSetBlocked(a, b, radius);
+}
+
+// Crowd externs
+
+// Add crowd using existing navmesh
+extern "C" EXPORT_API void addCrowd(int id, int navmeshid) {
+	if (crowds[id] == 0 && navmeshes[navmeshid] != 0)
+	{
+		Navmesh* navmesh = navmeshes[navmeshid];
+		Crowd* crowd = new Crowd(navmesh);
+		crowds[id] = crowd;
+	}
+}
+
+extern "C" EXPORT_API int addAgent(int crowdId, const float* p, float accel,
+ float speed, float radius, float height, int optflag, float sepWeight)
+{
+	Crowd* crowd = crowds[crowdId];
+	return crowd->addAgent(p, accel, speed, radius, height, optflag, sepWeight);
+}
+
+extern "C" EXPORT_API void removeAgent(int crowdId, const int idx)
+{
+	Crowd* crowd = crowds[crowdId];
+	crowd->removeAgent(idx);
+}
+extern "C" EXPORT_API void setMoveTarget(int crowdId, const float* p, bool adjust, int agentIdx)
+{
+	Crowd* crowd = crowds[crowdId];
+	crowd->setMoveTarget(p, adjust, agentIdx);
+}
+
+extern "C" EXPORT_API void getAgentPosition(int crowdId, int idx, float* resultPath)
+{
+	Crowd* crowd = crowds[crowdId];
+	const dtCrowdAgent* ag = crowd->getCrowd()->getAgent(idx);
+	if (!ag->active)
+        return;
+    memcpy(resultPath, ag->npos, 3*sizeof(float));
+}
+
+extern "C" EXPORT_API void updateTick(int crowdId, const float dt)
+{
+	Crowd* crowd = crowds[crowdId];
+	crowd->updateTick(dt);
+}
+
+
+// Astar 2d grid pathfinding externs
+
+extern "C" EXPORT_API void addPathfinder(int i, int width, int height) {
+	Astar* pathfinder = new Astar(width,height);
+	pathfinders[i] = pathfinder;
+}
+
+extern "C" EXPORT_API void setBlocked(int pathfinder, int x, int y) {
+	Astar *astar = pathfinders[pathfinder];
+	astar->setBlocked(x,y);
+}
+
+extern "C" EXPORT_API void setPassable(int pathfinder, int x, int y) {
+	Astar *astar = pathfinders[pathfinder];
+	astar->setPassable(x,y);
+}
+
+extern "C" EXPORT_API int getXAt(int pathfinder, int index) {
+	Astar *astar = pathfinders[pathfinder];
+	return astar->getXAt(index);
+}
+
+extern "C" EXPORT_API int getYAt(int pathfinder, int index) {
+	Astar *astar = pathfinders[pathfinder];
+	return astar->getYAt(index);
+}
+
+extern "C" EXPORT_API int findpath2d(int pathfinder, int startx, int starty, int endx, int endy)
+{
+	Astar *astar = pathfinders[pathfinder];
+	astar->ClearPath();
+	int res = astar->findPath(startx,starty,endx,endy);
+	astar->Print();
+	return res;
+}

data/pathfinding/premake4.lua

@@ -47,11 +47,14 @@ solution "pathfinding"
 	language "C++"
 	kind "StaticLib"
 	includedirs { 
-		"recastnavigation/Detour/Include" 
+		"recastnavigation/Detour/Include",
+		"recastnavigation/DetourCrowd/Include"
 	}
 	files { 
 		"recastnavigation/Detour/Include/*.h", 
-		"recastnavigation/Detour/Source/*.cpp" 
+		"recastnavigation/Detour/Source/*.cpp",
+		"recastnavigation/DetourCrowd/Include/*.h", 
+		"recastnavigation/DetourCrowd/Source/*.cpp" 
 	}
 	targetdir (todir .. "/lib")
   configuration "not windows"
@@ -63,6 +66,7 @@ project "detour_path"
 	includedirs { 
 		"recastnavigation/Detour/Include",
 		"recastnavigation/Recast/Include",
+		"recastnavigation/DetourCrowd/Include", 
 		"include"
 	}
 
@@ -71,6 +75,8 @@ project "detour_path"
 		"recastnavigation/Detour/Include/*.h", 
 		"recastnavigation/Recast/Include/Recast.h", 
 		"recastnavigation/Detour/Source/*.cpp",
+		"recastnavigation/DetourCrowd/Include/*.h", 
+		"recastnavigation/DetourCrowd/Source/*.cpp",
 		"include/*.h",
 		"*.cpp"
 	}
@@ -88,7 +94,8 @@ project "pathfind_test"
 	kind "ConsoleApp"
 	includedirs { 
 		"recastnavigation/Detour/Include",
-		"recastnavigation/Recast/Include", 
+		"recastnavigation/Recast/Include",
+		"recastnavigation/DetourCrowd/Include",
 		"include"
 	}
   libdirs {todir .. "lib" }
@@ -96,6 +103,8 @@ project "pathfind_test"
 		"recastnavigation/Detour/Include/*.h", 
 		"recastnavigation/Recast/Include/Recast.h", 
 		"recastnavigation/Detour/Source/*.cpp",
+		"recastnavigation/DetourCrowd/Include/*.h", 
+		"recastnavigation/DetourCrowd/Source/*.cpp",
 		"include/*.h",
 		"*.cpp"
 	}

data/spec/actor/actor_spec.rb

@@ -60,13 +60,6 @@ module GameMachine
         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'))
-          expect(Actor::Base.hashring('test')).to eq('ring')
-        end
-      end
-
     end
   end
 end

data/spec/client_manager_spec.rb

@@ -80,7 +80,7 @@ module GameMachine
     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")
+        client_connected_event.client_event.set_sender_id("#{Akka.instance.address}|me")
         expect(subject).to_not receive(:process_client_event)
         subject.on_receive(client_connected_event)
       end

data/spec/couchproxy_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+require 'benchmark'
+module GameMachine
+
+  describe "couchproxy integration test" do
+    
+    subject {JavaLib::Couchclient.get_instance}
+
+    before(:each) do
+      JavaLib::Couchclient.get_instance.set_credentials(
+          Application.config.gamecloud.host,
+          Application.config.gamecloud.user,
+          Application.config.gamecloud.api_key
+        )
+    end
+
+    it "should handle string values" do
+      subject.put_string("key1","value")
+      expect(subject.get_string("key1")).to eql 'value'
+    end
+
+    it "should handle keys that require uri escaping" do
+      key = 'first|two|=()*? $%#{@!~}"last'
+      value = "testing"
+      subject.put_string(key,value)
+      expect(subject.get_string(key)).to eql value
+    end
+
+    it "should handle protobuf binary messages" do
+      key = "one"
+      entity = MessageLib::Entity.new.set_id("testing")
+      subject.put_bytes(key,entity.to_byte_array)
+      bytes = subject.get_bytes(key)
+      entity = MessageLib::Entity.parse_from(bytes)
+      expect(entity.id).to eql "testing"
+    end
+  end
+end

data/spec/entity_persistence_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+module GameMachine
+
+  describe "entity persistence" do
+
+    let(:player_id) {'player'}
+    let(:id) {'one'}
+
+    let(:test_object) do
+      message = MessageLib::TestObject.new
+      message.set_id(id)
+      message.set_required_string('testing')
+      message.set_fvalue(1.9)
+      message.set_bvalue(true)
+      message.set_dvalue(3.4)
+      message.set_numbers64(555)
+    end
+
+    let(:entity) {MessageLib::Entity.new.set_id(id)}
+
+    subject do
+      MessageLib::TestObject
+    end
+
+    describe "objectdb persistence" do
+      
+      describe "#query" do
+        it "performs a query on the gamecloud" do
+          GameMachine::DataStore.instance.delete_matching("players",'')
+          player = MessageLib::Player.new.set_id('player2').set_password_hash('blah')
+          GameMachine::DataStore.instance.set("players##player2",player)
+          messages = GameMachine::DataStore.instance.query("players",'',200,'Player')
+          expect(messages.size).to eq(1)
+          expect(messages.first.id).to eq('player2')
+        end
+
+        it "should return players with matching ids" do
+          100.times do |i|
+            player = MessageLib::Player.new.set_id("player#{i}").set_password_hash('blah')
+            GameMachine::DataStore.instance.set("players##player#{i}",player)
+          end
+          messages = GameMachine::DataStore.instance.query("players",'',200,'Player')
+          expect(messages.size).to eq(100)
+
+          messages2 = GameMachine::DataStore.instance.query("players",'player95',200,'Player')
+          expect(messages2.size).to eq(1)
+        end
+      end
+
+      describe "#dbDelete" do
+        it "sends delete request to object store" do
+          MessageLib::Entity.store_delete(player_id,id)
+        end
+      end
+
+      describe "#dbPut" do
+        it "sends save request to object store" do
+          entity.store_set(player_id)
+        end
+      end
+
+      describe "#dbGet" do
+        it "retrieves entity from the object store" do
+          entity.store_set(player_id)
+          sleep 1
+          entity = MessageLib::Entity.store_get(player_id,id,6000)
+          expect(entity.id).to eql id
+        end
+      end
+
+      describe "store any message that has id" do
+        it "stores and retrieves message having correct id" do
+          player = MessageLib::Player.new.set_id('player2').set_password_hash('blah')
+          player.store_set(player_id)
+          sleep 1
+          player = MessageLib::Player.store_get(player_id,'player2',2000)
+          expect(player.id).to eql('player2')
+        end
+      end
+    end
+
+    describe "Orm persistence", :if => GameMachine::Application.config.orm do
+    	before(:each) do
+    	 GameMachine::Application.orm_connect
+       ModelLib::TestObject.open
+       ModelLib::TestObject.delete_all
+       ModelLib::TestObject.close
+    	end
+
+    	describe "#ormSave" do
+        it "should return true" do
+          expect(test_object.db_save(player_id)).to be_truthy
+        end
+    	end
+
+      describe "#ormFind" do
+        it "should return test object with correct values" do
+          test_object.db_save(player_id)
+          obj = subject.db_find(id,player_id)
+          expect(obj.required_string).to eql(test_object.required_string)
+          expect(obj.fvalue).to eql(test_object.fvalue)
+          expect(obj.bvalue).to eql(test_object.bvalue)
+          expect(obj.dvalue).to eql(test_object.dvalue)
+          expect(obj.numbers64).to eql(test_object.numbers64)
+        end
+      end
+
+      describe "#ormWhere" do
+        it "should return list with one test object" do
+          test_object.db_save(player_id)
+          list = subject.db_where('test_object_dvalue = ?',3.4)
+          expect(list.to_a.size).to eql(1)
+        end
+      end
+
+      describe "#ormDelete" do
+        it "should return false if no record" do
+          expect(test_object.db_delete(player_id)).to be_falsy
+        end
+
+        it "should return true" do
+          test_object.db_save(player_id)
+          expect(test_object.db_delete(player_id)).to be_truthy
+        end
+      end
+    end
+
+  end
+end

data/spec/game_systems/team_manager_spec.rb

@@ -16,11 +16,11 @@ module GameMachine
       let(:invite_id) {'invite'}
 
       let(:team) do
-        Team.new(:owner => player_id, :name => team_name, :access => 'public', :members => team_members)
+        Team.new(:id => team_name, :owner => player_id, :name => team_name, :access => 'public', :members => team_members)
       end
 
       let(:team_two_members) do
-        Team.new(:owner => player_id, :name => team_name2, :access => 'public', :members => [player_id,player2])
+        Team.new(:id => team_name2, :owner => player_id, :name => team_name2, :access => 'public', :members => [player_id,player2])
       end
 
       let(:team_invite) do

data/spec/hashring_spec.rb

@@ -1,59 +1,37 @@
 require 'spec_helper'
 
 module GameMachine
-  describe Hashring do
+  describe 'JavaLib::Hashring' do
 
-    let(:buckets) {['server1','server2']}
-    let(:bucket_name) {'test_bucket'}
+    let(:nodes) {['server1','server2']}
+    let(:node_name) {'test_node'}
 
     subject do
-      Hashring.new(buckets)
+      JavaLib::Hashring.new('test',nodes,3)
     end
 
-    describe "#nodes" do
-      it "nodes should equal buckets" do
-        expect(subject.nodes.sort).to eq(buckets.sort)
+    describe "#node_for" do
+      it "returns node for value" do
+        expect(nodes.to_a.include?(subject.node_for('test'))).to be_truthy
       end
     end
 
-    describe "#points" do
-      it "should be number of points equal to REPLICAS * buckets.size " do
-        expect(subject.points.size).to eq(subject.buckets.size * Hashring::REPLICAS)
-      end
-    end
-
-    describe "#bucket_for" do
-      it "returns bucket for value" do
-        expect(buckets.include?(subject.bucket_for('test'))).to be_truthy
-      end
-    end
-
-    describe "#remove_bucket" do
-      it "removes the bucket from buckets array" do
-        subject.remove_bucket('server1')
-        expect(subject.buckets.size).to eq(1)
-        expect(subject.buckets.first).to eq('server2')
-      end
-
+    describe "#remove_node" do
+      
       it "removes node from ring" do
-        subject.remove_bucket('server1')
-        expect(subject.nodes.size).to eq(1)
-        expect(subject.buckets.first).to eq('server2')
+        subject.remove_node('server1')
+        expect(subject.nodes.to_a.size).to eq(1)
+        expect(subject.nodes.to_a.first).to eq('server2')
       end
     end
 
-    describe "#add_bucket" do
-      it "adds new bucket to buckets array" do
-        subject.add_bucket('blah')
-        expect(subject.buckets.size).to eq(3)
-        expect(subject.buckets.sort.first).to eq('blah')
+    describe "#add_node" do
+      it "adds new node to nodes array" do
+        subject.add_node('blah')
+        expect(subject.nodes.to_a.size).to eq(3)
+        expect(subject.nodes.to_a.sort.first).to eq('blah')
       end
 
-      it "adds node to ring" do
-        subject.add_bucket('blah')
-        expect(subject.nodes.size).to eq(3)
-        expect(subject.nodes.sort.first).to eq('blah')
-      end
     end
   end
 end