private Tile retiradaDaBatalhaDaAI(Tile tileDeOrigem)
{
if (tileDeOrigem.vizinhos.Count != 4)
{
return(tileDeOrigem);
}
List <TilePath> pathsParaRetirada = new List <TilePath>();
List <Tile> movementTiles = TileHighlight.FindHighlight(tileDeOrigem, unidadeAssociada.status[3]);
foreach (Tile tilePossivelDeRetirar in BatalhaController.instancia.locaisDeRetiradaInimiga.Where(tile => movementTiles.Contains(tile)))
{
pathsParaRetirada.Add(TilePathFinder.FindPathTilePathReturn(tileDeOrigem, tilePossivelDeRetirar));
}
List <Tile> caminhoEscolhido = pathsParaRetirada.First(tilePath => tilePath.custoDoCaminho == pathsParaRetirada.Min(custos => custos.custoDoCaminho)).listaDeTiles;
for (int i = caminhoEscolhido.Count - 1; i >= 0; i--)
{
if (movementTiles.Contains(caminhoEscolhido[i]))
{
return(caminhoEscolhido[i]);
}
}
return(null);
}
private Tile fugirDe(Tile tileASeAfastar, Tile tileDeOrigem)
{
List <Tile> tilesEmDistancia = TileHighlight.FindHighlight(tileDeOrigem, unidadeAssociada.status[3]);
float distanciaMaxima = tilesEmDistancia.Max(tile => Vector2.Distance(tile.posicaoNoTabuleiro, tileASeAfastar.posicaoNoTabuleiro));
return(tilesEmDistancia.First(tile => Vector2.Distance(tile.posicaoNoTabuleiro, tileASeAfastar.posicaoNoTabuleiro) == distanciaMaxima));
}
public void highlightTilesAt(Vector2 originLocation, Color highlightColor, int distance)
{
List <Tile> highlightedTiles = TileHighlight.FindHighlight(map[(int)originLocation.x][(int)originLocation.y], distance);
foreach (Tile t in highlightedTiles)
{
t.transform.GetComponent <Renderer>().material.color = highlightColor;
}
}
public override void Load()
{
highlight = new TileHighlight(new Vector2(20, 20), Color.Blue);
chunk = new Chunk(new Vector2Int(0, 0));
renderer = new SimpleRenderer();
chunk.State = ChunkState.NotSoReady;
chunk.Add(new Tile(TileType.Floor, new Vector2Int(0, 0)));
chunk.Add(new Tile(TileType.Floor, new Vector2Int(20, 20)));
chunk.Add(new Tile(TileType.Floor, new Vector2Int(21, 20)));
chunk.Add(new Tile(TileType.Floor, new Vector2Int(22, 20)));
chunk.Add(new Tile(TileType.Floor, new Vector2Int(20, 21)));
chunk.Add(new Tile(TileType.Floor, new Vector2Int(21, 21)));
chunk.Add(new Tile(TileType.Floor, new Vector2Int(22, 21)));
chunk.Add(new Tile(TileType.Floor, new Vector2Int(20, 22)));
chunk.Add(new Tile(TileType.Floor, new Vector2Int(21, 22)));
chunk.Add(new Tile(TileType.Floor, new Vector2Int(22, 22)));
chunk.Add(new Tile(TileType.Wall, new Vector2Int(19, 20)));
chunk.Add(new Tile(TileType.Wall, new Vector2Int(19, 21)));
chunk.Add(new Tile(TileType.Wall, new Vector2Int(19, 22)));
chunk.Add(new Tile(TileType.Wall, new Vector2Int(23, 20)));
chunk.Add(new Tile(TileType.Wall, new Vector2Int(23, 22)));
chunk.Add(new Tile(TileType.Wall, new Vector2Int(23, 21)));
chunk.Add(new Tile(TileType.Wall, new Vector2Int(20, 19)));
chunk.Add(new Tile(TileType.Wall, new Vector2Int(21, 19)));
chunk.Add(new Tile(TileType.Wall, new Vector2Int(22, 19)));
chunk.Add(new Tile(TileType.Wall, new Vector2Int(20, 23)));
//chunk.Add(new Tile(TileType.Wall, new Vector2Int(21, 23)));
chunk.Add(new Tile(TileType.Floor, new Vector2Int(21, 23)));
chunk.Add(new Tile(TileType.Wall, new Vector2Int(22, 23)));
chunk.Add(new Tile(TileType.Wall, new Vector2Int(19, 19)));
chunk.Add(new Tile(TileType.Wall, new Vector2Int(19, 23)));
chunk.Add(new Tile(TileType.Wall, new Vector2Int(23, 19)));
chunk.Add(new Tile(TileType.Wall, new Vector2Int(23, 23)));
TileProcessor.Initialize();
TileProcessor.Process(chunk);
World.UpdateDayLight();
BananaGame.GamePlayer = new Player();
BananaGame.GamePlayer.Position = new Vector2(20, 20);
BananaGame.GamePlayer.Load();
ControllerManager.AddPlayer(BananaGame.GamePlayer);
BananaGame.GameCamera.FollowTaget = true;
BananaGame.GameCamera.Target = (BananaGame.GamePlayer);
//GameCamera.TargetOffset = new Vector3(0.0f, 0f, 10f);
BananaGame.GameCamera.TargetOffset = new Vector3(0.0f, 0f, 12f);
}
public override void Update(GameTime gameTime)
{
BananaGame.GamePlayer.Update(gameTime);
if (GameKeyState.IsKeyPressed(Keys.U))
{
//GameMouseState.WP();
Vector2Int blah = new Vector2Int(GameMouseState.WorldPosition());
highlight = new TileHighlight(blah.asVector2(), Color.Blue);
}
}
private Material[] BuildMaterial()
{
List <Material> materials = new List <Material>(2);
materials.Add(TileMap.Instance.tileMaterialMap[materialName]);
TileHighlight highlight = GetHighlight();
if (highlight != TileHighlight.None) // if has highlight, add highlight
{
materials.Add(TileMap.Instance.tileHighlightMap[highlight]);
}
return(materials.ToArray());
}
public void AttackIfPossible()
{
// this is an attempt on a workaround of the problem where units that die on counter f**k up the unit index
GameManager.instance.diedOnCounter = false;
List <Tile> attackTilesInRange = TileHighlight.FindHighlight(GameManager.instance.map[(int)gridPosition.x][(int)gridPosition.y], attackRange, true);
// trying to make healing work for AI
if (this.isHealer)
{
if (attackTilesInRange.Where(x => GameManager.instance.players.Where(y => y.isOwnedByAI == true && y.HP > 0 && y.HP < 9 &&
y != null && y != this && y.gridPosition == x.gridPosition).Count() > 0).Count() > 0)
{
var opponentsInRange = attackTilesInRange.Select(x => GameManager.instance.players.Where(y => y.HP > 0 && y.HP < 9 && y != this && y.isOwnedByAI == true && y.gridPosition == x.gridPosition).Count() > 0 ? GameManager.instance.players.Where(y => y.gridPosition == x.gridPosition).First() : null).ToList();
Player opponent = opponentsInRange.OrderBy(x => x != null ? -x.HP : 1000).First();
GameManager.instance.removeTileHighlights();
GameManager.instance.aiPlayers[GameManager.instance.currentAIUnitIndex].moving = false;
GameManager.instance.aiPlayers[GameManager.instance.currentAIUnitIndex].attacking = true;
GameManager.instance.highlightTilesAt(gridPosition, Color.red, attackRange);
GameManager.instance.attackWithCurrentPlayer(GameManager.instance.map[(int)opponent.gridPosition.x][(int)opponent.gridPosition.y]);
}
}
// after healing
else
if (attackTilesInRange.Where(x => GameManager.instance.players.Where(y => y.GetType() != typeof(AIPlayerFix) && y.inStorage != true && y.isOwnedByAI != true && y.HP > 0 && y != null && y != this && y.gridPosition == x.gridPosition).Count() > 0).Count() > 0)
{
var opponentsInRange = attackTilesInRange.Select(x => GameManager.instance.players.Where(y => y.GetType() != typeof(AIPlayerFix) && y.inStorage != true && y.HP > 0 && y != this && y.isOwnedByAI != true && y.gridPosition == x.gridPosition).Count() > 0 ? GameManager.instance.players.Where(y => y.gridPosition == x.gridPosition).First() : null).ToList();
Player opponent = opponentsInRange.OrderBy(x => x != null ? -x.HP : 1000).First();
GameManager.instance.removeTileHighlights();
GameManager.instance.aiPlayers[GameManager.instance.currentAIUnitIndex].moving = false;
GameManager.instance.aiPlayers[GameManager.instance.currentAIUnitIndex].attacking = true;
GameManager.instance.highlightTilesAt(gridPosition, Color.red, attackRange);
GameManager.instance.attackWithCurrentPlayer(GameManager.instance.map[(int)opponent.gridPosition.x][(int)opponent.gridPosition.y]);
if (GameManager.instance.diedOnCounter == true)
{
GameManager.instance.diedOnCounter = false;
GameManager.instance.unitIsDead = true;
SelectNextUnit();
}
}
AttackHasCompleted = true;
}
public void hightlightTilesAt(Vector2 originLocation, Color HighlightColor, int range, bool ignorePlayers = true)
{
List <Tile> hightlightedTiles = new List <Tile>();
if (ignorePlayers)
{
hightlightedTiles = TileHighlight.FindHightlight(map[(int)originLocation.x][(int)originLocation.y], range);
}
else
{
hightlightedTiles = TileHighlight.FindHightlight(map[(int)originLocation.x][(int)originLocation.y], range, players.Where(x => x.GridPosition != originLocation).Select(x => x.GridPosition).toArray());
}
foreach (Tile t in hightlightedTiles)
{
t.Rend.material.color = HighlightColor;
}
}
public void highlightTilesAt(Vector2 originLocation, Color highlightColour, int range, bool ignorePlayers = true)
{
List <Tile> highlightedTiles = new List <Tile> ();
if (ignorePlayers)
{
highlightedTiles = TileHighlight.FindHighlight(map [(int)originLocation.x] [(int)originLocation.y], range);
}
else
{
highlightedTiles = TileHighlight.FindHighlight(map [(int)originLocation.x] [(int)originLocation.y], range, players.Where(x => x.gridPosition != originLocation).Select(x => x.gridPosition).ToArray());
}
foreach (Tile t in highlightedTiles)
{
t.transform.GetComponent <Renderer>().material.color = highlightColour;
}
}
public void highlightTilesAt(Vector2 originLocation, Color highlightColor, int distance, bool ignorePlayers)
{
List <Tile> highlightedTiles = new List <Tile>();
if (ignorePlayers)
{
highlightedTiles = TileHighlight.FindHighlight(map[(int)originLocation.x][(int)originLocation.y], distance, highlightColor == Color.red);
}
else
{
highlightedTiles = TileHighlight.FindHighlight(map[(int)originLocation.x][(int)originLocation.y], distance, players.Where(x => x.gridPosition != originLocation).Select(x => x.gridPosition).ToArray(), highlightColor == Color.red);
}
foreach (Tile t in highlightedTiles)
{
t.visual.GetComponent <Renderer>().materials[0].color = highlightColor;
}
}
void Start()
{
tileOccupied = false;
// worldPosition = transform.position;
GameObject tileParents = GameObject.Find("MovementTiles");
if (tileParents == null)
{
tileParents = new GameObject();
}
GameObject movementHighlightObject = Instantiate(movementHighlightPrefab, transform.position, Quaternion.identity) as GameObject;
movementHighlightObject.transform.parent = tileParents.transform;
movementHighlight = movementHighlightObject.GetComponent <TileHighlight>();
GameObject attackHighlightObject = Instantiate(attackHighlightPrefab, transform.position, Quaternion.identity) as GameObject;
attackHighlightObject.transform.parent = tileParents.transform;
attackHighlight = attackHighlightObject.GetComponent <TileHighlight>();
BoardUtils.Instance.RegisterTile(this);
}
public void highlightTilesAt(Vector2 originLocation, Color highlightColor, int distance, bool ignorePlayers)
{
highlightedTiles = new List <Tile>();
if (ignorePlayers)
{
highlightedTiles = TileHighlight.FindHighlight(map[(int)originLocation.x][(int)originLocation.y], distance, highlightColor == Color.red);
}
else
{
highlightedTiles = TileHighlight.FindHighlight(map[(int)originLocation.x][(int)originLocation.y], distance, players.Where(x => x.gridPosition != originLocation).Select(x => x.gridPosition).ToArray(), highlightColor == Color.red);
}
changedTilesDictionary = new Dictionary <Tile, string>();
foreach (Tile t in highlightedTiles)
{
changedTilesDictionary.Add(t, t.visual.transform.GetComponent <Renderer>().materials[0].name);
t.visual.transform.GetComponent <Renderer>().sharedMaterial = materials[3];
}
}
public void artilleryMove(UnidadeNoTabuleiro target, Tile tileDeOrigem)
{
Tile tileDoTarget = BatalhaController.instancia.tabuleiro[(int)target.gridPosition.x][(int)target.gridPosition.y];
//Primeiro Caso, Alvo em Range e não precisa se mover a ele, portanto double attack
gridDeAtaque = true;
gridDeMovimento = false;
if (TileHighlight.FindHighlight(tileDeOrigem, unidadeAssociada.status[4]).Contains(tileDoTarget))
{
if (preparada)
{
BatalhaController.instancia.highlightTilesAt(tileDeOrigem.posicaoNoTabuleiro, BatalhaController.instancia.TileGridAtaque, unidadeAssociada.status[4]);
BatalhaController.instancia.atacarComPlayerAtual(tileDoTarget);
}
else
{
BatalhaController.instancia.unidadeDeArtilhariaSePreparou();
}
}
else
{
gridDeAtaque = false;
gridDeMovimento = true;
Classe classeDaUnidade = unidadeAssociada.classe;
if (!preparada)
{
BatalhaController.instancia.unidadeDeArtilhariaSePreparou();
}
else
{
BatalhaController.instancia.AdministrarFimDeAcao();
}
gridDeMovimento = false;
}
}
public SelectionTool()
{
highLight = new TileHighlight();
}
public override void TurnUpdate()
{
if (positionQueue.Count > 0)
{
transform.position += (positionQueue[0] - transform.position).normalized * moveSpeed * Time.deltaTime;
if (Vector3.Distance(positionQueue[0], transform.position) <= 0.1f)
{
transform.rotation = Quaternion.LookRotation((positionQueue [0] - transform.position).normalized, Vector3.up);
Debug.Log("forwardVector" + Quaternion.LookRotation((positionQueue[0] - transform.position).normalized, Vector3.up));
transform.position = positionQueue[0];
positionQueue.RemoveAt(0);
if (positionQueue.Count == 0)
{
moving = true;
}
}
}
else
{
//priority queue
List <Tile> attacktilesInRange = TileHighlight.FindHighlight(GameManager.instance.map[(int)gridPosition.x][(int)gridPosition.y], attackRange, true);
//List<Tile> movementToAttackTilesInRange = TileHighlight.FindHighlight(GameManager.instance.map[(int)gridPosition.x][(int)gridPosition.y], movementPerActionPoint + attackRange);
List <Tile> movementTilesInRange = TileHighlight.FindHighlight(GameManager.instance.map[(int)gridPosition.x][(int)gridPosition.y], movementPerActionPoint + 1000);
//attack if in range and with lowest HP
if (!attacking && attacktilesInRange.Where(x => GameManager.instance.players.Where(y => y.GetType() != typeof(AIPlayer) && y.HP > 0 && y != this && y.gridPosition == x.gridPosition).Count() > 0).Count() > 0)
{
var opponentsInRange = attacktilesInRange.Select(x => GameManager.instance.players.Where(y => y.GetType() != typeof(AIPlayer) && y.HP > 0 && y != this && y.gridPosition == x.gridPosition).Count() > 0 ? GameManager.instance.players.Where(y => y.gridPosition == x.gridPosition).First() : null).ToList();
Player opponent = opponentsInRange.OrderBy(x => x != null ? -x.HP : 1000).First();
GameManager.instance.removeTileHighlights();
GameManager.instance.highlightTilesAt(gridPosition, Color.red, attackRange);
GameManager.instance.attackWithCurrentPlayer(GameManager.instance.map[(int)opponent.gridPosition.x][(int)opponent.gridPosition.y]);
}
else if (!moving && movementTilesInRange.Where(x => GameManager.instance.players.Where(y => y.GetType() != typeof(AIPlayer) && y.HP > 0 && y != this && y.gridPosition == x.gridPosition).Count() > 0).Count() > 0)
{
var opponentsInRange = movementTilesInRange.Select(x => GameManager.instance.players.Where(y => y.GetType() != typeof(AIPlayer) && y.HP > 0 && y != this && y.gridPosition == x.gridPosition).Count() > 0 ? GameManager.instance.players.Where(y => y.gridPosition == x.gridPosition).First() : null).ToList();
Player opponent = opponentsInRange.OrderBy(x => x != null ? -x.HP : 1000).ThenBy(x => x != null ? TilePathFinder.FindPath(GameManager.instance.map[(int)gridPosition.x][(int)gridPosition.y], GameManager.instance.map[(int)x.gridPosition.x][(int)x.gridPosition.y]).Count() : 1000).First();
GameManager.instance.removeTileHighlights();
GameManager.instance.highlightTilesAt(gridPosition, Color.blue, movementPerActionPoint, false);
List <Tile> path = TilePathFinder.FindPath(GameManager.instance.map[(int)gridPosition.x][(int)gridPosition.y], GameManager.instance.map[(int)opponent.gridPosition.x][(int)opponent.gridPosition.y], GameManager.instance.players.Where(x => x.gridPosition != gridPosition && x.gridPosition != opponent.gridPosition).Select(x => x.gridPosition).ToArray());
if (path == null)
{
GameManager.instance.nextTurn();
}
if (path.Count() > 1)
{
List <Tile> actualMovement = TileHighlight.FindHighlight(GameManager.instance.map[(int)gridPosition.x][(int)gridPosition.y], movementPerActionPoint, GameManager.instance.players.Where(x => x.gridPosition != gridPosition).Select(x => x.gridPosition).ToArray());
path.Reverse();
if (path.Where(x => actualMovement.Contains(x)).Count() > 0)
{
GameManager.instance.moveCurrentPlayer(path.Where(x => actualMovement.Contains(x)).First());
}
}
}
else if (moving && attacktilesInRange.Where(x => GameManager.instance.players.Where(y => y.GetType() != typeof(AIPlayer) && y.HP > 0 && y != this && y.gridPosition == x.gridPosition).Count() > 0).Count() <= 0)
{
attacking = true;
}
}
base.TurnUpdate();
}
public void SetMovementOrders()
{
List <Tile> movementTilesInRange = TileHighlight.FindHighlight(GameManager.instance.map[(int)gridPosition.x][(int)gridPosition.y], movementPerActionPoint + 100000);
//heal first i think?
if (this.isHealer)
{
if (!moving && movementTilesInRange.Where(x => GameManager.instance.players.Where(y => y.isOwnedByAI == true && y.HP > 0 && y.HP < 9 && y != this && y.gridPosition == x.gridPosition).Count() > 0).Count() > 0)
{
var opponentsInRange = movementTilesInRange.Select(x => GameManager.instance.players.Where(y => y.isOwnedByAI == true && y.HP > 0 && y.HP < 9 && y != this && y.gridPosition == x.gridPosition).Count() > 0 ? GameManager.instance.players.Where(y => y.gridPosition == x.gridPosition && y.HP > 0).First() : null).ToList();
Player opponent = opponentsInRange.OrderBy(x => x != null ? -x.HP : 1000).OrderBy(x => x != null ? TilePathFinder.FindPath(GameManager.instance.map[(int)gridPosition.x][(int)gridPosition.y], GameManager.instance.map[(int)x.gridPosition.x][(int)x.gridPosition.y]).Count() : 1000).First();
GameManager.instance.aiPlayers[GameManager.instance.currentAIUnitIndex].moving = true;
GameManager.instance.aiPlayers[GameManager.instance.currentAIUnitIndex].attacking = false;
GameManager.instance.highlightTilesAt(gridPosition, Color.blue, movementPerActionPoint, false, true);
List <Tile> path = TilePathFinder.FindPath(GameManager.instance.map[(int)gridPosition.x][(int)gridPosition.y], GameManager.instance.map[(int)opponent.gridPosition.x][(int)opponent.gridPosition.y], GameManager.instance.players.Where(x => x.gridPosition != gridPosition && x.gridPosition != opponent.gridPosition).Select(x => x.gridPosition).ToArray());
if (path == null)
{
GameManager.instance.removeTileHighlights();
GameManager.instance.aiPlayers[GameManager.instance.currentAIUnitIndex].moving = false;
}
else
if (path.Count() > 1)
{
List <Tile> actualMovement = TileHighlight.FindHighlight(GameManager.instance.map[(int)gridPosition.x][(int)gridPosition.y], movementPerActionPoint, GameManager.instance.players.Where(x => x.gridPosition != gridPosition).Select(x => x.gridPosition).ToArray());
path.Reverse();
if (path.Where(x => actualMovement.Contains(x)).Count() > 0)
{
GameManager.instance.moveCurrentPlayer(path.Where(x => actualMovement.Contains(x)).First());
}
}
}
}
// after healing (or if no healing)
else
if (!moving && movementTilesInRange.Where(x => GameManager.instance.players.Where(y => y.GetType() != typeof(AIPlayerFix) && y.isOwnedByAI != true && y.inStorage != true && y.HP > 0 && y != this && y.gridPosition == x.gridPosition).Count() > 0).Count() > 0)
{
var opponentsInRange = movementTilesInRange.Select(x => GameManager.instance.players.Where(y => y.GetType() != typeof(AIPlayerFix) && y.isOwnedByAI != true && y.inStorage != true && y.HP > 0 && y != this && y.gridPosition == x.gridPosition).Count() > 0 ? GameManager.instance.players.Where(y => y.gridPosition == x.gridPosition && y.HP > 0).First() : null).ToList();
Player opponent = opponentsInRange.OrderBy(x => x != null ? -x.HP : 1000).OrderBy(x => x != null ? TilePathFinder.FindPath(GameManager.instance.map[(int)gridPosition.x][(int)gridPosition.y], GameManager.instance.map[(int)x.gridPosition.x][(int)x.gridPosition.y]).Count() : 1000).First();
GameManager.instance.aiPlayers[GameManager.instance.currentAIUnitIndex].moving = true;
GameManager.instance.aiPlayers[GameManager.instance.currentAIUnitIndex].attacking = false;
GameManager.instance.highlightTilesAt(gridPosition, Color.blue, movementPerActionPoint, false, true);
List <Tile> path = TilePathFinder.FindPath(GameManager.instance.map[(int)gridPosition.x][(int)gridPosition.y], GameManager.instance.map[(int)opponent.gridPosition.x][(int)opponent.gridPosition.y], GameManager.instance.players.Where(x => x.gridPosition != gridPosition && x.gridPosition != opponent.gridPosition).Select(x => x.gridPosition).ToArray());
if (path == null)
{
GameManager.instance.removeTileHighlights();
GameManager.instance.aiPlayers[GameManager.instance.currentAIUnitIndex].moving = false;
}
else
if (path.Count() > 1)
{
List <Tile> actualMovement = TileHighlight.FindHighlight(GameManager.instance.map[(int)gridPosition.x][(int)gridPosition.y], movementPerActionPoint, GameManager.instance.players.Where(x => x.gridPosition != gridPosition).Select(x => x.gridPosition).ToArray());
path.Reverse();
if (path.Where(x => actualMovement.Contains(x)).Count() > 0)
{
GameManager.instance.moveCurrentPlayer(path.Where(x => actualMovement.Contains(x)).First());
}
}
MovementHasBeenSet = true;
// i think we want this in updateunitposition GameManager.instance.aiPlayers[GameManager.instance.currentAIUnitIndex].waiting = true;
}
}
public override void TurnUpdate()
{
if (positionQueue.Count > 0)
{
transform.position += (positionQueue[0] - transform.position).normalized * moveSpeed * Time.deltaTime;
if (Vector3.Distance(positionQueue[0], transform.position) <= 0.1f)
{
transform.position = positionQueue[0];
positionQueue.RemoveAt(0);
if (positionQueue.Count == 0)
{
actionPoints--;
}
}
}
else
{
//priority queue
List <Tile> attacktilesInRange = TileHighlight.FindHighlight(GameManager.instance.map[(int)gridPosition.x][(int)gridPosition.y], attackRange, true);
//List<Tile> movementToAttackTilesInRange = TileHighlight.FindHighlight(GameManager.instance.map[(int)gridPosition.x][(int)gridPosition.y], movementPerActionPoint + attackRange);
List <Tile> movementTilesInRange = TileHighlight.FindHighlight(GameManager.instance.map[(int)gridPosition.x][(int)gridPosition.y], movementPerActionPoint + 1000);
//attack if in range and with lowest HP
if (attacktilesInRange.Where(x => GameManager.instance.players.Where(y => y.GetType() != typeof(AIPlayer) && y.HP > 0 && y != this && y.gridPosition == x.gridPosition).Count() > 0).Count() > 0)
{
var opponentsInRange = attacktilesInRange.Select(x => GameManager.instance.players.Where(y => y.GetType() != typeof(AIPlayer) && y.HP > 0 && y != this && y.gridPosition == x.gridPosition).Count() > 0 ? GameManager.instance.players.Where(y => y.gridPosition == x.gridPosition).First() : null).ToList();
Player opponent = opponentsInRange.OrderBy(x => x != null ? -x.HP : 1000).First();
GameManager.instance.removeTileHighlights();
moving = false;
attacking = true;
GameManager.instance.highlightTilesAt(gridPosition, Color.red, attackRange);
GameManager.instance.attackWithCurrentPlayer(GameManager.instance.map[(int)opponent.gridPosition.x][(int)opponent.gridPosition.y]);
}
//move toward nearest attack range of opponent
// else if (!moving && movementToAttackTilesInRange.Where(x => GameManager.instance.players.Where (y => y.GetType() != typeof(AIPlayer) && y.HP > 0 && y != this && y.gridPosition == x.gridPosition).Count() > 0).Count () > 0) {
// var opponentsInRange = movementToAttackTilesInRange.Select(x => GameManager.instance.players.Where (y => y.GetType() != typeof(AIPlayer) && y.HP > 0 && y != this && y.gridPosition == x.gridPosition).Count () > 0 ? GameManager.instance.players.Where(y => y.gridPosition == x.gridPosition && y.HP > 0).First() : null).ToList();
// Player opponent = opponentsInRange.OrderBy (x => x != null ? -x.HP : 1000).ThenBy (x => x != null ? TilePathFinder.FindPath(GameManager.instance.map[(int)gridPosition.x][(int)gridPosition.y],GameManager.instance.map[(int)x.gridPosition.x][(int)x.gridPosition.y]).Count() : 1000).First ();
//
// GameManager.instance.removeTileHighlights();
// moving = true;
// attacking = false;
// GameManager.instance.highlightTilesAt(gridPosition, Color.blue, movementPerActionPoint, false);
//
// List<Tile> path = TilePathFinder.FindPath (GameManager.instance.map[(int)gridPosition.x][(int)gridPosition.y],GameManager.instance.map[(int)opponent.gridPosition.x][(int)opponent.gridPosition.y], GameManager.instance.players.Where(x => x.gridPosition != gridPosition && x.gridPosition != opponent.gridPosition).Select(x => x.gridPosition).ToArray());
// if (path.Count() > 1) {
// GameManager.instance.moveCurrentPlayer(path[(int)Mathf.Max(0, path.Count - 1 - attackRange)]);
// }
// }
//move toward nearest opponent
else if (!moving && movementTilesInRange.Where(x => GameManager.instance.players.Where(y => y.GetType() != typeof(AIPlayer) && y.HP > 0 && y != this && y.gridPosition == x.gridPosition).Count() > 0).Count() > 0)
{
var opponentsInRange = movementTilesInRange.Select(x => GameManager.instance.players.Where(y => y.GetType() != typeof(AIPlayer) && y.HP > 0 && y != this && y.gridPosition == x.gridPosition).Count() > 0 ? GameManager.instance.players.Where(y => y.gridPosition == x.gridPosition).First() : null).ToList();
Player opponent = opponentsInRange.OrderBy(x => x != null ? -x.HP : 1000).ThenBy(x => x != null ? TilePathFinder.FindPath(GameManager.instance.map[(int)gridPosition.x][(int)gridPosition.y], GameManager.instance.map[(int)x.gridPosition.x][(int)x.gridPosition.y]).Count() : 1000).First();
GameManager.instance.removeTileHighlights();
moving = true;
attacking = false;
GameManager.instance.highlightTilesAt(gridPosition, Color.blue, movementPerActionPoint, false);
List <Tile> path = TilePathFinder.FindPath(GameManager.instance.map[(int)gridPosition.x][(int)gridPosition.y], GameManager.instance.map[(int)opponent.gridPosition.x][(int)opponent.gridPosition.y], GameManager.instance.players.Where(x => x.gridPosition != gridPosition && x.gridPosition != opponent.gridPosition).Select(x => x.gridPosition).ToArray());
if (path.Count() > 1)
{
List <Tile> actualMovement = TileHighlight.FindHighlight(GameManager.instance.map[(int)gridPosition.x][(int)gridPosition.y], movementPerActionPoint, GameManager.instance.players.Where(x => x.gridPosition != gridPosition).Select(x => x.gridPosition).ToArray());
path.Reverse();
if (path.Where(x => actualMovement.Contains(x)).Count() > 0)
{
GameManager.instance.moveCurrentPlayer(path.Where(x => actualMovement.Contains(x)).First());
}
}
}
}
// if (!attacking && !moving) {
// actionPoints = 2;
// GameManager.instance.nextTurn();
// return;
// }
if (actionPoints <= 1 && (attacking || moving))
{
moving = false;
attacking = false;
}
base.TurnUpdate();
}
public static List <Tile> FindPath(Tile startTile, Tile targetTile, Vector2[] occupied)
{
//Player tmpPlayer = (Player) GameManager.instance.players.Where(x => x.gridPosition == startTile.gridPosition);
// if (occupied.Contains (targetTile)) {
//path2target.RemoveAt (path2target.Count - 1);
// }
List <Tile> path2target = TileHighlight.AstarFindpath(startTile, targetTile, occupied);
// if (targetTile.cost <= tmpPlayer.movementPerActionPoint) {
// return targetTile.parent.path;
// }
// else {
//path2target.RemoveAt(path2target.Count - 1);
return(path2target);
// }
// List<Tile> openSet = new List<Tile> ();
// HashSet<Tile> closedSet = new HashSet<Tile> ();
// openSet.Add (startTile);
//
// while (openSet.Count > 0) {
// Tile currentTile = openSet [0];
// for (int i = 1; i < openSet.Count; i++) {
// if (openSet [i].fCost < currentTile.fCost || openSet [i].fCost == currentTile.fCost && openSet [i].hCost < currentTile.hCost) {
// currentTile = openSet [i];
// }
// }
// //remove current from Openlist and add it to Closelist
// openSet.Remove (currentTile);
// closedSet.Add (currentTile);
//
// if (currentTile = targetTile) {
// //find the path from startTile by using tile.parent
// Tile tmpcurTile = currentTile;
// List<Tile> tmppath = new List<Tile> ();
// while (tmpcurTile.parent != startTile) {
// tmppath.Add (tmpcurTile);
// tmpcurTile = tmpcurTile.parent;
// }
// tmppath.Add (startTile);
// tmppath.Reverse();
//
// //targetTile.path = tmppath;
//
// return tmppath;
// }
//
// foreach (Tile neighbor in currentTile.neighbors) {
// if (neighbor.impassible || closedSet.Contains(neighbor) || occupied.Contains(neighbor.gridPosition)) continue;
//
// int newMovecost2Neighbor = currentTile.gCost + GetDistance (currentTile, neighbor);
// if (newMovecost2Neighbor < neighbor.gCost || !openSet.Contains (neighbor)) {
// neighbor.gCost = newMovecost2Neighbor;
// neighbor.hCost = GetDistance (neighbor, targetTile);
// neighbor.parent = currentTile;
//
// if (!openSet.Contains (neighbor))
// openSet.Add (neighbor);
// }
// }
// }//end while
//
// //did not find a path
// return null;
}
public override void TurnUpdate()
{
if (positionQueue.Count > 0)
{
transform.position += (positionQueue [0] - transform.position).normalized * moveSpeed * Time.deltaTime;
if (Vector3.Distance(positionQueue [0], transform.position) <= 0.1f)
{
transform.position = positionQueue [0];
positionQueue.RemoveAt(0);
if (positionQueue.Count == 0)
{
actionPoints--;
}
}
}
else
{
// queue
// attack if in range and with lowest hp
List <Tile> attacktilesInRange = TileHighlight.FindHighlight(GameManager.instance.map[(int)gridPosition.x][(int)gridPosition.y], attackRange);
List <Tile> movementTilesInRange = TileHighlight.FindHighlight(GameManager.instance.map[(int)gridPosition.x][(int)gridPosition.y], movementPerActionPoint + 1000);
//attack if in range and with lowest HP
Debug.Log("attackTiles in range are " + attackRange + " and the return is " + attacktilesInRange.Count);
if (attacktilesInRange.Where(x => GameManager.instance.players.Where(y => y.GetType() != typeof(AIPlayer) && y.HP > 0 && y != this && y.gridPosition == x.gridPosition).Count() > 0).Count() > 0)
{
var opponentsInRange = attacktilesInRange.Select(x => GameManager.instance.players.Where(y => y.GetType() != typeof(AIPlayer) && y.HP > 0 && y != this && y.gridPosition == x.gridPosition).Count() > 0 ? GameManager.instance.players.Where(y => y.gridPosition == x.gridPosition).First() : null).ToList();
Player opponent = opponentsInRange.OrderBy(x => x != null ? -x.HP : 1000).First();
GameManager.instance.removeTileHighlights();
moving = false;
attacking = true;
GameManager.instance.highlightTilesAt(gridPosition, Color.red, attackRange);
GameManager.instance.attackWithCurrentPlayer(GameManager.instance.map[(int)opponent.gridPosition.x][(int)opponent.gridPosition.y]);
}
// if not, move towards nearest opponent
else if (!moving && movementTilesInRange.Where(x => GameManager.instance.players.Where(y => y.GetType() != typeof(AIPlayer) && y.HP > 0 && y != this && y.gridPosition == x.gridPosition).Count() > 0).Count() > 0)
{
var opponentsInRange = movementTilesInRange.Select(x => GameManager.instance.players.Where(y => y.GetType() != typeof(AIPlayer) && y.HP > 0 && y != this && y.gridPosition == x.gridPosition).Count() > 0 ? GameManager.instance.players.Where(y => y.gridPosition == x.gridPosition).First() : null).ToList();
Player opponent = opponentsInRange.OrderBy(x => x != null ? -x.HP : 1000).ThenBy(x => x != null ? (TilePathFinder.FindPath(GameManager.instance.map[(int)gridPosition.x][(int)gridPosition.y],
GameManager.instance.map[(int)x.gridPosition.x][(int)x.gridPosition.y])) != null ? TilePathFinder.FindPath(GameManager.instance.map[(int)gridPosition.x][(int)gridPosition.y],
GameManager.instance.map[(int)x.gridPosition.x][(int)x.gridPosition.y]).Count() : 1000 : 1000).First();
GameManager.instance.removeTileHighlights();
moving = true;
attacking = false;
GameManager.instance.highlightTilesAt(gridPosition, Color.blue, movementPerActionPoint, false);
List <Tile> path = TilePathFinder.FindPath(GameManager.instance.map[(int)gridPosition.x][(int)gridPosition.y], GameManager.instance.map[(int)opponent.gridPosition.x][(int)opponent.gridPosition.y], GameManager.instance.players.Where(x => x.gridPosition != gridPosition && x.gridPosition != opponent.gridPosition).Select(x => x.gridPosition).ToArray());
if (path != null && path.Count() > 1)
{
List <Tile> actualMovement = TileHighlight.FindHighlight(GameManager.instance.map[(int)gridPosition.x][(int)gridPosition.y], movementPerActionPoint, GameManager.instance.players.Where(x => x.gridPosition != gridPosition).Select(x => x.gridPosition).ToArray());
path.Reverse();
if (path.Where(x => actualMovement.Contains(x)).Count() > 0)
{
GameManager.instance.moveCurrentPlayer(path.Where(x => actualMovement.Contains(x)).First());
}
}
else
{
SkipTurn();
}
}
}
base.TurnUpdate();
}
public override void TurnUpdate()
{
transform.GetComponent <Renderer>().material.color = Color.green;
if (positionQueue.Count > 0)
{
if (Vector3.Distance(positionQueue[0], transform.position) > 0.1f)
{
transform.position += (positionQueue[0] - transform.position).normalized * moveSpeed * Time.deltaTime;
if (Vector3.Distance(positionQueue[0], transform.position) <= 0.1f)
{
transform.position = positionQueue[0];
positionQueue.RemoveAt(0);
if (positionQueue.Count == 0)
{
actionPoints--;
Tile.movable = true;
GameManager.instance.highlightTilesAt(gridPosition, Color.blue, moveDistance, false);
}
}
}
}
else
{
//priority queue
//attack if in range and with lowest HP
List <Tile> attacktilesInRange = TileHighlight.FindHighlight(GameManager.instance.map[(int)gridPosition.x][(int)gridPosition.y], attackRange);
//List<Tile> movementToAttackTilesInRange = TileHighlight.FindHighlight(GameManager.instance.map[(int)gridPosition.x][(int)gridPosition.y], movementPerActionPoint + attackRange);
List <Tile> movementTilesInRange = TileHighlight.FindHighlight(GameManager.instance.map[(int)gridPosition.x][(int)gridPosition.y], moveDistance + 1000);
//attack if in range and with lowest HP
if (attacktilesInRange.Where(x => GameManager.instance.players.Where(y => y.GetType() != typeof(AIMovement) && y.currentHP > 0 && y != this && y.gridPosition == x.gridPosition).Count() > 0).Count() > 0)
{
var opponentsInRange = attacktilesInRange.Select(x => GameManager.instance.players.Where(y => y.GetType() != typeof(AIMovement) && y.currentHP > 0 && y != this && y.gridPosition == x.gridPosition).Count() > 0 ? GameManager.instance.players.Where(y => y.gridPosition == x.gridPosition).First() : null).ToList();
Player opponent = opponentsInRange.OrderBy(x => x != null ? -x.currentHP : 1000).First();
GameManager.instance.removeHighlights();
moving = false;
attacking = true;
GameManager.instance.highlightTilesAt(gridPosition, Color.red, attackRange);
GameManager.instance.attackWithCurrentPlayer(GameManager.instance.map[(int)opponent.gridPosition.x][(int)opponent.gridPosition.y]);
}
//move towards nearest opponent
else if (movementTilesInRange.Where(x => GameManager.instance.players.Where(y => y.GetType() != typeof(AIMovement) && y.currentHP > 0 && y != this && y.gridPosition == x.gridPosition).Count() > 0).Count() > 0)
{
var opponentsInRange = movementTilesInRange.Select(x => GameManager.instance.players.Where(y => y.GetType() != typeof(AIMovement) && y.currentHP > 0 && y != this && y.gridPosition == x.gridPosition).Count() > 0 ? GameManager.instance.players.Where(y => y.gridPosition == x.gridPosition).First() : null).ToList();
Player opponent = opponentsInRange.OrderBy(x => x != null ? -x.currentHP : 1000).ThenBy(x => x != null ? Pathfinder.FindPath(GameManager.instance.map[(int)gridPosition.x][(int)gridPosition.y], GameManager.instance.map[(int)x.gridPosition.x][(int)x.gridPosition.y]).Count() : 1000).First();
GameManager.instance.removeHighlights();
moving = true;
attacking = false;
GameManager.instance.highlightTilesAt(gridPosition, Color.blue, moveDistance, false);
List <Tile> path = Pathfinder.FindPath(GameManager.instance.map[(int)gridPosition.x][(int)gridPosition.y], GameManager.instance.map[(int)opponent.gridPosition.x][(int)opponent.gridPosition.y], GameManager.instance.players.Where(x => x.gridPosition != gridPosition && x.gridPosition != opponent.gridPosition).Select(x => x.gridPosition).ToArray());
if (path.Count() > 1)
{
List <Tile> actualMovement = TileHighlight.FindHighlight(GameManager.instance.map[(int)gridPosition.x][(int)gridPosition.y], moveDistance, GameManager.instance.players.Where(x => x.gridPosition != gridPosition).Select(x => x.gridPosition).ToArray());
path.Reverse();
if (path.Where(x => actualMovement.Contains(x)).Count() > 0)
{
GameManager.instance.moveCurrentPlayer(path.Where(x => actualMovement.Contains(x)).First());
}
}
}
}
base.TurnUpdate();
}
public void TrackDownEnemies(UnidadeNoTabuleiro target, Tile tileDeOrigem)
{
Tile tileDoTarget = BatalhaController.instancia.tabuleiro[(int)target.gridPosition.x][(int)target.gridPosition.y];
//Primeiro Caso, Alvo em Range e não precisa se mover a ele, portanto double attack
gridDeAtaque = true;
gridDeMovimento = false;
if (TileHighlight.FindHighlight(tileDeOrigem, unidadeAssociada.status[4]).Contains(tileDoTarget))
{
BatalhaController.instancia.highlightTilesAt(tileDeOrigem.posicaoNoTabuleiro, BatalhaController.instancia.TileGridAtaque, unidadeAssociada.status[4]);
BatalhaController.instancia.atacarComPlayerAtual(tileDoTarget);
}
//Segundo caso, Alvo não está em range, mas pode ser alcançado com um movimento
else
{
gridDeAtaque = false;
gridDeMovimento = true;
BatalhaController.instancia.highlightTilesAt(tileDeOrigem.posicaoNoTabuleiro, BatalhaController.instancia.TileGridMovimento, unidadeAssociada.status[3]);
//Pegar todos os tiles de movimento possivel
List <Tile> movementTiles = TileHighlight.FindHighlight(tileDeOrigem, unidadeAssociada.status[3]);
//Verificar se algums dos tiles está a uma distancia que a unidade pode atacar após mover
if (movementTiles.Any(tile => Vector2.Distance(tile.posicaoNoTabuleiro, tileDoTarget.posicaoNoTabuleiro) == unidadeAssociada.status[4]))
{
//Pegar qualquer tile cuja distancia para o alvo seja igual ao range maximo do seu ataque
//List<Tile> possiveisParaMovimento = movementTiles.Where(tile => Vector2.Distance(tile.posicaoNoTabuleiro, tileDoTarget.posicaoNoTabuleiro) == unidadeAssociada.status[4]).ToList();
//float maiorDistancia = movementTiles.Max(tile => Vector2.Distance(tileDoTarget.posicaoNoTabuleiro, tile.posicaoNoTabuleiro));
Tile tileParaMoverMaisProximo = movementTiles.First(tile => Vector2.Distance(tile.posicaoNoTabuleiro, tileDoTarget.posicaoNoTabuleiro) == unidadeAssociada.status[4]);
BatalhaController.instancia.verificarTentativaDeMovimento(tileParaMoverMaisProximo);
alvoDeAtaque = target;
}
//Terceiro caso, Muito longe para atacar o inimigo depois do movimento, porntanto so se importar com chegar o mais proximo possivel
else
{
List <Tile> CaminhoMaisCurtoParaOAlvo = null;
foreach (Tile tile in tileDoTarget.vizinhos)
{
if (!tile.ocupado)
{
CaminhoMaisCurtoParaOAlvo = TilePathFinder.FindPathTilesReturn(tileDeOrigem, tile); break;
}
}
if (CaminhoMaisCurtoParaOAlvo == null)
{
BatalhaController.instancia.proximaVez();
return;
}
for (int i = CaminhoMaisCurtoParaOAlvo.Count - 1; i >= 0; i--)
{
if (movementTiles.Contains(CaminhoMaisCurtoParaOAlvo[i]))
{
BatalhaController.instancia.verificarTentativaDeMovimento(CaminhoMaisCurtoParaOAlvo[i]);
break;
}
}
//movementTiles.Any(tile => CaminhoMaisCurtoParaOAlvo.Contains(tile));
}
gridDeMovimento = false;
}
}
