async def create_plan(self) -> BuildOrder:
flying_buildings = lambda k: self._bot.enemy_structures.flying.exists and self._bot.supply_used > 30
in_case_of_air = [
Step(flying_buildings, StepBuildGas(2)),
ActUnit(UnitTypeId.DRONE, UnitTypeId.LARVA, 20),
MorphLair(),
ActUnit(UnitTypeId.DRONE, UnitTypeId.LARVA, 30),
StepBuildGas(4),
ActBuilding(UnitTypeId.SPIRE),
ZergUnit(UnitTypeId.MUTALISK, 10, priority=True)
]
return BuildOrder([
SequentialList([
ActBuilding(UnitTypeId.SPAWNINGPOOL, 1),
ActUnit(UnitTypeId.DRONE, UnitTypeId.LARVA, 14),
StepBuildGas(1),
ActUnit(UnitTypeId.DRONE, UnitTypeId.LARVA, 14),
ActUnit(UnitTypeId.OVERLORD, UnitTypeId.LARVA, 2),
ActBuilding(UnitTypeId.ROACHWARREN, 1),
ActUnit(UnitTypeId.DRONE, UnitTypeId.LARVA, 14),
ActUnit(UnitTypeId.QUEEN, UnitTypeId.HATCHERY, 1),
ActUnit(UnitTypeId.ROACH, UnitTypeId.LARVA, 100),
]), in_case_of_air,
SequentialList([
DistributeWorkers(),
Step(None, SpeedMining(), lambda ai: ai.client.game_step > 5),
PlanZoneDefense(),
AutoOverLord(),
InjectLarva(),
PlanZoneGather(),
Step(UnitExists(UnitTypeId.ROACH, 7), PlanZoneAttackAllIn(1)),
PlanFinishEnemy(),
])
])
async def create_plan(self) -> BuildOrder:
attack = TheAttack(4)
return BuildOrder([
Step(None, ChronoUnit(UnitTypeId.STALKER, UnitTypeId.GATEWAY)),
SequentialList([
GridBuilding(UnitTypeId.PYLON, 1),
ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 15),
GridBuilding(UnitTypeId.GATEWAY, 1),
ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 16),
StepBuildGas(1),
ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 19),
StepBuildGas(2),
GridBuilding(UnitTypeId.CYBERNETICSCORE, 1),
ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 21),
GridBuilding(UnitTypeId.PYLON, 2),
ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 22),
ProtossUnit(UnitTypeId.STALKER, 1),
Tech(UpgradeId.WARPGATERESEARCH, UnitTypeId.CYBERNETICSCORE),
ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 23),
GridBuilding(UnitTypeId.GATEWAY, 4),
GridBuilding(UnitTypeId.PYLON, 3),
BuildOrder([AutoPylon(),
ProtossUnit(UnitTypeId.STALKER, 100)])
]),
SequentialList([
PlanZoneDefense(),
RestorePower(),
DistributeWorkers(),
Step(None, SpeedMining(), lambda ai: ai.client.game_step > 5),
PlanZoneGather(),
Step(UnitReady(UnitTypeId.GATEWAY, 4), attack),
PlanFinishEnemy(),
])
])
async def create_plan(self) -> BuildOrder:
return BuildOrder([
SequentialList([
ActUnit(UnitTypeId.SCV, UnitTypeId.COMMANDCENTER, 13),
GridBuilding(UnitTypeId.SUPPLYDEPOT, 1),
GridBuilding(UnitTypeId.BARRACKS, 3),
ActUnit(UnitTypeId.SCV, UnitTypeId.COMMANDCENTER, 14),
ActUnit(UnitTypeId.MARINE, UnitTypeId.BARRACKS, 1),
ActUnit(UnitTypeId.SCV, UnitTypeId.COMMANDCENTER, 15),
GridBuilding(UnitTypeId.BARRACKS, 4),
BuildOrder([
AutoDepot(),
ActUnit(UnitTypeId.MARINE, UnitTypeId.BARRACKS, 200),
])
]),
SequentialList([
PlanCancelBuilding(),
LowerDepots(),
PlanZoneDefense(),
DistributeWorkers(),
Step(None, SpeedMining(), lambda ai: ai.client.game_step > 5),
ManTheBunkers(),
Repair(),
ContinueBuilding(),
PlanZoneGatherTerran(),
AllInPlanZoneAttack(10),
PlanFinishEnemy(),
])
])
async def create_plan(self) -> BuildOrder:
number = random.randint(10, 15)
attack = TheAttack(number + 1)
return BuildOrder(
Step(
None,
ChronoUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS),
skip=UnitExists(UnitTypeId.PROBE, 20, include_pending=True),
skip_until=UnitExists(UnitTypeId.ASSIMILATOR, 1),
),
SequentialList(
GridBuilding(UnitTypeId.PYLON, 1),
ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 14),
GridBuilding(UnitTypeId.GATEWAY, 1),
ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 16),
BuildGas(1),
ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 17),
GridBuilding(UnitTypeId.GATEWAY, 2),
ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 20),
ArtosisPylon(2),
BuildOrder(
AutoPylon(),
SequentialList(
Step(
None,
GridBuilding(UnitTypeId.CYBERNETICSCORE, 1),
skip_until=UnitReady(UnitTypeId.GATEWAY, 1),
),
Step(
UnitReady(UnitTypeId.CYBERNETICSCORE, 1),
ProtossUnit(UnitTypeId.ADEPT, 2, only_once=True),
),
Tech(UpgradeId.WARPGATERESEARCH),
ProtossUnit(UnitTypeId.ADEPT, 100),
),
Step(
UnitExists(UnitTypeId.CYBERNETICSCORE, 1),
GridBuilding(UnitTypeId.GATEWAY, 4),
skip_until=Minerals(200),
),
Step(
None,
ProtossUnit(UnitTypeId.ZEALOT, 100),
skip=Gas(25),
skip_until=Minerals(200),
),
),
),
SequentialList(
ChronoAnyTech(0),
PlanZoneDefense(),
RestorePower(),
DistributeWorkers(),
Step(None, SpeedMining(), lambda ai: ai.client.game_step > 5),
PlanZoneGather(),
DoubleAdeptScout(number),
attack,
PlanFinishEnemy(),
),
)
async def create_plan(self) -> BuildOrder:
attack = PlanZoneAttack(6)
attack.attack_on_advantage = False # Disables requirement for game analyzer
return BuildOrder(
Step(
None,
ChronoUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS),
skip=UnitExists(UnitTypeId.PROBE, 20, include_pending=True),
skip_until=UnitExists(UnitTypeId.ASSIMILATOR, 1),
),
ChronoTech(AbilityId.RESEARCH_BLINK, UnitTypeId.TWILIGHTCOUNCIL),
SequentialList(
ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 14),
GridBuilding(UnitTypeId.PYLON, 1),
ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 16),
GridBuilding(UnitTypeId.GATEWAY, 1),
ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 17),
BuildGas(2),
ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 19),
GridBuilding(UnitTypeId.GATEWAY, 2),
BuildOrder(
AutoPylon(),
ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 22),
SequentialList(
Step(
UnitReady(UnitTypeId.CYBERNETICSCORE, 1),
GridBuilding(UnitTypeId.TWILIGHTCOUNCIL, 1),
),
Step(UnitReady(UnitTypeId.TWILIGHTCOUNCIL, 1),
Tech(UpgradeId.BLINKTECH)),
),
SequentialList(
Step(
None,
GridBuilding(UnitTypeId.CYBERNETICSCORE, 1),
skip_until=UnitReady(UnitTypeId.GATEWAY, 1),
),
Step(
UnitReady(UnitTypeId.CYBERNETICSCORE, 1),
ProtossUnit(UnitTypeId.ADEPT, 2, only_once=True),
),
Tech(UpgradeId.WARPGATERESEARCH),
ProtossUnit(UnitTypeId.STALKER, 100),
),
Step(UnitExists(UnitTypeId.CYBERNETICSCORE, 1),
GridBuilding(UnitTypeId.GATEWAY, 4)),
),
),
SequentialList(
PlanZoneDefense(),
RestorePower(),
DistributeWorkers(),
Step(None, SpeedMining(), lambda ai: ai.client.game_step > 5),
PlanZoneGather(),
Step(TechReady(UpgradeId.BLINKTECH, 0.9), attack),
PlanFinishEnemy(),
),
)
async def create_plan(self) -> BuildOrder:
flying_buildings = lambda k: self._bot.enemy_structures.flying.exists and self._bot.supply_used > 30
in_case_of_air = [
Step(flying_buildings, StepBuildGas(2)),
ActUnit(UnitTypeId.DRONE, UnitTypeId.LARVA, 20),
MorphLair(),
ActUnit(UnitTypeId.DRONE, UnitTypeId.LARVA, 30),
StepBuildGas(4),
ActBuilding(UnitTypeId.SPIRE),
ZergUnit(UnitTypeId.MUTALISK, 10, priority=True)
]
limit_gas = Any(
[Gas(100),
TechReady(UpgradeId.ZERGLINGMOVEMENTSPEED, 0.001)])
return BuildOrder([
SequentialList([
ActUnit(UnitTypeId.DRONE, UnitTypeId.LARVA, 14),
Expand(2),
StepBuildGas(1),
ActBuilding(UnitTypeId.SPAWNINGPOOL, 1),
ActUnit(UnitTypeId.OVERLORD, UnitTypeId.LARVA, 2),
Step(None,
Tech(UpgradeId.ZERGLINGMOVEMENTSPEED,
UnitTypeId.SPAWNINGPOOL),
skip_until=Gas(100)),
ActUnit(UnitTypeId.QUEEN, UnitTypeId.HATCHERY, 1),
ActUnit(UnitTypeId.ZERGLING, UnitTypeId.LARVA, 30),
ActBuilding(UnitTypeId.BANELINGNEST, 1),
BuildOrder([
Step(None,
ActUnit(UnitTypeId.ZERGLING, UnitTypeId.LARVA, 200),
skip=RequireCustom(lambda k: self._bot.vespene > 25 or
flying_buildings)),
Step(None,
ActUnit(UnitTypeId.BANELING, UnitTypeId.ZERGLING,
200),
skip=RequireCustom(flying_buildings)),
])
]),
SequentialList([
Step(None, DistributeWorkers(), skip=limit_gas),
Step(limit_gas,
DistributeWorkers(1, 1),
skip=RequireCustom(flying_buildings)),
Step(RequireCustom(flying_buildings), DistributeWorkers()),
]), in_case_of_air,
SequentialList([
Step(None, SpeedMining(), lambda ai: ai.client.game_step > 5),
PlanZoneDefense(),
AutoOverLord(),
InjectLarva(),
PlanZoneGather(),
Step(TechReady(UpgradeId.ZERGLINGMOVEMENTSPEED),
PlanZoneAttackAllIn(10)),
PlanFinishEnemy(),
])
])
async def create_plan(self) -> BuildOrder:
attack = PlanZoneAttack(6)
return BuildOrder(
Step(
None,
ChronoUnitProduction(UnitTypeId.PROBE, UnitTypeId.NEXUS),
skip=UnitExists(UnitTypeId.PROBE, 20, include_pending=True),
skip_until=UnitExists(UnitTypeId.ASSIMILATOR, 1),
),
ChronoTech(AbilityId.RESEARCH_BLINK, UnitTypeId.TWILIGHTCOUNCIL),
SequentialList(
ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 14),
GridBuilding(UnitTypeId.PYLON, 1),
ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 16),
GridBuilding(UnitTypeId.GATEWAY, 1),
ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 17),
StepBuildGas(2),
ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 19),
GridBuilding(UnitTypeId.GATEWAY, 2),
BuildOrder(
AutoPylon(),
ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 22),
SequentialList(
Step(
RequiredUnitReady(UnitTypeId.CYBERNETICSCORE, 1),
GridBuilding(UnitTypeId.TWILIGHTCOUNCIL, 1),
),
Step(RequiredUnitReady(UnitTypeId.TWILIGHTCOUNCIL, 1), ActTech(UpgradeId.BLINKTECH)),
),
SequentialList(
Step(
None,
GridBuilding(UnitTypeId.CYBERNETICSCORE, 1),
skip_until=RequiredUnitReady(UnitTypeId.GATEWAY, 1),
),
Step(
RequiredUnitReady(UnitTypeId.CYBERNETICSCORE, 1),
GateUnit(UnitTypeId.ADEPT, 2, only_once=True),
),
ActTech(UpgradeId.WARPGATERESEARCH),
GateUnit(UnitTypeId.STALKER, 100),
),
Step(UnitExists(UnitTypeId.CYBERNETICSCORE, 1), GridBuilding(UnitTypeId.GATEWAY, 4)),
),
),
SequentialList(
PlanZoneDefense(),
RestorePower(),
PlanDistributeWorkers(),
PlanZoneGather(),
Step(RequiredTechReady(UpgradeId.BLINKTECH, 0.9), attack),
PlanFinishEnemy(),
),
)
async def create_plan(self) -> BuildOrder:
finish_rush = Any([Gas(150), UnitExists(UnitTypeId.PLANETARYFORTRESS)])
return BuildOrder([
SequentialList([
BuildPosition(UnitTypeId.COMMANDCENTER,
self._bot.knowledge.zone_manager.enemy_natural.
center_location,
exact=True,
only_once=True),
StepBuildGas(2),
ActBuilding(UnitTypeId.ENGINEERINGBAY),
ActUnit(UnitTypeId.SCV, UnitTypeId.COMMANDCENTER, 17),
MorphProxyPlanetary(),
GridBuilding(UnitTypeId.SUPPLYDEPOT, 1),
BuildOrder([
ActUnit(UnitTypeId.SCV, UnitTypeId.COMMANDCENTER, 38),
ActUnit(UnitTypeId.SCV, UnitTypeId.PLANETARYFORTRESS, 38),
GridBuilding(UnitTypeId.BARRACKS, 4),
BuildAddon(UnitTypeId.BARRACKSTECHLAB, UnitTypeId.BARRACKS,
2),
BuildAddon(UnitTypeId.BARRACKSREACTOR, UnitTypeId.BARRACKS,
2),
Tech(UpgradeId.STIMPACK, UnitTypeId.BARRACKSTECHLAB),
Tech(UpgradeId.TERRANINFANTRYWEAPONSLEVEL1,
UnitTypeId.ENGINEERINGBAY),
AutoDepot(),
ActUnit(UnitTypeId.MARAUDER, UnitTypeId.BARRACKS, 50),
ActUnit(UnitTypeId.MARINE, UnitTypeId.BARRACKS, 100),
GridBuilding(UnitTypeId.BARRACKS, 6),
BuildAddon(UnitTypeId.BARRACKSREACTOR, UnitTypeId.BARRACKS,
4),
]),
]),
SequentialList([
Step(None, DistributeWorkers(min_gas=6), skip=finish_rush),
Step(finish_rush, DistributeWorkers(max_gas=4)),
]),
SequentialList([
Step(None, SpeedMining(), lambda ai: ai.client.game_step > 5),
PlanCancelBuilding(),
LowerDepots(),
PlanZoneDefense(),
ManTheBunkers(),
Repair(),
ContinueBuilding(),
PlanZoneGatherTerran(),
Step(TechReady(UpgradeId.TERRANINFANTRYWEAPONSLEVEL1),
PlanZoneAttack(20)),
PlanFinishEnemy(),
])
])
async def create_plan(self) -> BuildOrder:
stop_gas = Any(
[Gas(100),
TechReady(UpgradeId.ZERGLINGMOVEMENTSPEED, 0.001)])
end_game = Any([Supply(70), UnitExists(UnitTypeId.LAIR, 1)])
return BuildOrder(
ActUnitOnce(UnitTypeId.DRONE, UnitTypeId.LARVA, 24),
LingFloodBuild(),
SequentialList(
InjectLarva(),
Step(None,
PlanDistributeWorkers(3, 3),
skip=Any([stop_gas, end_game])),
Step(None,
PlanDistributeWorkers(0, 0),
skip_until=stop_gas,
skip=end_game),
Step(None,
PlanDistributeWorkers(None, None),
skip_until=end_game),
WorkerAttack(),
DummyZergAttack(),
),
)
def __init__(self, orders: List[Union[ActBase, List[ActBase]]]):
"""
Build order package that replaces normal build order for Zerg with one that builds mutalisks to destroy terran
flying buildings.
Add any PlanDistributeWorkers acts with orders
"""
cover_list = SequentialList([
PlanDistributeWorkers(),
AutoOverLord(),
Step(None, ZergUnit(UnitTypeId.DRONE, 20), skip=Supply(198)),
StepBuildGas(4, None),
MorphLair(),
ActBuilding(UnitTypeId.SPIRE, 1),
Step(
None,
DefensiveBuilding(UnitTypeId.SPORECRAWLER,
DefensePosition.BehindMineralLineCenter),
skip_until=Supply(199),
),
Step(
None,
DefensiveBuilding(UnitTypeId.SPINECRAWLER,
DefensePosition.Entrance),
skip_until=Supply(199),
),
ZergUnit(UnitTypeId.MUTALISK, 10),
])
new_build_order = [
Step(None, cover_list, skip_until=self.should_build_mutalisks),
Step(None, BuildOrder(orders), skip=self.should_build_mutalisks),
]
super().__init__(new_build_order)
def aggressive(self) -> BuildOrder:
worker_scout = Step(None,
WorkerScout(),
skip_until=RequireCustom(
lambda k: len(self.enemy_start_locations) > 1))
stop_gas = Any(
[Gas(100),
TechReady(UpgradeId.ZERGLINGMOVEMENTSPEED, 0.001)])
end_game = Any([Supply(90), UnitExists(UnitTypeId.LAIR, 1)])
return BuildOrder([
LingFloodBuild(),
SequentialList([
worker_scout,
SpreadCreep(),
InjectLarva(),
Step(None,
PlanDistributeWorkers(3, 3),
skip=Any([stop_gas, end_game])),
Step(None,
PlanDistributeWorkers(0, 0),
skip_until=stop_gas,
skip=end_game),
Step(None,
PlanDistributeWorkers(None, None),
skip_until=end_game),
DummyZergAttack(),
]),
])
async def create_plan(self) -> BuildOrder:
tactics = SequentialList([
# TauntEnemy(),
# worker_scout,
InjectLarva(),
PlanHeatOverseer(),
PlanWorkerOnlyDefense(),
PlanZoneDefense(),
PlanZoneGather(),
PlanZoneAttack(),
PlanFinishEnemy(),
])
return BuildOrder([[
ZergUnit(UnitTypeId.DRONE, 14),
ZergUnit(UnitTypeId.OVERLORD, 2),
ActBuilding(UnitTypeId.SPAWNINGPOOL),
ZergUnit(UnitTypeId.DRONE, 20),
ZergUnit(UnitTypeId.ZERGLING, 20)
],
[
Step(
RequiredUnitReady(UnitTypeId.SPAWNINGPOOL),
DefensiveBuilding(UnitTypeId.SPINECRAWLER,
DefensePosition.Entrance,
0)),
ZergUnit(UnitTypeId.QUEEN, 2)
],
[
Step(RequiredUnitReady(UnitTypeId.SPAWNINGPOOL),
AutoOverLord()),
], tactics])
async def create_plan(self) -> BuildOrder:
worker_scout = Step(
None,
WorkerScout(),
skip=RequireCustom(
lambda k: len(self._bot.enemy_start_locations) == 1),
skip_until=Supply(20),
)
distribute = DistributeWorkers()
return BuildOrder(
MutaliskBuild(),
SequentialList(
PlanCancelBuilding(),
PlanZoneGather(),
PlanZoneDefense(),
worker_scout,
SpreadCreep(),
InjectLarva(),
distribute,
Step(None, SpeedMining(), lambda ai: ai.client.game_step > 5),
PlanZoneAttack(),
PlanFinishEnemy(),
),
)
async def create_plan(self) -> BuildOrder:
return BuildOrder(
Step(
None,
ChronoUnitProduction(UnitTypeId.PROBE, UnitTypeId.NEXUS),
skip=UnitExists(UnitTypeId.PROBE, 40, include_pending=True),
skip_until=UnitExists(UnitTypeId.ASSIMILATOR, 1),
),
SequentialList(
ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 14),
GridBuilding(UnitTypeId.PYLON, 1),
ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 16),
StepBuildGas(1),
GridBuilding(UnitTypeId.GATEWAY, 1),
ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 20),
ActExpand(2),
GridBuilding(UnitTypeId.CYBERNETICSCORE, 1),
ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 21),
StepBuildGas(2),
ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 22),
GridBuilding(UnitTypeId.PYLON, 1),
BuildOrder(
AutoPylon(),
ActTech(UpgradeId.WARPGATERESEARCH),
[
ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 22),
Step(UnitExists(UnitTypeId.NEXUS, 2),
ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 44)),
StepBuildGas(3, skip=RequiredGas(300)),
],
[GateUnit(UnitTypeId.STALKER, 100)],
[
GridBuilding(UnitTypeId.GATEWAY, 7),
StepBuildGas(4, skip=RequiredGas(200))
],
),
),
SequentialList(
PlanZoneDefense(),
RestorePower(),
PlanDistributeWorkers(),
PlanZoneGather(),
Step(RequiredUnitReady(UnitTypeId.GATEWAY, 4),
PlanZoneAttack(4)),
PlanFinishEnemy(),
),
)
async def create_plan(self) -> BuildOrder:
return BuildOrder(
Step(
None,
ChronoUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS),
skip=UnitExists(UnitTypeId.PROBE, 20, include_pending=True),
skip_until=UnitExists(UnitTypeId.ASSIMILATOR, 1),
),
# ChronoTech(AbilityId.RESEARCH_BLINK, UnitTypeId.TWILIGHTCOUNCIL),
SequentialList(
ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 14),
GridBuilding(UnitTypeId.PYLON, 1),
ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 16),
GridBuilding(UnitTypeId.GATEWAY, 1),
ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 17),
BuildGas(2),
ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 19),
GridBuilding(UnitTypeId.GATEWAY, 2),
BuildOrder(
AutoPylon(),
ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 22),
SequentialList(
Step(
None,
GridBuilding(UnitTypeId.CYBERNETICSCORE, 1),
skip_until=UnitReady(UnitTypeId.GATEWAY, 1),
),
Step(
UnitReady(UnitTypeId.CYBERNETICSCORE, 1), ProtossUnit(UnitTypeId.ADEPT, 2, only_once=True),
),
Tech(UpgradeId.WARPGATERESEARCH),
ProtossUnit(UnitTypeId.STALKER, 100),
),
Step(UnitExists(UnitTypeId.CYBERNETICSCORE, 1), GridBuilding(UnitTypeId.GATEWAY, 4)),
),
),
BuildOrder(
DistributeWorkers(),
PlanZoneAttack(),
PlanFinishEnemy(),
),
)
async def create_plan(self) -> BuildOrder:
self._bot.building_solver.wall_type = WallType.ProtossMainZerg
attack = PlanZoneAttack(4)
return BuildOrder([
ChronoUnit(UnitTypeId.TEMPEST, UnitTypeId.STARGATE),
SequentialList(
ProtossUnit(UnitTypeId.PROBE, 14),
GridBuilding(UnitTypeId.PYLON, 1),
ProtossUnit(UnitTypeId.PROBE, 15),
GridBuilding(UnitTypeId.GATEWAY, 1),
GridBuilding(UnitTypeId.FORGE, 1),
BuildGas(2),
ProtossUnit(UnitTypeId.PROBE, 18),
GridBuilding(UnitTypeId.PYLON, 2),
GridBuilding(UnitTypeId.CYBERNETICSCORE, 1),
ProtossUnit(UnitTypeId.PROBE, 22),
BuildOrder(
AutoPylon(),
SequentialList(
GridBuilding(UnitTypeId.STARGATE, 1),
Step(UnitReady(UnitTypeId.STARGATE, 1),
GridBuilding(UnitTypeId.FLEETBEACON, 1)),
),
[ProtossUnit(UnitTypeId.TEMPEST, 100, priority=True)],
[
Step(UnitExists(UnitTypeId.FLEETBEACON, 1),
GridBuilding(UnitTypeId.STARGATE, 2))
],
),
),
DefensiveCannons(4, 2, 0),
SequentialList(
PlanZoneDefense(),
RestorePower(),
DistributeWorkers(),
Step(None, SpeedMining(), lambda ai: ai.client.game_step > 5),
PlanZoneGather(),
Step(UnitExists(UnitTypeId.TEMPEST, 1, include_killed=True),
attack),
PlanFinishEnemy(),
),
])
async def create_plan(self) -> BuildOrder:
perform_cleanup = RequireCustom(
lambda k: self._bot.zone_manager.enemy_main_zone.
is_scouted_at_least_once and not self._bot.zone_manager.
enemy_main_zone.is_enemys)
return BuildOrder([
Step(
None,
SequentialList(
SetGameStepSize(1), # improve our worker micro
WorkerAttack()),
skip=perform_cleanup),
Step(
None,
SequentialList(
SetGameStepSize(self._bot.client.game_step
), # back to the original step size
await self.cleanup.create_plan()),
skip_until=perform_cleanup),
])
def __init__(self):
"""Set everything up."""
self.enemy_rushes = {
EnemyBuild.GeneralRush,
EnemyBuild.Pool12,
EnemyBuild.RoachRush,
EnemyBuild.LingRush,
EnemyBuild.CannonRush,
EnemyBuild.EarlyMarines,
}
self.distribute = PlanDistributeWorkers()
# basic build (17, 18, 17)
base_build = SequentialList([
Step(None, ZergUnit(UnitTypeId.DRONE, to_count=13)),
Step(None, ZergUnit(UnitTypeId.OVERLORD, to_count=2)),
Step(None, ZergUnit(UnitTypeId.DRONE, to_count=17)),
Step(
None,
ActExpand(to_count=2,
priority=True,
consider_worker_production=False)),
Step(None, ZergUnit(UnitTypeId.DRONE, to_count=18)),
Step(RequiredMinerals(120), StepBuildGas(to_count=1)),
Step(None, ActBuilding(UnitTypeId.SPAWNINGPOOL)),
Step(None, ZergUnit(UnitTypeId.DRONE, to_count=20)),
Step(UnitExists(UnitTypeId.SPAWNINGPOOL),
ZergUnit(UnitTypeId.ZERGLING, to_count=6)),
Step(UnitExists(UnitTypeId.SPAWNINGPOOL),
ZergUnit(UnitTypeId.QUEEN, to_count=2)),
Step(
RequiredAll(
[UnitExists(UnitTypeId.SPAWNINGPOOL),
RequiredGas(100)]),
ActTech(UpgradeId.ZERGLINGMOVEMENTSPEED),
),
Step(UnitExists(UnitTypeId.SPAWNINGPOOL),
ZergUnit(UnitTypeId.ZERGLING, to_count=100)),
])
build_together = BuildOrder([
Step(None,
base_build,
skip=lambda k: k.ai.scout_manager.enemy_build in self.
enemy_rushes),
Step(None,
RoachRushResponse(),
skip=lambda k: k.ai.scout_manager.enemy_build != EnemyBuild.
RoachRush),
])
super().__init__(build_together, self.distribute, AutoOverLord(),
InjectLarva(), SpreadCreep())
def macro(self) -> BuildOrder:
worker_scout = Step(
None, WorkerScout(), skip_until=RequireCustom(lambda k: len(self.enemy_start_locations) > 1)
)
distribute = PlanDistributeWorkers()
return BuildOrder(
[
LingSpeedBuild(),
SequentialList([worker_scout, SpreadCreep(), InjectLarva(), distribute, DummyZergAttack()]),
]
)
def __init__(self):
"""Build order steps to be combined."""
opening = SequentialList([
Step(None, ZergUnit(UnitTypeId.DRONE, to_count=13,
only_once=True)),
Step(None, ZergUnit(UnitTypeId.OVERLORD,
to_count=2,
only_once=True)),
Step(None, ZergUnit(UnitTypeId.DRONE, to_count=17)),
Step(None, ActExpand(2)),
Step(None, ZergUnit(UnitTypeId.DRONE, to_count=18,
only_once=True)),
Step(None, StepBuildGas(to_count=1)),
Step(
RequiredUnitExists(
UnitTypeId.EXTRACTOR,
count=1,
include_pending=True,
include_not_ready=True,
),
ActBuilding(UnitTypeId.SPAWNINGPOOL),
),
Step(
RequiredUnitExists(
UnitTypeId.SPAWNINGPOOL,
count=1,
include_not_ready=True,
include_pending=True,
),
ZergUnit(UnitTypeId.DRONE, to_count=21),
),
Step(
RequiredUnitExists(UnitTypeId.SPAWNINGPOOL),
ZergUnit(UnitTypeId.ZERGLING, to_count=6),
),
Step(
RequiredUnitExists(UnitTypeId.SPAWNINGPOOL),
ZergUnit(UnitTypeId.QUEEN, to_count=2),
),
Step(None, ActExpand(3)),
])
ling_speed = BuildOrder([
Step(
RequiredAll([
RequiredUnitExists(UnitTypeId.SPAWNINGPOOL),
RequiredGas(100)
]),
ActTech(UpgradeId.ZERGLINGMOVEMENTSPEED,
UnitTypeId.SPAWNINGPOOL),
)
])
super().__init__([opening, ling_speed])
def __init__(self):
"""Build order steps to be combined."""
opening = SequentialList(
Step(None, ActBuilding(UnitTypeId.SPAWNINGPOOL)),
Step(None, ZergUnit(UnitTypeId.DRONE, to_count=14)),
Step(RequiredSupply(14),
ZergUnit(UnitTypeId.OVERLORD, to_count=2, only_once=True)),
Step(RequiredUnitReady(UnitTypeId.SPAWNINGPOOL, 1),
ZergUnit(UnitTypeId.ZERGLING, 6, only_once=True)),
ZergExpand(2),
Step(RequiredUnitReady(UnitTypeId.SPAWNINGPOOL),
ZergUnit(UnitTypeId.ZERGLING, to_count=12, only_once=True)),
)
super().__init__([opening])
def __init__(self):
scout_pattern = SequentialList(
Step(None, OverlordScoutMain(), skip_until=RequiredTime(4 * 60)),
Step(None, OverlordScoutMain(), skip_until=RequiredTime(6 * 60)),
Step(None, OverlordScoutMain(), skip_until=RequiredTime(8 * 60)),
Step(None, OverlordScoutMain(), skip_until=RequiredTime(10 * 60)),
Step(None, OverlordScoutMain(), skip_until=RequiredTime(12 * 60)),
Step(None, OverlordScoutMain(), skip_until=RequiredTime(14 * 60)),
Step(None, OverlordScoutMain(), skip_until=RequiredTime(16 * 60)),
Step(None, OverlordScoutMain(), skip_until=RequiredTime(18 * 60)),
Step(None, OverlordScoutMain(), skip_until=RequiredTime(20 * 60)),
Step(None, OverlordScoutMain(), skip_until=RequiredTime(22 * 60)),
Step(None, OverlordScoutMain(), skip_until=RequiredTime(24 * 60)),
Step(None, OverlordScoutMain(), skip_until=RequiredTime(26 * 60)),
Step(None, OverlordScoutMain(), skip_until=RequiredTime(28 * 60)),
Step(None, OverlordScoutMain(), skip_until=RequiredTime(30 * 60)),
)
super().__init__([scout_pattern])
async def create_plan(self) -> BuildOrder:
worker_scout = Step(
None,
WorkerScout(),
skip=RequireCustom(lambda k: len(self.enemy_start_locations) == 1),
skip_until=RequiredSupply(20))
distribute = PlanDistributeWorkers()
return BuildOrder([
MutaliskBuild(),
SequentialList([
PlanCancelBuilding(),
PlanZoneGather(),
PlanZoneDefense(), worker_scout,
SpreadCreep(),
InjectLarva(), distribute,
PlanZoneAttack(),
PlanFinishEnemy()
]),
])
def __init__(self):
"""Create the build order."""
opener = SequentialList(
Step(
RequiredUnitReady(UnitTypeId.SPAWNINGPOOL),
NatSpines(4),
skip=RequiredUnitReady(UnitTypeId.SPINECRAWLER, count=4),
skip_until=lambda k: k.build_detector.rush_detected,
), Step(None, ZergUnit(UnitTypeId.DRONE, to_count=13)),
Step(None, ZergUnit(UnitTypeId.OVERLORD, to_count=2)),
Step(None, ZergUnit(UnitTypeId.DRONE, to_count=17)),
Step(None,
ActExpand(2, priority=True,
consider_worker_production=False)),
Step(
UnitExists(UnitTypeId.HATCHERY,
count=2,
include_pending=True,
include_not_ready=True),
ZergUnit(UnitTypeId.DRONE, to_count=18),
), Step(None, ActBuilding(UnitTypeId.SPAWNINGPOOL)),
Step(None, ZergUnit(UnitTypeId.DRONE, to_count=20)),
StepBuildGas(1),
Step(RequiredUnitReady(UnitTypeId.SPAWNINGPOOL),
ZergUnit(UnitTypeId.QUEEN, 2)),
Step(RequiredUnitReady(UnitTypeId.SPAWNINGPOOL),
ZergUnit(UnitTypeId.ZERGLING, 6)),
Step(None, ZergUnit(UnitTypeId.OVERLORD, to_count=3)),
BuildOrder([
Step(RequiredGas(100), MorphLair()),
Step(
None,
ZergUnit(UnitTypeId.DRONE),
skip=UnitExists(UnitTypeId.LAIR,
include_pending=True,
include_not_ready=True),
),
])
# end of build hard order, switch to reactive play
)
super().__init__([opener, AutoOverLord()])
async def create_plan(self) -> BuildOrder:
worker_scout = Step(
None, WorkerScout(), skip_until=RequireCustom(lambda k: len(self._bot.enemy_start_locations) > 1)
)
distribute = DistributeWorkers()
return BuildOrder(
[
LingSpeedBuild(),
SequentialList(
[
worker_scout,
SpreadCreep(),
InjectLarva(),
distribute,
Step(None, SpeedMining(), lambda ai: ai.client.game_step > 5),
DummyZergAttack(),
]
),
]
)
async def create_plan(self) -> BuildOrder:
self.attack = Step(None, PlanZoneAttack(random.randint(50, 80)))
worker_scout = Step(None, WorkerScout(), skip_until=UnitExists(UnitTypeId.SUPPLYDEPOT, 1))
tactics = [
PlanCancelBuilding(),
LowerDepots(),
PlanZoneDefense(),
worker_scout,
CallMule(100),
ScanEnemy(),
PlanDistributeWorkers(),
ManTheBunkers(),
Repair(),
ContinueBuilding(),
PlanZoneGatherTerran(),
self.attack,
PlanFinishEnemy(),
]
return BuildOrder([BuildTanks(), SequentialList(tactics)])
async def create_plan(self) -> BuildOrder:
buildings = [
Step(RequiredSupply(13), GridBuilding(UnitTypeId.SUPPLYDEPOT, 1)),
Step(RequiredSupply(16), ActExpand(2)),
Step(RequiredSupply(18), GridBuilding(UnitTypeId.BARRACKS, 1)),
StepBuildGas(1),
Step(RequiredSupply(20), GridBuilding(UnitTypeId.SUPPLYDEPOT, 2)),
Step(None,
StepBuildGas(2),
skip_until=UnitExists(UnitTypeId.MARINE, 2)),
Step(None,
GridBuilding(UnitTypeId.FACTORY, 1),
skip_until=RequiredUnitReady(UnitTypeId.BARRACKS, 1)),
GridBuilding(UnitTypeId.FACTORY, 1),
ActBuildAddon(UnitTypeId.FACTORYTECHLAB, UnitTypeId.FACTORY, 1),
StepBuildGas(4),
Step(None, ActExpand(3)),
GridBuilding(UnitTypeId.FACTORY, 2),
ActBuildAddon(UnitTypeId.FACTORYTECHLAB, UnitTypeId.FACTORY, 2),
Step(
None,
ActTech(UpgradeId.CYCLONELOCKONDAMAGEUPGRADE),
skip_until=RequiredUnitReady(UnitTypeId.FACTORYTECHLAB, 1),
),
StepBuildGas(5),
Step(None,
ActTech(UpgradeId.HIGHCAPACITYBARRELS),
skip_until=RequiredUnitReady(UnitTypeId.FACTORYTECHLAB, 2)),
StepBuildGas(6, None, RequiredGas(100)),
Step(RequiredMinerals(400), GridBuilding(UnitTypeId.FACTORY, 4)),
Step(
None,
ActBuildAddon(UnitTypeId.FACTORYREACTOR, UnitTypeId.FACTORY,
1)),
ActBuildAddon(UnitTypeId.FACTORYTECHLAB, UnitTypeId.FACTORY, 3),
Step(RequiredMinerals(400), ActExpand(4)),
GridBuilding(UnitTypeId.ENGINEERINGBAY, 1),
StepBuildGas(8),
GridBuilding(UnitTypeId.FACTORY, 6),
Step(RequiredMinerals(400), GridBuilding(UnitTypeId.FACTORY, 8)),
ActBuildAddon(UnitTypeId.FACTORYTECHLAB, UnitTypeId.FACTORY, 7),
Step(RequiredSupply(120), GridBuilding(UnitTypeId.ARMORY, 2)),
]
upgrades = [
Step(RequiredUnitReady(UnitTypeId.ARMORY, 1),
ActTech(UpgradeId.TERRANVEHICLEWEAPONSLEVEL1)),
ActTech(UpgradeId.TERRANVEHICLEANDSHIPARMORSLEVEL1),
ActTech(UpgradeId.TERRANVEHICLEWEAPONSLEVEL2),
ActTech(UpgradeId.TERRANVEHICLEANDSHIPARMORSLEVEL2),
ActTech(UpgradeId.TERRANVEHICLEWEAPONSLEVEL3),
ActTech(UpgradeId.TERRANVEHICLEANDSHIPARMORSLEVEL3),
]
self.attack = PlanZoneAttack(40)
worker_scout = Step(None,
WorkerScout(),
skip_until=UnitExists(UnitTypeId.SUPPLYDEPOT, 1))
self.distribute_workers = PlanDistributeWorkers()
tactics = [
PlanCancelBuilding(),
LowerDepots(),
PlanZoneDefense(),
worker_scout,
Step(None, CallMule(50), skip=RequiredTime(5 * 60)),
Step(None, CallMule(100), skip_until=RequiredTime(5 * 60)),
Step(None, ScanEnemy(), skip_until=RequiredTime(5 * 60)),
self.distribute_workers,
ManTheBunkers(),
Repair(),
ContinueBuilding(),
PlanZoneGatherTerran(),
Step(RequiredTechReady(UpgradeId.CYCLONELOCKONDAMAGEUPGRADE, 0.95),
self.attack),
PlanFinishEnemy(),
]
return BuildOrder(
Step(UnitExists(UnitTypeId.BARRACKS, 1),
SequentialList(self.depots)),
[
Step(
UnitExists(UnitTypeId.COMMANDCENTER, 2),
MorphOrbitals(3),
skip_until=RequiredUnitReady(UnitTypeId.BARRACKS, 1),
),
Step(None,
MorphPlanetary(2),
skip_until=RequiredUnitReady(UnitTypeId.ENGINEERINGBAY,
1)),
],
[
Step(None, ActUnit(UnitTypeId.SCV, UnitTypeId.COMMANDCENTER,
40)),
Step(
UnitExists(UnitTypeId.COMMANDCENTER, 3),
ActUnit(UnitTypeId.SCV, UnitTypeId.COMMANDCENTER, 70),
),
],
upgrades,
ActUnit(UnitTypeId.MARINE, UnitTypeId.BARRACKS, 4),
[
ActUnit(UnitTypeId.CYCLONE, UnitTypeId.FACTORY, 4),
ActUnitOnce(UnitTypeId.HELLION, UnitTypeId.FACTORY, 1),
ActUnit(UnitTypeId.CYCLONE, UnitTypeId.FACTORY, 4),
ActUnit(
UnitTypeId.CYCLONE, UnitTypeId.FACTORY, 120,
priority=True),
],
Step(
RequiredUnitReady(UnitTypeId.FACTORYREACTOR, 1),
ActUnit(UnitTypeId.HELLION, UnitTypeId.FACTORY, 60),
skip_until=RequiredMinerals(300),
),
buildings,
SequentialList(tactics),
)
def __init__(self):
"""Research basic unit upgrades with Overlord Speed and Burrow."""
upgrades = BuildOrder([
# ranged upgrades
SequentialList(
Step(
RequiredUnitReady(UnitTypeId.EVOLUTIONCHAMBER),
ActTech(UpgradeId.ZERGMISSILEWEAPONSLEVEL1,
UnitTypeId.EVOLUTIONCHAMBER),
),
Step(
RequiredAll([
RequiredUnitReady(UnitTypeId.EVOLUTIONCHAMBER),
RequiredTechReady(UpgradeId.ZERGMISSILEWEAPONSLEVEL1),
UnitExists(UnitTypeId.LAIR),
]),
ActTech(UpgradeId.ZERGMISSILEWEAPONSLEVEL2,
UnitTypeId.EVOLUTIONCHAMBER),
),
Step(
RequiredAll([
RequiredUnitReady(UnitTypeId.EVOLUTIONCHAMBER),
RequiredTechReady(UpgradeId.ZERGMISSILEWEAPONSLEVEL2),
UnitExists(UnitTypeId.HIVE),
]),
ActTech(UpgradeId.ZERGMISSILEWEAPONSLEVEL3,
UnitTypeId.EVOLUTIONCHAMBER),
),
),
# ground carapace upgrades
SequentialList(
Step(
RequiredUnitReady(UnitTypeId.EVOLUTIONCHAMBER),
ActTech(UpgradeId.ZERGGROUNDARMORSLEVEL1,
UnitTypeId.EVOLUTIONCHAMBER),
),
Step(
RequiredAll([
RequiredUnitReady(UnitTypeId.EVOLUTIONCHAMBER),
RequiredTechReady(UpgradeId.ZERGGROUNDARMORSLEVEL1),
UnitExists(UnitTypeId.LAIR),
]),
ActTech(UpgradeId.ZERGGROUNDARMORSLEVEL2,
UnitTypeId.EVOLUTIONCHAMBER),
),
Step(
RequiredAll([
RequiredUnitReady(UnitTypeId.EVOLUTIONCHAMBER),
RequiredTechReady(UpgradeId.ZERGGROUNDARMORSLEVEL2),
UnitExists(UnitTypeId.HIVE),
]),
ActTech(UpgradeId.ZERGGROUNDARMORSLEVEL3,
UnitTypeId.EVOLUTIONCHAMBER),
),
),
# melee upgrades
SequentialList(
Step(
RequiredUnitReady(UnitTypeId.EVOLUTIONCHAMBER),
ActTech(UpgradeId.ZERGMELEEWEAPONSLEVEL1,
UnitTypeId.EVOLUTIONCHAMBER),
),
Step(
RequiredAll([
RequiredUnitReady(UnitTypeId.EVOLUTIONCHAMBER),
RequiredTechReady(UpgradeId.ZERGMELEEWEAPONSLEVEL1),
UnitExists(UnitTypeId.LAIR),
]),
ActTech(UpgradeId.ZERGMELEEWEAPONSLEVEL2,
UnitTypeId.EVOLUTIONCHAMBER),
),
Step(
RequiredAll([
RequiredUnitReady(UnitTypeId.EVOLUTIONCHAMBER),
RequiredTechReady(UpgradeId.ZERGMELEEWEAPONSLEVEL2),
UnitExists(UnitTypeId.HIVE),
]),
ActTech(UpgradeId.ZERGMELEEWEAPONSLEVEL3,
UnitTypeId.EVOLUTIONCHAMBER),
),
),
# overlord speed then burrow
SequentialList(
Step(UnitExists(UnitTypeId.QUEEN, 2),
ActTech(UpgradeId.OVERLORDSPEED, UnitTypeId.HATCHERY)),
Step(UnitExists(UnitTypeId.LAIR),
ActTech(UpgradeId.BURROW, UnitTypeId.LAIR)),
),
Step(
RequiredAll([
UnitExists(UnitTypeId.INFESTATIONPIT),
RequiredUnitReady(UnitTypeId.LAIR),
RequiredTechReady(UpgradeId.ZERGMISSILEWEAPONSLEVEL2),
]),
MorphHive(),
),
])
super().__init__([upgrades])
async def create_plan(self) -> BuildOrder:
attack = TheAttack(4)
return BuildOrder(
Step(
None,
ChronoUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS),
skip=UnitExists(UnitTypeId.PROBE, 30, include_pending=True),
skip_until=UnitExists(UnitTypeId.ASSIMILATOR, 1),
),
ChronoUnit(UnitTypeId.IMMORTAL, UnitTypeId.ROBOTICSFACILITY),
SequentialList(
ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 14),
GridBuilding(UnitTypeId.PYLON, 1),
ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 16),
BuildGas(1),
GridBuilding(UnitTypeId.GATEWAY, 1),
ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 20),
Expand(2),
GridBuilding(UnitTypeId.CYBERNETICSCORE, 1),
ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 21),
BuildGas(2),
ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 22),
GridBuilding(UnitTypeId.PYLON, 1),
BuildOrder(
AutoPylon(),
ProtossUnit(UnitTypeId.STALKER, 2, priority=True),
Tech(UpgradeId.WARPGATERESEARCH),
[
ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 22),
Step(UnitExists(UnitTypeId.NEXUS, 2), ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 44)),
StepBuildGas(3, skip=Gas(300)),
Step(UnitExists(UnitTypeId.NEXUS, 3), ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 56)),
StepBuildGas(5, skip=Gas(200)),
],
SequentialList(
[
Step(
UnitReady(UnitTypeId.CYBERNETICSCORE, 1), GridBuilding(UnitTypeId.TWILIGHTCOUNCIL, 1),
),
GridBuilding(UnitTypeId.ROBOTICSFACILITY, 1),
Step(UnitReady(UnitTypeId.TWILIGHTCOUNCIL, 1), Tech(UpgradeId.CHARGE)),
]
),
[
ActUnit(UnitTypeId.IMMORTAL, UnitTypeId.ROBOTICSFACILITY, 1, priority=True),
ActUnit(UnitTypeId.OBSERVER, UnitTypeId.ROBOTICSFACILITY, 1, priority=True),
ActUnit(UnitTypeId.IMMORTAL, UnitTypeId.ROBOTICSFACILITY, 20, priority=True),
],
Step(Time(60 * 5), Expand(3)),
[ProtossUnit(UnitTypeId.ZEALOT, 100)],
[
GridBuilding(UnitTypeId.GATEWAY, 4),
StepBuildGas(4, skip=Gas(200)),
GridBuilding(UnitTypeId.ROBOTICSFACILITY, 2),
],
),
),
SequentialList(
PlanCancelBuilding(),
PlanHeatObserver(),
PlanZoneDefense(),
RestorePower(),
DistributeWorkers(),
PlanZoneGather(),
Step(UnitReady(UnitTypeId.IMMORTAL, 3), attack),
PlanFinishEnemy(),
),
)
async def create_plan(self) -> BuildOrder:
attack_value = random.randint(4, 7) * 10
self.attack = Step(None, PlanZoneAttack(attack_value))
self.jump = random.randint(0, 2)
self.knowledge.print(f"Att at {attack_value}", "Build")
worker_scout = Step(None,
WorkerScout(),
skip_until=UnitExists(UnitTypeId.SUPPLYDEPOT, 1))
self.distribute_workers = DistributeWorkers(4)
tactics = [
PlanCancelBuilding(),
LowerDepots(),
PlanZoneDefense(),
worker_scout,
Step(None, CallMule(50), skip=Time(5 * 60)),
Step(None, CallMule(100), skip_until=Time(5 * 60)),
Step(None, ScanEnemy(), skip_until=Time(5 * 60)),
self.distribute_workers,
ManTheBunkers(),
Repair(),
ContinueBuilding(),
PlanZoneGatherTerran(),
self.attack,
PlanFinishEnemy(),
]
return BuildOrder(
AutoDepot(),
Step(None,
MorphOrbitals(),
skip_until=UnitReady(UnitTypeId.BARRACKS, 1)),
[
Step(
None,
ActUnit(UnitTypeId.SCV, UnitTypeId.COMMANDCENTER, 34 + 12))
],
[
Step(Supply(13), GridBuilding(UnitTypeId.SUPPLYDEPOT, 1)),
Step(UnitReady(UnitTypeId.SUPPLYDEPOT, 0.95),
GridBuilding(UnitTypeId.BARRACKS, 1)),
BuildGas(1),
Expand(2),
Step(Supply(20), GridBuilding(UnitTypeId.SUPPLYDEPOT, 2)),
BuildGas(2),
Step(None,
GridBuilding(UnitTypeId.FACTORY, 1),
skip_until=UnitReady(UnitTypeId.BARRACKS, 1)),
Step(UnitReady(UnitTypeId.FACTORY, 1),
GridBuilding(UnitTypeId.STARPORT, 1)),
DefensiveBuilding(UnitTypeId.BUNKER, DefensePosition.Entrance,
1),
Step(None, GridBuilding(UnitTypeId.BARRACKS, 2)),
StepBuildGas(3, None, Gas(150)),
Step(
None,
BuildAddon(UnitTypeId.FACTORYTECHLAB, UnitTypeId.FACTORY,
1)),
# Step(RequiredUnitReady(UnitTypeId.STARPORT, 1), GridBuilding(UnitTypeId.FUSIONCORE, 1)),
Step(
None,
BuildAddon(UnitTypeId.STARPORTTECHLAB, UnitTypeId.STARPORT,
1)),
StepBuildGas(4, None, Gas(100)),
Step(UnitExists(UnitTypeId.BANSHEE, 1, include_killed=True),
GridBuilding(UnitTypeId.BARRACKS, 3)),
Step(
None,
BuildAddon(UnitTypeId.BARRACKSTECHLAB, UnitTypeId.BARRACKS,
1)),
Step(
None,
BuildAddon(UnitTypeId.BARRACKSREACTOR, UnitTypeId.BARRACKS,
1)),
Step(None, GridBuilding(UnitTypeId.STARPORT, 2)),
Step(
UnitReady(UnitTypeId.STARPORT, 2),
BuildAddon(UnitTypeId.STARPORTTECHLAB, UnitTypeId.STARPORT,
2),
),
Step(None, Tech(UpgradeId.SHIELDWALL)),
Step(Minerals(600), GridBuilding(UnitTypeId.BARRACKS, 5)),
Expand(3),
],
[
Step(
Any([
EnemyBuildingExists(UnitTypeId.DARKSHRINE),
EnemyUnitExistsAfter(UnitTypeId.DARKTEMPLAR),
EnemyUnitExistsAfter(UnitTypeId.BANSHEE),
]),
None,
),
Step(
UnitReady(UnitTypeId.STARPORT, 1),
ActUnit(UnitTypeId.RAVEN,
UnitTypeId.STARPORT,
2,
priority=True),
),
],
ActUnit(UnitTypeId.BANSHEE, UnitTypeId.STARPORT, 20,
priority=True),
ActUnit(UnitTypeId.SIEGETANK, UnitTypeId.FACTORY, 10),
ActUnit(UnitTypeId.MARINE, UnitTypeId.BARRACKS, 50),
SequentialList(tactics),
)