/* The keeper will move to a new position depending on the ball's position and direction. */ public override PlayerAction ActionWithoutBall(Player player, GameAction gameAction) { Pathfinding pathfinding = new Pathfinding(); Point ballTarget = GameAI.BallNextRoundLocation(); bool onOwnSide = GameAI.IsPointOnOwnSide(GameAI.PlayersTeam(player), ballTarget); if (onOwnSide) { if (GameAI.GameBall.IsInShootState) { Point ballTargetGridLocation = pathfinding.GetGridLocation(GameAI.GameBall.ExactTargetLocation); Goal ownGoal = GameAI.PlayersTeam(player).TeamGoal; Point? pointBeforeGoalEntry = GameAI.PointBeforeRectangleEntry(ownGoal.GoalRectangle); //true if the ball will go through the goal if (pointBeforeGoalEntry.HasValue) { return GoalKeeperShootDefense(player, pointBeforeGoalEntry.Value); } } else { return GoalKeeperPassDefense(player, ballTarget); } } return null; }
// Use this for initialization void Start() { graph = new Pathfinding(); graph.Load("PathfindingRodrigueTest"); graph.setNeighbors(); target = GameObject.FindGameObjectWithTag("Target"); road = PathfindingManager.GetInstance().GetRoad(transform.position, target.transform.position, graph); road = PathfindingManager.GetInstance().SmoothRoad(road); canShoot = true; //targetPossible = GameObject.FindGameObjectsWithTag("Target"); //foreach (GameObject temp in targetPossible) //{ // if (temp != this.gameObject) // { // //if(temp.transform.parent.GetComponent<TeamNumber>().teamName != "RektByRodrigue") // //{ // listOfTarget.Add(temp); // //} // } //} ////InvokeRepeating("GetTarget", 0.5f, 0.5f); //currentTarget = targetPossible[0]; spawnPoint = transform.position; rateOfFire = 1; //InvokeRepeating("FindTarget", 0.1f, 0.1f); InvokeRepeating("UpdateRoad", 0.5f, 0.5f); }
void CompletePath(Pathfinding.Path p) { if (!p.error) { path = p; currentWayPoint = 1; if (p.vectorPath.Count == 1) currentWayPoint = 0; if (!animator.GetBool("Running")) animator.SetBool("Run",true); } }
public JordanMoveTask() { //Select your pathfinding graph = new Pathfinding(); graph.Load("Windywyll"); graph.setNeighbors(); delayTimerUpdateRoad = 1.0f; startTimerUpdateRoad = Time.time; }
public override PlayerAction CornerDefense(Player player) { Pathfinding pathfinding = new Pathfinding(); Point targetPoint = player.StartLocation; targetPoint.X = GameAI.PlayersTeam(player).TeamGoal.MiddlePoint.X + pathfinding.CalculateHorizontalDirection(GameAI.PlayersTeam(player).TeamGoal.MiddlePoint, new Point(12, 12)) * 7; return new PlayerAction(null, targetPoint, ActionType.Run); }
private static void drawText(SpriteBatch spriteBatch, int tileSize, int px, int py, Pathfinding.Node node) { String heuristic = (Math.Truncate(node.h * 10) / 10).ToString(); String moveValue = (Math.Truncate(node.g * 10) / 10).ToString(); String totalValue = (Math.Truncate(node.f * 10) / 10).ToString(); spriteBatch.DrawString(Game1.font, heuristic, new Vector2(px + tileSize - 20, py), Color.White); spriteBatch.DrawString(Game1.font, moveValue, new Vector2(px, py), Color.White); if (node.f != Pathfinding.Map.INFINITY) spriteBatch.DrawString(Game1.font, totalValue.ToString(), new Vector2(px + tileSize / 2, py + tileSize / 2), Color.White); }
// Use this for initialization void Start() { //Select your pathfinding graph = new Pathfinding(); graph.Load("BenoitV"); graph.setNeighbors(); // road = PathfindingManager.GetInstance().GetRoad(transform.position, target.transform.position,graph); InvokeRepeating("UpdateRoad", 0.5f,1f); Debug.Log(PathfindingManager.GetInstance().test); }
// Use this for initialization void Start() { //Select your pathfinding graph = new Pathfinding(); graph.Load("PoulpeNavMesh"); graph.setNeighbors(); // target = GameObject.FindGameObjectWithTag("Target"); road = PathfindingManager.GetInstance().GetRoad(transform.position, target.transform.position,graph); InvokeRepeating("UpdateRoad", 0.5f, 0.5f); Debug.Log(PathfindingManager.GetInstance().test); }
public SW_Walk(int id, float pSpeed, float pRange, string graphName) : base(id) { target = TeamManagerWill.instance.mainTarget; closeEnoughRange = pRange; speed = pSpeed; graph = new Pathfinding(); graph.Load(graphName); graph.setNeighbors(); player = TeamManagerWill.instance.members[idAgent].gameObject; playerController = player.GetComponent<CharacterController>(); road = PathfindingManager.GetInstance().GetRoad(player.transform.position, target.transform.position, graph); road = PathfindingManager.GetInstance().SmoothRoad(road); }
/* Returns a list with all players who will tackle in this round. */ public List<Player> SearchTacklePlayers(Player[] allPlayers) { List<Player> tacklePlayers = new List<Player>(); foreach (Player player in allPlayers) { ActionType type; Pathfinding pathfinding = new Pathfinding(); //returns the last action type which the player will execute in this round. pathfinding.PlayerAtSpecificRound(player, 1, out type); if (type == ActionType.Tackle) { tacklePlayers.Add(player); } } return tacklePlayers; }
// Use this for initialization void Start() { //Select your pathfinding graph = new Pathfinding(); graph.Load("Windywyll"); graph.setNeighbors(); // GameObject[] temp = GameObject.FindGameObjectsWithTag("Target"); enemies = new List<GameObject>(temp); enemies.Remove(gameObject); target = enemies[Random.Range(0, enemies.Count)]; road = PathfindingManager.GetInstance().GetRoad(transform.position, target.transform.position, graph); InvokeRepeating("UpdateRoad", 0.5f, 0.5f); Debug.Log(PathfindingManager.GetInstance().test); }
/// <summary> /// For the case that the enemy has the ball and is close to the own goal. /// </summary> /// <param name="player">The player who will execute the action</param> /// <returns></returns> public virtual PlayerAction ActionEnemyClose(Player player) { Pathfinding pathfinding = new Pathfinding(); Team enemyTeam = GameAI.GetEnemyTeam(GameAI.PlayersTeam(player)); ActionType type; List<Player> nearPlayersToPenaltyPoint = GameAI.NearestPlayersToPoint(enemyTeam, GameAI.PenaltyKickPoint(enemyTeam.TeamGoal), 2, 1, false); Player nearPlayer; if (nearPlayersToPenaltyPoint.ElementAt(0).Equals(player)) { nearPlayer = nearPlayersToPenaltyPoint.ElementAt(1); } else { nearPlayer = nearPlayersToPenaltyPoint.ElementAt(0); } Point nextPlayerLocation = pathfinding.PlayerAtSpecificRound(nearPlayer, 1, out type); return new PlayerAction(null, nextPlayerLocation, ActionType.Run); }
public static void ShowRecastNavmesh(DbgRenderMesh renderMesh, PolyMeshAsset.PolyMeshData pmesh, Pathfinding.Config config) { renderMesh.Clear(); UnityEngine.Random.seed = c_RandomSeed; int npolys = pmesh.npolys; int nvp = pmesh.nvp; int[] tri = new int[3]; Vector3[] verts = new Vector3[3]; for (int i = 0; i < npolys; ++i) { int pIndex = i * nvp * 2; Color col = new Color(UnityEngine.Random.value, UnityEngine.Random.value, UnityEngine.Random.value); for (int j = 2; j < nvp; ++j) { if (pmesh.polys[pIndex + j] == RC_MESH_NULL_IDX) break; tri[0] = pmesh.polys[pIndex]; tri[1] = pmesh.polys[pIndex + j - 1]; tri[2] = pmesh.polys[pIndex + j]; for (int k = 0; k < 3; ++k) { int vIndex = tri[k] * 3; verts[k].x = config.bmin[0] + pmesh.verts[vIndex + 0] * pmesh.cs; verts[k].y = config.bmin[1] + (pmesh.verts[vIndex + 1] + 1) * pmesh.ch + 0.1f; verts[k].z = config.bmin[2] + pmesh.verts[vIndex + 2] * pmesh.cs; } col = VaryColor(col); renderMesh.AddTriangle(new DbgRenderTriangle(verts[0], verts[1], verts[2], col)); } } renderMesh.Rebuild(); }
// Start is called before the first frame update void Start() { pathFinding = new Pathfinding(10, 10, 1, Vector3.zero); }
protected new void Awake() { base.Awake(); sm = GameObject.FindWithTag("MainCamera").GetComponent<StateMachine>(); nametag = gameObject.AddComponent<Nametag>(); pathfinding = gameObject.AddComponent<Pathfinding>(); d20 = gameObject.AddComponent<D20>(); }
public IEnumerator EnemyMove(int rows, int columns, List <Vector3> currentUnwalkables) { UnitState priorState = state; state = UnitState.BUSY; if (dead || stun) { state = priorState; yield break; } targets = GameObject.FindGameObjectsWithTag("Player"); int temp = int.MaxValue; List <PathNode> tempPath = new List <PathNode>(); foreach (GameObject t in targets) { /*if (t.GetComponent<MovingObject>().health < tHealth) * { * tHealth = t.GetComponent<MovingObject>().health; * target = t.transform; * * currentUnwalkables.Remove(target.position); * * currentUnwalkables.Remove(transform.position); * * pathfinding = new Pathfinding(columns, rows, currentUnwalkables); * * path = pathfinding.FindPath((int)transform.position.x, (int)transform.position.y, (int)target.position.x, (int)target.position.y); * }*/ currentUnwalkables.Remove(t.transform.position); currentUnwalkables.Remove(transform.position); pathfinding = new Pathfinding(columns, rows, currentUnwalkables); path = pathfinding.FindPath((int)transform.position.x, (int)transform.position.y, (int)t.transform.position.x, (int)t.transform.position.y); if (path != null && path.Count < temp) { temp = path.Count; tempPath = path; target = t.transform; } else { path = tempPath; } currentUnwalkables.Add(t.transform.position); } if (path == null) { Debug.Log("No possible routes to targets!"); yield break; } if (path.Count == 0) { ChangeFacingDirection(target.position - transform.position); if (ReadyAbility(0)) { yield return(new WaitForSeconds(.5f)); CastAbility(); } yield return(null); } else { for (int i = 0; energy > 0 && i < path.Count; i++) { facingDirection = path[i].coord - transform.position; ChangeFacingDirection(facingDirection); yield return(StartCoroutine(Move((int)facingDirection.x, (int)facingDirection.y))); if (health <= 0 || stun) { state = priorState; yield break; } //yield return new WaitForSeconds(.1f); if (Vector3.Distance(transform.position, target.position) <= 1) { ChangeFacingDirection(target.position - transform.position); if (ReadyAbility(0)) { yield return(new WaitForSeconds(.5f)); CastAbility(); } } } } state = priorState; target = null; }
private void Start() { this.pathfinding = new Pathfinding(10, 10); Instantiate(pacmanPrefab); }
private static void calcTightTileBounds(Pathfinding.TileCacheLayerHeader header, ref float[] bmin, ref float[] bmax, float cs) { bmin[0] = header.bmin[0] + header.minx* cs; bmin[1] = header.bmin[1]; bmin[2] = header.bmin[2] + header.miny* cs; bmax[0] = header.bmin[0] + (header.maxx+1)*cs; bmax[1] = header.bmax[1]; bmax[2] = header.bmin[2] + (header.maxy+1)*cs; }
void Awake() { instance = this; pathfinding = GetComponent <Pathfinding>(); }
private void Awake() { pf = GameObject.Find("GameManager").GetComponent <Pathfinding>(); }
void Awake() { pathfinding = GameObject.Find("BattleManager").GetComponent<Pathfinding>(); }
private void Awake() { pathfinding = GetComponent <Pathfinding>(); }
public override bool Update(int tick) { if (tasks != null) { if (tasks.First().TaskComplete(this)) { tasks.RemoveAt(0); if (currentPath != null && isEnd(this)) { this.rack.Move(this.x + 1000, this.y, this.z); this.rack = null; this.Move(this.x, this.y, this.z + 90); currentPath = Pathfinding.Listnodes(currentNode, "Y" + this._name, Pathfinding.listOfNodes, this.path); this.AddTask(new TruckMove(currentPath)); } if (tasks.Count == 0) { tasks = null; } else { tasks.First().StartTask(this); } } } if (this.rack != null) { this.rack.Move(this.x, this.y + 1, this.z + 1.5); if (tasks == null) { currentPath.Clear(); this.currentPath = Pathfinding.Listnodes(currentNode, "Z" + this._name, Pathfinding.listOfNodes, this.path); tasks = new List <ITruckTask>(); this.AddTask(new TruckMove(this.currentPath)); } } if (this.currentPath != null && this.currentPath.Count != 0) { this._x = Math.Round(this._x, 1); this._z = Math.Round(this._z, 1); if (this._x < currentPath[0].GetX()) { this.Move(this.x + 0.1, this.y, this.z); } else if (this._x > currentPath[0].GetX()) { this.Move(this.x - 0.1, this.y, this.z); } else if (this._z < currentPath[0].GetZ()) { this.Move(this.x, this.y, this.z + 0.1); } else if (this._z > currentPath[0].GetZ()) { this.Move(this.x, this.y, this.z - 0.1); } else { this.currentNode = currentPath[0].GetName(); currentPath.RemoveAt(0); } } return(base.Update(tick)); }
void GenerateBoard() { GameObject go = Resources.Load <GameObject>(FilePath.TilePrefab); SavedDatabase <TileTypes> tileDB = Globals.campaign.GetTileData().Tiles; int sizeX = currMap.sizeX; int sizeY = currMap.sizeY; pathfinding = new Pathfinding(sizeX, sizeY); EffectBoard = new TileEffectSprite[sizeX, sizeY]; for (int x = 0; x < sizeX; x++) { for (int y = 0; y < sizeY; y++) { //Heres where we'll probably adjust the height map stuff GameObject temp = Instantiate(go, transform); TileData data = new TileData(x, y); // maybe we should create a new board that will just replace the board in the current // map? TileTypes types = tileDB.GetCopy(currMap.tileBoard[x, y]); //currMap.tileBoard[x, y] = types; Tile newTile = temp.GetComponent <Tile>(); temp.GetComponent <Tile>().InitTile(data, types); pathfinding.AddTile(newTile, x, y); // temp.transform.position = Globals.HeightCorrectedPosition(pathfinding.tiles[x, y]); temp.transform.position = Globals.GridToWorld(x, y); temp.GetComponent <SpriteRenderer>().sprite = atlas.GetSprite(types.spriteFilePath); temp.name = x + " " + y; // we create a concection between the tile effects on the map and the } } if (currentMission.started == false) { foreach (Tuple <MapCoords, List <string> > key in currentMission.initTileEffects) { int x = key.ele1.X; int y = key.ele1.Y; List <TileEffect> effects = new List <TileEffect>(); foreach (string s in key.ele2) { effects.Add(Globals.campaign.GetTileData().Effects.GetCopy(s)); } pathfinding.tiles[x, y].tileEffects = effects; pathfinding.tiles[x, y].InitTileEffect(); pathfinding.tiles[x, y].InitTileEffectsVisuals(); pathfinding.tiles[x, y].ProcessEffectQueue(); } } pathfinding.PopulateNieghbors(); }
public Pathfinding(int width, int height, float cellSize, Vector3 position) { Instance = this; grid = new CustomGrid <PathNode>(width, height, cellSize, position, (CustomGrid <PathNode> g, int x, int z) => new PathNode(g, x, z), true); }
void Awake() { instance = this; grid = GetComponent <Grid>(); }
public byte[] SerializeGraphs (Pathfinding.Serialization.SerializeSettings settings, out uint checksum) { Pathfinding.Serialization.AstarSerializer sr = new Pathfinding.Serialization.AstarSerializer(script.astarData, settings); sr.OpenSerialize(); script.astarData.SerializeGraphsPart (sr); sr.SerializeEditorSettings (graphEditors); byte[] bytes = sr.CloseSerialize(); checksum = sr.GetChecksum (); return bytes; //Forward to runtime serializer //return script.astarData.SerializeGraphs(Pathfinding.Serialization.SerializeSettings.Settings, out checksum); }
private void Awake() { instance = this; pathfinding = GetComponent <Pathfinding>(); pathRequestQueue = new Queue <PathRequest>(); }
public byte[] SerializeGraphs (Pathfinding.Serialization.SerializeSettings settings, out uint checksum) { byte[] bytes = null; uint ch = 0; AstarPath.active.AddWorkItem (new AstarPath.AstarWorkItem (delegate (bool force) { Pathfinding.Serialization.AstarSerializer sr = new Pathfinding.Serialization.AstarSerializer(script.astarData, settings); sr.OpenSerialize(); script.astarData.SerializeGraphsPart (sr); sr.SerializeEditorSettings (graphEditors); bytes = sr.CloseSerialize(); ch = sr.GetChecksum (); #if ASTARDEBUG Debug.Log ("Got a whole bunch of data, "+bytes.Length+" bytes"); #endif return true; })); //Make sure the above work item is run directly AstarPath.active.FlushWorkItems(); checksum = ch; return bytes; //Forward to runtime serializer //return script.astarData.SerializeGraphs(Pathfinding.Serialization.SerializeSettings.Settings, out checksum); }
public Pathfinding(int width, int height, Vector3 origin) { Instance = this; grid = new Grid <PathNode>(width, height, 1f, origin, (Grid <PathNode> g, int x, int y) => new PathNode(g, x, y)); this.origin = origin; }
// Use this for initialization void Start() { //theStateMachine = new StateMachineAntoine(gameObject); graph = new Pathfinding(); graph.Load("antoinePathFinding"); graph.setNeighbors(); SpawnPos = transform.position; //int rand = Random.Range(0, nodes.transform.childCount - 1); //target = nodes.transform.GetChild(rand).gameObject; //PathPoint = points[index].transform.position; enemies = GameObject.FindGameObjectsWithTag("Target"); for (int i = 0; i < enemies.Length; i++) { if (enemies[i] == gameObject) { enemies[i] = null; } else if (enemies[i] == bro1) { enemies[i] = null; } else if (enemies[i] == bro2) { enemies[i] = null; } } InvokeRepeating("ChangeColor", 0.5f, 0.1f); InvokeRepeating("FindNewTarget", 0f, 0.5f); InvokeRepeating("Calc", 0f, 1.0f); isMoving = false; isShooting = false; canShoot = true; bullet = Resources.Load("Bullet") as GameObject; finished = false; decisionTree = new SelectorAntoine(); SequenceAntoine s1 = new SequenceAntoine(); FiltreAntoine f1 = new FiltreAntoine(DelegateInvertBool); TaskAntoineDelegate delegateSeePlayer = new TaskAntoineDelegate(HaveTarget); SelectorAntoine se1 = new SelectorAntoine(); SequenceAntoine s2 = new SequenceAntoine(); TaskAntoineDelegate delegateCanShoot = new TaskAntoineDelegate(GetCanShootDelegate); TaskAntoineDelegate delegateShootBullet = new TaskAntoineDelegate(ShootBullet); TaskAntoineDelegate delegateDodge = new TaskAntoineDelegate(DelegateDodge); SelectorAntoine se2 = new SelectorAntoine(); SequenceAntoine s4 = new SequenceAntoine(); TaskAntoineDelegate delegateDistance = new TaskAntoineDelegate(DelegateDistance); TaskAntoineDelegate delegateChase = new TaskAntoineDelegate(DelegateChase); TaskAntoineDelegate delegatePatrol = new TaskAntoineDelegate(DelegatePatrol); decisionTree.AddNode(s1); decisionTree.AddNode(se2); //s1.AddNode(f1); s1.AddNode(delegateSeePlayer); s1.AddNode(se1); // f1.AddNode(delegateSeePlayer); se1.AddNode(s2); se1.AddNode(delegateDodge); s2.AddNode(delegateCanShoot); s2.AddNode(delegateShootBullet); se2.AddNode(s4); se2.AddNode(delegatePatrol); s4.AddNode(delegateDistance); s4.AddNode(delegateChase); }
public Pathfinding(int width, int height, float CellSize, Vector3 originPosition) { Instance = this; Grid = new Grid <PathNode>(width, height, CellSize, originPosition, (Grid <PathNode> g, int x, int y) => new PathNode(g, x, y)); }
// Start is called before the first frame update void Start() { pathfinding = new Pathfinding(20, 20); }
private void Start() { pathfinding = FindObjectOfType <Pathfinding>(); }
private void Awake() { pathfinding = GameObject.FindGameObjectWithTag("Navigation").GetComponent <Pathfinding>(); }
void Awake() { base.Awake(); pathfinding = GetComponent <Pathfinding>(); }
//Constructor public Pathfinding(int width, int height, Vector3 originPosition, LayerMask[] unwalkableMasks, float walkableCheckRadius, bool showDebug) { Instance = this; grid = new GridSystem <PathNode>(width, height, 1, originPosition, (GridSystem <PathNode> grid, int x, int y) => new PathNode(grid, x, y, originPosition, unwalkableMasks), showDebug); this.walkableCheckRadius = walkableCheckRadius; }
public bool RunAround(IAbilityUnit unit, Vector3 target) { if (this.Unit.SourceUnit.MovementSpeed <= unit.SourceUnit.MovementSpeed) { return(false); } var unitPosition = this.Unit.Position.PredictedByLatency; var targetPosition = unit.Position.PredictedByLatency; if (target.Distance2D(targetPosition) < 200) { this.Unit.SourceUnit.Move(unit.SourceUnit.InFront(250)); return(true); } if (this.Unit.Position.PredictedByLatency.Distance2D(target) < unit.Position.PredictedByLatency.Distance2D(target) || this.Unit.Position.PredictedByLatency.Distance2D(unit.Position.PredictedByLatency) > 250) { return(false); } var infront = unit.SourceUnit.InFront(500); // infront = // this.Target.SourceUnit.InFront( // (this.Unit.Position.Current.Distance2D(infront) / this.Unit.SourceUnit.MovementSpeed) // * this.Target.SourceUnit.MovementSpeed); var backWardsdirection = (targetPosition - infront).Normalized(); var projectionInfo = Vector3Extensions.ProjectOn(targetPosition, unitPosition, infront); var projectionInfo2 = Vector3Extensions.ProjectOn( unitPosition, targetPosition + backWardsdirection * (unitPosition.Distance2D(targetPosition) + 200), infront); var isCloserToFront = unitPosition.Distance2D(infront) + this.Unit.SourceUnit.HullRadius + unit.SourceUnit.HullRadius + 100 < targetPosition.Distance2D(infront); var distanceFromSegment2 = unitPosition.Distance2D( Vector2Extensions.ToVector3(projectionInfo2.SegmentPoint)); var canBlock = (projectionInfo2.IsOnSegment || distanceFromSegment2 < unit.SourceUnit.HullRadius / 2) && isCloserToFront; if (!canBlock && (projectionInfo.IsOnSegment || targetPosition.Distance2D(Vector2Extensions.ToVector3(projectionInfo.SegmentPoint)) < unit.SourceUnit.HullRadius + this.Unit.SourceUnit.HullRadius + 20)) { var direction = (infront - targetPosition).Normalized(); var direction1 = (infront - targetPosition).Perpendicular().Normalized(); var direction2 = (targetPosition - infront).Perpendicular().Normalized(); // Console.WriteLine(direction1 + " " + direction2); var position = Pathfinding.ExtendUntilWall( targetPosition, direction1, Math.Max(unit.SourceUnit.HullRadius + this.Unit.SourceUnit.HullRadius + 100, distanceFromSegment2), this.Unit.Pathfinder.EnsagePathfinding); var position2 = Pathfinding.ExtendUntilWall( targetPosition, direction2, Math.Max(unit.SourceUnit.HullRadius + this.Unit.SourceUnit.HullRadius + 100, distanceFromSegment2), this.Unit.Pathfinder.EnsagePathfinding); var distance = unitPosition.Distance2D(position); var distance2 = unitPosition.Distance2D(position2); if (distance2 < distance) { distance = distance2; position = position2; } if (!isCloserToFront) { if (distanceFromSegment2 < unit.SourceUnit.HullRadius + this.Unit.SourceUnit.HullRadius + 50) { infront = Pathfinding.ExtendUntilWall(position, direction, distance + 500, this.Unit.Pathfinder.EnsagePathfinding); } else { infront = Pathfinding.ExtendUntilWall(unitPosition, direction, 500, this.Unit.Pathfinder.EnsagePathfinding); } } // else // { // infront = Pathfinding.ExtendUntilWall(unitPosition, direction, 300, this.Pathfinder); // } } else { return(false); } this.Unit.SourceUnit.Move(infront); return(true); }
public byte[] SerializeGraphs(Pathfinding.Serialization.SerializeSettings settings, out uint checksum) { Pathfinding.Serialization.AstarSerializer sr = new Pathfinding.Serialization.AstarSerializer(script.astarData, settings); sr.OpenSerialize(); script.astarData.SerializeGraphsPart (sr); sr.SerializeEditorSettings (graphEditors); byte[] bytes = sr.CloseSerialize(); checksum = sr.GetChecksum (); #if ASTARDEBUG Debug.Log ("Got a whole bunch of data, "+bytes.Length+" bytes"); #endif return bytes; //Forward to runtime serializer //return script.astarData.SerializeGraphs(Pathfinding.Serialization.SerializeSettings.Settings, out checksum); }
public static void SetTagField (GUIContent label, ref Pathfinding.TagMask value) { GUILayout.BeginHorizontal (); //Debug.Log (value.ToString ()); EditorGUIUtility.LookLikeControls(); EditorGUILayout.PrefixLabel (label,EditorStyles.layerMaskField); //GUILayout.FlexibleSpace (); //Rect r = GUILayoutUtility.GetLastRect (); string text = ""; if (value.tagsChange == 0) text = "Nothing"; else if (value.tagsChange == ~0) text = "Everything"; else { text = System.Convert.ToString (value.tagsChange,2); } string[] tagNames = AstarPath.FindTagNames (); if (GUILayout.Button (text,EditorStyles.layerMaskField,GUILayout.ExpandWidth (true))) { //Debug.Log ("pre"); GenericMenu menu = new GenericMenu (); menu.AddItem (new GUIContent ("Everything"),value.tagsChange == ~0, value.SetValues, new Pathfinding.TagMask (~0,value.tagsSet)); menu.AddItem (new GUIContent ("Nothing"),value.tagsChange == 0, value.SetValues, new Pathfinding.TagMask (0,value.tagsSet)); for (int i=0;i<tagNames.Length;i++) { bool on = (value.tagsChange >> i & 0x1) != 0; Pathfinding.TagMask result = new Pathfinding.TagMask (on ? value.tagsChange & ~(1 << i) : value.tagsChange | 1<<i,value.tagsSet); menu.AddItem (new GUIContent (tagNames[i]),on,value.SetValues, result); //value.SetValues (result); } menu.AddItem (new GUIContent ("Edit Tags..."),false,AstarPathEditor.EditTags); menu.ShowAsContext (); Event.current.Use (); //Debug.Log ("Post"); } EditorGUIUtility.LookLikeInspector(); GUILayout.EndHorizontal (); }
void Start() { pF = GetComponent <Pathfinding>(); }
// // Constructors // public Thread (Pathfinding.WindowsStore.ParameterizedThreadStart start) { this._taskCancellationTokenSource = new CancellationTokenSource (); this._paramThreadStart = start; }
public byte[] SerializeGraphs (Pathfinding.Serialization.SerializeSettings settings, out uint checksum) { byte[] bytes = null; uint ch = 0; // Add a work item since we cannot be sure that pathfinding (or graph updates) // is not running at the same time AstarPath.active.AddWorkItem (new AstarPath.AstarWorkItem (force => { var sr = new Pathfinding.Serialization.AstarSerializer(script.astarData, settings); sr.OpenSerialize(); script.astarData.SerializeGraphsPart (sr); sr.SerializeEditorSettings (graphEditors); bytes = sr.CloseSerialize(); ch = sr.GetChecksum (); return true; })); // Make sure the above work item is executed immediately AstarPath.active.FlushWorkItems(); checksum = ch; return bytes; }
void Start() { mod = Vector3.zero; pathfinding = GetComponent<Pathfinding>(); }
public Pathfinding(int width, int height) { Instance = this; grid = new GridSystem <PathNode>(width, height, 10f, Vector3.zero, (GridSystem <PathNode> g, int x, int y) => new PathNode(g, x, y)); }
//public Node parent; // Use this for initialization void Start() { aStar = GameObject.Find("A*").GetComponent <Pathfinding>(); }
void Awake() { grid = GetComponent<Grid>(); instance = this; }
public bool Bodyblock() { var unitPosition = this.Unit.Position.PredictedByLatency; this.targetPosition = this.Target.Position.PredictedByLatency; var infront = this.Target.SourceUnit.InFront(1000); // infront = // this.Target.SourceUnit.InFront( // (this.Unit.Position.Current.Distance2D(infront) / this.Unit.SourceUnit.MovementSpeed) // * this.Target.SourceUnit.MovementSpeed); var backWardsdirection = (this.targetPosition - infront).Normalized(); var projectionInfo = Vector3Extensions.ProjectOn(this.targetPosition, unitPosition, infront); var projectionInfo2 = Vector3Extensions.ProjectOn( unitPosition, this.targetPosition + backWardsdirection * (unitPosition.Distance2D(this.targetPosition) + 200), infront); var distanceFromSegment2 = this.Unit.Position.Current.Distance2D(Vector2Extensions.ToVector3(projectionInfo2.SegmentPoint)); var isCloserToFront = projectionInfo2.SegmentPoint.Distance(infront) + this.Unit.SourceUnit.HullRadius + this.Target.SourceUnit.HullRadius + 50 < this.targetPosition.Distance2D(infront) && unitPosition.Distance2D(infront) < this.targetPosition.Distance2D(infront); var angle = this.Unit.SourceUnit.FindRelativeAngle(infront); // Console.WriteLine(angle + " " + Math.PI / 4); var goodposition = projectionInfo2.IsOnSegment && isCloserToFront; this.wasMoving = this.Unit.SourceUnit.NetworkActivity == NetworkActivity.Move; this.targetWasMoving = this.Target.SourceUnit.NetworkActivity == NetworkActivity.Move; this.lastRad = this.Target.SourceUnit.RotationRad; var idleTime = this.Target.MovementTracker.IdleTime(); if (isCloserToFront && idleTime < 1) { if (this.Unit.TargetSelector.LastDistanceToTarget > this.Target.SourceUnit.HullRadius + this.Unit.SourceUnit.HullRadius + this.Target.SourceUnit.MovementSpeed * (Game.Ping / 1000) * 2 + 200 || angle > Math.PI / 6 || !goodposition) { // Console.WriteLine("1"); this.moveOrderWasSent = true; this.Bodyblocking = true; return (this.Unit.SourceUnit.Move( this.Target.SourceUnit.InFront( this.Target.SourceUnit.HullRadius + this.Unit.SourceUnit.HullRadius + 150 + this.Target.SourceUnit.MovementSpeed * (Game.Ping / 1000) * 2))); } } if (goodposition) { if ((this.wasMoving || this.moveOrderWasSent) && this.Target.SourceUnit.CanMove() && idleTime < 1) { // Console.WriteLine("2"); this.moveOrderWasSent = false; this.issueSleeper.Sleep( this.IssueSleep + (this.Target.SourceUnit.HullRadius + this.Unit.SourceUnit.HullRadius * 2) / this.Target.SourceUnit.MovementSpeed * 1000); this.Bodyblocking = true; return(this.Stop()); } if (!this.Target.SourceUnit.CanMove() || idleTime >= 1) { // Console.WriteLine("3"); this.moveOrderWasSent = false; return(this.CantMove()); } // Console.WriteLine("5"); this.moveOrderWasSent = true; this.issueSleeper.Sleep( this.IssueSleep + (this.Target.SourceUnit.HullRadius + this.Unit.SourceUnit.HullRadius) / this.Target.SourceUnit.MovementSpeed * 1000); this.Bodyblocking = true; return (this.Unit.SourceUnit.Move( this.Target.SourceUnit.InFront( this.Target.SourceUnit.HullRadius + this.Unit.SourceUnit.HullRadius + 200 + this.Target.SourceUnit.MovementSpeed * (Game.Ping / 1000) * 2))); return(this.Stop()); // this.moveOrderWasSent = false; return(false); } // Console.WriteLine("4"); var canBlock = (this.wasMoving || this.moveOrderWasSent) && goodposition; if (!canBlock && (projectionInfo.IsOnSegment || this.targetPosition.Distance2D(Vector2Extensions.ToVector3(projectionInfo.SegmentPoint)) < this.Target.SourceUnit.HullRadius + this.Unit.SourceUnit.HullRadius + 20)) { var direction = (infront - this.targetPosition).Normalized(); var direction1 = (infront - this.targetPosition).Perpendicular().Normalized(); var direction2 = (this.targetPosition - infront).Perpendicular().Normalized(); // Console.WriteLine(direction1 + " " + direction2); var position = Pathfinding.ExtendUntilWall( this.targetPosition, direction1, Math.Max( this.Target.SourceUnit.HullRadius + this.Unit.SourceUnit.HullRadius + 100, distanceFromSegment2), this.Unit.Pathfinder.EnsagePathfinding); var position2 = Pathfinding.ExtendUntilWall( this.targetPosition, direction2, Math.Max( this.Target.SourceUnit.HullRadius + this.Unit.SourceUnit.HullRadius + 100, distanceFromSegment2), this.Unit.Pathfinder.EnsagePathfinding); var distance = unitPosition.Distance2D(position); var distance2 = unitPosition.Distance2D(position2); if (distance2 < distance) { distance = distance2; position = position2; } if (!isCloserToFront) { if (distanceFromSegment2 < this.Target.SourceUnit.HullRadius + this.Unit.SourceUnit.HullRadius + 50) { infront = Pathfinding.ExtendUntilWall( position, direction, distance + 500, this.Unit.Pathfinder.EnsagePathfinding); } else { infront = Pathfinding.ExtendUntilWall( unitPosition, direction, 500, this.Unit.Pathfinder.EnsagePathfinding); } } // else // { // infront = Pathfinding.ExtendUntilWall(unitPosition, direction, 300, this.Pathfinder); // } } else { // if (!this.Target.SourceUnit.CanMove() || !this.targetWasMoving) // { // this.moveOrderWasSent = false; // return this.CantMove(); // } infront = this.Target.SourceUnit.InFront( this.Target.SourceUnit.HullRadius + this.Unit.SourceUnit.HullRadius + 300 + this.Target.SourceUnit.MovementSpeed * (Game.Ping / 1000) * 2); // this.moveOrderWasSent = false; // return false; } this.moveOrderWasSent = true; this.Unit.SourceUnit.Move(infront); this.Bodyblocking = false; return(true); }
// Use this for initialization void Start () { path = new List<Vector3>(); pathfinder = GetComponent<Pathfinding>(); animationator = GetComponent<Animationator>(); }
public IEnumerator TurnCycle(Team team, Team team2) { while (team.AnySoldierActionsLeft()) { int lastCommand = attackCommand; // *** PLAYER *** // Right click on any slot moves active unit there. GridSlot hitSlot = GetGridUnderMouse(); if (hitSlot != null) { MapNode[] path = Pathfinding.FindPathAStar(team.ActiveSoldier.curPositionSlot.transform.position, hitSlot.transform.position, MapGrid.wholeMap); // mouse clicks if (hitSlot && Input.GetMouseButtonDown(1) && team.ActiveSoldier.NearEnough(path.Length)) { // shoot at enemy if (hitSlot.HasEnemy()) { attackCommand = 1; uiCommandKey = 0; // Require 2 clicks to auto attack enemy if (!clickedOnce) { clickedOnce = true; } else { clickedOnce = false; targetedEnemy = hitSlot.taken.soldierId; //flags[0].MoveActiveToRaycastedPoint(hit); team.ActiveSoldier.AttackSlot(hitSlot); SwapSoldierIfNoTurns(team); } } else { // move to slot attackCommand = -1; targetedEnemy = -1; uiCommandKey = -1; yield return(team.ActiveSoldier.StartCoroutine(MoveToSlot(team, team2, hitSlot, path))); } } // fire at nearest enemy if (Input.GetKeyDown(KeyCode.Alpha1)) { attackCommand = 2; uiCommandKey = 0; Soldier nearestEnemy = team2.GetNearestTo(team.ActiveSoldier); if (nearestEnemy) { targetedEnemy = nearestEnemy.soldierId; if (!clickedOnce) { clickedOnce = true; } else { clickedOnce = false; team.ActiveSoldier.AttackSlot(nearestEnemy.curPositionSlot); SwapSoldierIfNoTurns(team); } } } // grenade throw if (hitSlot && Input.GetKeyDown(KeyCode.Alpha3)) { attackCommand = 3; uiCommandKey = 2; if (!clickedOnce) { clickedOnce = true; } else { clickedOnce = false; team.ActiveSoldier.AttackSlot(hitSlot, 1); SwapSoldierIfNoTurns(team); } } // overwatch if (Input.GetKeyDown(KeyCode.Alpha2)) { attackCommand = 4; uiCommandKey = 1; if (!clickedOnce) { clickedOnce = true; } else { clickedOnce = false; team.ActiveSoldier.ToOverwatch(); SwapSoldierIfNoTurns(team); } } // reload if (Input.GetKeyDown(KeyCode.R)) { attackCommand = 5; uiCommandKey = 3; if (!clickedOnce) { clickedOnce = true; } else { clickedOnce = false; team.ActiveSoldier.Reload(); SwapSoldierIfNoTurns(team); } } // FIXED: it will work to click on enemy with right click and then 1. // makes sure you can't do mouse+something else attack if (attackCommand != lastCommand && lastCommand != 0) { clickedOnce = false; } // tabbing swaps units if (Input.GetKeyDown(KeyCode.Tab)) { if (targetedEnemy == -1) { SwapSoldier(team); } else { SwapTarget(team); } } // *** ENEMIES *** deprecated // if enemy moves, trigger all overwatched player's soldiers // AI: move all enemies /*for (int i = 0; i < team2.units.Count; i++) { * // trigger player's overwatch * HandleOverwatchWithoutFog(team2.units[i], team); * }*/ } yield return(null); } }
public Vector3 ApplyVector3(Vector3 to,Vector3 from,Pathfinding.Constraint3 constraints){ Vector3 result = to; if(constraints.a) result.x = from.x; if(constraints.b) result.y = from.y; if(constraints.c) result.z = from.z; return result; }
public IEnumerator TurnCycle(Team team, Team team2) { // AI calculations list of commands // yield return execute calculated commands and moves yield return(new WaitForSeconds(5)); Debug.Log("End Enemy turn"); /*stategies: * Scoring nearby slots based on utility. * n^2 n = around 20 = 400 per character * */ for (int i = 0; i < team.units.Count; i++) { Soldier unit = team.units[i]; //Generate data for all slots in move range and for soldiers in range that can be attacked. taken move slots are excluded. GridSlot[] slots = GridSlot.GetAvaliableSlotsInMoveRange(unit.curPositionSlot, unit.fullMovementRange); Soldier[] enemiesInRange = GridSlot.GetVisibleEnemySlots(unit, team2); AiSlotData[] moveData = new AiSlotData[slots.Length]; AiSlotData[] enemyData = new AiSlotData[enemiesInRange.Length]; moveScores = new int[moveData.Length]; enemyScores = new int[enemyData.Length]; for (int j = 0; j < slots.Length; j++) { moveData[j] = new AiSlotData(slots[j].id); } for (int j = 0; j < enemyData.Length; j++) { enemyData[j] = new AiSlotData(enemiesInRange[j].soldierId); } // Calculations have to be remade for every slots for every enemy. Not good. // Utility score. // + when enemies are on slot. +100 // + cover height +0 +50 +100 // - distance to enemy (gt dist, less) // /* how to choose to move vs choose to attack * just distance * */ // here we choose which actions will be prioritized, movement or shooting. int possibleMoveActions = 0; int attack = -1; if (enemiesInRange.Length == 0) { continue; } attack = 0; // shoot, when there are some enemies float dist = Vector3.Distance(enemiesInRange[0].transform.position, unit.transform.position); if (dist <= unit.movementRange1) { possibleMoveActions = 1; } if (enemiesInRange.Length == 0) { possibleMoveActions = 2; attack = -1; } int bestId = -1; int best = 0; // calculates scores for movement slots for (int j = 0; j < moveData.Length; j++) { moveData[j].score = (int)(ClampedReverseDist(unit, unit.fullMovementRange, slots, j) * MapGrid.CoverScoreMultiplier(slots[j])); if (moveData[j].score > best) { best = moveData[j].score; bestId = j; } moveScores[j] = moveData[j].score; } GameplayManager.m.moveScores = moveScores; int bestMoveDataId = bestId; GridSlot bestMove = slots[bestMoveDataId]; MapNode[] path = Pathfinding.FindPathAStar(unit.curPositionSlot.transform.position, bestMove.transform.position, MapGrid.wholeMap); yield return(unit.StartCoroutine(MoveToSlot(team, team2, bestMove, path))); if (attack != -1) { // calculates scores for enemies bestId = -1; for (int j = 0; j < enemyData.Length; j++) { enemyData[j].score = (int)(ClampedDist(enemiesInRange[j], 100, slots, j) * MapGrid.CoverScoreMultiplier(enemiesInRange[j].curPositionSlot)); if (enemyData[j].score > best) { best = enemyData[j].score; bestId = j; } enemyScores[j] = enemyData[j].score; } int bestEnemyDataId = bestId; if (bestEnemyDataId != -1) { Soldier bestEnemy = enemiesInRange[bestEnemyDataId]; unit.AttackSlot(bestEnemy.curPositionSlot); GameplayManager.m.enemyScores = enemyScores; } else { Debug.Log("No enemies in range"); } } team.ActiveSoldier.HandleCover(); SwapSoldier(team); } }
Pathfinding pathfinding; // Reference to the pathfinding script // Executes at the start of a game private void Awake() { instance = this; // Makes sure there is only one instance of the class ? pathfinding = GetComponent <Pathfinding>(); // Loads the pathfinding functions }
private void GoingNowhere_OnStateBegin(object sender) { path.Clear(); path = Pathfinding.FindPath(GameLoop.World.PathingGrid, Position, Tile.GetCenter(GameLoop.World.GetTile(0, 0))); }
public static void TagsMaskField (GUIContent changeLabel, GUIContent setLabel,ref Pathfinding.TagMask value) { GUILayout.BeginHorizontal (); //Debug.Log (value.ToString ()); EditorGUIUtility.LookLikeControls(); EditorGUILayout.PrefixLabel (changeLabel,EditorStyles.layerMaskField); //GUILayout.FlexibleSpace (); //Rect r = GUILayoutUtility.GetLastRect (); string text = ""; if (value.tagsChange == 0) text = "Nothing"; else if (value.tagsChange == ~0) text = "Everything"; else { text = System.Convert.ToString (value.tagsChange,2); } if (GUILayout.Button (text,EditorStyles.layerMaskField,GUILayout.ExpandWidth (true))) { //Debug.Log ("pre"); GenericMenu menu = new GenericMenu (); menu.AddItem (new GUIContent ("Everything"),value.tagsChange == ~0, value.SetValues, new Pathfinding.TagMask (~0,value.tagsSet)); menu.AddItem (new GUIContent ("Nothing"),value.tagsChange == 0, value.SetValues, new Pathfinding.TagMask (0,value.tagsSet)); for (int i=0;i<32;i++) { bool on = (value.tagsChange >> i & 0x1) != 0; Pathfinding.TagMask result = new Pathfinding.TagMask (on ? value.tagsChange & ~(1 << i) : value.tagsChange | 1<<i,value.tagsSet); menu.AddItem (new GUIContent (""+i),on,value.SetValues, result); //value.SetValues (result); } menu.ShowAsContext (); Event.current.Use (); //Debug.Log ("Post"); } EditorGUIUtility.LookLikeInspector(); GUILayout.EndHorizontal (); GUILayout.BeginHorizontal (); //Debug.Log (value.ToString ()); EditorGUIUtility.LookLikeControls(); EditorGUILayout.PrefixLabel (setLabel,EditorStyles.layerMaskField); //GUILayout.FlexibleSpace (); //r = GUILayoutUtility.GetLastRect (); text = ""; if (value.tagsSet == 0) text = "Nothing"; else if (value.tagsSet == ~0) text = "Everything"; else { text = System.Convert.ToString (value.tagsSet,2); } if (GUILayout.Button (text,EditorStyles.layerMaskField,GUILayout.ExpandWidth (true))) { //Debug.Log ("pre"); GenericMenu menu = new GenericMenu (); if (value.tagsChange != 0) menu.AddItem (new GUIContent ("Everything"),value.tagsSet == ~0, value.SetValues, new Pathfinding.TagMask (value.tagsChange,~0)); else menu.AddDisabledItem (new GUIContent ("Everything")); menu.AddItem (new GUIContent ("Nothing"),value.tagsSet == 0, value.SetValues, new Pathfinding.TagMask (value.tagsChange,0)); for (int i=0;i<32;i++) { bool enabled = (value.tagsChange >> i & 0x1) != 0; bool on = (value.tagsSet >> i & 0x1) != 0; Pathfinding.TagMask result = new Pathfinding.TagMask (value.tagsChange, on ? value.tagsSet & ~(1 << i) : value.tagsSet | 1<<i); if (enabled) menu.AddItem (new GUIContent (""+i),on,value.SetValues, result); else menu.AddDisabledItem (new GUIContent (""+i)); //value.SetValues (result); } menu.ShowAsContext (); Event.current.Use (); //Debug.Log ("Post"); } EditorGUIUtility.LookLikeInspector(); GUILayout.EndHorizontal (); //return value; }
public virtual IEnumerator TurnSequence(List <Vector3> currentUnwalkables) { UnitStateChange(UnitState.BUSY); currentUnwalkables.Remove(transform.position); //List of possible paths to a targets List <PathNode> chosenPath = new List <PathNode>(); GameObject target = null; //Find all players GameObject[] targets = GameObject.FindGameObjectsWithTag("Player"); int minPathLength = boardRows * boardColumns; foreach (GameObject t in targets) { currentUnwalkables.Remove(t.transform.position); //Make sure the target is reachable. Pathfinding pathfinding = new Pathfinding(boardColumns, boardRows, currentUnwalkables); currentUnwalkables.Add(t.transform.position); //Reinsert target for the next iteration. List <PathNode> path = pathfinding.FindPath((int)transform.position.x, (int)transform.position.y, (int)t.transform.position.x, (int)t.transform.position.y); if (path != null && path.Count < minPathLength) { minPathLength = path.Count; chosenPath = path; target = t; } } /* * if (chosenPath == null || target == null) * { * Debug.Log("No possible routes to targets!"); * EndTurn(); * yield return null; * } * * * //yield return new WaitForSecondsRealtime(1); * if (chosenPath.Count == 0) * { * yield return StartCoroutine(EnemyAbility(target)); * yield return null; * } * * foreach (PathNode pn in chosenPath) * { * Debug.Log(pn.coord); * facingDirection = Vector3.Normalize(pn.coord - transform.position); * ChangeFacingDirection(facingDirection); * yield return StartCoroutine(Move((int)facingDirection.x, (int)facingDirection.y)); * * if (currentHealth <= 0) * { * yield break; * } * * if (Vector3.Distance(transform.position, target.transform.position) <= 1) * { * yield return StartCoroutine(EnemyAbility(target)); * } * }*/ EndTurn(); yield return(null); }
public Thread (Pathfinding.WindowsStore.ThreadStart start) { this._taskCancellationTokenSource = new CancellationTokenSource (); this._threadStart = start; }
private void Start() { pathfinder = GetComponent <Pathfinding>(); rb2d = GetComponent <Rigidbody2D>(); }
void Awake() { instance = this; pathfinding = GetComponent<Pathfinding> (); }
private void Start() { Instance = this; gc = FindObjectOfType <GameController>(); }