private bool CanUseFlaskAsInstant(ExtensionParameter extensionParameter, PlayerFlask playerFlask)
{
// If the flask is instant, no special logic needed
return(playerFlask.InstantType == FlaskInstantType.Partial ||
playerFlask.InstantType == FlaskInstantType.Full ||
playerFlask.InstantType == FlaskInstantType.LowLife && extensionParameter.Plugin.PlayerHelper.isHealthBelowPercentage(35));
}
private bool MissingFlaskBuff(ExtensionParameter extensionParameter, PlayerFlask playerFlask)
{
return(!extensionParameter.Plugin.PlayerHelper.playerHasBuffs(new List <string> {
playerFlask.BuffString1
}) || !extensionParameter.Plugin.PlayerHelper.playerHasBuffs(new List <string> {
playerFlask.BuffString2
}));
}
private bool CanUseFlaskAsInstant(PlayerFlask playerFlask)
{
// If the flask is instant, no special logic needed
return(playerFlask.InstantType == FlaskInstantType.Partial ||
playerFlask.InstantType == FlaskInstantType.Full ||
(playerFlask.InstantType == FlaskInstantType.LowLife && (PlayerHelper.isHealthBelowPercentage(50) ||
Settings.AllocatedSupremeDecadence && IsReallyLowLife())));
}
private bool MissingFlaskBuff(PlayerFlask playerFlask)
{
return(!PlayerHelper.playerHasBuffs(new List <string> {
playerFlask.BuffString1
}) || !PlayerHelper.playerHasBuffs(new List <string> {
playerFlask.BuffString2
}));
}
public Boolean canUsePotion(PlayerFlask flask, int reservedUses = 0, bool ignoreActionType = false)
{
if (flask == null)
{
if (Core.Settings.Debug)
{
Core.Log(Core.PluginName + ": Cannot use a null flask.", 1);
}
return(false);
}
if (flask.TotalUses - reservedUses <= 0)
{
if (Core.Settings.Debug)
{
Core.Log(Core.PluginName + ": Don't have enough uses on flask " + flask.Name + " to use.", 1);
}
return(false);
}
if (ignoreActionType)
{
return(true);
}
if (flask.Action1 == FlaskActions.Life && !Core.PlayerHelper.isHealthBelowPercentage(99))
{
if (Core.Settings.Debug)
{
Core.Log(Core.PluginName + ": Can't use life flask " + flask.Name + " at full health.", 1);
}
return(false);
}
if (flask.Action1 == FlaskActions.Mana && !Core.PlayerHelper.isManaBelowPercentage(99))
{
if (Core.Settings.Debug)
{
Core.Log(Core.PluginName + ": Can't use mana flask " + flask.Name + " at full mana.", 1);
}
return(false);
}
if (flask.Action1 == FlaskActions.Hybrid && !(Core.PlayerHelper.isHealthBelowPercentage(99) || Core.PlayerHelper.isManaBelowPercentage(99)))
{
if (Core.Settings.Debug)
{
Core.Log(Core.PluginName + ": Can't use hybrid " + flask.Name + " at full health and mana.", 1);
}
return(false);
}
return(true);
}
public Boolean canUsePotion(int flaskIndex, int reservedUses = 0, bool ignoreActionType = false)
{
PlayerFlask flask = this.getFlaskInfo(flaskIndex);
if (flask == null)
{
if (Core.Settings.Debug)
{
Core.Log($"{Core.PluginName}: Cannot use a null flask in slot {flaskIndex}.", 1);
}
return(false);
}
return(canUsePotion(flask, reservedUses, ignoreActionType));
}
private bool CanUseFlaskAsRegen(PlayerFlask playerFlask)
{
return(playerFlask.InstantType == FlaskInstantType.None ||
playerFlask.InstantType == FlaskInstantType.Partial ||
playerFlask.InstantType == FlaskInstantType.LowLife);
}
private bool FlaskMatchesInstant(ExtensionParameter extensionParameter, PlayerFlask playerFlask, Boolean?instant)
{
return(instant == null ||
instant == false && CanUseFlaskAsRegen(playerFlask) ||
instant == true && CanUseFlaskAsInstant(extensionParameter, playerFlask));
}
private bool flaskHasAvailableAction(List <FlaskActions> flaskActions, List <FlaskActions> ignoreFlaskActions, PlayerFlask flask)
{
return(flaskActions.Any(x => x == flask.Action1 || x == flask.Action2) &&
(ignoreFlaskActions == null || !ignoreFlaskActions.Any(x => x == flask.Action1 || x == flask.Action2)));
}
private bool CanUseFlaskAsRegen(PlayerFlask playerFlask)
{
return(playerFlask.InstantType == FlaskInstantType.None ||
playerFlask.InstantType == FlaskInstantType.Partial && !Settings.ForceBubblingAsInstantOnly ||
playerFlask.InstantType == FlaskInstantType.LowLife && !Settings.ForcePanickedAsInstantOnly);
}
private bool FlaskMatchesInstant(PlayerFlask playerFlask, Boolean?instant)
{
return(instant == null ||
instant == false && CanUseFlaskAsRegen(playerFlask) ||
instant == true && CanUseFlaskAsInstant(playerFlask));
}
public PlayerFlask getFlaskInfo(int flaskIndex, Entity foundFlask = null)
{
if (Core.Cache.MiscBuffInfo == null)
{
Core.LogErr(Core.PluginName + ": Error: Misc Buff Info cache was never initialized. This method will not function properly.", Core.ErrmsgTime);
return(null);
}
Entity currentFlask = foundFlask ?? Core.GameController.Game.IngameState.ServerData.PlayerInventories.FirstOrDefault(x => x.Inventory.InventType == InventoryTypeE.Flasks)?.Inventory?.InventorySlotItems?.FirstOrDefault(x => x.PosX == flaskIndex)?.Item;
if (currentFlask == null || currentFlask.Address == 0x00)
{
if (Core.Settings.Debug)
{
Core.Log(Core.PluginName + ": No valid flask in slot " + flaskIndex, 5);
}
return(null);
}
PlayerFlask simplePlayerFlask = new PlayerFlask
{
Index = flaskIndex
};
if (currentFlask.Path == null || currentFlask.Path.Length == 0)
{
Core.LogErr(Core.PluginName + ": Ignoring Flask " + flaskIndex + " for an empty or null path.", 5);
return(null);
}
var baseItem = Core.GameController.Files.BaseItemTypes.Translate(currentFlask.Path);
if (baseItem == null)
{
Core.LogErr(Core.PluginName + ": Ignoring Flask " + flaskIndex + ". No base item was found! Path: " + currentFlask.Path, 5);
return(null);
}
simplePlayerFlask.Name = baseItem.BaseName;
Charges flaskChargesStruct = currentFlask.GetComponent <Charges>();
Mods flaskMods = currentFlask.GetComponent <Mods>();
var useCharge = calculateUseCharges(flaskChargesStruct.ChargesPerUse, flaskMods.ItemMods);
if (useCharge > 0)
{
simplePlayerFlask.TotalUses = flaskChargesStruct.NumCharges / useCharge;
}
//TreeRoutine.LogError("Flask: " + simplePlayerFlask.Name + "Num Charges: " + flaskChargesStruct.NumCharges + " Use Charges: " + useCharge + " Charges Per use: " + flaskChargesStruct.ChargesPerUse + " Total Uses: " + simplePlayerFlask.TotalUses, 5);
var flaskBaseName = currentFlask.GetComponent <PoeHUD.Poe.Components.Base>().Name;
String flaskBuffOut = null;
if (!Core.Cache.MiscBuffInfo.flaskNameToBuffConversion.TryGetValue(
flaskBaseName, out flaskBuffOut))
{
if (Core.Settings.Debug)
{
Core.LogErr(Core.PluginName + ": Cannot find Flask Buff for flask on slot " + (flaskIndex + 1) + " with base name: " + (flaskBaseName == null ? "NULL" : flaskBaseName), 5);
}
return(null);
}
simplePlayerFlask.BuffString1 = flaskBuffOut;
// For Hybrid Flask as it have two buffs.
if (!Core.Cache.MiscBuffInfo.flaskNameToBuffConversion2.TryGetValue(flaskBaseName, out flaskBuffOut))
{
simplePlayerFlask.BuffString2 = "";
}
else
{
simplePlayerFlask.BuffString2 = flaskBuffOut;
}
simplePlayerFlask.Mods = currentFlask.GetComponent <Mods>();
handleFlaskMods(simplePlayerFlask);
return(simplePlayerFlask);
}
private void handleFlaskMods(PlayerFlask flask)
{
FlaskActions flaskActionOut;
if (Core.Cache.FlaskInfo == null)
{
Core.LogErr(Core.PluginName + ": Error: Flask Info cache was never initialized. This method will not function properly.", Core.ErrmsgTime);
return;
}
//Checking flask action based on flask name type.
if (!Core.Cache.FlaskInfo.FlaskTypes.TryGetValue(flask.Name, out flaskActionOut))
{
Core.LogErr(Core.PluginName + ": Error: " + flask.Name + " name not found. Add to config/flaskinfo.json and report this error message.", Core.ErrmsgTime);
}
else
{
flask.Action1 = flaskActionOut;
}
//Checking for unique flasks.
if (flask.Mods.ItemRarity == ItemRarity.Unique)
{
flask.Name = flask.Mods.UniqueName;
//Enabling Unique flask action 2.
if (!Core.Cache.FlaskInfo.UniqueFlaskNames.TryGetValue(flask.Name, out flaskActionOut))
{
Core.LogErr(Core.PluginName + ": Error: " + flask.Name + " unique name not found. Add to config/flaskinfo.json and report this error message.", Core.ErrmsgTime);
}
else
{
flask.Action2 = flaskActionOut;
}
}
//Checking flask mods.
FlaskActions action2 = FlaskActions.Ignore;
foreach (var mod in flask.Mods.ItemMods)
{
if (mod.Name.ToLower().Contains("instant"))
{
if (mod.Name.Contains("FlaskPartialInstantRecovery"))
{
flask.InstantType = FlaskInstantType.Partial;
}
else if (mod.Name.Contains("FlaskInstantRecoveryOnLowLife"))
{
flask.InstantType = FlaskInstantType.LowLife;
}
else if (mod.Name.Contains("FlaskFullInstantRecovery"))
{
flask.InstantType = FlaskInstantType.Full;
}
}
// We have already decided action2 for unique flasks.
if (flask.Mods.ItemRarity == ItemRarity.Unique)
{
continue;
}
if (!Core.Cache.FlaskInfo.FlaskMods.TryGetValue(mod.Name, out action2))
{
Core.LogErr(Core.PluginName + ": Error: " + mod.Name + " mod not found. Is it unique flask? If not, report this error message.", Core.ErrmsgTime);
}
else if (action2 != FlaskActions.Ignore)
{
flask.Action2 = action2;
}
}
}
private bool GettingAllFlaskInfo(Element flaskRoot)
{
if (Settings.debugMode.Value)
{
LogMessage("Getting Inventory Flasks info.", logmsg_time);
}
playerFlaskList.Clear();
try
{
var flasksEquipped = flaskRoot.Children;
for (int j = 0; j < flasksEquipped.Count; j++)
{
InventoryItemIcon flask = flasksEquipped[j].AsObject <InventoryItemIcon>();
Entity flaskItem = flask.Item;
Charges flaskCharges = flaskItem.GetComponent <Charges>();
Mods flaskMods = flaskItem.GetComponent <Mods>();
PlayerFlask newFlask = new PlayerFlask();
newFlask.SetSettings(Settings);
newFlask.isInstant = false;
newFlask.Slot = flask.InventPosX;
newFlask.Item = flaskItem;
newFlask.MaxCharges = flaskCharges.ChargesMax;
newFlask.UseCharges = flaskCharges.ChargesPerUse;
newFlask.CurrentCharges = flaskCharges.NumCharges;
newFlask.flaskRarity = flaskMods.ItemRarity;
newFlask.FlaskName = GameController.Files.BaseItemTypes.Translate(flaskItem.Path).BaseName;
newFlask.FlaskAction2 = FlaskAction.NONE;
newFlask.FlaskAction1 = FlaskAction.NONE;
//Checking flask action based on flask name type.
if (!flaskInfo.FlaskTypes.TryGetValue(newFlask.FlaskName, out newFlask.FlaskAction1))
{
LogError("Error: " + newFlask.FlaskName + " name not found. Report this error message.", errmsg_time);
}
//Checking for unique flasks.
if (flaskMods.ItemRarity == ItemRarity.Unique)
{
newFlask.FlaskName = flaskMods.UniqueName;
if (Settings.uniqFlaskEnable.Value)
{
//Enabling Unique flask action 2.
if (!flaskInfo.UniqueFlaskNames.TryGetValue(newFlask.FlaskName, out newFlask.FlaskAction2))
{
LogError("Error: " + newFlask.FlaskName + " unique name not found. Report this error message.", errmsg_time);
}
}
else
{
//Disabling Unique Flask actions.
newFlask.FlaskAction1 = FlaskAction.NONE;
newFlask.FlaskAction2 = FlaskAction.NONE;
}
}
//Checking flask mods.
FlaskAction action2 = FlaskAction.NONE;
foreach (var mod in flaskMods.ItemMods)
{
if (mod.Name.ToLower().Contains("flaskchargesused"))
{
newFlask.UseCharges = (int)Math.Floor(newFlask.UseCharges + ((double)(newFlask.UseCharges) * mod.Value1 / 100));
}
if (mod.Name.ToLower().Contains("instant"))
{
newFlask.isInstant = true;
}
// We have already decided action2 for unique flasks.
if (flaskMods.ItemRarity == ItemRarity.Unique)
{
continue;
}
if (!flaskInfo.FlaskMods.TryGetValue(mod.Name, out action2))
{
LogError("Error: " + mod.Name + " mod not found. Is it unique flask? If not, report this error message.", errmsg_time);
}
else if (action2 != FlaskAction.IGNORE)
{
newFlask.FlaskAction2 = action2;
}
}
// Speedrun mod on mana/life flask wouldn't work when full mana/life is full respectively,
// So we will ignore speedrun mod from mana/life flask. Other mods
// on mana/life flasks will work.
if (newFlask.FlaskAction2 == FlaskAction.SPEEDRUN &&
(newFlask.FlaskAction1 == FlaskAction.LIFE ||
newFlask.FlaskAction1 == FlaskAction.MANA ||
newFlask.FlaskAction1 == FlaskAction.HYBRID))
{
newFlask.FlaskAction2 = FlaskAction.NONE;
if (_WarnFlaskSpeed)
{
LogError("Warning: Speed Run mod is ignored on mana/life/hybrid flasks. Use Alt Orbs on those flasks.", errmsg_time);
_WarnFlaskSpeed = false;
}
}
if (Settings.disableLifeSecUse.Value)
{
if (newFlask.FlaskAction1 == FlaskAction.LIFE || newFlask.FlaskAction1 == FlaskAction.HYBRID)
{
if (newFlask.FlaskAction2 == FlaskAction.OFFENSE || newFlask.FlaskAction2 == FlaskAction.DEFENSE)
{
newFlask.FlaskAction2 = FlaskAction.NONE;
}
}
}
if (Settings.treatOffenAsDef.Value)
{
if (newFlask.FlaskAction1 == FlaskAction.OFFENSE)
{
newFlask.FlaskAction1 = FlaskAction.DEFENSE;
}
if (newFlask.FlaskAction2 == FlaskAction.OFFENSE)
{
newFlask.FlaskAction2 = FlaskAction.DEFENSE;
}
}
newFlask.EnableDisableFlask();
playerFlaskList.Add(newFlask);
}
}
catch (Exception e)
{
if (Settings.debugMode.Value)
{
LogError("Warning: Error getting all flask Informations.", errmsg_time);
LogError(e.Message + e.StackTrace, errmsg_time);
}
playerFlaskList.Clear();
return(false);
}
playerFlaskList.Sort((x, y) => x.Slot.CompareTo(y.Slot));
return(true);
}
