Merge branch 'master' into build-order-support

# Conflicts:
#	examples/zerg_rush.py
#	sc2/bot_ai.py
#	sc2/data.py
#	sc2/ids/ability_id.py

Author: Reynald Pader

README.md

@@ -30,7 +30,7 @@ from sc2 import run_game, maps, Race, Difficulty
 from sc2.player import Bot, Computer
 
 class WorkerRushBot(sc2.BotAI):
-    async def on_step(self, state, iteration):
+    async def on_step(self, iteration):
         if iteration == 0:
             for worker in self.workers:
                 await self.do(worker.attack(self.enemy_start_locations[0]))

examples/cannon_rush.py

@@ -6,46 +6,46 @@
 from sc2.player import Bot, Computer
 
 class CannonRushBot(sc2.BotAI):
-    async def on_step(self, state, iteration):
+    async def on_step(self, iteration):
         if iteration == 0:
             await self.chat_send("(probe)(pylon)(cannon)(cannon)(gg)")
 
-        if not self.units(UnitTypeId.NEXUS).exists:
+        if not self.units(NEXUS).exists:
             for worker in self.workers:
                 await self.do(worker.attack(self.enemy_start_locations[0]))
             return
         else:
-            nexus = self.units(UnitTypeId.NEXUS).first
+            nexus = self.units(NEXUS).first
 
         if self.workers.amount < 16 and nexus.noqueue:
-            if self.can_afford(UnitTypeId.PROBE):
-                await self.do(nexus.train(UnitTypeId.PROBE))
+            if self.can_afford(PROBE):
+                await self.do(nexus.train(PROBE))
 
-        elif not self.units(UnitTypeId.PYLON).exists and not self.already_pending(UnitTypeId.PYLON):
-            if self.can_afford(UnitTypeId.PYLON):
-                await self.build(UnitTypeId.PYLON, near=nexus)
+        elif not self.units(PYLON).exists and not self.already_pending(PYLON):
+            if self.can_afford(PYLON):
+                await self.build(PYLON, near=nexus)
 
-        elif not self.units(UnitTypeId.FORGE).exists:
-            pylon = self.units(UnitTypeId.PYLON).ready
+        elif not self.units(FORGE).exists:
+            pylon = self.units(PYLON).ready
             if pylon.exists:
-                if self.can_afford(UnitTypeId.FORGE):
-                    await self.build(UnitTypeId.FORGE, near=pylon.closest_to(nexus))
+                if self.can_afford(FORGE):
+                    await self.build(FORGE, near=pylon.closest_to(nexus))
 
-        elif self.units(UnitTypeId.PYLON).amount < 2:
-            if self.can_afford(UnitTypeId.PYLON):
+        elif self.units(PYLON).amount < 2:
+            if self.can_afford(PYLON):
                 pos = self.enemy_start_locations[0].towards(self.game_info.map_center, random.randrange(8, 15))
-                await self.build(UnitTypeId.PYLON, near=pos)
+                await self.build(PYLON, near=pos)
 
-        elif not self.units(UnitTypeId.PHOTONCANNON).exists:
-            if self.units(UnitTypeId.PYLON).ready.amount >= 2 and self.can_afford(UnitTypeId.PHOTONCANNON):
-                pylon = self.units(UnitTypeId.PYLON).closer_than(20, self.enemy_start_locations[0]).random
-                await self.build(UnitTypeId.PHOTONCANNON, near=pylon)
+        elif not self.units(PHOTONCANNON).exists:
+            if self.units(PYLON).ready.amount >= 2 and self.can_afford(PHOTONCANNON):
+                pylon = self.units(PYLON).closer_than(20, self.enemy_start_locations[0]).random
+                await self.build(PHOTONCANNON, near=pylon)
 
         else:
-            if self.can_afford(UnitTypeId.PYLON) and self.can_afford(UnitTypeId.PHOTONCANNON): # ensure "fair" decision
+            if self.can_afford(PYLON) and self.can_afford(PHOTONCANNON): # ensure "fair" decision
                 for _ in range(20):
                     pos = self.enemy_start_locations[0].random_on_distance(random.randrange(5, 12))
-                    building = UnitTypeId.PHOTONCANNON if state.psionic_matrix.covers(pos) else UnitTypeId.PYLON
+                    building = PHOTONCANNON if self.state.psionic_matrix.covers(pos) else PYLON
                     r = await self.build(building, near=pos)
                     if not r: # success
                         break

examples/distributed_workers.py

@@ -5,22 +5,22 @@
 
 
 class TerranBot(sc2.BotAI):
-    async def on_step(self, state, iteration):
+    async def on_step(self, iteration):
         await self.distribute_workers()
-        await self.build_supply(state)
-        await self.build_workers(state)
-        await self.expand(state)
+        await self.build_supply()
+        await self.build_workers()
+        await self.expand()
 
-    async def build_workers(self, state):
+    async def build_workers(self):
         for cc in self.units(UnitTypeId.COMMANDCENTER).ready.noqueue:
             if self.can_afford(UnitTypeId.SCV):
                 await self.do(cc.train(UnitTypeId.SCV))
 
-    async def expand(self, state):
+    async def expand(self):
         if self.units(UnitTypeId.COMMANDCENTER).amount < 3 and self.can_afford(UnitTypeId.COMMANDCENTER):
             await self.expand_now()
 
-    async def build_supply(self, state):
+    async def build_supply(self):
         cc = self.units(UnitTypeId.COMMANDCENTER).ready.first
         if self.supply_left < 4 and not self.already_pending(UnitTypeId.SUPPLYDEPOT):
             if self.can_afford(UnitTypeId.SUPPLYDEPOT):

examples/onebase_battlecruiser.py

@@ -0,0 +1,112 @@
+import random
+
+import sc2
+from sc2 import Race, Difficulty
+from sc2.constants import *
+from sc2.player import Bot, Computer
+from sc2.player import Human
+
+class ProxyRaxBot(sc2.BotAI):
+    def select_target(self):
+        target = self.known_enemy_structures
+        if target.exists:
+            return target.random.position
+
+        target = self.known_enemy_units
+        if target.exists:
+            return target.random.position
+
+        if min([u.position.distance_to(self.enemy_start_locations[0]) for u in self.units]) < 5:
+            return self.enemy_start_locations[0].position
+
+        return self.state.mineral_field.random.position
+
+    async def on_step(self, iteration):
+        cc = (self.units(COMMANDCENTER) | self.units(ORBITALCOMMAND))
+        if not cc.exists:
+            target = self.known_enemy_structures.random_or(self.enemy_start_locations[0]).position
+            for unit in self.workers | self.units(BATTLECRUISER):
+                await self.do(unit.attack(target))
+            return
+        else:
+            cc = cc.first
+
+
+        if iteration % 50 == 0 and self.units(BATTLECRUISER).amount > 2:
+            target = self.select_target()
+            forces = self.units(BATTLECRUISER)
+            if (iteration//50) % 10 == 0:
+                for unit in forces:
+                    await self.do(unit.attack(target))
+            else:
+                for unit in forces.idle:
+                    await self.do(unit.attack(target))
+
+        if self.can_afford(SCV) and self.workers.amount < 22 and cc.noqueue:
+            await self.do(cc.train(SCV))
+
+        if self.units(FUSIONCORE).exists and self.can_afford(BATTLECRUISER):
+            for sp in self.units(STARPORT):
+                if sp.has_add_on and sp.noqueue:
+                    if not self.can_afford(BATTLECRUISER):
+                        break
+                    await self.do(sp.train(BATTLECRUISER))
+
+        elif self.supply_left < 3:
+            if self.can_afford(SUPPLYDEPOT):
+                await self.build(SUPPLYDEPOT, near=cc.position.towards(self.game_info.map_center, 8))
+
+        if self.units(SUPPLYDEPOT).exists:
+            if not self.units(BARRACKS).exists:
+                if self.can_afford(BARRACKS):
+                    await self.build(BARRACKS, near=cc.position.towards(self.game_info.map_center, 8))
+
+            elif self.units(BARRACKS).exists and self.units(REFINERY).amount < 2:
+                if self.can_afford(REFINERY):
+                    vgs = self.state.vespene_geyser.closer_than(20.0, cc)
+                    for vg in vgs:
+                        if self.units(REFINERY).closer_than(1.0, vg).exists:
+                            break
+
+                        worker = self.select_build_worker(vg.position)
+                        if worker is None:
+                            break
+
+                        await self.do(worker.build(REFINERY, vg))
+                        break
+
+            if self.units(BARRACKS).ready.exists:
+                f = self.units(FACTORY)
+                if not f.exists:
+                    if self.can_afford(FACTORY):
+                        await self.build(FACTORY, near=cc.position.towards(self.game_info.map_center, 8))
+                elif f.ready.exists and self.units(STARPORT).amount < 2:
+                    if self.can_afford(STARPORT):
+                        await self.build(STARPORT, near=cc.position.towards(self.game_info.map_center, 30).random_on_distance(8))
+
+        for sp in self.units(STARPORT).ready:
+            if sp.add_on_tag == 0:
+                await self.do(sp.build(STARPORTTECHLAB))
+
+        if self.units(STARPORT).ready.exists:
+            if self.can_afford(FUSIONCORE) and not self.units(FUSIONCORE).exists:
+                await self.build(FUSIONCORE, near=cc.position.towards(self.game_info.map_center, 8))
+
+        for a in self.units(REFINERY):
+            if a.assigned_harvesters < a.ideal_harvesters:
+                w = self.workers.closer_than(20, a)
+                if w.exists:
+                    await self.do(w.random.gather(a))
+
+        for scv in self.units(SCV).idle:
+            await self.do(scv.gather(self.state.mineral_field.closest_to(cc)))
+
+def main():
+    sc2.run_game(sc2.maps.get("Sequencer LE"), [
+        # Human(Race.Terran),
+        Bot(Race.Terran, ProxyRaxBot()),
+        Computer(Race.Zerg, Difficulty.Hard)
+    ], realtime=False)
+
+if __name__ == '__main__':
+    main()

examples/play_tvz.py

@@ -8,7 +8,6 @@
 def main():
     sc2.run_game(sc2.maps.get("Abyssal Reef LE"), [
         Human(Race.Terran),
-        # Bot(Race.Protoss, CannonRushBot())
         Bot(Race.Zerg, ZergRushBot())
     ], realtime=True)
 

examples/proxy_rax.py

@@ -6,39 +6,39 @@
 from sc2.player import Bot, Computer
 
 class ProxyRaxBot(sc2.BotAI):
-    async def on_step(self, state, iteration):
-        cc = self.units(UnitTypeId.COMMANDCENTER)
+    async def on_step(self, iteration):
+        cc = self.units(COMMANDCENTER)
         if not cc.exists:
             target = self.known_enemy_structures.random_or(self.enemy_start_locations[0]).position
-            for unit in self.workers | self.units(UnitTypeId.MARINE):
+            for unit in self.workers | self.units(MARINE):
                 await self.do(unit.attack(target))
             return
         else:
             cc = cc.first
 
-        if self.units(UnitTypeId.MARINE).idle.amount > 15 and iteration % 50 == 1:
+        if self.units(MARINE).idle.amount > 15 and iteration % 50 == 1:
             target = self.known_enemy_structures.random_or(self.enemy_start_locations[0]).position
-            for marine in self.units(UnitTypeId.MARINE).idle:
+            for marine in self.units(MARINE).idle:
                 await self.do(marine.attack(target))
 
-        if self.can_afford(UnitTypeId.SCV) and self.workers.amount < 16 and cc.noqueue:
-            await self.do(cc.train(UnitTypeId.SCV))
+        if self.can_afford(SCV) and self.workers.amount < 16 and cc.noqueue:
+            await self.do(cc.train(SCV))
 
-        elif self.supply_left < (2 if self.units(UnitTypeId.BARRACKS).amount < 3 else 4):
-            if self.can_afford(UnitTypeId.SUPPLYDEPOT):
-                await self.build(UnitTypeId.SUPPLYDEPOT, near=cc.position.towards(self.game_info.map_center, 5))
+        elif self.supply_left < (2 if self.units(BARRACKS).amount < 3 else 4):
+            if self.can_afford(SUPPLYDEPOT):
+                await self.build(SUPPLYDEPOT, near=cc.position.towards(self.game_info.map_center, 5))
 
-        elif self.units(UnitTypeId.BARRACKS).amount < 3 or (self.minerals > 400 and self.units(UnitTypeId.BARRACKS).amount < 5):
-            if self.can_afford(UnitTypeId.BARRACKS):
+        elif self.units(BARRACKS).amount < 3 or (self.minerals > 400 and self.units(BARRACKS).amount < 5):
+            if self.can_afford(BARRACKS):
                 p = self.game_info.map_center.towards(self.enemy_start_locations[0], 25)
-                await self.build(UnitTypeId.BARRACKS, near=p)
+                await self.build(BARRACKS, near=p)
 
-        for rax in self.units(UnitTypeId.BARRACKS).ready.noqueue:
-            if not self.can_afford(UnitTypeId.MARINE):
+        for rax in self.units(BARRACKS).ready.noqueue:
+            if not self.can_afford(MARINE):
                 break
-            await self.do(rax.train(UnitTypeId.MARINE))
+            await self.do(rax.train(MARINE))
 
-        for scv in self.units(UnitTypeId.SCV).idle:
+        for scv in self.units(SCV).idle:
             await self.do(scv.gather(self.state.mineral_field.closest_to(cc)))
 
 def main():

examples/run_external.py

@@ -1,3 +1,7 @@
+# Usage: python run_external.py [--host]
+
+import argparse
+
 import sys
 import asyncio
 
@@ -7,12 +11,11 @@
 
 from zerg_rush import ZergRushBot
 
-def main(pc):
-    if pc:
-        host = False
+def main(is_host, pc):
+    if args.portconfig:
         portconfig = sc2.portconfig.Portconfig.from_json(pc)
     else:
-        host = True
+        assert args.host, "Must be host if portconfig is not given"
         portconfig = sc2.portconfig.Portconfig()
         print(portconfig.as_json)
 
@@ -21,9 +24,9 @@ def main(pc):
         Bot(Race.Zerg, None)
     ]
 
-    player_config[0 if host else 1].ai = ZergRushBot()
+    player_config[0 if is_host else 1].ai = ZergRushBot()
 
-    if host:
+    if is_host:
         g = sc2.main._host_game(
             sc2.maps.get("Abyssal Reef LE"),
             player_config,
@@ -41,4 +44,9 @@ def main(pc):
     print(result)
 
 if __name__ == '__main__':
-    main(sys.argv[1] if len(sys.argv) > 1 else None)
+    parser = argparse.ArgumentParser(description='Process some integers.')
+    parser.add_argument('--host', action='store_true', help='host a game')
+    parser.add_argument('portconfig', type=str, nargs="?", help='port configuration as json')
+    args = parser.parse_args()
+
+    main(args.host, args.portconfig)