protected override string UpdateState()
{
if (HouseInSight())
{
if (Adjacent(destination))
{
return(AIHelper.CreateStealAction(Direction(brain.playerInfo.Position, destination)));
}
else
{
return(GoTo(destination));
}
}
else
{
if (destination != null && Adjacent(destination))
{
if (destinationType == TileContent.Resource)
{
return(AIHelper.CreateCollectAction(Direction(brain.playerInfo.Position, destination)));
}
else //(destinationType == TileContent.Wall)
{
return(AIHelper.CreateMeleeAttackAction(Direction(brain.playerInfo.Position, destination)));
}
}
else
{
return(SearchDirection(new Point(-1, 0)));
}
}
}
public override string Execute()
{
var playerPos = _executer.PlayerInfo.Position;
if (_executer.PlayerInfo.CarriedResources >= _executer.PlayerInfo.CarryingCapacity)
{
// Go home you're ~drunk~ full
var returnHomePath = _executer.Map.PathBetween(playerPos, _executer.PlayerInfo.HouseLocation);
return(MoveTo(returnHomePath[1].Tile.Position - playerPos));
}
else
{
var adjacentMine = _executer.Map.HasTileOfTypeAdjacentTo(TileContent.Resource, playerPos);
if (adjacentMine != null)
{
// if we're next to a mine, mine
return(AIHelper.CreateCollectAction(adjacentMine.Position - playerPos));
}
else
{
// Go to mine
var resource = _executer.Map.GetClosestTileOfType(TileContent.Resource, playerPos);
var minePath = _executer.Map.ShortestPathNextTo(resource.Position, playerPos);
return(MoveTo(minePath[1].Tile.Position - playerPos));
}
}
}
private string MineResources(Map map)
{
string action = "";
bool isFull = PlayerInfo.CarriedResources >= PlayerInfo.CarryingCapacity;
List <Tile> possibleResources = new List <Tile>();
foreach (Tile tile in map.GetVisibleTiles())
{
if (tile.TileType == TileContent.Resource)
{
possibleResources.Add(tile);
}
}
// Sort resources
possibleResources.Sort((a, b) => Point.Distance(a.Position, PlayerInfo.Position).CompareTo(Point.Distance(b.Position, PlayerInfo.Position)));
Point adjacentResource = GetAdjacentResource(map);
// prioritize this and upgrade
if (PlayerInfo.Position == PlayerInfo.HouseLocation)
{
//int carryingLevel = PlayerInfo.GetUpgradeLevel(UpgradeType.CarryingCapacity);
int maxHealthLevel = PlayerInfo.GetUpgradeLevel(UpgradeType.MaximumHealth);
int attackLevel = PlayerInfo.GetUpgradeLevel(UpgradeType.AttackPower);
if (attackLevel < 4 && UpgradeCosts[attackLevel + 1] <= PlayerInfo.TotalResources)
{
return(AIHelper.CreateUpgradeAction(UpgradeType.AttackPower));
}
else if (maxHealthLevel < 5 && UpgradeCosts[maxHealthLevel + 1] <= PlayerInfo.TotalResources)
{
return(AIHelper.CreateUpgradeAction(UpgradeType.MaximumHealth));
}
}
if (!isFull && adjacentResource == null && possibleResources.Count > 0)
{
if (possibleResources.Count > 0)
{
action = GoTo(possibleResources[0].Position, map, true);
}
else
{
Console.Out.WriteLine("Oups, no action for resource");
action = AIHelper.CreateEmptyAction();
}
}
else if (!isFull && adjacentResource != null)
{
action = AIHelper.CreateCollectAction(adjacentResource);
}
else if (isFull || possibleResources.Count == 0)
{
action = GoTo(PlayerInfo.HouseLocation, map, true);
}
return(action);
}
string GatherRessource()
{
if (Adjacent(miningDestination))
{
return(AIHelper.CreateCollectAction(Direction(brain.playerInfo.Position, miningDestination)));
}
else
{
return(GoTo(miningDestination));
}
}
public string NextAction(LegacyMap map, IPlayer player)
{
if (!done)
{
done = true;
Console.WriteLine(target - player.Position);
return(AIHelper.CreateCollectAction(target - player.Position));
}
else
{
return(null);
}
}
/// <summary>
/// Move to rock and if close enough, collect
/// </summary>
public static string MoveToRock(Map map)
{
Point position = new Point(2000, 2000);
if (PlayerInfo.CarriedResources == PlayerInfo.CarryingCapacity)
{
return(MovementActions.MoveTo(map, PlayerInfo.HouseLocation - PlayerInfo.Position));
}
else
{
foreach (Tile t in map.GetVisibleTiles())
{
if (t.TileType == TileContent.Resource)
{
if (Math.Pow(t.Position.X - PlayerInfo.Position.X, 2) + Math.Pow(t.Position.Y - PlayerInfo.Position.Y, 2)
< Math.Pow(position.X - PlayerInfo.Position.X, 2) + Math.Pow(position.Y - PlayerInfo.Position.Y, 2))
{
position = new Point(t.Position.X, t.Position.Y);
}
}
}
double distance = Math.Sqrt(Math.Pow((position.X - PlayerInfo.Position.X), 2) + (Math.Pow((position.Y - PlayerInfo.Position.Y), 2)));
if (distance > 1)
{
if (map.GetTileAt(PlayerInfo.Position.X + 1, PlayerInfo.Position.Y) == TileContent.Wall)
{
return(AIHelper.CreateMeleeAttackAction(new Point(1, 0)));
}
else if (map.GetTileAt(PlayerInfo.Position.X - 1, PlayerInfo.Position.Y) == TileContent.Wall)
{
return(AIHelper.CreateMeleeAttackAction(new Point(-1, 0)));
}
else if (map.GetTileAt(PlayerInfo.Position.X, PlayerInfo.Position.Y + 1) == TileContent.Wall)
{
return(AIHelper.CreateMeleeAttackAction(new Point(0, 1)));
}
else if (map.GetTileAt(PlayerInfo.Position.X, PlayerInfo.Position.Y - 1) == TileContent.Wall)
{
return(AIHelper.CreateMeleeAttackAction(new Point(0, -1)));
}
return(MovementActions.MoveTo(map, position - PlayerInfo.Position));
}
else
{
return(AIHelper.CreateCollectAction(position - PlayerInfo.Position));
}
}
}
/// <summary>
/// Implement your bot here.
/// </summary>
/// <param name="map">The gamemap.</param>
/// <param name="visiblePlayers">Players that are visible to your bot.</param>
/// <returns>The action you wish to execute.</returns>
internal string ExecuteTurn(Map map, IEnumerable <IPlayer> visiblePlayers)
{
if (PlayerInfo.CarriedResources >= PlayerInfo.CarryingCapacity)
{
return(WalkTowardsTile(PlayerInfo.HouseLocation, map, true));
}
int[] mineralDirection = MineralAdjacentDirection(map);
if (mineralDirection != null)
{
return(AIHelper.CreateCollectAction(new Point(mineralDirection[0], mineralDirection[1])));
}
else
{
var resource = LookForVisibleResource(map);
if (resource != null)
{
return(WalkTowardsTile(new Point(resource.X, resource.Y), map, false));
}
// randomly walk if no resource detected within range
else
{
if (map.GetTileAt(PlayerInfo.Position.X + _currentDirection, PlayerInfo.Position.Y) ==
TileContent.Wall)
{
_currentDirection *= -1;
distanceTravelled = 0;
moving = false;
previousDirection = INVALID_DIRECTION;
}
if (movingRandom)
{
return(MoveRandomly(map));
}
}
}
var data = StorageHelper.Read <TestClass>("Test");
return(AIHelper.CreateMoveAction(new Point(0, -1)));
}
private string moveToRessource(Point distance, List <Point> ressourcePositions, IPlayer playerInfor, Map map)
{
if (distance.X != 0)
{
if (Math.Abs((int)Point.DistanceSquared(ressourcePositions[0], PlayerInfo.Position)) == 1)
{
return(AIHelper.CreateCollectAction(miningPosition(ressourcePositions[0], PlayerInfo.Position)));
}
if (map.GetTileAt(playerInfor.Position.X - 1, playerInfor.Position.Y) == TileContent.Wall)
{
return(AIHelper.CreateMeleeAttackAction(new Point(-1, 0)));
}
if (map.GetTileAt(playerInfor.Position.X + 1, playerInfor.Position.Y) == TileContent.Wall)
{
return(AIHelper.CreateMeleeAttackAction(new Point(1, 0)));
}
return(distance.X > 0 ? AIHelper.CreateMoveAction(new Point(1, 0)) : AIHelper.CreateMoveAction(new Point(-1, 0)));
}
else if (distance.Y != 0)
{
if (Math.Abs((int)Point.DistanceSquared(ressourcePositions[0], PlayerInfo.Position)) == 1)
{
return(AIHelper.CreateCollectAction(miningPosition(ressourcePositions[0], PlayerInfo.Position)));
}
if (map.GetTileAt(playerInfor.Position.X, playerInfor.Position.Y - 1) == TileContent.Wall)
{
return(AIHelper.CreateMeleeAttackAction(new Point(0, -1)));
}
if (map.GetTileAt(playerInfor.Position.X, playerInfor.Position.Y + 1) == TileContent.Wall)
{
return(AIHelper.CreateMeleeAttackAction(new Point(0, 1)));
}
return(distance.Y > 0 ? AIHelper.CreateMoveAction(new Point(0, 1)) : AIHelper.CreateMoveAction(new Point(0, -1)));
}
return("");
}
internal string ExecuteTurn(Map map, IEnumerable <IPlayer> visiblePlayers)
{
//portion pathfinding pour les Mines debut
PathNoeud playerPosition = new PathNoeud(PlayerInfo.Position.X, PlayerInfo.Position.Y, 0, 0, null);
List <PathNoeud> minePosition = new List <PathNoeud>();
List <ResourceTile> minePosition_ = new List <ResourceTile>();
minePosition_ = GetVisibleResourceTiles(map);
foreach (ResourceTile rt in minePosition_)
{
minePosition.Add(new PathNoeud(rt.Position.X, rt.Position.Y, 0, 0, null));
}
List <PathNoeud> paths = new List <PathNoeud>();
//List<PathNoeud> finalPath = new List<PathNoeud>();
if (PlayerInfo.Position.X == PlayerInfo.HouseLocation.X)
{
if (PlayerInfo.Position.Y == PlayerInfo.HouseLocation.Y)
{
if (CanBuy_Amelioration(PlayerInfo))
{
return(WhatToBuy_Amelioration(PlayerInfo));
}
}
}
if (finalPath.Count() == 0)
{
if (MustReturnToHouse() || minePosition.Count == 0)
{
int x = PlayerInfo.HouseLocation.X;
int y = PlayerInfo.HouseLocation.Y;
PathNoeud housePath = new PathNoeud(x, y, 0, 0, null);
PathNoeud path = trouverPathMine(playerPosition, housePath, map, PlayerInfo);
paths.Add(path);
}
else
{
foreach (PathNoeud n in minePosition)
{
PathNoeud path = trouverPathMine(playerPosition, n, map, PlayerInfo);
if (path != null)
{
paths.Add(path);
}
}
}
if (paths.Count > 0)
{
PathNoeud currentPath = paths[0];
foreach (PathNoeud n in paths)
{
if (currentPath.getGCost() > n.getGCost())
{
currentPath = n;
}
}
//fin portion pathfinding
finalPath = new List <PathNoeud>();
while (currentPath != null)
{
finalPath.Add(currentPath);
currentPath = currentPath.getParent();
}
}
}
// miner si a coter dune mine
if (PlayerInfo.CarriedResources != PlayerInfo.CarryingCapacity && mineAutour(map, PlayerInfo))
{
int x = 0;
int y = 0;
for (int i = -1; i <= 1; i += 2)
{
if (TileContent.Resource == map.GetTileAt(PlayerInfo.Position.X + i, PlayerInfo.Position.Y))
{
x = PlayerInfo.Position.X + i;
y = PlayerInfo.Position.Y;
return(AIHelper.CreateCollectAction(new Point(x - PlayerInfo.Position.X, y - PlayerInfo.Position.Y)));
}
}
for (int i = -1; i <= 1; i += 2)
{
if (TileContent.Resource == map.GetTileAt(PlayerInfo.Position.X, PlayerInfo.Position.Y + i))
{
x = PlayerInfo.Position.X;
y = PlayerInfo.Position.Y + i;
return(AIHelper.CreateCollectAction(new Point(x - PlayerInfo.Position.X, y - PlayerInfo.Position.Y)));
}
}
}
// se deplacer
if (finalPath.Count > 0)
{
PathNoeud prochainMove = finalPath[finalPath.Count - 1];
if (map.GetTileAt(prochainMove.getX(), prochainMove.getY()) == TileContent.Wall)
{
return(AIHelper.CreateMeleeAttackAction(new Point(prochainMove.getX() - PlayerInfo.Position.X, prochainMove.getY() - PlayerInfo.Position.Y)));
}
else
{
finalPath.Remove(prochainMove);
return(AIHelper.CreateMoveAction(new Point(prochainMove.getX() - PlayerInfo.Position.X, prochainMove.getY() - PlayerInfo.Position.Y)));
}
}
var data = StorageHelper.Read <TestClass>("Test");
Console.WriteLine(data?.Test);
return(AIHelper.CreateMoveAction(new Point(_currentDirection, 0)));
return(null);
}
/// <summary>
/// Implement your bot here.
/// </summary>
/// <param name="map">The gamemap.</param>
/// <param name="visiblePlayers">Players that are visible to your bot.</param>
/// <returns>The action you wish to execute.</returns>
internal string ExecuteTurn(Map map, IEnumerable <IPlayer> visiblePlayers)
{
getInterestingObjects(map, PlayerInfo.Position);
objects.Sort((x, y) => x.priority.CompareTo(y.priority));
Point nextMove;
if (PlayerInfo.Position == PlayerInfo.HouseLocation)
{
nextMove = new Point();
if (PlayerInfo.GetUpgradeLevel(UpgradeType.Defence) == 0 && PlayerInfo.TotalResources >= upgrades[0])
{
return(AIHelper.CreateUpgradeAction(UpgradeType.Defence));
}
if (PlayerInfo.GetUpgradeLevel(UpgradeType.CarryingCapacity) == 0 && PlayerInfo.TotalResources >= upgrades[0])
{
return(AIHelper.CreateUpgradeAction(UpgradeType.CarryingCapacity));
}
if (PlayerInfo.GetUpgradeLevel(UpgradeType.AttackPower) == 0 && PlayerInfo.TotalResources >= upgrades[0])
{
return(AIHelper.CreateUpgradeAction(UpgradeType.AttackPower));
}
if (PlayerInfo.GetUpgradeLevel(UpgradeType.CarryingCapacity) == 1 && PlayerInfo.TotalResources >= upgrades[1])
{
return(AIHelper.CreateUpgradeAction(UpgradeType.CarryingCapacity));
}
if (PlayerInfo.GetUpgradeLevel(UpgradeType.CollectingSpeed) == 0 && PlayerInfo.TotalResources >= upgrades[0])
{
return(AIHelper.CreateUpgradeAction(UpgradeType.CollectingSpeed));
}
}
if (PlayerInfo.TotalResources >= 30000 && !PlayerInfo.CarriedItems.Contains(PurchasableItem.Backpack))
{
Point shopLocation = map.GetVisibleTiles().FirstOrDefault(x => x.TileType == TileContent.Shop)?.Position;
if (shopLocation == null)
{
TileContent tileToTheLeft = map.GetTileAt(PlayerInfo.Position.X - 1, PlayerInfo.Position.Y);
nextMove = tileToTheLeft != TileContent.Resource && tileToTheLeft != TileContent.Lava ? new Point(-1, 0) : new Point(0, 1);
}
else
{
nextMove = new PathFinder(map, PlayerInfo.Position, shopLocation).FindNextMove();
}
if (Point.DistanceSquared(PlayerInfo.Position, shopLocation) == 1)
{
return(AIHelper.CreatePurchaseAction(PurchasableItem.Backpack));
}
}
else if (PlayerInfo.CarriedResources == PlayerInfo.CarryingCapacity || objects.Count == 0)
{
nextMove = new PathFinder(map, PlayerInfo.Position, PlayerInfo.HouseLocation).FindNextMove();
}
else
{
nextMove = new PathFinder(map, PlayerInfo.Position, objects[0].position).FindNextMove();
}
Point shouldIStayOrShouldIGoNow = PlayerInfo.Position + nextMove;
TileContent content = map.GetTileAt(shouldIStayOrShouldIGoNow.X, shouldIStayOrShouldIGoNow.Y);
switch (content)
{
case TileContent.Empty:
case TileContent.House:
return(AIHelper.CreateMoveAction(nextMove));
case TileContent.Resource:
return(AIHelper.CreateCollectAction(nextMove));
case TileContent.Wall:
return(AIHelper.CreateMeleeAttackAction(nextMove));
case TileContent.Player:
return(AIHelper.CreateMeleeAttackAction(nextMove));
default:
return(AIHelper.CreateEmptyAction());
}
}
internal string ExecuteTurn(Map map, IEnumerable <IPlayer> visiblePlayers)
{
// TODO: Implement your AI here.
string instruction = "";
map.VisibleDistance = 20;
List <Tile> visibleTiles = map.GetVisibleTiles().ToList();
ressourceTiles = visibleTiles.Where(t => t.TileType == TileContent.Resource).ToList();
enemiesTiles = visibleTiles.Where(t => t.TileType == TileContent.Player).ToList();
DistanceFromTiles dist = new DistanceFromTiles(TrouverDistanceEntreDeuxPoints);
Point destination = PlayerInfo.HouseLocation;
Tuple <Point, TileContent> nextMove = null;
switch (listTitlePriority[0])
{
case TileContent.House:
nextMove = checkNextTile(map, destination);
break;
case TileContent.Lava:
break;
case TileContent.Player:
if (enemiesTiles.Count != 0)
{
enemiesTiles = enemiesTiles.OrderBy(p => dist(p.Position, PlayerInfo.Position)).ToList();
}
nextMove = checkNextTile(map, enemiesTiles[1].Position);
break;
case TileContent.Resource:
if (ressourceTiles.Count != 0)
{
ressourceTiles = ressourceTiles.OrderBy(t => dist(t.Position, PlayerInfo.Position)).ToList();
destination = ressourceTiles[0].Position;
}
nextMove = checkNextTile(map, destination);
break;
case TileContent.Shop:
break;
case TileContent.Wall:
break;
}
switch (nextMove.Item2)
{
case TileContent.Empty:
instruction = AIHelper.CreateMoveAction(nextMove.Item1 - this.PlayerInfo.Position);
break;
case TileContent.House:
instruction = AIHelper.CreateMoveAction(nextMove.Item1 - this.PlayerInfo.Position);
//nextMove = checkNextTile(map, closestResource.Position);
break;
case TileContent.Lava:
break;
case TileContent.Resource:
instruction = AIHelper.CreateCollectAction(nextMove.Item1 - this.PlayerInfo.Position);
break;
case TileContent.Shop:
break;
case TileContent.Player:
instruction = AIHelper.CreateMeleeAttackAction(nextMove.Item1 - this.PlayerInfo.Position);
break;
case TileContent.Wall:
instruction = AIHelper.CreateMeleeAttackAction(nextMove.Item1 - this.PlayerInfo.Position);
break;
}
if (vertical < 20)
{
vertical++;
instruction = AIHelper.CreateMoveAction(PlayerInfo.HouseLocation - this.PlayerInfo.Position);
}
var data = StorageHelper.Read <TestClass>("Test");
Console.WriteLine(data?.Test);
return(instruction);//AIHelper.CreateCollectAction(new Point(1, 0));
//return AIHelper.CreateMoveAction(new Point(-1, 0));
}
public override string GetNextMove(IPlayer player, IEnumerable <IPlayer> visiblePlayers, LegacyMap map)
{
// Dropper nos ressoruces si on est colles a la maison
if (Point.DistanceManhatan(player.HouseLocation, player.Position) == 0 && player.CarriedResources > 0)
{
return(AIHelper.CreateEmptyAction());
}
// Verifier si on doit rentrer pour drop nos ressources
if (player.CarryingCapacity - player.CarriedResources < 100)
{
Move moveTowardsHome = new Move(player, map, player.HouseLocation);
return(moveTowardsHome.NextAction(map, player));
}
// Trouver le filon le plus proche
Point closestMineralPosition = GetClosestMineralPosition(player, map);
// Si le filon le plus proche renvoit la maison, ca veut dire quon ne truove rien proche de nous. Nous allons donc aller explorer.
//if (closestMineralPosition.X == player.HouseLocation.X && closestMineralPosition.Y == player.HouseLocation.Y)
//{
// Random random = new Random();
// int randomlyGeneratedNumber = random.Next(1, 3);
// if (randomlyGeneratedNumber == 1)
// {
// Move moveTowardsHome = new Move(player, map, new Point(player.Position.X + 1, player.Position.Y));
// return moveTowardsHome.NextAction(map, player);
// }
// else
// {
// Move moveTowardsHome = new Move(player, map, new Point(player.Position.X, player.Position.Y -1));
// return moveTowardsHome.NextAction(map, player);
// }
//}
Console.WriteLine("");
// Sinon, good, on a qqch a miner. On trouve la case a partir de laquelle on va miner
Point closestMineralAdjacentPosition = GetClosestFreeAdjacentPosition(player, closestMineralPosition, map);
// Si on est colles au filon, le miner
if (Point.DistanceManhatan(closestMineralPosition, player.Position) <= 1)
{
return(AIHelper.CreateCollectAction(new Point(closestMineralPosition.X - player.Position.X,
closestMineralPosition.Y - player.Position.Y)));
}
// Si aller passer par la maison avant daller au filon ne nous ralenti pas, on va aller a la maison tds
// Verifier si on doit rentrer pour drop nos ressources
if ((player.CarriedResources >= 500) &&
((player.Position.X <= player.HouseLocation.X && closestMineralAdjacentPosition.X >= player.HouseLocation.X &&
player.Position.Y <= player.HouseLocation.Y && closestMineralAdjacentPosition.Y >= player.HouseLocation.Y)
|| (player.Position.X <= player.HouseLocation.X && closestMineralAdjacentPosition.X >= player.HouseLocation.X &&
player.Position.Y >= player.HouseLocation.Y && closestMineralAdjacentPosition.Y <= player.HouseLocation.Y)
|| (player.Position.X >= player.HouseLocation.X && closestMineralAdjacentPosition.X <= player.HouseLocation.X &&
player.Position.Y >= player.HouseLocation.Y && closestMineralAdjacentPosition.Y <= player.HouseLocation.Y)
|| (player.Position.X >= player.HouseLocation.X && closestMineralAdjacentPosition.X <= player.HouseLocation.X &&
player.Position.Y <= player.HouseLocation.Y && closestMineralAdjacentPosition.Y >= player.HouseLocation.Y)))
{
Move moveTowardsHome = new Move(player, map, player.HouseLocation);
return(moveTowardsHome.NextAction(map, player));
}
// Si on est pas colles, quon rentre pas, aller vers le filon
Move moveTowardsMineral = new Move(player, map, closestMineralAdjacentPosition);
return(moveTowardsMineral.NextAction(map, player));
}
/// <summary>
/// Implement your bot here.
/// </summary>
/// <param name="map">The gamemap.</param>
/// <param name="visiblePlayers">Players that are visible to your bot.</param>
/// <returns>The action you wish to execute.</returns>
internal string ExecuteTurn(Map map, IEnumerable <IPlayer> visiblePlayers)
{
worldMap = WorldMap.ReadMap();
if (worldMap == null || worldMap.HomePosition != PlayerInfo.HouseLocation)
{
worldMap = new WorldMap();
}
worldMap.UpdateWorldMap(map);
worldMap.HomePosition = PlayerInfo.HouseLocation;
WorldMap.WriteMap(worldMap);
this.astarService = new AStarAlgo(worldMap);
this.ressourcePlaner = new RessourcePlaner(worldMap, PlayerInfo, astarService);
this.navigationHelper = new NavigationHelper(PlayerInfo, astarService);
this.manathan = new Manathan();
this.placePlaner = new PlacePlaner(map, PlayerInfo, astarService);
Console.WriteLine("Cash : " + PlayerInfo.TotalResources);
try
{
var best_ressource = ressourcePlaner.GetBestRessourcePath();
//var best_place_for_shop = placePlaner.GetBestPlacePath(TileContent.Shop);
// 10000 15000 25000 50000 100000
if (PlayerInfo.Position == PlayerInfo.HouseLocation)
{
bool upgrade = false;
switch (PlayerInfo.GetUpgradeLevel(UpgradeType.AttackPower))
{
case 0:
if (PlayerInfo.TotalResources >= 10000)
{
upgrade = true;
}
break;
case 1:
if (PlayerInfo.TotalResources >= 15000)
{
upgrade = true;
}
break;
case 2:
if (PlayerInfo.TotalResources >= 25000)
{
upgrade = true;
}
break;
case 3:
if (PlayerInfo.TotalResources >= 50000)
{
upgrade = true;
}
break;
case 4:
if (PlayerInfo.TotalResources >= 100000)
{
upgrade = true;
}
break;
}
if (upgrade)
{
return(AIHelper.CreateUpgradeAction(UpgradeType.AttackPower));
}
}
if (PlayerInfo.CarriedResources < PlayerInfo.CarryingCapacity && best_ressource != null)
{
if (best_ressource.Path.Count == 2)
{
// On est adjacent à la meilleure ressource
var direction = astarService.DirectionToward(PlayerInfo.Position, best_ressource.Tile.Position);
return(AIHelper.CreateCollectAction(direction));
}
else if (best_ressource.Path.Count == 1)
{
// on est dessus
var tileToGo = map.GetTile(PlayerInfo.Position.X - 1, PlayerInfo.Position.Y);
var action = navigationHelper.NavigateToNextPosition(tileToGo);
return(action);
}
else
{
// On est pas rendu
return(navigationHelper.NavigateToNextPosition(best_ressource.Path[1]));
}
}
else
{
// on doit aller à la base
var home_tile = worldMap.GetTile(PlayerInfo.HouseLocation.X, PlayerInfo.HouseLocation.Y);
var current_tile = worldMap.GetTile(PlayerInfo.Position.X, PlayerInfo.Position.Y);
if (home_tile == null)
{
var path = manathan.GetManathanPath(current_tile.Position, PlayerInfo.HouseLocation);
return(navigationHelper.NavigateToNextPosition(worldMap.GetTile(path[0].X, path[0].Y)));
}
else
{
var best_path_to_home = astarService.Run(current_tile, home_tile);
if (best_path_to_home == null)
{
var path = manathan.GetManathanPath(current_tile.Position, PlayerInfo.HouseLocation);
return(navigationHelper.NavigateToNextPosition(worldMap.GetTile(path[0].X, path[0].Y)));
}
// On est pas rendu
return(navigationHelper.NavigateToNextPosition(best_path_to_home[1]));
}
}
}
catch (Exception e)
{
Console.WriteLine("*** Reset the map! ***");
Console.WriteLine(e.Message);
Console.WriteLine(e.StackTrace);
Console.WriteLine(e.InnerException);
Console.WriteLine("*** inner exception ***");
Console.WriteLine(e);
Console.WriteLine("*** exception ***");
worldMap = new WorldMap();
worldMap.UpdateWorldMap(map);
worldMap.HomePosition = PlayerInfo.HouseLocation;
WorldMap.WriteMap(worldMap);
return("");
}
/*
* AStarAlgo astar = new AStarAlgo(map);
* var result = astar.Run(PlayerInfo.Position, new Point(-4, 21));
*
*
* var data = StorageHelper.Read<TestClass>("Test");
* Console.WriteLine(data?.Test);
* //return AIHelper.CreateMoveAction(new Point(_currentDirection, 0)); astar.DirectionToward(PlayerInfo.Position, result[0].Position);
* return AIHelper.CreateMoveAction(astar.DirectionToward(PlayerInfo.Position, result[0].Position));*/
}
private string CollectRessource(Point direction)
{
return(AIHelper.CreateCollectAction(direction));
}
/// <summary>
/// Implement your bot here.
/// </summary>
/// <param name="map">The gamemap.</param>
/// <param name="visiblePlayers">Players that are visible to your bot.</param>
/// <returns>The action you wish to execute.</returns>
internal string ExecuteTurn(Map map, IEnumerable <IPlayer> visiblePlayers)
{
_currentDirection[0] = 0;
_currentDirection[1] = 0;
int[] HouseDistance = getHome(map);
if (ABS(HouseDistance[0], HouseDistance[1]) == 0)
{
for (int i = 0; i < 5; i++)
{
int price = prices[upgrades[i]];
if (price <= PlayerInfo.TotalResources)
{
upgrades[i] += 1;
/*return getType(i);*/
}
}
}
int[] ClosestMine = getDistance(TileContent.Resource, map);
int[] ClosestPlayer = getDistance(TileContent.Player, map);
if (ABS(ClosestPlayer[0], ClosestPlayer[1]) < 9 && ABS(ClosestPlayer[0], ClosestPlayer[1]) > 1)
{
return(MoveDirection(ClosestPlayer[0], ClosestPlayer[1], map));
}
else if (ABS(ClosestPlayer[0], ClosestPlayer[1]) == 1)
{
if (map.GetTileAt(PlayerInfo.Position.X + 1, PlayerInfo.Position.Y) == TileContent.Player)
{
return(AIHelper.CreateMeleeAttackAction(new Point(1, 0)));
}
if (map.GetTileAt(PlayerInfo.Position.X - 1, PlayerInfo.Position.Y) == TileContent.Player)
{
return(AIHelper.CreateMeleeAttackAction(new Point(-1, 0)));
}
if (map.GetTileAt(PlayerInfo.Position.X, PlayerInfo.Position.Y + 1) == TileContent.Player)
{
return(AIHelper.CreateMeleeAttackAction(new Point(0, 1)));
}
if (map.GetTileAt(PlayerInfo.Position.X, PlayerInfo.Position.Y - 1) == TileContent.Player)
{
return(AIHelper.CreateMeleeAttackAction(new Point(0, -1)));
}
}
bool full = (PlayerInfo.CarryingCapacity == PlayerInfo.CarriedResources);
if (!full)
{
if (ABS(ClosestMine[0], ClosestMine[1]) == 0)
{
return(MoveDirection(HouseDistance[0], HouseDistance[1], map));
}
if (ABS(ClosestMine[0], ClosestMine[1]) == 1) // a cote de la mine
{
if ((map.GetTileAt(PlayerInfo.Position.X + 1, PlayerInfo.Position.Y) == TileContent.Resource))
{
return(AIHelper.CreateCollectAction(new Point(1, 0)));
}
if ((map.GetTileAt(PlayerInfo.Position.X - 1, PlayerInfo.Position.Y) == TileContent.Resource))
{
return(AIHelper.CreateCollectAction(new Point(-1, 0)));
}
if ((map.GetTileAt(PlayerInfo.Position.X, PlayerInfo.Position.Y + 1) == TileContent.Resource))
{
return(AIHelper.CreateCollectAction(new Point(0, 1)));
}
if ((map.GetTileAt(PlayerInfo.Position.X, PlayerInfo.Position.Y - 1) == TileContent.Resource))
{
return(AIHelper.CreateCollectAction(new Point(0, -1)));
}
}
else
{
return(MoveDirection(ClosestMine[0], ClosestMine[1], map));
}
}
else
{
return(MoveDirection(HouseDistance[0], HouseDistance[1], map));
}
return(AIHelper.CreateMoveAction(new Point(0, 1)));
}
