diff --git a/build/gamesource/levels/stalker_atp/stalker_atp.ent b/build/gamesource/levels/stalker_atp/stalker_atp.ent
index e2fd6126675f1f4c0f5f2ec7a0220cdc9e26fe35..f91a0518dcd1406daef6721b393fec7868beeb71 100644
--- a/build/gamesource/levels/stalker_atp/stalker_atp.ent
+++ b/build/gamesource/levels/stalker_atp/stalker_atp.ent
@@ -1,4 +1,5 @@
 [ent_0]
+health = 100.000000
 parent = 
 owner = 
 flags = 0
@@ -10,15 +11,17 @@ rotation = 0.000000 0.000000 0.000000 1.000000
 speed = 5.000000
 
 [ent_1]
+health = 100.000000
 owner = 
 flags = 0
 classname = point_camera
 origin = -106.658783 -0.106368 1.572050
 parent = cam_train
 name = train_camera
-rotation = -0.000000 1.000000 0.000000 0.000000
+rotation = 0.000000 1.000000 0.000000 0.000000
 
 [ent_10]
+health = 100.000000
 owner = 
 flags = 0
 type = 0
@@ -31,6 +34,7 @@ name = cam_pt_8
 classname = path_corner
 
 [ent_11]
+health = 100.000000
 owner = 
 flags = 0
 type = 0
@@ -43,6 +47,7 @@ name = cam_pt_9
 classname = path_corner
 
 [ent_12]
+health = 100.000000
 owner = 
 flags = 0
 type = 0
@@ -55,6 +60,7 @@ name = cam_pt_10
 classname = path_corner
 
 [ent_13]
+health = 100.000000
 owner = 
 flags = 0
 type = 0
@@ -67,6 +73,7 @@ name = cam_pt_11
 classname = path_corner
 
 [ent_14]
+health = 100.000000
 owner = 
 flags = 0
 type = 0
@@ -79,6 +86,7 @@ name = cam_pt_12
 classname = path_corner
 
 [ent_15]
+health = 100.000000
 owner = 
 flags = 0
 type = 0
@@ -91,6 +99,7 @@ name = cam_pt_13
 classname = path_corner
 
 [ent_16]
+health = 100.000000
 owner = 
 flags = 0
 type = 0
@@ -103,6 +112,7 @@ name = cam_pt_14
 classname = path_corner
 
 [ent_17]
+health = 100.000000
 owner = 
 flags = 0
 type = 0
@@ -115,6 +125,7 @@ name = cam_pt_15
 classname = path_corner
 
 [ent_18]
+health = 100.000000
 owner = 
 flags = 0
 type = 0
@@ -127,6 +138,7 @@ name = cam_pt_16
 classname = path_corner
 
 [ent_19]
+health = 100.000000
 owner = 
 next = 
 flags = 0
@@ -139,6 +151,7 @@ name = cam_pt_17
 classname = path_corner
 
 [ent_2]
+health = 100.000000
 owner = 
 flags = 0
 type = 0
@@ -151,6 +164,7 @@ name = cam_pt_0
 classname = path_corner
 
 [ent_3]
+health = 100.000000
 owner = 
 flags = 0
 type = 0
@@ -163,6 +177,7 @@ name = cam_pt_1
 classname = path_corner
 
 [ent_4]
+health = 100.000000
 owner = 
 flags = 0
 type = 0
@@ -175,6 +190,7 @@ name = cam_pt_2
 classname = path_corner
 
 [ent_5]
+health = 100.000000
 owner = 
 flags = 0
 type = 0
@@ -187,6 +203,7 @@ name = cam_pt_3
 classname = path_corner
 
 [ent_6]
+health = 100.000000
 owner = 
 flags = 0
 type = 0
@@ -199,6 +216,7 @@ name = cam_pt_4
 classname = path_corner
 
 [ent_7]
+health = 100.000000
 owner = 
 flags = 0
 type = 0
@@ -211,6 +229,7 @@ name = cam_pt_5
 classname = path_corner
 
 [ent_8]
+health = 100.000000
 owner = 
 flags = 0
 type = 0
@@ -223,6 +242,7 @@ name = cam_pt_6
 classname = path_corner
 
 [ent_9]
+health = 100.000000
 owner = 
 flags = 0
 type = 0
@@ -235,6 +255,7 @@ name = cam_pt_7
 classname = path_corner
 
 [ent_20]
+health = 100.000000
 parent = 
 owner = 
 name = 
@@ -245,18 +266,27 @@ rotation = 0.000000 0.980603 0.000000 -0.196004
 team = 0
 
 [ent_21]
+toggle = 
+scale = 1.000000
+model = meshes/light/light_1.dse
+health = 100.000000
+enable = 
+disable = 
+OnTouchStart = test_light:turnOn:0.000000:
+OnTouchEndAll = 
+OnTouchEnd = test_light:turnOff:0.000000:
 type_shadow = 1
 turnOn = 1
 turnOff = 1
 parent = 
 owner = 
-name = test_light
+name = 
 light_far = 10.000000
 flags = 0
 dist = 10.000000
 color = 50.000000 50.000000 50.000000
-classname = light_point_qqqq
-origin = 0.000000 -0.750000 0.000000
+classname = trigger
+origin = -3.900000 -2.750000 22.000000
 rotation = 0.000000 0.000000 0.000000 1.000000
 
 [ent_22]
@@ -273,4 +303,4 @@ OnTouchEnd = test_light:turnOff:0:
 
 
 [meta]
-count = 23
+count = 22
diff --git a/build/gamesource/shaders/mtrlgeom/mtrlgeom_base.ps b/build/gamesource/shaders/mtrlgeom/mtrlgeom_base.ps
index 408a233296c23552142e73d0a9a284e881e586c7..2fd63a041ba51b176f58b0b059242ab1fb1961a2 100644
--- a/build/gamesource/shaders/mtrlgeom/mtrlgeom_base.ps
+++ b/build/gamesource/shaders/mtrlgeom/mtrlgeom_base.ps
@@ -19,7 +19,7 @@ ps_out_ds_mrt main(vs_out_gcommon IN)
 	ps_out_ds_mrt OUT; 
 	OUT.Color = tex2D(BaseTex,IN.TexUV);
 	
-	OUT.Normal.xyz = 0.5f * IN.Normal + 0.5f;
+	OUT.Normal.xyz = 0.5f * normalize(IN.Normal) + 0.5f;
 	OUT.Normal.w = NearFarIsUnlit.z;
 	
 	OUT.Param = tex2D(ParamTex,IN.TexUV);
diff --git a/build/gamesource/shaders/mtrlgeom/mtrlgeom_mrbase.ps b/build/gamesource/shaders/mtrlgeom/mtrlgeom_mrbase.ps
index afa93ae9d026facb60d4145a008ef0620fddaebf..65ed5463e0fa84569873b4be6a1d1364f212e0b7 100644
--- a/build/gamesource/shaders/mtrlgeom/mtrlgeom_mrbase.ps
+++ b/build/gamesource/shaders/mtrlgeom/mtrlgeom_mrbase.ps
@@ -23,6 +23,7 @@ ps_out_ds_mrt main(vs_out_gcommon IN)
 
 	half3 NormalMicro = ((2.f * (tex2D(MRTex0, IN.TexUV).rgb)) - 1.f);
 	NormalMicro *= Param.z;
+	IN.Normal = normalize(IN.Normal);
 	half3 NormalPixel = normalize((IN.Normal+half3(NormalMicro.xy,IN.Normal.z)) * 0.5f);
 	
 	OUT.Normal.xyz = 0.5f * NormalPixel + 0.5f;
diff --git a/source/aigrid/aigrid.cpp b/source/aigrid/aigrid.cpp
index bb46b75cfbab08d5a5c2f66b2f0c2d457f49de3f..2c8b5e9b7dd8371ed792ce134355bac576a228df 100644
--- a/source/aigrid/aigrid.cpp
+++ b/source/aigrid/aigrid.cpp
@@ -6,75 +6,51 @@ See the license in LICENSE
 
 #include "aigrid.h"
 
-void AIGrid::CorrectPosXZ(float3* pos)
+CAIGrid::CAIGrid()
 {
-	if(!pos)
-		return;
-
-	float count = pos->x / AIGRID_QUAD_SIZE;
-	pos->x = AIGRID_QUAD_SIZE * (float)((int)floor(count + 0.5));
-
-	/*count = pos->y / AIGRID_QUAD_SIZE;
-	pos->y = AIGRID_QUAD_SIZE * (float)((int)floor(count + 0.5));*/
-
-	count = pos->z / AIGRID_QUAD_SIZE;
-	pos->z = AIGRID_QUAD_SIZE * (float)((int)floor(count + 0.5));
-}
-
-bool AIGrid::IsValidIdInArrQuads(ID id)
-{
-	return (id >= 0 && ArrQuads.size() > id && !(ArrQuads[id]->IsClose));
-}
-
-bool AIGrid::AIGridCompareHeight(ID id1,ID id2)
-{
-	return (
-			abs(
-			abs(ArrLongCoordQuads[id1].y) - abs(ArrLongCoordQuads[id2].y)
-				) > LAIGRID_QUADS_CENTERS_MAXHEIGHT ? false : true
-		
-		);
-}
-
-AIGrid::AIGrid()
-{
-	AIQuadDecl = 0;
-	TransVertBuf = 0;
-	CountSplits = 0;
-	BoundBox = 0;
-	DXDevice = 0;
-	Tex_BB = -1;
-	IsMarkSplits = false;
-	Tex_AIGrid = -1;
+	m_pDecl = 0;
+	m_pTransVertBuf = 0;
+	m_uiCountSplits = 0;
+	m_pBoundBox = 0;
+	m_pDXDevice = 0;
+	m_idTexBB = -1;
+	m_isMarkSplits = false;
+	m_idTex = -1;
 
-	IDVS = -1;
-	IDPS = -1;
+	m_idVS = -1;
+	m_idPS = -1;
 
-	UseGraphics = false;
+	m_useGraphics = false;
 
 	m_iLastWait = 0;
 
 	m_aQueueFind.resize(1024);
+
+	m_pTreeBound = 0;
+
+	//bbCreate(&float3(0, 0, 0), &float3(10, 10, 10));
 }
 
-AIGrid::~AIGrid()
+CAIGrid::~CAIGrid()
 {
-	Clear();
-	mem_release(AIQuadDecl);
-	mem_release(BoundBox);
-	mem_release(VertexQuad);
-	mem_release(IndexQuad);
+	clear();
+	mem_release(m_pDecl);
+	mem_release(m_pBoundBox);
+	mem_release(m_pVertexQuad);
+	mem_release(m_pIndexQuad);
 }
 
-void AIGrid::GridSave(const char* path)
+//##########################################################################
+
+void CAIGrid::save(const char* path)
 {
-	if (ArrQuads.size() <= 0)
+	if (m_aQuads.size() <= 0)
 	{
 		LibReport(REPORT_MSG_LEVEL_WARNING, "AI grid not found\n");
 		return;
 	}
 
-	if (CountSplits <= 0)
+	if (m_uiCountSplits <= 0)
 	{
 		LibReport(REPORT_MSG_LEVEL_WARNING, "can not find path, because AI grid is not validate splits\n");
 		return;
@@ -84,48 +60,49 @@ void AIGrid::GridSave(const char* path)
 	file = fopen(path, "wb");
 
 	fwrite("aigrid\0", 7, 1, file);
-	fwrite(&float3_t((ArrBound[0]->max.x + ArrBound[0]->min.x) * 0.5f), sizeof(float3_t), 1, file);
-	fwrite(&float3_t(ArrBound[0]->max - ArrBound[0]->min), sizeof(float3_t), 1, file);
+	fwrite(&m_uiCountSplits, sizeof(uint16_t), 1, file);
+	fwrite(&float3_t((m_aBound[0]->m_f3Max.x + m_aBound[0]->m_f3Min.x) * 0.5f), sizeof(float3_t), 1, file);
+	fwrite(&float3_t(m_aBound[0]->m_f3Max - m_aBound[0]->m_f3Min), sizeof(float3_t), 1, file);
 
-	int32_t CountBB = ArrBound.size() - 1;
+	int32_t CountBB = m_aBound.size() - 1;
 	fwrite(&CountBB, sizeof(int32_t), 1, file);
 	int32_t tmpCountObjectBBQuads = 0;
 	int tmpcountids = 0;
-	for (int32_t i = 1; i<ArrBound.size(); i++)
+	for (int32_t i = 1; i<m_aBound.size(); i++)
 	{
-		fwrite(&(ArrBound[i]->min), sizeof(float3_t), 1, file);
-		fwrite(&(ArrBound[i]->max), sizeof(float3_t), 1, file);
+		fwrite(&(m_aBound[i]->m_f3Min), sizeof(float3_t), 1, file);
+		fwrite(&(m_aBound[i]->m_f3Max), sizeof(float3_t), 1, file);
 
-		tmpCountObjectBBQuads = ArrBound[i]->ArrIdsQuads.size();
+		tmpCountObjectBBQuads = m_aBound[i]->m_aIdsQuads.size();
 		fwrite(&tmpCountObjectBBQuads, sizeof(int32_t), 1, file);
 		tmpcountids += tmpCountObjectBBQuads;
 		if (tmpCountObjectBBQuads > 0)
 		{
-			fwrite(&(ArrBound[i]->ArrIdsQuads[0]), sizeof(ID), tmpCountObjectBBQuads, file);
+			fwrite(&(m_aBound[i]->m_aIdsQuads[0]), sizeof(ID), tmpCountObjectBBQuads, file);
 		}
 	}
 
-	int32_t CountObject = ArrQuads.size();
+	int32_t CountObject = m_aQuads.size();
 	fwrite(&CountObject, sizeof(int32_t), 1, file);
-	//fwrite((ArrQuads[0]), sizeof(AIQuad), CountObject, file);
+	//fwrite((m_aQuads[0]), sizeof(CAIquad), CountObject, file);
 
 	for (int32_t i = 0; i<CountObject; ++i)
 	{
-		AIQuad* tmpaq = ArrQuads[i];
-		fwrite(tmpaq, sizeof(AIQuad), 1, file);
+		CAIquad* tmpaq = m_aQuads[i];
+		fwrite(tmpaq, sizeof(CAIquad), 1, file);
 	}
 
-	CountObject = ArrGraphPointsIDs.size();
+	CountObject = m_aGraphPointsIDs.size();
 	fwrite(&CountObject, sizeof(int32_t), 1, file);
 	if (CountObject > 0)
-		fwrite(&(ArrGraphPointsIDs[0]), sizeof(AIQuad), CountObject, file);
+		fwrite(&(m_aGraphPointsIDs[0]), sizeof(CAIquad), CountObject, file);
 
 	fclose(file);
 }
 
-void AIGrid::GridLoad(const char* path)
+void CAIGrid::load(const char* path)
 {
-	Clear();
+	clear();
 	float3_t tmpcenter, tmpparam;
 
 	FILE* file = 0;
@@ -137,12 +114,13 @@ void AIGrid::GridLoad(const char* path)
 
 	if (strcmp(HeaderFile, "aigrid") == 0)
 	{
+		fread(&m_uiCountSplits, sizeof(uint16_t), 1, file);
 		fread(&tmpcenter, sizeof(float3_t), 1, file);
 		fread(&tmpparam, sizeof(float3_t), 1, file);
 
-		BBCreate(&float3(tmpcenter), &float3(tmpparam));
-		Max = ArrBound[0]->max;
-		Min = ArrBound[0]->min;
+		bbCreate(&float3(tmpcenter), &float3(tmpparam));
+		m_vMax = m_aBound[0]->m_f3Max;
+		m_vMin = m_aBound[0]->m_f3Min;
 		int32_t CountObjectBB = 0;
 		fread(&CountObjectBB, sizeof(int32_t), 1, file);
 
@@ -151,136 +129,273 @@ void AIGrid::GridLoad(const char* path)
 
 		for (int32_t i = 0; i<CountObjectBB; ++i)
 		{
-			BoundAIQuad* tmpbb = AllocBoundAIQuad.Alloc();
-			fread(&(tmpbb->min), sizeof(float3_t), 1, file);
-			fread(&(tmpbb->max), sizeof(float3_t), 1, file);
+			CBoundAIquad* tmpbb = m_oAllocBound.Alloc();
+			fread(&(tmpbb->m_f3Min), sizeof(float3_t), 1, file);
+			fread(&(tmpbb->m_f3Max), sizeof(float3_t), 1, file);
 
-			tmpbb->lmin.x = toint100(tmpbb->min.x);
-			tmpbb->lmin.y = toint100(tmpbb->min.y);
-			tmpbb->lmin.z = toint100(tmpbb->min.z);
+			tmpbb->m_i3Min.x = AIGRID_TOINT(tmpbb->m_f3Min.x);
+			tmpbb->m_i3Min.y = AIGRID_TOINT(tmpbb->m_f3Min.y);
+			tmpbb->m_i3Min.z = AIGRID_TOINT(tmpbb->m_f3Min.z);
 
-			tmpbb->lmax.x = toint100(tmpbb->max.x);
-			tmpbb->lmax.y = toint100(tmpbb->max.y);
-			tmpbb->lmax.z = toint100(tmpbb->max.z);
+			tmpbb->m_i3Max.x = AIGRID_TOINT(tmpbb->m_f3Max.x);
+			tmpbb->m_i3Max.y = AIGRID_TOINT(tmpbb->m_f3Max.y);
+			tmpbb->m_i3Max.z = AIGRID_TOINT(tmpbb->m_f3Max.z);
 
 			int32_t tmpCountObjectBBQuads = 0;
 			fread(&tmpCountObjectBBQuads, sizeof(int32_t), 1, file);
 			tmpcountids += tmpCountObjectBBQuads;
 			if (tmpCountObjectBBQuads > 0)
 			{
-				tmpbb->ArrIdsQuads.resize(tmpCountObjectBBQuads);
-				fread(&(tmpbb->ArrIdsQuads[0]), sizeof(ID), tmpCountObjectBBQuads, file);
+				tmpbb->m_aIdsQuads.resize(tmpCountObjectBBQuads);
+				fread(&(tmpbb->m_aIdsQuads[0]), sizeof(ID), tmpCountObjectBBQuads, file);
 			}
 
-			ArrBound.push_back(tmpbb);
+			m_aBound.push_back(tmpbb);
 		}
 
 		int32_t CountObject = 0;
 		fread(&CountObject, sizeof(int32_t), 1, file);
-		ArrQuads.reserve(CountObject);
+		m_aQuads.reserve(CountObject);
 		for (int32_t i = 0; i<CountObject; ++i)
 		{
-			AIQuad* tmpaq = AllocAIQuad.Alloc();
-			fread(tmpaq, sizeof(AIQuad), 1, file);
-			ArrQuads.push_back(tmpaq);
-			ArrLongCoordQuads[tmpaq->Id] = int3(toint100(tmpaq->pos.x), toint100(tmpaq->pos.y), toint100(tmpaq->pos.z));
+			CAIquad* tmpaq = m_oAllocQuad.Alloc();
+			fread(tmpaq, sizeof(CAIquad), 1, file);
+			m_aQuads.push_back(tmpaq);
+			m_aLongCoordQuads[tmpaq->m_id] = int3(AIGRID_TOINT(tmpaq->m_vPos.x), AIGRID_TOINT(tmpaq->m_vPos.y), AIGRID_TOINT(tmpaq->m_vPos.z));
 		}
 
 		CountObject = 0;
 		fread(&CountObject, sizeof(int32_t), 1, file);
 		if (CountObject > 0)
 		{
-			ArrGraphPointsIDs.resize(CountObject);
-			fread(&(ArrGraphPointsIDs[0]), sizeof(ID), CountObject, file);
+			m_aGraphPointsIDs.resize(CountObject);
+			fread(&(m_aGraphPointsIDs[0]), sizeof(ID), CountObject, file);
 		}
 	}
 
 	fclose(file);
-	ReCreateBuffs();
+	reCreateBuffs();
+
+	LibReport(REPORT_MSG_LEVEL_NOTICE, "AI grid is loaded, count quads %d, count graph points %d\n", m_aQuads.size(), m_aGraphPointsIDs.size());
 
-	LibReport(REPORT_MSG_LEVEL_NOTICE, "AI grid is loaded, count quads %d, count graph points %d\n", ArrQuads.size(), ArrGraphPointsIDs.size());
+	if (m_uiCountSplits <= 0)
+		gridTestValidation();
 
-	GridTestValidation();
+	createTreeBound();
 }
 
-UINT AIGrid::GridGetCountQuads()
+//##########################################################################
+
+void CAIGrid::createTreeBound()
 {
-	return ArrQuads.size();
+	mem_delete(m_pTreeBound);
+	if (m_aBound.size() < 1)
+		return;
+
+	m_pTreeBound = new CTreeBoundAIquad();
+	m_pTreeBound->m_pBoundBox = SGCore_CrBound();
+	m_pTreeBound->m_pBoundBox->setMinMax(&float3(m_aBound[0]->m_f3Min), &float3(m_aBound[0]->m_f3Max));
+	m_pTreeBound->m_i3Min = m_aBound[0]->m_i3Min;
+	m_pTreeBound->m_i3Max = m_aBound[0]->m_i3Max;
+	
+	for (int i = 1, il = m_aBound.size(); i < il; ++i)
+	{
+		m_pTreeBound->m_pBounds.push_back(m_aBound[i]);
+	}
+
+	Array<CTreeBoundAIquad*> queue;
+	int iCountTree = 0;
+	queue.push_back(m_pTreeBound);
+
+	while (queue.size())
+	{
+		CTreeBoundAIquad *pSplit = queue[0];
+
+		float3 vRootMin, vRootMax;
+		pSplit->m_pBoundBox->getMinMax(&vRootMin, &vRootMax);
+
+		for (int i = 0; i<4; i++)
+		{
+			pSplit->m_aSplits[i] = new CTreeBoundAIquad();
+		}
+
+		ISXBound* aBounds[4];
+		for (int i = 0; i < 4; ++i)
+		{
+			aBounds[i] = SGCore_CrBound();
+		}
+
+		float3 vMin, vMax, vNewMin, vNewMax;
+		SGCore_0ComBoundBoxArr4(pSplit->m_pBoundBox, aBounds);
+
+		bool isExists = false;
+		
+		for (int i = 0; i<4; i++)
+		{
+			pSplit->m_aSplits[i]->m_pBoundBox = aBounds[i];
+
+			pSplit->m_aSplits[i]->m_pBoundBox->getMinMax(&vMin, &vMax);
+			vNewMin = vMin;
+			vNewMax = vMax;
+			pSplit->m_aSplits[i]->m_i3Min = int3(AIGRID_TOINT(vMin.x), AIGRID_TOINT(vMin.y), AIGRID_TOINT(vMin.z));
+			pSplit->m_aSplits[i]->m_i3Max = int3(AIGRID_TOINT(vMax.x), AIGRID_TOINT(vMax.y), AIGRID_TOINT(vMax.z));
+
+			for (int k = 0, kl = pSplit->m_pBounds.size(); k < kl; k++)
+			{
+				CBoundAIquad *pBoundQuads = pSplit->m_pBounds[k];
+				//проверка вхождения бокса в бокс
+				if (
+					(pBoundQuads->m_f3Min.x >= vMin.x && pBoundQuads->m_f3Min.z >= vMin.z && pBoundQuads->m_f3Min.x <= vMax.x && pBoundQuads->m_f3Min.z <= vMax.z) ||
+					(pBoundQuads->m_f3Max.x <= vMax.x && pBoundQuads->m_f3Max.z <= vMax.z && pBoundQuads->m_f3Max.x >= vMin.x && pBoundQuads->m_f3Max.z >= vMin.z) ||
+					(pBoundQuads->m_f3Min.x >= vMin.x && pBoundQuads->m_f3Max.z <= vMax.z && pBoundQuads->m_f3Min.x <= vMax.x && pBoundQuads->m_f3Max.z >= vMin.z) ||
+					(pBoundQuads->m_f3Max.x <= vMax.x && pBoundQuads->m_f3Min.z >= vMin.z && pBoundQuads->m_f3Max.x >= vMin.x && pBoundQuads->m_f3Min.z <= vMax.z)
+					)
+				{
+					pSplit->m_aSplits[i]->m_pBounds.push_back(pBoundQuads);
+
+					if (vNewMin.x > pBoundQuads->m_f3Min.x)
+						vNewMin.x = pBoundQuads->m_f3Min.x;
+
+					if (vNewMin.z > pBoundQuads->m_f3Min.z)
+						vNewMin.z = pBoundQuads->m_f3Min.z;
+
+					if (vNewMax.x < pBoundQuads->m_f3Max.x)
+						vNewMax.x = pBoundQuads->m_f3Max.x;
+
+					if (vNewMax.z < pBoundQuads->m_f3Max.z)
+						vNewMax.z = pBoundQuads->m_f3Max.z;
+				}
+			}
+
+			pSplit->m_aSplits[i]->m_pBoundBox->setMinMax(&vNewMin, &vNewMax);
+			pSplit->m_aSplits[i]->m_i3Min = int3(AIGRID_TOINT(vNewMin.x), AIGRID_TOINT(vNewMin.y), AIGRID_TOINT(vNewMin.z));
+			pSplit->m_aSplits[i]->m_i3Max = int3(AIGRID_TOINT(vNewMax.x), AIGRID_TOINT(vNewMax.y), AIGRID_TOINT(vNewMax.z));
+
+			if ((vNewMax.x - vNewMin.x) > AIGRID_SPLIT_MIN_SIZE && (vNewMax.z - vNewMin.z) > AIGRID_SPLIT_MIN_SIZE)
+			{
+				queue.push_back(pSplit->m_aSplits[i]);
+				isExists = true;
+			}
+		}
+
+		if (isExists)
+			pSplit->m_pBounds.clear();
+
+		queue.erase(0);
+		++iCountTree;
+	}
+
+	LibReport(REPORT_MSG_LEVEL_NOTICE, "tree created, count nodes %d\n", iCountTree);
+}
+
+UINT CAIGrid::gridGetCountQuads() const
+{
+	return m_aQuads.size();
+}
+
+void CAIGrid::correctPosXZ(float3* pos)
+{
+	if (!pos)
+		return;
+
+	float count = pos->x / AIGRID_QUAD_SIZE;
+	pos->x = AIGRID_QUAD_SIZE * (float)((int)floor(count + 0.5));
+
+	/*count = pos->y / AIGRID_QUAD_SIZE;
+	pos->y = AIGRID_QUAD_SIZE * (float)((int)floor(count + 0.5));*/
+
+	count = pos->z / AIGRID_QUAD_SIZE;
+	pos->z = AIGRID_QUAD_SIZE * (float)((int)floor(count + 0.5));
 }
 
-void AIGrid::ReCreateBuffs()
+bool CAIGrid::isValidIdInArrQuads(ID id)
+{
+	return (id >= 0 && m_aQuads.size() > id && !(m_aQuads[id]->m_isClose));
+}
+
+bool CAIGrid::gridCompareHeight(ID id1, ID id2)
+{
+	return (
+		abs(
+		abs(m_aLongCoordQuads[id1].y) - abs(m_aLongCoordQuads[id2].y)
+		) > LAIGRID_QUADS_CENTERS_MAXHEIGHT ? false : true
+
+		);
+}
+
+void CAIGrid::reCreateBuffs()
 {
 	//GridClear();
-	mem_release_del(TransVertBuf);
-	if (ArrQuads.size() <= 0)
+	mem_release_del(m_pTransVertBuf);
+	if (m_aQuads.size() <= 0)
 	{
 		return;
 	}
 	
-	if (UseGraphics)
+	if (m_useGraphics)
 	{
-		DXDevice->CreateVertexBuffer(
-			ArrQuads.size() * sizeof(AIQuadVertexDataInst),
+		m_pDXDevice->CreateVertexBuffer(
+			m_aQuads.size() * sizeof(CAIQuadVertexDataInst),
 			D3DUSAGE_WRITEONLY,
 			0,
 			D3DPOOL_MANAGED,
-			&TransVertBuf,
+			&m_pTransVertBuf,
 			0);
 	}
 
-	ArrColor.resize(ArrQuads.size());
-	ArrIDsInOpen.resize(ArrQuads.size());
-	ArrCostQuads.resize(ArrQuads.size());
-	ArrOpenIDs.resize(ArrQuads.size());
-	ArrParentIDs.resize(ArrQuads.size());
-	ArrCloseIDs.resize(ArrQuads.size());
-	ArrState.resize(ArrQuads.size());
-	ArrStateWho.resize(ArrQuads.size());
-	ArrPreCondFreeState.resize(ArrQuads.size());
-	memset(&(ArrColor[0]), 0, ArrColor.size() * sizeof(uint32_t));
-	memset(&(ArrIDsInOpen[0]), -1, ArrIDsInOpen.size() * sizeof(ID));
-	memset(&(ArrCostQuads[0]), -1, ArrCostQuads.size() * sizeof(CostAIQuad));
-	memset(&(ArrOpenIDs[0]), -1, ArrOpenIDs.size() * sizeof(ID));
-	memset(&(ArrParentIDs[0]), -1, ArrParentIDs.size() * sizeof(ID));
-	memset(&(ArrCloseIDs[0]), 0, ArrCloseIDs.size() * sizeof(bool));
-	memset(&(ArrState[0]), (int)AIQUAD_STATE_FREE, ArrState.size() * sizeof(AIQUAD_STATE));
-	memset(&(ArrStateWho[0]), -1, ArrStateWho.size() * sizeof(ID));
-	memset(&(ArrPreCondFreeState[0]), false, ArrPreCondFreeState.size() * sizeof(bool));
+	m_aQuadColors.resize(m_aQuads.size());
+	m_aIDsInOpen.resize(m_aQuads.size());
+	m_aCostQuads.resize(m_aQuads.size());
+	m_aOpenIDs.resize(m_aQuads.size());
+	m_aParentIDs.resize(m_aQuads.size());
+	m_aTestSplitsIDs.resize(m_aQuads.size());
+	m_aQuadState.resize(m_aQuads.size());
+	m_aStateWho.resize(m_aQuads.size());
+	m_aPreCondFreeState.resize(m_aQuads.size());
+	memset(&(m_aQuadColors[0]), 0, m_aQuadColors.size() * sizeof(uint32_t));
+	memset(&(m_aIDsInOpen[0]), -1, m_aIDsInOpen.size() * sizeof(ID));
+	memset(&(m_aCostQuads[0]), -1, m_aCostQuads.size() * sizeof(CCostTransit));
+	memset(&(m_aOpenIDs[0]), -1, m_aOpenIDs.size() * sizeof(ID));
+	memset(&(m_aParentIDs[0]), -1, m_aParentIDs.size() * sizeof(ID));
+	memset(&(m_aTestSplitsIDs[0]), 0, m_aTestSplitsIDs.size() * sizeof(bool));
+	memset(&(m_aQuadState[0]), (int)AIQUAD_STATE_FREE, m_aQuadState.size() * sizeof(AIQUAD_STATE));
+	memset(&(m_aStateWho[0]), -1, m_aStateWho.size() * sizeof(ID));
+	memset(&(m_aPreCondFreeState[0]), false, m_aPreCondFreeState.size() * sizeof(bool));
 }
 
-void AIGrid::DefInitBuffs(ID id)
+void CAIGrid::defInitBuffs(ID id)
 {
-	mem_release_del(TransVertBuf);
-	if (ArrQuads.size() <= 0)
+	mem_release_del(m_pTransVertBuf);
+	if (m_aQuads.size() <= 0)
 	{
 		return;
 	}
 
-	if (UseGraphics)
+	if (m_useGraphics)
 	{
-		DXDevice->CreateVertexBuffer(
-			ArrQuads.size() * sizeof(AIQuadVertexDataInst),
+		m_pDXDevice->CreateVertexBuffer(
+			m_aQuads.size() * sizeof(CAIQuadVertexDataInst),
 			D3DUSAGE_WRITEONLY,
 			0,
 			D3DPOOL_MANAGED,
-			&TransVertBuf,
+			&m_pTransVertBuf,
 			0);
 	}
 
-	ArrColor[id] = 0;
-	ArrIDsInOpen[id] = -1;
-	ArrCostQuads[id] = CostAIQuad();
-	ArrOpenIDs[id] = -1;
-	ArrParentIDs[id] = -1;
-	ArrCloseIDs[id] = 0;
-	ArrState[id] = AIQUAD_STATE_FREE;
-	ArrStateWho[id] = -1;
-	ArrPreCondFreeState[id] = true;
+	m_aQuadColors[id] = 0;
+	m_aIDsInOpen[id] = -1;
+	m_aCostQuads[id] = CCostTransit();
+	m_aOpenIDs[id] = -1;
+	m_aParentIDs[id] = -1;
+	m_aTestSplitsIDs[id] = 0;
+	m_aQuadState[id] = AIQUAD_STATE_FREE;
+	m_aStateWho[id] = -1;
+	m_aPreCondFreeState[id] = true;
 }
 
-void AIGrid::BBCreate(const float3* center, const float3* param)
+void CAIGrid::bbCreate(const float3* center, const float3* param)
 {
-	if (ArrBound.size() > 1)
+	if (m_aBound.size() > 1)
 	{
 		LibReport(REPORT_MSG_LEVEL_WARNING, "bound box already splitting, unresolved create");
 		return;
@@ -289,36 +404,46 @@ void AIGrid::BBCreate(const float3* center, const float3* param)
 	if (!center || !param)
 		return;
 
-	BoundAIQuad* tmpbb;
+	CBoundAIquad* tmpbb;
 	
-	if(ArrBound.size() > 0)
-		tmpbb = ArrBound[0];
+	if(m_aBound.size() > 0)
+		tmpbb = m_aBound[0];
 	else
-		tmpbb = AllocBoundAIQuad.Alloc();
+		tmpbb = m_oAllocBound.Alloc();
+
+	tmpbb->m_f3Max = float3_t((*center) + (*param)*0.5f);
+	tmpbb->m_f3Min = float3_t((*center) - (*param)*0.5f);
+
+	tmpbb->m_i3Min.x = AIGRID_TOINT(tmpbb->m_f3Min.x);
+	tmpbb->m_i3Min.y = AIGRID_TOINT(tmpbb->m_f3Min.y);
+	tmpbb->m_i3Min.z = AIGRID_TOINT(tmpbb->m_f3Min.z);
 
-	tmpbb->max = float3_t((*center) + (*param)*0.5f);
-	tmpbb->min = float3_t((*center) - (*param)*0.5f);
-	mem_release(BoundBox);
+	tmpbb->m_i3Max.x = AIGRID_TOINT(tmpbb->m_f3Max.x);
+	tmpbb->m_i3Max.y = AIGRID_TOINT(tmpbb->m_f3Max.y);
+	tmpbb->m_i3Max.z = AIGRID_TOINT(tmpbb->m_f3Max.z);
 
-	if (UseGraphics)
-		SGCore_FCreateBoundingBoxMesh(&((float3)tmpbb->min), &((float3)tmpbb->max), &(BoundBox));
-	ArrBound.push_back(tmpbb);
+	mem_release(m_pBoundBox);
+
+	if (m_useGraphics)
+		SGCore_FCreateBoundingBoxMesh(&((float3)tmpbb->m_f3Min), &((float3)tmpbb->m_f3Max), &(m_pBoundBox));
+
+	m_aBound[0] = tmpbb;
 }
 
-bool AIGrid::BBIsCreated() const
+bool CAIGrid::bbIsCreated() const
 {
-	return (ArrBound.size() > 0);
+	return (m_aBound.size() > 0);
 }
 
-void AIGrid::BBSetDimensions(const float3* dim)
+void CAIGrid::bbSetDimensions(const float3* dim)
 {
-	if (ArrBound.size() <= 0)
+	if (m_aBound.size() <= 0)
 	{
 		LibReport(REPORT_MSG_LEVEL_WARNING, "bound box is not created");
 		return;
 	}
 
-	if (ArrBound.size() > 1)
+	if (m_aBound.size() > 1)
 	{
 		LibReport(REPORT_MSG_LEVEL_WARNING, "bound box already splitting, unresolved set dimensions");
 		return;
@@ -327,34 +452,34 @@ void AIGrid::BBSetDimensions(const float3* dim)
 	if (!dim)
 		return;
 
-	float3 tmpdim = ArrBound[0]->max - ArrBound[0]->min;
-	float3 tmpcx = (ArrBound[0]->max + ArrBound[0]->min) * 0.5f;
-	ArrBound[0]->min = (float3_t)(-(*dim) * 0.5f);
-	ArrBound[0]->max = (float3_t)((*dim) * 0.5f);
-	ArrBound[0]->min = (float3_t)(ArrBound[0]->min + tmpcx);
-	ArrBound[0]->max = (float3_t)(ArrBound[0]->max + tmpcx);
+	float3 tmpdim = m_aBound[0]->m_f3Max - m_aBound[0]->m_f3Min;
+	float3 tmpcx = (m_aBound[0]->m_f3Max + m_aBound[0]->m_f3Min) * 0.5f;
+	m_aBound[0]->m_f3Min = (float3_t)(-(*dim) * 0.5f);
+	m_aBound[0]->m_f3Max = (float3_t)((*dim) * 0.5f);
+	m_aBound[0]->m_f3Min = (float3_t)(m_aBound[0]->m_f3Min + tmpcx);
+	m_aBound[0]->m_f3Max = (float3_t)(m_aBound[0]->m_f3Max + tmpcx);
 
-	float3 tmpdim2 = ArrBound[0]->max - ArrBound[0]->min;
+	float3 tmpdim2 = m_aBound[0]->m_f3Max - m_aBound[0]->m_f3Min;
 	float3 tmpscale = tmpdim2 / tmpdim;
 
-	if (UseGraphics)
+	if (m_useGraphics)
 	{
 		char* tmppos;
-		BoundBox->LockVertexBuffer(0, (void**)&tmppos);
-		for (int i = 0; i < BoundBox->GetNumVertices(); i++)
+		m_pBoundBox->LockVertexBuffer(0, (void**)&tmppos);
+		for (int i = 0; i < m_pBoundBox->GetNumVertices(); i++)
 		{
-			float3_t* tpos = (float3_t*)((char*)(tmppos)+BoundBox->GetNumBytesPerVertex() * i);
+			float3_t* tpos = (float3_t*)((char*)(tmppos)+m_pBoundBox->GetNumBytesPerVertex() * i);
 			tpos->x *= tmpscale.x;
 			tpos->y *= tmpscale.y;
 			tpos->z *= tmpscale.z;
 		}
-		BoundBox->UnlockVertexBuffer();
+		m_pBoundBox->UnlockVertexBuffer();
 	}
 }
 
-void AIGrid::BBGetDimensions(float3* dim) const
+void CAIGrid::bbGetDimensions(float3* dim) const
 {
-	if (ArrBound.size() <= 0)
+	if (m_aBound.size() <= 0)
 	{
 		LibReport(REPORT_MSG_LEVEL_WARNING, "bound box is not created");
 		return;
@@ -363,20 +488,20 @@ void AIGrid::BBGetDimensions(float3* dim) const
 	if (!dim)
 		return;
 
-	dim->x = ArrBound[0]->max.x - ArrBound[0]->min.x;
-	dim->y = ArrBound[0]->max.y - ArrBound[0]->min.y;
-	dim->z = ArrBound[0]->max.z - ArrBound[0]->min.z;
+	dim->x = m_aBound[0]->m_f3Max.x - m_aBound[0]->m_f3Min.x;
+	dim->y = m_aBound[0]->m_f3Max.y - m_aBound[0]->m_f3Min.y;
+	dim->z = m_aBound[0]->m_f3Max.z - m_aBound[0]->m_f3Min.z;
 }
 
-void AIGrid::BBSetPos(const float3* pos)
+void CAIGrid::bbSetPos(const float3* pos)
 {
-	if (ArrBound.size() <= 0)
+	if (m_aBound.size() <= 0)
 	{
 		LibReport(REPORT_MSG_LEVEL_WARNING, "bound box is not created");
 		return;
 	}
 
-	if(ArrBound.size() > 1)
+	if(m_aBound.size() > 1)
 	{
 		LibReport(REPORT_MSG_LEVEL_WARNING, "bound box already splitting, unresolved set position");
 		return;
@@ -385,28 +510,28 @@ void AIGrid::BBSetPos(const float3* pos)
 	if (!pos)
 		return;
 
-	float3 tmpcenter = (float3(ArrBound[0]->max) + float3(ArrBound[0]->min)) * 0.5f;
-	ArrBound[0]->min = (float3_t)(float3(ArrBound[0]->min) + (-tmpcenter + (*pos)));
-	ArrBound[0]->max = (float3_t)(float3(ArrBound[0]->max) + (-tmpcenter + (*pos)));
+	float3 tmpcenter = (float3(m_aBound[0]->m_f3Max) + float3(m_aBound[0]->m_f3Min)) * 0.5f;
+	m_aBound[0]->m_f3Min = (float3_t)(float3(m_aBound[0]->m_f3Min) + (-tmpcenter + (*pos)));
+	m_aBound[0]->m_f3Max = (float3_t)(float3(m_aBound[0]->m_f3Max) + (-tmpcenter + (*pos)));
 	
-	if (UseGraphics)
+	if (m_useGraphics)
 	{
 		char* tmppos;
-		BoundBox->LockVertexBuffer(0, (void**)&tmppos);
-		for (int i = 0; i < BoundBox->GetNumVertices(); i++)
+		m_pBoundBox->LockVertexBuffer(0, (void**)&tmppos);
+		for (int i = 0; i < m_pBoundBox->GetNumVertices(); i++)
 		{
-			float3_t* tpos = (float3_t*)((char*)(tmppos)+BoundBox->GetNumBytesPerVertex() * i);
+			float3_t* tpos = (float3_t*)((char*)(tmppos)+m_pBoundBox->GetNumBytesPerVertex() * i);
 			tpos->x += -tmpcenter.x + (pos->x);
 			tpos->y += -tmpcenter.y + (pos->y);
 			tpos->z += -tmpcenter.z + (pos->z);
 		}
-		BoundBox->UnlockVertexBuffer();
+		m_pBoundBox->UnlockVertexBuffer();
 	}
 }
 
-void AIGrid::BBGetPos(float3* pos) const
+void CAIGrid::bbGetPos(float3* pos) const
 {
-	if (ArrBound.size() <= 0)
+	if (m_aBound.size() <= 0)
 	{
 		LibReport(REPORT_MSG_LEVEL_WARNING, "bound box is not created");
 		return;
@@ -415,19 +540,19 @@ void AIGrid::BBGetPos(float3* pos) const
 	if (!pos)
 		return;
 
-	*pos = (float3(ArrBound[0]->max) + float3(ArrBound[0]->min)) * 0.5f;
+	*pos = (float3(m_aBound[0]->m_f3Max) + float3(m_aBound[0]->m_f3Min)) * 0.5f;
 }
 
-void AIGrid::BBCreateFinish()
+void CAIGrid::bbCreateFinish()
 {
-	if (ArrBound.size() == 1)
+	if (m_aBound.size() == 1)
 	{
-		Max = float3_t(ArrBound[0]->max.x, ArrBound[0]->max.y, ArrBound[0]->max.z);
-		Min = float3_t(ArrBound[0]->min.x, ArrBound[0]->min.y, ArrBound[0]->min.z);
+		m_vMax = float3_t(m_aBound[0]->m_f3Max.x, m_aBound[0]->m_f3Max.y, m_aBound[0]->m_f3Max.z);
+		m_vMin = float3_t(m_aBound[0]->m_f3Min.x, m_aBound[0]->m_f3Min.y, m_aBound[0]->m_f3Min.z);
 
-		float tmpx = ArrBound[0]->max.x - ArrBound[0]->min.x;
-		float tmpy = ArrBound[0]->max.y - ArrBound[0]->min.y;
-		float tmpz = ArrBound[0]->max.z - ArrBound[0]->min.z;
+		float tmpx = m_aBound[0]->m_f3Max.x - m_aBound[0]->m_f3Min.x;
+		float tmpy = m_aBound[0]->m_f3Max.y - m_aBound[0]->m_f3Min.y;
+		float tmpz = m_aBound[0]->m_f3Max.z - m_aBound[0]->m_f3Min.z;
 
 		if (tmpx <= AIGRID_BBOXSIZE)
 			tmpx = 1;
@@ -444,507 +569,456 @@ void AIGrid::BBCreateFinish()
 		else
 			tmpz = tmpz / AIGRID_BBOXSIZE;
 
-		SplitBB(tmpx, tmpy, tmpz);
+		splitBB(tmpx, tmpy, tmpz);
+		createTreeBound();
 	}
 }
 
-bool AIGrid::BBIsCreatedFinish() const
+bool CAIGrid::bbIsCreatedFinish() const
 {
-	return (ArrBound.size() > 1);
+	return (m_aBound.size() > 1);
 }
 
-AIQUAD_STATE AIGrid::QuadGetState(ID id) const
+AIQUAD_STATE CAIGrid::quadGetState(ID id) const
 {
 	AIGRID_QUAD_PRECOND(id, AIQUAD_STATE::AIQUAD_STATE_FREE)
-	return ArrState[id];
+	return m_aQuadState[id];
 }
 
-void AIGrid::QuadSetState(ID id, AIQUAD_STATE state)
+void CAIGrid::quadSetState(ID id, AIQUAD_STATE state)
 {
 	AIGRID_QUAD_PRECOND(id, _VOID);
-	ArrState[id] = state;
+	m_aQuadState[id] = state;
 }
 
-void AIGrid::QuadSetStateWho(ID id, ID who)
+void CAIGrid::quadSetStateWho(ID id, ID who)
 {
 	AIGRID_QUAD_PRECOND(id, _VOID);
-	ArrStateWho[id] = who;
+	m_aStateWho[id] = who;
 }
 
-ID AIGrid::QuadGetStateWho(ID id)
+ID CAIGrid::quadGetStateWho(ID id) const
 {
 	AIGRID_QUAD_PRECOND(id, -1);
-	return ArrStateWho[id];
+	return m_aStateWho[id];
 }
 
-bool AIGrid::QuadIs2Neighbors(ID id, ID idn1, ID idn2)
+bool CAIGrid::quadIs2Neighbors(ID id, ID idn1, ID idn2) const
 {
 	AIGRID_QUAD_PRECOND(id, false);
 	AIGRID_QUAD_PRECOND(idn1, false);
 	AIGRID_QUAD_PRECOND(idn2, false);
 
-	AIQuad* aq = ArrQuads[id];
+	CAIquad* aq = m_aQuads[id];
 	int concurrence = 0;
 	for (int i = 0; i < 8; ++i)
 	{
-		if (aq->Arr[i] == idn1 || aq->Arr[i] == idn2)
+		if (aq->m_aNeighbors[i] == idn1 || aq->m_aNeighbors[i] == idn2)
 			++concurrence;
 	}
 
 	return (concurrence == 2);
 }
 
-void AIGrid::QuadSetPosY(ID id, float posy)
+void CAIGrid::quadSetPosY(ID id, float posy)
 {
 	AIGRID_QUAD_PRECOND(id, _VOID);
-	ArrQuads[id]->pos.y = posy;
+	m_aQuads[id]->m_vPos.y = posy;
 }
 
-float AIGrid::QuadGetPosY(ID id) const
+float CAIGrid::quadGetPosY(ID id) const
 {
 	AIGRID_QUAD_PRECOND(id, 0);
-	return ArrQuads[id]->pos.y;
+	return m_aQuads[id]->m_vPos.y;
 }
 
-ID AIGrid::QuadAdd(const float3* pos)
+ID CAIGrid::quadAdd(const float3* pos)
 {
-	ID idquad = QuadGet(pos,false);
+	ID idquad = quadGet(pos,false);
 
-	AIQuad* aq = 0;
+	CAIquad* aq = 0;
 	if (idquad >= 0)
 	{
-		if (!(ArrQuads[idquad]->IsClose))
+		if (!(m_aQuads[idquad]->m_isClose))
 			return idquad;
 		else
 		{
-			aq = ArrQuads[idquad];
-			aq->IsClose = false;
+			aq = m_aQuads[idquad];
+			aq->m_isClose = false;
 		}
 	}
 	else
-		aq = AllocAIQuad.Alloc();
+		aq = m_oAllocQuad.Alloc();
 
 	float3 tpos(*pos);
-	CorrectPosXZ(&tpos);
-	aq->pos.x = tpos.x;
-	aq->pos.y = tpos.y;
-	aq->pos.z = tpos.z;
+	correctPosXZ(&tpos);
+	aq->m_vPos.x = tpos.x;
+	aq->m_vPos.y = tpos.y;
+	aq->m_vPos.z = tpos.z;
 
-	aq->pos.y += AIGRID_QUAD_ADDYPOS;
-	ArrQuads.push_back(aq);
-	idquad = ArrQuads.size() - 1;
-	aq->Id = idquad;
-	DefInitBuffs(idquad);
+	aq->m_vPos.y += AIGRID_QUAD_ADDYPOS;
+	m_aQuads.push_back(aq);
+	idquad = m_aQuads.size() - 1;
+	aq->m_id = idquad;
+	defInitBuffs(idquad);
 
-	ID idneighboor = QuadGet(&float3(float3(aq->pos) + float3(-AIGRID_QUAD_SIZE, 0, AIGRID_QUAD_SIZE)), false);
-	if (IsValidIdInArrQuads(idneighboor))
+	ID idneighboor = quadGet(&float3(float3(aq->m_vPos) + float3(-AIGRID_QUAD_SIZE, 0, AIGRID_QUAD_SIZE)), false);
+	if (isValidIdInArrQuads(idneighboor))
 	{
-		aq->Arr[0] = idneighboor;
-		ArrQuads[idneighboor]->Arr[7] = idquad;
+		aq->m_aNeighbors[0] = idneighboor;
+		m_aQuads[idneighboor]->m_aNeighbors[7] = idquad;
 	}
 
-	idneighboor = QuadGet(&float3(float3(aq->pos) + float3(0, 0, AIGRID_QUAD_SIZE)), false);
-	if (IsValidIdInArrQuads(idneighboor))
+	idneighboor = quadGet(&float3(float3(aq->m_vPos) + float3(0, 0, AIGRID_QUAD_SIZE)), false);
+	if (isValidIdInArrQuads(idneighboor))
 	{
-		aq->Arr[1] = idneighboor;
-		ArrQuads[idneighboor]->Arr[6] = idquad;
+		aq->m_aNeighbors[1] = idneighboor;
+		m_aQuads[idneighboor]->m_aNeighbors[6] = idquad;
 
-		if (IsValidIdInArrQuads(ArrQuads[idneighboor]->Arr[1]))
-			ArrQuads[idneighboor]->axisy = AIGRID_QUAD_DIR_ALL;
+		if (isValidIdInArrQuads(m_aQuads[idneighboor]->m_aNeighbors[1]))
+			m_aQuads[idneighboor]->m_chAxisY = AIGRID_QUAD_DIR_ALL;
 		else
-			ArrQuads[idneighboor]->axisy = AIGRID_QUAD_DIR_NEGATIVE;
+			m_aQuads[idneighboor]->m_chAxisY = AIGRID_QUAD_DIR_NEGATIVE;
 	}
 
-	idneighboor = QuadGet(&float3(float3(aq->pos) + float3(AIGRID_QUAD_SIZE, 0, AIGRID_QUAD_SIZE)), false);
-	if (IsValidIdInArrQuads(idneighboor))
+	idneighboor = quadGet(&float3(float3(aq->m_vPos) + float3(AIGRID_QUAD_SIZE, 0, AIGRID_QUAD_SIZE)), false);
+	if (isValidIdInArrQuads(idneighboor))
 	{
-		aq->Arr[2] = idneighboor;
-		ArrQuads[idneighboor]->Arr[5] = idquad;
+		aq->m_aNeighbors[2] = idneighboor;
+		m_aQuads[idneighboor]->m_aNeighbors[5] = idquad;
 	}
 
-	idneighboor = QuadGet(&float3(float3(aq->pos) + float3(-AIGRID_QUAD_SIZE, 0, 0)), false);
-	if (IsValidIdInArrQuads(idneighboor))
+	idneighboor = quadGet(&float3(float3(aq->m_vPos) + float3(-AIGRID_QUAD_SIZE, 0, 0)), false);
+	if (isValidIdInArrQuads(idneighboor))
 	{
-		aq->Arr[3] = idneighboor;
-		ArrQuads[idneighboor]->Arr[4] = idquad;
+		aq->m_aNeighbors[3] = idneighboor;
+		m_aQuads[idneighboor]->m_aNeighbors[4] = idquad;
 
-		if (IsValidIdInArrQuads(ArrQuads[idneighboor]->Arr[3]))
-			ArrQuads[idneighboor]->axisx = AIGRID_QUAD_DIR_ALL;
+		if (isValidIdInArrQuads(m_aQuads[idneighboor]->m_aNeighbors[3]))
+			m_aQuads[idneighboor]->m_chAxisX = AIGRID_QUAD_DIR_ALL;
 		else
-			ArrQuads[idneighboor]->axisx = AIGRID_QUAD_DIR_POSITIVE;
+			m_aQuads[idneighboor]->m_chAxisX = AIGRID_QUAD_DIR_POSITIVE;
 	}
 
-	idneighboor = QuadGet(&float3(float3(aq->pos) + float3(AIGRID_QUAD_SIZE, 0, 0)), false);
-	if (IsValidIdInArrQuads(idneighboor))
+	idneighboor = quadGet(&float3(float3(aq->m_vPos) + float3(AIGRID_QUAD_SIZE, 0, 0)), false);
+	if (isValidIdInArrQuads(idneighboor))
 	{
-		aq->Arr[4] = idneighboor;
-		ArrQuads[idneighboor]->Arr[3] = idquad;
+		aq->m_aNeighbors[4] = idneighboor;
+		m_aQuads[idneighboor]->m_aNeighbors[3] = idquad;
 
-		if (IsValidIdInArrQuads(ArrQuads[idneighboor]->Arr[4]))
-			ArrQuads[idneighboor]->axisx = AIGRID_QUAD_DIR_ALL;
+		if (isValidIdInArrQuads(m_aQuads[idneighboor]->m_aNeighbors[4]))
+			m_aQuads[idneighboor]->m_chAxisX = AIGRID_QUAD_DIR_ALL;
 		else
-			ArrQuads[idneighboor]->axisx = AIGRID_QUAD_DIR_NEGATIVE;
+			m_aQuads[idneighboor]->m_chAxisX = AIGRID_QUAD_DIR_NEGATIVE;
 	}
 
-	idneighboor = QuadGet(&float3(float3(aq->pos) + float3(-AIGRID_QUAD_SIZE, 0, -AIGRID_QUAD_SIZE)), false);
-	if (IsValidIdInArrQuads(idneighboor))
+	idneighboor = quadGet(&float3(float3(aq->m_vPos) + float3(-AIGRID_QUAD_SIZE, 0, -AIGRID_QUAD_SIZE)), false);
+	if (isValidIdInArrQuads(idneighboor))
 	{
-		aq->Arr[5] = idneighboor;
-		ArrQuads[idneighboor]->Arr[2] = idquad;
+		aq->m_aNeighbors[5] = idneighboor;
+		m_aQuads[idneighboor]->m_aNeighbors[2] = idquad;
 	}
 
-	idneighboor = QuadGet(&float3(float3(aq->pos) + float3(0, 0, -AIGRID_QUAD_SIZE)), false);
-	if (IsValidIdInArrQuads(idneighboor))
+	idneighboor = quadGet(&float3(float3(aq->m_vPos) + float3(0, 0, -AIGRID_QUAD_SIZE)), false);
+	if (isValidIdInArrQuads(idneighboor))
 	{
-		aq->Arr[6] = idneighboor;
-		ArrQuads[idneighboor]->Arr[1] = idquad;
+		aq->m_aNeighbors[6] = idneighboor;
+		m_aQuads[idneighboor]->m_aNeighbors[1] = idquad;
 
-		if (IsValidIdInArrQuads(ArrQuads[idneighboor]->Arr[6]))
-			ArrQuads[idneighboor]->axisy = AIGRID_QUAD_DIR_ALL;
+		if (isValidIdInArrQuads(m_aQuads[idneighboor]->m_aNeighbors[6]))
+			m_aQuads[idneighboor]->m_chAxisY = AIGRID_QUAD_DIR_ALL;
 		else
-			ArrQuads[idneighboor]->axisy = AIGRID_QUAD_DIR_POSITIVE;
+			m_aQuads[idneighboor]->m_chAxisY = AIGRID_QUAD_DIR_POSITIVE;
 	}
 
-	idneighboor = QuadGet(&float3(float3(aq->pos) + float3(AIGRID_QUAD_SIZE, 0, -AIGRID_QUAD_SIZE)), false);
-	if (IsValidIdInArrQuads(idneighboor))
+	idneighboor = quadGet(&float3(float3(aq->m_vPos) + float3(AIGRID_QUAD_SIZE, 0, -AIGRID_QUAD_SIZE)), false);
+	if (isValidIdInArrQuads(idneighboor))
 	{
-		aq->Arr[7] = idneighboor;
-		ArrQuads[idneighboor]->Arr[0] = idquad;
+		aq->m_aNeighbors[7] = idneighboor;
+		m_aQuads[idneighboor]->m_aNeighbors[0] = idquad;
 	}
 
 	//определяем возможные направления из квада по оси Y
-	if (IsValidIdInArrQuads(aq->Arr[1]) && IsValidIdInArrQuads(aq->Arr[6]))
-		aq->axisy = AIGRID_QUAD_DIR_ALL;
-	else if (IsValidIdInArrQuads(aq->Arr[1]) && !IsValidIdInArrQuads(aq->Arr[6]))
-		aq->axisy = AIGRID_QUAD_DIR_POSITIVE;
-	else if (!IsValidIdInArrQuads(aq->Arr[1]) && IsValidIdInArrQuads(aq->Arr[6]))
-		aq->axisy = AIGRID_QUAD_DIR_NEGATIVE;
+	if (isValidIdInArrQuads(aq->m_aNeighbors[1]) && isValidIdInArrQuads(aq->m_aNeighbors[6]))
+		aq->m_chAxisY = AIGRID_QUAD_DIR_ALL;
+	else if (isValidIdInArrQuads(aq->m_aNeighbors[1]) && !isValidIdInArrQuads(aq->m_aNeighbors[6]))
+		aq->m_chAxisY = AIGRID_QUAD_DIR_POSITIVE;
+	else if (!isValidIdInArrQuads(aq->m_aNeighbors[1]) && isValidIdInArrQuads(aq->m_aNeighbors[6]))
+		aq->m_chAxisY = AIGRID_QUAD_DIR_NEGATIVE;
 	else
-		aq->axisy = AIGRID_QUAD_DIR_NONE;
+		aq->m_chAxisY = AIGRID_QUAD_DIR_NONE;
 
 	//определяем возможные направления из квада по оси X
-	if (IsValidIdInArrQuads(aq->Arr[3]) && IsValidIdInArrQuads(aq->Arr[4]))
-		aq->axisx = AIGRID_QUAD_DIR_ALL;
-	else if (IsValidIdInArrQuads(aq->Arr[3]) && !IsValidIdInArrQuads(aq->Arr[4]))
-		aq->axisx = AIGRID_QUAD_DIR_NEGATIVE;
-	else if (!IsValidIdInArrQuads(aq->Arr[3]) && IsValidIdInArrQuads(aq->Arr[4]))
-		aq->axisx = AIGRID_QUAD_DIR_POSITIVE;
+	if (isValidIdInArrQuads(aq->m_aNeighbors[3]) && isValidIdInArrQuads(aq->m_aNeighbors[4]))
+		aq->m_chAxisX = AIGRID_QUAD_DIR_ALL;
+	else if (isValidIdInArrQuads(aq->m_aNeighbors[3]) && !isValidIdInArrQuads(aq->m_aNeighbors[4]))
+		aq->m_chAxisX = AIGRID_QUAD_DIR_NEGATIVE;
+	else if (!isValidIdInArrQuads(aq->m_aNeighbors[3]) && isValidIdInArrQuads(aq->m_aNeighbors[4]))
+		aq->m_chAxisX = AIGRID_QUAD_DIR_POSITIVE;
 	else
-		aq->axisx = AIGRID_QUAD_DIR_NONE;
+		aq->m_chAxisX = AIGRID_QUAD_DIR_NONE;
 
-	AddUniqQuadArrag(aq);
-	CountSplits = 0;
+	addUniqQuadArrag(aq);
+	m_uiCountSplits = 0;
 	return idquad;
 }
 
-bool AIGrid::QuadDelete(ID id)
+bool CAIGrid::quadDelete(ID id)
 {
 	AIGRID_QUAD_PRECOND(id, false);
 
-	AIQuad* aq = ArrQuads[id];
+	CAIquad* aq = m_aQuads[id];
 
-	if (aq->Arr[0] != -1)
+	if (aq->m_aNeighbors[0] != -1)
 	{
-		ArrQuads[aq->Arr[0]]->Arr[7] = -1;
+		m_aQuads[aq->m_aNeighbors[0]]->m_aNeighbors[7] = -1;
 	}
 
-	if (aq->Arr[1] != -1)
+	if (aq->m_aNeighbors[1] != -1)
 	{
 		
-		ArrQuads[aq->Arr[1]]->Arr[6] = -1;
-		if (IsValidIdInArrQuads(ArrQuads[aq->Arr[1]]->Arr[1]))
-			ArrQuads[aq->Arr[1]]->axisy = AIGRID_QUAD_DIR_POSITIVE;
+		m_aQuads[aq->m_aNeighbors[1]]->m_aNeighbors[6] = -1;
+		if (isValidIdInArrQuads(m_aQuads[aq->m_aNeighbors[1]]->m_aNeighbors[1]))
+			m_aQuads[aq->m_aNeighbors[1]]->m_chAxisY = AIGRID_QUAD_DIR_POSITIVE;
 		else
-			ArrQuads[aq->Arr[1]]->axisy = AIGRID_QUAD_DIR_NONE;
+			m_aQuads[aq->m_aNeighbors[1]]->m_chAxisY = AIGRID_QUAD_DIR_NONE;
 	}
 
-	if (aq->Arr[2] != -1)
+	if (aq->m_aNeighbors[2] != -1)
 	{
-		ArrQuads[aq->Arr[2]]->Arr[5] = -1;
+		m_aQuads[aq->m_aNeighbors[2]]->m_aNeighbors[5] = -1;
 	}
 
-	if (aq->Arr[3] != -1)
+	if (aq->m_aNeighbors[3] != -1)
 	{
-		ArrQuads[aq->Arr[3]]->Arr[4] = -1;
-		if (IsValidIdInArrQuads(ArrQuads[aq->Arr[3]]->Arr[3]))
-			ArrQuads[aq->Arr[3]]->axisx = AIGRID_QUAD_DIR_NEGATIVE;
+		m_aQuads[aq->m_aNeighbors[3]]->m_aNeighbors[4] = -1;
+		if (isValidIdInArrQuads(m_aQuads[aq->m_aNeighbors[3]]->m_aNeighbors[3]))
+			m_aQuads[aq->m_aNeighbors[3]]->m_chAxisX = AIGRID_QUAD_DIR_NEGATIVE;
 		else
-			ArrQuads[aq->Arr[3]]->axisx = AIGRID_QUAD_DIR_NONE;
+			m_aQuads[aq->m_aNeighbors[3]]->m_chAxisX = AIGRID_QUAD_DIR_NONE;
 	}
 
-	if (aq->Arr[4] != -1)
+	if (aq->m_aNeighbors[4] != -1)
 	{
-		ArrQuads[aq->Arr[4]]->Arr[3] = -1;
-		if (IsValidIdInArrQuads(ArrQuads[aq->Arr[4]]->Arr[4]))
-			ArrQuads[aq->Arr[4]]->axisx = AIGRID_QUAD_DIR_POSITIVE;
+		m_aQuads[aq->m_aNeighbors[4]]->m_aNeighbors[3] = -1;
+		if (isValidIdInArrQuads(m_aQuads[aq->m_aNeighbors[4]]->m_aNeighbors[4]))
+			m_aQuads[aq->m_aNeighbors[4]]->m_chAxisX = AIGRID_QUAD_DIR_POSITIVE;
 		else
-			ArrQuads[aq->Arr[4]]->axisx = AIGRID_QUAD_DIR_NONE;
+			m_aQuads[aq->m_aNeighbors[4]]->m_chAxisX = AIGRID_QUAD_DIR_NONE;
 	}
 
-	if (aq->Arr[5] != -1)
+	if (aq->m_aNeighbors[5] != -1)
 	{
-		ArrQuads[aq->Arr[5]]->Arr[2] = -1;
+		m_aQuads[aq->m_aNeighbors[5]]->m_aNeighbors[2] = -1;
 	}
 
-	if (aq->Arr[6] != -1)
+	if (aq->m_aNeighbors[6] != -1)
 	{
-		ArrQuads[aq->Arr[6]]->Arr[1] = -1;
-		if (IsValidIdInArrQuads(ArrQuads[aq->Arr[6]]->Arr[6]))
-			ArrQuads[aq->Arr[6]]->axisy = AIGRID_QUAD_DIR_NEGATIVE;
+		m_aQuads[aq->m_aNeighbors[6]]->m_aNeighbors[1] = -1;
+		if (isValidIdInArrQuads(m_aQuads[aq->m_aNeighbors[6]]->m_aNeighbors[6]))
+			m_aQuads[aq->m_aNeighbors[6]]->m_chAxisY = AIGRID_QUAD_DIR_NEGATIVE;
 		else
-			ArrQuads[aq->Arr[6]]->axisy = AIGRID_QUAD_DIR_NONE;
+			m_aQuads[aq->m_aNeighbors[6]]->m_chAxisY = AIGRID_QUAD_DIR_NONE;
 	}
 
-	if (aq->Arr[7] != -1)
+	if (aq->m_aNeighbors[7] != -1)
 	{
-		ArrQuads[aq->Arr[7]]->Arr[0] = -1;
+		m_aQuads[aq->m_aNeighbors[7]]->m_aNeighbors[0] = -1;
 	}
 	
-	aq->IsClose = true;
-	aq->axisx = aq->axisy = AIGRID_QUAD_DIR_NONE;
+	aq->m_isClose = true;
+	aq->m_chAxisX = aq->m_chAxisY = AIGRID_QUAD_DIR_NONE;
 	for (int i = 0; i < 8; ++i)
 	{
-		aq->Arr[i] = -1;
+		aq->m_aNeighbors[i] = -1;
 	}
-	CountSplits = 0;
+	m_uiCountSplits = 0;
 
-	QuadDelete2(aq->Id);
+	quadDelete2(aq->m_id);
 	return true;
 }
 
-void AIGrid::QuadDeleteInvalidAll()
+void CAIGrid::quadDeleteInvalidAll()
 {
-	AIQuad* aq = 0;
+	CAIquad* aq = 0;
 	ID iddel = -1;
-	for (long i = 0, il = ArrQuads.size(); i < il; ++i)
+	for (long i = 0, il = m_aQuads.size(); i < il; ++i)
 	{
-		aq = ArrQuads[i];		
-		if (aq && (aq->IsClose || (aq->axisx == AIGRID_QUAD_DIR_NONE && aq->axisy == AIGRID_QUAD_DIR_NONE)))
+		aq = m_aQuads[i];		
+		if (aq && (aq->m_isClose || (aq->m_chAxisX == AIGRID_QUAD_DIR_NONE && aq->m_chAxisY == AIGRID_QUAD_DIR_NONE)))
 		{
-			QuadDelete(i);
-			il = ArrQuads.size();
+			quadDelete(i);
+			il = m_aQuads.size();
 		}
 	}
 }
 
-void AIGrid::QuadDelete2(ID id)
+void CAIGrid::quadDelete2(ID id)
 {
 	AIGRID_QUAD_PRECOND(id, _VOID);
 
-	AIQuad* aq = 0;
-	for (long i = 0, il = ArrQuads.size(); i < il; ++i)
+	CAIquad* aq = 0;
+	for (long i = 0, il = m_aQuads.size(); i < il; ++i)
 	{
-		aq = ArrQuads[i];
+		aq = m_aQuads[i];
 
-		if (aq->Id > id)
-			--(aq->Id);
+		if (aq->m_id > id)
+			--(aq->m_id);
 
 		for (int k = 0; k < 8; ++k)
 		{
-			if (aq->Arr[k] > id)
-				--(aq->Arr[k]);
-			else if (aq->Arr[k] == id)
-				aq->Arr[k] = -1;
+			if (aq->m_aNeighbors[k] > id)
+				--(aq->m_aNeighbors[k]);
+			else if (aq->m_aNeighbors[k] == id)
+				aq->m_aNeighbors[k] = -1;
 		}
 	}
 
-	BoundAIQuad* bound = 0;
-	long tmpx = toint100(ArrQuads[id]->pos.x);
-	long tmpy = toint100(ArrQuads[id]->pos.y);
-	long tmpz = toint100(ArrQuads[id]->pos.z);
+	CBoundAIquad* bound = 0;
+	long tmpx = AIGRID_TOINT(m_aQuads[id]->m_vPos.x);
+	long tmpy = AIGRID_TOINT(m_aQuads[id]->m_vPos.y);
+	long tmpz = AIGRID_TOINT(m_aQuads[id]->m_vPos.z);
 
-	for (int i = 1, il = ArrBound.size(); i <il; ++i)
+	for (int i = 1, il = m_aBound.size(); i <il; ++i)
 	{
-		bound = ArrBound[i];
-		for (int k = 0, kl = bound->ArrIdsQuads.size(); k < kl; ++k)
+		bound = m_aBound[i];
+		for (int k = 0, kl = bound->m_aIdsQuads.size(); k < kl; ++k)
 		{
-			if (bound->ArrIdsQuads[k] > id)
-				--(bound->ArrIdsQuads[k]);
-			else if (bound->ArrIdsQuads[k] == id)
+			if (bound->m_aIdsQuads[k] > id)
+				--(bound->m_aIdsQuads[k]);
+			else if (bound->m_aIdsQuads[k] == id)
 			{
-				bound->ArrIdsQuads.erase(k);
+				bound->m_aIdsQuads.erase(k);
 				--k;
-				kl = bound->ArrIdsQuads.size();
+				kl = bound->m_aIdsQuads.size();
 			}
 		}
 	}
 
-	for (int i = 0, il = ArrGraphPointsIDs.size(); i < il; ++i)
+	for (int i = 0, il = m_aGraphPointsIDs.size(); i < il; ++i)
 	{
-		if (ArrGraphPointsIDs[i] > id)
-			--(ArrGraphPointsIDs[i]);
-		else if (ArrGraphPointsIDs[i] == id)
-			ArrGraphPointsIDs.erase(i);
+		if (m_aGraphPointsIDs[i] > id)
+			--(m_aGraphPointsIDs[i]);
+		else if (m_aGraphPointsIDs[i] == id)
+			m_aGraphPointsIDs.erase(i);
 	}
 
-	ArrLongCoordQuads.erase(id);
-	AllocAIQuad.Delete(ArrQuads[id]);
-	ArrQuads.erase(id);
+	m_aLongCoordQuads.erase(id);
+	m_oAllocQuad.Delete(m_aQuads[id]);
+	m_aQuads.erase(id);
 
 	/*mem_release(TransVertBuf);
-	DXDevice->CreateVertexBuffer(
-		ArrQuads.size() * sizeof(AIQuadVertexDataInst),
+	m_pDXDevice->CreateVertexBuffer(
+		m_aQuads.size() * sizeof(CAIQuadVertexDataInst),
 		D3DUSAGE_WRITEONLY,
 		0,
 		D3DPOOL_MANAGED,
 		&TransVertBuf,
 		0);*/
 
-	ArrColor.erase(id);
-	ArrIDsInOpen.erase(id);
-	ArrCostQuads.erase(id);
-	ArrOpenIDs.erase(id);
-	ArrParentIDs.erase(id);
-	ArrCloseIDs.erase(id);
-	ArrState.erase(id);
-	ArrStateWho.erase(id);
-	ArrPreCondFreeState.erase(id);
+	m_aQuadColors.erase(id);
+	m_aIDsInOpen.erase(id);
+	m_aCostQuads.erase(id);
+	m_aOpenIDs.erase(id);
+	m_aParentIDs.erase(id);
+	m_aTestSplitsIDs.erase(id);
+	m_aQuadState.erase(id);
+	m_aStateWho.erase(id);
+	m_aPreCondFreeState.erase(id);
 }
 
-void AIGrid::QuadSelect(ID id, bool consider_prev)
+void CAIGrid::quadSelect(ID id, bool consider_prev)
 {
 	if (id < 0)
 	{
-		ArrSelected.clear();
+		m_aSelectedQuads.clear();
 		return;
 	}
 
 	AIGRID_QUAD_PRECOND(id, _VOID);
 
 	if (!consider_prev)
-		ArrSelected.clear();
+		m_aSelectedQuads.clear();
 
-	if (QuadSelectedExists(id))
+	if (quadSelectedExists(id))
 		return;
 
-	ArrSelected.push_back(id);
+	m_aSelectedQuads.push_back(id);
 }
 
-bool AIGrid::QuadSelectedExists(ID id)
+bool CAIGrid::quadSelectedExists(ID id)
 {
-	for (int i = 0, il = ArrSelected.size(); i < il; ++i)
+	for (int i = 0, il = m_aSelectedQuads.size(); i < il; ++i)
 	{
-		if (ArrSelected[i] == id)
+		if (m_aSelectedQuads[i] == id)
 			return true;
 	}
 
 	return false;
 }
 
-bool AIGrid::QuadSelectedExistsNeightborDirect(ID id)
+bool CAIGrid::quadSelectedExistsNeightborDirect(ID id)
 {
 	AIGRID_QUAD_PRECOND(id, false);
 
-	if (ArrSelected.size() <= 0)
+	if (m_aSelectedQuads.size() <= 0)
 		return false;
 
-	if (QuadSelectedExists(id))
+	if (quadSelectedExists(id))
 		return false;
 
-	AIQuad* aq = ArrQuads[id];
+	CAIquad* aq = m_aQuads[id];
 
-	if (QuadSelectedExists(aq->Arr[1]))
+	if (quadSelectedExists(aq->m_aNeighbors[1]))
 		return true;
 
-	if (QuadSelectedExists(aq->Arr[3]))
+	if (quadSelectedExists(aq->m_aNeighbors[3]))
 		return true;
 
-	if (QuadSelectedExists(aq->Arr[4]))
+	if (quadSelectedExists(aq->m_aNeighbors[4]))
 		return true;
 
-	if (QuadSelectedExists(aq->Arr[6]))
+	if (quadSelectedExists(aq->m_aNeighbors[6]))
 		return true;
 
 	return false;
 }
 
-void AIGrid::QuadSelectedAddPosY(float posy)
+void CAIGrid::quadSelectedAddPosY(float posy)
 {
-	for (int i = 0, il = ArrSelected.size(); i < il; ++i)
+	for (int i = 0, il = m_aSelectedQuads.size(); i < il; ++i)
 	{
-		if (ArrSelected[i] >= 0 && ArrQuads.size() > ArrSelected[i])
-			ArrQuads[ArrSelected[i]]->pos.y += posy;
+		if (m_aSelectedQuads[i] >= 0 && m_aQuads.size() > m_aSelectedQuads[i])
+			m_aQuads[m_aSelectedQuads[i]]->m_vPos.y += posy;
 	}
 }
 
-void AIGrid::QuadSelectedDelete()
+void CAIGrid::quadSelectedDelete()
 {
-	for (int i = 0, il = ArrSelected.size(); i < il; ++i)
+	for (int i = 0, il = m_aSelectedQuads.size(); i < il; ++i)
 	{
-		QuadDelete(ArrSelected[i]);
+		quadDelete(m_aSelectedQuads[i]);
 	}
 
-	ArrSelected.clear();
+	m_aSelectedQuads.clear();
 }
 
-void AIGrid::PhyNavigate(AIQuad* quad)
+void CAIGrid::phyNavigate(CAIquad *pQuad)
 {
-	quad->IsClose = AIQuadPhyNavigate(&(quad->pos));
-	/*static btBoxShape boxfull(btVector3(AIGRID_QUAD_SIZEDIV2, AIGRID_ENTITY_MAX_HEIGHTDIV2, AIGRID_QUAD_SIZEDIV2));
-	float3 start = quad->pos;
-	start.y = quad->pos.y + AIGRID_ENTITY_MAX_HEIGHT;
-	float3 end = quad->pos;
-	//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));
-	
-	static btTransform xForm;
-	xForm.setOrigin(F3_BTVEC(start));
-	xForm.getBasis().setIdentity();
-	static btTransform xForm2;
-	xForm2.setOrigin(F3_BTVEC(end));
-	xForm2.getBasis().setIdentity();
-	SXPhysics_GetDynWorld()->convexSweepTest(&boxfull, xForm, xForm2, cb);
-
-	if (cb.hasHit())
-	{
-		quad->pos.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 = quad->pos;
-		start.y = quad->pos.y + AIGRID_ENTITY_MAX_HEIGHTDIV2 + AIGRID_QUADS_CENTERS_MAXHEIGHT;
-		static btVector3 vec;
-		vec = btVector3(F3_BTVEC(start));
-		cb = btDiscreteDynamicsWorld::ClosestConvexResultCallback(vec, vec);
-		static btVector3 offs;
-		for (int x = -1; x <= 1; ++x)
-		{
-			for (int z = -1; z <= 1; ++z)
-			{
-				offs[0] = 0.5f*float(x) * 0.01f;
-				offs[1] = 1.f * 0.01f;
-				offs[2] = 0.5f*float(z) * 0.01f;
-				xForm.setOrigin(vec - offs);
-				xForm.getBasis().setIdentity();
-				xForm2.setOrigin(vec + offs);
-				xForm2.getBasis().setIdentity();
-				SXPhysics_GetDynWorld()->convexSweepTest(&boxoff, xForm, xForm2, cb);
-
-				if (cb.hasHit())
-				{
-					quad->IsClose = true;
-					return;
-				}
-			}
-		}
-	}
-	else
-		quad->IsClose = true;*/
+	pQuad->m_isClose = AIQuadPhyNavigate(&(pQuad->m_vPos));
 }
 
-void AIGrid::GraphicsInit()
+void CAIGrid::initGraphics()
 {
-	UseGraphics = true;
-	DXDevice = SGCore_GetDXDevice();
+	m_useGraphics = true;
+	m_pDXDevice = SGCore_GetDXDevice();
 
-	if (!DXDevice)
+	if (!m_pDXDevice)
 	{
 		LibReport(REPORT_MSG_LEVEL_ERROR, "%s - dx device is not init", GEN_MSG_LOCATION);
 	}
 
-	D3DVERTEXELEMENT9 InstanceAIQuad[] =
+	D3DVERTEXELEMENT9 InstanceCAIquad[] =
 	{
 		{ 0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 },
 		{ 0, 12, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 },
@@ -956,16 +1030,16 @@ void AIGrid::GraphicsInit()
 		D3DDECL_END()
 	};
 
-	DXDevice->CreateVertexDeclaration(InstanceAIQuad, &AIQuadDecl);
+	m_pDXDevice->CreateVertexDeclaration(InstanceCAIquad, &m_pDecl);
 
-	Tex_AIGrid = SGCore_LoadTexAddName("decal_aigrid1.dds", LOAD_TEXTURE_TYPE_CONST);
+	m_idTex = SGCore_LoadTexAddName("decal_aigrid1.dds", LOAD_TEXTURE_TYPE_CONST);
 
-	IDVS = SGCore_ShaderLoad(SHADER_TYPE_VERTEX, "aigrid_quad.vs", "aigrid_quad.vs", SHADER_CHECKDOUBLE_PATH);
-	IDPS = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "aigrid_quad.ps", "aigrid_quad.ps", SHADER_CHECKDOUBLE_PATH);
+	m_idVS = SGCore_ShaderLoad(SHADER_TYPE_VERTEX, "aigrid_quad.vs", "aigrid_quad.vs", SHADER_CHECKDOUBLE_PATH);
+	m_idPS = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "aigrid_quad.ps", "aigrid_quad.ps", SHADER_CHECKDOUBLE_PATH);
 
 
 	IDirect3DTexture9* TexBB;
-	DXDevice->CreateTexture(1, 1, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &TexBB, NULL);
+	m_pDXDevice->CreateTexture(1, 1, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &TexBB, NULL);
 	D3DLOCKED_RECT LockedRect;
 	
 	TexBB->LockRect(0, &LockedRect, 0, 0);
@@ -976,110 +1050,111 @@ void AIGrid::GraphicsInit()
 	TexBB->UnlockRect(0);
 
 	//SGCore_LoadTexLoadTextures();
-	Tex_BB = SGCore_LoadTexCreate("aigrid_tex_bb__", TexBB);
+	m_idTexBB = SGCore_LoadTexCreate("aigrid_tex_bb__", TexBB);
 
-	DXDevice->CreateVertexBuffer(
-                   4 * sizeof(AIQuadVertexData),
+	m_pDXDevice->CreateVertexBuffer(
+                   4 * sizeof(CAIQuadVertexData),
                    D3DUSAGE_WRITEONLY,
                    0,
                    D3DPOOL_MANAGED,
-                   &VertexQuad,
+				   &m_pVertexQuad,
                    0);
 
-	DXDevice->CreateIndexBuffer(
+	m_pDXDevice->CreateIndexBuffer(
                    6 * sizeof(WORD),
                    D3DUSAGE_WRITEONLY,
                    D3DFMT_INDEX16,
                    D3DPOOL_MANAGED,
-                   &IndexQuad,
+				   &m_pIndexQuad,
                    0);
 
-	AIQuadVertexData* vertices;
-	VertexQuad->Lock(0, 0, (void**)&vertices, 0);
+	CAIQuadVertexData* vertices;
+	m_pVertexQuad->Lock(0, 0, (void**)&vertices, 0);
 
-	vertices[0] = AIQuadVertexData(-AIGRID_QUAD_SIZEDIV2, 0.0f, -AIGRID_QUAD_SIZEDIV2, 0.0, 1.0f);
-	vertices[1] = AIQuadVertexData(-AIGRID_QUAD_SIZEDIV2, 0.0f,  AIGRID_QUAD_SIZEDIV2, 0.0, 0.0f);
-	vertices[2] = AIQuadVertexData( AIGRID_QUAD_SIZEDIV2, 0.0f,  AIGRID_QUAD_SIZEDIV2, 1.0, 0.0f);
-	vertices[3] = AIQuadVertexData( AIGRID_QUAD_SIZEDIV2, 0.0f, -AIGRID_QUAD_SIZEDIV2, 1.0, 1.0f);
+	vertices[0] = CAIQuadVertexData(-AIGRID_QUAD_SIZEDIV2, 0.0f, -AIGRID_QUAD_SIZEDIV2, 0.0, 1.0f);
+	vertices[1] = CAIQuadVertexData(-AIGRID_QUAD_SIZEDIV2, 0.0f,  AIGRID_QUAD_SIZEDIV2, 0.0, 0.0f);
+	vertices[2] = CAIQuadVertexData( AIGRID_QUAD_SIZEDIV2, 0.0f,  AIGRID_QUAD_SIZEDIV2, 1.0, 0.0f);
+	vertices[3] = CAIQuadVertexData( AIGRID_QUAD_SIZEDIV2, 0.0f, -AIGRID_QUAD_SIZEDIV2, 1.0, 1.0f);
 
-	VertexQuad->Unlock();
+	m_pVertexQuad->Unlock();
 
 	WORD* indices = 0;
-	IndexQuad->Lock(0, 0, (void**)&indices, 0);
+	m_pIndexQuad->Lock(0, 0, (void**)&indices, 0);
 
 	indices[0]  = 0; indices[1]  = 1; indices[2]  = 2;
 	indices[3]  = 0; indices[4]  = 2; indices[5]  = 3;
 
-	IndexQuad->Unlock();
+	m_pIndexQuad->Unlock();
 }
 
-void AIGrid::Clear()
+void CAIGrid::clear()
 {
-	AllocAIQuad.clear();
-	ArrQuads.clear();
+	mem_delete(m_pTreeBound);
+	m_oAllocQuad.clear();
+	m_aQuads.clear();
 
-	AllocBoundAIQuad.clear();
-	ArrBound.clear();
+	m_oAllocBound.clear();
+	m_aBound.clear();
 
-	mem_release_del(TransVertBuf);
-	ArrColor.clear();
-	ArrIDsInOpen.clear();
-	ArrCostQuads.clear();
-	ArrOpenIDs.clear();
-	ArrParentIDs.clear();
-	ArrCloseIDs.clear();
-	ArrState.clear();
-	ArrStateWho.clear();
-	ArrPreCondFreeState.clear();
-	ArrGraphPointsIDs.clear();
-	ArrCostGPIDs.clear();
-	mem_release_del(BoundBox);
+	mem_release_del(m_pTransVertBuf);
+	m_aQuadColors.clear();
+	m_aIDsInOpen.clear();
+	m_aCostQuads.clear();
+	m_aOpenIDs.clear();
+	m_aParentIDs.clear();
+	m_aTestSplitsIDs.clear();
+	m_aQuadState.clear();
+	m_aStateWho.clear();
+	m_aPreCondFreeState.clear();
+	m_aGraphPointsIDs.clear();
+	m_aCostGraphPointsIDs.clear();
+	mem_release_del(m_pBoundBox);
 }
 
-bool AIGrid::existsQuads()
+bool CAIGrid::existsQuads() const
 {
-	return (ArrQuads.size() > 0);
+	return (m_aQuads.size() > 0);
 }
 
-void AIGrid::GridClear()
+void CAIGrid::gridClear()
 {
-	AllocAIQuad.clear();
-	ArrQuads.clear();
+	m_oAllocQuad.clear();
+	m_aQuads.clear();
 
-	for (int i = 0, il = ArrBound.size(); i < il; ++i)
+	for (int i = 0, il = m_aBound.size(); i < il; ++i)
 	{
-		ArrBound[i]->ArrIdsQuads.clear();
+		m_aBound[i]->m_aIdsQuads.clear();
 	}
 
-	mem_release_del(TransVertBuf);
-	ArrColor.clear();
-	ArrIDsInOpen.clear();
-	ArrCostQuads.clear();
-	ArrOpenIDs.clear();
-	ArrParentIDs.clear();
-	ArrCloseIDs.clear();
-	ArrState.clear();
-	ArrStateWho.clear();
-	ArrPreCondFreeState.clear();
-	ArrGraphPointsIDs.clear();
-	ArrCostGPIDs.clear();
+	mem_release_del(m_pTransVertBuf);
+	m_aQuadColors.clear();
+	m_aIDsInOpen.clear();
+	m_aCostQuads.clear();
+	m_aOpenIDs.clear();
+	m_aParentIDs.clear();
+	m_aTestSplitsIDs.clear();
+	m_aQuadState.clear();
+	m_aStateWho.clear();
+	m_aPreCondFreeState.clear();
+	m_aGraphPointsIDs.clear();
+	m_aCostGraphPointsIDs.clear();
 }
 
-void AIGrid::SplitBB(int xv,int yv,int zv)
+void CAIGrid::splitBB(int xv,int yv,int zv)
 {
-	float xval = (ArrBound[0]->max.x - ArrBound[0]->min.x);
-	float yval = (ArrBound[0]->max.y - ArrBound[0]->min.y);
-	float zval = (ArrBound[0]->max.z - ArrBound[0]->min.z);
+	float xval = (m_aBound[0]->m_f3Max.x - m_aBound[0]->m_f3Min.x);
+	float yval = (m_aBound[0]->m_f3Max.y - m_aBound[0]->m_f3Min.y);
+	float zval = (m_aBound[0]->m_f3Max.z - m_aBound[0]->m_f3Min.z);
 
 	float countxval = xval / float(xv);
 	float countyval = yval / float(yv);
 	float countzval = zval / float(zv);
 
-	float cxval = (ArrBound[0]->max.x + ArrBound[0]->min.x)*0.5f;
-	float cyval = (ArrBound[0]->max.y + ArrBound[0]->min.y)*0.5f;
-	float czval = (ArrBound[0]->max.z + ArrBound[0]->min.z)*0.5f;
+	float cxval = (m_aBound[0]->m_f3Max.x + m_aBound[0]->m_f3Min.x)*0.5f;
+	float cyval = (m_aBound[0]->m_f3Max.y + m_aBound[0]->m_f3Min.y)*0.5f;
+	float czval = (m_aBound[0]->m_f3Max.z + m_aBound[0]->m_f3Min.z)*0.5f;
 
-	ArrBound.reserve(xv*yv*zv);
+	m_aBound.reserve(xv*yv*zv);
 
 		for(int x=0;x<xv;x++)
 		{
@@ -1087,54 +1162,53 @@ void AIGrid::SplitBB(int xv,int yv,int zv)
 				{
 						for(int z=0;z<zv;z++)
 						{
-							BoundAIQuad* tmpbb = AllocBoundAIQuad.Alloc();
+							CBoundAIquad* tmpbb = m_oAllocBound.Alloc();
 							float3 center = float3(
-													lerpf(ArrBound[0]->min.x,ArrBound[0]->max.x,float(x)/float(xv)) + countxval*0.5,
-													lerpf(ArrBound[0]->min.y,ArrBound[0]->max.y,float(y)/float(yv)) + countyval*0.5,
-													lerpf(ArrBound[0]->min.z,ArrBound[0]->max.z,float(z)/float(zv)) + countzval*0.5);
+													lerpf(m_aBound[0]->m_f3Min.x,m_aBound[0]->m_f3Max.x,float(x)/float(xv)) + countxval*0.5,
+													lerpf(m_aBound[0]->m_f3Min.y,m_aBound[0]->m_f3Max.y,float(y)/float(yv)) + countyval*0.5,
+													lerpf(m_aBound[0]->m_f3Min.z,m_aBound[0]->m_f3Max.z,float(z)/float(zv)) + countzval*0.5);
 
-							tmpbb->max.x = countxval*0.5 + center.x;
-							tmpbb->max.y = countyval*0.5 + center.y;
-							tmpbb->max.z = countzval*0.5 + center.z;
+							tmpbb->m_f3Max.x = countxval*0.5 + center.x;
+							tmpbb->m_f3Max.y = countyval*0.5 + center.y;
+							tmpbb->m_f3Max.z = countzval*0.5 + center.z;
 
-							tmpbb->min.x = -(countxval*0.5) + center.x;
-							tmpbb->min.y = -(countyval*0.5) + center.y;
-							tmpbb->min.z = -(countzval*0.5) + center.z;
+							tmpbb->m_f3Min.x = -(countxval*0.5) + center.x;
+							tmpbb->m_f3Min.y = -(countyval*0.5) + center.y;
+							tmpbb->m_f3Min.z = -(countzval*0.5) + center.z;
 
-							tmpbb->lmax.x = toint100(tmpbb->max.x);
-							tmpbb->lmax.y = toint100(tmpbb->max.y);
-							tmpbb->lmax.z = toint100(tmpbb->max.z);
+							tmpbb->m_i3Max.x = AIGRID_TOINT(tmpbb->m_f3Max.x);
+							tmpbb->m_i3Max.y = AIGRID_TOINT(tmpbb->m_f3Max.y);
+							tmpbb->m_i3Max.z = AIGRID_TOINT(tmpbb->m_f3Max.z);
 
-							tmpbb->lmin.x = toint100(tmpbb->min.x);
-							tmpbb->lmin.y = toint100(tmpbb->min.y);
-							tmpbb->lmin.z = toint100(tmpbb->min.z);
+							tmpbb->m_i3Min.x = AIGRID_TOINT(tmpbb->m_f3Min.x);
+							tmpbb->m_i3Min.y = AIGRID_TOINT(tmpbb->m_f3Min.y);
+							tmpbb->m_i3Min.z = AIGRID_TOINT(tmpbb->m_f3Min.z);
 
-							//SkyXEngine::Core::WorkModel::CreateBoundingBoxMesh(&float3(tmpbb->min),&float3(tmpbb->max),&(tmpbb->BoundBox));
-							ArrBound.push_back(tmpbb);
+							m_aBound.push_back(tmpbb);
 						}
 				}
 		}
 }
 
-void AIGrid::GridGenerate()
+void CAIGrid::gridGenerate()
 {
-	if (ArrQuads.size() <= 0)
+	if (m_aQuads.size() <= 0)
 	{
 		LibReport(REPORT_MSG_LEVEL_WARNING, "it is necessary one quad in AI grid");
 		return;
 	}
 
 	DWORD ttime = GetTickCount();
-	int oldsizegrid = ArrQuads.size();
+	int oldsizegrid = m_aQuads.size();
 
 	while (true)
 	{
 		ID idquadunchecked = -1;
 
 		//поиск первого не входящего ни в какой сплит
-		for (int i = 0, il = ArrQuads.size(); i < il; ++i)
+		for (int i = 0, il = m_aQuads.size(); i < il; ++i)
 		{
-			if (IsValidIdInArrQuads(i) && ArrQuads[i]->axisx == AIGRID_QUAD_DIR_NONE && ArrQuads[i]->axisy == AIGRID_QUAD_DIR_NONE)
+			if (isValidIdInArrQuads(i) && m_aQuads[i]->m_chAxisX == AIGRID_QUAD_DIR_NONE && m_aQuads[i]->m_chAxisY == AIGRID_QUAD_DIR_NONE)
 			{
 				idquadunchecked = i;
 				break;
@@ -1145,48 +1219,48 @@ void AIGrid::GridGenerate()
 		if (idquadunchecked < 0)
 			break;
 
-		ArrQuadsCheck.push_back(ArrQuads[idquadunchecked]);
+		m_aQuadsCheck.push_back(m_aQuads[idquadunchecked]);
 
 		DWORD tmptmp = 0;
 		DWORD tmpcountkey = 0;
-		while (ArrQuadsCheck.size() > 0 && ArrQuadsCheck.size() != tmptmp)
+		while (m_aQuadsCheck.size() > 0 && m_aQuadsCheck.size() != tmptmp)
 		{
 			tmpcountkey = tmptmp;
-			if (ArrQuadsCheck[tmpcountkey])
+			if (m_aQuadsCheck[tmpcountkey])
 			{
-				GenQuad(ArrQuadsCheck[tmpcountkey]);
+				genQuad(m_aQuadsCheck[tmpcountkey]);
 			}
 			++tmptmp;
 		}
-		ArrQuadsCheck.clear();
+		m_aQuadsCheck.clear();
 	}
 
-	LibReport(REPORT_MSG_LEVEL_NOTICE, "AI grid generated, all count = %d, gen count = %d, count time = %d mlsec\n", ArrQuads.size(), ArrQuads.size() - oldsizegrid, GetTickCount() - ttime);
+	LibReport(REPORT_MSG_LEVEL_NOTICE, "AI grid generated, all count = %d, gen count = %d, count time = %d mlsec\n", m_aQuads.size(), m_aQuads.size() - oldsizegrid, GetTickCount() - ttime);
 	
-	CountSplits = 0;
-	ReCreateBuffs();
+	m_uiCountSplits = 0;
+	reCreateBuffs();
 }
 
-void AIGrid::GraphPointGenerate()
+void CAIGrid::graphPointGenerate()
 {
-	if (ArrQuads.size() <= 1)
+	if (m_aQuads.size() <= 1)
 	{
 		LibReport(REPORT_MSG_LEVEL_WARNING, "AI grid not found\n");
 		return;
 	}
 
-	ArrGraphPointsIDs.clear();
-	ArrCostGPIDs.clear();
-	for (int k = 1, kl = ArrBound.size(); k<kl; ++k)
+	m_aGraphPointsIDs.clear();
+	m_aCostGraphPointsIDs.clear();
+	for (int k = 1, kl = m_aBound.size(); k<kl; ++k)
 	{
 		DWORD tmpgp = -1;
 		float tmplastdist = 0;
 		float tmplastdist2;
-		float3 tmpcenterbb = (float3(ArrBound[k]->max) + float3(ArrBound[k]->min)) * 0.5f;
+		float3 tmpcenterbb = (float3(m_aBound[k]->m_f3Max) + float3(m_aBound[k]->m_f3Min)) * 0.5f;
 
-		for (DWORD j = 0; j<ArrBound[k]->ArrIdsQuads.size(); j++)
+		for (DWORD j = 0; j<m_aBound[k]->m_aIdsQuads.size(); j++)
 		{
-			if ((tmplastdist2 = SMVector3Length2(tmpcenterbb - ArrQuads[ArrBound[k]->ArrIdsQuads[j]]->pos)) < tmplastdist || tmpgp == -1)
+			if ((tmplastdist2 = SMVector3Length2(tmpcenterbb - m_aQuads[m_aBound[k]->m_aIdsQuads[j]]->m_vPos)) < tmplastdist || tmpgp == -1)
 			{
 				tmpgp = j;
 				tmplastdist = tmplastdist2;
@@ -1195,127 +1269,133 @@ void AIGrid::GraphPointGenerate()
 
 		if (tmpgp != -1)
 		{
-			ArrGraphPointsIDs.push_back(ArrBound[k]->ArrIdsQuads[tmpgp]);
+			m_aGraphPointsIDs.push_back(m_aBound[k]->m_aIdsQuads[tmpgp]);
 		}
 	}
 
-	ArrCostGPIDs.resize(ArrGraphPointsIDs.size());
-	if (ArrGraphPointsIDs.size() > 0)
+	m_aCostGraphPointsIDs.resize(m_aGraphPointsIDs.size());
+	if (m_aGraphPointsIDs.size() > 0)
 	{
-		memset(&(ArrCostGPIDs[0]), -1, ArrCostGPIDs.size() * sizeof(int32_t));
-		LibReport(REPORT_MSG_LEVEL_NOTICE, "graph points is generated, count %d\n", ArrGraphPointsIDs.size());
+		memset(&(m_aCostGraphPointsIDs[0]), -1, m_aCostGraphPointsIDs.size() * sizeof(int32_t));
+		LibReport(REPORT_MSG_LEVEL_NOTICE, "graph points is generated, count %d\n", m_aGraphPointsIDs.size());
 	}
 }
 
-UINT AIGrid::GraphPointGetCount()
+UINT CAIGrid::graphPointGetCount() const
 {
-	return ArrGraphPointsIDs.size();
+	return m_aGraphPointsIDs.size();
 }
 
-void AIGrid::GraphPointClear()
+void CAIGrid::graphPointClear()
 {
-	ArrGraphPointsIDs.clear();
+	m_aGraphPointsIDs.clear();
 }
 
-void AIGrid::GraphPointAdd(ID id)
+void CAIGrid::graphPointAdd(ID id)
 {
 	AIGRID_QUAD_PRECOND(id, _VOID);
 
-	if (GraphPointGetKey(id) >= 0)
+	if (graphPointGetKey(id) >= 0)
 		return;
 
-	ArrGraphPointsIDs.push_back(id);
+	m_aGraphPointsIDs.push_back(id);
 }
 
-void AIGrid::GraphPointDelete(ID id)
+void CAIGrid::graphPointDelete(ID id)
 {
 	AIGRID_QUAD_PRECOND(id, _VOID);
 
 	ID gpkey = -1;
-	if ((gpkey = GraphPointGetKey(id)) < 0)
+	if ((gpkey = graphPointGetKey(id)) < 0)
 		return;
 
-	ArrGraphPointsIDs.erase(gpkey);
+	m_aGraphPointsIDs.erase(gpkey);
 }
 
-ID AIGrid::GraphPointGetKey(ID id)
+ID CAIGrid::graphPointGetKey(ID id)
 {
 	AIGRID_QUAD_PRECOND(id, -1);
 
-	for (int i = 0, il = ArrGraphPointsIDs.size(); i < il; ++i)
+	for (int i = 0, il = m_aGraphPointsIDs.size(); i < il; ++i)
 	{
-		if (ArrGraphPointsIDs[i] == id)
+		if (m_aGraphPointsIDs[i] == id)
 			return i;
 	}
 
 	return -1;
 }
 
-void AIGrid::AddUniqQuadArrag(const AIQuad* aq)
+void CAIGrid::addUniqQuadArrag(const CAIquad* aq)
 {
-	long tmpx = toint100(aq->pos.x);
-	long tmpy = toint100(aq->pos.y);
-	long tmpz = toint100(aq->pos.z);
-	BoundAIQuad* bound = 0;
-	for (int i = 1, il = ArrBound.size(); i < il; ++i)
+	long tmpx = AIGRID_TOINT(aq->m_vPos.x);
+	long tmpy = AIGRID_TOINT(aq->m_vPos.y);
+	long tmpz = AIGRID_TOINT(aq->m_vPos.z);
+	CBoundAIquad* bound = 0;
+	for (int i = 1, il = m_aBound.size(); i < il; ++i)
 	{
-		bound = ArrBound[i];
+		bound = m_aBound[i];
 		//если центр квада входит в какой-либо бокс
 		if (
-			bound->lmin.x <= tmpx && bound->lmin.y <= tmpy && bound->lmin.z <= tmpz &&
-			bound->lmax.x >= tmpx && bound->lmax.y >= tmpy && bound->lmax.z >= tmpz
+			bound->m_i3Min.x <= tmpx && bound->m_i3Min.y <= tmpy && bound->m_i3Min.z <= tmpz &&
+			bound->m_i3Max.x >= tmpx && bound->m_i3Max.y >= tmpy && bound->m_i3Max.z >= tmpz
 			)
 		{
-			bound->ArrIdsQuads.push_back(aq->Id);
+			bound->m_aIdsQuads.push_back(aq->m_id);
 			break;
 		}
 	}
 
-	ArrLongCoordQuads[aq->Id] = int3(tmpx, tmpy, tmpz);
+	m_aLongCoordQuads[aq->m_id] = int3(tmpx, tmpy, tmpz);
 }
 
-void AIGrid::AddUniqQuadArrag2(const AIQuad* aq, ID idbb)
+void CAIGrid::addUniqQuadArrag2(const CAIquad* aq, CBoundAIquad *pBB)
 {
-	if (!(idbb > 0 && ArrBound.size() > idbb))
+	if (!pBB)
 	{
 		return;
 	}
 
-	ArrBound[idbb]->ArrIdsQuads.push_back(aq->Id);
-	ArrLongCoordQuads[aq->Id] = int3(toint100(aq->pos.x), toint100(aq->pos.y), toint100(aq->pos.z));
+	pBB->m_aIdsQuads.push_back(aq->m_id);
+	m_aLongCoordQuads[aq->m_id] = int3(AIGRID_TOINT(aq->m_vPos.x), AIGRID_TOINT(aq->m_vPos.y), AIGRID_TOINT(aq->m_vPos.z));
 }
 
-bool AIGrid::IsUniqQuadArrag(AIQuad* aq, ID * idquad, ID * idbb)
+bool CAIGrid::isUniqQuadArrag(CAIquad* aq, ID * idquad, CBoundAIquad ** idbb)
 {
+	if (!m_pTreeBound)
+	{
+		LibReport(REPORT_MSG_LEVEL_ERROR, " %s - tree bounds is not build", GEN_MSG_LOCATION);
+		return false;
+	}
+
 	int3 l3;
-	ID tmpidbb = -1;
-	ID tmpsizearr = ArrQuads.size();
-	long tmpx = toint100(aq->pos.x);
-	long tmpy = toint100(aq->pos.y);
-	long tmpz = toint100(aq->pos.z);
-	BoundAIQuad* bound = 0;
+	CBoundAIquad *tmpidbb = 0;
+	ID tmpsizearr = m_aQuads.size();
+	long tmpx = AIGRID_TOINT(aq->m_vPos.x);
+	long tmpy = AIGRID_TOINT(aq->m_vPos.y);
+	long tmpz = AIGRID_TOINT(aq->m_vPos.z);
+	CBoundAIquad* bound = 0;
 
-	for (UINT i = 1, il = ArrBound.size(); i<il; ++i)
+	/*for (UINT i = 1, il = m_aBound.size(); i<il; ++i)
 	{
-		bound = ArrBound[i];
+		bound = m_aBound[i];
 		//если центр квада входит в какой-либо бокс
 		if (
-			bound->lmin.x <= tmpx && bound->lmin.y <= tmpy && bound->lmin.z <= tmpz &&
-			bound->lmax.x >= tmpx && bound->lmax.y >= tmpy && bound->lmax.z >= tmpz
+			bound->m_i3Min.x <= tmpx && bound->m_i3Min.y <= tmpy && bound->m_i3Min.z <= tmpz &&
+			bound->m_i3Max.x >= tmpx && bound->m_i3Max.y >= tmpy && bound->m_i3Max.z >= tmpz
 			)
 		{
 			tmpidbb = i;
 			//анализируем все входящие в данный бокс квады
-			for (UINT k = 0, kl = bound->ArrIdsQuads.size(); k < kl; ++k)
+			for (UINT k = 0, kl = bound->m_aIdsQuads.size(); k < kl; ++k)
 			{
-				l3 = ArrLongCoordQuads[bound->ArrIdsQuads[k]];
+				l3 = m_aLongCoordQuads[bound->m_aIdsQuads[k]];
 				if (
 					l3.x == tmpx &&
 					l3.z == tmpz &&
 					abs(l3.y - tmpy) < LAIGRID_QUADS_CENTERS_MAXHEIGHT
 					)
 				{
-					*idquad = bound->ArrIdsQuads[k];
+					*idquad = bound->m_aIdsQuads[k];
 					
 					if (idbb)
 						*idbb = tmpidbb;
@@ -1323,6 +1403,77 @@ bool AIGrid::IsUniqQuadArrag(AIQuad* aq, ID * idquad, ID * idbb)
 				}
 			}
 		}
+	}*/
+
+	Array<CTreeBoundAIquad*, 64> queue;
+	int iCurrKey = 0;
+	queue.push_back(m_pTreeBound);
+	CTreeBoundAIquad *pFoundSplit = 0;
+
+	while (queue.size() > iCurrKey)
+	{
+		CTreeBoundAIquad *pSplit = queue[iCurrKey];
+
+		for (int i = 0; i<4; i++)
+		{
+			if (
+				/*pSplit->m_aSplits[i]->m_i3Min.x - LAIGRID_QUAD_SIZE <= tmpx && pSplit->m_aSplits[i]->m_i3Min.z - LAIGRID_QUAD_SIZE <= tmpz &&
+				pSplit->m_aSplits[i]->m_i3Max.x + LAIGRID_QUAD_SIZE >= tmpx && pSplit->m_aSplits[i]->m_i3Max.z + LAIGRID_QUAD_SIZE >= tmpz*/
+				pSplit->m_aSplits[i]->m_i3Min.x <= tmpx && pSplit->m_aSplits[i]->m_i3Min.y <= tmpy && pSplit->m_aSplits[i]->m_i3Min.z <= tmpz &&
+				pSplit->m_aSplits[i]->m_i3Max.x >= tmpx && pSplit->m_aSplits[i]->m_i3Max.y >= tmpy && pSplit->m_aSplits[i]->m_i3Max.z >= tmpz
+				)
+			{
+				if (pSplit->m_aSplits[i]->m_aSplits[0])
+					queue.push_back(pSplit->m_aSplits[i]);
+				else
+				{
+					pFoundSplit = pSplit->m_aSplits[i];
+					queue.clear();
+					break;
+				}
+			}
+		}
+
+		//queue.erase(0);
+		++iCurrKey;
+	}
+
+	if (!pFoundSplit)
+		return -1;
+
+	for (int i = 0, il = pFoundSplit->m_pBounds.size(); i < il; ++i)
+	{
+		bound = pFoundSplit->m_pBounds[i];
+		if (
+			bound->m_i3Min.x <= tmpx && bound->m_i3Min.y <= tmpy && bound->m_i3Min.z <= tmpz &&
+			bound->m_i3Max.x >= tmpx && bound->m_i3Max.y >= tmpy && bound->m_i3Max.z >= tmpz
+			)
+		{
+			tmpidbb = bound;
+			for (int k = 0, kl = bound->m_aIdsQuads.size(); k < kl; ++k)
+			{
+				l3 = m_aLongCoordQuads[bound->m_aIdsQuads[k]];
+				/*if (
+					abs((l3.x) - (tmpx)) <= LAIGRID_QUAD_SIZEDIV2 &&
+					abs((l3.z) - (tmpz)) <= LAIGRID_QUAD_SIZEDIV2
+					)*/
+				{
+
+					if (
+						l3.x == tmpx &&
+						l3.z == tmpz &&
+						abs(l3.y - tmpy) < LAIGRID_QUADS_CENTERS_MAXHEIGHT
+						)
+					{
+						*idquad = bound->m_aIdsQuads[k];
+
+						if (idbb)
+							*idbb = bound;
+						return false;
+					}
+				}
+			}
+		}
 	}
 
 	if (idbb)
@@ -1331,397 +1482,403 @@ bool AIGrid::IsUniqQuadArrag(AIQuad* aq, ID * idquad, ID * idbb)
 	return true;
 }
 
-void AIGrid::GenQuad(AIQuad* aq)
+void CAIGrid::genQuad(CAIquad* aq)
 {
 	bool tmpiscom = true;
 	bool tmpiscom2 = true;
 	ID idquad = -1;
-	ID idbb = -1;
+	CBoundAIquad *pBB = 0;
 	static float3_t tmppos;
 
-	AIQuad *aq12, *aq21, *aq23, *aq32, *aqold;
+	CAIquad *aq12, *aq21, *aq23, *aq32, *aqold;
 	aq12 = aq21 = aq23 = aq32 = aqold = 0;
 	bool isunic = false;
 
 	// ^
-	if (!IsValidIdInArrQuads(aq->Arr[1]))
+	if (!isValidIdInArrQuads(aq->m_aNeighbors[1]))
 	{
-		tmppos = aq->pos;
+		tmppos = aq->m_vPos;
 		tmppos.z += AIGRID_QUAD_SIZE;
 
 		if (
-			Max.x >= tmppos.x + AIGRID_QUAD_SIZEDIV2 && Max.z >= tmppos.z + AIGRID_QUAD_SIZEDIV2 && 
-			Max.y >= tmppos.y && Min.y <= tmppos.y &&
-			Min.x <= tmppos.x - AIGRID_QUAD_SIZEDIV2 && Min.z <= tmppos.z - AIGRID_QUAD_SIZEDIV2
+			m_vMax.x >= tmppos.x + AIGRID_QUAD_SIZEDIV2 && m_vMax.z >= tmppos.z + AIGRID_QUAD_SIZEDIV2 &&
+			m_vMax.y >= tmppos.y && m_vMin.y <= tmppos.y &&
+			m_vMin.x <= tmppos.x - AIGRID_QUAD_SIZEDIV2 && m_vMin.z <= tmppos.z - AIGRID_QUAD_SIZEDIV2
 			)
 		{
-			aq12 = AllocAIQuad.Alloc();
+			aq12 = m_oAllocQuad.Alloc();
 
-			aq12->pos = tmppos;
+			aq12->m_vPos = tmppos;
 
-			idquad = idbb = -1;
-			isunic = IsUniqQuadArrag(aq12, &idquad, &idbb);
+			idquad = -1;
+			pBB = 0;
+			isunic = isUniqQuadArrag(aq12, &idquad, &pBB);
 
 			if (isunic)
 			{
-				PhyNavigate(aq12);
+				phyNavigate(aq12);
 
-				if (abs(aq->pos.y - aq12->pos.y) < AIGRID_QUADS_CENTERS_MAXHEIGHT && !(aq12->IsClose))
+				if (abs(aq->m_vPos.y - aq12->m_vPos.y) < AIGRID_QUADS_CENTERS_MAXHEIGHT && !(aq12->m_isClose))
 				{
-					aq12->pos.y += AIGRID_QUAD_ADDYPOS;
+					aq12->m_vPos.y += AIGRID_QUAD_ADDYPOS;
 
-					ArrQuadsCheck.push_back(aq12);
-					aq12->Id = ArrQuads.size();
-					ArrQuads.push_back(aq12);
-					aq->Arr[1] = aq12->Id;
-					AddUniqQuadArrag2(aq12, idbb);
+					m_aQuadsCheck.push_back(aq12);
+					aq12->m_id = m_aQuads.size();
+					m_aQuads.push_back(aq12);
+					aq->m_aNeighbors[1] = aq12->m_id;
+					addUniqQuadArrag2(aq12, pBB);
 				}
 				else
 				{
-					AllocAIQuad.Delete(aq12);
+					m_oAllocQuad.Delete(aq12);
 					aq12 = 0;
 				}
 			}
 			else
 			{
 				aqold = aq12;
-				aq->Arr[1] = idquad;
-				aq12 = ArrQuads[idquad];
-				if (aq12->IsClose)
+				aq->m_aNeighbors[1] = idquad;
+				aq12 = m_aQuads[idquad];
+				if (aq12->m_isClose)
 				{
-					aq12->pos = aqold->pos;
-					aq12->pos.y += AIGRID_QUAD_ADDYPOS;
-					aq12->IsClose = false;
-					ArrQuadsCheck.push_back(aq12);
+					aq12->m_vPos = aqold->m_vPos;
+					aq12->m_vPos.y += AIGRID_QUAD_ADDYPOS;
+					aq12->m_isClose = false;
+					m_aQuadsCheck.push_back(aq12);
 				}
 
-				AllocAIQuad.Delete(aqold);
+				m_oAllocQuad.Delete(aqold);
 				aqold = 0;
 			}
 		}
 	}
 
 	// \/
-	if (!IsValidIdInArrQuads(aq->Arr[6]))
+	if (!isValidIdInArrQuads(aq->m_aNeighbors[6]))
 	{
-		tmppos = aq->pos;
+		tmppos = aq->m_vPos;
 		tmppos.z -= AIGRID_QUAD_SIZE;
 
 		if (
-			Max.x >= tmppos.x + AIGRID_QUAD_SIZEDIV2 && Max.z >= tmppos.z + AIGRID_QUAD_SIZEDIV2 &&
-			Max.y >= tmppos.y && Min.y <= tmppos.y &&
-			Min.x <= tmppos.x - AIGRID_QUAD_SIZEDIV2 && Min.z <= tmppos.z - AIGRID_QUAD_SIZEDIV2
+			m_vMax.x >= tmppos.x + AIGRID_QUAD_SIZEDIV2 && m_vMax.z >= tmppos.z + AIGRID_QUAD_SIZEDIV2 &&
+			m_vMax.y >= tmppos.y && m_vMin.y <= tmppos.y &&
+			m_vMin.x <= tmppos.x - AIGRID_QUAD_SIZEDIV2 && m_vMin.z <= tmppos.z - AIGRID_QUAD_SIZEDIV2
 			)
 		{
-			aq32 = AllocAIQuad.Alloc();
+			aq32 = m_oAllocQuad.Alloc();
 
-			aq32->pos = tmppos;
+			aq32->m_vPos = tmppos;
 
-			idquad = idbb = -1;
-			isunic = IsUniqQuadArrag(aq32, &idquad, &idbb);
+			idquad = -1;
+			pBB = 0;
+			isunic = isUniqQuadArrag(aq32, &idquad, &pBB);
 
 			if (isunic)
 			{
-				PhyNavigate(aq32);
+				phyNavigate(aq32);
 
-				if (abs(aq->pos.y - aq32->pos.y) < AIGRID_QUADS_CENTERS_MAXHEIGHT && !(aq32->IsClose))
+				if (abs(aq->m_vPos.y - aq32->m_vPos.y) < AIGRID_QUADS_CENTERS_MAXHEIGHT && !(aq32->m_isClose))
 				{
-					aq32->pos.y += AIGRID_QUAD_ADDYPOS;
+					aq32->m_vPos.y += AIGRID_QUAD_ADDYPOS;
 
-					ArrQuadsCheck.push_back(aq32);
-					aq32->Id = ArrQuads.size();
-					ArrQuads.push_back(aq32);
-					aq->Arr[6] = aq32->Id;
-					AddUniqQuadArrag2(aq32, idbb);
+					m_aQuadsCheck.push_back(aq32);
+					aq32->m_id = m_aQuads.size();
+					m_aQuads.push_back(aq32);
+					aq->m_aNeighbors[6] = aq32->m_id;
+					addUniqQuadArrag2(aq32, pBB);
 				}
 				else
 				{
-					AllocAIQuad.Delete(aq32);
+					m_oAllocQuad.Delete(aq32);
 					aq32 = 0;
 				}
 			}
 			else
 			{
 				aqold = aq32;
-				aq->Arr[6] = idquad;
-				aq32 = ArrQuads[idquad];
-				if (aq32->IsClose)
+				aq->m_aNeighbors[6] = idquad;
+				aq32 = m_aQuads[idquad];
+				if (aq32->m_isClose)
 				{
-					aq32->pos = aqold->pos;
-					aq32->pos.y += AIGRID_QUAD_ADDYPOS;
-					aq32->IsClose = false;
-					ArrQuadsCheck.push_back(aq32);
+					aq32->m_vPos = aqold->m_vPos;
+					aq32->m_vPos.y += AIGRID_QUAD_ADDYPOS;
+					aq32->m_isClose = false;
+					m_aQuadsCheck.push_back(aq32);
 				}
 
-				AllocAIQuad.Delete(aqold);
+				m_oAllocQuad.Delete(aqold);
 				aqold = 0;
 			}
 		}
 	}
 
 	// ->
-	if (!IsValidIdInArrQuads(aq->Arr[4]))
+	if (!isValidIdInArrQuads(aq->m_aNeighbors[4]))
 	{
-		tmppos = aq->pos;
+		tmppos = aq->m_vPos;
 		tmppos.x += AIGRID_QUAD_SIZE;
 
 		if (
-			Max.x >= tmppos.x + AIGRID_QUAD_SIZEDIV2 && Max.z >= tmppos.z + AIGRID_QUAD_SIZEDIV2 &&
-			Max.y >= tmppos.y && Min.y <= tmppos.y &&
-			Min.x <= tmppos.x - AIGRID_QUAD_SIZEDIV2 && Min.z <= tmppos.z - AIGRID_QUAD_SIZEDIV2
+			m_vMax.x >= tmppos.x + AIGRID_QUAD_SIZEDIV2 && m_vMax.z >= tmppos.z + AIGRID_QUAD_SIZEDIV2 &&
+			m_vMax.y >= tmppos.y && m_vMin.y <= tmppos.y &&
+			m_vMin.x <= tmppos.x - AIGRID_QUAD_SIZEDIV2 && m_vMin.z <= tmppos.z - AIGRID_QUAD_SIZEDIV2
 			)
 		{
-			aq23 = AllocAIQuad.Alloc();
+			aq23 = m_oAllocQuad.Alloc();
 
-			aq23->pos = tmppos;
+			aq23->m_vPos = tmppos;
 
-			idquad = idbb = -1;
-			isunic = IsUniqQuadArrag(aq23, &idquad, &idbb);
+			idquad = -1;
+			pBB = 0;
+			isunic = isUniqQuadArrag(aq23, &idquad, &pBB);
 
 			if (isunic)
 			{
-				PhyNavigate(aq23);
+				phyNavigate(aq23);
 
-				if (abs(aq->pos.y - aq23->pos.y) < AIGRID_QUADS_CENTERS_MAXHEIGHT && !(aq23->IsClose))
+				if (abs(aq->m_vPos.y - aq23->m_vPos.y) < AIGRID_QUADS_CENTERS_MAXHEIGHT && !(aq23->m_isClose))
 				{
-					aq23->pos.y += AIGRID_QUAD_ADDYPOS;
+					aq23->m_vPos.y += AIGRID_QUAD_ADDYPOS;
 
-					ArrQuadsCheck.push_back(aq23);
-					aq23->Id = ArrQuads.size();
-					ArrQuads.push_back(aq23);
-					aq->Arr[4] = aq23->Id;
-					AddUniqQuadArrag2(aq23, idbb);
+					m_aQuadsCheck.push_back(aq23);
+					aq23->m_id = m_aQuads.size();
+					m_aQuads.push_back(aq23);
+					aq->m_aNeighbors[4] = aq23->m_id;
+					addUniqQuadArrag2(aq23, pBB);
 				}
 				else
 				{
-					AllocAIQuad.Delete(aq23);
+					m_oAllocQuad.Delete(aq23);
 					aq23 = 0;
 				}
 			}
 			else
 			{
 				aqold = aq23;
-				aq->Arr[4] = idquad;
-				aq23 = ArrQuads[idquad];
-				if (aq23->IsClose)
+				aq->m_aNeighbors[4] = idquad;
+				aq23 = m_aQuads[idquad];
+				if (aq23->m_isClose)
 				{
-					aq23->pos = aqold->pos;
-					aq23->pos.y += AIGRID_QUAD_ADDYPOS;
-					aq23->IsClose = false;
-					ArrQuadsCheck.push_back(aq23);
+					aq23->m_vPos = aqold->m_vPos;
+					aq23->m_vPos.y += AIGRID_QUAD_ADDYPOS;
+					aq23->m_isClose = false;
+					m_aQuadsCheck.push_back(aq23);
 				}
 
-				AllocAIQuad.Delete(aqold);
+				m_oAllocQuad.Delete(aqold);
 				aqold = 0;
 			}
 		}
 	}
 
 	// <-
-	if (!IsValidIdInArrQuads(aq->Arr[3]))
+	if (!isValidIdInArrQuads(aq->m_aNeighbors[3]))
 	{
-		tmppos = aq->pos;
+		tmppos = aq->m_vPos;
 		tmppos.x -= AIGRID_QUAD_SIZE;
 
 		if (
-			Max.x >= tmppos.x + AIGRID_QUAD_SIZEDIV2 && Max.z >= tmppos.z + AIGRID_QUAD_SIZEDIV2 &&
-			Max.y >= tmppos.y && Min.y <= tmppos.y &&
-			Min.x <= tmppos.x - AIGRID_QUAD_SIZEDIV2 && Min.z <= tmppos.z - AIGRID_QUAD_SIZEDIV2
+			m_vMax.x >= tmppos.x + AIGRID_QUAD_SIZEDIV2 && m_vMax.z >= tmppos.z + AIGRID_QUAD_SIZEDIV2 &&
+			m_vMax.y >= tmppos.y && m_vMin.y <= tmppos.y &&
+			m_vMin.x <= tmppos.x - AIGRID_QUAD_SIZEDIV2 && m_vMin.z <= tmppos.z - AIGRID_QUAD_SIZEDIV2
 			)
 		{
-			aq21 = AllocAIQuad.Alloc();
+			aq21 = m_oAllocQuad.Alloc();
 
-			aq21->pos = tmppos;
+			aq21->m_vPos = tmppos;
 
-			idquad = idbb = -1;
-			isunic = IsUniqQuadArrag(aq21, &idquad, &idbb);
+			idquad = -1;
+			pBB = 0;
+			isunic = isUniqQuadArrag(aq21, &idquad, &pBB);
 
 			if (isunic)
 			{
-				PhyNavigate(aq21);
+				phyNavigate(aq21);
 
-				if (abs(aq->pos.y - aq21->pos.y) < AIGRID_QUADS_CENTERS_MAXHEIGHT && !(aq21->IsClose))
+				if (abs(aq->m_vPos.y - aq21->m_vPos.y) < AIGRID_QUADS_CENTERS_MAXHEIGHT && !(aq21->m_isClose))
 				{
-					aq21->pos.y += AIGRID_QUAD_ADDYPOS;
+					aq21->m_vPos.y += AIGRID_QUAD_ADDYPOS;
 
-					ArrQuadsCheck.push_back(aq21);
-					aq21->Id = ArrQuads.size();
-					ArrQuads.push_back(aq21);
-					aq->Arr[3] = aq21->Id;
-					AddUniqQuadArrag2(aq21, idbb);
+					m_aQuadsCheck.push_back(aq21);
+					aq21->m_id = m_aQuads.size();
+					m_aQuads.push_back(aq21);
+					aq->m_aNeighbors[3] = aq21->m_id;
+					addUniqQuadArrag2(aq21, pBB);
 				}
 				else
 				{
-					AllocAIQuad.Delete(aq21);
+					m_oAllocQuad.Delete(aq21);
 					aq21 = 0;
 				}
 			}
 			else
 			{
 				aqold = aq21;
-				aq->Arr[3] = idquad;
-				aq21 = ArrQuads[idquad];
-				if (aq21->IsClose)
+				aq->m_aNeighbors[3] = idquad;
+				aq21 = m_aQuads[idquad];
+				if (aq21->m_isClose)
 				{
-					aq21->pos = aqold->pos;
-					aq21->pos.y += AIGRID_QUAD_ADDYPOS;
-					aq21->IsClose = false;
-					ArrQuadsCheck.push_back(aq21);
+					aq21->m_vPos = aqold->m_vPos;
+					aq21->m_vPos.y += AIGRID_QUAD_ADDYPOS;
+					aq21->m_isClose = false;
+					m_aQuadsCheck.push_back(aq21);
 				}
 
-				AllocAIQuad.Delete(aqold);
+				m_oAllocQuad.Delete(aqold);
 				aqold = 0;
 			}
 		}
 	}
 
 	//определяем возможные направления из квада по оси Y
-	if (IsValidIdInArrQuads(aq->Arr[1]) && IsValidIdInArrQuads(aq->Arr[6]))
-		aq->axisy = AIGRID_QUAD_DIR_ALL;
-	else if (IsValidIdInArrQuads(aq->Arr[1]) && !IsValidIdInArrQuads(aq->Arr[6]))
-		aq->axisy = AIGRID_QUAD_DIR_POSITIVE;
-	else if (!IsValidIdInArrQuads(aq->Arr[1]) && IsValidIdInArrQuads(aq->Arr[6]))
-		aq->axisy = AIGRID_QUAD_DIR_NEGATIVE;
+	if (isValidIdInArrQuads(aq->m_aNeighbors[1]) && isValidIdInArrQuads(aq->m_aNeighbors[6]))
+		aq->m_chAxisY = AIGRID_QUAD_DIR_ALL;
+	else if (isValidIdInArrQuads(aq->m_aNeighbors[1]) && !isValidIdInArrQuads(aq->m_aNeighbors[6]))
+		aq->m_chAxisY = AIGRID_QUAD_DIR_POSITIVE;
+	else if (!isValidIdInArrQuads(aq->m_aNeighbors[1]) && isValidIdInArrQuads(aq->m_aNeighbors[6]))
+		aq->m_chAxisY = AIGRID_QUAD_DIR_NEGATIVE;
 	else
-		aq->axisy = AIGRID_QUAD_DIR_NONE;
+		aq->m_chAxisY = AIGRID_QUAD_DIR_NONE;
 
 	//определяем возможные направления из квада по оси X
-	if (IsValidIdInArrQuads(aq->Arr[3]) && IsValidIdInArrQuads(aq->Arr[4]))
-		aq->axisx = AIGRID_QUAD_DIR_ALL;
-	else if (IsValidIdInArrQuads(aq->Arr[3]) && !IsValidIdInArrQuads(aq->Arr[4]))
-		aq->axisx = AIGRID_QUAD_DIR_NEGATIVE;
-	else if (!IsValidIdInArrQuads(aq->Arr[3]) && IsValidIdInArrQuads(aq->Arr[4]))
-		aq->axisx = AIGRID_QUAD_DIR_POSITIVE;
+	if (isValidIdInArrQuads(aq->m_aNeighbors[3]) && isValidIdInArrQuads(aq->m_aNeighbors[4]))
+		aq->m_chAxisX = AIGRID_QUAD_DIR_ALL;
+	else if (isValidIdInArrQuads(aq->m_aNeighbors[3]) && !isValidIdInArrQuads(aq->m_aNeighbors[4]))
+		aq->m_chAxisX = AIGRID_QUAD_DIR_NEGATIVE;
+	else if (!isValidIdInArrQuads(aq->m_aNeighbors[3]) && isValidIdInArrQuads(aq->m_aNeighbors[4]))
+		aq->m_chAxisX = AIGRID_QUAD_DIR_POSITIVE;
 	else
-		aq->axisx = AIGRID_QUAD_DIR_NONE;
+		aq->m_chAxisX = AIGRID_QUAD_DIR_NONE;
 
-	if (aq->axisy == AIGRID_QUAD_DIR_NONE && aq->axisx == AIGRID_QUAD_DIR_NONE)
+	if (aq->m_chAxisY == AIGRID_QUAD_DIR_NONE && aq->m_chAxisX == AIGRID_QUAD_DIR_NONE)
 	{
-		aq->IsClose = true;
-		QuadDelete(aq->Id);
+		aq->m_isClose = true;
+		quadDelete(aq->m_id);
 	}
 	else
-		ComputeNeighbor(aq->Id);
+	{
+		computeNeighbor(aq->m_id);
+	}
 }
 
-void AIGrid::ComputeNeighbor(ID id)
+void CAIGrid::computeNeighbor(ID id)
 {
-	AIQuad* aq = ArrQuads[id];
-	AIQuad *aq12, *aq21, *aq23, *aq32;
+	CAIquad* aq = m_aQuads[id];
+	CAIquad *aq12, *aq21, *aq23, *aq32;
 	aq12 = aq21 = aq23 = aq32 = 0;
 
-	AIQuad *aq11, *aq13, *aq31, *aq33;
+	CAIquad *aq11, *aq13, *aq31, *aq33;
 	aq11 = aq13 = aq31 = aq33 = 0;
 
 	if (aq)
 	{
-		if (aq->Arr[0] != -1)
-			aq11 = ArrQuads[aq->Arr[0]];
+		if (aq->m_aNeighbors[0] != -1)
+			aq11 = m_aQuads[aq->m_aNeighbors[0]];
 
-		if (aq->Arr[1] != -1)
-			aq12 = ArrQuads[aq->Arr[1]];
+		if (aq->m_aNeighbors[1] != -1)
+			aq12 = m_aQuads[aq->m_aNeighbors[1]];
 
-		if (aq->Arr[2] != -1)
-			aq13 = ArrQuads[aq->Arr[2]];
+		if (aq->m_aNeighbors[2] != -1)
+			aq13 = m_aQuads[aq->m_aNeighbors[2]];
 
-		if (aq->Arr[3] != -1)
-			aq21 = ArrQuads[aq->Arr[3]];
+		if (aq->m_aNeighbors[3] != -1)
+			aq21 = m_aQuads[aq->m_aNeighbors[3]];
 
-		if (aq->Arr[4] != -1)
-			aq23 = ArrQuads[aq->Arr[4]];
+		if (aq->m_aNeighbors[4] != -1)
+			aq23 = m_aQuads[aq->m_aNeighbors[4]];
 
-		if (aq->Arr[5] != -1)
-			aq31 = ArrQuads[aq->Arr[5]];
+		if (aq->m_aNeighbors[5] != -1)
+			aq31 = m_aQuads[aq->m_aNeighbors[5]];
 
-		if (aq->Arr[6] != -1)
-			aq32 = ArrQuads[aq->Arr[6]];
+		if (aq->m_aNeighbors[6] != -1)
+			aq32 = m_aQuads[aq->m_aNeighbors[6]];
 
-		if (aq->Arr[7] != -1)
-			aq33 = ArrQuads[aq->Arr[7]];
+		if (aq->m_aNeighbors[7] != -1)
+			aq33 = m_aQuads[aq->m_aNeighbors[7]];
 
-		if (aq->Arr[1] != -1)
+		if (aq->m_aNeighbors[1] != -1)
 		{
 			//указываем самый нижний соседом
-			aq12->SetNeighbor(6, aq->Id);
+			aq12->setNeighbor(6, aq->m_id);
 			//если левый нижний создан то он тоже сосед
-			if (aq->Arr[3] != -1)
-				aq12->SetNeighbor(5, aq->Arr[3]);
+			if (aq->m_aNeighbors[3] != -1)
+				aq12->setNeighbor(5, aq->m_aNeighbors[3]);
 
 			//если правый нижний создан то он тоже сосед
-			if (aq->Arr[4] != -1)
-				aq12->SetNeighbor(7, aq->Arr[4]);
+			if (aq->m_aNeighbors[4] != -1)
+				aq12->setNeighbor(7, aq->m_aNeighbors[4]);
 
 			//если у обрабатываемого нода есть верхний левый
-			if (aq->Arr[0] != -1)
+			if (aq->m_aNeighbors[0] != -1)
 			{
-				if (AIGridCompareHeight(aq->Arr[1], aq->Arr[0]))
-					aq12->SetNeighbor(3, aq->Arr[0]);
+				if (gridCompareHeight(aq->m_aNeighbors[1], aq->m_aNeighbors[0]))
+					aq12->setNeighbor(3, aq->m_aNeighbors[0]);
 
-				if (AIGridCompareHeight(aq->Arr[0], aq->Arr[1]))
-					aq11->SetNeighbor(4, aq->Arr[1]);
+				if (gridCompareHeight(aq->m_aNeighbors[0], aq->m_aNeighbors[1]))
+					aq11->setNeighbor(4, aq->m_aNeighbors[1]);
 
-				if (aq11->Arr[1] != -1)
+				if (aq11->m_aNeighbors[1] != -1)
 				{
-					if (AIGridCompareHeight(aq11->Arr[1], aq->Arr[1]))
-						ArrQuads[aq11->Arr[1]]->SetNeighbor(7, aq->Arr[1]);
+					if (gridCompareHeight(aq11->m_aNeighbors[1], aq->m_aNeighbors[1]))
+						m_aQuads[aq11->m_aNeighbors[1]]->setNeighbor(7, aq->m_aNeighbors[1]);
 
-					if (AIGridCompareHeight(aq->Arr[1], aq11->Arr[1]))
-						aq12->SetNeighbor(0, aq11->Arr[1]);
+					if (gridCompareHeight(aq->m_aNeighbors[1], aq11->m_aNeighbors[1]))
+						aq12->setNeighbor(0, aq11->m_aNeighbors[1]);
 				}
 
-				if (aq11->Arr[1] != -1 && ArrQuads[aq11->Arr[1]]->Arr[4] != -1)
+				if (aq11->m_aNeighbors[1] != -1 && m_aQuads[aq11->m_aNeighbors[1]]->m_aNeighbors[4] != -1)
 				{
-					if (AIGridCompareHeight(ArrQuads[aq11->Arr[1]]->Arr[4], aq->Arr[1]))
-						ArrQuads[ArrQuads[aq11->Arr[1]]->Arr[4]]->SetNeighbor(6, aq->Arr[1]);
+					if (gridCompareHeight(m_aQuads[aq11->m_aNeighbors[1]]->m_aNeighbors[4], aq->m_aNeighbors[1]))
+						m_aQuads[m_aQuads[aq11->m_aNeighbors[1]]->m_aNeighbors[4]]->setNeighbor(6, aq->m_aNeighbors[1]);
 
-					if (AIGridCompareHeight(aq->Arr[1], ArrQuads[aq11->Arr[1]]->Arr[4]))
-						aq12->SetNeighbor(1, ArrQuads[aq11->Arr[1]]->Arr[4]);
+					if (gridCompareHeight(aq->m_aNeighbors[1], m_aQuads[aq11->m_aNeighbors[1]]->m_aNeighbors[4]))
+						aq12->setNeighbor(1, m_aQuads[aq11->m_aNeighbors[1]]->m_aNeighbors[4]);
 				}
-				else if (aq11->Arr[2] != -1)
+				else if (aq11->m_aNeighbors[2] != -1)
 				{
-					if (AIGridCompareHeight(aq11->Arr[2], aq->Arr[1]))
-						ArrQuads[aq11->Arr[2]]->SetNeighbor(6, aq->Arr[1]);
+					if (gridCompareHeight(aq11->m_aNeighbors[2], aq->m_aNeighbors[1]))
+						m_aQuads[aq11->m_aNeighbors[2]]->setNeighbor(6, aq->m_aNeighbors[1]);
 
-					if (AIGridCompareHeight(aq->Arr[1], aq11->Arr[2]))
-						aq12->SetNeighbor(1, aq11->Arr[2]);
+					if (gridCompareHeight(aq->m_aNeighbors[1], aq11->m_aNeighbors[2]))
+						aq12->setNeighbor(1, aq11->m_aNeighbors[2]);
 				}
 			}
 
 			//если у обрабатываемого нода есть верхний правый
-			if (aq->Arr[2] != -1)
+			if (aq->m_aNeighbors[2] != -1)
 			{
-				if (AIGridCompareHeight(aq->Arr[1], aq->Arr[2]))
-					aq12->SetNeighbor(4, aq->Arr[2]);
+				if (gridCompareHeight(aq->m_aNeighbors[1], aq->m_aNeighbors[2]))
+					aq12->setNeighbor(4, aq->m_aNeighbors[2]);
 
-				if (AIGridCompareHeight(aq->Arr[1], aq->Arr[1]))
-					aq13->SetNeighbor(3, aq->Arr[1]);
+				if (gridCompareHeight(aq->m_aNeighbors[1], aq->m_aNeighbors[1]))
+					aq13->setNeighbor(3, aq->m_aNeighbors[1]);
 
-				if (aq13->Arr[1] != -1)
+				if (aq13->m_aNeighbors[1] != -1)
 				{
-					if (AIGridCompareHeight(aq13->Arr[1], aq->Arr[1]))
-						ArrQuads[aq13->Arr[1]]->SetNeighbor(5, aq->Arr[1]);
+					if (gridCompareHeight(aq13->m_aNeighbors[1], aq->m_aNeighbors[1]))
+						m_aQuads[aq13->m_aNeighbors[1]]->setNeighbor(5, aq->m_aNeighbors[1]);
 
-					if (AIGridCompareHeight(aq->Arr[1], aq13->Arr[1]))
-						aq12->SetNeighbor(2, aq13->Arr[1]);
+					if (gridCompareHeight(aq->m_aNeighbors[1], aq13->m_aNeighbors[1]))
+						aq12->setNeighbor(2, aq13->m_aNeighbors[1]);
 				}
 
-				if (aq12->Arr[1] == -1)
+				if (aq12->m_aNeighbors[1] == -1)
 				{
-					if (aq13->Arr[1] != -1 && ArrQuads[aq13->Arr[1]]->Arr[3] != -1)
+					if (aq13->m_aNeighbors[1] != -1 && m_aQuads[aq13->m_aNeighbors[1]]->m_aNeighbors[3] != -1)
 					{
-						if (AIGridCompareHeight(ArrQuads[aq13->Arr[1]]->Arr[3], aq->Arr[1]))
-							ArrQuads[ArrQuads[aq13->Arr[1]]->Arr[3]]->SetNeighbor(6, aq->Arr[1]);
+						if (gridCompareHeight(m_aQuads[aq13->m_aNeighbors[1]]->m_aNeighbors[3], aq->m_aNeighbors[1]))
+							m_aQuads[m_aQuads[aq13->m_aNeighbors[1]]->m_aNeighbors[3]]->setNeighbor(6, aq->m_aNeighbors[1]);
 
-						if (AIGridCompareHeight(aq->Arr[1], ArrQuads[aq13->Arr[1]]->Arr[3]))
-							aq12->SetNeighbor(1, ArrQuads[aq13->Arr[1]]->Arr[3]);
+						if (gridCompareHeight(aq->m_aNeighbors[1], m_aQuads[aq13->m_aNeighbors[1]]->m_aNeighbors[3]))
+							aq12->setNeighbor(1, m_aQuads[aq13->m_aNeighbors[1]]->m_aNeighbors[3]);
 					}
-					else if (aq13->Arr[0] != -1)
+					else if (aq13->m_aNeighbors[0] != -1)
 					{
-						if (AIGridCompareHeight(aq13->Arr[0], aq->Arr[1]))
-							ArrQuads[aq13->Arr[0]]->SetNeighbor(6, aq->Arr[1]);
+						if (gridCompareHeight(aq13->m_aNeighbors[0], aq->m_aNeighbors[1]))
+							m_aQuads[aq13->m_aNeighbors[0]]->setNeighbor(6, aq->m_aNeighbors[1]);
 
-						if (AIGridCompareHeight(aq->Arr[1], aq13->Arr[0]))
-							aq12->SetNeighbor(1, aq13->Arr[0]);
+						if (gridCompareHeight(aq->m_aNeighbors[1], aq13->m_aNeighbors[0]))
+							aq12->setNeighbor(1, aq13->m_aNeighbors[0]);
 					}
 				}
 			}
@@ -1731,90 +1888,90 @@ void AIGrid::ComputeNeighbor(ID id)
 
 
 		//если создали нижний нод
-		if (aq->Arr[6] != -1)
+		if (aq->m_aNeighbors[6] != -1)
 		{
 			//указываем самый верхний соседом
-			//aq32->Arr[1] = aq->Id;
-			aq32->SetNeighbor(1, aq->Id);
+			//aq32->m_aNeighbors[1] = aq->m_id;
+			aq32->setNeighbor(1, aq->m_id);
 			//если левый верхний создан то он тоже сосед
-			if (aq->Arr[3] != -1)
-				aq32->SetNeighbor(0, aq->Arr[3]);
+			if (aq->m_aNeighbors[3] != -1)
+				aq32->setNeighbor(0, aq->m_aNeighbors[3]);
 
 			//если правый верхний создан то он тоже сосед
-			if (aq->Arr[4] != -1)
-				aq32->SetNeighbor(2, aq->Arr[4]);
+			if (aq->m_aNeighbors[4] != -1)
+				aq32->setNeighbor(2, aq->m_aNeighbors[4]);
 
 			//если у обрабатываемого нода есть нижний левый
-			if (aq->Arr[5] != -1)
+			if (aq->m_aNeighbors[5] != -1)
 			{
-				if (AIGridCompareHeight(aq->Arr[6], aq->Arr[5]))
-					aq32->SetNeighbor(3, aq->Arr[5]);
+				if (gridCompareHeight(aq->m_aNeighbors[6], aq->m_aNeighbors[5]))
+					aq32->setNeighbor(3, aq->m_aNeighbors[5]);
 
-				if (AIGridCompareHeight(aq->Arr[5], aq->Arr[6]))
-					aq31->SetNeighbor(4, aq->Arr[6]);
+				if (gridCompareHeight(aq->m_aNeighbors[5], aq->m_aNeighbors[6]))
+					aq31->setNeighbor(4, aq->m_aNeighbors[6]);
 
-				if (aq31->Arr[6] != -1)
+				if (aq31->m_aNeighbors[6] != -1)
 				{
-					if (AIGridCompareHeight(aq->Arr[6], aq31->Arr[6]))
-						aq32->SetNeighbor(5, aq31->Arr[6]);
+					if (gridCompareHeight(aq->m_aNeighbors[6], aq31->m_aNeighbors[6]))
+						aq32->setNeighbor(5, aq31->m_aNeighbors[6]);
 
-					if (AIGridCompareHeight(aq31->Arr[6], aq->Arr[6]))
-						ArrQuads[aq31->Arr[6]]->SetNeighbor(2, aq->Arr[6]);
+					if (gridCompareHeight(aq31->m_aNeighbors[6], aq->m_aNeighbors[6]))
+						m_aQuads[aq31->m_aNeighbors[6]]->setNeighbor(2, aq->m_aNeighbors[6]);
 				}
 
-				if (aq31->Arr[6] != -1 && ArrQuads[aq31->Arr[6]]->Arr[4] != -1)
+				if (aq31->m_aNeighbors[6] != -1 && m_aQuads[aq31->m_aNeighbors[6]]->m_aNeighbors[4] != -1)
 				{
-					if (AIGridCompareHeight(ArrQuads[aq31->Arr[6]]->Arr[4], aq->Arr[6]))
-						ArrQuads[ArrQuads[aq31->Arr[6]]->Arr[4]]->SetNeighbor(1, aq->Arr[6]);
+					if (gridCompareHeight(m_aQuads[aq31->m_aNeighbors[6]]->m_aNeighbors[4], aq->m_aNeighbors[6]))
+						m_aQuads[m_aQuads[aq31->m_aNeighbors[6]]->m_aNeighbors[4]]->setNeighbor(1, aq->m_aNeighbors[6]);
 
-					if (AIGridCompareHeight(aq->Arr[6], ArrQuads[aq31->Arr[6]]->Arr[4]))
-						aq32->SetNeighbor(6, ArrQuads[aq31->Arr[6]]->Arr[4]);
+					if (gridCompareHeight(aq->m_aNeighbors[6], m_aQuads[aq31->m_aNeighbors[6]]->m_aNeighbors[4]))
+						aq32->setNeighbor(6, m_aQuads[aq31->m_aNeighbors[6]]->m_aNeighbors[4]);
 				}
-				else if (aq31->Arr[7] != -1)
+				else if (aq31->m_aNeighbors[7] != -1)
 				{
-					if (AIGridCompareHeight(aq31->Arr[7], aq->Arr[6]))
-						ArrQuads[aq31->Arr[7]]->SetNeighbor(1, aq->Arr[6]);
+					if (gridCompareHeight(aq31->m_aNeighbors[7], aq->m_aNeighbors[6]))
+						m_aQuads[aq31->m_aNeighbors[7]]->setNeighbor(1, aq->m_aNeighbors[6]);
 
-					if (AIGridCompareHeight(aq->Arr[6], aq31->Arr[7]))
-						aq32->SetNeighbor(6, aq31->Arr[7]);
+					if (gridCompareHeight(aq->m_aNeighbors[6], aq31->m_aNeighbors[7]))
+						aq32->setNeighbor(6, aq31->m_aNeighbors[7]);
 				}
 			}
 
 			//если у обрабатываемого нода есть нижний правый
-			if (aq->Arr[7] != -1)
+			if (aq->m_aNeighbors[7] != -1)
 			{
-				if (AIGridCompareHeight(aq->Arr[6], aq->Arr[7]))
-					aq32->SetNeighbor(4, aq->Arr[7]);
+				if (gridCompareHeight(aq->m_aNeighbors[6], aq->m_aNeighbors[7]))
+					aq32->setNeighbor(4, aq->m_aNeighbors[7]);
 
-				if (AIGridCompareHeight(aq->Arr[7], aq->Arr[6]))
-					aq33->SetNeighbor(3, aq->Arr[6]);
+				if (gridCompareHeight(aq->m_aNeighbors[7], aq->m_aNeighbors[6]))
+					aq33->setNeighbor(3, aq->m_aNeighbors[6]);
 
-				if (aq33->Arr[6] != -1)
+				if (aq33->m_aNeighbors[6] != -1)
 				{
-					if (AIGridCompareHeight(aq->Arr[7], aq->Arr[6]))
-						ArrQuads[aq33->Arr[6]]->SetNeighbor(0, aq->Arr[6]);
+					if (gridCompareHeight(aq->m_aNeighbors[7], aq->m_aNeighbors[6]))
+						m_aQuads[aq33->m_aNeighbors[6]]->setNeighbor(0, aq->m_aNeighbors[6]);
 
-					if (AIGridCompareHeight(aq->Arr[6], aq33->Arr[6]))
-						aq32->SetNeighbor(7, aq33->Arr[6]);
+					if (gridCompareHeight(aq->m_aNeighbors[6], aq33->m_aNeighbors[6]))
+						aq32->setNeighbor(7, aq33->m_aNeighbors[6]);
 				}
 
-				if (aq32->Arr[6] == -1)
+				if (aq32->m_aNeighbors[6] == -1)
 				{
-					if (aq33->Arr[6] != -1 && ArrQuads[aq33->Arr[6]]->Arr[3] != -1)
+					if (aq33->m_aNeighbors[6] != -1 && m_aQuads[aq33->m_aNeighbors[6]]->m_aNeighbors[3] != -1)
 					{
-						if (AIGridCompareHeight(ArrQuads[aq33->Arr[6]]->Arr[3], aq->Arr[6]))
-							ArrQuads[ArrQuads[aq33->Arr[6]]->Arr[3]]->SetNeighbor(1, aq->Arr[6]);
+						if (gridCompareHeight(m_aQuads[aq33->m_aNeighbors[6]]->m_aNeighbors[3], aq->m_aNeighbors[6]))
+							m_aQuads[m_aQuads[aq33->m_aNeighbors[6]]->m_aNeighbors[3]]->setNeighbor(1, aq->m_aNeighbors[6]);
 
-						if (AIGridCompareHeight(aq->Arr[6], ArrQuads[aq33->Arr[6]]->Arr[3]))
-							aq32->SetNeighbor(6, ArrQuads[aq33->Arr[6]]->Arr[3]);
+						if (gridCompareHeight(aq->m_aNeighbors[6], m_aQuads[aq33->m_aNeighbors[6]]->m_aNeighbors[3]))
+							aq32->setNeighbor(6, m_aQuads[aq33->m_aNeighbors[6]]->m_aNeighbors[3]);
 					}
-					else if (aq33->Arr[5] != -1)
+					else if (aq33->m_aNeighbors[5] != -1)
 					{
-						if (AIGridCompareHeight(aq33->Arr[5], aq->Arr[6]))
-							ArrQuads[aq33->Arr[5]]->SetNeighbor(1, aq->Arr[6]);
+						if (gridCompareHeight(aq33->m_aNeighbors[5], aq->m_aNeighbors[6]))
+							m_aQuads[aq33->m_aNeighbors[5]]->setNeighbor(1, aq->m_aNeighbors[6]);
 
-						if (AIGridCompareHeight(aq->Arr[6], aq33->Arr[5]))
-							aq32->SetNeighbor(6, aq33->Arr[5]);
+						if (gridCompareHeight(aq->m_aNeighbors[6], aq33->m_aNeighbors[5]))
+							aq32->setNeighbor(6, aq33->m_aNeighbors[5]);
 					}
 				}
 			}
@@ -1822,177 +1979,177 @@ void AIGrid::ComputeNeighbor(ID id)
 
 
 		//если создали левый нод
-		if (aq->Arr[3] != -1)
+		if (aq->m_aNeighbors[3] != -1)
 		{
 			//указываем самый правый соседом
-			//aq21->Arr[4] = aq->Id;
-			aq21->SetNeighbor(4, aq->Id);
+			//aq21->m_aNeighbors[4] = aq->m_id;
+			aq21->setNeighbor(4, aq->m_id);
 			//если верхний создан то он тоже сосед
-			if (aq->Arr[1] != -1)
-				aq21->SetNeighbor(2, aq->Arr[1]);
+			if (aq->m_aNeighbors[1] != -1)
+				aq21->setNeighbor(2, aq->m_aNeighbors[1]);
 
 			//если верхний создан то он тоже сосед
-			if (aq->Arr[6] != -1)
-				aq21->SetNeighbor(7, aq->Arr[6]);
+			if (aq->m_aNeighbors[6] != -1)
+				aq21->setNeighbor(7, aq->m_aNeighbors[6]);
 
-			if (aq->Arr[0] != -1)
+			if (aq->m_aNeighbors[0] != -1)
 			{
-				if (AIGridCompareHeight(aq->Arr[0], aq->Arr[3]))
-					aq11->SetNeighbor(6, aq->Arr[3]);
+				if (gridCompareHeight(aq->m_aNeighbors[0], aq->m_aNeighbors[3]))
+					aq11->setNeighbor(6, aq->m_aNeighbors[3]);
 
-				if (AIGridCompareHeight(aq->Arr[3], aq->Arr[0]))
-					aq21->SetNeighbor(1, aq->Arr[0]);
+				if (gridCompareHeight(aq->m_aNeighbors[3], aq->m_aNeighbors[0]))
+					aq21->setNeighbor(1, aq->m_aNeighbors[0]);
 
-				if (aq11->Arr[3] != -1)
+				if (aq11->m_aNeighbors[3] != -1)
 				{
-					if (AIGridCompareHeight(aq11->Arr[3], aq->Arr[3]))
-						ArrQuads[aq11->Arr[3]]->SetNeighbor(7, aq->Arr[3]);
+					if (gridCompareHeight(aq11->m_aNeighbors[3], aq->m_aNeighbors[3]))
+						m_aQuads[aq11->m_aNeighbors[3]]->setNeighbor(7, aq->m_aNeighbors[3]);
 
-					if (AIGridCompareHeight(aq->Arr[3], aq11->Arr[3]))
-						aq21->SetNeighbor(0, aq11->Arr[3]);
+					if (gridCompareHeight(aq->m_aNeighbors[3], aq11->m_aNeighbors[3]))
+						aq21->setNeighbor(0, aq11->m_aNeighbors[3]);
 				}
 
-				if (aq11->Arr[3] != -1 && ArrQuads[aq11->Arr[3]]->Arr[6] != -1)
+				if (aq11->m_aNeighbors[3] != -1 && m_aQuads[aq11->m_aNeighbors[3]]->m_aNeighbors[6] != -1)
 				{
-					if (AIGridCompareHeight(aq->Arr[3], ArrQuads[aq11->Arr[3]]->Arr[6]))
-						aq21->SetNeighbor(3, ArrQuads[aq11->Arr[3]]->Arr[6]);
+					if (gridCompareHeight(aq->m_aNeighbors[3], m_aQuads[aq11->m_aNeighbors[3]]->m_aNeighbors[6]))
+						aq21->setNeighbor(3, m_aQuads[aq11->m_aNeighbors[3]]->m_aNeighbors[6]);
 
-					if (AIGridCompareHeight(ArrQuads[aq11->Arr[3]]->Arr[6], aq->Arr[3]))
-						ArrQuads[ArrQuads[aq11->Arr[3]]->Arr[6]]->SetNeighbor(4, aq->Arr[3]);
+					if (gridCompareHeight(m_aQuads[aq11->m_aNeighbors[3]]->m_aNeighbors[6], aq->m_aNeighbors[3]))
+						m_aQuads[m_aQuads[aq11->m_aNeighbors[3]]->m_aNeighbors[6]]->setNeighbor(4, aq->m_aNeighbors[3]);
 				}
-				else if (aq11->Arr[5] != -1)
+				else if (aq11->m_aNeighbors[5] != -1)
 				{
-					if (AIGridCompareHeight(aq->Arr[3], aq11->Arr[5]))
-						aq21->SetNeighbor(3, aq11->Arr[5]);
+					if (gridCompareHeight(aq->m_aNeighbors[3], aq11->m_aNeighbors[5]))
+						aq21->setNeighbor(3, aq11->m_aNeighbors[5]);
 
-					if (AIGridCompareHeight(aq11->Arr[5], aq->Arr[3]))
-						ArrQuads[aq11->Arr[5]]->SetNeighbor(4, aq->Arr[3]);
+					if (gridCompareHeight(aq11->m_aNeighbors[5], aq->m_aNeighbors[3]))
+						m_aQuads[aq11->m_aNeighbors[5]]->setNeighbor(4, aq->m_aNeighbors[3]);
 				}
 			}
 
-			if (aq->Arr[5] != -1)
+			if (aq->m_aNeighbors[5] != -1)
 			{
-				if (AIGridCompareHeight(aq->Arr[5], aq->Arr[3]))
-					aq31->SetNeighbor(1, aq->Arr[3]);
+				if (gridCompareHeight(aq->m_aNeighbors[5], aq->m_aNeighbors[3]))
+					aq31->setNeighbor(1, aq->m_aNeighbors[3]);
 
-				if (AIGridCompareHeight(aq->Arr[3], aq->Arr[5]))
-					aq21->SetNeighbor(6, aq->Arr[5]);
+				if (gridCompareHeight(aq->m_aNeighbors[3], aq->m_aNeighbors[5]))
+					aq21->setNeighbor(6, aq->m_aNeighbors[5]);
 
-				if (aq31->Arr[3] != -1)
+				if (aq31->m_aNeighbors[3] != -1)
 				{
-					if (AIGridCompareHeight(aq31->Arr[3], aq->Arr[3]))
-						ArrQuads[aq31->Arr[3]]->SetNeighbor(2, aq->Arr[3]);
+					if (gridCompareHeight(aq31->m_aNeighbors[3], aq->m_aNeighbors[3]))
+						m_aQuads[aq31->m_aNeighbors[3]]->setNeighbor(2, aq->m_aNeighbors[3]);
 
-					if (AIGridCompareHeight(aq->Arr[3], aq31->Arr[3]))
-						aq21->SetNeighbor(5, aq31->Arr[3]);
+					if (gridCompareHeight(aq->m_aNeighbors[3], aq31->m_aNeighbors[3]))
+						aq21->setNeighbor(5, aq31->m_aNeighbors[3]);
 				}
 
-				if (aq21->Arr[3] == -1)
+				if (aq21->m_aNeighbors[3] == -1)
 				{
-					if (aq31->Arr[3] != -1 && ArrQuads[aq31->Arr[3]]->Arr[1] != -1)
+					if (aq31->m_aNeighbors[3] != -1 && m_aQuads[aq31->m_aNeighbors[3]]->m_aNeighbors[1] != -1)
 					{
-						if (AIGridCompareHeight(ArrQuads[aq31->Arr[3]]->Arr[1], aq->Arr[3]))
-							ArrQuads[ArrQuads[aq31->Arr[3]]->Arr[1]]->SetNeighbor(4, aq->Arr[3]);
+						if (gridCompareHeight(m_aQuads[aq31->m_aNeighbors[3]]->m_aNeighbors[1], aq->m_aNeighbors[3]))
+							m_aQuads[m_aQuads[aq31->m_aNeighbors[3]]->m_aNeighbors[1]]->setNeighbor(4, aq->m_aNeighbors[3]);
 
-						if (AIGridCompareHeight(aq->Arr[3], ArrQuads[aq31->Arr[3]]->Arr[1]))
-							aq21->SetNeighbor(3, ArrQuads[aq31->Arr[3]]->Arr[1]);
+						if (gridCompareHeight(aq->m_aNeighbors[3], m_aQuads[aq31->m_aNeighbors[3]]->m_aNeighbors[1]))
+							aq21->setNeighbor(3, m_aQuads[aq31->m_aNeighbors[3]]->m_aNeighbors[1]);
 					}
-					else if (aq31->Arr[0] != -1)
+					else if (aq31->m_aNeighbors[0] != -1)
 					{
-						if (AIGridCompareHeight(aq31->Arr[0], aq->Arr[3]))
-							ArrQuads[aq31->Arr[0]]->SetNeighbor(4, aq->Arr[3]);
+						if (gridCompareHeight(aq31->m_aNeighbors[0], aq->m_aNeighbors[3]))
+							m_aQuads[aq31->m_aNeighbors[0]]->setNeighbor(4, aq->m_aNeighbors[3]);
 
-						if (AIGridCompareHeight(aq->Arr[3], aq31->Arr[0]))
-							aq21->SetNeighbor(3, aq31->Arr[0]);
+						if (gridCompareHeight(aq->m_aNeighbors[3], aq31->m_aNeighbors[0]))
+							aq21->setNeighbor(3, aq31->m_aNeighbors[0]);
 					}
 				}
 			}
 		}
 
 		//если создали правый нод
-		if (aq->Arr[4] != -1)
+		if (aq->m_aNeighbors[4] != -1)
 		{
 			//указываем самый левый соседом
-			aq23->SetNeighbor(3, aq->Id);
+			aq23->setNeighbor(3, aq->m_id);
 			//если верхний создан то он тоже сосед
-			if (aq->Arr[1] != -1)
-				aq23->SetNeighbor(0, aq->Arr[1]);
+			if (aq->m_aNeighbors[1] != -1)
+				aq23->setNeighbor(0, aq->m_aNeighbors[1]);
 
 			//если нижний создан то он тоже сосед
-			if (aq->Arr[6] != -1)
-				aq23->SetNeighbor(5, aq->Arr[6]);
+			if (aq->m_aNeighbors[6] != -1)
+				aq23->setNeighbor(5, aq->m_aNeighbors[6]);
 
 
-			if (aq->Arr[2] != -1)
+			if (aq->m_aNeighbors[2] != -1)
 			{
-				if (AIGridCompareHeight(aq->Arr[2], aq->Arr[4]))
-					aq13->SetNeighbor(6, aq->Arr[4]);
+				if (gridCompareHeight(aq->m_aNeighbors[2], aq->m_aNeighbors[4]))
+					aq13->setNeighbor(6, aq->m_aNeighbors[4]);
 
-				if (AIGridCompareHeight(aq->Arr[4], aq->Arr[2]))
-					aq23->SetNeighbor(1, aq->Arr[2]);
+				if (gridCompareHeight(aq->m_aNeighbors[4], aq->m_aNeighbors[2]))
+					aq23->setNeighbor(1, aq->m_aNeighbors[2]);
 
-				if (aq13->Arr[4] != -1)
+				if (aq13->m_aNeighbors[4] != -1)
 				{
-					if (AIGridCompareHeight(aq->Arr[4], aq13->Arr[4]))
-						aq23->SetNeighbor(2, aq13->Arr[4]);
+					if (gridCompareHeight(aq->m_aNeighbors[4], aq13->m_aNeighbors[4]))
+						aq23->setNeighbor(2, aq13->m_aNeighbors[4]);
 
-					if (AIGridCompareHeight(aq13->Arr[4], aq->Arr[4]))
-						ArrQuads[aq13->Arr[4]]->SetNeighbor(5, aq->Arr[4]);
+					if (gridCompareHeight(aq13->m_aNeighbors[4], aq->m_aNeighbors[4]))
+						m_aQuads[aq13->m_aNeighbors[4]]->setNeighbor(5, aq->m_aNeighbors[4]);
 				}
 
 
-				if (aq13->Arr[4] != -1 && ArrQuads[aq13->Arr[4]]->Arr[6] != -1)
+				if (aq13->m_aNeighbors[4] != -1 && m_aQuads[aq13->m_aNeighbors[4]]->m_aNeighbors[6] != -1)
 				{
-					if (AIGridCompareHeight(aq->Arr[4], ArrQuads[aq13->Arr[4]]->Arr[6]))
-						aq23->SetNeighbor(4, ArrQuads[aq13->Arr[4]]->Arr[6]);
+					if (gridCompareHeight(aq->m_aNeighbors[4], m_aQuads[aq13->m_aNeighbors[4]]->m_aNeighbors[6]))
+						aq23->setNeighbor(4, m_aQuads[aq13->m_aNeighbors[4]]->m_aNeighbors[6]);
 
-					if (AIGridCompareHeight(ArrQuads[aq13->Arr[4]]->Arr[6], aq->Arr[4]))
-						ArrQuads[ArrQuads[aq13->Arr[4]]->Arr[6]]->SetNeighbor(3, aq->Arr[4]);
+					if (gridCompareHeight(m_aQuads[aq13->m_aNeighbors[4]]->m_aNeighbors[6], aq->m_aNeighbors[4]))
+						m_aQuads[m_aQuads[aq13->m_aNeighbors[4]]->m_aNeighbors[6]]->setNeighbor(3, aq->m_aNeighbors[4]);
 				}
-				else if (aq13->Arr[7] != -1)
+				else if (aq13->m_aNeighbors[7] != -1)
 				{
-					if (AIGridCompareHeight(aq->Arr[4], aq13->Arr[7]))
-						aq23->SetNeighbor(4, aq13->Arr[7]);
+					if (gridCompareHeight(aq->m_aNeighbors[4], aq13->m_aNeighbors[7]))
+						aq23->setNeighbor(4, aq13->m_aNeighbors[7]);
 
-					if (AIGridCompareHeight(aq13->Arr[7], aq->Arr[4]))
-						ArrQuads[aq13->Arr[7]]->SetNeighbor(3, aq->Arr[4]);
+					if (gridCompareHeight(aq13->m_aNeighbors[7], aq->m_aNeighbors[4]))
+						m_aQuads[aq13->m_aNeighbors[7]]->setNeighbor(3, aq->m_aNeighbors[4]);
 				}
 			}
 
-			if (aq->Arr[7] != -1)
+			if (aq->m_aNeighbors[7] != -1)
 			{
-				if (AIGridCompareHeight(aq->Arr[7], aq->Arr[4]))
-					aq33->SetNeighbor(1, aq->Arr[4]);
+				if (gridCompareHeight(aq->m_aNeighbors[7], aq->m_aNeighbors[4]))
+					aq33->setNeighbor(1, aq->m_aNeighbors[4]);
 
-				if (AIGridCompareHeight(aq->Arr[4], aq->Arr[7]))
-					aq23->SetNeighbor(6, aq->Arr[7]);
+				if (gridCompareHeight(aq->m_aNeighbors[4], aq->m_aNeighbors[7]))
+					aq23->setNeighbor(6, aq->m_aNeighbors[7]);
 
-				if (aq33->Arr[4] != -1)
+				if (aq33->m_aNeighbors[4] != -1)
 				{
-					if (AIGridCompareHeight(aq->Arr[4], aq33->Arr[4]))
-						aq23->SetNeighbor(7, aq33->Arr[4]);
+					if (gridCompareHeight(aq->m_aNeighbors[4], aq33->m_aNeighbors[4]))
+						aq23->setNeighbor(7, aq33->m_aNeighbors[4]);
 
-					if (AIGridCompareHeight(aq33->Arr[4], aq->Arr[4]))
-						ArrQuads[aq33->Arr[4]]->SetNeighbor(0, aq->Arr[4]);
+					if (gridCompareHeight(aq33->m_aNeighbors[4], aq->m_aNeighbors[4]))
+						m_aQuads[aq33->m_aNeighbors[4]]->setNeighbor(0, aq->m_aNeighbors[4]);
 				}
 
-				if (aq23->Arr[4] == -1)
+				if (aq23->m_aNeighbors[4] == -1)
 				{
-					if (aq33->Arr[4] != -1 && ArrQuads[aq33->Arr[4]]->Arr[1] != -1)
+					if (aq33->m_aNeighbors[4] != -1 && m_aQuads[aq33->m_aNeighbors[4]]->m_aNeighbors[1] != -1)
 					{
-						if (AIGridCompareHeight(aq->Arr[4], ArrQuads[aq33->Arr[4]]->Arr[1]))
-							aq23->SetNeighbor(4, ArrQuads[aq33->Arr[4]]->Arr[1]);
+						if (gridCompareHeight(aq->m_aNeighbors[4], m_aQuads[aq33->m_aNeighbors[4]]->m_aNeighbors[1]))
+							aq23->setNeighbor(4, m_aQuads[aq33->m_aNeighbors[4]]->m_aNeighbors[1]);
 
-						if (AIGridCompareHeight(ArrQuads[aq33->Arr[4]]->Arr[1], aq->Arr[4]))
-							ArrQuads[ArrQuads[aq33->Arr[4]]->Arr[1]]->SetNeighbor(3, aq->Arr[4]);
+						if (gridCompareHeight(m_aQuads[aq33->m_aNeighbors[4]]->m_aNeighbors[1], aq->m_aNeighbors[4]))
+							m_aQuads[m_aQuads[aq33->m_aNeighbors[4]]->m_aNeighbors[1]]->setNeighbor(3, aq->m_aNeighbors[4]);
 					}
-					else if (aq33->Arr[2] != -1)
+					else if (aq33->m_aNeighbors[2] != -1)
 					{
-						if (AIGridCompareHeight(aq->Arr[4], aq33->Arr[2]))
-							aq23->SetNeighbor(4, aq33->Arr[2]);
+						if (gridCompareHeight(aq->m_aNeighbors[4], aq33->m_aNeighbors[2]))
+							aq23->setNeighbor(4, aq33->m_aNeighbors[2]);
 
-						if (AIGridCompareHeight(aq33->Arr[2], aq->Arr[4]))
-							ArrQuads[aq33->Arr[2]]->SetNeighbor(3, aq->Arr[4]);
+						if (gridCompareHeight(aq33->m_aNeighbors[2], aq->m_aNeighbors[4]))
+							m_aQuads[aq33->m_aNeighbors[2]]->setNeighbor(3, aq->m_aNeighbors[4]);
 					}
 				}
 			}
@@ -2000,61 +2157,190 @@ void AIGrid::ComputeNeighbor(ID id)
 	}
 }
 
-ID AIGrid::QuadGet(const float3* pos, bool isnear_or_permissible) const
+ID CAIGrid::quadGet(const float3* pos, bool isnear_or_permissible) const
 {
+	if (!m_pTreeBound)
+		return -1;
+
 	long heightmin = -1;
 	ID howf = -1;
-	long tmpx = toint100(pos->x);
-	long tmpy = toint100(pos->y);
-	long tmpz = toint100(pos->z);
+	long tmpx = AIGRID_TOINT(pos->x);
+	long tmpy = AIGRID_TOINT(pos->y);
+	long tmpz = AIGRID_TOINT(pos->z);
+	CBoundAIquad *bound = 0;
 
 	int3 tiv;
 
-	for (int i = 1, il = ArrBound.size(); i<il; ++i)
+	/*for (int i = 1, il = m_aBound.size(); i<il; ++i)
 	{
+		bound = m_aBound[i];
 		if (
-			ArrBound[i]->lmin.x - LAIGRID_QUAD_SIZE <= tmpx && ArrBound[i]->lmin.z - LAIGRID_QUAD_SIZE <= tmpz &&
-			ArrBound[i]->lmax.x + LAIGRID_QUAD_SIZE >= tmpx && ArrBound[i]->lmax.z + LAIGRID_QUAD_SIZE >= tmpz
+			m_aBound[i]->m_i3Min.x - LAIGRID_QUAD_SIZE <= tmpx && m_aBound[i]->m_i3Min.z - LAIGRID_QUAD_SIZE <= tmpz &&
+			m_aBound[i]->m_i3Max.x + LAIGRID_QUAD_SIZE >= tmpx && m_aBound[i]->m_i3Max.z + LAIGRID_QUAD_SIZE >= tmpz
 			)
 		{
-			for (int k = 0, kl = ArrBound[i]->ArrIdsQuads.size(); k<kl; ++k)
+			for (int k = 0, kl = m_aBound[i]->m_aIdsQuads.size(); k<kl; ++k)
 			{
-				tiv = ArrLongCoordQuads[ArrBound[i]->ArrIdsQuads[k]];
+				tiv = m_aLongCoordQuads[m_aBound[i]->m_aIdsQuads[k]];
 				if (
-					abs((tiv.x) - (tmpx)) <= LAIGRID_QUAD_SIZEDIV2 &&
-					abs((tiv.z) - (tmpz)) <= LAIGRID_QUAD_SIZEDIV2
+					abs((tiv.x) - (tmpx)) <= LAIGRID_QUAD_SIZE &&
+					abs((tiv.z) - (tmpz)) <= LAIGRID_QUAD_SIZE
 					)
 				{
 
+					CAIquad *pQuad = m_aQuads[bound->m_aIdsQuads[k]];
 					if (
-						(isnear_or_permissible && ((heightmin > -1 && heightmin > abs((ArrLongCoordQuads[ArrBound[i]->ArrIdsQuads[k]].y) - (tmpy))) || heightmin == -1)) ||
-						(!isnear_or_permissible && (abs((ArrLongCoordQuads[ArrBound[i]->ArrIdsQuads[k]].y) - (tmpy)) <= LAIGRID_QUADS_CENTERS_MAXHEIGHT))
+						(
+						abs((pQuad->m_vPos.x) - (pos->x)) <= AIGRID_QUAD_SIZEDIV2 &&
+						abs((pQuad->m_vPos.z) - (pos->z)) <= AIGRID_QUAD_SIZEDIV2
+						)
+						&&
+						(isnear_or_permissible && ((heightmin > -1 && heightmin > abs((tiv.y) - (tmpy))) || heightmin == -1)) ||
+						(!isnear_or_permissible && (abs((tiv.y) - (tmpy)) <= LAIGRID_QUADS_CENTERS_MAXHEIGHT))
 						)
 					{
-						//int3 l3 = ArrLongCoordQuads[ArrBound[i]->ArrIdsQuads[k]];
-						//AIQuad* aq22 = ArrQuads[ArrBound[i]->ArrIdsQuads[k]];
-						heightmin = abs(abs(ArrLongCoordQuads[ArrBound[i]->ArrIdsQuads[k]].y) - abs(tmpy));
-						howf = ArrBound[i]->ArrIdsQuads[k];
+						//int3 l3 = m_aLongCoordQuads[m_aBound[i]->m_aIdsQuads[k]];
+						//CAIquad* aq22 = m_aQuads[m_aBound[i]->m_aIdsQuads[k]];
+						heightmin = abs(abs(m_aLongCoordQuads[m_aBound[i]->m_aIdsQuads[k]].y) - abs(tmpy));
+						howf = m_aBound[i]->m_aIdsQuads[k];
 					}
 				}
 			}
 		}
+	}*/
+
+	//LibReport(REPORT_MSG_LEVEL_NOTICE, "quadGet 0\n");
+
+	Array<CTreeBoundAIquad*, 64> queue;
+	int iCurrKey = 0;
+	queue.push_back(m_pTreeBound);
+	CTreeBoundAIquad *pFoundSplit = 0;
+
+	while (queue.size() > iCurrKey)
+	{
+		CTreeBoundAIquad *pSplit = queue[iCurrKey];
+
+		for (int i = 0; i<4; i++)
+		{
+			if (
+				/*pSplit->m_aSplits[i]->m_i3Min.x - LAIGRID_QUAD_SIZE <= tmpx && pSplit->m_aSplits[i]->m_i3Min.z - LAIGRID_QUAD_SIZE <= tmpz &&
+				pSplit->m_aSplits[i]->m_i3Max.x + LAIGRID_QUAD_SIZE >= tmpx && pSplit->m_aSplits[i]->m_i3Max.z + LAIGRID_QUAD_SIZE >= tmpz*/
+				pSplit->m_aSplits[i]->m_i3Min.x <= tmpx && pSplit->m_aSplits[i]->m_i3Min.y <= tmpy && pSplit->m_aSplits[i]->m_i3Min.z <= tmpz &&
+				pSplit->m_aSplits[i]->m_i3Max.x >= tmpx && pSplit->m_aSplits[i]->m_i3Max.y >= tmpy && pSplit->m_aSplits[i]->m_i3Max.z >= tmpz
+				)
+			{
+				if (pSplit->m_aSplits[i]->m_aSplits[0])
+					queue.push_back(pSplit->m_aSplits[i]);
+				else
+				{
+					pFoundSplit = pSplit->m_aSplits[i];
+					/*queue.clear();
+					break;*/
+
+					for (int j = 0, jl = pFoundSplit->m_pBounds.size(); j < jl; ++j)
+					{
+						bound = pFoundSplit->m_pBounds[j];
+						if (
+							bound->m_aIdsQuads.size() > 0 &&
+							/*bound->m_i3Min.x <= tmpx && bound->m_i3Min.z <= tmpz &&
+							bound->m_i3Max.x >= tmpx && bound->m_i3Max.z >= tmpz*/
+							bound->m_i3Min.x - LAIGRID_QUAD_SIZE <= tmpx && bound->m_i3Min.z - LAIGRID_QUAD_SIZE <= tmpz &&
+							bound->m_i3Max.x + LAIGRID_QUAD_SIZE >= tmpx && bound->m_i3Max.z + LAIGRID_QUAD_SIZE >= tmpz
+							)
+						{
+							for (int k = 0, kl = bound->m_aIdsQuads.size(); k<kl; ++k)
+							{
+								tiv = m_aLongCoordQuads[bound->m_aIdsQuads[k]];
+								if (
+									abs((tiv.x) - (tmpx)) <= LAIGRID_QUAD_SIZE &&
+									abs((tiv.z) - (tmpz)) <= LAIGRID_QUAD_SIZE
+									)
+								{
+									CAIquad *pQuad = m_aQuads[bound->m_aIdsQuads[k]];
+									if (
+										(
+										abs((pQuad->m_vPos.x) - (pos->x)) <= AIGRID_QUAD_SIZEDIV2 &&
+										abs((pQuad->m_vPos.z) - (pos->z)) <= AIGRID_QUAD_SIZEDIV2
+										)
+										&&
+										(isnear_or_permissible && ((heightmin > -1 && heightmin > abs((tiv.y) - (tmpy))) || heightmin == -1)) ||
+										(!isnear_or_permissible && (abs((tiv.y) - (tmpy)) <= LAIGRID_QUADS_CENTERS_MAXHEIGHT))
+										)
+									{
+										//int3 l3 = m_aLongCoordQuads[m_aBound[i]->m_aIdsQuads[k]];
+										//CAIquad* aq22 = m_aQuads[m_aBound[i]->m_aIdsQuads[k]];
+										heightmin = abs(abs(tiv.y) - abs(tmpy));
+										howf = bound->m_aIdsQuads[k];
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+
+		//queue.erase(0);
+		++iCurrKey;
 	}
+
+	if (!pFoundSplit)
+		return -1;
+
+	//LibReport(REPORT_MSG_LEVEL_NOTICE, "quadGet 1\n");
+
+	/*for (int j = 0, jl = pFoundSplit->m_pBounds.size(); j < jl; ++j)
+	{
+		bound = pFoundSplit->m_pBounds[j];
+		if (
+			bound->m_i3Min.x <= tmpx && bound->m_i3Min.y <= tmpy && bound->m_i3Min.z <= tmpz &&
+			bound->m_i3Max.x >= tmpx && bound->m_i3Max.y >= tmpy && bound->m_i3Max.z >= tmpz
+			)
+		{
+			for (int k = 0, kl = bound->m_aIdsQuads.size(); k<kl; ++k)
+			{
+				tiv = m_aLongCoordQuads[bound->m_aIdsQuads[k]];
+				if (
+					abs((tiv.x) - (tmpx)) <= LAIGRID_QUAD_SIZE &&
+					abs((tiv.z) - (tmpz)) <= LAIGRID_QUAD_SIZE
+					)
+				{
+					CAIquad *pQuad = m_aQuads[bound->m_aIdsQuads[k]];
+					if (
+						(
+						abs((pQuad->m_vPos.x) - (pos->x)) <= AIGRID_QUAD_SIZEDIV2 &&
+						abs((pQuad->m_vPos.z) - (pos->z)) <= AIGRID_QUAD_SIZEDIV2
+						)
+						&&
+						(isnear_or_permissible && ((heightmin > -1 && heightmin > abs((tiv.y) - (tmpy))) || heightmin == -1)) ||
+						(!isnear_or_permissible && (abs((tiv.y) - (tmpy)) <= LAIGRID_QUADS_CENTERS_MAXHEIGHT))
+						)
+					{
+						//int3 l3 = m_aLongCoordQuads[m_aBound[i]->m_aIdsQuads[k]];
+						//CAIquad* aq22 = m_aQuads[m_aBound[i]->m_aIdsQuads[k]];
+						heightmin = abs(abs(tiv.y) - abs(tmpy));
+						howf = bound->m_aIdsQuads[k];
+					}
+				}
+			}
+		}
+	}*/
+
 	return howf;
 }
 
-bool AIGrid::QuadGetPos(ID id, float3* pos)
+bool CAIGrid::quadGetPos(ID id, float3* pos) const
 {
-	if (pos && id >= 0 && id < ArrQuads.size())
+	if (pos && id >= 0 && id < m_aQuads.size())
 	{
-		*pos = ArrQuads[id]->pos;
+		*pos = m_aQuads[id]->m_vPos;
 		return false;
 	}
 
 	return false;
 }
 
-ID AIGrid::GridTraceBeam(const float3* start, const float3* dir) const
+ID CAIGrid::gridTraceBeam(const float3* start, const float3* dir) const
 {
 	ID idf = -1;
 	SXTriangle tmptri;
@@ -2066,20 +2352,20 @@ ID AIGrid::GridTraceBeam(const float3* start, const float3* dir) const
 
 	float3 center;
 	float radius;
-	BoundAIQuad* bound = 0;
+	CBoundAIquad* bound = 0;
 	float3 posquad, posquad2;
 
-	for (int i = 0, il = ArrBound.size(); i < il; ++i)
+	for (int i = 0, il = m_aBound.size(); i < il; ++i)
 	{
-		bound = ArrBound[i];
-		center = (bound->min + bound->max) * 0.5f;
-		radius = SMVector3Length(center - bound->max);
+		bound = m_aBound[i];
+		center = (bound->m_f3Min + bound->m_f3Max) * 0.5f;
+		radius = SMVector3Length(center - bound->m_f3Max);
 		float distsqr = SGCore_0DistancePointBeam2(center, *start, *dir);
 		if (distsqr <= radius*radius)
 		{
-			for (int k = 0, kl = bound->ArrIdsQuads.size(); k < kl; ++k)
+			for (int k = 0, kl = bound->m_aIdsQuads.size(); k < kl; ++k)
 			{
-				posquad = (float3)ArrQuads[bound->ArrIdsQuads[k]]->pos;
+				posquad = (float3)m_aQuads[bound->m_aIdsQuads[k]]->m_vPos;
 				tmptri.a = (float3_t)(posquad + float3(-AIGRID_QUAD_SIZEDIV2, 0, -AIGRID_QUAD_SIZEDIV2));
 				tmptri.b = (float3_t)(posquad + float3(AIGRID_QUAD_SIZEDIV2, 0, AIGRID_QUAD_SIZEDIV2));
 				tmptri.c = (float3_t)(posquad + float3(AIGRID_QUAD_SIZEDIV2, 0, -AIGRID_QUAD_SIZEDIV2));
@@ -2088,7 +2374,7 @@ ID AIGrid::GridTraceBeam(const float3* start, const float3* dir) const
 					if (SMVector3Length2((*start) - res) > SMVector3Length2((*start) - ip))
 					{
 						res = ip;
-						idf = bound->ArrIdsQuads[k];
+						idf = bound->m_aIdsQuads[k];
 					}
 				}
 
@@ -2100,7 +2386,7 @@ ID AIGrid::GridTraceBeam(const float3* start, const float3* dir) const
 					if (SMVector3Length2((*start) - res) > SMVector3Length2((*start) - ip))
 					{
 						res = ip;
-						idf = bound->ArrIdsQuads[k];
+						idf = bound->m_aIdsQuads[k];
 					}
 				}
 			}
@@ -2111,43 +2397,44 @@ ID AIGrid::GridTraceBeam(const float3* start, const float3* dir) const
 }
 
 
-//!!! почему то возникла ситуация когда после прохода валидации, у одного (наверное у одного) из квадов айди сплита был == 0, чего в общемто не должно быть
+//!!! (возможно неактуально) почему то возникла ситуация когда после прохода валидации, у одного (наверное у одного) из квадов айди сплита был == 0, чего в общемто не должно быть
 //возможно надо просто проходится циклом по всему массиву квадов и смотреть где у какого квада айди сплита еще равен нулю, а перед этим проходом обнулить все эти айди
 
-void AIGrid::GridTestValidation()
+void CAIGrid::gridTestValidation()
 {
-	if (ArrQuads.size() <= 1 || ArrBound.size() <= 1)
+	if (m_aQuads.size() <= 1 || m_aBound.size() <= 1)
 	{
 		LibReport(REPORT_MSG_LEVEL_WARNING, "AI grid is not created, unresolved validation\n");
 		return;
 	}
 
-	int oldcountquads = ArrQuads.size();
+	int oldcountquads = m_aQuads.size();
 
 	//удаление лишних квадов
-	QuadDeleteInvalidAll();
+	quadDeleteInvalidAll();
 
 	//подсчет и пометка сплитов
 	//{
 
-	for (int i = 0, il = ArrQuads.size(); i < il; ++i)
+	for (int i = 0, il = m_aQuads.size(); i < il; ++i)
 	{
-		ArrQuads[i]->IdSplit = 0;
+		m_aQuads[i]->m_iSplit = 0;
 	}
 
-	ArrTestSplitsIDs.clear();
-	CountSplits = 0;
+	m_aTestSplitsIDs.clear();
+	m_uiCountSplits = 0;
 	
 	while (true)
 	{
 		ID idquadunchecked = -1;
-		
+		CAIquad *quad = 0;
 		//поиск первого не входящего ни в какой сплит
-		for (int i = 0, il = ArrQuads.size(); i < il; ++i)
+		for (int i = 0, il = m_aQuads.size(); i < il; ++i)
 		{
-			if (ArrQuads[i]->IdSplit == 0 && !ArrQuads[i]->IsClose)
+			if (m_aQuads[i]->m_iSplit == 0 && !m_aQuads[i]->m_isClose)
 			{
 				idquadunchecked = i;
+				quad = m_aQuads[i];
 				break;
 			}
 		}
@@ -2158,145 +2445,160 @@ void AIGrid::GridTestValidation()
 
 		ID currkey = 0;
 		ID tmpid = -1;
-		ArrTestSplitsIDs.clear();
-		ArrTestSplitsIDs[0] = idquadunchecked;
-		++CountSplits;
+		m_aTestSplitsIDs.clear();
+		m_aTestSplitsIDs[0] = idquadunchecked;
+		++m_uiCountSplits;
+
+		Array<bool> aPushed;
+		aPushed.resize(m_aQuads.size());
+		memset(&(aPushed[0]), 0, sizeof(bool)* aPushed.size());
 
 		//начиная с первого невходящего квада проходимся по всем узлам к которым можно дойти, относя их к текущему идентификатору сплита
-		while (ArrTestSplitsIDs.size() > currkey)
+		while (m_aTestSplitsIDs.size() > currkey)
 		{
-			tmpid = ArrTestSplitsIDs[currkey];
-			if (ArrQuads[tmpid]->IdSplit == 0)
-			{
-				ArrQuads[tmpid]->IdSplit = CountSplits;
+			tmpid = m_aTestSplitsIDs[currkey];
+			
+			m_aQuads[tmpid]->m_iSplit = m_uiCountSplits;
 
-				//заносим всех соседей в непомеченный список
-				for (int i = 0; i < 8; ++i)
+			//заносим всех соседей в непомеченный список
+			for (int i = 0; i < 8; ++i)
+			{
+				if (isValidIdInArrQuads(m_aQuads[tmpid]->m_aNeighbors[i]) && m_aQuads[m_aQuads[tmpid]->m_aNeighbors[i]]->m_iSplit == 0 && aPushed[m_aQuads[tmpid]->m_aNeighbors[i]] == false)
 				{
-					if (IsValidIdInArrQuads(ArrQuads[tmpid]->Arr[i]))
-						ArrTestSplitsIDs.push_back(ArrQuads[tmpid]->Arr[i]);
+					m_aTestSplitsIDs.push_back(m_aQuads[tmpid]->m_aNeighbors[i]);
+					aPushed[m_aQuads[tmpid]->m_aNeighbors[i]] = true;
 				}
 			}
+			
 			++currkey;
 		}
+
+		int qwerty = 0;
 	}
 
-	for (int i = 0; i < CountSplits; ++i)
+	for (int i = 0; i < m_uiCountSplits; ++i)
 	{
-		ArrSplitsColor[i] = D3DCOLOR_ARGB(200, rand() % 255, rand() % 255, rand() % 255);
+		m_aSplitsColor[i] = D3DCOLOR_ARGB(200, rand() % 255, rand() % 255, rand() % 255);
 	}
 	//}
 
-	LibReport(REPORT_MSG_LEVEL_NOTICE, "AI grid is validation, deleted quads %d, count splits %d\n", oldcountquads - ArrQuads.size(), CountSplits);
+	LibReport(REPORT_MSG_LEVEL_NOTICE, "AI grid is validation, deleted quads %d, count splits %d\n", oldcountquads - m_aQuads.size(), m_uiCountSplits);
 }
 
-UINT AIGrid::GridGetCountSplits()
+UINT CAIGrid::gridGetCountSplits() const
 {
-	return CountSplits;
+	return m_uiCountSplits;
 }
 
-void AIGrid::GridSetMarkSplits(bool mark)
+void CAIGrid::gridSetMarkSplits(bool mark)
 {
-	IsMarkSplits = mark;
+	m_isMarkSplits = mark;
 }
 
-bool AIGrid::GridGetMarkSplits()
+bool CAIGrid::gridGetMarkSplits() const
 {
-	return IsMarkSplits;
+	return m_isMarkSplits;
 }
 
-void AIGrid::RenderBB()
+void CAIGrid::renderBB()
 {
-	if (!UseGraphics)
+	if (!m_useGraphics)
 		return;
 
-	DXDevice->SetTexture(0, SGCore_LoadTexGetTex(Tex_BB));
-	if (BoundBox)
-		BoundBox->DrawSubset(0);
+	m_pDXDevice->SetTexture(0, SGCore_LoadTexGetTex(m_idTexBB));
+	if (m_pBoundBox)
+		m_pBoundBox->DrawSubset(0);
 }
 
-void AIGrid::RenderQuads(const ISXFrustum * frustum, const float3 * viewpos, float dist)
+void CAIGrid::renderQuads(const ISXFrustum * frustum, const float3 * viewpos, float dist)
 {
-	if (!UseGraphics)
+	if (!m_useGraphics)
 		return;
 
 	if (!frustum)
 		return;
 
-	if (TransVertBuf)
+	if (m_pTransVertBuf)
 	{
-		AIQuadVertexDataInst* RTGPUArrVerteces;
-		TransVertBuf->Lock(0, 0, (void**)&RTGPUArrVerteces, D3DLOCK_DISCARD);
+		CAIQuadVertexDataInst* RTGPUArrVerteces;
+		m_pTransVertBuf->Lock(0, 0, (void**)&RTGPUArrVerteces, D3DLOCK_DISCARD);
 		UINT tmpkey = 0;
-		BoundAIQuad * bound = 0;
-		AIQuad * aq = 0;
+		CBoundAIquad * bound = 0;
+		CAIquad * aq = 0;
 		float3 center;
 		float radius;
 
-		for (int i = 0, il = ArrBound.size(); i < il; ++i)
+		for (int i = 0, il = m_aBound.size(); i < il; ++i)
 		{
-			bound = ArrBound[i];
-			center = (bound->min + bound->max) * 0.5f;
-			radius = SMVector3Length(center - bound->max);
+			bound = m_aBound[i];
+			center = (bound->m_f3Min + bound->m_f3Max) * 0.5f;
+			radius = SMVector3Length(center - bound->m_f3Max);
 			if (frustum->sphereInFrustum(&center, radius))
 			{
-				for (int k = 0, kl = bound->ArrIdsQuads.size(); k < kl; ++k)
+				for (int k = 0, kl = bound->m_aIdsQuads.size(); k < kl; ++k)
 				{
-					aq = ArrQuads[bound->ArrIdsQuads[k]];
-					if (SMVector3Distance(aq->pos, (*viewpos)) > dist)
+					aq = m_aQuads[bound->m_aIdsQuads[k]];
+					if (SMVector3Distance(aq->m_vPos, (*viewpos)) > dist)
 						continue;
 
-					RTGPUArrVerteces[tmpkey].pos = aq->pos;
+					RTGPUArrVerteces[tmpkey].m_vPos = aq->m_vPos;
 
-					if (QuadSelectedExists(aq->Id))
-						RTGPUArrVerteces[tmpkey].color = AIGRID_COLOR_SEL_MAIN;
-					else if (QuadSelectedExistsNeightborDirect(aq->Id))
-						RTGPUArrVerteces[tmpkey].color = AIGRID_COLOR_SEL_ADD;
-					else if (CountSplits > 0 && IsMarkSplits)
-						RTGPUArrVerteces[tmpkey].color = (ArrSplitsColor[aq->IdSplit - 1]);
+					if (quadSelectedExists(aq->m_id))
+						RTGPUArrVerteces[tmpkey].m_uiColor = AIGRID_COLOR_SEL_MAIN;
+					else if (quadSelectedExistsNeightborDirect(aq->m_id))
+						RTGPUArrVerteces[tmpkey].m_uiColor = AIGRID_COLOR_SEL_ADD;
+					else if (m_uiCountSplits > 0 && m_isMarkSplits)
+						RTGPUArrVerteces[tmpkey].m_uiColor = (m_aSplitsColor[aq->m_iSplit - 1]);
 					else
-						RTGPUArrVerteces[tmpkey].color = ArrColor[aq->Id];
-
-					if (aq->axisx == AIGRID_QUAD_DIR_POSITIVE && aq->axisy == AIGRID_QUAD_DIR_NEGATIVE)
-						RTGPUArrVerteces[tmpkey].tex = float4_t(0.25f, 0.25f, 0, 0);
-					else if (aq->axisx == AIGRID_QUAD_DIR_ALL && aq->axisy == AIGRID_QUAD_DIR_NEGATIVE)
-						RTGPUArrVerteces[tmpkey].tex = float4_t(0.25f, 0.25f, 0.25f, 0);
-					else if (aq->axisx == AIGRID_QUAD_DIR_NEGATIVE && aq->axisy == AIGRID_QUAD_DIR_NEGATIVE)
-						RTGPUArrVerteces[tmpkey].tex = float4_t(0.25f, 0.25f, 0.5f, 0);
-
-					else if (aq->axisx == AIGRID_QUAD_DIR_POSITIVE && aq->axisy == AIGRID_QUAD_DIR_ALL)
-						RTGPUArrVerteces[tmpkey].tex = float4_t(0.25f, 0.25f, 0, 0.25f);
-					else if (aq->axisx == AIGRID_QUAD_DIR_ALL && aq->axisy == AIGRID_QUAD_DIR_ALL)
-						RTGPUArrVerteces[tmpkey].tex = float4_t(0.25f, 0.25f, 0.25f, 0.25f);
-					else if (aq->axisx == AIGRID_QUAD_DIR_NEGATIVE && aq->axisy == AIGRID_QUAD_DIR_ALL)
-						RTGPUArrVerteces[tmpkey].tex = float4_t(0.25f, 0.25f, 0.5f, 0.25f);
-
-					else if (aq->axisx == AIGRID_QUAD_DIR_POSITIVE && aq->axisy == AIGRID_QUAD_DIR_POSITIVE)
-						RTGPUArrVerteces[tmpkey].tex = float4_t(0.25f, 0.25f, 0, 0.5f);
-					else if (aq->axisx == AIGRID_QUAD_DIR_ALL && aq->axisy == AIGRID_QUAD_DIR_POSITIVE)
-						RTGPUArrVerteces[tmpkey].tex = float4_t(0.25f, 0.25f, 0.25f, 0.5f);
-					else if (aq->axisx == AIGRID_QUAD_DIR_NEGATIVE && aq->axisy == AIGRID_QUAD_DIR_POSITIVE)
-						RTGPUArrVerteces[tmpkey].tex = float4_t(0.25f, 0.25f, 0.5f, 0.5f);
-
-					else if (aq->axisx == AIGRID_QUAD_DIR_NEGATIVE && aq->axisy == AIGRID_QUAD_DIR_NONE)
-						RTGPUArrVerteces[tmpkey].tex = float4_t(0.25f, 0.25f, 0.25f, 0.75f);
-					else if (aq->axisx == AIGRID_QUAD_DIR_POSITIVE && aq->axisy == AIGRID_QUAD_DIR_NONE)
-						RTGPUArrVerteces[tmpkey].tex = float4_t(0.25f, 0.25f, 0.5f, 0.75f);
-
-					else if (aq->axisx == AIGRID_QUAD_DIR_NONE && aq->axisy == AIGRID_QUAD_DIR_NEGATIVE)
-						RTGPUArrVerteces[tmpkey].tex = float4_t(0.25f, 0.25f, 0.75f, 0.75f);
-					else if (aq->axisx == AIGRID_QUAD_DIR_NONE && aq->axisy == AIGRID_QUAD_DIR_POSITIVE)
-						RTGPUArrVerteces[tmpkey].tex = float4_t(0.25f, 0.25f, 0.75f, 0.5f);
-
-					else if (aq->axisx == AIGRID_QUAD_DIR_ALL && aq->axisy == AIGRID_QUAD_DIR_NONE)
-						RTGPUArrVerteces[tmpkey].tex = float4_t(0.25f, 0.25f, 0.75f, 0.25f);
-					else if (aq->axisx == AIGRID_QUAD_DIR_NONE && aq->axisy == AIGRID_QUAD_DIR_ALL)
-						RTGPUArrVerteces[tmpkey].tex = float4_t(0.25f, 0.25f, 0.75f, 0);
+						RTGPUArrVerteces[tmpkey].m_uiColor = m_aQuadColors[aq->m_id];
+
+					/*if (aq->m_iSplit > 1)
+					{
+						int qwerty = 0;
+						RTGPUArrVerteces[tmpkey].pos.y += 0.1;
+						RTGPUArrVerteces[tmpkey].m_uiColor = D3DCOLOR_ARGB(128, 255, 0, 0);
+					}*/
+
+					if (aq->m_chAxisX == AIGRID_QUAD_DIR_POSITIVE && aq->m_chAxisY == AIGRID_QUAD_DIR_NEGATIVE)
+						RTGPUArrVerteces[tmpkey].m_vTC = float4_t(0.25f, 0.25f, 0, 0);
+					else if (aq->m_chAxisX == AIGRID_QUAD_DIR_ALL && aq->m_chAxisY == AIGRID_QUAD_DIR_NEGATIVE)
+						RTGPUArrVerteces[tmpkey].m_vTC = float4_t(0.25f, 0.25f, 0.25f, 0);
+					else if (aq->m_chAxisX == AIGRID_QUAD_DIR_NEGATIVE && aq->m_chAxisY == AIGRID_QUAD_DIR_NEGATIVE)
+						RTGPUArrVerteces[tmpkey].m_vTC = float4_t(0.25f, 0.25f, 0.5f, 0);
+
+					else if (aq->m_chAxisX == AIGRID_QUAD_DIR_POSITIVE && aq->m_chAxisY == AIGRID_QUAD_DIR_ALL)
+						RTGPUArrVerteces[tmpkey].m_vTC = float4_t(0.25f, 0.25f, 0, 0.25f);
+					else if (aq->m_chAxisX == AIGRID_QUAD_DIR_ALL && aq->m_chAxisY == AIGRID_QUAD_DIR_ALL)
+						RTGPUArrVerteces[tmpkey].m_vTC = float4_t(0.25f, 0.25f, 0.25f, 0.25f);
+					else if (aq->m_chAxisX == AIGRID_QUAD_DIR_NEGATIVE && aq->m_chAxisY == AIGRID_QUAD_DIR_ALL)
+						RTGPUArrVerteces[tmpkey].m_vTC = float4_t(0.25f, 0.25f, 0.5f, 0.25f);
+
+					else if (aq->m_chAxisX == AIGRID_QUAD_DIR_POSITIVE && aq->m_chAxisY == AIGRID_QUAD_DIR_POSITIVE)
+						RTGPUArrVerteces[tmpkey].m_vTC = float4_t(0.25f, 0.25f, 0, 0.5f);
+					else if (aq->m_chAxisX == AIGRID_QUAD_DIR_ALL && aq->m_chAxisY == AIGRID_QUAD_DIR_POSITIVE)
+						RTGPUArrVerteces[tmpkey].m_vTC = float4_t(0.25f, 0.25f, 0.25f, 0.5f);
+					else if (aq->m_chAxisX == AIGRID_QUAD_DIR_NEGATIVE && aq->m_chAxisY == AIGRID_QUAD_DIR_POSITIVE)
+						RTGPUArrVerteces[tmpkey].m_vTC = float4_t(0.25f, 0.25f, 0.5f, 0.5f);
+
+					else if (aq->m_chAxisX == AIGRID_QUAD_DIR_NEGATIVE && aq->m_chAxisY == AIGRID_QUAD_DIR_NONE)
+						RTGPUArrVerteces[tmpkey].m_vTC = float4_t(0.25f, 0.25f, 0.25f, 0.75f);
+					else if (aq->m_chAxisX == AIGRID_QUAD_DIR_POSITIVE && aq->m_chAxisY == AIGRID_QUAD_DIR_NONE)
+						RTGPUArrVerteces[tmpkey].m_vTC = float4_t(0.25f, 0.25f, 0.5f, 0.75f);
+
+					else if (aq->m_chAxisX == AIGRID_QUAD_DIR_NONE && aq->m_chAxisY == AIGRID_QUAD_DIR_NEGATIVE)
+						RTGPUArrVerteces[tmpkey].m_vTC = float4_t(0.25f, 0.25f, 0.75f, 0.75f);
+					else if (aq->m_chAxisX == AIGRID_QUAD_DIR_NONE && aq->m_chAxisY == AIGRID_QUAD_DIR_POSITIVE)
+						RTGPUArrVerteces[tmpkey].m_vTC = float4_t(0.25f, 0.25f, 0.75f, 0.5f);
+
+					else if (aq->m_chAxisX == AIGRID_QUAD_DIR_ALL && aq->m_chAxisY == AIGRID_QUAD_DIR_NONE)
+						RTGPUArrVerteces[tmpkey].m_vTC = float4_t(0.25f, 0.25f, 0.75f, 0.25f);
+					else if (aq->m_chAxisX == AIGRID_QUAD_DIR_NONE && aq->m_chAxisY == AIGRID_QUAD_DIR_ALL)
+						RTGPUArrVerteces[tmpkey].m_vTC = float4_t(0.25f, 0.25f, 0.75f, 0);
 
 					else
 					{
-						RTGPUArrVerteces[tmpkey].tex = float4_t(1, 1, 0, 0);
-						RTGPUArrVerteces[tmpkey].color = D3DCOLOR_ARGB(255, 255, 0, 0);
+						RTGPUArrVerteces[tmpkey].m_vTC = float4_t(1, 1, 0, 0);
+						RTGPUArrVerteces[tmpkey].m_uiColor = D3DCOLOR_ARGB(255, 255, 0, 0);
 					}
 
 					++tmpkey;
@@ -2304,155 +2606,155 @@ void AIGrid::RenderQuads(const ISXFrustum * frustum, const float3 * viewpos, flo
 			}
 		}
 
-		TransVertBuf->Unlock();
+		m_pTransVertBuf->Unlock();
 
-		DXDevice->SetStreamSourceFreq(0, (D3DSTREAMSOURCE_INDEXEDDATA | tmpkey));
+		m_pDXDevice->SetStreamSourceFreq(0, (D3DSTREAMSOURCE_INDEXEDDATA | tmpkey));
 
-		DXDevice->SetStreamSourceFreq(1, (D3DSTREAMSOURCE_INSTANCEDATA | 1));
-		DXDevice->SetStreamSource(1, TransVertBuf, 0, sizeof(AIQuadVertexDataInst));
+		m_pDXDevice->SetStreamSourceFreq(1, (D3DSTREAMSOURCE_INSTANCEDATA | 1));
+		m_pDXDevice->SetStreamSource(1, m_pTransVertBuf, 0, sizeof(CAIQuadVertexDataInst));
 
-		DXDevice->SetStreamSource(0, VertexQuad, 0, sizeof(AIQuadVertexData));
-		DXDevice->SetIndices(IndexQuad);
-		DXDevice->SetVertexDeclaration(AIQuadDecl);
+		m_pDXDevice->SetStreamSource(0, m_pVertexQuad, 0, sizeof(CAIQuadVertexData));
+		m_pDXDevice->SetIndices(m_pIndexQuad);
+		m_pDXDevice->SetVertexDeclaration(m_pDecl);
 
-		DXDevice->SetTexture(0, SGCore_LoadTexGetTex(Tex_AIGrid));
+		m_pDXDevice->SetTexture(0, SGCore_LoadTexGetTex(m_idTex));
 
-		SGCore_ShaderBind(SHADER_TYPE_VERTEX, IDVS);
-		SGCore_ShaderBind(SHADER_TYPE_PIXEL, IDPS);
+		SGCore_ShaderBind(SHADER_TYPE_VERTEX, m_idVS);
+		SGCore_ShaderBind(SHADER_TYPE_PIXEL, m_idPS);
 
 		D3DXMATRIX tmpview, tmpproj;
-		DXDevice->GetTransform(D3DTS_VIEW, &tmpview);
-		DXDevice->GetTransform(D3DTS_PROJECTION, &tmpproj);
+		m_pDXDevice->GetTransform(D3DTS_VIEW, &tmpview);
+		m_pDXDevice->GetTransform(D3DTS_PROJECTION, &tmpproj);
 
 		float4x4 wvp = SMMatrixIdentity() * float4x4(tmpview) * float4x4(tmpproj);
 		wvp = SMMatrixTranspose(wvp);
 
-		SGCore_ShaderSetVRF(SHADER_TYPE_VERTEX, IDVS, "WorldViewProjection", &wvp);
+		SGCore_ShaderSetVRF(SHADER_TYPE_VERTEX, m_idVS, "WorldViewProjection", &wvp);
 
-		DXDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, 4, 0, 2);
+		m_pDXDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, 4, 0, 2);
 
 		SGCore_ShaderUnBind();
 
-		DXDevice->SetStreamSourceFreq(0, 1);
-		DXDevice->SetStreamSourceFreq(1, 1);
+		m_pDXDevice->SetStreamSourceFreq(0, 1);
+		m_pDXDevice->SetStreamSourceFreq(1, 1);
 	}
 }
 
-void AIGrid::RenderGraphPoints(const float3 * viewpos, float dist)
+void CAIGrid::renderGraphPoints(const float3 * viewpos, float dist)
 {
-	if (!UseGraphics)
+	if (!m_useGraphics)
 		return;
 
-	if (TransVertBuf)
+	if (m_pTransVertBuf)
 	{
-		AIQuadVertexDataInst* RTGPUArrVerteces;
-		TransVertBuf->Lock(0, 0, (void**)&RTGPUArrVerteces, D3DLOCK_DISCARD);
+		CAIQuadVertexDataInst* RTGPUArrVerteces;
+		m_pTransVertBuf->Lock(0, 0, (void**)&RTGPUArrVerteces, D3DLOCK_DISCARD);
 		UINT tmpkey = 0;
-		AIQuad* aq = 0;
-		for (UINT i = 0; i<ArrGraphPointsIDs.size(); ++i)
+		CAIquad* aq = 0;
+		for (UINT i = 0; i<m_aGraphPointsIDs.size(); ++i)
 		{
-			aq = ArrQuads[ArrGraphPointsIDs[i]];
-			if (!(aq->IsClose) && SMVector3Distance(aq->pos, (*viewpos)) <= dist)
+			aq = m_aQuads[m_aGraphPointsIDs[i]];
+			if (!(aq->m_isClose) && SMVector3Distance(aq->m_vPos, (*viewpos)) <= dist)
 			{
-				RTGPUArrVerteces[tmpkey].pos = aq->pos;
+				RTGPUArrVerteces[tmpkey].m_vPos = aq->m_vPos;
 				//RTGPUArrVerteces[tmpkey].pos.y += 0.1f;
 
-				if (aq->axisx == 1 && aq->axisy == -1)
-					RTGPUArrVerteces[tmpkey].tex = float4_t(0.25f, 0.25f, 0, 0);
-				else if (aq->axisx == 0 && aq->axisy == -1)
-					RTGPUArrVerteces[tmpkey].tex = float4_t(0.25f, 0.25f, 0.25f, 0);
-				else if (aq->axisx == -1 && aq->axisy == -1)
-					RTGPUArrVerteces[tmpkey].tex = float4_t(0.25f, 0.25f, 0.5f, 0);
-
-				else if (aq->axisx == 1 && aq->axisy == 0)
-					RTGPUArrVerteces[tmpkey].tex = float4_t(0.25f, 0.25f, 0, 0.25f);
-				else if (aq->axisx == 0 && aq->axisy == 0)
-					RTGPUArrVerteces[tmpkey].tex = float4_t(0.25f, 0.25f, 0.25f, 0.25f);
-				else if (aq->axisx == -1 && aq->axisy == 0)
-					RTGPUArrVerteces[tmpkey].tex = float4_t(0.25f, 0.25f, 0.5f, 0.25f);
-
-				else if (aq->axisx == 1 && aq->axisy == 1)
-					RTGPUArrVerteces[tmpkey].tex = float4_t(0.25f, 0.25f, 0, 0.5f);
-				else if (aq->axisx == 0 && aq->axisy == 1)
-					RTGPUArrVerteces[tmpkey].tex = float4_t(0.25f, 0.25f, 0.25f, 0.5f);
-				else if (aq->axisx == -1 && aq->axisy == 1)
-					RTGPUArrVerteces[tmpkey].tex = float4_t(0.25f, 0.25f, 0.5f, 0.5f);
-
-				else if (aq->axisx == -1 && aq->axisy == 2)
-					RTGPUArrVerteces[tmpkey].tex = float4_t(0.25f, 0.25f, 0.25f, 0.75f);
-				else if (aq->axisx == 1 && aq->axisy == 2)
-					RTGPUArrVerteces[tmpkey].tex = float4_t(0.25f, 0.25f, 0.5f, 0.75f);
-
-				else if (aq->axisx == 2 && aq->axisy == -1)
-					RTGPUArrVerteces[tmpkey].tex = float4_t(0.25f, 0.25f, 0.75f, 0.75f);
-				else if (aq->axisx == 2 && aq->axisy == 1)
-					RTGPUArrVerteces[tmpkey].tex = float4_t(0.25f, 0.25f, 0.75f, 0.5f);
-
-				else if (aq->axisx == 0 && aq->axisy == 2)
-					RTGPUArrVerteces[tmpkey].tex = float4_t(0.25f, 0.25f, 0.75f, 0.25f);
-				else if (aq->axisx == 2 && aq->axisy == 0)
-					RTGPUArrVerteces[tmpkey].tex = float4_t(0.25f, 0.25f, 0.75f, 0);
+				if (aq->m_chAxisX == 1 && aq->m_chAxisY == -1)
+					RTGPUArrVerteces[tmpkey].m_vTC = float4_t(0.25f, 0.25f, 0, 0);
+				else if (aq->m_chAxisX == 0 && aq->m_chAxisY == -1)
+					RTGPUArrVerteces[tmpkey].m_vTC = float4_t(0.25f, 0.25f, 0.25f, 0);
+				else if (aq->m_chAxisX == -1 && aq->m_chAxisY == -1)
+					RTGPUArrVerteces[tmpkey].m_vTC = float4_t(0.25f, 0.25f, 0.5f, 0);
+
+				else if (aq->m_chAxisX == 1 && aq->m_chAxisY == 0)
+					RTGPUArrVerteces[tmpkey].m_vTC = float4_t(0.25f, 0.25f, 0, 0.25f);
+				else if (aq->m_chAxisX == 0 && aq->m_chAxisY == 0)
+					RTGPUArrVerteces[tmpkey].m_vTC = float4_t(0.25f, 0.25f, 0.25f, 0.25f);
+				else if (aq->m_chAxisX == -1 && aq->m_chAxisY == 0)
+					RTGPUArrVerteces[tmpkey].m_vTC = float4_t(0.25f, 0.25f, 0.5f, 0.25f);
+
+				else if (aq->m_chAxisX == 1 && aq->m_chAxisY == 1)
+					RTGPUArrVerteces[tmpkey].m_vTC = float4_t(0.25f, 0.25f, 0, 0.5f);
+				else if (aq->m_chAxisX == 0 && aq->m_chAxisY == 1)
+					RTGPUArrVerteces[tmpkey].m_vTC = float4_t(0.25f, 0.25f, 0.25f, 0.5f);
+				else if (aq->m_chAxisX == -1 && aq->m_chAxisY == 1)
+					RTGPUArrVerteces[tmpkey].m_vTC = float4_t(0.25f, 0.25f, 0.5f, 0.5f);
+
+				else if (aq->m_chAxisX == -1 && aq->m_chAxisY == 2)
+					RTGPUArrVerteces[tmpkey].m_vTC = float4_t(0.25f, 0.25f, 0.25f, 0.75f);
+				else if (aq->m_chAxisX == 1 && aq->m_chAxisY == 2)
+					RTGPUArrVerteces[tmpkey].m_vTC = float4_t(0.25f, 0.25f, 0.5f, 0.75f);
+
+				else if (aq->m_chAxisX == 2 && aq->m_chAxisY == -1)
+					RTGPUArrVerteces[tmpkey].m_vTC = float4_t(0.25f, 0.25f, 0.75f, 0.75f);
+				else if (aq->m_chAxisX == 2 && aq->m_chAxisY == 1)
+					RTGPUArrVerteces[tmpkey].m_vTC = float4_t(0.25f, 0.25f, 0.75f, 0.5f);
+
+				else if (aq->m_chAxisX == 0 && aq->m_chAxisY == 2)
+					RTGPUArrVerteces[tmpkey].m_vTC = float4_t(0.25f, 0.25f, 0.75f, 0.25f);
+				else if (aq->m_chAxisX == 2 && aq->m_chAxisY == 0)
+					RTGPUArrVerteces[tmpkey].m_vTC = float4_t(0.25f, 0.25f, 0.75f, 0);
 
 				else
-					RTGPUArrVerteces[tmpkey].tex = float4_t(1, 1, 0, 0);
+					RTGPUArrVerteces[tmpkey].m_vTC = float4_t(1, 1, 0, 0);
 
-				RTGPUArrVerteces[tmpkey].color = D3DCOLOR_ARGB(200, 0, 0, 255);
+				RTGPUArrVerteces[tmpkey].m_uiColor = D3DCOLOR_ARGB(200, 0, 0, 255);
 				++tmpkey;
 			}
 		}
 
-		TransVertBuf->Unlock();
+		m_pTransVertBuf->Unlock();
 
-		DXDevice->SetStreamSourceFreq(0, (D3DSTREAMSOURCE_INDEXEDDATA | tmpkey));
+		m_pDXDevice->SetStreamSourceFreq(0, (D3DSTREAMSOURCE_INDEXEDDATA | tmpkey));
 
-		DXDevice->SetStreamSourceFreq(1, (D3DSTREAMSOURCE_INSTANCEDATA | 1));
-		DXDevice->SetStreamSource(1, TransVertBuf, 0, sizeof(AIQuadVertexDataInst));
+		m_pDXDevice->SetStreamSourceFreq(1, (D3DSTREAMSOURCE_INSTANCEDATA | 1));
+		m_pDXDevice->SetStreamSource(1, m_pTransVertBuf, 0, sizeof(CAIQuadVertexDataInst));
 
-		DXDevice->SetStreamSource(0, VertexQuad, 0, sizeof(AIQuadVertexData));
-		DXDevice->SetIndices(IndexQuad);
-		DXDevice->SetVertexDeclaration(AIQuadDecl);
+		m_pDXDevice->SetStreamSource(0, m_pVertexQuad, 0, sizeof(CAIQuadVertexData));
+		m_pDXDevice->SetIndices(m_pIndexQuad);
+		m_pDXDevice->SetVertexDeclaration(m_pDecl);
 
-		DXDevice->SetTexture(0, SGCore_LoadTexGetTex(Tex_AIGrid));
+		m_pDXDevice->SetTexture(0, SGCore_LoadTexGetTex(m_idTex));
 
-		SGCore_ShaderBind(SHADER_TYPE_VERTEX, IDVS);
-		SGCore_ShaderBind(SHADER_TYPE_PIXEL, IDPS);
+		SGCore_ShaderBind(SHADER_TYPE_VERTEX, m_idVS);
+		SGCore_ShaderBind(SHADER_TYPE_PIXEL, m_idPS);
 
 		D3DXMATRIX tmpview, tmpproj;
-		DXDevice->GetTransform(D3DTS_VIEW, &tmpview);
-		DXDevice->GetTransform(D3DTS_PROJECTION, &tmpproj);
+		m_pDXDevice->GetTransform(D3DTS_VIEW, &tmpview);
+		m_pDXDevice->GetTransform(D3DTS_PROJECTION, &tmpproj);
 
 		float4x4 wvp = SMMatrixIdentity() * float4x4(tmpview) * float4x4(tmpproj);
 		wvp = SMMatrixTranspose(wvp);
 
-		SGCore_ShaderSetVRF(SHADER_TYPE_VERTEX, IDVS, "WorldViewProjection", &wvp);
+		SGCore_ShaderSetVRF(SHADER_TYPE_VERTEX, m_idVS, "WorldViewProjection", &wvp);
 
-		DXDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, 4, 0, 2);
+		m_pDXDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, 4, 0, 2);
 
 		SGCore_ShaderUnBind();
 
-		DXDevice->SetStreamSourceFreq(0, 1);
-		DXDevice->SetStreamSourceFreq(1, 1);
+		m_pDXDevice->SetStreamSourceFreq(0, 1);
+		m_pDXDevice->SetStreamSourceFreq(1, 1);
 	}
 }
 
 //#############################################################################
 
-bool AIGrid::IsOpen(ID id)
+bool CAIGrid::IsOpen(ID id)
 {
-	for (int i = 0; i<ArrOpenIDs.size(); ++i)
+	for (int i = 0; i<m_aOpenIDs.size(); ++i)
 	{
-		if (ArrOpenIDs[i] == id)
+		if (m_aOpenIDs[i] == id)
 			return true;
 	}
 	return false;
 }
 
-int AIGrid::CalcHCost(ID id, ID endid)
+int CAIGrid::CalcHCost(ID id, ID endid)
 {
 	return (
 		(
 		abs(
-		(ArrLongCoordQuads[id].x) - (ArrLongCoordQuads[endid].x)
+		(m_aLongCoordQuads[id].x) - (m_aLongCoordQuads[endid].x)
 		) / LAIGRID_QUAD_SIZE
 		)
 
@@ -2461,30 +2763,25 @@ int AIGrid::CalcHCost(ID id, ID endid)
 		(
 		(
 		abs(
-		(ArrLongCoordQuads[id].z) - (ArrLongCoordQuads[endid].z)
+		(m_aLongCoordQuads[id].z) - (m_aLongCoordQuads[endid].z)
 		) / LAIGRID_QUAD_SIZE
 		)
 		*10
 		);
 }
 
-int AIGrid::CalcH2Cost(ID id1, ID id2)
+int CAIGrid::CalcH2Cost(ID id1, ID id2)
 {
-	/*long tmpx = abs((ArrIntCoord[id].x) - (ArrIntCoord[endid].x));
-	long tmpz = abs((ArrIntCoord[id].z) - (ArrIntCoord[endid].z));
-	long tmpxz = tmpx + tmpz;
-	long tmpxzm = float(abs(tmpx - tmpz)) * 0.4f;
-	return tmpxz - tmpxzm;*/
-	return SMVector2Length(float2(ArrQuads[id1]->pos.x, ArrQuads[id1]->pos.z) - float2(ArrQuads[id2]->pos.x, ArrQuads[id2]->pos.z)) * 100.f;
+	return SMVector2Length(float2(m_aQuads[id1]->m_vPos.x, m_aQuads[id1]->m_vPos.z) - float2(m_aQuads[id2]->m_vPos.x, m_aQuads[id2]->m_vPos.z)) * 100.f;
 }
 
-ID AIGrid::AddInOpenList(ID id)
+ID CAIGrid::AddInOpenList(ID id)
 {
-	for (int i = NumLastKeyOpenList; i<ArrOpenIDs.size(); i++)
+	for (int i = NumLastKeyOpenList; i<m_aOpenIDs.size(); i++)
 	{
-		if (ArrOpenIDs[i] == -1)
+		if (m_aOpenIDs[i] == -1)
 		{
-			ArrOpenIDs[i] = id;
+			m_aOpenIDs[i] = id;
 			NumLastKeyOpenList = i;	//говорим первый -1 ключ
 			if (CountInitOpen2 < i + 1)
 			{
@@ -2496,41 +2793,41 @@ ID AIGrid::AddInOpenList(ID id)
 	return -1;
 }
 
-bool AIGrid::QuadIsFree(ID id, int radius)
+bool CAIGrid::quadIsFree(ID id, int radius)
 {
 	AIGRID_QUAD_PRECOND(id, false);
 
-	if (ArrState[id] == AIQUAD_STATE::AIQUAD_STATE_FREE)
+	if (m_aQuadState[id] == AIQUAD_STATE::AIQUAD_STATE_FREE)
 	{
 		if (radius == 1)
 			return true;
 		else if (radius > 1)
 		{
-			memset(&(ArrPreCondFreeState[0]), 0, ArrPreCondFreeState.size() * sizeof(bool));
-			ArrPreCondFreeState[id] = true;
-			return IsFreeQuad2(id, radius - 1);
+			memset(&(m_aPreCondFreeState[0]), 0, m_aPreCondFreeState.size() * sizeof(bool));
+			m_aPreCondFreeState[id] = true;
+			return isFreeQuad2(id, radius - 1);
 		}
 	}
 	return false;
 }
 
-bool AIGrid::IsFreeQuad2(ID id, int radius)
+bool CAIGrid::isFreeQuad2(ID id, int radius)
 {
 	AIGRID_QUAD_PRECOND(id, false);
 	bool tmpisfree = true;
 	
-	AIQuad* aq = ArrQuads[id];
+	CAIquad* aq = m_aQuads[id];
 	
 	if (radius > 0)
 	{
 		for (int i = 0; i<8; ++i)
 		{
-			if (aq->Arr[i] >= 0 && ArrState[aq->Arr[i]] == AIQUAD_STATE::AIQUAD_STATE_FREE)
+			if (aq->m_aNeighbors[i] >= 0 && m_aQuadState[aq->m_aNeighbors[i]] == AIQUAD_STATE::AIQUAD_STATE_FREE)
 			{
-				if (!ArrPreCondFreeState[aq->Arr[i]])
+				if (!m_aPreCondFreeState[aq->m_aNeighbors[i]])
 				{
-					ArrPreCondFreeState[aq->Arr[i]] = true;
-					if (!IsFreeQuad2(aq->Arr[i], radius - 1))
+					m_aPreCondFreeState[aq->m_aNeighbors[i]] = true;
+					if (!isFreeQuad2(aq->m_aNeighbors[i], radius - 1))
 					{
 						tmpisfree = false;
 						break;
@@ -2547,8 +2844,11 @@ bool AIGrid::IsFreeQuad2(ID id, int radius)
 	return tmpisfree;
 }
 
-ID AIGrid::QuadGetNear(const float3* pos, bool isfree, int raius)
+ID CAIGrid::quadGetNear(const float3 *pPos, float fRadius, bool isFree, int iQuadRadius)
 {
+	if (!m_pTreeBound)
+		return -1;
+
 	ID howf = -1;
 
 	ID tmpsmall = -1;
@@ -2557,87 +2857,129 @@ ID AIGrid::QuadGetNear(const float3* pos, bool isfree, int raius)
 	float tmpsmallqdist = 0;
 	float tmpsmallqdist2 = 0;
 
-	ID tmparrbb[8];
+	CBoundAIquad *tmparrbb[8];
 	float tmparrdist2[8];
 
 	for (int i = 0; i<8; ++i)
 	{
-		tmparrbb[i] = -1;
+		tmparrbb[i] = 0;
 		tmparrdist2[i] = -1;
 	}
 
 	bool isexistsfree = false;
-	BoundAIQuad* bound = 0;
-	for (int i = 1, il = ArrBound.size(); i<il; ++i)
+	CBoundAIquad* bound = 0;
+
+
+	Array<CTreeBoundAIquad*, 64> queue;
+	int iCurrKey = 0;
+	queue.push_back(m_pTreeBound);
+	
+	Array<CTreeBoundAIquad*> aBounds;
+	float3 vSphereCenter;
+	float fSphereRadius;
+
+	//LibReport(REPORT_MSG_LEVEL_NOTICE, "quadGetNear 0\n");
+
+	while (queue.size() > iCurrKey)
 	{
-		if (ArrBound[i]->ArrIdsQuads.size() > 0)
-		{
-			bound = ArrBound[i];
+		CTreeBoundAIquad *pSplit = queue[iCurrKey];
 
-			isexistsfree = false;
-			if (!isfree)
-				isexistsfree = true;
-			else
+		for (int i = 0; i<4; i++)
+		{
+			pSplit->m_aSplits[i]->m_pBoundBox->getSphere(&vSphereCenter, &fSphereRadius);
+			vSphereCenter.y = 0;
+			if (
+				SMVector3Length(float3(pPos->x, 0, pPos->z) - vSphereCenter) <= (fRadius + fSphereRadius)
+				)
 			{
-				for (int k = 0, kl = bound->ArrIdsQuads.size(); k<kl; ++k)
+				if (pSplit->m_aSplits[i] && pSplit->m_aSplits[i]->m_aSplits[0])
+					queue.push_back(pSplit->m_aSplits[i]);
+				else
 				{
-					if (QuadIsFree(bound->ArrIdsQuads[k], raius))
-					{
-						isexistsfree = true;
-						break;
-					}
+					aBounds.push_back(pSplit->m_aSplits[i]);
 				}
 			}
+		}
 
-			if (isexistsfree)
+		//queue.erase(0);
+		++iCurrKey;
+		//LibReport(REPORT_MSG_LEVEL_NOTICE, "iCurrKey %d\n", iCurrKey);
+	}
+
+	for (int i = 0, il = aBounds.size(); i<il; ++i)
+	{
+		for (int k = 0, kl = aBounds[i]->m_pBounds.size(); k<kl; ++k)
+		{
+			bound = aBounds[i]->m_pBounds[k];
+			if (bound->m_aIdsQuads.size() > 0 /*&& SMVector3Length2((*pPos) - ((bound->m_f3Max + bound->m_f3Min) * 0.5f)) <= fRadius*fRadius*/)
 			{
-				tmpsmalldist2 = SMVector3Length2(((bound->max + bound->min) * 0.5f) - (*pos));
-				tmpsmall = -1;
-				for (int k = 0; k<8; ++k)
+				isexistsfree = false;
+				if (!isFree)
+					isexistsfree = true;
+				else
 				{
-					if (tmparrbb[k] == -1)
+					for (int j = 0, jl = bound->m_aIdsQuads.size(); j < jl; ++j)
 					{
-						tmparrbb[k] = i;
-						tmparrdist2[k] = tmpsmalldist2;
-						break;
+						if (quadIsFree(bound->m_aIdsQuads[j], iQuadRadius))
+						{
+							isexistsfree = true;
+							break;
+						}
 					}
+				}
 
-					if (tmpsmall == -1 || (tmpsmalldist2 < tmparrdist2[k] && tmpsmalldist > tmparrdist2[k] - tmpsmalldist2))
+				if (isexistsfree)
+				{
+					tmpsmalldist2 = SMVector3Length2(((bound->m_f3Max + bound->m_f3Min) * 0.5f) - (*pPos));
+					tmpsmall = -1;
+					for (int j = 0; j < 8; ++j)
 					{
-						tmpsmalldist = tmparrdist2[k] - tmpsmalldist2;
-						tmpsmall = k;
+						if (tmparrbb[j] == 0)
+						{
+							tmparrbb[j] = bound;
+							tmparrdist2[j] = tmpsmalldist2;
+							break;
+						}
+
+						if (tmpsmall == -1 || (tmpsmalldist2 < tmparrdist2[j] && tmpsmalldist > tmparrdist2[j] - tmpsmalldist2))
+						{
+							tmpsmalldist = tmparrdist2[j] - tmpsmalldist2;
+							tmpsmall = j;
+						}
 					}
-				}
 
-				if (tmpsmall != -1)
-				{
-					tmparrbb[tmpsmall] = i;
-					tmparrdist2[tmpsmall] = tmpsmalldist2;
+					if (tmpsmall != -1)
+					{
+						tmparrbb[tmpsmall] = bound;
+						tmparrdist2[tmpsmall] = tmpsmalldist2;
+					}
 				}
 			}
 		}
 	}
 
+	//LibReport(REPORT_MSG_LEVEL_NOTICE, "quadGetNear 2\n");
+
 	for (int i = 0; i<8; ++i)
 	{
-		if (tmparrbb[i] != -1)
+		if (tmparrbb[i] != 0)
 		{
-			bound = ArrBound[tmparrbb[i]];
-			for (int k = 0, kl = bound->ArrIdsQuads.size(); k<kl; ++k)
+			bound = tmparrbb[i];
+			for (int k = 0, kl = bound->m_aIdsQuads.size(); k<kl; ++k)
 			{
 				isexistsfree = true;
-				tmpsmallqdist2 = SMVector3Length2(ArrQuads[bound->ArrIdsQuads[k]]->pos - (*pos));
-				if ((howf == -1 || tmpsmallqdist2 < tmpsmallqdist) && (ArrState[bound->ArrIdsQuads[k]] == 0 || !isfree))
+				tmpsmallqdist2 = SMVector3Length2(m_aQuads[bound->m_aIdsQuads[k]]->m_vPos - (*pPos));
+				if ((howf == -1 || tmpsmallqdist2 < tmpsmallqdist) && (m_aQuadState[bound->m_aIdsQuads[k]] == 0 || !isFree))
 				{
-					if (!isfree)
+					if (!isFree)
 					{
 						tmpsmallqdist = tmpsmallqdist2;
-						howf = bound->ArrIdsQuads[k];
+						howf = bound->m_aIdsQuads[k];
 					}
-					else if (QuadIsFree(bound->ArrIdsQuads[k], raius))
+					else if (quadIsFree(bound->m_aIdsQuads[k], iQuadRadius))
 					{
 						tmpsmallqdist = tmpsmallqdist2;
-						howf = bound->ArrIdsQuads[k];
+						howf = bound->m_aIdsQuads[k];
 					}
 				}
 			}
@@ -2647,9 +2989,9 @@ ID AIGrid::QuadGetNear(const float3* pos, bool isfree, int raius)
 	return howf;
 }
 
-ID AIGrid::GraphPointGetNear(ID beginq, ID endq)
+ID CAIGrid::graphPointGetNear(ID beginq, ID endq)
 {
-	if (ArrQuads.size() <= 1)
+	if (m_aQuads.size() <= 1)
 	{
 		LibReport(REPORT_MSG_LEVEL_WARNING, "AI grid not found\n");
 		return -1;
@@ -2658,13 +3000,13 @@ ID AIGrid::GraphPointGetNear(ID beginq, ID endq)
 	AIGRID_QUAD_PRECOND(beginq, false);
 	AIGRID_QUAD_PRECOND(endq, false);
 
-	if (CountSplits == 0)
+	if (m_uiCountSplits == 0)
 	{
 		LibReport(REPORT_MSG_LEVEL_WARNING, "can not find path, because AI grid is not validate splits\n");
 		return -1;
 	}
 
-	if (ArrQuads[beginq]->IdSplit != ArrQuads[endq]->IdSplit)
+	if (m_aQuads[beginq]->m_iSplit != m_aQuads[endq]->m_iSplit)
 	{
 		LibReport(REPORT_MSG_LEVEL_WARNING, "quads in different splits, path not found\n");
 		return -1;
@@ -2676,7 +3018,7 @@ ID AIGrid::GraphPointGetNear(ID beginq, ID endq)
 		return -1;
 	}
 
-	if (ArrGraphPointsIDs.size() == 0)
+	if (m_aGraphPointsIDs.size() == 0)
 	{
 		LibReport(REPORT_MSG_LEVEL_WARNING, "graph points not found\n");
 		return -1;
@@ -2684,10 +3026,10 @@ ID AIGrid::GraphPointGetNear(ID beginq, ID endq)
 	
 	if (CalcH2Cost(beginq, endq) > AIGRID_COST_GPATH)
 	{
-		if (ArrCostGPIDs.size() != ArrGraphPointsIDs.size())
-			ArrCostGPIDs.resize(ArrGraphPointsIDs.size());
+		if (m_aCostGraphPointsIDs.size() != m_aGraphPointsIDs.size())
+			m_aCostGraphPointsIDs.resize(m_aGraphPointsIDs.size());
 
-		memset(&(ArrCostGPIDs[0]), -1, ArrCostGPIDs.size() * sizeof(int32_t));
+		memset(&(m_aCostGraphPointsIDs[0]), -1, m_aCostGraphPointsIDs.size() * sizeof(int32_t));
 
 		long tmpcountstepbegin = 0;	//на сколько мы продвинулись от начальной точки до текущей точки графа
 		long tmpcountdel = 0;		//на сколько короче стал путь
@@ -2698,18 +3040,18 @@ ID AIGrid::GraphPointGetNear(ID beginq, ID endq)
 
 		while (tmpbigeff == -1)
 		{
-			for (int i = 0, il = ArrGraphPointsIDs.size(); i<il; ++i)
+			for (int i = 0, il = m_aGraphPointsIDs.size(); i<il; ++i)
 			{
-				if (ArrGraphPointsIDs[i] != beginq && ArrGraphPointsIDs[i] != endq)
+				if (m_aGraphPointsIDs[i] != beginq && m_aGraphPointsIDs[i] != endq)
 				{
 					tmpcostbe = CalcH2Cost(beginq, endq);
-					tmpcostagpe = CalcH2Cost(ArrGraphPointsIDs[i], endq);
+					tmpcostagpe = CalcH2Cost(m_aGraphPointsIDs[i], endq);
 					tmpcountdel = tmpcostbe - tmpcostagpe;
 					if (tmpcountdel > 0 && tmpcountdel < tmpdist)
 					{
-						tmpcountstepbegin = CalcH2Cost(beginq, ArrGraphPointsIDs[i]);
-						ArrCostGPIDs[i] = (tmpcountstepbegin - tmpcountdel);
-						if (tmpbigeff == -1 || (ArrCostGPIDs[tmpbigeff] > ArrCostGPIDs[i]))
+						tmpcountstepbegin = CalcH2Cost(beginq, m_aGraphPointsIDs[i]);
+						m_aCostGraphPointsIDs[i] = (tmpcountstepbegin - tmpcountdel);
+						if (tmpbigeff == -1 || (m_aCostGraphPointsIDs[tmpbigeff] > m_aCostGraphPointsIDs[i]))
 							tmpbigeff = i;
 					}
 				}
@@ -2717,17 +3059,17 @@ ID AIGrid::GraphPointGetNear(ID beginq, ID endq)
 			tmpdist *= 2;
 		}
 
-		if (tmpbigeff != -1 && CalcH2Cost(beginq, ArrGraphPointsIDs[tmpbigeff]) < CalcH2Cost(beginq, endq))
+		if (tmpbigeff != -1 && CalcH2Cost(beginq, m_aGraphPointsIDs[tmpbigeff]) < CalcH2Cost(beginq, endq))
 		{
-			//ArrColor[ArrGraphPointsIDs[tmpbigeff]] = 255;
-			return ArrGraphPointsIDs[tmpbigeff];
+			//m_aQuadColors[m_aGraphPointsIDs[tmpbigeff]] = 255;
+			return m_aGraphPointsIDs[tmpbigeff];
 		}
 		return -1;
 	}
 	return -1;
 }
 
-bool AIGrid::gridFindPath(ID idQueueObject)
+bool CAIGrid::gridFindPath(ID idQueueObject)
 {
 	if (!existsQuads())
 		return false;
@@ -2745,12 +3087,12 @@ bool AIGrid::gridFindPath(ID idQueueObject)
 
 	CountInitOpen2 = 0;
 	NumLastKeyOpenList = 0;
-	//memset(&(ArrColor[0]), 0, ArrColor.size() * sizeof(uint32_t));
-	memset(&(ArrIDsInOpen[0]), -1, ArrIDsInOpen.size() * sizeof(ID));
-	memset(&(ArrOpenIDs[0]), -1, ArrOpenIDs.size() * sizeof(ID));
-	memset(&(ArrParentIDs[0]), -1, ArrParentIDs.size() * sizeof(ID));
-	memset(&(ArrCostQuads[0]), 0, ArrCostQuads.size() * sizeof(CostAIQuad));
-	memset(&(ArrCloseIDs[0]), 0, ArrCloseIDs.size() * sizeof(bool));
+	//memset(&(m_aQuadColors[0]), 0, m_aQuadColors.size() * sizeof(uint32_t));
+	memset(&(m_aIDsInOpen[0]), -1, m_aIDsInOpen.size() * sizeof(ID));
+	memset(&(m_aOpenIDs[0]), -1, m_aOpenIDs.size() * sizeof(ID));
+	memset(&(m_aParentIDs[0]), -1, m_aParentIDs.size() * sizeof(ID));
+	memset(&(m_aCostQuads[0]), 0, m_aCostQuads.size() * sizeof(CCostTransit));
+	memset(&(m_aTestSplitsIDs[0]), 0, m_aTestSplitsIDs.size() * sizeof(bool));
 	//ArrPathIDs.clear();
 
 	bool IsFindPath = false;
@@ -2761,12 +3103,12 @@ bool AIGrid::gridFindPath(ID idQueueObject)
 	for (cycnum = 0; cycnum<8; cycnum++)
 	{
 		if (
-			ArrQuads[idStart]->Arr[cycnum] != -1)
+			m_aQuads[idStart]->m_aNeighbors[cycnum] != -1)
 		{
-			if (ArrQuads[idStart]->Arr[cycnum] == idFinish)
+			if (m_aQuads[idStart]->m_aNeighbors[cycnum] == idFinish)
 			{
 				aQuads.push_back(idFinish);
-				aQuads.push_back(ArrQuads[idStart]->Arr[cycnum]);
+				aQuads.push_back(m_aQuads[idStart]->m_aNeighbors[cycnum]);
 				return true;
 			}
 			tmpcost = AIGRID_COST_DIAGONAL;
@@ -2774,28 +3116,28 @@ bool AIGrid::gridFindPath(ID idQueueObject)
 			if (cycnum == 1 || cycnum == 3 || cycnum == 4 || cycnum == 6)
 				tmpcost = AIGRID_COST_DIRECT;
 
-			if (QuadGetState(ArrQuads[idStart]->Arr[cycnum]) != AIQUAD_STATE::AIQUAD_STATE_FREE)
+			if (quadGetState(m_aQuads[idStart]->m_aNeighbors[cycnum]) != AIQUAD_STATE::AIQUAD_STATE_FREE)
 			{
-				if (QuadGetState(ArrQuads[idStart]->Arr[cycnum]) == AIQUAD_STATE::AIQUAD_STATE_TEMPBUSY)
+				if (quadGetState(m_aQuads[idStart]->m_aNeighbors[cycnum]) == AIQUAD_STATE::AIQUAD_STATE_TEMPBUSY)
 					tmpcost += AIGRID_COSTADD_TEMPBUSY;
-				else if (QuadGetState(ArrQuads[idStart]->Arr[cycnum]) == AIQUAD_STATE::AIQUAD_STATE_BUSY)
+				else if (quadGetState(m_aQuads[idStart]->m_aNeighbors[cycnum]) == AIQUAD_STATE::AIQUAD_STATE_BUSY)
 					tmpcost += AIGRID_COSTADD_BUSY;
 			}
 			else
 				tmpaddcost = 0;
 
-			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);
+			m_aParentIDs[m_aQuads[idStart]->m_aNeighbors[cycnum]] = idStart;
+			m_aCostQuads[m_aQuads[idStart]->m_aNeighbors[cycnum]].G = tmpcost;
+			m_aCostQuads[m_aQuads[idStart]->m_aNeighbors[cycnum]].H = CalcHCost(m_aQuads[idStart]->m_aNeighbors[cycnum], idFinish);
 
-			ArrCostQuads[ArrQuads[idStart]->Arr[cycnum]].F = ArrCostQuads[ArrQuads[idStart]->Arr[cycnum]].G + ArrCostQuads[ArrQuads[idStart]->Arr[cycnum]].H + tmpaddcost;
+			m_aCostQuads[m_aQuads[idStart]->m_aNeighbors[cycnum]].F = m_aCostQuads[m_aQuads[idStart]->m_aNeighbors[cycnum]].G + m_aCostQuads[m_aQuads[idStart]->m_aNeighbors[cycnum]].H + tmpaddcost;
 
-			ArrIDsInOpen[ArrQuads[idStart]->Arr[cycnum]] = AddInOpenList(ArrQuads[idStart]->Arr[cycnum]);
+			m_aIDsInOpen[m_aQuads[idStart]->m_aNeighbors[cycnum]] = AddInOpenList(m_aQuads[idStart]->m_aNeighbors[cycnum]);
 		}
 	}
 
 	//стартовую точку помещаем в закрытый
-	ArrCloseIDs[idStart] = true;
+	m_aTestSplitsIDs[idStart] = true;
 
 	bool isfind = false;
 	ID tmpsmallF = -1;
@@ -2805,7 +3147,7 @@ bool AIGrid::gridFindPath(ID idQueueObject)
 	ID tmpcurrsmall = -1;
 	ID tmpcurridquad = -1;
 
-	AIQuad* tmpquad = 0;
+	CAIquad* tmpquad = 0;
 
 	while (!IsFindPath)
 	{
@@ -2817,11 +3159,11 @@ bool AIGrid::gridFindPath(ID idQueueObject)
 		tmpcurrsmall = -1;
 		for (cycnum = 0; cycnum<CountInitOpen2; ++cycnum)
 		{
-			if (ArrOpenIDs[cycnum] != -1)
+			if (m_aOpenIDs[cycnum] != -1)
 			{
 				if (tmpcurrsmall != -1)
 				{
-					if (ArrCostQuads[ArrOpenIDs[tmpcurrsmall]].F > ArrCostQuads[ArrOpenIDs[cycnum]].F)
+					if (m_aCostQuads[m_aOpenIDs[tmpcurrsmall]].F > m_aCostQuads[m_aOpenIDs[cycnum]].F)
 						tmpcurrsmall = cycnum;
 				}
 				else
@@ -2830,20 +3172,20 @@ bool AIGrid::gridFindPath(ID idQueueObject)
 		}
 
 		if (tmpcurrsmall != -1)
-			tmpsmallF = ArrOpenIDs[tmpcurrsmall];
+			tmpsmallF = m_aOpenIDs[tmpcurrsmall];
 
 		//анализируем соседей квада на наличие их в открытом списке
 		if (tmpsmallF != -1)
 		{
-			tmpquad = ArrQuads[tmpsmallF];
+			tmpquad = m_aQuads[tmpsmallF];
 			
 			for (cycnum = 0; cycnum<8; ++cycnum)
 			{
-				tmpcurridquad = tmpquad->Arr[cycnum];
+				tmpcurridquad = tmpquad->m_aNeighbors[cycnum];
 				//если квад существует
 				if (tmpcurridquad != -1)
 				{
-					if (!ArrCloseIDs[tmpcurridquad])
+					if (!m_aTestSplitsIDs[tmpcurridquad])
 					{
 						//если сосденяя точка конечная точка то мы нашли путь!!!
 						if (tmpcurridquad == idFinish)
@@ -2858,47 +3200,47 @@ bool AIGrid::gridFindPath(ID idQueueObject)
 
 						tmphcost = CalcHCost(tmpcurridquad, idFinish);
 
-						if (QuadGetState(tmpcurridquad) != AIQUAD_STATE::AIQUAD_STATE_FREE && tmphcost / 10 < AIGRID_QUADSCOUNT_BUSY)
+						if (quadGetState(tmpcurridquad) != AIQUAD_STATE::AIQUAD_STATE_FREE && tmphcost / 10 < AIGRID_QUADSCOUNT_BUSY)
 						{
-							if (QuadGetState(tmpcurridquad) == AIQUAD_STATE::AIQUAD_STATE_TEMPBUSY)
+							if (quadGetState(tmpcurridquad) == AIQUAD_STATE::AIQUAD_STATE_TEMPBUSY)
 								tmpcost += AIGRID_COSTADD_TEMPBUSY;
-							else if (QuadGetState(tmpcurridquad) == AIQUAD_STATE::AIQUAD_STATE_BUSY)
+							else if (quadGetState(tmpcurridquad) == AIQUAD_STATE::AIQUAD_STATE_BUSY)
 								tmpcost += AIGRID_COSTADD_BUSY;
 						}
 						else
 							tmpaddcost = 0;
 
 						//если есть родитель
-						if (ArrParentIDs[tmpcurridquad] != -1)
+						if (m_aParentIDs[tmpcurridquad] != -1)
 						{
 							//считаем а не дешевле ли перейти на соседний квад через этот квад
-							if (ArrCostQuads[tmpcurridquad].G > ArrCostQuads[tmpsmallF].G + tmpcost)
+							if (m_aCostQuads[tmpcurridquad].G > m_aCostQuads[tmpsmallF].G + tmpcost)
 							{
-								ArrParentIDs[tmpcurridquad] = tmpsmallF;
-								ArrCostQuads[tmpcurridquad].G = ArrCostQuads[tmpsmallF].G + tmpcost;
-								ArrCostQuads[tmpcurridquad].F = ArrCostQuads[tmpcurridquad].G + ArrCostQuads[tmpcurridquad].H;
+								m_aParentIDs[tmpcurridquad] = tmpsmallF;
+								m_aCostQuads[tmpcurridquad].G = m_aCostQuads[tmpsmallF].G + tmpcost;
+								m_aCostQuads[tmpcurridquad].F = m_aCostQuads[tmpcurridquad].G + m_aCostQuads[tmpcurridquad].H;
 							}
 						}
 						//если нет родителя то назначаем текущий квад родителем и считаем стоимости
 						//и если не в закрытом списке
 						else
 						{
-							ArrParentIDs[tmpcurridquad] = tmpsmallF;
-							ArrCostQuads[tmpcurridquad].G = ArrCostQuads[tmpsmallF].G + tmpcost;
-							ArrCostQuads[tmpcurridquad].H = tmphcost;// CalcHCost(tmpcurridquad, idFinish);
-							ArrCostQuads[tmpcurridquad].F = ArrCostQuads[tmpcurridquad].G + ArrCostQuads[tmpcurridquad].H;
-							ArrIDsInOpen[tmpcurridquad] = AddInOpenList(tmpcurridquad);
+							m_aParentIDs[tmpcurridquad] = tmpsmallF;
+							m_aCostQuads[tmpcurridquad].G = m_aCostQuads[tmpsmallF].G + tmpcost;
+							m_aCostQuads[tmpcurridquad].H = tmphcost;// CalcHCost(tmpcurridquad, idFinish);
+							m_aCostQuads[tmpcurridquad].F = m_aCostQuads[tmpcurridquad].G + m_aCostQuads[tmpcurridquad].H;
+							m_aIDsInOpen[tmpcurridquad] = AddInOpenList(tmpcurridquad);
 						}
 					}
 				}
 			}
 
-			ArrOpenIDs[ArrIDsInOpen[tmpsmallF]] = -1;
-			if (NumLastKeyOpenList > ArrIDsInOpen[tmpsmallF])
-				NumLastKeyOpenList = ArrIDsInOpen[tmpsmallF];
-			ArrIDsInOpen[tmpsmallF] = -1;
+			m_aOpenIDs[m_aIDsInOpen[tmpsmallF]] = -1;
+			if (NumLastKeyOpenList > m_aIDsInOpen[tmpsmallF])
+				NumLastKeyOpenList = m_aIDsInOpen[tmpsmallF];
+			m_aIDsInOpen[tmpsmallF] = -1;
 
-			ArrCloseIDs[tmpsmallF] = true;
+			m_aTestSplitsIDs[tmpsmallF] = true;
 
 			if (isfind)
 			{
@@ -2907,13 +3249,13 @@ bool AIGrid::gridFindPath(ID idQueueObject)
 				aQuads.push_back(tmpsmallF);
 				ID tmpquad = tmpsmallF;
 				ID tmpparent = -1;
-				/*ArrColor[tmpsmallF] = D3DCOLOR_ARGB(200,0,255,0);
-				ArrColor[idStart] = D3DCOLOR_ARGB(255, 0, 255, 0);
-				ArrColor[idFinish] = D3DCOLOR_ARGB(255, 0, 255, 0);*/
-				while ((tmpparent = ArrParentIDs[tmpquad]) != -1 && idStart != tmpparent)
+				/*m_aQuadColors[tmpsmallF] = D3DCOLOR_ARGB(200,0,255,0);
+				m_aQuadColors[idStart] = D3DCOLOR_ARGB(255, 0, 255, 0);
+				m_aQuadColors[idFinish] = D3DCOLOR_ARGB(255, 0, 255, 0);*/
+				while ((tmpparent = m_aParentIDs[tmpquad]) != -1 && idStart != tmpparent)
 				{
 					aQuads.push_back(tmpparent);
-					//ArrColor[tmpparent] = D3DCOLOR_ARGB(128, 0, 255, 0);
+					//m_aQuadColors[tmpparent] = D3DCOLOR_ARGB(128, 0, 255, 0);
 					tmpquad = tmpparent;
 				}
 
@@ -2929,7 +3271,7 @@ bool AIGrid::gridFindPath(ID idQueueObject)
 	return IsFindPath;
 }
 
-int AIGrid::gridGetSizePath(ID idQueueObject)
+int CAIGrid::gridGetSizePath(ID idQueueObject) const
 {
 	if (!existsQuads())
 		return -1;
@@ -2940,7 +3282,7 @@ int AIGrid::gridGetSizePath(ID idQueueObject)
 	return -1;
 }
 
-bool AIGrid::gridGetPath(ID idQueueObject, ID *pMemory, UINT uiCount, bool canReverse)
+bool CAIGrid::gridGetPath(ID idQueueObject, ID *pMemory, UINT uiCount, bool canReverse)
 {
 	if (!existsQuads())
 		return false;
@@ -2968,27 +3310,27 @@ bool AIGrid::gridGetPath(ID idQueueObject, ID *pMemory, UINT uiCount, bool canRe
 	return false;
 }
 
-void AIGrid::GridSetColorArr(const ID * pmem, DWORD color, UINT count)
+void CAIGrid::gridSetColorArr(const ID * pmem, DWORD color, UINT count)
 {
-	if (ArrColor.size() > 0 || !pmem)
+	if (m_aQuadColors.size() == 0 || !pmem)
 		return;
 
 	for (int i = 0; i < count; ++i)
 	{
-		if (pmem[i] >= 0 && pmem[i] < ArrColor.size())
-			ArrColor[pmem[i]] = color;
+		if (pmem[i] >= 0 && pmem[i] < m_aQuadColors.size())
+			m_aQuadColors[pmem[i]] = color;
 	}
 }
 
-void AIGrid::GridSetNullColor()
+void CAIGrid::gridSetNullColor()
 {
-	if (ArrColor.size() > 0)
-		memset(&(ArrColor[0]), 0, sizeof(uint32_t)* ArrColor.size());
+	if (m_aQuadColors.size() > 0)
+		memset(&(m_aQuadColors[0]), 0, sizeof(uint32_t)* m_aQuadColors.size());
 }
 
 //##########################################################################
 
-ID AIGrid::getQueueWaiting()
+ID CAIGrid::getQueueWaiting()
 {
 	for (int i = m_iLastWait, il = m_aQueueFind.size(); i < il; ++i)
 	{
@@ -3016,7 +3358,7 @@ ID AIGrid::getQueueWaiting()
 	return -1;
 }
 
-ID AIGrid::getQueueIdle()
+ID CAIGrid::getQueueIdle()
 {
 	for (int i = m_iLastWait, il = m_aQueueFind.size(); i < il; ++i)
 	{
@@ -3035,36 +3377,36 @@ ID AIGrid::getQueueIdle()
 	return m_aQueueFind.size() - 1;
 }
 
-ID AIGrid::gridQueryFindPath(ID idStart, ID idFinish)
+ID CAIGrid::gridQueryFindPath(ID idStart, ID idFinish)
 {
 	if (!existsQuads())
 		return -1;
 
-	if (ArrQuads.size() <= 1)
+	if (m_aQuads.size() <= 1)
 	{
 		LibReport(REPORT_MSG_LEVEL_WARNING, "AI grid not found\n");
 		return -1;
 	}
 
-	if (idStart < 0 || ArrQuads.size() <= idStart)
+	if (idStart < 0 || m_aQuads.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)
+	if (idFinish < 0 || m_aQuads.size() <= idFinish)
 	{
 		LibReport(REPORT_MSG_LEVEL_WARNING, " %s - unresolved index '%d' of quad, sxaigrid\n", GEN_MSG_LOCATION, idFinish);
 		return -1;
 	}
 
-	if (CountSplits == 0)
+	if (m_uiCountSplits == 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)
+	if (m_aQuads[idStart]->m_iSplit != m_aQuads[idFinish]->m_iSplit)
 	{
 		LibReport(REPORT_MSG_LEVEL_WARNING, "quads in different splits, path not found\n");
 		return -1;
@@ -3086,7 +3428,7 @@ ID AIGrid::gridQueryFindPath(ID idStart, ID idFinish)
 	return idQueueObject;
 }
 
-bool AIGrid::gridCancelQueryFindPath(ID idQuery)
+bool CAIGrid::gridCancelQueryFindPath(ID idQuery)
 {
 	if (!existsQuads())
 		return false;
@@ -3101,7 +3443,7 @@ bool AIGrid::gridCancelQueryFindPath(ID idQuery)
 	return false;
 }
 
-void AIGrid::gridQueryFindPathUpdate(UINT uiLimitMls)
+void CAIGrid::gridQueryFindPathUpdate(UINT uiLimitMls)
 {
 	if (!existsQuads())
 		return;
diff --git a/source/aigrid/aigrid.h b/source/aigrid/aigrid.h
index b93b17aa026477a675ae4efc13a5002ebfedec8b..3d0edfb328d01580c587b39d0910cdbd27949ecf 100644
--- a/source/aigrid/aigrid.h
+++ b/source/aigrid/aigrid.h
@@ -14,100 +14,155 @@ See the license in LICENSE
 #define SM_D3D_CONVERSIONS
 #include <common/SXMath.h>
 #include "sxaigrid.h"
+#include <math.h>
 
 extern g_aiquad_phy_navigate AIQuadPhyNavigate;
 
-#define AIGRID_QUAD_PRECOND(id,retval)  if (id < 0 || ArrQuads.size() <= id) {LibReport(REPORT_MSG_LEVEL_ERROR, " %s - unresolved index '%d' of quad, sxaigrid", GEN_MSG_LOCATION, id); return retval;}
+#define AIGRID_QUAD_PRECOND(id,retval)  if (id < 0 || m_aQuads.size() <= id) {LibReport(REPORT_MSG_LEVEL_ERROR, " %s - unresolved index '%d' of quad, sxaigrid", GEN_MSG_LOCATION, id); return retval;}
 
-#define toint100(fnum) (int32_t)((fnum + 0.0001f) * 100)
-
-//long значения позиций, float3 * 100
+//! int значения позиций полученные путем AIGRID_TOINT
 struct int3
 {
-	int3(){ this->x = this->y = this->z = 0; }
-	int3(long _x, long _y, long _z){ this->x = _x; this->y = _y; this->z = _z; }
-	int32_t x,y,z;
+	int3()
+	{ 
+		x = y = z = 0; 
+	}
+
+	int3(int32_t iX, int32_t iY, int32_t iZ)
+	{ 
+		x = iX; y = iY; z = iZ; 
+	}
+
+	int32_t x, y, z;
 };
 
-//структура описывающая квадрат на аи сетке
-struct AIQuad
+//! структура описывающая квадрат на аи сетке
+struct CAIquad
 {
-	AIQuad()
+	CAIquad()
 	{
-		axisx = axisy = 0;
-		IsClose = false;
-		Id = -1;
-			for(int i=0;i<8;++i)
-				Arr[i] = -1;
+		m_chAxisX = m_chAxisY = 0;
+		m_isClose = false;
+		m_id = -1;
 
-		IdSplit = 0;
-	}
+		for(int i=0;i<8;++i)
+			m_aNeighbors[i] = -1;
 
-	//направления по осям
-	//если равно 0 то в обоих направлениях, иначе еси 1 то положительное направление, иначе -1 то отрицательное, 2 - хода нет
-	char axisx;
-	char axisy;
+		m_iSplit = 0;
+	}
 
 	//установка соседа для квада
-	void SetNeighbor(int key,ID id)
+	void setNeighbor(int iKey,ID idQuad)
 	{
-		Arr[key] = id;
-
-			if(key == 1)
-			{
-					if(axisy == -1)
-						axisy = 0;
-					else if(axisy == 2)
-						axisy = 1;
-			}
-
-			if(key == 6)
-			{
-					if(axisy == 1)
-						axisy = 0;
-					else if(axisy == 2)
-						axisy = -1;
-			}
-
-			if(key == 3)
-			{
-					if(axisx == 1)
-						axisx = 0;
-					else if(axisx == 2)
-						axisx = -1;
-			}
-
-			if(key == 4)
-			{
-					if(axisx == -1)
-						axisx = 0;
-					else if(axisx == 2)
-						axisx = 1;
-			}
+		m_aNeighbors[iKey] = idQuad;
+
+		if (iKey == 1)
+		{
+			if (m_chAxisY == AIGRID_QUAD_DIR_NEGATIVE)
+				m_chAxisY = AIGRID_QUAD_DIR_ALL;
+			else if (m_chAxisY == AIGRID_QUAD_DIR_NONE)
+				m_chAxisY = AIGRID_QUAD_DIR_POSITIVE;
+		}
+
+		if (iKey == 6)
+		{
+			if (m_chAxisY == AIGRID_QUAD_DIR_POSITIVE)
+				m_chAxisY = AIGRID_QUAD_DIR_ALL;
+			else if (m_chAxisY == AIGRID_QUAD_DIR_NONE)
+				m_chAxisY = AIGRID_QUAD_DIR_NEGATIVE;
+		}
+
+		if (iKey == 3)
+		{
+			if (m_chAxisX == AIGRID_QUAD_DIR_POSITIVE)
+				m_chAxisX = AIGRID_QUAD_DIR_ALL;
+			else if (m_chAxisX == AIGRID_QUAD_DIR_NONE)
+				m_chAxisX = AIGRID_QUAD_DIR_NEGATIVE;
+		}
+
+		if (iKey == 4)
+		{
+			if (m_chAxisX == AIGRID_QUAD_DIR_NEGATIVE)
+				m_chAxisX = AIGRID_QUAD_DIR_ALL;
+			else if (m_chAxisX == AIGRID_QUAD_DIR_NONE)
+				m_chAxisX = AIGRID_QUAD_DIR_POSITIVE;
+		}
 	}
 
-	float3_t pos;		//позиция квада
-	bool IsClose;		//закрытый ли квад
-	ID Arr[8];			//id соседей
-	ID Id;				//идентификатор-ключ для обращения к массиву
-	uint16_t IdSplit;	//идентификатор сплита к которому отсносится данный квад (в случае если сетка не цельная)
+
+	//! направления по осям, значения из AIGRID_QUAD_DIR_
+	char m_chAxisX, m_chAxisY;
+
+	//! позиция квада
+	float3_t m_vPos;		
+
+	//! закрытый ли квад
+	bool m_isClose;		
+
+	//! id соседей
+	ID m_aNeighbors[8];
+
+	//! идентификатор-ключ для обращения к массиву
+	ID m_id;				
+
+	//! идентификатор сплита к которому отсносится данный квад (в случае если сетка не цельная)
+	uint16_t m_iSplit;	
 };
 
-//ограничивающий объем для квадов
-struct BoundAIQuad
+//! ограничивающий объем для квадов
+struct CBoundAIquad
 {
-	BoundAIQuad(){}
-	~BoundAIQuad(){}
+	CBoundAIquad(){}
+	~CBoundAIquad(){}
+
+	//! float экстремумы
+	float3_t m_f3Min, m_f3Max;
+
+	//! int (#AIGRID_TOINT) экстремумы 
+	int3 m_i3Min, m_i3Max;
+
+	//! массив идентификаторов квадов
+	Array<ID> m_aIdsQuads;
+};
+
+//! нод дерева боксов
+struct CTreeBoundAIquad
+{
+	CTreeBoundAIquad()
+	{
+		m_aSplits[0] = 0;
+		m_aSplits[1] = 0;
+		m_aSplits[2] = 0;
+		m_aSplits[3] = 0;
+		m_pBoundBox = 0;
+	}
+
+	~CTreeBoundAIquad()
+	{
+		mem_delete(m_aSplits[0]);
+		mem_delete(m_aSplits[1]);
+		mem_delete(m_aSplits[2]);
+		mem_delete(m_aSplits[3]);
+		mem_release(m_pBoundBox);
+	}
+
+	//! входящие ноды
+	CTreeBoundAIquad *m_aSplits[4];
+
+	//! ограничивающий объем
+	ISXBound *m_pBoundBox;
 
-	float3_t min,max;
-	int3 lmin, lmax;
-	Array<ID> ArrIdsQuads;
+	//! int данные ограничивающего объема
+	int3 m_i3Min, m_i3Max;
+
+	//! входящие боксы
+	Array<CBoundAIquad*, 64> m_pBounds;
 };
 
-//структура стоимости перехода по кваду
-struct CostAIQuad
+//!структура стоимости перехода по кваду
+struct CCostTransit
 {
-	CostAIQuad()
+	CCostTransit()
 	{
 		F=G=H=0;
 	}
@@ -115,170 +170,249 @@ struct CostAIQuad
 	uint32_t F,G,H;
 };
 
-struct AIQuadVertexData
+//! вершина квада AI сетки
+struct CAIQuadVertexData
 {
-	AIQuadVertexData(){}
-	AIQuadVertexData(float px,float py,float pz,float tcx,float tcy)
+	CAIQuadVertexData(){}
+	CAIQuadVertexData(float fX, float fY, float fZ, float fTCX, float fTCY)
 	{
-		pos.x = px;
-		pos.y = py;
-		pos.z = pz;
+		m_vPos.x = fX;
+		m_vPos.y = fY;
+		m_vPos.z = fZ;
 
-		tc.x = tcx;
-		tc.y = tcy;
+		m_vTC.x = fTCX;
+		m_vTC.y = fTCY;
 	}
-	float3_t pos;
-	float2_t tc;
+
+	//! позиция
+	float3_t m_vPos;
+
+	//! текстурные координаты
+	float2_t m_vTC;
 };
 
-//
-struct AIQuadVertexDataInst
+//! вершина трансформации для hardware instancing
+struct CAIQuadVertexDataInst
 {
-	float3_t pos;
-	float4_t tex;
-	uint32_t color;
+	//! позиция
+	float3_t m_vPos;
+
+	//! текстурные координаты
+	float4_t m_vTC;
+
+	//! цвет
+	uint32_t m_uiColor;
 };
 
+//##########################################################################
 
-class AIGrid
+//! класс AI сетки
+class CAIGrid
 {
 public:
-	AIGrid();
-	~AIGrid();
+	CAIGrid();
+	~CAIGrid();
 
-	void GraphicsInit();//инициализация графических данных, если надо
-	void Clear();		//очистка всех данных
+	//!инициализация графических данных, если надо
+	void initGraphics();
 
-	bool existsQuads();
+	//! очистка всех данных
+	void clear();		
 
-	//сохранение/загрузка
-	void GridSave(const char* path);
-	void GridLoad(const char* path);
+	//! есть ли квады в сетке?
+	bool existsQuads() const;
+
+	//! сохранение данных о сетке, путь абсолютный
+	void save(const char *szPath);
+
+	//! загрузка данных о сетке, путь абсолютный
+	void load(const char *szPath);
 	
 	//ограничивающий объем
 	//{
-	void BBCreate(const float3* center, const float3* param);	//создать ограничивающий объем по параметрам
-	bool BBIsCreated() const;									//создан ли ограничивающий объем
+
+	//! создать ограничивающий объем по параметрам
+	void bbCreate(const float3 *pCenter, const float3 *pParam);	
+
+	//! создан ли ограничивающий объем
+	bool bbIsCreated() const;									
 	
-	//установка/получение габаритов
-	void BBSetDimensions(const float3* dim);						
-	void BBGetDimensions(float3* dim) const;
+	//! установка габаритов
+	void bbSetDimensions(const float3 *pDimensions);
+
+	//! получение габаритов
+	void bbGetDimensions(float3 *pDimensions) const;
 
-	//установка/получение позиции
-	void BBSetPos(const float3* pos);
-	void BBGetPos(float3* pos) const;
+	//! установка позиции
+	void bbSetPos(const float3 *pPos);
 
-	void BBCreateFinish();	//завершение создания ограничивающего объема, после которого изменить какие-либо его данные будет невозможно
-	bool BBIsCreatedFinish() const;
+	//! получение позиции
+	void bbGetPos(float3 *pPos) const;
+
+	//! завершение создания ограничивающего объема, после которого изменить какие-либо его данные будет невозможно
+	void bbCreateFinish();
+
+	//! окончательно ли создан ограничивающий объем сетки?
+	bool bbIsCreatedFinish() const;
 	//}
 
 	//квады
 	//{
 	//установка/возвращение состояния квада
-	void QuadSetState(ID id, AIQUAD_STATE state);
-	AIQUAD_STATE QuadGetState(ID id) const;
-	void QuadSetStateWho(ID id, ID who);
-	ID QuadGetStateWho(ID id);
+	void quadSetState(ID id, AIQUAD_STATE state);
+
+	//! возвращает состояние квада
+	AIQUAD_STATE quadGetState(ID id) const;
+
+	//! установка занятости квада, idWho - идентификатор того кто занял квад
+	void quadSetStateWho(ID id, ID idWho);
+
+	//! возвращает идентификатор того кто занял квад
+	ID quadGetStateWho(ID id) const;
 
-	//проверка квада: является ли квад id соседом и idn1 кваду и idn2 кваду
-	bool QuadIs2Neighbors(ID id, ID idn1, ID idn2);
+	//! проверка квада: является ли квад id соседом и idn1 кваду и idn2 кваду
+	bool quadIs2Neighbors(ID id, ID idn1, ID idn2) const;
 	
-	//установка/возвращение позиции по оси Y для квада
-	void QuadSetPosY(ID id, float posy);
-	float QuadGetPosY(ID id) const;
+	//! установка/возвращение позиции по оси Y для квада
+	void quadSetPosY(ID id, float fPosY);
 
-	ID QuadAdd(const float3* pos);					//добавление квада в позицию
-	bool QuadDelete(ID id);							//удаление квада по его id
+	//! возвращение позиции по оси Y для квада
+	float quadGetPosY(ID id) const;
+
+
+	//! добавление квада в позицию
+	ID quadAdd(const float3 *pPos);					
+
+	//! удаление квада по его id
+	bool quadDelete(ID id);							
 	
-	void QuadSelect(ID id, bool consider_prev);		//добавление квада к списку выделения, id - идентификатор квада, если -1 то очищает список, consider_prev - учитывать ли предыдущие записанные, если нет то очищает массив и записывает туда, если да то записывает сверху
-	void QuadSelectedAddPosY(float posy);	//добавление к позиции по оси Y для выделенных квадов
-	void QuadSelectedDelete();						//удаление выделенных квадов
+
+	//! добавление квада к списку выделения, id - идентификатор квада, если -1 то очищает список, isConsiderPrev - учитывать ли предыдущие записанные, если нет то очищает массив и записывает туда, если да то записывает сверху
+	void quadSelect(ID id, bool isConsiderPrev);		
+
+	//! добавление к позиции по оси Y для выделенных квадов
+	void quadSelectedAddPosY(float fPosY);	
+
+	//! удаление выделенных квадов
+	void quadSelectedDelete();						
 	
-	bool QuadIsFree(ID id, int radius);		//свободен ли квад id в радиусе radius (radius - количество квадов вокруг указанного в id, 1 - значит только указанный, 2 - значит все соседние и т.д.)
-	ID QuadGetNear(const float3* pos, bool isfree = false, int raius = 1);	//возвращает id ближайшего квада (если isfree == true то ищет только свободные) С радиусом свободности radius
-	ID QuadGet(const float3* pos, bool isnear_or_permissible) const;	//получить id квада по позиции, isnear_or_permissible - самый ближний квад, или самый ближний в пределах допустимой разницы начальной точки?
-	bool QuadGetPos(ID id, float3* pos);
+	//! свободен ли квад id в радиусе radius (iRadius - количество квадов вокруг указанного в id, 1 - значит только указанный, 2 - значит все соседние и т.д.)
+	bool quadIsFree(ID id, int iRadius);		
+
+	//! возвращает id ближайшего квада в радиусе fRadius от pPos (если isFree == true то ищет только свободные) c радиусом свободности iQuadRadius
+	ID quadGetNear(const float3 *pPos, float fRadius, bool isFree = false, int iQuadRadius = 1);	
+
+	//! получить id квада по позиции, isNearOrPermissible - самый ближний квад, или самый ближний в пределах допустимой разницы по оси Y
+	ID quadGet(const float3 *pPos, bool isNearOrPermissible) const;
+
+	//! возвращает позицию квада по его id
+	bool quadGetPos(ID id, float3 *pPos) const;
 	//}
 
 	//сетка
 	//{
-	void GridGenerate();											//функция просчетов, ее нужно вызывать чтобы просчитать всю аи сетку
-	void GridClear();
-	ID GridTraceBeam(const float3* start, const float3* dir) const;	//трассировка луча и проверка его пересечения с каким либо квадом сетки
-	void GridTestValidation();										//тест действительности сетки и устранение возможных дефектов
-	UINT GridGetCountSplits();										//
-	void GridSetMarkSplits(bool mark);						//выделение сплитов
-	bool GridGetMarkSplits();								//возвращает состояние выделения сплитов
-	UINT GridGetCountQuads();								//возвращает количество квадов в сетке
+
+	//! функция генерации сетки, должен быть хотя бы один квад для начала генерации
+	void gridGenerate();	
+
+	//! очистка сетки, полное удаление данных
+	void gridClear();
+
+	//! трассировка луча и проверка его пересечения с каким либо квадом сетки
+	ID gridTraceBeam(const float3 *pStart, const float3 *pDir) const;	
+
+	//! тест действительности сетки и устранение возможных дефектов
+	void gridTestValidation();
+
+	//! возвращает количество сплитов сетки
+	UINT gridGetCountSplits() const;
+
+	//! выделение сплитов
+	void gridSetMarkSplits(bool isMark);						
+
+	//! возвращает состояние выделения сплитов
+	bool gridGetMarkSplits() const;
+
+	//! возвращает количество квадов в сетке
+	UINT gridGetCountQuads() const;								
 	
-	int gridGetSizePath(ID idQueueObject);									//размер найденного пути в количестве квадратов
-	bool gridGetPath(ID idQueueObject, ID *pMemory, UINT uiCount, bool canReverse);	//запись найденного пути в уже выделенную память
+	//! возвращает размер найденного пути в количестве квадратов, idQueueObject - идентификатор запроса
+	int gridGetSizePath(ID idQueueObject) const;
 
+	//! запись найденного пути в уже выделенную память
+	bool gridGetPath(ID idQueueObject, ID *pMemory, UINT uiCount, bool canReverse);	
+
+	//! запрос на поиск пути, возвращает идентификатор запроса
 	ID gridQueryFindPath(ID idStart, ID idFinish);
+
+	//! отменить запрос поиска пути по идентификатору запроса idQuery
 	bool gridCancelQueryFindPath(ID idQuery);
+
+	//! обновление запросов поиска пути, uiLimitMls количество млсекунд выделяемых на работу функции, но минимум один поиск
 	void gridQueryFindPathUpdate(UINT uiLimitMls);
 
-	void GridSetColorArr(const ID * pmem, DWORD color, UINT count);
-	void GridSetNullColor();
+	//! установить квадам сетки цвета
+	void gridSetColorArr(const ID *pMem, DWORD dwColor, UINT uiCount);
+
+	//! обнулить все цвета сетки
+	void gridSetNullColor();
+
 	//}
 
 	//графпоинты
 	//{
-	void GraphPointGenerate();					//автоматическая генерация графпоинтов в центрах играничивающих боксов
-	UINT GraphPointGetCount();			//возвращает количество графпоинтов
-	void GraphPointClear();				//очистка списка графпоинтов
-	void GraphPointAdd(ID id);			//добавление графпоинта (id - идентификатор квада сетки)
-	void GraphPointDelete(ID id);		//удаление графпоинта (id - идентификатор квада сетки)
-	ID GraphPointGetNear(ID beginq, ID endq);	//поиск наиболее близкого графпоинта между стартовой и конецной точкой следования
+
+	//! автоматическая генерация графпоинтов в центрах ограничивающих боксов
+	void graphPointGenerate();
+
+	//! возвращает количество графпоинтов
+	UINT graphPointGetCount() const;
+
+	//! очистка списка графпоинтов
+	void graphPointClear();
+
+	//! добавление графпоинта (id - идентификатор квада сетки)
+	void graphPointAdd(ID id);
+
+	//! удаление графпоинта (id - идентификатор квада сетки)
+	void graphPointDelete(ID id);
+
+	//! поиск наиболее близкого графпоинта между стартовой и конецной точкой следования
+	ID graphPointGetNear(ID idStart, ID idFinish);
+
 	//}
 	
-	//ренер
+	//рендер
 	//{
-	void RenderQuads(const ISXFrustum * frustum, const float3 * viewpos, float dist);	//отрисовка сетки
-	void RenderGraphPoints(const float3 * viewpos, float dist);							//отрисовка графпоинтов
-	void RenderBB();			//отрисовка ограничивающих объемов
+
+	//! отрисовка сетки
+	void renderQuads(const ISXFrustum *pFrustum, const float3 *pViewPos, float fDist);
+
+	//! отрисовка графпоинтов
+	void renderGraphPoints(const float3 *pViewPos, float fDist);
+
+	//! отрисовка ограничивающих объемов
+	void renderBB();
+
 	//}
 	
 protected:
 
-	bool UseGraphics;	//использовать ли графику
-
-	IDirect3DDevice9* DXDevice;
-	IDirect3DVertexDeclaration9* AIQuadDecl;
-	ID Tex_AIGrid;
-	ID IDVS;
-	ID IDPS;
-	ID Tex_BB;
-
-	MemAlloc<AIQuad> AllocAIQuad;			//выделенная память для квадов
-	MemAlloc<BoundAIQuad> AllocBoundAIQuad;	//выделенная память для баундов
-
-	Array<uint32_t,1000> ArrColor;		//массив цвета для каждого квада сетки (по id квада)
-	Array<uint32_t> ArrSplitsColor;		//массив цвета для каждого сплита (если сетка не цельная)
-	Array<int3, 1000> ArrLongCoordQuads;//массив long значений координат для каждого квада (по id квада)
-	Array<AIQuad*, 1000> ArrQuads;		//массив готовых квадов (порядковый номер и есть id)
-	Array<AIQuad*, 1000> ArrQuadsCheck;	//массив квадов на проверку (используется при генерации)
-	Array<AIQUAD_STATE> ArrState;		//массив состояний для каждого квада (по id квада)
-	Array<ID> ArrStateWho;				//массив идентификаторов объектов которые занимают квады (по id квада)
-	Array<bool> ArrPreCondFreeState;	//массив состояния проверка занятости для каждого квада (по id квада)
-
-	Array<BoundAIQuad*> ArrBound;		//массив ограничивающих объемов для разбиения сетки
-	Array<ID> ArrGraphPointsIDs;		//массив навигационных квадов, они такие же как и обычные квады, длинные пути удобнее строить через них
-	Array<int32_t> ArrCostGPIDs;		//массив со стоимостями перемещения по навигационным квадам
-
-	Array<ID, 1000> ArrTestSplitsIDs;	//массив id квадов которые мы проверяем при тесте целостности сетки
-	Array<bool> ArrCloseIDs;			//закрытый список (по id квада)
-	Array<ID> ArrOpenIDs;				//закрытый список, ArrIDsInOpen[id квада]
-	Array<ID> ArrIDsInOpen;				//значение квада в открытом списке, по id квада
-	Array<ID> ArrParentIDs;				//список родителей (по id квада)
-	Array<CostAIQuad> ArrCostQuads;		//список стоимостей проходов по каждому кваду (по 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,
 	};
 
@@ -304,63 +438,210 @@ protected:
 		Array<ID> m_aQuads;
 	};
 
+	//**********************************************************************
+
+	//! использовать ли графику, точнее: будет ли осуществляться рендер
+	bool m_useGraphics;
+
+	//! dx9 устройство
+	IDirect3DDevice9 *m_pDXDevice;
+
+	//! декларация вершин сетки
+	IDirect3DVertexDeclaration9 *m_pDecl;
+
+	//! текстура сетки
+	ID m_idTex;
+
+	//! вершинный шейдер
+	ID m_idVS;
+
+	//! пиксельный шейдер
+	ID m_idPS;
+
+	//! текстура для ограничивающих объемов
+	ID m_idTexBB;
+
+	//! выделенная память для квадов
+	MemAlloc<CAIquad> m_oAllocQuad;			
+
+	//! выделенная память для баундов
+	MemAlloc<CBoundAIquad> m_oAllocBound;
+
+	//! массив цвета для каждого квада сетки (по id квада)
+	Array<uint32_t, 1000> m_aQuadColors;		
+
+	//! массив цветов сплитов
+	Array<uint32_t> m_aSplitsColor;		
+
+	//! массив int значений координат для каждого квада (по id квада)
+	Array<int3, 1000> m_aLongCoordQuads;
+
+	//! массив готовых квадов (порядковый номер и есть id)
+	Array<CAIquad*, 1000> m_aQuads;		
+
+	//! массив состояний для каждого квада (по id квада)
+	Array<AIQUAD_STATE> m_aQuadState;		
+
+	//! массив квадов на проверку (используется при генерации)
+	Array<CAIquad*, 1000> m_aQuadsCheck;	
+	
+	//! массив идентификаторов объектов которые занимают квады (по id квада)
+	Array<ID> m_aStateWho;				
+
+	//! массив состояния проверка занятости для каждого квада (по id квада)
+	Array<bool> m_aPreCondFreeState;	
+
+	//! дерево (quad) боксов
+	CTreeBoundAIquad *m_pTreeBound;
+	
+	//! массив ограничивающих объемов для разбиения сетки
+	Array<CBoundAIquad*> m_aBound;		
+
+	//! массив навигационных квадов, они такие же как и обычные квады, длинные пути удобнее строить через них
+	Array<ID> m_aGraphPointsIDs;		
+
+	//! массив со стоимостями перемещения по навигационным квадам
+	Array<int32_t> m_aCostGraphPointsIDs;
+
+
+	//! массив id квадов которые мы проверяем при тесте целостности сетки
+	Array<ID, 1000> m_aTestSplitsIDs;	
+
+	//! закрытый список (по id квада)
+	Array<bool> m_aCloseIDs;			
+
+	//! закрытый список, ArrIDsInOpen[id квада]
+	Array<ID> m_aOpenIDs;
+
+	//! значение квада в открытом списке, по id квада
+	Array<ID> m_aIDsInOpen;				
+
+	//! список родителей (по id квада)
+	Array<ID> m_aParentIDs;				
+
+	//! список стоимостей проходов по каждому кваду (по id квада)
+	Array<CCostTransit> m_aCostQuads;
+
+	//! массив выделенных в данный момент квадов
+	Array<ID> m_aSelectedQuads;
+
+	//! выделить ли цветом сплиты сетки
+	bool m_isMarkSplits;
+
+	//! примерный размер открытого списка, бывает чуть больше чем надо, но не выходит за пределы массива
+	int NumLastKeyOpenList;
+
+	//! номер последнего занесенного квада в открытый список
+	ID CountInitOpen2;
+
+	//! количество сплитов сетки
+	uint16_t m_uiCountSplits;
+
+	//! вершинный буфер квада
+	IDirect3DVertexBuffer9 *m_pVertexQuad;
+
+	//! индексный буфер квада
+	IDirect3DIndexBuffer9 *m_pIndexQuad;
+
+	//! вершинный буфер с данными трансформаций
+	IDirect3DVertexBuffer9 *m_pTransVertBuf;
+
+	//! меш главного ограничивающего объема
+	ID3DXMesh *m_pBoundBox;
+
+	//! значения ограничивающего объема
+	float3_t m_vMax, m_vMin;
+
 	//! массив очереди запросов на поиск пути
 	Array<CQueueObject> m_aQueueFind;
 
+	//! номер последнего ожидающего запроса на поиск пути
 	int m_iLastWait;
+	
+	//**********************************************************************
 
+	//! генерация дерева боксов
+	void createTreeBound();
+
+	//! возвращает найденный ожидающий запрос на поиск пути
 	ID getQueueWaiting();
 
+
+	//! возвращает найденный простаивающий запрос на поиск пути
 	ID getQueueIdle();
 
-	bool gridFindPath(ID idQueueObject);							//поиск пути, (beginq,beginq]
 
+	//! поиск пути
+	bool gridFindPath(ID idQueueObject);							
 
-	Array<ID> ArrSelected;				//массив выделенных в данный момент квадов
+	//! является ил квад с id графпоинтом
+	ID graphPointGetKey(ID id);			
 
-	bool IsMarkSplits;		//true - выделить цветом сплиты сетки
-	int NumLastKeyOpenList;	//примерный размер открытого списка, бывает чуть больше чем надо, но не выходит за пределы массива
-	ID CountInitOpen2;		//номер последнего занесенного квада в открытый список
-	uint16_t CountSplits;	//количество сплитов сетки
+	//! рекурсивная функция проверки свободности квада
+	bool isFreeQuad2(ID id, int iRadius);	
 
-	//данные гпу, отрисовка по методу hardware instancing
-	IDirect3DVertexBuffer9* VertexQuad;
-	IDirect3DIndexBuffer9*  IndexQuad;
-	IDirect3DVertexBuffer9* TransVertBuf;
-	ID3DXMesh* BoundBox;
+	//! выделен ли квад с id
+	bool quadSelectedExists(ID id);					
 
-	//значения ограничивающего объема
-	float3_t Max, Min;
-	
+	//! есть ли у квада с id сосед по прямому направлению который сейчас выделен
+	bool quadSelectedExistsNeightborDirect(ID id);	
+
+
+	//! коррекция позиции под центр ближайшего квада (по xz)
+	void correctPosXZ(float3 *pPos);				
+
+	//! валидный ли квад с указанным id
+	bool isValidIdInArrQuads(ID id);		
+
+	//! удалить все невалидные квады (это те которые по каким-то причинам оказались закрытыми или не имеют прямого направления)
+	void quadDeleteInvalidAll();				
+
+	//! удаление информации о кваде из всех возможных источников (с изменением всех идентификаторов которые идут после него)
+	void quadDelete2(ID id);					
+
+
+	//! физическая навигация  квада
+	void phyNavigate(CAIquad *pQuad);	
+
+	//! находится ли разница между высотами центров квадов в допустимом пределе
+	bool gridCompareHeight(ID id1, ID id2);				
+
+	//! пересоздание буферов
+	void reCreateBuffs();											
+
+	//! установка значений по умолчанию для квада id
+	void defInitBuffs(ID id);										
+
+
+	//! добавление квада в подходящий ббокс и запись его позиции в int3
+	void addUniqQuadArrag(const CAIquad *pQuad);					
+
+	//! добавление квада в указанный ббокс и запись его позиции в int3
+	void addUniqQuadArrag2(const CAIquad *pQuad, CBoundAIquad *pBB);		
+
+	//! генерация соседей квада по прямым направлениям и полный просчет квада
+	void genQuad(CAIquad *pQuad);										
+
+	//! просчет и назначение соседей для квада
+	void computeNeighbor(ID id);									
+
+	//! является ли квад уникальным
+	bool isUniqQuadArrag(CAIquad *pQuad, ID *pIdQuad, CBoundAIquad **ppBB);
+
+	//! деление пространства ограничивающего объема на более мелкие части
+	void splitBB(int iX,int iY,int iZ);								
+
+	//! находится ли квад в открытом списке
+	bool IsOpen(ID id);				
+
+	//! просчет H стоимости, диагональные шаги не в счет
+	int CalcHCost(ID id1, ID id2);	
+
+	//! просчет H стоимости, просчет расстояния между квадами * 100
+	int CalcH2Cost(ID id1, ID id2);	
 
-	ID GraphPointGetKey(ID id);			//является ил квад с id графпоинтом
-	bool IsFreeQuad2(ID id, int radius);	//рекурсивная функция проверки свободности квада
-
-	bool QuadSelectedExists(ID id);					//выделен ли квад с id
-	bool QuadSelectedExistsNeightborDirect(ID id);	//есть ли у квада с id сосед по прямому направлению который сейчас выделен
-
-	void CorrectPosXZ(float3* pos);				//коррекция позиции под центр ближайшего квада (по xz)
-	bool IsValidIdInArrQuads(ID id);		//валидный ли квад с указанным id
-	void QuadDeleteInvalidAll();				//удалить все невалидные квады (это те которые по каким-то причинам оказались закрытыми или не имеют прямого направления)
-	void QuadDelete2(ID id);					//удаление информации о кваде из всех возможных источников (с изменением всех идентификаторов которые идут после него)
-
-	void PhyNavigate(AIQuad* quad);	//физическая навигация  квада
-	bool AIGridCompareHeight(ID id1, ID id2);				//находится ли разница между высотами центров квадов в допустимом пределе
-	void ReCreateBuffs();											//пересоздание буферов
-	void DefInitBuffs(ID id);										//установка значений по умолчанию для квада id
-
-	void AddUniqQuadArrag(const AIQuad* aq);					//добавление квада в подходящий ббокс и запись его позиции в int3
-	void AddUniqQuadArrag2(const AIQuad* aq, ID idbb);		//добавление квада в указанный ббокс и запись его позиции в int3
-	void GenQuad(AIQuad* aq);										//генерация соседей квада по прямым направлениям и полный просчет квада
-	void ComputeNeighbor(ID id);									//просчет и назначение соседей для квада
-	bool IsUniqQuadArrag(AIQuad* aq, ID * idquad, ID * idbb);//является ли квад уникальным
-	void SplitBB(int x,int y,int z);								//деление пространства ограничивающего объема на более мелкие части
-
-	//pathfind
-	bool IsOpen(ID id);				//находится ли квад в открытом списке
-	int CalcHCost(ID id, ID endid);	//просчет H стоимости, диагональные шаги не в счет
-	int CalcH2Cost(ID id1, ID id2);	//просчет H стоимости, просчет расстояния между квадами * 100
-	ID AddInOpenList(ID id);			//добавить квад в открытый список
+	//! добавить квад в открытый список
+	ID AddInOpenList(ID id);			
 };
 
 #endif
\ No newline at end of file
diff --git a/source/aigrid/sxaigrid.cpp b/source/aigrid/sxaigrid.cpp
index be1281ccdfe6a6a9f9121059b56c68b88989e63d..84b520cbb97efa92c95dc457c505facef273330f 100644
--- a/source/aigrid/sxaigrid.cpp
+++ b/source/aigrid/sxaigrid.cpp
@@ -21,7 +21,7 @@ bool QuadPhyNavigate(float3_t *pPos)
 
 g_aiquad_phy_navigate AIQuadPhyNavigate = QuadPhyNavigate;
 
-AIGrid* g_pAIGrid = 0;
+CAIGrid* g_pAIGrid = 0;
 
 #define AIG_PRECOND(retval) if(!g_pAIGrid){LibReport(REPORT_MSG_LEVEL_ERROR, "%s - sxaigrid is not init", GEN_MSG_LOCATION); return retval;}
 
@@ -51,16 +51,16 @@ SX_LIB_API void SAIG_0Create(const char *szName, bool useGraphics, bool isUnic)
 			}
 			else
 			{
-				g_pAIGrid = new AIGrid();
+				g_pAIGrid = new CAIGrid();
 				if (useGraphics)
-					g_pAIGrid->GraphicsInit();
+					g_pAIGrid->initGraphics();
 			}
 		}
 		else
 		{
-			g_pAIGrid = new AIGrid();
+			g_pAIGrid = new CAIGrid();
 			if (useGraphics)
-				g_pAIGrid->GraphicsInit();
+				g_pAIGrid->initGraphics();
 		}
 	}
 	else
@@ -87,7 +87,7 @@ SX_LIB_API void SAIG_Clear()
 {
 	AIG_PRECOND(_VOID);
 
-	g_pAIGrid->Clear();
+	g_pAIGrid->clear();
 }
 
 SX_LIB_API bool SAIG_ExistsQuads()
@@ -101,154 +101,154 @@ SX_LIB_API void SAIG_GridSave(const char *szPath)
 {
 	AIG_PRECOND(_VOID);
 
-	g_pAIGrid->GridSave(szPath);
+	g_pAIGrid->save(szPath);
 }
 
 SX_LIB_API void SAIG_GridLoad(const char* szPath)
 {
 	AIG_PRECOND(_VOID);
 
-	g_pAIGrid->GridLoad(szPath);
+	g_pAIGrid->load(szPath);
 }
 
 SX_LIB_API UINT SAIG_GridGetCountQuads()
 {
 	AIG_PRECOND(0);
 
-	return g_pAIGrid->GridGetCountQuads();
+	return g_pAIGrid->gridGetCountQuads();
 }
 
 SX_LIB_API void SAIG_BBCreate(const float3 *pCenter, const float3 *pParam)
 {
 	AIG_PRECOND(_VOID);
 
-	g_pAIGrid->BBCreate(pCenter, pParam);
+	g_pAIGrid->bbCreate(pCenter, pParam);
 }
 
 SX_LIB_API bool SAIG_BBIsCreated()
 {
 	AIG_PRECOND(false);
 
-	return g_pAIGrid->BBIsCreated();
+	return g_pAIGrid->bbIsCreated();
 }
 
 SX_LIB_API void SAIG_BBSetDimensions(const float3 *pDimensions)
 {
 	AIG_PRECOND(_VOID);
 
-	g_pAIGrid->BBSetDimensions(pDimensions);
+	g_pAIGrid->bbSetDimensions(pDimensions);
 }
 
 SX_LIB_API void SAIG_BBGetDimensions(float3 *pDimensions)
 {
 	AIG_PRECOND(_VOID);
 
-	g_pAIGrid->BBGetDimensions(pDimensions);
+	g_pAIGrid->bbGetDimensions(pDimensions);
 }
 
 SX_LIB_API void SAIG_BBSetPos(const float3 *pPos)
 {
 	AIG_PRECOND(_VOID);
 
-	g_pAIGrid->BBSetPos(pPos);
+	g_pAIGrid->bbSetPos(pPos);
 }
 
 SX_LIB_API void SAIG_BBGetPos(float3 *pPos)
 {
 	AIG_PRECOND(_VOID);
 
-	g_pAIGrid->BBGetPos(pPos);
+	g_pAIGrid->bbGetPos(pPos);
 }
 
 SX_LIB_API void SAIG_BBCreateFinish()
 {
 	AIG_PRECOND(_VOID);
 
-	g_pAIGrid->BBCreateFinish();
+	g_pAIGrid->bbCreateFinish();
 }
 
 SX_LIB_API bool SAIG_BBIsCreatedFinish()
 {
 	AIG_PRECOND(false);
 
-	return g_pAIGrid->BBIsCreatedFinish();
+	return g_pAIGrid->bbIsCreatedFinish();
 }
 
 SX_LIB_API AIQUAD_STATE SAIG_QuadGetState(ID idQuad)
 {
 	AIG_PRECOND(AIQUAD_STATE::AIQUAD_STATE_FREE);
 
-	return g_pAIGrid->QuadGetState(idQuad);
+	return g_pAIGrid->quadGetState(idQuad);
 }
 
 SX_LIB_API void SAIG_QuadSetState(ID idQuad, AIQUAD_STATE state)
 {
 	AIG_PRECOND(_VOID);
 
-	g_pAIGrid->QuadSetState(idQuad, state);
+	g_pAIGrid->quadSetState(idQuad, state);
 }
 
 SX_LIB_API void SAIG_QuadSetStateWho(ID idQuad, ID idWho)
 {
 	AIG_PRECOND(_VOID);
 
-	g_pAIGrid->QuadSetStateWho(idQuad, idWho);
+	g_pAIGrid->quadSetStateWho(idQuad, idWho);
 }
 
 SX_LIB_API ID SAIG_QuadGetStateWho(ID idQuad)
 {
 	AIG_PRECOND(-1);
 
-	return g_pAIGrid->QuadGetStateWho(idQuad);
+	return g_pAIGrid->quadGetStateWho(idQuad);
 }
 
 SX_LIB_API bool SAIG_QuadIs2Neighbors(ID idQuad, ID idQuad1, ID idQuad2)
 {
 	AIG_PRECOND(false);
 
-	return g_pAIGrid->QuadIs2Neighbors(idQuad, idQuad1, idQuad2);
+	return g_pAIGrid->quadIs2Neighbors(idQuad, idQuad1, idQuad2);
 }
 
 SX_LIB_API ID SAIG_QuadGet(const float3 *pPos, bool isNearOrPermissible)
 {
 	AIG_PRECOND(-1);
 
-	return g_pAIGrid->QuadGet(pPos, isNearOrPermissible);
+	return g_pAIGrid->quadGet(pPos, isNearOrPermissible);
 }
 
 SX_LIB_API bool SAIG_QuadGetPos(ID idQuad, float3 *pPos)
 {
 	AIG_PRECOND(false);
 
-	return g_pAIGrid->QuadGetPos(idQuad, pPos);
+	return g_pAIGrid->quadGetPos(idQuad, pPos);
 }
 
 SX_LIB_API void SAIG_QuadSetPosY(ID idQuad, float fPosY)
 {
 	AIG_PRECOND(_VOID);
 
-	g_pAIGrid->QuadSetPosY(idQuad, fPosY);
+	g_pAIGrid->quadSetPosY(idQuad, fPosY);
 }
 
 SX_LIB_API float SAIG_QuadGetPosY(ID idQuad)
 {
 	AIG_PRECOND(0);
 
-	return g_pAIGrid->QuadGetPosY(idQuad);
+	return g_pAIGrid->quadGetPosY(idQuad);
 }
 
 SX_LIB_API ID SAIG_QuadAdd(const float3 *pPos)
 {
 	AIG_PRECOND(-1);
 
-	return g_pAIGrid->QuadAdd(pPos);
+	return g_pAIGrid->quadAdd(pPos);
 }
 
 SX_LIB_API bool SAIG_QuadDelete(ID idQuad)
 {
 	AIG_PRECOND(false);
 
-	return g_pAIGrid->QuadDelete(idQuad);
+	return g_pAIGrid->quadDelete(idQuad);
 }
 
 
@@ -256,84 +256,84 @@ SX_LIB_API void SAIG_GridClear()
 {
 	AIG_PRECOND(_VOID);
 
-	g_pAIGrid->GridClear();
+	g_pAIGrid->gridClear();
 }
 
 SX_LIB_API ID SAIG_GridTraceBeam(const float3 *pStart, const float3 *pDir)
 {
 	AIG_PRECOND(-1);
 
-	return g_pAIGrid->GridTraceBeam(pStart, pDir);
+	return g_pAIGrid->gridTraceBeam(pStart, pDir);
 }
 
 SX_LIB_API void SAIG_QuadSelect(ID pStart, bool useConsiderPrev)
 {
 	AIG_PRECOND(_VOID);
 
-	g_pAIGrid->QuadSelect(pStart, useConsiderPrev);
+	g_pAIGrid->quadSelect(pStart, useConsiderPrev);
 }
 
 SX_LIB_API void SAIG_QuadSelectedAddPosY(float fPosY)
 {
 	AIG_PRECOND(_VOID);
 
-	g_pAIGrid->QuadSelectedAddPosY(fPosY);
+	g_pAIGrid->quadSelectedAddPosY(fPosY);
 }
 
 SX_LIB_API void SAIG_QuadSelectedDelete()
 {
 	AIG_PRECOND(_VOID);
 
-	g_pAIGrid->QuadSelectedDelete();
+	g_pAIGrid->quadSelectedDelete();
 }
 
 SX_LIB_API bool SAIG_QuadIsFree(ID idQuad, int fRadius)
 {
 	AIG_PRECOND(false);
 
-	return g_pAIGrid->QuadIsFree(idQuad, fRadius);
+	return g_pAIGrid->quadIsFree(idQuad, fRadius);
 }
 
-SX_LIB_API ID SAIG_QuadGetNear(const float3 *pPos, bool isFree, int iRadius)
+SX_LIB_API ID SAIG_QuadGetNear(const float3 *pPos, float fRadius, bool isFree, int iQuadRadius)
 {
 	AIG_PRECOND(-1);
 
-	return g_pAIGrid->QuadGetNear(pPos, isFree, iRadius);
+	return g_pAIGrid->quadGetNear(pPos, fRadius, isFree, iQuadRadius);
 }
 
 SX_LIB_API void SAIG_GridTestValidation()
 {
 	AIG_PRECOND(_VOID);
 
-	g_pAIGrid->GridTestValidation();
+	g_pAIGrid->gridTestValidation();
 }
 
 SX_LIB_API UINT SAIG_GridGetCountSplits()
 {
 	AIG_PRECOND(0);
 
-	return g_pAIGrid->GridGetCountSplits();
+	return g_pAIGrid->gridGetCountSplits();
 }
 
 SX_LIB_API void SAIG_GridSetMarkSplits(bool isMark)
 {
 	AIG_PRECOND(_VOID);
 
-	g_pAIGrid->GridSetMarkSplits(isMark);
+	g_pAIGrid->gridSetMarkSplits(isMark);
 }
 
 SX_LIB_API bool SAIG_GridGetMarkSplits()
 {
 	AIG_PRECOND(false);
 
-	return g_pAIGrid->GridGetMarkSplits();
+	return g_pAIGrid->gridGetMarkSplits();
 }
 
 SX_LIB_API void SAIG_GridGenerate()
 {
 	AIG_PRECOND(_VOID);
 
-	g_pAIGrid->GridGenerate();
+	g_pAIGrid->gridGenerate();
 }
 
 SX_LIB_API void SAIG_GridQueryFindPathUpdate(UINT uiLimitMls)
@@ -375,14 +375,14 @@ SX_LIB_API void SAIG_GridSetColorArr(const ID *pMem, DWORD dwColor, UINT uiCount
 {
 	AIG_PRECOND(_VOID);
 
-	g_pAIGrid->GridSetColorArr(pMem, dwColor, uiCount);
+	g_pAIGrid->gridSetColorArr(pMem, dwColor, uiCount);
 }
 
 SX_LIB_API void SAIG_GridSetNullColor()
 {
 	AIG_PRECOND(_VOID);
 
-	g_pAIGrid->GridSetNullColor();
+	g_pAIGrid->gridSetNullColor();
 }
 
 
@@ -390,42 +390,42 @@ SX_LIB_API void SAIG_GraphPointGenerate()
 {
 	AIG_PRECOND(_VOID);
 
-	g_pAIGrid->GraphPointGenerate();
+	g_pAIGrid->graphPointGenerate();
 }
 
 SX_LIB_API UINT SAIG_GraphPointGetCount()
 {
 	AIG_PRECOND(0);
 
-	return g_pAIGrid->GraphPointGetCount();
+	return g_pAIGrid->graphPointGetCount();
 }
 
 SX_LIB_API void SAIG_GraphPointClear()
 {
 	AIG_PRECOND(_VOID);
 
-	g_pAIGrid->GraphPointClear();
+	g_pAIGrid->graphPointClear();
 }
 
 SX_LIB_API void SAIG_GraphPointAdd(ID idQuad)
 {
 	AIG_PRECOND(_VOID);
 
-	g_pAIGrid->GraphPointAdd(idQuad);
+	g_pAIGrid->graphPointAdd(idQuad);
 }
 
 SX_LIB_API void SAIG_GraphPointDelete(ID idQuad)
 {
 	AIG_PRECOND(_VOID);
 
-	g_pAIGrid->GraphPointDelete(idQuad);
+	g_pAIGrid->graphPointDelete(idQuad);
 }
 
 SX_LIB_API ID SAIG_GraphPointGetNear(ID idBegin, ID idEnd)
 {
 	AIG_PRECOND(-1);
 
-	return g_pAIGrid->GraphPointGetNear(idBegin, idEnd);
+	return g_pAIGrid->graphPointGetNear(idBegin, idEnd);
 }
 
 
@@ -433,19 +433,19 @@ SX_LIB_API void SAIG_RenderQuads(const ISXFrustum *pFrustum, const float3 *pView
 {
 	AIG_PRECOND(_VOID);
 
-	g_pAIGrid->RenderQuads(pFrustum, pViewPos, fDist);
+	g_pAIGrid->renderQuads(pFrustum, pViewPos, fDist);
 }
 
 SX_LIB_API void SAIG_RenderGraphPoints(const float3 *pViewPos, float fDist)
 {
 	AIG_PRECOND(_VOID);
 
-	g_pAIGrid->RenderGraphPoints(pViewPos, fDist);
+	g_pAIGrid->renderGraphPoints(pViewPos, fDist);
 }
 
 SX_LIB_API void SAIG_RenderBB()
 {
 	AIG_PRECOND(_VOID);
 
-	g_pAIGrid->RenderBB();
+	g_pAIGrid->renderBB();
 }
diff --git a/source/aigrid/sxaigrid.h b/source/aigrid/sxaigrid.h
index 67bfaac4f659a166bc7905230c77e601f11865e8..6b3b1a319dfa4529f754c48e5edb0b1ea978cead 100644
--- a/source/aigrid/sxaigrid.h
+++ b/source/aigrid/sxaigrid.h
@@ -59,48 +59,101 @@ SX_LIB_API void SAIG_AKill();
 
 //!@}
 
-#define AIGRID_QUADS_CENTERS_MAXHEIGHT	0.6f	/*!< максимальная высота между центрами соседних квадов */
+/*! преобразование float в int
+ \warning осторожно, изменения  могут повлечь баги в генерации и некоторых иных функция. Когда было *100 то в некоторых местах генерировались дубликаты, и поиск квада по позиции не всегда работал корректно
+*/
+#define AIGRID_TOINT(fNum) (int32_t)(roundf(fNum * 10.f))
+
+/*! максимальная высота между центрами соседних квадов */
+#define AIGRID_QUADS_CENTERS_MAXHEIGHT	0.6f	
+
+/*! размеры ограничивающих боксов */
+#define AIGRID_BBOXSIZE					5.f		
+
+/*! минимально допустимый размер дял деления сплита дерева боксов */
+#define AIGRID_SPLIT_MIN_SIZE AIGRID_BBOXSIZE*5.f		
 
-#define AIGRID_BBOXSIZE					5.f		/*!< размеры ограничивающих боксов */
+/*! #AIGRID_TOINT максимальная высота между центрами соседних квадов */
+#define LAIGRID_QUADS_CENTERS_MAXHEIGHT	6		
 
-#define LAIGRID_QUADS_CENTERS_MAXHEIGHT	60		/*!< int*100 максимальная высота между центрами соседних квадов */
-#define LAIGRID_QUAD_SIZE				70		/*!< int*100 размеры квада */
-#define LAIGRID_QUAD_SIZEDIV2			35		/*!< int*100 половинный размер квада */
+/*! #AIGRID_TOINT размеры квада */
+#define LAIGRID_QUAD_SIZE				7		
 
 //направления
-#define AIGRID_QUAD_DIR_ALL				0		/*!< квад имеет переходы в положительное и отрицательное направления */
-#define AIGRID_QUAD_DIR_POSITIVE		1		/*!< квад имеет только положительный переход */
-#define AIGRID_QUAD_DIR_NEGATIVE		-1		/*!< квад имеет только отрицательный переход */
-#define AIGRID_QUAD_DIR_NONE			2		/*!< квад не имеет переходов */
+/*! квад имеет переходы в положительное и отрицательное направления */
+#define AIGRID_QUAD_DIR_ALL				0		
+
+/*! квад имеет только положительный переход */
+#define AIGRID_QUAD_DIR_POSITIVE		1		
+
+/*! квад имеет только отрицательный переход */
+#define AIGRID_QUAD_DIR_NEGATIVE		-1		
+
+/*! квад не имеет переходов */
+#define AIGRID_QUAD_DIR_NONE			2		
+
+
+/*! размеры квада */
+#define AIGRID_QUAD_SIZE				0.7f	
+
+/*! половинный размер квада */
+#define AIGRID_QUAD_SIZEDIV2			0.35f	
+
+/*! на сколько метров будет приподнят квад */
+#define AIGRID_QUAD_ADDYPOS				0.01f;	
 
-#define AIGRID_QUAD_SIZE				0.7f	/*!< размеры квада */
-#define AIGRID_QUAD_SIZEDIV2			0.35f	/*!< половинный размер квада */
-#define AIGRID_QUAD_ADDYPOS				0.01f;	/*!< на сколько метров будет приподнят квад */
 
 //цена перемещения
-#define AIGRID_COST_DIRECT				10		/*!< цена прямого перемещения */
-#define AIGRID_COST_DIAGONAL			14		/*!< цена перемещения по диагонали */
+/*! цена прямого перемещения */
+#define AIGRID_COST_DIRECT				10		
+
+/*! цена перемещения по диагонали */
+#define AIGRID_COST_DIAGONAL			14		
+
 
-#define AIGRID_COST_GPATH				500		/*!< минимально необходимая дистанция (int(dist * 100)) для нахождения ближайшего графпоинта */
+/*! минимально необходимая дистанция (int(dist * 100)) для нахождения ближайшего графпоинта */
+#define AIGRID_COST_GPATH				500		
 
-#define AIGRID_COSTADD_TEMPBUSY			50		/*!< добавочна стоимость для прохода через квад который временно занят */
-#define AIGRID_COSTADD_BUSY				250		/*!< добавочна стоимость для прохода через квад который занят */
 
-#define AIGRID_QUADSCOUNT_BUSY			50		/*!< дистанция (ходы по горизонтали и вертикали, но не по диагонали) в пределах которой будет учитываться занятость квада */
+/*! добавочная стоимость для прохода через квад который временно занят */
+#define AIGRID_COSTADD_TEMPBUSY			50		
 
-#define AIGRID_ENTITY_MAX_HEIGHT		1.5f								/*!< максимальная высота сущности, которая будет передвигаться по сетке */
-#define AIGRID_ENTITY_MAX_HEIGHTDIV2	(AIGRID_ENTITY_MAX_HEIGHT * 0.5f)	/*!< половинная максимальная высота сущности */
+/*! добавочная стоимость для прохода через квад который занят */
+#define AIGRID_COSTADD_BUSY				250		
 
-#define AIGRID_COLOR_GBBOX				D3DCOLOR_ARGB(128, 0, 255, 0)		/*!< цвет главного ограничивающего объема */
-#define AIGRID_COLOR_SEL_MAIN			D3DCOLOR_ARGB(220, 255, 255, 255)	/*!< цвет выделенного квада */
-#define AIGRID_COLOR_SEL_ADD			D3DCOLOR_ARGB(100, 255, 255, 255)	/*!< цвет соседей (прямых) выделенного квада */
+
+/*! дистанция (ходы по горизонтали и вертикали, но не по диагонали) в пределах которой будет учитываться занятость квада */
+#define AIGRID_QUADSCOUNT_BUSY			50		
+
+
+/*! максимальная высота сущности, которая будет передвигаться по сетке */
+#define AIGRID_ENTITY_MAX_HEIGHT		1.5f								
+
+/*! половинная максимальная высота сущности */
+#define AIGRID_ENTITY_MAX_HEIGHTDIV2	(AIGRID_ENTITY_MAX_HEIGHT * 0.5f)	
+
+
+/*! цвет главного ограничивающего объема */
+#define AIGRID_COLOR_GBBOX				D3DCOLOR_ARGB(128, 0, 255, 0)		
+
+/*! цвет выделенного квада */
+#define AIGRID_COLOR_SEL_MAIN			D3DCOLOR_ARGB(220, 255, 255, 255)	
+
+/*! цвет соседей (прямых) выделенного квада */
+#define AIGRID_COLOR_SEL_ADD			D3DCOLOR_ARGB(100, 255, 255, 255)	
 
 //! состояния занятости квада
 enum AIQUAD_STATE
 {
-	AIQUAD_STATE_FREE = 0,		//!< свободен
-	AIQUAD_STATE_TEMPBUSY = 1,	//!< временно занят
-	AIQUAD_STATE_BUSY = 2,		//!< занят
+
+	//! свободен
+	AIQUAD_STATE_FREE = 0,		
+
+	//! временно занят
+	AIQUAD_STATE_TEMPBUSY = 1,	
+
+	//! занят
+	AIQUAD_STATE_BUSY = 2,		
 };
 
 /*! тип функции для навигации квада по уровню, 
@@ -109,6 +162,8 @@ enum AIQUAD_STATE
 */
 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);
 
@@ -259,8 +314,8 @@ 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);	
+//! возвращает id ближайшего квада (если isFree == true то ищет только свободные) с радиусом свободности iQuadRadius
+SX_LIB_API ID SAIG_QuadGetNear(const float3 *pPos, float fRadius, bool isFree = false, int iQuadRadius = 1);
 
 #define SAIG_QuadSetColor(id, color) SAIG_GridSetColorArr(&id, color, 1)
 
diff --git a/source/game/NPCBase.cpp b/source/game/NPCBase.cpp
index 726d07b6b63ff2e1428ebd208c9a544a36179d5f..918786c6699eefaddf701a5c116d5c98ebf9b029 100644
--- a/source/game/NPCBase.cpp
+++ b/source/game/NPCBase.cpp
@@ -207,7 +207,7 @@ void CNPCBase::onSync()
 void CNPCBase::gridCheckBeyond()
 {
 	//находим ближайший квад к текущей позиции нпс
-	ID idq = SAIG_QuadGetNear(&(float3)m_vPosition);
+	ID idq = SAIG_QuadGetNear(&(float3)m_vPosition, 5);
 	if (idq >= 0)
 	{
 		float3 tpos;
diff --git a/source/gcore/shader.cpp b/source/gcore/shader.cpp
index 4f4a899f25a2f4debf5d90e535de24b1fcc44abe..3ebc81c1d6d7c4a19c6b9e45b54f8bac322a6b22 100644
--- a/source/gcore/shader.cpp
+++ b/source/gcore/shader.cpp
@@ -703,7 +703,7 @@ ID CShaderManager::preLoad(SHADER_TYPE type, const char *szPath, const char *szN
 
 void CShaderManager::allLoad()
 {
-	if (m_aVS.size() == m_iLastAllLoadVS || m_aPS.size() == m_iLastAllLoadPS)
+	if (m_aVS.size() == m_iLastAllLoadVS && m_aPS.size() == m_iLastAllLoadPS)
 		return;
 
 	DWORD dwTime = GetTickCount();
diff --git a/source/gdefines.h b/source/gdefines.h
index a49977adf08e37e81ac0fa75f5f7c1b95ddcd122..aacebb408ef48c4eec942fa9b948e9b0743074ee 100644
--- a/source/gdefines.h
+++ b/source/gdefines.h
@@ -257,7 +257,12 @@ inline void LibReport(int iLevel, const char *szFormat, ...)
 	static char szStr[REPORT_MSG_MAX_LEN];
 	szStr[0] = 0;
 	int iStrLen = sizeof(szStr);
-	format_str(szStr, szFormat);
+	//format_str(szStr, szFormat);
+
+	va_list va; 
+	va_start(va, szFormat);
+	vsprintf_s(szStr, sizeof(szStr), szFormat, va);
+	va_end(va);
 
 	g_fnReportf(iLevel, SX_LIB_NAME, szStr);
 }
diff --git a/source/skyxengine.cpp b/source/skyxengine.cpp
index bd448aab6a0fa0fca83c23046a40e9ff0fd83889..73bf1a17f4c9e753dd43582bf6e348404cced800 100644
--- a/source/skyxengine.cpp
+++ b/source/skyxengine.cpp
@@ -174,7 +174,7 @@ void SkyXEngine_Init(HWND hWnd3D, HWND hWndParent3D)
 	Core_RIntSet(G_RI_INT_TIMER_RENDER, idTimerRender);
 	Core_RIntSet(G_RI_INT_TIMER_GAME, idTimerGame);
 
-	tm ct = { 0, 0, 10, 27, 5, 2030 - 1900, 0, 0, 0 };
+	tm ct = { 0, 0, 8, 27, 5, 2030 - 1900, 0, 0, 0 };
 	Core_TimeUnixStartSet(idTimerGame, mktime(&ct));
 
 	Core_TimeWorkingSet(idTimerRender, true);
@@ -352,6 +352,8 @@ void SkyXEngine_Init(HWND hWnd3D, HWND hWndParent3D)
 		ShowWindow(hWnd3DCurr, SW_MAXIMIZE);
 #endif
 
+	SkyXEngind_UpdateDataCVar();
+
 	LibReport(REPORT_MSG_LEVEL_NOTICE, "Engine initialized!\n");
 }
 
@@ -719,6 +721,17 @@ void SkyXEngine_Frame(DWORD timeDelta)
 	Core_RFloat3Get(G_RI_FLOAT3_OBSERVER_POSITION, &vCamPos);
 	Core_RFloat3Get(G_RI_FLOAT3_OBSERVER_DIRECTION, &vCamDir);
 
+	//сделал для тестов, убрать если будет мешать
+	/*ttime = TimeGetMcsU(Core_RIntGet(G_RI_INT_TIMER_RENDER));
+	//ID idQuad = SAIG_QuadGetNear(&vCamPos, true, 1);
+	ID idQuad = -1;
+	for (int i = 0; i < 100;++i)
+		idQuad = SAIG_QuadGet(&vCamPos, true);
+	ttime = TimeGetMcsU(Core_RIntGet(G_RI_INT_TIMER_RENDER)) - ttime;
+	LibReport(REPORT_MSG_LEVEL_NOTICE, "ttime = %lld, idQuad = %d \n", ttime, idQuad);
+	SAIG_GridSetNullColor();
+	SAIG_GridSetColorArr(&idQuad, D3DCOLOR_RGBA(255, 0, 0, 255), 1);*/
+
 	Core_RMatrixGet(G_RI_MATRIX_OBSERVER_VIEW, &mView);
 	Core_RMatrixGet(G_RI_MATRIX_LIGHT_PROJ, &mProjLight);
 
@@ -739,26 +752,11 @@ void SkyXEngine_Frame(DWORD timeDelta)
 	}
 
 
-	
-	/*IDirect3DTexture9 *pINTZ = SGCore_RTGetTextureN("intz");
-	IDirect3DSurface9 *pINTZSurface = 0;
-
-	if (pINTZ)
-	{
-		pINTZ->GetSurfaceLevel(0, &pINTZSurface);
-		pDXDevice->SetDepthStencilSurface(pINTZSurface);
-		mem_release(pINTZSurface);
-	}*/
-
 	//рисуем сцену и заполняем mrt данными
 	ttime = TimeGetMcsU(Core_RIntGet(G_RI_INT_TIMER_RENDER));
 	SRender_BuildMRT(timeDelta, isSimulationRender);
 	DelayRenderMRT += TimeGetMcsU(Core_RIntGet(G_RI_INT_TIMER_RENDER)) - ttime;
 
-	//mem_release(pINTZSurface);
-
-	
-
 
 	if (*r_final_image == DS_RT_AMBIENTDIFF || *r_final_image == DS_RT_SPECULAR || *r_final_image == DS_RT_SCENELIGHT)
 	{
@@ -807,10 +805,10 @@ void SkyXEngine_Frame(DWORD timeDelta)
 	SRender_RenderEditorMain();
 
 
-/*#if defined(_DEBUG)
-	static const float * r_far = GET_PCVAR_FLOAT("r_far");
-	SAIG_RenderQuads(SRender_GetCamera()->ObjFrustum, &vCamPos, *r_far);
-#endif*/
+#if defined(SX_GAME) && defined(SX_AIGRID_RENDER)
+	//static const float * r_far = GET_PCVAR_FLOAT("r_far");
+	SAIG_RenderQuads(SRender_GetCamera()->getFrustum(), &vCamPos, *r_far);
+#endif
 
 #if defined(SX_GAME)
 	SXGame_RenderHUD();
@@ -1109,16 +1107,23 @@ void SkyXEngind_UpdateDataCVar()
 
 		static int iCountModes = 0;
 		static const DEVMODE *aModes = SGCore_GetModes(&iCountModes);
+		static const bool *r_win_windowed = GET_PCVAR_BOOL("r_win_windowed");
 
-		if (r_win_width && r_win_width_old != (*r_win_width) && r_win_height && r_win_height_old != (*r_win_height))
+		if (r_win_width_old != (*r_win_width) || r_win_height_old != (*r_win_height))
 		{
 			bool isValid = false;
-			for (int i = 0; i < iCountModes; ++i)
+
+			if (r_win_windowed && (*r_win_windowed) == true)
+				isValid = true;
+			else
 			{
-				if (aModes[i].dmPelsWidth == (*r_win_width) && aModes[i].dmPelsHeight == (*r_win_height))
+				for (int i = 0; i < iCountModes; ++i)
 				{
-					isValid = true;
-					break;
+					if (aModes[i].dmPelsWidth == (*r_win_width) && aModes[i].dmPelsHeight == (*r_win_height))
+					{
+						isValid = true;
+						break;
+					}
 				}
 			}
 
@@ -1152,7 +1157,7 @@ void SkyXEngind_UpdateDataCVar()
 			}
 		}
 
-		static const bool *r_win_windowed = GET_PCVAR_BOOL("r_win_windowed");
+		
 
 		if (r_win_windowed)
 		{
diff --git a/source/sxmaterialeditor/common_callback.cpp b/source/sxmaterialeditor/common_callback.cpp
index 1caae079c1355ed3bf2c320b6f13243b72239db3..9b1fd2eb5b7aa3c68c61c6189fc1aa91ea1a04a9 100644
--- a/source/sxmaterialeditor/common_callback.cpp
+++ b/source/sxmaterialeditor/common_callback.cpp
@@ -15,10 +15,8 @@ void SXMaterialEditor::MtlOpen()
 	tmppath[0] = 0;
 	char tmpname[1024];
 	//gui_func::dialogs::SelectFile(SXGUI_DIALOG_FILE_OPEN, tmppath, 0, Core_RStringGet(G_RI_STRING_PATH_GS_TEXTURES), FILE_FILTER_TEXTURE);
-	gui_func::dialogs::SelectFileOwn(tmpname, tmppath, Core_RStringGet(G_RI_STRING_PATH_GS_TEXTURES), "dds", "Select textures", true, Core_RStringGet(G_RI_STRING_PATH_GS_TEXTURES), SXMaterialEditor::JobWindow->getHWND(), SkyXEngine_EditorHandlerGetPreviewData, SkyXEngine_EditorHandlerGetTextureInfo);
-	if (def_str_validate(tmppath))
+	if (gui_func::dialogs::SelectFileOwn(tmpname, tmppath, Core_RStringGet(G_RI_STRING_PATH_GS_TEXTURES), "dds", "Select textures", true, Core_RStringGet(G_RI_STRING_PATH_GS_TEXTURES), SXMaterialEditor::JobWindow->getHWND(), SkyXEngine_EditorHandlerGetPreviewData, SkyXEngine_EditorHandlerGetTextureInfo))
 	{
-		StrCutName(tmppath, tmpname);
 		SML_MtlReloadMaterial(SRender_SimModelGetIDMtl(), tmpname);
 		SGCore_LoadTexAllLoad();