Exemplo n.º 1
0
        IEnumerator MoveToNode(TurnBasedAI unit, GraphNode node)
        {
            var path = ABPath.Construct(unit.transform.position, (Vector3)node.position);

            path.traversalProvider = unit.traversalProvider;

            // Schedule the path for calculation
            AstarPath.StartPath(path);

            // Wait for the path calculation to complete
            yield return(StartCoroutine(path.WaitForPath()));

            if (path.error)
            {
                // Not obvious what to do here, but show the possible moves again
                // and let the player choose another target node
                // Likely a node was blocked between the possible moves being
                // generated and the player choosing which node to move to
                Debug.LogError("Path failed:\n" + path.errorLog);
                state = State.SelectTarget;
                GeneratePossibleMoves(selected);
                yield break;
            }

            // Set the target node so other scripts know which
            // node is the end point in the path
            unit.targetNode = path.path[path.path.Count - 1];

            yield return(StartCoroutine(MoveAlongPath(unit, path, movementSpeed)));

            unit.blocker.BlockAtCurrentPosition();

            // Select a new unit to move
            state = State.SelectUnit;
        }
Exemplo n.º 2
0
        void GeneratePossibleMoves(TurnBasedAI unit)
        {
            var path = ConstantPath.Construct(unit.transform.position, unit.movementPoints * 1000 + 1);

            path.traversalProvider = unit.traversalProvider;

            // Schedule the path for calculation
            AstarPath.StartPath(path);

            // Force the path request to complete immediately
            // This assumes the graph is small enough that
            // this will not cause any lag
            path.BlockUntilCalculated();

            foreach (var node in path.allNodes)
            {
                if (node != path.startNode)
                {
                    // Create a new node prefab to indicate a node that can be reached
                    // NOTE: If you are going to use this in a real game, you might want to
                    // use an object pool to avoid instantiating new GameObjects all the time
                    var go = GameObject.Instantiate(nodePrefab, (Vector3)node.position, Quaternion.identity) as GameObject;
                    possibleMoves.Add(go);

                    go.GetComponent <Astar3DButton>().node = node;
                }
            }
        }
        // Token: 0x06002A2E RID: 10798 RVA: 0x001C739F File Offset: 0x001C559F
        private static IEnumerator MoveAlongPath(TurnBasedAI unit, ABPath path, float speed)
        {
            if (path.error || path.vectorPath.Count == 0)
            {
                throw new ArgumentException("Cannot follow an empty path");
            }
            float distanceAlongSegment = 0f;
            int   num;

            for (int i = 0; i < path.vectorPath.Count - 1; i = num + 1)
            {
                Vector3 p0            = path.vectorPath[Mathf.Max(i - 1, 0)];
                Vector3 p             = path.vectorPath[i];
                Vector3 p2            = path.vectorPath[i + 1];
                Vector3 p3            = path.vectorPath[Mathf.Min(i + 2, path.vectorPath.Count - 1)];
                float   segmentLength = Vector3.Distance(p, p2);
                while (distanceAlongSegment < segmentLength)
                {
                    Vector3 position = AstarSplines.CatmullRom(p0, p, p2, p3, distanceAlongSegment / segmentLength);
                    unit.transform.position = position;
                    yield return(null);

                    distanceAlongSegment += Time.deltaTime * speed;
                }
                distanceAlongSegment -= segmentLength;
                p0  = default(Vector3);
                p   = default(Vector3);
                p2  = default(Vector3);
                p3  = default(Vector3);
                num = i;
            }
            unit.transform.position = path.vectorPath[path.vectorPath.Count - 1];
            yield break;
        }
Exemplo n.º 4
0
        /// <summary>Interpolates the unit along the path</summary>
        static IEnumerator MoveAlongPath(TurnBasedAI unit, ABPath path, float speed)
        {
            if (path.error || path.vectorPath.Count == 0)
            {
                throw new System.ArgumentException("Cannot follow an empty path");
            }

            // Very simple movement, just interpolate using a catmull rom spline
            float distanceAlongSegment = 0;

            for (int i = 0; i < path.vectorPath.Count - 1; i++)
            {
                var p0 = path.vectorPath[Mathf.Max(i - 1, 0)];
                // Start of current segment
                var p1 = path.vectorPath[i];
                // End of current segment
                var p2 = path.vectorPath[i + 1];
                var p3 = path.vectorPath[Mathf.Min(i + 2, path.vectorPath.Count - 1)];

                var segmentLength = Vector3.Distance(p1, p2);

                while (distanceAlongSegment < segmentLength)
                {
                    var interpolatedPoint = AstarSplines.CatmullRom(p0, p1, p2, p3, distanceAlongSegment / segmentLength);
                    unit.transform.position = interpolatedPoint;
                    yield return(null);

                    distanceAlongSegment += Time.deltaTime * speed;
                }

                distanceAlongSegment -= segmentLength;
            }

            unit.transform.position = path.vectorPath[path.vectorPath.Count - 1];
        }
        // Token: 0x06002A1E RID: 10782 RVA: 0x001C7108 File Offset: 0x001C5308
        private void OnTriggerEnter(Collider coll)
        {
            TurnBasedAI componentInParent = coll.GetComponentInParent <TurnBasedAI>();
            GraphNode   node = AstarPath.active.GetNearest(base.transform.position).node;

            if (componentInParent != null && componentInParent.targetNode == node)
            {
                this.button.interactable = true;
                this.visible             = true;
                this.anim.CrossFade("show", 0.1f);
            }
        }
        // Token: 0x06002A30 RID: 10800 RVA: 0x001C7418 File Offset: 0x001C5618
        private void GeneratePossibleMoves(TurnBasedAI unit)
        {
            ConstantPath constantPath = ConstantPath.Construct(unit.transform.position, unit.movementPoints * 1000 + 1, null);

            constantPath.traversalProvider = unit.traversalProvider;
            AstarPath.StartPath(constantPath, false);
            constantPath.BlockUntilCalculated();
            foreach (GraphNode graphNode in constantPath.allNodes)
            {
                if (graphNode != constantPath.startNode)
                {
                    GameObject gameObject = UnityEngine.Object.Instantiate <GameObject>(this.nodePrefab, (Vector3)graphNode.position, Quaternion.identity);
                    this.possibleMoves.Add(gameObject);
                    gameObject.GetComponent <Astar3DButton>().node = graphNode;
                }
            }
        }
        // Token: 0x06002A2D RID: 10797 RVA: 0x001C7382 File Offset: 0x001C5582
        private IEnumerator MoveToNode(TurnBasedAI unit, GraphNode node)
        {
            ABPath path = ABPath.Construct(unit.transform.position, (Vector3)node.position, null);

            path.traversalProvider = unit.traversalProvider;
            AstarPath.StartPath(path, false);
            yield return(base.StartCoroutine(path.WaitForPath()));

            if (path.error)
            {
                Debug.LogError("Path failed:\n" + path.errorLog);
                this.state = TurnBasedManager.State.SelectTarget;
                this.GeneratePossibleMoves(this.selected);
                yield break;
            }
            unit.targetNode = path.path[path.path.Count - 1];
            yield return(base.StartCoroutine(TurnBasedManager.MoveAlongPath(unit, path, this.movementSpeed)));

            unit.blocker.BlockAtCurrentPosition();
            this.state = TurnBasedManager.State.SelectUnit;
            yield break;
        }
        // Token: 0x06002A29 RID: 10793 RVA: 0x001C7258 File Offset: 0x001C5458
        private void Update()
        {
            Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);

            if (this.eventSystem.IsPointerOverGameObject())
            {
                return;
            }
            if (this.state == TurnBasedManager.State.SelectTarget)
            {
                this.HandleButtonUnderRay(ray);
            }
            if ((this.state == TurnBasedManager.State.SelectUnit || this.state == TurnBasedManager.State.SelectTarget) && Input.GetKeyDown(KeyCode.Mouse0))
            {
                TurnBasedAI byRay = this.GetByRay <TurnBasedAI>(ray);
                if (byRay != null)
                {
                    this.Select(byRay);
                    this.DestroyPossibleMoves();
                    this.GeneratePossibleMoves(this.selected);
                    this.state = TurnBasedManager.State.SelectTarget;
                }
            }
        }
Exemplo n.º 9
0
 void Select(TurnBasedAI unit)
 {
     selected = unit;
 }
 // Token: 0x06002A2C RID: 10796 RVA: 0x001C7379 File Offset: 0x001C5579
 private void Select(TurnBasedAI unit)
 {
     this.selected = unit;
 }