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()
    protected bool resetGlobal_TrianglesAll(CNaviMesh naviMesh_active)
    {
        //@ Construct All Triangle
        naviMesh_active.ConstructAllTriangles(RecomputeAllIV);

        return(true);
    }
Exemple #3
0
    void setNew_NaviMesh(string strKey, CNaviMesh navimeshValue)
    {
        navimesh_name navimeshName = new navimesh_name();

        navimeshName._naviMesh        = navimeshValue;
        navimeshName._strNameNaviMesh = strKey;

        m_listNameNavimesh.Add(navimeshName);
    }
Exemple #4
0
    void Awake()
    {
        for (int iSeqNavimesh = 0; iSeqNavimesh < arrayStageMesh.Length; ++iSeqNavimesh)
        {
            CNaviMesh naviMesh    = arrayStageMesh[iSeqNavimesh];
            string    strNavimesh = arrayStageName[iSeqNavimesh];

            setNew_NaviMesh(strNavimesh, naviMesh);
        }
    }
Exemple #5
0
    //@Process private
    void Destroy_activeNaviMesh()
    {
        if (null != m_naviMesh_Instance && null != m_naviMesh_Instance.gameObject)
        {
            Destroy(m_naviMesh_Instance.gameObject);
        }

        m_naviMesh_Instance = null;

        m_iIdxNaviMesh_Instance = navimeshResource.null_navimesh_instance;
    }
Exemple #6
0
    public CNaviMesh getNavigationMesh(int iSeqKey)
    {
        if (true == outOfRangeNAVIMESH(iSeqKey))
        {
            return(null);
        }

        Destroy_activeNaviMesh();

        m_iIdxNaviMesh_Instance = iSeqKey;
        m_naviMesh_Instance     = (CNaviMesh)Instantiate(m_listNameNavimesh[iSeqKey]._naviMesh);

        return(m_naviMesh_Instance);
    }
    bool intersectNavimesh(CNaviMesh navimesh, Vector3 v3PosUnit, ref Vector3 v3PosIntersected)
    {
        Vector3 v3PosSimulate = v3PosUnit;
        v3PosSimulate.y = v3PosSimulate.y + dist_adjustpos_up;

        Ray rayTestsimulate = new Ray(v3PosSimulate, Vector3.down);
        RaycastHit casthitted = new RaycastHit();

        bool bIntersected = navimesh.GetComponent<Collider>().Raycast(rayTestsimulate, out casthitted, dist_raycast_adjust);
        if (true == bIntersected)
        {
            v3PosIntersected = casthitted.point;
        }
        return bIntersected;
    }
    protected bool resetGlobal_TrianglesAll_LoadBinaryFile(CNaviMesh naviMesh_active)
    {
        //  Load triangle and naviinfo
        if (0 < m_stageMap.MapTriangle.Count)
        {
            naviMesh_active.setAllFunctionalTris(m_stageMap.MapTriangle,
                                                 m_stageMap.GroundBlockPoint_List,
                                                 m_stageMap.GroundBlockRoadPoint_List,
                                                 m_stageMap.GroundStartPoint_List,
                                                 m_stageMap.GoalPoint_List);
        } // if (0 < m_stageMap.MapTriangle.Count)

        if (0 == m_stageMap.MapTriangle.Count)
        {
            return(resetGlobal_TrianglesAll(naviMesh_active));
        }

        return(true);
    }
    } // void Initialize

    protected bool clearGLOBAL(bool isSkipLoadedData = false)
    {
        try
        {
            //@ Release & Clear Triangle, DrawMesh, Object Dyn
            UnitPool unitpool_ = UnitPool.GetInstance;
            unitpool_.TruncateAll();

            m_intervalUnitWalking.DestructIntervalsAll();
            m_processInput.DestructInput();

            if (false == isSkipLoadedData)
            {
                m_stageMap.Release();
            }

            m_baseTowerCollector.DestructBaseAll();
            m_baseCoreCollector.DestructBaseAll();
            m_baseCoresubCollector.DestructBaseAll();
            m_baseStartCollector.DestructBaseAll();
            m_baseBlockCollector.DestructBaseAll();

            m_toolmoduleNavimesh.ReleaseNaviMeshTool();

            if (null != m_meshNavigation_global)
            {
                m_meshNavigation_global.DestructNaviMesh();
                m_meshNavigation_global = null;
            }

            GC.Collect();

            return(true);
        }
        catch (Exception e)
        {
            Debug.Log(e);
            return(false);
        }
    } // protected void clearGLOBAL()
    } // public bool SetPositionLandDirectly()

    #endregion // #region movement_unitwalking

    #region animationstatus
    protected override void DoAction(float deltaTime)
    {
        if (e_navistate.navistate_stop == _eStateNaviUnitWalking)
        {
            return;
        }

        CNaviMesh meshNavi = getNavimeshcurr();
        if (null == meshNavi)
        {
            //Debug.Log("ERROR! null == meshNavi //" + UnityEngine.Random.Range(0.0f, 1000.0f));
            return;
        }

        switch (m_UnitState)
        {
            case UNIT_STATE.SPAWN:
                break;
            case UNIT_STATE.MOVE:
                {
                    if (true == Update_unitWalking_Movement(deltaTime, meshNavi))
                    {
                        Update_Collision_sameforce(deltaTime, meshNavi, ref m_listCollides);
                    }
                }
                break;
            case UNIT_STATE.ATTACK:
                {
                    //Update_Collision_sameforce(fTimeDeltaProcess, ref m_listCollides);
                    m_AttackTime += deltaTime;
                    //Debug.DrawLine(transform.position, field.FindCoreMocel(m_TargetCoreID).transform.position, new Color(255, 0, 0));
                }
                break;
            case UNIT_STATE.DIE:

                break;
            default:
                break;
        }
    } // protected override void DoAction(float deltaTime)
    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
    //@ Process
    //@ 1.landing position 2.set target dir to object
    public bool SetPositionLandDirectly(CNaviMesh meshNavi)
    {
        Vector3 v3DirDown = Vector3.down;
        Vector3 v3PosCurrent;
        Vector3 v3PosVertical;
        bool bIntersectedWithLanding = false;
        float fAdjust = dist_adjustpos_up;

        v3PosCurrent = positionUnit;
        v3PosVertical = v3PosCurrent + (Vector3.up * fAdjust);

        Ray rayObj = new Ray(v3PosVertical, v3DirDown);

        int iTriLandingCurr = -1;
        RaycastHit raycastHit_info = new RaycastHit();
        bool bCrossoverAdjustedWayto = false;

        bIntersectedWithLanding = meshNavi.GetComponent<Collider>().Raycast(rayObj, out raycastHit_info, dist_raycast_adjust);
        if (false == bIntersectedWithLanding)
        {
            //Debug.Log("ERROR. SetPositionLandDirectly()//not Landing.");
            return false;
        }

        iTriLandingCurr = raycastHit_info.triangleIndex;

        setLandingTri(iTriLandingCurr);
        positionUnit = raycastHit_info.point;

        {
            Vector3 v3PosIntersected = raycastHit_info.point;
            Vector2[] arrv2PntOBJBoundary = boundaryUnit2D();

            if (true == _bMoveShortestSight)
            {
                bCrossoverAdjustedWayto = meshNavi.navigation.getPosWayTo_Portal(iTriLandingCurr, arrv2PntOBJBoundary, ref m_pntWayTo);
            }
            else
            {
                CNAVICELL.E_CELL_STATUS ecellStatus = meshNavi.navigation.getPosCurrentWayToGoal(iTriLandingCurr, ref m_pntWayTo);

                switch (ecellStatus)
                {
                    case CNAVICELL.E_CELL_STATUS.CELL_STATUS_GOAL:
                        {
                            bCrossoverAdjustedWayto = true;

                            reachtheGoal = true;
                        }
                        break;
                    case CNAVICELL.E_CELL_STATUS.CELL_STATUS_BLOCK:
                    case CNAVICELL.E_CELL_STATUS.CELL_STATUS_ROAD:
                        {
                            bCrossoverAdjustedWayto = true;
                        }
                        break;
                    case CNAVICELL.E_CELL_STATUS.CELL_STATUS_NULL:
                    default:
                        {
                            bCrossoverAdjustedWayto = false;
                        }
                        break;
                } // switch (ecellStatus)
            } // if (true == _bMoveShortestSight)

            if (false == bCrossoverAdjustedWayto || (int)CNAVICELL.E_CELL_STATUS.CELL_STATUS_NULL == m_pntWayTo._idxnavicell)
            {
                Debug.Log("Error(critical) set Unit landing.="
                    + (CNAVICELL.E_CELL_STATUS)m_pntWayTo._idxnavicell + "//" + UnityEngine.Random.Range(0.0f, 1000.0f));
                return false;
            }

            //@ Set dir standard
            forwardforMovement = m_pntWayTo._dirEntrytoNext;
            forwardforAngle = m_pntWayTo._dirEntrytoNext;
            positionUnit = v3PosIntersected;
        } // if (false == meshNavi.getCell(iTriLandingCurr).IsBlockCell())

        //@ To slicely adjustment position for rigidbody height.
        //if (rigidbody)
        //{
        //    Vector3 v3PositionAdjust = new Vector3();
        //    v3PositionAdjust = positionUnit;
        //    v3PositionAdjust.y = v3PositionAdjust.y + CMATH.FEPSILON_F3;

        //    positionUnit = v3PositionAdjust;
        //    setPosHeadObj(v3PositionAdjust, Vector3.zero);
        //}


        return bCrossoverAdjustedWayto;
    } // public bool SetPositionLandDirectly()
    } // void Update_Collision_sameforce()

    #endregion // collisionupdateprocess

    //@ Update movement process
    bool Update_unitWalking_Movement(float fTimeDelta, CNaviMesh meshNavi)
    {
        if (true == _bRequestLandDirectly)
        {
            SetPositionLandDirectly(meshNavi);
            _bRequestLandDirectly = false;
        }

        //@1.Forced setting, Cell wasn't prepared go to way to goal.
        if (false == _bProcessWalking_Static)
        {
            return true;
        }

        //@2.No landing mesh.
        if (null == meshNavi)
        {
            Debug.Log("(ERROR. null == meshNavi//Update_objDyn//");

            return false;
        }

        //@3.Current landing triangle is NULL. (== No landing mesh)
        if (CTRI.NULL_TRI == getLandingTri())
        {
            //Vector3 v3PosObj = positionUnit;
            //Debug.Log("(ERROR. NULL_TRI == getLandingTri()//Position(x="
            //    + v3PosObj.x + ")(y="
            //    + v3PosObj.y + ")(z="
            //    + v3PosObj.z + ")//Update_objDyn//");

            return false;
        }

        //@4.Reach GOAL
        if (true == reachtheGoal)
        {
            return true;
        }

        Vector3 v3PosCurrent = positionUnit;
        Vector3 v3PosCurrAdjusted = v3PosCurrent;
        Vector3 v3PosNextAdjusted = v3PosCurrent + (m_pntWayTo._dirEntrytoNext * fTimeDelta * speedmove);

        bool bCrossoverAdjustedWayto = false;

        //@ crossover == true than adjustment positioning.
        {
            int iCountofLevel = m_pntWayTo._ileveltoGoal;
            Vector3 v3PosIntersected = new Vector3();
            CNavigation.CCellWayto pntWayTo_ = new CNavigation.CCellWayto(m_pntWayTo);
            CNAVICELL.E_CELL_STATUS ecellStatus = CNAVICELL.E_CELL_STATUS.CELL_STATUS_NULL;

            //@ penetrate n-cell.
            for (int iterlevel = 0; iterlevel <= iCountofLevel; ++iterlevel)
            {
                if (true == pntWayTo_.crossoverTest(v3PosCurrAdjusted, v3PosNextAdjusted))
                {
                    setLandingTri(pntWayTo_._idxnavicell);
                    if (true == pntWayTo_.IntersectedPosToEdge(v3PosCurrAdjusted, v3PosNextAdjusted, ref v3PosIntersected))
                    {
                        ecellStatus = meshNavi.navigation.getPosNextWayTo(pntWayTo_._idxnavicell, ref pntWayTo_);

                        if (CNAVICELL.E_CELL_STATUS.CELL_STATUS_GOAL == ecellStatus)
                        {
                            v3PosNextAdjusted = v3PosIntersected;
                        }
                        float fRemainder = (v3PosNextAdjusted - v3PosIntersected).magnitude;

                        v3PosNextAdjusted = v3PosIntersected + (pntWayTo_._dirEntrytoNext * fRemainder);

                        v3PosCurrAdjusted = v3PosIntersected;
                        bCrossoverAdjustedWayto = true;
                    }
                    else
                    {
                        ecellStatus = meshNavi.navigation.getPosNextWayTo(pntWayTo_._idxnavicell, ref pntWayTo_);
                    }
                }
                else
                {
                    break;
                }
            } // for (int iterlevel = 0; iterlevel <= iCountofLevel; ++iterlevel)

            if (true == bCrossoverAdjustedWayto)
            {
                m_wayHorizon.renewRatioPerpend(pntWayTo_._dirEntrytoNext,
                                   pntWayTo_._posEdgeFrom0,
                                   pntWayTo_._posEdgeFrom1,
                                   pntWayTo_._ratioPerpen);

                m_pntWayTo = pntWayTo_;
            }

            switch (ecellStatus)
            {
                case CNAVICELL.E_CELL_STATUS.CELL_STATUS_GOAL:
                    {
                        reachtheGoal = true;
                        bCrossoverAdjustedWayto = true;
                    }
                    break;
                case CNAVICELL.E_CELL_STATUS.CELL_STATUS_BLOCK:
                case CNAVICELL.E_CELL_STATUS.CELL_STATUS_ROAD:
                    {
                        bCrossoverAdjustedWayto = true;
                    }
                    break;
            }
        }

        //@ 목표각도 설정.
        if (true == bCrossoverAdjustedWayto)
        {
            Vector3 v3DirAngleTarget = m_pntWayTo._dirEntrytoNext;

            if (true == m_bVerticalInclination)
            {
                forwardforAngleTarget = new Vector3(v3DirAngleTarget.x, 0.0f, v3DirAngleTarget.z);
            }
            else
            {
                forwardforAngleTarget = v3DirAngleTarget;
            }
            forwardforMovement = m_pntWayTo._dirEntrytoNext;

            Vector3 v3PosRatioAdjusted = new Vector3();
            m_wayHorizon.processPosPerpend(fTimeDelta,
                                            m_fratiohorizonRoad,
                                            v3PosNextAdjusted,
                                            ref v3PosRatioAdjusted);


            positionUnit = v3PosRatioAdjusted;
        }
        else
        { //@ position adjusted position, calculaed ratio on way perpendicular
            Vector3 v3PosRatioAdjusted = new Vector3();
            m_wayHorizon.processPosPerpend(fTimeDelta,
                                            m_fratiohorizonRoad,
                                            v3PosCurrent,
                                            ref v3PosRatioAdjusted);

            positionUnit = v3PosRatioAdjusted;
            base.Update_unitDyn(fTimeDelta);
        }

        #region inclination_teritory
        //bool bWayInclination = false;
        //if(false == CMATH.similarEst_float(m_pntWayTo._dirEntrytoNext.y, 0.0f, CMATH.FEPSILON_F2))
        //{
        //    bWayInclination = true;
        //}
        #endregion



        return true;
    } // public void Update_objWalk(float fTimeDelta)
    } // void calculatePosCollision(Vector3 v3DirForceCollide, float fTimeDelta, Vector3 v3PosObject, CNaviMesh meshNavi)

    bool Update_Collision_sameforce(float fTimeDelta, CNaviMesh meshNavi, ref SortedDictionary<int, float> listCollider)
    {
        //@1.Forced setting, Cell wasn't prepared go to way to goal.
        if (false == _bProcessWalking_Static)
        {
            return false;
        }
        //@2.No landing mesh.
        if (null == meshNavi)
        {
            return false;
        }

        UnitPool unitpool = UnitPool.GetInstance;

        //@ 1 more colliders 
        if (listCollider.Count > 0)
        {
            //@ If unit is null, Delete unit from collideList.
            List<UnitWalking> listCollideCollect = new List<UnitWalking>();
            ICollection<int> collectionID = listCollider.Keys;
            List<int> listcollideremove = new List<int>();

            foreach (int idunit in collectionID)
            {
                UnitWalking unitWalking = unitpool[idunit] as UnitWalking;
                if (null == unitWalking)
                {
                    listcollideremove.Add(idunit);
                }
                else
                {
                    if (true == unitWalking.IsUnitDie())
                    {
                        listcollideremove.Add(idunit);
                    }
                    else
                    {
                        float fdistInterEstimate = (unitWalking.m_fRadius_aabb * unitWalking.m_fRadius_aabb + m_fRadius_aabb * m_fRadius_aabb);
                        float fdistInterCurr = (positionUnit - unitWalking.positionUnit).sqrMagnitude;

                        if (fdistInterEstimate > fdistInterCurr)
                        {
                            listCollideCollect.Add(unitWalking);
                        }
                    }
                }
            } // foreach (int idunit in collectionID)

            //@ for safety elimination
            foreach (int idunitremove in listcollideremove)
            {
                listCollider.Remove(idunitremove);
            }

            if (listCollideCollect.Count == 0)
            {
                return false;
            }

            Vector3 v3DirForceCollide = Vector3.zero;
            Vector3 v3PosCurrent = positionUnit, v3PosOther, v3DistanceOther;

            int iCntActualCollide = 0;
            foreach (UnitWalking colliderUnitWalking in listCollideCollect)
            {
                v3PosOther = colliderUnitWalking.positionUnit;
                v3DistanceOther = (positionUnit - v3PosOther).normalized;

                if (colliderUnitWalking.IsUnitAttack())
                {
                    v3DistanceOther = v3DistanceOther.normalized * spdcollision_unit;
                }

                v3DirForceCollide = v3DirForceCollide + v3DistanceOther;
                iCntActualCollide++;
            }

            v3DirForceCollide = v3DirForceCollide.normalized;

            if (Vector3.zero != v3DirForceCollide)
            {
                calculatePosCollision(v3DirForceCollide, fTimeDelta, v3PosCurrent, meshNavi);
            }
        } // if (listCollider.Count > 0)

        return true;
    } // void Update_Collision_sameforce()
    void calculatePosCollision(Vector3 v3DirForceCollide, float fTimeDelta, Vector3 v3PosObject, CNaviMesh meshNavi)
    {
        float speedC_Curr = m_speedCollision * fTimeDelta;
        if (speedC_Curr > m_fRadius_aabb)
        {
            speedC_Curr = m_fRadius_aabb;
        }

        Vector3 dirForceCollide = v3DirForceCollide * (speedC_Curr);
        Vector3 v3PosSimulate = v3PosObject + dirForceCollide;
        Vector3 v3PosUnitIntersected = new Vector3();
        bool naviintersected = intersectNavimesh(meshNavi, v3PosSimulate, ref v3PosUnitIntersected);

        if (true == naviintersected)
        {
            if (false == reachtheGoal)
            {
                positionUnit = m_wayHorizon.processPosPerpend_collision(v3PosObject, dirForceCollide);
            }
            else
            {
                //WORKING
                positionUnit = v3PosUnitIntersected;
            }
        }

    } // void calculatePosCollision(Vector3 v3DirForceCollide, float fTimeDelta, Vector3 v3PosObject, CNaviMesh meshNavi)
 protected void setSplineGuide(int isplineguide, ref CSplineManufacturer.curvesection[] arrLineGuide)
 {
     CNaviMesh navimeshcurr = getNavimeshcurr();
     CSplineManufacturer splinecurveManufacturer = navimeshcurr.splinecurve;
     arrLineGuide = splinecurveManufacturer.getLineGuide(isplineguide);
 }