1134 lines
50 KiB
C#
1134 lines
50 KiB
C#
// Decompiled with JetBrains decompiler
|
|
// Type: Terraria.UI.ItemSorting
|
|
// Assembly: Terraria, Version=1.4.0.5, Culture=neutral, PublicKeyToken=null
|
|
// MVID: 67F9E73E-0A81-4937-A22C-5515CD405A83
|
|
// Assembly location: C:\Users\mikeyisbaeyt\Downloads\depotdownloader-2.4.5\depots\105601\6707058\Terraria.exe
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using Terraria.ID;
|
|
|
|
namespace Terraria.UI
|
|
{
|
|
public class ItemSorting
|
|
{
|
|
private static List<ItemSorting.ItemSortingLayer> _layerList = new List<ItemSorting.ItemSortingLayer>();
|
|
private static Dictionary<string, List<int>> _layerWhiteLists = new Dictionary<string, List<int>>();
|
|
|
|
public static void SetupWhiteLists()
|
|
{
|
|
ItemSorting._layerWhiteLists.Clear();
|
|
List<ItemSorting.ItemSortingLayer> itemSortingLayerList = new List<ItemSorting.ItemSortingLayer>();
|
|
List<Item> objList = new List<Item>();
|
|
List<int> intList1 = new List<int>();
|
|
itemSortingLayerList.Add(ItemSorting.ItemSortingLayers.WeaponsMelee);
|
|
itemSortingLayerList.Add(ItemSorting.ItemSortingLayers.WeaponsRanged);
|
|
itemSortingLayerList.Add(ItemSorting.ItemSortingLayers.WeaponsMagic);
|
|
itemSortingLayerList.Add(ItemSorting.ItemSortingLayers.WeaponsMinions);
|
|
itemSortingLayerList.Add(ItemSorting.ItemSortingLayers.WeaponsAssorted);
|
|
itemSortingLayerList.Add(ItemSorting.ItemSortingLayers.WeaponsAmmo);
|
|
itemSortingLayerList.Add(ItemSorting.ItemSortingLayers.ToolsPicksaws);
|
|
itemSortingLayerList.Add(ItemSorting.ItemSortingLayers.ToolsHamaxes);
|
|
itemSortingLayerList.Add(ItemSorting.ItemSortingLayers.ToolsPickaxes);
|
|
itemSortingLayerList.Add(ItemSorting.ItemSortingLayers.ToolsAxes);
|
|
itemSortingLayerList.Add(ItemSorting.ItemSortingLayers.ToolsHammers);
|
|
itemSortingLayerList.Add(ItemSorting.ItemSortingLayers.ToolsTerraforming);
|
|
itemSortingLayerList.Add(ItemSorting.ItemSortingLayers.ToolsAmmoLeftovers);
|
|
itemSortingLayerList.Add(ItemSorting.ItemSortingLayers.ArmorCombat);
|
|
itemSortingLayerList.Add(ItemSorting.ItemSortingLayers.ArmorVanity);
|
|
itemSortingLayerList.Add(ItemSorting.ItemSortingLayers.ArmorAccessories);
|
|
itemSortingLayerList.Add(ItemSorting.ItemSortingLayers.EquipGrapple);
|
|
itemSortingLayerList.Add(ItemSorting.ItemSortingLayers.EquipMount);
|
|
itemSortingLayerList.Add(ItemSorting.ItemSortingLayers.EquipCart);
|
|
itemSortingLayerList.Add(ItemSorting.ItemSortingLayers.EquipLightPet);
|
|
itemSortingLayerList.Add(ItemSorting.ItemSortingLayers.EquipVanityPet);
|
|
itemSortingLayerList.Add(ItemSorting.ItemSortingLayers.PotionsDyes);
|
|
itemSortingLayerList.Add(ItemSorting.ItemSortingLayers.PotionsHairDyes);
|
|
itemSortingLayerList.Add(ItemSorting.ItemSortingLayers.PotionsLife);
|
|
itemSortingLayerList.Add(ItemSorting.ItemSortingLayers.PotionsMana);
|
|
itemSortingLayerList.Add(ItemSorting.ItemSortingLayers.PotionsElixirs);
|
|
itemSortingLayerList.Add(ItemSorting.ItemSortingLayers.PotionsBuffs);
|
|
itemSortingLayerList.Add(ItemSorting.ItemSortingLayers.MiscValuables);
|
|
itemSortingLayerList.Add(ItemSorting.ItemSortingLayers.MiscPainting);
|
|
itemSortingLayerList.Add(ItemSorting.ItemSortingLayers.MiscWiring);
|
|
itemSortingLayerList.Add(ItemSorting.ItemSortingLayers.MiscMaterials);
|
|
itemSortingLayerList.Add(ItemSorting.ItemSortingLayers.MiscRopes);
|
|
itemSortingLayerList.Add(ItemSorting.ItemSortingLayers.MiscExtractinator);
|
|
itemSortingLayerList.Add(ItemSorting.ItemSortingLayers.LastMaterials);
|
|
itemSortingLayerList.Add(ItemSorting.ItemSortingLayers.LastTilesImportant);
|
|
itemSortingLayerList.Add(ItemSorting.ItemSortingLayers.LastTilesCommon);
|
|
itemSortingLayerList.Add(ItemSorting.ItemSortingLayers.LastNotTrash);
|
|
itemSortingLayerList.Add(ItemSorting.ItemSortingLayers.LastTrash);
|
|
for (int type = -48; type < 5045; ++type)
|
|
{
|
|
Item obj = new Item();
|
|
obj.netDefaults(type);
|
|
objList.Add(obj);
|
|
intList1.Add(type + 48);
|
|
}
|
|
Item[] array = objList.ToArray();
|
|
foreach (ItemSorting.ItemSortingLayer itemSortingLayer in itemSortingLayerList)
|
|
{
|
|
List<int> intList2 = itemSortingLayer.SortingMethod(itemSortingLayer, array, intList1);
|
|
List<int> intList3 = new List<int>();
|
|
for (int index = 0; index < intList2.Count; ++index)
|
|
intList3.Add(array[intList2[index]].netID);
|
|
ItemSorting._layerWhiteLists.Add(itemSortingLayer.Name, intList3);
|
|
}
|
|
}
|
|
|
|
private static void SetupSortingPriorities()
|
|
{
|
|
Player player = Main.player[Main.myPlayer];
|
|
ItemSorting._layerList.Clear();
|
|
List<float> floatList = new List<float>()
|
|
{
|
|
player.meleeDamage,
|
|
player.rangedDamage,
|
|
player.magicDamage,
|
|
player.minionDamage
|
|
};
|
|
floatList.Sort((Comparison<float>) ((x, y) => y.CompareTo(x)));
|
|
for (int index = 0; index < 5; ++index)
|
|
{
|
|
if (!ItemSorting._layerList.Contains(ItemSorting.ItemSortingLayers.WeaponsMelee) && (double) player.meleeDamage == (double) floatList[0])
|
|
{
|
|
floatList.RemoveAt(0);
|
|
ItemSorting._layerList.Add(ItemSorting.ItemSortingLayers.WeaponsMelee);
|
|
}
|
|
if (!ItemSorting._layerList.Contains(ItemSorting.ItemSortingLayers.WeaponsRanged) && (double) player.rangedDamage == (double) floatList[0])
|
|
{
|
|
floatList.RemoveAt(0);
|
|
ItemSorting._layerList.Add(ItemSorting.ItemSortingLayers.WeaponsRanged);
|
|
}
|
|
if (!ItemSorting._layerList.Contains(ItemSorting.ItemSortingLayers.WeaponsMagic) && (double) player.magicDamage == (double) floatList[0])
|
|
{
|
|
floatList.RemoveAt(0);
|
|
ItemSorting._layerList.Add(ItemSorting.ItemSortingLayers.WeaponsMagic);
|
|
}
|
|
if (!ItemSorting._layerList.Contains(ItemSorting.ItemSortingLayers.WeaponsMinions) && (double) player.minionDamage == (double) floatList[0])
|
|
{
|
|
floatList.RemoveAt(0);
|
|
ItemSorting._layerList.Add(ItemSorting.ItemSortingLayers.WeaponsMinions);
|
|
}
|
|
}
|
|
ItemSorting._layerList.Add(ItemSorting.ItemSortingLayers.WeaponsAssorted);
|
|
ItemSorting._layerList.Add(ItemSorting.ItemSortingLayers.WeaponsAmmo);
|
|
ItemSorting._layerList.Add(ItemSorting.ItemSortingLayers.ToolsPicksaws);
|
|
ItemSorting._layerList.Add(ItemSorting.ItemSortingLayers.ToolsHamaxes);
|
|
ItemSorting._layerList.Add(ItemSorting.ItemSortingLayers.ToolsPickaxes);
|
|
ItemSorting._layerList.Add(ItemSorting.ItemSortingLayers.ToolsAxes);
|
|
ItemSorting._layerList.Add(ItemSorting.ItemSortingLayers.ToolsHammers);
|
|
ItemSorting._layerList.Add(ItemSorting.ItemSortingLayers.ToolsTerraforming);
|
|
ItemSorting._layerList.Add(ItemSorting.ItemSortingLayers.ToolsAmmoLeftovers);
|
|
ItemSorting._layerList.Add(ItemSorting.ItemSortingLayers.ArmorCombat);
|
|
ItemSorting._layerList.Add(ItemSorting.ItemSortingLayers.ArmorVanity);
|
|
ItemSorting._layerList.Add(ItemSorting.ItemSortingLayers.ArmorAccessories);
|
|
ItemSorting._layerList.Add(ItemSorting.ItemSortingLayers.EquipGrapple);
|
|
ItemSorting._layerList.Add(ItemSorting.ItemSortingLayers.EquipMount);
|
|
ItemSorting._layerList.Add(ItemSorting.ItemSortingLayers.EquipCart);
|
|
ItemSorting._layerList.Add(ItemSorting.ItemSortingLayers.EquipLightPet);
|
|
ItemSorting._layerList.Add(ItemSorting.ItemSortingLayers.EquipVanityPet);
|
|
ItemSorting._layerList.Add(ItemSorting.ItemSortingLayers.PotionsDyes);
|
|
ItemSorting._layerList.Add(ItemSorting.ItemSortingLayers.PotionsHairDyes);
|
|
ItemSorting._layerList.Add(ItemSorting.ItemSortingLayers.PotionsLife);
|
|
ItemSorting._layerList.Add(ItemSorting.ItemSortingLayers.PotionsMana);
|
|
ItemSorting._layerList.Add(ItemSorting.ItemSortingLayers.PotionsElixirs);
|
|
ItemSorting._layerList.Add(ItemSorting.ItemSortingLayers.PotionsBuffs);
|
|
ItemSorting._layerList.Add(ItemSorting.ItemSortingLayers.MiscValuables);
|
|
ItemSorting._layerList.Add(ItemSorting.ItemSortingLayers.MiscPainting);
|
|
ItemSorting._layerList.Add(ItemSorting.ItemSortingLayers.MiscWiring);
|
|
ItemSorting._layerList.Add(ItemSorting.ItemSortingLayers.MiscMaterials);
|
|
ItemSorting._layerList.Add(ItemSorting.ItemSortingLayers.MiscRopes);
|
|
ItemSorting._layerList.Add(ItemSorting.ItemSortingLayers.MiscExtractinator);
|
|
ItemSorting._layerList.Add(ItemSorting.ItemSortingLayers.LastMaterials);
|
|
ItemSorting._layerList.Add(ItemSorting.ItemSortingLayers.LastTilesImportant);
|
|
ItemSorting._layerList.Add(ItemSorting.ItemSortingLayers.LastTilesCommon);
|
|
ItemSorting._layerList.Add(ItemSorting.ItemSortingLayers.LastNotTrash);
|
|
ItemSorting._layerList.Add(ItemSorting.ItemSortingLayers.LastTrash);
|
|
}
|
|
|
|
private static void Sort(Item[] inv, params int[] ignoreSlots)
|
|
{
|
|
ItemSorting.SetupSortingPriorities();
|
|
List<int> intList1 = new List<int>();
|
|
for (int index = 0; index < inv.Length; ++index)
|
|
{
|
|
if (!((IEnumerable<int>) ignoreSlots).Contains<int>(index))
|
|
{
|
|
Item obj = inv[index];
|
|
if (obj != null && obj.stack != 0 && obj.type != 0 && !obj.favorited)
|
|
intList1.Add(index);
|
|
}
|
|
}
|
|
for (int index1 = 0; index1 < intList1.Count; ++index1)
|
|
{
|
|
Item obj1 = inv[intList1[index1]];
|
|
if (obj1.stack < obj1.maxStack)
|
|
{
|
|
int num1 = obj1.maxStack - obj1.stack;
|
|
for (int index2 = index1; index2 < intList1.Count; ++index2)
|
|
{
|
|
if (index1 != index2)
|
|
{
|
|
Item obj2 = inv[intList1[index2]];
|
|
if (obj1.type == obj2.type && obj2.stack != obj2.maxStack)
|
|
{
|
|
int num2 = obj2.stack;
|
|
if (num1 < num2)
|
|
num2 = num1;
|
|
obj1.stack += num2;
|
|
obj2.stack -= num2;
|
|
num1 -= num2;
|
|
if (obj2.stack == 0)
|
|
{
|
|
inv[intList1[index2]] = new Item();
|
|
intList1.Remove(intList1[index2]);
|
|
--index1;
|
|
int num3 = index2 - 1;
|
|
break;
|
|
}
|
|
if (num1 == 0)
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
List<int> intList2 = new List<int>((IEnumerable<int>) intList1);
|
|
for (int index = 0; index < inv.Length; ++index)
|
|
{
|
|
if (!((IEnumerable<int>) ignoreSlots).Contains<int>(index) && !intList2.Contains(index))
|
|
{
|
|
Item obj = inv[index];
|
|
if (obj == null || obj.stack == 0 || obj.type == 0)
|
|
intList2.Add(index);
|
|
}
|
|
}
|
|
intList2.Sort();
|
|
List<int> intList3 = new List<int>();
|
|
List<int> intList4 = new List<int>();
|
|
foreach (ItemSorting.ItemSortingLayer layer in ItemSorting._layerList)
|
|
{
|
|
List<int> intList5 = layer.SortingMethod(layer, inv, intList1);
|
|
if (intList5.Count > 0)
|
|
intList4.Add(intList5.Count);
|
|
intList3.AddRange((IEnumerable<int>) intList5);
|
|
}
|
|
intList3.AddRange((IEnumerable<int>) intList1);
|
|
List<Item> objList = new List<Item>();
|
|
foreach (int index in intList3)
|
|
{
|
|
objList.Add(inv[index]);
|
|
inv[index] = new Item();
|
|
}
|
|
float num = 1f / (float) intList4.Count;
|
|
float hue = num / 2f;
|
|
for (int index3 = 0; index3 < objList.Count; ++index3)
|
|
{
|
|
int index4 = intList2[0];
|
|
ItemSlot.SetGlow(index4, hue, Main.player[Main.myPlayer].chest != -1);
|
|
--intList4[0];
|
|
if (intList4[0] == 0)
|
|
{
|
|
intList4.RemoveAt(0);
|
|
hue += num;
|
|
}
|
|
inv[index4] = objList[index3];
|
|
intList2.Remove(index4);
|
|
}
|
|
}
|
|
|
|
public static void SortInventory()
|
|
{
|
|
if (!Main.LocalPlayer.HasItem(905))
|
|
ItemSorting.SortCoins();
|
|
ItemSorting.SortAmmo();
|
|
ItemSorting.Sort(Main.player[Main.myPlayer].inventory, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 50, 51, 52, 53, 54, 55, 56, 57, 58);
|
|
}
|
|
|
|
public static void SortChest()
|
|
{
|
|
int chest = Main.player[Main.myPlayer].chest;
|
|
if (chest == -1)
|
|
return;
|
|
Item[] inv = Main.player[Main.myPlayer].bank.item;
|
|
if (chest == -3)
|
|
inv = Main.player[Main.myPlayer].bank2.item;
|
|
if (chest == -4)
|
|
inv = Main.player[Main.myPlayer].bank3.item;
|
|
if (chest == -5)
|
|
inv = Main.player[Main.myPlayer].bank4.item;
|
|
if (chest > -1)
|
|
inv = Main.chest[chest].item;
|
|
Tuple<int, int, int>[] tupleArray1 = new Tuple<int, int, int>[40];
|
|
for (int index = 0; index < 40; ++index)
|
|
tupleArray1[index] = Tuple.Create<int, int, int>(inv[index].netID, inv[index].stack, (int) inv[index].prefix);
|
|
ItemSorting.Sort(inv);
|
|
Tuple<int, int, int>[] tupleArray2 = new Tuple<int, int, int>[40];
|
|
for (int index = 0; index < 40; ++index)
|
|
tupleArray2[index] = Tuple.Create<int, int, int>(inv[index].netID, inv[index].stack, (int) inv[index].prefix);
|
|
if (Main.netMode != 1 || Main.player[Main.myPlayer].chest <= -1)
|
|
return;
|
|
for (int index = 0; index < 40; ++index)
|
|
{
|
|
if (tupleArray2[index] != tupleArray1[index])
|
|
NetMessage.SendData(32, number: Main.player[Main.myPlayer].chest, number2: ((float) index));
|
|
}
|
|
}
|
|
|
|
public static void SortAmmo()
|
|
{
|
|
ItemSorting.ClearAmmoSlotSpaces();
|
|
ItemSorting.FillAmmoFromInventory();
|
|
}
|
|
|
|
public static void FillAmmoFromInventory()
|
|
{
|
|
List<int> intList1 = new List<int>();
|
|
List<int> intList2 = new List<int>();
|
|
Item[] inventory = Main.player[Main.myPlayer].inventory;
|
|
for (int index = 54; index < 58; ++index)
|
|
{
|
|
ItemSlot.SetGlow(index, 0.31f, false);
|
|
Item obj = inventory[index];
|
|
if (obj.IsAir)
|
|
intList2.Add(index);
|
|
else if (obj.ammo != AmmoID.None)
|
|
{
|
|
if (!intList1.Contains(obj.type))
|
|
intList1.Add(obj.type);
|
|
ItemSorting.RefillItemStack(inventory, inventory[index], 0, 50);
|
|
}
|
|
}
|
|
if (intList2.Count < 1)
|
|
return;
|
|
for (int index1 = 0; index1 < 50; ++index1)
|
|
{
|
|
Item obj = inventory[index1];
|
|
if (obj.stack >= 1 && obj.CanFillEmptyAmmoSlot() && intList1.Contains(obj.type))
|
|
{
|
|
int index2 = intList2[0];
|
|
intList2.Remove(index2);
|
|
Utils.Swap<Item>(ref inventory[index1], ref inventory[index2]);
|
|
ItemSorting.RefillItemStack(inventory, inventory[index2], 0, 50);
|
|
if (intList2.Count == 0)
|
|
break;
|
|
}
|
|
}
|
|
if (intList2.Count < 1)
|
|
return;
|
|
for (int index3 = 0; index3 < 50; ++index3)
|
|
{
|
|
Item obj = inventory[index3];
|
|
if (obj.stack >= 1 && obj.CanFillEmptyAmmoSlot() && obj.FitsAmmoSlot())
|
|
{
|
|
int index4 = intList2[0];
|
|
intList2.Remove(index4);
|
|
Utils.Swap<Item>(ref inventory[index3], ref inventory[index4]);
|
|
ItemSorting.RefillItemStack(inventory, inventory[index4], 0, 50);
|
|
if (intList2.Count == 0)
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void ClearAmmoSlotSpaces()
|
|
{
|
|
Item[] inventory = Main.player[Main.myPlayer].inventory;
|
|
for (int index = 54; index < 58; ++index)
|
|
{
|
|
Item itemToRefill = inventory[index];
|
|
if (!itemToRefill.IsAir && itemToRefill.ammo != AmmoID.None && itemToRefill.stack < itemToRefill.maxStack)
|
|
ItemSorting.RefillItemStack(inventory, itemToRefill, index + 1, 58);
|
|
}
|
|
for (int slot = 54; slot < 58; ++slot)
|
|
{
|
|
if (inventory[slot].type > 0)
|
|
ItemSorting.TrySlidingUp(inventory, slot, 54);
|
|
}
|
|
}
|
|
|
|
private static void SortCoins()
|
|
{
|
|
Item[] inventory = Main.LocalPlayer.inventory;
|
|
bool overFlowing;
|
|
long count = Utils.CoinsCount(out overFlowing, inventory, 58);
|
|
if (overFlowing)
|
|
return;
|
|
int[] numArray = Utils.CoinsSplit(count);
|
|
int num1 = 0;
|
|
for (int index = 0; index < 3; ++index)
|
|
{
|
|
int num2 = numArray[index];
|
|
while (num2 > 0)
|
|
{
|
|
num2 -= 99;
|
|
++num1;
|
|
}
|
|
}
|
|
int num3 = numArray[3];
|
|
while (num3 > 999)
|
|
{
|
|
num3 -= 999;
|
|
++num1;
|
|
}
|
|
int num4 = 0;
|
|
for (int index = 0; index < 58; ++index)
|
|
{
|
|
if (inventory[index].type >= 71 && inventory[index].type <= 74 && inventory[index].stack > 0)
|
|
++num4;
|
|
}
|
|
if (num4 < num1)
|
|
return;
|
|
for (int index = 0; index < 58; ++index)
|
|
{
|
|
if (inventory[index].type >= 71 && inventory[index].type <= 74 && inventory[index].stack > 0)
|
|
inventory[index].TurnToAir();
|
|
}
|
|
label_23:
|
|
int index1;
|
|
int num5;
|
|
bool flag;
|
|
do
|
|
{
|
|
index1 = -1;
|
|
for (int index2 = 3; index2 >= 0; --index2)
|
|
{
|
|
if (numArray[index2] > 0)
|
|
{
|
|
index1 = index2;
|
|
break;
|
|
}
|
|
}
|
|
if (index1 != -1)
|
|
{
|
|
num5 = numArray[index1];
|
|
if (index1 == 3 && num5 > 999)
|
|
num5 = 999;
|
|
flag = false;
|
|
if (!flag)
|
|
{
|
|
for (int index3 = 50; index3 < 54; ++index3)
|
|
{
|
|
if (inventory[index3].IsAir)
|
|
{
|
|
inventory[index3].SetDefaults(71 + index1);
|
|
inventory[index3].stack = num5;
|
|
numArray[index1] -= num5;
|
|
flag = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
goto label_17;
|
|
}
|
|
while (flag);
|
|
goto label_38;
|
|
label_17:
|
|
return;
|
|
label_38:
|
|
for (int index4 = 0; index4 < 50; ++index4)
|
|
{
|
|
if (inventory[index4].IsAir)
|
|
{
|
|
inventory[index4].SetDefaults(71 + index1);
|
|
inventory[index4].stack = num5;
|
|
numArray[index1] -= num5;
|
|
break;
|
|
}
|
|
}
|
|
goto label_23;
|
|
}
|
|
|
|
private static void RefillItemStack(
|
|
Item[] inv,
|
|
Item itemToRefill,
|
|
int loopStartIndex,
|
|
int loopEndIndex)
|
|
{
|
|
int num1 = itemToRefill.maxStack - itemToRefill.stack;
|
|
if (num1 <= 0)
|
|
return;
|
|
for (int index = loopStartIndex; index < loopEndIndex; ++index)
|
|
{
|
|
Item obj = inv[index];
|
|
if (obj.stack >= 1 && obj.type == itemToRefill.type)
|
|
{
|
|
int num2 = obj.stack;
|
|
if (num2 > num1)
|
|
num2 = num1;
|
|
num1 -= num2;
|
|
itemToRefill.stack += num2;
|
|
obj.stack -= num2;
|
|
if (obj.stack <= 0)
|
|
obj.TurnToAir();
|
|
if (num1 <= 0)
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void TrySlidingUp(Item[] inv, int slot, int minimumIndex)
|
|
{
|
|
for (int index = slot; index > minimumIndex; --index)
|
|
{
|
|
if (inv[index - 1].IsAir)
|
|
Utils.Swap<Item>(ref inv[index], ref inv[index - 1]);
|
|
}
|
|
}
|
|
|
|
private class ItemSortingLayer
|
|
{
|
|
public readonly string Name;
|
|
public readonly Func<ItemSorting.ItemSortingLayer, Item[], List<int>, List<int>> SortingMethod;
|
|
|
|
public ItemSortingLayer(
|
|
string name,
|
|
Func<ItemSorting.ItemSortingLayer, Item[], List<int>, List<int>> method)
|
|
{
|
|
this.Name = name;
|
|
this.SortingMethod = method;
|
|
}
|
|
|
|
public void Validate(ref List<int> indexesSortable, Item[] inv)
|
|
{
|
|
List<int> list;
|
|
if (!ItemSorting._layerWhiteLists.TryGetValue(this.Name, out list))
|
|
return;
|
|
indexesSortable = indexesSortable.Where<int>((Func<int, bool>) (i => list.Contains(inv[i].netID))).ToList<int>();
|
|
}
|
|
|
|
public override string ToString() => this.Name;
|
|
}
|
|
|
|
private class ItemSortingLayers
|
|
{
|
|
public static ItemSorting.ItemSortingLayer WeaponsMelee = new ItemSorting.ItemSortingLayer("Weapons - Melee", (Func<ItemSorting.ItemSortingLayer, Item[], List<int>, List<int>>) ((layer, inv, itemsToSort) =>
|
|
{
|
|
List<int> list = itemsToSort.Where<int>((Func<int, bool>) (i => inv[i].maxStack == 1 && inv[i].damage > 0 && inv[i].ammo == 0 && inv[i].melee && inv[i].pick < 1 && inv[i].hammer < 1 && inv[i].axe < 1)).ToList<int>();
|
|
layer.Validate(ref list, inv);
|
|
foreach (int num in list)
|
|
itemsToSort.Remove(num);
|
|
list.Sort((Comparison<int>) ((x, y) =>
|
|
{
|
|
int num = inv[y].OriginalRarity.CompareTo(inv[x].OriginalRarity);
|
|
if (num == 0)
|
|
num = inv[y].OriginalDamage.CompareTo(inv[x].OriginalDamage);
|
|
if (num == 0)
|
|
num = x.CompareTo(y);
|
|
return num;
|
|
}));
|
|
return list;
|
|
}));
|
|
public static ItemSorting.ItemSortingLayer WeaponsRanged = new ItemSorting.ItemSortingLayer("Weapons - Ranged", (Func<ItemSorting.ItemSortingLayer, Item[], List<int>, List<int>>) ((layer, inv, itemsToSort) =>
|
|
{
|
|
List<int> list = itemsToSort.Where<int>((Func<int, bool>) (i => inv[i].maxStack == 1 && inv[i].damage > 0 && inv[i].ammo == 0 && inv[i].ranged)).ToList<int>();
|
|
layer.Validate(ref list, inv);
|
|
foreach (int num in list)
|
|
itemsToSort.Remove(num);
|
|
list.Sort((Comparison<int>) ((x, y) =>
|
|
{
|
|
int num = inv[y].OriginalRarity.CompareTo(inv[x].OriginalRarity);
|
|
if (num == 0)
|
|
num = inv[y].OriginalDamage.CompareTo(inv[x].OriginalDamage);
|
|
if (num == 0)
|
|
num = x.CompareTo(y);
|
|
return num;
|
|
}));
|
|
return list;
|
|
}));
|
|
public static ItemSorting.ItemSortingLayer WeaponsMagic = new ItemSorting.ItemSortingLayer("Weapons - Magic", (Func<ItemSorting.ItemSortingLayer, Item[], List<int>, List<int>>) ((layer, inv, itemsToSort) =>
|
|
{
|
|
List<int> list = itemsToSort.Where<int>((Func<int, bool>) (i => inv[i].maxStack == 1 && inv[i].damage > 0 && inv[i].ammo == 0 && inv[i].magic)).ToList<int>();
|
|
layer.Validate(ref list, inv);
|
|
foreach (int num in list)
|
|
itemsToSort.Remove(num);
|
|
list.Sort((Comparison<int>) ((x, y) =>
|
|
{
|
|
int num = inv[y].OriginalRarity.CompareTo(inv[x].OriginalRarity);
|
|
if (num == 0)
|
|
num = inv[y].OriginalDamage.CompareTo(inv[x].OriginalDamage);
|
|
if (num == 0)
|
|
num = x.CompareTo(y);
|
|
return num;
|
|
}));
|
|
return list;
|
|
}));
|
|
public static ItemSorting.ItemSortingLayer WeaponsMinions = new ItemSorting.ItemSortingLayer("Weapons - Minions", (Func<ItemSorting.ItemSortingLayer, Item[], List<int>, List<int>>) ((layer, inv, itemsToSort) =>
|
|
{
|
|
List<int> list = itemsToSort.Where<int>((Func<int, bool>) (i => inv[i].maxStack == 1 && inv[i].damage > 0 && inv[i].summon)).ToList<int>();
|
|
layer.Validate(ref list, inv);
|
|
foreach (int num in list)
|
|
itemsToSort.Remove(num);
|
|
list.Sort((Comparison<int>) ((x, y) =>
|
|
{
|
|
int num = inv[y].OriginalRarity.CompareTo(inv[x].OriginalRarity);
|
|
if (num == 0)
|
|
num = inv[y].OriginalDamage.CompareTo(inv[x].OriginalDamage);
|
|
if (num == 0)
|
|
num = x.CompareTo(y);
|
|
return num;
|
|
}));
|
|
return list;
|
|
}));
|
|
public static ItemSorting.ItemSortingLayer WeaponsAssorted = new ItemSorting.ItemSortingLayer("Weapons - Assorted", (Func<ItemSorting.ItemSortingLayer, Item[], List<int>, List<int>>) ((layer, inv, itemsToSort) =>
|
|
{
|
|
List<int> list = itemsToSort.Where<int>((Func<int, bool>) (i => inv[i].damage > 0 && inv[i].ammo == 0 && inv[i].pick == 0 && inv[i].axe == 0 && inv[i].hammer == 0)).ToList<int>();
|
|
layer.Validate(ref list, inv);
|
|
foreach (int num in list)
|
|
itemsToSort.Remove(num);
|
|
list.Sort((Comparison<int>) ((x, y) =>
|
|
{
|
|
int num = inv[y].OriginalRarity.CompareTo(inv[x].OriginalRarity);
|
|
if (num == 0)
|
|
num = inv[y].OriginalDamage.CompareTo(inv[x].OriginalDamage);
|
|
if (num == 0)
|
|
num = x.CompareTo(y);
|
|
return num;
|
|
}));
|
|
return list;
|
|
}));
|
|
public static ItemSorting.ItemSortingLayer WeaponsAmmo = new ItemSorting.ItemSortingLayer("Weapons - Ammo", (Func<ItemSorting.ItemSortingLayer, Item[], List<int>, List<int>>) ((layer, inv, itemsToSort) =>
|
|
{
|
|
List<int> list = itemsToSort.Where<int>((Func<int, bool>) (i => inv[i].ammo > 0 && inv[i].damage > 0)).ToList<int>();
|
|
layer.Validate(ref list, inv);
|
|
foreach (int num in list)
|
|
itemsToSort.Remove(num);
|
|
list.Sort((Comparison<int>) ((x, y) =>
|
|
{
|
|
int num = inv[y].OriginalRarity.CompareTo(inv[x].OriginalRarity);
|
|
if (num == 0)
|
|
num = inv[y].OriginalDamage.CompareTo(inv[x].OriginalDamage);
|
|
if (num == 0)
|
|
num = x.CompareTo(y);
|
|
return num;
|
|
}));
|
|
return list;
|
|
}));
|
|
public static ItemSorting.ItemSortingLayer ToolsPicksaws = new ItemSorting.ItemSortingLayer("Tools - Picksaws", (Func<ItemSorting.ItemSortingLayer, Item[], List<int>, List<int>>) ((layer, inv, itemsToSort) =>
|
|
{
|
|
List<int> list = itemsToSort.Where<int>((Func<int, bool>) (i => inv[i].pick > 0 && inv[i].axe > 0)).ToList<int>();
|
|
layer.Validate(ref list, inv);
|
|
foreach (int num in list)
|
|
itemsToSort.Remove(num);
|
|
list.Sort((Comparison<int>) ((x, y) => inv[x].pick.CompareTo(inv[y].pick)));
|
|
return list;
|
|
}));
|
|
public static ItemSorting.ItemSortingLayer ToolsHamaxes = new ItemSorting.ItemSortingLayer("Tools - Hamaxes", (Func<ItemSorting.ItemSortingLayer, Item[], List<int>, List<int>>) ((layer, inv, itemsToSort) =>
|
|
{
|
|
List<int> list = itemsToSort.Where<int>((Func<int, bool>) (i => inv[i].hammer > 0 && inv[i].axe > 0)).ToList<int>();
|
|
layer.Validate(ref list, inv);
|
|
foreach (int num in list)
|
|
itemsToSort.Remove(num);
|
|
list.Sort((Comparison<int>) ((x, y) => inv[x].axe.CompareTo(inv[y].axe)));
|
|
return list;
|
|
}));
|
|
public static ItemSorting.ItemSortingLayer ToolsPickaxes = new ItemSorting.ItemSortingLayer("Tools - Pickaxes", (Func<ItemSorting.ItemSortingLayer, Item[], List<int>, List<int>>) ((layer, inv, itemsToSort) =>
|
|
{
|
|
List<int> list = itemsToSort.Where<int>((Func<int, bool>) (i => inv[i].pick > 0)).ToList<int>();
|
|
layer.Validate(ref list, inv);
|
|
foreach (int num in list)
|
|
itemsToSort.Remove(num);
|
|
list.Sort((Comparison<int>) ((x, y) => inv[x].pick.CompareTo(inv[y].pick)));
|
|
return list;
|
|
}));
|
|
public static ItemSorting.ItemSortingLayer ToolsAxes = new ItemSorting.ItemSortingLayer("Tools - Axes", (Func<ItemSorting.ItemSortingLayer, Item[], List<int>, List<int>>) ((layer, inv, itemsToSort) =>
|
|
{
|
|
List<int> list = itemsToSort.Where<int>((Func<int, bool>) (i => inv[i].pick > 0)).ToList<int>();
|
|
layer.Validate(ref list, inv);
|
|
foreach (int num in list)
|
|
itemsToSort.Remove(num);
|
|
list.Sort((Comparison<int>) ((x, y) => inv[x].axe.CompareTo(inv[y].axe)));
|
|
return list;
|
|
}));
|
|
public static ItemSorting.ItemSortingLayer ToolsHammers = new ItemSorting.ItemSortingLayer("Tools - Hammers", (Func<ItemSorting.ItemSortingLayer, Item[], List<int>, List<int>>) ((layer, inv, itemsToSort) =>
|
|
{
|
|
List<int> list = itemsToSort.Where<int>((Func<int, bool>) (i => inv[i].hammer > 0)).ToList<int>();
|
|
layer.Validate(ref list, inv);
|
|
foreach (int num in list)
|
|
itemsToSort.Remove(num);
|
|
list.Sort((Comparison<int>) ((x, y) => inv[x].hammer.CompareTo(inv[y].hammer)));
|
|
return list;
|
|
}));
|
|
public static ItemSorting.ItemSortingLayer ToolsTerraforming = new ItemSorting.ItemSortingLayer("Tools - Terraforming", (Func<ItemSorting.ItemSortingLayer, Item[], List<int>, List<int>>) ((layer, inv, itemsToSort) =>
|
|
{
|
|
List<int> list = itemsToSort.Where<int>((Func<int, bool>) (i => inv[i].netID > 0 && ItemID.Sets.SortingPriorityTerraforming[inv[i].netID] > -1)).ToList<int>();
|
|
layer.Validate(ref list, inv);
|
|
foreach (int num in list)
|
|
itemsToSort.Remove(num);
|
|
list.Sort((Comparison<int>) ((x, y) =>
|
|
{
|
|
int num = ItemID.Sets.SortingPriorityTerraforming[inv[x].netID].CompareTo(ItemID.Sets.SortingPriorityTerraforming[inv[y].netID]);
|
|
if (num == 0)
|
|
num = inv[y].stack.CompareTo(inv[x].stack);
|
|
if (num == 0)
|
|
num = x.CompareTo(y);
|
|
return num;
|
|
}));
|
|
return list;
|
|
}));
|
|
public static ItemSorting.ItemSortingLayer ToolsAmmoLeftovers = new ItemSorting.ItemSortingLayer("Weapons - Ammo Leftovers", (Func<ItemSorting.ItemSortingLayer, Item[], List<int>, List<int>>) ((layer, inv, itemsToSort) =>
|
|
{
|
|
List<int> list = itemsToSort.Where<int>((Func<int, bool>) (i => inv[i].ammo > 0)).ToList<int>();
|
|
layer.Validate(ref list, inv);
|
|
foreach (int num in list)
|
|
itemsToSort.Remove(num);
|
|
list.Sort((Comparison<int>) ((x, y) =>
|
|
{
|
|
int num = inv[y].OriginalRarity.CompareTo(inv[x].OriginalRarity);
|
|
if (num == 0)
|
|
num = inv[y].OriginalDamage.CompareTo(inv[x].OriginalDamage);
|
|
if (num == 0)
|
|
num = x.CompareTo(y);
|
|
return num;
|
|
}));
|
|
return list;
|
|
}));
|
|
public static ItemSorting.ItemSortingLayer ArmorCombat = new ItemSorting.ItemSortingLayer("Armor - Combat", (Func<ItemSorting.ItemSortingLayer, Item[], List<int>, List<int>>) ((layer, inv, itemsToSort) =>
|
|
{
|
|
List<int> list = itemsToSort.Where<int>((Func<int, bool>) (i => (inv[i].bodySlot >= 0 || inv[i].headSlot >= 0 || inv[i].legSlot >= 0) && !inv[i].vanity)).ToList<int>();
|
|
layer.Validate(ref list, inv);
|
|
foreach (int num in list)
|
|
itemsToSort.Remove(num);
|
|
list.Sort((Comparison<int>) ((x, y) =>
|
|
{
|
|
int num = inv[y].OriginalRarity.CompareTo(inv[x].OriginalRarity);
|
|
if (num == 0)
|
|
num = inv[y].OriginalDefense.CompareTo(inv[x].OriginalDefense);
|
|
if (num == 0)
|
|
num = inv[x].netID.CompareTo(inv[y].netID);
|
|
return num;
|
|
}));
|
|
return list;
|
|
}));
|
|
public static ItemSorting.ItemSortingLayer ArmorVanity = new ItemSorting.ItemSortingLayer("Armor - Vanity", (Func<ItemSorting.ItemSortingLayer, Item[], List<int>, List<int>>) ((layer, inv, itemsToSort) =>
|
|
{
|
|
List<int> list = itemsToSort.Where<int>((Func<int, bool>) (i => (inv[i].bodySlot >= 0 || inv[i].headSlot >= 0 || inv[i].legSlot >= 0) && inv[i].vanity)).ToList<int>();
|
|
layer.Validate(ref list, inv);
|
|
foreach (int num in list)
|
|
itemsToSort.Remove(num);
|
|
list.Sort((Comparison<int>) ((x, y) =>
|
|
{
|
|
int num = inv[y].OriginalRarity.CompareTo(inv[x].OriginalRarity);
|
|
if (num == 0)
|
|
num = inv[x].netID.CompareTo(inv[y].netID);
|
|
return num;
|
|
}));
|
|
return list;
|
|
}));
|
|
public static ItemSorting.ItemSortingLayer ArmorAccessories = new ItemSorting.ItemSortingLayer("Armor - Accessories", (Func<ItemSorting.ItemSortingLayer, Item[], List<int>, List<int>>) ((layer, inv, itemsToSort) =>
|
|
{
|
|
List<int> list = itemsToSort.Where<int>((Func<int, bool>) (i => inv[i].accessory)).ToList<int>();
|
|
layer.Validate(ref list, inv);
|
|
foreach (int num in list)
|
|
itemsToSort.Remove(num);
|
|
list.Sort((Comparison<int>) ((x, y) =>
|
|
{
|
|
int num = inv[x].vanity.CompareTo(inv[y].vanity);
|
|
if (num == 0)
|
|
num = inv[y].OriginalRarity.CompareTo(inv[x].OriginalRarity);
|
|
if (num == 0)
|
|
num = inv[y].OriginalDefense.CompareTo(inv[x].OriginalDefense);
|
|
if (num == 0)
|
|
num = inv[x].netID.CompareTo(inv[y].netID);
|
|
return num;
|
|
}));
|
|
return list;
|
|
}));
|
|
public static ItemSorting.ItemSortingLayer EquipGrapple = new ItemSorting.ItemSortingLayer("Equip - Grapple", (Func<ItemSorting.ItemSortingLayer, Item[], List<int>, List<int>>) ((layer, inv, itemsToSort) =>
|
|
{
|
|
List<int> list = itemsToSort.Where<int>((Func<int, bool>) (i => Main.projHook[inv[i].shoot])).ToList<int>();
|
|
layer.Validate(ref list, inv);
|
|
foreach (int num in list)
|
|
itemsToSort.Remove(num);
|
|
list.Sort((Comparison<int>) ((x, y) =>
|
|
{
|
|
int num = inv[y].OriginalRarity.CompareTo(inv[x].OriginalRarity);
|
|
if (num == 0)
|
|
num = inv[x].netID.CompareTo(inv[y].netID);
|
|
if (num == 0)
|
|
num = x.CompareTo(y);
|
|
return num;
|
|
}));
|
|
return list;
|
|
}));
|
|
public static ItemSorting.ItemSortingLayer EquipMount = new ItemSorting.ItemSortingLayer("Equip - Mount", (Func<ItemSorting.ItemSortingLayer, Item[], List<int>, List<int>>) ((layer, inv, itemsToSort) =>
|
|
{
|
|
List<int> list = itemsToSort.Where<int>((Func<int, bool>) (i => inv[i].mountType != -1 && !MountID.Sets.Cart[inv[i].mountType])).ToList<int>();
|
|
layer.Validate(ref list, inv);
|
|
foreach (int num in list)
|
|
itemsToSort.Remove(num);
|
|
list.Sort((Comparison<int>) ((x, y) =>
|
|
{
|
|
int num = inv[y].OriginalRarity.CompareTo(inv[x].OriginalRarity);
|
|
if (num == 0)
|
|
num = inv[x].netID.CompareTo(inv[y].netID);
|
|
if (num == 0)
|
|
num = x.CompareTo(y);
|
|
return num;
|
|
}));
|
|
return list;
|
|
}));
|
|
public static ItemSorting.ItemSortingLayer EquipCart = new ItemSorting.ItemSortingLayer("Equip - Cart", (Func<ItemSorting.ItemSortingLayer, Item[], List<int>, List<int>>) ((layer, inv, itemsToSort) =>
|
|
{
|
|
List<int> list = itemsToSort.Where<int>((Func<int, bool>) (i => inv[i].mountType != -1 && MountID.Sets.Cart[inv[i].mountType])).ToList<int>();
|
|
layer.Validate(ref list, inv);
|
|
foreach (int num in list)
|
|
itemsToSort.Remove(num);
|
|
list.Sort((Comparison<int>) ((x, y) =>
|
|
{
|
|
int num = inv[y].OriginalRarity.CompareTo(inv[x].OriginalRarity);
|
|
if (num == 0)
|
|
num = inv[x].netID.CompareTo(inv[y].netID);
|
|
if (num == 0)
|
|
num = x.CompareTo(y);
|
|
return num;
|
|
}));
|
|
return list;
|
|
}));
|
|
public static ItemSorting.ItemSortingLayer EquipLightPet = new ItemSorting.ItemSortingLayer("Equip - Light Pet", (Func<ItemSorting.ItemSortingLayer, Item[], List<int>, List<int>>) ((layer, inv, itemsToSort) =>
|
|
{
|
|
List<int> list = itemsToSort.Where<int>((Func<int, bool>) (i => inv[i].buffType > 0 && Main.lightPet[inv[i].buffType])).ToList<int>();
|
|
layer.Validate(ref list, inv);
|
|
foreach (int num in list)
|
|
itemsToSort.Remove(num);
|
|
list.Sort((Comparison<int>) ((x, y) =>
|
|
{
|
|
int num = inv[y].OriginalRarity.CompareTo(inv[x].OriginalRarity);
|
|
if (num == 0)
|
|
num = inv[x].netID.CompareTo(inv[y].netID);
|
|
if (num == 0)
|
|
num = x.CompareTo(y);
|
|
return num;
|
|
}));
|
|
return list;
|
|
}));
|
|
public static ItemSorting.ItemSortingLayer EquipVanityPet = new ItemSorting.ItemSortingLayer("Equip - Vanity Pet", (Func<ItemSorting.ItemSortingLayer, Item[], List<int>, List<int>>) ((layer, inv, itemsToSort) =>
|
|
{
|
|
List<int> list = itemsToSort.Where<int>((Func<int, bool>) (i => inv[i].buffType > 0 && Main.vanityPet[inv[i].buffType])).ToList<int>();
|
|
layer.Validate(ref list, inv);
|
|
foreach (int num in list)
|
|
itemsToSort.Remove(num);
|
|
list.Sort((Comparison<int>) ((x, y) =>
|
|
{
|
|
int num = inv[y].OriginalRarity.CompareTo(inv[x].OriginalRarity);
|
|
if (num == 0)
|
|
num = inv[x].netID.CompareTo(inv[y].netID);
|
|
if (num == 0)
|
|
num = x.CompareTo(y);
|
|
return num;
|
|
}));
|
|
return list;
|
|
}));
|
|
public static ItemSorting.ItemSortingLayer PotionsLife = new ItemSorting.ItemSortingLayer("Potions - Life", (Func<ItemSorting.ItemSortingLayer, Item[], List<int>, List<int>>) ((layer, inv, itemsToSort) =>
|
|
{
|
|
List<int> list = itemsToSort.Where<int>((Func<int, bool>) (i => inv[i].consumable && inv[i].healLife > 0 && inv[i].healMana < 1)).ToList<int>();
|
|
layer.Validate(ref list, inv);
|
|
foreach (int num in list)
|
|
itemsToSort.Remove(num);
|
|
list.Sort((Comparison<int>) ((x, y) =>
|
|
{
|
|
int num = inv[y].healLife.CompareTo(inv[x].healLife);
|
|
if (num == 0)
|
|
num = inv[y].stack.CompareTo(inv[x].stack);
|
|
if (num == 0)
|
|
num = x.CompareTo(y);
|
|
return num;
|
|
}));
|
|
return list;
|
|
}));
|
|
public static ItemSorting.ItemSortingLayer PotionsMana = new ItemSorting.ItemSortingLayer("Potions - Mana", (Func<ItemSorting.ItemSortingLayer, Item[], List<int>, List<int>>) ((layer, inv, itemsToSort) =>
|
|
{
|
|
List<int> list = itemsToSort.Where<int>((Func<int, bool>) (i => inv[i].consumable && inv[i].healLife < 1 && inv[i].healMana > 0)).ToList<int>();
|
|
layer.Validate(ref list, inv);
|
|
foreach (int num in list)
|
|
itemsToSort.Remove(num);
|
|
list.Sort((Comparison<int>) ((x, y) =>
|
|
{
|
|
int num = inv[y].healMana.CompareTo(inv[x].healMana);
|
|
if (num == 0)
|
|
num = inv[y].stack.CompareTo(inv[x].stack);
|
|
if (num == 0)
|
|
num = x.CompareTo(y);
|
|
return num;
|
|
}));
|
|
return list;
|
|
}));
|
|
public static ItemSorting.ItemSortingLayer PotionsElixirs = new ItemSorting.ItemSortingLayer("Potions - Elixirs", (Func<ItemSorting.ItemSortingLayer, Item[], List<int>, List<int>>) ((layer, inv, itemsToSort) =>
|
|
{
|
|
List<int> list = itemsToSort.Where<int>((Func<int, bool>) (i => inv[i].consumable && inv[i].healLife > 0 && inv[i].healMana > 0)).ToList<int>();
|
|
layer.Validate(ref list, inv);
|
|
foreach (int num in list)
|
|
itemsToSort.Remove(num);
|
|
list.Sort((Comparison<int>) ((x, y) =>
|
|
{
|
|
int num = inv[y].healLife.CompareTo(inv[x].healLife);
|
|
if (num == 0)
|
|
num = inv[y].stack.CompareTo(inv[x].stack);
|
|
if (num == 0)
|
|
num = x.CompareTo(y);
|
|
return num;
|
|
}));
|
|
return list;
|
|
}));
|
|
public static ItemSorting.ItemSortingLayer PotionsBuffs = new ItemSorting.ItemSortingLayer("Potions - Buffs", (Func<ItemSorting.ItemSortingLayer, Item[], List<int>, List<int>>) ((layer, inv, itemsToSort) =>
|
|
{
|
|
List<int> list = itemsToSort.Where<int>((Func<int, bool>) (i => inv[i].consumable && inv[i].buffType > 0)).ToList<int>();
|
|
layer.Validate(ref list, inv);
|
|
foreach (int num in list)
|
|
itemsToSort.Remove(num);
|
|
list.Sort((Comparison<int>) ((x, y) =>
|
|
{
|
|
int num = inv[y].OriginalRarity.CompareTo(inv[x].OriginalRarity);
|
|
if (num == 0)
|
|
num = inv[x].netID.CompareTo(inv[y].netID);
|
|
if (num == 0)
|
|
num = inv[y].stack.CompareTo(inv[x].stack);
|
|
if (num == 0)
|
|
num = x.CompareTo(y);
|
|
return num;
|
|
}));
|
|
return list;
|
|
}));
|
|
public static ItemSorting.ItemSortingLayer PotionsDyes = new ItemSorting.ItemSortingLayer("Potions - Dyes", (Func<ItemSorting.ItemSortingLayer, Item[], List<int>, List<int>>) ((layer, inv, itemsToSort) =>
|
|
{
|
|
List<int> list = itemsToSort.Where<int>((Func<int, bool>) (i => inv[i].dye > (byte) 0)).ToList<int>();
|
|
layer.Validate(ref list, inv);
|
|
foreach (int num in list)
|
|
itemsToSort.Remove(num);
|
|
list.Sort((Comparison<int>) ((x, y) =>
|
|
{
|
|
int num = inv[y].OriginalRarity.CompareTo(inv[x].OriginalRarity);
|
|
if (num == 0)
|
|
num = inv[y].dye.CompareTo(inv[x].dye);
|
|
if (num == 0)
|
|
num = inv[y].stack.CompareTo(inv[x].stack);
|
|
if (num == 0)
|
|
num = x.CompareTo(y);
|
|
return num;
|
|
}));
|
|
return list;
|
|
}));
|
|
public static ItemSorting.ItemSortingLayer PotionsHairDyes = new ItemSorting.ItemSortingLayer("Potions - Hair Dyes", (Func<ItemSorting.ItemSortingLayer, Item[], List<int>, List<int>>) ((layer, inv, itemsToSort) =>
|
|
{
|
|
List<int> list = itemsToSort.Where<int>((Func<int, bool>) (i => inv[i].hairDye >= (short) 0)).ToList<int>();
|
|
layer.Validate(ref list, inv);
|
|
foreach (int num in list)
|
|
itemsToSort.Remove(num);
|
|
list.Sort((Comparison<int>) ((x, y) =>
|
|
{
|
|
int num = inv[y].OriginalRarity.CompareTo(inv[x].OriginalRarity);
|
|
if (num == 0)
|
|
num = inv[y].hairDye.CompareTo(inv[x].hairDye);
|
|
if (num == 0)
|
|
num = inv[y].stack.CompareTo(inv[x].stack);
|
|
if (num == 0)
|
|
num = x.CompareTo(y);
|
|
return num;
|
|
}));
|
|
return list;
|
|
}));
|
|
public static ItemSorting.ItemSortingLayer MiscValuables = new ItemSorting.ItemSortingLayer("Misc - Importants", (Func<ItemSorting.ItemSortingLayer, Item[], List<int>, List<int>>) ((layer, inv, itemsToSort) =>
|
|
{
|
|
List<int> list = itemsToSort.Where<int>((Func<int, bool>) (i => inv[i].netID > 0 && ItemID.Sets.SortingPriorityBossSpawns[inv[i].netID] > -1)).ToList<int>();
|
|
layer.Validate(ref list, inv);
|
|
foreach (int num in list)
|
|
itemsToSort.Remove(num);
|
|
list.Sort((Comparison<int>) ((x, y) =>
|
|
{
|
|
int num = ItemID.Sets.SortingPriorityBossSpawns[inv[x].netID].CompareTo(ItemID.Sets.SortingPriorityBossSpawns[inv[y].netID]);
|
|
if (num == 0)
|
|
num = inv[y].stack.CompareTo(inv[x].stack);
|
|
if (num == 0)
|
|
num = x.CompareTo(y);
|
|
return num;
|
|
}));
|
|
return list;
|
|
}));
|
|
public static ItemSorting.ItemSortingLayer MiscWiring = new ItemSorting.ItemSortingLayer("Misc - Wiring", (Func<ItemSorting.ItemSortingLayer, Item[], List<int>, List<int>>) ((layer, inv, itemsToSort) =>
|
|
{
|
|
List<int> list = itemsToSort.Where<int>((Func<int, bool>) (i => inv[i].netID > 0 && ItemID.Sets.SortingPriorityWiring[inv[i].netID] > -1 || inv[i].mech)).ToList<int>();
|
|
layer.Validate(ref list, inv);
|
|
foreach (int num in list)
|
|
itemsToSort.Remove(num);
|
|
list.Sort((Comparison<int>) ((x, y) =>
|
|
{
|
|
int num = ItemID.Sets.SortingPriorityWiring[inv[y].netID].CompareTo(ItemID.Sets.SortingPriorityWiring[inv[x].netID]);
|
|
if (num == 0)
|
|
num = inv[y].OriginalRarity.CompareTo(inv[x].OriginalRarity);
|
|
if (num == 0)
|
|
num = inv[y].netID.CompareTo(inv[x].netID);
|
|
if (num == 0)
|
|
num = inv[y].stack.CompareTo(inv[x].stack);
|
|
if (num == 0)
|
|
num = x.CompareTo(y);
|
|
return num;
|
|
}));
|
|
return list;
|
|
}));
|
|
public static ItemSorting.ItemSortingLayer MiscMaterials = new ItemSorting.ItemSortingLayer("Misc - Materials", (Func<ItemSorting.ItemSortingLayer, Item[], List<int>, List<int>>) ((layer, inv, itemsToSort) =>
|
|
{
|
|
List<int> list = itemsToSort.Where<int>((Func<int, bool>) (i => inv[i].netID > 0 && ItemID.Sets.SortingPriorityMaterials[inv[i].netID] > -1)).ToList<int>();
|
|
layer.Validate(ref list, inv);
|
|
foreach (int num in list)
|
|
itemsToSort.Remove(num);
|
|
list.Sort((Comparison<int>) ((x, y) =>
|
|
{
|
|
int num = ItemID.Sets.SortingPriorityMaterials[inv[y].netID].CompareTo(ItemID.Sets.SortingPriorityMaterials[inv[x].netID]);
|
|
if (num == 0)
|
|
num = inv[y].stack.CompareTo(inv[x].stack);
|
|
if (num == 0)
|
|
num = x.CompareTo(y);
|
|
return num;
|
|
}));
|
|
return list;
|
|
}));
|
|
public static ItemSorting.ItemSortingLayer MiscExtractinator = new ItemSorting.ItemSortingLayer("Misc - Extractinator", (Func<ItemSorting.ItemSortingLayer, Item[], List<int>, List<int>>) ((layer, inv, itemsToSort) =>
|
|
{
|
|
List<int> list = itemsToSort.Where<int>((Func<int, bool>) (i => inv[i].netID > 0 && ItemID.Sets.SortingPriorityExtractibles[inv[i].netID] > -1)).ToList<int>();
|
|
layer.Validate(ref list, inv);
|
|
foreach (int num in list)
|
|
itemsToSort.Remove(num);
|
|
list.Sort((Comparison<int>) ((x, y) =>
|
|
{
|
|
int num = ItemID.Sets.SortingPriorityExtractibles[inv[y].netID].CompareTo(ItemID.Sets.SortingPriorityExtractibles[inv[x].netID]);
|
|
if (num == 0)
|
|
num = inv[y].stack.CompareTo(inv[x].stack);
|
|
if (num == 0)
|
|
num = x.CompareTo(y);
|
|
return num;
|
|
}));
|
|
return list;
|
|
}));
|
|
public static ItemSorting.ItemSortingLayer MiscPainting = new ItemSorting.ItemSortingLayer("Misc - Painting", (Func<ItemSorting.ItemSortingLayer, Item[], List<int>, List<int>>) ((layer, inv, itemsToSort) =>
|
|
{
|
|
List<int> list = itemsToSort.Where<int>((Func<int, bool>) (i => inv[i].netID > 0 && ItemID.Sets.SortingPriorityPainting[inv[i].netID] > -1 || inv[i].paint > (byte) 0)).ToList<int>();
|
|
layer.Validate(ref list, inv);
|
|
foreach (int num in list)
|
|
itemsToSort.Remove(num);
|
|
list.Sort((Comparison<int>) ((x, y) =>
|
|
{
|
|
int num = ItemID.Sets.SortingPriorityPainting[inv[y].netID].CompareTo(ItemID.Sets.SortingPriorityPainting[inv[x].netID]);
|
|
if (num == 0)
|
|
num = inv[x].paint.CompareTo(inv[y].paint);
|
|
if (num == 0)
|
|
num = inv[y].stack.CompareTo(inv[x].stack);
|
|
if (num == 0)
|
|
num = x.CompareTo(y);
|
|
return num;
|
|
}));
|
|
return list;
|
|
}));
|
|
public static ItemSorting.ItemSortingLayer MiscRopes = new ItemSorting.ItemSortingLayer("Misc - Ropes", (Func<ItemSorting.ItemSortingLayer, Item[], List<int>, List<int>>) ((layer, inv, itemsToSort) =>
|
|
{
|
|
List<int> list = itemsToSort.Where<int>((Func<int, bool>) (i => inv[i].netID > 0 && ItemID.Sets.SortingPriorityRopes[inv[i].netID] > -1)).ToList<int>();
|
|
layer.Validate(ref list, inv);
|
|
foreach (int num in list)
|
|
itemsToSort.Remove(num);
|
|
list.Sort((Comparison<int>) ((x, y) =>
|
|
{
|
|
int num = ItemID.Sets.SortingPriorityRopes[inv[y].netID].CompareTo(ItemID.Sets.SortingPriorityRopes[inv[x].netID]);
|
|
if (num == 0)
|
|
num = inv[y].stack.CompareTo(inv[x].stack);
|
|
if (num == 0)
|
|
num = x.CompareTo(y);
|
|
return num;
|
|
}));
|
|
return list;
|
|
}));
|
|
public static ItemSorting.ItemSortingLayer LastMaterials = new ItemSorting.ItemSortingLayer("Last - Materials", (Func<ItemSorting.ItemSortingLayer, Item[], List<int>, List<int>>) ((layer, inv, itemsToSort) =>
|
|
{
|
|
List<int> list = itemsToSort.Where<int>((Func<int, bool>) (i => inv[i].createTile < 0 && inv[i].createWall < 1)).ToList<int>();
|
|
layer.Validate(ref list, inv);
|
|
foreach (int num in list)
|
|
itemsToSort.Remove(num);
|
|
list.Sort((Comparison<int>) ((x, y) =>
|
|
{
|
|
int num = inv[y].OriginalRarity.CompareTo(inv[x].OriginalRarity);
|
|
if (num == 0)
|
|
num = inv[y].value.CompareTo(inv[x].value);
|
|
if (num == 0)
|
|
num = inv[y].stack.CompareTo(inv[x].stack);
|
|
if (num == 0)
|
|
num = x.CompareTo(y);
|
|
return num;
|
|
}));
|
|
return list;
|
|
}));
|
|
public static ItemSorting.ItemSortingLayer LastTilesImportant = new ItemSorting.ItemSortingLayer("Last - Tiles (Frame Important)", (Func<ItemSorting.ItemSortingLayer, Item[], List<int>, List<int>>) ((layer, inv, itemsToSort) =>
|
|
{
|
|
List<int> list = itemsToSort.Where<int>((Func<int, bool>) (i => inv[i].createTile >= 0 && Main.tileFrameImportant[inv[i].createTile])).ToList<int>();
|
|
layer.Validate(ref list, inv);
|
|
foreach (int num in list)
|
|
itemsToSort.Remove(num);
|
|
list.Sort((Comparison<int>) ((x, y) =>
|
|
{
|
|
int num = string.Compare(inv[x].Name, inv[y].Name, StringComparison.OrdinalIgnoreCase);
|
|
if (num == 0)
|
|
num = inv[y].stack.CompareTo(inv[x].stack);
|
|
if (num == 0)
|
|
num = x.CompareTo(y);
|
|
return num;
|
|
}));
|
|
return list;
|
|
}));
|
|
public static ItemSorting.ItemSortingLayer LastTilesCommon = new ItemSorting.ItemSortingLayer("Last - Tiles (Common), Walls", (Func<ItemSorting.ItemSortingLayer, Item[], List<int>, List<int>>) ((layer, inv, itemsToSort) =>
|
|
{
|
|
List<int> list = itemsToSort.Where<int>((Func<int, bool>) (i => inv[i].createWall > 0 || inv[i].createTile >= 0)).ToList<int>();
|
|
layer.Validate(ref list, inv);
|
|
foreach (int num in list)
|
|
itemsToSort.Remove(num);
|
|
list.Sort((Comparison<int>) ((x, y) =>
|
|
{
|
|
int num = string.Compare(inv[x].Name, inv[y].Name, StringComparison.OrdinalIgnoreCase);
|
|
if (num == 0)
|
|
num = inv[y].stack.CompareTo(inv[x].stack);
|
|
if (num == 0)
|
|
num = x.CompareTo(y);
|
|
return num;
|
|
}));
|
|
return list;
|
|
}));
|
|
public static ItemSorting.ItemSortingLayer LastNotTrash = new ItemSorting.ItemSortingLayer("Last - Not Trash", (Func<ItemSorting.ItemSortingLayer, Item[], List<int>, List<int>>) ((layer, inv, itemsToSort) =>
|
|
{
|
|
List<int> list = itemsToSort.Where<int>((Func<int, bool>) (i => inv[i].OriginalRarity >= 0)).ToList<int>();
|
|
layer.Validate(ref list, inv);
|
|
foreach (int num in list)
|
|
itemsToSort.Remove(num);
|
|
list.Sort((Comparison<int>) ((x, y) =>
|
|
{
|
|
int num = inv[y].OriginalRarity.CompareTo(inv[x].OriginalRarity);
|
|
if (num == 0)
|
|
num = string.Compare(inv[x].Name, inv[y].Name, StringComparison.OrdinalIgnoreCase);
|
|
if (num == 0)
|
|
num = inv[y].stack.CompareTo(inv[x].stack);
|
|
if (num == 0)
|
|
num = x.CompareTo(y);
|
|
return num;
|
|
}));
|
|
return list;
|
|
}));
|
|
public static ItemSorting.ItemSortingLayer LastTrash = new ItemSorting.ItemSortingLayer("Last - Trash", (Func<ItemSorting.ItemSortingLayer, Item[], List<int>, List<int>>) ((layer, inv, itemsToSort) =>
|
|
{
|
|
List<int> indexesSortable = new List<int>((IEnumerable<int>) itemsToSort);
|
|
layer.Validate(ref indexesSortable, inv);
|
|
foreach (int num in indexesSortable)
|
|
itemsToSort.Remove(num);
|
|
indexesSortable.Sort((Comparison<int>) ((x, y) =>
|
|
{
|
|
int num = inv[y].value.CompareTo(inv[x].value);
|
|
if (num == 0)
|
|
num = inv[y].stack.CompareTo(inv[x].stack);
|
|
if (num == 0)
|
|
num = x.CompareTo(y);
|
|
return num;
|
|
}));
|
|
return indexesSortable;
|
|
}));
|
|
}
|
|
}
|
|
}
|