/// <summary>
/// Get a list of the best moves for each unit the computer player has.
/// </summary>
/// <returns>A list of moves, one per each unit the computer player has, decided by the AI.</returns>
public static List <Move> BestMoves()
{
List <Move> moves = new List <Move>();
Game game = Game.instance;
//Clone the board to get a disposable board to work with.
Tile[,] clone = DepthSearch.CopyBoard(Game.instance.tiles);
//Get the best move for each unit
foreach (Unit u in game.GetUnits())
{
if (u.player)
{
continue;
}
Task t = GetTask(u, clone);
Move m = BestMove(u, clone, t);
if (m != null)
{
moves.Add(m);
//Execute the move on the cloned board so next units know what move was chosen beforehand.
m.Execute(false, clone);
}
}
//Return the list of moves found.
return(moves);
}
/// <summary>
/// Find the best move for a unit.
/// </summary>
/// <param name="u">The unit to move</param>
/// <param name="board">The board to find units on</param>
/// <param name="task">The task the unit should do</param>
/// <returns>A move that is decided as the best move for this unit this turn.</returns>
public static Move BestMove(Unit u, Tile[,] board, Task task)
{
if (task == Task.improve)
{
//Get dictionary of amount of friendly units of type.
Dictionary <UnitType, int> friendlies = AIUtil.Count(board, new LookupConstraint(new PlayerConstraint(false)));
UnitType build = UnitType.builder; //The unit that needs to be built
bool needToBuild = false; //Whether there is a unit to build
//Find the first type in the build order that is not built yet.
foreach (UnitType test in BUILD_ORDER)
{
if (!friendlies.ContainsKey(test))
{
build = test;
needToBuild = true;
break;
}
if (friendlies[test] == 0)
{
build = test;
needToBuild = true;
break;
}
friendlies[test]--;
}
if (!needToBuild)
{
return(null);
}
//Check if the build target can be built (resources wise)
if (!(build.Cost() <= Game.instance.computer.resources || COMPUTER_INFINATE_RESOURCES))
{
return(null);
}
//Checks if the current unit is able to build the type
if (u.GetBuildable().Contains(build))
{
//Find all possibilites of building
List <Move> options = u.BuildAroundMove(board, build, 1);
//Make sure there is enough moves left for the unit to build
options.RemoveAll((o) => { return(o.cost > u.movesLeft); });
//If there is an option to build the target, do it.
if (options.Count > 0)
{
Move res = options[0];
return(res);
}
//Otherwise, if the unit is a builder, move to the nearest tile where building will be possible.
else
{
if (u.type == UnitType.builder)
{
//Find path to the nearest tile where the build target can be built
List <ALocation> path = PathFinder.PathToNearestTile(u.type, board, u.TileX, u.TileY, build.BuildableTiles()[0]);
//If a non empty path is found, walk it
if (path != null && path.Count != 0)
{
return(new MovementMove(u, path[0].x, path[0].y));
}
}
}
}
}
if (task == Task.forward)
{
//Find the resource tile that is open
Tile target = null;
if (board[3, 2].buildingOn == null)
{
target = board[3, 2];
}
if (board[4, 2].buildingOn == null)
{
target = board[4, 2];
}
if (board[2, 3].buildingOn == null)
{
target = board[2, 3];
}
if (board[2, 4].buildingOn == null)
{
target = board[2, 4];
}
if (target != null)
{
//Find all build options of the harvester of the open tile.
List <Move> options = u.BuildAroundMove(board, target.type.GetHarvesterType(), 1);
//If a good build option is found, return it.
options.RemoveAll((o) => { return(o.cost > u.movesLeft); });
if (options.Count > 0)
{
Move res = options[0];
return(res);
}
//Otherwise, find a path to that tile.
else
{
List <ALocation> path = PathFinder.PathToNearestTile(u.type, board, u.px / Tile.TILE_WIDTH, u.py / Tile.TILE_HEIGHT, target.type);
if (path != null && path.Count != 0)
{
return(new MovementMove(u, path[0].x, path[0].y));
}
}
}
}
if (task == Task.defend)
{
//First see if the unit can attack. If so, attack.
List <Move> attacks = u.DefaultAttackAroundMove(board);
if (attacks.Count > 0)
{
return(attacks[0]);
}
//If the unit can't attack, find a path to the nearest enemy unit in the friendly base.
List <ALocation> path = PathFinder.PathToNearestUnit(u.type, board, u.TileX, u.TileY, new LookupConstraint(new PlayerConstraint(true), new DistanceConstraint(10, 10, 4)));
if (path != null && path.Count > 0)
{
//If a path is found, move along it.
int i = Math.Min(Math.Max(0, path.Count - 2), u.movesLeft - 1);
return(new MovementMove(u, path[i].x, path[i].y));
}
//If no path is found, push instead of defending.
return(BestMove(u, board, Task.push));
}
if (task == Task.push)
{
if (u.type.GetDamage() > 0)
{
//Find the move that maximizes map control, calculating 3 moves ahead.
return(DepthSearch.GetBestMoveMin(u, board));
}
if (u.type.IsTraining())
{
//Build a unit.
List <Move> options = u.BuildAroundMove(board, u.GetBuildable()[0], 1).Where(m => m.cost <= u.movesLeft).ToList();
if (options.Count == 0)
{
return(null);
}
Move build = options[0];
return(build);
}
}
if (task == Task.destroy)
{
//Try to attack a nearby unit.
List <Move> attacks = u.DefaultAttackAroundMove(board);
if (attacks.Count > 0)
{
return(attacks[0]);
}
//If no nearby units, find the nearest unit and go towards it.
List <ALocation> path = PathFinder.PathToNearestUnit(u.type, board, u.TileX, u.TileY, true);
if (path == null || path.Count == 0)
{
return(null);
}
int i = Math.Min(Math.Max(0, path.Count - 2), u.movesLeft - 1);
return(new MovementMove(u, path[i].x, path[i].y));
}
if (task == Task.retreat)
{
//Find a path to the friendly base.
List <ALocation> path = PathFinder.PathToCoordinates(u.type, board, u.TileX, u.TileY, 10, 10);
if (path == null || path.Count == 0)
{
//If no path is found, find a path to a tile that is close to the friendly base.
List <ALocation> path2 = PathFinder.PathToNearestTile(u.type, board, u.TileX, u.TileY, new TileLookupConstraint(new DistanceTileConstraint(10, 10, 3)));
if (path2 == null || path2.Count == 0)
{
return(null);
}
int i2 = Math.Min(Math.Max(0, path2.Count - 2), u.movesLeft - 1);
return(new MovementMove(u, path2[i2].x, path2[i2].y));
}
int i = Math.Min(Math.Max(0, path.Count - 2), u.movesLeft - 1);
return(new MovementMove(u, path[i].x, path[i].y));
}
return(null);
}