Exemple #1
0
    async def create_plan(self) -> BuildOrder:
        if self.build_name == "default":
            self.tactic_index = select_build_index(self._bot.knowledge,
                                                   "build.marine", 0, 2)
        else:
            self.tactic_index = int(self.build_name)

        if self.tactic_index == 0:
            self._bot.knowledge.print("Proxy 2 rax bunker rush", "Build")
            self.attack = DodgeRampAttack(3)
            zone = self._bot.zone_manager.expansion_zones[-random.
                                                          randint(3, 5)]
            natural = self._bot.zone_manager.expansion_zones[-2]
            chunk = [
                Step(Supply(12), GridBuilding(UnitTypeId.SUPPLYDEPOT, 1)),
                BuildPosition(UnitTypeId.BARRACKS,
                              zone.center_location,
                              exact=False,
                              only_once=True),
                BuildPosition(
                    UnitTypeId.BARRACKS,
                    zone.center_location.towards(
                        self._bot.zone_manager.enemy_expansion_zones[0].ramp.
                        bottom_center, 5),
                    exact=False,
                    only_once=True,
                ),
                BuildPosition(
                    UnitTypeId.BARRACKS,
                    zone.center_location.towards(
                        self._bot.game_info.map_center, 5),
                    exact=False,
                    only_once=True,
                ),
                Step(None, GridBuilding(UnitTypeId.SUPPLYDEPOT, 2)),
                Step(
                    UnitReady(UnitTypeId.MARINE, 1),
                    BuildPosition(
                        UnitTypeId.BUNKER,
                        natural.center_location.towards(
                            self._bot.game_info.map_center, 4),
                        exact=False,
                        only_once=True,
                    ),
                ),
                Step(Minerals(225), GridBuilding(UnitTypeId.BARRACKS, 6)),
            ]
        elif self.tactic_index == 1:
            self._bot.knowledge.print("20 marine all in", "Build")
            self.attack = DodgeRampAttack(20)
            chunk = [
                Step(Supply(14), GridBuilding(UnitTypeId.SUPPLYDEPOT, 1)),
                Step(UnitReady(UnitTypeId.SUPPLYDEPOT, 1),
                     GridBuilding(UnitTypeId.BARRACKS, 1)),
                Step(None, GridBuilding(UnitTypeId.SUPPLYDEPOT, 2)),
                GridBuilding(UnitTypeId.BARRACKS, 6),
            ]
        else:
            self._bot.knowledge.print("10 marine proxy rax", "Build")
            self.attack = DodgeRampAttack(10)
            zone = self._bot.zone_manager.expansion_zones[-random.
                                                          randint(3, 5)]
            chunk = [
                Step(Supply(14), GridBuilding(UnitTypeId.SUPPLYDEPOT, 1)),
                Step(UnitReady(UnitTypeId.SUPPLYDEPOT, 1),
                     GridBuilding(UnitTypeId.BARRACKS, 1)),
                Step(None, GridBuilding(UnitTypeId.SUPPLYDEPOT, 2)),
                BuildPosition(UnitTypeId.BARRACKS,
                              zone.center_location,
                              exact=False,
                              only_once=True),
                BuildPosition(
                    UnitTypeId.BARRACKS,
                    zone.center_location.towards(
                        self._bot.zone_manager.expansion_zones[-1].ramp.
                        bottom_center, 5),
                    exact=False,
                    only_once=True,
                ),
                Step(Minerals(225), GridBuilding(UnitTypeId.BARRACKS, 6)),
            ]

        empty = BuildOrder([])

        worker_scout = Step(None,
                            WorkerScout(),
                            skip_until=UnitExists(UnitTypeId.SUPPLYDEPOT, 1))
        self.distribute_workers = DistributeWorkers()

        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,
            Step(None, SpeedMining(), lambda ai: ai.client.game_step > 5),
            ManTheBunkers(),
            Repair(),
            ContinueBuilding(),
            PlanZoneGatherTerran(),
            Step(None, self.attack),
            PlanFinishEnemy(),
        ]

        return BuildOrder(
            empty.depots,
            Step(None,
                 MorphOrbitals(),
                 skip_until=UnitReady(UnitTypeId.BARRACKS, 1)),
            [
                Step(None, ActUnit(UnitTypeId.SCV, UnitTypeId.COMMANDCENTER,
                                   20))
            ],
            chunk,
            ActUnit(UnitTypeId.MARINE, UnitTypeId.BARRACKS, 200),
            SequentialList(tactics),
        )
Exemple #2
0
    async def create_plan(self) -> BuildOrder:
        rnd = select_build_index(self.knowledge, "build.cannon_rush", 0, 2)
        self.knowledge.building_solver.wall_type = WallType.NoWall
        rush_killed = RequireCustom(
            lambda k: self.knowledge.lost_units_manager.own_lost_type(UnitTypeId.PROBE) >= 3 or self.time > 4 * 60
        )

        if rnd == 2:
            cannon_rush = self.cannon_expand()
        elif rnd == 1:
            cannon_rush = self.cannon_contain()
        else:
            cannon_rush = self.cannon_rush()

        return BuildOrder(
            Step(
                None,
                ChronoUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS),
                skip=UnitExists(UnitTypeId.PROBE, 16),
                skip_until=UnitReady(UnitTypeId.PYLON, 1),
            ),
            ChronoAnyTech(0),
            SequentialList(
                ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 13),
                GridBuilding(UnitTypeId.PYLON, 1),
                Step(None, cannon_rush, skip=rush_killed),
                BuildOrder(
                    [
                        Expand(2),
                        ProtossUnit(UnitTypeId.PROBE, 30),
                        Step(UnitExists(UnitTypeId.NEXUS, 2), ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 44)),
                    ],
                    GridBuilding(UnitTypeId.GATEWAY, 2),
                    GridBuilding(UnitTypeId.CYBERNETICSCORE, 1),
                    BuildGas(2),
                    AutoPylon(),
                    ProtossUnit(UnitTypeId.STALKER, 4, priority=True),
                    StepBuildGas(3, skip=Gas(300)),
                    Tech(UpgradeId.WARPGATERESEARCH),
                    BuildOrder([]).forge_upgrades_all,
                    Step(UnitReady(UnitTypeId.TWILIGHTCOUNCIL, 1), Tech(UpgradeId.BLINKTECH)),
                    [
                        ProtossUnit(UnitTypeId.PROBE, 22),
                        Step(UnitExists(UnitTypeId.NEXUS, 2), ActUnit(UnitTypeId.PROBE, UnitTypeId.NEXUS, 44)),
                        StepBuildGas(3, skip=Gas(300)),
                    ],
                    [ProtossUnit(UnitTypeId.STALKER, 100)],
                    [
                        Step(UnitReady(UnitTypeId.CYBERNETICSCORE, 1), GridBuilding(UnitTypeId.TWILIGHTCOUNCIL, 1),),
                        Step(UnitReady(UnitTypeId.CYBERNETICSCORE, 1), GridBuilding(UnitTypeId.GATEWAY, 7)),
                        StepBuildGas(4, skip=Gas(200)),
                    ],
                ),
            ),
            SequentialList(
                PlanCancelBuilding(),
                PlanZoneDefense(),
                PlanDistributeWorkers(),
                PlanZoneGather(),
                PlanZoneAttack(6),
                PlanFinishEnemy(),
            ),
        )
Exemple #3
0
    async def create_plan(self) -> BuildOrder:
        attack_value = random.randint(50, 80)
        self.attack = Step(None, PlanZoneAttack(attack_value))
        empty = BuildOrder([])

        if self.build_name == "default":
            self.jump = select_build_index(self.knowledge, "build.bc", 0, 1)
        else:
            self.jump = int(self.build_name)

        if self.jump == 0:
            self.knowledge.print(f"Att at {attack_value}", "Build")
        else:
            self.knowledge.print(f"Jump, 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(),
            Step(None, JumpIn(), RequireCustom(lambda k: self.jump == 0)),
            self.attack,
            PlanFinishEnemy(),
        ]

        return BuildOrder(
            empty.depots,
            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)),
                BuildGas(3),
                Step(
                    None,
                    BuildAddon(UnitTypeId.FACTORYTECHLAB, UnitTypeId.FACTORY,
                               1)),
                Step(UnitReady(UnitTypeId.STARPORT, 1),
                     GridBuilding(UnitTypeId.FUSIONCORE, 1)),
                Step(
                    None,
                    BuildAddon(UnitTypeId.STARPORTTECHLAB, UnitTypeId.STARPORT,
                               1)),
                StepBuildGas(
                    4, None,
                    UnitExists(UnitTypeId.BATTLECRUISER,
                               1,
                               include_killed=True,
                               include_pending=True)),
                Step(
                    UnitExists(
                        UnitTypeId.BATTLECRUISER, 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),
                ),
            ],
            Step(
                None,
                SequentialList(
                    ActUnit(UnitTypeId.BATTLECRUISER,
                            UnitTypeId.STARPORT,
                            20,
                            priority=True)),
                skip_until=UnitReady(UnitTypeId.FUSIONCORE, 1),
            ),
            ActUnit(UnitTypeId.SIEGETANK, UnitTypeId.FACTORY, 10),
            ActUnit(UnitTypeId.MARINE, UnitTypeId.BARRACKS, 50),
            SequentialList(tactics),
        )