public static PluginCommunicationResponse Receive(IPlugin sender, string command, params object[] args)
{
switch (command)
{
case "PING":
return(Respond("PONG"));
case "MOVETO":
var destination = (Vector3)args[0];
var moveResult = Navigator.NavigationProvider.MoveTo(destination);
return(Respond(moveResult));
case "COMBATMODE":
CombatMode mode;
if (TryGetEnum <CombatMode>(args[0], out mode))
{
Logger.Log("Setting Combat Mode to {0} at request of {0}", sender.Name);
CombatBase.CombatMode = mode;
return(Respond(true));
}
return(Respond(false));
case "ResetInactivity":
Logger.Log("Resetting Gold/XP Inactivity at request of {0}", sender.Name);
GoldInactivity.Instance.ResetCheckGold();
XpInactivity.Instance.ResetCheckXp();
return(Respond(true));
}
return(Respond(PluginCommunicationResult.InvalidCommand));
}
public static void RunCleanStash()
{
if (!BotMain.IsRunning)
{
TaskDispatcher.Start(ret => CleanTask(), ret => !IsCleaning);
return;
}
try
{
GoldInactivity.Instance.ResetCheckGold();
XpInactivity.Instance.ResetCheckXp();
if (!_hookInserted)
{
_cleanBehavior = CreateCleanBehavior();
TreeHooks.Instance.InsertHook(HookName, 0, _cleanBehavior);
_hookInserted = true;
BotMain.OnStop += bot => RemoveBehavior("Bot stopped");
}
}
catch (Exception ex)
{
Logger.LogError("Error running clean stash: " + ex);
RemoveBehavior("Exception");
}
}
private static void btnClick_Test1(object sender, RoutedEventArgs routedEventArgs)
{
try
{
Logger.Log("Starting");
using (ZetaDia.Memory.AcquireFrame())
{
ZetaDia.Actors.Update();
foreach (var item in ZetaDia.Me.Inventory.Backpack)
{
var stackHi = item.GetAttribute <int>(ActorAttributeType.ItemStackQuantityHi);
var stackLo = item.GetAttribute <int>(ActorAttributeType.ItemStackQuantityLo);
Logger.Log("Item: {0} {1} ItemStackQuantity={2} StackHi={3} StackLo={4}",
item.Name, item.ACDGuid, item.ItemStackQuantity, stackHi, stackLo);
}
}
Logger.Log("Finished");
}
catch (Exception ex)
{
Logger.LogError("Exception: " + ex);
}
}
/// <summary>
/// Updates the selected collection whenever an object is set to selected.
/// </summary>
/// <param name="args"></param>
public void SyncSelectedItem(ChildElementPropertyChangedEventArgs args)
{
var item = args.ChildElement as LItem;
if (item != null && args.PropertyName.ToString() == "IsSelected")
{
var match = _selectedItems.FirstOrDefault(i => i.Id == item.Id);
if (match != null)
{
if (!item.IsSelected)
{
// Remove
_selectedItems.Remove(match);
Logger.LogVerbose("Removed {0} ({2}) from Selected Items, NewSelectedCount={1}", item.Name, _selectedItems.Count, item.Id);
}
else
{
// Update Data
}
}
else if (match == null && item.IsSelected)
{
_selectedItems.Add(item);
Logger.LogVerbose("Added {0} ({2}) to Selected Items, NewSelectedCount={1}", item.Name, _selectedItems.Count, item.Id);
}
}
}
/// <summary>
/// Decodes an export code and applies it to the current state.
/// </summary>
public ItemListSettings ImportFromCode(string code)
{
if (string.IsNullOrEmpty(code) || string.IsNullOrWhiteSpace(code))
{
ValidationMessage = "You must enter an import/export code";
Logger.Log("You must enter an import/export code");
}
try
{
var decompressedXml = ExportHelper.Decompress(ExportCode);
var newSettings = TrinitySetting.GetSettingsInstance <ItemListSettings>(decompressedXml);
Grouping = newSettings.Grouping;
using (Collection.DeferRefresh())
{
SelectedItems = newSettings.SelectedItems;
UpdateSelectedItems();
}
}
catch (Exception ex)
{
ValidationMessage = string.Format("Error importing itemlist. {0} {1}", ex.Message, ex.InnerException);
Logger.Log("Error importing itemlist. {0} {1}", ex.Message, ex.InnerException);
}
return(this);
}
private static void btnClick_MassConvertRareToMagic(object sender, RoutedEventArgs routedEventArgs)
{
try
{
Logger.Log("Starting Conversion of Backpack VeiledCrystals to ArcaneDust");
if (Trinity.Settings.Loot.Pickup.MiscItemQuality > TrinityItemQuality.Common)
{
Logger.LogError("Aborting - Too dangerous to put crafting items into backpack when MiscItemQuality setting is set above common");
return;
}
var from = InventoryItemType.VeiledCrystal;
var to = InventoryItemType.ArcaneDust;
if (!UIElements.TransmuteItemsDialog.IsVisible || !ConvertMaterials.CanRun(from, to))
{
Logger.LogError("You need to have the cube window open and all the required materials in your backpack.");
return;
}
LastStartedConvert = DateTime.UtcNow;
CoroutineHelper.RunCoroutine(() => ConvertMaterials.Execute(from, to), result => !ConvertMaterials.CanRun(from, to) || CheckConvertTimeout());
Logger.Log("Finished");
}
catch (Exception ex)
{
Logger.LogError("Exception: " + ex);
}
}
public static void SortStash()
{
if (!BotMain.IsRunning)
{
TaskDispatcher.Start(ret => SortTask(InventorySlot.SharedStash), ret => !IsSorting);
return;
}
try
{
GoldInactivity.Instance.ResetCheckGold();
XpInactivity.Instance.ResetCheckXp();
if (!_hookInserted)
{
_sortBehavior = CreateSortBehavior(inventorySlot: InventorySlot.SharedStash);
TreeHooks.Instance.InsertHook(HookName, 0, _sortBehavior);
_hookInserted = true;
BotMain.OnStop += bot => RemoveBehavior();
}
}
catch (Exception ex)
{
Logger.LogError("Error running Sort stash: " + ex);
RemoveBehavior();
}
}
public void LoadCommands()
{
ResetFilterCommand = new RelayCommand(parameter =>
{
FilterText = string.Empty;
});
LoadModalCommand = new RelayCommand(parameter =>
{
if (parameter == null)
{
return;
}
ModalPage page;
if (Enum.TryParse(parameter.ToString(), out page))
{
if (page != ModalPage.None)
{
SelectedModalPage = page;
IsModalVisible = true;
}
ExportCode = string.Empty;
if (page == ModalPage.Export)
{
ExportCommand.Execute(parameter);
}
}
Logger.Log("Selecting modal content... {0}", parameter.ToString());
});
CloseModalCommand = new RelayCommand(parameter =>
{
IsModalVisible = false;
});
ImportCommand = new RelayCommand(parameter =>
{
Logger.Log("Importing ItemList...");
var oldSlected = _selectedItems.Count;
ImportFromCode(ExportCode);
Logger.Log("Selected Before = {0} After = {1}", oldSlected, _selectedItems.Count);
IsModalVisible = false;
});
ExportCommand = new RelayCommand(parameter =>
{
Logger.Log("Exporting ItemList... {0}", parameter);
ExportCode = CreateExportCode();
});
}
public static void SetCombatMode(CombatMode combatMode)
{
var result = Me.SendToAll("COMBATMODE", combatMode.ToString());
foreach (var pluginCommunicationResponse in result)
{
Logger.LogDebug("[PluginCommunicator][" + pluginCommunicationResponse.Plugin.Name + "] Response: " + pluginCommunicationResponse.Result);
}
}
private static void MarkCellAsUsed(int currentRow, int currentCol, ItemWrapper i)
{
_usedGrid[currentCol, currentRow] = true;
if (i.IsTwoSquareItem)
{
Logger.LogDebug("{0} is two squares, marking {1},{2} as used", i.Name, currentCol, currentRow + 1);
_usedGrid[currentCol, currentRow + 1] = true;
}
}
public static bool CheckConvertTimeout()
{
if (DateTime.UtcNow.Subtract(LastStartedConvert).TotalSeconds > 20)
{
Logger.LogError("Timeout");
return(true);
}
return(false);
}
private static void SortBackEventHandler(object sender, RoutedEventArgs e)
{
try
{
ItemSort.SortBackpack();
}
catch (Exception ex)
{
Logger.LogError("Error sorting backpack:" + ex);
}
}
private static void LogInvalidHandler(object sender, RoutedEventArgs routedEventArgs)
{
try
{
DebugUtil.LogInvalidItems();
}
catch (Exception ex)
{
Logger.LogError("Exception {0}", ex);
}
}
private static void SortStashEventHandler(object sender, RoutedEventArgs e)
{
try
{
ItemSort.SortStash();
}
catch (Exception ex)
{
Logger.LogError("Error dropping legendaries:" + ex);
}
}
/**************
*
* WARNING
*
* ALWAYS surround your RoutedEventHandlers in try/catch. Failure to do so will result in Demonbuddy CRASHING if an exception is thrown.
*
* WARNING
*
*************/
private static void btnClick_LogRunTime(object sender, RoutedEventArgs routedEventArgs)
{
try
{
Logger.Log("Bot {0} has been running for {1} hours {2} minutes and {3} seconds", ZetaDia.CPlayer.HeroName, GameStats.Instance.RunTime.Hours, GameStats.Instance.RunTime.Minutes, GameStats.Instance.RunTime.Seconds);
}
catch (Exception ex)
{
Logger.LogError("Exception {0}", ex);
}
}
private static void DumpBuildEventHandler(object sender, RoutedEventArgs routedEventArgs)
{
try
{
DebugUtil.LogBuildAndItems();
}
catch (Exception ex)
{
Logger.LogError("DumpBuildEventHandler: " + ex);
}
}
private static void CacheTestCacheEventHandler(object sender, RoutedEventArgs routedEventArgs)
{
try
{
Logger.Log("Finished Cache Test");
}
catch (Exception ex)
{
Logger.LogError("Exception {0}", ex);
}
}
private static void ShowCacheWindowEventHandler(object sender, RoutedEventArgs routedEventArgs)
{
try
{
CacheUI.CreateWindow();
}
catch (Exception ex)
{
Logger.LogError("Error showing CacheUI:" + ex);
}
}
private static void StopTestHandler(object sender, RoutedEventArgs routedEventArgs)
{
try
{
Worker.Stop();
}
catch (Exception ex)
{
Logger.LogError("Error Starting LazyCache: " + ex);
}
}
private static void GetNewActorSNOsEventHandler(object sender, RoutedEventArgs routedEventArgs)
{
try
{
DebugUtil.LogNewItems();
}
catch (Exception ex)
{
Logger.LogError("Error logging new items:" + ex);
}
}
private static void ShowMainTrinityUIEventHandler(object sender, RoutedEventArgs routedEventArgs)
{
try
{
var configWindow = UILoader.GetDisplayWindow();
configWindow.ShowDialog();
}
catch (Exception ex)
{
Logger.LogError("Error showing Configuration from TabUI:" + ex);
}
}
public static async Task <bool> ReturnToStashTask()
{
if (ZetaDia.Me.IsInCombat)
{
Logger.LogDebug("Cannot return to stash while in combat");
return(false);
}
if (!ZetaDia.IsInTown && ZetaDia.Me.IsFullyValid() && !ZetaDia.Me.IsInCombat && UIElements.BackgroundScreenPCButtonRecall.IsEnabled)
{
StartedOutOfTown = true;
await CommonCoroutines.UseTownPortal("Returning to stash");
return(true);
}
if (!GameUI.IsElementVisible(GameUI.StashDialogMainPage) && ZetaDia.IsInTown)
{
// Move to Stash
if (TownRun.StashLocation.Distance2D(ZetaDia.Me.Position) > 10f)
{
await MoveTo(TownRun.StashLocation, "Shared Stash");
return(true);
}
if (TownRun.StashLocation.Distance2D(ZetaDia.Me.Position) <= 10f && TownRun.SharedStash == null)
{
Logger.LogError("Shared Stash actor is null!");
return(false);
}
// Open Stash
if (TownRun.StashLocation.Distance2D(ZetaDia.Me.Position) <= 10f && TownRun.SharedStash != null && !GameUI.IsElementVisible(GameUI.StashDialogMainPage))
{
while (ZetaDia.Me.Movement.IsMoving)
{
Navigator.PlayerMover.MoveStop();
await Coroutine.Yield();
}
Logger.Log("Opening Stash");
TownRun.SharedStash.Interact();
await Coroutine.Sleep(200);
await Coroutine.Yield();
if (GameUI.IsElementVisible(GameUI.StashDialogMainPage))
{
return(true);
}
return(true);
}
}
return(true);
}
private static void btnClick_TestItemList(object sender, RoutedEventArgs routedEventArgs)
{
try
{
using (new MemoryHelper())
{
DebugUtil.ItemListTest();
}
}
catch (Exception ex)
{
Logger.LogError("Exception {0}", ex);
}
}
/// <summary>
/// Updates the DisplayItems collection to match the Selected collection.
/// </summary>
public void UpdateSelectedItems()
{
if (_selectedItems == null || _displayItems == null || _collection == null || _collection.View == null || _collection.View.SourceCollection == null)
{
Logger.Log("Skipping UpdateSelectedItems due to Null");
return;
}
// Prevent the collection from updating until outside of the using block.
using (Collection.DeferRefresh())
{
var selectedDictionary = _selectedItems.DistinctBy(i => i.Id).ToDictionary(k => k.Id, v => v);
var castView = _collection.View.SourceCollection.Cast <LItem>();
castView.ForEach(item =>
{
// After XML settings load _selectedItems will contain LItem husks that are lacking useful information, just what was saved.
// We want to take the saved information and make an object that is fully populated and linked with the UI collection.
LItem selectedItem;
if (selectedDictionary.TryGetValue(item.Id, out selectedItem))
{
//if(!item.IsSelected)
//Logger.LogVerbose("Update: Selecting {0} ({1}) with {2} rules", item.Name, item.Id, item.Rules.Count);
selectedItem.Rules.ForEach(r =>
{
r.TrinityItemType = item.TrinityItemType;
r.ItemStatRange = item.GetItemStatRange(r.ItemProperty);
});
item.IsSelected = true;
item.Rules = selectedItem.Rules;
item.Ops = selectedItem.Ops;
// Replacing the reference to automatically receive changes from UI.
_selectedItems.Remove(selectedItem);
_selectedItems.Add(item);
}
else
{
if (item.IsSelected)
{
Logger.LogVerbose("Update: Deselecting {0}", item.Name);
item.IsSelected = false;
}
}
});
}
}
private static void btnClick_MoveToCube(object sender, RoutedEventArgs routedEventArgs)
{
try
{
Logger.Log("Starting");
CoroutineHelper.RunCoroutine(() => Navigator.MoveTo(Town.Locations.KanaisCube));
Logger.Log("Finished");
}
catch (Exception ex)
{
Logger.LogError("Exception: " + ex);
}
}
private static void btnClick_UpgradeRares(object sender, RoutedEventArgs routedEventArgs)
{
try
{
Logger.Log("Starting");
CoroutineHelper.RunCoroutine(() => CubeRaresToLegendary.Execute());
Logger.Log("Finished");
}
catch (Exception ex)
{
Logger.LogError("Exception: " + ex);
}
}
private static void btnClick_HijackTest(object sender, RoutedEventArgs routedEventArgs)
{
try
{
Logger.Log("HijackTest Started");
CoroutineHelper.ForceRunCoroutine(() => CubeRaresToLegendary.Execute(), result => !CubeRaresToLegendary.CanRun());
Logger.Log("HijackTest Finished");
}
catch (Exception ex)
{
Logger.LogError("Exception: " + ex);
}
}
public static async Task <bool> MoveTo(Vector3 location, string destinationName, float range = 10f)
{
while (ZetaDia.Me.IsFullyValid() && !ZetaDia.Me.IsInCombat && location.Distance2D(ZetaDia.Me.Position) > range)
{
Logger.LogVerbose("Moving to " + destinationName);
PlayerMover.NavigateTo(location, destinationName);
await Coroutine.Yield();
}
if (location.Distance2D(ZetaDia.Me.Position) <= range)
{
Navigator.PlayerMover.MoveStop();
}
return(true);
}
internal static Tuple <int, int> FindEmptySquare(InventorySlot inventorySlot, int targetCol, int targetRow, bool isTwoSquare, bool isForward)
{
switch (inventorySlot)
{
case InventorySlot.BackpackItems:
return(FindEmptyBackpackSquare(targetCol, targetRow, isTwoSquare, isForward));
case InventorySlot.SharedStash:
return(FindEmptyStashSquare(targetCol, targetRow, isTwoSquare, isForward));
default:
Logger.LogError("Invalid location to find empty slot: {0}", inventorySlot);
return(new Tuple <int, int>(-1, -1));
}
}
/// <summary>
/// Fast lookup for a Skill by SNOPower
/// </summary>
public static Skill ById(SNOPower power)
{
if (!_allSkillBySnoPower.Any())
{
_allSkillBySnoPower = All.ToDictionary(s => s.SNOPower, s => s);
}
Skill skill;
var result = _allSkillBySnoPower.TryGetValue(power, out skill);
if (!result)
{
Logger.LogDebug("Unable to find skill for power {0}", power);
}
return(result ? skill : new Skill());
}
