using System;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using DataServer.Data;
using DataServer.Data.Entities;
using DataServer.Data.Enums;
using Server.Networking;
using GameServer.Networking.DTOs;
using Server.Networking.Messages;
namespace GameServer.Dungeon;
#region Stash System
public sealed partial class DungeonHandler
{
private const int STASH_SLOTS = 50; // Number of stash slots
///
/// Handle request to view stash contents
///
private async Task HandleStashRequest(IConnection connection, DungeonPlayerSession session, CancellationToken ct)
{
using var scope = _scopeFactory.CreateScope();
var db = scope.ServiceProvider.GetRequiredService();
// Get stash items
var stashItems = await db.DungeonStashItems
.Where(s => s.CharacterId == session.CharacterId)
.Include(s => s.Definition)
.OrderBy(s => s.SlotIndex)
.ToListAsync(ct);
await SendAsync(connection, DungeonOpCodes.STASH_STATE, new
{
slots = STASH_SLOTS,
items = stashItems.Select(s => new
{
id = s.Id,
slotIndex = s.SlotIndex,
itemDefinitionId = s.ItemDefinitionId,
quantity = s.Quantity,
storedAt = s.StoredAt,
definition = s.Definition == null ? null : new
{
id = s.Definition.Id,
name = s.Definition.Name,
description = s.Definition.Description,
type = s.Definition.Type.ToString(),
rarity = s.Definition.Rarity.ToString(),
spritePath = s.Definition.SpritePath,
stackable = s.Definition.Stackable,
maxStack = s.Definition.MaxStack
}
})
}, ct);
}
///
/// Handle depositing an item from inventory to stash
///
private async Task HandleStashDeposit(IConnection connection, DungeonPlayerSession session, ReadOnlyMemory payload, CancellationToken ct)
{
using var scope = _scopeFactory.CreateScope();
var db = scope.ServiceProvider.GetRequiredService();
// Must be in hub to use stash
if (session.State != PlayerState.InHub)
{
await SendAsync(connection, DungeonOpCodes.STASH_RESULT, new
{
success = false,
error = "not_in_hub",
message = "You must be in the hub to access your stash."
}, ct);
return;
}
var request = _ser.Deserialize(payload);
var inventorySlot = request.InventorySlot;
var quantity = request.Quantity > 0 ? request.Quantity : 1;
var targetSlot = request.TargetSlot;
// Find the inventory item
var invItem = await db.DungeonCharacterItems
.Include(i => i.ItemDefinition)
.FirstOrDefaultAsync(i => i.CharacterId == session.CharacterId && i.SlotIndex == inventorySlot && !i.IsEquipped, ct);
if (invItem == null)
{
await SendAsync(connection, DungeonOpCodes.STASH_RESULT, new
{
success = false,
error = "item_not_found",
message = "Item not found in inventory."
}, ct);
return;
}
// Find target slot
if (targetSlot < 0)
{
// Auto-find empty slot
var usedSlots = await db.DungeonStashItems
.Where(s => s.CharacterId == session.CharacterId)
.Select(s => s.SlotIndex)
.ToListAsync(ct);
for (int i = 0; i < STASH_SLOTS; i++)
{
if (!usedSlots.Contains(i))
{
targetSlot = i;
break;
}
}
if (targetSlot < 0)
{
await SendAsync(connection, DungeonOpCodes.STASH_RESULT, new
{
success = false,
error = "stash_full",
message = "Your stash is full!"
}, ct);
return;
}
}
// Validate quantity
quantity = Math.Min(quantity, invItem.Quantity);
// Check if stacking with existing stash item
DungeonStashItem? existingStash = null;
if (invItem.ItemDefinition?.Stackable == true)
{
existingStash = await db.DungeonStashItems
.Include(s => s.Definition)
.FirstOrDefaultAsync(s => s.CharacterId == session.CharacterId &&
s.ItemDefinitionId == invItem.ItemDefinitionId, ct);
}
if (existingStash != null && invItem.ItemDefinition?.Stackable == true)
{
// Stack with existing
var maxAdd = (invItem.ItemDefinition?.MaxStack ?? 99) - existingStash.Quantity;
var toAdd = Math.Min(quantity, maxAdd);
if (toAdd > 0)
{
existingStash.Quantity += toAdd;
invItem.Quantity -= toAdd;
if (invItem.Quantity <= 0)
db.DungeonCharacterItems.Remove(invItem);
}
}
else
{
// Create new stash entry
var stashItem = new DungeonStashItem
{
CharacterId = session.CharacterId,
ItemDefinitionId = invItem.ItemDefinitionId,
Quantity = quantity,
SlotIndex = targetSlot,
StoredAt = DateTime.UtcNow
};
db.DungeonStashItems.Add(stashItem);
invItem.Quantity -= quantity;
if (invItem.Quantity <= 0)
db.DungeonCharacterItems.Remove(invItem);
}
await db.SaveChangesAsync(ct);
await SendAsync(connection, DungeonOpCodes.STASH_RESULT, new
{
success = true,
message = "Item deposited to stash."
}, ct);
// Send updated inventory and stash
await HandleInventoryRequest(connection, session, ct);
await HandleStashRequest(connection, session, ct);
}
///
/// Handle withdrawing an item from stash to inventory
///
private async Task HandleStashWithdraw(IConnection connection, DungeonPlayerSession session, ReadOnlyMemory payload, CancellationToken ct)
{
using var scope = _scopeFactory.CreateScope();
var db = scope.ServiceProvider.GetRequiredService();
// Must be in hub to use stash
if (session.State != PlayerState.InHub)
{
await SendAsync(connection, DungeonOpCodes.STASH_RESULT, new
{
success = false,
error = "not_in_hub",
message = "You must be in the hub to access your stash."
}, ct);
return;
}
var request = _ser.Deserialize(payload);
var stashSlot = request.StashSlot;
var quantity = request.Quantity > 0 ? request.Quantity : 1;
// Find the stash item
var stashItem = await db.DungeonStashItems
.Include(s => s.Definition)
.FirstOrDefaultAsync(s => s.CharacterId == session.CharacterId && s.SlotIndex == stashSlot, ct);
if (stashItem == null)
{
await SendAsync(connection, DungeonOpCodes.STASH_RESULT, new
{
success = false,
error = "item_not_found",
message = "Item not found in stash."
}, ct);
return;
}
// Validate quantity
quantity = Math.Min(quantity, stashItem.Quantity);
// Find empty inventory slot or stackable slot
var invItems = await db.DungeonCharacterItems
.Where(i => i.CharacterId == session.CharacterId && !i.IsEquipped)
.Include(i => i.ItemDefinition)
.ToListAsync(ct);
// Check for stackable existing
DungeonCharacterItem? targetItem = null;
if (stashItem.Definition?.Stackable == true)
{
targetItem = invItems.FirstOrDefault(i =>
i.ItemDefinitionId == stashItem.ItemDefinitionId &&
i.Quantity < (i.ItemDefinition?.MaxStack ?? 99));
}
if (targetItem != null)
{
// Stack with existing
var maxAdd = (stashItem.Definition?.MaxStack ?? 99) - targetItem.Quantity;
var toAdd = Math.Min(quantity, maxAdd);
targetItem.Quantity += toAdd;
stashItem.Quantity -= toAdd;
if (stashItem.Quantity <= 0)
db.DungeonStashItems.Remove(stashItem);
}
else
{
// Find empty slot (starting from slot 0 for inventory)
var usedSlots = invItems.Select(i => i.SlotIndex).ToHashSet();
int emptySlot = -1;
for (int i = 0; i < 30; i++)
{
if (!usedSlots.Contains(i))
{
emptySlot = i;
break;
}
}
if (emptySlot < 0)
{
await SendAsync(connection, DungeonOpCodes.STASH_RESULT, new
{
success = false,
error = "inventory_full",
message = "Your inventory is full!"
}, ct);
return;
}
// Create new inventory item
var newItem = new DungeonCharacterItem
{
CharacterId = session.CharacterId,
ItemDefinitionId = stashItem.ItemDefinitionId,
Quantity = quantity,
SlotIndex = emptySlot
};
db.DungeonCharacterItems.Add(newItem);
stashItem.Quantity -= quantity;
if (stashItem.Quantity <= 0)
db.DungeonStashItems.Remove(stashItem);
}
await db.SaveChangesAsync(ct);
await SendAsync(connection, DungeonOpCodes.STASH_RESULT, new
{
success = true,
message = "Item withdrawn from stash."
}, ct);
// Send updated inventory and stash
await HandleInventoryRequest(connection, session, ct);
await HandleStashRequest(connection, session, ct);
}
}
#endregion