//from my smallest to closest enemy
public List<MovesSet> AttackAction()
{
List<MovesSet> movesSet = new List<MovesSet>();
Planets enemyPlanets = Context.EnemyPlanets();
if (enemyPlanets.Count == 0) return movesSet;
enemyPlanets.Sort(new Comparer(Context).CompareGrowsRateGT);
Planet targetPlanet = enemyPlanets[0];
Planets myPlanets = Context.MyPlanets();
Comparer comparer = new Comparer(Context) {TargetPlanet = targetPlanet};
myPlanets.Sort(comparer.CompareDistanceToTargetPlanetLT);
foreach (Moves moves in from myPlanet in myPlanets
where myPlanet.GrowthRate() < targetPlanet.GrowthRate()
select new Moves(1)
{
new Move(myPlanet, targetPlanet, Context.CanSend(myPlanet))
})
{
movesSet.Add(new MovesSet(moves, 99999, GetAdviserName(), Context));
break;
}
return movesSet;
}
public Planet FindNextPlanetInPath(Planet source)
{
Planets enemyPlanets = Context.GetPlanetsByLastOwner(Context.PlanetHolders(), 2);
int supplyPlanetFrontLevel = Context.GetClosestPlanetDistance(source, enemyPlanets);
//Context.GetPlanetSummaryDistance(Context.EnemyPlanets(), supplyPlanet);
//Planets nearPlanets = Context.GetFrontPlanets();
Planets nearPlanets = Context.Planets();
if (nearPlanets.Count == 0) return null;
//if (nearPlanets.Contains(source)) return null;
Comparer comparer = new Comparer(Context) {TargetPlanet = source};
nearPlanets.Sort(comparer.CompareDistanceToTargetPlanetLT);
//return nearPlanets[0];
Planet result = null;
int resultFrontLevel = supplyPlanetFrontLevel;
int resultDistance = 0;
foreach (Planet nearPlanet in nearPlanets)
{
if (nearPlanet.PlanetID() == source.PlanetID()) continue;
int distance = Context.Distance(nearPlanet, source);
Planet futurePlanet = Context.PlanetFutureStatus(nearPlanet, distance);
if (futurePlanet.Owner() != 1) continue;
int nearPlanetFrontLevel = Context.GetClosestPlanetDistance(nearPlanet, enemyPlanets);
if (nearPlanetFrontLevel < resultFrontLevel)
{
if ((result == null) || (distance < resultDistance * 1.2))
{
result = nearPlanet;
resultFrontLevel = nearPlanetFrontLevel;
resultDistance = distance;
}
}
}
return result;
/*return (from nearPlanet in nearPlanets
where nearPlanet.PlanetID() != source.PlanetID()
let distance = Context.Distance(nearPlanet, source)
let futurePlanet = Context.PlanetFutureStatus(nearPlanet, distance)
where futurePlanet.Owner() == 1
let nearPlanetFrontLevel = Context.GetClosestPlanetDistance(nearPlanet, enemyPlanets)
where nearPlanetFrontLevel < supplyPlanetFrontLevel
select nearPlanet).FirstOrDefault();*/
}
public override Moves Run(Planet planet)
{
Moves moves = new Moves();
loseTurn = 0;
//Planet planet = SelectPlanetForAdvise();
if (planet == null) return moves;
List<Step> saveSteps = Context.GetMyPlanetSaveSteps(planet);
if (saveSteps.Count == 0) return moves;
foreach (Step t in saveSteps)
{
Planets planetsCanHelp = Context.MyPlanetsWithinProximityToPlanet(planet, t.ToTurn);
Comparer comparer = new Comparer(Context) {TargetPlanet = planet};
planetsCanHelp.Sort(comparer.CompareDistanceToTargetPlanetLT);
int sendedShipsNum = 0;
foreach (Planet nearPlanet in planetsCanHelp)
{
int canSend = Math.Min(t.NumShips - sendedShipsNum, Context.CanSendByPlanets(nearPlanet, planet));
if (canSend <= 0) continue;
int distance = Context.Distance(planet, nearPlanet);
Move move = new Move(nearPlanet.PlanetID(), planet.PlanetID(), canSend);
if (distance < t.ToTurn)
{
//delay move
move.TurnsBefore = t.ToTurn - distance;
//move = new Move(nearPlanet.PlanetID(), planet.PlanetID(), Context.CanSend(nearPlanet, move.TurnsBefore));
}
moves.Add(move);
sendedShipsNum += canSend;
}
if (sendedShipsNum < t.NumShips)
{
loseTurn = t.NumShips;
}
}
return moves;
}
public override Moves Run(Planet targetPlanet)
{
Moves moves = new Moves();
if (targetPlanet == null) return moves;
Planets myPlanets = Context.MyPlanets();
if (myPlanets.Count == 0) return moves;
Comparer comparer = new Comparer(Context) {TargetPlanet = targetPlanet};
myPlanets.Sort(comparer.CompareDistanceToTargetPlanetLT);
PlanetHolder holder = Context.GetPlanetHolder(targetPlanet);
foreach (Planet myPlanet in myPlanets)
{
int targetDistance = Context.Distance(myPlanet, targetPlanet);
int myCanSend = Context.CanSendByPlanets(myPlanet, targetPlanet);
if (myCanSend == 0) continue;
Planet futurePlanet = Context.PlanetFutureStatus(targetPlanet, targetDistance);
if (futurePlanet.Owner() != 2) continue;
if (holder.IsNeutralToEnemySwith(targetDistance)) continue;
int needToSend = 1 + futurePlanet.NumShips();
if (Config.AttackSendMoreThanEnemyCanDefend)
needToSend += Context.GetEnemyAid(targetPlanet, targetDistance);
needToSend = moves.Aggregate(needToSend, (current, eachMove) => current - Context.CanSend(Context.GetPlanet(eachMove.SourceID)));
if (needToSend <= 0) return moves;
int canSend = Math.Min(needToSend, myCanSend);
needToSend -= canSend;
Move move = new Move(myPlanet, targetPlanet, canSend);
moves.Add(move);
if (needToSend <= 0) return moves;
}
return new Moves();
}
public override Moves Run(Planet targetPlanet)
{
Moves moves = new Moves();
if (targetPlanet == null) return moves;
Planets nearestPlanets = Context.GetClosestPlanetsToTargetBySectors(targetPlanet, Context.MyPlanets());
//Context.MyPlanets();
//MyPlanetsWithinProximityToPlanet(planet, Config.InvokeDistanceForInvade);););
if (nearestPlanets.Count == 0) return moves;
if (nearestPlanets.Count > 1)
{
Comparer comparer = new Comparer(Context) { TargetPlanet = targetPlanet };
nearestPlanets.Sort(comparer.CompareDistanceToTargetPlanetLT);
}
foreach (Planet nearestPlanet in nearestPlanets)
{
int canSend = Context.CanSendByPlanets(nearestPlanet, targetPlanet);
if (canSend == 0) continue;
int distance = Context.Distance(targetPlanet, nearestPlanet);
Planet futurePlanet = Context.PlanetFutureStatus(targetPlanet, distance);
if (futurePlanet.Owner() == 2)//Error?
{
#if LOG
Logger.Log("InvadeAdvizer: Error?");
#endif
moves.Clear();
return moves;
}
int needToSend = futurePlanet.NumShips() + 1;
if (Config.InvadeSendMoreThanEnemyCanDefend)
{
int extraTurns = (int)Math.Ceiling(targetPlanet.NumShips() / (double)targetPlanet.GrowthRate());
if (Context.MyFutureProduction < Context.EnemyFutureProduction) extraTurns = 0;
if ((Context.MyFutureProduction == Context.EnemyFutureProduction) &&
(Context.MyTotalShipCount <= Context.EnemyTotalShipCount)) extraTurns = 0;
needToSend += Context.GetEnemyAid(targetPlanet, distance + extraTurns);
}
needToSend = moves.Aggregate(needToSend, (current, eachMove) => current - Context.CanSendByPlanets(Context.GetPlanet(eachMove.SourceID), Context.GetPlanet(eachMove.DestinationID)));
//delay closer moves
/*foreach (Move eachMove in moves)
{
int moveDistance = Context.Distance(eachMove.DestinationID, eachMove.SourceID);
int turns = distance - moveDistance;
eachMove.TurnsBefore = turns;
needToSend -= Context.CanSend(Context.GetPlanet(eachMove.SourceID), turns);
}*/
if (needToSend <= 0) return moves;
canSend = Math.Min(needToSend, canSend);
needToSend -= canSend;
Move move = new Move(nearestPlanet, targetPlanet, canSend);
moves.Add(move);
if (needToSend <= 0) return moves;
}
moves.Clear();
return moves;
}
//From my strongest to closest suitable enemy
public List<MovesSet> InvadeAction()
{
List<MovesSet> movesSet = new List<MovesSet>();
Planets myPlanets = Context.MyStrongestPlanets(1);
if (myPlanets.Count == 0) return movesSet;
Planet myStrongestPlanet = myPlanets[0];
int canSend = Context.CanSend(myStrongestPlanet);
Planets targetFuturePlanets = new Planets(Config.MaxPlanets);
targetFuturePlanets.AddRange(from eachPlanet in Context.Planets()
where eachPlanet.GrowthRate() != 0
let distance = Context.Distance(myStrongestPlanet, eachPlanet)
select Context.PlanetFutureStatus(eachPlanet, distance)
into futurePlanet where futurePlanet.Owner() == 0 && canSend > futurePlanet.NumShips() + 1 select futurePlanet);
if (targetFuturePlanets.Count == 0) return movesSet;
Comparer comparer = new Comparer(Context) { TargetPlanet = myStrongestPlanet };
targetFuturePlanets.Sort(comparer.CompareDistanceToTargetPlanetLT);
Moves moves = new Moves(1)
{
new Move(myStrongestPlanet, targetFuturePlanets[0],
Math.Min(canSend, targetFuturePlanets[0].NumShips() + 1))
};
movesSet.Add(new MovesSet(moves, 99999, GetAdviserName(), Context));
return movesSet;
}
public Planets GetFrontPlanets()
{
if (frontPlanets == null)
{
frontPlanets = new Planets(Config.MaxPlanets);
Planets targetPlanets = GetPlanetsByLastOwner(PlanetHolders(), 2);
if (additionalTargetPlanets != null) targetPlanets.AddRange(additionalTargetPlanets);
Planets myPlanets = GetPlanetsByLastOwner(PlanetHolders(), 1);
foreach (Planet targetPlanet in targetPlanets)
{
Planets closestPlanets = new Planets(Config.MaxPlanets);
if (Config.UseSectorsForFront) closestPlanets = GetClosestPlanetsToTargetBySectors(targetPlanet, myPlanets);
else
{
Planet closestPlanet = GetClosestPlanet(targetPlanet, myPlanets);
if (closestPlanet != null) closestPlanets.Add(closestPlanet);
}
Comparer comparer = new Comparer(this) {TargetPlanet = targetPlanet};
closestPlanets.Sort(comparer.CompareDistanceToTargetPlanetLT);
for (int i = 0; i < closestPlanets.Count; i++)
{
if (frontPlanets.IndexOf(closestPlanets[i]) != -1) continue;
bool isCloseEnough = true;
for (int j = 0; j < i; j++)
{
if (Distance(closestPlanets[i], closestPlanets[j]) <
Distance(closestPlanets[i], targetPlanet))
{
isCloseEnough = false;
break;
}
}
if (isCloseEnough) frontPlanets.Add(closestPlanets[i]);
}
}
}
return frontPlanets;
}
