public bool resetGlobal_NavigationCells(CTriCollector triCollector,
ref CNaviMesh navigationMesh)
{
List <CTRI> listTris;
triCollector.getTris(out listTris); // TriCollector에서 데이터 리스트를 얻어옴
navigationMesh.navigation.ConstructNavi(listTris);
bool bResultMapping = navigationMesh.navigation.mappingNavigation(triCollector.m_listTris_naviGoal,
triCollector.m_listTris_naviBlock,
triCollector.m_listTris_naviBlockRoad,
triCollector.m_listTris_naviStart,
true);
if (true == bResultMapping)
{
m_toolmoduleNavimesh.drawStartCellToGoal(m_meshNavigation_global.navigation, m_triCollector);
}
triCollector._bReadyToExecuteBuildup_NAVI = false;
if (triCollector.getCount_NaviFunction_Tris() > 0)
{
m_toolmoduleNavimesh.drawAllTri_eachFunctional(m_meshNavigation_global.triCollector, false);
}
triCollector.setExtractAdjCells(navigationMesh.navigation);
return(true);
} // protected bool resetGlobal_NavigationCells()
} // void _LoadNaviFromTemplate()
public bool resetGlobal_constantObjects(CTriCollector triCollector, bool bConstantlyCreateObj)
{
if (triCollector.m_listTris_naviStart.Count > 0)
{
foreach (int iTriStart in triCollector.m_listTris_naviStart)
{
CTRI triStartCurr = triCollector.getTri(iTriStart);
if (null != triStartCurr)
{
m_intervalUnitWalking.newIntervalConstantly(iTriStart,
m_processInput._respawnunitwalking,
m_processInput._timeinterval_unitwalking,
triStartCurr.GetCenterTri());
}
}
}
else
{
m_intervalUnitWalking.workprocessInterval = false;
}
m_intervalUnitWalking.workprocessInterval = bConstantlyCreateObj;
return(true);
}
} // private void SetDrawCellsIndexAll()
public void _drawText3D_SeqCells(CTriCollector tricollector, List <int> listCellsIdx)
{
if (null == m_drawText3DStartCell || listCellsIdx.Count < 1)
{
return;
}
m_drawText3DStartCell.clear3DTextAll();
if (listCellsIdx.Count > 0)
{
Quaternion quaternionCoreText3D = new Quaternion();
Vector3 v3Position;
int iSequencialNumber = 0;
foreach (int iIdxTri in listCellsIdx)
{
if (iIdxTri < 0)
{
continue;
}
v3Position = tricollector.getTri(iIdxTri).GetCenterTri();
v3Position = v3Position + m_v3PosAdjustText3D;
m_drawText3DStartCell.setNew3DText(v3Position,
quaternionCoreText3D,
m_iFontSizeText3D,
m_colorText3D,
"" + (iSequencialNumber++) + "(" + iIdxTri + ")",
true);
} // for (int iSeqBase = 0; iSeqBase < listBase.Count; ++iSeqBase)
}
} // private void _drawText3D_SeqCells()
public bool newSquareBaseFromTri(int iIdxTri, bool bOnlyPair, CTriCollector tricollector)
{
bool bDeletedBaseCoreSub = delete_Base_byTri(iIdxTri);
if (true == bDeletedBaseCoreSub)
{
return(false);
}
if (true == beExistedBase_(iIdxTri))
{
return(false);
}
int iTriHypotenuse = tricollector.searchTriHypotenuse(iIdxTri);
if (-1 == iTriHypotenuse)
{
if (true == bOnlyPair)
{
return(false);
}
}
else
{
m_listTris_Instant.Add(iTriHypotenuse);
} // if (-1 == iTriHypotenuse)
m_listTris_Instant.Add(iIdxTri);
setNewBase_fromListTris(m_listTris_Instant);
return(true);
}
public void DestructNaviMesh()
{
_navigation.DestructNavi();
_splinecurve.destructSplinecurveAll();
_triCollector.DestructAllTris();
_triCollector = null;
_navigation = null;
_splinecurve = null;
}
} // protected bool resetGlobal_NavigationCells()
public void LinkTriCollectorToAllBase(ref CBaseTowerCollector managerBaseTower_ref,
ref CBaseCoreCollector managerBaseCore_ref,
ref CBaseCoreSubCollector managerBaseCoreSub_ref,
ref CBaseStartCollector managerBaseStart_ref,
ref CBaseBlockCollector managerBaseBlock_ref,
CTriCollector triCollector)
{
managerBaseTower_ref.setTrisallToBase(triCollector.getTris());
managerBaseCore_ref.setTrisallToBase(triCollector.getTris());
managerBaseCoreSub_ref.setTrisallToBase(triCollector.getTris());
managerBaseStart_ref.setTrisallToBase(triCollector.getTris());
managerBaseBlock_ref.setTrisallToBase(triCollector.getTris());
}
Vector3 GetStartTriangleRandomPosition(CTriCollector tricollector, int idxTriangle)
{
CTRI tri = tricollector.getTri(idxTriangle);
float r1 = Random.Range(0.1f, 0.8f);
float r2 = Random.Range(0.1f, (1.0f - r1 - 0.1f));
float r3 = 1.0f - r1 - r2;
float positionX = tri._arrv3PT[0].x * r1 + tri._arrv3PT[1].x * r2 + tri._arrv3PT[2].x * r3;
float positionZ = tri._arrv3PT[0].z * r1 + tri._arrv3PT[1].z * r2 + tri._arrv3PT[2].z * r3;
return(new Vector3(positionX, tri._arrv3PT[0].y, positionZ));
}
//@ Process
public void InitializeNaviMesh()
{
_navigation = new CNavigation();
_triCollector = new CTriCollector();
_splinecurve = new CSplineManufacturer();
_navigation.InitializeNavi();
_triCollector.InitTriCollector();
_splinecurve.InitSplieCurve();
m_meshGeometry = GetComponent <MeshFilter>().mesh;
m_arrVertex = m_meshGeometry.vertices;
m_arrTri = m_meshGeometry.triangles;
}
public bool newSquareBaseBlockFromTri(int iIdxTri, bool bOnlyPair, CTriCollector tricollector)
{
bool bSetNew = base.newSquareBaseFromTri(iIdxTri, bOnlyPair, tricollector);
if (true == bSetNew)
{
if (m_listBase__.Count < 1)
{
return(false);
}
int irandomizeBlocktype = UnityEngine.Random.Range(0, m_itypeblockNum);
CBASE__ baseBlockLastof = m_listBase__[m_listBase__.Count - 1];
baseBlockLastof.setIdxType(irandomizeBlocktype);
return(true);
}
return(false);
}
//@ Triangle Collection Composition all renderLine of triangles.
public void _drawRenderLine_AllTris_Debug(CTriCollector triCollector)
{
if (null == m_drawRenderLine_triCollector)
{
return;
}
List <CTRI> listTriangle = triCollector.getTris();
if (listTriangle.Count < 1)
{
return;
}
if (m_iSequenceRenderLine_forDebug >= 0)
{
return;
}
int iLengthMapping = listTriangle.Count * 3;
Vector3[] arrVertexmapping = new Vector3[iLengthMapping];
for (int iSeqTri = 0; iSeqTri < listTriangle.Count; ++iSeqTri)
{
CTRI triCurr = listTriangle[iSeqTri];
for (int iPnt = 0; iPnt < 3; ++iPnt)
{
int iSeqPnt = iSeqTri * 3 + iPnt;
Vector3 v3PntCurr = triCurr._arrv3PT[iPnt];
arrVertexmapping[iSeqPnt] = v3PntCurr;
}
}
m_iSequenceRenderLine_forDebug = m_drawRenderLine_triCollector.DrawNewLine_user(arrVertexmapping);
} // public void _drawRenderLine_AllTris_Debug()
//@ For DEBUG, Set Draw way StartCell to Goal
public void drawStartCellToGoal(CNavigation navigation, CTriCollector tricollector)
{
UndrawStartCellToGoal();
_SetundrawNaviCells_Text3D();
if (null == navigation.m_arrNavicells)
{
return;
}
bool bResultOrganized = navigation.collectWay_allStartsToGoal(tricollector, ref m_arrSequenceCell);
if (false == bResultOrganized)
{
return;
}
CNAVICELL[] arrNavicells = navigation.m_arrNavicells;
List <int> listSeqTri = getListSequenceOrganized();
int iBasisUniqueNum = m_iBasisUniqueNum_RenderMesh;
for (int iTriAdj = 0; iTriAdj < listSeqTri.Count; ++iTriAdj)
{
int iSeqUniqueNum = iBasisUniqueNum + listSeqTri[iTriAdj];
CTRI triAdj_ = arrNavicells[listSeqTri[iTriAdj]].trilinkcell;
m_drawRenderMesh_navi.DrawNewRendermesh(iSeqUniqueNum,
triAdj_._arrv3PT,
Color.Lerp(Color.gray, Color.black, 0.5f),
CMATH.FEPSILON_F3 + CMATH.FEPSILON_F3,
CDrawRenderMesh.scaleadjust_render_070);
}
_drawText3D_SeqCells(tricollector, tricollector.m_listTris_naviStart);
} // private void drawStartCellToGoal()
public bool resetGlobal(int iIdxKeyNavi, bool bInitFromGeometry)
{
if (iIdxKeyNavi < 0)
{
return(false);
}
_IdxKeyNavi = iIdxKeyNavi;
bool bResultProcess = false;
//@ Clear all managers
bResultProcess = clearGLOBAL(true);
if (false == bResultProcess)
{
Debug.Log("Error. clearGLOBAL()!/////");
}
//@ Instantiate NaviMesh
m_meshNavigation_global = m_datanavimeshs.getNavigationMesh(iIdxKeyNavi);
m_meshNavigation_global.InitializeNaviMesh();
m_triCollector = m_meshNavigation_global.triCollector;
m_SplineCurve = m_meshNavigation_global.splinecurve;
if (true == bInitFromGeometry)
{
//@ Construct All Triangle
bResultProcess = resetGlobal_TrianglesAll(m_meshNavigation_global);
if (false == bResultProcess)
{
Debug.Log("Error!.//");
}
//@ Set constant objects to start position
bResultProcess = resetGlobal_constantObjects(m_triCollector, false);
if (false == bResultProcess)
{
Debug.Log("Error!.//");
}
//@ Intiailzie basemanets
LinkTriCollectorToAllBase(ref m_baseTowerCollector,
ref m_baseCoreCollector,
ref m_baseCoresubCollector,
ref m_baseStartCollector,
ref m_baseBlockCollector,
m_triCollector);
//@ Re-load navi cells from template pre-loads.
LoadNaviFromTemplate();
//@ Load bases.
Load_BaseTower_Binary(ref m_baseTowerCollector);
Load_BaseCore_Binary(ref m_baseCoreCollector);
Load_BaseCoreSub_Binary(ref m_baseCoresubCollector);
Load_BaseStart_Binary(ref m_baseStartCollector);
Load_BaseBlock_Binary(ref m_baseBlockCollector);
//@ Load Curve Path through script
bResultProcess = Load_CurvePath_Binary(ref m_SplineCurve);
if (false == bResultProcess)
{
Debug.Log("loadingProcess_Binary Load_CurvePath_Binary_error. //");
}
//@ Construct Navigation
bResultProcess = resetGlobal_NavigationCells(m_triCollector, ref m_meshNavigation_global);
if (false == bResultProcess)
{
Debug.Log("Error!.//");
}
//@Initialze UnitWalking
UnitWalking.SetStatusCellToCell();
} // if (true == bInitFromGeometry)
else
{
//@ Load using script.
loadingProcess_Binary(iIdxKeyNavi);
} // if (false == bInitFromGeometry)
//@ Input Process Initialize
m_processInput.resetInput(this);
m_intervalUnitWalking.InitIntervalUnitWalking(m_triCollector);
return(true);
} // public void resetGlobal
//@ Collect All BaseTower List which calculated Perfect Square.
static public bool CollectAll_perfectSqre_exceptGoalTri(CNAVICELL[] arrNavicells,
CTriCollector tricollector,
ref List <CBASE__> listBase)
{
int iCntNaviCell = arrNavicells.Length;
if (iCntNaviCell < 1)
{
Debug.Log("if(iCntNaviCell < 1)");
return(false);
}
List <int> listIdxTrisGoal = tricollector.m_listTris_naviGoal;
List <int> listIdxTrisStart = tricollector.m_listTris_naviStart;
List <int> listTriIR = new List <int>();
CNAVICELL.CADJ_TRI[] arrAdjs_ = tricollector.arrayAllTriAdjacent;
tricollector.collectAll_IsoscellesRightTriangles(ref listTriIR);
List <int> listTri_Instant__ = new List <int>();
bool bValidatedBase_perfectSquare = false;
foreach (int iIdxTri in listTriIR)
{
CNAVICELL.CADJ_TRI adjTri = arrAdjs_[iIdxTri];
CTRI triCurr = tricollector.getTri(iIdxTri);
bValidatedBase_perfectSquare = false;
//@ process skip
if (true == triCurr.inclinedPlane())
{
continue;
}
if (-1 < listIdxTrisGoal.BinarySearch(iIdxTri))
{
continue;
}
if (-1 < listIdxTrisStart.BinarySearch(iIdxTri))
{
continue;
}
int iEdge_Hyptenuse = triCurr.GetHypotenuseEdge();
if (CTRI.NULL_TRI_EDGE == iEdge_Hyptenuse)
{
continue;
}
int iTri_Hypotenuse = adjTri._arrTrisAdjacent[iEdge_Hyptenuse];
if (iTri_Hypotenuse == CNAVICELL.NULL_CELL)
{
continue;
}
CTRI triHyptenuse = tricollector.getTri(iTri_Hypotenuse);
if (triHyptenuse.IsisoscelesRightAngle() == true)
{
bValidatedBase_perfectSquare = true;
listTri_Instant__.Add(iIdxTri);
listTri_Instant__.Add(iTri_Hypotenuse);
}
if (true == bValidatedBase_perfectSquare)
{
CBASE__ base__New = new CBASE__();
for (int iTri_ = 0; iTri_ < listTri_Instant__.Count; ++iTri_)
{
int iSeqTri_ = listTri_Instant__[iTri_];
CTRI triPicked = tricollector.getTri(iSeqTri_);
base__New.InsertNewTri(iSeqTri_, triPicked, false);
}
bool bAlreadyExisted = false;
foreach (CBASE__ base__Sub in listBase)
{
if (true == base__Sub.IsSimilar(base__New))
{
bAlreadyExisted = true;
break;
}
}
if (false == bAlreadyExisted)
{
base__New.CalculateBase__(iIdxTri);
listBase.Add(base__New);
}
listTri_Instant__.Clear();
} // if(true==bValidatedBase_perfectSquare)
} // foreach(int iIdxTri in listTriIR)
return(true);
} // static public bool CollectAll_perfectSqre_exceptGoalTri()
//@ Process
public void InitIntervalUnitWalking(CTriCollector tricollector)
{
m_tricollector = tricollector;
}
//@ Debug Draw for Tri Eachtype
public void drawAllTri_eachFunctional(CTriCollector triCollector, bool bRepresentBlocks)
{
if (null == m_drawRenderMesh_triCollector)
{
return;
}
undrawAllTri();
List <int> listTrisPicked_naviGoal = triCollector.m_listTris_naviGoal;
List <int> listTrisPicked_naviBlock = triCollector.m_listTris_naviBlock;
List <int> listTrisPicked_naviBlockRoad = triCollector.m_listTris_naviBlockRoad;
List <int> listTrisPicked_naviStart = triCollector.m_listTris_naviStart;
// Blocks
if (true == bRepresentBlocks)
{
if (listTrisPicked_naviBlock.Count > 0)
{
foreach (int iIdxTri in listTrisPicked_naviBlock)
{
CTRI triRenderDebug = triCollector.getTri(iIdxTri);
m_drawRenderMesh_triCollector.DrawNewRendermesh(DFLT_IDX_RENDERTRI_TYPE + iIdxTri,
triRenderDebug._arrv3PT,
Color.Lerp(Color.blue, Color.black, 0.5f),
CMATH.FEPSILON_F2 * 3.0f,
CDrawRenderMesh.scaleadjust_render_095);
}
}
// BlockRoads
if (listTrisPicked_naviBlockRoad.Count > 0)
{
foreach (int iIdxTri in listTrisPicked_naviBlockRoad)
{
CTRI triRenderDebug = triCollector.getTri(iIdxTri);
m_drawRenderMesh_triCollector.DrawNewRendermesh(DFLT_IDX_RENDERTRI_TYPE + iIdxTri,
triRenderDebug._arrv3PT,
Color.Lerp(Color.blue, Color.white, 0.2f),
CMATH.FEPSILON_F2 * 3.0f,
CDrawRenderMesh.scaleadjust_render_095);
}
}
} // if (true == bRepresentBlocks)
// Goals
if (listTrisPicked_naviGoal.Count > 0)
{
foreach (int iIdxTri in listTrisPicked_naviGoal)
{
CTRI triRenderDebug = triCollector.getTri(iIdxTri);
m_drawRenderMesh_triCollector.DrawNewRendermesh(DFLT_IDX_RENDERTRI_TYPE + iIdxTri,
triRenderDebug._arrv3PT,
Color.red,
CMATH.FEPSILON_F2 * 3.0f,
CDrawRenderMesh.scaleadjust_render_093);
}
}
// Starts
if (listTrisPicked_naviStart.Count > 0)
{
foreach (int iIdxTri in listTrisPicked_naviStart)
{
CTRI triRenderDebug = triCollector.getTri(iIdxTri);
m_drawRenderMesh_triCollector.DrawNewRendermesh(DFLT_IDX_RENDERTRI_TYPE + iIdxTri,
triRenderDebug._arrv3PT,
Color.yellow,
CMATH.FEPSILON_F2 * 3.0f,
CDrawRenderMesh.scaleadjust_render_093);
}
}
} // public void drawAllTri_eachFunctional()
} // public void collectWayToGoalLinear
//@ Organize shortest way block edges startcell to goalcell.
public bool collectWay_allStartsToGoal(CTriCollector tricollector, ref CNAVICELL[] arrSequenceCellforPortal)
{
if (tricollector.m_listTris_naviStart.Count < 1)
{
return(false);
}
if (tricollector.m_listTris_naviGoal.Count < 1)
{
return(false);
}
arrSequenceCellforPortal = null;
Vector3 v3PntStart_ = new Vector3();
Vector3 v3PntEnd_ = new Vector3();
Vector3 v3PntPortal = new Vector3();
List <CNAVICELL> listSequenceCell = new List <CNAVICELL>();
//@ each start cell
foreach (int iSeqTriStart in tricollector.m_listTris_naviStart)
{
CNAVICELL cellWayStart = m_arrNavicells[iSeqTriStart];
//@ First Collect all blocks start to goal. And then buildup shortest way start to goal.
collectWayToGoalLinear(m_arrNavicells, cellWayStart, ref listSequenceCell, ref m_computeEdgeBlock);
//@ Organize Start -> Goal
if (listSequenceCell.Count > 2)
{
int iLenSeq = listSequenceCell.Count;
int iSeqIteration = 0, iSeqPortalSpot = 0;
v3PntStart_ = listSequenceCell[0].poscenterofcell;
CNAVICELL cellGOAL = listSequenceCell[iLenSeq - 1];
bool bCrosswithBlock = false;
foreach (CNAVICELL cellCurr in listSequenceCell)
{
int iSeqCurr = iSeqIteration++;
if (cellCurr == cellGOAL)
{
break;
}
cellCurr.getPos_nextWay(ref v3PntEnd_);
bCrosswithBlock = m_computeEdgeBlock.crossBlockIteration(v3PntStart_, v3PntEnd_);
if (true == bCrosswithBlock)
{
iSeqPortalSpot = iSeqCurr - 1;
if (listSequenceCell.Count <= iSeqPortalSpot || iSeqPortalSpot < 0)
{
continue;
}
listSequenceCell[iSeqPortalSpot].getPos_nextWay(ref v3PntPortal);
////@ Some problem this, have to solve.
//for (int iCellSeq = iSeqPortalSpot__ + 1; iCellSeq < iSeqPortalSpot; ++iCellSeq)
//{
// listSequenceCell[iCellSeq].SetPortalPosition(iSeqPortalSpot__, v3PntPortal);
//} //for (int iCellSeq = iSeqPortalSpot; iCellSeq < iSeqCurr - 1; ++iCellSeq)
v3PntStart_ = v3PntPortal;
} // if (true == bCrosswithBlock)
} // foreach (CNAVICELL cellCurr in listSequenceCell)
int iSeqCopyTo = 0;
if (null == arrSequenceCellforPortal)
{
arrSequenceCellforPortal = new CNAVICELL[listSequenceCell.Count];
}
else
{
iSeqCopyTo = arrSequenceCellforPortal.Length;
Array.Resize(ref arrSequenceCellforPortal, arrSequenceCellforPortal.Length + listSequenceCell.Count);
} // if (null == arrSequenceCellforPortal)
listSequenceCell.CopyTo(arrSequenceCellforPortal, iSeqCopyTo);
listSequenceCell.Clear();
} // if(listSequenceCell.Count > 2)
} // foreach(int iSeqTriStart in m_listCellsIdxStart)
listSequenceCell.Clear();
listSequenceCell = null;
return(true);
} // protected bool collectWay_allStartsToGoal()
