Mob AIv2 and player speed cap

This commit is contained in:
dingo
2025-12-27 11:09:09 -05:00
parent 4d26c37671
commit 9c67dd3935
14 changed files with 3479 additions and 34 deletions
+462
View File
@@ -0,0 +1,462 @@
using DataServer.Data.Entities;
using DataServer.Data.Enums;
namespace Server.Game.Dungeon;
/// <summary>
/// Handles mob AI behavior and decision making
/// </summary>
public static class MobAI
{
/// <summary>
/// Main AI update - called each tick for each mob
/// </summary>
public static void UpdateMob(MobInstance mob, DungeonSimulation sim, float deltaTime)
{
if (!mob.IsAlive || mob.IsStunned) return;
// Update cooldowns
UpdateCooldowns(mob, deltaTime);
// Update status effects
UpdateStatusEffects(mob, sim, deltaTime);
// Check for phase transitions (for bosses)
CheckPhaseTransition(mob);
// Update state time
mob.StateTime += deltaTime;
// Handle casting
if (mob.CastingAbility != null)
{
mob.CastTimeRemaining -= deltaTime;
if (mob.CastTimeRemaining <= 0)
{
ExecuteAbility(mob, mob.CastingAbility, sim);
mob.CastingAbility = null;
mob.State = MobState.Idle;
}
return;
}
// Main behavior switch
switch (mob.Behavior)
{
case MobBehavior.Aggressive:
UpdateAggressive(mob, sim, deltaTime);
break;
case MobBehavior.Defensive:
UpdateDefensive(mob, sim, deltaTime);
break;
case MobBehavior.Ranged:
UpdateRanged(mob, sim, deltaTime);
break;
case MobBehavior.Skirmisher:
UpdateSkirmisher(mob, sim, deltaTime);
break;
case MobBehavior.Summoner:
case MobBehavior.Tank:
case MobBehavior.Assassin:
case MobBehavior.Healer:
case MobBehavior.Patrol:
case MobBehavior.Pack:
// For now, fall back to aggressive behavior
// TODO: Implement specialized behaviors
UpdateAggressive(mob, sim, deltaTime);
break;
}
}
#region Core Behaviors
private static void UpdateAggressive(MobInstance mob, DungeonSimulation sim, float deltaTime)
{
var target = FindNearestPlayer(mob, sim);
if (target == null)
{
ReturnToSpawn(mob, sim, deltaTime);
return;
}
float distance = GetDistance(mob.X, mob.Y, target.X, target.Y);
mob.TargetId = target.CharacterId;
mob.UpdateFacingDirection(target.X, target.Y);
mob.CombatTime += deltaTime;
// Try to use abilities
var ability = SelectAbility(mob, distance);
if (ability != null && TryUseAbility(mob, ability, target, sim))
{
return;
}
// Chase and melee
if (distance <= mob.Stats.AttackRange)
{
mob.State = MobState.Attacking;
mob.CurrentAnimation = mob.GetDirectionalAnimation("attack");
}
else if (distance <= mob.Stats.LeashRange)
{
mob.State = MobState.Chasing;
mob.CurrentAnimation = mob.GetDirectionalAnimation("walk");
MoveToward(mob, target.X, target.Y, mob.Stats.MoveSpeed * mob.GetSpeedModifier() * deltaTime);
}
else
{
ReturnToSpawn(mob, sim, deltaTime);
}
}
private static void UpdateDefensive(MobInstance mob, DungeonSimulation sim, float deltaTime)
{
float distFromSpawn = GetDistance(mob.X, mob.Y, mob.SpawnX, mob.SpawnY);
var target = FindNearestPlayer(mob, sim);
if (target != null)
{
float targetDistFromSpawn = GetDistance(target.X, target.Y, mob.SpawnX, mob.SpawnY);
float distance = GetDistance(mob.X, mob.Y, target.X, target.Y);
if (targetDistFromSpawn <= mob.Stats.AggroRange)
{
mob.TargetId = target.CharacterId;
mob.UpdateFacingDirection(target.X, target.Y);
if (distFromSpawn > mob.Stats.LeashRange * 0.5f)
{
ReturnToSpawn(mob, sim, deltaTime);
return;
}
var ability = SelectAbility(mob, distance);
if (ability != null && TryUseAbility(mob, ability, target, sim))
{
return;
}
if (distance <= mob.Stats.AttackRange)
{
mob.State = MobState.Attacking;
}
else
{
mob.State = MobState.Chasing;
MoveToward(mob, target.X, target.Y, mob.Stats.MoveSpeed * 0.7f * deltaTime);
}
}
else
{
mob.TargetId = null;
ReturnToSpawn(mob, sim, deltaTime);
}
}
else
{
ReturnToSpawn(mob, sim, deltaTime);
}
}
private static void UpdateRanged(MobInstance mob, DungeonSimulation sim, float deltaTime)
{
var target = FindNearestPlayer(mob, sim);
if (target == null)
{
ReturnToSpawn(mob, sim, deltaTime);
return;
}
float distance = GetDistance(mob.X, mob.Y, target.X, target.Y);
mob.TargetId = target.CharacterId;
mob.UpdateFacingDirection(target.X, target.Y);
mob.CombatTime += deltaTime;
var ability = SelectAbility(mob, distance, preferRanged: true);
if (ability != null && TryUseAbility(mob, ability, target, sim))
{
return;
}
// Maintain preferred range
if (distance < mob.PreferredRange * 0.6f)
{
mob.State = MobState.Kiting;
MoveAwayFrom(mob, target.X, target.Y, mob.Stats.MoveSpeed * deltaTime);
}
else if (distance > mob.PreferredRange * 1.2f && distance <= mob.Stats.LeashRange)
{
mob.State = MobState.Chasing;
MoveToward(mob, target.X, target.Y, mob.Stats.MoveSpeed * deltaTime);
}
else if (distance > mob.Stats.LeashRange)
{
ReturnToSpawn(mob, sim, deltaTime);
}
else
{
mob.State = MobState.Attacking;
}
}
private static void UpdateSkirmisher(MobInstance mob, DungeonSimulation sim, float deltaTime)
{
var target = FindNearestPlayer(mob, sim);
if (target == null)
{
ReturnToSpawn(mob, sim, deltaTime);
return;
}
float distance = GetDistance(mob.X, mob.Y, target.X, target.Y);
mob.TargetId = target.CharacterId;
mob.UpdateFacingDirection(target.X, target.Y);
if (mob.HpPercent <= mob.FleeThreshold && mob.FleeThreshold > 0)
{
mob.State = MobState.Fleeing;
MoveAwayFrom(mob, target.X, target.Y, mob.Stats.MoveSpeed * 1.2f * deltaTime);
return;
}
// Attack then retreat pattern
if (mob.State == MobState.Attacking && mob.StateTime < 2.0f)
{
var ability = SelectAbility(mob, distance);
if (ability != null && TryUseAbility(mob, ability, target, sim))
{
return;
}
if (distance <= mob.Stats.AttackRange)
{
mob.CurrentAnimation = mob.GetDirectionalAnimation("attack");
}
else
{
MoveToward(mob, target.X, target.Y, mob.Stats.MoveSpeed * deltaTime);
}
}
else if (mob.StateTime < 4.0f)
{
mob.State = MobState.Kiting;
MoveAwayFrom(mob, target.X, target.Y, mob.Stats.MoveSpeed * deltaTime);
}
else
{
mob.StateTime = 0;
mob.State = MobState.Attacking;
}
}
#endregion
#region Ability System
private static MobAbilityState? SelectAbility(MobInstance mob, float distance, bool preferRanged = false)
{
var available = mob.Abilities
.Where(a => a.IsAvailable(mob.HpPercent))
.Where(a => a.Phase == 0 || a.Phase == mob.CurrentPhase)
.Where(a => a.Definition.Range >= distance || a.Definition.Range == 0)
.ToList();
if (preferRanged)
{
available = available
.Where(a => a.Definition.AbilityType == MobAbilityType.ProjectileSingle ||
a.Definition.AbilityType == MobAbilityType.ProjectileAoe)
.ToList();
}
if (available.Count == 0) return null;
// Weight by priority
var weighted = available.OrderByDescending(a => a.Priority).ToList();
// Add some randomness
if (weighted.Count > 1 && Random.Shared.NextDouble() < 0.3)
{
return weighted[Random.Shared.Next(weighted.Count)];
}
return weighted.FirstOrDefault();
}
private static bool TryUseAbility(MobInstance mob, MobAbilityState ability, PlayerInstance target, DungeonSimulation sim)
{
if (!ability.IsAvailable(mob.HpPercent)) return false;
if (mob.IsSilenced && ability.Definition.CastTime > 0) return false;
float distance = GetDistance(mob.X, mob.Y, target.X, target.Y);
if (ability.Definition.Range > 0 && distance > ability.Definition.Range) return false;
// Check mana cost
if (ability.Definition.ManaCost > mob.Mana) return false;
// Start casting
if (ability.Definition.CastTime > 0)
{
mob.CastingAbility = ability;
mob.CastTimeRemaining = ability.Definition.CastTime;
mob.State = MobState.Casting;
mob.CurrentAnimation = mob.GetDirectionalAnimation(ability.Definition.AnimationKey);
return true;
}
// Instant ability
ExecuteAbility(mob, ability, sim);
return true;
}
private static void ExecuteAbility(MobInstance mob, MobAbilityState ability, DungeonSimulation sim)
{
ability.CooldownRemaining = ability.Definition.Cooldown;
mob.Mana -= ability.Definition.ManaCost;
mob.CurrentAnimation = mob.GetDirectionalAnimation(ability.Definition.AnimationKey);
// TODO: Queue the ability effect for the simulation to process
// For now, abilities are tracked but effects need to be wired up in DungeonSimulation
// The simulation will need to check mob.CastingAbility and process effects there
}
#endregion
#region Helpers
private static void UpdateCooldowns(MobInstance mob, float deltaTime)
{
foreach (var ability in mob.Abilities)
{
if (ability.CooldownRemaining > 0)
ability.CooldownRemaining -= deltaTime;
}
}
private static void UpdateStatusEffects(MobInstance mob, DungeonSimulation sim, float deltaTime)
{
var expired = new List<MobStatusEffect>();
foreach (var effect in mob.StatusEffects)
{
effect.Duration -= deltaTime;
// Handle DOT
if (effect.DamagePerTick > 0)
{
effect.NextTickIn -= deltaTime;
if (effect.NextTickIn <= 0)
{
mob.Health -= effect.DamagePerTick;
effect.NextTickIn = effect.TickInterval;
if (mob.Health <= 0)
{
mob.Health = 0;
mob.IsAlive = false;
mob.State = MobState.Dead;
}
}
}
if (effect.Duration <= 0)
expired.Add(effect);
}
foreach (var e in expired)
mob.StatusEffects.Remove(e);
}
private static void CheckPhaseTransition(MobInstance mob)
{
if (mob.Phases == null || mob.Phases.Count == 0) return;
for (int i = mob.Phases.Count - 1; i >= 0; i--)
{
var phase = mob.Phases[i];
if (mob.HpPercent <= phase.HpThreshold && mob.CurrentPhase < i + 1)
{
mob.CurrentPhase = i + 1;
mob.Behavior = phase.Behavior;
mob.StateTime = 0;
break;
}
}
}
private static PlayerInstance? FindNearestPlayer(MobInstance mob, DungeonSimulation sim)
{
return sim.Players.Values
.Where(p => p.IsAlive)
.Where(p => GetDistance(mob.X, mob.Y, p.X, p.Y) <= mob.Stats.AggroRange)
.OrderBy(p => GetDistance(mob.X, mob.Y, p.X, p.Y))
.FirstOrDefault();
}
private static void ReturnToSpawn(MobInstance mob, DungeonSimulation sim, float deltaTime)
{
float dist = GetDistance(mob.X, mob.Y, mob.SpawnX, mob.SpawnY);
if (dist < 10f)
{
mob.State = MobState.Idle;
mob.TargetId = null;
mob.CombatTime = 0;
mob.CurrentAnimation = mob.GetDirectionalAnimation("idle");
// Heal when returning
if (mob.Health < mob.MaxHealth)
{
mob.Health = Math.Min(mob.MaxHealth, mob.Health + (int)(mob.MaxHealth * 0.1f * deltaTime));
}
}
else
{
mob.State = MobState.Returning;
mob.UpdateFacingDirection(mob.SpawnX, mob.SpawnY);
mob.CurrentAnimation = mob.GetDirectionalAnimation("walk");
MoveToward(mob, mob.SpawnX, mob.SpawnY, mob.Stats.MoveSpeed * deltaTime);
}
}
private static void MoveToward(MobInstance mob, float targetX, float targetY, float speed)
{
if (mob.IsRooted) return;
float dx = targetX - mob.X;
float dy = targetY - mob.Y;
float dist = MathF.Sqrt(dx * dx + dy * dy);
if (dist > 0)
{
mob.X += (dx / dist) * speed;
mob.Y += (dy / dist) * speed;
}
}
private static void MoveAwayFrom(MobInstance mob, float targetX, float targetY, float speed)
{
if (mob.IsRooted) return;
float dx = mob.X - targetX;
float dy = mob.Y - targetY;
float dist = MathF.Sqrt(dx * dx + dy * dy);
if (dist > 0)
{
mob.X += (dx / dist) * speed;
mob.Y += (dy / dist) * speed;
}
}
private static float GetDistance(float x1, float y1, float x2, float y2)
{
float dx = x2 - x1;
float dy = y2 - y1;
return MathF.Sqrt(dx * dx + dy * dy);
}
#endregion
}
+147 -3
View File
@@ -20,6 +20,45 @@ public class CarriedLootItem
public int Quantity { get; set; }
}
/// <summary>
/// Runtime state for a mob ability
/// </summary>
public class MobAbilityState
{
public int AbilityId { get; set; }
public MobAbilityDefinition Definition { get; set; } = null!;
public float CooldownRemaining { get; set; }
public int Priority { get; set; }
public int Phase { get; set; }
public float? MinHpPercent { get; set; }
public float? MaxHpPercent { get; set; }
/// <summary>
/// Check if this ability is available (off cooldown and HP in range)
/// </summary>
public bool IsAvailable(float currentHpPercent)
{
if (CooldownRemaining > 0) return false;
if (MinHpPercent.HasValue && currentHpPercent < MinHpPercent.Value) return false;
if (MaxHpPercent.HasValue && currentHpPercent > MaxHpPercent.Value) return false;
return true;
}
}
/// <summary>
/// Active status effect on a mob
/// </summary>
public class MobStatusEffect
{
public string EffectType { get; set; } = ""; // poison, bleed, burn, slow, stun, etc.
public float Duration { get; set; }
public float TickInterval { get; set; }
public float NextTickIn { get; set; }
public int DamagePerTick { get; set; }
public float Modifier { get; set; } = 1.0f; // For slow, etc.
public ulong SourcePlayerId { get; set; }
}
/// <summary>
/// Runtime instance of a mob in a dungeon
/// </summary>
@@ -37,15 +76,73 @@ public class MobInstance
public int Health { get; set; }
public int MaxHealth { get; set; }
public int Mana { get; set; }
public int MaxMana { get; set; }
public bool IsAlive { get; set; } = true;
public DungeonMobCombatStats Stats { get; set; } = new();
public MobState State { get; set; } = MobState.Idle;
public MobType Type { get; set; }
public MobBehavior Behavior { get; set; } = MobBehavior.Aggressive;
/// <summary>Current phase for multi-phase mobs (0 = first phase)</summary>
public int CurrentPhase { get; set; } = 0;
/// <summary>Phase configurations loaded from definition</summary>
public List<MobPhaseConfig>? Phases { get; set; }
public ulong? TargetId { get; set; }
public long LastAttackTick { get; set; }
/// <summary>Time spent in current state (for behavior decisions)</summary>
public float StateTime { get; set; }
/// <summary>Last position for stuck detection</summary>
public float LastX { get; set; }
public float LastY { get; set; }
public float StuckTime { get; set; }
// === Abilities ===
/// <summary>Abilities this mob can use</summary>
public List<MobAbilityState> Abilities { get; set; } = new();
/// <summary>Currently casting ability (null if not casting)</summary>
public MobAbilityState? CastingAbility { get; set; }
/// <summary>Remaining cast time</summary>
public float CastTimeRemaining { get; set; }
/// <summary>Active status effects on this mob</summary>
public List<MobStatusEffect> StatusEffects { get; set; } = new();
/// <summary>Current animation being played</summary>
public string CurrentAnimation { get; set; } = "idle";
/// <summary>Direction mob is facing (down, up, left, right)</summary>
public string FacingDirection { get; set; } = "down";
// === Behavior-specific ===
/// <summary>Preferred combat distance (for ranged/skirmisher)</summary>
public float PreferredRange { get; set; } = 40f;
/// <summary>Flee threshold HP percentage</summary>
public float FleeThreshold { get; set; } = 0f;
/// <summary>Has already called for help this combat</summary>
public bool HasCalledForHelp { get; set; }
/// <summary>Patrol waypoints (for Patrol behavior)</summary>
public List<(float X, float Y)>? PatrolPath { get; set; }
/// <summary>Current patrol waypoint index</summary>
public int PatrolIndex { get; set; }
/// <summary>Enrage stacks (for Enrage behavior)</summary>
public int EnrageStacks { get; set; }
/// <summary>Time since combat started (for time-based mechanics)</summary>
public float CombatTime { get; set; }
// Visual - sprite configuration JSON
public string? SpriteConfigJson { get; set; }
public string TintColor { get; set; } = "#ffffff";
@@ -54,10 +151,53 @@ public class MobInstance
// Carried loot from player kills
public List<CarriedLoot> CarriedPlayerLoot { get; set; } = new();
/// <summary>
/// Check if this mob is carrying loot from player kills
/// </summary>
/// <summary>Check if this mob is carrying loot from player kills</summary>
public bool HasCarriedLoot => CarriedPlayerLoot.Count > 0;
/// <summary>Current HP as percentage (0-1)</summary>
public float HpPercent => MaxHealth > 0 ? (float)Health / MaxHealth : 0f;
/// <summary>Check if mob is stunned</summary>
public bool IsStunned => StatusEffects.Any(e => e.EffectType == "stun" && e.Duration > 0);
/// <summary>Check if mob is rooted</summary>
public bool IsRooted => StatusEffects.Any(e => e.EffectType == "root" && e.Duration > 0);
/// <summary>Check if mob is silenced</summary>
public bool IsSilenced => StatusEffects.Any(e => e.EffectType == "silence" && e.Duration > 0);
/// <summary>Get current speed modifier from status effects</summary>
public float GetSpeedModifier()
{
float modifier = 1.0f;
foreach (var effect in StatusEffects.Where(e => e.EffectType == "slow"))
{
modifier *= effect.Modifier;
}
return modifier;
}
/// <summary>Update facing direction based on movement</summary>
public void UpdateFacingDirection(float targetX, float targetY)
{
float dx = targetX - X;
float dy = targetY - Y;
if (Math.Abs(dx) > Math.Abs(dy))
{
FacingDirection = dx > 0 ? "right" : "left";
}
else
{
FacingDirection = dy > 0 ? "down" : "up";
}
}
/// <summary>Get the animation key with direction</summary>
public string GetDirectionalAnimation(string baseAnim)
{
return $"{baseAnim}_{FacingDirection}";
}
}
public enum MobState
@@ -65,7 +205,11 @@ public enum MobState
Idle,
Chasing,
Attacking,
Casting,
Returning,
Fleeing,
Kiting, // Moving away while attacking (skirmisher)
Summoning, // In summoning animation
Healing, // Healing self or ally
Dead
}
File diff suppressed because it is too large Load Diff
+223
View File
@@ -0,0 +1,223 @@
using System;
using Microsoft.EntityFrameworkCore.Metadata;
using Microsoft.EntityFrameworkCore.Migrations;
#nullable disable
namespace SystemRevivalServer.Migrations
{
/// <inheritdoc />
public partial class MobAI : Migration
{
/// <inheritdoc />
protected override void Up(MigrationBuilder migrationBuilder)
{
migrationBuilder.DropColumn(
name: "AbilitiesJson",
table: "dungeon_mob_definitions");
migrationBuilder.AlterColumn<string>(
name: "SpriteConfigJson",
table: "dungeon_mob_definitions",
type: "varchar(8192)",
maxLength: 8192,
nullable: true,
oldClrType: typeof(string),
oldType: "varchar(4096)",
oldMaxLength: 4096,
oldNullable: true)
.Annotation("MySql:CharSet", "utf8mb4")
.OldAnnotation("MySql:CharSet", "utf8mb4");
migrationBuilder.AddColumn<int>(
name: "Behavior",
table: "dungeon_mob_definitions",
type: "int",
nullable: false,
defaultValue: 0);
migrationBuilder.AddColumn<float>(
name: "CallForHelpRadius",
table: "dungeon_mob_definitions",
type: "float",
nullable: false,
defaultValue: 0f);
migrationBuilder.AddColumn<float>(
name: "FleeThreshold",
table: "dungeon_mob_definitions",
type: "float",
nullable: false,
defaultValue: 0f);
migrationBuilder.AddColumn<string>(
name: "PhasesJson",
table: "dungeon_mob_definitions",
type: "varchar(2048)",
maxLength: 2048,
nullable: true)
.Annotation("MySql:CharSet", "utf8mb4");
migrationBuilder.AddColumn<float>(
name: "PreferredRange",
table: "dungeon_mob_definitions",
type: "float",
nullable: false,
defaultValue: 0f);
migrationBuilder.CreateTable(
name: "dungeon_mob_abilities",
columns: table => new
{
Id = table.Column<int>(type: "int", nullable: false)
.Annotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn),
Name = table.Column<string>(type: "varchar(64)", maxLength: 64, nullable: false)
.Annotation("MySql:CharSet", "utf8mb4"),
Description = table.Column<string>(type: "varchar(256)", maxLength: 256, nullable: false)
.Annotation("MySql:CharSet", "utf8mb4"),
Key = table.Column<string>(type: "varchar(64)", maxLength: 64, nullable: false)
.Annotation("MySql:CharSet", "utf8mb4"),
AbilityType = table.Column<int>(type: "int", nullable: false),
Targeting = table.Column<int>(type: "int", nullable: false),
BaseDamage = table.Column<int>(type: "int", nullable: false),
DamagePerTier = table.Column<float>(type: "float", nullable: false),
DamageTypeKey = table.Column<string>(type: "varchar(32)", maxLength: 32, nullable: false)
.Annotation("MySql:CharSet", "utf8mb4"),
Range = table.Column<float>(type: "float", nullable: false),
AoeRadius = table.Column<float>(type: "float", nullable: false),
ConeAngle = table.Column<float>(type: "float", nullable: false),
Cooldown = table.Column<float>(type: "float", nullable: false),
CastTime = table.Column<float>(type: "float", nullable: false),
AnimationDuration = table.Column<float>(type: "float", nullable: false),
ProjectileSpeed = table.Column<float>(type: "float", nullable: false),
ProjectileSprite = table.Column<string>(type: "varchar(256)", maxLength: 256, nullable: true)
.Annotation("MySql:CharSet", "utf8mb4"),
EffectDuration = table.Column<float>(type: "float", nullable: false),
DotDamagePerTick = table.Column<int>(type: "int", nullable: false),
DotTickInterval = table.Column<float>(type: "float", nullable: false),
SpeedModifier = table.Column<float>(type: "float", nullable: false),
DisplacementDistance = table.Column<float>(type: "float", nullable: false),
SummonMobId = table.Column<int>(type: "int", nullable: true),
SummonCount = table.Column<int>(type: "int", nullable: false),
StatModifier = table.Column<float>(type: "float", nullable: false),
AffectedStat = table.Column<string>(type: "varchar(32)", maxLength: 32, nullable: true)
.Annotation("MySql:CharSet", "utf8mb4"),
HpThresholdBelow = table.Column<float>(type: "float", nullable: true),
HpThresholdAbove = table.Column<float>(type: "float", nullable: true),
MinTargetsInRange = table.Column<int>(type: "int", nullable: true),
Priority = table.Column<int>(type: "int", nullable: false),
ManaCost = table.Column<int>(type: "int", nullable: false),
AnimationKey = table.Column<string>(type: "varchar(32)", maxLength: 32, nullable: false)
.Annotation("MySql:CharSet", "utf8mb4"),
SoundEffectKey = table.Column<string>(type: "varchar(64)", maxLength: 64, nullable: true)
.Annotation("MySql:CharSet", "utf8mb4"),
VisualEffectKey = table.Column<string>(type: "varchar(64)", maxLength: 64, nullable: true)
.Annotation("MySql:CharSet", "utf8mb4"),
IsEnabled = table.Column<bool>(type: "tinyint(1)", nullable: false),
CreatedAt = table.Column<DateTime>(type: "datetime(6)", nullable: false),
UpdatedAt = table.Column<DateTime>(type: "datetime(6)", nullable: false)
},
constraints: table =>
{
table.PrimaryKey("PK_dungeon_mob_abilities", x => x.Id);
})
.Annotation("MySql:CharSet", "utf8mb4");
migrationBuilder.CreateTable(
name: "dungeon_mob_ability_assignments",
columns: table => new
{
Id = table.Column<int>(type: "int", nullable: false)
.Annotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn),
MobDefinitionId = table.Column<int>(type: "int", nullable: false),
AbilityDefinitionId = table.Column<int>(type: "int", nullable: false),
CooldownOverride = table.Column<float>(type: "float", nullable: true),
DamageOverride = table.Column<int>(type: "int", nullable: true),
PriorityOverride = table.Column<int>(type: "int", nullable: true),
Phase = table.Column<int>(type: "int", nullable: false),
MinHpPercent = table.Column<float>(type: "float", nullable: true),
MaxHpPercent = table.Column<float>(type: "float", nullable: true),
IsEnabled = table.Column<bool>(type: "tinyint(1)", nullable: false)
},
constraints: table =>
{
table.PrimaryKey("PK_dungeon_mob_ability_assignments", x => x.Id);
table.ForeignKey(
name: "FK_dungeon_mob_ability_assignments_dungeon_mob_abilities_Abilit~",
column: x => x.AbilityDefinitionId,
principalTable: "dungeon_mob_abilities",
principalColumn: "Id",
onDelete: ReferentialAction.Cascade);
table.ForeignKey(
name: "FK_dungeon_mob_ability_assignments_dungeon_mob_definitions_MobD~",
column: x => x.MobDefinitionId,
principalTable: "dungeon_mob_definitions",
principalColumn: "Id",
onDelete: ReferentialAction.Cascade);
})
.Annotation("MySql:CharSet", "utf8mb4");
migrationBuilder.CreateIndex(
name: "IX_dungeon_mob_ability_assignments_AbilityDefinitionId",
table: "dungeon_mob_ability_assignments",
column: "AbilityDefinitionId");
migrationBuilder.CreateIndex(
name: "IX_dungeon_mob_ability_assignments_MobDefinitionId",
table: "dungeon_mob_ability_assignments",
column: "MobDefinitionId");
}
/// <inheritdoc />
protected override void Down(MigrationBuilder migrationBuilder)
{
migrationBuilder.DropTable(
name: "dungeon_mob_ability_assignments");
migrationBuilder.DropTable(
name: "dungeon_mob_abilities");
migrationBuilder.DropColumn(
name: "Behavior",
table: "dungeon_mob_definitions");
migrationBuilder.DropColumn(
name: "CallForHelpRadius",
table: "dungeon_mob_definitions");
migrationBuilder.DropColumn(
name: "FleeThreshold",
table: "dungeon_mob_definitions");
migrationBuilder.DropColumn(
name: "PhasesJson",
table: "dungeon_mob_definitions");
migrationBuilder.DropColumn(
name: "PreferredRange",
table: "dungeon_mob_definitions");
migrationBuilder.AlterColumn<string>(
name: "SpriteConfigJson",
table: "dungeon_mob_definitions",
type: "varchar(4096)",
maxLength: 4096,
nullable: true,
oldClrType: typeof(string),
oldType: "varchar(8192)",
oldMaxLength: 8192,
oldNullable: true)
.Annotation("MySql:CharSet", "utf8mb4")
.OldAnnotation("MySql:CharSet", "utf8mb4");
migrationBuilder.AddColumn<string>(
name: "AbilitiesJson",
table: "dungeon_mob_definitions",
type: "varchar(1024)",
maxLength: 1024,
nullable: false,
defaultValue: "")
.Annotation("MySql:CharSet", "utf8mb4");
}
}
}
+221 -7
View File
@@ -963,11 +963,6 @@ namespace SystemRevivalServer.Migrations
MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("Id"));
b.Property<string>("AbilitiesJson")
.IsRequired()
.HasMaxLength(1024)
.HasColumnType("varchar(1024)");
b.Property<float>("AggroRange")
.HasColumnType("float");
@@ -1004,6 +999,12 @@ namespace SystemRevivalServer.Migrations
b.Property<int>("BaseXp")
.HasColumnType("int");
b.Property<int>("Behavior")
.HasColumnType("int");
b.Property<float>("CallForHelpRadius")
.HasColumnType("float");
b.Property<int>("Category")
.HasColumnType("int");
@@ -1023,6 +1024,9 @@ namespace SystemRevivalServer.Migrations
b.Property<float>("DropChanceMultiplier")
.HasColumnType("float");
b.Property<float>("FleeThreshold")
.HasColumnType("float");
b.Property<float>("HealthPerTier")
.HasColumnType("float");
@@ -1049,6 +1053,13 @@ namespace SystemRevivalServer.Migrations
.HasMaxLength(64)
.HasColumnType("varchar(64)");
b.Property<string>("PhasesJson")
.HasMaxLength(2048)
.HasColumnType("varchar(2048)");
b.Property<float>("PreferredRange")
.HasColumnType("float");
b.Property<string>("ResistancesJson")
.IsRequired()
.HasMaxLength(1024)
@@ -1058,8 +1069,8 @@ namespace SystemRevivalServer.Migrations
.HasColumnType("float");
b.Property<string>("SpriteConfigJson")
.HasMaxLength(4096)
.HasColumnType("varchar(4096)");
.HasMaxLength(8192)
.HasColumnType("varchar(8192)");
b.Property<string>("TintColor")
.IsRequired()
@@ -1298,6 +1309,185 @@ namespace SystemRevivalServer.Migrations
b.ToTable("dungeon_stash_items");
});
modelBuilder.Entity("DataServer.Data.Entities.MobAbilityAssignment", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("int");
MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("Id"));
b.Property<int>("AbilityDefinitionId")
.HasColumnType("int");
b.Property<float?>("CooldownOverride")
.HasColumnType("float");
b.Property<int?>("DamageOverride")
.HasColumnType("int");
b.Property<bool>("IsEnabled")
.HasColumnType("tinyint(1)");
b.Property<float?>("MaxHpPercent")
.HasColumnType("float");
b.Property<float?>("MinHpPercent")
.HasColumnType("float");
b.Property<int>("MobDefinitionId")
.HasColumnType("int");
b.Property<int>("Phase")
.HasColumnType("int");
b.Property<int?>("PriorityOverride")
.HasColumnType("int");
b.HasKey("Id");
b.HasIndex("AbilityDefinitionId");
b.HasIndex("MobDefinitionId");
b.ToTable("dungeon_mob_ability_assignments");
});
modelBuilder.Entity("DataServer.Data.Entities.MobAbilityDefinition", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("int");
MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("Id"));
b.Property<int>("AbilityType")
.HasColumnType("int");
b.Property<string>("AffectedStat")
.HasMaxLength(32)
.HasColumnType("varchar(32)");
b.Property<float>("AnimationDuration")
.HasColumnType("float");
b.Property<string>("AnimationKey")
.IsRequired()
.HasMaxLength(32)
.HasColumnType("varchar(32)");
b.Property<float>("AoeRadius")
.HasColumnType("float");
b.Property<int>("BaseDamage")
.HasColumnType("int");
b.Property<float>("CastTime")
.HasColumnType("float");
b.Property<float>("ConeAngle")
.HasColumnType("float");
b.Property<float>("Cooldown")
.HasColumnType("float");
b.Property<DateTime>("CreatedAt")
.HasColumnType("datetime(6)");
b.Property<float>("DamagePerTier")
.HasColumnType("float");
b.Property<string>("DamageTypeKey")
.IsRequired()
.HasMaxLength(32)
.HasColumnType("varchar(32)");
b.Property<string>("Description")
.IsRequired()
.HasMaxLength(256)
.HasColumnType("varchar(256)");
b.Property<float>("DisplacementDistance")
.HasColumnType("float");
b.Property<int>("DotDamagePerTick")
.HasColumnType("int");
b.Property<float>("DotTickInterval")
.HasColumnType("float");
b.Property<float>("EffectDuration")
.HasColumnType("float");
b.Property<float?>("HpThresholdAbove")
.HasColumnType("float");
b.Property<float?>("HpThresholdBelow")
.HasColumnType("float");
b.Property<bool>("IsEnabled")
.HasColumnType("tinyint(1)");
b.Property<string>("Key")
.IsRequired()
.HasMaxLength(64)
.HasColumnType("varchar(64)");
b.Property<int>("ManaCost")
.HasColumnType("int");
b.Property<int?>("MinTargetsInRange")
.HasColumnType("int");
b.Property<string>("Name")
.IsRequired()
.HasMaxLength(64)
.HasColumnType("varchar(64)");
b.Property<int>("Priority")
.HasColumnType("int");
b.Property<float>("ProjectileSpeed")
.HasColumnType("float");
b.Property<string>("ProjectileSprite")
.HasMaxLength(256)
.HasColumnType("varchar(256)");
b.Property<float>("Range")
.HasColumnType("float");
b.Property<string>("SoundEffectKey")
.HasMaxLength(64)
.HasColumnType("varchar(64)");
b.Property<float>("SpeedModifier")
.HasColumnType("float");
b.Property<float>("StatModifier")
.HasColumnType("float");
b.Property<int>("SummonCount")
.HasColumnType("int");
b.Property<int?>("SummonMobId")
.HasColumnType("int");
b.Property<int>("Targeting")
.HasColumnType("int");
b.Property<DateTime>("UpdatedAt")
.HasColumnType("datetime(6)");
b.Property<string>("VisualEffectKey")
.HasMaxLength(64)
.HasColumnType("varchar(64)");
b.HasKey("Id");
b.ToTable("dungeon_mob_abilities");
});
modelBuilder.Entity("DataServer.Data.Session", b =>
{
b.Property<ulong>("Id")
@@ -1673,6 +1863,25 @@ namespace SystemRevivalServer.Migrations
b.Navigation("Definition");
});
modelBuilder.Entity("DataServer.Data.Entities.MobAbilityAssignment", b =>
{
b.HasOne("DataServer.Data.Entities.MobAbilityDefinition", "AbilityDefinition")
.WithMany()
.HasForeignKey("AbilityDefinitionId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
b.HasOne("DataServer.Data.Entities.DungeonMobDefinition", "MobDefinition")
.WithMany("AbilityAssignments")
.HasForeignKey("MobDefinitionId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
b.Navigation("AbilityDefinition");
b.Navigation("MobDefinition");
});
modelBuilder.Entity("DataServer.Data.Session", b =>
{
b.HasOne("DataServer.Data.Account", "Account")
@@ -1718,6 +1927,11 @@ namespace SystemRevivalServer.Migrations
{
b.Navigation("Entries");
});
modelBuilder.Entity("DataServer.Data.Entities.DungeonMobDefinition", b =>
{
b.Navigation("AbilityAssignments");
});
#pragma warning restore 612, 618
}
}
+4 -1
View File
@@ -230,7 +230,10 @@ public class EditModel : AdminPageModel
AnimationSpeed = Mob.AnimationSpeed,
SpriteConfigJson = Mob.SpriteConfigJson,
ResistancesJson = Mob.ResistancesJson,
AbilitiesJson = Mob.AbilitiesJson,
Behavior = Mob.Behavior,
PreferredRange = Mob.PreferredRange,
FleeThreshold = Mob.FleeThreshold,
CallForHelpRadius = Mob.CallForHelpRadius,
IsEnabled = Mob.IsEnabled
};
_db.DungeonMobDefinitions.Add(newMob);
+5
View File
@@ -22,6 +22,11 @@ public sealed class GameDbContext : DbContext
public DbSet<DungeonLootTable> DungeonLootTables => Set<DungeonLootTable>();
public DbSet<DungeonLootTableEntry> DungeonLootTableEntries => Set<DungeonLootTableEntry>();
public DbSet<DungeonMobLootTable> DungeonMobLootTables => Set<DungeonMobLootTable>();
// Mob abilities
public DbSet<MobAbilityDefinition> MobAbilityDefinitions => Set<MobAbilityDefinition>();
public DbSet<MobAbilityAssignment> MobAbilityAssignments => Set<MobAbilityAssignment>();
public DbSet<DungeonBeltItem> DungeonBeltItems => Set<DungeonBeltItem>();
public DbSet<DeathChest> DeathChests => Set<DeathChest>();
public DbSet<DeathChestItem> DeathChestItems => Set<DeathChestItem>();
+6 -2
View File
@@ -5,11 +5,15 @@ namespace DataServer.Data.Entities;
/// </summary>
public static class DungeonCharacterStats
{
private const float BaseSpeed = 100f;
private const float DexSpeedModifier = 0.5f; // Reduced from 2f
private const float MaxSpeed = 500f;
public static int GetMaxHealth(DungeonCharacter c) => 50 + (c.Endurance * 10);
public static int GetMaxMana(DungeonCharacter c) => 20 + (c.Wisdom * 8);
public static int GetMaxStamina(DungeonCharacter c) => 50 + (c.Endurance * 5);
public static float GetXpBonus(DungeonCharacter c) => 1.0f + (c.Wisdom * 0.02f);
public static float GetMoveSpeed(DungeonCharacter c) => 100f + (c.Dexterity * 2f);
public static float GetMoveSpeed(DungeonCharacter c) => Math.Min(MaxSpeed, BaseSpeed + (c.Dexterity * DexSpeedModifier));
public static float GetAttackSpeed(DungeonCharacter c) => 1.0f + (c.Dexterity * 0.02f);
public static float GetRegenRate(DungeonCharacter c) => 1.0f + (c.Endurance * 0.1f);
@@ -45,7 +49,7 @@ public static class DungeonCharacterStats
stats.MaxHealth = 50 + (stats.Endurance * 10) + stats.BonusHealth;
stats.MaxMana = 20 + (stats.Wisdom * 8) + stats.BonusMana;
stats.MaxStamina = 50 + (stats.Endurance * 5);
stats.MoveSpeed = 100f + (stats.Dexterity * 2f);
stats.MoveSpeed = Math.Min(MaxSpeed, BaseSpeed + (stats.Dexterity * DexSpeedModifier));
stats.AttackSpeed = 1.0f + (stats.Dexterity * 0.02f);
stats.RegenRate = 1.0f + (stats.Endurance * 0.1f);
stats.PhysicalDamageMultiplier = 1.0f + (stats.Strength * 0.05f);
+73 -21
View File
@@ -24,6 +24,11 @@ public class DungeonMobDefinition
public MobType Type { get; set; } = MobType.Normal;
public MobCategory Category { get; set; } = MobCategory.Undead;
/// <summary>
/// AI behavior pattern for this mob
/// </summary>
public MobBehavior Behavior { get; set; } = MobBehavior.Aggressive;
public int MinTier { get; set; } = 1; // Minimum dungeon tier to spawn
public int MaxTier { get; set; } = 99; // Maximum tier (for progression gating)
@@ -49,6 +54,21 @@ public class DungeonMobDefinition
public float AggroRange { get; set; } = 150f; // Detection radius
public float LeashRange { get; set; } = 400f; // Max chase distance before reset
/// <summary>
/// Preferred combat distance (for ranged/skirmisher behaviors)
/// </summary>
public float PreferredRange { get; set; } = 40f;
/// <summary>
/// Flee threshold - if HP drops below this %, mob may flee (for skirmisher/defensive)
/// </summary>
public float FleeThreshold { get; set; } = 0f;
/// <summary>
/// Call for help radius - alerts nearby mobs when engaged
/// </summary>
public float CallForHelpRadius { get; set; } = 0f;
// Scaling per dungeon tier (multipliers)
public float HealthPerTier { get; set; } = 1.2f;
public float DamagePerTier { get; set; } = 1.15f;
@@ -69,32 +89,38 @@ public class DungeonMobDefinition
public string ResistancesJson { get; set; } = "{}";
/// <summary>
/// JSON block for special abilities/behaviors
/// Example: {"canFlee": true, "fleeHealthPercent": 0.2, "callsForHelp": true}
/// JSON block for boss phases (for multi-phase bosses)
/// Example: [{"hpThreshold": 0.75, "behavior": "Enrage"}, {"hpThreshold": 0.25, "behavior": "Summoner"}]
/// </summary>
[MaxLength(1024)]
public string AbilitiesJson { get; set; } = "{}";
[MaxLength(2048)]
public string? PhasesJson { get; set; }
// Visuals
/// <summary>
/// JSON configuration for mob sprites and animations
/// Example: {
/// "sprites": {
/// "idle_front": "assets/sprites/skeleton_idle_front.png",
/// "idle_back": "assets/sprites/skeleton_idle_back.png",
/// "run_front": "assets/sprites/skeleton_run_front.png"
/// },
/// Structure: {
/// "spriteSheet": "textures/mobs/skeleton.png",
/// "frameWidth": 64,
/// "frameHeight": 64,
/// "fps": 8,
/// "animations": {
/// "idle_front": {"frames": 8, "loop": true},
/// "run_front": {"frames": 8, "loop": true}
/// "idle_down": {"row": 0, "frames": 4, "fps": 4, "loop": true},
/// "idle_up": {"row": 1, "frames": 4, "fps": 4, "loop": true},
/// "idle_left": {"row": 2, "frames": 4, "fps": 4, "loop": true},
/// "idle_right": {"row": 3, "frames": 4, "fps": 4, "loop": true},
/// "walk_down": {"row": 4, "frames": 8, "fps": 8, "loop": true},
/// "walk_up": {"row": 5, "frames": 8, "fps": 8, "loop": true},
/// "walk_left": {"row": 6, "frames": 8, "fps": 8, "loop": true},
/// "walk_right": {"row": 7, "frames": 8, "fps": 8, "loop": true},
/// "attack_down": {"row": 8, "frames": 6, "fps": 12, "loop": false},
/// "attack_up": {"row": 9, "frames": 6, "fps": 12, "loop": false},
/// "attack_left": {"row": 10, "frames": 6, "fps": 12, "loop": false},
/// "attack_right": {"row": 11, "frames": 6, "fps": 12, "loop": false},
/// "cast_down": {"row": 12, "frames": 8, "fps": 10, "loop": false},
/// "death": {"row": 16, "frames": 6, "fps": 8, "loop": false}
/// }
/// }
/// If null/empty, client uses fallback placeholder shape
/// </summary>
[MaxLength(4096)]
[MaxLength(8192)]
public string? SpriteConfigJson { get; set; }
/// <summary>
@@ -112,6 +138,12 @@ public class DungeonMobDefinition
public bool IsEnabled { get; set; } = true;
// === Navigation Properties ===
/// <summary>
/// Abilities assigned to this mob
/// </summary>
public ICollection<MobAbilityAssignment> AbilityAssignments { get; set; } = new List<MobAbilityAssignment>();
// Helper to get parsed sprite config
[NotMapped]
public Dictionary<string, object>? SpriteConfig
@@ -137,18 +169,17 @@ public class DungeonMobDefinition
}
[NotMapped]
public Dictionary<string, object> Abilities
public List<MobPhaseConfig>? Phases
{
get
{
try { return JsonSerializer.Deserialize<Dictionary<string, object>>(AbilitiesJson) ?? new(); }
catch { return new(); }
if (string.IsNullOrEmpty(PhasesJson)) return null;
try { return JsonSerializer.Deserialize<List<MobPhaseConfig>>(PhasesJson); }
catch { return null; }
}
set { AbilitiesJson = JsonSerializer.Serialize(value); }
set { PhasesJson = value != null ? JsonSerializer.Serialize(value) : null; }
}
/// <summary>
/// Calculate scaled stats for a specific level bracket
/// Level bracket scaling: each bracket adds 15% to base stats
@@ -178,3 +209,24 @@ public class DungeonMobDefinition
};
}
}
/// <summary>
/// Configuration for a boss phase
/// </summary>
public class MobPhaseConfig
{
/// <summary>HP threshold to trigger this phase (0-1)</summary>
public float HpThreshold { get; set; }
/// <summary>New behavior for this phase</summary>
public MobBehavior Behavior { get; set; }
/// <summary>Speed multiplier for this phase</summary>
public float SpeedMultiplier { get; set; } = 1.0f;
/// <summary>Damage multiplier for this phase</summary>
public float DamageMultiplier { get; set; } = 1.0f;
/// <summary>Optional message to display when entering phase</summary>
public string? PhaseMessage { get; set; }
}
+63
View File
@@ -0,0 +1,63 @@
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
namespace DataServer.Data.Entities;
/// <summary>
/// Junction table linking mobs to their abilities
/// A mob can have multiple abilities, and abilities can be shared
/// </summary>
[Table("dungeon_mob_ability_assignments")]
public class MobAbilityAssignment
{
[Key]
public int Id { get; set; }
/// <summary>The mob definition this ability is assigned to</summary>
public int MobDefinitionId { get; set; }
[ForeignKey(nameof(MobDefinitionId))]
public DungeonMobDefinition? MobDefinition { get; set; }
/// <summary>The ability definition</summary>
public int AbilityDefinitionId { get; set; }
[ForeignKey(nameof(AbilityDefinitionId))]
public MobAbilityDefinition? AbilityDefinition { get; set; }
/// <summary>
/// Override cooldown for this mob (null = use ability default)
/// </summary>
public float? CooldownOverride { get; set; }
/// <summary>
/// Override damage for this mob (null = use ability default)
/// </summary>
public int? DamageOverride { get; set; }
/// <summary>
/// Priority override for AI selection (null = use ability default)
/// </summary>
public int? PriorityOverride { get; set; }
/// <summary>
/// Phase this ability is available in (for multi-phase bosses)
/// 0 = all phases, 1 = phase 1 only, etc.
/// </summary>
public int Phase { get; set; } = 0;
/// <summary>
/// Minimum HP percentage for this ability to be available (0-1)
/// </summary>
public float? MinHpPercent { get; set; }
/// <summary>
/// Maximum HP percentage for this ability to be available (0-1)
/// </summary>
public float? MaxHpPercent { get; set; }
/// <summary>
/// Is this ability enabled for this mob
/// </summary>
public bool IsEnabled { get; set; } = true;
}
+143
View File
@@ -0,0 +1,143 @@
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using DataServer.Data.Enums;
namespace DataServer.Data.Entities;
/// <summary>
/// Definition for a mob ability that can be assigned to mobs
/// </summary>
[Table("dungeon_mob_abilities")]
public class MobAbilityDefinition
{
[Key]
public int Id { get; set; }
[Required]
[MaxLength(64)]
public string Name { get; set; } = "";
[MaxLength(256)]
public string Description { get; set; } = "";
/// <summary>
/// Internal key for referencing (e.g., "skeleton_arrow", "boss_slam")
/// </summary>
[Required]
[MaxLength(64)]
public string Key { get; set; } = "";
public MobAbilityType AbilityType { get; set; } = MobAbilityType.MeleeAttack;
public MobAbilityTargeting Targeting { get; set; } = MobAbilityTargeting.CurrentTarget;
// === Damage/Healing ===
/// <summary>Base damage or healing amount</summary>
public int BaseDamage { get; set; } = 10;
/// <summary>Damage scaling per dungeon tier</summary>
public float DamagePerTier { get; set; } = 1.15f;
/// <summary>Damage type key (references DamageResistanceType)</summary>
[MaxLength(32)]
public string DamageTypeKey { get; set; } = "physical";
// === Range & Area ===
/// <summary>Maximum range to use ability</summary>
public float Range { get; set; } = 40f;
/// <summary>AOE radius (0 for single target)</summary>
public float AoeRadius { get; set; } = 0f;
/// <summary>Cone angle in degrees (for cone attacks)</summary>
public float ConeAngle { get; set; } = 0f;
// === Timing ===
/// <summary>Cooldown in seconds between uses</summary>
public float Cooldown { get; set; } = 5f;
/// <summary>Cast time in seconds (0 for instant)</summary>
public float CastTime { get; set; } = 0f;
/// <summary>Animation duration in seconds</summary>
public float AnimationDuration { get; set; } = 0.5f;
// === Projectile (if applicable) ===
/// <summary>Projectile speed (if projectile type)</summary>
public float ProjectileSpeed { get; set; } = 300f;
/// <summary>Projectile sprite path</summary>
[MaxLength(256)]
public string? ProjectileSprite { get; set; }
// === Status Effects ===
/// <summary>Duration of any applied status effect</summary>
public float EffectDuration { get; set; } = 3f;
/// <summary>Damage per tick for DOT effects</summary>
public int DotDamagePerTick { get; set; } = 5;
/// <summary>Tick interval for DOT effects</summary>
public float DotTickInterval { get; set; } = 1f;
/// <summary>Slow/speed modifier (0.5 = 50% slow)</summary>
public float SpeedModifier { get; set; } = 0.5f;
/// <summary>Knockback/pull distance</summary>
public float DisplacementDistance { get; set; } = 100f;
// === Summoning ===
/// <summary>Mob definition ID to summon</summary>
public int? SummonMobId { get; set; }
/// <summary>Number of mobs to summon</summary>
public int SummonCount { get; set; } = 1;
// === Buff/Debuff ===
/// <summary>Stat modifier percentage (1.5 = +50%, 0.5 = -50%)</summary>
public float StatModifier { get; set; } = 1.0f;
/// <summary>Which stat to modify (damage, defense, speed, etc.)</summary>
[MaxLength(32)]
public string? AffectedStat { get; set; }
// === Conditions ===
/// <summary>Only usable below this HP percentage (0-1)</summary>
public float? HpThresholdBelow { get; set; }
/// <summary>Only usable above this HP percentage (0-1)</summary>
public float? HpThresholdAbove { get; set; }
/// <summary>Minimum number of targets in range to use</summary>
public int? MinTargetsInRange { get; set; }
/// <summary>Priority for AI ability selection (higher = more likely)</summary>
public int Priority { get; set; } = 1;
// === Mana/Resource Cost ===
public int ManaCost { get; set; } = 0;
// === Animation ===
/// <summary>
/// Animation key to play (e.g., "attack", "cast", "special1")
/// Client will look for [animation]_[direction] sprites
/// </summary>
[MaxLength(32)]
public string AnimationKey { get; set; } = "attack";
/// <summary>
/// Sound effect key to play
/// </summary>
[MaxLength(64)]
public string? SoundEffectKey { get; set; }
/// <summary>
/// Visual effect to spawn (particle effect key)
/// </summary>
[MaxLength(64)]
public string? VisualEffectKey { get; set; }
public bool IsEnabled { get; set; } = true;
public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
public DateTime UpdatedAt { get; set; } = DateTime.UtcNow;
}
+46
View File
@@ -0,0 +1,46 @@
namespace DataServer.Data.Enums;
/// <summary>
/// How an ability selects its target
/// </summary>
public enum MobAbilityTargeting
{
/// <summary>Targets self</summary>
Self,
/// <summary>Targets current aggro target</summary>
CurrentTarget,
/// <summary>Targets nearest enemy</summary>
NearestEnemy,
/// <summary>Targets lowest HP enemy</summary>
LowestHpEnemy,
/// <summary>Targets highest HP enemy</summary>
HighestHpEnemy,
/// <summary>Targets nearest ally</summary>
NearestAlly,
/// <summary>Targets lowest HP ally</summary>
LowestHpAlly,
/// <summary>Targets random enemy in range</summary>
RandomEnemy,
/// <summary>Targets ground location</summary>
GroundLocation,
/// <summary>AOE around self</summary>
AroundSelf,
/// <summary>AOE around target</summary>
AroundTarget,
/// <summary>All enemies in range</summary>
AllEnemiesInRange,
/// <summary>All allies in range</summary>
AllAlliesInRange
}
+108
View File
@@ -0,0 +1,108 @@
namespace DataServer.Data.Enums;
/// <summary>
/// Types of abilities mobs can use
/// </summary>
public enum MobAbilityType
{
// === Damage Abilities ===
/// <summary>Basic melee attack</summary>
MeleeAttack,
/// <summary>Single target projectile</summary>
ProjectileSingle,
/// <summary>Projectile that explodes on impact for AOE damage</summary>
ProjectileAoe,
/// <summary>Ground-targeted AOE damage zone</summary>
GroundAoe,
/// <summary>Cone-shaped attack in front of mob</summary>
ConeAttack,
/// <summary>Attack all targets in range</summary>
Cleave,
// === Healing Abilities ===
/// <summary>Heal self</summary>
HealSelf,
/// <summary>Heal single ally</summary>
HealAlly,
/// <summary>AOE heal for nearby allies</summary>
HealAoe,
// === Summoning ===
/// <summary>Summon a single mob</summary>
SummonSingle,
/// <summary>Summon multiple mobs at once</summary>
SummonBulk,
// === Crowd Control ===
/// <summary>Stun target, preventing movement and actions</summary>
Stun,
/// <summary>Knock target back from mob</summary>
Knockback,
/// <summary>Fear target, causing them to flee</summary>
Fear,
/// <summary>Pull target toward mob</summary>
Pull,
/// <summary>Root target in place (can still attack)</summary>
Root,
/// <summary>Slow target movement speed</summary>
Slow,
/// <summary>Silence target (prevent ability use)</summary>
Silence,
// === Damage Over Time ===
/// <summary>Apply poison damage over time</summary>
Poison,
/// <summary>Apply bleed damage over time</summary>
Bleed,
/// <summary>Apply burn damage over time</summary>
Burn,
// === Buffs/Debuffs ===
/// <summary>Buff self with increased stats</summary>
BuffSelf,
/// <summary>Buff nearby allies</summary>
BuffAllies,
/// <summary>Debuff target with reduced stats</summary>
Debuff,
/// <summary>Enrage - increased damage, possibly reduced defense</summary>
Enrage,
/// <summary>Shield self from damage</summary>
Shield,
// === Movement ===
/// <summary>Dash/charge toward target</summary>
Charge,
/// <summary>Teleport to location</summary>
Teleport,
/// <summary>Dash away from target</summary>
Retreat,
// === Special ===
/// <summary>Create a dangerous zone on ground</summary>
HazardZone,
/// <summary>Phase change - switch behavior/abilities at HP threshold</summary>
PhaseChange
}
+37
View File
@@ -0,0 +1,37 @@
namespace DataServer.Data.Enums;
/// <summary>
/// AI behavior patterns for mobs
/// </summary>
public enum MobBehavior
{
/// <summary>Charges player on sight, melee attacks</summary>
Aggressive,
/// <summary>Stays near spawn, only attacks if approached</summary>
Defensive,
/// <summary>Keeps distance, fires projectiles</summary>
Ranged,
/// <summary>Hit-and-run tactics, kites players</summary>
Skirmisher,
/// <summary>Spawns additional mobs, stays back</summary>
Summoner,
/// <summary>High HP, slow movement, blocks paths</summary>
Tank,
/// <summary>Targets low-HP players, high burst damage</summary>
Assassin,
/// <summary>Heals nearby allied mobs</summary>
Healer,
/// <summary>Walks a route, alerts others on player sight</summary>
Patrol,
/// <summary>Calls nearby mobs when engaged</summary>
Pack
}