Пример #1
0
    IEnumerator DoSomething()
    {
        Routine = true;
        yield return(new WaitForSeconds(TimeForNewPath));

        GetNewPath();
        validpath = navMeshAgent.CalculatePath(target, navpath);
        if (!validpath)
        {
            Debug.Log("no path");
            validpath = navMeshAgent.CalculatePath(target, navpath);
        }
        yield return(new WaitForSeconds(RestTime));

        Routine = false;
    }
        //  Calculates the distance of the target to npc.  Compare the return value with sight range.
        public float CalculatePathLength(NavMeshAgent navMeshAgent, Vector3 targetPosition)
        {
            NavMeshPath path = new NavMeshPath();

            if (navMeshAgent.enabled)
            {
                navMeshAgent.CalculatePath(targetPosition, path);
            }

            Vector3[] allWayPoints = new Vector3[path.corners.Length + 2];

            allWayPoints[0] = entity.transform.position;
            allWayPoints[allWayPoints.Length - 1] = targetPosition;

            for (int i = 0; i < path.corners.Length; i++)
            {
                allWayPoints[i + 1] = path.corners[i];
            }

            float pathLength = 0f;

            for (int i = 0; i < allWayPoints.Length - 1; i++)
            {
                pathLength += Vector3.Distance(allWayPoints[i], allWayPoints[i + 1]);
            }

            return(pathLength);
        }
    public void onJump(int id)
    {
        if (5009 == id)
        {//死亡印记
            if (m_linkProfessionRole.m_LockRole != null)
            {
                NavMeshPath  path = new NavMeshPath();
                NavMeshAgent nav  = transform.GetComponent <NavMeshAgent>();
                Vector3      pos  = transform.position;

                int i = 2;
                for (; i <= 2 && i >= 0; i--)
                {
                    Vector3 endPos = m_linkProfessionRole.m_LockRole.m_curModel.position + transform.forward * i;
                    if (nav.CalculatePath(endPos, path))
                    {
                        float dis = Vector3.Distance(pos, endPos);
                        transform.DOJump(endPos, 0.2f * dis + endPos.y, 1, 0.01f);
                        break;
                    }
                }
                GameObject inst = GameObject.Instantiate(ASSASSIN_S1) as GameObject;
                inst.transform.SetParent(m_linkProfessionRole.m_LockRole.m_curModel, false);

                GameObject.Destroy(inst, 3f);
            }
        }
        m_linkProfessionRole.ShowAll();
    }
    IEnumerator ReserveSpawn()
    {
        _reserveCount++;
        yield return(new WaitForSeconds(Random.Range(0, _spawnTime)));

        GameObject obj = Managers.Game.Spawn(Define.WorldObject.Monster, monsterName);

        Vector3      randPos;
        NavMeshAgent nma = obj.GetOrAddComponent <NavMeshAgent>();

        while (true)
        {
            Vector3 randDir = Random.insideUnitSphere * Random.Range(0, _spawnRadius);
            randDir.y = 0;
            randPos   = _spawnPos + randDir;

            NavMeshPath path = new NavMeshPath();
            if (nma.CalculatePath(randPos, path))
            {
                break;
            }
        }

        obj.transform.position = randPos;
        _reserveCount--;
    }
Пример #5
0
    private bool IsAltarReachable()
    {
        NavMeshPath _tryPath = new NavMeshPath();

        _agent.CalculatePath(_altar.transform.position, _tryPath);
        float _pathDistance = 0;

        for (int i = 0; i < _tryPath.corners.Length; i++)
        {
            if (i + 1 < _tryPath.corners.Length)
            {
                _pathDistance += Vector3.Distance(_tryPath.corners[i], _tryPath.corners[i + 1]);
            }
        }


        if (_tryPath.status == NavMeshPathStatus.PathPartial)
        {
            return(false);
        }
        else if (_tryPath.status == NavMeshPathStatus.PathComplete && _pathDistance <= _maxDistance)
        {
            return(true);
        }

        else
        {
            return(false);
        }
    }
    /// <summary>
    /// Generates the random positions and checks if they are validly placed on the navmesh
    /// </summary>
    /// <param name="a_iAmountOfPoints">The amount of patrol points</param>
    /// <param name="a_fRange">The range the points can be generated away from the center point</param>
    private void GeneratePositions(int a_iAmountOfPoints, float a_fRange)
    {
        for (int i = 0; i < a_iAmountOfPoints; i++)                                                                     //Loop through the points
        {
            PatrolPoints ppPatrolPlaceholder = new PatrolPoints();                                                      //Temporary placeholder to add later
            bool         bCanReachTarget     = false;                                                                   //Can the point actually be reached
            while (bCanReachTarget == false)                                                                            //Loop until point is valid
            {
                ppPatrolPlaceholder.SetRandomPos(m_v3PatrolCenter, a_fRange);                                           //Get random position

                NavMeshPath nmpPath = new NavMeshPath();                                                                //Create new nav path
                m_aAgentRef.CalculatePath(ppPatrolPlaceholder.m_v3PatrolPointPosition, nmpPath);                        //

                if (nmpPath.status == NavMeshPathStatus.PathPartial || nmpPath.status == NavMeshPathStatus.PathInvalid) //If path is not valid
                {
                    Debug.Log("Bad Point");
                }
                else
                {
                    bCanReachTarget = true;
                }
            }
            ppPatrolPlaceholder.m_iIndex = i;            //Set index of point
            m_lPatrolPointList.Add(ppPatrolPlaceholder); //Add it to list
        }
    }
Пример #7
0
    IEnumerator NavTargetUpdate()
    {
        yield return(new WaitForSeconds(1.0f));

        while (true)
        {
            NavMeshPath path = new NavMeshPath();
            nav.CalculatePath(playerPos.position, path);
            if (path.status == NavMeshPathStatus.PathComplete)
            {
                if (!playerSpotted)
                {
                    yield return(new WaitForSeconds(Random.Range(0.0f, 0.5f)));

                    anim.SetTrigger("PlayerSpotted");
                    playerSpotted = true;
                    spotDelay     = 2.8f;
                }
                if (spotDelay <= 0)
                {
                    nav.SetPath(path);
                }
            }

            yield return(new WaitForSeconds(navTargetRefreshDelay));
        }
    }
Пример #8
0
    public IEnumerator wander()
    {


        Vector3 newPos = RandomNavmeshLocation(wanderRadius); // gets random point on navmesh
        while (true)
        {
            NavMeshPath path = new NavMeshPath();
            navMeshAgent.CalculatePath(newPos, path);
            if (path.status != NavMeshPathStatus.PathComplete) // checks to make sure that a path can be calcultaed with given random point
            {
                Debug.Log("Invalid path");
                newPos = NavMeshUtils.RandomNavSphere(transform.position, wanderRadius, -1);
            }
            else
            {
                break;

            }
           
        }
        AICurrentTargetLocation = newPos;

        navMeshAgent.SetDestination(newPos);
        yield return new WaitUntil(() => Vector3.Distance(gameObject.transform.position, newPos) <= 0.25f);
        wanderCoroutine = null;

    }
Пример #9
0
        public bool IsReachable(NavMeshAgent nmAgent, float radiusA, float radiusB)
        {
            if (this._pathForCalc == null)
            {
                this._pathForCalc = new NavMeshPath();
            }
            bool flag1 = true;
            bool flag2;

            if (((Behaviour)nmAgent).get_isActiveAndEnabled())
            {
                nmAgent.CalculatePath(this.Position, this._pathForCalc);
                flag2 = flag1 & this._pathForCalc.get_status() == 0;
                float     num1    = 0.0f;
                Vector3[] corners = this._pathForCalc.get_corners();
                for (int index = 0; index < corners.Length - 1; ++index)
                {
                    float num2 = Vector3.Distance(corners[index], corners[index + 1]);
                    num1 += num2;
                    float num3 = this.CommandType != CommandType.Forward ? radiusB : radiusA;
                    if ((double)num1 > (double)num3)
                    {
                        flag2 = false;
                        break;
                    }
                }
            }
            else
            {
                flag2 = false;
            }
            return(flag2);
        }
Пример #10
0
    void ChaseTarget()
    {
        // Do not chase if currently attacking
        if (currentlyAttacking || blocking || takingDamage)
        {
            return;
        }

        // Walk towards target
        walking = true;

        // Find closest point on navmesh from the player controllers center, check if it is reachable
        NavMeshHit  hit;
        NavMeshPath path = new NavMeshPath();

        if (NavMesh.SamplePosition(playerPos, out hit, 2f, NavMesh.AllAreas))
        {
            agent.CalculatePath(hit.position, path);
            if (path.status == NavMeshPathStatus.PathComplete)
            {
                agent.SetDestination(hit.position);
            }
            else
            {
                OutOfReach();
            }
        }
        else
        {
            OutOfReach();
        }
    }
    void Fleeing()
    {
        //If the smoke grenade does not exist anymore
        if (go_SmokeAOE == null)
        {
            //Sets the ReturnToPost state
            SetNewState("ReturnToPost");
        }
        else if (!SmokeGrenadeSeen)             //If the smoke grenade hasn't been seen
        {
            //Calculate the distance between itself and the smoke grenade while ignoring the Y position
            float Distance = Vector3.Distance(new Vector3(transform.position.x, 1f, transform.position.z), new Vector3(go_SmokeAOE.transform.position.x, 1f, go_SmokeAOE.transform.position.z));

            //If the distance is less than the maximum fleeing distance
            if (Distance < fl_NPC_FleeingDist)
            {
                //Calculate the direction between itself and the smoke grenade while ignoring the Y position
                Vector3 Direction = new Vector3(transform.position.x, 1f, transform.position.z) - new Vector3(go_SmokeAOE.transform.position.x, 1f, go_SmokeAOE.transform.position.z);

                //Calculate the new position
                Vector3 NewPosition = new Vector3(transform.position.x, 1f, transform.position.z) + Direction;

                //Set the target position to the new position
                v3_NPC_TargetPos = NewPosition;
            }
            //Create local variable for setting a new path
            NavMeshPath NewPath = new NavMeshPath();

            //Calculate a path for the target position and store it in a variable
            nm_Agent.CalculatePath(v3_NPC_TargetPos, NewPath);

            //Replace the current path as the stored path
            nm_Agent.path = NewPath;
        }
    }
Пример #12
0
    // Update is called once per frame
    void Update()
    {
        UnityEngine.Collider[] col = Physics.OverlapSphere(transform.position, 10f);

        if (col.Length > 0)
        {
            for (int i = 0; i < col.Length; i++)
            {
                Transform tf_Target = col[i].transform;

                if (tf_Target.name == "Player")
                {
                    NavMeshPath path = new NavMeshPath();
                    agent.CalculatePath(tf_Target.position, path);

                    Vector3[] wayPoints = new Vector3[path.corners.Length + 2];
                    wayPoints[0] = transform.position;
                    wayPoints[wayPoints.Length - 1] = tf_Target.position;

                    float _distance = 0f;
                    for (int j = 0; j < path.corners.Length; j++)
                    {
                        wayPoints[j + 1] = path.corners[j];
                        _distance       += Vector3.Distance(wayPoints[j], wayPoints[j + 1]);
                    }

                    if (_distance <= 10f)
                    {
                        agent.SetDestination(tf_Target.position);
                    }
                }
            }
        }
    }
Пример #13
0
    public override void OnBehaviourPlay(Playable playable, FrameData info)
    {
        NavMeshPath path = new NavMeshPath();

        meshAgent.CalculatePath(destination.position, path);
        if (path.corners.Length < 2)
        {
            return;
        }

        Vector3 previousCorner = path.corners[0];
        float   lengthSoFar    = 0.0f;
        int     i = 1;

        while (i < path.corners.Length)
        {
            Vector3 currentCorner = path.corners[i];
            lengthSoFar   += Vector3.Distance(previousCorner, currentCorner);
            previousCorner = currentCorner;
            i++;
        }
        double navTime = lengthSoFar / meshAgent.speed;

        Debug.Log("NavTime: " + navTime);
    }
Пример #14
0
    private void NavAgentPath()
    {//导航路径 整合
        NavMeshPath path = new NavMeshPath();

        navAgent.CalculatePath(targetPos, path);
        way = new Vector3[path.corners.Length];
        for (int i = 0; i < path.corners.Length; i++)
        {
            way[i] = path.corners[i];//将用导航网格获得的路径关键点,添加到这个数组中
        }//那么此时way这个数组中包含的就是从这个机器人当前位置 到目的位置 所要经过的所有关键点
         //那么接下来 机器人导航按照上面所说的路径来
         //先计算这个路径的总长度。用来判断是否到达目的地的关键要素
        length = 0;
        for (int i = 0; i < way.Length - 1; i++)
        {
            length += (way[i + 1] - way[i]).magnitude;//计算两点之间的长度
        }
        //for(int i = 0; i < way.Length; i++)
        //{
        //    print(way[i]);
        //}
        //l++;
        //print("way数组的长度" + way.Length);
        //print("遍历完"+l);
    }
Пример #15
0
    //Move around player Function
    void CheckCover()
    {
        Debug.Log("funciona!");
        float minDistance = 1000;
        float HidingSpotDistance;
        float playerToHideDistance;

        for (int i = 0; i < hidingPoints.Length; i++)
        {
            HidingSpotDistance   = Vector3.Distance(transform.position, hidingPoints [i].transform.position);
            playerToHideDistance = Vector3.Distance(playerPos.position, hidingPoints [i].transform.position);
            if (HidingSpotDistance < minDistance && HidingSpotDistance > stopHidingRange && HidingSpotDistance < playerToHideDistance)
            {
                hideSpotPos = hidingPoints [i].transform.position;
                minDistance = Vector3.Distance(transform.position, hidingPoints [i].transform.position);
            }
        }
        if (minDistance < 1000)
        {
            bool        checkpath;
            NavMeshPath myPath = new NavMeshPath();
            checkpath = myNav.CalculatePath(hideSpotPos, myPath);
            if (myPath.status == NavMeshPathStatus.PathComplete)
            {
                StartGetCover();
            }
        }
    }
Пример #16
0
    /// <summary>
    /// Calculate the path to player using nav path
    /// </summary>
    /// <param name="targetPos"></param>
    /// <returns></returns>
    private float PathLength(Vector3 targetPos)
    {
        NavMeshPath path = new NavMeshPath();

        if (nav.enabled)
        {
            nav.CalculatePath(targetPos, path);
        }

        Vector3[] allWayPoints = new Vector3[path.corners.Length + 2];
        allWayPoints[0] = npcT.position;
        allWayPoints[allWayPoints.Length - 1] = targetPos;

        for (int i = 0; i < path.corners.Length; i++)
        {
            allWayPoints[i + 1] = path.corners[i];
        }

        float pathLength = 0;

        for (int i = 0; i < allWayPoints.Length - 1; i++)
        {
            pathLength += Vector3.Distance(allWayPoints[i], allWayPoints[i + 1]);
        }

        return(pathLength);
    }
Пример #17
0
    GameObject GetRetreatRedBase(BluePoliceSim threat)
    {
        GameObject selectedRedBase = simControlScript.RedBases[0];
        float      minRangeRatio   = float.MaxValue;

        foreach (GameObject redBase in simControlScript.RedBases)
        {
            NavMeshPath thisPath = new NavMeshPath();
            if (thisNavAgent.CalculatePath(redBase.transform.position, thisPath))
            {
                float thisLength  = PathLength(thisPath);
                float threatRange = threat.GetRangeTo(redBase);
                if (threatRange > 0f)
                {
                    float thisRatio = thisLength / threatRange;
                    if (thisRatio < minRangeRatio)
                    {
                        minRangeRatio   = thisRatio;
                        selectedRedBase = redBase;
                    }
                }
            }
        }
        return(selectedRedBase);
    }
Пример #18
0
    IEnumerator ReserveSpawn()
    {
        ++_reserveCount;

        yield return(new WaitForSeconds(UnityEngine.Random.Range(0, _spawnTime)));

        GameObject Obj = Managers.Game.Spawn(Define.eWorldObject.Monster, "Knight");

        NavMeshAgent nma = Obj.GetComponent <NavMeshAgent>();

        Vector3 randPos;

        while (true)
        {
            Vector3 randDir = Random.insideUnitSphere * Random.Range(0, _SpawnRadius);
            randPos.y = 0;
            randPos   = _SpawnPosition + randDir;

            // 갈 수 있나
            NavMeshPath path = new NavMeshPath();
            if (nma.CalculatePath(randPos, path))
            {
                break;
            }
        }

        Obj.transform.position = randPos;
        --_reserveCount;
    }
Пример #19
0
    public NullableVector3 FindCover(Transform attacker, NavMeshAgent na, float coverCheckRadius, int numberOfChecks, LayerMask coverCriteria)
    {
        NullableVector3 cover     = null;
        NavMeshPath     coverPath = null;

        for (int i = 0; i < numberOfChecks; i++)
        {
            // Obtains a random position within a certain vicinity of the agent
            Vector3    randomPosition = ai.transform.position + Random.insideUnitSphere * coverCheckRadius;
            NavMeshHit coverCheck;
            // Checks if there is an actual point on the navmesh close to the randomly selected position
            if (NavMesh.SamplePosition(randomPosition, out coverCheck, na.height * 2, NavMesh.AllAreas))
            {
                if (AIFunction.LineOfSight(coverCheck.position, attacker, coverCriteria) == false) // If line of sight is not established
                {
                    // Ensures that the agent can actually move to the cover position.
                    NavMeshPath newPathToTest = new NavMeshPath();
                    if (na.CalculatePath(coverCheck.position, newPathToTest))
                    {
                        // Checks if the new cover position is easier to get to than the old one.
                        if (cover == null || AIFunction.NavMeshPathLength(newPathToTest) < AIFunction.NavMeshPathLength(coverPath)) // Use OR statement, and check navmesh path cost between transform.position and the cover point currently being checked.
                        {
                            // If so, new cover position is established, and navmesh path is stored for next comparison
                            cover     = new NullableVector3(coverCheck.position);
                            coverPath = newPathToTest;
                        }
                    }
                }
            }
        }

        return(cover);
    }
Пример #20
0
    public float AgentWalkDistance(Vector3 start, Vector3 end, Color color)
    {
        //move agent to the start position
        Vector3 initialPosition = transform.position;

        _agent.Move(start - initialPosition);

        //test to see if agent has path or not
        float       distance    = Mathf.Infinity;
        NavMeshPath navMeshPath = _agent.path;

        if (!_agent.CalculatePath(end, navMeshPath))
        {
            _agent.Move(initialPosition - start); return(distance);
        }
        Vector3[] path = navMeshPath.corners;
        if (path.Length < 2)
        {
            _agent.Move(initialPosition - start); return(distance);
        }

        //get walking path distance
        distance = 0;
        for (int i = 1; i < path.Length; i++)
        {
            distance += Vector3.Distance(path[i - 1], path[i]);
            Debug.DrawLine(path[i - 1], path[i], color); //visualizing the path, not necessary to return
        }

        _agent.Move(initialPosition - start);
        return(distance);
    }
    public void CalculatePathAndMoveAgent()
    {
        agent = GetComponent <NavMeshAgent>();
        agent.CalculatePath(finishPoint.transform.position, path);

        if (path.status == NavMeshPathStatus.PathComplete)
        {
            agent.SetDestination(finishPoint.transform.position);
        }
        else if (path.status == NavMeshPathStatus.PathInvalid)
        {
            print("Path invalid");
        }
        else if (path.status == NavMeshPathStatus.PathPartial)
        {
            print("Path partial (GETTING BLOCKED)");
            fntScript = GetComponent <FindNearestTurret>();

            if (fntScript.target == null)
            {
                agent.SetDestination(finishPoint.transform.position);
            }
            else
            {
                Destroy(fntScript.target.gameObject);
            }
        }
    }
Пример #22
0
    public static float WalkDistance(Vector3 to, NavMeshAgent usedAgent)
    {
        NavMeshPath path = new NavMeshPath();

        usedAgent.CalculatePath(to, path);
        return(CalcPathDistance(path));
    }
Пример #23
0
    public void DetectNewObstacle(Vector3 obstaclePos)
    {
        //print ("method get called");

        //print (Vector3.Distance (obstaclePos, transform.position));

        if (Vector3.Distance(obstaclePos, this.transform.position) < detectRadius)
        {
            print("flee obj");

            Vector3 fleeDirection = (transform.position - obstaclePos).normalized;
            Vector3 newGoal       = this.transform.position + fleeDirection * fleeRadius;

            // creating a path must make sure the environment is baked
            NavMeshPath path = new NavMeshPath();
            agent.CalculatePath(newGoal, path);

            if (path.status == NavMeshPathStatus.PathInvalid)
            {
                Debug.Log("Invalid Path");
            }
            // path is not invalid then flee mother f****r
            if (path.status != NavMeshPathStatus.PathInvalid)
            {
                //Debug.Log (path.corners[0]);

                agent.SetDestination(path.corners[path.corners.Length - 1]);
                agent.speed        = 20f;
                agent.angularSpeed = 500f;

                print("fleeing");
            }
        }
    }
Пример #24
0
    IEnumerator shootAndKill()
    {
        RaycastHit rh2;

        Debug.Log("preshot");
        float gaa = Vector3.Distance(this.transform.position, target.position);

        Physics.Raycast(this.transform.position, target.position - this.transform.position, out rh2);
        Debug.DrawRay(this.transform.position + new Vector3(0, 2, 0), target.position - this.transform.position, Color.blue);
        Debug.Log("preshot2");
        if ((rh2.transform.gameObject.tag == "Statute" || rh2.transform.gameObject.tag == "Player" || rh2.transform.gameObject.tag == "gate") && gaa < range)
        {
            Debug.Log("wszedl do shotu");
            anim.SetInteger("controller", 2);
            nma.isStopped = true;
            Rigidbody tmp = Instantiate(rb, transsexualista.position, transsexualista.rotation);
            tmp.gameObject.GetComponent <Rigidbody>().AddForce(this.transform.forward * shootforce, ForceMode.Impulse);
            yield return(new WaitForSeconds(tor));

            StartCoroutine(shootAndKill());
            Debug.Log("postshot");
        }
        else
        {
            Debug.Log("nie wszedl do shotu");
            anim.SetInteger("controller", 1);
            Debug.Log(target.name);
            nma.CalculatePath(target.position, nmp);
            nma.path = nmp;
            yield return(new WaitForSeconds(tor));

            StartCoroutine(shootAndKill());
            Debug.Log("postnoshot");
        }
    }
Пример #25
0
    public void SetDestination(Vector3 destination)
    {
        //if(!canComputePath) return;

        NavMeshHit hit;

        if (!NavMesh.SamplePosition(destination, out hit, 30, NavMesh.AllAreas))
        {
            Debug.LogWarning("Creature Die Because off of navmesh");
            owner.Creature.Die();
            return;
        }
        destination = hit.position;

        Destination = destination;

        if (!nav.isOnNavMesh)
        {
            Debug.LogWarning("Creature Die Because off of navmesh");
            owner.Creature.Die();
            return;
        }

        nav.CalculatePath(Destination, computingPath);

        //owner.StartCoroutine(WaitAndCanComputePath());
    }
Пример #26
0
    void Update()
    {
        SetAgentPosition();
        if (Input.GetMouseButtonDown(0) && !Input.GetKey(KeyCode.LeftShift))
        {
            var ray = Camera.main.ScreenPointToRay(Input.mousePosition);
            if (Physics.Raycast(ray.origin, ray.direction, out m_HitInfo))
            {
                //m_Agent.destination = m_HitInfo.point;
                m_Path         = new NavMeshPath();
                endDestination = m_HitInfo.point;
                m_Agent.CalculatePath(endDestination, m_Path);
                pathIter          = 1;
                m_Agent.isStopped = false;
            }
        }

        if (m_Path.corners == null || m_Path.corners.Length == 0)
        {
            return;
        }


        if (pathIter >= m_Path.corners.Length)
        {
            destination       = new Vector3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity);
            m_Agent.isStopped = true;
            return;
        }
        else
        {
            destination = m_Path.corners[pathIter];
        }

        if (destination.x < float.PositiveInfinity)
        {
            Vector3 direction = destination - AgentPosition;
            var     newDir    = Vector3.RotateTowards(transform.forward, direction, 50 * Time.deltaTime, 0.0f);
            var     newRot    = Quaternion.LookRotation(newDir);
            transform.rotation = Quaternion.Slerp(transform.rotation, newRot, Time.deltaTime * 2f);

            float distance = Vector3.Distance(AgentPosition, destination);

            if (distance > m_Agent.radius + 0.1)
            {
                Vector3 movement = transform.forward * Time.deltaTime * 2f;

                m_Agent.Move(movement);
            }
            else
            {
                ++pathIter;
                if (pathIter >= m_Path.corners.Length)
                {
                    destination       = new Vector3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity);
                    m_Agent.isStopped = true;
                }
            }
        }
    }
    public bool CanReachPosition(Vector3 position)
    {
        NavMeshPath path = new NavMeshPath();

        navMeshAgent.CalculatePath(position, path);
        return(path.status == NavMeshPathStatus.PathComplete);
    }
Пример #28
0
    //소리가 이동하는 총 거리를 계산합니다.
    float CalculatePathLength(Vector3 targetPosition)
    {
        NavMeshPath path = new NavMeshPath();

        if (nav.enabled)
        {
            nav.CalculatePath(targetPosition, path);
        }

        //각 코너를 저장합니다.
        Vector3[] allWayPoints = new Vector3[path.corners.Length + 2];

        //처음과 끝은 플레이어와 NPC의 위치
        allWayPoints[0] = transform.position;
        allWayPoints[allWayPoints.Length - 1] = targetPosition;


        for (int i = 0; i < path.corners.Length; i++)
        {
            allWayPoints[i + 1] = path.corners[i];
        }

        float pathLength = 0f;

        //거리를 더합니다
        for (int i = 0; i < allWayPoints.Length - 1; i++)
        {
            pathLength += Vector3.Distance(allWayPoints[i], allWayPoints[i + 1]);
        }

        return(pathLength);
    }
Пример #29
0
        void MoveCheck(Ray screenRay)
        {
            if (m_CalculatedPath.status == NavMeshPathStatus.PathComplete)
            {
                m_Agent.SetPath(m_CalculatedPath);
                m_CalculatedPath.ClearCorners();
            }

            if (Physics.RaycastNonAlloc(screenRay, m_RaycastHitCache, 1000.0f, m_LevelLayer) > 0)
            {
                Vector3 point = m_RaycastHitCache[0].point;
                //avoid recomputing path for close enough click
                if (Vector3.SqrMagnitude(point - m_LastRaycastResult) > 1.0f)
                {
                    NavMeshHit hit;
                    if (NavMesh.SamplePosition(point, out hit, 0.5f, NavMesh.AllAreas))
                    {//sample just around where we hit, avoid setting destination outside of navmesh (ie. on building)
                        m_LastRaycastResult = point;
                        //m_Agent.SetDestination(hit.position);

                        m_Agent.CalculatePath(hit.position, m_CalculatedPath);
                    }
                }
            }
        }
Пример #30
0
    public static float CalculatePathLength(Vector3 targetPosition, Vector3 originalPosition, GameObject originalObject)
    {
        NavMeshPath  path = new NavMeshPath();
        NavMeshAgent nav  = originalObject.GetComponent <NavMeshAgent>();

        if (nav.enabled)
        {
            nav.CalculatePath(targetPosition, path);
        }
        Vector3[] allWayPoints = new Vector3[path.corners.Length + 2];

        allWayPoints[0] = originalPosition;
        allWayPoints[allWayPoints.Length - 1] = targetPosition;

        for (int i = 0; i < path.corners.Length; i++)
        {
            allWayPoints[i + 1] = path.corners[i];
        }

        float pathLength = 0f;

        for (int i = 0; i < allWayPoints.Length - 1; i++)
        {
            pathLength += Vector3.Distance(allWayPoints[i], allWayPoints[i + 1]);
        }

        return(pathLength / 2);
    }