private static async Task RetrieveFromInventories()
{
foreach (CachedInventory cachedInventory in ItemSortStatus.GetAllInventories())
{
if (cachedInventory.Index <= ItemSortStatus.PlayerInventoryIndex)
{
continue;
}
if (cachedInventory.AllBelong())
{
continue;
}
await SortLoop(cachedInventory.Index);
}
}
public static void PopulateSettings(string settingsPath)
{
if (string.IsNullOrEmpty(settingsPath))
{
AutoRetainerSort.LogCritical("Provided Lisbeth settings path is invalid!");
return;
}
JObject settingsJObject = GetJObject(settingsPath);
LisbethRetainerRules knownRules = new LisbethRetainerRules(settingsJObject);
foreach (var indexInfoPair in AutoRetainerSortSettings.Instance.InventoryOptions)
{
if (!knownRules.RulesByIndex.ContainsKey(indexInfoPair.Key))
{
continue;
}
var ruleList = knownRules.RulesByIndex[indexInfoPair.Key];
foreach (uint itemId in indexInfoPair.Value.SpecificItems.Select(x => x.RawItemId).Distinct())
{
ruleList.Add(new LisbethRetainerRules.ItemRule(itemId));
}
}
foreach (CachedInventory cachedInventory in ItemSortStatus.GetAllInventories())
{
if (!knownRules.RulesByIndex.ContainsKey(cachedInventory.Index))
{
continue;
}
var ruleList = knownRules.RulesByIndex[cachedInventory.Index];
foreach (ItemSortInfo sortInfo in cachedInventory.ItemCounts.Select(x => ItemSortStatus.GetSortInfo(x.Key)).Distinct())
{
if (sortInfo.ItemInfo.Unique || sortInfo.ItemInfo.StackSize <= 1)
{
continue;
}
ruleList.Add(new LisbethRetainerRules.ItemRule(sortInfo.RawItemId));
}
}
SetRules(settingsJObject, knownRules);
using (StreamWriter outputFile = new StreamWriter(settingsPath, false))
{
outputFile.Write(JsonConvert.SerializeObject(settingsJObject, Formatting.None));
}
}
private void AutoSetup_Click(object sender, EventArgs e)
{
if (!AutoRetainerSortSettings.Instance.InventoryOptions.ContainsKey(ItemSortStatus.PlayerInventoryIndex))
{
DialogResult dr = MessageBox.Show(
"It looks like you don't have the player inventory added to the indexes... somehow. Do you want me to re-add that for you?",
"Um.",
MessageBoxButtons.YesNo,
MessageBoxIcon.Warning
);
if (dr == DialogResult.Yes)
{
AutoRetainerSortSettings.Instance.InventoryOptions.Add(ItemSortStatus.PlayerInventoryIndex, new InventorySortInfo("Player Inventory"));
}
}
if (!AutoRetainerSortSettings.Instance.InventoryOptions.ContainsKey(ItemSortStatus.SaddlebagInventoryIndex))
{
DialogResult dr = MessageBox.Show(
"It looks like you don't have the chocobo saddlebag added to the indexes. Do you want me to re-add that for you?",
"Hey Listen!",
MessageBoxButtons.YesNo,
MessageBoxIcon.Information
);
if (dr == DialogResult.Yes)
{
AutoRetainerSortSettings.Instance.InventoryOptions.Add(ItemSortStatus.SaddlebagInventoryIndex, new InventorySortInfo("Chocobo Saddlebag"));
}
}
MessageBox.Show(
Strings.AutoSetup_CacheAdvice,
"Careful!",
MessageBoxButtons.OK,
MessageBoxIcon.Information);
DialogResult warningResult = MessageBox.Show(
Strings.AutoSetup_OverwriteWarning,
"Warning!",
MessageBoxButtons.YesNo,
MessageBoxIcon.Warning);
if (warningResult == DialogResult.No)
{
return;
}
bool conflictUnsorted = MessageBox.Show(
Strings.AutoSetup_ConflictQuestion,
"Conflict?",
MessageBoxButtons.YesNo,
MessageBoxIcon.Question) == DialogResult.Yes;
var newInventorySetup = AutoRetainerSortSettings.Instance.InventoryOptions;
foreach (InventorySortInfo inventorySortInfo in newInventorySetup.Values)
{
inventorySortInfo.SortTypes.Clear();
}
var orderedRetainerList = RetainerList.Instance.OrderedRetainerList;
for (var i = 0; i < orderedRetainerList.Length; i++)
{
if (newInventorySetup.ContainsKey(i))
{
continue;
}
RetainerInfo retInfo = orderedRetainerList[i];
if (!retInfo.Active)
{
continue;
}
newInventorySetup.Add(i, new InventorySortInfo(retInfo.Name));
}
AutoRetainerSortSettings.Instance.InventoryOptions = newInventorySetup;
ItemSortStatus.UpdateFromCache(orderedRetainerList);
var sortTypeCounts = new Dictionary <SortType, Dictionary <int, int> >();
foreach (SortType sortType in Enum.GetValues(typeof(SortType)).Cast <SortType>())
{
sortTypeCounts[sortType] = new Dictionary <int, int>();
}
foreach (CachedInventory cachedInventory in ItemSortStatus.GetAllInventories())
{
foreach (SortType sortType in cachedInventory.ItemCounts.Select(x => ItemSortStatus.GetSortInfo(x.Key).SortType))
{
var indexCountDic = sortTypeCounts[sortType];
if (indexCountDic.ContainsKey(cachedInventory.Index))
{
indexCountDic[cachedInventory.Index]++;
}
else
{
indexCountDic.Add(cachedInventory.Index, 1);
}
}
}
foreach (var typeDicPair in sortTypeCounts)
{
SortType sortType = typeDicPair.Key;
int indexCount = typeDicPair.Value.Keys.Count;
if (indexCount == 0)
{
continue;
}
if (indexCount > 1 && conflictUnsorted)
{
continue;
}
int desiredIndex = typeDicPair.Value.OrderByDescending(x => x.Value).First().Key;
AutoRetainerSortSettings.Instance.InventoryOptions[desiredIndex].SortTypes.Add(new SortTypeWithCount(sortType));
}
ResetBindingSource();
AutoRetainerSortSettings.Instance.Save();
AutoRetainerSort.LogSuccess("Auto-Setup done!");
}
private async Task <bool> Run()
{
if (AutoRetainerSortSettings.Instance.InventoryOptions.Count == 0)
{
LogCritical("You don't have any inventories (or sorting rules for them) added yet! Go check the settings?");
TreeRoot.Stop("No sort settings.");
return(false);
}
if (!ItemSortStatus.AnyRulesExist())
{
LogCritical("You don't have any sorting rules set up... maybe go hit the Auto-Setup button?");
TreeRoot.Stop("No sort settings.");
return(false);
}
LogCritical($"The journey begins! {Strings.AutoSetup_CacheAdvice}");
await GeneralFunctions.StopBusy(true, true, false);
var retData = await HelperFunctions.GetOrderedRetainerArray(true);
if (retData.Length == 0)
{
LogCritical("No retainers. Exiting.");
TreeRoot.Stop("No retainer data found.");
return(false);
}
foreach (var pair in AutoRetainerSortSettings.Instance.InventoryOptions)
{
if (pair.Key < 0)
{
continue;
}
if (pair.Key >= retData.Length)
{
LogCritical($"{pair.Value.Name}'s index of {pair.Key.ToString()} doesn't exist in retainer data.");
TreeRoot.Stop("Invalid index.");
return(false);
}
if (!retData[pair.Key].Active)
{
LogCritical($"{pair.Value.Name} isn't an active retainer!");
TreeRoot.Stop("Retainer inactive.");
return(false);
}
}
ItemSortStatus.ItemSortInfoCache.Clear();
await ItemFinder.FlashSaddlebags();
ItemSortStatus.UpdateFromCache(retData);
if (AutoRetainerSortSettings.Instance.PrintMoves)
{
alreadyPrintedUniques.Clear();
foreach (CachedInventory cachedInventory in ItemSortStatus.GetAllInventories())
{
PrintMoves(cachedInventory.Index);
}
}
while (ItemSortStatus.AnyUnsorted())
{
if (ItemSortStatus.FilledAndSortedInventories.Contains(ItemSortStatus.PlayerInventoryIndex))
{
LogCritical("Everything currently in the player's inventory belongs there, but it's full! Can't move items like this. I quit.");
break;
}
await DepositFromPlayer();
await RetrieveFromInventories();
await Coroutine.Sleep(250);
ItemSortStatus.UpdateFromCache(retData);
await Coroutine.Sleep(250);
}
foreach (CachedInventory cachedInventory in ItemSortStatus.GetAllInventories())
{
foreach (ItemSortInfo sortInfo in cachedInventory.ItemCounts.Select(x => ItemSortStatus.GetSortInfo(x.Key)))
{
int[] localIndexCache = sortInfo.MatchingIndexes.ToArray();
if (localIndexCache.Length == 0)
{
continue;
}
if (sortInfo.SortStatus(cachedInventory.Index) == SortStatus.MoveButUnable)
{
if (ItemSortStatus.FilledAndSortedInventories.Contains(cachedInventory.Index) || (cachedInventory.FreeSlots == 0 && cachedInventory.AllBelong()))
{
LogCritical($"We want to move {sortInfo.Name} to {ItemSortStatus.GetByIndex(localIndexCache[0]).Name} but it's full and everything there belongs. Too bad!");
}
else if (sortInfo.ItemInfo.Unique)
{
if (localIndexCache.Length == 1)
{
LogCritical($"We want to move {sortInfo.Name} to {ItemSortStatus.GetByIndex(localIndexCache[0]).Name} but it's unique and that inventory already has one. Too bad!");
}
else
{
LogCritical($"We want to move {sortInfo.Name} but it's unique and all inventories set for it already have one. Too bad!");
}
}
else
{
LogCritical($"We want to move {sortInfo.Name} to {ItemSortStatus.GetByIndex(localIndexCache[0]).Name} " +
$"but it can't be moved there for... some reason. IndexStatus: {sortInfo.IndexStatus(cachedInventory.Index).ToString()}");
}
}
}
}
await GeneralFunctions.ExitRetainer(true);
if (AutoRetainerSortSettings.Instance.AutoGenLisbeth)
{
string lisbethSettingsPath = LisbethRuleGenerator.GetSettingsPath();
if (!string.IsNullOrEmpty(lisbethSettingsPath))
{
LisbethRuleGenerator.PopulateSettings(lisbethSettingsPath);
LogSuccess("Auto-populated Lisbeth's retainer item rules!");
MessageBox.Show(
Strings.LisbethRules_RestartRB,
"Just Letting You Know...",
MessageBoxButtons.OK,
MessageBoxIcon.Information);
}
else
{
LogCritical("Couldn't find Lisbeth settings path! We won't auto-generate retainer rules.");
}
}
TreeRoot.Stop("Done sorting inventories.");
return(false);
}
