using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.Json;
using BepInEx;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using HarmonyLib;
using Il2CppInterop.Runtime;
using Il2CppSystem.Collections.Generic;
using ProjectM;
using ProjectM.Network;
using ProjectM.Scripting;
using SlotSort.Commands.Converters;
using SlotSort.Models;
using SlotSort.Services;
using SlotSort.Ui;
using Stunlock.Core;
using Unity.Collections;
using Unity.Entities;
using Unity.Scenes;
using VampireCommandFramework;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("SlotSort")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Custom inventory slot sorting on sort button")]
[assembly: AssemblyFileVersion("1.1.1.0")]
[assembly: AssemblyInformationalVersion("1.1.1")]
[assembly: AssemblyProduct("SlotSort")]
[assembly: AssemblyTitle("SlotSort")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.1.0")]
[module: UnverifiableCode]
namespace SlotSort
{
internal static class Core
{
private static bool hasInitialized;
public static World Server { get; } = GetWorld("Server") ?? throw new Exception("Server world not found. Install this mod on the dedicated server.");
public static EntityManager EntityManager { get; } = Server.EntityManager;
public static PrefabCollectionSystem PrefabCollectionSystem { get; private set; } = null;
public static ServerScriptMapper ServerScriptMapper { get; private set; } = null;
public static ServerGameManager ServerGameManager => ServerScriptMapper.GetServerGameManager();
public static SlotAssignmentService SlotAssignments { get; } = new SlotAssignmentService();
public static InventorySlotService InventorySlots { get; } = new InventorySlotService();
public static SlotSortUiService Ui { get; } = new SlotSortUiService();
public static ManualLogSource Log => Plugin.LogInstance;
public static bool HasInitialized => hasInitialized;
public static void Initialize()
{
if (!hasInitialized)
{
PrefabCollectionSystem = Server.GetExistingSystemManaged<PrefabCollectionSystem>();
ServerScriptMapper = Server.GetExistingSystemManaged<ServerScriptMapper>();
SlotAssignments.LoadDefaults();
SlotAssignments.LoadAllPlayers();
hasInitialized = true;
Log.LogInfo((object)"SlotSort initialized");
}
}
private static World GetWorld(string name)
{
Enumerator<World> enumerator = World.s_AllWorlds.GetEnumerator();
while (enumerator.MoveNext())
{
World current = enumerator.Current;
if (current.Name == name)
{
return current;
}
}
return null;
}
public static void LogException(Exception e, string context)
{
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Expected O, but got Unknown
ManualLogSource log = Log;
bool flag = default(bool);
BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(4, 3, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(context);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("] ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(e.Message);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\n");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(e.StackTrace);
}
log.LogError(val);
}
}
internal static class ECSExtensions
{
private static EntityManager EntityManager => Core.EntityManager;
public unsafe static void Write<T>(this Entity entity, T componentData) where T : struct
{
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
ComponentType val = default(ComponentType);
((ComponentType)(ref val))..ctor(Il2CppType.Of<T>(), (AccessMode)0);
byte[] array = StructureToByteArray(componentData);
int num = Marshal.SizeOf<T>();
fixed (byte* ptr = array)
{
EntityManager entityManager = EntityManager;
((EntityManager)(ref entityManager)).SetComponentDataRaw(entity, val.TypeIndex, (void*)ptr, num);
}
}
private static byte[] StructureToByteArray<T>(T structure) where T : struct
{
int num = Marshal.SizeOf(structure);
byte[] array = new byte[num];
IntPtr intPtr = Marshal.AllocHGlobal(num);
Marshal.StructureToPtr(structure, intPtr, fDeleteOld: true);
Marshal.Copy(intPtr, array, 0, num);
Marshal.FreeHGlobal(intPtr);
return array;
}
public unsafe static T Read<T>(this Entity entity) where T : struct
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
ComponentType val = default(ComponentType);
((ComponentType)(ref val))..ctor(Il2CppType.Of<T>(), (AccessMode)0);
EntityManager entityManager = EntityManager;
return Marshal.PtrToStructure<T>(new IntPtr(((EntityManager)(ref entityManager)).GetComponentDataRawRO(entity, val.TypeIndex)));
}
public static DynamicBuffer<T> ReadBuffer<T>(this Entity entity) where T : struct
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
EntityManager entityManager = EntityManager;
return ((EntityManager)(ref entityManager)).GetBuffer<T>(entity, false);
}
public static bool Has<T>(this Entity entity) where T : struct
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
ComponentType val = default(ComponentType);
((ComponentType)(ref val))..ctor(Il2CppType.Of<T>(), (AccessMode)0);
EntityManager entityManager = EntityManager;
return ((EntityManager)(ref entityManager)).HasComponent(entity, val);
}
public static string PrefabName(this PrefabGUID prefabGuid)
{
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
Enumerator<string, PrefabGUID> enumerator = Core.PrefabCollectionSystem._SpawnableNameToPrefabGuidDictionary.GetEnumerator();
while (enumerator.MoveNext())
{
KeyValuePair<string, PrefabGUID> current = enumerator.Current;
PrefabGUID value = current.Value;
if (((PrefabGUID)(ref value)).Equals(prefabGuid))
{
return current.Key;
}
}
return $"Unknown ({((PrefabGUID)(ref prefabGuid)).GuidHash})";
}
public static string LookupName(this PrefabGUID prefabGuid)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
return prefabGuid.PrefabName();
}
}
[BepInPlugin("SlotSort", "SlotSort", "1.1.1")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class Plugin : BasePlugin
{
private static Plugin instance;
private Harmony harmony;
public static Harmony Harmony => instance.harmony;
public static ManualLogSource LogInstance => ((BasePlugin)instance).Log;
public override void Load()
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Expected O, but got Unknown
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: Expected O, but got Unknown
instance = this;
ManualLogSource log = ((BasePlugin)this).Log;
bool flag = default(bool);
BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(24, 2, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Plugin ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("SlotSort");
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" version ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("1.1.1");
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" loaded.");
}
log.LogInfo(val);
harmony = new Harmony("SlotSort");
harmony.PatchAll(typeof(Plugin).Assembly);
CommandRegistry.RegisterAll();
}
public override bool Unload()
{
CommandRegistry.UnregisterAssembly();
Harmony obj = harmony;
if (obj != null)
{
obj.UnpatchSelf();
}
return true;
}
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "SlotSort";
public const string PLUGIN_NAME = "SlotSort";
public const string PLUGIN_VERSION = "1.1.1";
}
}
namespace SlotSort.Ui
{
internal sealed class SlotSortUiService
{
private readonly ZuiPacketService packets = new ZuiPacketService();
private static readonly (string Label, string ItemQuery, int Slot)[] QuickPresets = new(string, string, int)[5]
{
("Blood Rose -> slot 9", "BloodRose", 9),
("Blood Potion -> slot 10", "BloodPotion", 10),
("Cloak -> slot 11", "Cloak", 11),
("Vermin Salve -> slot 12", "VerminSalve", 12),
("Wolf Pelt -> slot 13", "WolfPelt", 13)
};
public void Open(User user, ulong steamId)
{
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
bool enabled = Core.SlotAssignments.IsEnabled(steamId);
IReadOnlyList<SlotAssignmentEntry> assignments = Core.SlotAssignments.GetAssignments(steamId);
packets.Send(user, "SetPlugin", new Dictionary<string, string> { { "Plugin", "SlotSort" } });
packets.Send(user, "SetTargetWindow", new Dictionary<string, string> { { "Window", "SlotSortPanel" } });
packets.Send(user, "SetUICustom", new Dictionary<string, string>
{
{ "W", "640" },
{ "H", "560" }
});
packets.Send(user, "SetTitle", new Dictionary<string, string> { { "Text", "<color=#9B59B6>SlotSort</color> — fixed inventory slots" } });
BuildMainTab(user, enabled);
BuildRulesTab(user, assignments);
BuildAddTab(user);
BuildSearchTab(user, steamId);
packets.Send(user, "Open", new Dictionary<string, string>());
}
private void BuildMainTab(User user, bool enabled)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0088: Unknown result type (might be due to invalid IL or missing references)
//IL_010a: Unknown result type (might be due to invalid IL or missing references)
//IL_0126: Unknown result type (might be due to invalid IL or missing references)
//IL_0145: Unknown result type (might be due to invalid IL or missing references)
//IL_0169: Unknown result type (might be due to invalid IL or missing references)
//IL_01af: Unknown result type (might be due to invalid IL or missing references)
//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
packets.Send(user, "CreateTab", new Dictionary<string, string> { { "Name", "Main" } });
string text = (enabled ? "<color=#2ECC71>Enabled</color>" : "<color=#E74C3C>Disabled</color>");
packets.Send(user, "AddText", new Dictionary<string, string>
{
{
"Text",
"Status: " + text
},
{ "X", "20" },
{ "Y", "20" }
});
packets.Send(user, "AddText", new Dictionary<string, string>
{
{
"Text",
$"Slots 1-{8} = hotbar, {9}+ = bag. Press Sort to apply."
},
{ "X", "20" },
{ "Y", "50" }
});
AddButton(user, "Toggle on/off", ".slotsort toggle", 20, 90, 600, 36);
AddButton(user, "Apply slots now", ".slotsort sort", 20, 136, 600, 36);
AddButton(user, "Refresh window", ".slotsort gui", 20, 182, 600, 36);
packets.Send(user, "AddCategory", new Dictionary<string, string>
{
{ "Name", "<color=#3498DB>How it works</color>" },
{ "X", "20" },
{ "Y", "240" }
});
packets.Send(user, "AddText", new Dictionary<string, string>
{
{ "Text", "1) Add rules on the Add tab\n2) Press Sort in inventory\n3) Items move to your chosen slots" },
{ "X", "20" },
{ "Y", "270" }
});
packets.Send(user, "AddText", new Dictionary<string, string>
{
{ "Text", "<color=#95A5A6>Requires ZUI client mod (Zanakinz/ZUI)</color>" },
{ "X", "20" },
{ "Y", "360" }
});
}
private void BuildRulesTab(User user, IReadOnlyList<SlotAssignmentEntry> assignments)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
//IL_00de: Unknown result type (might be due to invalid IL or missing references)
//IL_0158: Unknown result type (might be due to invalid IL or missing references)
//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
packets.Send(user, "CreateTab", new Dictionary<string, string> { { "Name", "Rules" } });
packets.Send(user, "AddText", new Dictionary<string, string>
{
{ "Text", "Active slot rules:" },
{ "X", "20" },
{ "Y", "20" }
});
if (assignments.Count == 0)
{
packets.Send(user, "AddText", new Dictionary<string, string>
{
{ "Text", "<color=#F39C12>No rules yet. Use the Add tab.</color>" },
{ "X", "20" },
{ "Y", "55" }
});
return;
}
int num = 55;
int num2 = 0;
foreach (SlotAssignmentEntry assignment in assignments)
{
if (num2 >= 10)
{
packets.Send(user, "AddText", new Dictionary<string, string>
{
{ "Text", "<color=#95A5A6>...and more. Use .slotsort list</color>" },
{ "X", "20" },
{
"Y",
num.ToString()
}
});
break;
}
string displayName = GetDisplayName(assignment);
string value = ((displayName.Length > 42) ? (displayName.Substring(0, 39) + "...") : displayName);
packets.Send(user, "AddText", new Dictionary<string, string>
{
{
"Text",
$"<color=#F1C40F>Slot {assignment.Slot}</color> {value}"
},
{ "X", "20" },
{
"Y",
num.ToString()
}
});
AddButton(user, "X", $".slotsort rmid {assignment.ItemGuid}", 560, num - 4, 50, 28);
num += 42;
num2++;
}
}
private void BuildAddTab(User user)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_0091: Unknown result type (might be due to invalid IL or missing references)
//IL_0111: Unknown result type (might be due to invalid IL or missing references)
//IL_009d: Unknown result type (might be due to invalid IL or missing references)
//IL_016f: Unknown result type (might be due to invalid IL or missing references)
//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
packets.Send(user, "CreateTab", new Dictionary<string, string> { { "Name", "Add" } });
packets.Send(user, "AddCategory", new Dictionary<string, string>
{
{ "Name", "<color=#2ECC71>Quick presets</color>" },
{ "X", "20" },
{ "Y", "20" }
});
int num = 55;
(string, string, int)[] quickPresets = QuickPresets;
for (int i = 0; i < quickPresets.Length; i++)
{
(string, string, int) tuple = quickPresets[i];
PrefabGUID val = InventorySlotService.ResolveItemGuidByName(tuple.Item2);
if (((PrefabGUID)(ref val)).GuidHash != 0)
{
AddButton(user, tuple.Item1, $".slotsort setid {((PrefabGUID)(ref val)).GuidHash} {tuple.Item3}", 20, num, 600, 34);
num += 42;
}
}
packets.Send(user, "AddCategory", new Dictionary<string, string>
{
{ "Name", "<color=#3498DB>Pick a bag slot (9-16)</color>" },
{ "X", "20" },
{
"Y",
(num + 10).ToString()
}
});
num += 45;
int num2 = 0;
for (int j = 9; j <= 16; j++)
{
int x = 20 + num2 * 74;
AddButton(user, j.ToString(), $".slotsort pickslot {j}", x, num, 68, 32);
num2++;
}
packets.Send(user, "AddText", new Dictionary<string, string>
{
{ "Text", "Pick slot, then chat: .slotsort setheld\nOr: .slotsort set \"item name\" 12\nOr: .slotsort search blood" },
{ "X", "20" },
{
"Y",
(num + 45).ToString()
}
});
}
private void BuildSearchTab(User user, ulong steamId)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
//IL_010d: Unknown result type (might be due to invalid IL or missing references)
//IL_0178: Unknown result type (might be due to invalid IL or missing references)
//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
//IL_023b: Unknown result type (might be due to invalid IL or missing references)
//IL_0313: Unknown result type (might be due to invalid IL or missing references)
packets.Send(user, "CreateTab", new Dictionary<string, string> { { "Name", "Search" } });
packets.Send(user, "AddText", new Dictionary<string, string>
{
{ "Text", "Chat: <color=#F1C40F>.slotsort search blood</color> (or any part of the item name)" },
{ "X", "20" },
{ "Y", "20" }
});
int slot;
string value = (Core.SlotAssignments.TryGetPendingSlot(steamId, out slot) ? $"<color=#2ECC71>Selected slot: {slot}</color>" : "<color=#F39C12>Pick a slot below before assigning</color>");
packets.Send(user, "AddText", new Dictionary<string, string>
{
{ "Text", value },
{ "X", "20" },
{ "Y", "50" }
});
int num = 80;
for (int i = 9; i <= 16; i++)
{
int x = 20 + (i - 9) * 74;
AddButton(user, i.ToString(), $".slotsort pickslot {i}", x, num, 68, 32);
}
num += 45;
if (!Core.SlotAssignments.TryGetSearchResults(steamId, out var query, out var itemGuids) || itemGuids.Count == 0)
{
packets.Send(user, "AddText", new Dictionary<string, string>
{
{ "Text", "<color=#95A5A6>No search yet. Run .slotsort search in chat.</color>" },
{ "X", "20" },
{
"Y",
num.ToString()
}
});
return;
}
packets.Send(user, "AddCategory", new Dictionary<string, string>
{
{
"Name",
"<color=#3498DB>Results for \"" + query + "\"</color>"
},
{ "X", "20" },
{
"Y",
num.ToString()
}
});
num += 35;
int num2 = 0;
foreach (int item in itemGuids)
{
if (num2 >= 8)
{
packets.Send(user, "AddText", new Dictionary<string, string>
{
{
"Text",
$"<color=#95A5A6>...and {itemGuids.Count - 8} more. Refine your search.</color>"
},
{ "X", "20" },
{
"Y",
num.ToString()
}
});
break;
}
string text = ItemSearchService.FormatDisplayName(ECSExtensions.PrefabName(new PrefabGUID(item)));
if (text.Length > 36)
{
text = text.Substring(0, 33) + "...";
}
string cmd = $".slotsort setid {item}";
AddButton(user, text, cmd, 20, num, 520, 34);
num += 42;
num2++;
}
}
private static string GetDisplayName(SlotAssignmentEntry entry)
{
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
if (entry.ItemGuid != 0)
{
return ECSExtensions.PrefabName(new PrefabGUID(entry.ItemGuid));
}
return entry.ItemName;
}
private void AddButton(User user, string text, string cmd, int x, int y, int w, int h)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
packets.Send(user, "AddButton", new Dictionary<string, string>
{
{ "Text", text },
{ "Cmd", cmd },
{
"X",
x.ToString()
},
{
"Y",
y.ToString()
},
{
"W",
w.ToString()
},
{
"H",
h.ToString()
}
});
}
}
internal sealed class ZuiPacketService
{
public const string PluginName = "SlotSort";
public const string WindowName = "SlotSortPanel";
public void Send(User user, string type, Dictionary<string, string> data)
{
//IL_0074: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Expected O, but got Unknown
string text = JsonSerializer.Serialize(new
{
Type = type,
Plugin = "SlotSort",
Window = "SlotSortPanel",
Data = data
});
string text2 = "[[ZUI]]" + text;
if (text2.Length >= 511)
{
ManualLogSource log = Core.Log;
bool flag = default(bool);
BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(30, 2, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("ZUI packet too long (");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(text2.Length);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" chars): ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(type);
}
log.LogWarning(val);
}
else
{
ServerChatUtils.SendSystemMessageToClient(Core.EntityManager, user, text2);
}
}
}
}
namespace SlotSort.Services
{
internal sealed class InventorySlotService
{
public const int HotbarSlots = 8;
public void ApplyAssignments(Entity character, ulong steamId)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_005c: Unknown result type (might be due to invalid IL or missing references)
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
//IL_0094: Unknown result type (might be due to invalid IL or missing references)
//IL_0095: Unknown result type (might be due to invalid IL or missing references)
//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
Entity val = default(Entity);
if (!InventoryUtilities.TryGetInventoryEntity(Core.EntityManager, character, ref val, 0))
{
return;
}
ServerGameManager serverGameManager = Core.ServerGameManager;
DynamicBuffer<InventoryBuffer> buffer = default(DynamicBuffer<InventoryBuffer>);
if (!((ServerGameManager)(ref serverGameManager)).TryGetBuffer<InventoryBuffer>(val, ref buffer))
{
return;
}
IReadOnlyList<SlotAssignmentEntry> assignments = Core.SlotAssignments.GetAssignments(steamId);
if (assignments.Count == 0)
{
return;
}
foreach (SlotAssignmentEntry item in assignments)
{
PrefabGUID itemGuid = (PrefabGUID)((item.ItemGuid != 0) ? new PrefabGUID(item.ItemGuid) : ResolveItemGuid(item.ItemName));
if (((PrefabGUID)(ref itemGuid)).GuidHash != 0)
{
int num = ToBufferIndex(item.Slot, buffer.Length);
if (num >= 0 && TryFindItemSlot(buffer, itemGuid, num, out var sourceIndex) && sourceIndex != num)
{
SwapSlots(val, buffer, sourceIndex, num);
}
}
}
}
public static PrefabGUID ResolveItemGuidByName(string itemName)
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
if (string.IsNullOrWhiteSpace(itemName))
{
return PrefabGUID.Empty;
}
if (ItemSearchService.TryResolveExact(itemName, out var prefab))
{
return prefab;
}
List<ItemSearchService.ItemMatch> list = ItemSearchService.FindItems(itemName, 2);
if (list.Count != 1)
{
return PrefabGUID.Empty;
}
return list[0].Guid;
}
private static PrefabGUID ResolveItemGuid(string itemName)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
return ResolveItemGuidByName(itemName);
}
private static int ToBufferIndex(int slotNumber, int bufferLength)
{
int num = slotNumber - 1;
if (num < 0 || num >= bufferLength)
{
return -1;
}
return num;
}
private static bool TryFindItemSlot(DynamicBuffer<InventoryBuffer> buffer, PrefabGUID itemGuid, int skipIndex, out int sourceIndex)
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
for (int i = 0; i < buffer.Length; i++)
{
if (i != skipIndex)
{
InventoryBuffer val = buffer[i];
if (val.Amount > 0 && ((PrefabGUID)(ref val.ItemType)).Equals(itemGuid))
{
sourceIndex = i;
return true;
}
}
}
sourceIndex = -1;
return false;
}
private static void SwapSlots(Entity inventory, DynamicBuffer<InventoryBuffer> buffer, int sourceIndex, int targetIndex)
{
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
InventoryBuffer val = buffer[sourceIndex];
InventoryBuffer entry = (buffer[sourceIndex] = buffer[targetIndex]);
buffer[targetIndex] = val;
UpdateItemEntityContainer(val, inventory);
UpdateItemEntityContainer(entry, inventory);
}
private static void UpdateItemEntityContainer(InventoryBuffer entry, Entity inventory)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
Entity entityOnServer = ((NetworkedEntity)(ref entry.ItemEntity)).GetEntityOnServer();
if (!((Entity)(ref entityOnServer)).Equals(Entity.Null) && entityOnServer.Has<InventoryItem>())
{
InventoryItem componentData = entityOnServer.Read<InventoryItem>();
componentData.ContainerEntity = inventory;
entityOnServer.Write<InventoryItem>(componentData);
}
}
}
internal static class ItemSearchService
{
public readonly record struct ItemMatch(PrefabGUID Guid, string PrefabName);
public static bool TryResolveExact(string query, out PrefabGUID prefab)
{
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
Enumerator<string, PrefabGUID> enumerator = Core.PrefabCollectionSystem._SpawnableNameToPrefabGuidDictionary.GetEnumerator();
while (enumerator.MoveNext())
{
KeyValuePair<string, PrefabGUID> current = enumerator.Current;
if (current.Key.Equals(query, StringComparison.OrdinalIgnoreCase))
{
prefab = current.Value;
return true;
}
}
prefab = PrefabGUID.Empty;
return false;
}
public static List<ItemMatch> FindItems(string query, int maxResults = 20)
{
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
List<ItemMatch> list = new List<ItemMatch>();
if (string.IsNullOrWhiteSpace(query) || maxResults < 1)
{
return list;
}
Enumerator<string, PrefabGUID> enumerator = Core.PrefabCollectionSystem._SpawnableNameToPrefabGuidDictionary.GetEnumerator();
while (enumerator.MoveNext())
{
KeyValuePair<string, PrefabGUID> current = enumerator.Current;
if (current.Key.StartsWith("Item_") && current.Key.Contains(query, StringComparison.OrdinalIgnoreCase))
{
list.Add(new ItemMatch(current.Value, current.Key));
}
}
return list.OrderBy<ItemMatch, string>((ItemMatch m) => m.PrefabName, StringComparer.OrdinalIgnoreCase).Take(maxResults).ToList();
}
public static string FormatDisplayName(string prefabName)
{
if (prefabName.StartsWith("Item_", StringComparison.Ordinal))
{
string text = prefabName;
prefabName = text.Substring(5, text.Length - 5);
}
return prefabName.Replace('_', ' ');
}
}
internal sealed class SlotAssignmentService
{
private const string ConfigFolderName = "SlotSort";
private const string DefaultsFileName = "defaults.json";
private readonly Dictionary<ulong, SlotAssignmentData> playerData = new Dictionary<ulong, SlotAssignmentData>();
private readonly Dictionary<ulong, int> pendingSlots = new Dictionary<ulong, int>();
private readonly Dictionary<ulong, (string Query, List<int> ItemGuids)> searchResults = new Dictionary<ulong, (string, List<int>)>();
private SlotAssignmentData globalDefaults = new SlotAssignmentData();
private string ConfigRoot => Path.Combine(Paths.ConfigPath, "SlotSort");
private string DefaultsPath => Path.Combine(ConfigRoot, "defaults.json");
private string PlayersPath => Path.Combine(ConfigRoot, "players");
public void LoadDefaults()
{
//IL_007d: Unknown result type (might be due to invalid IL or missing references)
//IL_0083: Expected O, but got Unknown
Directory.CreateDirectory(ConfigRoot);
Directory.CreateDirectory(PlayersPath);
if (!File.Exists(DefaultsPath))
{
globalDefaults = CreateExampleDefaults();
ResolveMissingGuids(globalDefaults);
SaveDefaults();
return;
}
try
{
string json = File.ReadAllText(DefaultsPath);
globalDefaults = JsonSerializer.Deserialize<SlotAssignmentData>(json) ?? new SlotAssignmentData();
ResolveMissingGuids(globalDefaults);
}
catch (Exception ex)
{
ManualLogSource log = Core.Log;
bool flag = default(bool);
BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(30, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Failed to load defaults.json: ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
}
log.LogError(val);
globalDefaults = new SlotAssignmentData();
}
}
public void LoadAllPlayers()
{
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_006f: Expected O, but got Unknown
playerData.Clear();
bool flag = default(bool);
foreach (string item in Directory.EnumerateFiles(PlayersPath, "*.json"))
{
if (!ulong.TryParse(Path.GetFileNameWithoutExtension(item), out var result))
{
continue;
}
try
{
SlotAssignmentData slotAssignmentData = JsonSerializer.Deserialize<SlotAssignmentData>(File.ReadAllText(item));
if (slotAssignmentData != null)
{
playerData[result] = slotAssignmentData;
}
}
catch (Exception ex)
{
ManualLogSource log = Core.Log;
BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(31, 2, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Failed to load player config ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(item);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(": ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
}
log.LogWarning(val);
}
}
}
public bool IsEnabled(ulong steamId)
{
return GetMergedData(steamId).Enabled;
}
public bool ToggleEnabled(ulong steamId)
{
SlotAssignmentData orCreatePlayerData = GetOrCreatePlayerData(steamId);
orCreatePlayerData.Enabled = !orCreatePlayerData.Enabled;
SavePlayer(steamId);
return orCreatePlayerData.Enabled;
}
public IReadOnlyList<SlotAssignmentEntry> GetAssignments(ulong steamId)
{
SlotAssignmentData orCreatePlayerData = GetOrCreatePlayerData(steamId);
HashSet<int> disabled = new HashSet<int>(orCreatePlayerData.DisabledDefaultGuids);
return MergeAssignments(globalDefaults.Assignments.Where((SlotAssignmentEntry a) => !disabled.Contains(a.ItemGuid)), orCreatePlayerData.Assignments);
}
public void SetPendingSlot(ulong steamId, int slot)
{
pendingSlots[steamId] = slot;
}
public bool TryGetPendingSlot(ulong steamId, out int slot)
{
return pendingSlots.TryGetValue(steamId, out slot);
}
public void SetSearchResults(ulong steamId, string query, IReadOnlyList<ItemSearchService.ItemMatch> results)
{
searchResults[steamId] = (query, results.Select(delegate(ItemSearchService.ItemMatch r)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
PrefabGUID guid = r.Guid;
return ((PrefabGUID)(ref guid)).GuidHash;
}).ToList());
}
public bool TryGetSearchResults(ulong steamId, out string query, out IReadOnlyList<int> itemGuids)
{
if (searchResults.TryGetValue(steamId, out (string, List<int>) value))
{
(query, itemGuids) = value;
return true;
}
query = string.Empty;
itemGuids = Array.Empty<int>();
return false;
}
public bool TrySetAssignment(ulong steamId, PrefabGUID item, int slotNumber, out string error)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_0076: Unknown result type (might be due to invalid IL or missing references)
error = string.Empty;
if (slotNumber < 1)
{
error = "Slot number must be at least 1.";
return false;
}
SlotAssignmentData orCreatePlayerData = GetOrCreatePlayerData(steamId);
orCreatePlayerData.DisabledDefaultGuids.Remove(((PrefabGUID)(ref item)).GuidHash);
orCreatePlayerData.Assignments.RemoveAll((SlotAssignmentEntry a) => a.ItemGuid == ((PrefabGUID)(ref item)).GuidHash);
orCreatePlayerData.Assignments.Add(new SlotAssignmentEntry
{
ItemGuid = ((PrefabGUID)(ref item)).GuidHash,
ItemName = item.PrefabName(),
Slot = slotNumber
});
SavePlayer(steamId);
return true;
}
public bool TryRemoveAssignment(ulong steamId, PrefabGUID item, out string error)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_009b: Unknown result type (might be due to invalid IL or missing references)
error = string.Empty;
SlotAssignmentData orCreatePlayerData = GetOrCreatePlayerData(steamId);
if (orCreatePlayerData.Assignments.RemoveAll((SlotAssignmentEntry a) => a.ItemGuid == ((PrefabGUID)(ref item)).GuidHash) > 0)
{
SavePlayer(steamId);
return true;
}
if (globalDefaults.Assignments.Exists((SlotAssignmentEntry a) => a.ItemGuid == ((PrefabGUID)(ref item)).GuidHash) && !orCreatePlayerData.DisabledDefaultGuids.Contains(((PrefabGUID)(ref item)).GuidHash))
{
orCreatePlayerData.DisabledDefaultGuids.Add(((PrefabGUID)(ref item)).GuidHash);
SavePlayer(steamId);
return true;
}
error = "No assignment found for " + item.PrefabName() + ".";
return false;
}
public bool TryRemoveByGuid(ulong steamId, int itemGuid, out string error)
{
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
if (itemGuid == 0)
{
error = "Invalid item id.";
return false;
}
return TryRemoveAssignment(steamId, new PrefabGUID(itemGuid), out error);
}
public bool TrySetByGuid(ulong steamId, int itemGuid, int slotNumber, out string error)
{
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
if (itemGuid == 0)
{
error = "Invalid item id.";
return false;
}
return TrySetAssignment(steamId, new PrefabGUID(itemGuid), slotNumber, out error);
}
private SlotAssignmentData GetMergedData(ulong steamId)
{
SlotAssignmentData orCreatePlayerData = GetOrCreatePlayerData(steamId);
HashSet<int> disabled = new HashSet<int>(orCreatePlayerData.DisabledDefaultGuids);
IEnumerable<SlotAssignmentEntry> defaults = globalDefaults.Assignments.Where((SlotAssignmentEntry a) => !disabled.Contains(a.ItemGuid));
return new SlotAssignmentData
{
Enabled = orCreatePlayerData.Enabled,
Assignments = MergeAssignments(defaults, orCreatePlayerData.Assignments),
DisabledDefaultGuids = orCreatePlayerData.DisabledDefaultGuids
};
}
private SlotAssignmentData GetOrCreatePlayerData(ulong steamId)
{
if (!playerData.TryGetValue(steamId, out var value))
{
value = new SlotAssignmentData();
playerData[steamId] = value;
}
return value;
}
private static List<SlotAssignmentEntry> MergeAssignments(IEnumerable<SlotAssignmentEntry> defaults, IEnumerable<SlotAssignmentEntry> playerOverrides)
{
Dictionary<int, SlotAssignmentEntry> dictionary = new Dictionary<int, SlotAssignmentEntry>();
foreach (SlotAssignmentEntry @default in defaults)
{
dictionary[@default.ItemGuid] = @default;
}
foreach (SlotAssignmentEntry playerOverride in playerOverrides)
{
dictionary[playerOverride.ItemGuid] = playerOverride;
}
return dictionary.Values.OrderBy((SlotAssignmentEntry v) => v.Slot).ToList();
}
private void SaveDefaults()
{
string contents = JsonSerializer.Serialize(globalDefaults, new JsonSerializerOptions
{
WriteIndented = true
});
File.WriteAllText(DefaultsPath, contents);
}
private void SavePlayer(ulong steamId)
{
if (playerData.TryGetValue(steamId, out var value))
{
string path = Path.Combine(PlayersPath, $"{steamId}.json");
string contents = JsonSerializer.Serialize(value, new JsonSerializerOptions
{
WriteIndented = true
});
File.WriteAllText(path, contents);
}
}
private static void ResolveMissingGuids(SlotAssignmentData data)
{
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
if (Core.PrefabCollectionSystem == null)
{
return;
}
foreach (SlotAssignmentEntry assignment in data.Assignments)
{
if (assignment.ItemGuid == 0)
{
PrefabGUID val = InventorySlotService.ResolveItemGuidByName(assignment.ItemName);
if (((PrefabGUID)(ref val)).GuidHash != 0)
{
assignment.ItemGuid = ((PrefabGUID)(ref val)).GuidHash;
}
}
}
}
private static SlotAssignmentData CreateExampleDefaults()
{
return new SlotAssignmentData
{
Enabled = true,
Assignments =
{
new SlotAssignmentEntry
{
ItemName = "Item_Consumable_BloodRose",
ItemGuid = 0,
Slot = 9
},
new SlotAssignmentEntry
{
ItemName = "Item_Consumable_BloodPotion",
ItemGuid = 0,
Slot = 10
},
new SlotAssignmentEntry
{
ItemName = "Item_Equipment_Cloak",
ItemGuid = 0,
Slot = 11
}
}
};
}
}
}
namespace SlotSort.Patches
{
[HarmonyPatch(typeof(SceneSectionStreamingSystem), "ShutdownAsynchrnonousStreamingSupport")]
internal static class InitializationPatch
{
[HarmonyPostfix]
private static void OneShot_AfterLoad()
{
Core.Initialize();
Plugin.Harmony.Unpatch((MethodBase)typeof(SceneSectionStreamingSystem).GetMethod("ShutdownAsynchrnonousStreamingSupport"), typeof(InitializationPatch).GetMethod("OneShot_AfterLoad"));
}
}
[HarmonyPatch(typeof(SortSingleInventorySystem), "OnUpdate")]
internal static class SortInventoryPatch
{
[HarmonyPostfix]
private static void AfterSort(SortSingleInventorySystem __instance)
{
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
//IL_005c: Unknown result type (might be due to invalid IL or missing references)
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: Unknown result type (might be due to invalid IL or missing references)
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
//IL_0080: Unknown result type (might be due to invalid IL or missing references)
//IL_009f: Unknown result type (might be due to invalid IL or missing references)
//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
if (!Core.HasInitialized)
{
return;
}
EntityQuery eventQuery = __instance._EventQuery;
NativeArray<Entity> val = ((EntityQuery)(ref eventQuery)).ToEntityArray(AllocatorHandle.op_Implicit((Allocator)2));
try
{
Enumerator<Entity> enumerator = val.GetEnumerator();
while (enumerator.MoveNext())
{
Entity current = enumerator.Current;
if (((Entity)(ref current)).Equals(Entity.Null))
{
continue;
}
FromCharacter val2 = current.Read<FromCharacter>();
SortSingleInventoryEvent val3 = current.Read<SortSingleInventoryEvent>();
InventoryOwner val4 = val2.Character.Read<InventoryOwner>();
ref NetworkId inventory = ref val3.Inventory;
object obj = val4;
if (((object)Unsafe.As<NetworkId, NetworkId>(ref inventory)/*cast due to .constrained prefix*/).Equals(obj))
{
ulong platformId = val2.User.Read<User>().PlatformId;
if (Core.SlotAssignments.IsEnabled(platformId))
{
Core.InventorySlots.ApplyAssignments(val2.Character, platformId);
}
}
}
}
catch (Exception e)
{
Core.LogException(e, "SortInventoryPatch");
}
finally
{
val.Dispose();
}
}
}
}
namespace SlotSort.Models
{
internal sealed class SlotAssignmentData
{
public bool Enabled { get; set; } = true;
public List<SlotAssignmentEntry> Assignments { get; set; } = new List<SlotAssignmentEntry>();
public List<int> DisabledDefaultGuids { get; set; } = new List<int>();
}
internal sealed class SlotAssignmentEntry
{
public int ItemGuid { get; set; }
public string ItemName { get; set; } = string.Empty;
public int Slot { get; set; }
}
}
namespace SlotSort.Commands
{
[CommandGroup("slotsort", "ss")]
internal static class SlotSortCommands
{
[Command("gui", null, null, "Open SlotSort settings window (requires ZUI client mod).", null, false)]
public static void OpenGui(ChatCommandContext ctx)
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
Core.Ui.Open(ctx.Event.User, ctx.Event.User.PlatformId);
ctx.Reply("Opening SlotSort panel. Install <color=yellow>ZUI</color> on your client if the window does not appear.");
}
[Command("set", null, null, "Assign an item to a fixed inventory slot (1 = first hotbar slot).", null, false)]
public static void SetSlot(ChatCommandContext ctx, ItemPrefab item, int slot = -1)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
ulong platformId = ctx.Event.User.PlatformId;
if (slot < 1 && !Core.SlotAssignments.TryGetPendingSlot(platformId, out slot))
{
ctx.Reply("Specify a slot number or pick one in GUI (.slotsort pickslot 12).");
return;
}
if (!Core.SlotAssignments.TrySetAssignment(platformId, item.Prefab, slot, out var error))
{
ctx.Reply(error);
return;
}
ctx.Reply($"<color=green>{item.Prefab.PrefabName()}</color> -> slot <color=yellow>{slot}</color>. Press Sort in inventory.");
}
[Command("setid", null, null, "Assign item by internal GUID hash (used by GUI).", null, false)]
public static void SetSlotById(ChatCommandContext ctx, int itemGuid, int slot = -1)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Unknown result type (might be due to invalid IL or missing references)
ulong platformId = ctx.Event.User.PlatformId;
if (slot < 1 && !Core.SlotAssignments.TryGetPendingSlot(platformId, out slot))
{
ctx.Reply("Specify a slot number or pick one first (.slotsort pickslot 12).");
return;
}
if (!Core.SlotAssignments.TrySetByGuid(platformId, itemGuid, slot, out var error))
{
ctx.Reply(error);
return;
}
string prefabName = ECSExtensions.PrefabName(new PrefabGUID(itemGuid));
ctx.Reply($"<color=green>{ItemSearchService.FormatDisplayName(prefabName)}</color> -> slot <color=yellow>{slot}</color>.");
}
[Command("search", null, null, "Search items by name and show matches in chat and GUI.", null, false)]
public static void SearchItems(ChatCommandContext ctx, string query)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_017e: Unknown result type (might be due to invalid IL or missing references)
ulong platformId = ctx.Event.User.PlatformId;
List<ItemSearchService.ItemMatch> list = ItemSearchService.FindItems(query);
if (list.Count == 0)
{
ctx.Reply("No items found matching \"" + query + "\".");
return;
}
Core.SlotAssignments.SetSearchResults(platformId, query, list);
StringBuilder stringBuilder = new StringBuilder();
StringBuilder stringBuilder2 = stringBuilder;
StringBuilder stringBuilder3 = stringBuilder2;
StringBuilder.AppendInterpolatedStringHandler handler = new StringBuilder.AppendInterpolatedStringHandler(44, 2, stringBuilder2);
handler.AppendLiteral("Found ");
handler.AppendFormatted(list.Count);
handler.AppendLiteral(" item(s) for \"<color=yellow>");
handler.AppendFormatted(query);
handler.AppendLiteral("</color>\":");
stringBuilder3.AppendLine(ref handler);
int num = 0;
foreach (ItemSearchService.ItemMatch item in list)
{
if (num >= 10)
{
stringBuilder2 = stringBuilder;
StringBuilder stringBuilder4 = stringBuilder2;
handler = new StringBuilder.AppendInterpolatedStringHandler(37, 1, stringBuilder2);
handler.AppendLiteral(" ...and ");
handler.AppendFormatted(list.Count - 10);
handler.AppendLiteral(" more in GUI (.slotsort gui)");
stringBuilder4.AppendLine(ref handler);
break;
}
stringBuilder2 = stringBuilder;
StringBuilder stringBuilder5 = stringBuilder2;
handler = new StringBuilder.AppendInterpolatedStringHandler(23, 1, stringBuilder2);
handler.AppendLiteral(" <color=green>");
handler.AppendFormatted(ItemSearchService.FormatDisplayName(item.PrefabName));
handler.AppendLiteral("</color>");
stringBuilder5.AppendLine(ref handler);
num++;
}
ctx.Reply(stringBuilder.ToString().TrimEnd());
Core.Ui.Open(ctx.Event.User, platformId);
}
[Command("pickslot", null, null, "Remember a slot for the next .slotsort set command.", null, false)]
public static void PickSlot(ChatCommandContext ctx, int slot)
{
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
if (slot < 1)
{
ctx.Reply("Slot must be at least 1.");
return;
}
Core.SlotAssignments.SetPendingSlot(ctx.Event.User.PlatformId, slot);
ctx.Reply($"Selected slot <color=yellow>{slot}</color>. Now run: .slotsort set \"item name\"");
}
[Command("remove", "rm", null, "Remove a slot assignment for an item.", null, false)]
public static void RemoveSlot(ChatCommandContext ctx, ItemPrefab item)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
ulong platformId = ctx.Event.User.PlatformId;
if (!Core.SlotAssignments.TryRemoveAssignment(platformId, item.Prefab, out var error))
{
ctx.Reply(error);
}
else
{
ctx.Reply("Removed rule for <color=yellow>" + item.Prefab.PrefabName() + "</color>.");
}
}
[Command("rmid", null, null, "Remove assignment by item GUID (used by GUI).", null, false)]
public static void RemoveById(ChatCommandContext ctx, int itemGuid)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
ulong platformId = ctx.Event.User.PlatformId;
if (!Core.SlotAssignments.TryRemoveByGuid(platformId, itemGuid, out var error))
{
ctx.Reply(error);
}
else
{
ctx.Reply("Rule removed.");
}
}
[Command("list", "ls", null, "Show your active slot assignments.", null, false)]
public static void ListSlots(ChatCommandContext ctx)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_011d: Unknown result type (might be due to invalid IL or missing references)
ulong platformId = ctx.Event.User.PlatformId;
IReadOnlyList<SlotAssignmentEntry> assignments = Core.SlotAssignments.GetAssignments(platformId);
bool flag = Core.SlotAssignments.IsEnabled(platformId);
if (assignments.Count == 0)
{
ctx.Reply("SlotSort is " + (flag ? "enabled" : "disabled") + ". No assignments configured.");
return;
}
StringBuilder stringBuilder = new StringBuilder();
StringBuilder stringBuilder2 = stringBuilder;
StringBuilder stringBuilder3 = stringBuilder2;
StringBuilder.AppendInterpolatedStringHandler handler = new StringBuilder.AppendInterpolatedStringHandler(10, 1, stringBuilder2);
handler.AppendLiteral("SlotSort: ");
handler.AppendFormatted(flag ? "<color=green>enabled</color>" : "<color=red>disabled</color>");
stringBuilder3.AppendLine(ref handler);
stringBuilder2 = stringBuilder;
StringBuilder stringBuilder4 = stringBuilder2;
handler = new StringBuilder.AppendInterpolatedStringHandler(26, 2, stringBuilder2);
handler.AppendLiteral("Slots 1-");
handler.AppendFormatted(8);
handler.AppendLiteral(" = hotbar, ");
handler.AppendFormatted(9);
handler.AppendLiteral("+ = bag");
stringBuilder4.AppendLine(ref handler);
stringBuilder.AppendLine("Assignments:");
foreach (SlotAssignmentEntry item in assignments)
{
string value = ((item.ItemGuid != 0) ? ECSExtensions.PrefabName(new PrefabGUID(item.ItemGuid)) : item.ItemName);
stringBuilder2 = stringBuilder;
StringBuilder stringBuilder5 = stringBuilder2;
handler = new StringBuilder.AppendInterpolatedStringHandler(28, 2, stringBuilder2);
handler.AppendLiteral(" <color=yellow>");
handler.AppendFormatted(item.Slot);
handler.AppendLiteral("</color> -> ");
handler.AppendFormatted(value);
stringBuilder5.AppendLine(ref handler);
}
ctx.Reply(stringBuilder.ToString().TrimEnd());
}
[Command("toggle", null, null, "Enable or disable slot sorting for your character.", null, false)]
public static void Toggle(ChatCommandContext ctx)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
ulong platformId = ctx.Event.User.PlatformId;
bool flag = Core.SlotAssignments.ToggleEnabled(platformId);
ctx.Reply("SlotSort is " + (flag ? "<color=green>enabled</color>" : "<color=red>disabled</color>") + ".");
}
[Command("sort", null, null, "Apply slot assignments without pressing the sort button.", null, false)]
public static void SortNow(ChatCommandContext ctx)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
ulong platformId = ctx.Event.User.PlatformId;
if (!Core.SlotAssignments.IsEnabled(platformId))
{
ctx.Reply("SlotSort is disabled. Use .slotsort toggle");
return;
}
Core.InventorySlots.ApplyAssignments(ctx.Event.SenderCharacterEntity, platformId);
ctx.Reply("Slot assignments applied.");
}
}
}
namespace SlotSort.Commands.Converters
{
internal readonly record struct ItemPrefab(PrefabGUID Prefab);
internal sealed class ItemPrefabConverter : CommandArgumentConverter<ItemPrefab>
{
public override ItemPrefab Parse(ICommandContext ctx, string input)
{
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
if (ItemSearchService.TryResolveExact(input, out var prefab))
{
return new ItemPrefab(prefab);
}
List<ItemSearchService.ItemMatch> list = ItemSearchService.FindItems(input, 2);
if (list.Count == 1)
{
return new ItemPrefab(list[0].Guid);
}
if (list.Count > 1)
{
throw ctx.Error("Multiple items match \"" + input + "\". Be more specific or use .slotsort search " + input);
}
throw ctx.Error("No item found matching \"" + input + "\".");
}
}
}
