public static bool TryAttack(Pirate pirate, PirateGame game)
{
if (game.GetOpponentName() == "12220" || game.GetOpponentName() == "12224" || game.GetOpponentName() == "12109" || game.GetOpponentName() == "12111")
{
// Go over all enemies
foreach (Aircraft enemy in game.GetEnemyLivingAircrafts())
{
// Check if the enemy is in attack range and he's not our decoy
if (enemy != game.GetMyDecoy() && pirate.InAttackRange(enemy))
{
// Fire!
game.Attack(pirate, enemy);
// Print a message
game.Debug("pirate " + pirate + " attacks " + enemy);
// Did attack
return(true);
}
}
}
else
{
// Go over all enemy drones
foreach (Drone enemy in game.GetEnemyLivingDrones())
{
// Check if the enemy is in attack range and he's not our decoy
if (pirate.InAttackRange(enemy))
{
// Fire!
game.Attack(pirate, enemy);
// Print a message
game.Debug("pirate " + pirate + " attacks " + enemy);
// Did attack
return(true);
}
}
//Go over all enemy pirates
foreach (Pirate enemy in game.GetEnemyLivingPirates())
{
// Check if the enemy is in attack range and he's not our decoy
if (enemy != game.GetMyDecoy() && pirate.InAttackRange(enemy))
{
// Fire!
game.Attack(pirate, enemy);
// Print a message
game.Debug("pirate " + pirate + " attacks " + enemy);
// Did attack
return(true);
}
}
}
// Didn't attack
return(false);
}
public static void MoveAircraft(Drone drone, MapObject destination, PirateGame game)
{
if (game.GetOpponentName() == "12220")
{
destination = game.GetMyCities()[1];
}
// Get sail options for the pirate to get to the destination
List <Location> sailOptions = game.GetSailOptions(drone, destination);
if (game.GetOpponentName() == "12110") // 2nd Week 3rd Bot
{
if (drone.Location.Row != game.GetMyCities()[0].Location.Row)
{
game.SetSail(drone, sailOptions[FindSafeSpot(sailOptions, game)]);
}
else if (game.GetMyLivingDrones().Count > 10 && game.GetMyLivingDrones()[10].Location.Row == game.GetMyCities()[0].Location.Row)
{
game.SetSail(drone, sailOptions[FindSafeSpot(sailOptions, game)]);
}
}
else
{
// Set sail towards the destination
game.SetSail(drone, sailOptions[FindSafeSpot(sailOptions, game)]);
// Debug
game.Debug("Drone " + drone + " sails to " + sailOptions[FindSafeSpot(sailOptions, game)] + game.GetOpponentName().ToString());
}
}
// ------------------------------------------
// Assisting functions
// ------------------------------------------
private void Print(string s)
{
if (Debug)
{
game.Debug(s);
}
}
/// <summary> Calculates what is the best task to asign </summary>
/// <returns> Tuple with the pirate and the task-type </returns>
public Tuple <Pirate, TaskType> BestTaskToAssign()
{
var scores = new Dictionary <Tuple <Pirate, TaskType>, double>();
foreach (Pirate pirate in unemployedPirates)
{
foreach (TaskType taskType in todoTasks)
{
Task task = TaskTypeToTask(pirate, taskType);
double score = task.Bias() + task.GetWeight();
scores[new Tuple <Pirate, TaskType>(pirate, taskType)] = score;
}
}
if (scores.Count > 0)
{
var best = scores.OrderByDescending(pair => pair.Value).First();
if (fullDebug)
{
(from pirate in unemployedPirates
let tasks = from tup in scores.Keys.Where(p => pirate.Equals(p)) select tup.Item2 + " > " + scores[tup]
let taskString = tasks.Aggregate((t1, t2) => t1 + " || " + t2)
select taskString).ToList().ForEach(game.Debug);
game.Debug("Gave: " + best.Key.Item1.Id + " | " + best.Key.Item2 + " at: " + best.Value);
}
return(best.Key);
}
return(new Tuple <Pirate, TaskType>(game.GetMyLivingPirates()[0], TaskType.MINER));
}
public static void MoveAircraft(Aircraft aircraft, MapObject destination, PirateGame game)
{
// Get sail options for the pirate to get to the destination
List <Location> sailOptions = game.GetSailOptions(aircraft, destination);
// Set sail towards the destination
game.SetSail(aircraft, sailOptions[0]);
// Debug
game.Debug("aircraft " + aircraft + " sails to " + sailOptions[0]);
}
public void DoTurn(PirateGame game)
{
try
{
int turn = game.Turn;
SquadPirateHandler handler;
/* Update Game */
Engine.Store.NextTurn();
Engine.Update(game);
/* Strategy Change Check */
handler = new PVPBot();
/* Display logs */
if (turn > 1)
{
Engine.PrintStatusLog();
}
/* Play Strategy Selection */
Engine.DoTurn(handler);
/* Display logs */
if (turn > 1)
{
Engine.PrintActionLog();
}
Engine.Store.Flush();
game.Debug("Turn took: " + (game.GetMaxTurnTime() - game.GetTimeRemaining()) + "ms / " + game.GetMaxTurnTime() + "ms");
}
catch (System.Exception e)
{
/* Error Handling */
game.Debug("Error!");
game.Debug(e.Message);
game.Debug(e.StackTrace);
}
}
bool done = false; //Got island 0
public void DoTurn(PirateGame game)
{
game.Debug(game.GetOpponentName());
// Give orders to my pirates
HandlePirates(game);
// Give orders to my drones if my city exists
if (game.GetMyCities().Count > 0 || game.GetNeutralCities().Count > 0)
{
HandleDrones(game);
}
HandleDecoy(game);
}
public static bool TryAttack(Pirate pirate, PirateGame game, Pirate enemy)
{
// Check if the enemy is in attack range and he's not our decoy
if (pirate.InAttackRange(enemy))
{
// Fire!
game.Attack(pirate, enemy);
// Print a message
game.Debug("pirate " + pirate + " attacks " + enemy);
// Did attack
return(true);
}
// Didn't attack
return(false);
}
private void HandlePirates(PirateGame game)
{
// Go over all of my pirates
foreach (Pirate pirate in game.GetMyLivingPirates())
{
if (!TryAttack(pirate, game))
{
// Get the first island
Island destination = game.GetAllIslands()[0];
// Get sail options
List <Location> sailOptions = game.GetSailOptions(pirate, destination);
// Set sail!
game.SetSail(pirate, sailOptions[0]);
// Print a message
game.Debug("pirate " + pirate + " sails to " + sailOptions[0]);
}
}
}
public static void MoveAircraft(Pirate pirate, MapObject destination, PirateGame game)
{
// Get sail options for the pirate to get to the destination
List <Location> sailOptions = game.GetSailOptions(pirate, destination);
// Set sail towards the destination\
if (game.GetOpponentName() == "12111")
{
game.SetSail(pirate, sailOptions[sailOptions.Count - 1]);
}
else
{
game.SetSail(pirate, sailOptions[0]);
}
// Debug
game.Debug("Pirate " + pirate + " sails to " + sailOptions[0] + game.GetOpponentName().ToString());
}
public bool TryAttack(Pirate pirate, PirateGame game)
{
// Go over all enemies
foreach (Aircraft enemy in game.GetEnemyLivingAircrafts())
{
// Check if the enemy is in attack range
if (pirate.InAttackRange(enemy))
{
// Fire!
game.Attack(pirate, enemy);
// Print a message
game.Debug("pirate " + pirate + " attacks " + enemy);
// Did attack
return(true);
}
}
// Didnt attack
return(false);
}
override public string Preform()
{
if (game.GetEnemyCapsules().Count() == 0 || game.GetEnemyMotherships().Count() == 0)
{
return(Utils.GetPirateStatus(pirate, "No enemy capsules or ships"));
}
var nearestCapsule = Utils.OrderByDistance(game.GetEnemyCapsules().ToList(), pirate.Location).First();
var nearestShip = Utils.OrderByDistance(game.GetEnemyMotherships().ToList(), nearestCapsule.Location).First();
if (Main.didTurn.Contains(pirate.Id))
{
return(Utils.GetPirateStatus(pirate, "Already did turn"));
}
if (Utils.HasEnemyBomb(pirate))
{
return(Utils.GetPirateStatus(pirate, Sailing.SafeSail(pirate, new Location(0, 0))));
}
var sortedEnemyHolders = Utils.EnemyHoldersByDistance(pirate.GetLocation()).Where(enemy => !Main.piratesPushed.Contains(enemy) && pirate.CanPush(enemy));
bool shouldGo = !sortedEnemyHolders.Any() || pirate.MaxSpeed * 4 + pirate.Distance(nearestShip) < sortedEnemyHolders.First().Distance(nearestShip);
if (shouldGo)
{
foreach (Wormhole hole in game.GetAllWormholes().Where(h => h.Distance(nearestShip) < pirate.MaxSpeed * 10 && !Main.wormsPushed.Contains(h)))
{
var molesByDistance = Utils.PiratesWithTask(TaskType.MOLE).OrderBy(hole.Distance);
bool closest = molesByDistance.First().Id == pirate.Id || (molesByDistance.Count() > 1 && molesByDistance.Take(2).Contains(pirate));
var eholdersbydistance = Utils.EnemyHoldersByDistance(nearestShip.GetLocation());
if (!pirate.CanPush(hole) && pirate.PushRange < pirate.Distance(hole) && closest)
{
var wormLoc = pirate.Location.Towards(hole, pirate.Distance(hole) - hole.WormholeRange);
var assDanger = game.__livingAsteroids.Any(a => a.Location.Add(a.Direction).Distance(pirate) <= a.Size + pirate.MaxSpeed * 2);
var bombDanger = game.__stickyBombs.Any(b => b.Distance(pirate) < b.ExplosionRange + pirate.MaxSpeed * 2);
var wormPushLocation = pirate.Location.Towards(hole, pirate.Distance(hole) - pirate.PushRange);
var caseI = pirate.Distance(wormPushLocation) / pirate.MaxSpeed >= pirate.PushReloadTurns;
var caseII = true;
if (eholdersbydistance.Any())
{
caseII = hole.Distance(nearestShip) + pirate.MaxSpeed * 4 < eholdersbydistance.First().Distance(nearestShip);
}
if (!assDanger && !bombDanger && caseI && caseII)
{
pirate.Sail(wormLoc);
Main.didTurn.Add(pirate.Id);
return(Utils.GetPirateStatus(pirate, "Sailing out to worm hole "));
}
if (caseI && caseII)
{
return(Utils.GetPirateStatus(pirate, "Safely sailing out to worm hole " + Sailing.SafeSail(pirate, wormLoc)));
}
}
var enemyHolders = Utils.EnemyHoldersByDistance(pirate.GetLocation()).SkipWhile(Main.piratesPushed.Contains).OrderBy(hole.Distance);
if (pirate.CanPush(hole) && hole.IsActive && enemyHolders.Any() && hole.Distance(nearestShip) < hole.Partner.Distance(nearestShip))
{
foreach (Pirate enemyHolder in enemyHolders)
{
int cost = enemyHolder.Distance(hole) + enemyHolder.MaxSpeed / 2;
if (cost < pirate.PushDistance)
{
pirate.Push(hole, pirate.Location.Towards(enemyHolder.Location, cost));
Main.didTurn.Add(pirate.Id);
Main.piratesPushed.Add(enemyHolder);
Main.wormsPushed.Add(hole);
return(Utils.GetPirateStatus(pirate, "Pushed hole on enemy"));
}
}
}
if (pirate.CanPush(hole) && Main.mines.Any())
{
pirate.Push(hole, Main.mines.OrderBy(nearestShip.Distance).First());
Main.didTurn.Add(pirate.Id);
Main.wormsPushed.Add(hole);
return(Utils.GetPirateStatus(pirate, "Pushed hole away"));
}
}
}
foreach (Pirate enemyHolder in sortedEnemyHolders)
{
game.Debug("pirate can push holder: " + pirate.CanPush(enemyHolder));
var killLocation = Utils.NearestKillLocation(enemyHolder.Location);
double maxDistance = ((double)killLocation.Item1 + enemyHolder.MaxSpeed / 2);
var canKillAlone = maxDistance / pirate.PushDistance <= 1;
if (canKillAlone)
{
pirate.Push(enemyHolder, killLocation.Item2);
Main.didTurn.Add(pirate.Id);
Main.piratesPushed.Add(enemyHolder);
return(Utils.GetPirateStatus(pirate, "Killed enemy holder"));
}
// Initialize variables
var pushHelpers = game.GetMyLivingPirates().Where(h => h.CanPush(enemyHolder) && !Main.didTurn.Contains(h.Id)).OrderBy(h => h.PushDistance);
var killHelpers = pushHelpers.Where(h => h.Id != pirate.Id && ((double)killLocation.Item1 + enemyHolder.MaxSpeed / 2) / ((double)h.PushDistance + pirate.PushDistance) <= 1);
// If they can kill him
if (killHelpers.Any())
{
var partner = killHelpers.OrderByDescending(h => maxDistance / ((double)h.PushDistance + pirate.PushDistance) <= 1).First();
pirate.Push(enemyHolder, killLocation.Item2);
partner.Push(enemyHolder, killLocation.Item2);
Main.didTurn.AddRange(new List <int> {
pirate.Id, partner.Id
});
Main.piratesPushed.Add(enemyHolder);
return(Utils.GetPirateStatus(pirate, "Couple killed enemy holder"));
}
// If they can make him drop his capsule but not kill him
if (pushHelpers.Count() >= enemyHolder.NumPushesForCapsuleLoss)
{
var pushers = pushHelpers.Take(enemyHolder.NumPushesForCapsuleLoss).ToList();
var pushLocation = Utils.NearestKillLocation(enemyHolder.GetLocation()).Item2;
if (Utils.NearestKillLocation(enemyHolder.GetLocation()).Item2.Distance(nearestCapsule) < nearestShip.Distance(nearestCapsule))
{
pushLocation = nearestShip.GetLocation();
}
pushers.ForEach(m => m.Push(enemyHolder, pushLocation));
Main.didTurn.AddRange(from p in pushers select p.Id);
Main.piratesPushed.Add(enemyHolder);
return(Utils.GetPirateStatus(pirate, enemyHolder.NumPushesForCapsuleLoss + " pirates droped the enemy capsule"));
}
// Boost enemy to closest dropers couple
var myMoles = Utils.PiratesWithTask(TaskType.MOLE).ToList().Where(p => p.Id != pirate.Id && p.PushReloadTurns <= 1).OrderBy(p => p.Distance(nearestShip)).ToList();
var regularEnemyPirates = game.GetEnemyLivingPirates().Where(prt => !prt.HasCapsule()).ToList();
bool shouldUseBuddies = myMoles.Any() && pirate.PushRange + pirate.MaxSpeed / 2 < myMoles.OrderBy(pirate.Distance).First().Distance(pirate);
bool enemyIsTerr = Utils.HasMyBomb(enemyHolder);
if (regularEnemyPirates.Any() && myMoles.Count() >= 2 && shouldUseBuddies && !enemyIsTerr)
{
foreach (Pirate A in myMoles)
{
foreach (Pirate B in myMoles.Where(m => m.Id != A.Id))
{
if (A.Distance(pirate) < A.PushRange * 1.5)
{
continue;
}
var centerLoc = Utils.Center(A.Location, B.Location);
var pushLocation = pirate.GetLocation().Towards(centerLoc, pirate.PushDistance - enemyHolder.MaxSpeed / 2);
bool checkI = pushLocation.Distance(A) <= A.PushRange && pushLocation.Distance(B) <= B.PushRange;
bool checkII = enemyHolder.StateName == "normal";
// TODO add check if there is a booster close to the enemy pirate
if (checkI && checkII)
{
pirate.Push(enemyHolder, centerLoc);
Main.didTurn.Add(pirate.Id);
Main.piratesPushed.Add(enemyHolder);
return(Utils.GetPirateStatus(pirate, "Pushed pirates towards buddies!"));
}
}
}
}
}
int radius = (game.PushRange + game.HeavyPushDistance) / 3;
int coupleIndex = Utils.PiratesWithTask(TaskType.MOLE).OrderBy(nearestShip.Distance).ToList().IndexOf(pirate) / 2;
if (coupleIndex > 0)
{
radius += game.HeavyPushDistance;
}
var loc = nearestShip.GetLocation().Towards(nearestCapsule, radius);
foreach (Pirate enemyHolder in sortedEnemyHolders)
{
var CheckI = enemyHolder.Distance(nearestShip) < 2 * pirate.PushRange + pirate.Distance(nearestShip);
var CheckII = pirate.PushReloadTurns <= (enemyHolder.Distance(nearestShip) - pirate.Distance(nearestShip)) / (2 * enemyHolder.MaxSpeed);
var CheckIII = pirate.Distance(loc) < 2 * pirate.MaxSpeed;
var CheckIV = game.GetMyLivingPirates().Count(p => p.Id != pirate.Id && p.GetLocation().Col == pirate.Location.Col && p.GetLocation().Row == pirate.Location.Row) >= 1;
//var CheckV = Utils.PiratesWithTask(TaskType.MOLE).OrderBy(enemyHolder.Distance).First().Id == pirate.Id;
//game.Debug(CheckI + " || " + CheckII + " || " + CheckIII + " || " + CheckIV + " || "/*+ CheckV + " || "*/);
if (CheckI && CheckII && CheckIII && CheckIV /* && CheckV*/)
{
return(Utils.GetPirateStatus(pirate, "Sailing out to enemy holder " + Sailing.SafeSail(pirate, enemyHolder.GetLocation())));
}
}
return(Utils.GetPirateStatus(pirate, "Is sailing to position, " + Sailing.SafeSail(pirate, loc)));
}
//--------------------------------------------
public void DoTurn(PirateGame game)
{
Main.game = game;
///*
game.Debug("Kol od baleivav penimah");
game.Debug("Nefesh Yehudi homiyah,");
game.Debug("Ul(e)faatei mizrach kadimah,");
game.Debug("Ayin leTziyon tzofiyah;");
game.Debug("");
game.Debug("Od lo avdah tikvateinu,");
game.Debug("Hatikvah bat sh(e)not alpayim,");
game.Debug("Lihyot am chofshi b(e)artzeinu,");
game.Debug("Eretz-Tziyon virushalayim.");
game.Debug("");
//*/
if (goStick.Any() && !game.GetMyPirateById(goStick.First().Id).IsAlive())
{
goStick.Clear();
}
// Clearing objects
didTurn.Clear();
sailToworm.Clear();
capsulesTargetted.Clear();
asteroidsPushed.Clear();
piratesPushed.Clear();
wormsPushed.Clear();
// Gettings the mines
if (game.GetMyCapsules().Any() && game.Turn == 1)
{
game.GetMyCapsules().Where(cap => cap.Holder == null && !mines.Contains(cap.Location)).ToList().ForEach(cap => mines.Add(cap.Location));
}
if (game.GetEnemyCapsules().Any() && game.Turn == 1)
{
game.GetEnemyCapsules().Where(cap => cap.Holder == null && !enemyMines.Contains(cap.Location)).ToList().ForEach(cap => enemyMines.Add(cap.Location));
}
unemployedPirates = game.GetMyLivingPirates().ToList();
HandTasks();
foreach (Pirate pirate in game.GetMyLivingPirates().Where(p => p.StateName != game.STATE_NAME_HEAVY).OrderByDescending(p => tasks[p.Id].Item2.HeavyWeight()))
{
if (tasks[pirate.Id].Item2.HeavyWeight() <= 0)
{
break;
}
var switchWith = game.GetMyLivingPirates().Where(p => p.Id != pirate.Id &&
tasks[p.Id].Item2.HeavyWeight() < tasks[pirate.Id].Item2.HeavyWeight() &&
p.StateName == game.STATE_NAME_HEAVY)
.OrderBy(p => tasks[p.Id].Item2.HeavyWeight());
bool shouldNotSwitch = game.__livingAsteroids.Any(a => pirate.Distance(a) < pirate.MaxSpeed * 5) || game.GetEnemyLivingPirates().Any(e => pirate.Distance(e) < pirate.MaxSpeed * 3.5);
if (shouldNotSwitch)
{
break;
}
if (switchWith.Any() && pirate.StateName != game.STATE_NAME_HEAVY)
{
switchWith.First().SwapStates(pirate);
didTurn.Add(switchWith.First().Id);
break;
}
}
foreach (KeyValuePair <int, Tuple <TaskType, Task> > pair in tasks.OrderByDescending(pair => pair.Value.Item2.Priority()))
{
try {
var preform = pair.Value.Item2.Preform();
if (debug)
{
game.Debug(preform);
}
} catch (System.Exception e) {
game.Debug(e.Message);
}
}
if (stopStick == true)
{
Main.goStick.Clear();
}
}
override public string Preform()
{
if (!Utils.GetMyHolders().Any() || !game.GetMyCapsules().Any() || !game.GetAllMotherships().Any())
{
if (Main.mines.Count > 0 && game.GetMyMotherships().Any())
{
var sailLocation = Utils.GetMyHolders().OrderBy(h => h.Distance(pirate)).First().Location;
return(Utils.GetPirateStatus(pirate, "Sailing to rendezvous point, " + Sailing.SafeSail(pirate, sailLocation)));
}
return(Utils.GetPirateStatus(pirate, "Is idle."));
}
var holders = Utils.GetMyHolders().OrderBy(h => h.Distance(pirate));
var cloestHolder = holders.First();
foreach (Pirate holder in Utils.GetMyHolders().OrderBy(h => h.Distance(pirate)))
{
var nearestShip = Utils.OrderByDistance(game.GetMyMotherships().ToList(), holder.Location).First();
if (!pirate.CanPush(holder))
{
var sailLocation = Utils.GetMyHolders().OrderBy(h => h.Distance(pirate)).First().Location;
return(Utils.GetPirateStatus(pirate, "Sailing towards holder, " + Sailing.SafeSail(pirate, sailLocation)));
}
var threats = game.GetEnemyLivingPirates().Where(t => t.PushReloadTurns > 2 && t.Distance(nearestShip) < pirate.Distance(nearestShip) * 1.5).OrderBy(nearestShip.Distance);
// Checks if the holder can be pushed directly onto the ship
bool caseI = holder.Distance(nearestShip) - game.MothershipUnloadRange <= pirate.PushDistance + holder.MaxSpeed;
bool caseII = false;
if (threats.Any() && threats.First().Distance(nearestShip) > holder.Distance(nearestShip))
{
caseII = holder.Distance(nearestShip) - threats.First().Distance(nearestShip) < pirate.PushRange;
}
var holderLocAfterPush = holder.GetLocation().Towards(nearestShip, pirate.PushDistance + holder.MaxSpeed / 2);
bool caseIII_PI = threats.Any() && threats.First().Distance(nearestShip) < holder.Distance(nearestShip);
bool caseIII_PII = threats.Any() && threats.First().PushRange < holderLocAfterPush.Distance(threats.First());
bool ImminentDeath = game.GetEnemyLivingPirates().Count(t => holder.InRange(t, holder.MaxSpeed + t.PushRange) && t.PushReloadTurns <= 1) >= holder.NumPushesForCapsuleLoss;
if (ImminentDeath && !caseI && holder.MaxSpeed * 10 < holder.Distance(nearestShip))
{
var safest = Sailing.SafestCloestLocation(holder.Location, nearestShip.Location, 2, true, pirate);
pirate.Push(holder, safest);
Main.piratesPushed.Add(holder);
Main.didTurn.Add(pirate.Id);
if (!Main.didTurn.Contains(holder.Id))
{
holder.Push(pirate, safest);
Main.piratesPushed.Add(pirate);
Main.didTurn.Add(holder.Id);
}
return(Utils.GetPirateStatus(pirate, "Moved away from danger zone"));
}
bool caseIII = threats.Any() && caseIII_PI && caseIII_PII && ImminentDeath;
game.Debug(caseI + " || " + caseII + " || " + caseIII + " +| IMD: " + ImminentDeath);
if (caseI || caseIII)
{
if (Utils.GetMyHolders().Count() > 1)
{
var secondHolder = Utils.GetMyHolders().First(h => h.Id != holder.Id);
if (!Main.didTurn.Contains(holder.Id) && holder.CanPush(secondHolder) && !Main.piratesPushed.Contains(secondHolder) && secondHolder.Distance(nearestShip) - nearestShip.UnloadRange < pirate.PushDistance + secondHolder.MaxSpeed)
{
holder.Push(secondHolder, nearestShip);
Main.piratesPushed.Add(secondHolder);
pirate.Push(holder, nearestShip);
Main.piratesPushed.Add(holder);
if (!Main.didTurn.Contains(secondHolder.Id) && holder.NumPushesForCapsuleLoss > 2 && secondHolder.CanPush(holder))
{
secondHolder.Push(holder, nearestShip);
Main.piratesPushed.Add(holder);
}
Main.didTurn.Add(holder.Id);
Main.didTurn.Add(pirate.Id);
return(Utils.GetPirateStatus(pirate, "Pushed holder to the motherShip while the holder boosted another holder"));
}
}
if (!Main.didTurn.Contains(holder.Id))
{
holder.Sail(nearestShip);
Main.didTurn.Add(holder.Id);
}
pirate.Push(holder, nearestShip);
Main.didTurn.Add(pirate.Id);
Main.piratesPushed.Add(holder);
return(Utils.GetPirateStatus(pirate, "Pushed holder directly to ship"));
}
Main.holdersPaired.Add(holder);
return(Utils.GetPirateStatus(pirate, "Sailing towards paired holder, " + Sailing.SafeSail(pirate, holder.Location)));
}
return("Did nothing");
}
public void Tostring(PirateGame game)
{
game.Debug($"y = {this.a}x +- {this.b}");
}
