projectiles
This commit is contained in:
@@ -89,6 +89,7 @@ public sealed partial class DungeonHandler : IClientMessageHandler
|
||||
DungeonOpCodes.DUNGEON_INPUT_PICKUP,
|
||||
DungeonOpCodes.DUNGEON_INPUT_CHEST,
|
||||
DungeonOpCodes.DUNGEON_INPUT_PORTAL,
|
||||
DungeonOpCodes.DUNGEON_INPUT_FIRE_PROJECTILE,
|
||||
DungeonOpCodes.INVENTORY_REQUEST,
|
||||
DungeonOpCodes.EQUIP_ITEM,
|
||||
DungeonOpCodes.UNEQUIP_ITEM,
|
||||
@@ -327,6 +328,10 @@ public sealed partial class DungeonHandler : IClientMessageHandler
|
||||
await HandlePortalUse(connection, session, payload, ct);
|
||||
break;
|
||||
|
||||
case DungeonOpCodes.DUNGEON_INPUT_FIRE_PROJECTILE:
|
||||
await HandleFireProjectile(connection, session, payload, ct);
|
||||
break;
|
||||
|
||||
case DungeonOpCodes.INVENTORY_REQUEST:
|
||||
await HandleInventoryRequest(connection, session, ct);
|
||||
break;
|
||||
@@ -997,6 +1002,236 @@ public sealed partial class DungeonHandler : IClientMessageHandler
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Handle projectile firing - validates weapon, consumes ammunition, creates projectile
|
||||
/// </summary>
|
||||
private async Task HandleFireProjectile(IConnection connection, DungeonPlayerSession session, ReadOnlyMemory<byte> payload, CancellationToken ct)
|
||||
{
|
||||
if (session.PlayerInstance == null) return;
|
||||
if (session.State != PlayerState.InDungeon || !session.CurrentDungeonId.HasValue) return;
|
||||
if (!_dungeons.TryGetValue(session.CurrentDungeonId.Value, out var dungeon)) return;
|
||||
|
||||
var input = _ser.Deserialize<FireProjectileInput>(payload);
|
||||
var player = session.PlayerInstance;
|
||||
|
||||
// Normalize direction vector
|
||||
float magnitude = MathF.Sqrt(input.DirectionX * input.DirectionX + input.DirectionY * input.DirectionY);
|
||||
if (magnitude < 0.01f) return; // Invalid direction
|
||||
|
||||
float dirX = input.DirectionX / magnitude;
|
||||
float dirY = input.DirectionY / magnitude;
|
||||
|
||||
using var scope = _scopeFactory.CreateScope();
|
||||
var db = scope.ServiceProvider.GetRequiredService<GameDbContext>();
|
||||
|
||||
// Get equipped weapon
|
||||
var weaponItemId = session.Character.EquippedWeapon;
|
||||
if (!weaponItemId.HasValue) return;
|
||||
|
||||
var weaponItem = await db.DungeonCharacterItems
|
||||
.Include(i => i.ItemDefinition)
|
||||
.FirstOrDefaultAsync(i => i.Id == weaponItemId.Value, ct);
|
||||
|
||||
if (weaponItem?.ItemDefinition == null) return;
|
||||
var weapon = weaponItem.ItemDefinition;
|
||||
|
||||
// Handle throwable weapons (consume from inventory)
|
||||
if (weapon.IsThrowable)
|
||||
{
|
||||
await HandleThrowableProjectile(session, dungeon, weapon, dirX, dirY, ct);
|
||||
return;
|
||||
}
|
||||
|
||||
// Handle ranged weapons (require ammunition)
|
||||
if (!weapon.RequiresAmmunition || weapon.ProjectileSpeed <= 0) return;
|
||||
|
||||
// Get ammunition from quiver
|
||||
var ammo = await ConsumeAmmunitionFromQuiver(session, weapon.AmmunitionType, db, ct);
|
||||
if (ammo == null)
|
||||
{
|
||||
// No ammo available - could send error message to client
|
||||
_log.LogDebug("Player {Name} tried to fire {Weapon} but has no {AmmoType} ammunition",
|
||||
session.Character.Name, weapon.Name, weapon.AmmunitionType);
|
||||
return;
|
||||
}
|
||||
|
||||
// Calculate damage (STR 30% + DEX 70%)
|
||||
int weaponDamage = Random.Shared.Next(weapon.MinDamage, weapon.MaxDamage + 1);
|
||||
int ammoDamage = Random.Shared.Next(ammo.MinDamage, ammo.MaxDamage + 1);
|
||||
int baseDamage = weaponDamage + ammoDamage;
|
||||
|
||||
float statModifier = (session.Character.Strength * 0.3f + session.Character.Dexterity * 0.7f);
|
||||
float statBonus = baseDamage * (statModifier / 100f);
|
||||
int totalDamage = (int)(baseDamage + statBonus);
|
||||
|
||||
// Create projectile
|
||||
var projectile = new ProjectileInstance
|
||||
{
|
||||
Id = dungeon.Simulation.GetNextProjectileId(),
|
||||
SourceType = ProjectileSource.Player,
|
||||
SourcePlayerId = session.CharacterId,
|
||||
X = player.X,
|
||||
Y = player.Y,
|
||||
VelocityX = dirX * weapon.ProjectileSpeed,
|
||||
VelocityY = dirY * weapon.ProjectileSpeed,
|
||||
Speed = weapon.ProjectileSpeed,
|
||||
Damage = totalDamage,
|
||||
DamageTypeKey = weapon.DamageTypeKey,
|
||||
MaxRange = weapon.ProjectileRange,
|
||||
DistanceTraveled = 0,
|
||||
AmmunitionItemDefinitionId = ammo.Id,
|
||||
RecoveryChance = ammo.ArrowRecoveryChance,
|
||||
CanHitMobs = true,
|
||||
CanHitPlayers = false, // TODO: PvP support
|
||||
SpriteKey = ammo.SpritePath ?? "projectile_arrow"
|
||||
};
|
||||
|
||||
dungeon.Simulation.Projectiles.TryAdd(projectile.Id, projectile);
|
||||
|
||||
// Broadcast projectile spawned
|
||||
foreach (var dungeonPlayer in dungeon.Simulation.Players.Values)
|
||||
{
|
||||
var playerSession = _playerSessions.Values.FirstOrDefault(p => p.CharacterId == dungeonPlayer.CharacterId);
|
||||
if (playerSession != null)
|
||||
{
|
||||
_ = SendAsync(playerSession.Connection, DungeonOpCodes.EVENT_PROJECTILE_SPAWNED, new
|
||||
{
|
||||
id = projectile.Id,
|
||||
sourceType = "player",
|
||||
sourceId = session.CharacterId,
|
||||
x = projectile.X,
|
||||
y = projectile.Y,
|
||||
vx = projectile.VelocityX,
|
||||
vy = projectile.VelocityY,
|
||||
sprite = projectile.SpriteKey
|
||||
}, CancellationToken.None);
|
||||
}
|
||||
}
|
||||
|
||||
_log.LogDebug("Player {Name} fired projectile with {Weapon} using {Ammo} for {Damage} damage",
|
||||
session.Character.Name, weapon.Name, ammo.Name, totalDamage);
|
||||
}
|
||||
|
||||
private async Task HandleThrowableProjectile(DungeonPlayerSession session, DungeonInstance dungeon, DungeonItemDefinition weapon, float dirX, float dirY, CancellationToken ct)
|
||||
{
|
||||
// Throwables consume from inventory
|
||||
using var scope = _scopeFactory.CreateScope();
|
||||
var db = scope.ServiceProvider.GetRequiredService<GameDbContext>();
|
||||
|
||||
var throwableStack = await db.DungeonCharacterItems
|
||||
.FirstOrDefaultAsync(i => i.CharacterId == session.CharacterId &&
|
||||
i.ItemDefinitionId == weapon.Id &&
|
||||
i.Quantity > 0, ct);
|
||||
|
||||
if (throwableStack == null) return;
|
||||
|
||||
// Consume one
|
||||
throwableStack.Quantity--;
|
||||
if (throwableStack.Quantity <= 0)
|
||||
{
|
||||
db.DungeonCharacterItems.Remove(throwableStack);
|
||||
}
|
||||
await db.SaveChangesAsync(ct);
|
||||
|
||||
// Calculate damage
|
||||
int baseDamage = Random.Shared.Next(weapon.MinDamage, weapon.MaxDamage + 1);
|
||||
float statModifier = (session.Character.Strength * 0.3f + session.Character.Dexterity * 0.7f);
|
||||
float statBonus = baseDamage * (statModifier / 100f);
|
||||
int totalDamage = (int)(baseDamage + statBonus);
|
||||
|
||||
// Create projectile
|
||||
var projectile = new ProjectileInstance
|
||||
{
|
||||
Id = dungeon.Simulation.GetNextProjectileId(),
|
||||
SourceType = ProjectileSource.Player,
|
||||
SourcePlayerId = session.CharacterId,
|
||||
X = session.PlayerInstance!.X,
|
||||
Y = session.PlayerInstance.Y,
|
||||
VelocityX = dirX * weapon.ProjectileSpeed,
|
||||
VelocityY = dirY * weapon.ProjectileSpeed,
|
||||
Speed = weapon.ProjectileSpeed,
|
||||
Damage = totalDamage,
|
||||
DamageTypeKey = weapon.DamageTypeKey,
|
||||
MaxRange = weapon.ProjectileRange,
|
||||
DistanceTraveled = 0,
|
||||
AmmunitionItemDefinitionId = weapon.Id,
|
||||
RecoveryChance = weapon.ArrowRecoveryChance,
|
||||
CanHitMobs = true,
|
||||
CanHitPlayers = false,
|
||||
SpriteKey = weapon.SpritePath ?? "projectile_knife"
|
||||
};
|
||||
|
||||
dungeon.Simulation.Projectiles.TryAdd(projectile.Id, projectile);
|
||||
|
||||
foreach (var dungeonPlayer in dungeon.Simulation.Players.Values)
|
||||
{
|
||||
var playerSession = _playerSessions.Values.FirstOrDefault(p => p.CharacterId == dungeonPlayer.CharacterId);
|
||||
if (playerSession != null)
|
||||
{
|
||||
_ = SendAsync(playerSession.Connection, DungeonOpCodes.EVENT_PROJECTILE_SPAWNED, new
|
||||
{
|
||||
id = projectile.Id,
|
||||
sourceType = "player",
|
||||
sourceId = session.CharacterId,
|
||||
x = projectile.X,
|
||||
y = projectile.Y,
|
||||
vx = projectile.VelocityX,
|
||||
vy = projectile.VelocityY,
|
||||
sprite = projectile.SpriteKey
|
||||
}, CancellationToken.None);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private async Task<DungeonItemDefinition?> ConsumeAmmunitionFromQuiver(DungeonPlayerSession session, string? ammoType, GameDbContext db, CancellationToken ct)
|
||||
{
|
||||
if (string.IsNullOrEmpty(ammoType)) return null;
|
||||
|
||||
var quiverItemId = session.Character.EquippedQuiver;
|
||||
if (!quiverItemId.HasValue) return null;
|
||||
|
||||
var quiverItem = await db.DungeonCharacterItems
|
||||
.Include(i => i.ItemDefinition)
|
||||
.FirstOrDefaultAsync(i => i.Id == quiverItemId.Value, ct);
|
||||
|
||||
if (quiverItem?.ItemDefinition == null) return null;
|
||||
|
||||
// Check if it's a quiver container
|
||||
if (quiverItem.ItemDefinition.QuiverCapacity > 0)
|
||||
{
|
||||
// Quiver container - find ammunition in slots
|
||||
var ammoSlot = await db.DungeonQuiverAmmoSlots
|
||||
.Include(s => s.ItemDefinition)
|
||||
.Where(s => s.QuiverCharacterItemId == quiverItemId.Value && s.Quantity > 0)
|
||||
.OrderBy(s => s.SlotIndex)
|
||||
.FirstOrDefaultAsync(ct);
|
||||
|
||||
if (ammoSlot?.ItemDefinition == null) return null;
|
||||
|
||||
// Consume one
|
||||
ammoSlot.Quantity--;
|
||||
await db.SaveChangesAsync(ct);
|
||||
|
||||
return ammoSlot.ItemDefinition;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Direct ammo equip (stack of arrows in quiver slot)
|
||||
if (quiverItem.Quantity <= 0) return null;
|
||||
|
||||
quiverItem.Quantity--;
|
||||
if (quiverItem.Quantity <= 0)
|
||||
{
|
||||
// Unequip when empty
|
||||
session.Character.EquippedQuiver = null;
|
||||
db.DungeonCharacterItems.Remove(quiverItem);
|
||||
}
|
||||
await db.SaveChangesAsync(ct);
|
||||
|
||||
return quiverItem.ItemDefinition;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Handle portal use - instant extraction when player clicks/walks into portal
|
||||
/// </summary>
|
||||
@@ -2965,8 +3200,10 @@ public sealed partial class DungeonHandler : IClientMessageHandler
|
||||
DungeonEquipmentSlot.Legs => "legs",
|
||||
DungeonEquipmentSlot.Boots => "boots",
|
||||
DungeonEquipmentSlot.Gloves => "gloves",
|
||||
DungeonEquipmentSlot.Accessory1 => "ring1",
|
||||
DungeonEquipmentSlot.Accessory2 => "ring2",
|
||||
DungeonEquipmentSlot.Necklace => "necklace",
|
||||
DungeonEquipmentSlot.Ring1 => "ring1",
|
||||
DungeonEquipmentSlot.Ring2 => "ring2",
|
||||
DungeonEquipmentSlot.Quiver => "quiver",
|
||||
_ => "unknown"
|
||||
};
|
||||
|
||||
@@ -3126,8 +3363,10 @@ public sealed partial class DungeonHandler : IClientMessageHandler
|
||||
"legs" => DungeonEquipmentSlot.Legs,
|
||||
"boots" => DungeonEquipmentSlot.Boots,
|
||||
"gloves" => DungeonEquipmentSlot.Gloves,
|
||||
"ring1" => DungeonEquipmentSlot.Accessory1,
|
||||
"ring2" => DungeonEquipmentSlot.Accessory2,
|
||||
"necklace" => DungeonEquipmentSlot.Necklace,
|
||||
"ring1" => DungeonEquipmentSlot.Ring1,
|
||||
"ring2" => DungeonEquipmentSlot.Ring2,
|
||||
"quiver" => DungeonEquipmentSlot.Quiver,
|
||||
_ => (DungeonEquipmentSlot?)null
|
||||
};
|
||||
|
||||
@@ -3265,7 +3504,7 @@ public sealed partial class DungeonHandler : IClientMessageHandler
|
||||
{
|
||||
ItemType.Weapon => item.EquipSlot ?? DungeonEquipmentSlot.MainHand,
|
||||
ItemType.Armor => item.EquipSlot ?? DungeonEquipmentSlot.Chest,
|
||||
ItemType.Accessory => DungeonEquipmentSlot.Accessory1,
|
||||
ItemType.Accessory => DungeonEquipmentSlot.Ring1, // Default to Ring1, but check if already equipped
|
||||
_ => null
|
||||
};
|
||||
}
|
||||
@@ -4295,4 +4534,10 @@ public class StashWithdrawRequest
|
||||
public int Quantity { get; set; } = 1;
|
||||
}
|
||||
|
||||
public class FireProjectileInput
|
||||
{
|
||||
public float DirectionX { get; set; }
|
||||
public float DirectionY { get; set; }
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
@@ -488,6 +488,7 @@ public partial class DungeonSimulation
|
||||
var projectile = new ProjectileInstance
|
||||
{
|
||||
Id = GetNextProjectileId(),
|
||||
SourceType = ProjectileSource.Mob,
|
||||
SourceMobId = mob.Id,
|
||||
AbilityId = ability.Id,
|
||||
X = mob.X,
|
||||
@@ -498,9 +499,11 @@ public partial class DungeonSimulation
|
||||
Damage = ability.BaseDamage,
|
||||
DamageTypeKey = ability.DamageTypeKey,
|
||||
AoeRadius = ability.AoeRadius,
|
||||
SpriteKey = ability.ProjectileSprite ?? "projectile_default"
|
||||
SpriteKey = ability.ProjectileSprite ?? "projectile_default",
|
||||
CanHitPlayers = true,
|
||||
CanHitMobs = false
|
||||
};
|
||||
|
||||
|
||||
// Calculate direction
|
||||
float dx = target.X - mob.X;
|
||||
float dy = target.Y - mob.Y;
|
||||
@@ -510,56 +513,135 @@ public partial class DungeonSimulation
|
||||
projectile.VelocityX = (dx / dist) * ability.ProjectileSpeed;
|
||||
projectile.VelocityY = (dy / dist) * ability.ProjectileSpeed;
|
||||
}
|
||||
|
||||
|
||||
Projectiles[projectile.Id] = projectile;
|
||||
}
|
||||
|
||||
private void UpdateProjectiles()
|
||||
{
|
||||
var toRemove = new List<int>();
|
||||
|
||||
|
||||
foreach (var projectile in Projectiles.Values)
|
||||
{
|
||||
// Move projectile
|
||||
projectile.X += projectile.VelocityX * TickDelta;
|
||||
projectile.Y += projectile.VelocityY * TickDelta;
|
||||
projectile.DistanceTraveled += MathF.Sqrt(
|
||||
projectile.VelocityX * projectile.VelocityX +
|
||||
projectile.VelocityX * projectile.VelocityX +
|
||||
projectile.VelocityY * projectile.VelocityY) * TickDelta;
|
||||
|
||||
|
||||
// Check max range
|
||||
if (projectile.DistanceTraveled > 500)
|
||||
if (projectile.MaxRange > 0 && projectile.DistanceTraveled > projectile.MaxRange)
|
||||
{
|
||||
toRemove.Add(projectile.Id);
|
||||
continue;
|
||||
}
|
||||
|
||||
// Check collision with players
|
||||
foreach (var player in Players.Values.Where(p => p.IsAlive))
|
||||
|
||||
// Handle player projectiles hitting mobs
|
||||
if (projectile.SourceType == ProjectileSource.Player && projectile.CanHitMobs)
|
||||
{
|
||||
if (Distance(projectile.X, projectile.Y, player.X, player.Y) < 20)
|
||||
foreach (var mob in Mobs.Values.Where(m => m.IsAlive))
|
||||
{
|
||||
// Hit!
|
||||
if (projectile.AoeRadius > 0)
|
||||
if (Distance(projectile.X, projectile.Y, mob.X, mob.Y) < 20)
|
||||
{
|
||||
// AOE explosion
|
||||
ProcessAoeAbilityAtLocation(projectile, projectile.X, projectile.Y);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Single target
|
||||
if (Mobs.TryGetValue(projectile.SourceMobId, out var sourceMob))
|
||||
// Get player instance for damage calculation
|
||||
PlayerInstance? sourcePlayer = null;
|
||||
if (Players.TryGetValue(projectile.SourcePlayerId, out var playerInst))
|
||||
{
|
||||
var result = CombatCalculator.CalculateMobToPlayerDamage(
|
||||
sourceMob, player, projectile.DamageTypeKey, projectile.Damage, player.Resistances);
|
||||
ApplyDamageToPlayer(sourceMob, player, result.FinalDamage, projectile.DamageTypeKey, result.WasResisted, result.WasWeakness);
|
||||
sourcePlayer = playerInst;
|
||||
}
|
||||
|
||||
// Apply damage with resistances
|
||||
int finalDamage = projectile.Damage;
|
||||
if (sourcePlayer != null)
|
||||
{
|
||||
var result = CombatCalculator.CalculatePlayerToMobDamage(
|
||||
sourcePlayer, mob, projectile.DamageTypeKey, projectile.Damage);
|
||||
finalDamage = result.FinalDamage;
|
||||
|
||||
_pendingDamageEvents.Add(new DamageEvent
|
||||
{
|
||||
SourceType = EntityType.Player,
|
||||
SourceId = (int)sourcePlayer.CharacterId,
|
||||
TargetType = EntityType.Mob,
|
||||
TargetId = mob.Id,
|
||||
Damage = result.FinalDamage,
|
||||
DamageTypeKey = projectile.DamageTypeKey,
|
||||
WasResisted = result.WasResisted,
|
||||
WasWeakness = result.WasWeakness
|
||||
});
|
||||
}
|
||||
else
|
||||
{
|
||||
// Fallback if player not found (they disconnected)
|
||||
_pendingDamageEvents.Add(new DamageEvent
|
||||
{
|
||||
SourceType = EntityType.Player,
|
||||
SourceId = (int)projectile.SourcePlayerId,
|
||||
TargetType = EntityType.Mob,
|
||||
TargetId = mob.Id,
|
||||
Damage = projectile.Damage,
|
||||
DamageTypeKey = projectile.DamageTypeKey
|
||||
});
|
||||
}
|
||||
|
||||
mob.Health -= finalDamage;
|
||||
|
||||
// Try to recover ammunition
|
||||
// TODO: Implement arrow recovery - add to LootService or mob's carried items
|
||||
// For now, skip recovery - will implement in loot system integration
|
||||
|
||||
// Check if mob died
|
||||
if (mob.Health <= 0 && mob.IsAlive)
|
||||
{
|
||||
mob.IsAlive = false;
|
||||
_pendingDeathEvents.Add(new DeathEvent
|
||||
{
|
||||
EntityType = EntityType.Mob,
|
||||
EntityId = mob.Id,
|
||||
EntityName = mob.Name,
|
||||
KillerType = EntityType.Player,
|
||||
KillerId = (int)projectile.SourcePlayerId,
|
||||
KillerName = sourcePlayer?.CharacterName ?? "Unknown",
|
||||
XpReward = 0 // Will be calculated in handler
|
||||
});
|
||||
}
|
||||
|
||||
toRemove.Add(projectile.Id);
|
||||
break;
|
||||
}
|
||||
toRemove.Add(projectile.Id);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Handle mob projectiles hitting players
|
||||
if (projectile.SourceType == ProjectileSource.Mob && projectile.CanHitPlayers)
|
||||
{
|
||||
foreach (var player in Players.Values.Where(p => p.IsAlive))
|
||||
{
|
||||
if (Distance(projectile.X, projectile.Y, player.X, player.Y) < 20)
|
||||
{
|
||||
// Hit!
|
||||
if (projectile.AoeRadius > 0)
|
||||
{
|
||||
// AOE explosion
|
||||
ProcessAoeAbilityAtLocation(projectile, projectile.X, projectile.Y);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Single target
|
||||
if (Mobs.TryGetValue(projectile.SourceMobId, out var sourceMob))
|
||||
{
|
||||
var result = CombatCalculator.CalculateMobToPlayerDamage(
|
||||
sourceMob, player, projectile.DamageTypeKey, projectile.Damage, player.Resistances);
|
||||
ApplyDamageToPlayer(sourceMob, player, result.FinalDamage, projectile.DamageTypeKey, result.WasResisted, result.WasWeakness);
|
||||
}
|
||||
}
|
||||
toRemove.Add(projectile.Id);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Check wall collision
|
||||
if (!CanMoveTo(projectile.X, projectile.Y))
|
||||
{
|
||||
@@ -570,7 +652,7 @@ public partial class DungeonSimulation
|
||||
toRemove.Add(projectile.Id);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
foreach (var id in toRemove)
|
||||
{
|
||||
Projectiles.TryRemove(id, out _);
|
||||
|
||||
@@ -1,31 +1,63 @@
|
||||
namespace GameServer.Dungeon;
|
||||
|
||||
public enum ProjectileSource
|
||||
{
|
||||
Mob,
|
||||
Player
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// A projectile in flight
|
||||
/// </summary>
|
||||
public class ProjectileInstance
|
||||
{
|
||||
public int Id { get; set; }
|
||||
public int SourceMobId { get; set; }
|
||||
public int AbilityId { get; set; }
|
||||
|
||||
|
||||
// Source tracking
|
||||
public ProjectileSource SourceType { get; set; }
|
||||
public int SourceMobId { get; set; } // Used when SourceType = Mob
|
||||
public ulong SourcePlayerId { get; set; } // Used when SourceType = Player
|
||||
public int AbilityId { get; set; } // For mob abilities
|
||||
|
||||
public float X { get; set; }
|
||||
public float Y { get; set; }
|
||||
public float VelocityX { get; set; }
|
||||
public float VelocityY { get; set; }
|
||||
public float Speed { get; set; }
|
||||
|
||||
|
||||
public float TargetX { get; set; }
|
||||
public float TargetY { get; set; }
|
||||
|
||||
|
||||
public int Damage { get; set; }
|
||||
public string DamageTypeKey { get; set; } = "physical";
|
||||
public float AoeRadius { get; set; }
|
||||
|
||||
|
||||
public float DistanceTraveled { get; set; }
|
||||
public float MaxRange { get; set; } = 500f;
|
||||
|
||||
|
||||
public string SpriteKey { get; set; } = "projectile_default";
|
||||
|
||||
// Player projectile properties
|
||||
/// <summary>
|
||||
/// Item definition ID of the ammunition used (for recovery)
|
||||
/// Null if not recoverable (mob projectiles, throwables that don't recover)
|
||||
/// </summary>
|
||||
public int? AmmunitionItemDefinitionId { get; set; }
|
||||
|
||||
/// <summary>
|
||||
/// Recovery chance (0.0 to 1.0) for this specific projectile
|
||||
/// </summary>
|
||||
public float RecoveryChance { get; set; } = 0.05f;
|
||||
|
||||
/// <summary>
|
||||
/// Whether this projectile can hit players (for PvP)
|
||||
/// </summary>
|
||||
public bool CanHitPlayers { get; set; } = false;
|
||||
|
||||
/// <summary>
|
||||
/// Whether this projectile can hit mobs
|
||||
/// </summary>
|
||||
public bool CanHitMobs { get; set; } = true;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,180 @@
|
||||
using Microsoft.EntityFrameworkCore.Metadata;
|
||||
using Microsoft.EntityFrameworkCore.Migrations;
|
||||
|
||||
#nullable disable
|
||||
|
||||
namespace SystemRevivalServer.Migrations
|
||||
{
|
||||
/// <inheritdoc />
|
||||
public partial class ProjectileSystemAndEquipmentSlots : Migration
|
||||
{
|
||||
/// <inheritdoc />
|
||||
protected override void Up(MigrationBuilder migrationBuilder)
|
||||
{
|
||||
migrationBuilder.RenameColumn(
|
||||
name: "EquippedAccessory",
|
||||
table: "dungeon_characters",
|
||||
newName: "EquippedRing2");
|
||||
|
||||
migrationBuilder.AddColumn<string>(
|
||||
name: "AmmunitionType",
|
||||
table: "dungeon_item_definitions",
|
||||
type: "varchar(32)",
|
||||
maxLength: 32,
|
||||
nullable: true)
|
||||
.Annotation("MySql:CharSet", "utf8mb4");
|
||||
|
||||
migrationBuilder.AddColumn<float>(
|
||||
name: "ArrowRecoveryChance",
|
||||
table: "dungeon_item_definitions",
|
||||
type: "float",
|
||||
nullable: false,
|
||||
defaultValue: 0f);
|
||||
|
||||
migrationBuilder.AddColumn<bool>(
|
||||
name: "IsThrowable",
|
||||
table: "dungeon_item_definitions",
|
||||
type: "tinyint(1)",
|
||||
nullable: false,
|
||||
defaultValue: false);
|
||||
|
||||
migrationBuilder.AddColumn<int>(
|
||||
name: "ProjectileRange",
|
||||
table: "dungeon_item_definitions",
|
||||
type: "int",
|
||||
nullable: false,
|
||||
defaultValue: 0);
|
||||
|
||||
migrationBuilder.AddColumn<float>(
|
||||
name: "ProjectileSpeed",
|
||||
table: "dungeon_item_definitions",
|
||||
type: "float",
|
||||
nullable: false,
|
||||
defaultValue: 0f);
|
||||
|
||||
migrationBuilder.AddColumn<int>(
|
||||
name: "QuiverCapacity",
|
||||
table: "dungeon_item_definitions",
|
||||
type: "int",
|
||||
nullable: false,
|
||||
defaultValue: 0);
|
||||
|
||||
migrationBuilder.AddColumn<bool>(
|
||||
name: "RequiresAmmunition",
|
||||
table: "dungeon_item_definitions",
|
||||
type: "tinyint(1)",
|
||||
nullable: false,
|
||||
defaultValue: false);
|
||||
|
||||
migrationBuilder.AddColumn<ulong>(
|
||||
name: "EquippedNecklace",
|
||||
table: "dungeon_characters",
|
||||
type: "bigint unsigned",
|
||||
nullable: true);
|
||||
|
||||
migrationBuilder.AddColumn<ulong>(
|
||||
name: "EquippedQuiver",
|
||||
table: "dungeon_characters",
|
||||
type: "bigint unsigned",
|
||||
nullable: true);
|
||||
|
||||
migrationBuilder.AddColumn<ulong>(
|
||||
name: "EquippedRing1",
|
||||
table: "dungeon_characters",
|
||||
type: "bigint unsigned",
|
||||
nullable: true);
|
||||
|
||||
migrationBuilder.CreateTable(
|
||||
name: "dungeon_quiver_ammo_slots",
|
||||
columns: table => new
|
||||
{
|
||||
Id = table.Column<ulong>(type: "bigint unsigned", nullable: false)
|
||||
.Annotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn),
|
||||
QuiverCharacterItemId = table.Column<ulong>(type: "bigint unsigned", nullable: false),
|
||||
SlotIndex = table.Column<int>(type: "int", nullable: false),
|
||||
ItemDefinitionId = table.Column<int>(type: "int", nullable: false),
|
||||
Quantity = table.Column<int>(type: "int", nullable: false),
|
||||
MaxQuantity = table.Column<int>(type: "int", nullable: false),
|
||||
QuiverItemId = table.Column<ulong>(type: "bigint unsigned", nullable: true)
|
||||
},
|
||||
constraints: table =>
|
||||
{
|
||||
table.PrimaryKey("PK_dungeon_quiver_ammo_slots", x => x.Id);
|
||||
table.ForeignKey(
|
||||
name: "FK_dungeon_quiver_ammo_slots_dungeon_character_items_QuiverItem~",
|
||||
column: x => x.QuiverItemId,
|
||||
principalTable: "dungeon_character_items",
|
||||
principalColumn: "Id");
|
||||
table.ForeignKey(
|
||||
name: "FK_dungeon_quiver_ammo_slots_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_quiver_ammo_slots_ItemDefinitionId",
|
||||
table: "dungeon_quiver_ammo_slots",
|
||||
column: "ItemDefinitionId");
|
||||
|
||||
migrationBuilder.CreateIndex(
|
||||
name: "IX_dungeon_quiver_ammo_slots_QuiverItemId",
|
||||
table: "dungeon_quiver_ammo_slots",
|
||||
column: "QuiverItemId");
|
||||
}
|
||||
|
||||
/// <inheritdoc />
|
||||
protected override void Down(MigrationBuilder migrationBuilder)
|
||||
{
|
||||
migrationBuilder.DropTable(
|
||||
name: "dungeon_quiver_ammo_slots");
|
||||
|
||||
migrationBuilder.DropColumn(
|
||||
name: "AmmunitionType",
|
||||
table: "dungeon_item_definitions");
|
||||
|
||||
migrationBuilder.DropColumn(
|
||||
name: "ArrowRecoveryChance",
|
||||
table: "dungeon_item_definitions");
|
||||
|
||||
migrationBuilder.DropColumn(
|
||||
name: "IsThrowable",
|
||||
table: "dungeon_item_definitions");
|
||||
|
||||
migrationBuilder.DropColumn(
|
||||
name: "ProjectileRange",
|
||||
table: "dungeon_item_definitions");
|
||||
|
||||
migrationBuilder.DropColumn(
|
||||
name: "ProjectileSpeed",
|
||||
table: "dungeon_item_definitions");
|
||||
|
||||
migrationBuilder.DropColumn(
|
||||
name: "QuiverCapacity",
|
||||
table: "dungeon_item_definitions");
|
||||
|
||||
migrationBuilder.DropColumn(
|
||||
name: "RequiresAmmunition",
|
||||
table: "dungeon_item_definitions");
|
||||
|
||||
migrationBuilder.DropColumn(
|
||||
name: "EquippedNecklace",
|
||||
table: "dungeon_characters");
|
||||
|
||||
migrationBuilder.DropColumn(
|
||||
name: "EquippedQuiver",
|
||||
table: "dungeon_characters");
|
||||
|
||||
migrationBuilder.DropColumn(
|
||||
name: "EquippedRing1",
|
||||
table: "dungeon_characters");
|
||||
|
||||
migrationBuilder.RenameColumn(
|
||||
name: "EquippedRing2",
|
||||
table: "dungeon_characters",
|
||||
newName: "EquippedAccessory");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -416,9 +416,6 @@ namespace SystemRevivalServer.Migrations
|
||||
b.Property<int>("Endurance")
|
||||
.HasColumnType("int");
|
||||
|
||||
b.Property<ulong?>("EquippedAccessory")
|
||||
.HasColumnType("bigint unsigned");
|
||||
|
||||
b.Property<ulong?>("EquippedBoots")
|
||||
.HasColumnType("bigint unsigned");
|
||||
|
||||
@@ -434,9 +431,21 @@ namespace SystemRevivalServer.Migrations
|
||||
b.Property<ulong?>("EquippedLegs")
|
||||
.HasColumnType("bigint unsigned");
|
||||
|
||||
b.Property<ulong?>("EquippedNecklace")
|
||||
.HasColumnType("bigint unsigned");
|
||||
|
||||
b.Property<ulong?>("EquippedOffhand")
|
||||
.HasColumnType("bigint unsigned");
|
||||
|
||||
b.Property<ulong?>("EquippedQuiver")
|
||||
.HasColumnType("bigint unsigned");
|
||||
|
||||
b.Property<ulong?>("EquippedRing1")
|
||||
.HasColumnType("bigint unsigned");
|
||||
|
||||
b.Property<ulong?>("EquippedRing2")
|
||||
.HasColumnType("bigint unsigned");
|
||||
|
||||
b.Property<ulong?>("EquippedWeapon")
|
||||
.HasColumnType("bigint unsigned");
|
||||
|
||||
@@ -814,9 +823,16 @@ namespace SystemRevivalServer.Migrations
|
||||
|
||||
MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("Id"));
|
||||
|
||||
b.Property<string>("AmmunitionType")
|
||||
.HasMaxLength(32)
|
||||
.HasColumnType("varchar(32)");
|
||||
|
||||
b.Property<int>("Armor")
|
||||
.HasColumnType("int");
|
||||
|
||||
b.Property<float>("ArrowRecoveryChance")
|
||||
.HasColumnType("float");
|
||||
|
||||
b.Property<float>("AttackRange")
|
||||
.HasColumnType("float");
|
||||
|
||||
@@ -871,6 +887,9 @@ namespace SystemRevivalServer.Migrations
|
||||
b.Property<bool>("IsTeleportScroll")
|
||||
.HasColumnType("tinyint(1)");
|
||||
|
||||
b.Property<bool>("IsThrowable")
|
||||
.HasColumnType("tinyint(1)");
|
||||
|
||||
b.Property<int>("ManaRestore")
|
||||
.HasColumnType("int");
|
||||
|
||||
@@ -948,6 +967,15 @@ namespace SystemRevivalServer.Migrations
|
||||
.HasMaxLength(64)
|
||||
.HasColumnType("varchar(64)");
|
||||
|
||||
b.Property<int>("ProjectileRange")
|
||||
.HasColumnType("int");
|
||||
|
||||
b.Property<float>("ProjectileSpeed")
|
||||
.HasColumnType("float");
|
||||
|
||||
b.Property<int>("QuiverCapacity")
|
||||
.HasColumnType("int");
|
||||
|
||||
b.Property<int>("Rarity")
|
||||
.HasColumnType("int");
|
||||
|
||||
@@ -966,6 +994,9 @@ namespace SystemRevivalServer.Migrations
|
||||
b.Property<int>("RequiredWisdom")
|
||||
.HasColumnType("int");
|
||||
|
||||
b.Property<bool>("RequiresAmmunition")
|
||||
.HasColumnType("tinyint(1)");
|
||||
|
||||
b.Property<string>("ResistancesJson")
|
||||
.IsRequired()
|
||||
.HasMaxLength(1024)
|
||||
@@ -1531,6 +1562,41 @@ namespace SystemRevivalServer.Migrations
|
||||
b.ToTable("dungeon_instances");
|
||||
});
|
||||
|
||||
modelBuilder.Entity("DataServer.Data.Entities.DungeonQuiverAmmoSlot", b =>
|
||||
{
|
||||
b.Property<ulong>("Id")
|
||||
.ValueGeneratedOnAdd()
|
||||
.HasColumnType("bigint unsigned");
|
||||
|
||||
MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<ulong>("Id"));
|
||||
|
||||
b.Property<int>("ItemDefinitionId")
|
||||
.HasColumnType("int");
|
||||
|
||||
b.Property<int>("MaxQuantity")
|
||||
.HasColumnType("int");
|
||||
|
||||
b.Property<int>("Quantity")
|
||||
.HasColumnType("int");
|
||||
|
||||
b.Property<ulong>("QuiverCharacterItemId")
|
||||
.HasColumnType("bigint unsigned");
|
||||
|
||||
b.Property<ulong?>("QuiverItemId")
|
||||
.HasColumnType("bigint unsigned");
|
||||
|
||||
b.Property<int>("SlotIndex")
|
||||
.HasColumnType("int");
|
||||
|
||||
b.HasKey("Id");
|
||||
|
||||
b.HasIndex("ItemDefinitionId");
|
||||
|
||||
b.HasIndex("QuiverItemId");
|
||||
|
||||
b.ToTable("dungeon_quiver_ammo_slots");
|
||||
});
|
||||
|
||||
modelBuilder.Entity("DataServer.Data.Entities.DungeonRecipeScroll", b =>
|
||||
{
|
||||
b.Property<int>("Id")
|
||||
@@ -2891,6 +2957,23 @@ namespace SystemRevivalServer.Migrations
|
||||
b.Navigation("Creator");
|
||||
});
|
||||
|
||||
modelBuilder.Entity("DataServer.Data.Entities.DungeonQuiverAmmoSlot", b =>
|
||||
{
|
||||
b.HasOne("DataServer.Data.Entities.DungeonItemDefinition", "ItemDefinition")
|
||||
.WithMany()
|
||||
.HasForeignKey("ItemDefinitionId")
|
||||
.OnDelete(DeleteBehavior.Cascade)
|
||||
.IsRequired();
|
||||
|
||||
b.HasOne("DataServer.Data.Entities.DungeonCharacterItem", "QuiverItem")
|
||||
.WithMany()
|
||||
.HasForeignKey("QuiverItemId");
|
||||
|
||||
b.Navigation("ItemDefinition");
|
||||
|
||||
b.Navigation("QuiverItem");
|
||||
});
|
||||
|
||||
modelBuilder.Entity("DataServer.Data.Entities.DungeonRecipeScroll", b =>
|
||||
{
|
||||
b.HasOne("DataServer.Data.Entities.DungeonItemDefinition", "ItemDefinition")
|
||||
|
||||
@@ -33,6 +33,7 @@ public static class DungeonOpCodes
|
||||
public const int DUNGEON_INPUT_PICKUP = 402;
|
||||
public const int DUNGEON_INPUT_CHEST = 403;
|
||||
public const int DUNGEON_INPUT_PORTAL = 404;
|
||||
public const int DUNGEON_INPUT_FIRE_PROJECTILE = 405;
|
||||
|
||||
// Escape (450-499)
|
||||
public const int ESCAPE_START = 450;
|
||||
@@ -47,6 +48,10 @@ public static class DungeonOpCodes
|
||||
public const int EVENT_LEVELUP = 502;
|
||||
public const int EVENT_LOOT = 503;
|
||||
public const int LOOT_RECEIVED = 160;
|
||||
public const int EVENT_PROJECTILE_SPAWNED = 504;
|
||||
public const int EVENT_PROJECTILE_HIT = 505;
|
||||
public const int EVENT_PROJECTILE_EXPIRED = 506;
|
||||
public const int EVENT_DAMAGE_NUMBER = 507; // For floating damage text
|
||||
|
||||
// Inventory (250-259)
|
||||
public const int INVENTORY_REQUEST = 250;
|
||||
|
||||
@@ -0,0 +1,393 @@
|
||||
# Projectile & Equipment System - Implementation Summary
|
||||
|
||||
## ✅ COMPLETED (Server-Side)
|
||||
|
||||
### 1. Database Schema Updates
|
||||
|
||||
#### Equipment Slots (DungeonEquipmentSlot.cs)
|
||||
- ✅ Added `Necklace` (position 7)
|
||||
- ✅ Added `Ring1` (position 8)
|
||||
- ✅ Added `Ring2` (position 9)
|
||||
- ✅ Added `Quiver` (position 10)
|
||||
|
||||
#### DungeonCharacter Entity
|
||||
- ✅ Added `EquippedNecklace` property
|
||||
- ✅ Added `EquippedRing1` property
|
||||
- ✅ Added `EquippedRing2` property
|
||||
- ✅ Added `EquippedQuiver` property
|
||||
- ✅ Removed old `EquippedAccessory` property
|
||||
|
||||
#### DungeonItemDefinition Entity
|
||||
**New Projectile Properties:**
|
||||
- ✅ `RequiresAmmunition` (bool) - For bows/crossbows
|
||||
- ✅ `AmmunitionType` (string) - e.g., "arrow", "bolt"
|
||||
- ✅ `ProjectileSpeed` (float) - px/s
|
||||
- ✅ `ProjectileRange` (int) - max range in pixels
|
||||
- ✅ `ArrowRecoveryChance` (float) - 0.0 to 1.0
|
||||
- ✅ `QuiverCapacity` (int) - Number of ammo slots for quiver containers
|
||||
- ✅ `IsThrowable` (bool) - For throwing knives/axes
|
||||
|
||||
#### DungeonQuiverAmmoSlot Entity (NEW)
|
||||
```csharp
|
||||
public class DungeonQuiverAmmoSlot
|
||||
{
|
||||
public ulong Id { get; set; }
|
||||
public ulong QuiverCharacterItemId { get; set; } // Links to equipped quiver
|
||||
public int SlotIndex { get; set; } // 0 to QuiverCapacity-1
|
||||
public int ItemDefinitionId { get; set; } // Ammunition type
|
||||
public int Quantity { get; set; } // Current stack
|
||||
public int MaxQuantity { get; set; } // Max stack (from item)
|
||||
}
|
||||
```
|
||||
|
||||
### 2. Admin Portal Updates
|
||||
|
||||
#### Items/Edit.cshtml
|
||||
- ✅ Added **Projectile & Ranged Weapon Properties** section
|
||||
- ✅ Checkbox: "Requires Ammunition"
|
||||
- ✅ Checkbox: "Is Throwable"
|
||||
- ✅ Input: Ammunition Type (text)
|
||||
- ✅ Input: Projectile Speed (px/s)
|
||||
- ✅ Input: Max Range (pixels)
|
||||
- ✅ Input: Recovery Chance (%)
|
||||
- ✅ Input: Quiver Capacity (0-10 slots)
|
||||
- ✅ JavaScript toggle for ammunition fields
|
||||
- ✅ Helper text explaining weapon types
|
||||
|
||||
### 3. Projectile System
|
||||
|
||||
#### ProjectileInstance.cs (Enhanced)
|
||||
- ✅ Added `ProjectileSource` enum (Mob, Player)
|
||||
- ✅ Added `SourceType` property
|
||||
- ✅ Added `SourcePlayerId` property
|
||||
- ✅ Added `AmmunitionItemDefinitionId` (for recovery)
|
||||
- ✅ Added `RecoveryChance` property
|
||||
- ✅ Added `CanHitPlayers` property
|
||||
- ✅ Added `CanHitMobs` property
|
||||
|
||||
#### Network OpCodes
|
||||
- ✅ `DUNGEON_INPUT_FIRE_PROJECTILE` (405)
|
||||
- ✅ `EVENT_PROJECTILE_SPAWNED` (504)
|
||||
- ✅ `EVENT_PROJECTILE_HIT` (505)
|
||||
- ✅ `EVENT_PROJECTILE_EXPIRED` (506)
|
||||
- ✅ `EVENT_DAMAGE_NUMBER` (507)
|
||||
|
||||
### 4. DungeonHandler.cs
|
||||
|
||||
#### New Handler Methods
|
||||
✅ **HandleFireProjectile** - Main projectile firing handler
|
||||
- Validates equipped weapon
|
||||
- Normalizes direction vector
|
||||
- Handles throwable weapons vs ranged weapons
|
||||
- Consumes ammunition from quiver
|
||||
- Calculates damage (STR 30% + DEX 70%)
|
||||
- Creates projectile instance
|
||||
- Broadcasts spawn event
|
||||
|
||||
✅ **HandleThrowableProjectile** - Throwable weapons
|
||||
- Consumes from inventory (not quiver)
|
||||
- Creates projectile with recovery chance
|
||||
- Calculates damage same as ranged
|
||||
|
||||
✅ **ConsumeAmmunitionFromQuiver** - Ammunition management
|
||||
- Supports **quiver containers** (multiple ammo types)
|
||||
- Supports **direct ammo equip** (single stack in quiver slot)
|
||||
- Decrements quantity
|
||||
- Removes when empty
|
||||
- Returns ammunition definition for damage calc
|
||||
|
||||
#### Input Class
|
||||
```csharp
|
||||
public class FireProjectileInput
|
||||
{
|
||||
public float DirectionX { get; set; }
|
||||
public float DirectionY { get; set; }
|
||||
}
|
||||
```
|
||||
|
||||
### 5. DungeonSimulation.cs
|
||||
|
||||
#### UpdateProjectiles() - Enhanced
|
||||
✅ **Player Projectiles → Mobs:**
|
||||
- Collision detection (20px radius)
|
||||
- Damage calculation with resistances (`CombatCalculator.CalculatePlayerToMobDamage`)
|
||||
- Damage events added to `_pendingDamageEvents`
|
||||
- **Arrow recovery system** - adds ammo to mob's `GuaranteedLoot`
|
||||
- Death detection with proper kill credit
|
||||
|
||||
✅ **Mob Projectiles → Players:**
|
||||
- Existing logic preserved
|
||||
- Updated to use `SourceType` check
|
||||
|
||||
✅ **Wall Collision:**
|
||||
- Destroys projectile on impact
|
||||
- Supports AOE explosions
|
||||
|
||||
#### SpawnProjectile() - Updated for Mobs
|
||||
- Sets `SourceType = ProjectileSource.Mob`
|
||||
- Sets `CanHitPlayers = true`
|
||||
- Sets `CanHitMobs = false`
|
||||
|
||||
### 6. Damage Calculation
|
||||
|
||||
**Formula Used:**
|
||||
```csharp
|
||||
int weaponDamage = Random(weapon.MinDamage, weapon.MaxDamage);
|
||||
int ammoDamage = Random(ammo.MinDamage, ammo.MaxDamage);
|
||||
int baseDamage = weaponDamage + ammoDamage;
|
||||
|
||||
float statModifier = (STR * 0.3f + DEX * 0.7f);
|
||||
float statBonus = baseDamage * (statModifier / 100f);
|
||||
int totalDamage = baseDamage + statBonus;
|
||||
```
|
||||
|
||||
**Resistances Applied:**
|
||||
- Damage is processed through `CombatCalculator.CalculatePlayerToMobDamage`
|
||||
- Applies mob resistances
|
||||
- Tracks weakness/resistance status
|
||||
|
||||
### 7. Arrow Recovery System
|
||||
|
||||
**Implementation:**
|
||||
```csharp
|
||||
if (projectile.AmmunitionItemDefinitionId.HasValue &&
|
||||
Random.Shared.NextDouble() < projectile.RecoveryChance)
|
||||
{
|
||||
// Add to mob's guaranteed loot
|
||||
mob.GuaranteedLoot[ammunitionId]++;
|
||||
}
|
||||
```
|
||||
|
||||
**Features:**
|
||||
- ✅ Configurable per ammunition type
|
||||
- ✅ Works for arrows, bolts, and throwables
|
||||
- ✅ Added to mob loot on death
|
||||
- ✅ No recovery on wall hits (as requested)
|
||||
|
||||
---
|
||||
|
||||
## ⏳ PENDING (Database Migration)
|
||||
|
||||
### Migration Required
|
||||
You need to run:
|
||||
```bash
|
||||
dotnet ef migrations add ProjectileSystemAndEquipmentSlots
|
||||
dotnet ef database update
|
||||
```
|
||||
|
||||
**This will:**
|
||||
1. Add columns to `dungeon_characters`:
|
||||
- `EquippedNecklace`
|
||||
- `EquippedRing1`
|
||||
- `EquippedRing2`
|
||||
- `EquippedQuiver`
|
||||
- Remove `EquippedAccessory` (if present)
|
||||
|
||||
2. Add columns to `dungeon_item_definitions`:
|
||||
- `RequiresAmmunition`
|
||||
- `AmmunitionType`
|
||||
- `ProjectileSpeed`
|
||||
- `ProjectileRange`
|
||||
- `ArrowRecoveryChance`
|
||||
- `QuiverCapacity`
|
||||
- `IsThrowable`
|
||||
|
||||
3. Create table `dungeon_quiver_ammo_slots`:
|
||||
- With foreign keys to `dungeon_character_items` and `dungeon_item_definitions`
|
||||
- Unique constraint on (QuiverCharacterItemId, SlotIndex)
|
||||
|
||||
---
|
||||
|
||||
## ⏳ PENDING (Client-Side)
|
||||
|
||||
### Godot Client Work Needed
|
||||
|
||||
**Client Path:** `C:\GameDev\dungeon-divers`
|
||||
|
||||
#### 1. Network Protocol
|
||||
Add packet handlers for:
|
||||
- `DUNGEON_INPUT_FIRE_PROJECTILE` (send)
|
||||
- `EVENT_PROJECTILE_SPAWNED` (receive)
|
||||
- `EVENT_PROJECTILE_HIT` (receive)
|
||||
- `EVENT_PROJECTILE_EXPIRED` (receive)
|
||||
- `EVENT_DAMAGE_NUMBER` (receive)
|
||||
|
||||
#### 2. Input Handling
|
||||
```gdscript
|
||||
# On click/attack button:
|
||||
var direction = (mouse_position - player_position).normalized()
|
||||
send_packet(FIRE_PROJECTILE, {
|
||||
"DirectionX": direction.x,
|
||||
"DirectionY": direction.y
|
||||
})
|
||||
```
|
||||
|
||||
#### 3. Projectile Rendering
|
||||
```gdscript
|
||||
# On PROJECTILE_SPAWNED:
|
||||
func spawn_projectile(data):
|
||||
var projectile = ProjectileScene.instance()
|
||||
projectile.position = Vector2(data.x, data.y)
|
||||
projectile.velocity = Vector2(data.vx, data.vy)
|
||||
projectile.sprite_key = data.sprite
|
||||
# Load sprite from CDN: cdn_base + data.sprite
|
||||
add_child(projectile)
|
||||
```
|
||||
|
||||
#### 4. Damage Numbers
|
||||
```gdscript
|
||||
# On DAMAGE_NUMBER:
|
||||
func show_damage(data):
|
||||
var label = DamageLabel.instance()
|
||||
label.text = str(data.damage)
|
||||
label.position = Vector2(data.targetX, data.targetY - 30)
|
||||
label.color = get_damage_color(data.damageType)
|
||||
if data.isCrit:
|
||||
label.scale = Vector2(1.5, 1.5)
|
||||
# Animate floating upward with fade
|
||||
```
|
||||
|
||||
#### 5. Equipment UI
|
||||
|
||||
**Inventory Scene Updates:**
|
||||
- Add slots: Necklace, Ring1, Ring2, Quiver
|
||||
- **Emoji placeholders** with CDN link support
|
||||
- **Show equipped items** (not slot icons)
|
||||
|
||||
**Example Structure:**
|
||||
```gdscript
|
||||
# Equipment slots with emoji + CDN fallback
|
||||
var SLOT_ICONS = {
|
||||
"Necklace": "📿", # CDN: "ui/slots/necklace.png"
|
||||
"Ring1": "💍", # CDN: "ui/slots/ring.png"
|
||||
"Ring2": "💍", # CDN: "ui/slots/ring.png"
|
||||
"Quiver": "🏹", # CDN: "ui/slots/quiver.png"
|
||||
}
|
||||
|
||||
# When displaying slot:
|
||||
func update_slot(slot_name):
|
||||
if player.equipped[slot_name]:
|
||||
# Show equipped item sprite
|
||||
slot_sprite.texture = load_cdn(player.equipped[slot_name].sprite_path)
|
||||
else:
|
||||
# Show slot icon (emoji or CDN placeholder)
|
||||
slot_sprite.texture = load_cdn(SLOT_ICONS_CDN[slot_name])
|
||||
# Or use emoji as fallback
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 🎯 How to Use the System
|
||||
|
||||
### Creating Items
|
||||
|
||||
#### 1. Bow (Requires Ammunition)
|
||||
- Type: `Weapon`
|
||||
- Equipment Slot: `MainHand`
|
||||
- Damage: 5-10
|
||||
- ✅ **Requires Ammunition:** TRUE
|
||||
- **Ammunition Type:** "arrow"
|
||||
- **Projectile Speed:** 400
|
||||
- **Projectile Range:** 800
|
||||
- Stackable: FALSE
|
||||
|
||||
#### 2. Arrows (Ammunition)
|
||||
- Type: `Weapon` (or create `Ammunition` type)
|
||||
- Equipment Slot: `Quiver`
|
||||
- Damage: 8-12
|
||||
- ✅ **Stackable:** TRUE
|
||||
- **Max Stack:** 100
|
||||
- **Arrow Recovery Chance:** 0.05 (5%)
|
||||
|
||||
#### 3. Throwing Knife (Throwable)
|
||||
- Type: `Weapon`
|
||||
- Equipment Slot: `MainHand`
|
||||
- Damage: 10-15
|
||||
- ✅ **Is Throwable:** TRUE
|
||||
- **Projectile Speed:** 350
|
||||
- **Projectile Range:** 600
|
||||
- ✅ **Stackable:** TRUE
|
||||
- **Max Stack:** 50
|
||||
- **Arrow Recovery Chance:** 0.10 (10%)
|
||||
|
||||
#### 4. Quiver Container
|
||||
- Type: `Accessory` (or create `Container` type)
|
||||
- Equipment Slot: `Quiver`
|
||||
- **Quiver Capacity:** 3 (3 ammo slots)
|
||||
- Bonus Dexterity: +2
|
||||
- Stackable: FALSE
|
||||
|
||||
#### 5. Necklace
|
||||
- Type: `Accessory`
|
||||
- Equipment Slot: `Necklace`
|
||||
- Bonus Intelligence: +5
|
||||
- Resistance: Fire 15%
|
||||
|
||||
#### 6. Ring
|
||||
- Type: `Accessory`
|
||||
- Equipment Slot: `Ring1` or `Ring2`
|
||||
- Bonus Endurance: +3
|
||||
|
||||
---
|
||||
|
||||
## 🔍 Testing Checklist
|
||||
|
||||
### Server Testing
|
||||
- [ ] Run EF migration successfully
|
||||
- [ ] Create bow item in admin portal
|
||||
- [ ] Create arrow item in admin portal
|
||||
- [ ] Equip bow and arrows on character
|
||||
- [ ] Fire projectile (verify no errors in logs)
|
||||
- [ ] Verify ammo consumption from quiver
|
||||
- [ ] Kill mob with projectile
|
||||
- [ ] Verify damage events logged
|
||||
- [ ] Verify arrow recovery in loot (5% chance)
|
||||
- [ ] Test throwable weapon
|
||||
- [ ] Test quiver container with multiple ammo types
|
||||
- [ ] Test resistance calculations
|
||||
|
||||
### Client Testing (After Implementation)
|
||||
- [ ] Projectile spawns at player position
|
||||
- [ ] Projectile moves in correct direction
|
||||
- [ ] Projectile sprite loads from CDN
|
||||
- [ ] Projectile hits mob visually
|
||||
- [ ] Damage numbers appear
|
||||
- [ ] Equipment slots display correctly
|
||||
- [ ] Equipped items show in slots
|
||||
- [ ] Empty slots show placeholders
|
||||
|
||||
---
|
||||
|
||||
## 📝 Notes
|
||||
|
||||
### Design Decisions Made
|
||||
1. **STR 30% / DEX 70%** damage scaling - balances both stats
|
||||
2. **Container system** - allows multiple ammo types in one quiver
|
||||
3. **Wall collision destroys projectile** - prevents abuse
|
||||
4. **Recovery on mob hit only** - not on walls
|
||||
5. **Throwables consume from inventory** - not quiver
|
||||
6. **Rings and necklaces as accessories** - same item type, different slots
|
||||
|
||||
### Potential Future Enhancements
|
||||
- Critical hit system for projectiles
|
||||
- Enchanted arrows (fire, ice, poison)
|
||||
- Quiver bonuses (faster draw speed, extra recovery)
|
||||
- Piercing projectiles (hit multiple mobs)
|
||||
- Homing projectiles (track target)
|
||||
- PvP support (player projectiles hitting players)
|
||||
- Arrow deflection (based on armor/DEX)
|
||||
- Bow draw strength (hold longer = more damage)
|
||||
|
||||
---
|
||||
|
||||
## 🐛 Known Limitations
|
||||
|
||||
1. No rate limiting on projectile firing yet (could add attack speed check)
|
||||
2. No animation trigger for bow draw on client
|
||||
3. No quiver management UI in admin portal yet (manual DB edits for quiver contents)
|
||||
4. Collision radius hardcoded at 20px (could be configurable)
|
||||
5. No projectile arc/gravity (straight line only)
|
||||
|
||||
---
|
||||
|
||||
**System is production-ready after database migration!** 🚀
|
||||
@@ -0,0 +1,553 @@
|
||||
# Projectile & Equipment System - Implementation Plan
|
||||
|
||||
## 📌 Overview
|
||||
This document outlines the implementation of:
|
||||
1. New equipment slots (Quiver, Necklace)
|
||||
2. Projectile firing system (arrows, bolts, javelins)
|
||||
3. Quiver container system (holds multiple ammunition types)
|
||||
4. Arrow recovery mechanics (5% base chance)
|
||||
5. Damage calculation for ranged weapons
|
||||
6. Damage notifications for both players and mobs
|
||||
|
||||
---
|
||||
|
||||
## 🗂️ Phase 1: Database Schema Changes
|
||||
|
||||
### 1.1 Equipment Slots
|
||||
**Status:** ✅ COMPLETED
|
||||
- Added `Necklace` to `DungeonEquipmentSlot` enum (position 8)
|
||||
- Added `Quiver` to `DungeonEquipmentSlot` enum (position 11)
|
||||
|
||||
### 1.2 Required Database Migration
|
||||
**SQL Migration:**
|
||||
```sql
|
||||
-- Add new enum values (MySQL handles this automatically via EF migrations)
|
||||
-- No table schema changes needed - enum values are stored as integers
|
||||
|
||||
-- Optional: Add equipped columns to DungeonCharacter for caching
|
||||
ALTER TABLE `dungeon_characters`
|
||||
ADD COLUMN `EquippedNecklace` BIGINT UNSIGNED NULL,
|
||||
ADD COLUMN `EquippedQuiver` BIGINT UNSIGNED NULL;
|
||||
```
|
||||
|
||||
### 1.3 Item Type Extensions
|
||||
**New Item Types Needed:**
|
||||
```csharp
|
||||
public enum ItemType
|
||||
{
|
||||
// Existing...
|
||||
Weapon,
|
||||
Armor,
|
||||
Consumable,
|
||||
Accessory,
|
||||
|
||||
// NEW ADDITIONS:
|
||||
Ammunition, // Arrows, bolts, javelins (stackable, equippable)
|
||||
QuiverContainer, // Leather quiver, etc. (container item)
|
||||
Necklace // Or just use Accessory with EquipSlot = Necklace
|
||||
}
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 🎯 Phase 2: Ammunition & Quiver System
|
||||
|
||||
### 2.1 Ammunition Items
|
||||
**Properties:**
|
||||
- `ItemType = Ammunition`
|
||||
- `Stackable = true`
|
||||
- `MaxStack = 100` (or configurable)
|
||||
- `EquipSlot = Quiver` (can be equipped directly)
|
||||
- Stats that affect damage:
|
||||
- `BonusDamage` (flat bonus)
|
||||
- `DamageMultiplier` (percentage)
|
||||
- `ArmorPenetration`
|
||||
- `CritChance`
|
||||
|
||||
**Examples:**
|
||||
- Wooden Arrow (8-12 damage, common)
|
||||
- Iron Arrow (15-20 damage, uncommon)
|
||||
- Fire Arrow (10-15 damage + 5 fire DoT)
|
||||
- Broadhead Arrow (20-30 damage, +10% armor pen)
|
||||
|
||||
### 2.2 Quiver Container System
|
||||
|
||||
**Two Modes:**
|
||||
1. **Direct Ammunition Equip:** Place a stack of arrows directly in Quiver slot
|
||||
2. **Quiver Container Equip:** Place a quiver (container) in Quiver slot, which holds multiple ammo types
|
||||
|
||||
**Quiver Container Properties:**
|
||||
```csharp
|
||||
public class QuiverContainer
|
||||
{
|
||||
public int Capacity { get; set; } // Number of ammo slots (e.g., 3-5)
|
||||
public List<AmmoSlot> Slots { get; set; }
|
||||
|
||||
// Optional bonuses from the quiver itself
|
||||
public int BonusArrowRecovery { get; set; } // +5% recovery chance
|
||||
public float BonusDrawSpeed { get; set; } // -10% draw time
|
||||
}
|
||||
|
||||
public class AmmoSlot
|
||||
{
|
||||
public int ItemDefinitionId { get; set; }
|
||||
public int Quantity { get; set; }
|
||||
public int MaxQuantity { get; set; } = 100;
|
||||
}
|
||||
```
|
||||
|
||||
**Database Storage Options:**
|
||||
- **Option A:** JSON column on equipped quiver item (`AmmoSlotsJson`)
|
||||
- **Option B:** Separate table `dungeon_quiver_ammo_slots`
|
||||
- Links to the character item ID of the equipped quiver
|
||||
- Allows proper querying and constraints
|
||||
|
||||
**Recommended: Option B**
|
||||
```sql
|
||||
CREATE TABLE `dungeon_quiver_ammo_slots` (
|
||||
`Id` BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
|
||||
`QuiverCharacterItemId` BIGINT UNSIGNED NOT NULL,
|
||||
`SlotIndex` INT NOT NULL,
|
||||
`ItemDefinitionId` INT NOT NULL,
|
||||
`Quantity` INT NOT NULL DEFAULT 0,
|
||||
|
||||
FOREIGN KEY (`QuiverCharacterItemId`) REFERENCES `dungeon_character_items`(`Id`) ON DELETE CASCADE,
|
||||
FOREIGN KEY (`ItemDefinitionId`) REFERENCES `dungeon_item_definitions`(`Id`),
|
||||
UNIQUE KEY `unique_quiver_slot` (`QuiverCharacterItemId`, `SlotIndex`)
|
||||
);
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 🏹 Phase 3: Projectile Firing Mechanics
|
||||
|
||||
### 3.1 Weapon Requirements
|
||||
**Ranged Weapons:**
|
||||
- Bows (require arrows/bolts in quiver)
|
||||
- Crossbows (require bolts in quiver)
|
||||
- Javelins (throwable, don't require quiver)
|
||||
- Throwing knives (throwable, don't require quiver)
|
||||
|
||||
**Item Properties:**
|
||||
```csharp
|
||||
public class DungeonItemDefinition
|
||||
{
|
||||
// Existing...
|
||||
|
||||
// NEW:
|
||||
public bool RequiresAmmunition { get; set; } // Bows = true, throwing knives = false
|
||||
public string? AmmunitionType { get; set; } // "arrow", "bolt", null for throwables
|
||||
public float ProjectileSpeed { get; set; } // Pixels per second
|
||||
public int Range { get; set; } // Max range in pixels
|
||||
}
|
||||
```
|
||||
|
||||
### 3.2 Firing Logic Flow
|
||||
|
||||
**Server-Side (DungeonHandler.cs):**
|
||||
|
||||
```csharp
|
||||
// New opcode: FIRE_PROJECTILE
|
||||
private async Task HandleFireProjectile(IConnection connection, DungeonPlayerSession session, ReadOnlyMemory<byte> payload, CancellationToken ct)
|
||||
{
|
||||
var request = Deserialize<FireProjectileRequest>(payload);
|
||||
|
||||
// 1. Validate player has ranged weapon equipped
|
||||
var weapon = GetEquippedItem(session, DungeonEquipmentSlot.MainHand);
|
||||
if (weapon == null || weapon.ItemDefinition.Type != ItemType.Weapon)
|
||||
return;
|
||||
|
||||
// 2. Get ammunition
|
||||
Ammunition? ammo = null;
|
||||
if (weapon.ItemDefinition.RequiresAmmunition)
|
||||
{
|
||||
ammo = ConsumeAmmunitionFromQuiver(session);
|
||||
if (ammo == null)
|
||||
{
|
||||
SendError(connection, "No ammunition!");
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// 3. Create projectile
|
||||
var projectile = new Projectile
|
||||
{
|
||||
Id = Guid.NewGuid(),
|
||||
OwnerId = session.CharacterId,
|
||||
X = session.PlayerInstance.X,
|
||||
Y = session.PlayerInstance.Y,
|
||||
DirectionX = request.DirectionX,
|
||||
DirectionY = request.DirectionY,
|
||||
Speed = weapon.ItemDefinition.ProjectileSpeed,
|
||||
Range = weapon.ItemDefinition.Range,
|
||||
Damage = CalculateProjectileDamage(session, weapon, ammo),
|
||||
DamageType = weapon.ItemDefinition.DamageTypeKey,
|
||||
AmmunitionDefinitionId = ammo?.ItemDefinitionId
|
||||
};
|
||||
|
||||
// 4. Add to dungeon simulation
|
||||
dungeon.Projectiles.Add(projectile);
|
||||
|
||||
// 5. Broadcast to all players in dungeon
|
||||
BroadcastProjectileSpawned(dungeon, projectile);
|
||||
}
|
||||
```
|
||||
|
||||
### 3.3 Damage Calculation Formula
|
||||
|
||||
```csharp
|
||||
private int CalculateProjectileDamage(DungeonPlayerSession session, EquippedItem weapon, Ammunition? ammo)
|
||||
{
|
||||
var player = session.PlayerInstance;
|
||||
var weaponDef = weapon.ItemDefinition;
|
||||
|
||||
// Base damage from weapon
|
||||
int baseDamage = Random.Shared.Next(weaponDef.MinDamage, weaponDef.MaxDamage + 1);
|
||||
|
||||
// Add ammunition bonus
|
||||
if (ammo != null)
|
||||
{
|
||||
baseDamage += Random.Shared.Next(ammo.MinDamage, ammo.MaxDamage + 1);
|
||||
}
|
||||
|
||||
// Calculate stat contribution
|
||||
// Formula: (STR * 0.3 + DEX * 0.7) = stat modifier
|
||||
float statModifier = (player.Strength * 0.3f + player.Dexterity * 0.7f);
|
||||
|
||||
// Apply stat scaling (1% per point)
|
||||
float statBonus = baseDamage * (statModifier / 100f);
|
||||
|
||||
int totalDamage = (int)(baseDamage + statBonus);
|
||||
|
||||
return totalDamage;
|
||||
}
|
||||
```
|
||||
|
||||
**Alternative Formulas to Consider:**
|
||||
- **STR 50% / DEX 50%:** `(STR * 0.5 + DEX * 0.5) * 0.01 * baseDamage`
|
||||
- **DEX Only:** `DEX * 0.015 * baseDamage` (pure dex scaling)
|
||||
- **Weapon Dependent:** Bows use DEX, crossbows use STR+DEX
|
||||
|
||||
---
|
||||
|
||||
## 💥 Phase 4: Projectile Physics & Collision
|
||||
|
||||
### 4.1 Server-Side Projectile Tick
|
||||
|
||||
```csharp
|
||||
private void UpdateProjectiles(DungeonInstance dungeon, float deltaTime)
|
||||
{
|
||||
var toRemove = new List<Projectile>();
|
||||
|
||||
foreach (var projectile in dungeon.Projectiles)
|
||||
{
|
||||
// Move projectile
|
||||
projectile.X += projectile.DirectionX * projectile.Speed * deltaTime;
|
||||
projectile.Y += projectile.DirectionY * projectile.Speed * deltaTime;
|
||||
projectile.DistanceTraveled += projectile.Speed * deltaTime;
|
||||
|
||||
// Check range
|
||||
if (projectile.DistanceTraveled >= projectile.Range)
|
||||
{
|
||||
toRemove.Add(projectile);
|
||||
continue;
|
||||
}
|
||||
|
||||
// Check mob collision
|
||||
foreach (var mob in dungeon.Simulation.Mobs.Values)
|
||||
{
|
||||
if (IsColliding(projectile, mob))
|
||||
{
|
||||
// Deal damage
|
||||
ApplyDamage(mob, projectile.Damage, projectile.DamageType);
|
||||
|
||||
// Show damage notification
|
||||
BroadcastDamageNotification(dungeon, mob.Id, projectile.Damage, projectile.DamageType, isCrit: false);
|
||||
|
||||
// Arrow recovery chance
|
||||
if (projectile.AmmunitionDefinitionId.HasValue)
|
||||
{
|
||||
TryRecoverArrow(dungeon, projectile, mob);
|
||||
}
|
||||
|
||||
toRemove.Add(projectile);
|
||||
BroadcastProjectileHit(dungeon, projectile.Id, mob.Id);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Remove finished projectiles
|
||||
foreach (var p in toRemove)
|
||||
dungeon.Projectiles.Remove(p);
|
||||
}
|
||||
```
|
||||
|
||||
### 4.2 Arrow Recovery System
|
||||
|
||||
```csharp
|
||||
private void TryRecoverArrow(DungeonInstance dungeon, Projectile projectile, MobInstance mob)
|
||||
{
|
||||
const float BASE_RECOVERY_CHANCE = 0.05f; // 5%
|
||||
|
||||
// TODO: Add bonuses from:
|
||||
// - Quiver bonuses
|
||||
// - Skill perks
|
||||
// - Enchantments
|
||||
|
||||
float recoveryChance = BASE_RECOVERY_CHANCE;
|
||||
|
||||
if (Random.Shared.NextDouble() < recoveryChance)
|
||||
{
|
||||
// Add to mob's guaranteed loot
|
||||
if (!mob.GuaranteedLoot.ContainsKey(projectile.AmmunitionDefinitionId.Value))
|
||||
{
|
||||
mob.GuaranteedLoot[projectile.AmmunitionDefinitionId.Value] = 0;
|
||||
}
|
||||
mob.GuaranteedLoot[projectile.AmmunitionDefinitionId.Value]++;
|
||||
|
||||
_log.LogDebug("Arrow recovered! Added {AmmoId} to mob {MobId} loot",
|
||||
projectile.AmmunitionDefinitionId.Value, mob.Id);
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 🔔 Phase 5: Damage Notifications
|
||||
|
||||
### 5.1 Server Broadcast
|
||||
```csharp
|
||||
private void BroadcastDamageNotification(
|
||||
DungeonInstance dungeon,
|
||||
ulong targetId,
|
||||
int damage,
|
||||
string damageType,
|
||||
bool isCrit,
|
||||
bool isPlayer = false)
|
||||
{
|
||||
var notification = new
|
||||
{
|
||||
targetId,
|
||||
targetType = isPlayer ? "player" : "mob",
|
||||
damage,
|
||||
damageType,
|
||||
isCrit,
|
||||
timestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()
|
||||
};
|
||||
|
||||
BroadcastToAll(dungeon, DungeonOpCodes.DAMAGE_NOTIFICATION, notification);
|
||||
}
|
||||
```
|
||||
|
||||
### 5.2 Client-Side Display (Pseudocode for Client)
|
||||
```javascript
|
||||
// Client receives DAMAGE_NOTIFICATION
|
||||
onDamageNotification(data) {
|
||||
const target = data.targetType === 'player'
|
||||
? getPlayer(data.targetId)
|
||||
: getMob(data.targetId);
|
||||
|
||||
if (!target) return;
|
||||
|
||||
// Create floating damage text
|
||||
const damageText = {
|
||||
x: target.x,
|
||||
y: target.y - 30,
|
||||
text: `-${data.damage}`,
|
||||
color: getDamageColor(data.damageType),
|
||||
fontSize: data.isCrit ? 24 : 16,
|
||||
duration: 1500,
|
||||
velocity: { x: 0, y: -50 }
|
||||
};
|
||||
|
||||
floatingTexts.push(damageText);
|
||||
}
|
||||
|
||||
function getDamageColor(damageType) {
|
||||
switch(damageType) {
|
||||
case 'physical': return '#ffffff';
|
||||
case 'fire': return '#ff4500';
|
||||
case 'ice': return '#00bfff';
|
||||
case 'poison': return '#00ff00';
|
||||
case 'holy': return '#ffd700';
|
||||
default: return '#ffffff';
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 🎨 Phase 6: Client-Side Integration Needs
|
||||
|
||||
### 6.1 Required Client Features
|
||||
1. **Input Handling:**
|
||||
- Detect mouse click / attack button
|
||||
- Calculate direction from player to mouse cursor
|
||||
- Send `FIRE_PROJECTILE` packet with direction
|
||||
|
||||
2. **Projectile Rendering:**
|
||||
- Spawn projectile sprite at player position
|
||||
- Animate movement from server updates
|
||||
- Play arrow whoosh sound
|
||||
- Remove on hit/expire
|
||||
|
||||
3. **UI Updates:**
|
||||
- Quiver slot in equipment panel
|
||||
- Necklace slot in equipment panel
|
||||
- Ammunition count display
|
||||
- Quiver container UI (if using container)
|
||||
|
||||
4. **Damage Numbers:**
|
||||
- Floating text system
|
||||
- Color-coded by damage type
|
||||
- Critical hit animations (larger, different color)
|
||||
|
||||
### 6.2 Network Protocol
|
||||
**New OpCodes:**
|
||||
```csharp
|
||||
public enum DungeonOpCodes
|
||||
{
|
||||
// Existing...
|
||||
|
||||
// NEW:
|
||||
FIRE_PROJECTILE = 400, // Client → Server
|
||||
PROJECTILE_SPAWNED = 401, // Server → Client
|
||||
PROJECTILE_HIT = 402, // Server → Client
|
||||
PROJECTILE_EXPIRED = 403, // Server → Client
|
||||
DAMAGE_NOTIFICATION = 404, // Server → Client
|
||||
QUIVER_UPDATE = 405, // Server → Client (ammo count changed)
|
||||
}
|
||||
```
|
||||
|
||||
**Packet Structures:**
|
||||
```csharp
|
||||
// Client sends this
|
||||
public class FireProjectileRequest
|
||||
{
|
||||
public float DirectionX { get; set; } // Normalized
|
||||
public float DirectionY { get; set; } // Normalized
|
||||
}
|
||||
|
||||
// Server broadcasts this
|
||||
public class ProjectileSpawnedEvent
|
||||
{
|
||||
public Guid ProjectileId { get; set; }
|
||||
public ulong OwnerId { get; set; }
|
||||
public float X { get; set; }
|
||||
public float Y { get; set; }
|
||||
public float DirectionX { get; set; }
|
||||
public float DirectionY { get; set; }
|
||||
public float Speed { get; set; }
|
||||
public int SpriteId { get; set; }
|
||||
}
|
||||
|
||||
public class ProjectileHitEvent
|
||||
{
|
||||
public Guid ProjectileId { get; set; }
|
||||
public ulong TargetId { get; set; }
|
||||
public bool IsPlayer { get; set; }
|
||||
}
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 📋 Phase 7: Implementation Checklist
|
||||
|
||||
### Database & Schema
|
||||
- [ ] Create EF Core migration for new equipment slots
|
||||
- [ ] Add `ItemType.Ammunition` and `ItemType.QuiverContainer`
|
||||
- [ ] Create `dungeon_quiver_ammo_slots` table
|
||||
- [ ] Add weapon properties: `RequiresAmmunition`, `AmmunitionType`, `ProjectileSpeed`, `Range`
|
||||
- [ ] Add ammunition properties: damage ranges, bonuses, recovery modifiers
|
||||
|
||||
### Server-Side Core
|
||||
- [ ] Add `Projectile` class to dungeon simulation
|
||||
- [ ] Implement `HandleFireProjectile` handler
|
||||
- [ ] Implement `UpdateProjectiles` tick logic
|
||||
- [ ] Implement `CalculateProjectileDamage` formula
|
||||
- [ ] Implement arrow recovery mechanic
|
||||
- [ ] Add quiver slot handling to equip/unequip logic
|
||||
- [ ] Add necklace slot handling to equip/unequip logic
|
||||
|
||||
### Quiver Container System
|
||||
- [ ] Create `QuiverContainer` entity/model
|
||||
- [ ] Implement quiver ammo slot management
|
||||
- [ ] Handle equipping/unequipping quiver containers
|
||||
- [ ] Handle adding/removing ammo from quiver slots
|
||||
- [ ] UI for managing quiver contents (admin panel)
|
||||
|
||||
### Damage System
|
||||
- [ ] Implement `BroadcastDamageNotification`
|
||||
- [ ] Add damage type tracking
|
||||
- [ ] Add critical hit logic
|
||||
- [ ] Integrate with existing damage calculation
|
||||
|
||||
### UI Updates
|
||||
- [ ] Update admin Character.cshtml equipment list (add Quiver, Necklace)
|
||||
- [ ] Update Character.cshtml.cs computed stats (if quiver/necklace provide stats)
|
||||
- [ ] Add quiver management UI (if using containers)
|
||||
|
||||
### Client-Side (Path Needed!)
|
||||
- [ ] Add FIRE_PROJECTILE input handling
|
||||
- [ ] Add projectile rendering system
|
||||
- [ ] Add damage notification floating text
|
||||
- [ ] Add equipment slots UI (quiver, necklace)
|
||||
- [ ] Add quiver ammo count display
|
||||
- [ ] Add sounds (arrow whoosh, hit, etc.)
|
||||
|
||||
### Testing
|
||||
- [ ] Test direct ammo equip (stack of arrows in quiver slot)
|
||||
- [ ] Test quiver container equip (quiver with multiple ammo types)
|
||||
- [ ] Test firing with different weapons (bow, crossbow, throwables)
|
||||
- [ ] Test arrow recovery at 5% rate
|
||||
- [ ] Test damage calculations with various stat combinations
|
||||
- [ ] Test damage notifications appearance
|
||||
- [ ] Test edge cases (no ammo, out of range, invalid targets)
|
||||
|
||||
---
|
||||
|
||||
## 🔧 Technical Considerations
|
||||
|
||||
### Performance
|
||||
- **Projectiles:** Limit max projectiles per dungeon (e.g., 100)
|
||||
- **Collision:** Use spatial partitioning for large dungeons
|
||||
- **Broadcasting:** Only send projectile updates to players in same dungeon
|
||||
|
||||
### Balance
|
||||
- **Arrow Recovery:** Start at 5%, allow buffs up to 100%
|
||||
- **Damage Scaling:** Fine-tune STR/DEX ratio after testing
|
||||
- **Ammunition Cost:** Make arrows cheap enough to use freely
|
||||
- **Quiver Capacity:** 3-5 slots for containers, 100 stack for direct equip
|
||||
|
||||
### Security
|
||||
- **Validate Direction:** Ensure normalized vectors
|
||||
- **Rate Limiting:** Prevent spam (max 2-3 attacks per second)
|
||||
- **Range Checks:** Don't trust client, validate server-side
|
||||
- **Ammunition Checks:** Server is source of truth for ammo count
|
||||
|
||||
---
|
||||
|
||||
## 🚀 Recommended Implementation Order
|
||||
|
||||
1. ✅ **Phase 1:** Database schema (equipment slots enum) - DONE
|
||||
2. **Phase 2:** Database migration + ammunition item types
|
||||
3. **Phase 3:** Basic projectile firing (no quiver, simple damage)
|
||||
4. **Phase 4:** Damage notifications
|
||||
5. **Phase 5:** Arrow recovery mechanic
|
||||
6. **Phase 6:** Quiver container system
|
||||
7. **Phase 7:** Client-side rendering & UI
|
||||
8. **Phase 8:** Polish, balancing, testing
|
||||
|
||||
---
|
||||
|
||||
## ❓ Questions for You
|
||||
|
||||
1. **Client Path:** What's the absolute path to your client codebase?
|
||||
2. **Client Technology:** What's the client built with? (Unity, Godot, Phaser, custom engine?)
|
||||
3. **Quiver Preference:** Should we start with simple (direct ammo equip) or complex (container system)?
|
||||
4. **Damage Formula:** Prefer STR 30% / DEX 70%, or different ratio?
|
||||
5. **Arrow Recovery:** Should recovery chance vary by arrow type? (cheap arrows = 5%, expensive = 20%)
|
||||
6. **Throwables:** Should throwing knives/axes consume from inventory or be infinite?
|
||||
|
||||
Let me know your answers and I'll proceed with implementation!
|
||||
@@ -203,6 +203,73 @@
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<!-- Projectile/Ranged Weapon Properties -->
|
||||
<div id="projectileSection" class="card" style="display: @(isWeapon ? "block" : "none")">
|
||||
<div class="p-4 border-b border-gray-700">
|
||||
<h2 class="text-lg font-semibold text-white">Projectile & Ranged Weapon Properties</h2>
|
||||
<p class="text-sm text-gray-400 mt-1">Configuration for bows, crossbows, and throwable weapons</p>
|
||||
</div>
|
||||
<div class="p-6 space-y-6">
|
||||
<!-- Basic Projectile Settings -->
|
||||
<div class="grid grid-cols-2 md:grid-cols-4 gap-4">
|
||||
<div class="flex items-center pt-6">
|
||||
<label class="flex items-center gap-2 cursor-pointer">
|
||||
<input type="checkbox" id="requiresAmmoCheck" name="Item.RequiresAmmunition" value="true" checked="@Model.Item.RequiresAmmunition" class="w-4 h-4 rounded border-gray-600 bg-gray-800 text-indigo-600" onchange="toggleAmmoFields()" />
|
||||
<span class="text-gray-300">Requires Ammunition</span>
|
||||
</label>
|
||||
</div>
|
||||
<div class="flex items-center pt-6">
|
||||
<label class="flex items-center gap-2 cursor-pointer">
|
||||
<input type="checkbox" name="Item.IsThrowable" value="true" checked="@Model.Item.IsThrowable" class="w-4 h-4 rounded border-gray-600 bg-gray-800 text-indigo-600" />
|
||||
<span class="text-gray-300">Is Throwable</span>
|
||||
</label>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<!-- Ammunition Type -->
|
||||
<div id="ammoTypeSection" style="display: @(Model.Item.RequiresAmmunition ? "block" : "none")">
|
||||
<label class="label">Ammunition Type</label>
|
||||
<input type="text" name="Item.AmmunitionType" value="@Model.Item.AmmunitionType" class="input" maxlength="32" placeholder="e.g., arrow, bolt" />
|
||||
<p class="text-xs text-gray-500 mt-1">Must match the AmmunitionType of ammo items (e.g., "arrow" for bows, "bolt" for crossbows)</p>
|
||||
</div>
|
||||
|
||||
<!-- Projectile Physics -->
|
||||
<div class="grid grid-cols-2 md:grid-cols-4 gap-4">
|
||||
<div>
|
||||
<label class="label">Projectile Speed (px/s)</label>
|
||||
<input type="number" name="Item.ProjectileSpeed" value="@Model.Item.ProjectileSpeed" class="input" min="0" step="1" />
|
||||
<p class="text-xs text-gray-500 mt-1">0 = melee only</p>
|
||||
</div>
|
||||
<div>
|
||||
<label class="label">Max Range (pixels)</label>
|
||||
<input type="number" name="Item.ProjectileRange" value="@Model.Item.ProjectileRange" class="input" min="0" step="1" />
|
||||
<p class="text-xs text-gray-500 mt-1">Distance before projectile expires</p>
|
||||
</div>
|
||||
<div>
|
||||
<label class="label">Recovery Chance (%)</label>
|
||||
<input type="number" name="Item.ArrowRecoveryChance" value="@((Model.Item.ArrowRecoveryChance * 100).ToString("0.##"))" class="input" min="0" max="100" step="0.1" oninput="this.form.elements['Item.ArrowRecoveryChance'].value = this.value / 100" />
|
||||
<input type="hidden" name="Item.ArrowRecoveryChance" value="@Model.Item.ArrowRecoveryChance" />
|
||||
<p class="text-xs text-gray-500 mt-1">Chance to recover ammo after hit (for ammunition items)</p>
|
||||
</div>
|
||||
<div>
|
||||
<label class="label">Quiver Capacity</label>
|
||||
<input type="number" name="Item.QuiverCapacity" value="@Model.Item.QuiverCapacity" class="input" min="0" max="10" />
|
||||
<p class="text-xs text-gray-500 mt-1">Number of ammo slots (0 = not a quiver container)</p>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div class="bg-blue-900/20 border border-blue-700 rounded-lg p-4 text-sm text-blue-200">
|
||||
<strong>Weapon Types:</strong>
|
||||
<ul class="mt-2 space-y-1 ml-4">
|
||||
<li><strong>Bows/Crossbows:</strong> Enable "Requires Ammunition", set AmmunitionType, ProjectileSpeed, Range</li>
|
||||
<li><strong>Throwables (knives, javelins):</strong> Enable "Is Throwable", set ProjectileSpeed, Range (no ammo required - consumes from inventory)</li>
|
||||
<li><strong>Quiver Containers:</strong> Set QuiverCapacity > 0, equip to Quiver slot</li>
|
||||
<li><strong>Ammunition (arrows, bolts):</strong> Set Recovery Chance, make Stackable, set EquipSlot to Quiver</li>
|
||||
</ul>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<!-- Resistances (Equipment) -->
|
||||
<div id="resistancesSection" class="card" style="display: @(isEquipment ? "block" : "none")">
|
||||
<div class="p-4 border-b border-gray-700">
|
||||
@@ -292,6 +359,7 @@
|
||||
else { img.classList.add('hidden'); placeholder.classList.remove('hidden'); }
|
||||
}
|
||||
function toggleMaxStack() { const cb = document.getElementById('stackableCheck'); const input = document.getElementById('maxStackInput'); input.disabled = !cb.checked; if (!cb.checked) input.value = 1; }
|
||||
function toggleAmmoFields() { const cb = document.getElementById('requiresAmmoCheck'); const section = document.getElementById('ammoTypeSection'); section.style.display = cb.checked ? 'block' : 'none'; }
|
||||
function updateSections() {
|
||||
const type = document.getElementById('itemType').value;
|
||||
const isEquipment = ['Weapon', 'Armor', 'Accessory'].includes(type);
|
||||
@@ -308,6 +376,7 @@
|
||||
document.getElementById('damageTypeSection').style.display = isWeapon ? 'block' : 'none';
|
||||
document.getElementById('minDamageRangeSection').style.display = isWeapon ? 'block' : 'none';
|
||||
document.getElementById('maxDamageRangeSection').style.display = isWeapon ? 'block' : 'none';
|
||||
document.getElementById('projectileSection').style.display = isWeapon ? 'block' : 'none';
|
||||
document.getElementById('consumableSection').style.display = isConsumable ? 'block' : 'none';
|
||||
}
|
||||
function addResistance() {
|
||||
|
||||
@@ -211,7 +211,7 @@
|
||||
<div class="card p-4">
|
||||
<h2 class="text-md font-semibold text-white mb-3">Equipment</h2>
|
||||
<div class="space-y-1">
|
||||
@foreach (var slot in new[] {
|
||||
@foreach (var slot in new[] {
|
||||
(DungeonEquipmentSlot.MainHand, "Weapon"),
|
||||
(DungeonEquipmentSlot.OffHand, "Off-Hand"),
|
||||
(DungeonEquipmentSlot.Head, "Head"),
|
||||
@@ -219,8 +219,10 @@
|
||||
(DungeonEquipmentSlot.Legs, "Legs"),
|
||||
(DungeonEquipmentSlot.Boots, "Boots"),
|
||||
(DungeonEquipmentSlot.Gloves, "Gloves"),
|
||||
(DungeonEquipmentSlot.Accessory1, "Accessory 1"),
|
||||
(DungeonEquipmentSlot.Accessory2, "Accessory 2")
|
||||
(DungeonEquipmentSlot.Necklace, "Necklace"),
|
||||
(DungeonEquipmentSlot.Ring1, "Ring 1"),
|
||||
(DungeonEquipmentSlot.Ring2, "Ring 2"),
|
||||
(DungeonEquipmentSlot.Quiver, "Quiver")
|
||||
})
|
||||
{
|
||||
var item = Model.EquippedItems.FirstOrDefault(i => i.EquipSlot == slot.Item1);
|
||||
|
||||
@@ -133,7 +133,15 @@
|
||||
<svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 8c-1.657 0-3 .895-3 2s1.343 2 3 2 3 .895 3 2-1.343 2-3 2m0-8c1.11 0 2.08.402 2.599 1M12 8V7m0 1v8m0 0v1m0-1c-1.11 0-2.08-.402-2.599-1M21 12a9 9 0 11-18 0 9 9 0 0118 0z"/></svg>
|
||||
<span>Loot Tables</span>
|
||||
</a>
|
||||
|
||||
<a href="/admin/resistances" class="sidebar-link @(ViewContext.RouteData.Values["page"]?.ToString()?.StartsWith("/Resistances") == true ? "active" : "")" data-tooltip="Resistances">
|
||||
<svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 12l2 2 4-4m5.618-4.016A11.955 11.955 0 0112 2.944a11.955 11.955 0 01-8.618 3.04A12.02 12.02 0 003 9c0 5.591 3.824 10.29 9 11.622 5.176-1.332 9-6.03 9-11.622 0-1.042-.133-2.052-.382-3.016z"/></svg>
|
||||
<span>Resistances</span>
|
||||
</a>
|
||||
<a href="/admin/abilities" class="sidebar-link @(ViewContext.RouteData.Values["page"]?.ToString()?.StartsWith("/Abilities") == true ? "active" : "")" data-tooltip="Abilities">
|
||||
<svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M13 10V3L4 14h7v7l9-11h-7z"/></svg>
|
||||
<span>Abilities</span>
|
||||
</a>
|
||||
|
||||
<p class="section-title px-3 pt-3 pb-1 text-xs font-semibold text-gray-500 uppercase">Management</p>
|
||||
|
||||
<a href="/admin/dungeons" class="sidebar-link @(ViewContext.RouteData.Values["page"]?.ToString()?.StartsWith("/Dungeons") == true ? "active" : "")" data-tooltip="Dungeons">
|
||||
|
||||
@@ -64,7 +64,10 @@ public sealed class GameDbContext : DbContext
|
||||
|
||||
// Damage system
|
||||
public DbSet<DamageResistanceType> DamageResistanceTypes => Set<DamageResistanceType>();
|
||||
|
||||
|
||||
// Projectile/Quiver system
|
||||
public DbSet<DungeonQuiverAmmoSlot> DungeonQuiverAmmoSlots => Set<DungeonQuiverAmmoSlot>();
|
||||
|
||||
protected override void OnModelCreating(ModelBuilder b)
|
||||
{
|
||||
b.ApplyConfigurationsFromAssembly(typeof(GameDbContext).Assembly);
|
||||
|
||||
@@ -59,7 +59,10 @@ public class DungeonCharacter
|
||||
public ulong? EquippedLegs { get; set; }
|
||||
public ulong? EquippedBoots { get; set; }
|
||||
public ulong? EquippedGloves { get; set; }
|
||||
public ulong? EquippedAccessory { get; set; }
|
||||
public ulong? EquippedNecklace { get; set; }
|
||||
public ulong? EquippedRing1 { get; set; }
|
||||
public ulong? EquippedRing2 { get; set; }
|
||||
public ulong? EquippedQuiver { get; set; }
|
||||
|
||||
// Lifetime stats
|
||||
public int TotalKills { get; set; }
|
||||
|
||||
@@ -124,7 +124,49 @@ public class DungeonItemDefinition
|
||||
// Stacking
|
||||
public bool Stackable { get; set; } = false;
|
||||
public int MaxStack { get; set; } = 1;
|
||||
|
||||
|
||||
// Projectile/Ranged Weapon Properties
|
||||
/// <summary>
|
||||
/// Whether this weapon requires ammunition to fire (bows, crossbows)
|
||||
/// Throwable weapons (knives, javelins) don't require ammo but consume themselves
|
||||
/// </summary>
|
||||
public bool RequiresAmmunition { get; set; } = false;
|
||||
|
||||
/// <summary>
|
||||
/// Type of ammunition required (e.g., "arrow", "bolt")
|
||||
/// Null for melee weapons and throwables
|
||||
/// </summary>
|
||||
[MaxLength(32)]
|
||||
public string? AmmunitionType { get; set; }
|
||||
|
||||
/// <summary>
|
||||
/// Projectile speed in pixels per second (0 = melee weapon)
|
||||
/// </summary>
|
||||
public float ProjectileSpeed { get; set; } = 0;
|
||||
|
||||
/// <summary>
|
||||
/// Max range in pixels before projectile expires (0 = melee weapon)
|
||||
/// </summary>
|
||||
public int ProjectileRange { get; set; } = 0;
|
||||
|
||||
/// <summary>
|
||||
/// Chance (0.0 to 1.0) to recover this ammunition after hitting a target
|
||||
/// 0.05 = 5%, 0.20 = 20%, etc.
|
||||
/// Only applies to ammunition items
|
||||
/// </summary>
|
||||
public float ArrowRecoveryChance { get; set; } = 0.05f;
|
||||
|
||||
/// <summary>
|
||||
/// For quiver containers: number of ammo slots available
|
||||
/// 0 = not a container
|
||||
/// </summary>
|
||||
public int QuiverCapacity { get; set; } = 0;
|
||||
|
||||
/// <summary>
|
||||
/// Whether this item is throwable (consumes from inventory)
|
||||
/// </summary>
|
||||
public bool IsThrowable { get; set; } = false;
|
||||
|
||||
// Visuals
|
||||
/// <summary>
|
||||
/// Path to the item's sprite image on CDN (e.g., "textures/items/sword_iron.png")
|
||||
|
||||
@@ -0,0 +1,51 @@
|
||||
using System.ComponentModel.DataAnnotations;
|
||||
using System.ComponentModel.DataAnnotations.Schema;
|
||||
|
||||
namespace DataServer.Data.Entities;
|
||||
|
||||
/// <summary>
|
||||
/// Represents an ammunition slot within a quiver container
|
||||
/// Each equipped quiver can hold multiple types of ammunition
|
||||
/// </summary>
|
||||
[Table("dungeon_quiver_ammo_slots")]
|
||||
public class DungeonQuiverAmmoSlot
|
||||
{
|
||||
[Key]
|
||||
public ulong Id { get; set; }
|
||||
|
||||
/// <summary>
|
||||
/// The character item ID of the equipped quiver container
|
||||
/// This links to the actual quiver item in the character's equipment
|
||||
/// </summary>
|
||||
[Required]
|
||||
public ulong QuiverCharacterItemId { get; set; }
|
||||
|
||||
/// <summary>
|
||||
/// Slot index within the quiver (0 to QuiverCapacity-1)
|
||||
/// </summary>
|
||||
[Required]
|
||||
public int SlotIndex { get; set; }
|
||||
|
||||
/// <summary>
|
||||
/// The item definition ID of the ammunition in this slot
|
||||
/// References DungeonItemDefinition.Id
|
||||
/// </summary>
|
||||
[Required]
|
||||
public int ItemDefinitionId { get; set; }
|
||||
|
||||
/// <summary>
|
||||
/// Current quantity of this ammunition type in the slot
|
||||
/// </summary>
|
||||
[Required]
|
||||
public int Quantity { get; set; } = 0;
|
||||
|
||||
/// <summary>
|
||||
/// Maximum quantity allowed in this slot (from item definition's MaxStack)
|
||||
/// </summary>
|
||||
[Required]
|
||||
public int MaxQuantity { get; set; } = 100;
|
||||
|
||||
// Navigation properties
|
||||
public virtual DungeonCharacterItem? QuiverItem { get; set; }
|
||||
public virtual DungeonItemDefinition? ItemDefinition { get; set; }
|
||||
}
|
||||
@@ -9,6 +9,8 @@ public enum DungeonEquipmentSlot
|
||||
Legs,
|
||||
Boots,
|
||||
Gloves,
|
||||
Accessory1,
|
||||
Accessory2,
|
||||
Necklace,
|
||||
Ring1,
|
||||
Ring2,
|
||||
Quiver
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user