"""Improved Terran bot for full ladder games. Beats baseline by: proactive macro, 3-base economy, marine/marauder/medivac with stim, proper attack timings, upgrades, and basic micro. """ from sc2.bot_ai import BotAI from sc2.data import Race from sc2.ids.unit_typeid import UnitTypeId from sc2.ids.ability_id import AbilityId from sc2.ids.upgrade_id import UpgradeId from sc2.position import Point2 from sc2.unit import Unit from sc2.units import Units RACE = Race.Terran class CompetitionBot(BotAI): def __init__(self): super().__init__() self.attack_started = False self.rallied = False self.last_expand_time = 0 async def on_step(self, iteration: int): try: await self._on_step(iteration) except Exception: # Never crash -- a crash concedes the game pass async def _on_step(self, iteration: int): if not self.townhalls: for unit in self.units.of_type({UnitTypeId.MARINE, UnitTypeId.MARAUDER, UnitTypeId.SCV, UnitTypeId.MEDIVAC}): await self.do(unit.attack(self.enemy_start_locations[0])) return await self.distribute_workers() # ==== ECONOMY ==== await self._manage_workers() await self._manage_supply() await self._expand() # ==== PRODUCTION ==== await self._build_structures() await self._train_units() await self._research_upgrades() # ==== ARMY ==== await self._manage_army() # ------------------------------------------------------------------ # Economy # ------------------------------------------------------------------ async def _manage_workers(self): """Produce SCVs up to ~80 (4 bases * 20 saturated), but prioritize supply when tight.""" for cc in self.townhalls.ready.idle: # Don't build SCVs if supply is critically low - save minerals for depot if self.supply_left < 4: continue if self.can_afford(UnitTypeId.SCV) and self.workers.amount < 80: await self.do(cc.train(UnitTypeId.SCV)) async def _manage_supply(self): """Proactive supply: build depots before blocked, wall when possible.""" depots = self.units(UnitTypeId.SUPPLYDEPOT) pending = self.already_pending(UnitTypeId.SUPPLYDEPOT) # Always build if supply is getting tight if self.supply_left < 10 and self.can_afford(UnitTypeId.SUPPLYDEPOT): cc = self.townhalls.ready.first if cc: await self.build(UnitTypeId.SUPPLYDEPOT, near=cc) # Also build proactively if we have very few depots relative to supply used elif self.supply_used > 16 and depots.amount < 3 and self.can_afford(UnitTypeId.SUPPLYDEPOT): cc = self.townhalls.ready.first if cc: await self.build(UnitTypeId.SUPPLYDEPOT, near=cc) async def _expand(self): """Expand based on worker saturation, not fixed timer.""" if self.townhalls.amount >= 4: return # Expand when we have ~16+ workers per base and can afford CC workers_per_base = self.workers.amount / max(1, self.townhalls.amount) if workers_per_base > 16 and self.can_afford(UnitTypeId.COMMANDCENTER): # Also check we're not floating excessive minerals if self.minerals > 300: await self.expand_now() # ------------------------------------------------------------------ # Production buildings # ------------------------------------------------------------------ async def _build_structures(self): cc = self.townhalls.ready.first if not cc: return barracks = self.units(UnitTypeId.BARRACKS) factories = self.units(UnitTypeId.FACTORY) starports = self.units(UnitTypeId.STARPORT) ebay = self.units(UnitTypeId.ENGINEERINGBAY) armory = self.units(UnitTypeId.ARMORY) # Use a simple, reliable build position near CC build_pos = cc.position.towards(self.game_info.map_center, 8) # Barracks: want 5-8 total (with tech labs/reactors) target_rax = 3 if self.townhalls.amount == 1 else (5 if self.townhalls.amount == 2 else (7 if self.townhalls.amount == 3 else 8)) if barracks.amount < target_rax and self.can_afford(UnitTypeId.BARRACKS) and not self.already_pending(UnitTypeId.BARRACKS): await self.build(UnitTypeId.BARRACKS, near=build_pos) # Factory: 1-3 target_factory = 1 if self.townhalls.amount <= 2 else (2 if self.townhalls.amount == 3 else 3) if factories.amount < target_factory and self.can_afford(UnitTypeId.FACTORY) and not self.already_pending(UnitTypeId.FACTORY): await self.build(UnitTypeId.FACTORY, near=build_pos) # Starport: 1-3 target_starport = 1 if self.townhalls.amount <= 2 else (2 if self.townhalls.amount == 3 else 3) if starports.amount < target_starport and self.can_afford(UnitTypeId.STARPORT) and not self.already_pending(UnitTypeId.STARPORT): await self.build(UnitTypeId.STARPORT, near=build_pos) # Engineering Bay for upgrades if ebay.amount == 0 and self.can_afford(UnitTypeId.ENGINEERINGBAY) and not self.already_pending(UnitTypeId.ENGINEERINGBAY): await self.build(UnitTypeId.ENGINEERINGBAY, near=build_pos) # Armory for vehicle upgrades if armory.amount == 0 and factories.ready and self.can_afford(UnitTypeId.ARMORY) and not self.already_pending(UnitTypeId.ARMORY): await self.build(UnitTypeId.ARMORY, near=build_pos) # Add-ons: Tech Labs on 2-3 rax, Reactors on rest for rax in barracks.ready.idle: if rax.add_on_tag == 0: tech_lab_rax = self.units(UnitTypeId.BARRACKSTECHLAB).amount if tech_lab_rax < 3 and self.can_afford(UnitTypeId.BARRACKSTECHLAB): await self.do(rax.build(UnitTypeId.BARRACKSTECHLAB)) elif self.can_afford(UnitTypeId.BARRACKSREACTOR): await self.do(rax.build(UnitTypeId.BARRACKSREACTOR)) for fact in factories.ready.idle: if fact.add_on_tag == 0 and self.can_afford(UnitTypeId.FACTORYTECHLAB): await self.do(fact.build(UnitTypeId.FACTORYTECHLAB)) for sp in starports.ready.idle: if sp.add_on_tag == 0 and self.can_afford(UnitTypeId.STARPORTTECHLAB): await self.do(sp.build(UnitTypeId.STARPORTTECHLAB)) # Lower supply depots when not needed for wall for depot in self.units(UnitTypeId.SUPPLYDEPOT).ready: if depot.is_idle: await self.do(depot(AbilityId.MORPH_SUPPLYDEPOT_LOWER)) # ------------------------------------------------------------------ # Unit production # ------------------------------------------------------------------ async def _train_units(self): barracks = self.units(UnitTypeId.BARRACKS).ready factories = self.units(UnitTypeId.FACTORY).ready starports = self.units(UnitTypeId.STARPORT).ready # Train from ALL ready barracks (not just idle) - use train which queues for rax in barracks: if not rax.is_idle: continue has_addon = rax.add_on_tag != 0 addon_type = None if has_addon: addon = self.units.find_by_tag(rax.add_on_tag) if addon: addon_type = addon.type_id if addon_type == UnitTypeId.BARRACKSREACTOR: if self.can_afford(UnitTypeId.MARINE) and self.supply_left > 0: await self.do(rax.train(UnitTypeId.MARINE)) elif addon_type == UnitTypeId.BARRACKSTECHLAB: if self.can_afford(UnitTypeId.MARAUDER) and self.supply_left > 0: await self.do(rax.train(UnitTypeId.MARAUDER)) else: # No add-on yet -- prefer marine if self.can_afford(UnitTypeId.MARINE) and self.supply_left > 0: await self.do(rax.train(UnitTypeId.MARINE)) # Factory units: Siege Tanks, Hellions for fact in factories: if not fact.is_idle: continue has_addon = fact.add_on_tag != 0 addon_type = None if has_addon: addon = self.units.find_by_tag(fact.add_on_tag) if addon: addon_type = addon.type_id if addon_type == UnitTypeId.FACTORYTECHLAB: if self.can_afford(UnitTypeId.SIEGETANK) and self.supply_left > 1: await self.do(fact.train(UnitTypeId.SIEGETANK)) elif self.can_afford(UnitTypeId.HELLION) and self.supply_left > 0: await self.do(fact.train(UnitTypeId.HELLION)) else: if self.can_afford(UnitTypeId.HELLION) and self.supply_left > 0: await self.do(fact.train(UnitTypeId.HELLION)) # Starport: Medivacs first, then Vikings for sp in starports: if not sp.is_idle: continue has_addon = sp.add_on_tag != 0 addon_type = None if has_addon: addon = self.units.find_by_tag(sp.add_on_tag) if addon: addon_type = addon.type_id medivacs = self.units(UnitTypeId.MEDIVAC).amount # Scale medivacs with army size: ~1 per 8 bio units bio_count = self.units(UnitTypeId.MARINE).amount + self.units(UnitTypeId.MARAUDER).amount target_medivacs = max(8, bio_count // 8) if addon_type == UnitTypeId.STARPORTTECHLAB: if medivacs < target_medivacs and self.can_afford(UnitTypeId.MEDIVAC) and self.supply_left > 1: await self.do(sp.train(UnitTypeId.MEDIVAC)) elif self.can_afford(UnitTypeId.VIKINGFIGHTER) and self.supply_left > 1: await self.do(sp.train(UnitTypeId.VIKINGFIGHTER)) else: if medivacs < target_medivacs and self.can_afford(UnitTypeId.MEDIVAC) and self.supply_left > 1: await self.do(sp.train(UnitTypeId.MEDIVAC)) # ------------------------------------------------------------------ # Upgrades # ------------------------------------------------------------------ async def _research_upgrades(self): ebay = self.units(UnitTypeId.ENGINEERINGBAY).ready armory = self.units(UnitTypeId.ARMORY).ready for b in ebay: if b.is_idle: # Priority: Stim -> Weapons -> Armor -> Shields if self.can_afford(UpgradeId.STIMPACK) and not self.already_pending_upgrade(UpgradeId.STIMPACK): await self.do(b.research(UpgradeId.STIMPACK)) return if self.can_afford(UpgradeId.TERRANINFANTRYWEAPONSLEVEL1) and not self.already_pending_upgrade(UpgradeId.TERRANINFANTRYWEAPONSLEVEL1): await self.do(b.research(UpgradeId.TERRANINFANTRYWEAPONSLEVEL1)) return if self.can_afford(UpgradeId.TERRANINFANTRYARMORSLEVEL1) and not self.already_pending_upgrade(UpgradeId.TERRANINFANTRYARMORSLEVEL1): await self.do(b.research(UpgradeId.TERRANINFANTRYARMORSLEVEL1)) return if self.can_afford(UpgradeId.SHIELDS) and not self.already_pending_upgrade(UpgradeId.SHIELDS): await self.do(b.research(UpgradeId.SHIELDS)) return for a in armory: if a.is_idle: if self.can_afford(UpgradeId.TERRANVEHICLEWEAPONSLEVEL1) and not self.already_pending_upgrade(UpgradeId.TERRANVEHICLEWEAPONSLEVEL1): await self.do(a.research(UpgradeId.TERRANVEHICLEWEAPONSLEVEL1)) return if self.can_afford(UpgradeId.TERRANVEHICLEARMORSLEVEL1) and not self.already_pending_upgrade(UpgradeId.TERRANVEHICLEARMORSLEVEL1): await self.do(a.research(UpgradeId.TERRANVEHICLEARMORSLEVEL1)) return if self.can_afford(UpgradeId.TERRANSHIPWEAPONSLEVEL1) and not self.already_pending_upgrade(UpgradeId.TERRANSHIPWEAPONSLEVEL1): await self.do(a.research(UpgradeId.TERRANSHIPWEAPONSLEVEL1)) return # ------------------------------------------------------------------ # Army management # ------------------------------------------------------------------ async def _manage_army(self): army = self.units.of_type({ UnitTypeId.MARINE, UnitTypeId.MARAUDER, UnitTypeId.MEDIVAC, UnitTypeId.SIEGETANK, UnitTypeId.HELLION, UnitTypeId.VIKINGFIGHTER, UnitTypeId.THOR, UnitTypeId.LIBERATOR }) if army.amount == 0: return # Rally point: forward towards enemy main_army = army.filter(lambda u: u.type_id != UnitTypeId.SCV) if main_army: rally = self.townhalls.ready.first.position.towards(self.enemy_start_locations[0], 30) for u in main_army.idle: await self.do(u.move(rally)) # Attack timing: when we have stim + decent army, or 200/200 stim_ready = self.already_pending_upgrade(UpgradeId.STIMPACK) == 0 and self.state.upgrades.get(UpgradeId.STIMPACK, 0) == 1 army_value = sum(u.health + u.shield for u in main_army) should_attack = ( (stim_ready and army.amount >= 30) or (self.supply_used >= 180) or (self.time > 480 and army.amount >= 40) # 8 min fallback ) if should_attack and not self.attack_started: self.attack_started = True if self.attack_started: await self._attack_with_army(main_army) else: # Pre-stim: defend and scout await self._defend_and_scout(main_army) async def _attack_with_army(self, army: Units): """Attack move with basic micro: focus fire, kite, siege tanks siege.""" target = self._pick_target() if not target: return for unit in army: if not unit.is_ready: continue # Siege tanks: siege when in range if unit.type_id == UnitTypeId.SIEGETANK: enemies_in_range = self.known_enemy_units.filter(lambda e: unit.distance_to(e) <= 13) if enemies_in_range and not unit.is_sieged: await self.do(unit(AbilityId.SIEGEMODE_SIEGEMODE)) elif not enemies_in_range and unit.is_sieged: await self.do(unit(AbilityId.UNSIEGE_UNSIEGE)) else: await self.do(unit.attack(target)) continue # Vikings: toggle mode based on target if unit.type_id == UnitTypeId.VIKINGFIGHTER: air_targets = self.known_enemy_units.filter(lambda e: e.is_flying) if air_targets and not unit.is_flying: await self.do(unit(AbilityId.MORPH_VIKINGASSAULTMODE)) elif not air_targets and unit.is_flying: await self.do(unit(AbilityId.MORPH_VIKINGFIGHTERMODE)) # Stim usage if unit.type_id in {UnitTypeId.MARINE, UnitTypeId.MARAUDER}: if unit.health_percentage > 0.5 and self.state.upgrades.get(UpgradeId.STIMPACK, 0) == 1: buff = self.state.buffs.get(unit.tag) has_stim = buff and buff.id == 18 # StimPack buff if not has_stim and unit.distance_to(target) < 15: await self.do(unit(AbilityId.EFFECT_STIM)) # Medivacs: heal hurt bio if unit.type_id == UnitTypeId.MEDIVAC: hurt_bio = army.filter(lambda u: u.type_id in {UnitTypeId.MARINE, UnitTypeId.MARAUDER} and u.health_percentage < 0.7) if hurt_bio: await self.do(unit(AbilityId.MEDIVACHEAL_HEAL, hurt_bio.closest_to(unit))) else: await self.do(unit.move(target.towards(army.center, 5))) continue # Hellions: kite if unit.type_id == UnitTypeId.HELLION: await self._kite_unit(unit, target) continue # Default attack move await self.do(unit.attack(target)) async def _defend_and_scout(self, army: Units): """Defend bases and scout before attack timing.""" # Send a few units to scout scouts = army.filter(lambda u: u.type_id in {UnitTypeId.MARINE, UnitTypeId.HELLION, UnitTypeId.REAPER})[:3] for scout in scouts: if scout.is_idle: await self.do(scout.move(self.enemy_start_locations[0])) # Defend: attack any visible enemy near bases for base in self.townhalls: nearby_enemies = self.known_enemy_units.filter(lambda e: e.distance_to(base) < 25) if nearby_enemies: defenders = army.closer_than(40, base) for d in defenders: if d.is_idle: await self.do(d.attack(nearby_enemies.closest_to(d))) async def _kite_unit(self, unit: Unit, target: Point2): """Basic kiting for hellions and marines.""" enemies = self.known_enemy_units.filter(lambda e: e.distance_to(unit) < unit.ground_range + 2) if enemies: closest = enemies.closest_to(unit) retreat_pos = unit.position.towards(closest, -4) if self.in_pathing_grid(retreat_pos): await self.do(unit.move(retreat_pos)) else: await self.do(unit.attack(target)) else: await self.do(unit.attack(target)) def _pick_target(self) -> Point2 | None: """Pick best attack target.""" if self.known_enemy_units: # Prioritize workers, then production, then army workers = self.known_enemy_units.filter(lambda u: u.is_worker) if workers: return workers.closest_to(self.enemy_start_locations[0]).position structures = self.known_enemy_structures.filter(lambda s: s.type_id not in { UnitTypeId.CREEPTUMOR, UnitTypeId.CREEPTUMORBURROWED, UnitTypeId.CREEPTUMORQUEEN }) if structures: return structures.closest_to(self.enemy_start_locations[0]).position return self.known_enemy_units.closest_to(self.enemy_start_locations[0]).position if self.known_enemy_structures: return self.known_enemy_structures.closest_to(self.enemy_start_locations[0]).position return self.enemy_start_locations[0]