refactor(OnChestOnQuickStack): use OTAPI.Hooks.Chest.QuickStack instead of GetDataHandlers.ForceItemIntoNearestChest

Author: ACaiCat

TShockAPI/GetDataHandlers.cs

@@ -2759,20 +2759,20 @@ private static bool HandleSpawn(GetDataHandlerArgs args)
 
 			if (OnPlayerSpawn(args.Player, args.Data, player, spawnX, spawnY, respawnTimer, numberOfDeathsPVE, numberOfDeathsPVP, context))
 				return true;
-			
+
 			args.Player.Dead = respawnTimer > 0;
 
 			if (Main.ServerSideCharacter)
 			{
 				// As long as the player has not changed his spawnpoint since initial connection,
-				// we should not use the client's spawnpoint value. This is because the spawnpoint 
-				// value is not saved on the client when SSC is enabled. Hence, we have to assert 
-				// the server-saved spawnpoint value until we can detect that the player has changed 
+				// we should not use the client's spawnpoint value. This is because the spawnpoint
+				// value is not saved on the client when SSC is enabled. Hence, we have to assert
+				// the server-saved spawnpoint value until we can detect that the player has changed
 				// his spawn. Once we detect the spawnpoint changed, the client's spawnpoint value
 				// becomes the correct one to use.
 				//
-				// Note that spawnpoint changes (right-clicking beds) are not broadcasted to the 
-				// server. Hence, the only way to detect spawnpoint changes is from the 
+				// Note that spawnpoint changes (right-clicking beds) are not broadcasted to the
+				// server. Hence, the only way to detect spawnpoint changes is from the
 				// PlayerSpawn packet.
 
 				// handle initial connection
@@ -2788,13 +2788,13 @@ private static bool HandleSpawn(GetDataHandlerArgs args)
 					args.Player.initialClientSpawnX = spawnX;
 					args.Player.initialClientSpawnY = spawnY;
 
-					// we first let the game handle completing the connection (state 3 => 10), 
-					// then we will spawn the player at the saved spawnpoint in the next second, 
+					// we first let the game handle completing the connection (state 3 => 10),
+					// then we will spawn the player at the saved spawnpoint in the next second,
 					// by reasserting the correct spawnpoint value
 					return false;
 				}
 
-				// once we detect the client has changed his spawnpoint in the current session, 
+				// once we detect the client has changed his spawnpoint in the current session,
 				// the client spawnpoint value will be correct for the rest of the session
 				if (args.Player.spawnSynced || args.Player.initialClientSpawnX != spawnX || args.Player.initialClientSpawnY != spawnY)
 				{
@@ -2806,11 +2806,11 @@ private static bool HandleSpawn(GetDataHandlerArgs args)
 				// spawn the player before teleporting
 				NetMessage.SendData((int)PacketTypes.PlayerSpawn, -1, args.Player.Index, null, args.Player.Index, (int)PlayerSpawnContext.ReviveFromDeath);
 
-				// the player has not changed his spawnpoint yet, so we assert the server-saved spawnpoint 
+				// the player has not changed his spawnpoint yet, so we assert the server-saved spawnpoint
 				// by teleporting the player instead of letting the game use the client's incorrect spawnpoint.
 				TShock.Log.ConsoleDebug(GetString("GetDataHandlers / HandleSpawn force ssc teleport for {0} at ({1},{2})", args.Player.Name, args.TPlayer.SpawnX, args.TPlayer.SpawnY));
 				args.Player.TeleportSpawnpoint();
-				
+
 				args.TPlayer.respawnTimer = respawnTimer;
 				args.TPlayer.numberOfDeathsPVE = numberOfDeathsPVE;
 				args.TPlayer.numberOfDeathsPVP = numberOfDeathsPVP;
@@ -3906,7 +3906,7 @@ private static bool HandleTeleport(GetDataHandlerArgs args)
 			if (type == 0 && !args.Player.HasPermission(Permissions.rod))
 			{
 				TShock.Log.ConsoleDebug(GetString("GetDataHandlers / HandleTeleport rejected rod type {0} {1}", args.Player.Name, type));
-				args.Player.SendErrorMessage(GetString("You do not have permission to teleport using items.")); // Was going to write using RoD but Hook of Disonnance and Potion of Return both use the same teleport packet as RoD. 
+				args.Player.SendErrorMessage(GetString("You do not have permission to teleport using items.")); // Was going to write using RoD but Hook of Disonnance and Potion of Return both use the same teleport packet as RoD.
 				args.Player.Teleport(args.TPlayer.position.X, args.TPlayer.position.Y); // Suggest renaming rod permission unless someone plans to add separate perms for the other 2 tp items.
 				return true;
 			}

TShockAPI/Utils.cs

@@ -1202,5 +1202,77 @@ internal void ComputeMaxStyles()
 				}
 			}
 		}
+
+		/// <summary>
+		/// Locates the nearest available chest suitable for quick-stacking items from the player's inventory.
+		/// </summary>
+		/// <param name="player">The player attempting to quick-stack items.</param>
+		/// <param name="slot">The inventory slot of the item being quick-stacked (currently unused in this method).</param>
+		/// <returns>
+		/// The index of the nearest available chest within range that isn't locked or in use, or -1 if no suitable chest is found.
+		/// </returns>
+		public static int LocateQuickStackChestIndex(TSPlayer player, short slot)
+		{
+		    const float maxDistance = 600f;
+		    Item item;
+
+		    if (slot >= PlayerItemSlotID.Bank4_0 && slot < PlayerItemSlotID.Bank4_0 + NetItem.VoidSlots)
+		    {
+			    var index = slot - PlayerItemSlotID.Bank4_0;
+			    item = player.TPlayer.bank4.item[index];
+		    }
+		    else
+		    {
+			    if (slot >= NetItem.InventorySlots - 1)
+				    return -1;
+			    item = player.TPlayer.inventory[slot];
+		    }
+
+		    for (var i = 0; i < Main.maxChests; i++)
+		    {
+			    var chest = Main.chest[i];
+			    if (chest == null || Chest.IsPlayerInChest(i) || Chest.IsLocked(chest.x, chest.y))
+				    continue;
+
+			    var chestPos = new Vector2(chest.x * 16 + 16, chest.y * 16 + 16);
+			    if ((chestPos - player.TPlayer.position).Length() >= maxDistance)
+				    continue;
+
+			    var canStack = false;
+			    var hasSpace = false;
+
+			    foreach (var chestItem in chest.item)
+			    {
+				    if (chestItem.IsAir)
+				    {
+					    hasSpace = true;
+					    continue;
+				    }
+
+				    if (item.IsTheSameAs(chestItem))
+				    {
+					    canStack = true;
+					    var space = chestItem.maxStack - chestItem.stack;
+					    if (space > 0)
+					    {
+						    return i;
+					    }
+				    }
+				    else
+				    {
+					    hasSpace = true;
+				    }
+			    }
+
+			    if (canStack && hasSpace && item.stack > 0)
+			    {
+				    if (chest.item.Any(t => t.IsAir))
+				    {
+					    return i;
+				    }
+			    }
+		    }
+		    return -1;
+		}
 	}
 }