void SeekNextTargetAtRandom() { AIPathNode[] adjNodes = targetPathNode.GetAdjacentNodes(); Assert.IsNotNull(adjNodes); targetPathNode = adjNodes[Random.Range(0, adjNodes.Length)]; Assert.IsNotNull(targetPathNode); }
bool NodePositionsSame(AIPathNode curr, AIPathNode iter) { if (curr.transform.position.x == iter.transform.position.x && curr.transform.position.z == iter.transform.position.z) { return(true); } return(false); }
// TODO: separate loading for data edited by MonoAGS version private static void loadAIPathsData(TrackAIData data, string assetpath, Size trackSize) { Stream s = File.OpenRead(assetpath + "aipaths.dat"); if (s == null) { return; } List <AIPathNode> paths = new List <AIPathNode>(); AGSFileReader f = new AGSFileReader(s); int firstNodeIndex = f.ReadInt(); int lastNodeIndex = f.ReadInt(); int n = firstNodeIndex; AIPathNode last = null; do { int x = f.ReadInt(); int y = f.ReadInt(); // NOTE: since MonoAGS has Y axis pointing up, we need to invert one read from AGS file y = trackSize.Height - y; AIPathNode node = new AIPathNode(); node.pt = new Vector2(x, y); node.radius = f.ReadInt(); node.threshold = f.ReadInt(); node.speed = f.ReadInt(); int p = f.ReadInt(); n = f.ReadInt(); if (last != null) { node.prev = last; last.next = node; } last = node; paths.Add(node); }while (n != firstNodeIndex); // Bind last node to the first one if (last != null) { last.next = paths[0]; paths[0].prev = last; } data.AIPathNodes = paths; }
// Use this for initialization void Start() { // Debug target = GameObject.Find("Target").transform.position; targetNode = GameObject.Find("Target").transform.FindChild("TargetNode").GetComponent <AIPathNode> (); NodeList.Nodes.Add(targetNode); // ------------------------------ characterRadius = 1f; jumpvector = new Vector3(0f, jumpHeight, 0f); control = this.GetComponent <AIController> (); dash = this.GetComponent <BurstDash> (); // subTargets = new LinkedList<Vector3> (); nodeListObject = GameObject.Find("NodeList"); aiPlayerNode = this.transform.FindChild("PlayerNode").GetComponent <AIPathNode> (); // StartCoroutine (CreatePath ()); Invoke("ChangeTarget", .3f); }
private bool testShouldChooseNewTarget() { if (!_targetValid) { return(true); } // Choose next path node if inside the check radius for current one, or closer to next one. if (_currentNode != null) { AIPathNode prevNode = _currentNode.prev; AIPathNode nextNode = _currentNode.next; if (nextNode != null && (prevNode == null || Vectors.Distance(_veh.Position, prevNode.pt) > Vectors.Distance(_currentNode.pt, prevNode.pt)) && Vectors.Distance(_veh.Position, nextNode.pt) < Vectors.Distance(_currentNode.pt, nextNode.pt)) { return(true); } } return(Vectors.Distance(_veh.Position, _targetPos) <= _targetCheckRadius); }
private bool chooseNewTarget() { if (_pathNodes != null && _pathNodes.Count > 0) { if (_currentNode != null && _currentNode.pt != null) { _currentNode = _currentNode.next; } else { _currentNode = _pathNodes[0]; // TODO: find nearest? } _targetPos = _currentNode.pt; _targetCheckRadius = _currentNode.radius; _targetThreshold = _currentNode.threshold; _targetSpeedHint = _currentNode.speed; _targetValid = true; } else { // TODO?? } return(true); }
LinkedList <AIPathNode> GetPath(Vector3 target) { List <AIPathNode> open = new List <AIPathNode> (); LinkedList <AIPathNode> closed = new LinkedList <AIPathNode> (); AIPathNode currentNode = aiPlayerNode; closed.AddFirst(currentNode); AIPathNode iterNode; while (closed.Last.Value != targetNode) { AIPathNode closestNode = null; float closestDist = Mathf.Infinity; for (int i = 0; i < NodeList.Nodes.Count; ++i) { iterNode = NodeList.Nodes [i]; if (iterNode != currentNode && !closed.Contains(iterNode) && !NodePositionsSame(currentNode, iterNode)) { float dist = Vector3.Distance(currentNode.transform.position, iterNode.transform.position); if (dist < closestDist) { closestNode = iterNode; closestDist = dist; } } } closed.AddLast(closestNode); currentNode = closestNode; } closed.RemoveFirst(); return(closed); /*ClearHeuristics (); * open.Add (aiPlayerNode); * * AIPathNode lowestF = aiPlayerNode; * * while (!closed.Contains (targetNode) && open.Count > 0) { * CalculateHeuristics (open, target); * bool noLowest = true; * for (int i = 0; i < open.Count; ++i) { * if (noLowest || open[i].F < lowestF.F) { * lowestF = open[i]; * noLowest = false; * } * } * * closed.AddLast (lowestF); * open.Remove (lowestF); * * print ("Node iterated on: " + lowestF); * * AIPathNode iterNode; * for (int i = 0; i < NodeList.Nodes.Count; ++i) { * iterNode = NodeList.Nodes [i]; * * if (closed.Contains (iterNode) || * iterNode == lowestF || * !StraightPathPossible (lowestF.transform.position, iterNode.transform.position) || * !NextNodeWithinHeight (lowestF.transform.position, iterNode.transform.position) || * NextNodeStraightAbove (lowestF.transform.position, iterNode.transform.position)) { * continue; * } * * // print ("-----LOS node: " + iterNode); * * if (iterNode == targetNode) { * closed.AddLast (iterNode); * iterNode.Parent = lowestF; * } else if (open.Contains (iterNode)) { * float newG = lowestF.G + Vector3.Distance (iterNode.transform.position, lowestF.transform.position); * if (newG < iterNode.G) { * iterNode.Parent = lowestF; * iterNode.G = newG; * iterNode.F = iterNode.G + iterNode.H; * } * } else { * open.Add (iterNode); * iterNode.Parent = lowestF; * } * } * } * * if (closed.Count == 0) { * return new LinkedList<AIPathNode> (); * } * * LinkedList<AIPathNode> output = new LinkedList<AIPathNode> (); * AIPathNode next = closed.Last.Value; * while (next != aiPlayerNode) { * output.AddFirst (next); * next = next.Parent; * } * * * return output; */ }
// Start is called before the first frame update void Start() { Assert.IsNotNull(m_path); targetPathNode = m_path.GetHeadNode(); Assert.IsNotNull(targetPathNode); }