Roach rush AI- v1

import sc2
from sc2 import run_game, maps, Race, Difficulty
from sc2.constants import HATCHERY, ZERGLING, QUEEN, LARVA, EFFECT_INJECTLARVA, \
SPAWNINGPOOL, RESEARCH_ZERGLINGMETABOLICBOOST, OVERLORD, EXTRACTOR, DRONE, ROACHWARREN, ROACH, \
QUEENSPAWNLARVATIMER, EVOLUTIONCHAMBER, RESEARCH_ZERGMISSILEWEAPONSLEVEL1, AbilityId, \
RESEARCH_ZERGGROUNDARMORLEVEL1
from sc2.player import Bot, Computer


class ZergRoach(sc2.BotAI):
    def __init__(self):
        self.flag1 = False
        self.flag2 = False

    async def on_step(self, iteration):
        await self.distribute_workers()
        await self.build_workers()
        await self.build_overlords()
        await self.build_hatchery()
        await self.build_spawning_pool()
        await self.build_queens_inject_larva()
        await self.build_Roach_Warren()
        await self.build_extrator()
        await self.build_evochamber()
        await self.build_Roaches()
        await self.defend_attack()
        await self.one_one()

    async def build_workers(self):
        larvas = self.units(LARVA)
        if self.units(DRONE).amount < 18 * self.units(HATCHERY).amount \
                and self.can_afford(DRONE) and larvas.exists\
                and self.supply_left >= 1:
            await self.do(larvas.random.train(DRONE))

    async def build_overlords(self):
        larvas = self.units(LARVA)
        if self.supply_left < 3 and self.can_afford(OVERLORD) and larvas.exists \
                and not self.already_pending(OVERLORD):
            await self.do(larvas.random.train(OVERLORD))


    async def build_hatchery(self):
        hatch_amount = self.units(HATCHERY).amount
        if self.can_afford(HATCHERY) and hatch_amount <= 4\
                and not self.already_pending(HATCHERY):
            if hatch_amount == 1:
                await self.expand_now()
            elif hatch_amount * 10 < self.units(ROACH).amount:
                await self.expand_now()

    async def build_spawning_pool(self):
        hatcherys = self.units(HATCHERY)
        if self.can_afford(SPAWNINGPOOL) and not self.units(SPAWNINGPOOL).exists \
                and hatcherys.amount == 2:
                    await self.build(SPAWNINGPOOL, near=hatcherys.first)

    async def build_queens_inject_larva(self):
        hatcherys = self.units(HATCHERY).random
        if self.units(SPAWNINGPOOL).exists:
            if self.units(QUEEN).amount < 2 and hatcherys.is_ready\
                    and not self.already_pending(QUEEN) and hatcherys.noqueue:
                if self.can_afford(QUEEN):
                    await self.do(hatcherys.train(QUEEN))
        for queen in self.units(QUEEN).idle:
            abilities = await self.get_available_abilities(queen)
            if AbilityId.EFFECT_INJECTLARVA in abilities:
                await self.do(queen(EFFECT_INJECTLARVA, hatcherys))

    async def build_Roach_Warren(self):
        sp = self.units(SPAWNINGPOOL)
        if self.can_afford(ROACHWARREN) and sp.exists\
                and not self.units(ROACHWARREN).exists\
                and not self.already_pending(ROACHWARREN):
            await self.build(ROACHWARREN, near=sp.first)

    async def build_extrator(self):
        if self.units(EXTRACTOR).amount < 3 and not self.already_pending(EXTRACTOR) \
                and self.units(HATCHERY).amount == 2 and self.can_afford(EXTRACTOR):
            drone = self.workers.random
            await self.do(drone.build(EXTRACTOR, self.state.vespene_geyser.closest_to(drone.position)))

    async def build_evochamber(self):
        rw = self.units(ROACHWARREN)
        if self.can_afford(EVOLUTIONCHAMBER)and rw.exists \
                and self.units(EVOLUTIONCHAMBER).amount < 2\
                and not self.already_pending(EVOLUTIONCHAMBER)\
                and self.units(ROACH).amount < 10:
            await self.build(EVOLUTIONCHAMBER, near=rw.first)

    async def build_Roaches(self):
        larvas = self.units(LARVA)
        if self.supply_left > 1 and self.can_afford(ROACH) and larvas.exists \
                and not self.already_pending(ROACH):
            await self.do(larvas.random.train(ROACH))

    async def defend_attack(self):
        roaches = self.units(ROACH)
        enemy_units = self.known_enemy_units
        enemy_buildings = self.known_enemy_structures
        if roaches.amount in range(1, 5):
            for r in roaches.idle:
                if enemy_units.exists:
                    await self.do(r.attack(enemy_units.closest_to(r.position)))
        if roaches.amount > 15:
            for r in roaches.idle:
                if enemy_units.exists:
                    await self.do(r.attack(enemy_units.closest_to(r.position)))
                elif enemy_buildings.exists:
                    await self.do(r.attack(enemy_buildings.closest_to(r.position)))
                else:
                    await self.do(r.attack(self.enemy_start_locations[0]))

    async def one_one(self):
        evochambers = self.units(EVOLUTIONCHAMBER)
        if evochambers.exists and any(i is False for i in [self.flag2, self.flag1]):
                for evoc in evochambers.idle.noqueue:
                    if self.can_afford(RESEARCH_ZERGMISSILEWEAPONSLEVEL1) and not self.flag1 \
                            and evoc.is_ready:
                        self.flag1 = True
                        await self.do(evoc(RESEARCH_ZERGMISSILEWEAPONSLEVEL1))
                    if self.can_afford(RESEARCH_ZERGGROUNDARMORLEVEL1) and not self.flag2 \
                            and evoc.is_ready:
                        self.flag2 = True
                        await self.do(evoc(RESEARCH_ZERGGROUNDARMORLEVEL1))


run_game(maps.get("AbyssalReefLE"), [
        Bot(Race.Zerg, ZergRoach()),
        Computer(Race.Zerg, Difficulty.Medium)
    ], realtime=False)