diff --git a/Game/Dungeon/DungeonHandler.cs b/Game/Dungeon/DungeonHandler.cs
index e1235bc..d875b35 100644
--- a/Game/Dungeon/DungeonHandler.cs
+++ b/Game/Dungeon/DungeonHandler.cs
@@ -71,7 +71,12 @@ public sealed class DungeonHandler : IClientMessageHandler
DungeonOpCodes.USE_ITEM,
DungeonOpCodes.DROP_ITEM,
DungeonOpCodes.CHAT_SEND,
- DungeonOpCodes.HOTBAR_ASSIGN
+ DungeonOpCodes.HOTBAR_ASSIGN,
+ // Loot chest operations
+ DungeonOpCodes.LOOT_CHEST_OPEN,
+ DungeonOpCodes.LOOT_CHEST_TAKE_ITEM,
+ DungeonOpCodes.LOOT_CHEST_TAKE_ALL,
+ DungeonOpCodes.LOOT_CHEST_CLOSE
};
public async Task InitializeAsync()
@@ -172,19 +177,19 @@ public sealed class DungeonHandler : IClientMessageHandler
case DungeonOpCodes.DUNGEON_INPUT_PORTAL:
await HandlePortalUse(connection, session, payload, ct);
break;
-
+
case DungeonOpCodes.INVENTORY_REQUEST:
await HandleInventoryRequest(connection, session, ct);
break;
-
+
case DungeonOpCodes.EQUIP_ITEM:
await HandleEquipItem(connection, session, payload, ct);
break;
-
+
case DungeonOpCodes.UNEQUIP_ITEM:
await HandleUnequipItem(connection, session, payload, ct);
break;
-
+
case DungeonOpCodes.USE_ITEM:
await HandleUseItem(connection, session, payload, ct);
break;
@@ -194,6 +199,20 @@ public sealed class DungeonHandler : IClientMessageHandler
case DungeonOpCodes.HOTBAR_ASSIGN:
await HandleHotbarAssign(connection, session, payload, ct);
break;
+
+ // Loot chest operations
+ case DungeonOpCodes.LOOT_CHEST_OPEN:
+ await HandleLootChestOpen(connection, session, payload, ct);
+ break;
+ case DungeonOpCodes.LOOT_CHEST_TAKE_ITEM:
+ await HandleLootChestTakeItem(connection, session, payload, ct);
+ break;
+ case DungeonOpCodes.LOOT_CHEST_TAKE_ALL:
+ await HandleLootChestTakeAll(connection, session, payload, ct);
+ break;
+ case DungeonOpCodes.LOOT_CHEST_CLOSE:
+ await HandleLootChestClose(connection, session, payload, ct);
+ break;
}
}
catch (Exception ex)
@@ -655,7 +674,7 @@ public sealed class DungeonHandler : IClientMessageHandler
{
var result = instance.Simulation.Tick(_currentTick);
- // Process mob death events for loot generation
+ // Process death events for loot generation
if (result.DeathEvents != null)
{
foreach (var death in result.DeathEvents)
@@ -665,6 +684,11 @@ public sealed class DungeonHandler : IClientMessageHandler
// Fire and forget loot generation (async in sync context)
_ = ProcessMobDeathLootAsync(instance, death);
}
+ else if (death.EntityType == EntityType.Player)
+ {
+ // Player died - transfer loot to killer
+ _ = ProcessPlayerDeathLootTransferAsync(instance, death);
+ }
}
}
@@ -716,7 +740,7 @@ public sealed class DungeonHandler : IClientMessageHandler
}
}
///
- /// Process loot when a mob dies
+ /// Process loot when a mob dies - includes normal loot roll plus any carried player loot
///
private async Task ProcessMobDeathLootAsync(DungeonInstance dungeon, DeathEvent death)
{
@@ -737,20 +761,70 @@ public sealed class DungeonHandler : IClientMessageHandler
var loot = _lootService.GenerateMobLoot(
mob.DefinitionId,
dungeon.Tier,
- 1.0f // Can multiply by mob's DropChanceMultiplier if stored
+ 1.0f
);
- if (loot.Count == 0)
+ // Collect all items to give (normal loot + carried player loot)
+ var allItems = new List(loot);
+ long totalGold = 0;
+
+ // Add any carried player loot from player kills
+ if (mob.HasCarriedLoot)
+ {
+ _log.LogInformation("Mob {MobName} was carrying loot from {Count} player kills",
+ mob.Name, mob.CarriedPlayerLoot.Count);
+
+ using var scope = _scopeFactory.CreateScope();
+ var db = scope.ServiceProvider.GetRequiredService();
+
+ foreach (var carried in mob.CarriedPlayerLoot)
+ {
+ totalGold += carried.Gold;
+
+ // Convert carried items to LootDrops
+ foreach (var item in carried.Items)
+ {
+ var itemDef = await db.Set()
+ .FirstOrDefaultAsync(d => d.Id == item.ItemDefinitionId);
+
+ if (itemDef != null)
+ {
+ allItems.Add(new LootDrop
+ {
+ ItemDefinitionId = item.ItemDefinitionId,
+ Item = itemDef,
+ Quantity = item.Quantity
+ });
+ }
+ }
+ }
+
+ // Clear the carried loot from the mob
+ mob.CarriedPlayerLoot.Clear();
+ }
+
+ if (allItems.Count == 0 && totalGold == 0)
return;
- // Add loot to player's inventory
- await AddLootToInventoryAsync(killerSession, loot);
+ // Try to add loot to player's inventory, get overflow
+ var (addedItems, overflowItems, overflowGold) = await AddLootToInventoryWithOverflowAsync(
+ killerSession, allItems, totalGold);
- // Send loot popup to the player
- await SendLootPopupAsync(killerSession, loot);
+ // Send loot popup for items that were added directly
+ if (addedItems.Count > 0)
+ {
+ await SendLootPopupAsync(killerSession, addedItems);
+ }
- _log.LogDebug("Player {Player} received {Count} items from {Mob}",
- killerSession.Character.Name, loot.Count, mob.Name);
+ // If there's overflow, spawn a personal loot chest
+ if (overflowItems.Count > 0 || overflowGold > 0)
+ {
+ await SpawnLootChestAsync(dungeon, killerSession, overflowItems, overflowGold,
+ mob.X, mob.Y, null, mob.DefinitionId);
+ }
+
+ _log.LogDebug("Player {Player} received {Count} items and {Gold} gold from {Mob}",
+ killerSession.Character.Name, addedItems.Count, totalGold - overflowGold, mob.Name);
}
catch (Exception ex)
{
@@ -759,21 +833,194 @@ public sealed class DungeonHandler : IClientMessageHandler
}
///
- /// Adds loot directly to player's inventory in the database
+ /// Process player death - transfer inventory and 10% gold to killer
///
- private async Task AddLootToInventoryAsync(DungeonPlayerSession session, List loot)
+ private async Task ProcessPlayerDeathLootTransferAsync(DungeonInstance dungeon, DeathEvent death)
{
+ try
+ {
+ var victimSession = _playerSessions.Values
+ .FirstOrDefault(s => s.CharacterId == (ulong)death.EntityId);
+
+ if (victimSession == null)
+ return;
+
+ using var scope = _scopeFactory.CreateScope();
+ var db = scope.ServiceProvider.GetRequiredService();
+
+ // Get victim's inventory (non-equipped items only)
+ var victimInventory = await db.Set()
+ .Include(i => i.ItemDefinition)
+ .Where(i => i.CharacterId == victimSession.CharacterId && !i.IsEquipped)
+ .ToListAsync();
+
+ // Calculate gold to transfer (10%)
+ var victim = await db.DungeonCharacters.FindAsync(victimSession.CharacterId);
+ if (victim == null) return;
+
+ long goldToTransfer = (long)(victim.Gold * 0.10);
+
+ // Build the loot package
+ var lootItems = victimInventory.Select(i => new CarriedLootItem
+ {
+ ItemDefinitionId = i.ItemDefinitionId,
+ Quantity = i.Quantity
+ }).ToList();
+
+ var carriedLoot = new CarriedLoot
+ {
+ VictimCharacterId = victimSession.CharacterId,
+ VictimName = victim.Name,
+ Items = lootItems,
+ Gold = goldToTransfer
+ };
+
+ // Remove items from victim's inventory
+ db.Set().RemoveRange(victimInventory);
+
+ // Deduct gold from victim
+ victim.Gold -= goldToTransfer;
+
+ await db.SaveChangesAsync();
+
+ // Send notification to victim about what they lost
+ await SendDeathLootLostNotificationAsync(victimSession, victimInventory, goldToTransfer);
+
+ _log.LogInformation("Player {Victim} died to {KillerType} {KillerId}. Lost {ItemCount} items and {Gold} gold",
+ victim.Name, death.KillerType, death.KillerId, victimInventory.Count, goldToTransfer);
+
+ // Transfer loot based on killer type
+ if (death.KillerType == EntityType.Mob)
+ {
+ // Mob killed player - mob now carries the loot
+ if (dungeon.Simulation.Mobs.TryGetValue(death.KillerId, out var killerMob))
+ {
+ killerMob.CarriedPlayerLoot.Add(carriedLoot);
+ _log.LogInformation("Mob {MobName} is now carrying loot from {Victim}",
+ killerMob.Name, victim.Name);
+ }
+ }
+ else if (death.KillerType == EntityType.Player)
+ {
+ // Player killed player - transfer directly
+ var killerSession = _playerSessions.Values
+ .FirstOrDefault(s => s.CharacterId == (ulong)death.KillerId);
+
+ if (killerSession != null)
+ {
+ await TransferPlayerLootToPlayerAsync(dungeon, killerSession, carriedLoot,
+ victimSession.PlayerInstance?.X ?? 0, victimSession.PlayerInstance?.Y ?? 0);
+ }
+ }
+ }
+ catch (Exception ex)
+ {
+ _log.LogError(ex, "Error processing player death loot transfer");
+ }
+ }
+
+ ///
+ /// Transfer carried loot directly to a player (from PvP kill)
+ ///
+ private async Task TransferPlayerLootToPlayerAsync(DungeonInstance dungeon, DungeonPlayerSession killer,
+ CarriedLoot loot, float x, float y)
+ {
+ using var scope = _scopeFactory.CreateScope();
+ var db = scope.ServiceProvider.GetRequiredService();
+
+ // Convert carried items to LootDrops
+ var lootDrops = new List();
+ foreach (var item in loot.Items)
+ {
+ var itemDef = await db.Set()
+ .FirstOrDefaultAsync(d => d.Id == item.ItemDefinitionId);
+
+ if (itemDef != null)
+ {
+ lootDrops.Add(new LootDrop
+ {
+ ItemDefinitionId = item.ItemDefinitionId,
+ Item = itemDef,
+ Quantity = item.Quantity
+ });
+ }
+ }
+
+ // Try to add to killer's inventory
+ var (addedItems, overflowItems, overflowGold) = await AddLootToInventoryWithOverflowAsync(
+ killer, lootDrops, loot.Gold);
+
+ if (addedItems.Count > 0)
+ {
+ await SendLootPopupAsync(killer, addedItems);
+ }
+
+ // Spawn chest for overflow
+ if (overflowItems.Count > 0 || overflowGold > 0)
+ {
+ await SpawnLootChestAsync(dungeon, killer, overflowItems, overflowGold, x, y,
+ loot.VictimCharacterId, null);
+ }
+
+ _log.LogInformation("Player {Killer} received loot from killing {Victim}: {Items} items, {Gold} gold",
+ killer.Character.Name, loot.VictimName, loot.Items.Count, loot.Gold);
+ }
+
+ ///
+ /// Send notification to victim about what they lost on death
+ ///
+ private async Task SendDeathLootLostNotificationAsync(DungeonPlayerSession victim,
+ List lostItems, long lostGold)
+ {
+ var itemsData = lostItems.Select(i => new
+ {
+ name = i.ItemDefinition?.Name ?? "Unknown",
+ quantity = i.Quantity,
+ rarity = i.ItemDefinition?.Rarity.ToString() ?? "Common"
+ });
+
+ await SendAsync(victim.Connection, DungeonOpCodes.PLAYER_DEATH_LOOT_LOST, new
+ {
+ items = itemsData,
+ gold = lostGold,
+ message = $"You died and lost {lostItems.Count} items and {lostGold} gold!"
+ }, CancellationToken.None);
+ }
+
+ ///
+ /// Add loot to inventory, returning what was added and what overflowed
+ ///
+ private async Task<(List added, List overflow, long overflowGold)>
+ AddLootToInventoryWithOverflowAsync(DungeonPlayerSession session, List loot, long gold)
+ {
+ var added = new List();
+ var overflow = new List();
+ long overflowGold = 0;
+
using var scope = _scopeFactory.CreateScope();
var db = scope.ServiceProvider.GetRequiredService();
// Get existing inventory items
var existingItems = await db.Set()
- .Where(i => i.CharacterId == session.CharacterId)
+ .Where(i => i.CharacterId == session.CharacterId && !i.IsEquipped)
.ToListAsync();
- int nextSlot = existingItems.Count > 0
- ? existingItems.Max(i => i.SlotIndex) + 1
- : 0;
+ // Find used slots
+ var usedSlots = existingItems.Select(i => i.SlotIndex).ToHashSet();
+
+ // Find next available slot
+ int FindNextSlot()
+ {
+ for (int i = 0; i < 30; i++)
+ {
+ if (!usedSlots.Contains(i))
+ {
+ usedSlots.Add(i);
+ return i;
+ }
+ }
+ return -1; // Full
+ }
foreach (var drop in loot)
{
@@ -784,39 +1031,512 @@ public sealed class DungeonHandler : IClientMessageHandler
if (existingStack != null && drop.Item.Stackable)
{
- // Add to existing stack
- existingStack.Quantity = Math.Min(
- existingStack.Quantity + drop.Quantity,
- drop.Item.MaxStack
- );
+ int spaceInStack = drop.Item.MaxStack - existingStack.Quantity;
+ int toAdd = Math.Min(drop.Quantity, spaceInStack);
+
+ if (toAdd > 0)
+ {
+ existingStack.Quantity += toAdd;
+ added.Add(new LootDrop
+ {
+ ItemDefinitionId = drop.ItemDefinitionId,
+ Item = drop.Item,
+ Quantity = toAdd
+ });
+ }
+
+ int remaining = drop.Quantity - toAdd;
+ if (remaining > 0)
+ {
+ // Overflow the rest
+ overflow.Add(new LootDrop
+ {
+ ItemDefinitionId = drop.ItemDefinitionId,
+ Item = drop.Item,
+ Quantity = remaining
+ });
+ }
}
else
{
- // Check if inventory is full (30 slots)
- if (nextSlot >= 30)
+ int nextSlot = FindNextSlot();
+ if (nextSlot >= 0)
{
- // TODO: Drop item on ground instead
- _log.LogWarning("Player {Name} inventory full, item {Item} not added",
- session.Character.Name, drop.Item.Name);
- continue;
+ // Create new inventory entry
+ var newItem = new DungeonCharacterItem
+ {
+ CharacterId = session.CharacterId,
+ ItemDefinitionId = drop.ItemDefinitionId,
+ Quantity = drop.Quantity,
+ SlotIndex = nextSlot
+ };
+ db.Set().Add(newItem);
+ existingItems.Add(newItem);
+ added.Add(drop);
}
-
- // Create new inventory entry
- var newItem = new DungeonCharacterItem
+ else
{
- CharacterId = session.CharacterId,
- ItemDefinitionId = drop.ItemDefinitionId,
- Quantity = drop.Quantity,
- SlotIndex = nextSlot++
- };
- db.Set().Add(newItem);
- existingItems.Add(newItem);
+ // Inventory full - overflow
+ overflow.Add(drop);
+ }
}
}
+ // Handle gold
+ var character = await db.DungeonCharacters.FindAsync(session.CharacterId);
+ if (character != null)
+ {
+ character.Gold += gold;
+ }
+
await db.SaveChangesAsync();
+
+ return (added, overflow, overflowGold);
}
+ ///
+ /// Spawn a personal loot chest for overflow items
+ ///
+ private async Task SpawnLootChestAsync(DungeonInstance dungeon, DungeonPlayerSession owner,
+ List items, long gold, float x, float y, ulong? victimCharacterId, int? victimMobId)
+ {
+ using var scope = _scopeFactory.CreateScope();
+ var db = scope.ServiceProvider.GetRequiredService();
+
+ // Create database record for auditing
+ var deathChest = new DeathChest
+ {
+ DungeonInstanceId = dungeon.Id,
+ OwnerCharacterId = owner.CharacterId,
+ VictimCharacterId = victimCharacterId,
+ VictimMobDefinitionId = victimMobId,
+ X = x,
+ Y = y,
+ GoldAmount = gold,
+ CreatedAt = DateTime.UtcNow
+ };
+ db.DeathChests.Add(deathChest);
+ await db.SaveChangesAsync();
+
+ // Add items to chest
+ int slotIndex = 0;
+ foreach (var item in items)
+ {
+ var chestItem = new DeathChestItem
+ {
+ DeathChestId = deathChest.Id,
+ ItemDefinitionId = item.ItemDefinitionId,
+ Quantity = item.Quantity,
+ SlotIndex = slotIndex++
+ };
+ db.DeathChestItems.Add(chestItem);
+ }
+ await db.SaveChangesAsync();
+
+ // Create runtime instance
+ var lootChest = new LootChestInstance
+ {
+ Id = dungeon.Simulation.GetNextLootChestId(),
+ DatabaseId = deathChest.Id,
+ X = x,
+ Y = y,
+ OwnerCharacterId = owner.CharacterId,
+ Gold = gold,
+ Items = items.Select((item, idx) => new LootChestItem
+ {
+ SlotIndex = idx,
+ ItemDefinitionId = item.ItemDefinitionId,
+ Quantity = item.Quantity
+ }).ToList()
+ };
+
+ dungeon.Simulation.LootChests.TryAdd(lootChest.Id, lootChest);
+
+ // Notify the owner about the chest
+ await SendAsync(owner.Connection, DungeonOpCodes.LOOT_CHEST_SPAWNED, new
+ {
+ chestId = lootChest.Id,
+ x = lootChest.X,
+ y = lootChest.Y,
+ itemCount = lootChest.Items.Count,
+ gold = lootChest.Gold,
+ message = "A loot chest appeared with your overflow items!"
+ }, CancellationToken.None);
+
+ _log.LogInformation("Spawned loot chest {ChestId} for player {Player} with {Items} items and {Gold} gold at ({X}, {Y})",
+ lootChest.Id, owner.Character.Name, items.Count, gold, x, y);
+ }
+
+ ///
+ /// Adds loot directly to player's inventory in the database (legacy - kept for compatibility)
+ ///
+ private async Task AddLootToInventoryAsync(DungeonPlayerSession session, List loot)
+ {
+ var (_, _, _) = await AddLootToInventoryWithOverflowAsync(session, loot, 0);
+ }
+
+ #region Loot Chest Handlers
+
+ ///
+ /// Handle opening a loot chest
+ ///
+ private async Task HandleLootChestOpen(IConnection connection, DungeonPlayerSession session, ReadOnlyMemory payload, CancellationToken ct)
+ {
+ var json = System.Text.Encoding.UTF8.GetString(payload.Span);
+ var request = System.Text.Json.JsonSerializer.Deserialize(json);
+ if (request == null) return;
+
+ if (!session.CurrentDungeonId.HasValue ||
+ !_dungeons.TryGetValue(session.CurrentDungeonId.Value, out var dungeon))
+ return;
+
+ if (!dungeon.Simulation.LootChests.TryGetValue(request.ChestId, out var chest))
+ {
+ await SendErrorAsync(connection, "Chest not found", ct);
+ return;
+ }
+
+ // Check ownership
+ if (chest.OwnerCharacterId != session.CharacterId)
+ {
+ await SendErrorAsync(connection, "This chest doesn't belong to you", ct);
+ return;
+ }
+
+ // Check distance
+ if (session.PlayerInstance != null)
+ {
+ float dist = MathF.Sqrt(
+ MathF.Pow(session.PlayerInstance.X - chest.X, 2) +
+ MathF.Pow(session.PlayerInstance.Y - chest.Y, 2));
+
+ if (dist > 96) // Interaction range
+ {
+ await SendErrorAsync(connection, "Too far from chest", ct);
+ return;
+ }
+ }
+
+ chest.IsOpen = true;
+
+ // Load item definitions for display
+ using var scope = _scopeFactory.CreateScope();
+ var db = scope.ServiceProvider.GetRequiredService();
+
+ var itemDefIds = chest.Items.Select(i => i.ItemDefinitionId).Distinct().ToList();
+ var itemDefs = await db.Set()
+ .Where(d => itemDefIds.Contains(d.Id))
+ .ToDictionaryAsync(d => d.Id, ct);
+
+ // Build chest state
+ var chestItems = new object?[100];
+ foreach (var item in chest.Items)
+ {
+ if (itemDefs.TryGetValue(item.ItemDefinitionId, out var def))
+ {
+ chestItems[item.SlotIndex] = new
+ {
+ slotIndex = item.SlotIndex,
+ definitionId = def.Id,
+ name = def.Name,
+ description = def.Description,
+ type = def.Type.ToString(),
+ rarity = def.Rarity.ToString(),
+ quantity = item.Quantity,
+ spriteId = def.SpriteId
+ };
+ }
+ }
+
+ await SendAsync(connection, DungeonOpCodes.LOOT_CHEST_STATE, new
+ {
+ chestId = chest.Id,
+ gold = chest.Gold,
+ items = chestItems,
+ slots = 100
+ }, ct);
+ }
+
+ ///
+ /// Handle taking a single item from loot chest
+ ///
+ private async Task HandleLootChestTakeItem(IConnection connection, DungeonPlayerSession session, ReadOnlyMemory payload, CancellationToken ct)
+ {
+ var json = System.Text.Encoding.UTF8.GetString(payload.Span);
+ var request = System.Text.Json.JsonSerializer.Deserialize(json);
+ if (request == null) return;
+
+ if (!session.CurrentDungeonId.HasValue ||
+ !_dungeons.TryGetValue(session.CurrentDungeonId.Value, out var dungeon))
+ return;
+
+ if (!dungeon.Simulation.LootChests.TryGetValue(request.ChestId, out var chest))
+ return;
+
+ if (chest.OwnerCharacterId != session.CharacterId)
+ return;
+
+ // Find the item in chest
+ var chestItem = chest.Items.FirstOrDefault(i => i.SlotIndex == request.SlotIndex);
+ if (chestItem == null)
+ {
+ await SendErrorAsync(connection, "Item not found in chest", ct);
+ return;
+ }
+
+ using var scope = _scopeFactory.CreateScope();
+ var db = scope.ServiceProvider.GetRequiredService();
+
+ // Get item definition
+ var itemDef = await db.Set()
+ .FirstOrDefaultAsync(d => d.Id == chestItem.ItemDefinitionId, ct);
+ if (itemDef == null) return;
+
+ // Get player's current inventory
+ var existingItems = await db.Set()
+ .Where(i => i.CharacterId == session.CharacterId && !i.IsEquipped)
+ .ToListAsync(ct);
+
+ // Find an available slot
+ var usedSlots = existingItems.Select(i => i.SlotIndex).ToHashSet();
+ int targetSlot = request.TargetSlotIndex;
+
+ if (targetSlot < 0 || targetSlot >= 30 || usedSlots.Contains(targetSlot))
+ {
+ // Find first available slot
+ targetSlot = -1;
+ for (int i = 0; i < 30; i++)
+ {
+ if (!usedSlots.Contains(i))
+ {
+ targetSlot = i;
+ break;
+ }
+ }
+ }
+
+ if (targetSlot < 0)
+ {
+ await SendErrorAsync(connection, "Inventory full", ct);
+ return;
+ }
+
+ // Add to player inventory
+ var newItem = new DungeonCharacterItem
+ {
+ CharacterId = session.CharacterId,
+ ItemDefinitionId = chestItem.ItemDefinitionId,
+ Quantity = chestItem.Quantity,
+ SlotIndex = targetSlot
+ };
+ db.Set().Add(newItem);
+
+ // Update database chest item as taken
+ var dbChestItem = await db.DeathChestItems
+ .FirstOrDefaultAsync(i => i.DeathChestId == chest.DatabaseId &&
+ i.SlotIndex == request.SlotIndex &&
+ !i.IsTaken, ct);
+ if (dbChestItem != null)
+ {
+ dbChestItem.IsTaken = true;
+ dbChestItem.TakenAt = DateTime.UtcNow;
+ }
+
+ await db.SaveChangesAsync(ct);
+
+ // Remove from runtime chest
+ chest.Items.Remove(chestItem);
+
+ // Check if chest is now empty
+ await CheckAndRemoveEmptyChestAsync(db, dungeon, chest, ct);
+
+ // Send updated states
+ await HandleInventoryRequest(connection, session, ct);
+ await HandleLootChestOpen(connection, session, payload, ct); // Resend chest state
+ }
+
+ ///
+ /// Handle taking all items from loot chest
+ ///
+ private async Task HandleLootChestTakeAll(IConnection connection, DungeonPlayerSession session, ReadOnlyMemory payload, CancellationToken ct)
+ {
+ var json = System.Text.Encoding.UTF8.GetString(payload.Span);
+ var request = System.Text.Json.JsonSerializer.Deserialize(json);
+ if (request == null) return;
+
+ if (!session.CurrentDungeonId.HasValue ||
+ !_dungeons.TryGetValue(session.CurrentDungeonId.Value, out var dungeon))
+ return;
+
+ if (!dungeon.Simulation.LootChests.TryGetValue(request.ChestId, out var chest))
+ return;
+
+ if (chest.OwnerCharacterId != session.CharacterId)
+ return;
+
+ using var scope = _scopeFactory.CreateScope();
+ var db = scope.ServiceProvider.GetRequiredService();
+
+ // Get player's current inventory
+ var existingItems = await db.Set()
+ .Where(i => i.CharacterId == session.CharacterId && !i.IsEquipped)
+ .ToListAsync(ct);
+
+ var usedSlots = existingItems.Select(i => i.SlotIndex).ToHashSet();
+ var itemsTaken = new List();
+ var takenLoot = new List();
+
+ // Try to take each item
+ foreach (var chestItem in chest.Items.ToList())
+ {
+ // Find available slot
+ int targetSlot = -1;
+ for (int i = 0; i < 30; i++)
+ {
+ if (!usedSlots.Contains(i))
+ {
+ targetSlot = i;
+ usedSlots.Add(i);
+ break;
+ }
+ }
+
+ if (targetSlot < 0)
+ break; // Inventory full
+
+ // Get item definition for popup
+ var itemDef = await db.Set()
+ .FirstOrDefaultAsync(d => d.Id == chestItem.ItemDefinitionId, ct);
+
+ // Add to player inventory
+ var newItem = new DungeonCharacterItem
+ {
+ CharacterId = session.CharacterId,
+ ItemDefinitionId = chestItem.ItemDefinitionId,
+ Quantity = chestItem.Quantity,
+ SlotIndex = targetSlot
+ };
+ db.Set().Add(newItem);
+
+ // Update database chest item as taken
+ var dbChestItem = await db.DeathChestItems
+ .FirstOrDefaultAsync(i => i.DeathChestId == chest.DatabaseId &&
+ i.SlotIndex == chestItem.SlotIndex &&
+ !i.IsTaken, ct);
+ if (dbChestItem != null)
+ {
+ dbChestItem.IsTaken = true;
+ dbChestItem.TakenAt = DateTime.UtcNow;
+ }
+
+ itemsTaken.Add(chestItem);
+
+ if (itemDef != null)
+ {
+ takenLoot.Add(new LootDrop
+ {
+ ItemDefinitionId = chestItem.ItemDefinitionId,
+ Item = itemDef,
+ Quantity = chestItem.Quantity
+ });
+ }
+ }
+
+ // Take gold
+ if (chest.Gold > 0)
+ {
+ var character = await db.DungeonCharacters.FindAsync(new object[] { session.CharacterId }, ct);
+ if (character != null)
+ {
+ character.Gold += chest.Gold;
+
+ // Update database chest
+ var dbChest = await db.DeathChests.FindAsync(new object[] { chest.DatabaseId }, ct);
+ if (dbChest != null)
+ {
+ dbChest.GoldAmount = 0;
+ }
+
+ chest.Gold = 0;
+ }
+ }
+
+ await db.SaveChangesAsync(ct);
+
+ // Remove taken items from runtime chest
+ foreach (var item in itemsTaken)
+ {
+ chest.Items.Remove(item);
+ }
+
+ // Send loot popup
+ if (takenLoot.Count > 0)
+ {
+ await SendLootPopupAsync(session, takenLoot);
+ }
+
+ // Check if chest is now empty
+ await CheckAndRemoveEmptyChestAsync(db, dungeon, chest, ct);
+
+ // Send updated inventory
+ await HandleInventoryRequest(connection, session, ct);
+
+ // If chest still has items, send updated state
+ if (!chest.IsEmpty)
+ {
+ var openPayload = System.Text.Json.JsonSerializer.SerializeToUtf8Bytes(
+ new LootChestOpenRequest { ChestId = request.ChestId });
+ await HandleLootChestOpen(connection, session, openPayload, ct);
+ }
+ }
+
+ ///
+ /// Handle closing a loot chest
+ ///
+ private async Task HandleLootChestClose(IConnection connection, DungeonPlayerSession session, ReadOnlyMemory payload, CancellationToken ct)
+ {
+ var json = System.Text.Encoding.UTF8.GetString(payload.Span);
+ var request = System.Text.Json.JsonSerializer.Deserialize(json);
+ if (request == null) return;
+
+ if (!session.CurrentDungeonId.HasValue ||
+ !_dungeons.TryGetValue(session.CurrentDungeonId.Value, out var dungeon))
+ return;
+
+ if (dungeon.Simulation.LootChests.TryGetValue(request.ChestId, out var chest))
+ {
+ if (chest.OwnerCharacterId == session.CharacterId)
+ {
+ chest.IsOpen = false;
+ }
+ }
+ }
+
+ ///
+ /// Check if a chest is empty and remove it if so
+ ///
+ private async Task CheckAndRemoveEmptyChestAsync(GameDbContext db, DungeonInstance dungeon, LootChestInstance chest, CancellationToken ct)
+ {
+ if (chest.IsEmpty)
+ {
+ // Update database
+ var dbChest = await db.DeathChests.FindAsync(new object[] { chest.DatabaseId }, ct);
+ if (dbChest != null)
+ {
+ dbChest.IsEmpty = true;
+ dbChest.EmptiedAt = DateTime.UtcNow;
+ await db.SaveChangesAsync(ct);
+ }
+
+ // Remove from runtime
+ dungeon.Simulation.LootChests.TryRemove(chest.Id, out _);
+
+ _log.LogInformation("Loot chest {ChestId} emptied and removed", chest.Id);
+ }
+ }
+
+ #endregion
+
///
/// Sends loot popup to client showing what they received
///
@@ -1208,6 +1928,19 @@ public sealed class DungeonHandler : IClientMessageHandler
type = p.Type.ToString().ToLower()
}),
+ // Loot chests are only visible to their owner
+ lootChests = sim.LootChests.Values
+ .Where(c => c.OwnerCharacterId == session.CharacterId)
+ .Select(c => new
+ {
+ id = c.Id,
+ x = c.X,
+ y = c.Y,
+ itemCount = c.Items.Count,
+ gold = c.Gold,
+ isOpen = c.IsOpen
+ }),
+
events = tickResult == null ? null : new
{
damage = tickResult.DamageEvents.Select(e => new
@@ -1369,7 +2102,8 @@ public sealed class DungeonHandler : IClientMessageHandler
dexterity = character.Dexterity,
maxHealth = DungeonCharacterStats.GetMaxHealth(character),
maxMana = DungeonCharacterStats.GetMaxMana(character),
- maxStamina = DungeonCharacterStats.GetMaxStamina(character)
+ maxStamina = DungeonCharacterStats.GetMaxStamina(character),
+ gold = character.Gold
}
};
}
@@ -1429,7 +2163,7 @@ public sealed class DungeonHandler : IClientMessageHandler
// In dungeon - broadcast to all players in same dungeon
foreach (var player in dungeon.Simulation.Players.Values)
{
-
+
await SendAsync(_playerSessions.Values.Where(p => p.CharacterId == player.CharacterId).FirstOrDefault().Connection, DungeonOpCodes.CHAT_MESSAGE, new
{
sender = senderName,
@@ -1454,7 +2188,7 @@ public sealed class DungeonHandler : IClientMessageHandler
_log.LogDebug("Chat from {Player}: {Message}", senderName, message);
}
-
+
///
/// Broadcast a system message to all players in a dungeon
///
@@ -1543,3 +2277,25 @@ public class PortalUseRequest
{
public int PortalId { get; set; }
}
+
+public class LootChestOpenRequest
+{
+ public int ChestId { get; set; }
+}
+
+public class LootChestTakeItemRequest
+{
+ public int ChestId { get; set; }
+ public int SlotIndex { get; set; }
+ public int TargetSlotIndex { get; set; } // Where to put it in player inventory (-1 for auto)
+}
+
+public class LootChestTakeAllRequest
+{
+ public int ChestId { get; set; }
+}
+
+public class LootChestCloseRequest
+{
+ public int ChestId { get; set; }
+}
diff --git a/Migrations/20251217153958_MobLoot2.Designer.cs b/Migrations/20251217153958_MobLoot2.Designer.cs
new file mode 100644
index 0000000..86b2327
--- /dev/null
+++ b/Migrations/20251217153958_MobLoot2.Designer.cs
@@ -0,0 +1,1765 @@
+//
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Server.Data;
+
+#nullable disable
+
+namespace SystemRevivalServer.Migrations
+{
+ [DbContext(typeof(GameDbContext))]
+ [Migration("20251217153958_MobLoot2")]
+ partial class MobLoot2
+ {
+ ///
+ protected override void BuildTargetModel(ModelBuilder modelBuilder)
+ {
+#pragma warning disable 612, 618
+ modelBuilder
+ .HasAnnotation("ProductVersion", "9.0.10")
+ .HasAnnotation("Relational:MaxIdentifierLength", 64);
+
+ MySqlModelBuilderExtensions.AutoIncrementColumns(modelBuilder);
+
+ modelBuilder.Entity("Server.Data.Account", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("bigint unsigned");
+
+ MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property("Id"));
+
+ b.Property("BannedUntil")
+ .HasColumnType("datetime(6)");
+
+ b.Property("CreatedAt")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("datetime(6)")
+ .HasDefaultValueSql("CURRENT_TIMESTAMP(6)");
+
+ b.Property("Email")
+ .HasMaxLength(255)
+ .HasColumnType("varchar(255)");
+
+ b.Property("IsBanned")
+ .HasColumnType("tinyint(1)");
+
+ b.Property("PasswordHash")
+ .IsRequired()
+ .HasColumnType("varbinary(64)");
+
+ b.Property("PasswordSalt")
+ .IsRequired()
+ .HasColumnType("varbinary(32)");
+
+ b.Property("Role")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("int")
+ .HasDefaultValue(0);
+
+ b.Property("UpdatedAt")
+ .ValueGeneratedOnAddOrUpdate()
+ .HasColumnType("datetime(6)")
+ .HasDefaultValueSql("CURRENT_TIMESTAMP(6)");
+
+ MySqlPropertyBuilderExtensions.UseMySqlComputedColumn(b.Property("UpdatedAt"));
+
+ b.Property("Username")
+ .IsRequired()
+ .HasMaxLength(32)
+ .HasColumnType("varchar(32)");
+
+ b.HasKey("Id");
+
+ b.HasIndex("Email")
+ .IsUnique();
+
+ b.HasIndex("Username")
+ .IsUnique();
+
+ b.ToTable("accounts", (string)null);
+ });
+
+ modelBuilder.Entity("Server.Data.Entities.DeathChest", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("bigint unsigned");
+
+ MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property("Id"));
+
+ b.Property("CreatedAt")
+ .HasColumnType("datetime(6)");
+
+ b.Property("DungeonInstanceId")
+ .HasColumnType("char(36)");
+
+ b.Property("EmptiedAt")
+ .HasColumnType("datetime(6)");
+
+ b.Property("GoldAmount")
+ .HasColumnType("bigint");
+
+ b.Property("IsEmpty")
+ .HasColumnType("tinyint(1)");
+
+ b.Property("OwnerCharacterId")
+ .HasColumnType("bigint unsigned");
+
+ b.Property("VictimCharacterId")
+ .HasColumnType("bigint unsigned");
+
+ b.Property("VictimMobDefinitionId")
+ .HasColumnType("int");
+
+ b.Property("X")
+ .HasColumnType("float");
+
+ b.Property("Y")
+ .HasColumnType("float");
+
+ b.HasKey("Id");
+
+ b.HasIndex("OwnerCharacterId");
+
+ b.HasIndex("VictimCharacterId");
+
+ b.ToTable("dungeon_death_chests");
+ });
+
+ modelBuilder.Entity("Server.Data.Entities.DeathChestItem", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("bigint unsigned");
+
+ MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property("Id"));
+
+ b.Property("DeathChestId")
+ .HasColumnType("bigint unsigned");
+
+ b.Property("IsTaken")
+ .HasColumnType("tinyint(1)");
+
+ b.Property("ItemDefinitionId")
+ .HasColumnType("int");
+
+ b.Property("Quantity")
+ .HasColumnType("int");
+
+ b.Property("SlotIndex")
+ .HasColumnType("int");
+
+ b.Property("TakenAt")
+ .HasColumnType("datetime(6)");
+
+ b.HasKey("Id");
+
+ b.HasIndex("DeathChestId");
+
+ b.HasIndex("ItemDefinitionId");
+
+ b.ToTable("dungeon_death_chest_items");
+ });
+
+ modelBuilder.Entity("Server.Data.Entities.DungeonBeltItem", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("bigint unsigned");
+
+ MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property("Id"));
+
+ b.Property("CharacterId")
+ .HasColumnType("bigint unsigned");
+
+ b.Property("InventorySlotIndex")
+ .HasColumnType("int");
+
+ b.Property("SlotIndex")
+ .HasColumnType("int");
+
+ b.HasKey("Id");
+
+ b.HasIndex("CharacterId");
+
+ b.ToTable("dungeon_belt_items");
+ });
+
+ modelBuilder.Entity("Server.Data.Entities.DungeonCharacter", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("bigint unsigned");
+
+ MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property("Id"));
+
+ b.Property("AccountId")
+ .HasColumnType("bigint unsigned");
+
+ b.Property("BossesKilled")
+ .HasColumnType("int");
+
+ b.Property("CreatedAt")
+ .HasColumnType("datetime(6)");
+
+ b.Property("CurrentHealth")
+ .HasColumnType("int");
+
+ b.Property("CurrentMana")
+ .HasColumnType("int");
+
+ b.Property("Dexterity")
+ .HasColumnType("int");
+
+ b.Property("DungeonsCompleted")
+ .HasColumnType("int");
+
+ b.Property("Endurance")
+ .HasColumnType("int");
+
+ b.Property("EquippedAccessory")
+ .HasColumnType("bigint unsigned");
+
+ b.Property("EquippedBoots")
+ .HasColumnType("bigint unsigned");
+
+ b.Property("EquippedChest")
+ .HasColumnType("bigint unsigned");
+
+ b.Property("EquippedGloves")
+ .HasColumnType("bigint unsigned");
+
+ b.Property("EquippedHead")
+ .HasColumnType("bigint unsigned");
+
+ b.Property("EquippedLegs")
+ .HasColumnType("bigint unsigned");
+
+ b.Property("EquippedOffhand")
+ .HasColumnType("bigint unsigned");
+
+ b.Property("EquippedWeapon")
+ .HasColumnType("bigint unsigned");
+
+ b.Property("Experience")
+ .HasColumnType("bigint");
+
+ b.Property("Gold")
+ .HasColumnType("bigint");
+
+ b.Property("Intelligence")
+ .HasColumnType("int");
+
+ b.Property("IsDeleted")
+ .HasColumnType("tinyint(1)");
+
+ b.Property("LastPlayedAt")
+ .HasColumnType("datetime(6)");
+
+ b.Property("Level")
+ .HasColumnType("int");
+
+ b.Property("Name")
+ .IsRequired()
+ .HasMaxLength(32)
+ .HasColumnType("varchar(32)");
+
+ b.Property("PlayersKilled")
+ .HasColumnType("int");
+
+ b.Property("Strength")
+ .HasColumnType("int");
+
+ b.Property("TotalDeaths")
+ .HasColumnType("int");
+
+ b.Property("TotalKills")
+ .HasColumnType("int");
+
+ b.Property("UnspentStatPoints")
+ .HasColumnType("int");
+
+ b.Property("Wisdom")
+ .HasColumnType("int");
+
+ b.HasKey("Id");
+
+ b.HasIndex("AccountId");
+
+ b.ToTable("dungeon_characters");
+ });
+
+ modelBuilder.Entity("Server.Data.Entities.DungeonCharacterItem", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("bigint unsigned");
+
+ MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property("Id"));
+
+ b.Property("AcquiredAt")
+ .HasColumnType("datetime(6)");
+
+ b.Property("CharacterId")
+ .HasColumnType("bigint unsigned");
+
+ b.Property("EquipSlot")
+ .HasColumnType("int");
+
+ b.Property("IsEquipped")
+ .HasColumnType("tinyint(1)");
+
+ b.Property("ItemDefinitionId")
+ .HasColumnType("int");
+
+ b.Property("Quantity")
+ .HasColumnType("int");
+
+ b.Property("SlotIndex")
+ .HasColumnType("int");
+
+ b.HasKey("Id");
+
+ b.HasIndex("CharacterId");
+
+ b.HasIndex("ItemDefinitionId");
+
+ b.ToTable("dungeon_character_items");
+ });
+
+ modelBuilder.Entity("Server.Data.Entities.DungeonItemDefinition", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("int");
+
+ MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property("Id"));
+
+ b.Property("Armor")
+ .HasColumnType("int");
+
+ b.Property("AttackRange")
+ .HasColumnType("float");
+
+ b.Property("BonusDexterity")
+ .HasColumnType("int");
+
+ b.Property("BonusEndurance")
+ .HasColumnType("int");
+
+ b.Property("BonusHealth")
+ .HasColumnType("int");
+
+ b.Property("BonusIntelligence")
+ .HasColumnType("int");
+
+ b.Property("BonusMana")
+ .HasColumnType("int");
+
+ b.Property("BonusStrength")
+ .HasColumnType("int");
+
+ b.Property("BonusWisdom")
+ .HasColumnType("int");
+
+ b.Property("DamageType")
+ .HasColumnType("int");
+
+ b.Property("Description")
+ .IsRequired()
+ .HasMaxLength(256)
+ .HasColumnType("varchar(256)");
+
+ b.Property("EquipSlot")
+ .HasColumnType("int");
+
+ b.Property("HealAmount")
+ .HasColumnType("int");
+
+ b.Property("IsEnabled")
+ .HasColumnType("tinyint(1)");
+
+ b.Property("IsTeleportScroll")
+ .HasColumnType("tinyint(1)");
+
+ b.Property("MagicResist")
+ .HasColumnType("int");
+
+ b.Property("ManaRestore")
+ .HasColumnType("int");
+
+ b.Property("MaxDamage")
+ .HasColumnType("int");
+
+ b.Property("MaxStack")
+ .HasColumnType("int");
+
+ b.Property("MinDamage")
+ .HasColumnType("int");
+
+ b.Property("Name")
+ .IsRequired()
+ .HasMaxLength(64)
+ .HasColumnType("varchar(64)");
+
+ b.Property("Rarity")
+ .HasColumnType("int");
+
+ b.Property("RequiredDexterity")
+ .HasColumnType("int");
+
+ b.Property("RequiredIntelligence")
+ .HasColumnType("int");
+
+ b.Property("RequiredLevel")
+ .HasColumnType("int");
+
+ b.Property("RequiredStrength")
+ .HasColumnType("int");
+
+ b.Property("RequiredWisdom")
+ .HasColumnType("int");
+
+ b.Property("SpriteId")
+ .HasColumnType("int");
+
+ b.Property("Stackable")
+ .HasColumnType("tinyint(1)");
+
+ b.Property("StaminaRestore")
+ .HasColumnType("int");
+
+ b.Property("TeachesSpellId")
+ .HasColumnType("int");
+
+ b.Property("Type")
+ .HasColumnType("int");
+
+ b.HasKey("Id");
+
+ b.ToTable("dungeon_item_definitions");
+ });
+
+ modelBuilder.Entity("Server.Data.Entities.DungeonLearnedSpell", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("bigint unsigned");
+
+ MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property("Id"));
+
+ b.Property("CharacterId")
+ .HasColumnType("bigint unsigned");
+
+ b.Property("DefinitionId")
+ .HasColumnType("int");
+
+ b.Property("LearnedAt")
+ .HasColumnType("datetime(6)");
+
+ b.Property("SpellDefinitionId")
+ .HasColumnType("int");
+
+ b.Property("SpellLevel")
+ .HasColumnType("int");
+
+ b.HasKey("Id");
+
+ b.HasIndex("CharacterId");
+
+ b.HasIndex("DefinitionId");
+
+ b.ToTable("dungeon_learned_spells");
+ });
+
+ modelBuilder.Entity("Server.Data.Entities.DungeonLootTable", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("int");
+
+ MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property("Id"));
+
+ b.Property("Description")
+ .IsRequired()
+ .HasMaxLength(256)
+ .HasColumnType("varchar(256)");
+
+ b.Property("DropChanceMultiplier")
+ .HasColumnType("float");
+
+ b.Property("GuaranteedDrop")
+ .HasColumnType("tinyint(1)");
+
+ b.Property("IsEnabled")
+ .HasColumnType("tinyint(1)");
+
+ b.Property("MaxDrops")
+ .HasColumnType("int");
+
+ b.Property("MaxTier")
+ .HasColumnType("int");
+
+ b.Property("MinDrops")
+ .HasColumnType("int");
+
+ b.Property("MinTier")
+ .HasColumnType("int");
+
+ b.Property("Name")
+ .IsRequired()
+ .HasMaxLength(64)
+ .HasColumnType("varchar(64)");
+
+ b.HasKey("Id");
+
+ b.ToTable("dungeon_loot_tables");
+ });
+
+ modelBuilder.Entity("Server.Data.Entities.DungeonLootTableEntry", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("int");
+
+ MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property("Id"));
+
+ b.Property("DropChance")
+ .HasColumnType("float");
+
+ b.Property("DropChancePerTier")
+ .HasColumnType("float");
+
+ b.Property("Guaranteed")
+ .HasColumnType("tinyint(1)");
+
+ b.Property("ItemDefinitionId")
+ .HasColumnType("int");
+
+ b.Property("LootTableId")
+ .HasColumnType("int");
+
+ b.Property("MaxDropChance")
+ .HasColumnType("float");
+
+ b.Property("MaxQuantity")
+ .HasColumnType("int");
+
+ b.Property("MinQuantity")
+ .HasColumnType("int");
+
+ b.Property("Weight")
+ .HasColumnType("int");
+
+ b.HasKey("Id");
+
+ b.HasIndex("ItemDefinitionId");
+
+ b.HasIndex("LootTableId");
+
+ b.ToTable("dungeon_loot_table_entries");
+ });
+
+ modelBuilder.Entity("Server.Data.Entities.DungeonMobDefinition", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("int");
+
+ MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property("Id"));
+
+ b.Property("AbilitiesJson")
+ .IsRequired()
+ .HasMaxLength(1024)
+ .HasColumnType("varchar(1024)");
+
+ b.Property("AggroRange")
+ .HasColumnType("float");
+
+ b.Property("AnimationSpeed")
+ .HasColumnType("float");
+
+ b.Property("ArmorPerTier")
+ .HasColumnType("float");
+
+ b.Property("AttackFrames")
+ .IsRequired()
+ .HasMaxLength(256)
+ .HasColumnType("varchar(256)");
+
+ b.Property("AttackRange")
+ .HasColumnType("float");
+
+ b.Property("AttackSpeed")
+ .HasColumnType("float");
+
+ b.Property("BaseArmor")
+ .HasColumnType("int");
+
+ b.Property("BaseHealth")
+ .HasColumnType("int");
+
+ b.Property("BaseMagicDamage")
+ .HasColumnType("int");
+
+ b.Property("BaseMagicResist")
+ .HasColumnType("int");
+
+ b.Property("BaseMana")
+ .HasColumnType("int");
+
+ b.Property("BasePhysicalDamage")
+ .HasColumnType("int");
+
+ b.Property("BaseXp")
+ .HasColumnType("int");
+
+ b.Property("Category")
+ .HasColumnType("int");
+
+ b.Property("DamagePerTier")
+ .HasColumnType("float");
+
+ b.Property("DeathFrames")
+ .IsRequired()
+ .HasMaxLength(256)
+ .HasColumnType("varchar(256)");
+
+ b.Property("Description")
+ .IsRequired()
+ .HasMaxLength(256)
+ .HasColumnType("varchar(256)");
+
+ b.Property("DropChanceMultiplier")
+ .HasColumnType("float");
+
+ b.Property("HealthPerTier")
+ .HasColumnType("float");
+
+ b.Property("IdleFrames")
+ .IsRequired()
+ .HasMaxLength(256)
+ .HasColumnType("varchar(256)");
+
+ b.Property("IsEnabled")
+ .HasColumnType("tinyint(1)");
+
+ b.Property("LeashRange")
+ .HasColumnType("float");
+
+ b.Property("LootTableId")
+ .HasColumnType("int");
+
+ b.Property("MaxTier")
+ .HasColumnType("int");
+
+ b.Property("MinTier")
+ .HasColumnType("int");
+
+ b.Property("MoveSpeed")
+ .HasColumnType("float");
+
+ b.Property("Name")
+ .IsRequired()
+ .HasMaxLength(64)
+ .HasColumnType("varchar(64)");
+
+ b.Property("ResistancesJson")
+ .IsRequired()
+ .HasMaxLength(1024)
+ .HasColumnType("varchar(1024)");
+
+ b.Property("SpriteHeight")
+ .HasColumnType("int");
+
+ b.Property("SpriteIndex")
+ .HasColumnType("int");
+
+ b.Property("SpriteSheet")
+ .IsRequired()
+ .HasMaxLength(128)
+ .HasColumnType("varchar(128)");
+
+ b.Property("SpriteWidth")
+ .HasColumnType("int");
+
+ b.Property("TintColor")
+ .IsRequired()
+ .HasMaxLength(16)
+ .HasColumnType("varchar(16)");
+
+ b.Property("Type")
+ .HasColumnType("int");
+
+ b.Property("WalkFrames")
+ .IsRequired()
+ .HasMaxLength(256)
+ .HasColumnType("varchar(256)");
+
+ b.Property("XpPerTier")
+ .HasColumnType("float");
+
+ b.HasKey("Id");
+
+ b.ToTable("dungeon_mob_definitions");
+ });
+
+ modelBuilder.Entity("Server.Data.Entities.DungeonMobLootTable", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("int");
+
+ MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property("Id"));
+
+ b.Property("LootTableId")
+ .HasColumnType("int");
+
+ b.Property("MobDefinitionId")
+ .HasColumnType("int");
+
+ b.Property("Priority")
+ .HasColumnType("int");
+
+ b.Property("RollChance")
+ .HasColumnType("float");
+
+ b.HasKey("Id");
+
+ b.HasIndex("LootTableId");
+
+ b.HasIndex("MobDefinitionId");
+
+ b.ToTable("dungeon_mob_loot_tables");
+ });
+
+ modelBuilder.Entity("Server.Data.Entities.DungeonSpellDefinition", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("int");
+
+ MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property("Id"));
+
+ b.Property("AreaOfEffect")
+ .HasColumnType("float");
+
+ b.Property("BaseDamage")
+ .HasColumnType("int");
+
+ b.Property("BaseHealing")
+ .HasColumnType("int");
+
+ b.Property("Cooldown")
+ .HasColumnType("float");
+
+ b.Property("Description")
+ .IsRequired()
+ .HasMaxLength(256)
+ .HasColumnType("varchar(256)");
+
+ b.Property("EffectColor")
+ .IsRequired()
+ .HasColumnType("longtext");
+
+ b.Property("IsEnabled")
+ .HasColumnType("tinyint(1)");
+
+ b.Property("IsShield")
+ .HasColumnType("tinyint(1)");
+
+ b.Property("IsTeleport")
+ .HasColumnType("tinyint(1)");
+
+ b.Property("ManaCost")
+ .HasColumnType("int");
+
+ b.Property("Name")
+ .IsRequired()
+ .HasMaxLength(64)
+ .HasColumnType("varchar(64)");
+
+ b.Property("Range")
+ .HasColumnType("float");
+
+ b.Property("RequiredIntelligence")
+ .HasColumnType("int");
+
+ b.Property("RequiredLevel")
+ .HasColumnType("int");
+
+ b.Property("RequiredWisdom")
+ .HasColumnType("int");
+
+ b.Property("ShieldAmount")
+ .HasColumnType("int");
+
+ b.Property("SpriteId")
+ .HasColumnType("int");
+
+ b.Property("Type")
+ .HasColumnType("int");
+
+ b.HasKey("Id");
+
+ b.ToTable("dungeon_spell_definitions");
+ });
+
+ modelBuilder.Entity("Server.Data.Entities.DungeonStashItem", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("bigint unsigned");
+
+ MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property("Id"));
+
+ b.Property("CharacterId")
+ .HasColumnType("bigint unsigned");
+
+ b.Property("DefinitionId")
+ .HasColumnType("int");
+
+ b.Property("ItemDefinitionId")
+ .HasColumnType("int");
+
+ b.Property("Quantity")
+ .HasColumnType("int");
+
+ b.Property