/// <summary>
/// Returns whether the pirate attacked last turn
/// </summary>
public static PredictionResult AttackedLastTurn(Game game, Pirate p)
{
if (p == null)
{
return(PredictionResult.NotSure);
}
else if (p.HasPowerup(AttackPowerup.NAME))
{
return(PredictionResult.NotSure);
}
else if (p.TurnsToAttackReload == game.TurnsUntilAttackReload)
{
return(PredictionResult.True);
}
else
{
return(PredictionResult.False);
}
}
/// <summary>
/// Add possible responses to "chooser", based on the situation in "game" and in "statesManager"
/// </summary>
public override void AddResponseOptions(Game game, StatesManager statesManager, ActionsChooser chooser)
{
// if the pirate is not carrying treasure OR if he can't move, we cannot do anything
if (this.myPirate.State != PirateState.CarryingTreasure ||
!this.myPirate.CanMove)
{
return;
}
/*
* bool isEscorted = false;
* foreach (Pirate ally in game.GetMyFreePirates())
* {
* if (Game.InAttackRange(ally, myPirate, ally.AttackRadius))
* {
* isEscorted = true;
* break;
* }
* }*/
var sailOptions = game.GetCompleteSailOptions(this.myPirate, this.myPirate.InitialLocation, myPirate.DefenseDuration == 0 && Game.ManhattanDistance(myPirate, myPirate.InitialLocation) > myPirate.MaxSpeed, Terrain.EnemyLocation);
List <Pirate> closestEnemies = game.GetEnemyClosestPirates(myPirate, PirateState.Free);
// check all possible destinations for returning home
foreach (var pair in sailOptions)
{
if (sailOptions[0].Value > pair.Value && (game.GetPirateOn(pair.Key) == null || game.GetPirateOn(pair.Key).Owner == Owner.Me))
{
ActionsPack ap = ActionsPack.NewCommandPack(game, new SailCommand(this.myPirate, pair.Key), base.Id);
double prioritize = (pair.Value == 0 ? myPirate.CarriedTreasureValue * 65536 : 5.0 * (pair.Value + 1.0) / (pair.Value));
double stayAwayPrioritize = 10;
if (closestEnemies.Count > 0)
{
Pirate enemy = closestEnemies[0];
if (Game.ManhattanDistance(enemy, myPirate) > enemy.MaxSpeed)
{
double distanceToEnemy = Game.EuclideanDistance(pair.Key, enemy);
stayAwayPrioritize = 5.0 * (distanceToEnemy) / (distanceToEnemy + 1.0);
}
}
double value = (MOVE_TOWARDS_HOME + prioritize + stayAwayPrioritize - Utils.Pow(pair.Value, 1.3)) * myPirate.CarriedTreasureValue;
if (myPirate.HasPowerup(SpeedPowerup.NAME))
{
value = value * SPEED_POWERUP_MULTIPLYER;
}
if (game.GetAllMyPiratesCount() > game.ActionsPerTurn)
{
value += ARMADA_BONUS;
}
ap.BurnInformation("Made in ReturnTreasureEvent, Value: {0:F3}", value);
chooser.AddActionsPack(ap, value);
}
}
}
/// <summary>
/// Add possible responses to "chooser", based on the situation in "game" and in "statesManager"
/// </summary>
public override void AddResponseOptions(Game game, StatesManager statesManager, ActionsChooser chooser)
{
if (!this.myPirate.CanMove || this.myPirate.State != PirateState.Free) //If my pirate can't move, or isn't free he can't Seek&Destroy
{
return;
}
// get all the enemy pirates with treasure, sorted by their manhattan distance to me
List <Pirate> enemyPiratesWithTreasure = game.GetEnemyClosestPirates(this.myPirate, PirateState.CarryingTreasure);
ImpendingDoomState impendingDoom = statesManager.GetState <ImpendingDoomState>();
double pirateCountMultiplier = (double)game.ActionsPerTurn / (double)game.GetAllEnemyPiratesCount();
pirateCountMultiplier = pirateCountMultiplier > 1 ? 1.0 : pirateCountMultiplier;
// If the enemy has treasure
foreach (Pirate enemy in enemyPiratesWithTreasure)
{
if (Game.InAttackRange(this.myPirate, enemy, this.myPirate.AttackRadius - 1))
{
continue; //We are in attack range to AttackEvent. This should be handled by it.
}
int distanceLeftForEnemy = Game.ManhattanDistance(enemy, enemy.InitialLocation);
if (distanceLeftForEnemy <= 1 || distanceLeftForEnemy < Game.ManhattanDistance(this.myPirate, enemy) / game.ActionsPerTurn)
{
continue; //It's too late now, we can't reach him. Douchebag should handle this.
}
//get the sailing directions
ILocateable dest = enemy;
int distanceFromDest = (int)this.myPirate.AttackRadius - 2;
foreach (Powerup up in game.GetPowerups())
{
if (up is AttackPowerup && Game.OnTrack(myPirate, enemy, up))
{
dest = up;
distanceFromDest = 0;
break;
}
}
var sailOptions = game.GetCompleteSailOptions(this.myPirate, enemy, 0, distanceFromDest, Terrain.CurrentTreasureLocation, Terrain.EnemyLocation);
//Get sailing packs - with Value and Burnt information according to the Distance Category from the enemy
switch (GetDistanceCategory(game, enemy, Game.EuclideanDistance(myPirate, enemy)))
{
case DistanceCategory.Close: //enemy is close to me
foreach (var pair in sailOptions)
{
if (sailOptions[0].Value > pair.Value) //sail only if it's actually better than staying in place
{
ActionsPack ap = ActionsPack.NewCommandPack(game, new SailCommand(this.myPirate, pair.Key), base.Id);
ap.AddEnemyPirate(enemy);
double value = CLOSE_ENEMY_HAS_TREASURE * enemy.CarriedTreasureValue - Utils.Pow((pair.Value), 1.5) - Game.ManhattanDistance(pair.Key, enemy.InitialLocation);
if (impendingDoom.IsDoomIncoming)
{
value = value * IMPENDING_DOOM_MULTIPLYER;
}
if (myPirate.HasPowerup(AttackPowerup.NAME))
{
value = value * ATTACK_POWERUP_MULTIPLYER;
}
//value *= pirateCountMultiplier;
ap.BurnInformation("Made in SeekAndDestroyEvent, against {0}, value: {1:F3}, case: close treasure", enemy.Id, value);
chooser.AddActionsPack(ap, value);
}
}
break;
case DistanceCategory.Medium: //enemy is in medium range
foreach (var pair in sailOptions)
{
if (sailOptions[0].Value > pair.Value) //sail only if it's actually better than staying in place
{
ActionsPack ap = ActionsPack.NewCommandPack(game, new SailCommand(this.myPirate, pair.Key), base.Id);
ap.AddEnemyPirate(enemy);
double value = MEDIUM_RANGE_ENEMY_HAS_TREASURE * enemy.CarriedTreasureValue - Utils.Pow((pair.Value) + (game.ActionsPerTurn + 1) / 2 - 2, 1.3) - Game.ManhattanDistance(pair.Key, enemy.InitialLocation);
if (enemy.HasPowerup(SpeedPowerup.NAME))
{
value += ENEMY_WITH_SPEED_UP_AND_TREASURE;
}
if (impendingDoom.IsDoomIncoming)
{
value = value * IMPENDING_DOOM_MULTIPLYER;
}
if (myPirate.HasPowerup(AttackPowerup.NAME))
{
value = value * ATTACK_POWERUP_MULTIPLYER;
}
value *= pirateCountMultiplier;
ap.BurnInformation("Made in SeekAndDestroyEvent, against {0}, value: {1:F3}, case: medium treasure", enemy.Id, value);
chooser.AddActionsPack(ap, value);
}
}
break;
case DistanceCategory.Far: //enemy is far away
foreach (var pair in sailOptions)
{
if (sailOptions[0].Value > pair.Value) //sail only if it's actually better than staying in place
{
ActionsPack ap = ActionsPack.NewCommandPack(game, new SailCommand(this.myPirate, pair.Key), base.Id);
ap.AddEnemyPirate(enemy);
double value = FAR_RANGE_ENEMY_HAS_TREASURE * enemy.CarriedTreasureValue - Utils.Pow((pair.Value) - game.ActionsPerTurn / 3 - 2, 1.2) - Game.ManhattanDistance(pair.Key, enemy.InitialLocation);
if (enemy.HasPowerup(SpeedPowerup.NAME))
{
value += ENEMY_WITH_SPEED_UP_AND_TREASURE;
}
if (impendingDoom.IsDoomIncoming)
{
value = value * IMPENDING_DOOM_MULTIPLYER;
}
if (myPirate.HasPowerup(AttackPowerup.NAME))
{
value = value * ATTACK_POWERUP_MULTIPLYER;
}
value *= pirateCountMultiplier;
ap.BurnInformation("Made in SeekAndDestroyEvent, against {0}, value: {1:F3}, case: far treasure", enemy.Id, value);
chooser.AddActionsPack(ap, value);
}
}
break;
}
}
Pirate closest = null;
if (game.GetEnemyPiratesCount(PirateState.Free) > 0)
{
closest = game.GetEnemyClosestPirates(myPirate, PirateState.Free)[0];
}
//if the enemy doesn't have a treasure
foreach (Pirate enemy in game.GetEnemyPirates(PirateState.Free))
{
if (Game.InAttackRange(this.myPirate, enemy, this.myPirate.AttackRadius))
{
continue; //We are in attack range to AttackEvent. This should be handled by it.
}
//get the sailing directions
var sailOptions = game.GetCompleteSailOptions(this.myPirate, enemy, 0, (int)this.myPirate.AttackRadius, Terrain.CurrentTreasureLocation, Terrain.EnemyLocation);
//Get sailing packs - with Value and Burnt information according to the Distance Category from the enemy
if (enemy.PowerupCount > 0)
{
switch (GetDistanceCategory(game, enemy, Game.EuclideanDistance(myPirate, enemy)))
{
case DistanceCategory.Close: //enemy is close to me
foreach (var pair in sailOptions)
{
if (sailOptions[0].Value > pair.Value) //sail only if it's actually better than staying in place
{
ActionsPack ap = ActionsPack.NewCommandPack(game, new SailCommand(this.myPirate, pair.Key), base.Id);
ap.AddEnemyPirate(enemy);
double value = CLOSE_ENEMY_HAS_POWERUP - Utils.Pow((pair.Value), 1.3);
if (myPirate.HasPowerup(AttackPowerup.NAME))
{
value = value * ATTACK_POWERUP_MULTIPLYER;
}
value *= pirateCountMultiplier;
ap.BurnInformation("Made in SeekAndDestroyEvent, against {0}, value: {1:F3}, case: close powerup", enemy.Id, value);
chooser.AddActionsPack(ap, value);
}
}
break;
case DistanceCategory.Medium: //enemy is in medium range
foreach (var pair in sailOptions)
{
if (sailOptions[0].Value > pair.Value) //sail only if it's actually better than staying in place
{
ActionsPack ap = ActionsPack.NewCommandPack(game, new SailCommand(this.myPirate, pair.Key), base.Id);
ap.AddEnemyPirate(enemy);
double value = MEDIUM_RANGE_ENEMY_HAS_POWERUP - Utils.Pow((pair.Value) + (game.ActionsPerTurn + 1) / 2 - 2, 1.2);
if (myPirate.HasPowerup(AttackPowerup.NAME))
{
value = value * ATTACK_POWERUP_MULTIPLYER;
}
value *= pirateCountMultiplier;
ap.BurnInformation("Made in SeekAndDestroyEvent, against {0}, value: {1:F3}, case: medium powerup", enemy.Id, value);
chooser.AddActionsPack(ap, value);
}
}
break;
case DistanceCategory.Far: //enemy is far away
foreach (var pair in sailOptions)
{
if (sailOptions[0].Value > pair.Value) //sail only if it's actually better than staying in place
{
ActionsPack ap = ActionsPack.NewCommandPack(game, new SailCommand(this.myPirate, pair.Key), base.Id);
ap.AddEnemyPirate(enemy);
double value = FAR_RANGE_ENEMY_HAS_POWERUP - Utils.Pow((pair.Value) - game.ActionsPerTurn / 3 - 2, 1);
if (myPirate.HasPowerup(AttackPowerup.NAME))
{
value = value * ATTACK_POWERUP_MULTIPLYER;
}
value *= pirateCountMultiplier;
ap.BurnInformation("Made in SeekAndDestroyEvent, against {0}, value: {1:F3}, case: far powerup", enemy.Id, value);
chooser.AddActionsPack(ap, value);
}
}
break;
}
}
else if (enemy == closest || !game.EnemyArmada)
{
if (impendingDoom.IsDoomIncoming)
{
return;
}
if (myPirate.CanAttack) //Seek and Destroy a non-treasure enemy only if you can shoot him
{
if (Game.InAttackRange(this.myPirate, enemy, this.myPirate.AttackRadius))
{
continue; //We are in attack range to AttackEvent. This should be handled by it.;
}
//Get sailing packs
foreach (var pair in sailOptions)
{
if (sailOptions[0].Value > pair.Value) //sail only if it's actually better than staying in place
{
ActionsPack ap = ActionsPack.NewCommandPack(game, new SailCommand(this.myPirate, pair.Key), base.Id);
ap.AddEnemyPirate(enemy);
double value = Utils.Max(ENEMY_HAS_NO_TREASURE - Utils.Pow(pair.Value, 0.7), 1.0 / (pair.Value + 1.0));
if (myPirate.HasPowerup(AttackPowerup.NAME))
{
value = value * ATTACK_POWERUP_MULTIPLYER;
}
value *= pirateCountMultiplier;
ap.BurnInformation("Made in SeekAndDestroyEvent, against {0}, value: {1:F3}, case: no Treasure", enemy.Id, value);
chooser.AddActionsPack(ap, value);
}
}
}
}
}
}
/// <summary>
/// Add possible responses to "chooser", based on the situation in "game" and in "statesManager"
/// </summary>
public override void AddResponseOptions(Game game, StatesManager statesManager, ActionsChooser chooser)
{
if (!this.myPirate.CanMove || this.myPirate.State != PirateState.Free) //If my pirate can't move or isn't free, he can't go to fetch treasures.
{
return;
}
// Get threatened treasure state
ThreatenedTreasureState treasureState = statesManager.GetState <ThreatenedTreasureState>();
// Get all the free treasures and sort them by manhattan distance to me
List <Treasure> freeTreasures = treasureState.GetSafeTreasures().OrderBy(t => Game.ManhattanDistance(t, this.myPirate)).ToList();
// calculate the maximum amount of treasures to check
int maxTreasuresToCheck = (int)Utils.Min(freeTreasures.Count, game.GetMyPiratesCount(PirateState.Free), game.ActionsPerTurn, game.MaxCommandsPerTurn);
// remove all the excess treasures, based on their value
Dictionary <int, int> usedTreasuresDict = new Dictionary <int, int>(); // the key is the value of the treasure, and the value is how many treasures with the value are already in the list
for (int i = 0; i < freeTreasures.Count;)
{
if (usedTreasuresDict.ContainsKey(freeTreasures[i].Value))
{
usedTreasuresDict[freeTreasures[i].Value]++;
if (usedTreasuresDict[freeTreasures[i].Value] > maxTreasuresToCheck)
{
freeTreasures.RemoveAt(i);
}
else
{
i++;
}
}
else
{
usedTreasuresDict.Add(freeTreasures[i].Value, 1);
i++;
}
}
double multiplyer = Utils.Pow(1 - ((double)game.GetMyPiratesCount(PirateState.CarryingTreasure)) / game.GetMyPiratesCount(PirateState.Free, PirateState.CarryingTreasure), 2);
// try to sail to each treasure
foreach (Treasure t in freeTreasures)
{
if (game.GetPirateOn(t) != null) // there is a pirate where the treasure is, most likely a drunk one. Leave it be.
{
continue;
}
ILocateable dest = t;
// search for a speed powerup on the way to the treasure
foreach (Powerup up in game.GetPowerups())
{
if (up is SpeedPowerup && Game.OnTrack(myPirate, t, up))
{
dest = up;
break;
}
}
var sailOptions = game.GetCompleteSailOptions(this.myPirate, dest, Terrain.EnemyLocation, Terrain.CurrentTreasureLocation);
int maxActionsUsed = (int)Utils.Min(this.myPirate.MaxSpeed, game.ActionsPerTurn, Game.ManhattanDistance(this.myPirate, dest));
foreach (var pair in sailOptions)
{
if (sailOptions[0].Value > pair.Value) //sail only if it's actually better than staying in place
{
ActionsPack ap = ActionsPack.NewCommandPack(game, new SailCommand(this.myPirate, pair.Key), base.Id);
ap.AddTreasure(t);
double returnDistance = Game.ManhattanDistance(this.myPirate.InitialLocation, t);
double maxDistance = game.Rows + game.Collumns;
double value = (FETCH_VALUE - Utils.Pow(pair.Value, 0.9)) * multiplyer * ((maxDistance - returnDistance) / (maxDistance));
if (game.GetTreasuresCount(TreasureState.BeingCarried, TreasureState.Taken) == 0 && Game.ManhattanDistance(pair.Key, this.myPirate) == maxActionsUsed)
{
value += GAME_START_MULT;
}
value *= t.Value;
if (myPirate.HasPowerup(SpeedPowerup.NAME))
{
value *= SPEED_POWERUP_MULTIPLYER;
}
ap.BurnInformation("Made in FetchTreasureEvent. Fetching Treasure: {0}, value: {1:F3}", t.Id, value);
chooser.AddActionsPack(ap, value);
}
}
}
}
/// <summary>
/// Add possible responses to "chooser", based on the situation in "game" and in "statesManager"
/// </summary>
public override void AddResponseOptions(Game game, StatesManager statesManager, ActionsChooser chooser)
{
if (this.myPirate.State != PirateState.Free)
{
return;
}
bool inRisk = false; // Is my pirate in risk of shooting right now?
foreach (Pirate threat in game.GetEnemyPirates(PirateState.Free))
{
if (Game.InAttackRange(threat, myPirate, threat.AttackRadius) || Game.ManhattanDistance(threat, myPirate) <= threat.MaxSpeed)
{
inRisk = true;
break;
}
}
bool isDouche = game.GetPirateSpawnOn(myPirate) != null && game.GetPirateSpawnOn(myPirate).Owner == Owner.Enemy; // If my pirate is a douche, he shouldn't ram the enemy since spawn-blocking is better.
// try to attack every enemy pirate which is carrying a treasure / which is free
foreach (Pirate enemy in game.GetEnemyPirates(PirateState.CarryingTreasure, PirateState.Free, PirateState.Drunk))
{
//safe attack a treasure carrier
if (enemy.State == PirateState.CarryingTreasure)
{
if (Game.InAttackRange(this.myPirate, enemy, this.myPirate.AttackRadius - 1) && //in close range - enemy can't escape
game.IsAttackPossible(this.myPirate, enemy) && //can fire
(!inRisk || isDouche)) // it's safe to shoot (a douche shouldn't care if it's safe or not to shoot - he has nothing to lose)
{
ActionsPack ap = ActionsPack.NewCommandPack(game, new AttackCommand(this.myPirate, enemy), this.Id);
double value = ENEMY_HAS_TREASURE * enemy.CarriedTreasureValue;
if (myPirate.HasPowerup(AttackPowerup.NAME))
{
value *= ATTACK_POWERUP_MULTIPLYER;
}
ap.BurnInformation("Made in AttackEvent, case: shoot treasure. Value: {0:F3}", value);
chooser.AddActionsPack(ap, value);
}
else if ((Game.ManhattanDistance(enemy, enemy.InitialLocation) <= enemy.MaxSpeed || inRisk || !myPirate.CanAttack || myPirate.TurnsToAttackReload > enemy.DefenseDuration) && enemy.MaxSpeed < myPirate.MaxSpeed && !enemy.HasPowerup(SpeedPowerup.NAME))// ram
{
if (!isDouche || (!myPirate.CanDefend && inRisk && Game.ManhattanDistance(enemy, enemy.InitialLocation) > enemy.MaxSpeed))
{
// ram his predicted location
Location predictedLocation = game.PredictMovement(enemy);
// if there is no predicted location, try to ram his current location
if (predictedLocation == null)
{
predictedLocation = enemy.Location;
}
if (Game.ManhattanDistance(predictedLocation, myPirate) <= myPirate.MaxSpeed) // too far to ram
{
ActionsPack ap = ActionsPack.NewCommandPack(game, new SailCommand(this.myPirate, predictedLocation), this.Id);
ap.AddEnemyPirate(enemy);
double value = ENEMY_HAS_TREASURE * enemy.CarriedTreasureValue - Game.ManhattanDistance(myPirate, enemy);
ap.BurnInformation("Made in AttackEvent, case: ram treasure. Value: {0:F3}", value);
chooser.AddActionsPack(ap, value);
}
}
}
else if (enemy.DefenseDuration > 0 && myPirate.TurnsToAttackReload < enemy.DefenseDuration &&
Game.InAttackRange(this.myPirate, enemy, this.myPirate.AttackRadius - 1))
{
var sailOptions = game.GetCompleteSailOptions(this.myPirate, enemy.InitialLocation, 0, 0, this.myPirate.MaxSpeed, this.myPirate.DefenseDuration == 0, 0, enemy.MaxSpeed, 2, Terrain.EnemyLocation, Terrain.CurrentTreasureLocation);
foreach (var pair in sailOptions)
{
if (sailOptions[0].Value > pair.Value) // sail only if it's actually better than staying in place
{
ActionsPack ap = ActionsPack.NewCommandPack(game, new SailCommand(this.myPirate, pair.Key), base.Id);
ap.AddEnemyPirate(enemy);
double value = GHOST_TREASURE_VAL * enemy.CarriedTreasureValue - Utils.Pow(pair.Value, 1.5) - Game.ManhattanDistance(pair.Key, enemy);
if (myPirate.HasPowerup(AttackPowerup.NAME))
{
value *= ATTACK_POWERUP_MULTIPLYER;
}
ap.BurnInformation("Made in AttackEvent, against {0}, value: {1:F3}, case: ghost shielded treasure", enemy.Id, value);
chooser.AddActionsPack(ap, value);
}
}
}
}
else if (enemy.PowerupCount > 0)
{
/*double multiplier = 2 * game.GetMyPiratesInAttackRange(enemy, PirateState.Free).Count;
* multiplier += 4 * game.GetMyPiratesInAttackRange(enemy, PirateState.CarryingTreasure).Count;*/
double multiplier = 1;
if (game.GetMyPiratesInAttackRange(enemy, PirateState.Free).Count > 1 && game.GetMyPiratesInAttackRange(enemy, PirateState.CarryingTreasure).Count == 0)
{
multiplier = 8;
}
if (game.IsAttackPossible(myPirate, enemy) && enemy.TurnToSober == 0) //fire!
{
ActionsPack ap = ActionsPack.NewCommandPack(game, new AttackCommand(this.myPirate, enemy), base.Id);
double value = ENEMY_HAS_POWERUP;
if (myPirate.HasPowerup(AttackPowerup.NAME))
{
value = value * ATTACK_POWERUP_MULTIPLYER;
}
value = value * multiplier;
ap.BurnInformation("Made in AttackEvent, case: shoot powerup. Value: {0:F3}", value);
chooser.AddActionsPack(ap, value);
}
else if (Game.ManhattanDistance(myPirate, enemy) <= myPirate.MaxSpeed && myPirate.PowerupCount == 0)// ram
{
if (!isDouche)
{
if (!enemy.CanAttack && !enemy.CanDefend)
{
continue;
}
// ram his location
Location enemyLocation = enemy.Location; // assume enemy will shoot or defend, otherwise ramming is practically impossible
ActionsPack ap = ActionsPack.NewCommandPack(game, new SailCommand(this.myPirate, enemyLocation), base.Id);
double value = ENEMY_HAS_POWERUP - Game.ManhattanDistance(myPirate, enemy);
value = value * multiplier;
ap.AddEnemyPirate(enemy);
ap.BurnInformation("Made in AttackEvent, case: ram powerup. Value: {0:F3}", value);
chooser.AddActionsPack(ap, value);
}
}
}
//just attack a free pirate
else if (enemy.State == PirateState.Free && Game.InAttackRange(this.myPirate, enemy, this.myPirate.AttackRadius))
{
if (!myPirate.CanAttack)
{
continue;
}
if (enemy.DefenseDuration > 0)
{
continue;
}
if (game.IsAttackPossible(this.myPirate, enemy))
{
ActionsPack ap = ActionsPack.NewCommandPack(game, new AttackCommand(this.myPirate, enemy), base.Id);
/*double multiplier = 2 * game.GetMyPiratesInAttackRange(enemy, PirateState.Free).Count;
* multiplier += 4 * game.GetMyPiratesInAttackRange(enemy, PirateState.CarryingTreasure).Count;*/
double multiplier = 1;
if (game.GetMyPiratesInAttackRange(enemy, PirateState.Free).Count > 1 && game.GetMyPiratesInAttackRange(enemy, PirateState.CarryingTreasure).Count == 0)
{
multiplier = 8;
}
double value = ENEMY_HAS_NO_TREASURE * multiplier;
if (myPirate.HasPowerup(AttackPowerup.NAME))
{
value = value * ATTACK_POWERUP_MULTIPLYER;
}
ap.BurnInformation("Made in AttackEvent, case: shoot regular. Value: {0:F3}", value);
chooser.AddActionsPack(ap, value);
}
}
}
}
/// <summary>
/// Add possible responses to "chooser", based on the situation in "game" and in "statesManager"
/// </summary>
public override void AddResponseOptions(Game game, StatesManager statesManager, ActionsChooser chooser)
{
if (this.treasure.CarryingPirate == null)
{
return;
}
Pirate carrying = this.treasure.CarryingPirate;
double multiplyer = Utils.Pow(1 - ((double)game.GetMyPiratesCount(PirateState.CarryingTreasure)) / game.GetMyPiratesCount(PirateState.Free, PirateState.CarryingTreasure), 2);
multiplyer *= this.treasure.Value;
switch (carrying.Owner)
{
case Owner.Enemy:
if (game.GetMyPiratesCount(PirateState.Free) > 0)
{
Pirate myClosestPirate = game.GetMyClosestPirates(carrying, PirateState.Free)[0];
foreach (Pirate free in game.GetMyPirates(PirateState.Free))
{
if (free == myClosestPirate)
{
continue;
}
var sailOptions = game.GetCompleteSailOptions(free, treasure.InitialLocation, Terrain.EnemyLocation, Terrain.CurrentTreasureLocation);
foreach (var pair in sailOptions)
{
if (sailOptions[0].Value > pair.Value) //sail only if it's actually better than staying in place
{
ActionsPack ap = ActionsPack.NewCommandPack(game, new SailCommand(free, pair.Key), base.Id);
ap.AddTreasure(treasure);
double returnDistance = Game.ManhattanDistance(free.InitialLocation, treasure);
double maxDistance = game.Rows + game.Collumns;
double value = (TREASURE_VALUE - Utils.Pow(pair.Value, 0.9)) * multiplyer * ((maxDistance - returnDistance) / (maxDistance));
if (myClosestPirate.HasPowerup(SpeedPowerup.NAME))
{
value = value * SPEED_POWERUP_MULTIPLYER;
}
switch (GetDistanceCategory(game, myClosestPirate, Game.EuclideanDistance(carrying, myClosestPirate)))
{
case DistanceCategory.Close:
value = value * ENEMY_HAS_TREASURE_ALLY_CLOSE;
ap.BurnInformation("Made in GhostTreasureEvent, collecting treasure {0} from {1}, value: {2:F3}, case: close ally", treasure.Id, carrying.Id, value);
break;
case DistanceCategory.Medium:
value = value * ENEMY_HAS_TREASURE_ALLY_MEDIUM;
ap.BurnInformation("Made in GhostTreasureEvent, collecting treasure {0} from {1}, value: {2:F3}, case: medium ally", treasure.Id, carrying.Id, value);
break;
case DistanceCategory.Far:
value = value * ENEMY_HAS_TREASURE_ALLY_FAR;
ap.BurnInformation("Made in GhostTreasureEvent, collecting treasure {0} from {1}, value: {2:F3}, case: far ally", treasure.Id, carrying.Id, value);
break;
default:
continue;
}
chooser.AddActionsPack(ap, value);
}
}
}
}
break;
case Owner.Me:
if (game.GetEnemyPiratesCount(PirateState.Free) > 0)
{
Pirate closestEnemy = game.GetEnemyClosestPirates(carrying, PirateState.Free)[0];
if (Game.InAttackRange(carrying, closestEnemy, closestEnemy.AttackRadius + closestEnemy.MaxSpeed))
{
if (game.GetMyPiratesCount(PirateState.Free) > 0)
{
Pirate closestAlly = game.GetMyClosestPirates(carrying, PirateState.Free)[0];
if (Game.InAttackRange(carrying, closestAlly, closestAlly.AttackRadius) || Game.InAttackRange(closestAlly, closestEnemy, closestAlly.AttackRadius))
{
return; // is safe by the power of escort
}
foreach (Pirate free in game.GetMyPirates(PirateState.Free))
{
var sailOptions = game.GetCompleteSailOptions(free, treasure.InitialLocation, Terrain.EnemyLocation, Terrain.CurrentTreasureLocation);
foreach (var pair in sailOptions)
{
if (sailOptions[0].Value > pair.Value) //sail only if it's actually better than staying in place
{
ActionsPack ap = ActionsPack.NewCommandPack(game, new SailCommand(free, pair.Key), base.Id);
ap.AddTreasure(treasure);
double returnDistance = Game.ManhattanDistance(free.InitialLocation, treasure);
double maxDistance = game.Rows + game.Collumns;
double value = (TREASURE_VALUE - Utils.Pow(pair.Value, 0.9)) * multiplyer * ((maxDistance - returnDistance) / (maxDistance));
if (free.HasPowerup(SpeedPowerup.NAME))
{
value = value * SPEED_POWERUP_MULTIPLYER;
}
value = value * ALLY_ABOUT_TO_DIE;
ap.BurnInformation("Made in GhostTreasureEvent, collecting treasure {0} from {1}, value: {2:F3}, case: dead ally", treasure.Id, carrying.Id, value);
chooser.AddActionsPack(ap, value);
}
}
}
}
}
}
break;
default:
break;
}
}
