diff --git a/Game/Dungeon/MobAI.cs b/Game/Dungeon/MobAI.cs
new file mode 100644
index 0000000..0bd3d93
--- /dev/null
+++ b/Game/Dungeon/MobAI.cs
@@ -0,0 +1,462 @@
+using DataServer.Data.Entities;
+using DataServer.Data.Enums;
+
+namespace Server.Game.Dungeon;
+
+///
+/// Handles mob AI behavior and decision making
+///
+public static class MobAI
+{
+ ///
+ /// Main AI update - called each tick for each mob
+ ///
+ 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();
+
+ 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
+}
diff --git a/Game/Dungeon/MobInstance.cs b/Game/Dungeon/MobInstance.cs
index 6b5e3d7..4b4dab8 100644
--- a/Game/Dungeon/MobInstance.cs
+++ b/Game/Dungeon/MobInstance.cs
@@ -20,6 +20,45 @@ public class CarriedLootItem
public int Quantity { get; set; }
}
+///
+/// Runtime state for a mob ability
+///
+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; }
+
+ ///
+ /// Check if this ability is available (off cooldown and HP in range)
+ ///
+ 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;
+ }
+}
+
+///
+/// Active status effect on a mob
+///
+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; }
+}
+
///
/// Runtime instance of a mob in a dungeon
///
@@ -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;
+
+ /// Current phase for multi-phase mobs (0 = first phase)
+ public int CurrentPhase { get; set; } = 0;
+
+ /// Phase configurations loaded from definition
+ public List? Phases { get; set; }
public ulong? TargetId { get; set; }
public long LastAttackTick { get; set; }
+ /// Time spent in current state (for behavior decisions)
+ public float StateTime { get; set; }
+
+ /// Last position for stuck detection
+ public float LastX { get; set; }
+ public float LastY { get; set; }
+ public float StuckTime { get; set; }
+
+ // === Abilities ===
+ /// Abilities this mob can use
+ public List Abilities { get; set; } = new();
+
+ /// Currently casting ability (null if not casting)
+ public MobAbilityState? CastingAbility { get; set; }
+
+ /// Remaining cast time
+ public float CastTimeRemaining { get; set; }
+
+ /// Active status effects on this mob
+ public List StatusEffects { get; set; } = new();
+
+ /// Current animation being played
+ public string CurrentAnimation { get; set; } = "idle";
+
+ /// Direction mob is facing (down, up, left, right)
+ public string FacingDirection { get; set; } = "down";
+
+ // === Behavior-specific ===
+ /// Preferred combat distance (for ranged/skirmisher)
+ public float PreferredRange { get; set; } = 40f;
+
+ /// Flee threshold HP percentage
+ public float FleeThreshold { get; set; } = 0f;
+
+ /// Has already called for help this combat
+ public bool HasCalledForHelp { get; set; }
+
+ /// Patrol waypoints (for Patrol behavior)
+ public List<(float X, float Y)>? PatrolPath { get; set; }
+
+ /// Current patrol waypoint index
+ public int PatrolIndex { get; set; }
+
+ /// Enrage stacks (for Enrage behavior)
+ public int EnrageStacks { get; set; }
+
+ /// Time since combat started (for time-based mechanics)
+ 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 CarriedPlayerLoot { get; set; } = new();
- ///
- /// Check if this mob is carrying loot from player kills
- ///
+ /// Check if this mob is carrying loot from player kills
public bool HasCarriedLoot => CarriedPlayerLoot.Count > 0;
+
+ /// Current HP as percentage (0-1)
+ public float HpPercent => MaxHealth > 0 ? (float)Health / MaxHealth : 0f;
+
+ /// Check if mob is stunned
+ public bool IsStunned => StatusEffects.Any(e => e.EffectType == "stun" && e.Duration > 0);
+
+ /// Check if mob is rooted
+ public bool IsRooted => StatusEffects.Any(e => e.EffectType == "root" && e.Duration > 0);
+
+ /// Check if mob is silenced
+ public bool IsSilenced => StatusEffects.Any(e => e.EffectType == "silence" && e.Duration > 0);
+
+ /// Get current speed modifier from status effects
+ public float GetSpeedModifier()
+ {
+ float modifier = 1.0f;
+ foreach (var effect in StatusEffects.Where(e => e.EffectType == "slow"))
+ {
+ modifier *= effect.Modifier;
+ }
+ return modifier;
+ }
+
+ /// Update facing direction based on movement
+ 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";
+ }
+ }
+
+ /// Get the animation key with direction
+ 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
}
diff --git a/Migrations/20251227160629_Mob AI.Designer.cs b/Migrations/20251227160629_Mob AI.Designer.cs
new file mode 100644
index 0000000..99536b1
--- /dev/null
+++ b/Migrations/20251227160629_Mob AI.Designer.cs
@@ -0,0 +1,1941 @@
+//
+using System;
+using DataServer.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace SystemRevivalServer.Migrations
+{
+ [DbContext(typeof(GameDbContext))]
+ [Migration("20251227160629_Mob AI")]
+ partial class MobAI
+ {
+ ///
+ protected override void BuildTargetModel(ModelBuilder modelBuilder)
+ {
+#pragma warning disable 612, 618
+ modelBuilder
+ .HasAnnotation("ProductVersion", "9.0.10")
+ .HasAnnotation("Relational:MaxIdentifierLength", 64);
+
+ MySqlModelBuilderExtensions.AutoIncrementColumns(modelBuilder);
+
+ modelBuilder.Entity("DataServer.Data.Account", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("bigint unsigned");
+
+ MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property("Id"));
+
+ b.Property("BannedUntil")
+ .HasColumnType("datetime(6)");
+
+ b.Property("CreatedAt")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("datetime(6)")
+ .HasDefaultValueSql("CURRENT_TIMESTAMP(6)");
+
+ b.Property("Email")
+ .HasMaxLength(255)
+ .HasColumnType("varchar(255)");
+
+ b.Property("IsBanned")
+ .HasColumnType("tinyint(1)");
+
+ b.Property("PasswordHash")
+ .IsRequired()
+ .HasColumnType("varbinary(64)");
+
+ b.Property("PasswordSalt")
+ .IsRequired()
+ .HasColumnType("varbinary(32)");
+
+ b.Property("Role")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("int")
+ .HasDefaultValue(0);
+
+ b.Property("UpdatedAt")
+ .ValueGeneratedOnAddOrUpdate()
+ .HasColumnType("datetime(6)")
+ .HasDefaultValueSql("CURRENT_TIMESTAMP(6)");
+
+ MySqlPropertyBuilderExtensions.UseMySqlComputedColumn(b.Property("UpdatedAt"));
+
+ b.Property("Username")
+ .IsRequired()
+ .HasMaxLength(32)
+ .HasColumnType("varchar(32)");
+
+ b.HasKey("Id");
+
+ b.HasIndex("Email")
+ .IsUnique();
+
+ b.HasIndex("Username")
+ .IsUnique();
+
+ b.ToTable("accounts", (string)null);
+ });
+
+ modelBuilder.Entity("DataServer.Data.Entities.ClientAsset", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("int");
+
+ MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property("Id"));
+
+ b.Property("AssetType")
+ .HasColumnType("int");
+
+ b.Property("CdnPath")
+ .HasMaxLength(256)
+ .HasColumnType("varchar(256)");
+
+ b.Property("CreatedAt")
+ .HasColumnType("datetime(6)");
+
+ b.Property("FileHash")
+ .IsRequired()
+ .HasMaxLength(32)
+ .HasColumnType("varchar(32)");
+
+ b.Property("FilePath")
+ .IsRequired()
+ .HasMaxLength(256)
+ .HasColumnType("varchar(256)");
+
+ b.Property("FileSize")
+ .HasColumnType("bigint");
+
+ b.Property("IsEnabled")
+ .HasColumnType("tinyint(1)");
+
+ b.Property("IsRequired")
+ .HasColumnType("tinyint(1)");
+
+ b.Property("MinClientVersion")
+ .HasMaxLength(16)
+ .HasColumnType("varchar(16)");
+
+ b.Property("UpdatedAt")
+ .HasColumnType("datetime(6)");
+
+ b.Property("Version")
+ .HasColumnType("int");
+
+ b.HasKey("Id");
+
+ b.ToTable("client_assets");
+ });
+
+ modelBuilder.Entity("DataServer.Data.Entities.DamageResistanceType", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("int");
+
+ MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property("Id"));
+
+ b.Property("Color")
+ .IsRequired()
+ .HasMaxLength(16)
+ .HasColumnType("varchar(16)");
+
+ b.Property("CreatedAt")
+ .HasColumnType("datetime(6)");
+
+ b.Property("Description")
+ .IsRequired()
+ .HasMaxLength(256)
+ .HasColumnType("varchar(256)");
+
+ b.Property("DisplayName")
+ .IsRequired()
+ .HasMaxLength(64)
+ .HasColumnType("varchar(64)");
+
+ b.Property("IconPath")
+ .HasMaxLength(256)
+ .HasColumnType("varchar(256)");
+
+ b.Property("IsEnabled")
+ .HasColumnType("tinyint(1)");
+
+ b.Property("Key")
+ .IsRequired()
+ .HasMaxLength(32)
+ .HasColumnType("varchar(32)");
+
+ b.Property("SortOrder")
+ .HasColumnType("int");
+
+ b.HasKey("Id");
+
+ b.ToTable("damage_resistance_types");
+ });
+
+ modelBuilder.Entity("DataServer.Data.Entities.DeathChest", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("bigint unsigned");
+
+ MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property("Id"));
+
+ b.Property("CreatedAt")
+ .HasColumnType("datetime(6)");
+
+ b.Property("DungeonInstanceId")
+ .HasColumnType("char(36)");
+
+ b.Property("EmptiedAt")
+ .HasColumnType("datetime(6)");
+
+ b.Property("GoldAmount")
+ .HasColumnType("bigint");
+
+ b.Property("IsEmpty")
+ .HasColumnType("tinyint(1)");
+
+ b.Property("OwnerCharacterId")
+ .HasColumnType("bigint unsigned");
+
+ b.Property("VictimCharacterId")
+ .HasColumnType("bigint unsigned");
+
+ b.Property("VictimMobDefinitionId")
+ .HasColumnType("int");
+
+ b.Property("X")
+ .HasColumnType("float");
+
+ b.Property("Y")
+ .HasColumnType("float");
+
+ b.HasKey("Id");
+
+ b.HasIndex("OwnerCharacterId");
+
+ b.HasIndex("VictimCharacterId");
+
+ b.ToTable("dungeon_death_chests");
+ });
+
+ modelBuilder.Entity("DataServer.Data.Entities.DeathChestItem", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("bigint unsigned");
+
+ MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property("Id"));
+
+ b.Property("DeathChestId")
+ .HasColumnType("bigint unsigned");
+
+ b.Property("IsTaken")
+ .HasColumnType("tinyint(1)");
+
+ b.Property("ItemDefinitionId")
+ .HasColumnType("int");
+
+ b.Property("Quantity")
+ .HasColumnType("int");
+
+ b.Property("SlotIndex")
+ .HasColumnType("int");
+
+ b.Property("TakenAt")
+ .HasColumnType("datetime(6)");
+
+ b.HasKey("Id");
+
+ b.HasIndex("DeathChestId");
+
+ b.HasIndex("ItemDefinitionId");
+
+ b.ToTable("dungeon_death_chest_items");
+ });
+
+ modelBuilder.Entity("DataServer.Data.Entities.DungeonBeltItem", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("bigint unsigned");
+
+ MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property("Id"));
+
+ b.Property("CharacterId")
+ .HasColumnType("bigint unsigned");
+
+ b.Property("InventorySlotIndex")
+ .HasColumnType("int");
+
+ b.Property("SlotIndex")
+ .HasColumnType("int");
+
+ b.HasKey("Id");
+
+ b.HasIndex("CharacterId");
+
+ b.ToTable("dungeon_belt_items");
+ });
+
+ modelBuilder.Entity("DataServer.Data.Entities.DungeonCharacter", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("bigint unsigned");
+
+ MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property("Id"));
+
+ b.Property("AccountId")
+ .HasColumnType("bigint unsigned");
+
+ b.Property("BossesKilled")
+ .HasColumnType("int");
+
+ b.Property("CreatedAt")
+ .HasColumnType("datetime(6)");
+
+ b.Property("CurrentHealth")
+ .HasColumnType("int");
+
+ b.Property("CurrentMana")
+ .HasColumnType("int");
+
+ b.Property("Dexterity")
+ .HasColumnType("int");
+
+ b.Property("DungeonsCompleted")
+ .HasColumnType("int");
+
+ b.Property("Endurance")
+ .HasColumnType("int");
+
+ b.Property("EquippedAccessory")
+ .HasColumnType("bigint unsigned");
+
+ b.Property("EquippedBoots")
+ .HasColumnType("bigint unsigned");
+
+ b.Property("EquippedChest")
+ .HasColumnType("bigint unsigned");
+
+ b.Property("EquippedGloves")
+ .HasColumnType("bigint unsigned");
+
+ b.Property("EquippedHead")
+ .HasColumnType("bigint unsigned");
+
+ b.Property("EquippedLegs")
+ .HasColumnType("bigint unsigned");
+
+ b.Property("EquippedOffhand")
+ .HasColumnType("bigint unsigned");
+
+ b.Property("EquippedWeapon")
+ .HasColumnType("bigint unsigned");
+
+ b.Property("Experience")
+ .HasColumnType("bigint");
+
+ b.Property("Gold")
+ .HasColumnType("bigint");
+
+ b.Property("Intelligence")
+ .HasColumnType("int");
+
+ b.Property("IsDeleted")
+ .HasColumnType("tinyint(1)");
+
+ b.Property("LastPlayedAt")
+ .HasColumnType("datetime(6)");
+
+ b.Property("Level")
+ .HasColumnType("int");
+
+ b.Property("Name")
+ .IsRequired()
+ .HasMaxLength(32)
+ .HasColumnType("varchar(32)");
+
+ b.Property("PlayersKilled")
+ .HasColumnType("int");
+
+ b.Property("ResistancesJson")
+ .IsRequired()
+ .HasMaxLength(1024)
+ .HasColumnType("varchar(1024)");
+
+ b.Property("Strength")
+ .HasColumnType("int");
+
+ b.Property("TotalDeaths")
+ .HasColumnType("int");
+
+ b.Property("TotalKills")
+ .HasColumnType("int");
+
+ b.Property("UnspentStatPoints")
+ .HasColumnType("int");
+
+ b.Property("Wisdom")
+ .HasColumnType("int");
+
+ b.HasKey("Id");
+
+ b.HasIndex("AccountId");
+
+ b.ToTable("dungeon_characters");
+ });
+
+ modelBuilder.Entity("DataServer.Data.Entities.DungeonCharacterCraftingSkill", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("bigint unsigned");
+
+ MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property("Id"));
+
+ b.Property("CharacterId")
+ .HasColumnType("bigint unsigned");
+
+ b.Property("Experience")
+ .HasColumnType("bigint");
+
+ b.Property("Level")
+ .HasColumnType("int");
+
+ b.Property("SkillType")
+ .HasColumnType("int");
+
+ b.Property("TotalItemsCrafted")
+ .HasColumnType("int");
+
+ b.HasKey("Id");
+
+ b.HasIndex("CharacterId");
+
+ b.ToTable("dungeon_character_crafting_skills");
+ });
+
+ modelBuilder.Entity("DataServer.Data.Entities.DungeonCharacterItem", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("bigint unsigned");
+
+ MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property("Id"));
+
+ b.Property("AcquiredAt")
+ .HasColumnType("datetime(6)");
+
+ b.Property("CharacterId")
+ .HasColumnType("bigint unsigned");
+
+ b.Property("EquipSlot")
+ .HasColumnType("int");
+
+ b.Property("IsEquipped")
+ .HasColumnType("tinyint(1)");
+
+ b.Property("ItemDefinitionId")
+ .HasColumnType("int");
+
+ b.Property("Quantity")
+ .HasColumnType("int");
+
+ b.Property("SlotIndex")
+ .HasColumnType("int");
+
+ b.HasKey("Id");
+
+ b.HasIndex("CharacterId");
+
+ b.HasIndex("ItemDefinitionId");
+
+ b.ToTable("dungeon_character_items");
+ });
+
+ modelBuilder.Entity("DataServer.Data.Entities.DungeonCharacterItemCraftedLink", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("bigint unsigned");
+
+ MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property("Id"));
+
+ b.Property("CharacterItemId")
+ .HasColumnType("bigint unsigned");
+
+ b.Property("CraftedItemId")
+ .HasColumnType("bigint unsigned");
+
+ b.HasKey("Id");
+
+ b.HasIndex("CharacterItemId");
+
+ b.HasIndex("CraftedItemId");
+
+ b.ToTable("dungeon_character_item_crafted_link");
+ });
+
+ modelBuilder.Entity("DataServer.Data.Entities.DungeonCharacterKnownRecipe", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("bigint unsigned");
+
+ MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property("Id"));
+
+ b.Property("CharacterId")
+ .HasColumnType("bigint unsigned");
+
+ b.Property("DiscoveredAt")
+ .HasColumnType("datetime(6)");
+
+ b.Property("RecipeId")
+ .HasColumnType("int");
+
+ b.Property("TimesCrafted")
+ .HasColumnType("int");
+
+ b.HasKey("Id");
+
+ b.HasIndex("CharacterId");
+
+ b.HasIndex("RecipeId");
+
+ b.ToTable("dungeon_character_known_recipes");
+ });
+
+ modelBuilder.Entity("DataServer.Data.Entities.DungeonCraftedItem", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("bigint unsigned");
+
+ MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property("Id"));
+
+ b.Property("BaseItemDefinitionId")
+ .HasColumnType("int");
+
+ b.Property("CraftedAt")
+ .HasColumnType("datetime(6)");
+
+ b.Property("CrafterId")
+ .HasColumnType("bigint unsigned");
+
+ b.Property("CrafterName")
+ .HasMaxLength(32)
+ .HasColumnType("varchar(32)");
+
+ b.Property("CraftingLevelAtCreation")
+ .HasColumnType("int");
+
+ b.Property("CustomName")
+ .HasMaxLength(64)
+ .HasColumnType("varchar(64)");
+
+ b.Property("QualityRating")
+ .HasColumnType("int");
+
+ b.Property("RecipeId")
+ .HasColumnType("int");
+
+ b.Property("RollHistoryJson")
+ .HasMaxLength(1024)
+ .HasColumnType("varchar(1024)");
+
+ b.Property("RolledBonusArmor")
+ .HasColumnType("int");
+
+ b.Property("RolledBonusDexterity")
+ .HasColumnType("int");
+
+ b.Property("RolledBonusEndurance")
+ .HasColumnType("int");
+
+ b.Property("RolledBonusHealAmount")
+ .HasColumnType("int");
+
+ b.Property("RolledBonusHealth")
+ .HasColumnType("int");
+
+ b.Property("RolledBonusIntelligence")
+ .HasColumnType("int");
+
+ b.Property("RolledBonusMagicResist")
+ .HasColumnType("int");
+
+ b.Property("RolledBonusMana")
+ .HasColumnType("int");
+
+ b.Property("RolledBonusManaRestore")
+ .HasColumnType("int");
+
+ b.Property("RolledBonusMaxDamage")
+ .HasColumnType("int");
+
+ b.Property("RolledBonusMinDamage")
+ .HasColumnType("int");
+
+ b.Property("RolledBonusStrength")
+ .HasColumnType("int");
+
+ b.Property("RolledBonusWisdom")
+ .HasColumnType("int");
+
+ b.HasKey("Id");
+
+ b.HasIndex("BaseItemDefinitionId");
+
+ b.HasIndex("CrafterId");
+
+ b.HasIndex("RecipeId");
+
+ b.ToTable("dungeon_crafted_items");
+ });
+
+ modelBuilder.Entity("DataServer.Data.Entities.DungeonCraftingRecipe", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("int");
+
+ MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property("Id"));
+
+ b.Property("BaseXp")
+ .HasColumnType("int");
+
+ b.Property("BonusOutputChanceAtMinLevel")
+ .HasColumnType("float");
+
+ b.Property("BonusOutputItemDefinitionId")
+ .HasColumnType("int");
+
+ b.Property("BonusOutputMaxLevel")
+ .HasColumnType("int");
+
+ b.Property("BonusOutputMinLevel")
+ .HasColumnType("int");
+
+ b.Property("BonusOutputQuantity")
+ .HasColumnType("int");
+
+ b.Property("Description")
+ .IsRequired()
+ .HasMaxLength(256)
+ .HasColumnType("varchar(256)");
+
+ b.Property("HasStatRolls")
+ .HasColumnType("tinyint(1)");
+
+ b.Property("IsBaseRecipe")
+ .HasColumnType("tinyint(1)");
+
+ b.Property("IsEnabled")
+ .HasColumnType("tinyint(1)");
+
+ b.Property("Name")
+ .IsRequired()
+ .HasMaxLength(64)
+ .HasColumnType("varchar(64)");
+
+ b.Property("OutputItemDefinitionId")
+ .HasColumnType("int");
+
+ b.Property("OutputQuantity")
+ .HasColumnType("int");
+
+ b.Property("PossibleStatsJson")
+ .HasMaxLength(1024)
+ .HasColumnType("varchar(1024)");
+
+ b.Property("RequiredLevel")
+ .HasColumnType("int");
+
+ b.Property("SkillType")
+ .HasColumnType("int");
+
+ b.Property("Tier")
+ .HasColumnType("int");
+
+ b.HasKey("Id");
+
+ b.HasIndex("OutputItemDefinitionId");
+
+ b.ToTable("dungeon_crafting_recipes");
+ });
+
+ modelBuilder.Entity("DataServer.Data.Entities.DungeonCraftingRecipeIngredient", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("int");
+
+ MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property("Id"));
+
+ b.Property("ItemDefinitionId")
+ .HasColumnType("int");
+
+ b.Property("Quantity")
+ .HasColumnType("int");
+
+ b.Property("RecipeId")
+ .HasColumnType("int");
+
+ b.Property("SlotOrder")
+ .HasColumnType("int");
+
+ b.HasKey("Id");
+
+ b.HasIndex("ItemDefinitionId");
+
+ b.HasIndex("RecipeId");
+
+ b.ToTable("dungeon_crafting_recipe_ingredients");
+ });
+
+ modelBuilder.Entity("DataServer.Data.Entities.DungeonItemDefinition", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("int");
+
+ MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property("Id"));
+
+ b.Property("Armor")
+ .HasColumnType("int");
+
+ b.Property("AttackRange")
+ .HasColumnType("float");
+
+ b.Property("BonusDexterity")
+ .HasColumnType("int");
+
+ b.Property("BonusEndurance")
+ .HasColumnType("int");
+
+ b.Property("BonusHealth")
+ .HasColumnType("int");
+
+ b.Property("BonusIntelligence")
+ .HasColumnType("int");
+
+ b.Property("BonusMana")
+ .HasColumnType("int");
+
+ b.Property("BonusStrength")
+ .HasColumnType("int");
+
+ b.Property("BonusWisdom")
+ .HasColumnType("int");
+
+ b.Property("BuffDuration")
+ .HasColumnType("int");
+
+ b.Property("BuffResistancesJson")
+ .IsRequired()
+ .HasMaxLength(1024)
+ .HasColumnType("varchar(1024)");
+
+ b.Property("DamageTypeKey")
+ .IsRequired()
+ .HasMaxLength(32)
+ .HasColumnType("varchar(32)");
+
+ b.Property("Description")
+ .IsRequired()
+ .HasMaxLength(256)
+ .HasColumnType("varchar(256)");
+
+ b.Property("EquipSlot")
+ .HasColumnType("int");
+
+ b.Property("HealAmount")
+ .HasColumnType("int");
+
+ b.Property("IsEnabled")
+ .HasColumnType("tinyint(1)");
+
+ b.Property("IsTeleportScroll")
+ .HasColumnType("tinyint(1)");
+
+ b.Property("ManaRestore")
+ .HasColumnType("int");
+
+ b.Property("MaxDamage")
+ .HasColumnType("int");
+
+ b.Property("MaxStack")
+ .HasColumnType("int");
+
+ b.Property("MinDamage")
+ .HasColumnType("int");
+
+ b.Property("Name")
+ .IsRequired()
+ .HasMaxLength(64)
+ .HasColumnType("varchar(64)");
+
+ b.Property("Rarity")
+ .HasColumnType("int");
+
+ b.Property("RequiredDexterity")
+ .HasColumnType("int");
+
+ b.Property("RequiredIntelligence")
+ .HasColumnType("int");
+
+ b.Property("RequiredLevel")
+ .HasColumnType("int");
+
+ b.Property("RequiredStrength")
+ .HasColumnType("int");
+
+ b.Property("RequiredWisdom")
+ .HasColumnType("int");
+
+ b.Property("ResistancesJson")
+ .IsRequired()
+ .HasMaxLength(1024)
+ .HasColumnType("varchar(1024)");
+
+ b.Property("SpriteId")
+ .HasColumnType("int");
+
+ b.Property("SpritePath")
+ .HasMaxLength(256)
+ .HasColumnType("varchar(256)");
+
+ b.Property("Stackable")
+ .HasColumnType("tinyint(1)");
+
+ b.Property("StaminaRestore")
+ .HasColumnType("int");
+
+ b.Property("TeachesSpellId")
+ .HasColumnType("int");
+
+ b.Property("TintColor")
+ .HasMaxLength(16)
+ .HasColumnType("varchar(16)");
+
+ b.Property("Type")
+ .HasColumnType("int");
+
+ b.HasKey("Id");
+
+ b.ToTable("dungeon_item_definitions");
+ });
+
+ modelBuilder.Entity("DataServer.Data.Entities.DungeonLearnedSpell", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("bigint unsigned");
+
+ MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property("Id"));
+
+ b.Property("CharacterId")
+ .HasColumnType("bigint unsigned");
+
+ b.Property("DefinitionId")
+ .HasColumnType("int");
+
+ b.Property("LearnedAt")
+ .HasColumnType("datetime(6)");
+
+ b.Property("SpellDefinitionId")
+ .HasColumnType("int");
+
+ b.Property("SpellLevel")
+ .HasColumnType("int");
+
+ b.HasKey("Id");
+
+ b.HasIndex("CharacterId");
+
+ b.HasIndex("DefinitionId");
+
+ b.ToTable("dungeon_learned_spells");
+ });
+
+ modelBuilder.Entity("DataServer.Data.Entities.DungeonLootTable", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("int");
+
+ MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property("Id"));
+
+ b.Property("Description")
+ .IsRequired()
+ .HasMaxLength(256)
+ .HasColumnType("varchar(256)");
+
+ b.Property("DropChanceMultiplier")
+ .HasColumnType("float");
+
+ b.Property("GuaranteedDrop")
+ .HasColumnType("tinyint(1)");
+
+ b.Property("IsEnabled")
+ .HasColumnType("tinyint(1)");
+
+ b.Property("MaxDrops")
+ .HasColumnType("int");
+
+ b.Property("MaxTier")
+ .HasColumnType("int");
+
+ b.Property("MinDrops")
+ .HasColumnType("int");
+
+ b.Property("MinTier")
+ .HasColumnType("int");
+
+ b.Property("Name")
+ .IsRequired()
+ .HasMaxLength(64)
+ .HasColumnType("varchar(64)");
+
+ b.HasKey("Id");
+
+ b.ToTable("dungeon_loot_tables");
+ });
+
+ modelBuilder.Entity("DataServer.Data.Entities.DungeonLootTableEntry", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("int");
+
+ MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property("Id"));
+
+ b.Property("DropChance")
+ .HasColumnType("float");
+
+ b.Property("DropChancePerTier")
+ .HasColumnType("float");
+
+ b.Property("Guaranteed")
+ .HasColumnType("tinyint(1)");
+
+ b.Property("ItemDefinitionId")
+ .HasColumnType("int");
+
+ b.Property("LootTableId")
+ .HasColumnType("int");
+
+ b.Property("MaxDropChance")
+ .HasColumnType("float");
+
+ b.Property("MaxQuantity")
+ .HasColumnType("int");
+
+ b.Property("MinQuantity")
+ .HasColumnType("int");
+
+ b.Property("Weight")
+ .HasColumnType("int");
+
+ b.HasKey("Id");
+
+ b.HasIndex("ItemDefinitionId");
+
+ b.HasIndex("LootTableId");
+
+ b.ToTable("dungeon_loot_table_entries");
+ });
+
+ modelBuilder.Entity("DataServer.Data.Entities.DungeonMobDefinition", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("int");
+
+ MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property("Id"));
+
+ b.Property("AggroRange")
+ .HasColumnType("float");
+
+ b.Property("AnimationSpeed")
+ .HasColumnType("float");
+
+ b.Property("ArmorPerTier")
+ .HasColumnType("float");
+
+ b.Property("AttackRange")
+ .HasColumnType("float");
+
+ b.Property("AttackSpeed")
+ .HasColumnType("float");
+
+ b.Property("BaseArmor")
+ .HasColumnType("int");
+
+ b.Property("BaseHealth")
+ .HasColumnType("int");
+
+ b.Property("BaseMagicDamage")
+ .HasColumnType("int");
+
+ b.Property("BaseMagicResist")
+ .HasColumnType("int");
+
+ b.Property("BaseMana")
+ .HasColumnType("int");
+
+ b.Property("BasePhysicalDamage")
+ .HasColumnType("int");
+
+ b.Property("BaseXp")
+ .HasColumnType("int");
+
+ b.Property("Behavior")
+ .HasColumnType("int");
+
+ b.Property