Fix Deathchests

This commit is contained in:
dingo
2025-12-17 12:49:34 -05:00
parent 959590b030
commit fe594fce80
7 changed files with 4589 additions and 45 deletions
+801 -45
View File
@@ -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
}
}
/// <summary>
/// Process loot when a mob dies
/// Process loot when a mob dies - includes normal loot roll plus any carried player loot
/// </summary>
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<LootDrop>(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<GameDbContext>();
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<DungeonItemDefinition>()
.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
}
/// <summary>
/// Adds loot directly to player's inventory in the database
/// Process player death - transfer inventory and 10% gold to killer
/// </summary>
private async Task AddLootToInventoryAsync(DungeonPlayerSession session, List<LootDrop> 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<GameDbContext>();
// Get victim's inventory (non-equipped items only)
var victimInventory = await db.Set<DungeonCharacterItem>()
.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<DungeonCharacterItem>().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");
}
}
/// <summary>
/// Transfer carried loot directly to a player (from PvP kill)
/// </summary>
private async Task TransferPlayerLootToPlayerAsync(DungeonInstance dungeon, DungeonPlayerSession killer,
CarriedLoot loot, float x, float y)
{
using var scope = _scopeFactory.CreateScope();
var db = scope.ServiceProvider.GetRequiredService<GameDbContext>();
// Convert carried items to LootDrops
var lootDrops = new List<LootDrop>();
foreach (var item in loot.Items)
{
var itemDef = await db.Set<DungeonItemDefinition>()
.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);
}
/// <summary>
/// Send notification to victim about what they lost on death
/// </summary>
private async Task SendDeathLootLostNotificationAsync(DungeonPlayerSession victim,
List<DungeonCharacterItem> 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);
}
/// <summary>
/// Add loot to inventory, returning what was added and what overflowed
/// </summary>
private async Task<(List<LootDrop> added, List<LootDrop> overflow, long overflowGold)>
AddLootToInventoryWithOverflowAsync(DungeonPlayerSession session, List<LootDrop> loot, long gold)
{
var added = new List<LootDrop>();
var overflow = new List<LootDrop>();
long overflowGold = 0;
using var scope = _scopeFactory.CreateScope();
var db = scope.ServiceProvider.GetRequiredService<GameDbContext>();
// Get existing inventory items
var existingItems = await db.Set<DungeonCharacterItem>()
.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<DungeonCharacterItem>().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<DungeonCharacterItem>().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);
}
/// <summary>
/// Spawn a personal loot chest for overflow items
/// </summary>
private async Task SpawnLootChestAsync(DungeonInstance dungeon, DungeonPlayerSession owner,
List<LootDrop> items, long gold, float x, float y, ulong? victimCharacterId, int? victimMobId)
{
using var scope = _scopeFactory.CreateScope();
var db = scope.ServiceProvider.GetRequiredService<GameDbContext>();
// 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);
}
/// <summary>
/// Adds loot directly to player's inventory in the database (legacy - kept for compatibility)
/// </summary>
private async Task AddLootToInventoryAsync(DungeonPlayerSession session, List<LootDrop> loot)
{
var (_, _, _) = await AddLootToInventoryWithOverflowAsync(session, loot, 0);
}
#region Loot Chest Handlers
/// <summary>
/// Handle opening a loot chest
/// </summary>
private async Task HandleLootChestOpen(IConnection connection, DungeonPlayerSession session, ReadOnlyMemory<byte> payload, CancellationToken ct)
{
var json = System.Text.Encoding.UTF8.GetString(payload.Span);
var request = System.Text.Json.JsonSerializer.Deserialize<LootChestOpenRequest>(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<GameDbContext>();
var itemDefIds = chest.Items.Select(i => i.ItemDefinitionId).Distinct().ToList();
var itemDefs = await db.Set<DungeonItemDefinition>()
.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);
}
/// <summary>
/// Handle taking a single item from loot chest
/// </summary>
private async Task HandleLootChestTakeItem(IConnection connection, DungeonPlayerSession session, ReadOnlyMemory<byte> payload, CancellationToken ct)
{
var json = System.Text.Encoding.UTF8.GetString(payload.Span);
var request = System.Text.Json.JsonSerializer.Deserialize<LootChestTakeItemRequest>(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<GameDbContext>();
// Get item definition
var itemDef = await db.Set<DungeonItemDefinition>()
.FirstOrDefaultAsync(d => d.Id == chestItem.ItemDefinitionId, ct);
if (itemDef == null) return;
// Get player's current inventory
var existingItems = await db.Set<DungeonCharacterItem>()
.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<DungeonCharacterItem>().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
}
/// <summary>
/// Handle taking all items from loot chest
/// </summary>
private async Task HandleLootChestTakeAll(IConnection connection, DungeonPlayerSession session, ReadOnlyMemory<byte> payload, CancellationToken ct)
{
var json = System.Text.Encoding.UTF8.GetString(payload.Span);
var request = System.Text.Json.JsonSerializer.Deserialize<LootChestTakeAllRequest>(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<GameDbContext>();
// Get player's current inventory
var existingItems = await db.Set<DungeonCharacterItem>()
.Where(i => i.CharacterId == session.CharacterId && !i.IsEquipped)
.ToListAsync(ct);
var usedSlots = existingItems.Select(i => i.SlotIndex).ToHashSet();
var itemsTaken = new List<LootChestItem>();
var takenLoot = new List<LootDrop>();
// 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<DungeonItemDefinition>()
.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<DungeonCharacterItem>().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);
}
}
/// <summary>
/// Handle closing a loot chest
/// </summary>
private async Task HandleLootChestClose(IConnection connection, DungeonPlayerSession session, ReadOnlyMemory<byte> payload, CancellationToken ct)
{
var json = System.Text.Encoding.UTF8.GetString(payload.Span);
var request = System.Text.Json.JsonSerializer.Deserialize<LootChestCloseRequest>(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;
}
}
}
/// <summary>
/// Check if a chest is empty and remove it if so
/// </summary>
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
/// <summary>
/// Sends loot popup to client showing what they received
/// </summary>
@@ -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);
}
/// <summary>
/// Broadcast a system message to all players in a dungeon
/// </summary>
@@ -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; }
}
File diff suppressed because it is too large Load Diff
+111
View File
@@ -0,0 +1,111 @@
using System;
using Microsoft.EntityFrameworkCore.Metadata;
using Microsoft.EntityFrameworkCore.Migrations;
#nullable disable
namespace SystemRevivalServer.Migrations
{
/// <inheritdoc />
public partial class MobLoot2 : Migration
{
/// <inheritdoc />
protected override void Up(MigrationBuilder migrationBuilder)
{
migrationBuilder.CreateTable(
name: "dungeon_death_chests",
columns: table => new
{
Id = table.Column<ulong>(type: "bigint unsigned", nullable: false)
.Annotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn),
DungeonInstanceId = table.Column<Guid>(type: "char(36)", nullable: false, collation: "ascii_general_ci"),
OwnerCharacterId = table.Column<ulong>(type: "bigint unsigned", nullable: false),
VictimCharacterId = table.Column<ulong>(type: "bigint unsigned", nullable: true),
VictimMobDefinitionId = table.Column<int>(type: "int", nullable: true),
X = table.Column<float>(type: "float", nullable: false),
Y = table.Column<float>(type: "float", nullable: false),
GoldAmount = table.Column<long>(type: "bigint", nullable: false),
CreatedAt = table.Column<DateTime>(type: "datetime(6)", nullable: false),
EmptiedAt = table.Column<DateTime>(type: "datetime(6)", nullable: true),
IsEmpty = table.Column<bool>(type: "tinyint(1)", nullable: false)
},
constraints: table =>
{
table.PrimaryKey("PK_dungeon_death_chests", x => x.Id);
table.ForeignKey(
name: "FK_dungeon_death_chests_dungeon_characters_OwnerCharacterId",
column: x => x.OwnerCharacterId,
principalTable: "dungeon_characters",
principalColumn: "Id",
onDelete: ReferentialAction.Cascade);
table.ForeignKey(
name: "FK_dungeon_death_chests_dungeon_characters_VictimCharacterId",
column: x => x.VictimCharacterId,
principalTable: "dungeon_characters",
principalColumn: "Id");
})
.Annotation("MySql:CharSet", "utf8mb4");
migrationBuilder.CreateTable(
name: "dungeon_death_chest_items",
columns: table => new
{
Id = table.Column<ulong>(type: "bigint unsigned", nullable: false)
.Annotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn),
DeathChestId = table.Column<ulong>(type: "bigint unsigned", nullable: false),
ItemDefinitionId = table.Column<int>(type: "int", nullable: false),
Quantity = table.Column<int>(type: "int", nullable: false),
SlotIndex = table.Column<int>(type: "int", nullable: false),
IsTaken = table.Column<bool>(type: "tinyint(1)", nullable: false),
TakenAt = table.Column<DateTime>(type: "datetime(6)", nullable: true)
},
constraints: table =>
{
table.PrimaryKey("PK_dungeon_death_chest_items", x => x.Id);
table.ForeignKey(
name: "FK_dungeon_death_chest_items_dungeon_death_chests_DeathChestId",
column: x => x.DeathChestId,
principalTable: "dungeon_death_chests",
principalColumn: "Id",
onDelete: ReferentialAction.Cascade);
table.ForeignKey(
name: "FK_dungeon_death_chest_items_dungeon_item_definitions_ItemDefin~",
column: x => x.ItemDefinitionId,
principalTable: "dungeon_item_definitions",
principalColumn: "Id",
onDelete: ReferentialAction.Cascade);
})
.Annotation("MySql:CharSet", "utf8mb4");
migrationBuilder.CreateIndex(
name: "IX_dungeon_death_chest_items_DeathChestId",
table: "dungeon_death_chest_items",
column: "DeathChestId");
migrationBuilder.CreateIndex(
name: "IX_dungeon_death_chest_items_ItemDefinitionId",
table: "dungeon_death_chest_items",
column: "ItemDefinitionId");
migrationBuilder.CreateIndex(
name: "IX_dungeon_death_chests_OwnerCharacterId",
table: "dungeon_death_chests",
column: "OwnerCharacterId");
migrationBuilder.CreateIndex(
name: "IX_dungeon_death_chests_VictimCharacterId",
table: "dungeon_death_chests",
column: "VictimCharacterId");
}
/// <inheritdoc />
protected override void Down(MigrationBuilder migrationBuilder)
{
migrationBuilder.DropTable(
name: "dungeon_death_chest_items");
migrationBuilder.DropTable(
name: "dungeon_death_chests");
}
}
}
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,22 @@
using Microsoft.EntityFrameworkCore.Migrations;
#nullable disable
namespace SystemRevivalServer.Migrations
{
/// <inheritdoc />
public partial class fixdeathchests : Migration
{
/// <inheritdoc />
protected override void Up(MigrationBuilder migrationBuilder)
{
}
/// <inheritdoc />
protected override void Down(MigrationBuilder migrationBuilder)
{
}
}
}
+123
View File
@@ -81,6 +81,88 @@ namespace SystemRevivalServer.Migrations
b.ToTable("accounts", (string)null);
});
modelBuilder.Entity("Server.Data.Entities.DeathChest", b =>
{
b.Property<ulong>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("bigint unsigned");
MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<ulong>("Id"));
b.Property<DateTime>("CreatedAt")
.HasColumnType("datetime(6)");
b.Property<Guid>("DungeonInstanceId")
.HasColumnType("char(36)");
b.Property<DateTime?>("EmptiedAt")
.HasColumnType("datetime(6)");
b.Property<long>("GoldAmount")
.HasColumnType("bigint");
b.Property<bool>("IsEmpty")
.HasColumnType("tinyint(1)");
b.Property<ulong>("OwnerCharacterId")
.HasColumnType("bigint unsigned");
b.Property<ulong?>("VictimCharacterId")
.HasColumnType("bigint unsigned");
b.Property<int?>("VictimMobDefinitionId")
.HasColumnType("int");
b.Property<float>("X")
.HasColumnType("float");
b.Property<float>("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<ulong>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("bigint unsigned");
MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<ulong>("Id"));
b.Property<ulong>("DeathChestId")
.HasColumnType("bigint unsigned");
b.Property<bool>("IsTaken")
.HasColumnType("tinyint(1)");
b.Property<int>("ItemDefinitionId")
.HasColumnType("int");
b.Property<int>("Quantity")
.HasColumnType("int");
b.Property<int>("SlotIndex")
.HasColumnType("int");
b.Property<DateTime?>("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<ulong>("Id")
@@ -1399,6 +1481,42 @@ namespace SystemRevivalServer.Migrations
b.ToTable("zones", (string)null);
});
modelBuilder.Entity("Server.Data.Entities.DeathChest", b =>
{
b.HasOne("Server.Data.Entities.DungeonCharacter", "OwnerCharacter")
.WithMany()
.HasForeignKey("OwnerCharacterId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
b.HasOne("Server.Data.Entities.DungeonCharacter", "VictimCharacter")
.WithMany()
.HasForeignKey("VictimCharacterId");
b.Navigation("OwnerCharacter");
b.Navigation("VictimCharacter");
});
modelBuilder.Entity("Server.Data.Entities.DeathChestItem", b =>
{
b.HasOne("Server.Data.Entities.DeathChest", "DeathChest")
.WithMany("Items")
.HasForeignKey("DeathChestId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
b.HasOne("Server.Data.Entities.DungeonItemDefinition", "ItemDefinition")
.WithMany()
.HasForeignKey("ItemDefinitionId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
b.Navigation("DeathChest");
b.Navigation("ItemDefinition");
});
modelBuilder.Entity("Server.Data.Entities.DungeonBeltItem", b =>
{
b.HasOne("Server.Data.Entities.DungeonCharacter", "Character")
@@ -1620,6 +1738,11 @@ namespace SystemRevivalServer.Migrations
b.Navigation("Sessions");
});
modelBuilder.Entity("Server.Data.Entities.DeathChest", b =>
{
b.Navigation("Items");
});
modelBuilder.Entity("Server.Data.Entities.DungeonCharacter", b =>
{
b.Navigation("Inventory");
+2
View File
@@ -32,6 +32,8 @@ public sealed class GameDbContext : DbContext
public DbSet<DungeonLootTableEntry> DungeonLootTableEntries => Set<DungeonLootTableEntry>();
public DbSet<DungeonMobLootTable> DungeonMobLootTables => Set<DungeonMobLootTable>();
public DbSet<DungeonBeltItem> DungeonBeltItems => Set<DungeonBeltItem>();
public DbSet<DeathChest> DeathChests => Set<DeathChest>();
public DbSet<DeathChestItem> DeathChestItems => Set<DeathChestItem>();
protected override void OnModelCreating(ModelBuilder b)
{
b.ApplyConfigurationsFromAssembly(typeof(GameDbContext).Assembly);