public override void InitializeTasks()
{
base.InitializeTasks();
if (ReaperDefenseTask == null)
{
ReaperDefenseTask = new DefenseSquadTask(Main, UnitTypes.STALKER)
{
MaxDefenders = 2, Priority = 10
}
}
;
DefenseSquadTask.Enable(ReaperDefenseTask);
DefenseTask.Enable();
TimingAttackTask.Enable();
if (Tyr.Bot.TargetManager.PotentialEnemyStartLocations.Count > 1)
{
WorkerScoutTask.Enable();
}
if (Tyr.Bot.BaseManager.Pocket != null)
{
ScoutProxyTask.Enable(Tyr.Bot.BaseManager.Pocket.BaseLocation.Pos);
}
ArmyObserverTask.Enable();
TimedObserverTask.Enable();
SaveWorkersTask.Enable();
}
public override void InitializeTasks()
{
base.InitializeTasks();
TimingAttackTask.Enable();
WorkerScoutTask.Enable();
QueenInjectTask.Enable();
QueenDefenseTask.Enable();
ArmyOverseerTask.Enable();
QueenTumorTask.Enable();
DefenseTask.Enable();
DefenseSquadTask.Enable(true, UnitTypes.HYDRALISK);
}
public override void InitializeTasks()
{
base.InitializeTasks();
TimingAttackTask.Enable();
WorkerScoutTask.Enable();
QueenInjectTask.Enable();
QueenDefenseTask.Enable();
ArmyOverseerTask.Enable();
QueenTumorTask.Enable();
DefenseTask.Enable();
WorkerRushDefenseTask.Enable();
OverlordSuicideTask.Enable();
SafeZerglingsFromReapersTask.Enable();
BaseLocation enemyNatural = Tyr.Bot.MapAnalyzer.GetEnemyNatural();
if (enemyNatural != null)
{
Base enemyNaturalBase = null;
foreach (Base b in Tyr.Bot.BaseManager.Bases)
{
if (SC2Util.DistanceSq(b.BaseLocation.Pos, enemyNatural.Pos) <= 2 * 2)
{
enemyNaturalBase = b;
break;
}
}
DefendEnemyNaturalTask = new DefenseSquadTask(enemyNaturalBase, UnitTypes.ZERGLING);
DefendEnemyNaturalTask.MaxDefenders = 100;
DefendEnemyNaturalTask.AlwaysNeeded = true;
DefendEnemyNaturalTask.DraftFromFarAway = true;
DefendEnemyNaturalTask.DefendRange = 12;
DefendEnemyNaturalTask.RetreatMoveCommand = true;
PotentialHelper potential = new PotentialHelper(enemyNatural.Pos);
potential.Magnitude = 10;
potential.From(Tyr.Bot.MapAnalyzer.GetEnemyRamp());
DefendEnemyNaturalTask.OverrideIdleLocation = potential.Get();
potential = new PotentialHelper(enemyNatural.Pos);
potential.Magnitude = 5;
potential.From(Tyr.Bot.MapAnalyzer.GetEnemyRamp());
DefendEnemyNaturalTask.OverrideDefenseLocation = potential.Get();
DefenseSquadTask.Enable(DefendEnemyNaturalTask);
}
}
public override void InitializeTasks()
{
base.InitializeTasks();
GroupedAttackTask.Enable();
WorkerScoutTask.Enable();
QueenInjectTask.Enable();
DefenseTask.Enable();
QueenDefenseTask.Enable();
ArmyOverseerTask.Enable();
DefendingOverseerTask.Enable();
QueenTumorTask.Enable();
OverlordScoutTask.Enable();
CreeperLordTask.Enable();
OverlordAtNaturalTask.Enable();
ParasitedBCTask.Enable();
DefenseSquadTask.Enable(false, UnitTypes.QUEEN);
MechDestroyExpandsTask.Enable();
}
public override void InitializeTasks()
{
base.InitializeTasks();
ArmyObserverTask.Enable();
DefenseTask.Enable();
TimingAttackTask.Enable();
if (Bot.Main.TargetManager.PotentialEnemyStartLocations.Count > 1)
{
WorkerScoutTask.Enable();
}
if (Bot.Main.BaseManager.Pocket != null)
{
ScoutProxyTask.Enable(Bot.Main.BaseManager.Pocket.BaseLocation.Pos);
}
ProxyFourGateTask.Enable();
ReaperDefenseTask = new DefenseSquadTask(Main, UnitTypes.STALKER);
ReaperDefenseTask.MaxDefenders = 0;
DefenseSquadTask.Enable(ReaperDefenseTask);
}
public override void InitializeTasks()
{
base.InitializeTasks();
WorkerScoutTask.Enable();
DefenseTask.Enable();
BunkerDefendersTask.Enable();
SupplyDepotTask.Enable();
ArmyRavenTask.Enable();
//MechDestroyExpandsTask.Enable();
RepairTask.Enable();
ReplenishBuildingSCVTask.Enable();
TransformTask.Enable();
WorkerRushDefenseTask.Enable();
TimingAttackTask.Enable();
DefenseSquadTask.Enable(false, UnitTypes.MARINE);
SiegeAtRampTask.Enable();
SiegeBelowRampTask.Enable();
HomeRepairTask.Enable();
}
public override void InitializeTasks()
{
base.InitializeTasks();
TimingAttackTask.Enable();
WorkerScoutTask.Enable();
DefenseTask.Enable();
BunkerDefendersTask.Enable();
SupplyDepotTask.Enable();
ArmyRavenTask.Enable();
RepairTask.Enable();
ReplenishBuildingSCVTask.Enable();
DistributedDefenseTask.Enable();
TransformTask.Enable();
KillScoutsTask.Enable();
HomeRepairTask.Enable();
MechDestroyExpandsTask.Enable();
DistributeHellbatsTask = new DistributeOverBasesTask(UnitTypes.HELLBAT);
DistributeHellbatsTask.Enable();
if (CycloneDefenseSquads == null)
{
CycloneDefenseSquads = DefenseSquadTask.GetDefenseTasks(UnitTypes.CYCLONE);
}
else
{
foreach (DefenseSquadTask task in CycloneDefenseSquads)
{
Tyr.Bot.TaskManager.Add(task);
}
}
DefenseSquadTask.Enable(CycloneDefenseSquads, true, true);
foreach (DefenseSquadTask task in CycloneDefenseSquads)
{
task.Priority = 4;
task.MaxDefenders = 1;
task.AllowClaiming = false;
}
}
public override void InitializeTasks()
{
base.InitializeTasks();
ArmyObserverTask.Enable();
DefenseTask.Enable();
//TimingAttackTask.Enable();
if (Bot.Main.TargetManager.PotentialEnemyStartLocations.Count > 1)
{
WorkerScoutTask.Enable();
}
if (Bot.Main.BaseManager.Pocket != null)
{
ScoutProxyTask.Enable(Bot.Main.BaseManager.Pocket.BaseLocation.Pos);
}
ProxyTask.Enable(new List <ProxyBuilding>()
{
new ProxyBuilding()
{
UnitType = UnitTypes.PYLON
},
new ProxyBuilding()
{
UnitType = UnitTypes.ROBOTICS_FACILITY, Number = 2
}
});
if (DefendProxyTask == null)
{
DefendProxyTask = new DefenseSquadTask(Main);
DefendProxyTask.DraftFromFarAway = true;
DefendProxyTask.AlwaysNeeded = true;
DefendProxyTask.MaxDefenders = 1000000;
DefendProxyTask.Priority = 3;
}
DefenseSquadTask.Enable(DefendProxyTask);
ReaperDefenseTask = new DefenseSquadTask(Main, UnitTypes.STALKER);
ReaperDefenseTask.MaxDefenders = 0;
DefenseSquadTask.Enable(ReaperDefenseTask);
WarpPrismElevatorTask.Enable();
}
public override void OnFrame(Tyr tyr)
{
WorkerScoutTask.Task.ScoutNatural = true;
WorkerScoutTask.Task.StartFrame = 224;
if (!InitialAttackDone &&
TimingAttackTask.Task.AttackSent &&
Completed(UnitTypes.HELLBAT) + Completed(UnitTypes.HELLION) + Completed(UnitTypes.MARINE) <= 4)
{
InitialAttackDone = true;
for (int i = 0; i < AttackMicroControllers.Count; i++)
{
if (AttackMicroControllers[i] is HellionHarassController)
{
AttackMicroControllers.RemoveAt(i);
break;
}
}
}
if (!InitialAttackDone && (tyr.EnemyStrategyAnalyzer.Count(UnitTypes.ROACH) > 0 ||
tyr.EnemyStrategyAnalyzer.Count(UnitTypes.HYDRALISK) >= 3 ||
tyr.EnemyStrategyAnalyzer.Count(UnitTypes.RAVAGER) > 0 ||
tyr.EnemyStrategyAnalyzer.Count(UnitTypes.BANELING) >= 2 ||
tyr.EnemyStrategyAnalyzer.TotalCount(UnitTypes.QUEEN) >= 4) ||
LingRush)
{
InitialAttackDone = true;
TimingAttackTask.Task.Clear();
for (int i = 0; i < AttackMicroControllers.Count; i++)
{
if (AttackMicroControllers[i] is HellionHarassController)
{
AttackMicroControllers.RemoveAt(i);
break;
}
}
}
if (InitialAttackDone)
{
TimingAttackTask.Task.RequiredSize = 40;
TimingAttackTask.Task.RetreatSize = 12;
}
else
{
TimingAttackTask.Task.RequiredSize = 8;
TimingAttackTask.Task.RetreatSize = 3;
}
if (tyr.EnemyStrategyAnalyzer.TotalCount(UnitTypes.MUTALISK) > 0)
{
DesiredTanks = 0;
}
else if (DesiredTanks == 0)
{
foreach (Unit enemy in tyr.Enemies())
{
if (
(enemy.UnitType == UnitTypes.QUEEN || enemy.UnitType == UnitTypes.SPINE_CRAWLER || enemy.UnitType == UnitTypes.SPINE_CRAWLER_UPROOTED) &&
SC2Util.DistanceSq(enemy.Pos, tyr.MapAnalyzer.StartLocation) <= 40 * 40)
{
DesiredTanks = 2;
break;
}
}
}
if (!LingRush && tyr.Frame <= 22.4 * 150 &&
tyr.EnemyStrategyAnalyzer.Count(UnitTypes.ZERGLING) >= 5)
{
LingRush = true;
}
TimingAttackTask.Task.CustomControllers = AttackMicroControllers;
DefenseTask.AirDefenseTask.ExpandDefenseRadius = 20;
DefenseTask.GroundDefenseTask.ExpandDefenseRadius = 20;
DefenseTask.AirDefenseTask.MaxDefenseRadius = 120;
DefenseTask.GroundDefenseTask.MaxDefenseRadius = 120;
DefenseTask.AirDefenseTask.Priority = 4;
RepairTask.Task.WallIn = WallIn;
SupplyDepotTask.Task.RaiseWall = LingRush && Completed(UnitTypes.HELLION) + Completed(UnitTypes.HELLBAT) < 4 ? WallIn : null;
TransformTask.Task.HellionsToHellbats();
MechDestroyExpandsTask.Task.Stopped = BlueFlameStarted < 0 || tyr.Frame < BlueFlameStarted + 22.4 * 20 || UltralisksDetected || DefendMutas || RoachHydra;
if (!UltralisksDetected && tyr.EnemyStrategyAnalyzer.Count(UnitTypes.ULTRALISK) + tyr.EnemyStrategyAnalyzer.Count(UnitTypes.ULTRALISK_CAVERN) > 0)
{
UltralisksDetected = true;
}
if (tyr.EnemyStrategyAnalyzer.TotalCount(UnitTypes.MUTALISK) > 0)
{
MinVikings = 6;
MaxVikings = 6;
DefendMutas = true;
}
else if (UltralisksDetected)
{
MinVikings = 3;
MaxVikings = 3;
}
if (tyr.EnemyStrategyAnalyzer.Count(UnitTypes.ZERGLING) >= 15)
{
ManyLings = true;
}
if (tyr.EnemyStrategyAnalyzer.Count(UnitTypes.ROACH) + tyr.EnemyStrategyAnalyzer.Count(UnitTypes.HYDRALISK) >= 10)
{
RoachHydra = true;
}
if (ManyLings &&
!DefendMutas &&
!RoachHydra)
{
MinimumHellbats = 12;
}
else if (!InitialAttackDone)
{
MinimumHellbats = 8;
}
else
{
MinimumHellbats = 0;
}
if (DefendMutas)
{
TimingAttackTask.Task.ExcludeUnitTypes.Add(UnitTypes.VIKING_FIGHTER);
DistributedDefenseTask.AirDefenseTask.AllowedDefenderTypes.Add(UnitTypes.VIKING_FIGHTER);
VikingController.StickToTanks = false;
}
if (DefendMutas && !TimingAttackTask.Task.IsNeeded())
{
DefenseSquadTask.Enable(CycloneDefenseSquads, true, true);
}
else
{
foreach (DefenseSquadTask task in CycloneDefenseSquads)
{
task.Stopped = true;
task.Clear();
}
}
if (Count(UnitTypes.SCV) < 10 || (Gas() >= 800 && Minerals() < 500))
{
GasWorkerTask.WorkersPerGas = 0;
}
else if (Gas() >= 700 && Minerals() < 500)
{
GasWorkerTask.WorkersPerGas = 1;
}
else if (Gas() >= 600 && Minerals() < 500)
{
GasWorkerTask.WorkersPerGas = 2;
}
else
{
GasWorkerTask.WorkersPerGas = 3;
}
DistributeHellbatsTask.Stopped = Count(UnitTypes.COMMAND_CENTER) < 2 ||
Completed(UnitTypes.HELLBAT) < 2 * (Count(UnitTypes.COMMAND_CENTER) - 1);
if (tyr.EnemyStrategyAnalyzer.TotalCount(UnitTypes.BANELING) > 0 ||
tyr.EnemyStrategyAnalyzer.TotalCount(UnitTypes.MUTALISK) > 0)
{
DesiredMines = 6;
}
if (tyr.TargetManager.PotentialEnemyStartLocations.Count == 1 &&
!ScanTimingsSet)
{
ScanTimingsSet = true;
tyr.OrbitalAbilityManager.SaveEnergy = 50;
tyr.OrbitalAbilityManager.ScanCommands.Add(new ScanCommand()
{
Pos = tyr.TargetManager.PotentialEnemyStartLocations[0],
FromFrame = (int)(22.4 * 60 * 8.5)
});
tyr.OrbitalAbilityManager.ScanCommands.Add(new ScanCommand()
{
Pos = tyr.MapAnalyzer.GetEnemyNatural().Pos,
FromFrame = (int)(22.4 * 60 * 8.5 + 22.4)
});
}
if (BlueFlameStarted < 0 && tyr.UnitManager.ActiveOrders.Contains(761))
{
BlueFlameStarted = tyr.Frame;
}
}
public override void InitializeTasks()
{
base.InitializeTasks();
SiegeTask.Enable();
TimingAttackTask.Enable();
WorkerScoutTask.Enable();
DefenseTask.Enable();
BunkerDefendersTask.Enable();
SupplyDepotTask.Enable();
ArmyRavenTask.Enable();
RepairTask.Enable();
ReplenishBuildingSCVTask.Enable();
ClearBlockedExpandsTask.Enable();
HomeRepairTask.Enable();
TransformTask.Enable();
if (TankDefenseTasks.Count == 0)
{
foreach (Base b in Bot.Main.BaseManager.Bases)
{
if (b == Natural ||
b == Main)
{
continue;
}
TankDefenseTasks.Add(new DefenseSquadTask(b, UnitTypes.SIEGE_TANK)
{
MaxDefenders = 2
});
LiberatorDefenseTasks.Add(new DefenseSquadTask(b, UnitTypes.LIBERATOR)
{
MaxDefenders = 1
});
VikingDefenseTasks.Add(new DefenseSquadTask(b, UnitTypes.VIKING_FIGHTER)
{
MaxDefenders = 1
});
}
}
foreach (DefenseSquadTask task in TankDefenseTasks)
{
Task.Enable(task);
}
foreach (DefenseSquadTask task in LiberatorDefenseTasks)
{
Task.Enable(task);
}
foreach (DefenseSquadTask task in VikingDefenseTasks)
{
Task.Enable(task);
}
DefenseSquadTask.Enable(false, UnitTypes.CYCLONE);
foreach (DefenseSquadTask task in DefenseSquadTask.Tasks)
{
task.MaxDefenders = 2;
}
if (CycloneDefenseTasks == null)
{
CycloneDefenseTasks = DefenseSquadTask.GetDefenseTasks(UnitTypes.CYCLONE);
}
DefenseSquadTask.Enable(CycloneDefenseTasks, false, false);
foreach (DefenseSquadTask task in CycloneDefenseTasks)
{
task.MaxDefenders = 1;
task.Priority = 8;
}
}
public override void OnFrame(Bot bot)
{
if (bot.Observation.ActionErrors != null)
{
foreach (ActionError error in bot.Observation.ActionErrors)
{
DebugUtil.WriteLine("Error with ability " + error.AbilityId + ": " + error.Result);
}
}
foreach (WorkerDefenseTask task in WorkerDefenseTask.Tasks)
{
task.CannonDefenseRadius = 20;
}
TransformTask.Task.ThorsToSingleTarget();
if (FourRax.Get().Detected)
{
FourRaxSuspected = true;
}
if (!FourRaxSuspected)
{
Point2D enemyRamp = bot.MapAnalyzer.GetEnemyRamp();
int enemyBarrackWallCount = 0;
foreach (Unit enemy in bot.Enemies())
{
if (enemyRamp == null)
{
break;
}
if (enemy.UnitType == UnitTypes.BARRACKS && SC2Util.DistanceSq(enemy.Pos, enemyRamp) <= 5.5 * 5.5)
{
enemyBarrackWallCount++;
}
}
if (enemyBarrackWallCount >= 2)
{
WorkerScoutTask.Task.Stopped = true;
WorkerScoutTask.Task.Clear();
FourRaxSuspected = true;
}
}
if (bot.Frame % 224 == 0)
{
if (bot.OrbitalAbilityManager.ScanCommands.Count == 0)
{
UnitLocation scanTarget = null;
foreach (UnitLocation enemy in Bot.Main.EnemyMineManager.Mines)
{
scanTarget = enemy;
break;
}
if (scanTarget != null)
{
bot.OrbitalAbilityManager.ScanCommands.Add(new Managers.ScanCommand()
{
FromFrame = bot.Frame, Pos = SC2Util.To2D(scanTarget.Pos)
});
}
}
}
if (bot.EnemyStrategyAnalyzer.TotalCount(UnitTypes.REAPER) == 1 &&
Completed(UnitTypes.SIEGE_TANK) > 0 &&
bot.Frame <= 22.4 * 60 * 4 &&
Count(UnitTypes.COMMAND_CENTER) < 3)
{
IdleTask.Task.OverrideTarget = SC2Util.Point((bot.MapAnalyzer.GetMainRamp().X + Natural.BaseLocation.Pos.X) / 2f, (bot.MapAnalyzer.GetMainRamp().Y + Natural.BaseLocation.Pos.Y) / 2f);
}
else if (FourRaxSuspected &&
Completed(UnitTypes.SIEGE_TANK) > 0 &&
Count(UnitTypes.COMMAND_CENTER) == 2)
{
IdleTask.Task.OverrideTarget = SC2Util.Point((NaturalDefensePos.X + Natural.BaseLocation.Pos.X) / 2f, (NaturalDefensePos.Y + Natural.BaseLocation.Pos.Y) / 2f);
}
else if (Count(UnitTypes.COMMAND_CENTER) > 3)
{
IdleTask.Task.OverrideTarget = OverrideDefenseTarget;
}
else
{
IdleTask.Task.OverrideTarget = null;
}
if (ReapersDetected)
{
SiegeTask.Task.Stopped = true;
TimingAttackTask.Task.RequiredSize = 30;
TimingAttackTask.Task.RetreatSize = 8;
TimingAttackTask.Task.Stopped = false;
}
else
{
SiegeTask.Task.Stopped = true;
if (Completed(UnitTypes.LIBERATOR) >= 4 ||
FoodUsed() >= 198)
{
TimingAttackTask.Task.RequiredSize = 50;
}
else
{
TimingAttackTask.Task.RequiredSize = 70;
}
TimingAttackTask.Task.RetreatSize = 12;
TimingAttackTask.Task.Stopped = false;
TimingAttackTask.Task.BeforeControllers = AttackMicroControllers;
}
/*
* else
* {
* TimingAttackTask.Task.Stopped = true;
*
* if (Completed(UnitTypes.LIBERATOR) >= 4
|| FoodUsed() >= 198)
|| SiegeTask.Task.RequiredSize = 50;
|| else
|| SiegeTask.Task.RequiredSize = 70;
|| SiegeTask.Task.RetreatSize = 12;
|| SiegeTask.Task.Stopped = false;
|| SiegeTask.Task.CustomControllers = AttackMicroControllers;
||}*/
bool attacking = (!TimingAttackTask.Task.Stopped && TimingAttackTask.Task.IsNeeded()) ||
(!SiegeTask.Task.Stopped && SiegeTask.Task.IsNeeded());
foreach (Task task in VikingDefenseTasks)
{
task.Stopped = attacking;
}
foreach (Task task in TankDefenseTasks)
{
task.Stopped = attacking;
}
foreach (Task task in LiberatorDefenseTasks)
{
task.Stopped = attacking;
}
int defendingTanksPerBase = 2;
if (Completed(UnitTypes.SIEGE_TANK) >= 4 * (Count(UnitTypes.COMMAND_CENTER) - 1))
{
defendingTanksPerBase = 4;
}
else if (Completed(UnitTypes.SIEGE_TANK) >= 3 * (Count(UnitTypes.COMMAND_CENTER) - 1))
{
defendingTanksPerBase = 3;
}
foreach (DefenseSquadTask task in TankDefenseTasks)
{
task.MaxDefenders = defendingTanksPerBase;
}
foreach (DefenseSquadTask task in DefenseSquadTask.Tasks)
{
task.Priority = 4;
task.MaxDefenders = 3;
task.Stopped = task.Base != Main;
}
DefenseTask.AirDefenseTask.ExpandDefenseRadius = 20;
DefenseTask.GroundDefenseTask.ExpandDefenseRadius = 20;
DefenseTask.AirDefenseTask.MaxDefenseRadius = 80;
DefenseTask.GroundDefenseTask.MaxDefenseRadius = 80;
if (Count(UnitTypes.COMMAND_CENTER) > 2)
{
DefenseTask.GroundDefenseTask.MainDefenseRadius = 40;
DefenseTask.AirDefenseTask.MainDefenseRadius = 40;
}
else
{
DefenseTask.GroundDefenseTask.MainDefenseRadius = 30;
DefenseTask.AirDefenseTask.MainDefenseRadius = 30;
}
if (StrategyAnalysis.Bio.Get().Detected)
{
ReapersDetected = false;
}
else if ((bot.EnemyStrategyAnalyzer.TotalCount(UnitTypes.REAPER) > 4 ||
bot.EnemyStrategyAnalyzer.Count(UnitTypes.BANSHEE) >= 1) &&
bot.Frame < 22.4 * 600)
{
ReapersDetected = true;
}
BunkerDefendersTask.Task.LeaveBunkers = !StrategyAnalysis.Bio.Get().Detected &&
bot.EnemyStrategyAnalyzer.TotalCount(UnitTypes.REAPER) >= 1 &&
(bot.EnemyStrategyAnalyzer.TotalCount(UnitTypes.REAPER) >= 2 || bot.Frame <= 22.4 * 60 * 4);
if (ReapersDetected)
{
DefenseSquadTask.Enable(CycloneDefenseTasks, false, false);
}
else
{
foreach (DefenseSquadTask task in CycloneDefenseTasks)
{
task.Stopped = true;
task.Clear();
}
}
if (bot.EnemyStrategyAnalyzer.Count(UnitTypes.STARPORT_TECH_LAB)
+ bot.EnemyStrategyAnalyzer.Count(UnitTypes.BANSHEE) > 0 ||
(bot.EnemyStrategyAnalyzer.Count(UnitTypes.FACTORY) > 0 && bot.Frame <= 22.4 * 60 * 2.5))
{
SuspectCloackedBanshees = true;
}
if (FourRaxSuspected)
{
bot.OrbitalAbilityManager.SaveEnergy = 0;
}
else
{
bot.OrbitalAbilityManager.SaveEnergy = 50;
}
if (bot.TargetManager.PotentialEnemyStartLocations.Count == 1 &&
!ScanTimingsSet &&
bot.Frame >= 22.4 * 60 * 2.25 &&
!FourRaxSuspected
)
{
ScanTimingsSet = true;
bot.OrbitalAbilityManager.ScanCommands.Add(new ScanCommand()
{
Pos = bot.TargetManager.PotentialEnemyStartLocations[0],
FromFrame = (int)(22.4 * 60 * 2.5)
});
}
}
public override void OnStart(Tyr tyr)
{
DefenseTask.Enable();
tyr.TaskManager.Add(attackTask);
tyr.TaskManager.Add(WorkerScoutTask);
ArmyObserverTask.Enable();
tyr.TaskManager.Add(new ObserverScoutTask()
{
Priority = 6
});
tyr.TaskManager.Add(new AdeptScoutTask());
if (tyr.BaseManager.Pocket != null)
{
tyr.TaskManager.Add(new ScoutProxyTask(tyr.BaseManager.Pocket.BaseLocation.Pos));
}
ArchonMergeTask.Enable();
if (StalkerDefenseSquads == null)
{
StalkerDefenseSquads = DefenseSquadTask.GetDefenseTasks(UnitTypes.STALKER);
}
else
{
foreach (DefenseSquadTask task in StalkerDefenseSquads)
{
Tyr.Bot.TaskManager.Add(task);
}
}
DefenseSquadTask.Enable(StalkerDefenseSquads, true, true);
OverrideDefenseTarget = tyr.MapAnalyzer.Walk(NaturalDefensePos, tyr.MapAnalyzer.EnemyDistances, 15);
MicroControllers.Add(FearSpinesController);
MicroControllers.Add(new StalkerController());
MicroControllers.Add(new DisruptorController());
MicroControllers.Add(new StutterController());
MicroControllers.Add(new HTController());
MicroControllers.Add(new ColloxenController());
MicroControllers.Add(new TempestController());
if (WallIn == null)
{
System.Console.WriteLine("Creating wall.");
WallIn = new WallInCreator();
WallIn.Create(new List <uint>()
{
UnitTypes.GATEWAY, UnitTypes.PYLON, UnitTypes.GATEWAY
});
WallIn.ReserveSpace();
System.Console.WriteLine("Wall size: " + WallIn.Wall.Count);
foreach (WallBuilding building in WallIn.Wall)
{
System.Console.WriteLine("Building pos: " + building.Pos);
}
}
Set += ProtossBuildUtil.Pylons(() => Completed(UnitTypes.PYLON) > 0);
Set += CannonDefense();
Set += EmergencyGateways();
Set += ExpandBuildings();
Set += Nexii();
Set += MainBuild();
}
public override void OnStart(Tyr tyr)
{
DefenseTask.Enable();
tyr.TaskManager.Add(attackTask);
tyr.TaskManager.Add(WorkerScoutTask);
ArmyObserverTask.Enable();
tyr.TaskManager.Add(new ObserverScoutTask()
{
Priority = 6
});
tyr.TaskManager.Add(new AdeptScoutTask());
if (tyr.BaseManager.Pocket != null)
{
tyr.TaskManager.Add(new ScoutProxyTask(tyr.BaseManager.Pocket.BaseLocation.Pos));
}
ArchonMergeTask.Enable();
if (StalkerDefenseSquads == null)
{
StalkerDefenseSquads = DefenseSquadTask.GetDefenseTasks(UnitTypes.STALKER);
}
else
{
foreach (DefenseSquadTask task in StalkerDefenseSquads)
{
Tyr.Bot.TaskManager.Add(task);
}
}
DefenseSquadTask.Enable(StalkerDefenseSquads, true, true);
OverrideDefenseTarget = tyr.MapAnalyzer.Walk(NaturalDefensePos, tyr.MapAnalyzer.EnemyDistances, 15);
MicroControllers.Add(new SpreadOutController()
{
SpreadTypes = new HashSet <uint>()
{
UnitTypes.IMMORTAL, UnitTypes.ARCHON, UnitTypes.STALKER
}
});
MicroControllers.Add(FearSpinesController);
MicroControllers.Add(new FearMinesController());
MicroControllers.Add(new FallBackController());
MicroControllers.Add(new StalkerController());
MicroControllers.Add(new DisruptorController());
MicroControllers.Add(new StutterController());
MicroControllers.Add(new HTController());
MicroControllers.Add(new ColloxenController());
MicroControllers.Add(new TempestController());
if (WallIn == null)
{
WallIn = new WallInCreator();
WallIn.Create(new List <uint>()
{
UnitTypes.GATEWAY, UnitTypes.PYLON, UnitTypes.GATEWAY
});
WallIn.ReserveSpace();
}
Set += ProtossBuildUtil.Pylons(() => Completed(UnitTypes.PYLON) > 0 && (Completed(Natural, UnitTypes.PYLON) > 0 || Count(UnitTypes.PYLON) < 2 || Minerals() >= 500));
Set += CannonDefense();
Set += EmergencyGateways();
Set += ExpandBuildings();
Set += Nexii();
Set += Units();
Set += MainBuild();
}
public override void OnFrame(Tyr tyr)
{
BalanceGas();
if (tyr.Observation.ActionErrors != null)
{
foreach (ActionError error in tyr.Observation.ActionErrors)
{
DebugUtil.WriteLine("Error with ability " + error.AbilityId + ": " + error.Result);
}
}
TransformTask.Task.Priority = 10;
if (Completed(UnitTypes.SIEGE_TANK) + Completed(UnitTypes.THOR) + Completed(UnitTypes.CYCLONE) >= 10)
{
TransformTask.Task.HellionsToHellbats();
}
TransformTask.Task.ThorsToSingleTarget();
foreach (WorkerDefenseTask task in WorkerDefenseTask.Tasks)
{
task.CannonDefenseRadius = 20;
}
if (tyr.EnemyStrategyAnalyzer.TotalCount(UnitTypes.REAPER) == 1 &&
Completed(UnitTypes.SIEGE_TANK) > 0 &&
tyr.Frame <= 22.4 * 60 * 4 &&
Count(UnitTypes.COMMAND_CENTER) < 3)
{
IdleTask.Task.OverrideTarget = SC2Util.Point((tyr.MapAnalyzer.GetMainRamp().X + Natural.BaseLocation.Pos.X) / 2f, (tyr.MapAnalyzer.GetMainRamp().Y + Natural.BaseLocation.Pos.Y) / 2f);
}
else if (Count(UnitTypes.COMMAND_CENTER) >= 3 && !SuspectCloackedBanshees)
{
IdleTask.Task.OverrideTarget = OverrideDefenseTarget;
}
else if (Count(UnitTypes.COMMAND_CENTER) >= 2 && SuspectCloackedBanshees)
{
IdleTask.Task.OverrideTarget = Natural.BaseLocation.Pos;
}
else
{
IdleTask.Task.OverrideTarget = null;
}
if (ReapersDetected)
{
SiegeTask.Task.Stopped = true;
TimingAttackTask.Task.RequiredSize = 30;
TimingAttackTask.Task.RetreatSize = 8;
TimingAttackTask.Task.Stopped = false;
}
else
{
SiegeTask.Task.Stopped = true;
if (Completed(UnitTypes.LIBERATOR) >= 4 ||
FoodUsed() >= 198)
{
TimingAttackTask.Task.RequiredSize = 50;
}
else
{
TimingAttackTask.Task.RequiredSize = 70;
}
TimingAttackTask.Task.RetreatSize = 12;
TimingAttackTask.Task.Stopped = false;
TimingAttackTask.Task.CustomControllers = AttackMicroControllers;
}
/*
* else
* {
* TimingAttackTask.Task.Stopped = true;
*
* if (Completed(UnitTypes.LIBERATOR) >= 4
|| FoodUsed() >= 198)
|| SiegeTask.Task.RequiredSize = 50;
|| else
|| SiegeTask.Task.RequiredSize = 70;
|| SiegeTask.Task.RetreatSize = 12;
|| SiegeTask.Task.Stopped = false;
|| SiegeTask.Task.CustomControllers = AttackMicroControllers;
||}*/
bool attacking = (!TimingAttackTask.Task.Stopped && TimingAttackTask.Task.IsNeeded()) ||
(!SiegeTask.Task.Stopped && SiegeTask.Task.IsNeeded());
foreach (Task task in VikingDefenseTasks)
{
task.Stopped = attacking;
}
foreach (Task task in TankDefenseTasks)
{
task.Stopped = attacking;
}
foreach (Task task in LiberatorDefenseTasks)
{
task.Stopped = attacking;
}
int defendingTanksPerBase = 2;
if (Completed(UnitTypes.SIEGE_TANK) >= 4 * (Count(UnitTypes.COMMAND_CENTER) - 1))
{
defendingTanksPerBase = 4;
}
else if (Completed(UnitTypes.SIEGE_TANK) >= 3 * (Count(UnitTypes.COMMAND_CENTER) - 1))
{
defendingTanksPerBase = 3;
}
foreach (DefenseSquadTask task in TankDefenseTasks)
{
task.MaxDefenders = defendingTanksPerBase;
}
foreach (DefenseSquadTask task in DefenseSquadTask.Tasks)
{
task.Priority = 4;
task.MaxDefenders = 3;
task.Stopped = task.Base != Main;
}
DefenseTask.AirDefenseTask.ExpandDefenseRadius = 20;
DefenseTask.GroundDefenseTask.ExpandDefenseRadius = 20;
DefenseTask.AirDefenseTask.MaxDefenseRadius = 80;
DefenseTask.GroundDefenseTask.MaxDefenseRadius = 80;
if (SuspectCloackedBanshees)
{
DefenseTask.GroundDefenseTask.MainDefenseRadius = 30;
DefenseTask.AirDefenseTask.MainDefenseRadius = 30;
DefenseTask.AirDefenseTask.ExpandDefenseRadius = 15;
DefenseTask.GroundDefenseTask.ExpandDefenseRadius = 15;
}
else if (Count(UnitTypes.COMMAND_CENTER) > 2)
{
DefenseTask.GroundDefenseTask.MainDefenseRadius = 40;
DefenseTask.AirDefenseTask.MainDefenseRadius = 40;
DefenseTask.AirDefenseTask.ExpandDefenseRadius = 30;
DefenseTask.GroundDefenseTask.ExpandDefenseRadius = 30;
}
else
{
DefenseTask.GroundDefenseTask.MainDefenseRadius = 30;
DefenseTask.AirDefenseTask.MainDefenseRadius = 30;
}
if (tyr.EnemyStrategyAnalyzer.BioDetected ||
tyr.EnemyStrategyAnalyzer.TotalCount(UnitTypes.SIEGE_TANK) + tyr.EnemyStrategyAnalyzer.TotalCount(UnitTypes.SIEGE_TANK_SIEGED) > 0 ||
tyr.EnemyStrategyAnalyzer.TotalCount(UnitTypes.WIDOW_MINE) + tyr.EnemyStrategyAnalyzer.TotalCount(UnitTypes.WIDOW_MINE_BURROWED) >= 3)
{
ReapersDetected = false;
}
else if ((tyr.EnemyStrategyAnalyzer.TotalCount(UnitTypes.REAPER) > 6 ||
tyr.EnemyStrategyAnalyzer.Count(UnitTypes.BANSHEE) >= 1) &&
tyr.Frame < 22.4 * 600)
{
ReapersDetected = true;
}
BunkerDefendersTask.Task.LeaveBunkers = !tyr.EnemyStrategyAnalyzer.BioDetected &&
tyr.EnemyStrategyAnalyzer.TotalCount(UnitTypes.REAPER) >= 1 &&
(tyr.EnemyStrategyAnalyzer.TotalCount(UnitTypes.REAPER) >= 2 || tyr.Frame <= 22.4 * 60 * 4);
if (ReapersDetected)
{
DefenseSquadTask.Enable(CycloneDefenseTasks, false, false);
}
else
{
foreach (DefenseSquadTask task in CycloneDefenseTasks)
{
task.Stopped = true;
task.Clear();
}
}
if ((tyr.EnemyStrategyAnalyzer.Count(UnitTypes.STARPORT_TECH_LAB) > 0 && tyr.Frame <= 4 * 60 * 22.4) ||
tyr.EnemyStrategyAnalyzer.Count(UnitTypes.BANSHEE) > 0 ||
(tyr.EnemyStrategyAnalyzer.Count(UnitTypes.STARPORT) > 0 && tyr.Frame <= 3 * 60 * 22.4))
{
SuspectCloackedBanshees = true;
}
if (tyr.TargetManager.PotentialEnemyStartLocations.Count == 1 &&
!ScanTimingsSet)
{
ScanTimingsSet = true;
tyr.OrbitalAbilityManager.SaveEnergy = 50;
tyr.OrbitalAbilityManager.ScanCommands.Add(new ScanCommand()
{
Pos = tyr.TargetManager.PotentialEnemyStartLocations[0],
FromFrame = (int)(22.4 * 60 * 2.5)
});
}
}
public DefaultSharkyBot(GameConnection gameConnection)
{
var debug = false;
#if DEBUG
debug = true;
#endif
var framesPerSecond = 22.4f;
SharkyOptions = new SharkyOptions {
Debug = debug, FramesPerSecond = framesPerSecond, TagsEnabled = true
};
MacroData = new MacroData();
AttackData = new AttackData {
ArmyFoodAttack = 30, ArmyFoodRetreat = 25, Attacking = false, UseAttackDataManager = true, CustomAttackFunction = true, RetreatTrigger = 1f, AttackTrigger = 1.5f
};
TargetingData = new TargetingData {
HiddenEnemyBase = false
};
BaseData = new BaseData();
ActiveChatData = new ActiveChatData();
EnemyData = new EnemyData();
SharkyUnitData = new SharkyUnitData();
UnitDataService = new UnitDataService(SharkyUnitData);
Managers = new List <IManager>();
DebugService = new DebugService(SharkyOptions);
DebugManager = new DebugManager(gameConnection, SharkyOptions, DebugService);
Managers.Add(DebugManager);
UpgradeDataService = new UpgradeDataService();
BuildingDataService = new BuildingDataService();
TrainingDataService = new TrainingDataService();
AddOnDataService = new AddOnDataService();
MorphDataService = new MorphDataService();
WallDataService = new WallDataService();
UnitDataManager = new UnitDataManager(UpgradeDataService, BuildingDataService, TrainingDataService, AddOnDataService, MorphDataService, SharkyUnitData);
Managers.Add(UnitDataManager);
MapData = new MapData();
MapDataService = new MapDataService(MapData);
AreaService = new AreaService(MapDataService);
TargetPriorityService = new TargetPriorityService(SharkyUnitData);
CollisionCalculator = new CollisionCalculator();
ActiveUnitData = new ActiveUnitData();
UnitCountService = new UnitCountService(ActiveUnitData, SharkyUnitData);
DamageService = new DamageService();
UnitManager = new UnitManager(ActiveUnitData, SharkyUnitData, SharkyOptions, TargetPriorityService, CollisionCalculator, MapDataService, DebugService, DamageService, UnitDataService);
MapManager = new MapManager(MapData, ActiveUnitData, SharkyOptions, SharkyUnitData, DebugService, WallDataService);
Managers.Add(MapManager);
Managers.Add(UnitManager);
EnemyRaceManager = new EnemyRaceManager(ActiveUnitData, SharkyUnitData, EnemyData);
Managers.Add(EnemyRaceManager);
SharkyPathFinder = new SharkyPathFinder(new Roy_T.AStar.Paths.PathFinder(), MapData, MapDataService, DebugService);
SharkySimplePathFinder = new SharkySimplePathFinder(MapDataService);
SharkyAdvancedPathFinder = new SharkyAdvancedPathFinder(new Roy_T.AStar.Paths.PathFinder(), MapData, MapDataService, DebugService);
NoPathFinder = new SharkyNoPathFinder();
BuildingService = new BuildingService(MapData, ActiveUnitData, TargetingData, BaseData);
ChokePointService = new ChokePointService(SharkyPathFinder, MapDataService, BuildingService);
ChokePointsService = new ChokePointsService(SharkyPathFinder, ChokePointService);
BaseManager = new BaseManager(SharkyUnitData, ActiveUnitData, SharkyPathFinder, UnitCountService, BaseData);
Managers.Add(BaseManager);
TargetingManager = new TargetingManager(SharkyUnitData, BaseData, MacroData, TargetingData, MapData, ChokePointService, ChokePointsService, DebugService);
Managers.Add(TargetingManager);
BuildOptions = new BuildOptions {
StrictGasCount = false, StrictSupplyCount = false, StrictWorkerCount = false
};
MacroSetup = new MacroSetup();
WallOffPlacement = new HardCodedWallOffPlacement(ActiveUnitData, SharkyUnitData, DebugService, MapData, BuildingService, TargetingData, BaseData);
//WallOffPlacement = new WallOffPlacement(ActiveUnitData, SharkyUnitData, DebugService, MapData, BuildingService, TargetingData);
ProtossBuildingPlacement = new ProtossBuildingPlacement(ActiveUnitData, SharkyUnitData, DebugService, MapDataService, BuildingService, WallOffPlacement);
TerranBuildingPlacement = new TerranBuildingPlacement(ActiveUnitData, SharkyUnitData, DebugService, BuildingService);
ZergBuildingPlacement = new ZergBuildingPlacement(ActiveUnitData, SharkyUnitData, DebugService, BuildingService);
BuildingPlacement = new BuildingPlacement(ProtossBuildingPlacement, TerranBuildingPlacement, ZergBuildingPlacement, BaseData, ActiveUnitData, BuildingService, SharkyUnitData);
BuildingBuilder = new BuildingBuilder(ActiveUnitData, TargetingData, BuildingPlacement, SharkyUnitData, BaseData);
WarpInPlacement = new WarpInPlacement(ActiveUnitData, DebugService, MapData);
Morpher = new Morpher(ActiveUnitData);
BuildPylonService = new BuildPylonService(MacroData, BuildingBuilder, SharkyUnitData, ActiveUnitData, BaseData, TargetingData, BuildingService);
BuildDefenseService = new BuildDefenseService(MacroData, BuildingBuilder, SharkyUnitData, ActiveUnitData, BaseData, TargetingData, BuildOptions);
ChronoData = new ChronoData();
NexusManager = new NexusManager(ActiveUnitData, SharkyUnitData, ChronoData);
Managers.Add(NexusManager);
ShieldBatteryManager = new ShieldBatteryManager(ActiveUnitData);
Managers.Add(ShieldBatteryManager);
PhotonCannonManager = new PhotonCannonManager(ActiveUnitData);
Managers.Add(PhotonCannonManager);
OrbitalManager = new OrbitalManager(ActiveUnitData, BaseData, EnemyData);
Managers.Add(OrbitalManager);
HttpClient = new HttpClient();
ChatHistory = new ChatHistory();
ChatDataService = new ChatDataService();
EnemyNameService = new EnemyNameService();
EnemyPlayerService = new EnemyPlayerService(EnemyNameService);
ChatService = new ChatService(ChatDataService, SharkyOptions, ActiveChatData);
ChatManager = new ChatManager(HttpClient, ChatHistory, SharkyOptions, ChatDataService, EnemyPlayerService, EnemyNameService, ChatService, ActiveChatData);
Managers.Add((IManager)ChatManager);
ProxyLocationService = new ProxyLocationService(BaseData, TargetingData, SharkyPathFinder, MapDataService, AreaService);
var individualMicroController = new IndividualMicroController(MapDataService, SharkyUnitData, ActiveUnitData, DebugService, SharkyAdvancedPathFinder, BaseData, SharkyOptions, DamageService, UnitDataService, TargetingData, MicroPriority.LiveAndAttack, false);
var adeptMicroController = new AdeptMicroController(MapDataService, SharkyUnitData, ActiveUnitData, DebugService, SharkyAdvancedPathFinder, BaseData, SharkyOptions, DamageService, UnitDataService, TargetingData, MicroPriority.LiveAndAttack, false);
var adeptShadeMicroController = new AdeptShadeMicroController(MapDataService, SharkyUnitData, ActiveUnitData, DebugService, SharkyAdvancedPathFinder, BaseData, SharkyOptions, DamageService, UnitDataService, TargetingData, MicroPriority.LiveAndAttack, false);
var archonMicroController = new ArchonMicroController(MapDataService, SharkyUnitData, ActiveUnitData, DebugService, SharkyAdvancedPathFinder, BaseData, SharkyOptions, DamageService, UnitDataService, TargetingData, MicroPriority.AttackForward, false);
var colossusMicroController = new ColossusMicroController(MapDataService, SharkyUnitData, ActiveUnitData, DebugService, SharkyAdvancedPathFinder, BaseData, SharkyOptions, DamageService, UnitDataService, TargetingData, MicroPriority.LiveAndAttack, false, CollisionCalculator);
var darkTemplarMicroController = new DarkTemplarMicroController(MapDataService, SharkyUnitData, ActiveUnitData, DebugService, SharkyAdvancedPathFinder, BaseData, SharkyOptions, DamageService, UnitDataService, TargetingData, MicroPriority.LiveAndAttack, false);
var disruptorMicroController = new DisruptorMicroController(MapDataService, SharkyUnitData, ActiveUnitData, DebugService, SharkyAdvancedPathFinder, BaseData, SharkyOptions, DamageService, UnitDataService, TargetingData, MicroPriority.LiveAndAttack, false);
var disruptorPhasedMicroController = new DisruptorPhasedMicroController(MapDataService, SharkyUnitData, ActiveUnitData, DebugService, SharkyAdvancedPathFinder, BaseData, SharkyOptions, DamageService, UnitDataService, TargetingData, MicroPriority.AttackForward, false);
var highTemplarMicroController = new HighTemplarMicroController(MapDataService, SharkyUnitData, ActiveUnitData, DebugService, SharkyAdvancedPathFinder, BaseData, SharkyOptions, DamageService, UnitDataService, TargetingData, MicroPriority.LiveAndAttack, false);
var mothershipMicroController = new MothershipMicroController(MapDataService, SharkyUnitData, ActiveUnitData, DebugService, SharkyAdvancedPathFinder, BaseData, SharkyOptions, DamageService, UnitDataService, TargetingData, MicroPriority.LiveAndAttack, false);
var oracleMicroController = new OracleMicroController(MapDataService, SharkyUnitData, ActiveUnitData, DebugService, SharkyAdvancedPathFinder, BaseData, SharkyOptions, DamageService, UnitDataService, TargetingData, MicroPriority.LiveAndAttack, false);
var observerMicroController = new ObserverMicroController(MapDataService, SharkyUnitData, ActiveUnitData, DebugService, SharkyAdvancedPathFinder, BaseData, SharkyOptions, DamageService, UnitDataService, TargetingData, MicroPriority.LiveAndAttack, false);
var phoenixMicroController = new PhoenixMicroController(MapDataService, SharkyUnitData, ActiveUnitData, DebugService, SharkyAdvancedPathFinder, BaseData, SharkyOptions, DamageService, UnitDataService, TargetingData, MicroPriority.LiveAndAttack, true);
var sentryMicroController = new SentryMicroController(MapDataService, SharkyUnitData, ActiveUnitData, DebugService, SharkyAdvancedPathFinder, BaseData, SharkyOptions, DamageService, UnitDataService, TargetingData, MicroPriority.StayOutOfRange, true);
var stalkerMicroController = new StalkerMicroController(MapDataService, SharkyUnitData, ActiveUnitData, DebugService, SharkyAdvancedPathFinder, BaseData, SharkyOptions, DamageService, UnitDataService, TargetingData, MicroPriority.LiveAndAttack, false);
var tempestMicroController = new TempestMicroController(MapDataService, SharkyUnitData, ActiveUnitData, DebugService, SharkyAdvancedPathFinder, BaseData, SharkyOptions, DamageService, UnitDataService, TargetingData, MicroPriority.LiveAndAttack, false);
var voidrayMicroController = new VoidRayMicroController(MapDataService, SharkyUnitData, ActiveUnitData, DebugService, SharkyAdvancedPathFinder, BaseData, SharkyOptions, DamageService, UnitDataService, TargetingData, MicroPriority.LiveAndAttack, false);
var carrierMicroController = new CarrierMicroController(MapDataService, SharkyUnitData, ActiveUnitData, DebugService, SharkyAdvancedPathFinder, BaseData, SharkyOptions, DamageService, UnitDataService, TargetingData, MicroPriority.LiveAndAttack, false);
var warpPrismpMicroController = new WarpPrismMicroController(MapDataService, SharkyUnitData, ActiveUnitData, DebugService, SharkyAdvancedPathFinder, BaseData, SharkyOptions, DamageService, UnitDataService, TargetingData, MicroPriority.LiveAndAttack, false);
var zealotMicroController = new ZealotMicroController(MapDataService, SharkyUnitData, ActiveUnitData, DebugService, SharkyAdvancedPathFinder, BaseData, SharkyOptions, DamageService, UnitDataService, TargetingData, MicroPriority.AttackForward, false);
var zerglingMicroController = new ZerglingMicroController(MapDataService, SharkyUnitData, ActiveUnitData, DebugService, SharkyAdvancedPathFinder, BaseData, SharkyOptions, DamageService, UnitDataService, TargetingData, MicroPriority.AttackForward, false);
var marineMicroController = new MarineMicroController(MapDataService, SharkyUnitData, ActiveUnitData, DebugService, SharkyAdvancedPathFinder, BaseData, SharkyOptions, DamageService, UnitDataService, TargetingData, MicroPriority.LiveAndAttack, false);
var reaperMicroController = new ReaperMicroController(MapDataService, SharkyUnitData, ActiveUnitData, DebugService, SharkyAdvancedPathFinder, BaseData, SharkyOptions, DamageService, UnitDataService, TargetingData, MicroPriority.LiveAndAttack, false);
var bansheeMicroController = new BansheeMicroController(MapDataService, SharkyUnitData, ActiveUnitData, DebugService, SharkyAdvancedPathFinder, BaseData, SharkyOptions, DamageService, UnitDataService, TargetingData, MicroPriority.LiveAndAttack, false);
var workerDefenseMicroController = new IndividualMicroController(MapDataService, SharkyUnitData, ActiveUnitData, DebugService, SharkyAdvancedPathFinder, BaseData, SharkyOptions, DamageService, UnitDataService, TargetingData, MicroPriority.LiveAndAttack, false, 3);
var workerProxyScoutMicroController = new WorkerScoutMicroController(MapDataService, SharkyUnitData, ActiveUnitData, DebugService, SharkyAdvancedPathFinder, BaseData, SharkyOptions, DamageService, UnitDataService, TargetingData, MicroPriority.AttackForward, false);
var oracleHarassMicroController = new OracleMicroController(MapDataService, SharkyUnitData, ActiveUnitData, DebugService, SharkyAdvancedPathFinder, BaseData, SharkyOptions, DamageService, UnitDataService, TargetingData, MicroPriority.LiveAndAttack, false);
var reaperHarassMicroController = new ReaperMicroController(MapDataService, SharkyUnitData, ActiveUnitData, DebugService, SharkyAdvancedPathFinder, BaseData, SharkyOptions, DamageService, UnitDataService, TargetingData, MicroPriority.LiveAndAttack, false);
var individualMicroControllers = new Dictionary <UnitTypes, IIndividualMicroController>
{
{ UnitTypes.PROTOSS_ADEPT, adeptMicroController },
{ UnitTypes.PROTOSS_ADEPTPHASESHIFT, adeptShadeMicroController },
{ UnitTypes.PROTOSS_ARCHON, archonMicroController },
{ UnitTypes.PROTOSS_COLOSSUS, colossusMicroController },
{ UnitTypes.PROTOSS_DARKTEMPLAR, darkTemplarMicroController },
{ UnitTypes.PROTOSS_DISRUPTOR, disruptorMicroController },
{ UnitTypes.PROTOSS_DISRUPTORPHASED, disruptorPhasedMicroController },
{ UnitTypes.PROTOSS_HIGHTEMPLAR, highTemplarMicroController },
{ UnitTypes.PROTOSS_MOTHERSHIP, mothershipMicroController },
{ UnitTypes.PROTOSS_ORACLE, oracleMicroController },
{ UnitTypes.PROTOSS_PHOENIX, phoenixMicroController },
{ UnitTypes.PROTOSS_SENTRY, sentryMicroController },
{ UnitTypes.PROTOSS_STALKER, stalkerMicroController },
{ UnitTypes.PROTOSS_TEMPEST, tempestMicroController },
{ UnitTypes.PROTOSS_VOIDRAY, voidrayMicroController },
{ UnitTypes.PROTOSS_CARRIER, carrierMicroController },
{ UnitTypes.PROTOSS_WARPPRISM, warpPrismpMicroController },
{ UnitTypes.PROTOSS_WARPPRISMPHASING, warpPrismpMicroController },
{ UnitTypes.PROTOSS_ZEALOT, zealotMicroController },
{ UnitTypes.PROTOSS_OBSERVER, observerMicroController },
{ UnitTypes.ZERG_ZERGLING, zerglingMicroController },
{ UnitTypes.TERRAN_MARINE, marineMicroController },
{ UnitTypes.TERRAN_MARAUDER, marineMicroController },
{ UnitTypes.TERRAN_REAPER, reaperMicroController },
{ UnitTypes.TERRAN_BANSHEE, bansheeMicroController }
};
MicroData = new MicroData {
IndividualMicroControllers = individualMicroControllers, IndividualMicroController = individualMicroController
};
DefenseService = new DefenseService(ActiveUnitData);
TargetingService = new TargetingService(ActiveUnitData, MapDataService, BaseData, TargetingData);
MicroController = new MicroController(MicroData);
MicroTaskData = new MicroTaskData {
MicroTasks = new Dictionary <string, IMicroTask>()
};
var defenseSquadTask = new DefenseSquadTask(ActiveUnitData, TargetingData, DefenseService, MicroController, new ArmySplitter(AttackData, TargetingData, ActiveUnitData, DefenseService, MicroController), new List <DesiredUnitsClaim>(), 0, false);
var workerScoutTask = new WorkerScoutTask(SharkyUnitData, TargetingData, MapDataService, false, 0.5f, workerDefenseMicroController, DebugService, BaseData, AreaService);
var workerScoutGasStealTask = new WorkerScoutGasStealTask(SharkyUnitData, TargetingData, MacroData, MapDataService, false, 0.5f, DebugService, BaseData, AreaService, MapData, BuildingService, ActiveUnitData);
var findHiddenBaseTask = new FindHiddenBaseTask(BaseData, TargetingData, MapDataService, individualMicroController, 15, false, 0.5f);
var proxyScoutTask = new ProxyScoutTask(SharkyUnitData, TargetingData, BaseData, SharkyOptions, false, 0.5f, workerProxyScoutMicroController);
var miningDefenseService = new MiningDefenseService(BaseData, ActiveUnitData, workerDefenseMicroController, DebugService);
var miningTask = new MiningTask(SharkyUnitData, BaseData, ActiveUnitData, 1, miningDefenseService, MacroData, BuildOptions);
var queenInjectTask = new QueenInjectsTask(ActiveUnitData, 1.1f, UnitCountService);
var attackTask = new AttackTask(MicroController, TargetingData, ActiveUnitData, DefenseService, MacroData, AttackData, TargetingService, MicroTaskData, new ArmySplitter(AttackData, TargetingData, ActiveUnitData, DefenseService, MicroController), new EnemyCleanupService(MicroController), 2);
var adeptWorkerHarassTask = new AdeptWorkerHarassTask(BaseData, TargetingData, adeptMicroController, 2, false);
var oracleWorkerHarassTask = new OracleWorkerHarassTask(TargetingData, BaseData, ChatService, MapDataService, MapData, oracleHarassMicroController, 1, false);
var lateGameOracleHarassTask = new LateGameOracleHarassTask(BaseData, TargetingData, MapDataService, oracleHarassMicroController, 1, false);
var reaperWorkerHarassTask = new ReaperWorkerHarassTask(BaseData, TargetingData, reaperHarassMicroController, 2, false);
var hallucinationScoutTask = new HallucinationScoutTask(TargetingData, BaseData, false, .5f);
var wallOffTask = new WallOffTask(SharkyUnitData, TargetingData, ActiveUnitData, MacroData, WallOffPlacement, false, .25f);
var destroyWallOffTask = new DestroyWallOffTask(ActiveUnitData, false, .25f);
MicroTaskData.MicroTasks[defenseSquadTask.GetType().Name] = defenseSquadTask;
MicroTaskData.MicroTasks[workerScoutGasStealTask.GetType().Name] = workerScoutGasStealTask;
MicroTaskData.MicroTasks[workerScoutTask.GetType().Name] = workerScoutTask;
MicroTaskData.MicroTasks[findHiddenBaseTask.GetType().Name] = findHiddenBaseTask;
MicroTaskData.MicroTasks[proxyScoutTask.GetType().Name] = proxyScoutTask;
MicroTaskData.MicroTasks[miningTask.GetType().Name] = miningTask;
MicroTaskData.MicroTasks[queenInjectTask.GetType().Name] = queenInjectTask;
MicroTaskData.MicroTasks[attackTask.GetType().Name] = attackTask;
MicroTaskData.MicroTasks[adeptWorkerHarassTask.GetType().Name] = adeptWorkerHarassTask;
MicroTaskData.MicroTasks[oracleWorkerHarassTask.GetType().Name] = oracleWorkerHarassTask;
MicroTaskData.MicroTasks[lateGameOracleHarassTask.GetType().Name] = lateGameOracleHarassTask;
MicroTaskData.MicroTasks[reaperWorkerHarassTask.GetType().Name] = reaperWorkerHarassTask;
MicroTaskData.MicroTasks[hallucinationScoutTask.GetType().Name] = hallucinationScoutTask;
MicroTaskData.MicroTasks[wallOffTask.GetType().Name] = wallOffTask;
MicroTaskData.MicroTasks[destroyWallOffTask.GetType().Name] = destroyWallOffTask;
MicroManager = new MicroManager(ActiveUnitData, MicroTaskData);
Managers.Add(MicroManager);
AttackDataManager = new AttackDataManager(AttackData, ActiveUnitData, attackTask, TargetPriorityService, TargetingData, MacroData, BaseData, DebugService);
Managers.Add(AttackDataManager);
BuildProxyService = new BuildProxyService(MacroData, BuildingBuilder, SharkyUnitData, ActiveUnitData, Morpher, MicroTaskData);
BuildingCancelService = new BuildingCancelService(ActiveUnitData, MacroData);
MacroManager = new MacroManager(MacroSetup, ActiveUnitData, SharkyUnitData, BuildingBuilder, SharkyOptions, BaseData, TargetingData, AttackData, WarpInPlacement, MacroData, Morpher, BuildOptions, BuildPylonService, BuildDefenseService, BuildProxyService, UnitCountService, BuildingCancelService);
Managers.Add(MacroManager);
EnemyStrategyHistory = new EnemyStrategyHistory();
EnemyData.EnemyStrategies = new Dictionary <string, IEnemyStrategy>
{
["Proxy"] = new EnemyStrategies.Proxy(EnemyStrategyHistory, ChatService, ActiveUnitData, SharkyOptions, TargetingData, DebugService, UnitCountService),
["WorkerRush"] = new WorkerRush(EnemyStrategyHistory, ChatService, ActiveUnitData, SharkyOptions, TargetingData, DebugService, UnitCountService),
["InvisibleAttacks"] = new InvisibleAttacks(EnemyStrategyHistory, ChatService, ActiveUnitData, SharkyOptions, DebugService, UnitCountService),
["AdeptRush"] = new AdeptRush(EnemyStrategyHistory, ChatService, ActiveUnitData, SharkyOptions, DebugService, UnitCountService),
["CannonRush"] = new CannonRush(EnemyStrategyHistory, ChatService, ActiveUnitData, SharkyOptions, TargetingData, DebugService, UnitCountService),
["ProtossFastExpand"] = new ProtossFastExpand(EnemyStrategyHistory, ChatService, ActiveUnitData, SharkyOptions, DebugService, UnitCountService, TargetingData),
["ProxyRobo"] = new ProxyRobo(EnemyStrategyHistory, ChatService, ActiveUnitData, SharkyOptions, DebugService, UnitCountService, TargetingData),
["ProxyStargate"] = new ProxyStargate(EnemyStrategyHistory, ChatService, ActiveUnitData, SharkyOptions, DebugService, UnitCountService, TargetingData),
["ZealotRush"] = new ZealotRush(EnemyStrategyHistory, ChatService, ActiveUnitData, SharkyOptions, DebugService, UnitCountService),
["MarineRush"] = new MarineRush(EnemyStrategyHistory, ChatService, ActiveUnitData, SharkyOptions, DebugService, UnitCountService),
["BunkerRush"] = new BunkerRush(EnemyStrategyHistory, ChatService, ActiveUnitData, SharkyOptions, TargetingData, DebugService, UnitCountService),
["MassVikings"] = new MassVikings(EnemyStrategyHistory, ChatService, ActiveUnitData, SharkyOptions, DebugService, UnitCountService),
["ThreeRax"] = new ThreeRax(EnemyStrategyHistory, ChatService, ActiveUnitData, SharkyOptions, DebugService, UnitCountService),
["ZerglingRush"] = new ZerglingRush(EnemyStrategyHistory, ChatService, ActiveUnitData, SharkyOptions, DebugService, UnitCountService),
["RoachRavager"] = new RoachRavager(EnemyStrategyHistory, ChatService, ActiveUnitData, SharkyOptions, DebugService, UnitCountService)
};
EnemyStrategyManager = new EnemyStrategyManager(EnemyData);
Managers.Add(EnemyStrategyManager);
EmptyCounterTransitioner = new EmptyCounterTransitioner(EnemyData, SharkyOptions);
var antiMassMarine = new AntiMassMarine(BuildOptions, MacroData, ActiveUnitData, AttackData, ChatService, ChronoData, EmptyCounterTransitioner, UnitCountService, MicroTaskData);
var fourGate = new FourGate(BuildOptions, MacroData, ActiveUnitData, AttackData, ChatService, ChronoData, SharkyUnitData, EmptyCounterTransitioner, UnitCountService, MicroTaskData);
var nexusFirst = new NexusFirst(BuildOptions, MacroData, ActiveUnitData, AttackData, ChatService, ChronoData, EmptyCounterTransitioner, UnitCountService, MicroTaskData);
var robo = new Robo(BuildOptions, MacroData, ActiveUnitData, AttackData, ChatService, ChronoData, EnemyData, MicroTaskData, EmptyCounterTransitioner, UnitCountService);
var protossRobo = new ProtossRobo(BuildOptions, MacroData, ActiveUnitData, AttackData, ChatService, ChronoData, SharkyOptions, MicroTaskData, EnemyData, EmptyCounterTransitioner, UnitCountService);
var everyProtossUnit = new EveryProtossUnit(BuildOptions, MacroData, ActiveUnitData, AttackData, ChatService, ChronoData, EmptyCounterTransitioner, UnitCountService, MicroTaskData);
var protossBuilds = new Dictionary <string, ISharkyBuild>
{
[everyProtossUnit.Name()] = everyProtossUnit,
[nexusFirst.Name()] = nexusFirst,
[robo.Name()] = robo,
[protossRobo.Name()] = protossRobo,
[fourGate.Name()] = fourGate,
[antiMassMarine.Name()] = antiMassMarine
};
var protossSequences = new List <List <string> >
{
new List <string> {
everyProtossUnit.Name()
},
new List <string> {
nexusFirst.Name(), robo.Name(), protossRobo.Name()
},
new List <string> {
antiMassMarine.Name()
},
new List <string> {
fourGate.Name()
}
};
var protossBuildSequences = new Dictionary <string, List <List <string> > >
{
[Race.Terran.ToString()] = protossSequences,
[Race.Zerg.ToString()] = protossSequences,
[Race.Protoss.ToString()] = protossSequences,
[Race.Random.ToString()] = protossSequences,
["Transition"] = protossSequences
};
var massMarine = new MassMarines(this);
var battleCruisers = new BattleCruisers(BuildOptions, MacroData, ActiveUnitData, AttackData, MicroTaskData, ChatService, UnitCountService);
var everyTerranUnit = new EveryTerranUnit(BuildOptions, MacroData, ActiveUnitData, AttackData, ChatService, MicroTaskData, UnitCountService);
var terranBuilds = new Dictionary <string, ISharkyBuild>
{
[massMarine.Name()] = massMarine,
[battleCruisers.Name()] = battleCruisers,
[everyTerranUnit.Name()] = everyTerranUnit
};
var terranSequences = new List <List <string> >
{
new List <string> {
massMarine.Name(), battleCruisers.Name()
},
new List <string> {
everyTerranUnit.Name()
},
new List <string> {
battleCruisers.Name()
},
};
var terranBuildSequences = new Dictionary <string, List <List <string> > >
{
[Race.Terran.ToString()] = terranSequences,
[Race.Zerg.ToString()] = terranSequences,
[Race.Protoss.ToString()] = terranSequences,
[Race.Random.ToString()] = terranSequences,
["Transition"] = terranSequences
};
var basicZerglingRush = new BasicZerglingRush(BuildOptions, MacroData, ActiveUnitData, AttackData, ChatService, MicroTaskData, UnitCountService);
var everyZergUnit = new EveryZergUnit(BuildOptions, MacroData, ActiveUnitData, AttackData, MicroTaskData, ChatService, UnitCountService);
var zergBuilds = new Dictionary <string, ISharkyBuild>
{
[everyZergUnit.Name()] = everyZergUnit,
[basicZerglingRush.Name()] = basicZerglingRush
};
var zergSequences = new List <List <string> >
{
new List <string> {
everyZergUnit.Name()
},
new List <string> {
basicZerglingRush.Name(), everyZergUnit.Name()
}
};
var zergBuildSequences = new Dictionary <string, List <List <string> > >
{
[Race.Terran.ToString()] = zergSequences,
[Race.Zerg.ToString()] = zergSequences,
[Race.Protoss.ToString()] = zergSequences,
[Race.Random.ToString()] = zergSequences,
["Transition"] = zergSequences
};
MacroBalancer = new MacroBalancer(BuildOptions, ActiveUnitData, MacroData, SharkyUnitData, BaseData, UnitCountService);
BuildChoices = new Dictionary <Race, BuildChoices>
{
{ Race.Protoss, new BuildChoices {
Builds = protossBuilds, BuildSequences = protossBuildSequences
} },
{ Race.Terran, new BuildChoices {
Builds = terranBuilds, BuildSequences = terranBuildSequences
} },
{ Race.Zerg, new BuildChoices {
Builds = zergBuilds, BuildSequences = zergBuildSequences
} }
};
BuildDecisionService = new BuildDecisionService(ChatService);
BuildManager = new BuildManager(BuildChoices, DebugService, MacroBalancer, BuildDecisionService, EnemyPlayerService, ChatHistory, EnemyStrategyHistory);
Managers.Add(BuildManager);
}
