game_machine 0.0.8

data/mono/server/proxy_client.cs

@@ -0,0 +1,73 @@
+using System;
+using System.Diagnostics;
+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 Entity = GameMachine.Messages.Entity;
+
+namespace GameMachine
+{
+    public class ProxyClient
+    {
+        private IPEndPoint udp_ep;
+        private UdpClient udpClient;
+        private int port = 8800;
+        private string host = "127.0.0.1";
+
+        public ProxyClient(int _port)
+        {
+          port = _port;
+        }
+
+        public void Start()
+        {
+            udp_ep = new IPEndPoint(IPAddress.Any, 11000);
+            udpClient = new UdpClient(udp_ep);
+            receiveData();
+			
+            Task.Factory.StartNew(() => {
+                Ping(); });
+        }
+
+        private void Ping()
+        {
+            Entity entity = new Entity();
+            entity.id = "ping";
+            byte[] bytes = MessageUtil.EntityToByteArray(entity);
+            while (true)
+            {
+                Thread.Sleep(1000);
+                Send(bytes);
+            }
+        }
+
+        private void SendCallback(IAsyncResult ar)
+        {
+            UdpClient u = (UdpClient)ar.AsyncState;
+            u.EndSend(ar);
+        }
+		
+        public void Send(byte[] bytes)
+        {
+            udpClient.BeginSend(bytes, bytes.Length, host, port, new AsyncCallback(SendCallback), udpClient);
+        }
+		
+        private void dataReady(IAsyncResult ar)
+        {
+            byte[] bytes = udpClient.EndReceive(ar, ref udp_ep);
+            receiveData();
+            MessageRouter.Route(bytes, this);
+        }
+		
+        private void receiveData()
+        {
+            udpClient.BeginReceive(new AsyncCallback(dataReady), udp_ep);
+        }
+		
+    }
+}

data/mono/server/proxy_server.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Diagnostics;
+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;
+
+namespace GameMachine
+{
+	public class ProxyServer
+	{
+
+		public static Logger logger = LogManager.GetLogger("GameMachine");
+		static void Main(string[] args)
+		{
+			ProxyClient proxyClient = new ProxyClient(Int32.Parse(args[0]));
+			proxyClient.Start();
+			
+			ProxyServer.logger.Info("Proxy Starting");
+			Console.WriteLine("Press any key to exit.");
+			Console.ReadLine();
+		}
+
+	}
+}

data/mono/server/test_actor.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Text;
+using System.IO;
+using System.Threading;
+using System.Runtime.InteropServices;
+using  ProtoBuf;
+using System.Collections.Generic;
+using Entity = GameMachine.Messages.Entity;
+using GameMachine;
+
+namespace GameMachine
+{
+    public class TestActor : GameMachine.Actor
+    {
+			
+        public TestActor()
+        {
+        }
+		
+        public override void OnReceive(object message)
+        {
+            try
+            {
+                Entity entity = message as Entity;
+                Tell("/GameMachine/GameSystems/Devnull", entity);
+            } catch (Exception ex)
+            {
+                ProxyServer.logger.Info(ex);
+            }
+
+        }
+    }
+}

data/pathfinding/include/mesh_loader.h

@@ -0,0 +1,28 @@
+#include "DetourNavMesh.h"
+
+static const int NAVMESHSET_MAGIC = 'M'<<24 | 'S'<<16 | 'E'<<8 | 'T'; //'MSET';
+static const int NAVMESHSET_VERSION = 1;
+
+struct NavMeshSetRcnHeader
+{
+  long version;
+  int numTiles;
+  dtNavMeshParams params;
+};
+struct NavMeshSetHeader
+{
+  int magic;
+  int version;
+  int numTiles;
+  dtNavMeshParams params;
+};
+
+struct NavMeshTileHeader
+{
+	dtTileRef tileRef;
+	int dataSize;
+};
+
+void save_navmesh(const char* path, const dtNavMesh* mesh);
+dtNavMesh* load_navmesh(const char* path);
+

data/pathfinding/include/pathfind.h

@@ -0,0 +1,167 @@
+#define _USE_MATH_DEFINES
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "Recast.h"
+#include "DetourCommon.h"
+#include "DetourNavMesh.h"
+#include "DetourNavMeshBuilder.h"
+#include "DetourNavMeshQuery.h"
+#include "mesh_loader.h"
+
+#if _MSC_VER    // TRUE for Microsoft compiler.
+#define EXPORT_API __declspec(dllexport) // Required for VC++
+#else
+#define EXPORT_API // Otherwise don't define.
+#endif
+
+#define VERTEX_SIZE       3
+#define INVALID_POLYREF   0
+
+static const int P_FAILURE = -1;
+static const int P_NO_START_POLY = -2;
+static const int P_NO_END_POLY = -3;
+static const int P_PATH_NOT_FOUND = -4;
+static const int P_MESH_NOT_FOUND = -5;
+static const int P_QUERY_NOT_FOUND = -6;
+
+static dtNavMesh* meshes[1024];
+static dtNavMeshQuery* queries[4096];
+static const int MAX_POLYS = 256;
+static const int MAX_STEER_POINTS = 10;
+static const int MAX_SMOOTH = 256;
+static const float STEP_SIZE = 0.5f;
+static const float SLOP = 0.01f;
+
+extern "C" EXPORT_API int loadNavMesh(int map, const char *file);
+
+extern "C" EXPORT_API dtNavMeshQuery* getQuery(int map);
+
+extern "C" void EXPORT_API freeQuery(dtNavMeshQuery* query);
+
+extern "C" EXPORT_API int findPath(dtNavMeshQuery* query, float startx,
+    float starty, float startz, float endx, float endy, float endz,
+    int find_straight_path, float* resultPath);
+
+extern "C" EXPORT_API float* getPathPtr(int max_paths);
+
+extern "C" EXPORT_API void freePath(float* path);
+
+enum SamplePolyFlags
+{
+	SAMPLE_POLYFLAGS_WALK		= 0x01,		// Ability to walk (ground, grass, road)
+	SAMPLE_POLYFLAGS_SWIM		= 0x02,		// Ability to swim (water).
+	SAMPLE_POLYFLAGS_DOOR		= 0x04,		// Ability to move through doors.
+	SAMPLE_POLYFLAGS_JUMP		= 0x08,		// Ability to jump.
+	SAMPLE_POLYFLAGS_DISABLED	= 0x10,		// Disabled polygon
+	SAMPLE_POLYFLAGS_ALL		= 0xffff	// All abilities.
+};
+
+
+// Returns a random number [0..1)
+static float frand()
+{
+//	return ((float)(rand() & 0xffff)/(float)0xffff);
+	return (float)rand()/(float)RAND_MAX;
+}
+
+inline bool inRange(const float* v1, const float* v2, const float r, const float h)
+{
+	const float dx = v2[0] - v1[0];
+	const float dy = v2[1] - v1[1];
+	const float dz = v2[2] - v1[2];
+	return (dx*dx + dz*dz) < r*r && fabsf(dy) < h;
+}
+
+static bool getSteerTarget(dtNavMeshQuery* navQuery, const float* startPos, const float* endPos,
+						   const float minTargetDist,
+						   const dtPolyRef* path, const int pathSize,
+						   float* steerPos, unsigned char& steerPosFlag, dtPolyRef& steerPosRef,
+						   float* outPoints = 0, int* outPointCount = 0)							 
+{
+	// Find steer target.
+	static const int MAX_STEER_POINTS = 3;
+	float steerPath[MAX_STEER_POINTS*3];
+	unsigned char steerPathFlags[MAX_STEER_POINTS];
+	dtPolyRef steerPathPolys[MAX_STEER_POINTS];
+	int nsteerPath = 0;
+	navQuery->findStraightPath(startPos, endPos, path, pathSize,
+							   steerPath, steerPathFlags, steerPathPolys, &nsteerPath, MAX_STEER_POINTS);
+	if (!nsteerPath)
+		return false;
+
+	if (outPoints && outPointCount)
+	{
+		*outPointCount = nsteerPath;
+		for (int i = 0; i < nsteerPath; ++i)
+			dtVcopy(&outPoints[i*3], &steerPath[i*3]);
+	}
+
+
+	// Find vertex far enough to steer to.
+	int ns = 0;
+	while (ns < nsteerPath)
+	{
+		// Stop at Off-Mesh link or when point is further than slop away.
+		if ((steerPathFlags[ns] & DT_STRAIGHTPATH_OFFMESH_CONNECTION) ||
+			!inRange(&steerPath[ns*3], startPos, minTargetDist, 1000.0f))
+			break;
+		ns++;
+	}
+	// Failed to find good point to steer to.
+	if (ns >= nsteerPath)
+		return false;
+
+	dtVcopy(steerPos, &steerPath[ns*3]);
+	steerPos[1] = startPos[1];
+	steerPosFlag = steerPathFlags[ns];
+	steerPosRef = steerPathPolys[ns];
+
+	return true;
+}
+
+static int fixupCorridor(dtPolyRef* path, const int npath, const int maxPath,
+						 const dtPolyRef* visited, const int nvisited)
+{
+	int furthestPath = -1;
+	int furthestVisited = -1;
+
+	// Find furthest common polygon.
+	for (int i = npath-1; i >= 0; --i)
+	{
+		bool found = false;
+		for (int j = nvisited-1; j >= 0; --j)
+		{
+			if (path[i] == visited[j])
+			{
+				furthestPath = i;
+				furthestVisited = j;
+				found = true;
+			}
+		}
+		if (found)
+			break;
+	}
+
+	// If no intersection found just return current path. 
+	if (furthestPath == -1 || furthestVisited == -1)
+		return npath;
+
+	// Concatenate paths.	
+
+	// Adjust beginning of the buffer to include the visited.
+	const int req = nvisited - furthestVisited;
+	const int orig = rcMin(furthestPath+1, npath);
+	int size = rcMax(0, npath-orig);
+	if (req+size > maxPath)
+		size = maxPath-req;
+	if (size)
+		memmove(path+req, path+orig, size*sizeof(dtPolyRef));
+
+	// Store visited
+	for (int i = 0; i < req; ++i)
+		path[i] = visited[(nvisited-1)-i];				
+
+	return req+size;
+}

data/pathfinding/main.cpp

@@ -0,0 +1,39 @@
+#include "pathfind.h"
+
+int main (int argc, char* argv[]) {
+
+  int find_straight_path = 1;
+  float *newPath;
+  newPath = getPathPtr(MAX_SMOOTH);
+
+  //const char *file = "/home2/chris/game_machine/server/detour/meshes/terrain.bin";
+  const char *file = "/home2/chris/game_machine/data/meshes/all_tiles_navmesh.bin";
+
+
+  int loadRes = loadNavMesh(1,file);
+  fprintf (stderr, "loadNavMesh returned %d\n", loadRes);
+  dtNavMeshQuery* query = getQuery(1);
+
+  if (loadRes == 1) {
+    for (int j = 0; j < 1; ++j) {
+      for (int i = 0; i < 1; ++i) {
+        //int res = findPath(query, 563.0, 0.2, 504.0, 509.0, 0.2, 528.0,
+        int res = findPath(query, 563.0f, 0.2f, 504.0f, 563.0f, 0.2f, 541.0f,
+            find_straight_path, newPath);
+        fprintf (stderr, "findPath returned %d\n", res);
+        for (int i = 0; i < res; ++i) {
+          //fprintf (stderr, "%d\n", i);
+          const float* v = &newPath[i*3];
+          fprintf (stderr, "%f.%f.%f\n", v[0], v[1], v[2]);
+        }
+      }
+    }
+  }
+
+  fprintf (stderr, "endLoop\n");
+  freePath(newPath);
+  fprintf (stderr, "freePath\n");
+  freeQuery(query);
+  fprintf (stderr, "freeQuery\n");
+  return 1;
+}

data/pathfinding/mesh_loader.cpp

@@ -0,0 +1,108 @@
+#include <string>
+#include <cstring>
+#include <stdlib.h>
+#include <stdio.h>
+#include "Recast.h"
+#include "DetourCommon.h"
+#include "DetourNavMesh.h"
+#include "DetourNavMeshBuilder.h"
+#include "DetourNavMeshQuery.h"
+
+#include "mesh_loader.h"
+
+
+void save_navmesh(const char* path, const dtNavMesh* mesh) {
+	if (!mesh) return;
+
+	FILE* fp = fopen(path, "wb");
+	if (!fp)
+		return;
+
+	// Store header.
+	NavMeshSetHeader header;
+	header.magic = NAVMESHSET_MAGIC;
+	header.version = NAVMESHSET_VERSION;
+	header.numTiles = 0;
+	for (int i = 0; i < mesh->getMaxTiles(); ++i)
+	{
+		const dtMeshTile* tile = mesh->getTile(i);
+		if (!tile || !tile->header || !tile->dataSize) continue;
+		header.numTiles++;
+	}
+	memcpy(&header.params, mesh->getParams(), sizeof(dtNavMeshParams));
+	fwrite(&header, sizeof(NavMeshSetHeader), 1, fp);
+
+	// Store tiles.
+	for (int i = 0; i < mesh->getMaxTiles(); ++i)
+	{
+		const dtMeshTile* tile = mesh->getTile(i);
+		if (!tile || !tile->header || !tile->dataSize) continue;
+
+		NavMeshTileHeader tileHeader;
+		tileHeader.tileRef = mesh->getTileRef(tile);
+		tileHeader.dataSize = tile->dataSize;
+		fwrite(&tileHeader, sizeof(tileHeader), 1, fp);
+
+		fwrite(tile->data, tile->dataSize, 1, fp);
+	}
+
+	fclose(fp);
+}
+
+dtNavMesh* load_navmesh(const char* path)
+{
+	FILE* fp = fopen(path, "rb");
+	if (!fp) return 0;
+
+	// Read header.
+	NavMeshSetHeader header;
+	fread(&header, sizeof(NavMeshSetHeader), 1, fp);
+	if (header.magic != NAVMESHSET_MAGIC)
+	{
+		fclose(fp);
+   fprintf (stderr, "Bad magic %d\n", header.magic);
+		return 0;
+	}
+
+	if (header.version != NAVMESHSET_VERSION)
+	{
+		fclose(fp);
+   fprintf (stderr, "Bad version %d\n", header.version);
+		return 0;
+	}
+
+	dtNavMesh* mesh = dtAllocNavMesh();
+	if (!mesh)
+	{
+		fclose(fp);
+		return 0;
+	}
+	dtStatus status = mesh->init(&header.params);
+	if (dtStatusFailed(status))
+	{
+		fclose(fp);
+		return 0;
+	}
+
+	// Read tiles.
+	for (int i = 0; i < header.numTiles; ++i)
+	{
+		NavMeshTileHeader tileHeader;
+		fread(&tileHeader, sizeof(tileHeader), 1, fp);
+		if (!tileHeader.tileRef || !tileHeader.dataSize)
+			break;
+
+		unsigned char* data = (unsigned char*)dtAlloc(tileHeader.dataSize, DT_ALLOC_PERM);
+		if (!data) break;
+		memset(data, 0, tileHeader.dataSize);
+		fread(data, tileHeader.dataSize, 1, fp);
+
+   //fprintf (stderr, "Adding tile %s\n", data);
+		mesh->addTile(data, tileHeader.dataSize, DT_TILE_FREE_DATA, tileHeader.tileRef, 0);
+	}
+
+	fclose(fp);
+
+	return mesh;
+}
+