Пример #1
0
        async Task <bool> MultiAccountLoopTask()
        {
            updateStatus("Kicking off dual account loop task");

            foreach (String character in EQScreen.GetAllPlayerNames())
            {
                Console.WriteLine("Found character " + character);
            }
            EQScreen.SetNextCharacter();

            DmgShieldLoopTask();
            //DruidLoopTask();
            RogueLoopTask();

            return(true);
        }
Пример #2
0
        async Task <bool> DruidLoopTask()
        {
            updateStatus("Kicking off druid loop");
            EQState     currentEQState     = EQState.GetCurrentEQState();
            PlayerState currentPlayerState = PlayerState.WAITING_TO_FOCUS;

            while (currentPlayerState != PlayerState.EXITING_CORE_GAMEPLAY_LOOP)
            {
                if (EQScreen.currentCharacterName != "Durdle")
                {
                    await Task.Delay(100);

                    continue;
                }
                await EQTask.FocusOnEQWindowTask();

                currentEQState = EQState.GetCurrentEQState();

                // always update EQState here?
                switch (currentPlayerState)
                {
                case PlayerState.WAITING_TO_FOCUS:
                    updateStatus("Focusing on EQ Window");
                    currentPlayerState = await ChangeStateBasedOnTaskResult(EQTask.FocusOnEQWindowTask(),
                                                                            PlayerState.FOCUSED_ON_EQ_WINDOW,
                                                                            PlayerState.EXITING_CORE_GAMEPLAY_LOOP);

                    break;

                case PlayerState.FOCUSED_ON_EQ_WINDOW:
                    updateStatus("Focused on EQ Window");
                    await EQTask.HideCorpsesTask();

                    currentPlayerState = PlayerState.CHECK_COMBAT_STATUS;
                    break;

                case PlayerState.CHECK_FARMING_TIME_LIMIT:
                    updateStatus("Checking farming time limit");
                    if (!CurrentTimeInsideDuration(lastFarmingLimitTime, FARMING_LIMIT_TIME_MILLIS))
                    {
                        lastFarmingLimitTime = DateTimeOffset.Now.ToUnixTimeMilliseconds();
                    }
                    currentPlayerState = PlayerState.CHECK_COMBAT_STATUS;
                    break;

                case PlayerState.CHECK_COMBAT_STATUS:
                    updateStatus("Checking combat status");
                    currentPlayerState = ChangeStateBasedOnBool(currentEQState.characterState == EQState.CharacterState.COMBAT,
                                                                PlayerState.PULL_WITH_NUKE,
                                                                PlayerState.WAITING_FOR_MANA);
                    break;

                case PlayerState.PULL_WITH_NUKE:
                    updateStatus("Pulling with Nuke");
                    await EQTask.PullWithSpellTask();

                    await EQTask.EnterCombatTask();

                    currentPlayerState = PlayerState.KILLING_TARGET_ASAP;
                    break;

                case PlayerState.KILLING_TARGET_ASAP:
                    updateStatus("Killing target ASAP");
                    currentPlayerState = await ChangeStateBasedOnTaskResult(EQTask.NukeTask(),
                                                                            PlayerState.ATTEMPT_TO_LOOT,
                                                                            PlayerState.KILLING_TARGET_ASAP);

                    break;

                case PlayerState.WAITING_FOR_MANA:
                    updateStatus("Resting for mana");
                    currentPlayerState = await ChangeStateBasedOnTaskResult(EQTask.RestUntilFullManaTask(),
                                                                            PlayerState.CASTING_BURNOUT_ON_PET,
                                                                            PlayerState.WAITING_FOR_MANA);

                    break;

                case PlayerState.CASTING_BURNOUT_ON_PET:
                    updateStatus("Casting skin like rock");
                    if (!CurrentTimeInsideDuration(lastSkinLikeRockCastTime, SKIN_LIKE_ROCK_MILLIS))
                    {
                        lastSkinLikeRockCastTime = DateTimeOffset.Now.ToUnixTimeMilliseconds();
                        await EQTask.ApplyPetBuffTask();

                        await EQTask.RestTask();
                    }
                    currentPlayerState = PlayerState.FINDING_SUITABLE_TARGET;
                    break;

                case PlayerState.FINDING_SUITABLE_TARGET:
                    updateStatus("Finding Suitable Target");
                    //bool foundTargetResult = await EQTask.FindNearestTargetTask(true);
                    bool foundTargetResult = await EQTask.FindAnyTargetWithMacroTask();

                    currentPlayerState = ChangeStateBasedOnBool(foundTargetResult,
                                                                PlayerState.PULL_WITH_NUKE,
                                                                PlayerState.CHECK_COMBAT_STATUS);
                    break;

                case PlayerState.ATTEMPT_TO_LOOT:
                    updateStatus("Attempting to loot");
                    await EQTask.ScoochForwardTask();

                    currentPlayerState = await ChangeStateBasedOnTaskResult(EQTask.LootTask(true),
                                                                            PlayerState.HIDE_CORPSES,
                                                                            PlayerState.HIDE_CORPSES);

                    break;

                case PlayerState.HIDE_CORPSES:
                    updateStatus("Hiding Corpses");
                    currentPlayerState = await ChangeStateBasedOnTaskResult(EQTask.HideCorpsesTask(),
                                                                            PlayerState.CHECK_FARMING_TIME_LIMIT,
                                                                            PlayerState.CHECK_FARMING_TIME_LIMIT);

                    break;
                }

                EQScreen.SetNextCharacter();
            }

            updateStatus("Exited Core Gameplay, attempting to camp");
            await EQTask.CampTask();

            EQScreen.SetNextCharacter();
            return(true);
        }
Пример #3
0
        async Task <bool> RogueLoopTask()
        {
            int creaturesPulled     = 0;
            int throwingDaggerStack = 0;

            lastFarmingLimitTime = DateTimeOffset.Now.ToUnixTimeMilliseconds();

            updateStatus("Kicking off rogue loop");
            EQState     currentEQState     = EQState.GetCurrentEQState();
            PlayerState currentPlayerState = PlayerState.WAITING_TO_FOCUS;

            while (currentPlayerState != PlayerState.EXITING_CORE_GAMEPLAY_LOOP)
            {
                if (EQScreen.currentCharacterName != "Trakklo")
                {
                    await Task.Delay(100);

                    continue;
                }
                await EQTask.FocusOnEQWindowTask();

                currentEQState = EQState.GetCurrentEQState();

                switch (currentPlayerState)
                {
                case PlayerState.WAITING_TO_FOCUS:
                    updateStatus("Focusing on EQ Window");
                    currentPlayerState = await ChangeStateBasedOnTaskResult(EQTask.FocusOnEQWindowTask(),
                                                                            PlayerState.FOCUSED_ON_EQ_WINDOW,
                                                                            PlayerState.EXITING_CORE_GAMEPLAY_LOOP);

                    break;

                case PlayerState.FOCUSED_ON_EQ_WINDOW:
                    updateStatus("Focused on EQ Window");
                    await EQTask.HideCorpsesTask();

                    currentPlayerState = PlayerState.CHECK_COMBAT_STATUS;
                    break;

                case PlayerState.CHECK_FARMING_TIME_LIMIT:
                    updateStatus("Checking farming time limit");
                    currentPlayerState = PlayerState.CHECK_COMBAT_STATUS;
                    if (!CurrentTimeInsideDuration(lastFarmingLimitTime, FARMING_LIMIT_TIME_MILLIS))
                    {
                        currentPlayerState = PlayerState.EXITING_CORE_GAMEPLAY_LOOP;
                    }

                    creaturesPulled++;
                    if (creaturesPulled % 30 == 0)
                    {
                        SlackHelper.SendSlackMessageAsync("Out of daggers, go refill");
                        currentPlayerState = PlayerState.EXITING_CORE_GAMEPLAY_LOOP;
                    }

                    break;

                case PlayerState.CHECK_COMBAT_STATUS:
                    updateStatus("Checking combat Status");
                    currentPlayerState = ChangeStateBasedOnBool(currentEQState.characterState == EQState.CharacterState.COMBAT,
                                                                PlayerState.PREPARED_FOR_BATTLE,
                                                                PlayerState.WAITING_FOR_MANA);
                    break;

                case PlayerState.PREPARED_FOR_BATTLE:
                    updateStatus("Killing target ASAP");
                    await EQTask.ScoochForwardTask();

                    await EQTask.PullWithThrowingWeaponTask();

                    await EQTask.EnterCombatTask();

                    await EQTask.EnterCombatTask();

                    await EQTask.EnterCombatTask();

                    currentPlayerState = PlayerState.KILLING_TARGET_ASAP;
                    break;

                case PlayerState.KILLING_TARGET_ASAP:
                    updateStatus("Killing target ASAP");
                    currentPlayerState = await ChangeStateBasedOnTaskResult(EQTask.LevelSkillUntilDeadTask(),
                                                                            PlayerState.ATTEMPT_TO_LOOT,
                                                                            PlayerState.KILLING_TARGET_ASAP);

                    break;

                case PlayerState.WAITING_FOR_MANA:
                    updateStatus("Resting until fuly healed");
                    await EQTask.RestUntilFullyHealedTask();

                    currentPlayerState = await ChangeStateBasedOnTaskResult(EQTask.RestUntilFullyHealedTask(),
                                                                            PlayerState.FINDING_SUITABLE_TARGET,
                                                                            PlayerState.WAITING_FOR_MANA);

                    break;
                    if (currentEQState.characterState == EQState.CharacterState.COMBAT)
                    {
                        SlackHelper.SendSlackMessageAsync("Attacked while resting, something's probably wrong.");
                        currentPlayerState = PlayerState.PREPARED_FOR_BATTLE;
                    }

                case PlayerState.FINDING_SUITABLE_TARGET:
                    updateStatus("Finding Suitable Target");
                    //bool foundTargetResult = await EQTask.FindNearestTargetTask(false);
                    bool foundTargetResult = await EQTask.FindAnyTargetWithMacroTask();

                    currentPlayerState = ChangeStateBasedOnBool(foundTargetResult,
                                                                PlayerState.PREPARED_FOR_BATTLE,
                                                                PlayerState.CHECK_COMBAT_STATUS);
                    break;

                case PlayerState.ATTEMPT_TO_LOOT:
                    updateStatus("Attempting to loot");
                    //await EQTask.ScoochForwardTask();
                    currentPlayerState = await ChangeStateBasedOnTaskResult(EQTask.LootTask(false),
                                                                            PlayerState.HIDE_CORPSES,
                                                                            PlayerState.HIDE_CORPSES);

                    break;

                case PlayerState.HIDE_CORPSES:
                    updateStatus("Hiding Corpses");
                    currentPlayerState = await ChangeStateBasedOnTaskResult(EQTask.HideCorpsesTask(),
                                                                            PlayerState.CHECK_FARMING_TIME_LIMIT,
                                                                            PlayerState.CHECK_FARMING_TIME_LIMIT);

                    break;
                }

                EQScreen.SetNextCharacter();
            }

            updateStatus("Exited Core Gameplay, attempting to camp");
            await EQTask.CampTask();

            EQScreen.SetNextCharacter();
            return(true);
        }
Пример #4
0
        async Task <bool> DmgShieldLoopTask()
        {
            updateStatus("Kicking off core gameplay loop");

            lastFarmingLimitTime = DateTimeOffset.Now.ToUnixTimeMilliseconds();

            EQState     currentEQState     = EQState.GetCurrentEQState();
            PlayerState currentPlayerState = PlayerState.WAITING_TO_FOCUS;

            while (currentPlayerState != PlayerState.EXITING_CORE_GAMEPLAY_LOOP)
            {
                if (EQScreen.currentCharacterName != "Yoyokazoo")
                {
                    await Task.Delay(100);

                    continue;
                }
                await EQTask.FocusOnEQWindowTask();

                currentEQState = EQState.GetCurrentEQState();

                // always update EQState here?
                switch (currentPlayerState)
                {
                case PlayerState.WAITING_TO_FOCUS:
                    updateStatus("Focusing on EQ Window");
                    currentPlayerState = await ChangeStateBasedOnTaskResult(EQTask.FocusOnEQWindowTask(),
                                                                            PlayerState.FOCUSED_ON_EQ_WINDOW,
                                                                            PlayerState.EXITING_CORE_GAMEPLAY_LOOP);

                    break;

                case PlayerState.FOCUSED_ON_EQ_WINDOW:
                    updateStatus("Focused on EQ Window");
                    await EQTask.HideCorpsesTask();

                    currentPlayerState = PlayerState.CHECK_FARMING_TIME_LIMIT;
                    break;

                case PlayerState.CHECK_FARMING_TIME_LIMIT:
                    updateStatus("Checking farming time limit");
                    currentPlayerState = PlayerState.WAITING_FOR_MANA;

                    if (!CurrentTimeInsideDuration(lastFarmingLimitTime, FARMING_LIMIT_TIME_MILLIS))
                    {
                        currentPlayerState = PlayerState.EXITING_CORE_GAMEPLAY_LOOP;
                    }
                    break;

                case PlayerState.WAITING_FOR_MANA:
                    updateStatus("Resting for mana");
                    currentPlayerState = await ChangeStateBasedOnTaskResult(EQTask.RestUntilFullManaTask(),
                                                                            PlayerState.CHECKING_FOR_PYZJN,
                                                                            PlayerState.WAITING_FOR_MANA);

                    break;

                case PlayerState.CHECKING_FOR_PYZJN:
                    updateStatus("Checking for Pyzjn");
                    currentPlayerState = await ChangeStateBasedOnTaskResult(EQTask.FindSpecificTarget(),
                                                                            PlayerState.KILLING_TARGET_ASAP,
                                                                            PlayerState.FINDING_SUITABLE_TARGET);

                    break;

                case PlayerState.KILLING_TARGET_ASAP:
                    updateStatus("Killing target ASAP");
                    SlackHelper.SendSlackMessageAsync("Killing Lockjaw, check for loot");
                    await EQTask.PetAttackTask();

                    await EQTask.NukeTask();

                    await EQTask.EnterCombatTask();

                    currentPlayerState = await ChangeStateBasedOnTaskResult(EQTask.NukeUntilDeadTask(),
                                                                            PlayerState.CHECK_FARMING_TIME_LIMIT,
                                                                            PlayerState.CHECK_FARMING_TIME_LIMIT);

                    break;

                case PlayerState.FINDING_SUITABLE_TARGET:
                    updateStatus("Finding Suitable Target");
                    bool foundTargetResult = await EQTask.FindAnyTargetWithMacroTask();

                    currentPlayerState = ChangeStateBasedOnBool(foundTargetResult,
                                                                PlayerState.CASTING_DMG_SHIELD_ON_PET,
                                                                PlayerState.CHECK_FARMING_TIME_LIMIT);
                    break;

                case PlayerState.CASTING_DMG_SHIELD_ON_PET:
                    updateStatus("Casting Damage Shield on target");
                    if (!CurrentTimeInsideDuration(lastDmgShieldCastTime, DMG_SHIELD_TIME_MILLIS))
                    {
                        lastDmgShieldCastTime = DateTimeOffset.Now.ToUnixTimeMilliseconds();
                        await EQTask.DamageShieldBotTask();
                    }
                    await Task.Delay(5000);

                    await EQTask.DeselectTargetTask();

                    currentPlayerState = PlayerState.CHECK_FARMING_TIME_LIMIT;
                    break;
                }

                EQScreen.SetNextCharacter();
            }

            updateStatus("Exited Core Gameplay, attempting to camp");
            await EQTask.CampTask();

            EQScreen.SetNextCharacter();
            return(true);
        }