game_machine 0.0.11 → 1.0.2

data/mono/server/server.cs

@@ -0,0 +1,120 @@
+using System;
+using System.Net;
+using System.Net.Sockets;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using System.IO;
+using  ProtoBuf;
+using GameMachine;
+using NLog;
+using MonoMessage = GameMachine.Messages.MonoMessage;
+using Entity = GameMachine.Messages.Entity;
+
+namespace GameMachine
+{
+    public class DataPacket
+    {
+        public Socket sock;
+        public byte[] buf;
+        public EndPoint ep;
+
+        public DataPacket(Socket sock, byte[] buf, EndPoint ep)
+        {
+            this.sock = sock;
+            this.buf = buf;
+            this.ep = ep;
+        }
+    }
+
+    public class Server
+    {
+
+        public static int port = 24320;
+        public static Logger logger = LogManager.GetLogger("GameMachine");
+        private Socket server;
+        private MessageRouter router;
+
+        static void Main(string[] args)
+        {
+            Server server = new Server();
+            server.Run();
+			
+            Server.logger.Info("Server Starting");
+            Console.WriteLine("Press any key to exit.");
+            Console.ReadLine();
+        }
+		
+        public void Run()
+        {
+            router = new MessageRouter();
+            server = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
+            server.Bind(new IPEndPoint(IPAddress.Loopback, port));
+
+            for (int i=0; i<5; i++)
+            {
+                BeginReceive();
+            }
+        }
+
+        private void BeginReceive()
+        {
+            byte[] buffer = new byte[4096];
+            EndPoint ep = (EndPoint)new IPEndPoint(IPAddress.Loopback, 0);
+            DataPacket packet = new DataPacket(server, buffer, ep);
+            server.BeginReceiveFrom(packet.buf, 0, packet.buf.Length, SocketFlags.None, ref packet.ep, new AsyncCallback(Received), packet);
+        }
+
+        private void Received(IAsyncResult iar)
+        {
+            try
+            {
+                DataPacket packet = (DataPacket)iar.AsyncState;
+                int msgLen = packet.sock.EndReceiveFrom(iar, ref packet.ep);
+                byte[] localMsg = new byte[msgLen];
+                Array.Copy(packet.buf, localMsg, msgLen);
+
+                server.BeginReceiveFrom(packet.buf, 0, packet.buf.Length, SocketFlags.None, ref packet.ep, new AsyncCallback(Received), packet);
+
+                Task.Factory.StartNew(() => {
+                    MonoMessage monoMessage = ByteArrayToMonoMessage(localMsg);
+                    monoMessage.entity = router.Route(monoMessage.klass, monoMessage.entity);
+                    byte[] bytes = MonoMessageToByteArray(monoMessage);
+                    server.BeginSendTo(bytes, 0, bytes.Length, SocketFlags.None, packet.ep, new AsyncCallback(Sent), packet.ep);
+                });
+
+            } catch (ObjectDisposedException e)
+            {
+                Console.WriteLine(e.Message);
+            }
+        }
+
+        public void Sent(IAsyncResult ar)
+        {
+            try
+            {
+                server.EndSend(ar);
+            } catch (Exception ex)
+            {
+                Console.WriteLine(ex.Message);
+            }
+        }
+
+        public static MonoMessage ByteArrayToMonoMessage(byte[] bytes)
+        {
+            MonoMessage monoMessage;
+            MemoryStream stream = new MemoryStream(bytes);
+            monoMessage = Serializer.Deserialize<MonoMessage>(stream);
+            return monoMessage;
+        }
+        
+        public static byte[] MonoMessageToByteArray(MonoMessage monoMessage)
+        {
+            byte[] data;
+            MemoryStream stream = new MemoryStream();
+            Serializer.Serialize(stream, monoMessage);
+            data = stream.ToArray();
+            return data;
+        }
+    }
+}

data/pathfinding/astar.cpp

@@ -0,0 +1,149 @@
+#include <map>
+
+#include "astar.h"
+using namespace std;
+
+Astar::Astar(int a, int b) : width(a), height(b), gmap(width*height+1), pather(0)
+{
+	pather = new MicroPather( this, 100);
+}
+
+void Astar::setPassable(int x, int y)
+{
+	gmap[ y*width + x] = '\0';
+}
+
+void Astar::setBlocked(int x, int y)
+{
+	gmap[ y*width + x] = 'D';
+}
+
+int Astar::Passable( int nx, int ny ) 
+{
+	if (    nx >= 0 && nx < width 
+		 && ny >= 0 && ny < height )
+	{
+		int index = ny*width+nx;
+		char c = gmap[ index ];
+		if ( c == '\0' )
+			return 1;
+		else if ( c == 'D' )
+			return 2;
+	}		
+	return 0;
+}
+
+void Astar::ClearPath()
+{
+	path.resize( 0 );
+	pather->Reset();
+}
+
+int Astar::findPath(int startx, int starty, int endx, int endy)
+{
+	int result = 0;
+	float totalCost;
+	
+	if (Passable(startx,starty) && Passable(endx,endy))
+	{
+		result = pather->Solve( XYToNode( startx, starty ), XYToNode( endx, endy ), &path, &totalCost );
+		if ( result == MicroPather::SOLVED ) {
+			return path.size();
+		}
+	}
+	return result;
+}
+
+void Astar::NodeToXY( void* node, int* x, int* y ) 
+{
+	intptr_t index = (intptr_t)node;
+	*y = index / width;
+	*x = index - *y * width;
+}
+
+void* Astar::XYToNode( int x, int y )
+{
+	return (void*) ( y*width + x );
+}
+
+int Astar::getYAt(int i)
+{
+	int y;
+	intptr_t index = (intptr_t)path[i];
+	y = index / width;
+	return y;
+}
+
+int Astar::getXAt(int i)
+{
+	int x,y;
+	intptr_t index = (intptr_t)path[i];
+	y = index / width;
+	x = index - y * width;
+	return x;
+}
+
+float Astar::LeastCostEstimate( void* nodeStart, void* nodeEnd ) 
+{
+	int xStart, yStart, xEnd, yEnd;
+	NodeToXY( nodeStart, &xStart, &yStart );
+	NodeToXY( nodeEnd, &xEnd, &yEnd );
+
+	/* Compute the minimum path cost using distance measurement. It is possible
+	   to compute the exact minimum path using the fact that you can move only 
+	   on a straight line or on a diagonal, and this will yield a better result.
+	*/
+	int dx = xStart - xEnd;
+	int dy = yStart - yEnd;
+	return (float) sqrt( (double)(dx*dx) + (double)(dy*dy) );
+}
+
+void Astar::AdjacentCost( void* node, micropather::MPVector< StateCost > *neighbors ) 
+{
+	int x, y;
+	const int dx[8] = { 1, 1, 0, -1, -1, -1, 0, 1 };
+	const int dy[8] = { 0, 1, 1, 1, 0, -1, -1, -1 };
+	const float cost[8] = { 1.0f, 1.41f, 1.0f, 1.41f, 1.0f, 1.41f, 1.0f, 1.41f };
+
+	NodeToXY( node, &x, &y );
+
+	for( int i=0; i<8; ++i ) {
+		int nx = x + dx[i];
+		int ny = y + dy[i];
+
+		int pass = Passable( nx, ny );
+		if ( pass > 0 ) {
+			if ( pass == 1) 
+			{
+				// Normal floor
+				StateCost nodeCost = { XYToNode( nx, ny ), cost[i] };
+				neighbors->push_back( nodeCost );
+			}
+			else 
+			{
+				// Normal floor
+				StateCost nodeCost = { XYToNode( nx, ny ), FLT_MAX };
+				neighbors->push_back( nodeCost );
+			}
+		}
+	}
+}
+
+void Astar::PrintStateInfo( void* node ) 
+{
+	int x, y;
+	NodeToXY( node, &x, &y );
+	printf( "(%d,%d)", x, y );
+}
+
+void Astar::Print() 
+{
+	unsigned k;
+	// Wildly inefficient demo code.
+	unsigned size = path.size();
+	for( k=0; k<size; ++k ) {
+		int x, y;
+		NodeToXY( path[k], &x, &y );
+		fprintf (stderr, "%d.%d\n", x,y);
+	}
+}

data/pathfinding/build.sh

@@ -0,0 +1,6 @@
+rm -rf build
+cp overrides/DetourNavMeshQuery.cpp recastnavigation/Detour/Source
+cp overrides/DetourNavMeshQuery.h recastnavigation/Detour/Include
+cp overrides/DetourCrowd.cpp recastnavigation/DetourCrowd/Source
+premake/premake4 gmake
+cd build && make

data/pathfinding/build.txt

@@ -0,0 +1,16 @@
+
+First you need to clone recastnavigation into the pathfinding folder.
+
+There are premake4 binaries for linux and windows in the premake folder.
+
+Run one of the premake binaries with the options for your OS.  This should give you a build folder.  For windows open the sln and build.  For linux cd to the build folder and type 'make'.
+
+The linux build will copy the libraries to the bin folder which is where game machine expects to find them.  On windows you will need to copy them there manually.
+
+pathfinding.cs is a wrapper around the dll for windows that can be used in Unity (or any C# game engine).  Note that the query methods have coordinate mappings where we swap x and z.  This is so it works correctly with our own obj export. Feel free to change that if needed.  This is the C# code, native code always uses recast coordinates.
+
+The dll provides simple functionality for loading navigation meshes and performing pathfinding queries.  pathfinding.cs is a good reference for how to use it.  
+
+In ruby the Navigation module has several classes for working with navigation meshes and doing queries.  It uses the ruby FFI to call the library.
+
+Also, look at clients/unity/GameMachine/Editor/ExportScene.cs which is an obj file exporter that can export terrain + object meshes to a single obj file that recastdemo can use.

data/pathfinding/crowd.cpp

@@ -0,0 +1,194 @@
+#include "crowd.h"
+using namespace std;
+
+Crowd::Crowd(Navmesh* n)
+
+{
+	navmesh = n;
+	crowd = dtAllocCrowd();
+	
+	nav = navmesh->getMesh();
+
+	crowd->init(MAX_AGENTS, 0.6f, nav);
+
+	// Make polygons with 'disabled' flag invalid.
+	crowd->getEditableFilter(0)->setExcludeFlags(navmesh->SAMPLE_POLYFLAGS_DISABLED);
+
+	// Setup local avoidance params to different qualities.
+	dtObstacleAvoidanceParams params;
+	// Use mostly default settings, copy from dtCrowd.
+	memcpy(&params, crowd->getObstacleAvoidanceParams(0), sizeof(dtObstacleAvoidanceParams));
+
+	// Low (11)
+	params.velBias = 0.5f;
+	params.adaptiveDivs = 5;
+	params.adaptiveRings = 2;
+	params.adaptiveDepth = 1;
+	crowd->setObstacleAvoidanceParams(0, &params);
+
+	// Medium (22)
+	params.velBias = 0.5f;
+	params.adaptiveDivs = 5; 
+	params.adaptiveRings = 2;
+	params.adaptiveDepth = 2;
+	crowd->setObstacleAvoidanceParams(1, &params);
+
+	// Good (45)
+	params.velBias = 0.5f;
+	params.adaptiveDivs = 7;
+	params.adaptiveRings = 2;
+	params.adaptiveDepth = 3;
+	crowd->setObstacleAvoidanceParams(2, &params);
+
+	// High (66)
+	params.velBias = 0.5f;
+	params.adaptiveDivs = 7;
+	params.adaptiveRings = 3;
+	params.adaptiveDepth = 3;
+
+	crowd->setObstacleAvoidanceParams(3, &params);
+
+	memset(m_trails, 0, sizeof(m_trails));
+
+	m_vod = dtAllocObstacleAvoidanceDebugData();
+	m_vod->init(2048);
+
+	memset(&m_agentDebug, 0, sizeof(m_agentDebug));
+	m_agentDebug.idx = -1;
+	m_agentDebug.vod = m_vod;
+	fprintf (stderr, "Crowd initialized\n");
+}
+
+int Crowd::addAgent(const float* p, float accel, float speed, float radius, float height, int optflag, float sepWeight)
+{
+	dtCrowdAgentParams ap;
+	memset(&ap, 0, sizeof(ap));
+	ap.radius = radius;
+	ap.height = height;
+	ap.maxAcceleration = accel;
+	ap.maxSpeed = speed;
+	ap.collisionQueryRange = ap.radius * 12.0f;
+	ap.pathOptimizationRange = ap.radius * 30.0f;
+	ap.updateFlags = 0;
+	ap.updateFlags |= DT_CROWD_ANTICIPATE_TURNS;
+	ap.updateFlags |= DT_CROWD_OPTIMIZE_VIS;
+	ap.updateFlags |= DT_CROWD_OPTIMIZE_TOPO;
+	ap.updateFlags |= DT_CROWD_OBSTACLE_AVOIDANCE;
+	ap.updateFlags |= DT_CROWD_SEPARATION;
+	
+	ap.obstacleAvoidanceType = (unsigned char)3.0f;
+	ap.separationWeight = sepWeight;
+
+	int idx = crowd->addAgent(p, &ap);
+	if (idx != -1)
+	{
+		if (m_targetRef)
+			crowd->requestMoveTarget(idx, m_targetRef, m_targetPos);
+
+		// Init trail
+		AgentTrail* trail = &m_trails[idx];
+		for (int i = 0; i < AGENT_MAX_TRAIL; ++i)
+			dtVcopy(&trail->trail[i*3], p);
+		trail->htrail = 0;
+	}
+	return idx;
+}
+
+void Crowd::removeAgent(const int idx)
+{
+	crowd->removeAgent(idx);
+}
+
+static void calcVel(float* vel, const float* pos, const float* tgt, const float speed)
+{
+	dtVsub(vel, tgt, pos);
+	vel[1] = 0.0;
+	dtVnormalize(vel);
+	dtVscale(vel, vel, speed);
+}
+
+dtCrowd* Crowd::getCrowd()
+{
+	return crowd;
+}
+
+
+void Crowd::setMoveTarget(const float* p, bool adjust, int agentIdx)
+{
+
+	// Find nearest point on navmesh and set move request to that location.
+	dtNavMeshQuery* navquery = dtAllocNavMeshQuery();
+  	navquery->init(nav, 4096);
+
+	myQueryFilter filter;
+	filter.setNavmesh(navmesh);
+	filter.setIncludeFlags(navmesh->SAMPLE_POLYFLAGS_ALL ^ navmesh->SAMPLE_POLYFLAGS_DISABLED);
+  	filter.setExcludeFlags(0);
+	const float* ext = crowd->getQueryExtents();
+
+	if (adjust)
+	{
+		float vel[3];
+		// Request velocity
+		if (agentIdx != -1)
+		{
+			const dtCrowdAgent* ag = crowd->getAgent(agentIdx);
+			if (ag && ag->active)
+			{
+				calcVel(vel, ag->npos, p, ag->params.maxSpeed);
+				crowd->requestMoveVelocity(agentIdx, vel);
+			}
+		}
+		else
+		{
+			for (int i = 0; i < crowd->getAgentCount(); ++i)
+			{
+				const dtCrowdAgent* ag = crowd->getAgent(i);
+				if (!ag->active) continue;
+				calcVel(vel, ag->npos, p, ag->params.maxSpeed);
+				crowd->requestMoveVelocity(i, vel);
+			}
+		}
+	}
+	else
+	{
+		navquery->findNearestPoly(p, ext, &filter, &m_targetRef, m_targetPos);
+
+		if (agentIdx != -1)
+		{
+			const dtCrowdAgent* ag = crowd->getAgent(agentIdx);
+			if (ag && ag->active)
+				crowd->requestMoveTarget(agentIdx, m_targetRef, m_targetPos);
+		}
+		else
+		{
+			for (int i = 0; i < crowd->getAgentCount(); ++i)
+			{
+				const dtCrowdAgent* ag = crowd->getAgent(i);
+				if (!ag->active) continue;
+				crowd->requestMoveTarget(i, m_targetRef, m_targetPos);
+			}
+		}
+	}
+}
+
+void Crowd::updateTick(const float dt)
+{
+	crowd->update(dt, &m_agentDebug);
+
+	// Update agent trails
+	for (int i = 0; i < crowd->getAgentCount(); ++i)
+	{
+		const dtCrowdAgent* ag = crowd->getAgent(i);
+		AgentTrail* trail = &m_trails[i];
+		if (!ag->active)
+			continue;
+		// Update agent movement trail.
+		trail->htrail = (trail->htrail + 1) % AGENT_MAX_TRAIL;
+		dtVcopy(&trail->trail[trail->htrail*3], ag->npos);
+	}
+}
+
+
+
+