public void DrawAOOTLines(List <ATTile> path) { DestroyAOOPLines(); for (int i = 0; i < path.Count - 1; i++) { ATTile t = path [i]; if (t.FirstOccupant != actor.TileMovement) { continue; } ATTile n = path [i + 1]; foreach (Actor a in t.Reachers) { if (a.EnemiesWith(actor) && !n.Reachers.Contains(a) && !a.UsedReaction()) { DrawAOOPLineFrom(a.transform.position, actor.transform.position); //Draw line/sword from a to char.... } } } }
public void ActorMovedOutOfTile(ATTile current, ATTile dest) { movesThisRound += dest.MoveCostFor(this); foreach (Actor a in current.Reachers) { if (!a.EnemiesWith(this)) { continue; } //If you are moving out of a tile within reach for this reacher.... if (!a.TileMovement.TilesWithinAttackReach().Contains(dest) && !a.UsedReaction()) { GetComponent <AnimationTransform> ().Pause(); Attack opportunity = new Attack(a); //TODO: give player an option to use main/offhand for reaction //Hardcode offhand being false for now // IsOffhand optVal = new IsOffhand (false); (opportunity.ActionOptions [0] as AttackTypeOption).chosenChoice = new AttackTypeChoice(AttackType.MAINHAND_MELEE, a.CharSheet.MainHand()); opportunity.IsReaction = true; opportunity.LateSetTargetParameters(); opportunity.SetTarget(this); opportunity.OnFinished += FinishedGettingOpportunityAttacked; opportunity.Perform(); } } }
private void PotentialMousedOut(ATTile t) { if (OnPotentialTargetMousedOut != null) { OnPotentialTargetMousedOut(t); } }
void WalkingOutOfTile(string inDirection) { if (OnWalkedOutOfTile != null) { ATTile dest = null; ATTile now = MapManager.instance.TileAt(avatar.position); switch (inDirection) { case "WalkUp": dest = now.Up(); break; case "WalkDown": dest = now.Down(); break; case "WalkLeft": dest = now.Left(); break; case "WalkRight": dest = now.Right(); break; } OnWalkedOutOfTile(now, dest); } }
public void SetOccupyingTile(ATTile from, ATTile destination) { // Debug.Log ("Setting occupaancy for " + ActorComponent.GetType()); // Debug.Log ("Actors that sees dest: " + destination.actorsThatSeeThisTile.Count); if (from != null) { if (from.AllOccupants.Contains(this)) { from.RemoveOccupant(this, destination); } } //Fixes an odd bug where this function is called after moving into a tile, //where the moving creature was killed by a reaction. //The new tile would set reachers if (!ActorComponent.Dying) { occupying = destination; CycleReachTo(destination); destination.AddOccupant(this, from); } if (OnTileOccupancySet != null) { OnTileOccupancySet(destination); } }
public void CallOnWalkedOutOfTile(ATTile current, ATTile dest) { if (OnWalkedOutOfTile != null) { OnWalkedOutOfTile(current, dest); } }
private void CancelMovementOnLostVision(Actor enemyLostVisionOf) { movingToPosition.canceled = true; lastTileLostEnemyVisionOn = enemyLostVisionOf.TileMovement.occupying; enemyLostVisionOf.OnDidPerform -= CancelMovementIfEnemyActs; }
private void CheckInNow(ATTile t) { allTilesCached.Add(t); int tX = (int)t.transform.position.x; int tY = (int)t.transform.position.y; // Debug.Log ("fhiL: : " + tX + " " + tY); if (tX < minX || minX == NOT_SET) { minX = tX; } if (tX > maxX || maxX == NOT_SET) { maxX = tX; } if (tY > maxY || maxY == NOT_SET) { maxY = tY; } if (tY < minY || minY == NOT_SET) { minY = tY; } }
public void EmitActorMovedEvent(Actor mover, ATTile fromTile, ATTile toTile) { if (OnActorMovedEvent != null) { ActorMovedEvent evt = new ActorMovedEvent(mover, fromTile, toTile); OnActorMovedEvent(evt); } } //character event:
public void Reset() { if (listening) { StopListen(); } chosenTile = null; }
private void TargetClicked(ATTile t) { chosenTile = t; if (OnTargetTileChosen != null) { OnTargetTileChosen(this); } }
public bool TileHasEnemyReach(ATTile t) { foreach (Actor a in t.Reachers) { if (a.EnemiesWith(this.ActorComponent) && !a.UsedReaction()) { return(true); } } return(false); }
//uses a* algorithm to find the shortest path from start to finish public List <ATTile> AStarPath(ATTile start, ATTile finish) { ATTile startNode = start; ATTile targetNode = finish; List <ATTile> openSet = new List <ATTile> (); List <ATTile> closedSet = new List <ATTile> (); openSet.Add(startNode); while (openSet.Count > 0) { ATTile currentNode = openSet [0]; foreach (ATTile t in openSet) { if (t.FCost() < currentNode.FCost() || (t.FCost() == currentNode.FCost() && t.DistanceSquared(targetNode) < currentNode.DistanceSquared(targetNode))) { currentNode = t; } } openSet.Remove(currentNode); closedSet.Add(currentNode); if (currentNode == targetNode) { return(startNode.TracePathTo(targetNode)); } foreach (ATTile n in currentNode.Neighbors()) { if (!n.Occupyable() || closedSet.Contains(n)) { continue; } //TODO: I think this is where a* needs to incorporate movecost of the target tile. int newMoveCostToNeighbor = (int)currentNode.gCost + 1; if (newMoveCostToNeighbor < n.gCost || !openSet.Contains(n)) { n.gCost = newMoveCostToNeighbor; n.hCost = n.HCostTo(targetNode); n.pathParent = currentNode; if (!openSet.Contains(n)) { openSet.Add(n); } } } } return(null); }
public List <ATTile> TilesWithinRange(int range = -1, bool ignoreMovability = false) { List <ATTile> tiles = new List <ATTile> (); Actor actor = GetComponent <Actor> (); if (range == -1) { range = actor.MovesLeft(); } Vector3 bottomLeftOfRange = new Vector3(occupying.transform.position.x - range, occupying.transform.position.y - range); int checks = (range * 2) + 1; for (int i = 0; i < checks; i++) { for (int j = 0; j < checks; j++) { ATTile prospect = MapManager.instance.TileAt(bottomLeftOfRange + new Vector3(i, j, occupying.transform.position.z)); if (prospect == null) { //Debug.Log ("prospect is null"); continue; } if (!ignoreMovability) { if (!prospect.Occupyable()) { //Debug.Log ("prospect is not occupyable"); continue; } if (prospect == occupying) { //Debug.Log ("prospect is occ tile"); continue; } if (MapManager.instance.AStarPathForMover(actor, prospect) == null) { //Debug.Log ("no path to tile: " + prospect.name + ": " + prospect.transform.position); continue; } tiles.Add(prospect); } else { if (prospect.HCostTo(occupying) <= range) { tiles.Add(prospect); } } } } return(tiles); }
private void ColorTilesMousedOver(ATTile t) { cachedPath = MapManager.instance.AStarPathForMoverPreferNoReachers(actor, t); if (cachedPath != null) { MapManager.instance.ColorTiles(cachedPath, new Color(1f, 1f, 1f, .5f)); List <ATTile> fromP = cachedPath.ToList(); fromP.Insert(0, actor.GetComponent <TileMovement> ().occupying); DrawAOOTLines(fromP); } }
private void CycleReachTo(ATTile newOcc) { if (lastReachTiles != null) { RemoveReach(lastReachTiles); } List <ATTile> withinReach = TilesWithinAttackReach(); foreach (ATTile t in withinReach) { t.AddReacher(GetComponent <Actor>()); } lastReachTiles = withinReach; }
public void SetATTilePropsFromTile(Tile t, ATTile dndTile) { int moveCost = t.paramContainer.GetIntParam("baseMoveCost"); if (moveCost != 0) { dndTile.baseMoveCost = moveCost; } bool isDiff = t.paramContainer.GetBoolParam("isDifficultTerrain"); if (isDiff) { dndTile.IsDifficultTerrain = true; } }
void RadiateVision(ATTile t) { // Debug.Log ("Radiating vision for " + GetComponent<Actor> ().GetType ()); List <ATTile> tiles = new List <ATTile>(); //GetComponent<TileMovement> ().TilesWithinRange (VISION_DISTANCE, true); tiles.Add(t); // Debug.Log ("from out to " + t.transform.position + " out to " + preCalculatedUnitCircle [0]); for (int i = 0; i < VISIBLE_ANGLES_OF_CASTING; i++) { RaycastHit2D[] hits = Physics2D.RaycastAll( t.transform.position + eyesOffset, preCalculatedUnitCircle [i], VISION_DISTANCE, MapManager.instance.TileLayerMask ); foreach (RaycastHit2D hit in hits) { ATTile tileHit = hit.collider.gameObject.GetComponent <ATTile>(); if (!tiles.Contains(tileHit)) { tiles.Add(tileHit); } if (tileHit.BlocksVision) // Then stop cursing over the tiles. { break; } } } RemoveVisionFrom(previousInVision, tiles); foreach (ATTile tile in tiles) { if (previousInVision.Contains(tile)) //if the previous in vision has the tile, continue { continue; } if (OnTileVisionGained != null) { OnTileVisionGained(tile); } } previousInVision = tiles; }
// public virtual void Initialize() { Tilemap tm = transform.GetComponent <Tilemap> (); //tm.TintColor = new Color (1f,1f,1f,.75f); // Debug.LogError("initializing " + name); ForEachTile((t, x, y) => { ATTile tile = MapManager.instance.TileAt(x, y); if (tile != null) { SetATTilePropsFromTile(t, tile); if (overridesProperties) { ATTile propTile = MapManager.instance.TileAt(x, y); if (baseMovementCostOverride > 0) { //set base stuff propTile.baseMoveCost = baseMovementCostOverride; } if (isDifficultTerrainOverride) { propTile.IsDifficultTerrain = true; } if (blocksVisionOverride) { // Debug.Log("Setting tile blocking vision! " + x + " , " + y); propTile.BlocksVision = true; } if (blocksMissiles) { propTile.BlocksMissiles = true; } if (unwalkableOverride) { propTile.overriddenAsNotWalkable = true; } } } }); }
private void NonAnimatedMovePerform(List <ATTile> thePath) { actor.GetComponent <Vision> ().OnDiscoveredByEnemy += DiscoveredByEnemyDuringNonAnimatedMove; List <ATTile> runningPath = thePath.ToList(); while (runningPath.Count > 0 && !discoveryFlagged) { ATTile nextTile = runningPath.First(); actor.TileMovement.CallOnWalkedOutOfTile(actor.TileMovement.occupying, nextTile); actor.TileMovement.SetOccupyingTile(actor.TileMovement.occupying, nextTile); actor.transform.position = nextTile.transform.position; runningPath.Remove(nextTile); // Debug.Log ("movement left walking 1 step: " + actor.MovesLeft ()); } actor.GetComponent <Vision> ().OnDiscoveredByEnemy -= DiscoveredByEnemyDuringNonAnimatedMove; FinishedMove(); }
public void OnTriggerEnter2D(Collider2D other) { if (other.CompareTag("Tile")) { ATTile tile = other.GetComponent <ATTile> (); if (tile == targetTile) { StartCoroutine(WaitForGroundZero()); } else if (tile.BlocksMissiles && !this.ignoreBlockers) { if (OnHitBlocker != null) { OnHitBlocker(this, tile); } DetachParticlesAndDestroy(); } previousHitTile = tile; } }
public List <ATTile> AStarPathForMoverPreferNoReachers(Actor actor, ATTile finish) { List <ATTile> path = AStarPathForMover(actor, finish); if (path == null || path.Count == 0) { return(null); } bool TrySecond = actor.HasEnemyReachersIn(path.GetRange(0, path.Count - 1)); if (TrySecond) { List <ATTile> path2 = AStarPathForMoverCountReachersUnwalkable(actor, finish); if (path2 != null && path2.Count <= path.Count) { path = path2; } } return(path); }
void Start() { Vision vis = GetComponent <Vision> (); if (vis != null) { vis.OnDiscoveredByEnemy += GoVisibleForDiscovery; vis.OnUndiscoveredByEnemy += GoInvisibleForUndiscovery; } else { ATTile til = MapManager.instance.TileAt(transform.position); foreach (Actor a in til.actorsThatSeeThisTile) { if (a is PlayerControlledActor) { GoVis(); break; } } til.OnViewerAdded += (Actor actor) => { if (actor.IsOnPlayerSide) { GoVis(); } }; til.OnViewerRemoved += (Actor actor) => { if (actor.IsOnPlayerSide && !til.SeenByAlliesOf(actor)) { GoInvis(); } }; } }
private IEnumerator DelayCheckIn(ATTile t) { yield return(new WaitForSeconds(.2f)); CheckInNow(t); }
public void ShowSelectorOnTile(ATTile t) { selector.transform.position = t.transform.position; selector.GetComponent <SpriteRenderer> ().enabled = true; }
public void Initialize() { //action yielding state camping = new Camping(actor, this); //should be transitory states.... but they yield wait if somehow get caught up. findingBestTarget = new FindingBestTarget(actor, this); seekingTarget = new SeekingTarget(actor, this); //more action yielding states movingToPosition = new MovingToPosition(actor, this); attacking = new Attacking(actor, this); camping.AddTransition((state) => { return(camping.TargetSighted()); }, findingBestTarget); camping.AddTransition((state) => { if (lastTileLostEnemyVisionOn != null) { movingToPosition.position = lastTileLostEnemyVisionOn; lastTileLostEnemyVisionOn = null; return(true); } return(false); }, movingToPosition); findingBestTarget.AddTransition((state) => { return(findingBestTarget.NoTargetInSight()); }, camping); findingBestTarget.AddTransition((state) => { Actor enemy = findingBestTarget.BestTarget(); if (enemy != null) { seekingTarget.target = enemy; return(true); } return(false); }, seekingTarget); findingBestTarget.AddTransition((state) => { if (findingBestTarget.NoPathToBestTarget() && lastTileLostEnemyVisionOn != null) { movingToPosition.position = lastTileLostEnemyVisionOn; lastTileLostEnemyVisionOn = null; return(true); } return(false); }, movingToPosition); seekingTarget.AddTransition((state) => { if (seekingTarget.RightByTarget()) { attacking.target = seekingTarget.target; return(true); } return(false); }, attacking); seekingTarget.AddTransition((state) => { ATTile bestPosition = seekingTarget.BestPosition(); if (bestPosition != null) { movingToPosition.position = bestPosition; return(true); } return(false); }, movingToPosition); seekingTarget.AddTransition((state) => { if (seekingTarget.NoPathToTarget()) { return(true); } return(false); }, findingBestTarget); //This cancels out the movement if any enemy characters move movingToPosition.OnDidEnter += (s, fromPrevious) => { //used to go somewhere when an enemy is seen for a flash // tileToInspect = null; // tileToInspect = null; foreach (Actor enemy in actor.GetComponent <Vision>().EnemiesInVision) { enemy.OnDidPerform += CancelMovementIfEnemyActs; } }; movingToPosition.OnWillExit += (s, toDest) => { foreach (Actor enemy in actor.GetComponent <Vision>().EnemiesInVision) { enemy.OnDidPerform -= CancelMovementIfEnemyActs; } }; movingToPosition.AddTransition((state) => { if (movingToPosition.ReachedPosition()) { return(true); } return(false); }, findingBestTarget); actor.GetComponent <Vision>().OnVisionOfEnemyGained += CancelMovementOnGainedVision; actor.GetComponent <Vision>().OnVisionOfEnemyLost += CancelMovementOnLostVision; attacking.AddTransition((state) => { return(attacking.LostEnemySight()); }, findingBestTarget); attacking.AddTransition((state) => { return(attacking.TargetDied()); }, findingBestTarget); attacking.AddTransition((state) => { return(attacking.TargetMoved()); }, findingBestTarget); // InitDebugStateChanges (); this.SwitchState(camping); }
public void TryCheckInTile(ATTile t) { StartCoroutine(DelayCheckIn(t)); //CheckInNow (t); }
public void LaunchAt(AT.ATTile tTile, bool noBlockers = false) { targetTile = tTile; LaunchAt(targetTile.transform, noBlockers); }
void TellBattleManagerToEmitMoved(ATTile fromTile, ATTile toTile) { BattleManager.instance.EmitActorMovedEvent(this.ActorComponent, fromTile, toTile); }
void AvatarMovedInto(ATTile from, ATTile toDestination) { ResetRenderLayer(MapManager.instance, new Vector2(toDestination.transform.position.x, toDestination.transform.position.y)); SetChildrenOffsets(GetComponent <SpriteRenderer>().sortingOrder); }