game_machine 0.0.8

data/pathfinding/pathfind.cpp

@@ -0,0 +1,174 @@
+#include "pathfind.h"
+
+extern "C" EXPORT_API int loadNavMesh(int map, const char *file) {
+  if (meshes[map] != 0) {
+    return 0;
+  }
+  dtNavMesh* navMesh;
+  navMesh = load_navmesh(file);
+  meshes[map] = navMesh;
+  return 1;
+}
+
+extern "C" EXPORT_API dtNavMeshQuery* getQuery(int map) {
+  if (meshes[map] == 0) {
+    fprintf (stderr, "Unable to load navmesh\n");
+    return 0;
+  }
+
+  dtNavMeshQuery* query = dtAllocNavMeshQuery();
+  query->init(meshes[map], 4096);
+  return query;
+}
+
+extern "C" void EXPORT_API freeQuery(dtNavMeshQuery* query) {
+  dtFreeNavMeshQuery(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) {
+
+  if (query == NULL) {
+    return P_QUERY_NOT_FOUND;
+  }
+
+  float m_spos[3] = {startx,starty,startz};
+  float m_epos[3] = {endx,endy,endz};
+
+
+  dtPolyRef m_polys[MAX_POLYS];
+
+  dtQueryFilter m_filter;
+  float straight[MAX_POLYS*3];
+  int straightPathCount = 0;
+  float polyPickExt[3] = {40,40,40};
+  int m_npolys = 0;
+
+  float m_steerPoints[MAX_STEER_POINTS*3];
+  int m_steerPointCount;
+  float m_smoothPath[MAX_SMOOTH*3];
+  int m_nsmoothPath = 0;
+
+  m_filter.setIncludeFlags(SAMPLE_POLYFLAGS_ALL ^ SAMPLE_POLYFLAGS_DISABLED);
+  m_filter.setExcludeFlags(0);
+
+  dtPolyRef m_startRef, m_endRef;
+
+  dtStatus res;
+
+  res = query->findNearestPoly(m_spos, polyPickExt, &m_filter, &m_startRef, 0);
+  if (res == DT_SUCCESS) {
+    if (m_startRef == 0) {
+      return P_NO_START_POLY;
+    }
+  } else {
+    return P_NO_START_POLY;
+  }
+
+  res = query->findNearestPoly(m_epos, polyPickExt, &m_filter, &m_endRef, 0);
+  if (res == DT_SUCCESS) {
+    if (m_endRef == 0) {
+      return P_NO_END_POLY;
+    }
+  } else {
+    return P_NO_END_POLY;
+  }
+
+  res = query->findPath(m_startRef, m_endRef, m_spos, m_epos, &m_filter, m_polys, &m_npolys, MAX_POLYS);
+  if (res != DT_SUCCESS) {
+    return P_PATH_NOT_FOUND;
+  }
+
+
+  if (find_straight_path == 0) {
+    dtPolyRef polys[MAX_POLYS];
+    memcpy(polys, m_polys, sizeof(dtPolyRef)*m_npolys); 
+    int npolys = m_npolys;
+
+    float iterPos[3], targetPos[3];
+    query->closestPointOnPoly(m_startRef, m_spos, iterPos,0);
+    query->closestPointOnPoly(polys[npolys-1], m_epos, targetPos,0);
+
+    m_nsmoothPath = 0;
+    
+    dtVcopy(&m_smoothPath[m_nsmoothPath*3], iterPos);
+    m_nsmoothPath++;
+
+    while (npolys && m_nsmoothPath < MAX_SMOOTH) {
+      // Find location to steer towards.
+      float steerPos[3];
+      unsigned char steerPosFlag;
+      dtPolyRef steerPosRef;
+
+      if (!getSteerTarget(query, iterPos, targetPos, SLOP, polys, npolys, steerPos, steerPosFlag, steerPosRef)) {
+        break;
+      }
+
+      bool endOfPath = (steerPosFlag & DT_STRAIGHTPATH_END) ? true : false;
+      bool offMeshConnection = (steerPosFlag & DT_STRAIGHTPATH_OFFMESH_CONNECTION) ? true : false;
+
+      // Find movement delta.
+      float delta[3], len;
+      dtVsub(delta, steerPos, iterPos);
+      len = dtSqrt(dtVdot(delta,delta));
+      // If the steer target is end of path or off-mesh link, do not move past the location.
+      if ((endOfPath || offMeshConnection) && len < STEP_SIZE) {
+        len = 1;
+      } else {
+        len = STEP_SIZE / len;
+      }
+
+      float moveTgt[3];
+      dtVmad(moveTgt, iterPos, delta, len);
+
+      // Move
+      float result[3];
+      dtPolyRef visited[16];
+      int nvisited = 0;
+      query->moveAlongSurface(polys[0], iterPos, moveTgt, &m_filter, result, visited, &nvisited, 16);
+
+      npolys = fixupCorridor(polys, npolys, MAX_POLYS, visited, nvisited);
+      float h = 0;
+      query->getPolyHeight(polys[0], result, &h);
+      result[1] = h;
+      dtVcopy(iterPos, result);
+
+      if (endOfPath && inRange(iterPos, steerPos, SLOP, 1.0f)) {
+        // Reached end of path.
+        fprintf (stderr, "End of path reached\n");
+        dtVcopy(iterPos, targetPos);
+        if (m_nsmoothPath < MAX_SMOOTH) {
+          dtVcopy(&m_smoothPath[m_nsmoothPath*3], iterPos);
+          m_nsmoothPath++;
+        }
+        break;
+      }
+
+      if (m_nsmoothPath < MAX_SMOOTH) {
+        dtVcopy(&m_smoothPath[m_nsmoothPath*3], iterPos);
+        m_nsmoothPath++;
+      }
+    }
+
+    memcpy(resultPath, m_smoothPath, sizeof(float)*3*m_nsmoothPath);
+    return m_nsmoothPath;
+  }
+
+
+  query->findStraightPath(m_spos, m_epos, m_polys, m_npolys, straight, 0, 0, &straightPathCount, MAX_POLYS);
+  memcpy(resultPath, straight, sizeof(float)*3*straightPathCount);
+  return straightPathCount;
+}
+
+extern "C" EXPORT_API float* getPathPtr(int max_paths) {
+  float *path;
+  path = new float[max_paths*3];
+  return path;
+}
+
+extern "C" EXPORT_API void freePath(float* path) {
+  delete [] path;
+}
+
+

data/pathfinding/pathfinder.cs

@@ -0,0 +1,66 @@
+
+using UnityEngine;
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace pathfinder
+{
+	public class Pathfinder
+	{
+		public static int maxPaths = 256;
+		private IntPtr query;
+		private bool hasQuery = false;
+
+
+		public Pathfinder (int navmeshId, string navmeshPath)
+		{
+			int navmeshLoadRes = loadNavMesh (navmeshId, navmeshPath);
+			if (navmeshLoadRes == 1 || navmeshLoadRes == 0) {
+				query = getQuery (navmeshId);
+				hasQuery = true;
+			} else {
+				Debug.Log (string.Format ("loadNavMesh returned {0}",navmeshLoadRes));
+			}
+		}
+
+		public Vector3[] FindPath (Vector3 start, Vector3 end, bool straight = false)
+		{
+			if (hasQuery == false) {
+				return null;
+			}
+			int straightPath = straight ? 1 : 0;
+			float[,] resultPath = new float[Pathfinder.maxPaths, 3];
+			int numPaths = findPath (query, start.z, start.y, start.x, end.z, end.y, end.x, straightPath, resultPath);
+			
+			Vector3[] paths = new Vector3[numPaths];
+			for (int i = 0; i < numPaths; i++) {
+				paths [i] = new Vector3 (resultPath [i, 2], resultPath [i, 1], resultPath [i, 0]);
+			}
+			return paths;
+		}
+
+		[DllImport("detour_path")]
+		public static extern IntPtr getQuery (int map);
+
+		[DllImport("detour_path")]
+		public static extern void freeQuery (IntPtr query);
+
+		[DllImport("detour_path")]
+		public static extern int loadNavMesh (int map, string filename);
+
+		[DllImport("detour_path")]
+		public static extern int findPath (
+            IntPtr query,
+            float startx,
+            float starty,
+            float startz,
+            float endx,
+            float endy,
+            float endz,
+            int find_straight_path,
+            [In, Out]  float[,] resultPath
+            );
+	}
+}

data/pathfinding/premake4.lua

@@ -0,0 +1,109 @@
+local action = _ACTION or ""
+local todir = "build/"
+
+solution "pathfinding"
+	configurations { 
+		"debug",
+		"release"
+	}
+	location (todir)
+
+	-- extra warnings, no exceptions or rtti
+	flags { 
+		"ExtraWarnings",
+		"NoExceptions",
+		"NoRTTI"
+	}
+
+	-- debug configs
+	configuration "debug*"
+		defines { "DEBUG" }
+		flags { "Symbols" }
+
+		targetdir ( "build/" .. action .. "/debug" )
+	-- linux library cflags and libs
+	configuration { "linux", "gmake" }
+		buildoptions { 
+      "-fpic"
+		}
+		linkoptions { 
+      "-fpic"
+		}
+
+	-- windows library cflags and libs
+	configuration { "windows" }
+ 
+ 	-- release configs
+	configuration "release*"
+		defines { "NDEBUG" }
+		flags { "Optimize" }
+		targetdir ( "build/" .. action .. "/release" )
+
+	-- windows specific
+	configuration "windows"
+		defines { "WIN32", "_WINDOWS", "_CRT_SECURE_NO_WARNINGS" }
+
+  project "Detour"
+	language "C++"
+	kind "StaticLib"
+	includedirs { 
+		"recastnavigation/Detour/Include" 
+	}
+	files { 
+		"recastnavigation/Detour/Include/*.h", 
+		"recastnavigation/Detour/Source/*.cpp" 
+	}
+	targetdir (todir .. "/lib")
+  configuration "not windows"
+    postbuildcommands { "cp lib/libDetour.a ../bin" }
+
+project "detour_path"
+	language "C++"
+	kind "SharedLib"
+	includedirs { 
+		"recastnavigation/Detour/Include",
+		"recastnavigation/Recast/Include",
+		"include"
+	}
+
+  libdirs {todir .. "lib" }
+	files { 
+		"recastnavigation/Detour/Include/*.h", 
+		"recastnavigation/Recast/Include/Recast.h", 
+		"recastnavigation/Detour/Source/*.cpp",
+		"include/*.h",
+		"*.cpp"
+	}
+	targetdir (todir .. "/lib")
+
+	-- project dependencies
+	links { 
+		"Detour"
+	}
+  configuration "not windows"
+    postbuildcommands { "cp lib/libdetour_path.so ../bin" }
+
+project "pathfind_test"
+	language "C++"
+	kind "ConsoleApp"
+	includedirs { 
+		"recastnavigation/Detour/Include",
+		"recastnavigation/Recast/Include", 
+		"include"
+	}
+  libdirs {todir .. "lib" }
+	files { 
+		"recastnavigation/Detour/Include/*.h", 
+		"recastnavigation/Recast/Include/Recast.h", 
+		"recastnavigation/Detour/Source/*.cpp",
+		"include/*.h",
+		"*.cpp"
+	}
+	targetdir (todir .. "/bin")
+	links { 
+		"Detour",
+    "detour_path"
+	}
+  configuration "not windows"
+    postbuildcommands { "cp bin/pathfind_test ../bin" }
+

data/script/server.sh

@@ -0,0 +1,109 @@
+#!/bin/bash
+#export LD_PRELOAD=/usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/libjsig.so
+SCRIPT_PATH=`dirname "$0"`; SCRIPT_PATH=`eval "cd \"$SCRIPT_PATH\" && pwd"`
+SERVER_HOME=$SCRIPT_PATH/../
+SERVER_LOG=$SERVER_HOME/log
+SERVER_TMP=$SERVER_HOME/tmp
+
+mkdir -p $SERVER_LOG
+mkdir -p $SERVER_TMP
+
+cd $SERVER_HOME
+
+#unset GEM_HOME
+#unset BUNDLE_GEMFILE
+#unset GEM_PATH
+CWD=$(pwd)
+APP_NAME=game_machine
+
+ERR_FILE=$SERVER_HOME/log/game_machine.stderr
+OUT_FILE=$SERVER_HOME/log/game_machine.stdout
+
+PID_PATH=$SERVER_HOME/tmp
+PID_FILE=$PID_PATH/game_machine.pid
+mkdir -p $PID_PATH
+ARGV="$2"
+
+start_daemon() {
+if [ -e "$PID_FILE" ]; then
+  echo "PID file already exists."
+  exit 1
+else
+  if [ -e "./bin/game_machine" ]; then
+    echo "Starting local $APP_NAME with args $ARGV."
+    nohup ./bin/game_machine s -s "$ARGV" 2>> "$ERR_FILE" >> "$OUT_FILE" &
+  else
+    echo "Starting $APP_NAME with args $ARGV."
+    nohup game_machine server "$ARGV" 2>> "$ERR_FILE" >> "$OUT_FILE" &
+  fi
+  echo $! > "$PID_FILE"
+  exit $?
+fi
+}
+
+stop_daemon() {
+if [ -e "$PID_FILE" ]; then
+  echo "Stopping $APP_NAME."
+  PID=`cat $PID_FILE`
+  for i in 1 2 3 4 5 6 7 8 9 10
+  do
+    if [ "$i" -gt 2 ] ;then
+      echo "Using kill -9"
+      kill -9 $PID 2> /dev/null
+    else
+      kill -TERM $PID 2> /dev/null
+    fi
+    echo "try $i"
+    if [ `ps $PID 2> /dev/null | grep $PID | wc -l` -eq 1 ]; then
+      echo "$APP_NAME still running"
+    else
+      echo "$APP_NAME killed"
+      break;
+    fi
+    sleep 1
+  done
+  rm $PID_FILE
+else
+  echo "PID file not found."
+  return 1
+fi
+}
+
+check_status() {
+  if [ -e "$PID_FILE" ]; then
+    PID=`cat $PID_FILE`
+    if [ `ps $PID 2> /dev/null | grep $PID | wc -l` -eq 1 ]; then
+      echo "$APP_NAME is running"
+      return 0
+    else
+      echo "$APP_NAME is not running (stale pidfile)"
+      return 3
+    fi
+  fi
+
+  echo "$APP_NAME is not running"
+  return 3
+}
+
+
+case $1 in
+  start)
+    start_daemon
+  ;;
+  stop)
+    stop_daemon
+  ;;
+  status)
+    check_status
+  ;;
+  restart)
+    stop_daemon
+    sleep 1
+    start_daemon
+  ;;
+  *)
+    echo "usage: $0 start|stop|restart|status"
+    exit 1
+  ;;
+esac
+