Attacking and Defeating the Enemy

引言

Welcome to part 3 of the Starcraft AI with Python series. In the previous tutorials we learned the basics of writing an AI agent within Starcraft 2, but we’ve not yet been able to defeat the enemy computer player. In order to do this, we’re going to need to go on the offensive. There are many different types of units that we can go with to play more offensively, but my unit of choice is going to be the Void Ray. This is a good general purpose unit that flies around and shoots a laser beam.

The Void Ray isn’t necessarily the best unit to use in all situations, but we’re just here to have fun and learn for now.

In order to build a Void Ray, we need a Stargate. In order to build a Stargate, we need a Cybernetics Core, and for that…we need a Gateway! In order to build the Stargate, as well as the Void Ray units, we’re going to also need “gas.” For gas, we need to build assimilators to extract the vespene gas. To handle for all of this, we’ll again mostly revisit the elif chain. Our first order of business will be to build 2 assimilators. At least on this map, we seem to always start next to 2 vespene gas sources.

I think Pylons are more important in the order of needs than the assimilators, so right after those, I’ll add:

elif self.structures(UnitTypeId.ASSIMILATOR).amount <= 1:
    for nexus in self.structures(UnitTypeId.NEXUS):
        vespenes = self.vespene_geyser.closer_than(15, nexus)
        for vespene in vespenes:
            if self.can_afford(UnitTypeId.ASSIMILATOR) and not self.already_pending(UnitTypeId.ASSIMILATOR):
                await self.build(UnitTypeId.ASSIMILATOR, vespene)

Take all of my orders with a grain of salt, it may be wise to test out different things, but for now we’ll do this. Later, we could maybe make this dynamic by checking how many vespenes we have close, and simply building assimilators on any unoccupied vespenes. I think the assimilators are more important than the forges and cannons, but I suspect it’s best to hold off on further buildings until we have some more defenses. After our cannons are built, however, we should go ahead and build the Gateway, Cybernetics Core, then Stargate:

# a gateway? this gets us towards cyb core > stargate > void ray
elif not self.structures(UnitTypeId.GATEWAY):
    if self.can_afford(UnitTypeId.GATEWAY):
        await self.build(UnitTypeId.GATEWAY, near=self.structures(UnitTypeId.PYLON).closest_to(nexus))

# a cyber core? this gets us towards stargate > void ray
elif not self.structures(UnitTypeId.CYBERNETICSCORE):
    if self.can_afford(UnitTypeId.CYBERNETICSCORE):
        await self.build(UnitTypeId.CYBERNETICSCORE, near=self.structures(UnitTypeId.PYLON).closest_to(nexus))

# a stargate? this gets us towards void ray
elif not self.structures(UnitTypeId.STARGATE):
    if self.can_afford(UnitTypeId.STARGATE):
        await self.build(UnitTypeId.STARGATE, near=self.structures(UnitTypeId.PYLON).closest_to(nexus))

With all of this, we can build Void Rays, but I would argue that Void Rays are one of our top priorities, and we can also build Void Rays while we do other things. For this reason, I will actually just put this above the if/elif logic, after the nexus definition:

# if we have less than 10 voidrays, build one:
if self.structures(UnitTypeId.VOIDRAY).amount < 10 and self.can_afford(UnitTypeId.VOIDRAY):
    for sg in self.structures(UnitTypeId.STARGATE).ready.idle:
        if self.can_afford(UnitTypeId.VOIDRAY):
            sg.train(UnitTypeId.VOIDRAY)

In this case, I am going to just try to build up to 10 total. Maybe I’ll change this later, I just picked a random number that seemed reasonable. The last thing we need to is control our probe creation. Since we’re building infinite probes, we’ll always be able to build another probe, because a probe takse up 1 supply. A Void Ray costs us 4 supply, so we should probably always leave some room for at least 1 Void Ray. Maybe once we can build Void Rays, we can progressively open this up, or build more pylons to make more supply space. Again, this is all just a first pass of effort, there’s definitely a ton of improvement that could be made.

We can calc the supply remaining with:

supply_remaining = self.supply_cap - self.supply_used

Then we can just add another and to the if statement for the Pylons:

# leave room to build void rays
supply_remaining = self.supply_cap - self.supply_used
if nexus.is_idle and self.can_afford(UnitTypeId.PROBE) and supply_remaining > 4:
    nexus.train(UnitTypeId.PROBE)

Okay, we’ve added quite a bit up to this point. Here’s our code:

from sc2.bot_ai import BotAI  # parent class we inherit from
from sc2.data import Difficulty, Race  # difficulty for bots, race for the 1 of 3 races
from sc2.main import run_game  # function that facilitates actually running the agents in games
from sc2.player import Bot, Computer  #wrapper for whether or not the agent is one of your bots, or a "computer" player
from sc2 import maps  # maps method for loading maps to play in.
from sc2.ids.unit_typeid import UnitTypeId
import random

class IncrediBot(BotAI): # inhereits from BotAI (part of BurnySC2)
    async def on_step(self, iteration: int): # on_step is a method that is called every step of the game.
        print(f"{iteration}, n_workers: {self.workers.amount}, n_idle_workers: {self.workers.idle.amount},", \
            f"minerals: {self.minerals}, gas: {self.vespene}, cannons: {self.structures(UnitTypeId.PHOTONCANNON).amount},", \
            f"pylons: {self.structures(UnitTypeId.PYLON).amount}, nexus: {self.structures(UnitTypeId.NEXUS).amount}", \
            f"gateways: {self.structures(UnitTypeId.GATEWAY).amount}, cybernetics cores: {self.structures(UnitTypeId.CYBERNETICSCORE).amount}", \
            f"stargates: {self.structures(UnitTypeId.STARGATE).amount}, voidrays: {self.units(UnitTypeId.VOIDRAY).amount}, supply: {self.supply_used}/{self.supply_cap}")
        
        
        # begin logic:

        await self.distribute_workers() # put idle workers back to work

        if self.townhalls:  # do we have a nexus?
            nexus = self.townhalls.random  # select one (will just be one for now)


            # if we have less than 10 voidrays, build one:
            if self.structures(UnitTypeId.VOIDRAY).amount < 10 and self.can_afford(UnitTypeId.VOIDRAY):
                for sg in self.structures(UnitTypeId.STARGATE).ready.idle:
                    if self.can_afford(UnitTypeId.VOIDRAY):
                        sg.train(UnitTypeId.VOIDRAY)


            # leave room to build void rays
            supply_remaining = self.supply_cap - self.supply_used
            if nexus.is_idle and self.can_afford(UnitTypeId.PROBE) and supply_remaining > 4:
                nexus.train(UnitTypeId.PROBE)


            # if we dont have *any* pylons, we'll build one close to the nexus.
            elif not self.structures(UnitTypeId.PYLON) and self.already_pending(UnitTypeId.PYLON) == 0:
                if self.can_afford(UnitTypeId.PYLON):
                    await self.build(UnitTypeId.PYLON, near=nexus)


            elif self.structures(UnitTypeId.PYLON).amount < 5:
                if self.can_afford(UnitTypeId.PYLON):
                    # build from the closest pylon towards the enemy
                    target_pylon = self.structures(UnitTypeId.PYLON).closest_to(self.enemy_start_locations[0])
                    # build as far away from target_pylon as possible:
                    pos = target_pylon.position.towards(self.enemy_start_locations[0], random.randrange(8, 15))
                    await self.build(UnitTypeId.PYLON, near=pos)

            
            
            elif self.structures(UnitTypeId.ASSIMILATOR).amount <= 1:
                for nexus in self.structures(UnitTypeId.NEXUS):
                    vespenes = self.vespene_geyser.closer_than(15, nexus)
                    for vespene in vespenes:
                        if self.can_afford(UnitTypeId.ASSIMILATOR) and not self.already_pending(UnitTypeId.ASSIMILATOR):
                            await self.build(UnitTypeId.ASSIMILATOR, vespene)




            elif not self.structures(UnitTypeId.FORGE):  # if we don't have a forge:
                if self.can_afford(UnitTypeId.FORGE):  # and we can afford one:
                    # build one near the Pylon that is closest to the nexus:
                    await self.build(UnitTypeId.FORGE, near=self.structures(UnitTypeId.PYLON).closest_to(nexus))

            # if we have less than 3 cannons, let's build some more if possible:
            elif self.structures(UnitTypeId.FORGE).ready and self.structures(UnitTypeId.PHOTONCANNON).amount < 3:
                if self.can_afford(UnitTypeId.PHOTONCANNON):  # can we afford a cannon?
                    await self.build(UnitTypeId.PHOTONCANNON, near=nexus)  # build one near the nexus


            # a gateway? this gets us towards cyb core > stargate > void ray
            elif not self.structures(UnitTypeId.GATEWAY):
                if self.can_afford(UnitTypeId.GATEWAY):
                    await self.build(UnitTypeId.GATEWAY, near=self.structures(UnitTypeId.PYLON).closest_to(nexus))
            
            # a cyber core? this gets us towards stargate > void ray
            elif not self.structures(UnitTypeId.CYBERNETICSCORE):
                if self.can_afford(UnitTypeId.CYBERNETICSCORE):
                    await self.build(UnitTypeId.CYBERNETICSCORE, near=self.structures(UnitTypeId.PYLON).closest_to(nexus))

            # a stargate? this gets us towards void ray
            elif not self.structures(UnitTypeId.STARGATE):
                if self.can_afford(UnitTypeId.STARGATE):
                    await self.build(UnitTypeId.STARGATE, near=self.structures(UnitTypeId.PYLON).closest_to(nexus))
            


        else:
            if self.can_afford(UnitTypeId.NEXUS):  # can we afford one?
                await self.expand_now()  # build one!



run_game(  # run_game is a function that runs the game.
    maps.get("2000AtmospheresAIE"), # the map we are playing on
    [Bot(Race.Protoss, IncrediBot()), # runs our coded bot, protoss race, and we pass our bot object 
     Computer(Race.Zerg, Difficulty.Hard)], # runs a pre-made computer agent, zerg race, with a hard difficulty.
    realtime=False, # When set to True, the agent is limited in how long each step can take to process.
)

Running this, things actually look fairly decent. We wind up building 2 Starbases, and a few extra Void Rays, but we are definitely able to hold off the enemy for quite some time with this group:

So we’ve definitely got a strong defense when needed with these Void Rays, but that’s not the reason we built them. We built these for battle! For the extra buildings, we can add a pending building check, same for Void Rays. It’s probably not a huge mistake to have a couple Starbases, since that means we can build Void Rays faster, but it would probably be a waste to have multiple Cybernetics Cores or something.

But, before I address that, I want to see an attack. To command this force, I propose we do it outside of the Nexus check. Our army of Void Rays does not need a Nexus to attack, so we can have their commands sit outside of the Nexus check. Void Rays also can’t build a Nexus back, so it’s fairly irrelevant. For now, in order to attack, I think it’s best we attack with more than just 1 Void Ray. I really don’t know if that’s true, and I’ll just arbitrarily set the number required for attack: 4.

The next question is: where do we attack?

We have access to some data about our game, as noted here. We can see that we can access enemy units, enemy structures, and the enemy start location. If we’ve seen enemy units or buildings, then we might as well target those first. If we don’t know where any enemy units are, then let’s head towards the enemy’s starting location, because we’ll probably find some enemies there!

# if we have more than 3 voidrays, let's attack!
if self.units(UnitTypeId.VOIDRAY).amount >= 3:
    if self.enemy_units:
        for vr in self.units(UnitTypeId.VOIDRAY).idle:
            vr.attack(random.choice(self.enemy_units))
    
    elif self.enemy_structures:
        for vr in self.units(UnitTypeId.VOIDRAY).idle:
            vr.attack(random.choice(self.enemy_structures))

    # otherwise attack enemy starting position
    else:
        for vr in self.units(UnitTypeId.VOIDRAY).idle:
            vr.attack(self.enemy_start_locations[0])

Now, full code is:

from sc2.bot_ai import BotAI  # parent class we inherit from
from sc2.data import Difficulty, Race  # difficulty for bots, race for the 1 of 3 races
from sc2.main import run_game  # function that facilitates actually running the agents in games
from sc2.player import Bot, Computer  #wrapper for whether or not the agent is one of your bots, or a "computer" player
from sc2 import maps  # maps method for loading maps to play in.
from sc2.ids.unit_typeid import UnitTypeId
import random

class IncrediBot(BotAI): # inhereits from BotAI (part of BurnySC2)
    async def on_step(self, iteration: int): # on_step is a method that is called every step of the game.
        print(f"{iteration}, n_workers: {self.workers.amount}, n_idle_workers: {self.workers.idle.amount},", \
            f"minerals: {self.minerals}, gas: {self.vespene}, cannons: {self.structures(UnitTypeId.PHOTONCANNON).amount},", \
            f"pylons: {self.structures(UnitTypeId.PYLON).amount}, nexus: {self.structures(UnitTypeId.NEXUS).amount}", \
            f"gateways: {self.structures(UnitTypeId.GATEWAY).amount}, cybernetics cores: {self.structures(UnitTypeId.CYBERNETICSCORE).amount}", \
            f"stargates: {self.structures(UnitTypeId.STARGATE).amount}, voidrays: {self.units(UnitTypeId.VOIDRAY).amount}, supply: {self.supply_used}/{self.supply_cap}")
        
        
        # begin logic:

        await self.distribute_workers() # put idle workers back to work

        if self.townhalls:  # do we have a nexus?
            nexus = self.townhalls.random  # select one (will just be one for now)


            # if we have less than 10 voidrays, build one:
            if self.structures(UnitTypeId.VOIDRAY).amount < 10 and self.can_afford(UnitTypeId.VOIDRAY):
                for sg in self.structures(UnitTypeId.STARGATE).ready.idle:
                    if self.can_afford(UnitTypeId.VOIDRAY):
                        sg.train(UnitTypeId.VOIDRAY)


            # leave room to build void rays
            supply_remaining = self.supply_cap - self.supply_used
            if nexus.is_idle and self.can_afford(UnitTypeId.PROBE) and supply_remaining > 4:
                nexus.train(UnitTypeId.PROBE)


            # if we dont have *any* pylons, we'll build one close to the nexus.
            elif not self.structures(UnitTypeId.PYLON) and self.already_pending(UnitTypeId.PYLON) == 0:
                if self.can_afford(UnitTypeId.PYLON):
                    await self.build(UnitTypeId.PYLON, near=nexus)


            elif self.structures(UnitTypeId.PYLON).amount < 5:
                if self.can_afford(UnitTypeId.PYLON):
                    # build from the closest pylon towards the enemy
                    target_pylon = self.structures(UnitTypeId.PYLON).closest_to(self.enemy_start_locations[0])
                    # build as far away from target_pylon as possible:
                    pos = target_pylon.position.towards(self.enemy_start_locations[0], random.randrange(8, 15))
                    await self.build(UnitTypeId.PYLON, near=pos)

            
            
            elif self.structures(UnitTypeId.ASSIMILATOR).amount <= 1:
                for nexus in self.structures(UnitTypeId.NEXUS):
                    vespenes = self.vespene_geyser.closer_than(15, nexus)
                    for vespene in vespenes:
                        if self.can_afford(UnitTypeId.ASSIMILATOR) and not self.already_pending(UnitTypeId.ASSIMILATOR):
                            await self.build(UnitTypeId.ASSIMILATOR, vespene)




            elif not self.structures(UnitTypeId.FORGE):  # if we don't have a forge:
                if self.can_afford(UnitTypeId.FORGE):  # and we can afford one:
                    # build one near the Pylon that is closest to the nexus:
                    await self.build(UnitTypeId.FORGE, near=self.structures(UnitTypeId.PYLON).closest_to(nexus))

            # if we have less than 3 cannons, let's build some more if possible:
            elif self.structures(UnitTypeId.FORGE).ready and self.structures(UnitTypeId.PHOTONCANNON).amount < 3:
                if self.can_afford(UnitTypeId.PHOTONCANNON):  # can we afford a cannon?
                    await self.build(UnitTypeId.PHOTONCANNON, near=nexus)  # build one near the nexus


            # a gateway? this gets us towards cyb core > stargate > void ray
            elif not self.structures(UnitTypeId.GATEWAY):
                if self.can_afford(UnitTypeId.GATEWAY):
                    await self.build(UnitTypeId.GATEWAY, near=self.structures(UnitTypeId.PYLON).closest_to(nexus))
            
            # a cyber core? this gets us towards stargate > void ray
            elif not self.structures(UnitTypeId.CYBERNETICSCORE):
                if self.can_afford(UnitTypeId.CYBERNETICSCORE):
                    await self.build(UnitTypeId.CYBERNETICSCORE, near=self.structures(UnitTypeId.PYLON).closest_to(nexus))

            # a stargate? this gets us towards void ray
            elif not self.structures(UnitTypeId.STARGATE):
                if self.can_afford(UnitTypeId.STARGATE):
                    await self.build(UnitTypeId.STARGATE, near=self.structures(UnitTypeId.PYLON).closest_to(nexus))
            


        else:
            if self.can_afford(UnitTypeId.NEXUS):  # can we afford one?
                await self.expand_now()  # build one!

        

        # if we have more than 3 voidrays, let's attack!
        if self.units(UnitTypeId.VOIDRAY).amount >= 3:
            if self.enemy_units:
                for vr in self.units(UnitTypeId.VOIDRAY).idle:
                    vr.attack(random.choice(self.enemy_units))
            
            elif self.enemy_structures:
                for vr in self.units(UnitTypeId.VOIDRAY).idle:
                    vr.attack(random.choice(self.enemy_structures))

            # otherwise attack enemy starting position
            else:
                for vr in self.units(UnitTypeId.VOIDRAY).idle:
                    vr.attack(self.enemy_start_locations[0])




run_game(  # run_game is a function that runs the game.
    maps.get("2000AtmospheresAIE"), # the map we are playing on
    [Bot(Race.Protoss, IncrediBot()), # runs our coded bot, protoss race, and we pass our bot object 
     Computer(Race.Zerg, Difficulty.Hard)], # runs a pre-made computer agent, zerg race, with a hard difficulty.
    realtime=False, # When set to True, the agent is limited in how long each step can take to process.
)

Running this, we make some void rays and can see them promptly go to the enemy starting location across the map, wreaking immediate havoc on the enemy:

The enemy does propose to surrender, but we don’t accept this. Eventually:

Running this a few times seems to yield similar results. It seems like Void Rays do pretty well here, at least up to the Hard Zerg computer. When poking around, I saw that Void Rays apparently don’t do well against terran. Let’s change the computer to Terran race instead:

run_game(  # run_game is a function that runs the game.
    maps.get("2000AtmospheresAIE"), # the map we are playing on
    [Bot(Race.Protoss, IncrediBot()), # runs our coded bot, protoss race, and we pass our bot object 
     Computer(Race.Terran, Difficulty.Hard)], # runs a pre-made computer agent, zerg race, with a hard difficulty.
    realtime=False, # When set to True, the agent is limited in how long each step can take to process.
)

While the fight definitely looked a bit harder, it certainly wasn’t as swift of a defeat and we lost more Void Rays, we still won. Running again, the victory seems to come even easier:

It does seem like the Terrans can handle Void Rays better, and that probably harder bots will require a better strategy, but I’d say this is a pretty good start.