public static async Task <CoroutineResult> UpgradeGems()
{
if (AdvDia.RiftQuest.Step != RiftStep.UrshiSpawned)
{
return(CoroutineResult.NoAction);
}
CoroutineResult previousResult;
if ((previousResult = await EnsureInRift()) == CoroutineResult.Running)
{
return(CoroutineResult.Running);
}
if (previousResult == CoroutineResult.Failed)
{
return(CoroutineResult.Failed);
}
ACDItem gemToUpgrade = PluginSettings.Current.Gems.GetUpgradeTarget();
if (gemToUpgrade == null)
{
return(CoroutineResult.NoAction);
}
return(await CommonCoroutines.AttemptUpgradeGem(gemToUpgrade));
}
private async Task <bool> UpgradingGems()
{
if (RiftData.VendorDialog.IsVisible && RiftData.ContinueButton.IsVisible && RiftData.ContinueButton.IsEnabled)
{
Logger.Debug("[Rift] Clicking to Continue button.");
RiftData.ContinueButton.Click();
RiftData.VendorCloseButton.Click();
await Coroutine.Sleep(2000);
return(false);
}
var gemToUpgrade = GetUpgradeTarget(_enableGemUpgradeLogs);
if (gemToUpgrade == null)
{
Logger.Info("[Rift] I couldn't find any gems to upgrade, failing.");
State = States.Failed;
return(false);
}
_enableGemUpgradeLogs = false;
if (AdvDia.RiftQuest.Step == RiftStep.Cleared)
{
Logger.Debug("[Rift] Rift Quest is completed, returning to town");
State = States.Completed;
return(false);
}
Logger.Debug("[Rift] Gem upgrades left before the attempt: {0}", ZetaDia.Me.JewelUpgradesLeft);
if (!await CommonCoroutines.AttemptUpgradeGem(gemToUpgrade))
{
Logger.Debug("[Rift] Gem upgrades left after the attempt: {0}", ZetaDia.Me.JewelUpgradesLeft);
return(false);
}
var gemUpgradesLeft = ZetaDia.Me.JewelUpgradesLeft;
if (_gemUpgradesLeft != gemUpgradesLeft)
{
_gemUpgradesLeft = gemUpgradesLeft;
_enableGemUpgradeLogs = true;
}
if (gemUpgradesLeft == 0)
{
//TODO add await here by andrew
await Coroutine.Sleep(8000);
Logger.Debug("[Rift] Finished all upgrades, returning to town.");
State = States.Completed;
return(false);
}
return(false);
}
private async Task <bool> BehaviorRoutine()
{
//Refresh Active Quests and Check that we are still in the reward step..
FunkyGame.Bounty.RefreshActiveQuests();
if (!FunkyGame.Bounty.ActiveQuests.ContainsKey(337492) || FunkyGame.Bounty.ActiveQuests[337492].Step != 34)
{
Logger.DBLog.Info("Active Quest no longer valid for reward!");
m_IsDone = true;
return(true);
}
//Check if the rift key upgrade continue button is visible
if (UI.ValidateUIElement(UI.Game.RiftReward_UpgradeKey_ContinueButton))
{
UI.Game.RiftReward_UpgradeKey_ContinueButton.Click();
await Coroutine.Sleep(250);
await Coroutine.Yield();
}
if (!delayer.Test(5))
{
await Coroutine.Sleep(250);
await Coroutine.Yield();
}
//Check if the NPC dialog is still valid
if (!UI.ValidateUIElement(UI.Game.SalvageMainPage))
{
Logger.DBLog.Info("Rift Reward Dialog not valid.");
m_IsDone = true;
return(true);
}
//Upgrading Gems?
if (UI.Game.RiftReward_gemUpgradePane_UpgradeButton.IsVisible)
{
if (!delayer.Test(10))
{
await Coroutine.Sleep(250);
await Coroutine.Yield();
}
Logger.DBLog.Info("Upgrading Gems..");
//Update our variables (UIElements of gems, number of gems, and the gem ACDItems)
if (SelectableGems.Count == 0)
{
GRiftLevel = GetTieredLootLevel();
SelectableUIGemElements = GetGemUIElements();
int totalGemUIElements = SelectableUIGemElements.Count;
SelectableUIGemElementIndexs = GetGemACDGuids(totalGemUIElements);
SelectableGems = GetGemCacheACDItems(SelectableUIGemElementIndexs).OrderByDescending(i => i.LegendaryGemRank).ToList();
Logger.DBLog.DebugFormat("Total number of possible gems to upgrade {0}", SelectableGems.Count);
double minSucessChance = FunkyBaseExtension.Settings.AdventureMode.GemUpgradingMinimumSuccessRate;
if (FunkyBaseExtension.Settings.AdventureMode.GemUpgradeType == SettingAdventureMode.GemUpgradingType.HighestRank)
{
if (SelectableGems.Any(i => ItemFunc.GetLegendaryGemUpgradeChance(GRiftLevel, i.LegendaryGemRank) >= minSucessChance))
{
SelectableGems = SelectableGems.Where(i => ItemFunc.GetLegendaryGemUpgradeChance(GRiftLevel, i.LegendaryGemRank) >= minSucessChance).OrderByDescending(i => i.LegendaryGemRank).ToList();
}
else
{
SelectableGems = SelectableGems.OrderByDescending(i => i.LegendaryGemRank).ToList();
}
}
else if (FunkyBaseExtension.Settings.AdventureMode.GemUpgradeType == SettingAdventureMode.GemUpgradingType.LowestRank)
{
if (SelectableGems.Any(i => ItemFunc.GetLegendaryGemUpgradeChance(GRiftLevel, i.LegendaryGemRank) >= minSucessChance))
{
SelectableGems = SelectableGems.Where(i => ItemFunc.GetLegendaryGemUpgradeChance(GRiftLevel, i.LegendaryGemRank) >= minSucessChance).OrderBy(i => i.LegendaryGemRank).ToList();
}
else
{
SelectableGems = SelectableGems.OrderBy(i => i.LegendaryGemRank).ToList();
}
}
else if (FunkyBaseExtension.Settings.AdventureMode.GemUpgradeType == SettingAdventureMode.GemUpgradingType.Priority && FunkyBaseExtension.Settings.AdventureMode.GemUpgradePriorityList.Count > 0)
{
if (SelectableGems.Any(i => FunkyBaseExtension.Settings.AdventureMode.GemUpgradePriorityList.Contains(i.LegendaryGemType) && ItemFunc.GetLegendaryGemUpgradeChance(GRiftLevel, i.LegendaryGemRank) >= minSucessChance))
{
//Select only Prioritized Gems
SelectableGems = SelectableGems.Where(i => FunkyBaseExtension.Settings.AdventureMode.GemUpgradePriorityList.Contains(i.LegendaryGemType) && ItemFunc.GetLegendaryGemUpgradeChance(GRiftLevel, i.LegendaryGemRank) >= minSucessChance).ToList();
//Create new list with priority order
List <CacheACDItem> PrioritizedList = new List <CacheACDItem>();
for (int i = 0; i < FunkyBaseExtension.Settings.AdventureMode.GemUpgradePriorityList.Count - 1; i++)
{
var LegenadryEnumValue = FunkyBaseExtension.Settings.AdventureMode.GemUpgradePriorityList[i];
if (SelectableGems.Any(item => item.LegendaryGemType == LegenadryEnumValue && ItemFunc.GetLegendaryGemUpgradeChance(GRiftLevel, item.LegendaryGemRank) >= minSucessChance))
{
var acditem = SelectableGems.First(item => item.LegendaryGemType == LegenadryEnumValue && ItemFunc.GetLegendaryGemUpgradeChance(GRiftLevel, item.LegendaryGemRank) >= minSucessChance);
PrioritizedList.Add(acditem);
}
}
if (PrioritizedList.Count > 0)
{
SelectableGems = PrioritizedList;
}
}
}
else
{
if (SelectableGems.Any(i => ItemFunc.GetLegendaryGemUpgradeChance(GRiftLevel, i.LegendaryGemRank) >= minSucessChance))
{
SelectableGems = SelectableGems.Where(i => ItemFunc.GetLegendaryGemUpgradeChance(GRiftLevel, i.LegendaryGemRank) >= minSucessChance).ToList();
}
}
Logger.DBLog.InfoFormat("Number of Gems capable of upgrading {0}", SelectableGems.Count);
foreach (var gem in SelectableGems)
{
double successChance = ItemFunc.GetLegendaryGemUpgradeChance(GRiftLevel, gem.LegendaryGemRank);
Logger.DBLog.DebugFormat("Upgrade Capable Gem {0} with Chance {1}%", gem.LegendaryGemType, (successChance * 100).ToString());
}
}
//Check if the upgrade button is enabled.. if not we select our gem!
if (!UI.Game.RiftReward_gemUpgradePane_UpgradeButton.IsEnabled)
{
//Set our default upgrade to our highest ranked (thats not 0%)
var upgradingGem = SelectableGems.FirstOrDefault();
int selectIndex = SelectableUIGemElementIndexs.IndexOf(upgradingGem.ACDGUID);
string GemName = upgradingGem.ThisRealName +
" Rank " + upgradingGem.LegendaryGemRank +
" Chance " + ItemFunc.GetLegendaryGemUpgradeChance(GRiftLevel, upgradingGem.LegendaryGemRank);
Logger.DBLog.InfoFormat("Upgrading Gem {0}", GemName);
//Select the Gem UIElement
UI.Game.RiftReward_gemUpgradePane_List.ItemsListSetSelectedItemByIndex(selectIndex);
await Coroutine.Sleep(250);
await Coroutine.Yield();
}
else
{
UI.Game.RiftReward_gemUpgradePane_UpgradeButton.Click();
await Coroutine.Sleep(250);
await Coroutine.Yield();
}
}
else
{
Logger.DBLog.Info("Reward Selection..");
//Click continue after selecting a reward (not used currently)
if (UI.ValidateUIElement(UI.Game.RiftReward_UpgradeContinue))
{
UI.Game.RiftReward_UpgradeContinue.Click();
await Coroutine.Sleep(250);
await Coroutine.Yield();
}
//Validate that upgrade key is enabled.. then attempt to upgrade!
if (Reward == RewardType.Key && UI.Game.RiftReward_Choice_UpgradeKey.IsEnabled && ZetaDia.Me.AttemptUpgradeKeystone())
{
Logger.DBLog.Info("Keystone Upgraded");
UIManager.CloseAllOpenFrames();
await Coroutine.Sleep(250);
await Coroutine.Yield();
}
else
{
//Doing Gem Upgrade..
GRiftLevel = GetTieredLootLevel();
var Gems = GetGemCacheACDItems().OrderByDescending(i => i.LegendaryGemRank).ToList();
if (Gems.Count > 0)
{
//Logger.DBLog.InfoFormat("Upgrading Gem {0}", Gems[0].ThisRealName);
await CommonCoroutines.AttemptUpgradeGem(Gems[0].ACDItem);
await Coroutine.Sleep(250);
await Coroutine.Yield();
}
else
{
Reward = RewardType.Key;
await Coroutine.Sleep(250);
await Coroutine.Yield();
}
}
}
return(true);
}
private async Task <bool> UpgradeGemsTask(bool force = false)
{
if (VendorDialog.IsVisible && (GameUI.IsElementVisible(UpgradeGemButton) && UpgradeGemButton.IsEnabled) || GameUI.IsElementVisible(UpgradeButton))
{
bool hasUpgradeableGems = ZetaDia.Actors.GetActorsOfType <ACDItem>()
.Where(item => item.ItemType == ItemType.LegendaryGem).Any(item => GetUpgradeChance(item) > 0.00f);
if (!hasUpgradeableGems)
{
Logger.Error("No valid gems found to upgrade! Leaving game...");
await CommonCoroutines.UseTownPortal("Unable to upgrade gem - leaving game");
await Coroutine.Sleep(100);
await Coroutine.Yield();
await CommonCoroutines.LeaveGame("Unable to upgrade gem");
_isDone = true;
await Coroutine.Sleep(100);
await Coroutine.Yield();
return(true);
}
float minimumGemChance = force ? 0f : QuestToolsSettings.Instance.MinimumGemChance;
List <ACDItem> gems = ZetaDia.Actors.GetActorsOfType <ACDItem>()
.Where(item => item.ItemType == ItemType.LegendaryGem && GetUpgradeChance(item) > 0.00f && GetUpgradeChance(item) >= minimumGemChance)
.OrderByDescending(item => GetUpgradeChance(item))
.ThenByDescending(item => item.JewelRank).ToList();
if (gems.Count == 0 && !_isGemsOnly) //No gems that can be upgraded - upgrade keystone
{
return(false);
}
if (gems.Count == 0 && _isGemsOnly)
{
gems = ZetaDia.Actors.GetActorsOfType <ACDItem>()
.Where(item => item.ItemType == ItemType.LegendaryGem)
.Where(item => !IsMaxLevelGem(item) && GetUpgradeChance(item) > 0.00f)
.OrderByDescending(item => GetUpgradeChance(item))
.ThenByDescending(item => item.JewelRank).ToList();
}
_isGemsOnly = true;
int selectedGemId = int.MaxValue;
string selectedGemPreference = "";
foreach (string gemName in QuestToolsSettings.Instance.GemPriority)
{
selectedGemId = DataDictionary.LegendaryGems.FirstOrDefault(kv => kv.Value == gemName).Key;
// Map to known gem type or dynamic priority
if (selectedGemId == int.MaxValue)
{
Logger.Error("Invalid Gem Name: {0}", gemName);
continue;
}
// Equipped Gems
if (selectedGemId == 0)
{
selectedGemPreference = gemName;
if (gems.Any(IsGemEquipped))
{
gems = gems.Where(item => item.InventorySlot == InventorySlot.Socket).ToList();
break;
}
}
// Lowest Rank
if (selectedGemId == 1)
{
selectedGemPreference = gemName;
gems = gems.OrderBy(item => item.JewelRank).ToList();
break;
}
// Highest Rank
if (selectedGemId == 2)
{
selectedGemPreference = gemName;
gems = gems.OrderByDescending(item => item.JewelRank).ToList();
break;
}
// Selected gem
if (gems.Any(i => i.ActorSNO == selectedGemId))
{
selectedGemPreference = gemName;
if (gems.Any(i => i.ActorSNO == selectedGemId))
{
gems = gems.Where(i => i.ActorSNO == selectedGemId).Take(1).ToList();
break;
}
}
// No gem found... skip!
}
if (selectedGemId < 10)
{
Logger.Log("Using gem priority of {0}", selectedGemPreference);
}
var bestGem = gems.FirstOrDefault();
if (bestGem != null && await CommonCoroutines.AttemptUpgradeGem(bestGem))
{
await Coroutine.Sleep(250);
GameUI.SafeClickElement(VendorCloseButton, "Vendor Window Close Button");
await Coroutine.Yield();
return(true);
}
else
{
/*
* Demonbuddy MAY randomly fail to upgrade the selected gem. This is a workaround, in case we get stuck...
*/
var randomGems = ZetaDia.Actors.GetActorsOfType <ACDItem>()
.Where(item => item.ItemType == ItemType.LegendaryGem)
.OrderBy(item => item.JewelRank).ToList();
Random random = new Random(DateTime.UtcNow.Millisecond);
int i = random.Next(0, randomGems.Count - 1);
var randomGem = randomGems.ElementAtOrDefault(i);
if (randomGem == null)
{
Logger.Error("Error: No gems found");
return(false);
}
Logger.Error("Gem Upgrade failed! Upgrading random Gem {0} ({1}) - {2:##.##}% {3} ", randomGem.Name, randomGem.JewelRank, GetUpgradeChance(randomGem) * 100, IsGemEquipped(randomGem) ? "Equipped" : string.Empty);
if (!await CommonCoroutines.AttemptUpgradeGem(randomGem))
{
Logger.Error("Random gem upgrade also failed. Something... seriously... wrong... ");
}
return(true);
}
}
return(false);
}