예제 #1
0
def rebirth_init(rt):
    """Procedure that handles start of rebirth."""
    Misc.reclaim_all()  # make sure we reset e/m if we run this mid-rebirth
    FightBoss.nuke(101)  # PPP
    Inventory.loadout(respawn_loadout)
    Adventure.adventure(highest=True)
    TimeMachine.time_machine(5e11, magic=True)
    Augmentation.augments({"CI": 0.7, "ML": 0.3}, 1e12)
    BloodMagic.blood_magic(8)
    BloodMagic.toggle_auto_spells()
    GoldDiggers.gold_diggers()

    if rt.timestamp.tm_hour > 0 or rt.timestamp.tm_min >= 13:
        print("assigning adv training")
    else:
        duration = (12.5 - rt.timestamp.tm_min) * 60
        print(f"doing itopod for {duration} seconds while waiting for adv training to activate")
        Adventure.itopod_snipe(duration)

    AdvancedTraining.advanced_training(2e12)
    GoldDiggers.gold_diggers()
    Misc.reclaim_bm()
    Wandoos.wandoos(True)
    NGU.assign_ngu(Misc.get_idle_cap(2), range(1, 11), False)
    NGU.assign_ngu(Misc.get_idle_cap(1), range(1, 9), True)
예제 #2
0
    def speedrun():
        """Start a speedrun.

        Keyword arguments
        duration -- duration in minutes to run
        f -- feature object
        """
        diggers = [2, 3, 11, 12]
        FightBoss.nuke()
        Wandoos.set_wandoos(0)
        Adventure.adventure(highest=True)
        TimeMachine.time_machine(Misc.get_idle_cap(1) * 0.01, magic=True)
        GoldDiggers.gold_diggers(diggers)
        Wandoos.wandoos(True)
        BloodMagic.blood_magic(8)
        while Rebirth.check_challenge():
            FightBoss.nuke()
            Augmentation.augments({
                "LS": 0.92,
                "QSL": 0.08
            }, Misc.get_idle_cap(1))
            GoldDiggers.gold_diggers(diggers)

        rb_time = Rebirth.get_rebirth_time()
        while int(rb_time.timestamp.tm_min) < 3:
            rb_time = Rebirth.get_rebirth_time()
            time.sleep(1)
예제 #3
0
    def speedrun(duration):
        """Start a speedrun.

        Keyword arguments
        duration -- duration in minutes to run
        f -- feature object
        """
        diggers = [2, 3, 11, 12]
        FightBoss.nuke()
        time.sleep(2)

        FightBoss.fight()
        Adventure.adventure(highest=True)
        time.sleep(2)

        rb_time = Rebirth.get_rebirth_time()
        while int(rb_time.timestamp.tm_min) < duration:
            GoldDiggers.gold_diggers(diggers)
            Wandoos.wandoos(True)
            Augmentation.augments({"SM": 1}, coords.INPUT_MAX)
            if not Inputs.check_pixel_color(*coords.COLOR_TM_LOCKED):
                BloodMagic.blood_magic(6)
            FightBoss.nuke()
            rb_time = Rebirth.get_rebirth_time()
        MoneyPit.pit()
        MoneyPit.spin()
        return
예제 #4
0
 def speedrun(duration):
     """Procedure for first rebirth in a 100LC."""
     FightBoss.nuke()
     time.sleep(2)
     FightBoss.fight()
     diggers = [2, 3, 11, 12]
     Adventure.adventure(highest=True)
     current_boss = int(FightBoss.get_current_boss())
     if current_boss > 48:
         Augmentation.augments({
             "EB": 0.66,
             "CS": 0.34
         }, Misc.get_idle_cap(1))
     else:
         Augmentation.augments({"EB": 1}, coords.INPUT_MAX)
     GoldDiggers.gold_diggers(diggers)
     rb_time = Rebirth.get_rebirth_time()
     while int(rb_time.timestamp.tm_min) < duration:
         Augmentation.augments({
             "EB": 0.66,
             "CS": 0.34
         }, Misc.get_idle_cap(1))
         FightBoss.nuke()
         FightBoss.fight()
         GoldDiggers.gold_diggers(diggers)
         rb_time = Rebirth.get_rebirth_time()
     if not Rebirth.check_challenge() and rb_time.timestamp.tm_min >= 3:
         return
     Rebirth.do_rebirth()
     return
예제 #5
0
    def first_rebirth(duration):
        """Procedure for first rebirth."""
        ss_assigned = False
        adventure_pushed = False

        FightBoss.nuke()
        Adventure.adventure(highest=True)
        while Inputs.check_pixel_color(*coords.COLOR_TM_LOCKED):
            if not ss_assigned:
                time.sleep(1)
                Augmentation.augments({"SS": 1}, Misc.get_idle_cap(1))
                ss_assigned = True
            Wandoos.wandoos(True)
            if Wandoos.check_wandoos_bb_status():
                Augmentation.augments({"SS": 1}, Misc.get_idle_cap(1))
            FightBoss.nuke()
            time.sleep(2)
            FightBoss.fight()
        if ss_assigned:
            Misc.reclaim_aug()
        Augmentation.augments({"EB": 1}, Misc.get_idle_cap(1))

        while Inputs.check_pixel_color(*coords.COLOR_BM_LOCKED):
            Wandoos.wandoos(True)
            if Wandoos.check_wandoos_bb_status():
                Augmentation.augments({"EB": 1}, Misc.get_idle_cap(1))
            FightBoss.nuke()
            FightBoss.fight()
        BloodMagic.toggle_auto_spells(drop=False, gold=False)
        BloodMagic.blood_magic(8)
        rb_time = Rebirth.get_rebirth_time()
        while int(rb_time.timestamp.tm_min) < duration:
            Wandoos.wandoos(True)
            FightBoss.nuke()
            FightBoss.fight()
            time.sleep(2)
            try:
                current_boss = int(FightBoss.get_current_boss())
                if current_boss > 28 and current_boss < 49:
                    if not Timemachine.buster_assigned:
                        Misc.reclaim_aug()
                        Timemachine.buster_assigned = True
                    Augmentation.augments({"EB": 1}, Misc.get_idle_cap(1))

                elif current_boss >= 49:
                    if not Timemachine.final_aug:
                        Misc.reclaim_aug()
                        Timemachine.final_aug = True
                        time.sleep(1)
                    Augmentation.augments({
                        "EB": 0.66,
                        "CS": 0.34
                    }, Misc.get_idle_cap(1))
                if current_boss > 58 and not adventure_pushed:
                    Adventure.adventure(highest=True)
                    adventure_pushed = True
            except ValueError:
                print("couldn't get current boss")
            rb_time = Rebirth.get_rebirth_time()
예제 #6
0
def run(duration):
    """Procedure for Blind Challenge RBs."""
    global advanced_training_locked, bm_locked, tm_locked

    advanced_training_locked = True
    bm_locked = True
    tm_locked = True

    tm_assigned = False
    bm_assigned = False

    end = time.time() + duration * 60 + 10
    FightBoss.nuke()
    time.sleep(2)
    FightBoss.fight()
    diggers = [2, 3, 11, 12]
    Adventure.adventure(highest=True)
    Augmentation.augments({"SS": 1}, 1e12)
    GoldDiggers.gold_diggers(diggers)
    while time.time() < end:
        Augmentation.augments({"EB": 0.66, "CS": 0.34}, 1e13)
        Wandoos.wandoos(True, True)
        FightBoss.nuke()
        FightBoss.fight()
        GoldDiggers.gold_diggers(diggers)
        update_gamestate()
        if not tm_locked and not tm_assigned:
            TimeMachine.time_machine(1e13, m=1e13)
            tm_assigned = True
        if not bm_locked and not bm_assigned:
            BloodMagic.blood_magic(8)
            bm_assigned = True
        if not Rebirth.check_challenge() and end - time.time() > 180:
            return
    if not Rebirth.check_challenge():
        return
    Rebirth.do_rebirth()
    return
예제 #7
0
    def normal_rebirth(duration):
        """Procedure for first rebirth."""
        diggers = [2, 3, 11, 12]  # Wandoos, stat, blood, exp
        FightBoss.nuke()
        time.sleep(2)
        FightBoss.fight()
        Adventure.adventure(highest=True)
        Wandoos.set_wandoos(1)  # wandoos Meh, use 0 for 98
        BloodMagic.toggle_auto_spells(drop=False)
        GoldDiggers.gold_diggers(diggers)
        while Inputs.check_pixel_color(*coords.COLOR_TM_LOCKED):
            Wandoos.wandoos(True)
            FightBoss.nuke()
            time.sleep(2)
            FightBoss.fight()

        TimeMachine.time_machine(Misc.get_idle_cap(1) * 0.1, magic=True)
        Adventure.adventure(itopod=True, itopodauto=True)

        while Inputs.check_pixel_color(*coords.COLOR_BM_LOCKED):
            Wandoos.wandoos(True)
            FightBoss.nuke()
            time.sleep(2)
            FightBoss.fight()
            GoldDiggers.gold_diggers(diggers)
        BloodMagic.blood_magic(8)
        rb_time = Rebirth.get_rebirth_time()
        while int(rb_time.timestamp.tm_min) < duration:
            Wandoos.wandoos(True)
            FightBoss.nuke()
            FightBoss.fight()
            time.sleep(2)
            GoldDiggers.gold_diggers(diggers)
            rb_time = Rebirth.get_rebirth_time()
            # return if challenge is completed and rebirth time is above 3 minutes
            if int(rb_time.timestamp.tm_min
                   ) >= 3 and not Rebirth.check_challenge():
                return

        Rebirth.do_rebirth()
예제 #8
0
    def run() -> None:
        """Rebirth procedure."""
        GuffinRun.advanced_training_locked = True
        GuffinRun.current_boss = 0
        GuffinRun.rb_time = 0
        GuffinRun.__update_gamestate()
        if GuffinRun.rb_time > GuffinRun.max_rb_duration:
            Rebirth.do_rebirth()
            return
        FightBoss.nuke()
        time.sleep(2)
        Adventure.adventure(const.ZONE_MAP[GuffinRun.gold_zone])
        BloodMagic.toggle_auto_spells(number=False, drop=False)
        GoldDiggers.gold_diggers(GuffinRun.diggers)
        BloodMagic.blood_magic(8)
        NGU.cap_ngu()
        NGU.cap_ngu(magic=True)
        Wandoos.set_wandoos(0)
        Wandoos.wandoos(True, True)
        Augmentation.augments({
            GuffinRun.aug[0]: 0.66,
            GuffinRun.aug[1]: 0.34
        },
                              Misc.get_idle_cap(1) * 0.5)
        TimeMachine.time_machine(Misc.get_idle_cap(1) * 0.1, magic=True)
        GuffinRun.__update_gamestate()
        BloodMagic.toggle_auto_spells(drop=False, gold=False)
        if GuffinRun.wishes:
            GuffinRun.wishes.get_caps()
            GuffinRun.wishes.get_wish_status()
            GuffinRun.wishes.allocate_wishes()

        while GuffinRun.advanced_training_locked:
            GuffinRun.__do_quest()
            FightBoss.nuke()
            GoldDiggers.gold_diggers(GuffinRun.diggers)
            NGU.cap_ngu()
            NGU.cap_ngu(magic=True)
            Hacks.hacks(GuffinRun.hacks, coords.INPUT_MAX)
            Augmentation.augments(
                {
                    GuffinRun.aug[0]: 0.66,
                    GuffinRun.aug[1]: 0.34
                },
                Misc.get_idle_cap(1) * 0.5,
            )
            TimeMachine.time_machine(coords.INPUT_MAX, magic=True)
            GuffinRun.__update_gamestate()

        Misc.reclaim_tm(energy=True, magic=True)
        Misc.reclaim_aug()
        AdvancedTraining.advanced_training(1e12)
        Wandoos.set_wandoos(GuffinRun.wandoos_version)
        Wandoos.wandoos(True, True)
        Augmentation.augments({
            GuffinRun.aug[0]: 0.66,
            GuffinRun.aug[1]: 0.34
        },
                              Misc.get_idle_cap(1) * 0.5)
        TimeMachine.time_machine(Misc.get_idle_cap(1) * 0.1, magic=True)
        while GuffinRun.rb_time < GuffinRun.max_rb_duration - 140:
            GoldDiggers.gold_diggers(GuffinRun.diggers)
            FightBoss.nuke()
            Hacks.hacks(GuffinRun.hacks, coords.INPUT_MAX)
            GuffinRun.__do_quest()
            GuffinRun.__update_gamestate()

        FightBoss.fight()
        Adventure.adventure(itopodauto=True)
        MoneyPit.pit()
        Misc.save_check()
        while GuffinRun.rb_time < GuffinRun.max_rb_duration:
            time.sleep(1)
            GuffinRun.__update_gamestate()

        FightBoss.nuke()
        Rebirth.do_rebirth()
        # Must wait for game to fully redraw all elements after rebirthing
        time.sleep(1)
        GuffinRun.runs += 1
        print(
            f"Completed guffin run #{GuffinRun.runs} in {time.strftime('%H:%M:%S', time.gmtime(GuffinRun.rb_time))}"
        )
예제 #9
0
        print(f"doing itopod for {duration} seconds while waiting for adv training to activate")
        Adventure.itopod_snipe(duration)

    AdvancedTraining.advanced_training(2e12)
    GoldDiggers.gold_diggers()
    Misc.reclaim_bm()
    Wandoos.wandoos(True)
    NGU.assign_ngu(Misc.get_idle_cap(2), range(1, 11), False)
    NGU.assign_ngu(Misc.get_idle_cap(1), range(1, 9), True)

rt = Rebirth.get_rebirth_time()
rebirth_init(rt)

while True:
    rt = Rebirth.get_rebirth_time()
    FightBoss.nuke()
    GoldDiggers.gold_diggers()
    Inventory.merge_inventory(8)  # merge uneqipped guffs
    spells = BloodMagic.check_spells_ready()
    if spells:  # check if any spells are off CD
        NGU.reclaim_ngu(True)  # take all magic from magic NGUs
        for spell in spells:
            BloodMagic.cast_spell(spell)
        Misc.reclaim_bm()
        NGU.assign_ngu(Misc.get_idle_cap(1), range(1, 9), True)
        BloodMagic.toggle_auto_spells()  # retoggle autospells

    if rt.days > 0:  # rebirth is at >24 hours
        print(f"rebirthing at {rt}")  # debug
        FightBoss.nuke()
        MoneyPit.spin()
예제 #10
0
def speedrun(duration):
    """Start a speedrun.

    Keyword arguments
    duration -- duration in minutes to run
    f -- feature object
    """
    global current_boss, minutes_elapsed, advanced_training_locked, bm_locked, tm_locked

    diggers = [2, 3, 11, 12]
    adv_training_assigned = False
    Rebirth.do_rebirth()
    Wandoos.wandoos(True, True)
    FightBoss.nuke()
    time.sleep(2)
    FightBoss.fight()
    Adventure.adventure(highest=True)
    current_boss = 1
    minutes_elapsed = 0
    advanced_training_locked = True
    bm_locked = True
    tm_locked = True
    update_gamestate()

    while current_boss < 18 and minutes_elapsed < duration:  # augs unlocks after 17
        Wandoos.wandoos(True, True)
        Augmentation.augments({"SS": 1}, Misc.get_idle_cap(1))
        FightBoss.nuke()
        FightBoss.fight()
        if not advanced_training_locked and not adv_training_assigned:
            print("assigning adv")
            Misc.reclaim_aug()
            AdvancedTraining.advanced_training(4e11)
            Augmentation.augments({"SS": 1}, Misc.get_idle_cap(1))
            adv_training_assigned = True
        update_gamestate()
    Adventure.adventure(highest=True)

    while current_boss < 29 and minutes_elapsed < duration:  # buster unlocks after 28
        Wandoos.wandoos(True, True)
        FightBoss.nuke()
        FightBoss.fight()
        if not advanced_training_locked and not adv_training_assigned:
            print("assigning adv")
            Misc.reclaim_aug()
            AdvancedTraining.advanced_training(4e11)
            Augmentation.augments({"SS": 1}, Misc.get_idle_cap(1))
            adv_training_assigned = True
        update_gamestate()

    if minutes_elapsed < duration:  # only reclaim if we're not out of time
        Misc.reclaim_aug()

    while current_boss < 31 and minutes_elapsed < duration:  # TM unlocks after 31
        Augmentation.augments({"EB": 1}, Misc.get_idle_cap(1))
        Wandoos.wandoos(True, True)
        FightBoss.nuke()
        FightBoss.fight()
        if not advanced_training_locked and not adv_training_assigned:
            print("assigning adv")
            Misc.reclaim_aug()
            AdvancedTraining.advanced_training(4e11)
            Augmentation.augments({"EB": 1}, Misc.get_idle_cap(1))
            adv_training_assigned = True
        update_gamestate()

    if minutes_elapsed < duration:  # only reclaim if we're not out of time
        Misc.reclaim_aug()  # get some energy back for TM
        Misc.reclaim_res(magic=True)  # get all magic back from wandoos
        TimeMachine.time_machine(Misc.get_idle_cap(1) * 0.05, m=Misc.get_idle_cap(2) * 0.05)

    while current_boss < 38 and minutes_elapsed < duration:  # BM unlocks after 37
        GoldDiggers.gold_diggers(diggers)
        Augmentation.augments({"EB": 1}, Misc.get_idle_cap(1))
        Wandoos.wandoos(True, True)
        FightBoss.nuke()
        FightBoss.fight()
        if not advanced_training_locked and not adv_training_assigned:
            print("assigning adv")
            Misc.reclaim_aug()
            AdvancedTraining.advanced_training(4e11)
            Augmentation.augments({"EB": 1}, Misc.get_idle_cap(1))
            adv_training_assigned = True
        update_gamestate()

    if minutes_elapsed < duration:
        BloodMagic.blood_magic(8)
        BloodMagic.toggle_auto_spells(drop=False)
        time.sleep(10)
        print("waiting 10 seconds for gold ritual")
        BloodMagic.toggle_auto_spells(drop=False, gold=False)

    while current_boss < 49 and minutes_elapsed < duration:
        GoldDiggers.gold_diggers(diggers)
        Wandoos.wandoos(True, True)
        Augmentation.augments({"EB": 1}, Misc.get_idle_cap(1))
        FightBoss.nuke()
        FightBoss.fight()
        if not advanced_training_locked and not adv_training_assigned:
            print("assigning adv")
            Misc.reclaim_aug()
            AdvancedTraining.advanced_training(4e11)
            Augmentation.augments({"EB": 1}, Misc.get_idle_cap(1))
            adv_training_assigned = True
        update_gamestate()
    if minutes_elapsed < duration:  # only reclaim if we're not out of time
        Misc.reclaim_aug()

    while minutes_elapsed < duration:
        Augmentation.augments({"EB": 0.66, "CS": 0.34}, Misc.get_idle_cap(1))
        GoldDiggers.gold_diggers(diggers)
        Wandoos.wandoos(True, True)
        FightBoss.nuke()
        FightBoss.fight()
        if not advanced_training_locked and not adv_training_assigned:
            print("assigning adv")
            Misc.reclaim_aug()
            AdvancedTraining.advanced_training(4e11)
            Augmentation.augments({"EB": 0.66, "CS": 0.34}, Misc.get_idle_cap(1))
            adv_training_assigned = True
        update_gamestate()
        if not Rebirth.check_challenge() and minutes_elapsed >= 3:
            return
 
    return
예제 #11
0
    def speedrun(duration):
        """Start a speedrun.

        Keyword arguments
        duration -- duration in minutes to run
        f -- feature object
        """
        Rebirth.do_rebirth()
        FightBoss.nuke()
        time.sleep(2)
        Adventure.adventure(highest=True)

        try:
            current_boss = int(FightBoss.get_current_boss())
            if current_boss > 28 and current_boss < 49:
                Augmentation.augments({"EB": 1}, Misc.get_idle_cap(1))
            elif current_boss >= 49:
                Augmentation.augments({
                    "EB": 0.66,
                    "CS": 0.34
                }, Misc.get_idle_cap(1))
        except ValueError:
            print("couldn't get current boss")

        while Inputs.check_pixel_color(*coords.COLOR_TM_LOCKED):
            FightBoss.nuke()
            FightBoss.fight()
            Wandoos.wandoos(True)

        while Inputs.check_pixel_color(*coords.COLOR_BM_LOCKED):
            Wandoos.wandoos(True)
            FightBoss.nuke()
            time.sleep(2)
            FightBoss.fight()

        BloodMagic.blood_magic(8)
        Wandoos.wandoos(True)
        rb_time = Rebirth.get_rebirth_time()
        while int(rb_time.timestamp.tm_min) < duration:
            FightBoss.nuke()
            FightBoss.fight()
            Adventure.adventure(highest=True)
            Wandoos.wandoos(True)
            if Wandoos.check_wandoos_bb_status():
                Augmentation.augments({
                    "EB": 0.66,
                    "CS": 0.34
                }, Misc.get_idle_cap(1))
            """If current rebirth is scheduled for more than 3 minutes and
            we already finished the rebirth, we will return here, instead
            of waiting for the duration. Since we cannot start a new
            challenge if less than 3 minutes have passed, we must always
            wait at least 3 minutes."""
            rb_time = Rebirth.get_rebirth_time()
            if duration > 3:
                if not Rebirth.check_challenge():
                    while int(rb_time.timestamp.tm_min) < 3:
                        rb_time = Rebirth.get_rebirth_time()
                        time.sleep(1)
                    MoneyPit.pit()
                    MoneyPit.spin()
                    return

        MoneyPit.pit()
        MoneyPit.spin()
        return
예제 #12
0
    def first_rebirth():
        """Procedure for first rebirth."""
        final_aug = False
        ss_assigned = False

        end = time.time() + 3 * 60

        FightBoss.nuke()
        time.sleep(2)

        FightBoss.fight()
        Adventure.adventure(highest=True)
        while Inputs.check_pixel_color(*coords.COLOR_TM_LOCKED):
            if not ss_assigned:
                time.sleep(1)
                Augmentation.augments({"SS": 1}, 3e12)
                ss_assigned = True
            Wandoos.wandoos(True)
            FightBoss.nuke()
            time.sleep(2)
            FightBoss.fight()

        TimeMachine.time_machine(1e9, magic=True)
        Augmentation.augments({"DS": 1}, 1e12)
        GoldDiggers.gold_diggers()
        Adventure.adventure(itopod=True, itopodauto=True)

        while Inputs.check_pixel_color(
                *coords.COLOR_BM_LOCKED) or Inputs.check_pixel_color(
                    *coords.COLOR_BM_LOCKED_ALT):
            Wandoos.wandoos(True)
            FightBoss.nuke()
            time.sleep(2)
            FightBoss.fight()
            GoldDiggers.gold_diggers()
        BloodMagic.blood_magic(8)
        BloodMagic.toggle_auto_spells(drop=False, number=False)
        while time.time() < end - 90:
            Wandoos.wandoos(True)
            FightBoss.nuke()
            time.sleep(2)
            try:
                current_boss = int(FightBoss.get_current_boss())
                if current_boss > 36:
                    Augmentation.augments({
                        "SS": 0.67,
                        "DS": 0.33
                    }, Misc.get_idle_cap(1))
            except ValueError:
                print("couldn't get current boss")
            GoldDiggers.gold_diggers()

        while True:
            Wandoos.wandoos(True)
            FightBoss.nuke()
            time.sleep(1)
            try:
                current_boss = int(FightBoss.get_current_boss())
                if current_boss > 45:
                    if not final_aug:
                        Misc.reclaim_aug()
                        final_aug = True
                    Augmentation.augments({
                        "SM": 0.67,
                        "AA": 0.33
                    }, Misc.get_idle_cap(1))
            except ValueError:
                print("couldn't get current boss")
            FightBoss.fight()
            GoldDiggers.gold_diggers()

            if time.time() > end and not RB.check_challenge():
                return