diff --git a/source/SkyXEngine_Build/SkyXEngine_Build.cpp b/source/SkyXEngine_Build/SkyXEngine_Build.cpp
index 34613266fea9ccbcca3af4c1ebeb619d8d7db466..0c1a37113e461f39731de45ef3e3e3ee3b607b0a 100644
--- a/source/SkyXEngine_Build/SkyXEngine_Build.cpp
+++ b/source/SkyXEngine_Build/SkyXEngine_Build.cpp
@@ -36,9 +36,13 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLin
 		//bEnt->setKV("origin", "14.90 0.36 25.56");
 		bEnt->setKV("origin", "0 0 0");
 	}*/
-	CBaseEntity* bEnt = SXGame_CreateEntity("npc_zombie");
-	bEnt->setFlags(bEnt->getFlags() | EF_EXPORT | EF_LEVEL);
-	bEnt->setKV("origin", "0 0 0");
+
+	for (int i = 0; i < 100; ++i)
+	{
+		CBaseEntity* bEnt = SXGame_CreateEntity("npc_zombie");
+		bEnt->setFlags(bEnt->getFlags() | EF_EXPORT | EF_LEVEL);
+		bEnt->setKV("origin", "0 1 0");
+	}
 	/*for (int i = 0; i < 10; ++i)
 	{
 	for (int k = 0; k < 10; ++k)
diff --git a/source/aigrid/aigrid.cpp b/source/aigrid/aigrid.cpp
index afc23a97b8e12d67d08f3a318b42ac9c4b4b1deb..c9533b7e330460fb1c0575a58db0abb17b574d54 100644
--- a/source/aigrid/aigrid.cpp
+++ b/source/aigrid/aigrid.cpp
@@ -51,6 +51,10 @@ AIGrid::AIGrid()
 	IDPS = -1;
 
 	UseGraphics = false;
+
+	m_iLastWait = 0;
+
+	m_aQueueFind.resize(1024);
 }
 
 AIGrid::~AIGrid()
@@ -2718,34 +2722,12 @@ ID AIGrid::GraphPointGetNear(ID beginq, ID endq)
 	return -1;
 }
 
-bool AIGrid::GridFindPath(ID beginq, ID endq)
+bool AIGrid::gridFindPath(ID idQueueObject)
 {
-	if (ArrQuads.size() <= 1)
-	{
-		LibReport(REPORT_MSG_LEVEL_WARNING, "AI grid not found\n");
-		return false;
-	}
-
-	AIGRID_QUAD_PRECOND(beginq, false);
-	AIGRID_QUAD_PRECOND(endq, false);
-
-	if (CountSplits == 0)
-	{
-		LibReport(REPORT_MSG_LEVEL_WARNING, "can not find path, because AI grid is not validate splits\n");
-		return false;
-	}
-
-	if (ArrQuads[beginq]->IdSplit != ArrQuads[endq]->IdSplit)
-	{
-		LibReport(REPORT_MSG_LEVEL_WARNING, "quads in different splits, path not found\n");
-		return false;
-	}
-
-	if (beginq == endq)
-	{
-		LibReport(REPORT_MSG_LEVEL_WARNING, "beginq == endq, path not found\n");
-		return false;
-	}
+	ID idStart = m_aQueueFind[idQueueObject].m_idStart;
+	ID idFinish = m_aQueueFind[idQueueObject].m_idFinish;
+	Array<ID> &aQuads = m_aQueueFind[idQueueObject].m_aQuads;
+	aQuads.clearFast();
 
 	int tmpcost = AIGRID_COST_DIAGONAL;
 	int cycnum = 0;
@@ -2761,7 +2743,7 @@ bool AIGrid::GridFindPath(ID beginq, ID endq)
 	memset(&(ArrParentIDs[0]), -1, ArrParentIDs.size() * sizeof(ID));
 	memset(&(ArrCostQuads[0]), 0, ArrCostQuads.size() * sizeof(CostAIQuad));
 	memset(&(ArrCloseIDs[0]), 0, ArrCloseIDs.size() * sizeof(bool));
-	ArrPathIDs.clear();
+	//ArrPathIDs.clear();
 
 	bool IsFindPath = false;
 
@@ -2771,12 +2753,12 @@ bool AIGrid::GridFindPath(ID beginq, ID endq)
 	for (cycnum = 0; cycnum<8; cycnum++)
 	{
 		if (
-			ArrQuads[beginq]->Arr[cycnum] != -1)
+			ArrQuads[idStart]->Arr[cycnum] != -1)
 		{
-			if (ArrQuads[beginq]->Arr[cycnum] == endq)
+			if (ArrQuads[idStart]->Arr[cycnum] == idFinish)
 			{
-				ArrPathIDs.push_back(endq);
-				ArrPathIDs.push_back(ArrQuads[beginq]->Arr[cycnum]);
+				aQuads.push_back(idFinish);
+				aQuads.push_back(ArrQuads[idStart]->Arr[cycnum]);
 				return true;
 			}
 			tmpcost = AIGRID_COST_DIAGONAL;
@@ -2784,28 +2766,28 @@ bool AIGrid::GridFindPath(ID beginq, ID endq)
 			if (cycnum == 1 || cycnum == 3 || cycnum == 4 || cycnum == 6)
 				tmpcost = AIGRID_COST_DIRECT;
 
-			if (QuadGetState(ArrQuads[beginq]->Arr[cycnum]) != AIQUAD_STATE::AIQUAD_STATE_FREE)
+			if (QuadGetState(ArrQuads[idStart]->Arr[cycnum]) != AIQUAD_STATE::AIQUAD_STATE_FREE)
 			{
-				if (QuadGetState(ArrQuads[beginq]->Arr[cycnum]) == AIQUAD_STATE::AIQUAD_STATE_TEMPBUSY)
+				if (QuadGetState(ArrQuads[idStart]->Arr[cycnum]) == AIQUAD_STATE::AIQUAD_STATE_TEMPBUSY)
 					tmpcost += AIGRID_COSTADD_TEMPBUSY;
-				else if (QuadGetState(ArrQuads[beginq]->Arr[cycnum]) == AIQUAD_STATE::AIQUAD_STATE_BUSY)
+				else if (QuadGetState(ArrQuads[idStart]->Arr[cycnum]) == AIQUAD_STATE::AIQUAD_STATE_BUSY)
 					tmpcost += AIGRID_COSTADD_BUSY;
 			}
 			else
 				tmpaddcost = 0;
 
-			ArrParentIDs[ArrQuads[beginq]->Arr[cycnum]] = beginq;
-			ArrCostQuads[ArrQuads[beginq]->Arr[cycnum]].G = tmpcost;
-			ArrCostQuads[ArrQuads[beginq]->Arr[cycnum]].H = CalcHCost(ArrQuads[beginq]->Arr[cycnum], endq);
+			ArrParentIDs[ArrQuads[idStart]->Arr[cycnum]] = idStart;
+			ArrCostQuads[ArrQuads[idStart]->Arr[cycnum]].G = tmpcost;
+			ArrCostQuads[ArrQuads[idStart]->Arr[cycnum]].H = CalcHCost(ArrQuads[idStart]->Arr[cycnum], idFinish);
 
-			ArrCostQuads[ArrQuads[beginq]->Arr[cycnum]].F = ArrCostQuads[ArrQuads[beginq]->Arr[cycnum]].G + ArrCostQuads[ArrQuads[beginq]->Arr[cycnum]].H + tmpaddcost;
+			ArrCostQuads[ArrQuads[idStart]->Arr[cycnum]].F = ArrCostQuads[ArrQuads[idStart]->Arr[cycnum]].G + ArrCostQuads[ArrQuads[idStart]->Arr[cycnum]].H + tmpaddcost;
 
-			ArrIDsInOpen[ArrQuads[beginq]->Arr[cycnum]] = AddInOpenList(ArrQuads[beginq]->Arr[cycnum]);
+			ArrIDsInOpen[ArrQuads[idStart]->Arr[cycnum]] = AddInOpenList(ArrQuads[idStart]->Arr[cycnum]);
 		}
 	}
 
 	//стартовую точку помещаем в закрытый
-	ArrCloseIDs[beginq] = true;
+	ArrCloseIDs[idStart] = true;
 
 	bool isfind = false;
 	ID tmpsmallF = -1;
@@ -2856,7 +2838,7 @@ bool AIGrid::GridFindPath(ID beginq, ID endq)
 					if (!ArrCloseIDs[tmpcurridquad])
 					{
 						//если сосденяя точка конечная точка то мы нашли путь!!!
-						if (tmpcurridquad == endq)
+						if (tmpcurridquad == idFinish)
 						{
 							isfind = true;
 							break;
@@ -2866,7 +2848,7 @@ bool AIGrid::GridFindPath(ID beginq, ID endq)
 						if (cycnum == 1 || cycnum == 3 || cycnum == 4 || cycnum == 6)
 							tmpcost = AIGRID_COST_DIRECT;
 
-						tmphcost = CalcHCost(tmpcurridquad, endq);
+						tmphcost = CalcHCost(tmpcurridquad, idFinish);
 
 						if (QuadGetState(tmpcurridquad) != AIQUAD_STATE::AIQUAD_STATE_FREE && tmphcost / 10 < AIGRID_QUADSCOUNT_BUSY)
 						{
@@ -2895,7 +2877,7 @@ bool AIGrid::GridFindPath(ID beginq, ID endq)
 						{
 							ArrParentIDs[tmpcurridquad] = tmpsmallF;
 							ArrCostQuads[tmpcurridquad].G = ArrCostQuads[tmpsmallF].G + tmpcost;
-							ArrCostQuads[tmpcurridquad].H = tmphcost;// CalcHCost(tmpcurridquad, endq);
+							ArrCostQuads[tmpcurridquad].H = tmphcost;// CalcHCost(tmpcurridquad, idFinish);
 							ArrCostQuads[tmpcurridquad].F = ArrCostQuads[tmpcurridquad].G + ArrCostQuads[tmpcurridquad].H;
 							ArrIDsInOpen[tmpcurridquad] = AddInOpenList(tmpcurridquad);
 						}
@@ -2913,16 +2895,16 @@ bool AIGrid::GridFindPath(ID beginq, ID endq)
 			if (isfind)
 			{
 				IsFindPath = true;
-				ArrPathIDs.push_back(endq);
-				ArrPathIDs.push_back(tmpsmallF);
+				aQuads.push_back(idFinish);
+				aQuads.push_back(tmpsmallF);
 				ID tmpquad = tmpsmallF;
 				ID tmpparent = -1;
 				/*ArrColor[tmpsmallF] = D3DCOLOR_ARGB(200,0,255,0);
-				ArrColor[beginq] = D3DCOLOR_ARGB(255, 0, 255, 0);
-				ArrColor[endq] = D3DCOLOR_ARGB(255, 0, 255, 0);*/
-				while ((tmpparent = ArrParentIDs[tmpquad]) != -1 && beginq != tmpparent)
+				ArrColor[idStart] = D3DCOLOR_ARGB(255, 0, 255, 0);
+				ArrColor[idFinish] = D3DCOLOR_ARGB(255, 0, 255, 0);*/
+				while ((tmpparent = ArrParentIDs[tmpquad]) != -1 && idStart != tmpparent)
 				{
-					ArrPathIDs.push_back(tmpparent);
+					aQuads.push_back(tmpparent);
 					//ArrColor[tmpparent] = D3DCOLOR_ARGB(128, 0, 255, 0);
 					tmpquad = tmpparent;
 				}
@@ -2939,25 +2921,34 @@ bool AIGrid::GridFindPath(ID beginq, ID endq)
 	return IsFindPath;
 }
 
-UINT AIGrid::GridGetSizePath()
+int AIGrid::gridGetSizePath(ID idQueueObject)
 {
-	return ArrPathIDs.size();
+	if (idQueueObject >= 0 && idQueueObject < m_aQueueFind.size() && m_aQueueFind[idQueueObject].m_state == QUEUE_OBJ_STATE_COMPLITE)
+		return m_aQueueFind[idQueueObject].m_aQuads.size();
+
+	return -1;
 }
 
-bool AIGrid::GridGetPath(ID * pmem, UINT count, bool reverse)
+bool AIGrid::gridGetPath(ID idQueueObject, ID *pMemory, UINT uiCount, bool canReverse)
 {
-	if (pmem)
+	if (idQueueObject >= 0 && idQueueObject < m_aQueueFind.size() && m_aQueueFind[idQueueObject].m_state == QUEUE_OBJ_STATE_COMPLITE)
 	{
-		if (!reverse)
-			memcpy(pmem, &(ArrPathIDs[0]), count * sizeof(ID));
-		else
+		if (pMemory)
 		{
-			for (int i = 0, il = ArrPathIDs.size(); i < il; ++i)
+			if (!canReverse)
+				memcpy(pMemory, &(m_aQueueFind[idQueueObject].m_aQuads[0]), uiCount * sizeof(ID));
+			else
 			{
-				pmem[i] = ArrPathIDs[(il - 1) - i];
+				for (int i = 0, il = m_aQueueFind[idQueueObject].m_aQuads.size(); i < il; ++i)
+				{
+					pMemory[i] = m_aQueueFind[idQueueObject].m_aQuads[(il - 1) - i];
+				}
 			}
+			m_aQueueFind[idQueueObject].m_aQuads.clearFast();
+			m_aQueueFind[idQueueObject].m_state = QUEUE_OBJ_STATE_IDLE;
+			m_aQueueFind[idQueueObject].m_idStart = m_aQueueFind[idQueueObject].m_idFinish = -1;
+			return true;
 		}
-		return true;
 	}
 
 	return false;
@@ -2978,4 +2969,119 @@ void AIGrid::GridSetColorArr(const ID * pmem, DWORD color, UINT count)
 void AIGrid::GridSetNullColor()
 {
 	memset(&(ArrColor[0]), 0, sizeof(uint32_t)* ArrColor.size());
+}
+
+//##########################################################################
+
+ID AIGrid::getQueueWaiting()
+{
+	for (int i = m_iLastWait, il = m_aQueueFind.size(); i < il; ++i)
+	{
+		if (m_aQueueFind[i].m_state == QUEUE_OBJ_STATE_WAIT)
+		{
+			m_iLastWait = i;
+			return i;
+		}
+	}
+
+	m_iLastWait = 0;
+
+	for (int i = m_iLastWait, il = m_aQueueFind.size(); i < il; ++i)
+	{
+		if (m_aQueueFind[i].m_state == QUEUE_OBJ_STATE_WAIT)
+		{
+			m_iLastWait = i;
+			return i;
+		}
+	}
+
+	if (m_iLastWait >= m_aQueueFind.size() - 1)
+		m_iLastWait = 0;
+
+	return -1;
+}
+
+ID AIGrid::getQueueIdle()
+{
+	for (int i = m_iLastWait, il = m_aQueueFind.size(); i < il; ++i)
+	{
+		if (m_aQueueFind[i].m_state == QUEUE_OBJ_STATE_IDLE)
+			return i;
+	}
+
+	for (int i = 0, il = m_iLastWait; i < il; ++i)
+	{
+		if (m_aQueueFind[i].m_state == QUEUE_OBJ_STATE_IDLE)
+			return i;
+	}
+
+	m_aQueueFind.push_back(CQueueObject());
+
+	return m_aQueueFind.size() - 1;
+}
+
+ID AIGrid::gridQueryFindPath(ID idStart, ID idFinish)
+{
+	if (ArrQuads.size() <= 1)
+	{
+		LibReport(REPORT_MSG_LEVEL_WARNING, "AI grid not found\n");
+		return -1;
+	}
+
+	if (idStart < 0 || ArrQuads.size() <= idStart)
+	{ 
+		LibReport(REPORT_MSG_LEVEL_WARNING, " %s - unresolved index '%d' of quad, sxaigrid\n", GEN_MSG_LOCATION, idStart);
+		return -1; 
+	}
+
+	if (idFinish < 0 || ArrQuads.size() <= idFinish)
+	{
+		LibReport(REPORT_MSG_LEVEL_WARNING, " %s - unresolved index '%d' of quad, sxaigrid\n", GEN_MSG_LOCATION, idFinish);
+		return -1;
+	}
+
+	if (CountSplits == 0)
+	{
+		LibReport(REPORT_MSG_LEVEL_WARNING, "can not find path, because AI grid is not validate splits\n");
+		return -1;
+	}
+
+	if (ArrQuads[idStart]->IdSplit != ArrQuads[idFinish]->IdSplit)
+	{
+		LibReport(REPORT_MSG_LEVEL_WARNING, "quads in different splits, path not found\n");
+		return -1;
+	}
+
+	if (idStart == idFinish)
+	{
+		LibReport(REPORT_MSG_LEVEL_WARNING, "idStart == idFinish, path not found\n");
+		return -1;
+	}
+
+	ID idQueueObject = getQueueIdle();
+
+	m_aQueueFind[idQueueObject].m_aQuads.clearFast();
+	m_aQueueFind[idQueueObject].m_state = QUEUE_OBJ_STATE_WAIT;
+	m_aQueueFind[idQueueObject].m_idStart = idStart;
+	m_aQueueFind[idQueueObject].m_idFinish = idFinish;
+
+	return idQueueObject;
+}
+
+void AIGrid::gridQueryFindPathUpdate(UINT uiLimitMls)
+{
+	UINT uiStartTime = GetTickCount();
+
+	while ((GetTickCount() - uiStartTime < uiLimitMls) || uiLimitMls == 0)
+	{
+		ID idQueueObject = getQueueWaiting();
+
+		if (idQueueObject >= 0)
+		{
+			if (gridFindPath(idQueueObject))
+				m_aQueueFind[idQueueObject].m_state = QUEUE_OBJ_STATE_COMPLITE;
+			else
+				m_aQueueFind[idQueueObject].m_state = QUEUE_OBJ_STATE_ERROR;
+		}
+	}
 }
\ No newline at end of file
diff --git a/source/aigrid/aigrid.h b/source/aigrid/aigrid.h
index 9193ec82fe280bdf6e727dda0c20317b5999b2f7..d735f72a538ec0860efb5ffde87d44636d109d13 100644
--- a/source/aigrid/aigrid.h
+++ b/source/aigrid/aigrid.h
@@ -208,9 +208,12 @@ public:
 	void GridSetMarkSplits(bool mark);						//выделение сплитов
 	bool GridGetMarkSplits();								//возвращает состояние выделения сплитов
 	UINT GridGetCountQuads();								//возвращает количество квадов в сетке
-	bool GridFindPath(ID beginq, ID endq);							//поиск пути, (beginq,beginq]
-	UINT GridGetSizePath();									//размер найденного пути в количестве квадратов
-	bool GridGetPath(ID * pmem, UINT count, bool reverse);	//запись найденного пути в уже выделенную память
+	
+	int gridGetSizePath(ID idQueueObject);									//размер найденного пути в количестве квадратов
+	bool gridGetPath(ID idQueueObject, ID *pMemory, UINT uiCount, bool canReverse);	//запись найденного пути в уже выделенную память
+
+	ID gridQueryFindPath(ID idStart, ID idFinish);
+	void gridQueryFindPathUpdate(UINT uiLimitMls);
 
 	void GridSetColorArr(const ID * pmem, DWORD color, UINT count);
 	void GridSetNullColor();
@@ -266,7 +269,49 @@ protected:
 	Array<ID> ArrIDsInOpen;				//значение квада в открытом списке, по id квада
 	Array<ID> ArrParentIDs;				//список родителей (по id квада)
 	Array<CostAIQuad> ArrCostQuads;		//список стоимостей проходов по каждому кваду (по id квада)
-	Array<ID> ArrPathIDs;				//массив с id квадов наденного пути
+	//Array<ID> ArrPathIDs;				//массив с id квадов наденного пути
+
+	enum QUEUE_OBJ_STATE
+	{
+		QUEUE_OBJ_STATE_IDLE,
+		QUEUE_OBJ_STATE_WAIT,
+		QUEUE_OBJ_STATE_COMPLITE,
+		QUEUE_OBJ_STATE_ERROR,
+	};
+
+	//! объект очереди
+	struct CQueueObject
+	{
+		CQueueObject()
+		{
+			m_state = QUEUE_OBJ_STATE_IDLE;
+			m_idStart = m_idFinish = -1;
+		}
+
+		//! ожидает ли текущий объект поиска?
+		QUEUE_OBJ_STATE m_state;
+
+		//! стартовый квад
+		ID m_idStart;
+
+		//! финальный квад
+		ID m_idFinish;
+
+		//! массив id квадов найденного пути
+		Array<ID> m_aQuads;
+	};
+
+	//! массив очереди запросов на поиск пути
+	Array<CQueueObject> m_aQueueFind;
+
+	int m_iLastWait;
+
+	ID getQueueWaiting();
+
+	ID getQueueIdle();
+
+	bool gridFindPath(ID idQueueObject);							//поиск пути, (beginq,beginq]
+
 
 	Array<ID> ArrSelected;				//массив выделенных в данный момент квадов
 
diff --git a/source/aigrid/sxaigrid.cpp b/source/aigrid/sxaigrid.cpp
index ae2e1834e22f91c5838ac4dd9b154b2b76048621..dd79a4e408d104a47bb418ee87104d4d022b1894 100644
--- a/source/aigrid/sxaigrid.cpp
+++ b/source/aigrid/sxaigrid.cpp
@@ -14,16 +14,16 @@ See the license in LICENSE
 report_func g_fnReportf = DefReport;
 #endif
 
-bool QuadPhyNavigate(float3_t * pos)
+bool QuadPhyNavigate(float3_t *pPos)
 {
 	return false;
 }
 
 g_aiquad_phy_navigate AIQuadPhyNavigate = QuadPhyNavigate;
 
-AIGrid* ObjAIGrid = 0;
+AIGrid* g_pAIGrid = 0;
 
-#define AIG_PRECOND(retval) if(!ObjAIGrid){LibReport(REPORT_MSG_LEVEL_ERROR, "%s - sxaigrid is not init", GEN_MSG_LOCATION); return retval;}
+#define AIG_PRECOND(retval) if(!g_pAIGrid){LibReport(REPORT_MSG_LEVEL_ERROR, "%s - sxaigrid is not init", GEN_MSG_LOCATION); return retval;}
 
 //##########################################################################
 
@@ -32,18 +32,18 @@ SX_LIB_API long SAIG_0GetVersion()
 	return SXAIGRID_VERSION;
 }
 
-SX_LIB_API void SAIG_Dbg_Set(report_func rf)
+SX_LIB_API void SAIG_Dbg_Set(report_func fnReport)
 {
-	g_fnReportf = rf;
+	g_fnReportf = fnReport;
 }
 
-SX_LIB_API void SAIG_0Create(const char* name, bool use_graphics, bool is_unic)
+SX_LIB_API void SAIG_0Create(const char *szName, bool useGraphics, bool isUnic)
 {
-	if (name && strlen(name) > 1)
+	if (szName && strlen(szName) > 1)
 	{
-		if (is_unic)
+		if (isUnic)
 		{
-			HANDLE hMutex = CreateMutex(NULL, FALSE, name);
+			HANDLE hMutex = CreateMutex(NULL, FALSE, szName);
 			if (GetLastError() == ERROR_ALREADY_EXISTS)
 			{
 				CloseHandle(hMutex);
@@ -51,16 +51,16 @@ SX_LIB_API void SAIG_0Create(const char* name, bool use_graphics, bool is_unic)
 			}
 			else
 			{
-				ObjAIGrid = new AIGrid();
-				if (use_graphics)
-					ObjAIGrid->GraphicsInit();
+				g_pAIGrid = new AIGrid();
+				if (useGraphics)
+					g_pAIGrid->GraphicsInit();
 			}
 		}
 		else
 		{
-			ObjAIGrid = new AIGrid();
-			if (use_graphics)
-				ObjAIGrid->GraphicsInit();
+			g_pAIGrid = new AIGrid();
+			if (useGraphics)
+				g_pAIGrid->GraphicsInit();
 		}
 	}
 	else
@@ -71,7 +71,7 @@ SX_LIB_API void SAIG_AKill()
 {
 	AIG_PRECOND(_VOID);
 
-	mem_delete(ObjAIGrid);
+	mem_delete(g_pAIGrid);
 }
 
 //#############################################################################
@@ -87,161 +87,161 @@ SX_LIB_API void SAIG_Clear()
 {
 	AIG_PRECOND(_VOID);
 
-	ObjAIGrid->Clear();
+	g_pAIGrid->Clear();
 }
 
-SX_LIB_API void SAIG_GridSave(const char* path)
+SX_LIB_API void SAIG_GridSave(const char *szPath)
 {
 	AIG_PRECOND(_VOID);
 
-	ObjAIGrid->GridSave(path);
+	g_pAIGrid->GridSave(szPath);
 }
 
-SX_LIB_API void SAIG_GridLoad(const char* path)
+SX_LIB_API void SAIG_GridLoad(const char* szPath)
 {
 	AIG_PRECOND(_VOID);
 
-	ObjAIGrid->GridLoad(path);
+	g_pAIGrid->GridLoad(szPath);
 }
 
 SX_LIB_API UINT SAIG_GridGetCountQuads()
 {
 	AIG_PRECOND(0);
 
-	return ObjAIGrid->GridGetCountQuads();
+	return g_pAIGrid->GridGetCountQuads();
 }
 
-SX_LIB_API void SAIG_BBCreate(const float3* center, const float3* param)
+SX_LIB_API void SAIG_BBCreate(const float3 *pCenter, const float3 *pParam)
 {
 	AIG_PRECOND(_VOID);
 
-	ObjAIGrid->BBCreate(center, param);
+	g_pAIGrid->BBCreate(pCenter, pParam);
 }
 
 SX_LIB_API bool SAIG_BBIsCreated()
 {
 	AIG_PRECOND(false);
 
-	return ObjAIGrid->BBIsCreated();
+	return g_pAIGrid->BBIsCreated();
 }
 
-SX_LIB_API void SAIG_BBSetDimensions(const float3* dim)
+SX_LIB_API void SAIG_BBSetDimensions(const float3 *pDimensions)
 {
 	AIG_PRECOND(_VOID);
 
-	ObjAIGrid->BBSetDimensions(dim);
+	g_pAIGrid->BBSetDimensions(pDimensions);
 }
 
-SX_LIB_API void SAIG_BBGetDimensions(float3* dim)
+SX_LIB_API void SAIG_BBGetDimensions(float3 *pDimensions)
 {
 	AIG_PRECOND(_VOID);
 
-	ObjAIGrid->BBGetDimensions(dim);
+	g_pAIGrid->BBGetDimensions(pDimensions);
 }
 
-SX_LIB_API void SAIG_BBSetPos(const float3* pos)
+SX_LIB_API void SAIG_BBSetPos(const float3 *pPos)
 {
 	AIG_PRECOND(_VOID);
 
-	ObjAIGrid->BBSetPos(pos);
+	g_pAIGrid->BBSetPos(pPos);
 }
 
-SX_LIB_API void SAIG_BBGetPos(float3* pos)
+SX_LIB_API void SAIG_BBGetPos(float3 *pPos)
 {
 	AIG_PRECOND(_VOID);
 
-	ObjAIGrid->BBGetPos(pos);
+	g_pAIGrid->BBGetPos(pPos);
 }
 
 SX_LIB_API void SAIG_BBCreateFinish()
 {
 	AIG_PRECOND(_VOID);
 
-	ObjAIGrid->BBCreateFinish();
+	g_pAIGrid->BBCreateFinish();
 }
 
 SX_LIB_API bool SAIG_BBIsCreatedFinish()
 {
 	AIG_PRECOND(false);
 
-	return ObjAIGrid->BBIsCreatedFinish();
+	return g_pAIGrid->BBIsCreatedFinish();
 }
 
-SX_LIB_API AIQUAD_STATE SAIG_QuadGetState(ID id)
+SX_LIB_API AIQUAD_STATE SAIG_QuadGetState(ID idQuad)
 {
 	AIG_PRECOND(AIQUAD_STATE::AIQUAD_STATE_FREE);
 
-	return ObjAIGrid->QuadGetState(id);
+	return g_pAIGrid->QuadGetState(idQuad);
 }
 
-SX_LIB_API void SAIG_QuadSetState(ID id, AIQUAD_STATE state)
+SX_LIB_API void SAIG_QuadSetState(ID idQuad, AIQUAD_STATE state)
 {
 	AIG_PRECOND(_VOID);
 
-	ObjAIGrid->QuadSetState(id, state);
+	g_pAIGrid->QuadSetState(idQuad, state);
 }
 
-SX_LIB_API void SAIG_QuadSetStateWho(ID id, ID who)
+SX_LIB_API void SAIG_QuadSetStateWho(ID idQuad, ID idWho)
 {
 	AIG_PRECOND(_VOID);
 
-	ObjAIGrid->QuadSetStateWho(id, who);
+	g_pAIGrid->QuadSetStateWho(idQuad, idWho);
 }
 
-SX_LIB_API ID SAIG_QuadGetStateWho(ID id)
+SX_LIB_API ID SAIG_QuadGetStateWho(ID idQuad)
 {
 	AIG_PRECOND(-1);
 
-	return ObjAIGrid->QuadGetStateWho(id);
+	return g_pAIGrid->QuadGetStateWho(idQuad);
 }
 
-SX_LIB_API bool SAIG_QuadIs2Neighbors(ID id, ID idn1, ID idn2)
+SX_LIB_API bool SAIG_QuadIs2Neighbors(ID idQuad, ID idQuad1, ID idQuad2)
 {
 	AIG_PRECOND(false);
 
-	return ObjAIGrid->QuadIs2Neighbors(id, idn1, idn2);
+	return g_pAIGrid->QuadIs2Neighbors(idQuad, idQuad1, idQuad2);
 }
 
-SX_LIB_API ID SAIG_QuadGet(const float3* pos, bool isnear_or_permissible)
+SX_LIB_API ID SAIG_QuadGet(const float3 *pPos, bool isNearOrPermissible)
 {
 	AIG_PRECOND(-1);
 
-	return ObjAIGrid->QuadGet(pos, isnear_or_permissible);
+	return g_pAIGrid->QuadGet(pPos, isNearOrPermissible);
 }
 
-SX_LIB_API bool SAIG_QuadGetPos(ID id, float3* pos)
+SX_LIB_API bool SAIG_QuadGetPos(ID idQuad, float3 *pPos)
 {
 	AIG_PRECOND(false);
 
-	return ObjAIGrid->QuadGetPos(id, pos);
+	return g_pAIGrid->QuadGetPos(idQuad, pPos);
 }
 
-SX_LIB_API void SAIG_QuadSetPosY(ID id, float posy)
+SX_LIB_API void SAIG_QuadSetPosY(ID idQuad, float fPosY)
 {
 	AIG_PRECOND(_VOID);
 
-	ObjAIGrid->QuadSetPosY(id, posy);
+	g_pAIGrid->QuadSetPosY(idQuad, fPosY);
 }
 
-SX_LIB_API float SAIG_QuadGetPosY(ID id)
+SX_LIB_API float SAIG_QuadGetPosY(ID idQuad)
 {
 	AIG_PRECOND(0);
 
-	return ObjAIGrid->QuadGetPosY(id);
+	return g_pAIGrid->QuadGetPosY(idQuad);
 }
 
-SX_LIB_API ID SAIG_QuadAdd(const float3* pos)
+SX_LIB_API ID SAIG_QuadAdd(const float3 *pPos)
 {
 	AIG_PRECOND(-1);
 
-	return ObjAIGrid->QuadAdd(pos);
+	return g_pAIGrid->QuadAdd(pPos);
 }
 
-SX_LIB_API bool SAIG_QuadDelete(ID id)
+SX_LIB_API bool SAIG_QuadDelete(ID idQuad)
 {
 	AIG_PRECOND(false);
 
-	return ObjAIGrid->QuadDelete(id);
+	return g_pAIGrid->QuadDelete(idQuad);
 }
 
 
@@ -249,119 +249,126 @@ SX_LIB_API void SAIG_GridClear()
 {
 	AIG_PRECOND(_VOID);
 
-	ObjAIGrid->GridClear();
+	g_pAIGrid->GridClear();
 }
 
-SX_LIB_API ID SAIG_GridTraceBeam(const float3* start, const float3* dir)
+SX_LIB_API ID SAIG_GridTraceBeam(const float3 *pStart, const float3 *pDir)
 {
 	AIG_PRECOND(-1);
 
-	return ObjAIGrid->GridTraceBeam(start, dir);
+	return g_pAIGrid->GridTraceBeam(pStart, pDir);
 }
 
-SX_LIB_API void SAIG_QuadSelect(ID id, bool consider_prev)
+SX_LIB_API void SAIG_QuadSelect(ID pStart, bool useConsiderPrev)
 {
 	AIG_PRECOND(_VOID);
 
-	ObjAIGrid->QuadSelect(id, consider_prev);
+	g_pAIGrid->QuadSelect(pStart, useConsiderPrev);
 }
 
-SX_LIB_API void SAIG_QuadSelectedAddPosY(float posy)
+SX_LIB_API void SAIG_QuadSelectedAddPosY(float fPosY)
 {
 	AIG_PRECOND(_VOID);
 
-	ObjAIGrid->QuadSelectedAddPosY(posy);
+	g_pAIGrid->QuadSelectedAddPosY(fPosY);
 }
 
 SX_LIB_API void SAIG_QuadSelectedDelete()
 {
 	AIG_PRECOND(_VOID);
 
-	ObjAIGrid->QuadSelectedDelete();
+	g_pAIGrid->QuadSelectedDelete();
 }
 
-SX_LIB_API bool SAIG_QuadIsFree(ID id, int radius)
+SX_LIB_API bool SAIG_QuadIsFree(ID idQuad, int fRadius)
 {
 	AIG_PRECOND(false);
 
-	return ObjAIGrid->QuadIsFree(id, radius);
+	return g_pAIGrid->QuadIsFree(idQuad, fRadius);
 }
 
-SX_LIB_API ID SAIG_QuadGetNear(const float3* pos, bool isfree, int raius)
+SX_LIB_API ID SAIG_QuadGetNear(const float3 *pPos, bool isFree, int iRadius)
 {
 	AIG_PRECOND(-1);
 
-	return ObjAIGrid->QuadGetNear(pos, isfree, raius);
+	return g_pAIGrid->QuadGetNear(pPos, isFree, iRadius);
 }
 
 SX_LIB_API void SAIG_GridTestValidation()
 {
 	AIG_PRECOND(_VOID);
 
-	ObjAIGrid->GridTestValidation();
+	g_pAIGrid->GridTestValidation();
 }
 
 SX_LIB_API UINT SAIG_GridGetCountSplits()
 {
 	AIG_PRECOND(0);
 
-	return ObjAIGrid->GridGetCountSplits();
+	return g_pAIGrid->GridGetCountSplits();
 }
 
-SX_LIB_API void SAIG_GridSetMarkSplits(bool mark)
+SX_LIB_API void SAIG_GridSetMarkSplits(bool isMark)
 {
 	AIG_PRECOND(_VOID);
 
-	ObjAIGrid->GridSetMarkSplits(mark);
+	g_pAIGrid->GridSetMarkSplits(isMark);
 }
 
 SX_LIB_API bool SAIG_GridGetMarkSplits()
 {
 	AIG_PRECOND(false);
 
-	return ObjAIGrid->GridGetMarkSplits();
+	return g_pAIGrid->GridGetMarkSplits();
 }
 
 SX_LIB_API void SAIG_GridGenerate()
 {
 	AIG_PRECOND(_VOID);
 
-	ObjAIGrid->GridGenerate();
+	g_pAIGrid->GridGenerate();
 }
 
-SX_LIB_API bool SAIG_GridFindPath(ID beginq, ID endq)
+SX_LIB_API void SAIG_GridQueryFindPathUpdate(UINT uiLimitMls)
 {
-	AIG_PRECOND(false);
+	AIG_PRECOND(_VOID);
+
+	g_pAIGrid->gridQueryFindPathUpdate(uiLimitMls);
+}
+
+SX_LIB_API ID SAIG_GridQueryFindPath(ID idBegin, ID idEnd)
+{
+	AIG_PRECOND(-1);
 
-	return ObjAIGrid->GridFindPath(beginq, endq);
+	return g_pAIGrid->gridQueryFindPath(idBegin, idEnd);
 }
 
-SX_LIB_API UINT SAIG_GridGetSizePath()
+SX_LIB_API int SAIG_GridGetSizePath(ID idQueueObject)
 {
 	AIG_PRECOND(0);
 
-	return ObjAIGrid->GridGetSizePath();
+	return g_pAIGrid->gridGetSizePath(idQueueObject);
 }
 
-SX_LIB_API bool SAIG_GridGetPath(ID * pmem, UINT count, bool reverse)
+SX_LIB_API bool SAIG_GridGetPath(ID idQueueObject, ID *pMem, UINT uiCount, bool isReverse)
 {
 	AIG_PRECOND(false);
 
-	return ObjAIGrid->GridGetPath(pmem, count, reverse);
+	return g_pAIGrid->gridGetPath(idQueueObject, pMem, uiCount, isReverse);
 }
 
-SX_LIB_API void SAIG_GridSetColorArr(const ID * pmem, DWORD color, UINT count)
+SX_LIB_API void SAIG_GridSetColorArr(const ID *pMem, DWORD dwColor, UINT uiCount)
 {
 	AIG_PRECOND(_VOID);
 
-	ObjAIGrid->GridSetColorArr(pmem, color, count);
+	g_pAIGrid->GridSetColorArr(pMem, dwColor, uiCount);
 }
 
 SX_LIB_API void SAIG_GridSetNullColor()
 {
 	AIG_PRECOND(_VOID);
 
-	ObjAIGrid->GridSetNullColor();
+	g_pAIGrid->GridSetNullColor();
 }
 
 
@@ -369,62 +376,62 @@ SX_LIB_API void SAIG_GraphPointGenerate()
 {
 	AIG_PRECOND(_VOID);
 
-	ObjAIGrid->GraphPointGenerate();
+	g_pAIGrid->GraphPointGenerate();
 }
 
 SX_LIB_API UINT SAIG_GraphPointGetCount()
 {
 	AIG_PRECOND(0);
 
-	return ObjAIGrid->GraphPointGetCount();
+	return g_pAIGrid->GraphPointGetCount();
 }
 
 SX_LIB_API void SAIG_GraphPointClear()
 {
 	AIG_PRECOND(_VOID);
 
-	ObjAIGrid->GraphPointClear();
+	g_pAIGrid->GraphPointClear();
 }
 
-SX_LIB_API void SAIG_GraphPointAdd(ID id)
+SX_LIB_API void SAIG_GraphPointAdd(ID idQuad)
 {
 	AIG_PRECOND(_VOID);
 
-	ObjAIGrid->GraphPointAdd(id);
+	g_pAIGrid->GraphPointAdd(idQuad);
 }
 
-SX_LIB_API void SAIG_GraphPointDelete(ID id)
+SX_LIB_API void SAIG_GraphPointDelete(ID idQuad)
 {
 	AIG_PRECOND(_VOID);
 
-	ObjAIGrid->GraphPointDelete(id);
+	g_pAIGrid->GraphPointDelete(idQuad);
 }
 
-SX_LIB_API ID SAIG_GraphPointGetNear(ID beginq, ID endq)
+SX_LIB_API ID SAIG_GraphPointGetNear(ID idBegin, ID idEnd)
 {
 	AIG_PRECOND(-1);
 
-	return ObjAIGrid->GraphPointGetNear(beginq, endq);
+	return g_pAIGrid->GraphPointGetNear(idBegin, idEnd);
 }
 
 
-SX_LIB_API void SAIG_RenderQuads(const ISXFrustum * frustum, const float3 * viewpos, float dist)
+SX_LIB_API void SAIG_RenderQuads(const ISXFrustum *pFrustum, const float3 *pViewPos, float fDist)
 {
 	AIG_PRECOND(_VOID);
 
-	ObjAIGrid->RenderQuads(frustum, viewpos, dist);
+	g_pAIGrid->RenderQuads(pFrustum, pViewPos, fDist);
 }
 
-SX_LIB_API void SAIG_RenderGraphPoints(const float3 * viewpos, float dist)
+SX_LIB_API void SAIG_RenderGraphPoints(const float3 *pViewPos, float fDist)
 {
 	AIG_PRECOND(_VOID);
 
-	ObjAIGrid->RenderGraphPoints(viewpos, dist);
+	g_pAIGrid->RenderGraphPoints(pViewPos, fDist);
 }
 
 SX_LIB_API void SAIG_RenderBB()
 {
 	AIG_PRECOND(_VOID);
 
-	ObjAIGrid->RenderBB();
+	g_pAIGrid->RenderBB();
 }
diff --git a/source/aigrid/sxaigrid.h b/source/aigrid/sxaigrid.h
index f1c2dec5e8aa3b56cc05d36370ba7948721ad635..e27a76ec3975f4f9132aa6aa7e09f324542dcc11 100644
--- a/source/aigrid/sxaigrid.h
+++ b/source/aigrid/sxaigrid.h
@@ -41,17 +41,21 @@ AI сетка состоит из квадратов (квад), квады им
 /*! \name Базовые функции библиотеки
 @{*/
 
-SX_LIB_API long SAIG_0GetVersion();				//!< версия подсистемы
-SX_LIB_API void SAIG_Dbg_Set(report_func rf);	//!< установить функцию обработки сообщений
+//! версия подсистемы
+SX_LIB_API long SAIG_0GetVersion();				
+
+//! установить функцию обработки сообщений
+SX_LIB_API void SAIG_Dbg_Set(report_func fnReport);	
 
 //! инициализация подсистемы
 SX_LIB_API void SAIG_0Create(
-	const char* name,			//!< присваиваемое имя
-	bool use_graphics = false,	//!< использовать ли графическое отображение (для редакторов к прмиеру) или нет (игровой режим)
-	bool is_unic = true			//!< должна ли подсистема быть уникальной по имени
+	const char *szName,			//!< присваиваемое имя
+	bool useGraphics = false,	//!< использовать ли графическое отображение (для редакторов к прмиеру) или нет (игровой режим)
+	bool isUnic = true			//!< должна ли подсистема быть уникальной по имени
 	);
 
-SX_LIB_API void SAIG_AKill();	//!< уничтожить подсистему
+//! уничтожить подсистему
+SX_LIB_API void SAIG_AKill();	
 
 //!@}
 
@@ -103,82 +107,153 @@ enum AIQUAD_STATE
 на вход идет текущая позиция квада, 
 возвращает false в случае удачи (изъянов не найдено) и true в случае неудачи(есть боковые пересечения или нет персечения с уровнем вообще, либо по высоте не вмещается) 
 */
-typedef bool(*g_aiquad_phy_navigate) (float3_t * pos);
+typedef bool(*g_aiquad_phy_navigate) (float3_t *pPos);
 
 /*! переназначение g_aiquad_phy_navigate, обязательное действие для работы с сеткой */
 SX_LIB_API void SAIG_SetFunc_QuadPhyNavigate(g_aiquad_phy_navigate func);
 
-SX_LIB_API void SAIG_Clear();						//!< очистка всех данных
+//! очистка всех данных
+SX_LIB_API void SAIG_Clear();						
+
+
+//! сохранение сетки
+SX_LIB_API void SAIG_GridSave(const char *szPath);	
 
-//сохранение/загрузка
-SX_LIB_API void SAIG_GridSave(const char* path);	//!< сохранение сетки
-SX_LIB_API void SAIG_GridLoad(const char* path);	//!< загрузка сетки
+//! загрузка сетки
+SX_LIB_API void SAIG_GridLoad(const char *szPath);	
 
 /*! \name Ограничивающий объем 
 @{*/
 
-SX_LIB_API void SAIG_BBCreate(const float3* center, const float3* param);	//!< создать ограничивающий объем по параметрам
-SX_LIB_API bool SAIG_BBIsCreated();											//!< создан ли ограничивающий объем
+//! создать ограничивающий объем по параметрам
+SX_LIB_API void SAIG_BBCreate(const float3 *pCenter, const float3 *pParam);	
+
+//! создан ли ограничивающий объем
+SX_LIB_API bool SAIG_BBIsCreated();											
+
+
+//! установка габаритов ббокса для каждой оси
+SX_LIB_API void SAIG_BBSetDimensions(const float3 *pDimensions);	
 
-//установка/получение габаритов
-SX_LIB_API void SAIG_BBSetDimensions(const float3* dim);	//!< установка габаритов ббокса для каждой оси
-SX_LIB_API void SAIG_BBGetDimensions(float3* dim);			//!< записывает габариты ббокса
+//! записывает габариты ббокса
+SX_LIB_API void SAIG_BBGetDimensions(float3 *pDimensions);			
 
-//установка/получение позиции
-SX_LIB_API void SAIG_BBSetPos(const float3* pos);			//!< установак позиции ббокса
-SX_LIB_API void SAIG_BBGetPos(float3* pos);					//!< записывает позицию ббокса
 
-SX_LIB_API void SAIG_BBCreateFinish();						//!< завершение создания ограничивающего объема, после которого изменить какие-либо его данные будет невозможно
-SX_LIB_API bool SAIG_BBIsCreatedFinish();					//!< завершено ли создание ббокса
+//! установак позиции ббокса
+SX_LIB_API void SAIG_BBSetPos(const float3 *pPos);			
+
+//! записывает позицию ббокса
+SX_LIB_API void SAIG_BBGetPos(float3 *pPos);		
+
+
+//! завершение создания ограничивающего объема, после которого изменить какие-либо его данные будет невозможно
+SX_LIB_API void SAIG_BBCreateFinish();						
+
+//! завершено ли создание ббокса
+SX_LIB_API bool SAIG_BBIsCreatedFinish();					
 
 //!@}
 
 /*! \name Управление AI сеткой
 @{*/
 
-SX_LIB_API void SAIG_GridClear();							//!< очистка данных сетки
-SX_LIB_API ID SAIG_GridTraceBeam(const float3* start, const float3* dir);	//!< трассировка луча и проверка его пересечения с каким либо квадом сетки, возвращает id квада если было пересечение
-SX_LIB_API void SAIG_GridTestValidation();									//!< тест действительности сетки и устранение возможных дефектов
+//! очистка данных сетки
+SX_LIB_API void SAIG_GridClear();	
+
+//! трассировка луча и проверка его пересечения с каким либо квадом сетки, возвращает id квада если было пересечение
+SX_LIB_API ID SAIG_GridTraceBeam(const float3 *pStart, const float3 *pDir);	
+
+//! тест действительности сетки и устранение возможных дефектов
+SX_LIB_API void SAIG_GridTestValidation();									
+
 SX_LIB_API UINT SAIG_GridGetCountSplits();
-SX_LIB_API void SAIG_GridSetMarkSplits(bool mark);			//!< выделение сплитов
-SX_LIB_API bool SAIG_GridGetMarkSplits();					//!< возвращает состояние выделения сплитов
 
-SX_LIB_API void SAIG_GridGenerate();						//!< функция просчетов, ее нужно вызывать чтобы просчитать всю аи сетку
-SX_LIB_API UINT SAIG_GridGetCountQuads();					//!< возвращает количество квадов в сетке
-SX_LIB_API bool SAIG_GridFindPath(ID beginq, ID endq);		//!< поиск пути, (beginq,beginq]
-SX_LIB_API UINT SAIG_GridGetSizePath();						//!< размер найденного пути в количестве квадратов
+//! выделение сплитов
+SX_LIB_API void SAIG_GridSetMarkSplits(bool isMark);			
+
+//! возвращает состояние выделения сплитов
+SX_LIB_API bool SAIG_GridGetMarkSplits();					
+
+
+//! функция просчетов, ее нужно вызывать чтобы просчитать всю аи сетку
+SX_LIB_API void SAIG_GridGenerate();						
+
+//! возвращает количество квадов в сетке
+SX_LIB_API UINT SAIG_GridGetCountQuads();
+
+SX_LIB_API void SAIG_GridQueryFindPathUpdate(UINT uiLimitMls);
+
+//! поиск пути, (beginq,beginq]
+SX_LIB_API ID SAIG_GridQueryFindPath(ID idBegin, ID idEnd);
+
+//! размер найденного пути в количестве квадратов
+SX_LIB_API int SAIG_GridGetSizePath(ID idQueueObject);
+
 
 //! запись найденного пути в уже выделенную память, если reverse == true то будет записано от начала до конца пути, иначе от конца до начала пути
-SX_LIB_API bool SAIG_GridGetPath(ID * pmem, UINT count, bool reverse);	
+SX_LIB_API bool SAIG_GridGetPath(ID idQueueObject, ID *pMem, UINT uiCount, bool isReverse);
+
+//! установка цвета массиву квадов
+SX_LIB_API void SAIG_GridSetColorArr(const ID *pMem, DWORD dwColor, UINT uiCount);	
 
-SX_LIB_API void SAIG_GridSetColorArr(const ID * pmem, DWORD color, UINT count);	//!< установка цвета массиву квадов
-SX_LIB_API void SAIG_GridSetNullColor();					//!< обнуление увета у всех квадов
+//! обнуление увета у всех квадов
+SX_LIB_API void SAIG_GridSetNullColor();					
 
 //!@}
 
 /*! \name Управление квадратами сетки
 @{*/
 
-SX_LIB_API void SAIG_QuadSetState(ID id, AIQUAD_STATE state);	//!< устанавливает состояние для квада
-SX_LIB_API AIQUAD_STATE SAIG_QuadGetState(ID id);				//!< возвращает текущее состояние квада
-SX_LIB_API void SAIG_QuadSetStateWho(ID id, ID who);			//!< устанавливает id объекта который занял квад
-SX_LIB_API ID SAIG_QuadGetStateWho(ID id);						//!< возвращает id объекта который занял квад
-SX_LIB_API bool SAIG_QuadIs2Neighbors(ID id, ID idn1, ID idn2);	//!< проверка квада: является ли квад id соседом и idn1 кваду и idn2 кваду
+//! устанавливает состояние для квада
+SX_LIB_API void SAIG_QuadSetState(ID idQuad, AIQUAD_STATE state);
 
-SX_LIB_API ID SAIG_QuadGet(const float3* pos, bool isnear_or_permissible);	//!< получить id квада по позиции, isnear_or_permissible - самый ближний квад (true), или самый ближний в пределах допустимой разницы начальной точки (false)?
-SX_LIB_API bool SAIG_QuadGetPos(ID id, float3* pos);
-SX_LIB_API void SAIG_QuadSetPosY(ID id, float posy);			//!< установка позиции по оси Y для квада
-SX_LIB_API float SAIG_QuadGetPosY(ID id);						//!< возвращает позицию по оси Y квада
+//! возвращает текущее состояние квада
+SX_LIB_API AIQUAD_STATE SAIG_QuadGetState(ID idQuad);
 
-SX_LIB_API ID SAIG_QuadAdd(const float3* pos);					//!< добавление квада в позицию
-SX_LIB_API bool SAIG_QuadDelete(ID id);							//!< удаление квада по его id
+//! устанавливает idQuad объекта который занял квад
+SX_LIB_API void SAIG_QuadSetStateWho(ID idQuad, ID idWho);
 
-SX_LIB_API void SAIG_QuadSelect(ID id, bool consider_prev);		//!< добавление квада к списку выделения, id - идентификатор квада, если -1 то очищает список, consider_prev - учитывать ли предыдущие записанные, если нет то очищает массив и записывает туда, если да то записывает сверху
-SX_LIB_API void SAIG_QuadSelectedAddPosY(float posy);			//!< добавление к позиции по оси Y для выделенных квадов
-SX_LIB_API void SAIG_QuadSelectedDelete();						//!< удаление выделенных квадов
+//! возвращает idQuad объекта который занял квад
+SX_LIB_API ID SAIG_QuadGetStateWho(ID idQuad);
 
-SX_LIB_API bool SAIG_QuadIsFree(ID id, int radius);				//!< свободен ли квад id в радиусе radius (radius - количество квадов вокруг указанного в id, 1 - значит только указанный, 2 - значит все соседние и так далее)
-SX_LIB_API ID SAIG_QuadGetNear(const float3* pos, bool isfree = false, int raius = 1);	//!< возвращает id ближайшего квада (если isfree == true то ищет только свободные) с радиусом свободности radius
+//! проверка квада: является ли квад idQuad соседом и idQuad1 кваду и idQuad2 кваду
+SX_LIB_API bool SAIG_QuadIs2Neighbors(ID idQuad, ID idQuad1, ID idQuad2);
+
+
+//! получить idQuad квада по позиции, isNearOrPermissible - самый ближний квад (true), или самый ближний в пределах допустимой разницы начальной точки (false)?
+SX_LIB_API ID SAIG_QuadGet(const float3 *pPos, bool isNearOrPermissible);	
+
+SX_LIB_API bool SAIG_QuadGetPos(ID idQuad, float3 *pPos);
+
+//! установка позиции по оси Y для квада
+SX_LIB_API void SAIG_QuadSetPosY(ID idQuad, float fPosY);
+
+//! возвращает позицию по оси Y квада
+SX_LIB_API float SAIG_QuadGetPosY(ID idQuad);
+
+
+//! добавление квада в позицию
+SX_LIB_API ID SAIG_QuadAdd(const float3 *pPos);					
+
+//! удаление квада по его idQuad
+SX_LIB_API bool SAIG_QuadDelete(ID idQuad);
+
+
+//! добавление квада к списку выделения, idQuad - идентификатор квада, если -1 то очищает список, useConsiderPrev - учитывать ли предыдущие записанные, если нет то очищает массив и записывает туда, если да то записывает сверху
+SX_LIB_API void SAIG_QuadSelect(ID idQuad, bool useConsiderPrev);
+
+//! добавление к позиции по оси Y для выделенных квадов
+SX_LIB_API void SAIG_QuadSelectedAddPosY(float fPosY);			
+
+//! удаление выделенных квадов
+SX_LIB_API void SAIG_QuadSelectedDelete();						
+
+
+//! свободен ли квад idQuad в радиусе iRadius (iRadius - количество квадов вокруг указанного в idQuad, 1 - значит только указанный, 2 - значит все соседние и так далее)
+SX_LIB_API bool SAIG_QuadIsFree(ID idQuad, int iRadius);
+
+//! возвращает id ближайшего квада (если isFree == true то ищет только свободные) с радиусом свободности iRadius
+SX_LIB_API ID SAIG_QuadGetNear(const float3 *pPos, bool isFree = false, int iRadius = 1);	
 
 #define SAIG_QuadSetColor(id, color) SAIG_GridSetColorArr(&id, color, 1)
 
@@ -189,21 +264,37 @@ SX_LIB_API ID SAIG_QuadGetNear(const float3* pos, bool isfree = false, int raius
  \note Графпоинтов не должно быть много, они могут быть расставлены вручную, либо сгенерированы автоматически (по центру каждого ббокса имеющего квады)
 @{*/
 
-SX_LIB_API void SAIG_GraphPointGenerate();					//!< автоматическая генерация графпоинтов в центрах ограничивающих боксов
-SX_LIB_API UINT SAIG_GraphPointGetCount();					//!< возвращает количество графпоинтов
-SX_LIB_API void SAIG_GraphPointClear();						//!< очистка списка графпоинтов
-SX_LIB_API void SAIG_GraphPointAdd(ID id);					//!< добавление графпоинта (id - идентификатор квада сетки)
-SX_LIB_API void SAIG_GraphPointDelete(ID id);				//!< удаление графпоинта (id - идентификатор квада сетки)
-SX_LIB_API ID SAIG_GraphPointGetNear(ID beginq, ID endq);	//!< поиск наиболее близкого графпоинта между стартовым и конечным квадами следования
+//! автоматическая генерация графпоинтов в центрах ограничивающих боксов
+SX_LIB_API void SAIG_GraphPointGenerate();					
+
+//! возвращает количество графпоинтов
+SX_LIB_API UINT SAIG_GraphPointGetCount();					
+
+//! очистка списка графпоинтов
+SX_LIB_API void SAIG_GraphPointClear();						
+
+//! добавление графпоинта (idQuad - идентификатор квада сетки)
+SX_LIB_API void SAIG_GraphPointAdd(ID idQuad);
+
+//! удаление графпоинта (idQuad - идентификатор квада сетки)
+SX_LIB_API void SAIG_GraphPointDelete(ID idQuad);				
+
+//! поиск наиболее близкого графпоинта между стартовым и конечным квадами следования
+SX_LIB_API ID SAIG_GraphPointGetNear(ID idBegin, ID idEnd);	
 
 //!@}
 
 /*! \name Рендер
 @{*/
 
-SX_LIB_API void SAIG_RenderQuads(const ISXFrustum * frustum, const float3 * viewpos, float dist);	//!< отрисовка сетки
-SX_LIB_API void SAIG_RenderGraphPoints(const float3 * viewpos, float dist);							//!< отрисовка графпоинтов
-SX_LIB_API void SAIG_RenderBB();			//!< отрисовка ограничивающих объемов
+//! отрисовка сетки
+SX_LIB_API void SAIG_RenderQuads(const ISXFrustum *pFrustum, const float3 *pViewPos, float fDist);	
+
+//! отрисовка графпоинтов
+SX_LIB_API void SAIG_RenderGraphPoints(const float3 *pViewPos, float fDist);			
+
+//! отрисовка ограничивающих объемов
+SX_LIB_API void SAIG_RenderBB();			
 
 //!@}
 
diff --git a/source/game/NPCBase.cpp b/source/game/NPCBase.cpp
index e52e8bfca4b8e04078e5cdbd951db5a1dcd6927e..726d07b6b63ff2e1428ebd208c9a544a36179d5f 100644
--- a/source/game/NPCBase.cpp
+++ b/source/game/NPCBase.cpp
@@ -28,6 +28,8 @@ CNPCBase::CNPCBase(CEntityManager * pMgr):
 	m_stateMove = NPC_STATE_MOVE_IDLE_START;
 	m_statePath = NPC_STATE_PATH_NOTFOUND;
 
+	m_idQueueFindPath = -1;
+
 	m_fAngleYLast = 0;
 	m_fAngleYNext = 0;
 	m_ulTimeAllRot = 0;
@@ -107,16 +109,23 @@ ID CNPCBase::getAIQuad()
 
 bool CNPCBase::pathFind(ID endq)
 {
-	if(m_idCurrAiQuad >= 0 && SAIG_GridFindPath(m_idCurrAiQuad, endq))
+	if(m_idCurrAiQuad >= 0)
 	{
-		if (m_aPathQuads.size() > 0)
-			SAIG_GridSetColorArr(&(m_aPathQuads[0]), 0, m_aPathQuads.size());
-		m_statePath = NPC_STATE_PATH_FOUND;
-		m_aPathQuads.resize(SAIG_GridGetSizePath());
-		SAIG_GridGetPath(&(m_aPathQuads[0]), m_aPathQuads.size(), true);
-		SAIG_GridSetColorArr(&(m_aPathQuads[0]), m_ulColor, m_aPathQuads.size());
-		m_vLastPathPos = m_vPosition;
-		return true;
+		if (m_idQueueFindPath >= 0 && SAIG_GridGetSizePath(m_idQueueFindPath) >= 0)
+		{
+			if (m_aPathQuads.size() > 0)
+				SAIG_GridSetColorArr(&(m_aPathQuads[0]), 0, m_aPathQuads.size());
+			m_statePath = NPC_STATE_PATH_FOUND;
+			int iCount = SAIG_GridGetSizePath(m_idQueueFindPath);
+			m_aPathQuads.resize(iCount);
+			SAIG_GridGetPath(m_idQueueFindPath, &(m_aPathQuads[0]), m_aPathQuads.size(), true);
+			SAIG_GridSetColorArr(&(m_aPathQuads[0]), m_ulColor, m_aPathQuads.size());
+			m_vLastPathPos = m_vPosition;
+			m_idQueueFindPath = -1;
+			return true;
+		}
+		else if (m_idQueueFindPath <= -1)
+			m_idQueueFindPath = SAIG_GridQueryFindPath(m_idCurrAiQuad, endq);
 	}
 	
 	m_statePath = NPC_STATE_PATH_NOTFOUND;
diff --git a/source/game/NPCBase.h b/source/game/NPCBase.h
index 303daa135872ca6bcc5bf4383e0ae886a4f43f0d..59352f3e863dd7c2062532469ed67e803fed0beb 100644
--- a/source/game/NPCBase.h
+++ b/source/game/NPCBase.h
@@ -97,6 +97,8 @@ protected:
 
 	Array<ID> m_aPathQuads;		//!< массив с идентификаторами квадов пути на аи сетке
 	ID m_idCurrQuaidInPath;		//!< номер текущего квада из m_arr_path
+
+	ID m_idQueueFindPath;
 	
 	float3 m_vLastPathPos;		//!< последняя позиция нпс на пути
 
diff --git a/source/skyxengine.cpp b/source/skyxengine.cpp
index 51c22d8bfa06305ffa6293dcbba0346f7a878b7e..ee3716b213032f9d12aca052698a7b1b3dfcca89 100644
--- a/source/skyxengine.cpp
+++ b/source/skyxengine.cpp
@@ -927,6 +927,8 @@ void SkyXEngine_Frame(DWORD timeDelta)
 	SPE_EffectComputeAll();
 	SPE_EffectComputeLightingAll();
 	DelayUpdateParticles += TimeGetMcsU(Core_RIntGet(G_RI_INT_TIMER_RENDER)) - ttime;
+
+	SAIG_GridQueryFindPathUpdate(25);
 	
 	ttime = TimeGetMcsU(Core_RIntGet(G_RI_INT_TIMER_RENDER));
 	pDXDevice->Present(0, 0, 0, 0);
@@ -1407,12 +1409,12 @@ ID SkyXEngine_RFuncMtlLoad(const char* name, int mtl_type)
 	return SML_MtlLoad(name, (MTLTYPE_MODEL)mtl_type);
 }
 
-bool SkyXEngine_RFuncAIQuadPhyNavigate(float3_t * pos)
+bool SkyXEngine_RFuncAIQuadPhyNavigate(float3_t *pPos)
 {
 	static btBoxShape boxfull(btVector3(AIGRID_QUAD_SIZEDIV2, AIGRID_ENTITY_MAX_HEIGHTDIV2, AIGRID_QUAD_SIZEDIV2));
-	float3 start = (*pos);
-	start.y = pos->y + AIGRID_ENTITY_MAX_HEIGHT;
-	float3 end = (*pos);
+	float3 start = (*pPos);
+	start.y = pPos->y + AIGRID_ENTITY_MAX_HEIGHT;
+	float3 end = (*pPos);
 	//end.y = min->y - AIGRID_ENTITY_MAX_HEIGHT;
 	static btDiscreteDynamicsWorld::ClosestConvexResultCallback cb(F3_BTVEC(start), F3_BTVEC(end));
 	cb = btDiscreteDynamicsWorld::ClosestConvexResultCallback(F3_BTVEC(start), F3_BTVEC(end));
@@ -1427,13 +1429,13 @@ bool SkyXEngine_RFuncAIQuadPhyNavigate(float3_t * pos)
 
 	if (cb.hasHit())
 	{
-		pos->y = cb.m_hitPointWorld[1];
+		pPos->y = cb.m_hitPointWorld[1];
 		//quad->IsClose = false;
 
 		static btBoxShape boxoff(btVector3(AIGRID_QUAD_SIZEDIV2, (AIGRID_ENTITY_MAX_HEIGHT - AIGRID_QUADS_CENTERS_MAXHEIGHT) * 0.5, AIGRID_QUAD_SIZEDIV2));
 
-		start = (*pos);
-		start.y = pos->y + AIGRID_ENTITY_MAX_HEIGHTDIV2 + AIGRID_QUADS_CENTERS_MAXHEIGHT;
+		start = (*pPos);
+		start.y = pPos->y + AIGRID_ENTITY_MAX_HEIGHTDIV2 + AIGRID_QUADS_CENTERS_MAXHEIGHT;
 		static btVector3 vec;
 		vec = btVector3(F3_BTVEC(start));
 		cb = btDiscreteDynamicsWorld::ClosestConvexResultCallback(vec, vec);