// Use this for initialization
void Start()
{
pathGenerator = new AStarPath();
path = new List <AStarConnection>();
test = GameObject.FindObjectOfType <AStarTest>();
tf = GetComponent <Transform>();
}
void Start()
{
astarTime = gameObject.transform.FindChild("AstarTime").GetComponent<Text>();
fringeTime = gameObject.transform.FindChild("FringeTime").GetComponent<Text>();
a = GameObject.Find("Floor").GetComponent<AStarPath>();
f = GameObject.Find("Floor").GetComponent<FringePath>();
}
// Returns bool representing if the path has been found the path itself
private Tuple <bool, AStarPath> FindDirectPath(ITransit transit, AStarNode endingNode, TimeSpan time)
{
ITransit directTransit = null;
var originalWeight = endingNode.Weight;
var originalHeuristicWeight = endingNode.HeuristicWeight;
// We are not interested in direct paths by feet, as it will most likely won't be the best path.
// If it is A* will find it in the main part of the algorithm.
if (transit.Transport.Alias != "Feet" && transit.Transport.IsTransitPossible(transit.StartNode.Location, endingNode.Location))
{
directTransit = new Transit();
directTransit.Transport = transit.Transport;
directTransit.StartNode = transit.StartNode;
directTransit.EndNode = endingNode;
var potentialWeight = _weightCalculator.CalculateWeight(directTransit, time) * 0.75 + ((AStarNode)transit.StartNode).Weight;
var potentialHeuristic = _heuristicCalculator.CalculateWeight(transit, time);
endingNode.Weight = potentialWeight;
endingNode.HeuristicWeight = potentialHeuristic;
directTransit.DepartureTime = directTransit.Transport.GetClosestDepartureTime(directTransit.StartNode.Location, time);
directTransit.ArrivalTime = directTransit.DepartureTime + directTransit.Transport.TravelTime(directTransit.StartNode.Location, directTransit.EndNode.Location, directTransit.DepartureTime);
}
AStarPath path = BacktrackPath(directTransit);
// Reset ending node weight as to not interfere with the main part of the algorithm
endingNode.Weight = originalWeight;
endingNode.HeuristicWeight = originalHeuristicWeight;
return(Tuple.Create(path.Value > 0, path));
}
public void FixedUpdate()
{
if (mPath == null)
{
//We have no path to move after yet
return;
}
if (mCurrentWaypoint >= mPath.Count())
{
Debug.Log("End Of Path Reached");
mPath = null;
movingDirection = Vector2.zero;
return;
}
//Direction to the next waypoint
Vector3 dir = (mPath.GetNode(mCurrentWaypoint).transform.position - transform.position).normalized;
movingDirection = dir;
dir *= mSpeed * Time.fixedDeltaTime;
transform.position += dir;
//Check if we are close enough to the next waypoint
//If we are, proceed to follow the next waypoint
if (Vector3.Distance(transform.position, mPath.GetNode(mCurrentWaypoint).transform.position) < mTargetDistance)
{
mCurrentWaypoint++;
return;
}
}
void Start()
{
ASPath = new AStarPath(WorldController.Instance.graph);
path = new List <Tile> ();
//just for debugging
//DrawPathLine = true;
}
void CalcEnemyPath(GameCube startCube, AStarPath suppliedPath = null)
{
RemoveEnemyPathUI(startCube);
List <GameObject> pathTrails = new List <GameObject> ();
List <GameCube> cachedPath = new List <GameCube> ();
AStarPath path = (suppliedPath != null) ? suppliedPath : new AStarPath(startCube, enemyDestination);
if (path.IsComplete == false)
{
Debug.LogError("Enemy Path Completely Blocked!");
}
cachedPath.Add(startCube);
while (path.IsNext())
{
cachedPath.Add(path.GetNext());
}
for (float i = 0; i < cachedPath.Count; i++)
{
pathTrails.Add(SpawnEnemyPathUI(cachedPath, (int)i, pathTrails));
}
currentPaths [startCube] = cachedPath;
currentPathTrails [startCube] = pathTrails;
}
protected void Move(Vector2 position)
{
state = EnemyState.MOVE;
// transform.position = Vector2.MoveTowards(transform.position, position, moveSpeed * Time.deltaTime);
Vector2 tilePos = AStarPath.GetTilePosition(transform.position);
Vector2 playerTilePos = AStarPath.GetTilePosition(player.transform.position);
path = AStarPath.FindPath(tilePos, playerTilePos);
if (path != null)
{
path.Reverse();
List <Vector2> pathWorldPosition = new List <Vector2>();
for (int i = 0; i < path.Count; i++)
{
pathWorldPosition.Add(AStarPath.GetTileWorldPosition(path[i].position));
}
if (followEnumerator != null)
{
StopCoroutine(followEnumerator);
}
followEnumerator = FollowPath(pathWorldPosition, player.transform.position);
StartCoroutine(followEnumerator);
}
}
public Color[] generateRoadMask(int roadCount, int minRoadLength)
{
int width = (int)Mathf.Sqrt(fullHeightMap.Length);
Color[] colors = new Color[fullHeightMap.Length];
for (int x = 0; x < width * width; x++)
{
colors[x] = new Color(255, 255, 255);
}
for (int i = 0; i < roadCount; i++)
{
Vector2 pointA = new Vector2(Random.Range(0, width), Random.Range(0, width));
Vector2 pointB;
do
{
pointB = new Vector2(Random.Range(0, width), Random.Range(0, width));
} while (AStarPath.manhattanDistanceHeuristic(pointA, pointB) < minRoadLength);
Debug.Log("Start: " + pointA + " End: " + pointB);
List <Vector2> path = AStarPath.findPath(pointA, pointB, width, fullHeightMap, heightMultiplier);
foreach (Vector2 point in path)
{
int roadMapIndex = (int)(point.y * width + point.x);
colors[roadMapIndex] = new Color(0, 0, 0);
List <int> neighbors = AStarPath.getGridNeighbors(roadMapIndex, width);
foreach (int index in neighbors)
{
colors[index] = new Color(0, 0, 0);
}
}
}
return(colors);
}
void MovementMouseUI(Hex mouseHex)
{
//button needs to be disabled if the player is moving or has the ball
//need to be able to free throw - different UI
hexOutliner.SetActive(true);
hexOutliner.transform.position = mouseHex.Position + outlinerOffset;
if (selected != null)
{
if (selected.Moving == false && selected.MoveHexesInRange.Contains(mouseHex))
{
AStarPath p = new AStarPath(GridManager.Instance.Grid, selected.CurrentHex, mouseHex, true);
List <Vector3> hexPositions = new List <Vector3> ();
LineRenderer lr = selected.GetComponent <LineRenderer> ();
lr.enabled = true;
hexPositions.Add(selected.transform.position + outlinerOffset - selected.HexOffset);
while (p.IsNextHex())
{
hexPositions.Add(p.GetNextHex().Position + outlinerOffset);
}
lr.positionCount = hexPositions.Count;
lr.SetPositions(hexPositions.ToArray());
}
else
{
selected.GetComponent <LineRenderer> ().enabled = false;
}
}
}
public void GenerateGrid()
{
map = CreateNodesFromTilemaps.CreateNodes(grid, floor, obstacleLayers, transform);
SpawnNodes(map, false);
AStarPath.SaveMap(map);
path = AStarPath.FindPath(new Vector2(-7.9f, -.2f), new Vector2(-.1f, -.1f));
StartCoroutine(DelayedPath());
}
private AStarPath BacktrackPath(ITransit transit)
{
var path = new AStarPath();
if (transit == null)
{
return(path);
}
path.Add(transit);
return(BacktrackPath(transit.StartNode, path));
}
public twin StepTowardsTarget(twin mover, twin target)
{
var path = new AStarPath(this.robotPather, mover, target);
if (path.cost > 0 && path.cells.Count > 1)
{
return(path.cells[1] - mover);
}
// else: there is no path
return(twin.zero);
}
IEnumerator GetPath(Point destination)
{
AStarPath aPath = new AStarPath(map.Maps);
Point startPoint = new Point(row, column);
IList<Point> list = aPath.GetPath(startPoint, destination);
if (null == list || list.Count == 0) yield break;
list.RemoveAt(0);//第一个为自身位置
targetPosEffect.SetActive(true);
Vector3 effectPos = Map.Instance.GetGridPos(list[list.Count - 1].R, list[list.Count - 1].C);
effectPos.z = targetPosEffect.transform.position.z;
targetPosEffect.transform.position = effectPos;
if (null != hideEffectCoroutine) StopCoroutine(hideEffectCoroutine);
hideEffectCoroutine =StartCoroutine(HideEffectObj());
Animation animation = player.GetComponent<Animation>();
for (int i = 0; i < list.Count; i++)
{
Point p = list[i];
Vector3 _pos = GetWorldPos(list[i].R, list[i].C);
Vector3 targetPos = new Vector3(_pos.x, _pos.y, transform.position.z);
//设置层级
rendqueue = map.Maps[list[i].R, list[i].C].SortOrder + 1;
playerRender.material.renderQueue = rendqueue;
targetPos = GetChangePos(targetPos);
//获取转向
eDirectionType direction = MapHelper.GetNextDirection(row, column, list[i].R, list[i].C);
RotatePlayer(direction, player);
animation.Play("run");
while (Vector3.Distance(transform.position, targetPos) > 0.01f)
{
yield return new WaitForSeconds(Time.deltaTime);
transform.position = Vector3.MoveTowards(transform.position, targetPos, moveSpeed * Time.deltaTime);
}
row = list[i].R;
column = list[i].C;
targetPosEffect.SetActive(false);
}
animation.Play("idle");
Debug.Log(string.Format("寻路完成:{0}_{1}",row,column));
playerRender.material.renderQueue = rendqueue;
}
public static AStarPath GetPath(Vector3 vStartPosition, Vector3 vEndPosition)
{
AStarPath path = new AStarPath();
AStarNode pStartNode = GetClosestNode(vStartPosition);
AStarNode pEndNode = GetClosestNode(vEndPosition);
Vector3 vEndNodePosition = pEndNode.transform.position;
Dictionary <AStarNode, AStarNodeInfo> nodeInfos = new Dictionary <AStarNode, AStarNodeInfo>();
List <AStarNodeInfo> openList = new List <AStarNodeInfo>();
List <AStarNode> closedList = new List <AStarNode>();
// Add start node to open list
AddNodeToOpenList(pStartNode, null, nodeInfos, openList, closedList, vEndNodePosition);
AStarNodeInfo pFinalNode = null;
while (openList.Count > 0)
{
// Examine node
AStarNodeInfo pCurrentNode = openList[0];
openList.RemoveAt(0);
if (pCurrentNode.mNode == pEndNode)
{
pFinalNode = pCurrentNode;
break;
}
else
{
foreach (AStarNode pNode in pCurrentNode.mNode.Links)
{
AddNodeToOpenList(pNode, pCurrentNode, nodeInfos, openList, closedList, vEndNodePosition);
}
}
}
// Retrace path
if (pFinalNode != null)
{
AStarNodeInfo pNode = pFinalNode;
while (pNode != null)
{
path.InsertNode(pNode.mNode);
pNode = pNode.mPreviousNode;
}
}
return(path);
}
public Stack <Coordinate> FindRandomPath(Vector3 objectPosition)
{
var start = Maze[(int)Math.Round(objectPosition.x) / mazeScale, (int)Math.Round(objectPosition.z) / mazeScale];
var end = Maze[UnityEngine.Random.Range(1, MazeWidth - 2), UnityEngine.Random.Range(1, MazeWidth - 2)];
while (end.type != MazeID.SPACE)
{
end = Maze[UnityEngine.Random.Range(1, MazeWidth - 2), UnityEngine.Random.Range(1, MazeWidth - 2)];
}
AStarPath pathfinder = new AStarPath(Maze, start, end, MazeWidth, MazeHeight);
return(pathfinder.FindPath());
}
/// <summary>
/// Begins A* pathfinding using the A* algorithm
/// Copies the grid to an object and begins to traverse this
/// new grid finding a path to target node
/// </summary>
/// <param name="startPos">Start position.</param>
/// <param name="targetPos">Target position.</param>
/// <param name="lineOfSight">If set to <c>true</c> line of sight.</param>
/// <param name="callback">Callback.</param>
/// <param name="pathId">Path identifier.</param>
public IEnumerator AStarPathfinding(Vector3 startPos, Vector3 targetPos, bool lineOfSight, Action<Vector3[], bool> callback, int pathId, float totalMs)
{
//Added for mesh copy O(n2) heavy
Node[,] meshCopy = grid.GetGridCopy();
//Done for frame processing take over
yield return null;
UnityEngine.Debug.Log("Going into A* Thread");
AStarPath aStar = new AStarPath(grid, meshCopy, startPos, targetPos, lineOfSight, callback, pathId, totalMs);
paths.Add(aStar);
//Starts a new thread using threadpool management
ThreadPool.QueueUserWorkItem(aStar.ThreadPoolCallback, paths.Count);
}
// Use this for initialization
void Start()
{
this.spawned = 0;
//The only way to create a new object from scratch is to attach it to a new object:
pathObj = new GameObject("PathSystem");
pathObj.transform.parent = this.transform;
pathObj.transform.localPosition = Vector3.zero;
//This is the only way to create a component properly:
path = pathObj.AddComponent<AStarPath>();
//If the world changes we need to recompute:
GenerateWorld.WorldCubeData.CellAdded += (obj) => { this.validPath = false; };
GenerateWorld.WorldCubeData.CellRemoved += (obj) => { this.validPath = false; };
}
public void GetPathTo(twin target, out twin move, out AStarPath path)
{
move = twin.zero;
path = new AStarPath(pather, my_cell_pos, target);
if (path.cells == null)
{
return;
}
foreach (var cell in path.cells)
{
if (cell != my_cell_pos)
{
move = cell - my_cell_pos;
return;
}
}
}
private AStarPath BacktrackPath(INode endNode, AStarPath existingPath = null)
{
var path = existingPath ?? new AStarPath();
var currentNode = endNode;
while (true)
{
if (currentNode.FastestTransit == null)
{
break;
}
path.Add(currentNode.FastestTransit);
currentNode = (AStarNode)currentNode.FastestTransit.StartNode;
}
return(path);
}
IEnumerator MoveCoroutine(Hex destHex)
{
moving = true;
if (onMoveBegan != null)
{
onMoveBegan(this);
}
HideMovementHexes();
AStarPath p = new AStarPath(GridManager.Instance.Grid, currentHex, destHex, true);
Hex next;
Hex current = CurrentHex;
destOccupant = destHex.Occupant;
CurrentHex = destHex;
while (p.IsNextHex())
{
next = p.GetNextHex();
CheckHex(next.Occupant);
if (movesInActionRemaining >= next.MoveCost)
{
yield return(StartCoroutine(MoveToHex(current, next)));
}
current = next;
}
onMoveComplete(this);
if (UserControlManager.Instance.Selected == this)
{
ShowMovementHexes();
}
moving = false;
}
private static Point GetTileNextToBuilding(int tileX, int tileY, AStarGraph graph)
{
AStarNode tileNode = graph.GetNode(tileX, tileY);
if (tileNode is not null)
{
tileNode.FakeTileClear = true;
AStarPath path = graph.FindPathWithBubbleCheck(graph.FarmerNodeOffset, tileNode);
if (path is not null && path.Count > 0)
{
return(new Point(tileX, tileY));
}
tileNode.FakeTileClear = false;
}
return(Point.Zero);
}
public bool SetDestination(BasePath path, BasePathNode newTargetNode, float speedFraction)
{
if (!AI.move)
{
return(false);
}
if (!AI.navthink)
{
return(false);
}
paused = false;
if (!CanUseAStar)
{
return(false);
}
if (newTargetNode == targetNode && HasPath)
{
return(true);
}
if (ReachedPosition(newTargetNode.transform.position))
{
return(true);
}
BasePathNode closestToPoint = path.GetClosestToPoint(base.transform.position);
if (closestToPoint == null || closestToPoint.transform == null)
{
return(false);
}
float pathCost;
if (AStarPath.FindPath(closestToPoint, newTargetNode, out currentAStarPath, out pathCost))
{
currentSpeedFraction = speedFraction;
targetNode = newTargetNode;
SetCurrentNavigationType(NavigationType.AStar);
Destination = newTargetNode.transform.position;
return(true);
}
return(false);
}
//When we delete something, does it open a shorter path?
public void ShouldRecalcPathRemoved()
{
Debug.Log("Called");
Dictionary <GameCube, List <GameCube> > paths = new Dictionary <GameCube, List <GameCube> > ();
foreach (KeyValuePair <GameCube, List <GameCube> > kvp in currentPaths)
{
paths [kvp.Key] = currentPaths [kvp.Key];
}
foreach (KeyValuePair <GameCube, List <GameCube> > path in paths)
{
AStarPath newPath = new AStarPath(path.Key, enemyDestination);
if (newPath.Length() < path.Value.Count)
{
CalcEnemyPath(path.Key, newPath);
}
}
}
/*
* THere should always be a path the enemies can take from (each) start cube to
* the enemy destination
*/
public bool WouldYieldNoPaths(GameCube test, float newMoveCost)
{
// set test cube to Mathf.Infinity
float testMoveCost = test.MoveCost;
test.MoveCost = newMoveCost;
foreach (GameCube start in startCubes)
{
AStarPath path = new AStarPath(start, enemyDestination);
if (path.IsComplete == false)
{
test.MoveCost = testMoveCost;
return(false);
}
}
test.MoveCost = testMoveCost;
//there is at least one path for each start cube
return(true);
}
// Use this for initialization
void Start()
{
pathGenerator = new AStarPath();
}
public void UpdateMovement_Hunt()
{
if (Interface.CallHook("OnBradleyApcHunt", this) != null || patrolPath == null)
{
return;
}
TargetInfo targetInfo = targetList[0];
if (!targetInfo.IsValid())
{
return;
}
if (HasPath() && targetInfo.IsVisible())
{
if (currentPath.Count > 1)
{
Vector3 item = currentPath[currentPathIndex];
ClearPath();
currentPath.Add(item);
finalDestination = item;
currentPathIndex = 0;
}
}
else
{
if (!(UnityEngine.Time.time > nextEngagementPathTime) || HasPath() || targetInfo.IsVisible())
{
return;
}
bool flag = false;
BasePathNode start = patrolPath.GetClosestToPoint(base.transform.position);
List <BasePathNode> nodes = Facepunch.Pool.GetList <BasePathNode>();
if (GetEngagementPath(ref nodes))
{
flag = true;
start = nodes[nodes.Count - 1];
}
BasePathNode basePathNode = null;
List <BasePathNode> nearNodes = Facepunch.Pool.GetList <BasePathNode>();
patrolPath.GetNodesNear(targetInfo.lastSeenPosition, ref nearNodes, 30f);
Stack <BasePathNode> stack = null;
float num = float.PositiveInfinity;
float y = mainTurretEyePos.localPosition.y;
foreach (BasePathNode item2 in nearNodes)
{
Stack <BasePathNode> path = new Stack <BasePathNode>();
float pathCost;
if (targetInfo.entity.IsVisible(item2.transform.position + new Vector3(0f, y, 0f)) && AStarPath.FindPath(start, item2, out path, out pathCost) && pathCost < num)
{
stack = path;
num = pathCost;
basePathNode = item2;
}
}
if (stack == null && nearNodes.Count > 0)
{
Stack <BasePathNode> path2 = new Stack <BasePathNode>();
BasePathNode basePathNode2 = nearNodes[UnityEngine.Random.Range(0, nearNodes.Count)];
float pathCost2;
if (AStarPath.FindPath(start, basePathNode2, out path2, out pathCost2) && pathCost2 < num)
{
stack = path2;
basePathNode = basePathNode2;
}
}
if (stack != null)
{
currentPath.Clear();
if (flag)
{
for (int i = 0; i < nodes.Count - 1; i++)
{
currentPath.Add(nodes[i].transform.position);
}
}
foreach (BasePathNode item3 in stack)
{
currentPath.Add(item3.transform.position);
}
currentPathIndex = -1;
pathLooping = false;
finalDestination = basePathNode.transform.position;
}
Facepunch.Pool.FreeList(ref nearNodes);
Facepunch.Pool.FreeList(ref nodes);
nextEngagementPathTime = UnityEngine.Time.time + 5f;
}
}
public void SetManualDest(int x, int y)
{
ASPath = new AStarPath(WorldController.Instance.graph);
AStarFindPathTo(WorldController.Instance.GetTileAt(x, y));
}
public void UpdateMovement_Patrol()
{
if (patrolPath == null || UnityEngine.Time.time < nextPatrolTime)
{
return;
}
nextPatrolTime = UnityEngine.Time.time + 20f;
if ((HasPath() && !IsAtFinalDestination()) || Interface.CallHook("OnBradleyApcPatrol", this) != null)
{
return;
}
PathInterestNode randomInterestNodeAwayFrom = patrolPath.GetRandomInterestNodeAwayFrom(base.transform.position);
BasePathNode closestToPoint = patrolPath.GetClosestToPoint(randomInterestNodeAwayFrom.transform.position);
BasePathNode basePathNode = null;
bool flag = false;
List <BasePathNode> nodes = Facepunch.Pool.GetList <BasePathNode>();
if (GetEngagementPath(ref nodes))
{
flag = true;
basePathNode = nodes[nodes.Count - 1];
}
else
{
basePathNode = patrolPath.GetClosestToPoint(base.transform.position);
}
if (!(Vector3.Distance(finalDestination, closestToPoint.transform.position) > 2f))
{
return;
}
if (closestToPoint == basePathNode)
{
currentPath.Clear();
currentPath.Add(closestToPoint.transform.position);
currentPathIndex = -1;
pathLooping = false;
finalDestination = closestToPoint.transform.position;
}
else
{
Stack <BasePathNode> path;
float pathCost;
if (!AStarPath.FindPath(basePathNode, closestToPoint, out path, out pathCost))
{
return;
}
currentPath.Clear();
if (flag)
{
for (int i = 0; i < nodes.Count - 1; i++)
{
currentPath.Add(nodes[i].transform.position);
}
}
foreach (BasePathNode item in path)
{
currentPath.Add(item.transform.position);
}
currentPathIndex = -1;
pathLooping = false;
finalDestination = closestToPoint.transform.position;
}
}
void GenerateRandomGrid()
{
var gridArea = TestGrid.GetGridArea();
var width = gridArea.Width;
var height = gridArea.Height;
var grid = new List <GridTile> ();
var gridModels = new List <GridModel> ();
ClearGridParent();
for (int y = 0; y < height; ++y)
{
for (int x = 0; x < width; ++x)
{
var gt = Instantiate(gridPrefab, GridParent);
gt.name = (x + "," + y);
gt.transform.localPosition = new Vector3(x, y, GridParent.transform.position.z);
grid.Add(gt);
gridModels.Add(new GridModel(gt));
}
}
gridArea.SetGrids(gridModels);
var cpu = TestGrid.GetCpu();
var cpuModel = GridUtility.GetEmptyGrid(gridArea);
var cpuLocation = gridArea.GetCellLocation(cpuModel.Cells.First()); //need PORTS and ENTRANCE
cpuModel.GridComponents.Add(cpu);
var componentScript = cpuModel.GridTile.gameObject.GetComponent <ComponentScript>();
componentScript.CreateComponent(cpu);
//empty.GridTile.SetState(empty);
var boostChip = TestGrid.GetBoostChip();
var boostModel = GridUtility.GetEmptyGrid(gridArea);
var boostChipLocation = gridArea.GetCellLocation(boostModel.Cells.First());//need PORTS and ENTRANCE
boostModel.AddComponent(boostChip);
componentScript = boostModel.GridTile.gameObject.GetComponent <ComponentScript>();
componentScript.CreateComponent(boostChip);
boostModel.GridTile.SetState(boostModel);
var componentCount = 4;
var usedTiles = new List <GridTile> ();
var max = grid.Count;
int i = 0;
List <GridAreaLocation> recvrLocations = new List <GridAreaLocation>();
while (i < componentCount)
{
var receiverModel = GridUtility.GetEmptyGrid(gridArea);
var gridComponent = new GridComponent();
gridComponent.Color = GameUtility.GetRandomColor();
var c = new CellLocation(Random.Range(0, 3), Random.Range(0, 3));
var rCell = receiverModel.GetCell(c);// testing, picking first cell of the grid
recvrLocations.Add(gridArea.GetCellLocation(rCell));
gridComponent.CellLocations.Add(c);
receiverModel.AddComponent(gridComponent);
componentScript = receiverModel.GridTile.gameObject.GetComponent <ComponentScript>();
componentScript.CreateComponent(gridComponent);
++i;
receiverModel.GridTile.SetState(receiverModel);
}
List <GridPath> paths = new List <GridPath>();
foreach (var r in recvrLocations)
{
var gp = new GridPath();
gp.StartEntrance = r;
gp.FinishEntrance = cpuLocation;
AStarPath aStar = new AStarPath();
var path = aStar.FindPath(r, cpuLocation, gridArea);
gp.Path = path;
//GridUtility.GeneratePath(gp, gridArea);
paths.Add(gp);
}
GridUtility.SetCellStates(paths, gridArea);
gridModels.ForEach(x => x.GridTile.SetState(x));
//gridComponent.Cell.Location = new CellLocation { X = 0, Y = 1 };
//componentScript.CreateComponent (gridComponent);
//g.gameObject.AddComponent<ComponentScript> ();
}
public void UpdateMovement_Hunt()
{
float single;
if (Interface.CallHook("OnBradleyApcHunt", this) != null)
{
return;
}
if (this.patrolPath == null)
{
return;
}
BradleyAPC.TargetInfo item = this.targetList[0];
if (item.IsValid())
{
if (this.HasPath() && item.IsVisible())
{
if (this.currentPath.Count > 1)
{
Vector3 vector3 = this.currentPath[this.currentPathIndex];
this.ClearPath();
this.currentPath.Add(vector3);
this.finalDestination = vector3;
this.currentPathIndex = 0;
return;
}
}
else if (UnityEngine.Time.time > this.nextEngagementPathTime && !this.HasPath() && !item.IsVisible())
{
bool flag = false;
BasePathNode closestToPoint = this.patrolPath.GetClosestToPoint(base.transform.position);
List <BasePathNode> list = Facepunch.Pool.GetList <BasePathNode>();
if (this.GetEngagementPath(ref list))
{
flag = true;
closestToPoint = list[list.Count - 1];
}
BasePathNode basePathNode = null;
List <BasePathNode> basePathNodes = Facepunch.Pool.GetList <BasePathNode>();
this.patrolPath.GetNodesNear(item.lastSeenPosition, ref basePathNodes, 30f);
Stack <BasePathNode> basePathNodes1 = null;
float single1 = Single.PositiveInfinity;
float single2 = this.mainTurretEyePos.localPosition.y;
foreach (BasePathNode basePathNode1 in basePathNodes)
{
Stack <BasePathNode> basePathNodes2 = new Stack <BasePathNode>();
if (!item.entity.IsVisible(basePathNode1.transform.position + new Vector3(0f, single2, 0f), Single.PositiveInfinity) || !AStarPath.FindPath(closestToPoint, basePathNode1, out basePathNodes2, out single) || single >= single1)
{
continue;
}
basePathNodes1 = basePathNodes2;
single1 = single;
basePathNode = basePathNode1;
}
if (basePathNodes1 != null)
{
this.currentPath.Clear();
if (flag)
{
for (int i = 0; i < list.Count - 1; i++)
{
this.currentPath.Add(list[i].transform.position);
}
}
foreach (BasePathNode basePathNode2 in basePathNodes1)
{
this.currentPath.Add(basePathNode2.transform.position);
}
this.currentPathIndex = -1;
this.pathLooping = false;
this.finalDestination = basePathNode.transform.position;
}
Facepunch.Pool.FreeList <BasePathNode>(ref basePathNodes);
Facepunch.Pool.FreeList <BasePathNode>(ref list);
this.nextEngagementPathTime = UnityEngine.Time.time + 5f;
}
}
}
public void OnEnable()
{
aStarPathScript = target as AStarPath;
aStarPathScript.OnDrawGizmosCallback = OnDrawGizmos;
}
public void UpdateMovement_Patrol()
{
float single;
Stack <BasePathNode> basePathNodes;
if (this.patrolPath == null)
{
return;
}
if (UnityEngine.Time.time < this.nextPatrolTime)
{
return;
}
this.nextPatrolTime = UnityEngine.Time.time + 20f;
if (this.HasPath() && !this.IsAtFinalDestination())
{
return;
}
if (Interface.CallHook("OnBradleyApcPatrol", this) != null)
{
return;
}
PathInterestNode randomInterestNodeAwayFrom = this.patrolPath.GetRandomInterestNodeAwayFrom(base.transform.position, 10f);
BasePathNode closestToPoint = this.patrolPath.GetClosestToPoint(randomInterestNodeAwayFrom.transform.position);
BasePathNode item = null;
bool flag = false;
List <BasePathNode> list = Facepunch.Pool.GetList <BasePathNode>();
if (!this.GetEngagementPath(ref list))
{
item = this.patrolPath.GetClosestToPoint(base.transform.position);
}
else
{
flag = true;
item = list[list.Count - 1];
}
if (Vector3.Distance(this.finalDestination, closestToPoint.transform.position) > 2f)
{
if (closestToPoint == item)
{
this.currentPath.Clear();
this.currentPath.Add(closestToPoint.transform.position);
this.currentPathIndex = -1;
this.pathLooping = false;
this.finalDestination = closestToPoint.transform.position;
return;
}
if (AStarPath.FindPath(item, closestToPoint, out basePathNodes, out single))
{
this.currentPath.Clear();
if (flag)
{
for (int i = 0; i < list.Count - 1; i++)
{
this.currentPath.Add(list[i].transform.position);
}
}
foreach (BasePathNode basePathNode in basePathNodes)
{
this.currentPath.Add(basePathNode.transform.position);
}
this.currentPathIndex = -1;
this.pathLooping = false;
this.finalDestination = closestToPoint.transform.position;
}
}
}
public void WalkTo(Vector3 vPosition)
{
mPath = AStarGraph.GetPath(transform.position, vPosition);
mCurrentWaypoint = 0;
}
private void _handleMovement()
{
// Do not move if we do not have a path to move to!
if (PathName == null)
{
return;
}
// Do not move the mob if its dead. corpses dont move!
if (_mobAttributesMono.Dead)
{
return;
}
// Do not move if not tracked.
if (MobNumber == 0)
{
return;
}
if (NetworkingManager.Instance.IsServer)
{
#region Server-sided movement handler
#region Continuously find the platform and path objects.
if (_mapPlatform == null)
{
_mapPlatform = MapPlatform.Instance;
return;
}
if (_pathObject == null)
{
AStarPath.AStarPathDictionary.TryGetValue(PathName, out _pathObject);
if (!_pathObject)
{
return;
}
_path = _pathObject.GetComponent <AStarPath>();
_currPathIndex = _path.CompactPath.Count - 1;
_currPathList = new List <Vector3>(_path.CompactPath);
Destination = _currPathList[_currPathIndex];
return;
}
#endregion
#region Check for path object and a checkpoint list.
if (_path == null)
{
return;
}
if (_currPathList.Count == 0)
{
_currPathList = new List <Vector3>(_path.CompactPath);
_currPathIndex = _currPathList.Count - 1;
Destination = _currPathList[_currPathIndex];
_mobModifierRpc.UpdateMoveStateSendRpc(MobNumber, transform.position, Destination);
return;
}
#endregion
var currPos = transform.position;
var endPos = _mobAttributesMono.Flying ? _currPathList[0] : Destination;
endPos.y = currPos.y;
var dir = Vector3.Normalize(endPos - currPos);
var remainingDistance = Vector3.Distance(currPos, endPos);
var travelDistance = _mobAttributesMono.MoveSpeed * Time.fixedDeltaTime;
var nextPosition = currPos + (dir * travelDistance);
var distanceAvaliable = remainingDistance > travelDistance;
var nextPosIsBlocked = _mapPlatform.LocationIsBlocked(nextPosition);
#region Blocked path handler.
if (nextPosIsBlocked && !_mobAttributesMono.Flying)
{
List <Vector3> placeHolder;
_mapPlatform.FindAStarPath(currPos, _path.EndPoint.transform.position, out _currPathList, out placeHolder);
_currPathIndex = _currPathList.Count - 1;
Destination = _currPathList[_currPathIndex];
_mobModifierRpc.UpdateMoveStateSendRpc(MobNumber, transform.position, Destination);
return;
}
#endregion
#region Movement and path change handler.
if (distanceAvaliable)
{
transform.position = nextPosition;
}
else
{
transform.position = endPos;
if (--_currPathIndex >= 0)
{
Destination = _currPathList[_currPathIndex];
_mobModifierRpc.UpdateMoveStateSendRpc(MobNumber, transform.position, Destination);
}
else
{
var nextPath = _path.NextPath.GetComponent <AStarPath>();
_path = (nextPath == null || nextPath == _path) ? null : nextPath;
if (_path != null)
{
_currPathIndex = _path.CompactPath.Count - 1;
_currPathList = new List <Vector3>(_path.CompactPath);
Destination = _currPathList[_currPathIndex];
_mobModifierRpc.UpdateMoveStateSendRpc(MobNumber, transform.position, Destination);
}
}
}
if (_prevLocation != transform.position)
{
transform.LookAt(2 * transform.position - _prevLocation);
}
_prevLocation = transform.position;
#endregion
#endregion
}
else
{
#region Client-sided movement handler
if (transform.position != Destination)
{
transform.LookAt(Destination);
}
var currPos = transform.position;
var endPos = Destination;
endPos.y = currPos.y;
var dir = Vector3.Normalize(endPos - currPos);
var remainingDistance = Vector3.Distance(currPos, endPos);
var travelDistance = _mobAttributesMono.MoveSpeed * Time.fixedDeltaTime;
var nextPosition = currPos + (dir * travelDistance);
var distanceAvaliable = remainingDistance > travelDistance;
if (distanceAvaliable)
{
transform.position = nextPosition;
}
#endregion
}
}
