public static List<IslandCM> GetBridgedNeibourIslands(MapCM map, int islandID, int playerID, bool enemyOnly = false)
{
List<IslandCM> bridgedNeibours = new List<IslandCM>();
List<IslandCM> neibours = (enemyOnly ? GetNeibourEnemyIslands(map, islandID, playerID) : GetNeibourIslands(map, islandID));
for (int i = 0; i < neibours.Count; ++i)
{
IslandCM island = neibours[i];
if (map.HasIslandsShipBrige(islandID, island.ID, playerID))
bridgedNeibours.Add(island);
}
return bridgedNeibours;
}
public static List<IslandCM> GetNeibourIslands(MapCM map, int islandID)
{
List<IslandCM> neibours = new List<IslandCM>();
List<Hex> seas = map.GetSeasNearIsland(islandID);
for(int i = 0; i < seas.Count; ++i)
{
List<IslandCM> islands = map.GetNeiborIslandsByMapPos(seas[i]);
for (int t = 0; t < islands.Count; ++t)
{
IslandCM island = islands[t];
if (island.ID != islandID && !neibours.Contains(island))
neibours.Add(island);
}
}
return neibours;
}
public static float GetIslandPriceVP(MapCM map, int islandID, int playerID, AIOptions options)
{
float price = 0;
IslandCM island = map.Islands[islandID];
price += island.Horns * options.coefficients.HornVPT * options.turnsToEnd;
price += island.HasMetro ? options.coefficients.MetroVP : 0;
if (island.OwnerID != playerID)
{
price += island.Slots.Where(e => e != Build.None).Select(e => (Library.Map.IsNeedBuild(map, playerID, e) ? options.coefficients.NeedBuildVP : options.coefficients.NotNeedBuildVP)).Sum();
}
else
{
price += island.Slots.Where(e => e != Build.None).Select(e => options.coefficients.NeedBuildVP).Sum();
}
return price;
}
public static List<IslandCM> GetEnemyNeibourIslands(MapCM map, int playerID, bool hasBridge)
{
List<IslandCM> res = new List<IslandCM>();
List<IslandCM> playerIslands = map.GetIslandsByOwner(playerID);
for (int i = 0; i < playerIslands.Count; ++i)
{
IslandCM island = playerIslands[i];
List<IslandCM> bridgedEnemy = GetBridgedNeibourIslands(map, island.ID, playerID, true);
if (hasBridge)
{
res.AddRange(bridgedEnemy);
}
else
{
List<IslandCM> neibourEnemy = GetNeibourEnemyIslands(map, island.ID, playerID);
res.AddRange(neibourEnemy.Where(e => !bridgedEnemy.Contains(e)));
}
}
return res.Distinct().ToList();
}
public static List<IslandCM> GetNeibourEnemyIslands(MapCM map, int islandID, int playerID)
{
return GetNeibourIslands(map, islandID).Where(e => e.OwnerID != playerID).ToList();
}
public static bool HasPlayerPlaceForBuilding(MapCM map, int playerID)
{
List<IslandCM> islands = map.GetIslandsByOwner(playerID);
for (int i = 0; i < islands.Count; ++i)
{
IslandCM island = islands[i];
if (island.Slots.Skip(island.HasMetro ? IslandCM.IslandMetroSizeByIslandSize(island.Slots.Count) : 0).Any(e => e == Build.None))
return true;
}
return false;
}
public static int GetTheLastEmptySlot(MapCM map, int islandID)
{
IslandCM island = map.Islands[islandID];
List<Build> slots = island.Slots;
int metroSize = island.HasMetro ? IslandCM.IslandMetroSizeByIslandSize(island.Slots.Count) : 0;
if (metroSize > 0)
slots = slots.Skip(metroSize).ToList();
int index = slots.FindIndex(e => e == Build.None);
if (index >= 0)
return index + metroSize;
return -1;
}
public static List<NavyUnitCM> GetUselesShips(MapCM map, int playerID)
{
List<NavyUnitCM> uselesNavy = new List<NavyUnitCM>();
List<NavyUnitCM> playersNavy = map.Navy.Where(e => e.OwnerID == playerID && !map.IsWhereSeaHornByPoint(e.Cell)).ToList();
for (int i = 0; i < playersNavy.Count; ++i)
{
NavyUnitCM navy = playersNavy[i];
if (map.GetNeiborIslandsByMapPos(navy.Cell).Count < 2)
uselesNavy.Add(navy);
}
return uselesNavy;
}
public static IslandCM GetTheBestIslandForBuild(MapCM map, int playerID, bool metro = false, bool build = false, bool horn = false)
{
List<IslandCM> playerIslands = map.GetIslandsByOwner(playerID);
if (build)
playerIslands = playerIslands.Where(e => GetTheLastEmptySlot(map, e.ID) >= 0).ToList();
if (metro)
playerIslands = playerIslands.Where(e => !e.HasMetro).ToList();
if (playerIslands.Count == 0)
return map.GetIslandsByOwner(playerID).First();
if (playerIslands.Count == 1)
return playerIslands[0];
IslandCM theMostProtectedIsland = GetTheMostProtectedIsland(map, playerIslands);
return theMostProtectedIsland;
}
public static List<Hex> GetSeaPathToAnyPoint(MapCM map, int playerID, Hex from, List<Hex> toList)
{
for (int i = 0; i < toList.Count; ++i)
{
Hex to = toList[i];
List<Hex> path = MapCM.GetSeaPath(map, from, to, playerID, Constants.navyMove);
if (path != null)
return path;
}
return null;
}
public static int NeedForceToDefenceIsland(MapCM map, int islandID)
{
//TODO
return 0;
}
public static float GetProbOfIslandCapture(MapCM map, int islandID, int attackForce)
{
int islandForce = GetIslandForce(map, islandID, true);
int defenceArmy = GetIslandForce(map, islandID, false);
if (defenceArmy == 0)
{
return 1;
}
else
{
if (attackForce > islandForce + 2)
return 0.9f;
else if (attackForce > islandForce + 1)
return 0.75f;
else if (attackForce > islandForce)
return 0.5f;
else if (attackForce == islandForce)
return 0.4f;
else if (attackForce > islandForce - 1)
return 0.25f;
else
return 0;
}
}
public static int GetForceNeedToCapture(MapCM map, int islandID, float prob)
{
return (GetIslandForce(map, islandID, false) == 0 ? 1 : GetIslandForce(map, islandID, true) + 1);
}
public static int GetIslandForce(MapCM map, int islandID, bool withBuilds = true)
{
IslandCM island = map.Islands[islandID];
return map.GetArmyCountByIsland(islandID, island.OwnerID) + (withBuilds ? map.GetBuildCountAtIsland(islandID, Build.Mars, true) : 0) + (map.IsThereCreatureOnIsland(Card.Minotaur, islandID) ? Constants.minotaurForce : 0);
}
public static bool IsNeedBuild(MapCM map, int playerID, Build build)
{
return (map.GetBuildCountAtIslands(map.GetIslandsByOwner(playerID), build, false) == 0);
}
public static IslandCM GetTheMostProtectedIsland(MapCM map, List<IslandCM> playerIslands)
{
IslandCM theMostProtectedIsland = playerIslands.OrderByDescending(e => map.GetArmyCountByIsland(e.ID, e.OwnerID)).First();
return theMostProtectedIsland;
}
public static List<IslandCM> GetEnemyNeibourIslandsWithTheirBridge(MapCM map, int playerID)
{
List<IslandCM> res = new List<IslandCM>();
List<IslandCM> playerIslands = map.GetIslandsByOwner(playerID);
for (int i = 0; i < playerIslands.Count; ++i)
{
IslandCM island = playerIslands[i];
List<IslandCM> neibourEnemy = GetNeibourEnemyIslands(map, island.ID, playerID);
res.AddRange(neibourEnemy.Where(e => map.HasIslandsShipBrige(e.ID, island.ID, e.OwnerID)));
}
return res.Distinct().ToList();
}
public static List<Hex> GetAccessibleSeaHorns(MapCM map, int playerID, bool onlyForReadyShips, bool is_possible_to_attack_enemy)
{
List<Hex> horns = new List<Hex>();
List<Hex> fromCells;
if (onlyForReadyShips)
fromCells = map.Navy.Where(e => e.OwnerID == playerID && !map.IsWhereSeaHornByPoint(e.Cell)).Select(e => e.Cell).Distinct().ToList();
else
fromCells = map.GetAllPlayerCoast(playerID);
for (int i = 0; i < fromCells.Count; ++i)
{
List<Hex> cells = MapCM.GetConnectedSeas(map, playerID, fromCells[i], Constants.navyMove, false);
List<Hex> _horns = cells.Where(e => map.IsWhereSeaHornByPoint(e)).ToList();
horns.AddRange(_horns);
}
return horns.Distinct().ToList();
}
