2824 lines
102 KiB
C#
2824 lines
102 KiB
C#
// Decompiled with JetBrains decompiler
|
|
// Type: Terraria.UI.ItemSlot
|
|
// 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 Microsoft.Xna.Framework;
|
|
using Microsoft.Xna.Framework.Graphics;
|
|
using Terraria.Audio;
|
|
using Terraria.DataStructures;
|
|
using Terraria.GameContent;
|
|
using Terraria.GameContent.Achievements;
|
|
using Terraria.GameContent.UI;
|
|
using Terraria.GameContent.UI.Chat;
|
|
using Terraria.GameInput;
|
|
using Terraria.ID;
|
|
using Terraria.Localization;
|
|
using Terraria.UI.Chat;
|
|
using Terraria.UI.Gamepad;
|
|
|
|
namespace Terraria.UI
|
|
{
|
|
public class ItemSlot
|
|
{
|
|
public static bool DrawGoldBGForCraftingMaterial = false;
|
|
public static bool ShiftForcedOn;
|
|
private static Item[] singleSlotArray = new Item[1];
|
|
private static bool[] canFavoriteAt = new bool[31];
|
|
private static bool[] canShareAt = new bool[31];
|
|
private static float[] inventoryGlowHue = new float[58];
|
|
private static int[] inventoryGlowTime = new int[58];
|
|
private static float[] inventoryGlowHueChest = new float[58];
|
|
private static int[] inventoryGlowTimeChest = new int[58];
|
|
private static int _customCurrencyForSavings = -1;
|
|
private static int dyeSlotCount;
|
|
private static int accSlotToSwapTo;
|
|
public static float CircularRadialOpacity;
|
|
public static float QuicksRadialOpacity;
|
|
|
|
static ItemSlot()
|
|
{
|
|
ItemSlot.canFavoriteAt[0] = true;
|
|
ItemSlot.canFavoriteAt[1] = true;
|
|
ItemSlot.canFavoriteAt[2] = true;
|
|
ItemSlot.canShareAt[15] = true;
|
|
ItemSlot.canShareAt[4] = true;
|
|
ItemSlot.canShareAt[5] = true;
|
|
ItemSlot.canShareAt[6] = true;
|
|
ItemSlot.canShareAt[7] = true;
|
|
ItemSlot.canShareAt[27] = true;
|
|
ItemSlot.canShareAt[26] = true;
|
|
ItemSlot.canShareAt[23] = true;
|
|
ItemSlot.canShareAt[24] = true;
|
|
ItemSlot.canShareAt[25] = true;
|
|
ItemSlot.canShareAt[22] = true;
|
|
ItemSlot.canShareAt[3] = true;
|
|
ItemSlot.canShareAt[8] = true;
|
|
ItemSlot.canShareAt[9] = true;
|
|
ItemSlot.canShareAt[10] = true;
|
|
ItemSlot.canShareAt[11] = true;
|
|
ItemSlot.canShareAt[12] = true;
|
|
ItemSlot.canShareAt[16] = true;
|
|
ItemSlot.canShareAt[20] = true;
|
|
ItemSlot.canShareAt[18] = true;
|
|
ItemSlot.canShareAt[19] = true;
|
|
ItemSlot.canShareAt[17] = true;
|
|
ItemSlot.canShareAt[29] = true;
|
|
ItemSlot.canShareAt[30] = true;
|
|
}
|
|
|
|
public static bool ShiftInUse => Main.keyState.PressingShift() || ItemSlot.ShiftForcedOn;
|
|
|
|
public static bool ControlInUse => Main.keyState.PressingControl();
|
|
|
|
public static bool NotUsingGamepad => !PlayerInput.UsingGamepad;
|
|
|
|
public static void SetGlow(int index, float hue, bool chest)
|
|
{
|
|
if (chest)
|
|
{
|
|
if ((double) hue < 0.0)
|
|
{
|
|
ItemSlot.inventoryGlowTimeChest[index] = 0;
|
|
ItemSlot.inventoryGlowHueChest[index] = 0.0f;
|
|
}
|
|
else
|
|
{
|
|
ItemSlot.inventoryGlowTimeChest[index] = 300;
|
|
ItemSlot.inventoryGlowHueChest[index] = hue;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ItemSlot.inventoryGlowTime[index] = 300;
|
|
ItemSlot.inventoryGlowHue[index] = hue;
|
|
}
|
|
}
|
|
|
|
public static void UpdateInterface()
|
|
{
|
|
if (!Main.playerInventory || Main.player[Main.myPlayer].talkNPC == -1)
|
|
ItemSlot._customCurrencyForSavings = -1;
|
|
for (int index = 0; index < ItemSlot.inventoryGlowTime.Length; ++index)
|
|
{
|
|
if (ItemSlot.inventoryGlowTime[index] > 0)
|
|
{
|
|
--ItemSlot.inventoryGlowTime[index];
|
|
if (ItemSlot.inventoryGlowTime[index] == 0)
|
|
ItemSlot.inventoryGlowHue[index] = 0.0f;
|
|
}
|
|
}
|
|
for (int index = 0; index < ItemSlot.inventoryGlowTimeChest.Length; ++index)
|
|
{
|
|
if (ItemSlot.inventoryGlowTimeChest[index] > 0)
|
|
{
|
|
--ItemSlot.inventoryGlowTimeChest[index];
|
|
if (ItemSlot.inventoryGlowTimeChest[index] == 0)
|
|
ItemSlot.inventoryGlowHueChest[index] = 0.0f;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void Handle(ref Item inv, int context = 0)
|
|
{
|
|
ItemSlot.singleSlotArray[0] = inv;
|
|
ItemSlot.Handle(ItemSlot.singleSlotArray, context);
|
|
inv = ItemSlot.singleSlotArray[0];
|
|
Recipe.FindRecipes();
|
|
}
|
|
|
|
public static void Handle(Item[] inv, int context = 0, int slot = 0)
|
|
{
|
|
ItemSlot.OverrideHover(inv, context, slot);
|
|
ItemSlot.LeftClick(inv, context, slot);
|
|
ItemSlot.RightClick(inv, context, slot);
|
|
if (Main.mouseLeftRelease && Main.mouseLeft)
|
|
Recipe.FindRecipes();
|
|
ItemSlot.MouseHover(inv, context, slot);
|
|
}
|
|
|
|
public static void OverrideHover(ref Item inv, int context = 0)
|
|
{
|
|
ItemSlot.singleSlotArray[0] = inv;
|
|
ItemSlot.OverrideHover(ItemSlot.singleSlotArray, context);
|
|
inv = ItemSlot.singleSlotArray[0];
|
|
}
|
|
|
|
public static bool isEquipLocked(int type) => Main.npcShop > 0 && (type == 854 || type == 3035);
|
|
|
|
public static void OverrideHover(Item[] inv, int context = 0, int slot = 0)
|
|
{
|
|
Item obj = inv[slot];
|
|
if (ItemSlot.NotUsingGamepad && ItemSlot.Options.DisableLeftShiftTrashCan)
|
|
{
|
|
if (ItemSlot.ControlInUse)
|
|
{
|
|
if (obj.type > 0 && obj.stack > 0 && !inv[slot].favorited)
|
|
{
|
|
switch (context)
|
|
{
|
|
case 0:
|
|
case 1:
|
|
case 2:
|
|
Main.cursorOverride = Main.npcShop <= 0 || obj.favorited ? 6 : 10;
|
|
break;
|
|
case 3:
|
|
case 4:
|
|
case 7:
|
|
if (Main.player[Main.myPlayer].ItemSpace(obj).CanTakeItemToPersonalInventory)
|
|
{
|
|
Main.cursorOverride = 6;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else if (ItemSlot.ShiftInUse)
|
|
{
|
|
bool flag = false;
|
|
if (Main.LocalPlayer.tileEntityAnchor.IsInValidUseTileEntity())
|
|
flag = Main.LocalPlayer.tileEntityAnchor.GetTileEntity().OverrideItemSlotHover(inv, context, slot);
|
|
if (obj.type > 0 && obj.stack > 0 && !inv[slot].favorited && !flag)
|
|
{
|
|
switch (context)
|
|
{
|
|
case 0:
|
|
case 1:
|
|
case 2:
|
|
if (context == 0 && Main.CreativeMenu.IsShowingResearchMenu())
|
|
{
|
|
Main.cursorOverride = 9;
|
|
break;
|
|
}
|
|
if (context == 0 && Main.InReforgeMenu)
|
|
{
|
|
if (obj.maxStack == 1 && obj.Prefix(-3))
|
|
{
|
|
Main.cursorOverride = 9;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if (context == 0 && Main.InGuideCraftMenu)
|
|
{
|
|
if (obj.material)
|
|
{
|
|
Main.cursorOverride = 9;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if (Main.player[Main.myPlayer].chest != -1 && ChestUI.TryPlacingInChest(obj, true))
|
|
{
|
|
Main.cursorOverride = 9;
|
|
break;
|
|
}
|
|
break;
|
|
case 3:
|
|
case 4:
|
|
if (Main.player[Main.myPlayer].ItemSpace(obj).CanTakeItemToPersonalInventory)
|
|
{
|
|
Main.cursorOverride = 8;
|
|
break;
|
|
}
|
|
break;
|
|
case 5:
|
|
case 7:
|
|
case 8:
|
|
case 9:
|
|
case 10:
|
|
case 11:
|
|
case 12:
|
|
case 16:
|
|
case 17:
|
|
case 18:
|
|
case 19:
|
|
case 20:
|
|
case 23:
|
|
case 24:
|
|
case 25:
|
|
case 26:
|
|
case 27:
|
|
case 29:
|
|
if (Main.player[Main.myPlayer].ItemSpace(inv[slot]).CanTakeItemToPersonalInventory)
|
|
{
|
|
Main.cursorOverride = 7;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (ItemSlot.ShiftInUse)
|
|
{
|
|
bool flag = false;
|
|
if (Main.LocalPlayer.tileEntityAnchor.IsInValidUseTileEntity())
|
|
flag = Main.LocalPlayer.tileEntityAnchor.GetTileEntity().OverrideItemSlotHover(inv, context, slot);
|
|
if (obj.type > 0 && obj.stack > 0 && !inv[slot].favorited && !flag)
|
|
{
|
|
switch (context)
|
|
{
|
|
case 0:
|
|
case 1:
|
|
case 2:
|
|
if (Main.npcShop > 0 && !obj.favorited)
|
|
{
|
|
Main.cursorOverride = 10;
|
|
break;
|
|
}
|
|
if (context == 0 && Main.CreativeMenu.IsShowingResearchMenu())
|
|
{
|
|
Main.cursorOverride = 9;
|
|
break;
|
|
}
|
|
if (context == 0 && Main.InReforgeMenu)
|
|
{
|
|
if (obj.maxStack == 1 && obj.Prefix(-3))
|
|
{
|
|
Main.cursorOverride = 9;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if (context == 0 && Main.InGuideCraftMenu)
|
|
{
|
|
if (obj.material)
|
|
{
|
|
Main.cursorOverride = 9;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if (Main.player[Main.myPlayer].chest != -1)
|
|
{
|
|
if (ChestUI.TryPlacingInChest(obj, true))
|
|
{
|
|
Main.cursorOverride = 9;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
Main.cursorOverride = 6;
|
|
break;
|
|
case 3:
|
|
case 4:
|
|
if (Main.player[Main.myPlayer].ItemSpace(obj).CanTakeItemToPersonalInventory)
|
|
{
|
|
Main.cursorOverride = 8;
|
|
break;
|
|
}
|
|
break;
|
|
case 5:
|
|
case 7:
|
|
case 8:
|
|
case 9:
|
|
case 10:
|
|
case 11:
|
|
case 12:
|
|
case 16:
|
|
case 17:
|
|
case 18:
|
|
case 19:
|
|
case 20:
|
|
case 23:
|
|
case 24:
|
|
case 25:
|
|
case 26:
|
|
case 27:
|
|
case 29:
|
|
if (Main.player[Main.myPlayer].ItemSpace(inv[slot]).CanTakeItemToPersonalInventory)
|
|
{
|
|
Main.cursorOverride = 7;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!Main.keyState.IsKeyDown(Main.FavoriteKey) || !ItemSlot.canFavoriteAt[context] && (!Main.drawingPlayerChat || !ItemSlot.canShareAt[context]))
|
|
return;
|
|
if (obj.type > 0 && obj.stack > 0 && Main.drawingPlayerChat)
|
|
{
|
|
Main.cursorOverride = 2;
|
|
}
|
|
else
|
|
{
|
|
if (obj.type <= 0 || obj.stack <= 0)
|
|
return;
|
|
Main.cursorOverride = 3;
|
|
}
|
|
}
|
|
|
|
private static bool OverrideLeftClick(Item[] inv, int context = 0, int slot = 0)
|
|
{
|
|
if (context == 10 && ItemSlot.isEquipLocked(inv[slot].type) || Main.LocalPlayer.tileEntityAnchor.IsInValidUseTileEntity() && Main.LocalPlayer.tileEntityAnchor.GetTileEntity().OverrideItemSlotLeftClick(inv, context, slot))
|
|
return true;
|
|
Item I = inv[slot];
|
|
switch (Main.cursorOverride)
|
|
{
|
|
case 2:
|
|
if (ChatManager.AddChatText(FontAssets.MouseText.Value, ItemTagHandler.GenerateTag(I), Vector2.One))
|
|
SoundEngine.PlaySound(12);
|
|
return true;
|
|
case 3:
|
|
if (!ItemSlot.canFavoriteAt[context])
|
|
return false;
|
|
I.favorited = !I.favorited;
|
|
SoundEngine.PlaySound(12);
|
|
return true;
|
|
case 7:
|
|
if (context == 29)
|
|
{
|
|
Item newItem = new Item();
|
|
newItem.SetDefaults(inv[slot].netID);
|
|
newItem.stack = newItem.maxStack;
|
|
Main.player[Main.myPlayer].GetItem(Main.myPlayer, newItem, GetItemSettings.InventoryEntityToPlayerInventorySettings);
|
|
SoundEngine.PlaySound(12);
|
|
return true;
|
|
}
|
|
inv[slot] = Main.player[Main.myPlayer].GetItem(Main.myPlayer, inv[slot], GetItemSettings.InventoryEntityToPlayerInventorySettings);
|
|
SoundEngine.PlaySound(12);
|
|
return true;
|
|
case 8:
|
|
inv[slot] = Main.player[Main.myPlayer].GetItem(Main.myPlayer, inv[slot], GetItemSettings.InventoryEntityToPlayerInventorySettings);
|
|
if (Main.player[Main.myPlayer].chest > -1)
|
|
NetMessage.SendData(32, number: Main.player[Main.myPlayer].chest, number2: ((float) slot));
|
|
return true;
|
|
case 9:
|
|
if (Main.CreativeMenu.IsShowingResearchMenu())
|
|
{
|
|
Main.CreativeMenu.SwapItem(ref inv[slot]);
|
|
SoundEngine.PlaySound(7);
|
|
}
|
|
else if (Main.InReforgeMenu)
|
|
{
|
|
Utils.Swap<Item>(ref inv[slot], ref Main.reforgeItem);
|
|
SoundEngine.PlaySound(7);
|
|
}
|
|
else if (Main.InGuideCraftMenu)
|
|
{
|
|
Utils.Swap<Item>(ref inv[slot], ref Main.guideItem);
|
|
Recipe.FindRecipes();
|
|
SoundEngine.PlaySound(7);
|
|
}
|
|
else
|
|
ChestUI.TryPlacingInChest(inv[slot], false);
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static void LeftClick(ref Item inv, int context = 0)
|
|
{
|
|
ItemSlot.singleSlotArray[0] = inv;
|
|
ItemSlot.LeftClick(ItemSlot.singleSlotArray, context);
|
|
inv = ItemSlot.singleSlotArray[0];
|
|
}
|
|
|
|
public static void LeftClick(Item[] inv, int context = 0, int slot = 0)
|
|
{
|
|
Player player = Main.player[Main.myPlayer];
|
|
bool flag = Main.mouseLeftRelease && Main.mouseLeft;
|
|
if (flag)
|
|
{
|
|
if (ItemSlot.OverrideLeftClick(inv, context, slot))
|
|
return;
|
|
inv[slot].newAndShiny = false;
|
|
if (ItemSlot.LeftClick_SellOrTrash(inv, context, slot) || player.itemAnimation != 0 || player.itemTime != 0)
|
|
return;
|
|
}
|
|
int num1 = ItemSlot.PickItemMovementAction(inv, context, slot, Main.mouseItem);
|
|
if (num1 != 3 && !flag)
|
|
return;
|
|
switch (num1)
|
|
{
|
|
case 0:
|
|
if (context == 6 && Main.mouseItem.type != 0)
|
|
inv[slot].SetDefaults();
|
|
if (context != 11 || inv[slot].FitsAccessoryVanitySlot)
|
|
{
|
|
Utils.Swap<Item>(ref inv[slot], ref Main.mouseItem);
|
|
if (inv[slot].stack > 0)
|
|
{
|
|
switch (context)
|
|
{
|
|
case 0:
|
|
AchievementsHelper.NotifyItemPickup(player, inv[slot]);
|
|
break;
|
|
case 8:
|
|
case 9:
|
|
case 10:
|
|
case 11:
|
|
case 12:
|
|
case 16:
|
|
case 17:
|
|
case 25:
|
|
case 27:
|
|
AchievementsHelper.HandleOnEquip(player, inv[slot], context);
|
|
break;
|
|
}
|
|
}
|
|
if (inv[slot].type == 0 || inv[slot].stack < 1)
|
|
inv[slot] = new Item();
|
|
if (Main.mouseItem.IsTheSameAs(inv[slot]))
|
|
{
|
|
Utils.Swap<bool>(ref inv[slot].favorited, ref Main.mouseItem.favorited);
|
|
if (inv[slot].stack != inv[slot].maxStack && Main.mouseItem.stack != Main.mouseItem.maxStack)
|
|
{
|
|
if (Main.mouseItem.stack + inv[slot].stack <= Main.mouseItem.maxStack)
|
|
{
|
|
inv[slot].stack += Main.mouseItem.stack;
|
|
Main.mouseItem.stack = 0;
|
|
}
|
|
else
|
|
{
|
|
int num2 = Main.mouseItem.maxStack - inv[slot].stack;
|
|
inv[slot].stack += num2;
|
|
Main.mouseItem.stack -= num2;
|
|
}
|
|
}
|
|
}
|
|
if (Main.mouseItem.type == 0 || Main.mouseItem.stack < 1)
|
|
Main.mouseItem = new Item();
|
|
if (Main.mouseItem.type > 0 || inv[slot].type > 0)
|
|
{
|
|
Recipe.FindRecipes();
|
|
SoundEngine.PlaySound(7);
|
|
}
|
|
if (context == 3 && Main.netMode == 1)
|
|
{
|
|
NetMessage.SendData(32, number: player.chest, number2: ((float) slot));
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
case 1:
|
|
if (Main.mouseItem.stack == 1 && Main.mouseItem.type > 0 && inv[slot].type > 0 && inv[slot].IsNotTheSameAs(Main.mouseItem) && (context != 11 || Main.mouseItem.FitsAccessoryVanitySlot))
|
|
{
|
|
Utils.Swap<Item>(ref inv[slot], ref Main.mouseItem);
|
|
SoundEngine.PlaySound(7);
|
|
if (inv[slot].stack > 0)
|
|
{
|
|
if (context <= 12)
|
|
{
|
|
if (context != 0)
|
|
{
|
|
if ((uint) (context - 8) > 4U)
|
|
goto label_59;
|
|
}
|
|
else
|
|
{
|
|
AchievementsHelper.NotifyItemPickup(player, inv[slot]);
|
|
goto label_59;
|
|
}
|
|
}
|
|
else if ((uint) (context - 16) > 1U && context != 25 && context != 27)
|
|
goto label_59;
|
|
AchievementsHelper.HandleOnEquip(player, inv[slot], context);
|
|
}
|
|
}
|
|
else if (Main.mouseItem.type == 0 && inv[slot].type > 0)
|
|
{
|
|
Utils.Swap<Item>(ref inv[slot], ref Main.mouseItem);
|
|
if (inv[slot].type == 0 || inv[slot].stack < 1)
|
|
inv[slot] = new Item();
|
|
if (Main.mouseItem.type == 0 || Main.mouseItem.stack < 1)
|
|
Main.mouseItem = new Item();
|
|
if (Main.mouseItem.type > 0 || inv[slot].type > 0)
|
|
{
|
|
Recipe.FindRecipes();
|
|
SoundEngine.PlaySound(7);
|
|
}
|
|
}
|
|
else if (Main.mouseItem.type > 0 && inv[slot].type == 0 && (context != 11 || Main.mouseItem.FitsAccessoryVanitySlot))
|
|
{
|
|
if (Main.mouseItem.stack == 1)
|
|
{
|
|
Utils.Swap<Item>(ref inv[slot], ref Main.mouseItem);
|
|
if (inv[slot].type == 0 || inv[slot].stack < 1)
|
|
inv[slot] = new Item();
|
|
if (Main.mouseItem.type == 0 || Main.mouseItem.stack < 1)
|
|
Main.mouseItem = new Item();
|
|
if (Main.mouseItem.type > 0 || inv[slot].type > 0)
|
|
{
|
|
Recipe.FindRecipes();
|
|
SoundEngine.PlaySound(7);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
--Main.mouseItem.stack;
|
|
inv[slot].SetDefaults(Main.mouseItem.type);
|
|
Recipe.FindRecipes();
|
|
SoundEngine.PlaySound(7);
|
|
}
|
|
if (inv[slot].stack > 0)
|
|
{
|
|
if (context <= 12)
|
|
{
|
|
if (context != 0)
|
|
{
|
|
if ((uint) (context - 8) > 4U)
|
|
goto label_59;
|
|
}
|
|
else
|
|
{
|
|
AchievementsHelper.NotifyItemPickup(player, inv[slot]);
|
|
goto label_59;
|
|
}
|
|
}
|
|
else if ((uint) (context - 16) > 1U && context != 25 && context != 27)
|
|
goto label_59;
|
|
AchievementsHelper.HandleOnEquip(player, inv[slot], context);
|
|
}
|
|
}
|
|
label_59:
|
|
if ((context == 23 || context == 24) && Main.netMode == 1)
|
|
NetMessage.SendData(121, number: Main.myPlayer, number2: ((float) player.tileEntityAnchor.interactEntityID), number3: ((float) slot));
|
|
if (context == 26 && Main.netMode == 1)
|
|
{
|
|
NetMessage.SendData(124, number: Main.myPlayer, number2: ((float) player.tileEntityAnchor.interactEntityID), number3: ((float) slot));
|
|
break;
|
|
}
|
|
break;
|
|
case 2:
|
|
if (Main.mouseItem.stack == 1 && Main.mouseItem.dye > (byte) 0 && inv[slot].type > 0 && inv[slot].type != Main.mouseItem.type)
|
|
{
|
|
Utils.Swap<Item>(ref inv[slot], ref Main.mouseItem);
|
|
SoundEngine.PlaySound(7);
|
|
if (inv[slot].stack > 0)
|
|
{
|
|
if (context <= 12)
|
|
{
|
|
if (context != 0)
|
|
{
|
|
if ((uint) (context - 8) > 4U)
|
|
goto label_95;
|
|
}
|
|
else
|
|
{
|
|
AchievementsHelper.NotifyItemPickup(player, inv[slot]);
|
|
goto label_95;
|
|
}
|
|
}
|
|
else if ((uint) (context - 16) > 1U && context != 25 && context != 27)
|
|
goto label_95;
|
|
AchievementsHelper.HandleOnEquip(player, inv[slot], context);
|
|
}
|
|
}
|
|
else if (Main.mouseItem.type == 0 && inv[slot].type > 0)
|
|
{
|
|
Utils.Swap<Item>(ref inv[slot], ref Main.mouseItem);
|
|
if (inv[slot].type == 0 || inv[slot].stack < 1)
|
|
inv[slot] = new Item();
|
|
if (Main.mouseItem.type == 0 || Main.mouseItem.stack < 1)
|
|
Main.mouseItem = new Item();
|
|
if (Main.mouseItem.type > 0 || inv[slot].type > 0)
|
|
{
|
|
Recipe.FindRecipes();
|
|
SoundEngine.PlaySound(7);
|
|
}
|
|
}
|
|
else if (Main.mouseItem.dye > (byte) 0 && inv[slot].type == 0)
|
|
{
|
|
if (Main.mouseItem.stack == 1)
|
|
{
|
|
Utils.Swap<Item>(ref inv[slot], ref Main.mouseItem);
|
|
if (inv[slot].type == 0 || inv[slot].stack < 1)
|
|
inv[slot] = new Item();
|
|
if (Main.mouseItem.type == 0 || Main.mouseItem.stack < 1)
|
|
Main.mouseItem = new Item();
|
|
if (Main.mouseItem.type > 0 || inv[slot].type > 0)
|
|
{
|
|
Recipe.FindRecipes();
|
|
SoundEngine.PlaySound(7);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
--Main.mouseItem.stack;
|
|
inv[slot].SetDefaults(Main.mouseItem.type);
|
|
Recipe.FindRecipes();
|
|
SoundEngine.PlaySound(7);
|
|
}
|
|
if (inv[slot].stack > 0)
|
|
{
|
|
if (context <= 12)
|
|
{
|
|
if (context != 0)
|
|
{
|
|
if ((uint) (context - 8) > 4U)
|
|
goto label_95;
|
|
}
|
|
else
|
|
{
|
|
AchievementsHelper.NotifyItemPickup(player, inv[slot]);
|
|
goto label_95;
|
|
}
|
|
}
|
|
else if ((uint) (context - 16) > 1U && context != 25 && context != 27)
|
|
goto label_95;
|
|
AchievementsHelper.HandleOnEquip(player, inv[slot], context);
|
|
}
|
|
}
|
|
label_95:
|
|
if (context == 25 && Main.netMode == 1)
|
|
NetMessage.SendData(121, number: Main.myPlayer, number2: ((float) player.tileEntityAnchor.interactEntityID), number3: ((float) slot), number4: 1f);
|
|
if (context == 27 && Main.netMode == 1)
|
|
{
|
|
NetMessage.SendData(124, number: Main.myPlayer, number2: ((float) player.tileEntityAnchor.interactEntityID), number3: ((float) slot), number4: 1f);
|
|
break;
|
|
}
|
|
break;
|
|
case 3:
|
|
ItemSlot.HandleShopSlot(inv, slot, false, true);
|
|
break;
|
|
case 4:
|
|
Chest chest = Main.instance.shop[Main.npcShop];
|
|
if (player.SellItem(Main.mouseItem))
|
|
{
|
|
chest.AddItemToShop(Main.mouseItem);
|
|
Main.mouseItem.SetDefaults();
|
|
SoundEngine.PlaySound(18);
|
|
}
|
|
else if (Main.mouseItem.value == 0)
|
|
{
|
|
chest.AddItemToShop(Main.mouseItem);
|
|
Main.mouseItem.SetDefaults();
|
|
SoundEngine.PlaySound(7);
|
|
}
|
|
Recipe.FindRecipes();
|
|
Main.stackSplit = 9999;
|
|
break;
|
|
default:
|
|
if (num1 == 5 && Main.mouseItem.IsAir)
|
|
{
|
|
SoundEngine.PlaySound(7);
|
|
Main.mouseItem.SetDefaults(inv[slot].netID);
|
|
Main.mouseItem.stack = Main.mouseItem.maxStack;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if ((uint) context <= 2U || context == 5)
|
|
return;
|
|
inv[slot].favorited = false;
|
|
}
|
|
|
|
private static bool LeftClick_SellOrTrash(Item[] inv, int context, int slot)
|
|
{
|
|
bool flag1 = false;
|
|
bool flag2 = false;
|
|
if (ItemSlot.NotUsingGamepad && ItemSlot.Options.DisableLeftShiftTrashCan)
|
|
{
|
|
switch (context)
|
|
{
|
|
case 0:
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
case 4:
|
|
case 7:
|
|
flag1 = true;
|
|
break;
|
|
}
|
|
if (ItemSlot.ControlInUse & flag1)
|
|
{
|
|
ItemSlot.SellOrTrash(inv, context, slot);
|
|
flag2 = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch (context)
|
|
{
|
|
case 0:
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
case 4:
|
|
flag1 = Main.player[Main.myPlayer].chest == -1;
|
|
break;
|
|
}
|
|
if (ItemSlot.ShiftInUse & flag1)
|
|
{
|
|
ItemSlot.SellOrTrash(inv, context, slot);
|
|
flag2 = true;
|
|
}
|
|
}
|
|
return flag2;
|
|
}
|
|
|
|
private static void SellOrTrash(Item[] inv, int context, int slot)
|
|
{
|
|
Player player = Main.player[Main.myPlayer];
|
|
if (inv[slot].type <= 0)
|
|
return;
|
|
if (Main.npcShop > 0 && !inv[slot].favorited)
|
|
{
|
|
Chest chest = Main.instance.shop[Main.npcShop];
|
|
if (inv[slot].type >= 71 && inv[slot].type <= 74)
|
|
return;
|
|
if (player.SellItem(inv[slot]))
|
|
{
|
|
chest.AddItemToShop(inv[slot]);
|
|
inv[slot].SetDefaults();
|
|
SoundEngine.PlaySound(18);
|
|
Recipe.FindRecipes();
|
|
}
|
|
else
|
|
{
|
|
if (inv[slot].value != 0)
|
|
return;
|
|
chest.AddItemToShop(inv[slot]);
|
|
inv[slot].SetDefaults();
|
|
SoundEngine.PlaySound(7);
|
|
Recipe.FindRecipes();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (inv[slot].favorited)
|
|
return;
|
|
SoundEngine.PlaySound(7);
|
|
player.trashItem = inv[slot].Clone();
|
|
inv[slot].SetDefaults();
|
|
if (context == 3 && Main.netMode == 1)
|
|
NetMessage.SendData(32, number: player.chest, number2: ((float) slot));
|
|
Recipe.FindRecipes();
|
|
}
|
|
}
|
|
|
|
private static string GetOverrideInstructions(Item[] inv, int context, int slot)
|
|
{
|
|
Player player = Main.player[Main.myPlayer];
|
|
TileEntity tileEntity = player.tileEntityAnchor.GetTileEntity();
|
|
string instruction;
|
|
if (tileEntity != null && tileEntity.TryGetItemGamepadOverrideInstructions(inv, context, slot, out instruction))
|
|
return instruction;
|
|
if (inv[slot].type > 0 && inv[slot].stack > 0)
|
|
{
|
|
if (!inv[slot].favorited)
|
|
{
|
|
switch (context)
|
|
{
|
|
case 0:
|
|
case 1:
|
|
case 2:
|
|
if (Main.npcShop > 0 && !inv[slot].favorited)
|
|
return Lang.misc[75].Value;
|
|
if (Main.player[Main.myPlayer].chest != -1)
|
|
{
|
|
if (ChestUI.TryPlacingInChest(inv[slot], true))
|
|
return Lang.misc[76].Value;
|
|
break;
|
|
}
|
|
return Main.InGuideCraftMenu && inv[slot].material ? Lang.misc[76].Value : Lang.misc[74].Value;
|
|
case 3:
|
|
case 4:
|
|
if (Main.player[Main.myPlayer].ItemSpace(inv[slot]).CanTakeItemToPersonalInventory)
|
|
return Lang.misc[76].Value;
|
|
break;
|
|
case 5:
|
|
case 8:
|
|
case 9:
|
|
case 10:
|
|
case 11:
|
|
case 12:
|
|
case 16:
|
|
case 17:
|
|
case 18:
|
|
case 19:
|
|
case 20:
|
|
case 25:
|
|
case 27:
|
|
if (Main.player[Main.myPlayer].ItemSpace(inv[slot]).CanTakeItemToPersonalInventory)
|
|
return Lang.misc[68].Value;
|
|
break;
|
|
}
|
|
}
|
|
bool flag = false;
|
|
if ((uint) context <= 4U)
|
|
flag = player.chest == -1;
|
|
if (flag)
|
|
{
|
|
if (Main.npcShop > 0 && !inv[slot].favorited)
|
|
{
|
|
Chest chest = Main.instance.shop[Main.npcShop];
|
|
return inv[slot].type >= 71 && inv[slot].type <= 74 ? "" : Lang.misc[75].Value;
|
|
}
|
|
if (!inv[slot].favorited)
|
|
return Lang.misc[74].Value;
|
|
}
|
|
}
|
|
return "";
|
|
}
|
|
|
|
public static int PickItemMovementAction(Item[] inv, int context, int slot, Item checkItem)
|
|
{
|
|
Player player = Main.player[Main.myPlayer];
|
|
int num = -1;
|
|
switch (context)
|
|
{
|
|
case 0:
|
|
num = 0;
|
|
break;
|
|
case 1:
|
|
if (checkItem.type == 0 || checkItem.type == 71 || checkItem.type == 72 || checkItem.type == 73 || checkItem.type == 74)
|
|
{
|
|
num = 0;
|
|
break;
|
|
}
|
|
break;
|
|
case 2:
|
|
if (checkItem.FitsAmmoSlot())
|
|
{
|
|
num = 0;
|
|
break;
|
|
}
|
|
break;
|
|
case 3:
|
|
num = 0;
|
|
break;
|
|
case 4:
|
|
Item[] chestinv;
|
|
ChestUI.GetContainerUsageInfo(out bool _, out chestinv);
|
|
if (!ChestUI.IsBlockedFromTransferIntoChest(checkItem, chestinv))
|
|
{
|
|
num = 0;
|
|
break;
|
|
}
|
|
break;
|
|
case 5:
|
|
if (checkItem.Prefix(-3) || checkItem.type == 0)
|
|
{
|
|
num = 0;
|
|
break;
|
|
}
|
|
break;
|
|
case 6:
|
|
num = 0;
|
|
break;
|
|
case 7:
|
|
if (checkItem.material || checkItem.type == 0)
|
|
{
|
|
num = 0;
|
|
break;
|
|
}
|
|
break;
|
|
case 8:
|
|
if (checkItem.type == 0 || checkItem.headSlot > -1 && slot == 0 || checkItem.bodySlot > -1 && slot == 1 || checkItem.legSlot > -1 && slot == 2)
|
|
{
|
|
num = 1;
|
|
break;
|
|
}
|
|
break;
|
|
case 9:
|
|
if (checkItem.type == 0 || checkItem.headSlot > -1 && slot == 10 || checkItem.bodySlot > -1 && slot == 11 || checkItem.legSlot > -1 && slot == 12)
|
|
{
|
|
num = 1;
|
|
break;
|
|
}
|
|
break;
|
|
case 10:
|
|
if (checkItem.type == 0 || checkItem.accessory && !ItemSlot.AccCheck(Main.LocalPlayer.armor, checkItem, slot))
|
|
{
|
|
num = 1;
|
|
break;
|
|
}
|
|
break;
|
|
case 11:
|
|
if (checkItem.type == 0 || checkItem.accessory && !ItemSlot.AccCheck(Main.LocalPlayer.armor, checkItem, slot))
|
|
{
|
|
num = 1;
|
|
break;
|
|
}
|
|
break;
|
|
case 23:
|
|
if (checkItem.type == 0 || checkItem.headSlot > 0 && slot == 0 || checkItem.bodySlot > 0 && slot == 1 || checkItem.legSlot > 0 && slot == 2)
|
|
{
|
|
num = 1;
|
|
break;
|
|
}
|
|
break;
|
|
case 24:
|
|
if (checkItem.type == 0 || checkItem.accessory && !ItemSlot.AccCheck(inv, checkItem, slot))
|
|
{
|
|
num = 1;
|
|
break;
|
|
}
|
|
break;
|
|
case 26:
|
|
if (checkItem.type == 0 || checkItem.headSlot > 0)
|
|
{
|
|
num = 1;
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
if (context == 12 || context == 25 || context == 27)
|
|
{
|
|
num = 2;
|
|
break;
|
|
}
|
|
switch (context)
|
|
{
|
|
case 15:
|
|
if (checkItem.type == 0 && inv[slot].type > 0)
|
|
{
|
|
num = 3;
|
|
break;
|
|
}
|
|
if (checkItem.type == inv[slot].type && checkItem.type > 0 && checkItem.stack < checkItem.maxStack && inv[slot].stack > 0)
|
|
{
|
|
num = 3;
|
|
break;
|
|
}
|
|
if (inv[slot].type == 0 && checkItem.type > 0 && (checkItem.type < 71 || checkItem.type > 74))
|
|
{
|
|
num = 4;
|
|
break;
|
|
}
|
|
break;
|
|
case 16:
|
|
if (checkItem.type == 0 || Main.projHook[checkItem.shoot])
|
|
{
|
|
num = 1;
|
|
break;
|
|
}
|
|
break;
|
|
case 17:
|
|
if (checkItem.type == 0 || checkItem.mountType != -1 && !MountID.Sets.Cart[checkItem.mountType])
|
|
{
|
|
num = 1;
|
|
break;
|
|
}
|
|
break;
|
|
case 18:
|
|
if (checkItem.type == 0 || checkItem.mountType != -1 && MountID.Sets.Cart[checkItem.mountType])
|
|
{
|
|
num = 1;
|
|
break;
|
|
}
|
|
break;
|
|
case 19:
|
|
if (checkItem.type == 0 || checkItem.buffType > 0 && Main.vanityPet[checkItem.buffType] && !Main.lightPet[checkItem.buffType])
|
|
{
|
|
num = 1;
|
|
break;
|
|
}
|
|
break;
|
|
case 20:
|
|
if (checkItem.type == 0 || checkItem.buffType > 0 && Main.lightPet[checkItem.buffType])
|
|
{
|
|
num = 1;
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
if (context == 29 && checkItem.type == 0 && inv[slot].type > 0)
|
|
{
|
|
num = 5;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if (context == 30)
|
|
num = 0;
|
|
return num;
|
|
}
|
|
|
|
public static void RightClick(ref Item inv, int context = 0)
|
|
{
|
|
ItemSlot.singleSlotArray[0] = inv;
|
|
ItemSlot.RightClick(ItemSlot.singleSlotArray, context);
|
|
inv = ItemSlot.singleSlotArray[0];
|
|
}
|
|
|
|
public static void RightClick(Item[] inv, int context = 0, int slot = 0)
|
|
{
|
|
Player player = Main.player[Main.myPlayer];
|
|
inv[slot].newAndShiny = false;
|
|
if (player.itemAnimation > 0 || ItemSlot.RightClick_FindSpecialActions(inv, context, slot, player))
|
|
return;
|
|
if ((context == 0 || context == 4 || context == 3) && Main.mouseRight && Main.mouseRightRelease && inv[slot].maxStack == 1)
|
|
{
|
|
ItemSlot.SwapEquip(inv, context, slot);
|
|
}
|
|
else
|
|
{
|
|
if (Main.stackSplit > 1 || !Main.mouseRight)
|
|
return;
|
|
bool flag = true;
|
|
if (context == 0 && inv[slot].maxStack <= 1)
|
|
flag = false;
|
|
if (context == 3 && inv[slot].maxStack <= 1)
|
|
flag = false;
|
|
if (context == 4 && inv[slot].maxStack <= 1)
|
|
flag = false;
|
|
if (!flag || !Main.mouseItem.IsTheSameAs(inv[slot]) && Main.mouseItem.type != 0 || Main.mouseItem.stack >= Main.mouseItem.maxStack && Main.mouseItem.type != 0)
|
|
return;
|
|
ItemSlot.PickupItemIntoMouse(inv, context, slot, player);
|
|
SoundEngine.PlaySound(12);
|
|
ItemSlot.RefreshStackSplitCooldown();
|
|
}
|
|
}
|
|
|
|
public static void PickupItemIntoMouse(Item[] inv, int context, int slot, Player player)
|
|
{
|
|
if (Main.mouseItem.type == 0)
|
|
{
|
|
Main.mouseItem = inv[slot].Clone();
|
|
if (context == 29)
|
|
Main.mouseItem.SetDefaults(Main.mouseItem.type);
|
|
Main.mouseItem.stack = 0;
|
|
Main.mouseItem.favorited = inv[slot].favorited && inv[slot].stack == 1;
|
|
}
|
|
++Main.mouseItem.stack;
|
|
if (context != 29)
|
|
--inv[slot].stack;
|
|
if (inv[slot].stack <= 0)
|
|
inv[slot] = new Item();
|
|
Recipe.FindRecipes();
|
|
if (context == 3 && Main.netMode == 1)
|
|
NetMessage.SendData(32, number: player.chest, number2: ((float) slot));
|
|
if ((context == 23 || context == 24) && Main.netMode == 1)
|
|
NetMessage.SendData(121, number: Main.myPlayer, number2: ((float) player.tileEntityAnchor.interactEntityID), number3: ((float) slot));
|
|
if (context == 25 && Main.netMode == 1)
|
|
NetMessage.SendData(121, number: Main.myPlayer, number2: ((float) player.tileEntityAnchor.interactEntityID), number3: ((float) slot), number4: 1f);
|
|
if (context == 26 && Main.netMode == 1)
|
|
NetMessage.SendData(124, number: Main.myPlayer, number2: ((float) player.tileEntityAnchor.interactEntityID), number3: ((float) slot));
|
|
if (context != 27 || Main.netMode != 1)
|
|
return;
|
|
NetMessage.SendData(124, number: Main.myPlayer, number2: ((float) player.tileEntityAnchor.interactEntityID), number3: ((float) slot), number4: 1f);
|
|
}
|
|
|
|
public static void RefreshStackSplitCooldown()
|
|
{
|
|
if (Main.stackSplit == 0)
|
|
Main.stackSplit = 30;
|
|
else
|
|
Main.stackSplit = Main.stackDelay;
|
|
}
|
|
|
|
private static bool RightClick_FindSpecialActions(
|
|
Item[] inv,
|
|
int context,
|
|
int slot,
|
|
Player player)
|
|
{
|
|
bool flag1 = false;
|
|
switch (context)
|
|
{
|
|
case 0:
|
|
flag1 = true;
|
|
if (Main.mouseRight && (inv[slot].type >= 3318 && inv[slot].type <= 3332 || inv[slot].type == 3860 || inv[slot].type == 3862 || inv[slot].type == 3861 || inv[slot].type == 4782 || inv[slot].type == 4957))
|
|
{
|
|
if (Main.mouseRightRelease)
|
|
{
|
|
player.OpenBossBag(inv[slot].type);
|
|
--inv[slot].stack;
|
|
if (inv[slot].stack == 0)
|
|
inv[slot].SetDefaults();
|
|
SoundEngine.PlaySound(7);
|
|
Main.stackSplit = 30;
|
|
Main.mouseRightRelease = false;
|
|
Recipe.FindRecipes();
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if (Main.mouseRight && inv[slot].type > 0 && inv[slot].type < 5045 && ItemID.Sets.IsFishingCrate[inv[slot].type])
|
|
{
|
|
if (Main.mouseRightRelease)
|
|
{
|
|
player.OpenFishingCrate(inv[slot].type);
|
|
--inv[slot].stack;
|
|
if (inv[slot].stack == 0)
|
|
inv[slot].SetDefaults();
|
|
SoundEngine.PlaySound(7);
|
|
Main.stackSplit = 30;
|
|
Main.mouseRightRelease = false;
|
|
Recipe.FindRecipes();
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if (Main.mouseRight && inv[slot].type == 3093)
|
|
{
|
|
if (Main.mouseRightRelease)
|
|
{
|
|
player.OpenHerbBag();
|
|
--inv[slot].stack;
|
|
if (inv[slot].stack == 0)
|
|
inv[slot].SetDefaults();
|
|
SoundEngine.PlaySound(7);
|
|
Main.stackSplit = 30;
|
|
Main.mouseRightRelease = false;
|
|
Recipe.FindRecipes();
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if (Main.mouseRight && inv[slot].type == 4345)
|
|
{
|
|
if (Main.mouseRightRelease)
|
|
{
|
|
player.OpenCanofWorms();
|
|
--inv[slot].stack;
|
|
if (inv[slot].stack == 0)
|
|
inv[slot].SetDefaults();
|
|
SoundEngine.PlaySound(7);
|
|
Main.stackSplit = 30;
|
|
Main.mouseRightRelease = false;
|
|
Recipe.FindRecipes();
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if (Main.mouseRight && inv[slot].type == 4410)
|
|
{
|
|
if (Main.mouseRightRelease)
|
|
{
|
|
player.OpenOyster();
|
|
--inv[slot].stack;
|
|
if (inv[slot].stack == 0)
|
|
inv[slot].SetDefaults();
|
|
SoundEngine.PlaySound(7);
|
|
Main.stackSplit = 30;
|
|
Main.mouseRightRelease = false;
|
|
Recipe.FindRecipes();
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if (Main.mouseRight && inv[slot].type == 1774)
|
|
{
|
|
if (Main.mouseRightRelease)
|
|
{
|
|
--inv[slot].stack;
|
|
if (inv[slot].stack == 0)
|
|
inv[slot].SetDefaults();
|
|
SoundEngine.PlaySound(7);
|
|
Main.stackSplit = 30;
|
|
Main.mouseRightRelease = false;
|
|
player.OpenGoodieBag();
|
|
Recipe.FindRecipes();
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if (Main.mouseRight && inv[slot].type == 3085)
|
|
{
|
|
if (Main.mouseRightRelease && player.ConsumeItem(327))
|
|
{
|
|
--inv[slot].stack;
|
|
if (inv[slot].stack == 0)
|
|
inv[slot].SetDefaults();
|
|
SoundEngine.PlaySound(7);
|
|
Main.stackSplit = 30;
|
|
Main.mouseRightRelease = false;
|
|
player.OpenLockBox();
|
|
Recipe.FindRecipes();
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if (Main.mouseRight && inv[slot].type == 4879)
|
|
{
|
|
if (Main.mouseRightRelease && player.HasItem(329))
|
|
{
|
|
--inv[slot].stack;
|
|
if (inv[slot].stack == 0)
|
|
inv[slot].SetDefaults();
|
|
SoundEngine.PlaySound(7);
|
|
Main.stackSplit = 30;
|
|
Main.mouseRightRelease = false;
|
|
player.OpenShadowLockbox();
|
|
Recipe.FindRecipes();
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if (Main.mouseRight && inv[slot].type == 1869)
|
|
{
|
|
if (Main.mouseRightRelease)
|
|
{
|
|
--inv[slot].stack;
|
|
if (inv[slot].stack == 0)
|
|
inv[slot].SetDefaults();
|
|
SoundEngine.PlaySound(7);
|
|
Main.stackSplit = 30;
|
|
Main.mouseRightRelease = false;
|
|
player.openPresent();
|
|
Recipe.FindRecipes();
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if (Main.mouseRight && Main.mouseRightRelease && (inv[slot].type == 599 || inv[slot].type == 600 || inv[slot].type == 601))
|
|
{
|
|
SoundEngine.PlaySound(7);
|
|
Main.stackSplit = 30;
|
|
Main.mouseRightRelease = false;
|
|
int num = Main.rand.Next(14);
|
|
if (num == 0 && Main.hardMode)
|
|
inv[slot].SetDefaults(602);
|
|
else if (num <= 7)
|
|
{
|
|
inv[slot].SetDefaults(586);
|
|
inv[slot].stack = Main.rand.Next(20, 50);
|
|
}
|
|
else
|
|
{
|
|
inv[slot].SetDefaults(591);
|
|
inv[slot].stack = Main.rand.Next(20, 50);
|
|
}
|
|
Recipe.FindRecipes();
|
|
break;
|
|
}
|
|
flag1 = false;
|
|
break;
|
|
case 9:
|
|
case 11:
|
|
flag1 = true;
|
|
if (Main.mouseRight && Main.mouseRightRelease)
|
|
{
|
|
if (Main.npcShop > 0)
|
|
return true;
|
|
if (inv[slot].type > 0 && inv[slot].stack > 0 || inv[slot - 10].type > 0 && inv[slot - 10].stack > 0)
|
|
{
|
|
Item obj = inv[slot - 10];
|
|
bool flag2 = context != 11 || obj.FitsAccessoryVanitySlot || obj.IsAir;
|
|
if (flag2 && context == 11 && inv[slot].wingSlot > (sbyte) 0)
|
|
{
|
|
for (int index = 3; index < 10; ++index)
|
|
{
|
|
if (inv[index].wingSlot > (sbyte) 0 && index != slot - 10)
|
|
flag2 = false;
|
|
}
|
|
}
|
|
if (flag2)
|
|
{
|
|
Utils.Swap<Item>(ref inv[slot], ref inv[slot - 10]);
|
|
SoundEngine.PlaySound(7);
|
|
Recipe.FindRecipes();
|
|
if (inv[slot].stack > 0)
|
|
{
|
|
switch (context)
|
|
{
|
|
case 0:
|
|
AchievementsHelper.NotifyItemPickup(player, inv[slot]);
|
|
break;
|
|
case 8:
|
|
case 9:
|
|
case 10:
|
|
case 11:
|
|
case 12:
|
|
case 16:
|
|
case 17:
|
|
case 25:
|
|
case 27:
|
|
AchievementsHelper.HandleOnEquip(player, inv[slot], context);
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
else
|
|
break;
|
|
break;
|
|
case 12:
|
|
case 25:
|
|
case 27:
|
|
flag1 = true;
|
|
if (Main.mouseRight && Main.mouseRightRelease)
|
|
{
|
|
bool flag3 = false;
|
|
if (!flag3 && (Main.mouseItem.stack < Main.mouseItem.maxStack && Main.mouseItem.type > 0 || Main.mouseItem.IsAir) && inv[slot].type > 0 && (Main.mouseItem.type == inv[slot].type || Main.mouseItem.IsAir))
|
|
{
|
|
flag3 = true;
|
|
if (Main.mouseItem.IsAir)
|
|
Main.mouseItem.SetDefaults(inv[slot].type);
|
|
else
|
|
++Main.mouseItem.stack;
|
|
inv[slot].SetDefaults();
|
|
SoundEngine.PlaySound(7);
|
|
}
|
|
if (flag3)
|
|
{
|
|
if (context == 25 && Main.netMode == 1)
|
|
NetMessage.SendData(121, number: Main.myPlayer, number2: ((float) player.tileEntityAnchor.interactEntityID), number3: ((float) slot), number4: 1f);
|
|
if (context == 27 && Main.netMode == 1)
|
|
{
|
|
NetMessage.SendData(124, number: Main.myPlayer, number2: ((float) player.tileEntityAnchor.interactEntityID), number3: ((float) slot), number4: 1f);
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
case 15:
|
|
flag1 = true;
|
|
ItemSlot.HandleShopSlot(inv, slot, true, false);
|
|
break;
|
|
}
|
|
return flag1;
|
|
}
|
|
|
|
private static void HandleShopSlot(
|
|
Item[] inv,
|
|
int slot,
|
|
bool rightClickIsValid,
|
|
bool leftClickIsValid)
|
|
{
|
|
if (Main.cursorOverride == 2)
|
|
return;
|
|
Chest chest = Main.instance.shop[Main.npcShop];
|
|
bool flag = Main.mouseRight & rightClickIsValid || Main.mouseLeft & leftClickIsValid;
|
|
if (!(Main.stackSplit <= 1 & flag) || inv[slot].type <= 0 || !Main.mouseItem.IsTheSameAs(inv[slot]) && Main.mouseItem.type != 0)
|
|
return;
|
|
int num = Main.superFastStack + 1;
|
|
Player localPlayer = Main.LocalPlayer;
|
|
for (int index = 0; index < num; ++index)
|
|
{
|
|
if (Main.mouseItem.stack < Main.mouseItem.maxStack || Main.mouseItem.type == 0)
|
|
{
|
|
int calcForBuying;
|
|
localPlayer.GetItemExpectedPrice(inv[slot], out int _, out calcForBuying);
|
|
if (localPlayer.BuyItem(calcForBuying, inv[slot].shopSpecialCurrency) && inv[slot].stack > 0)
|
|
{
|
|
if (index == 0)
|
|
{
|
|
if (inv[slot].value > 0)
|
|
SoundEngine.PlaySound(18);
|
|
else
|
|
SoundEngine.PlaySound(7);
|
|
}
|
|
if (Main.mouseItem.type == 0)
|
|
{
|
|
Main.mouseItem.netDefaults(inv[slot].netID);
|
|
if (inv[slot].prefix != (byte) 0)
|
|
Main.mouseItem.Prefix((int) inv[slot].prefix);
|
|
Main.mouseItem.stack = 0;
|
|
}
|
|
if (!inv[slot].buyOnce)
|
|
Main.shopSellbackHelper.Add(inv[slot]);
|
|
++Main.mouseItem.stack;
|
|
ItemSlot.RefreshStackSplitCooldown();
|
|
if (inv[slot].buyOnce && --inv[slot].stack <= 0)
|
|
inv[slot].SetDefaults();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void Draw(
|
|
SpriteBatch spriteBatch,
|
|
ref Item inv,
|
|
int context,
|
|
Vector2 position,
|
|
Color lightColor = default (Color))
|
|
{
|
|
ItemSlot.singleSlotArray[0] = inv;
|
|
ItemSlot.Draw(spriteBatch, ItemSlot.singleSlotArray, context, 0, position, lightColor);
|
|
inv = ItemSlot.singleSlotArray[0];
|
|
}
|
|
|
|
public static void Draw(
|
|
SpriteBatch spriteBatch,
|
|
Item[] inv,
|
|
int context,
|
|
int slot,
|
|
Vector2 position,
|
|
Color lightColor = default (Color))
|
|
{
|
|
Player player = Main.player[Main.myPlayer];
|
|
Item obj = inv[slot];
|
|
float inventoryScale = Main.inventoryScale;
|
|
Color color1 = Color.White;
|
|
if (lightColor != Color.Transparent)
|
|
color1 = lightColor;
|
|
int ID = -1;
|
|
bool flag1 = false;
|
|
int num1 = 0;
|
|
if (PlayerInput.UsingGamepadUI)
|
|
{
|
|
switch (context)
|
|
{
|
|
case 0:
|
|
case 1:
|
|
case 2:
|
|
ID = slot;
|
|
break;
|
|
case 3:
|
|
case 4:
|
|
ID = 400 + slot;
|
|
break;
|
|
case 5:
|
|
ID = 303;
|
|
break;
|
|
case 6:
|
|
ID = 300;
|
|
break;
|
|
case 7:
|
|
ID = 1500;
|
|
break;
|
|
case 8:
|
|
case 9:
|
|
case 10:
|
|
case 11:
|
|
ID = 100 + slot;
|
|
break;
|
|
case 12:
|
|
if (inv == player.dye)
|
|
ID = 120 + slot;
|
|
if (inv == player.miscDyes)
|
|
{
|
|
ID = 185 + slot;
|
|
break;
|
|
}
|
|
break;
|
|
case 15:
|
|
ID = 2700 + slot;
|
|
break;
|
|
case 16:
|
|
ID = 184;
|
|
break;
|
|
case 17:
|
|
ID = 183;
|
|
break;
|
|
case 18:
|
|
ID = 182;
|
|
break;
|
|
case 19:
|
|
ID = 180;
|
|
break;
|
|
case 20:
|
|
ID = 181;
|
|
break;
|
|
case 22:
|
|
if (UILinkPointNavigator.Shortcuts.CRAFT_CurrentRecipeBig != -1)
|
|
ID = 700 + UILinkPointNavigator.Shortcuts.CRAFT_CurrentRecipeBig;
|
|
if (UILinkPointNavigator.Shortcuts.CRAFT_CurrentRecipeSmall != -1)
|
|
{
|
|
ID = 1500 + UILinkPointNavigator.Shortcuts.CRAFT_CurrentRecipeSmall + 1;
|
|
break;
|
|
}
|
|
break;
|
|
case 23:
|
|
ID = 5100 + slot;
|
|
break;
|
|
case 24:
|
|
ID = 5100 + slot;
|
|
break;
|
|
case 25:
|
|
ID = 5108 + slot;
|
|
break;
|
|
case 26:
|
|
ID = 5000 + slot;
|
|
break;
|
|
case 27:
|
|
ID = 5002 + slot;
|
|
break;
|
|
case 29:
|
|
ID = 3000 + slot;
|
|
if (UILinkPointNavigator.Shortcuts.CREATIVE_ItemSlotShouldHighlightAsSelected)
|
|
{
|
|
ID = UILinkPointNavigator.CurrentPoint;
|
|
break;
|
|
}
|
|
break;
|
|
case 30:
|
|
ID = 15000 + slot;
|
|
break;
|
|
}
|
|
flag1 = UILinkPointNavigator.CurrentPoint == ID;
|
|
if (context == 0)
|
|
{
|
|
num1 = player.DpadRadial.GetDrawMode(slot);
|
|
if (num1 > 0 && !PlayerInput.CurrentProfile.UsingDpadHotbar())
|
|
num1 = 0;
|
|
}
|
|
}
|
|
Texture2D texture2D1 = TextureAssets.InventoryBack.Value;
|
|
Color color2 = Main.inventoryBack;
|
|
bool flag2 = false;
|
|
if (obj.type > 0 && obj.stack > 0 && obj.favorited && context != 13 && context != 21 && context != 22 && context != 14)
|
|
{
|
|
texture2D1 = TextureAssets.InventoryBack10.Value;
|
|
if (context == 0 && slot < 10 && player.selectedItem == slot)
|
|
{
|
|
color2 = Color.White;
|
|
texture2D1 = TextureAssets.InventoryBack17.Value;
|
|
}
|
|
}
|
|
else if (obj.type > 0 && obj.stack > 0 && ItemSlot.Options.HighlightNewItems && obj.newAndShiny && context != 13 && context != 21 && context != 14 && context != 22)
|
|
{
|
|
texture2D1 = TextureAssets.InventoryBack15.Value;
|
|
float num2 = (float) ((double) ((float) Main.mouseTextColor / (float) byte.MaxValue) * 0.200000002980232 + 0.800000011920929);
|
|
color2 = color2.MultiplyRGBA(new Color(num2, num2, num2));
|
|
}
|
|
else if (PlayerInput.UsingGamepadUI && obj.type > 0 && obj.stack > 0 && num1 != 0 && context != 13 && context != 21 && context != 22)
|
|
{
|
|
texture2D1 = TextureAssets.InventoryBack15.Value;
|
|
float num3 = (float) ((double) ((float) Main.mouseTextColor / (float) byte.MaxValue) * 0.200000002980232 + 0.800000011920929);
|
|
color2 = num1 != 1 ? color2.MultiplyRGBA(new Color(num3 / 2f, num3, num3 / 2f)) : color2.MultiplyRGBA(new Color(num3, num3 / 2f, num3 / 2f));
|
|
}
|
|
else if (context == 0 && slot < 10)
|
|
{
|
|
texture2D1 = TextureAssets.InventoryBack9.Value;
|
|
if (player.selectedItem == slot && !PlayerInput.UsingGamepad)
|
|
{
|
|
texture2D1 = TextureAssets.InventoryBack14.Value;
|
|
color2 = Color.White;
|
|
}
|
|
}
|
|
else if (context == 28)
|
|
{
|
|
texture2D1 = TextureAssets.InventoryBack7.Value;
|
|
color2 = Color.White;
|
|
}
|
|
else if (context == 10 || context == 8 || context == 16 || context == 17 || context == 19 || context == 18 || context == 20)
|
|
texture2D1 = TextureAssets.InventoryBack3.Value;
|
|
else if (context == 11 || context == 9 || context == 24 || context == 23 || context == 26)
|
|
texture2D1 = TextureAssets.InventoryBack8.Value;
|
|
else if (context == 12 || context == 25 || context == 27)
|
|
{
|
|
texture2D1 = TextureAssets.InventoryBack12.Value;
|
|
}
|
|
else
|
|
{
|
|
switch (context)
|
|
{
|
|
case 3:
|
|
texture2D1 = TextureAssets.InventoryBack5.Value;
|
|
break;
|
|
case 4:
|
|
texture2D1 = TextureAssets.InventoryBack2.Value;
|
|
break;
|
|
default:
|
|
if (context == 7 || context == 5)
|
|
{
|
|
texture2D1 = TextureAssets.InventoryBack4.Value;
|
|
break;
|
|
}
|
|
switch (context)
|
|
{
|
|
case 6:
|
|
texture2D1 = TextureAssets.InventoryBack7.Value;
|
|
break;
|
|
case 13:
|
|
byte num4 = 200;
|
|
if (slot == Main.player[Main.myPlayer].selectedItem)
|
|
{
|
|
texture2D1 = TextureAssets.InventoryBack14.Value;
|
|
num4 = byte.MaxValue;
|
|
}
|
|
color2 = new Color((int) num4, (int) num4, (int) num4, (int) num4);
|
|
break;
|
|
default:
|
|
if (context == 14 || context == 21)
|
|
{
|
|
flag2 = true;
|
|
break;
|
|
}
|
|
switch (context)
|
|
{
|
|
case 15:
|
|
texture2D1 = TextureAssets.InventoryBack6.Value;
|
|
break;
|
|
case 22:
|
|
texture2D1 = TextureAssets.InventoryBack4.Value;
|
|
if (ItemSlot.DrawGoldBGForCraftingMaterial)
|
|
{
|
|
ItemSlot.DrawGoldBGForCraftingMaterial = false;
|
|
texture2D1 = TextureAssets.InventoryBack14.Value;
|
|
float t = (float) color2.A / (float) byte.MaxValue;
|
|
color2 = Color.White * ((double) t >= 0.699999988079071 ? 1f : Utils.GetLerpValue(0.0f, 0.7f, t, true));
|
|
break;
|
|
}
|
|
break;
|
|
case 29:
|
|
color2 = new Color(53, 69, (int) sbyte.MaxValue, (int) byte.MaxValue);
|
|
texture2D1 = TextureAssets.InventoryBack18.Value;
|
|
break;
|
|
case 30:
|
|
flag2 = !flag1;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if ((context == 0 || context == 2) && ItemSlot.inventoryGlowTime[slot] > 0 && !inv[slot].favorited && !inv[slot].IsAir)
|
|
{
|
|
float num5 = Main.invAlpha / (float) byte.MaxValue;
|
|
Color color3 = new Color(63, 65, 151, (int) byte.MaxValue) * num5;
|
|
Color color4 = Main.hslToRgb(ItemSlot.inventoryGlowHue[slot], 1f, 0.5f) * num5;
|
|
float num6 = (float) ItemSlot.inventoryGlowTime[slot] / 300f;
|
|
float num7 = num6 * num6;
|
|
Color color5 = color4;
|
|
double num8 = (double) num7 / 2.0;
|
|
color2 = Color.Lerp(color3, color5, (float) num8);
|
|
texture2D1 = TextureAssets.InventoryBack13.Value;
|
|
}
|
|
if ((context == 4 || context == 3) && ItemSlot.inventoryGlowTimeChest[slot] > 0 && !inv[slot].favorited && !inv[slot].IsAir)
|
|
{
|
|
float num9 = Main.invAlpha / (float) byte.MaxValue;
|
|
Color color6 = new Color(130, 62, 102, (int) byte.MaxValue) * num9;
|
|
if (context == 3)
|
|
color6 = new Color(104, 52, 52, (int) byte.MaxValue) * num9;
|
|
Color color7 = Main.hslToRgb(ItemSlot.inventoryGlowHueChest[slot], 1f, 0.5f) * num9;
|
|
float num10 = (float) ItemSlot.inventoryGlowTimeChest[slot] / 300f;
|
|
float num11 = num10 * num10;
|
|
color2 = Color.Lerp(color6, color7, num11 / 2f);
|
|
texture2D1 = TextureAssets.InventoryBack13.Value;
|
|
}
|
|
if (flag1)
|
|
{
|
|
texture2D1 = TextureAssets.InventoryBack14.Value;
|
|
color2 = Color.White;
|
|
}
|
|
if (context == 28 && Main.MouseScreen.Between(position, position + texture2D1.Size() * inventoryScale) && !player.mouseInterface)
|
|
{
|
|
texture2D1 = TextureAssets.InventoryBack14.Value;
|
|
color2 = Color.White;
|
|
}
|
|
if (!flag2)
|
|
spriteBatch.Draw(texture2D1, position, new Rectangle?(), color2, 0.0f, new Vector2(), inventoryScale, SpriteEffects.None, 0.0f);
|
|
int num12 = -1;
|
|
switch (context)
|
|
{
|
|
case 8:
|
|
case 23:
|
|
if (slot == 0)
|
|
num12 = 0;
|
|
if (slot == 1)
|
|
num12 = 6;
|
|
if (slot == 2)
|
|
{
|
|
num12 = 12;
|
|
break;
|
|
}
|
|
break;
|
|
case 9:
|
|
if (slot == 10)
|
|
num12 = 3;
|
|
if (slot == 11)
|
|
num12 = 9;
|
|
if (slot == 12)
|
|
{
|
|
num12 = 15;
|
|
break;
|
|
}
|
|
break;
|
|
case 10:
|
|
case 24:
|
|
num12 = 11;
|
|
break;
|
|
case 11:
|
|
num12 = 2;
|
|
break;
|
|
case 12:
|
|
case 25:
|
|
case 27:
|
|
num12 = 1;
|
|
break;
|
|
case 16:
|
|
num12 = 4;
|
|
break;
|
|
case 17:
|
|
num12 = 13;
|
|
break;
|
|
case 18:
|
|
num12 = 7;
|
|
break;
|
|
case 19:
|
|
num12 = 10;
|
|
break;
|
|
case 20:
|
|
num12 = 17;
|
|
break;
|
|
case 26:
|
|
num12 = 0;
|
|
break;
|
|
}
|
|
if ((obj.type <= 0 || obj.stack <= 0) && num12 != -1)
|
|
{
|
|
Texture2D texture2D2 = TextureAssets.Extra[54].Value;
|
|
Rectangle r = texture2D2.Frame(3, 6, num12 % 3, num12 / 3);
|
|
r.Width -= 2;
|
|
r.Height -= 2;
|
|
spriteBatch.Draw(texture2D2, position + texture2D1.Size() / 2f * inventoryScale, new Rectangle?(r), Color.White * 0.35f, 0.0f, r.Size() / 2f, inventoryScale, SpriteEffects.None, 0.0f);
|
|
}
|
|
Vector2 vector2 = texture2D1.Size() * inventoryScale;
|
|
if (obj.type > 0 && obj.stack > 0)
|
|
{
|
|
Main.instance.LoadItem(obj.type);
|
|
Texture2D texture2D3 = TextureAssets.Item[obj.type].Value;
|
|
Rectangle r = Main.itemAnimations[obj.type] == null ? texture2D3.Frame() : Main.itemAnimations[obj.type].GetFrame(texture2D3);
|
|
Color currentColor = color1;
|
|
float scale1 = 1f;
|
|
ItemSlot.GetItemLight(ref currentColor, ref scale1, obj);
|
|
float num13 = 1f;
|
|
if (r.Width > 32 || r.Height > 32)
|
|
num13 = r.Width <= r.Height ? 32f / (float) r.Height : 32f / (float) r.Width;
|
|
float scale2 = num13 * inventoryScale;
|
|
Vector2 position1 = position + vector2 / 2f - r.Size() * scale2 / 2f;
|
|
Vector2 origin = r.Size() * (float) ((double) scale1 / 2.0 - 0.5);
|
|
spriteBatch.Draw(texture2D3, position1, new Rectangle?(r), obj.GetAlpha(currentColor), 0.0f, origin, scale2 * scale1, SpriteEffects.None, 0.0f);
|
|
if (obj.color != Color.Transparent)
|
|
spriteBatch.Draw(texture2D3, position1, new Rectangle?(r), obj.GetColor(color1), 0.0f, origin, scale2 * scale1, SpriteEffects.None, 0.0f);
|
|
if (ItemID.Sets.TrapSigned[obj.type])
|
|
spriteBatch.Draw(TextureAssets.Wire.Value, position + new Vector2(40f, 40f) * inventoryScale, new Rectangle?(new Rectangle(4, 58, 8, 8)), color1, 0.0f, new Vector2(4f), 1f, SpriteEffects.None, 0.0f);
|
|
if (obj.stack > 1)
|
|
ChatManager.DrawColorCodedStringWithShadow(spriteBatch, FontAssets.ItemStack.Value, obj.stack.ToString(), position + new Vector2(10f, 26f) * inventoryScale, color1, 0.0f, Vector2.Zero, new Vector2(inventoryScale), spread: inventoryScale);
|
|
int num14 = -1;
|
|
if (context == 13)
|
|
{
|
|
if (obj.DD2Summon)
|
|
{
|
|
for (int index = 0; index < 58; ++index)
|
|
{
|
|
if (inv[index].type == 3822)
|
|
num14 += inv[index].stack;
|
|
}
|
|
if (num14 >= 0)
|
|
++num14;
|
|
}
|
|
if (obj.useAmmo > 0)
|
|
{
|
|
int useAmmo = obj.useAmmo;
|
|
num14 = 0;
|
|
for (int index = 0; index < 58; ++index)
|
|
{
|
|
if (inv[index].ammo == useAmmo)
|
|
num14 += inv[index].stack;
|
|
}
|
|
}
|
|
if (obj.fishingPole > 0)
|
|
{
|
|
num14 = 0;
|
|
for (int index = 0; index < 58; ++index)
|
|
{
|
|
if (inv[index].bait > 0)
|
|
num14 += inv[index].stack;
|
|
}
|
|
}
|
|
if (obj.tileWand > 0)
|
|
{
|
|
int tileWand = obj.tileWand;
|
|
num14 = 0;
|
|
for (int index = 0; index < 58; ++index)
|
|
{
|
|
if (inv[index].type == tileWand)
|
|
num14 += inv[index].stack;
|
|
}
|
|
}
|
|
if (obj.type == 509 || obj.type == 851 || obj.type == 850 || obj.type == 3612 || obj.type == 3625 || obj.type == 3611)
|
|
{
|
|
num14 = 0;
|
|
for (int index = 0; index < 58; ++index)
|
|
{
|
|
if (inv[index].type == 530)
|
|
num14 += inv[index].stack;
|
|
}
|
|
}
|
|
}
|
|
if (num14 != -1)
|
|
ChatManager.DrawColorCodedStringWithShadow(spriteBatch, FontAssets.ItemStack.Value, num14.ToString(), position + new Vector2(8f, 30f) * inventoryScale, color1, 0.0f, Vector2.Zero, new Vector2(inventoryScale * 0.8f), spread: inventoryScale);
|
|
if (context == 13)
|
|
{
|
|
string text = string.Concat((object) (slot + 1));
|
|
if (text == "10")
|
|
text = "0";
|
|
ChatManager.DrawColorCodedStringWithShadow(spriteBatch, FontAssets.ItemStack.Value, text, position + new Vector2(8f, 4f) * inventoryScale, color1, 0.0f, Vector2.Zero, new Vector2(inventoryScale), spread: inventoryScale);
|
|
}
|
|
if (context == 13 && obj.potion)
|
|
{
|
|
Vector2 position2 = position + texture2D1.Size() * inventoryScale / 2f - TextureAssets.Cd.Value.Size() * inventoryScale / 2f;
|
|
Color color8 = obj.GetAlpha(color1) * ((float) player.potionDelay / (float) player.potionDelayTime);
|
|
spriteBatch.Draw(TextureAssets.Cd.Value, position2, new Rectangle?(), color8, 0.0f, new Vector2(), scale2, SpriteEffects.None, 0.0f);
|
|
}
|
|
if ((context == 10 || context == 18) && obj.expertOnly && !Main.expertMode)
|
|
{
|
|
Vector2 position3 = position + texture2D1.Size() * inventoryScale / 2f - TextureAssets.Cd.Value.Size() * inventoryScale / 2f;
|
|
Color white = Color.White;
|
|
spriteBatch.Draw(TextureAssets.Cd.Value, position3, new Rectangle?(), white, 0.0f, new Vector2(), scale2, SpriteEffects.None, 0.0f);
|
|
}
|
|
}
|
|
else if (context == 6)
|
|
{
|
|
Texture2D texture2D4 = TextureAssets.Trash.Value;
|
|
Vector2 position4 = position + texture2D1.Size() * inventoryScale / 2f - texture2D4.Size() * inventoryScale / 2f;
|
|
spriteBatch.Draw(texture2D4, position4, new Rectangle?(), new Color(100, 100, 100, 100), 0.0f, new Vector2(), inventoryScale, SpriteEffects.None, 0.0f);
|
|
}
|
|
if (context == 0 && slot < 10)
|
|
{
|
|
float num15 = inventoryScale;
|
|
string text = string.Concat((object) (slot + 1));
|
|
if (text == "10")
|
|
text = "0";
|
|
Color baseColor = Main.inventoryBack;
|
|
int num16 = 0;
|
|
if (Main.player[Main.myPlayer].selectedItem == slot)
|
|
{
|
|
baseColor = Color.White;
|
|
baseColor.A = (byte) 200;
|
|
num16 -= 2;
|
|
float num17 = num15 * 1.4f;
|
|
}
|
|
ChatManager.DrawColorCodedStringWithShadow(spriteBatch, FontAssets.ItemStack.Value, text, position + new Vector2(6f, (float) (4 + num16)) * inventoryScale, baseColor, 0.0f, Vector2.Zero, new Vector2(inventoryScale), spread: inventoryScale);
|
|
}
|
|
if (ID == -1)
|
|
return;
|
|
UILinkPointNavigator.SetPosition(ID, position + vector2 * 0.75f);
|
|
}
|
|
|
|
public static void MouseHover(ref Item inv, int context = 0)
|
|
{
|
|
ItemSlot.singleSlotArray[0] = inv;
|
|
ItemSlot.MouseHover(ItemSlot.singleSlotArray, context);
|
|
inv = ItemSlot.singleSlotArray[0];
|
|
}
|
|
|
|
public static void MouseHover(Item[] inv, int context = 0, int slot = 0)
|
|
{
|
|
if (context == 6 && Main.hoverItemName == null)
|
|
Main.hoverItemName = Lang.inter[3].Value;
|
|
if (inv[slot].type > 0 && inv[slot].stack > 0)
|
|
{
|
|
ItemSlot._customCurrencyForSavings = inv[slot].shopSpecialCurrency;
|
|
Main.hoverItemName = inv[slot].Name;
|
|
if (inv[slot].stack > 1)
|
|
Main.hoverItemName = Main.hoverItemName + " (" + (object) inv[slot].stack + ")";
|
|
Main.HoverItem = inv[slot].Clone();
|
|
Main.HoverItem.tooltipContext = context;
|
|
if (context == 8 && slot <= 2)
|
|
Main.HoverItem.wornArmor = true;
|
|
else if (context == 11 || context == 9)
|
|
{
|
|
Main.HoverItem.social = true;
|
|
}
|
|
else
|
|
{
|
|
if (context != 15)
|
|
return;
|
|
Main.HoverItem.buy = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (context == 10 || context == 11 || context == 24)
|
|
Main.hoverItemName = Lang.inter[9].Value;
|
|
if (context == 11)
|
|
Main.hoverItemName = Lang.inter[11].Value + " " + Main.hoverItemName;
|
|
if (context == 8 || context == 9 || context == 23 || context == 26)
|
|
{
|
|
if (slot == 0 || slot == 10 || context == 26)
|
|
Main.hoverItemName = Lang.inter[12].Value;
|
|
else if (slot == 1 || slot == 11)
|
|
Main.hoverItemName = Lang.inter[13].Value;
|
|
else if (slot == 2 || slot == 12)
|
|
Main.hoverItemName = Lang.inter[14].Value;
|
|
else if (slot >= 10)
|
|
Main.hoverItemName = Lang.inter[11].Value + " " + Main.hoverItemName;
|
|
}
|
|
if (context == 12 || context == 25 || context == 27)
|
|
Main.hoverItemName = Lang.inter[57].Value;
|
|
if (context == 16)
|
|
Main.hoverItemName = Lang.inter[90].Value;
|
|
if (context == 17)
|
|
Main.hoverItemName = Lang.inter[91].Value;
|
|
if (context == 19)
|
|
Main.hoverItemName = Lang.inter[92].Value;
|
|
if (context == 18)
|
|
Main.hoverItemName = Lang.inter[93].Value;
|
|
if (context != 20)
|
|
return;
|
|
Main.hoverItemName = Lang.inter[94].Value;
|
|
}
|
|
}
|
|
|
|
public static void SwapEquip(ref Item inv, int context = 0)
|
|
{
|
|
ItemSlot.singleSlotArray[0] = inv;
|
|
ItemSlot.SwapEquip(ItemSlot.singleSlotArray, context, 0);
|
|
inv = ItemSlot.singleSlotArray[0];
|
|
}
|
|
|
|
public static void SwapEquip(Item[] inv, int context, int slot)
|
|
{
|
|
Player player = Main.player[Main.myPlayer];
|
|
if (ItemSlot.isEquipLocked(inv[slot].type))
|
|
return;
|
|
if (inv[slot].dye > (byte) 0)
|
|
{
|
|
bool success;
|
|
inv[slot] = ItemSlot.DyeSwap(inv[slot], out success);
|
|
if (success)
|
|
{
|
|
Main.EquipPageSelected = 0;
|
|
AchievementsHelper.HandleOnEquip(player, inv[slot], 12);
|
|
}
|
|
}
|
|
else if (Main.projHook[inv[slot].shoot])
|
|
{
|
|
bool success;
|
|
inv[slot] = ItemSlot.EquipSwap(inv[slot], player.miscEquips, 4, out success);
|
|
if (success)
|
|
{
|
|
Main.EquipPageSelected = 2;
|
|
AchievementsHelper.HandleOnEquip(player, inv[slot], 16);
|
|
}
|
|
}
|
|
else if (inv[slot].mountType != -1 && !MountID.Sets.Cart[inv[slot].mountType])
|
|
{
|
|
bool success;
|
|
inv[slot] = ItemSlot.EquipSwap(inv[slot], player.miscEquips, 3, out success);
|
|
if (success)
|
|
{
|
|
Main.EquipPageSelected = 2;
|
|
AchievementsHelper.HandleOnEquip(player, inv[slot], 17);
|
|
}
|
|
}
|
|
else if (inv[slot].mountType != -1 && MountID.Sets.Cart[inv[slot].mountType])
|
|
{
|
|
bool success;
|
|
inv[slot] = ItemSlot.EquipSwap(inv[slot], player.miscEquips, 2, out success);
|
|
if (success)
|
|
Main.EquipPageSelected = 2;
|
|
}
|
|
else if (inv[slot].buffType > 0 && Main.lightPet[inv[slot].buffType])
|
|
{
|
|
bool success;
|
|
inv[slot] = ItemSlot.EquipSwap(inv[slot], player.miscEquips, 1, out success);
|
|
if (success)
|
|
Main.EquipPageSelected = 2;
|
|
}
|
|
else if (inv[slot].buffType > 0 && Main.vanityPet[inv[slot].buffType])
|
|
{
|
|
bool success;
|
|
inv[slot] = ItemSlot.EquipSwap(inv[slot], player.miscEquips, 0, out success);
|
|
if (success)
|
|
Main.EquipPageSelected = 2;
|
|
}
|
|
else
|
|
{
|
|
Item obj = inv[slot];
|
|
bool success;
|
|
inv[slot] = ItemSlot.ArmorSwap(inv[slot], out success);
|
|
if (success)
|
|
{
|
|
Main.EquipPageSelected = 0;
|
|
AchievementsHelper.HandleOnEquip(player, obj, obj.accessory ? 10 : 8);
|
|
}
|
|
}
|
|
Recipe.FindRecipes();
|
|
if (context != 3 || Main.netMode != 1)
|
|
return;
|
|
NetMessage.SendData(32, number: player.chest, number2: ((float) slot));
|
|
}
|
|
|
|
public static bool Equippable(ref Item inv, int context = 0)
|
|
{
|
|
ItemSlot.singleSlotArray[0] = inv;
|
|
int num = ItemSlot.Equippable(ItemSlot.singleSlotArray, context, 0) ? 1 : 0;
|
|
inv = ItemSlot.singleSlotArray[0];
|
|
return num != 0;
|
|
}
|
|
|
|
public static bool Equippable(Item[] inv, int context, int slot)
|
|
{
|
|
Player player = Main.player[Main.myPlayer];
|
|
return inv[slot].dye > (byte) 0 || Main.projHook[inv[slot].shoot] || inv[slot].mountType != -1 || inv[slot].buffType > 0 && Main.lightPet[inv[slot].buffType] || inv[slot].buffType > 0 && Main.vanityPet[inv[slot].buffType] || inv[slot].headSlot >= 0 || inv[slot].bodySlot >= 0 || inv[slot].legSlot >= 0 || inv[slot].accessory;
|
|
}
|
|
|
|
private static bool AccCheck(Item[] itemCollection, Item item, int slot)
|
|
{
|
|
if (ItemSlot.isEquipLocked(item.type))
|
|
return true;
|
|
if (slot != -1 && (itemCollection[slot].IsTheSameAs(item) || itemCollection[slot].wingSlot > (sbyte) 0 && item.wingSlot > (sbyte) 0))
|
|
return false;
|
|
for (int index = 0; index < itemCollection.Length; ++index)
|
|
{
|
|
if (slot < 10 && index < 10 && (item.wingSlot > (sbyte) 0 && itemCollection[index].wingSlot > (sbyte) 0 || slot >= 10 && index >= 10 && item.wingSlot > (sbyte) 0 && itemCollection[index].wingSlot > (sbyte) 0) || item.IsTheSameAs(itemCollection[index]))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private static Item DyeSwap(Item item, out bool success)
|
|
{
|
|
success = false;
|
|
if (item.dye <= (byte) 0)
|
|
return item;
|
|
Player player = Main.player[Main.myPlayer];
|
|
for (int index = 0; index < 10; ++index)
|
|
{
|
|
if (player.dye[index].type == 0)
|
|
{
|
|
ItemSlot.dyeSlotCount = index;
|
|
break;
|
|
}
|
|
}
|
|
if (ItemSlot.dyeSlotCount >= 10)
|
|
ItemSlot.dyeSlotCount = 0;
|
|
if (ItemSlot.dyeSlotCount < 0)
|
|
ItemSlot.dyeSlotCount = 9;
|
|
Item obj = player.dye[ItemSlot.dyeSlotCount].Clone();
|
|
player.dye[ItemSlot.dyeSlotCount] = item.Clone();
|
|
++ItemSlot.dyeSlotCount;
|
|
if (ItemSlot.dyeSlotCount >= 10)
|
|
ItemSlot.accSlotToSwapTo = 0;
|
|
SoundEngine.PlaySound(7);
|
|
Recipe.FindRecipes();
|
|
success = true;
|
|
return obj;
|
|
}
|
|
|
|
private static Item ArmorSwap(Item item, out bool success)
|
|
{
|
|
success = false;
|
|
if (item.headSlot == -1 && item.bodySlot == -1 && item.legSlot == -1 && !item.accessory)
|
|
return item;
|
|
Player player = Main.player[Main.myPlayer];
|
|
int index1 = !item.vanity || item.accessory ? 0 : 10;
|
|
item.favorited = false;
|
|
Item obj = item;
|
|
if (item.headSlot != -1)
|
|
{
|
|
obj = player.armor[index1].Clone();
|
|
player.armor[index1] = item.Clone();
|
|
}
|
|
else if (item.bodySlot != -1)
|
|
{
|
|
obj = player.armor[index1 + 1].Clone();
|
|
player.armor[index1 + 1] = item.Clone();
|
|
}
|
|
else if (item.legSlot != -1)
|
|
{
|
|
obj = player.armor[index1 + 2].Clone();
|
|
player.armor[index1 + 2] = item.Clone();
|
|
}
|
|
else if (item.accessory)
|
|
{
|
|
int num = 3;
|
|
for (int slot = 3; slot < 10; ++slot)
|
|
{
|
|
if (player.IsAValidEquipmentSlotForIteration(slot))
|
|
{
|
|
num = slot;
|
|
if (player.armor[slot].type == 0)
|
|
{
|
|
ItemSlot.accSlotToSwapTo = slot - 3;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
for (int index2 = 0; index2 < player.armor.Length; ++index2)
|
|
{
|
|
if (item.IsTheSameAs(player.armor[index2]))
|
|
ItemSlot.accSlotToSwapTo = index2 - 3;
|
|
if (index2 < 10 && item.wingSlot > (sbyte) 0 && player.armor[index2].wingSlot > (sbyte) 0)
|
|
ItemSlot.accSlotToSwapTo = index2 - 3;
|
|
}
|
|
if (ItemSlot.accSlotToSwapTo > num)
|
|
return item;
|
|
if (ItemSlot.accSlotToSwapTo < 0)
|
|
ItemSlot.accSlotToSwapTo = num - 3;
|
|
int index3 = 3 + ItemSlot.accSlotToSwapTo;
|
|
if (ItemSlot.isEquipLocked(player.armor[index3].type))
|
|
return item;
|
|
for (int index4 = 0; index4 < player.armor.Length; ++index4)
|
|
{
|
|
if (item.IsTheSameAs(player.armor[index4]))
|
|
index3 = index4;
|
|
}
|
|
obj = player.armor[index3].Clone();
|
|
player.armor[index3] = item.Clone();
|
|
ItemSlot.accSlotToSwapTo = 0;
|
|
}
|
|
SoundEngine.PlaySound(7);
|
|
Recipe.FindRecipes();
|
|
success = true;
|
|
return obj;
|
|
}
|
|
|
|
private static Item EquipSwap(Item item, Item[] inv, int slot, out bool success)
|
|
{
|
|
success = false;
|
|
Player player = Main.player[Main.myPlayer];
|
|
item.favorited = false;
|
|
Item obj = inv[slot].Clone();
|
|
inv[slot] = item.Clone();
|
|
SoundEngine.PlaySound(7);
|
|
Recipe.FindRecipes();
|
|
success = true;
|
|
return obj;
|
|
}
|
|
|
|
public static void DrawMoney(
|
|
SpriteBatch sb,
|
|
string text,
|
|
float shopx,
|
|
float shopy,
|
|
int[] coinsArray,
|
|
bool horizontal = false)
|
|
{
|
|
Utils.DrawBorderStringFourWay(sb, FontAssets.MouseText.Value, text, shopx, shopy + 40f, Color.White * ((float) Main.mouseTextColor / (float) byte.MaxValue), Color.Black, Vector2.Zero);
|
|
if (horizontal)
|
|
{
|
|
for (int index = 0; index < 4; ++index)
|
|
{
|
|
Main.instance.LoadItem(74 - index);
|
|
if (index == 0)
|
|
{
|
|
int coins = coinsArray[3 - index];
|
|
}
|
|
Vector2 position = new Vector2((float) ((double) shopx + (double) ChatManager.GetStringSize(FontAssets.MouseText.Value, text, Vector2.One).X + (double) (24 * index) + 45.0), shopy + 50f);
|
|
sb.Draw(TextureAssets.Item[74 - index].Value, position, new Rectangle?(), Color.White, 0.0f, TextureAssets.Item[74 - index].Value.Size() / 2f, 1f, SpriteEffects.None, 0.0f);
|
|
Utils.DrawBorderStringFourWay(sb, FontAssets.ItemStack.Value, coinsArray[3 - index].ToString(), position.X - 11f, position.Y, Color.White, Color.Black, new Vector2(0.3f), 0.75f);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int index = 0; index < 4; ++index)
|
|
{
|
|
Main.instance.LoadItem(74 - index);
|
|
int num = index != 0 || coinsArray[3 - index] <= 99 ? 0 : -6;
|
|
sb.Draw(TextureAssets.Item[74 - index].Value, new Vector2(shopx + 11f + (float) (24 * index), shopy + 75f), new Rectangle?(), Color.White, 0.0f, TextureAssets.Item[74 - index].Value.Size() / 2f, 1f, SpriteEffects.None, 0.0f);
|
|
Utils.DrawBorderStringFourWay(sb, FontAssets.ItemStack.Value, coinsArray[3 - index].ToString(), shopx + (float) (24 * index) + (float) num, shopy + 75f, Color.White, Color.Black, new Vector2(0.3f), 0.75f);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void DrawSavings(SpriteBatch sb, float shopx, float shopy, bool horizontal = false)
|
|
{
|
|
Player player = Main.player[Main.myPlayer];
|
|
if (ItemSlot._customCurrencyForSavings != -1)
|
|
{
|
|
CustomCurrencyManager.DrawSavings(sb, ItemSlot._customCurrencyForSavings, shopx, shopy, horizontal);
|
|
}
|
|
else
|
|
{
|
|
bool overFlowing;
|
|
long num1 = Utils.CoinsCount(out overFlowing, player.bank.item);
|
|
long num2 = Utils.CoinsCount(out overFlowing, player.bank2.item);
|
|
long num3 = Utils.CoinsCount(out overFlowing, player.bank3.item);
|
|
long num4 = Utils.CoinsCount(out overFlowing, player.bank4.item);
|
|
long count = Utils.CoinsCombineStacks(out overFlowing, num1, num2, num3, num4);
|
|
if (count <= 0L)
|
|
return;
|
|
Main.instance.LoadItem(4076);
|
|
Main.instance.LoadItem(3813);
|
|
Main.instance.LoadItem(346);
|
|
Main.instance.LoadItem(87);
|
|
if (num4 > 0L)
|
|
sb.Draw(TextureAssets.Item[4076].Value, Utils.CenteredRectangle(new Vector2(shopx + 92f, shopy + 45f), TextureAssets.Item[4076].Value.Size() * 0.65f), new Rectangle?(), Color.White);
|
|
if (num3 > 0L)
|
|
sb.Draw(TextureAssets.Item[3813].Value, Utils.CenteredRectangle(new Vector2(shopx + 92f, shopy + 45f), TextureAssets.Item[3813].Value.Size() * 0.65f), new Rectangle?(), Color.White);
|
|
if (num2 > 0L)
|
|
sb.Draw(TextureAssets.Item[346].Value, Utils.CenteredRectangle(new Vector2(shopx + 80f, shopy + 50f), TextureAssets.Item[346].Value.Size() * 0.65f), new Rectangle?(), Color.White);
|
|
if (num1 > 0L)
|
|
sb.Draw(TextureAssets.Item[87].Value, Utils.CenteredRectangle(new Vector2(shopx + 70f, shopy + 60f), TextureAssets.Item[87].Value.Size() * 0.65f), new Rectangle?(), Color.White);
|
|
ItemSlot.DrawMoney(sb, Lang.inter[66].Value, shopx, shopy, Utils.CoinsSplit(count), horizontal);
|
|
}
|
|
}
|
|
|
|
public static void GetItemLight(ref Color currentColor, Item item, bool outInTheWorld = false)
|
|
{
|
|
float scale = 1f;
|
|
ItemSlot.GetItemLight(ref currentColor, ref scale, item, outInTheWorld);
|
|
}
|
|
|
|
public static void GetItemLight(ref Color currentColor, int type, bool outInTheWorld = false)
|
|
{
|
|
float scale = 1f;
|
|
ItemSlot.GetItemLight(ref currentColor, ref scale, type, outInTheWorld);
|
|
}
|
|
|
|
public static void GetItemLight(
|
|
ref Color currentColor,
|
|
ref float scale,
|
|
Item item,
|
|
bool outInTheWorld = false)
|
|
{
|
|
ItemSlot.GetItemLight(ref currentColor, ref scale, item.type, outInTheWorld);
|
|
}
|
|
|
|
public static Color GetItemLight(
|
|
ref Color currentColor,
|
|
ref float scale,
|
|
int type,
|
|
bool outInTheWorld = false)
|
|
{
|
|
if (type < 0 || type > 5045)
|
|
return currentColor;
|
|
if (type == 662 || type == 663)
|
|
{
|
|
currentColor.R = (byte) Main.DiscoR;
|
|
currentColor.G = (byte) Main.DiscoG;
|
|
currentColor.B = (byte) Main.DiscoB;
|
|
currentColor.A = byte.MaxValue;
|
|
}
|
|
else if (ItemID.Sets.ItemIconPulse[type])
|
|
{
|
|
scale = Main.essScale;
|
|
currentColor.R = (byte) ((double) currentColor.R * (double) scale);
|
|
currentColor.G = (byte) ((double) currentColor.G * (double) scale);
|
|
currentColor.B = (byte) ((double) currentColor.B * (double) scale);
|
|
currentColor.A = (byte) ((double) currentColor.A * (double) scale);
|
|
}
|
|
else if (type == 58 || type == 184 || type == 4143)
|
|
{
|
|
scale = (float) ((double) Main.essScale * 0.25 + 0.75);
|
|
currentColor.R = (byte) ((double) currentColor.R * (double) scale);
|
|
currentColor.G = (byte) ((double) currentColor.G * (double) scale);
|
|
currentColor.B = (byte) ((double) currentColor.B * (double) scale);
|
|
currentColor.A = (byte) ((double) currentColor.A * (double) scale);
|
|
}
|
|
return currentColor;
|
|
}
|
|
|
|
public static void DrawRadialCircular(SpriteBatch sb, Vector2 position)
|
|
{
|
|
ItemSlot.CircularRadialOpacity = MathHelper.Clamp(ItemSlot.CircularRadialOpacity + (!PlayerInput.UsingGamepad || !PlayerInput.Triggers.Current.RadialHotbar ? -0.15f : 0.25f), 0.0f, 1f);
|
|
if ((double) ItemSlot.CircularRadialOpacity == 0.0)
|
|
return;
|
|
Player player = Main.player[Main.myPlayer];
|
|
Texture2D texture2D1 = TextureAssets.HotbarRadial[2].Value;
|
|
float num1 = ItemSlot.CircularRadialOpacity * 0.9f;
|
|
float num2 = ItemSlot.CircularRadialOpacity * 1f;
|
|
float num3 = (float) Main.mouseTextColor / (float) byte.MaxValue;
|
|
Color color = Color.White * ((float) (1.0 - (1.0 - (double) num3) * (1.0 - (double) num3)) * 0.785f) * num1;
|
|
Texture2D texture2D2 = TextureAssets.HotbarRadial[1].Value;
|
|
float num4 = 6.283185f / (float) player.CircularRadial.RadialCount;
|
|
float num5 = -1.570796f;
|
|
for (int index = 0; index < player.CircularRadial.RadialCount; ++index)
|
|
{
|
|
int binding = player.CircularRadial.Bindings[index];
|
|
Vector2 vector2 = new Vector2(150f, 0.0f).RotatedBy((double) num5 + (double) num4 * (double) index) * num2;
|
|
float num6 = 0.85f;
|
|
if (player.CircularRadial.SelectedBinding == index)
|
|
num6 = 1.7f;
|
|
sb.Draw(texture2D2, position + vector2, new Rectangle?(), color * num6, 0.0f, texture2D2.Size() / 2f, num2 * num6, SpriteEffects.None, 0.0f);
|
|
if (binding != -1)
|
|
{
|
|
double inventoryScale = (double) Main.inventoryScale;
|
|
Main.inventoryScale = num2 * num6;
|
|
ItemSlot.Draw(sb, player.inventory, 14, binding, position + vector2 + new Vector2(-26f * num2 * num6), Color.White);
|
|
Main.inventoryScale = (float) inventoryScale;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void DrawRadialQuicks(SpriteBatch sb, Vector2 position)
|
|
{
|
|
ItemSlot.QuicksRadialOpacity = MathHelper.Clamp(ItemSlot.QuicksRadialOpacity + (!PlayerInput.UsingGamepad || !PlayerInput.Triggers.Current.RadialQuickbar ? -0.15f : 0.25f), 0.0f, 1f);
|
|
if ((double) ItemSlot.QuicksRadialOpacity == 0.0)
|
|
return;
|
|
Player player = Main.player[Main.myPlayer];
|
|
Texture2D texture2D = TextureAssets.HotbarRadial[2].Value;
|
|
Texture2D texture = TextureAssets.QuicksIcon.Value;
|
|
float num1 = ItemSlot.QuicksRadialOpacity * 0.9f;
|
|
float num2 = ItemSlot.QuicksRadialOpacity * 1f;
|
|
float num3 = (float) Main.mouseTextColor / (float) byte.MaxValue;
|
|
Color color = Color.White * ((float) (1.0 - (1.0 - (double) num3) * (1.0 - (double) num3)) * 0.785f) * num1;
|
|
float num4 = 6.283185f / (float) player.QuicksRadial.RadialCount;
|
|
float num5 = -1.570796f;
|
|
Item obj1 = player.QuickHeal_GetItemToUse();
|
|
Item obj2 = player.QuickMana_GetItemToUse();
|
|
Item obj3 = (Item) null;
|
|
Item obj4 = (Item) null;
|
|
if (obj1 == null)
|
|
{
|
|
obj1 = new Item();
|
|
obj1.SetDefaults(28);
|
|
}
|
|
if (obj2 == null)
|
|
{
|
|
obj2 = new Item();
|
|
obj2.SetDefaults(110);
|
|
}
|
|
if (obj3 == null)
|
|
{
|
|
obj3 = new Item();
|
|
obj3.SetDefaults(292);
|
|
}
|
|
if (obj4 == null)
|
|
{
|
|
obj4 = new Item();
|
|
obj4.SetDefaults(2428);
|
|
}
|
|
for (int index = 0; index < player.QuicksRadial.RadialCount; ++index)
|
|
{
|
|
Item inv = obj4;
|
|
if (index == 1)
|
|
inv = obj1;
|
|
if (index == 2)
|
|
inv = obj3;
|
|
if (index == 3)
|
|
inv = obj2;
|
|
int binding = player.QuicksRadial.Bindings[index];
|
|
Vector2 vector2 = new Vector2(120f, 0.0f).RotatedBy((double) num5 + (double) num4 * (double) index) * num2;
|
|
float num6 = 0.85f;
|
|
if (player.QuicksRadial.SelectedBinding == index)
|
|
num6 = 1.7f;
|
|
sb.Draw(texture2D, position + vector2, new Rectangle?(), color * num6, 0.0f, texture2D.Size() / 2f, (float) ((double) num2 * (double) num6 * 1.29999995231628), SpriteEffects.None, 0.0f);
|
|
double inventoryScale = (double) Main.inventoryScale;
|
|
Main.inventoryScale = num2 * num6;
|
|
ItemSlot.Draw(sb, ref inv, 14, position + vector2 + new Vector2(-26f * num2 * num6), Color.White);
|
|
Main.inventoryScale = (float) inventoryScale;
|
|
sb.Draw(texture, position + vector2 + new Vector2(34f, 20f) * 0.85f * num2 * num6, new Rectangle?(), color * num6, 0.0f, texture2D.Size() / 2f, (float) ((double) num2 * (double) num6 * 1.29999995231628), SpriteEffects.None, 0.0f);
|
|
}
|
|
}
|
|
|
|
public static void DrawRadialDpad(SpriteBatch sb, Vector2 position)
|
|
{
|
|
if (!PlayerInput.UsingGamepad || !PlayerInput.CurrentProfile.UsingDpadHotbar())
|
|
return;
|
|
Player player = Main.player[Main.myPlayer];
|
|
if (player.chest != -1)
|
|
return;
|
|
Texture2D texture2D = TextureAssets.HotbarRadial[0].Value;
|
|
float num = (float) Main.mouseTextColor / (float) byte.MaxValue;
|
|
Color color = Color.White * ((float) (1.0 - (1.0 - (double) num) * (1.0 - (double) num)) * 0.785f);
|
|
sb.Draw(texture2D, position, new Rectangle?(), color, 0.0f, texture2D.Size() / 2f, Main.inventoryScale, SpriteEffects.None, 0.0f);
|
|
for (int index = 0; index < 4; ++index)
|
|
{
|
|
int binding = player.DpadRadial.Bindings[index];
|
|
if (binding != -1)
|
|
ItemSlot.Draw(sb, player.inventory, 14, binding, position + new Vector2((float) (texture2D.Width / 3), 0.0f).RotatedBy(1.57079637050629 * (double) index - 1.57079637050629) + new Vector2(-26f * Main.inventoryScale), Color.White);
|
|
}
|
|
}
|
|
|
|
public static string GetGamepadInstructions(ref Item inv, int context = 0)
|
|
{
|
|
ItemSlot.singleSlotArray[0] = inv;
|
|
string gamepadInstructions = ItemSlot.GetGamepadInstructions(ItemSlot.singleSlotArray, context);
|
|
inv = ItemSlot.singleSlotArray[0];
|
|
return gamepadInstructions;
|
|
}
|
|
|
|
public static string GetGamepadInstructions(Item[] inv, int context = 0, int slot = 0)
|
|
{
|
|
Player player = Main.player[Main.myPlayer];
|
|
string s = "";
|
|
if (inv == null || inv[slot] == null || Main.mouseItem == null)
|
|
return s;
|
|
if (context == 0 || context == 1 || context == 2)
|
|
{
|
|
if (inv[slot].type > 0 && inv[slot].stack > 0)
|
|
{
|
|
string str;
|
|
if (Main.mouseItem.type > 0)
|
|
{
|
|
str = s + PlayerInput.BuildCommand(Lang.misc[65].Value, false, PlayerInput.ProfileGamepadUI.KeyStatus["MouseLeft"]);
|
|
if (inv[slot].type == Main.mouseItem.type && Main.mouseItem.stack < inv[slot].maxStack && inv[slot].maxStack > 1)
|
|
str += PlayerInput.BuildCommand(Lang.misc[55].Value, false, PlayerInput.ProfileGamepadUI.KeyStatus["MouseRight"]);
|
|
}
|
|
else
|
|
{
|
|
if (context == 0 && player.chest == -1)
|
|
player.DpadRadial.ChangeBinding(slot);
|
|
str = s + PlayerInput.BuildCommand(Lang.misc[54].Value, false, PlayerInput.ProfileGamepadUI.KeyStatus["MouseLeft"]);
|
|
if (inv[slot].maxStack > 1)
|
|
str += PlayerInput.BuildCommand(Lang.misc[55].Value, false, PlayerInput.ProfileGamepadUI.KeyStatus["MouseRight"]);
|
|
}
|
|
if (inv[slot].maxStack == 1 && ItemSlot.Equippable(inv, context, slot))
|
|
{
|
|
str += PlayerInput.BuildCommand(Lang.misc[67].Value, false, PlayerInput.ProfileGamepadUI.KeyStatus["Grapple"]);
|
|
if (PlayerInput.Triggers.JustPressed.Grapple)
|
|
ItemSlot.SwapEquip(inv, context, slot);
|
|
}
|
|
s = str + PlayerInput.BuildCommand(Lang.misc[83].Value, false, PlayerInput.ProfileGamepadUI.KeyStatus["SmartCursor"]);
|
|
if (PlayerInput.Triggers.JustPressed.SmartCursor)
|
|
inv[slot].favorited = !inv[slot].favorited;
|
|
}
|
|
else if (Main.mouseItem.type > 0)
|
|
s += PlayerInput.BuildCommand(Lang.misc[65].Value, false, PlayerInput.ProfileGamepadUI.KeyStatus["MouseLeft"]);
|
|
}
|
|
if (context == 3 || context == 4)
|
|
{
|
|
if (inv[slot].type > 0 && inv[slot].stack > 0)
|
|
{
|
|
if (Main.mouseItem.type > 0)
|
|
{
|
|
s += PlayerInput.BuildCommand(Lang.misc[65].Value, false, PlayerInput.ProfileGamepadUI.KeyStatus["MouseLeft"]);
|
|
if (inv[slot].type == Main.mouseItem.type && Main.mouseItem.stack < inv[slot].maxStack && inv[slot].maxStack > 1)
|
|
s += PlayerInput.BuildCommand(Lang.misc[55].Value, false, PlayerInput.ProfileGamepadUI.KeyStatus["MouseRight"]);
|
|
}
|
|
else
|
|
{
|
|
s += PlayerInput.BuildCommand(Lang.misc[54].Value, false, PlayerInput.ProfileGamepadUI.KeyStatus["MouseLeft"]);
|
|
if (inv[slot].maxStack > 1)
|
|
s += PlayerInput.BuildCommand(Lang.misc[55].Value, false, PlayerInput.ProfileGamepadUI.KeyStatus["MouseRight"]);
|
|
}
|
|
if (inv[slot].maxStack == 1 && ItemSlot.Equippable(inv, context, slot))
|
|
{
|
|
s += PlayerInput.BuildCommand(Lang.misc[67].Value, false, PlayerInput.ProfileGamepadUI.KeyStatus["Grapple"]);
|
|
if (PlayerInput.Triggers.JustPressed.Grapple)
|
|
ItemSlot.SwapEquip(inv, context, slot);
|
|
}
|
|
}
|
|
else if (Main.mouseItem.type > 0)
|
|
s += PlayerInput.BuildCommand(Lang.misc[65].Value, false, PlayerInput.ProfileGamepadUI.KeyStatus["MouseLeft"]);
|
|
}
|
|
if (context == 15)
|
|
{
|
|
if (inv[slot].type > 0 && inv[slot].stack > 0)
|
|
{
|
|
if (Main.mouseItem.type > 0)
|
|
{
|
|
if (inv[slot].type == Main.mouseItem.type && Main.mouseItem.stack < inv[slot].maxStack && inv[slot].maxStack > 1)
|
|
s += PlayerInput.BuildCommand(Lang.misc[91].Value, false, PlayerInput.ProfileGamepadUI.KeyStatus["MouseRight"]);
|
|
}
|
|
else
|
|
s += PlayerInput.BuildCommand(Lang.misc[90].Value, false, PlayerInput.ProfileGamepadUI.KeyStatus["MouseLeft"], PlayerInput.ProfileGamepadUI.KeyStatus["MouseRight"]);
|
|
}
|
|
else if (Main.mouseItem.type > 0)
|
|
s += PlayerInput.BuildCommand(Lang.misc[92].Value, false, PlayerInput.ProfileGamepadUI.KeyStatus["MouseLeft"]);
|
|
}
|
|
if (context == 8 || context == 9 || context == 16 || context == 17 || context == 18 || context == 19 || context == 20)
|
|
{
|
|
if (inv[slot].type > 0 && inv[slot].stack > 0)
|
|
{
|
|
if (Main.mouseItem.type > 0)
|
|
{
|
|
if (ItemSlot.Equippable(ref Main.mouseItem, context))
|
|
s += PlayerInput.BuildCommand(Lang.misc[65].Value, false, PlayerInput.ProfileGamepadUI.KeyStatus["MouseLeft"]);
|
|
}
|
|
else if (context != 8 || !ItemSlot.isEquipLocked(inv[slot].type))
|
|
s += PlayerInput.BuildCommand(Lang.misc[54].Value, false, PlayerInput.ProfileGamepadUI.KeyStatus["MouseLeft"]);
|
|
if (context == 8 && slot >= 3)
|
|
{
|
|
bool flag = player.hideVisibleAccessory[slot];
|
|
s += PlayerInput.BuildCommand(Lang.misc[flag ? 77 : 78].Value, false, PlayerInput.ProfileGamepadUI.KeyStatus["Grapple"]);
|
|
if (PlayerInput.Triggers.JustPressed.Grapple)
|
|
{
|
|
player.hideVisibleAccessory[slot] = !player.hideVisibleAccessory[slot];
|
|
SoundEngine.PlaySound(12);
|
|
if (Main.netMode == 1)
|
|
NetMessage.SendData(4, number: Main.myPlayer);
|
|
}
|
|
}
|
|
if ((context == 16 || context == 17 || context == 18 || context == 19 || context == 20) && slot < 2)
|
|
{
|
|
bool flag = player.hideMisc[slot];
|
|
s += PlayerInput.BuildCommand(Lang.misc[flag ? 77 : 78].Value, false, PlayerInput.ProfileGamepadUI.KeyStatus["Grapple"]);
|
|
if (PlayerInput.Triggers.JustPressed.Grapple)
|
|
{
|
|
player.hideMisc[slot] = !player.hideMisc[slot];
|
|
SoundEngine.PlaySound(12);
|
|
if (Main.netMode == 1)
|
|
NetMessage.SendData(4, number: Main.myPlayer);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (Main.mouseItem.type > 0 && ItemSlot.Equippable(ref Main.mouseItem, context))
|
|
s += PlayerInput.BuildCommand(Lang.misc[65].Value, false, PlayerInput.ProfileGamepadUI.KeyStatus["MouseLeft"]);
|
|
if (context == 8 && slot >= 3)
|
|
{
|
|
bool flag = player.hideVisibleAccessory[slot];
|
|
s += PlayerInput.BuildCommand(Lang.misc[flag ? 77 : 78].Value, false, PlayerInput.ProfileGamepadUI.KeyStatus["Grapple"]);
|
|
if (PlayerInput.Triggers.JustPressed.Grapple)
|
|
{
|
|
player.hideVisibleAccessory[slot] = !player.hideVisibleAccessory[slot];
|
|
SoundEngine.PlaySound(12);
|
|
if (Main.netMode == 1)
|
|
NetMessage.SendData(4, number: Main.myPlayer);
|
|
}
|
|
}
|
|
if ((context == 16 || context == 17 || context == 18 || context == 19 || context == 20) && slot < 2)
|
|
{
|
|
bool flag = player.hideMisc[slot];
|
|
s += PlayerInput.BuildCommand(Lang.misc[flag ? 77 : 78].Value, false, PlayerInput.ProfileGamepadUI.KeyStatus["Grapple"]);
|
|
if (PlayerInput.Triggers.JustPressed.Grapple)
|
|
{
|
|
if (slot == 0)
|
|
player.TogglePet();
|
|
if (slot == 1)
|
|
player.ToggleLight();
|
|
Main.mouseLeftRelease = false;
|
|
SoundEngine.PlaySound(12);
|
|
if (Main.netMode == 1)
|
|
NetMessage.SendData(4, number: Main.myPlayer);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (context == 12 || context == 25 || context == 27)
|
|
{
|
|
if (inv[slot].type > 0 && inv[slot].stack > 0)
|
|
{
|
|
if (Main.mouseItem.type > 0)
|
|
{
|
|
if (Main.mouseItem.dye > (byte) 0)
|
|
s += PlayerInput.BuildCommand(Lang.misc[65].Value, false, PlayerInput.ProfileGamepadUI.KeyStatus["MouseLeft"]);
|
|
}
|
|
else
|
|
s += PlayerInput.BuildCommand(Lang.misc[54].Value, false, PlayerInput.ProfileGamepadUI.KeyStatus["MouseLeft"]);
|
|
if (context == 12 || context == 25 || context == 27)
|
|
{
|
|
int num = -1;
|
|
if (inv == player.dye)
|
|
num = slot;
|
|
if (inv == player.miscDyes)
|
|
num = 10 + slot;
|
|
if (num != -1)
|
|
{
|
|
if (num < 10)
|
|
{
|
|
bool flag = player.hideVisibleAccessory[slot];
|
|
s += PlayerInput.BuildCommand(Lang.misc[flag ? 77 : 78].Value, false, PlayerInput.ProfileGamepadUI.KeyStatus["Grapple"]);
|
|
if (PlayerInput.Triggers.JustPressed.Grapple)
|
|
{
|
|
player.hideVisibleAccessory[slot] = !player.hideVisibleAccessory[slot];
|
|
SoundEngine.PlaySound(12);
|
|
if (Main.netMode == 1)
|
|
NetMessage.SendData(4, number: Main.myPlayer);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bool flag = player.hideMisc[slot];
|
|
s += PlayerInput.BuildCommand(Lang.misc[flag ? 77 : 78].Value, false, PlayerInput.ProfileGamepadUI.KeyStatus["Grapple"]);
|
|
if (PlayerInput.Triggers.JustPressed.Grapple)
|
|
{
|
|
player.hideMisc[slot] = !player.hideMisc[slot];
|
|
SoundEngine.PlaySound(12);
|
|
if (Main.netMode == 1)
|
|
NetMessage.SendData(4, number: Main.myPlayer);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (Main.mouseItem.type > 0 && Main.mouseItem.dye > (byte) 0)
|
|
s += PlayerInput.BuildCommand(Lang.misc[65].Value, false, PlayerInput.ProfileGamepadUI.KeyStatus["MouseLeft"]);
|
|
return s;
|
|
}
|
|
if (context == 6)
|
|
{
|
|
if (inv[slot].type > 0 && inv[slot].stack > 0)
|
|
{
|
|
if (Main.mouseItem.type > 0)
|
|
s += PlayerInput.BuildCommand(Lang.misc[74].Value, false, PlayerInput.ProfileGamepadUI.KeyStatus["MouseLeft"]);
|
|
else
|
|
s += PlayerInput.BuildCommand(Lang.misc[54].Value, false, PlayerInput.ProfileGamepadUI.KeyStatus["MouseLeft"]);
|
|
}
|
|
else if (Main.mouseItem.type > 0)
|
|
s += PlayerInput.BuildCommand(Lang.misc[74].Value, false, PlayerInput.ProfileGamepadUI.KeyStatus["MouseLeft"]);
|
|
return s;
|
|
}
|
|
if (context == 5 || context == 7)
|
|
{
|
|
bool flag = false;
|
|
if (context == 5)
|
|
flag = Main.mouseItem.Prefix(-3) || Main.mouseItem.type == 0;
|
|
if (context == 7)
|
|
flag = Main.mouseItem.material;
|
|
if (inv[slot].type > 0 && inv[slot].stack > 0)
|
|
{
|
|
if (Main.mouseItem.type > 0)
|
|
{
|
|
if (flag)
|
|
s += PlayerInput.BuildCommand(Lang.misc[65].Value, false, PlayerInput.ProfileGamepadUI.KeyStatus["MouseLeft"]);
|
|
}
|
|
else
|
|
s += PlayerInput.BuildCommand(Lang.misc[54].Value, false, PlayerInput.ProfileGamepadUI.KeyStatus["MouseLeft"]);
|
|
}
|
|
else if (Main.mouseItem.type > 0 & flag)
|
|
s += PlayerInput.BuildCommand(Lang.misc[65].Value, false, PlayerInput.ProfileGamepadUI.KeyStatus["MouseLeft"]);
|
|
return s;
|
|
}
|
|
string overrideInstructions = ItemSlot.GetOverrideInstructions(inv, context, slot);
|
|
bool flag1 = Main.mouseItem.type > 0 && (context == 0 || context == 1 || context == 2 || context == 6 || context == 15 || context == 7 || context == 4 || context == 3);
|
|
if (context != 8 || !ItemSlot.isEquipLocked(inv[slot].type))
|
|
{
|
|
if (flag1 && string.IsNullOrEmpty(overrideInstructions))
|
|
{
|
|
s += PlayerInput.BuildCommand(Lang.inter[121].Value, false, PlayerInput.ProfileGamepadUI.KeyStatus["SmartSelect"]);
|
|
if (PlayerInput.Triggers.JustPressed.SmartSelect)
|
|
player.DropSelectedItem();
|
|
}
|
|
else if (!string.IsNullOrEmpty(overrideInstructions))
|
|
{
|
|
ItemSlot.ShiftForcedOn = true;
|
|
int cursorOverride = Main.cursorOverride;
|
|
ItemSlot.OverrideHover(inv, context, slot);
|
|
if (-1 != Main.cursorOverride)
|
|
{
|
|
s += PlayerInput.BuildCommand(overrideInstructions, false, PlayerInput.ProfileGamepadUI.KeyStatus["SmartSelect"]);
|
|
if (PlayerInput.Triggers.JustPressed.SmartSelect)
|
|
{
|
|
int num = Main.mouseLeft ? 1 : 0;
|
|
Main.mouseLeft = true;
|
|
ItemSlot.LeftClick(inv, context, slot);
|
|
Main.mouseLeft = num != 0;
|
|
}
|
|
}
|
|
Main.cursorOverride = cursorOverride;
|
|
ItemSlot.ShiftForcedOn = false;
|
|
}
|
|
}
|
|
if (!ItemSlot.TryEnteringFastUseMode(inv, context, slot, player, ref s))
|
|
ItemSlot.TryEnteringBuildingMode(inv, context, slot, player, ref s);
|
|
return s;
|
|
}
|
|
|
|
private static bool TryEnteringFastUseMode(
|
|
Item[] inv,
|
|
int context,
|
|
int slot,
|
|
Player player,
|
|
ref string s)
|
|
{
|
|
int num = 0;
|
|
if (Main.mouseItem.CanBeQuickUsed)
|
|
num = 1;
|
|
if (num == 0 && Main.mouseItem.stack <= 0 && context == 0 && inv[slot].CanBeQuickUsed)
|
|
num = 2;
|
|
if (num <= 0)
|
|
return false;
|
|
s += PlayerInput.BuildCommand(Language.GetTextValue("UI.QuickUseItem"), false, PlayerInput.ProfileGamepadUI.KeyStatus["QuickMount"]);
|
|
if (PlayerInput.Triggers.JustPressed.QuickMount)
|
|
{
|
|
switch (num)
|
|
{
|
|
case 1:
|
|
PlayerInput.TryEnteringFastUseModeForMouseItem();
|
|
break;
|
|
case 2:
|
|
PlayerInput.TryEnteringFastUseModeForInventorySlot(slot);
|
|
break;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private static bool TryEnteringBuildingMode(
|
|
Item[] inv,
|
|
int context,
|
|
int slot,
|
|
Player player,
|
|
ref string s)
|
|
{
|
|
int num = 0;
|
|
if (ItemSlot.IsABuildingItem(Main.mouseItem))
|
|
num = 1;
|
|
if (num == 0 && Main.mouseItem.stack <= 0 && context == 0 && ItemSlot.IsABuildingItem(inv[slot]))
|
|
num = 2;
|
|
if (num > 0)
|
|
{
|
|
Item mouseItem = Main.mouseItem;
|
|
if (num == 1)
|
|
mouseItem = Main.mouseItem;
|
|
if (num == 2)
|
|
mouseItem = inv[slot];
|
|
if (num != 1 || player.ItemSpace(mouseItem).CanTakeItemToPersonalInventory)
|
|
{
|
|
if (mouseItem.damage > 0 && mouseItem.ammo == 0)
|
|
s += PlayerInput.BuildCommand(Lang.misc[60].Value, false, PlayerInput.ProfileGamepadUI.KeyStatus["QuickMount"]);
|
|
else if (mouseItem.createTile >= 0 || mouseItem.createWall > 0)
|
|
s += PlayerInput.BuildCommand(Lang.misc[61].Value, false, PlayerInput.ProfileGamepadUI.KeyStatus["QuickMount"]);
|
|
else
|
|
s += PlayerInput.BuildCommand(Lang.misc[63].Value, false, PlayerInput.ProfileGamepadUI.KeyStatus["QuickMount"]);
|
|
if (PlayerInput.Triggers.JustPressed.QuickMount)
|
|
PlayerInput.EnterBuildingMode();
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static bool IsABuildingItem(Item item) => item.type > 0 && item.stack > 0 && item.useStyle != 0 && item.useTime > 0;
|
|
|
|
public static void SelectEquipPage(Item item)
|
|
{
|
|
Main.EquipPage = -1;
|
|
if (item.IsAir)
|
|
return;
|
|
if (Main.projHook[item.shoot])
|
|
Main.EquipPage = 2;
|
|
else if (item.mountType != -1)
|
|
Main.EquipPage = 2;
|
|
else if (item.buffType > 0 && Main.vanityPet[item.buffType])
|
|
Main.EquipPage = 2;
|
|
else if (item.buffType > 0 && Main.lightPet[item.buffType])
|
|
Main.EquipPage = 2;
|
|
else if (item.dye > (byte) 0 && Main.EquipPageSelected == 1)
|
|
{
|
|
Main.EquipPage = 0;
|
|
}
|
|
else
|
|
{
|
|
if (item.legSlot == -1 && item.headSlot == -1 && item.bodySlot == -1 && !item.accessory)
|
|
return;
|
|
Main.EquipPage = 0;
|
|
}
|
|
}
|
|
|
|
public class Options
|
|
{
|
|
public static bool DisableLeftShiftTrashCan = true;
|
|
public static bool HighlightNewItems = true;
|
|
}
|
|
|
|
public class Context
|
|
{
|
|
public const int InventoryItem = 0;
|
|
public const int InventoryCoin = 1;
|
|
public const int InventoryAmmo = 2;
|
|
public const int ChestItem = 3;
|
|
public const int BankItem = 4;
|
|
public const int PrefixItem = 5;
|
|
public const int TrashItem = 6;
|
|
public const int GuideItem = 7;
|
|
public const int EquipArmor = 8;
|
|
public const int EquipArmorVanity = 9;
|
|
public const int EquipAccessory = 10;
|
|
public const int EquipAccessoryVanity = 11;
|
|
public const int EquipDye = 12;
|
|
public const int HotbarItem = 13;
|
|
public const int ChatItem = 14;
|
|
public const int ShopItem = 15;
|
|
public const int EquipGrapple = 16;
|
|
public const int EquipMount = 17;
|
|
public const int EquipMinecart = 18;
|
|
public const int EquipPet = 19;
|
|
public const int EquipLight = 20;
|
|
public const int MouseItem = 21;
|
|
public const int CraftingMaterial = 22;
|
|
public const int DisplayDollArmor = 23;
|
|
public const int DisplayDollAccessory = 24;
|
|
public const int DisplayDollDye = 25;
|
|
public const int HatRackHat = 26;
|
|
public const int HatRackDye = 27;
|
|
public const int GoldDebug = 28;
|
|
public const int CreativeInfinite = 29;
|
|
public const int CreativeSacrifice = 30;
|
|
public const int Count = 31;
|
|
}
|
|
}
|
|
}
|