/// <summary>
/// Called when user disable the plugin.
/// </summary>
public void OnDisabled()
{
_isPluginEnabled = false;
BotManager.ReplaceTreeHooks();
Navigator.PlayerMover = new DefaultPlayerMover();
Navigator.StuckHandler = new DefaultStuckHandler();
CombatTargeting.Instance.Provider = new DefaultCombatTargetingProvider();
LootTargeting.Instance.Provider = new DefaultLootTargetingProvider();
ObstacleTargeting.Instance.Provider = new DefaultObstacleTargetingProvider();
Navigator.SearchGridProvider = new MainGridProvider();
GameEvents.OnPlayerDied -= TrinityOnDeath;
BotMain.OnStop -= TrinityBotStop;
GameEvents.OnPlayerDied -= TrinityOnDeath;
GameEvents.OnGameJoined -= TrinityOnJoinGame;
GameEvents.OnGameLeft -= TrinityOnLeaveGame;
GameEvents.OnItemSold -= ItemEvents.TrinityOnItemSold;
GameEvents.OnItemSalvaged -= ItemEvents.TrinityOnItemSalvaged;
GameEvents.OnItemStashed -= ItemEvents.TrinityOnItemStashed;
GameEvents.OnItemIdentificationRequest -= ItemEvents.TrinityOnOnItemIdentificationRequest;
GameEvents.OnGameChanged -= GameEvents_OnGameChanged;
GameEvents.OnWorldChanged -= GameEvents_OnWorldChanged;
ItemManager.Current = new LootRuleItemManager();
Logger.Log(TrinityLogLevel.Info, LogCategory.UserInformation, "");
Logger.Log(TrinityLogLevel.Info, LogCategory.UserInformation, "DISABLED: Trinity is now shut down...");
Logger.Log(TrinityLogLevel.Info, LogCategory.UserInformation, "");
GenericCache.Shutdown();
GenericBlacklist.Shutdown();
}
internal static bool ShouldStashItem(CachedACDItem cItem)
{
if (cItem.AcdItem != null && cItem.AcdItem.IsValid)
{
bool result = false;
var item = new Item(cItem.AcdItem);
var wrappedItem = new ItemWrapper(cItem.AcdItem);
if (Trinity.Settings.Loot.ItemRank.AncientItemsOnly && wrappedItem.IsEquipment && !cItem.IsAncient)
{
result = false;
}
else if (Trinity.Settings.Loot.ItemRank.RequireSocketsOnJewelry && wrappedItem.IsJewelry && cItem.AcdItem.NumSockets != 0)
{
result = false;
}
else
{
result = ShouldStashItem(item);
}
string action = result ? "KEEP" : "TRASH";
Logger.Log(LogCategory.ItemValuation, "Ranked Item - {0} - {1}", action, item.Name);
return(result);
}
return(false);
}
/// <summary>
/// Searches for a skill matching some criteria
/// </summary>
/// <param name="typeName">name for the type of skill, used in logging</param>
/// <param name="condition">condition to be applied to skill list FirstOrDefault lamda</param>
/// <param name="skillCollection">colleciton of skills to search against, defaults to all Active skills</param>
/// <returns>a TrinityPower</returns>
internal static TrinityPower FindSkill(string typeName, Func <Skill, bool> condition, List <Skill> skillCollection = null)
{
Logger.Log(TrinityLogLevel.Verbose, LogCategory.SkillSelection, "Finding {0} Skill", typeName);
skillCollection = skillCollection ?? SkillUtils.Active;
if (condition == null)
{
return(null);
}
var skill = skillCollection.FirstOrDefault(condition);
if (skill == null)
{
return(null);
}
var power = GetTrinityPower(skill);
Logger.Log(TrinityLogLevel.Verbose, LogCategory.SkillSelection, " >> Selected {0} Skill: {1} ({2}) Target={3}",
typeName, power.SNOPower, (int)power.SNOPower, (CurrentTarget == null) ? "None" : CurrentTarget.InternalName);
return(power);
}
private static void CreateRadarWindow()
{
if (_radarWindow == null)
{
Logger.Log("Loading RadarUI");
var radarXamlPath = Path.Combine(FileManager.PluginPath, "UI", "RadarUI.xaml");
_radarWindow = new ThreadedWindow(radarXamlPath, _dataModel, "RadarUI", 600, 600);
_dataModel.PropertyChanged += (sender, args) =>
{
if (args.PropertyName == "IsRadarWindowVisible")
{
if (_dataModel.IsRadarWindowVisible)
{
_radarWindow.Show();
}
else
{
_radarWindow.Hide();
}
}
};
_radarWindow.OnHidden += () =>
{
_dataModel.IsRadarWindowVisible = false;
};
}
}
public static async Task <bool> TownRunCoroutineWrapper(Decorator original)
{
ModifyTownRun(original);
for (int i = 0; i < original.Children.Count; i++)
{
try
{
await original.Children[i].ExecuteCoroutine();
}
catch (Exception ex)
{
Logger.LogDebug("Exception in TownRunCoroutineWrapper {0}", ex);
}
}
if (!BrainBehavior.IsVendoring)
{
Logger.Log("TownRun complete");
Trinity.WantToTownRun = false;
Trinity.ForceVendorRunASAP = false;
TownRunCheckTimer.Reset();
SendEmailNotification();
SendMobileNotifications();
}
return(true);
}
public static void ResetEverythingNewGame()
{
// In-thread stuff
V.ValidateLoad();
// Out of thread Async stuff
BeginInvoke(new Action(() =>
{
Logger.Log("New Game - resetting everything");
Trinity.IsReadyToTownRun = false;
Trinity.ForceVendorRunASAP = false;
TownRun.TownRunCheckTimer.Reset();
TownRun.SendEmailNotification();
TownRun.PreTownRunPosition = Vector3.Zero;
TownRun.PreTownRunWorldId = -1;
TownRun.WasVendoring = false;
CacheData.AbilityLastUsed.Clear();
SpellHistory.HistoryQueue.Clear();
DeathsThisRun = 0;
LastDeathTime = DateTime.UtcNow;
_hashsetItemStatsLookedAt = new HashSet <string>();
_hashsetItemPicksLookedAt = new HashSet <string>();
_hashsetItemFollowersIgnored = new HashSet <string>();
Blacklist60Seconds = new HashSet <int>();
Blacklist90Seconds = new HashSet <int>();
Blacklist15Seconds = new HashSet <int>();
BacktrackList = new SortedList <int, Vector3>();
TotalBacktracks = 0;
HasMappedPlayerAbilities = false;
PlayerMover.TotalAntiStuckAttempts = 1;
PlayerMover.vSafeMovementLocation = Vector3.Zero;
PlayerMover.LastPosition = Vector3.Zero;
PlayerMover.TimesReachedStuckPoint = 0;
PlayerMover.TimeLastRecordedPosition = DateTime.MinValue;
PlayerMover.LastGeneratedStuckPosition = DateTime.MinValue;
PlayerMover.TimesReachedMaxUnstucks = 0;
PlayerMover.CancelUnstuckerForSeconds = 0;
PlayerMover.LastCancelledUnstucker = DateTime.MinValue;
NavHelper.UsedStuckSpots = new List <GridPoint>();
CacheData.FullClear();
// Reset all the caches
ProfileHistory = new List <string>();
CurrentProfile = "";
FirstProfile = "";
Logger.Log("New Game, resetting Gold Inactivity Timer");
GoldInactivity.Instance.ResetCheckGold();
CombatBase.IsQuestingMode = false;
GenericCache.ClearCache();
GenericBlacklist.ClearBlacklist();
}));
}
private static void PrintObjectProperties <T>(T item)
{
PropertyInfo[] properties = typeof(T).GetProperties(BindingFlags.Instance | BindingFlags.Public);
foreach (PropertyInfo property in properties.ToList().OrderBy(p => p.Name))
{
try
{
object val = property.GetValue(item, null);
if (val != null)
{
Logger.Log(typeof(T).Name + "." + property.Name + "=" + val);
// Special cases!
if (property.Name == "ValidInventorySlots")
{
foreach (var slot in ((InventorySlot[])val))
{
Logger.Log(slot.ToString());
}
}
}
}
catch
{
Logger.Log("Exception reading {0} from object", property.Name);
}
}
}
private static void Monk_TempestRushStatus(string trUse)
{
Logger.Log(TrinityLogLevel.Debug, LogCategory.Behavior, "{0}, xyz={4} spirit={1:0} cd={2} lastUse={3:0}",
trUse,
Trinity.Player.PrimaryResource, PowerManager.CanCast(SNOPower.Monk_TempestRush),
TimeSinceUse(SNOPower.Monk_TempestRush), CombatBase.ZigZagPosition);
}
private bool ItemRulesSalvageSell(ACDItem item, ItemEvaluationType evaluationType)
{
ItemEvents.ResetTownRun();
if (!item.IsPotion)
{
Logger.Log(TrinityLogLevel.Info, LogCategory.ItemValuation,
"Incoming {0} Request: {1}, {2}, {3}, {4}, {5}",
evaluationType, item.ItemQualityLevel, item.Level, item.ItemBaseType,
item.ItemType, item.IsOneHand ? "1H" : item.IsTwoHand ? "2H" : "NH");
}
Interpreter.InterpreterAction action = Trinity.StashRule.checkItem(item, ItemEvaluationType.Salvage);
switch (action)
{
case Interpreter.InterpreterAction.SALVAGE:
Logger.Log(TrinityLogLevel.Info, LogCategory.UserInformation, "{0}: {1}", evaluationType, (evaluationType == ItemEvaluationType.Salvage));
return(evaluationType == ItemEvaluationType.Salvage);
case Interpreter.InterpreterAction.SELL:
Logger.Log(TrinityLogLevel.Info, LogCategory.UserInformation, "{0}: {1}", evaluationType, (evaluationType == ItemEvaluationType.Sell));
return(evaluationType == ItemEvaluationType.Sell);
default:
Logger.Log(TrinityLogLevel.Info, LogCategory.ScriptRule, "Trinity, item is unhandled by ItemRules (SalvageSell)!");
switch (evaluationType)
{
case ItemEvaluationType.Salvage:
return(TrinitySalvage(item));
default:
return(TrinitySell(item));
}
}
}
public static void LogBuffs()
{
if (CacheData.Buffs != null && CacheData.Buffs.ActiveBuffs != null)
{
_lastBuffs.ForEach(b =>
{
if (CacheData.Buffs.ActiveBuffs.Any(o => o.Id + o.VariantId == b.Key))
{
return;
}
Logger.Log(LogCategory.ActiveBuffs, "Buff lost '{0}' ({1}) Stacks={2} VariantId={3} VariantName={4}", b.Value.InternalName, b.Value.Id, b.Value.StackCount, b.Value.VariantId, b.Value.VariantName);
});
CacheData.Buffs.ActiveBuffs.ForEach(b =>
{
CachedBuff lastBuff;
if (_lastBuffs.TryGetValue(b.Id + b.VariantId, out lastBuff))
{
if (b.StackCount != lastBuff.StackCount)
{
Logger.Log(LogCategory.ActiveBuffs, "Buff Stack Changed: '{0}' ({1}) Stacks={2}", b.InternalName, b.Id, b.StackCount);
}
}
else
{
Logger.Log(LogCategory.ActiveBuffs, "Buff Gained '{0}' ({1}) Stacks={2} VariantId={3} VariantName={4}", b.InternalName, b.Id, b.StackCount, b.VariantId, b.VariantName);
}
});
_lastBuffs = CacheData.Buffs.ActiveBuffs.DistinctBy(k => k.Id + k.VariantId).ToDictionary(k => k.Id + k.VariantId, v => v);
}
}
internal static void DumpReferenceItems(TrinityLogLevel level = TrinityLogLevel.Debug)
{
var path = Path.Combine(FileManager.DemonBuddyPath, "Resources\\JS Class Generator\\ItemReference.js");
if (File.Exists(path))
{
File.Delete(path);
}
using (StreamWriter w = File.AppendText(path))
{
w.WriteLine("var itemLookup = {");
foreach (var item in Legendary.ToList())
{
if (item.Id != 0)
{
w.WriteLine(string.Format(" \"{0}\": [\"{1}\", {2}, \"{3}\"],", item.Slug, item.Name, item.Id, item.InternalName));
}
}
w.WriteLine("}");
}
Logger.Log("Dumped Reference Items to: {0}", path);
}
internal static List <TrinityCacheObject> GetCacheObjectHotSpots()
{
List <TrinityCacheObject> list = new List <TrinityCacheObject>();
if (Trinity.Player.IsInTown)
{
return(list);
}
var hotSpotList = HotSpotList.Where(s =>
s.Location.Distance2D(Trinity.Player.Position) <= V.F("Cache.HotSpot.MaxDistance") &&
s.Location.Distance2D(Trinity.Player.Position) >= V.F("Cache.HotSpot.MinDistance") &&
s.WorldId == Trinity.Player.WorldID).ToList();
foreach (var hotSpot in hotSpotList)
{
Logger.Log(TrinityLogLevel.Debug, LogCategory.CacheManagement, "Adding HotSpot to Cache: {0}", hotSpot);
var o = new TrinityCacheObject()
{
Position = hotSpot.Location,
InternalName = "HotSpot",
Type = TrinityObjectType.HotSpot,
Distance = Trinity.Player.Position.Distance2D(hotSpot.Location),
Radius = HotSpot.MaxPositionDistance,
};
list.Add(o);
}
return(list);
}
public static async Task <bool> Execute(ItemQualityColor qualityColor, List <ItemType> types = null, int totalAmount = -1, int vendorId = -1)
{
Logger.Log("BuyItemsFromVendor Started!");
//if (ZetaDia.Me.Inventory.NumFreeBackpackSlots < totalAmount * 2)
//{
// Logger.Log("Not enough bag space to buy {0} items", totalAmount);
// await BrainBehavior.CreateVendorBehavior().ExecuteCoroutine();
//}
foreach (var item in ZetaDia.Me.Inventory.MerchantItems)
{
item.PrintEFlags();
}
var items = ZetaDia.Me.Inventory.MerchantItems.ToList();
var vendorLocation = Town.Locations.GetLocationFromActorId(vendorId);
if (!await MoveToAndInteract.Execute(vendorLocation, vendorId, 5f))
{
return(false);
}
Logger.Log("BuyItemsFromVendor Finished!");
return(true);
}
public static void CreateWindow()
{
if (_dataModel == null)
{
_dataModel = new CacheUIDataModel();
_dataModel.PropertyChanged += DataModelOnPropertyChanged;
Configuration.Events.OnCacheUpdated += Update;
}
if (_cacheWindow == null)
{
Logger.Log("Loading CacheUI");
var cacheXamlPath = Path.Combine(FileManager.PluginPath, "UI", "CacheUI.xaml");
_cacheWindow = new ThreadedWindow(cacheXamlPath, _dataModel, "CacheUI", 750, 1200);
}
_cacheWindow.Show();
CreateRadarWindow();
_internalTimer = new DispatcherTimer();
_internalTimer.Tick += InternalTimerTick;
_internalTimer.Interval = new TimeSpan(0, 0, 0, 0, 50);
_internalTimer.Start();
}
/// <summary>
/// Returns if we're trying to TownRun or if profile tag is UseTownPortalTag
/// </summary>
/// <returns></returns>
internal static bool IsTryingToTownPortal()
{
if (DateTime.UtcNow.Subtract(lastTownPortalCheckTime).TotalMilliseconds < Trinity.Settings.Advanced.CacheRefreshRate)
{
return(lastTownPortalCheckResult);
}
bool result = false;
if (Trinity.IsReadyToTownRun)
{
result = true;
}
if (Trinity.ForceVendorRunASAP)
{
result = true;
}
if (TownRunCheckTimer.IsRunning)
{
result = true;
}
ProfileBehavior CurrentProfileBehavior = null;
try
{
if (ProfileManager.CurrentProfileBehavior != null)
{
CurrentProfileBehavior = ProfileManager.CurrentProfileBehavior;
}
}
catch (Exception ex)
{
Logger.Log(LogCategory.UserInformation, "Exception while checking for TownPortal!");
Logger.Log(LogCategory.GlobalHandler, ex.ToString());
}
if (CurrentProfileBehavior != null)
{
Type profileBehaviortype = CurrentProfileBehavior.GetType();
string behaviorName = profileBehaviortype.Name;
if ((profileBehaviortype == typeof(UseTownPortalTag) ||
profileBehaviortype == typeof(WaitTimerTag) ||
behaviorName.ToLower().Contains("townrun") ||
behaviorName.ToLower().Contains("townportal")))
{
result = true;
}
}
if (BrainBehavior.IsVendoring)
{
result = true;
}
lastTownPortalCheckTime = DateTime.UtcNow;
lastTownPortalCheckResult = result;
return(result);
}
private static void ReplaceHookWithOriginal(string hook)
{
if (OriginalHooks.ContainsKey(hook))
{
Logger.Log("Replacing " + hook + " Hook with Original");
TreeHooks.Instance.ReplaceHook(hook, OriginalHooks[hook]);
}
}
public static void AddHotSpot(HotSpot hotSpot)
{
if (hotSpot.IsValid && !hotSpotList.Any(h => h.Equals(hotSpot)))
{
Logger.Log(TrinityLogLevel.Debug, LogCategory.CacheManagement, "Added HotSpot {0}", hotSpot);
hotSpotList.Add(hotSpot);
}
}
/// <summary>
/// Returns an appropriately selected TrinityPower and related information
/// </summary>
/// <returns></returns>
internal static TrinityPower AbilitySelector()
{
using (new PerformanceLogger("AbilitySelector"))
{
// See if archon just appeared/disappeared, so update the hotbar
if (Trinity.ShouldRefreshHotbarAbilities || Trinity.HotbarRefreshTimer.ElapsedMilliseconds > 5000)
{
PlayerInfoCache.RefreshHotbar();
}
// Switch based on the cached character class
TrinityPower power = CurrentPower;
using (new PerformanceLogger("AbilitySelector.ClassAbility"))
{
switch (Player.ActorClass)
{
// Barbs
case ActorClass.Barbarian:
power = BarbarianCombat.GetPower();
break;
case ActorClass.Crusader:
power = CrusaderCombat.GetPower();
break;
// Monks
//case ActorClass.Monk:
// power = GetMonkPower(IsCurrentlyAvoiding, UseOOCBuff, UseDestructiblePower);
// break;
//// Wizards
//case ActorClass.Wizard:
// power = GetWizardPower(IsCurrentlyAvoiding, UseOOCBuff, UseDestructiblePower);
// break;
//// Witch Doctors
//case ActorClass.Witchdoctor:
// power = GetWitchDoctorPower(IsCurrentlyAvoiding, UseOOCBuff, UseDestructiblePower);
// break;
//// Demon Hunters
//case ActorClass.DemonHunter:
// power = GetDemonHunterPower(IsCurrentlyAvoiding, UseOOCBuff, UseDestructiblePower);
// break;
}
}
// use IEquatable to check if they're equal
if (CurrentPower == power)
{
Logger.Log(TrinityLogLevel.Debug, LogCategory.Behavior, "Keeping {0}", CurrentPower.ToString());
return(CurrentPower);
}
if (power != null)
{
Logger.Log(TrinityLogLevel.Debug, LogCategory.Behavior, "Selected new {0}", power.ToString());
return(power);
}
return(DefaultPower);
}
}
internal static MoveResult NavigateTo(Vector3 destination, string destinationName = "")
{
PositionCache.AddPosition();
MoveResult result;
try
{
Stopwatch t1 = new Stopwatch();
t1.Start();
using (new PerformanceLogger("Navigator.MoveTo"))
{
result = Navigator.MoveTo(destination, destinationName, false);
}
t1.Stop();
const float maxTime = 750;
// Shit was slow, make it slower but tell us why :)
string pathCheck = "";
if (Trinity.Settings.Advanced.LogCategories.HasFlag(LogCategory.Navigator) && t1.ElapsedMilliseconds > maxTime)
{
if (Navigator.GetNavigationProviderAs <DefaultNavigationProvider>().CanFullyClientPathTo(destination))
{
pathCheck = "CanFullyPath";
}
else
{
pathCheck = "CannotFullyPath";
}
}
LogCategory lc;
if (t1.ElapsedMilliseconds > maxTime)
{
lc = LogCategory.UserInformation;
}
else
{
lc = LogCategory.Navigator;
}
Logger.Log(lc, "Navigator {0} dest={1} ({2}) duration={3:0} distance={4:0} {5}",
result, NavHelper.PrettyPrintVector3(destination), destinationName, t1.ElapsedMilliseconds, destination.Distance2D(Trinity.Player.Position), pathCheck);
}
catch (OutOfMemoryException)
{
Logger.LogDebug("Navigator ran out of memory!");
return(MoveResult.Failed);
}
catch (Exception ex)
{
Logger.Log("{0}", ex);
return(MoveResult.Failed);
}
return(result);
}
/// <summary>
/// Refreshes all player buffs
/// </summary>
internal static void RefreshBuffs()
{
using (new PerformanceLogger("RefreshBuffs"))
{
Trinity.PlayerBuffs = new Dictionary <int, int>();
Trinity.listCachedBuffs = ZetaDia.Me.GetAllBuffs().ToList();
// Special flag for detecting the activation and de-activation of archon
bool archonBuff = false;
int stackCount;
string buffList = "";
Trinity.GotFrenzyShrine = false;
Trinity.GotBlessedShrine = false;
// Store how many stacks of each buff we have
foreach (Buff buff in Trinity.listCachedBuffs)
{
buffList += " " + buff.InternalName + " (SNO: " + buff.SNOId + " stack: " + buff.StackCount.ToString() + ")";
// Store the stack count of this buff
if (!Trinity.PlayerBuffs.TryGetValue(buff.SNOId, out stackCount))
{
Trinity.PlayerBuffs.Add(buff.SNOId, buff.StackCount);
}
// Check for archon stuff
if (buff.SNOId == (int)SNOPower.Wizard_Archon)
{
archonBuff = true;
}
if (buff.SNOId == 30476) //Blessed (+25% defence)
{
Trinity.GotBlessedShrine = true;
}
if (buff.SNOId == 30479) //Frenzy (+25% atk speed)
{
Trinity.GotFrenzyShrine = true;
}
}
Logger.Log(TrinityLogLevel.Debug, LogCategory.CacheManagement, "Refreshed buffs: " + buffList);
// Archon stuff
if (archonBuff)
{
if (!Trinity.HasHadArchonbuff)
{
Trinity.ShouldRefreshHotbarAbilities = true;
}
Trinity.HasHadArchonbuff = true;
}
else
{
if (Trinity.HasHadArchonbuff)
{
Trinity.Hotbar = new List <SNOPower>(Trinity.hashCachedPowerHotbarAbilities);
}
Trinity.HasHadArchonbuff = false;
}
}
}
public void LogLocation(string pre, CombatMovement movement, string post = "", TrinityLogLevel level = TrinityLogLevel.Info)
{
Logger.Log(level, LogCategory.Movement, pre + " {0} Distance={4:0.#} ({1:0.#},{2:0.#},{3:0.#}) {5}",
movement.Name,
movement.Destination.X,
movement.Destination.Y,
movement.Destination.Z,
ZetaDia.Me.Position.Distance(movement.Destination),
post);
}
private static void StoreAndReplaceHook(string hookName, Composite behavior)
{
if (!OriginalHooks.ContainsKey(hookName))
{
OriginalHooks.Add(hookName, TreeHooks.Instance.Hooks[hookName][0]);
}
Logger.Log("Replacing " + hookName + " Hook");
TreeHooks.Instance.ReplaceHook(hookName, behavior);
}
public void ApplyDefaults()
{
Logger.Log(TrinityLogLevel.Verbose, LogCategory.Configuration, "Applying SkillMeta Defaults for {0} ({1})",
Skill.Name, Logger.CallingClassName, Logger.CallingMethodName);
if (Defaults != null)
{
Defaults(Skill, this);
}
}
public static void DumpQuickItems()
{
List <ACDItem> itemList = ZetaDia.Actors.GetActorsOfType <ACDItem>(true).OrderBy(i => i.InventorySlot).ThenBy(i => i.Name).ToList();
StringBuilder sbTopList = new StringBuilder();
foreach (var item in itemList)
{
sbTopList.AppendFormat("\nName={0} InternalName={1} ActorSNO={2} DynamicID={3} InventorySlot={4}",
item.Name, item.InternalName, item.ActorSNO, item.DynamicId, item.InventorySlot);
}
Logger.Log(sbTopList.ToString());
}
private static void GenerateMonkZigZag()
{
float fExtraDistance = CurrentTarget.RadiusDistance <= 20f ? 15f : 20f;
CombatBase.ZigZagPosition = TargetUtil.GetZigZagTarget(CurrentTarget.Position, fExtraDistance);
double direction = MathUtil.FindDirectionRadian(Player.Position, CombatBase.ZigZagPosition);
CombatBase.ZigZagPosition = MathEx.GetPointAt(Player.Position, 40f, (float)direction);
Logger.Log(TrinityLogLevel.Debug, LogCategory.Behavior, "Generated ZigZag {0} distance {1:0}", CombatBase.ZigZagPosition, CombatBase.ZigZagPosition.Distance2D(Player.Position));
LastZigZagUnitAcdGuid = CurrentTarget.ACDGuid;
LastChangedZigZag = DateTime.UtcNow;
}
public static void LogSystemInformation(TrinityLogLevel level = TrinityLogLevel.Debug)
{
Logger.Log(level, LogCategory.UserInformation, "------ System Information ------");
Logger.Log(level, LogCategory.UserInformation, "Processor: " + SystemInformation.Processor);
Logger.Log(level, LogCategory.UserInformation, "Current Speed: " + SystemInformation.ActualProcessorSpeed);
Logger.Log(level, LogCategory.UserInformation, "Operating System: " + SystemInformation.OperatingSystem);
Logger.Log(level, LogCategory.UserInformation, "Motherboard: " + SystemInformation.MotherBoard);
Logger.Log(level, LogCategory.UserInformation, "System Type: " + SystemInformation.SystemType);
Logger.Log(level, LogCategory.UserInformation, "Free Physical Memory: " + SystemInformation.FreeMemory);
Logger.Log(level, LogCategory.UserInformation, "Hard Drive: " + SystemInformation.HardDisk);
Logger.Log(level, LogCategory.UserInformation, "Video Card: " + SystemInformation.VideoCard);
Logger.Log(level, LogCategory.UserInformation, "Resolution: " + SystemInformation.Resolution);
}
internal static void SetUnstuckProvider()
{
if (Settings.Advanced.UnstuckerEnabled)
{
Navigator.StuckHandler = new StuckHandler();
Logger.Log(TrinityLogLevel.Verbose, LogCategory.UserInformation, "Using Trinity Unstucker", true);
}
else
{
Navigator.StuckHandler = new DefaultStuckHandler();
Logger.Log(TrinityLogLevel.Verbose, LogCategory.UserInformation, "Using Default Demonbuddy Unstucker", true);
}
}
private static bool UpdateCurrentTarget()
{
// Return true if we need to refresh objects and get a new target
bool forceUpdate = false;
try
{
Player.Position = ZetaDia.Me.Position;
Player.CurrentHealthPct = ZetaDia.Me.HitpointsCurrentPct;
if (CurrentTarget != null && CurrentTarget.IsUnit && CurrentTarget.Unit != null && CurrentTarget.Unit.IsValid)
{
try
{
DiaUnit unit = CurrentTarget.Unit;
//if (unit.HitpointsCurrent <= 0d)
//{
// Logger.Log(TrinityLogLevel.Debug, LogCategory.Behavior, "CurrentTarget is dead, setting null");
// CurrentTarget = null;
// forceUpdate = true;
//}
//else
//{
CurrentTarget.Position = unit.Position;
CurrentTarget.HitPointsPct = unit.HitpointsCurrentPct;
CurrentTarget.HitPoints = unit.HitpointsCurrent;
Logger.Log(TrinityLogLevel.Debug, LogCategory.Behavior, "Updated CurrentTarget HitPoints={0:0.00} & Position={1}", CurrentTarget.HitPointsPct, CurrentTarget.Position);
//}
}
catch (Exception)
{
Logger.Log(TrinityLogLevel.Debug, LogCategory.Behavior, "Error updating current target information");
CurrentTarget = null;
forceUpdate = true;
}
}
else if (CurrentTarget != null && CurrentTarget.IsUnit)
{
Logger.Log(TrinityLogLevel.Debug, LogCategory.Behavior, "CurrentTarget is invalid, setting null");
CurrentTarget = null;
forceUpdate = true;
}
}
catch
{
Logger.Log(TrinityLogLevel.Debug, LogCategory.Behavior, "Error updating current target information");
CurrentTarget = null;
forceUpdate = true;
}
return(forceUpdate);
}
internal static void SetBotTicksPerSecond()
{
// Carguy's ticks-per-second feature
if (Settings.Advanced.TPSEnabled)
{
BotMain.TicksPerSecond = Settings.Advanced.TPSLimit;
Logger.Log(TrinityLogLevel.Verbose, LogCategory.UserInformation, "Bot TPS set to {0}", Settings.Advanced.TPSLimit);
}
else
{
BotMain.TicksPerSecond = 10;
//BotMain.TicksPerSecond = Int32.MaxValue;
Logger.Log(TrinityLogLevel.Verbose, LogCategory.UserInformation, "Reset bot TPS to default", Settings.Advanced.TPSLimit);
}
}
/// <summary>
/// Main method for selecting a power
/// </summary>
public static TrinityPower GetPower()
{
TrinityPower power;
if (UseDestructiblePower && TryGetPower(GetDestructablesSkill(), out power))
{
return(power);
}
if (IsCurrentlyAvoiding && TryGetPower(GetAvoidanceSkill(), out power))
{
return(power);
}
if (CurrentTarget == null)
{
// Out of Combat Buffs
if (!IsCurrentlyAvoiding && !Player.IsInTown && TryGetPower(GetBuffSkill(), out power))
{
return(power);
}
}
else
{
// Use Generator for the Bastians Ring Set buff
if (!IsCurrentlyAvoiding && ShouldRefreshBastiansGeneratorBuff && TryGetPower(GetAttackGenerator(), out power))
{
return(power);
}
// Use Spender for the Bastians Ring Set buff
if (!IsCurrentlyAvoiding && ShouldRefreshBastiansSpenderBuff && TryGetPower(GetAttackSpender(), out power))
{
return(power);
}
// Main ability selection
if (TryGetPower(GetCombatPower(CombatSkillOrder), out power))
{
return(power);
}
}
Logger.Log(TrinityLogLevel.Verbose, LogCategory.SkillSelection, Player.ActorClass + " GetPower() Returning DefaultPower Target={0}",
(CurrentTarget == null) ? "Null" : CurrentTarget.InternalName);
return(DefaultPower);
}
