Beispiel #1
0
        private void Dodge(FightingObjectView attackTarget, Evade evadeMethod)
        {
            Vector3 movePosition;

            switch (evadeMethod)
            {
            case Evade.Behind:
                movePosition = (attackTarget.transform.position - attackTarget.transform.forward * 3);
                _player.RequestMove(movePosition);
                break;

            case Evade.Left:
                movePosition = (attackTarget.transform.position - attackTarget.transform.right * 3);
                _player.RequestMove(movePosition);
                break;

            case Evade.Defensive:
                // Not implemented yet.
                break;

            case Evade.Tank:
            default:
                break;
            }
        }
        public void Continue()
        {
            switch (_state.State)
            {
            case State.Start:
            {
                if (_path.Count > 0)
                {
                    _state.Fire(Trigger.ApprachTarget);
                }
                else
                {
                    _state.Fire(Trigger.ReachedTarget);
                }

                break;
            }

            case State.Running:
            {
                var currentNode     = _path[0];
                var minimumDistance = 3f;

                if (_path.Count < 2 && _useCollider)
                {
                    minimumDistance = _target.GetColliderExtents() + _player.GetColliderExtents();

                    var directionToPlayer = (_player.transform.position - _target.transform.position).normalized;
                    var bufferDistance    = directionToPlayer * minimumDistance;

                    currentNode = _target.transform.position + bufferDistance;
                }

                var distanceToNode = (_player.transform.position - currentNode).sqrMagnitude;

                if (distanceToNode < minimumDistance)
                {
                    _path.RemoveAt(0);
                }
                else
                {
                    _player.RequestMove(currentNode);
                }

                if (_path.Count > 0)
                {
                    break;
                }

                _state.Fire(Trigger.ReachedTarget);
                break;
            }
            }
        }
 public static bool RequestMove(this LocalPlayerCharacterView view, Vector3 position) => view.RequestMove(position.c());
Beispiel #4
0
        public void Continue()
        {
            switch (_state.State)
            {
            case State.Start:
            {
                if (_path.Count > 0)
                {
                    _state.Fire(Trigger.ApproachTarget);
                }
                else
                {
                    _state.Fire(Trigger.ReachedTarget);
                }

                break;
            }

            case State.Running:
            {
                //Early exit if player is null.
                if (_player == null)
                {
                    _state.Fire(Trigger.ReachedTarget);
                    break;
                }

                var currentNode     = _path[0];
                var minimumDistance = 3f;

                if (_path.Count < 2 && _useCollider)
                {
                    minimumDistance = _player.GetColliderExtents();

                    var directionToPlayer = (_player.transform.position - _target).normalized;
                    var bufferDistance    = directionToPlayer * minimumDistance;

                    currentNode = _target + bufferDistance;
                }

                var playerPosV2   = new Vector2(_player.transform.position.x, _player.transform.position.z);
                var currentNodeV2 = new Vector2(currentNode.x, currentNode.z);

                var distanceToNode = (playerPosV2 - currentNodeV2).sqrMagnitude;

                if (distanceToNode < minimumDistance)
                {
                    _path.RemoveAt(0);
                }
                else
                {
                    _player.RequestMove(currentNode);
                }

                if (_path.Count > 0)
                {
                    break;
                }

                _state.Fire(Trigger.ReachedTarget);
                break;
            }
            }
        }
 public static bool RequestMove(this LocalPlayerCharacterView instance, Vector3 position)
 {
     return(instance.RequestMove(position.c()));
 }
Beispiel #6
0
        public void Continue()
        {
            switch (_state.State)
            {
            case State.Pause:
            {
                var previousNode           = _completedpath[_completedpath.Count - 1];
                var playerPosV2            = new Vector2(_player.transform.position.x, _player.transform.position.z);
                var previousNodeV2         = new Vector2(previousNode.x, previousNode.z);
                var target2D               = new Vector2(_target.x, _target.z);
                var distanceToTarget       = Vector2.Distance(playerPosV2, target2D);
                var distancePreviousToNode = (playerPosV2 - previousNodeV2).sqrMagnitude;
                var minimumDistance        = 2f;
                _landscape = _client.GetLandscapeManager();

                Core.Log("Paused");
                if (DateTime.Now < _notMovingTimer)
                {
                    Core.Log("Checking for movement restart");
                    isMovingUpdate();
                    if (IsMoving)
                    {
                        Core.Log("MOVING AGAIN");
                        _state.Fire(Trigger.ApproachTarget);
                        break;
                    }

                    break;
                }

                if (distanceToTarget < 40 && _allowMinDistCheck)
                {
                    Core.Log($"The target {target2D} is {distanceToTarget} from this position {playerPosV2}");
                    Core.Log("@ target");
                    _state.Fire(Trigger.ReachedTarget);
                    break;
                }



                if (DateTime.Now > _pauseTimer)
                {
                    _state.Fire(Trigger.ReachedTarget);
                    break;
                }



                if (_completedpath.Count < 1)
                {
                    Vector3 randomSpot = new Vector3(UnityEngine.Random.Range(-100f, 100f), 0, UnityEngine.Random.Range(-100f, 100f)) + _player.transform.position;
                    _completedpath.Add(randomSpot);
                    break;
                }

                if (_path.Count < 2)
                {
                    _player.RequestMove(_player.transform.position + new Vector3(UnityEngine.Random.Range(-100f, 100f), 0, UnityEngine.Random.Range(-100f, 100f)));
                }


                if (distancePreviousToNode < minimumDistance)
                {
                    if (_player.TryFindPath(new ClusterPathfinder(), _target, IsBlockedWithExitCheck, out List <Vector3> pathing))
                    {
                        Core.Log("Reached Previous Node and found path");

                        _path = pathing;
                        _state.Fire(Trigger.Restart);
                        break;
                    }
                    else
                    {
                        Core.Log("Reached Previous Node and didnt find path. Moving to next previous node");
                        _completedpath.RemoveAt(_completedpath.Count - 1);

                        _pauseTimer = DateTime.Now + TimeSpan.FromSeconds(15);
                    }
                }
                else
                {
                    _player.RequestMove(previousNode);
                }



                break;
            }

            case State.Start:
            {
                Core.Log($"Position pathing request path count {_path.Count}");
                if (_path.Count > 0)
                {
                    _state.Fire(Trigger.ApproachTarget);
                }
                else
                {
                    _state.Fire(Trigger.ReachedTarget);
                }

                break;
            }

            case State.Running:
            {
                //Early exit if player is null.
                if (_player == null)
                {
                    _state.Fire(Trigger.ReachedTarget);
                    break;
                }

                isMovingUpdate();
                // Core.Log($"Position pathing request is Moving {IsMoving} at { _player.transform.position}");
                if (!IsMoving)
                {
                    _notMovingTimer = DateTime.Now + TimeSpan.FromSeconds(1.5);
                    _pauseTimer     = DateTime.Now + TimeSpan.FromSeconds(15);
                    Core.Log($"Stuck Position Pathing Request During Running. State is {_state}");
                    _state.Fire(Trigger.Stuck);
                    Core.Log($"Position Pathing Request During Running 2. State is {_state}");
                }


                var currentNode     = _path[0];
                var minimumDistance = 3f;

                if (_path.Count < 2 && _useCollider)
                {
                    minimumDistance = _player.GetColliderExtents();

                    var directionToPlayer = (_player.transform.position - _target).normalized;
                    var bufferDistance    = directionToPlayer * minimumDistance;

                    currentNode = _target + bufferDistance;
                }

                var playerPosV2   = new Vector2(_player.transform.position.x, _player.transform.position.z);
                var currentNodeV2 = new Vector2(currentNode.x, currentNode.z);

                var distanceToNode = (playerPosV2 - currentNodeV2).sqrMagnitude;

                if (distanceToNode < minimumDistance)
                {
                    _completedpath.Add(_path[0]);
                    _path.RemoveAt(0);
                }
                else
                {
                    _player.RequestMove(currentNode);
                }

                if (_path.Count > 0)
                {
                    break;
                }

                _state.Fire(Trigger.ReachedTarget);
                break;
            }
            }
        }
Beispiel #7
0
        public void Continue()
        {
            switch (_state.State)
            {
            case State.Pause:
            {
                if (DateTime.Now > _pauseTimer)
                {
                    _state.Fire(Trigger.ReachedTarget);
                }


                if (_completedpath.Count < 2)
                {
                    //Core.Log("moving to random Location");
                    Vector3 randomSpot = new Vector3(UnityEngine.Random.Range(-100f, 100f), 0, UnityEngine.Random.Range(-100f, 100f)) + _player.transform.position;
                    _completedpath.Add(randomSpot);
                    break;
                }
                var previousNode   = _completedpath[_completedpath.Count - 1];
                var playerPosV2    = new Vector2(_player.transform.position.x, _player.transform.position.z);
                var previousNodeV2 = new Vector2(previousNode.x, previousNode.z);

                var distancePreviousToNode = (playerPosV2 - previousNodeV2).sqrMagnitude;
                var minimumDistance        = 1f;

                if (distancePreviousToNode < minimumDistance)
                {
                    //Core.Log("Reached Previous Node");
                }
                else
                {
                    _player.RequestMove(previousNode);
                }

                break;
            }

            case State.Start:
            {
                if (_path.Count > 0)
                {
                    _state.Fire(Trigger.ApproachTarget);
                }
                else
                {
                    _state.Fire(Trigger.ReachedTarget);
                }

                break;
            }

            case State.Running:
            {
                //Early exit if one of them is null.
                if (_player == null || _target == null)
                {
                    _state.Fire(Trigger.ReachedTarget);
                    break;
                }
                isMovingUpdate();
                //Core.Log($"Cluster Pathing Request. Player at {_player.transform.position}. Player is move {IsMoving}");

                if (!IsMoving)
                {
                    _state.Fire(Trigger.Stuck);
                    _pauseTimer = DateTime.Now + TimeSpan.FromSeconds(0.5);
                    //Core.Log("Stuck Cluster Pathing Request");
                    break;
                }
                var currentNode     = _path[0];
                var minimumDistance = 3f;

                if (_path.Count < 2 && _useCollider)
                {
                    minimumDistance = _target.GetColliderExtents() + _player.GetColliderExtents();

                    var directionToPlayer = (_player.transform.position - _target.transform.position).normalized;
                    var bufferDistance    = directionToPlayer * minimumDistance;

                    currentNode = _target.transform.position + bufferDistance;
                }

                var distanceToNode = (_player.transform.position - currentNode).sqrMagnitude;

                if (distanceToNode < minimumDistance)
                {
                    _completedpath.Add(_path[0]);
                    _path.RemoveAt(0);
                }
                else
                {
                    _player.RequestMove(currentNode);
                }

                if (_path.Count > 0)
                {
                    break;
                }

                _state.Fire(Trigger.ReachedTarget);
                break;
            }
            }
        }