523 lines
20 KiB
C#
523 lines
20 KiB
C#
using Microsoft.AspNetCore.Mvc;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using DataServer.Data;
|
|
using DataServer.Data.Entities;
|
|
using DataServer.Data.Enums;
|
|
using System.Text.Json;
|
|
|
|
namespace GameServices.Admin.Pages.Mobs;
|
|
|
|
// Helper class for sprite configuration (legacy - keeping for backwards compatibility)
|
|
public class MobSpriteConfig
|
|
{
|
|
public Dictionary<string, string> Sprites { get; set; } = new();
|
|
public Dictionary<string, SpriteAnimation> Animations { get; set; } = new();
|
|
public int FrameWidth { get; set; } = 64;
|
|
public int FrameHeight { get; set; } = 64;
|
|
public int Fps { get; set; } = 8;
|
|
|
|
public int GetFrameCount(string key) => Animations.TryGetValue(key, out var anim) ? anim.Frames : 8;
|
|
public bool IsLooping(string key) => !Animations.TryGetValue(key, out var anim) || anim.Loop;
|
|
|
|
public class SpriteAnimation
|
|
{
|
|
public int Frames { get; set; } = 8;
|
|
public bool Loop { get; set; } = true;
|
|
}
|
|
}
|
|
|
|
public class EditModel : AdminPageModel
|
|
{
|
|
private readonly GameDbContext _db;
|
|
private readonly IConfiguration _config;
|
|
|
|
public EditModel(GameDbContext db, IConfiguration config)
|
|
{
|
|
_db = db;
|
|
_config = config;
|
|
}
|
|
|
|
[BindProperty]
|
|
public DungeonMobDefinition Mob { get; set; } = new();
|
|
|
|
public List<DungeonMobLootTable> MobLootTables { get; set; } = new();
|
|
public List<DungeonLootTable> AllLootTables { get; set; } = new();
|
|
public List<DamageResistanceType> ResistanceTypes { get; set; } = new();
|
|
|
|
// Ability management
|
|
public List<MobAbilityAssignment> MobAbilities { get; set; } = new();
|
|
public List<MobAbilityDefinition> AllAbilities { get; set; } = new();
|
|
public Dictionary<int, string> AbilityAnimationByAssignmentId { get; set; } = new();
|
|
public List<string> AvailableAbilityAnimationKeys { get; set; } = new();
|
|
|
|
// Animation management
|
|
public List<MobAnimationAssignment> MobAnimations { get; set; } = new();
|
|
public List<MobAnimationDefinition> AllAnimations { get; set; } = new();
|
|
public string CdnBaseUrl { get; set; } = "";
|
|
|
|
public bool IsNew => Mob.Id == 0;
|
|
public string? Message { get; set; }
|
|
public bool IsError { get; set; }
|
|
|
|
// Helper to get all resistances as dictionary
|
|
public Dictionary<string, float> Resistances
|
|
{
|
|
get
|
|
{
|
|
try
|
|
{
|
|
return JsonSerializer.Deserialize<Dictionary<string, float>>(Mob.ResistancesJson ?? "{}") ?? new();
|
|
}
|
|
catch { return new(); }
|
|
}
|
|
}
|
|
|
|
// Helper to get single resistance value for a damage type
|
|
public float GetResistance(string damageType)
|
|
{
|
|
if (Resistances.TryGetValue(damageType, out var value))
|
|
return value;
|
|
return 0f;
|
|
}
|
|
|
|
// Sprite config helper
|
|
public MobSpriteConfig SpriteConfig
|
|
{
|
|
get
|
|
{
|
|
try
|
|
{
|
|
if (string.IsNullOrEmpty(Mob.SpriteConfigJson)) return new();
|
|
var options = new JsonSerializerOptions { PropertyNameCaseInsensitive = true };
|
|
return JsonSerializer.Deserialize<MobSpriteConfig>(Mob.SpriteConfigJson, options) ?? new();
|
|
}
|
|
catch { return new(); }
|
|
}
|
|
}
|
|
|
|
public async Task OnGetAsync(int? id)
|
|
{
|
|
CdnBaseUrl = _config["Cdn:BaseUrl"] ?? "https://assets.aeternalisgames.com";
|
|
|
|
AllLootTables = await _db.DungeonLootTables
|
|
.Where(t => t.IsEnabled)
|
|
.OrderBy(t => t.Name)
|
|
.ToListAsync();
|
|
|
|
ResistanceTypes = await _db.DamageResistanceTypes
|
|
.Where(r => r.IsEnabled)
|
|
.OrderBy(r => r.SortOrder)
|
|
.ToListAsync();
|
|
|
|
AllAbilities = await _db.MobAbilityDefinitions
|
|
.Where(a => a.IsEnabled)
|
|
.OrderBy(a => a.Name)
|
|
.ToListAsync();
|
|
|
|
AllAnimations = await _db.MobAnimationDefinitions
|
|
.Include(a => a.SpriteSheet)
|
|
.Where(a => a.IsEnabled)
|
|
.OrderBy(a => a.SpriteSheet!.Name)
|
|
.ThenBy(a => a.Key)
|
|
.ToListAsync();
|
|
|
|
if (id.HasValue)
|
|
{
|
|
var mob = await _db.DungeonMobDefinitions.FindAsync(id.Value);
|
|
if (mob != null)
|
|
{
|
|
Mob = mob;
|
|
MobLootTables = await _db.DungeonMobLootTables
|
|
.Include(m => m.LootTable)
|
|
.ThenInclude(t => t!.Entries)
|
|
.Where(m => m.MobDefinitionId == id.Value)
|
|
.OrderBy(m => m.Priority)
|
|
.ToListAsync();
|
|
|
|
MobAbilities = await _db.MobAbilityAssignments
|
|
.Include(a => a.AbilityDefinition)
|
|
.Where(a => a.MobDefinitionId == id.Value)
|
|
.OrderBy(a => a.AbilityDefinition!.Name)
|
|
.ToListAsync();
|
|
|
|
MobAnimations = await _db.MobAnimationAssignments
|
|
.Include(a => a.AnimationDefinition)
|
|
.ThenInclude(d => d!.SpriteSheet)
|
|
.Where(a => a.MobDefinitionId == id.Value)
|
|
.OrderBy(a => a.AnimationDefinition!.Key)
|
|
.ToListAsync();
|
|
|
|
AvailableAbilityAnimationKeys = BuildAvailableAbilityAnimationKeys(MobAnimations);
|
|
var assignmentIds = MobAbilities.Select(a => a.Id).ToList();
|
|
if (assignmentIds.Count > 0)
|
|
{
|
|
var mappings = await _db.Set<MobAbilityAnimationMapping>()
|
|
.Where(m => assignmentIds.Contains(m.AbilityAssignmentId))
|
|
.ToListAsync();
|
|
AbilityAnimationByAssignmentId = mappings.ToDictionary(m => m.AbilityAssignmentId, m => m.AnimationKey);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Defaults
|
|
Mob.IsEnabled = true;
|
|
Mob.MinTier = 1;
|
|
Mob.MaxTier = 99;
|
|
Mob.BaseHealth = 50;
|
|
Mob.BasePhysicalDamage = 5;
|
|
Mob.DamageTypeKey = "physical";
|
|
Mob.MoveSpeed = 60f;
|
|
Mob.AttackRange = 40f;
|
|
Mob.AttackSpeed = 1.0f;
|
|
Mob.AggroRange = 150f;
|
|
Mob.LeashRange = 400f;
|
|
Mob.HealthPerTier = 1.2f;
|
|
Mob.DamagePerTier = 1.15f;
|
|
Mob.ArmorPerTier = 1.1f;
|
|
Mob.BaseXp = 10;
|
|
Mob.XpPerTier = 1.25f;
|
|
Mob.TintColor = "#ffffff";
|
|
Mob.Scale = 1.0f;
|
|
Mob.AnimationSpeed = 8f;
|
|
}
|
|
}
|
|
|
|
public async Task<IActionResult> OnPostAsync(string? action)
|
|
{
|
|
AllLootTables = await _db.DungeonLootTables.Where(t => t.IsEnabled).OrderBy(t => t.Name).ToListAsync();
|
|
|
|
// Handle checkbox binding
|
|
Mob.IsEnabled = Request.Form.ContainsKey("Mob.IsEnabled");
|
|
|
|
// Ensure nullable strings are never null
|
|
Mob.Description ??= "";
|
|
Mob.TintColor ??= "#ffffff";
|
|
|
|
// Parse resistances from form (array format)
|
|
var resistances = new Dictionary<string, float>();
|
|
var names = Request.Form["resist_name[]"].ToArray();
|
|
var values = Request.Form["resist_value[]"].ToArray();
|
|
for (int i = 0; i < names.Length && i < values.Length; i++)
|
|
{
|
|
var name = names[i]?.Trim().ToLower();
|
|
if (!string.IsNullOrEmpty(name) && float.TryParse(values[i], out var value))
|
|
{
|
|
resistances[name] = value;
|
|
}
|
|
}
|
|
Mob.ResistancesJson = JsonSerializer.Serialize(resistances);
|
|
|
|
// Parse sprite config from form
|
|
var spriteConfig = new MobSpriteConfig();
|
|
if (int.TryParse(Request.Form["sprite_frameWidth"], out var fw)) spriteConfig.FrameWidth = fw;
|
|
if (int.TryParse(Request.Form["sprite_frameHeight"], out var fh)) spriteConfig.FrameHeight = fh;
|
|
if (int.TryParse(Request.Form["sprite_fps"], out var fps)) spriteConfig.Fps = fps;
|
|
|
|
var spriteKeys = Request.Form["sprite_key[]"].ToArray();
|
|
var spritePaths = Request.Form["sprite_path[]"].ToArray();
|
|
var spriteFrames = Request.Form["sprite_frames[]"].ToArray();
|
|
var spriteLoops = Request.Form["sprite_loop[]"].ToArray();
|
|
|
|
for (int i = 0; i < spriteKeys.Length && i < spritePaths.Length; i++)
|
|
{
|
|
var key = spriteKeys[i]?.Trim();
|
|
var path = spritePaths[i]?.Trim();
|
|
if (!string.IsNullOrEmpty(key) && !string.IsNullOrEmpty(path))
|
|
{
|
|
spriteConfig.Sprites[key] = path;
|
|
var frames = i < spriteFrames.Length && int.TryParse(spriteFrames[i], out var f) ? f : 8;
|
|
var loop = spriteLoops.Contains(key) || spriteLoops.Contains("new");
|
|
spriteConfig.Animations[key] = new MobSpriteConfig.SpriteAnimation { Frames = frames, Loop = loop };
|
|
}
|
|
}
|
|
|
|
if (spriteConfig.Sprites.Any())
|
|
{
|
|
Mob.SpriteConfigJson = JsonSerializer.Serialize(spriteConfig, new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });
|
|
}
|
|
else
|
|
{
|
|
Mob.SpriteConfigJson = null;
|
|
}
|
|
|
|
if (string.IsNullOrWhiteSpace(Mob.Name))
|
|
{
|
|
Message = "Name is required.";
|
|
IsError = true;
|
|
return Page();
|
|
}
|
|
|
|
try
|
|
{
|
|
if (action == "duplicate")
|
|
{
|
|
var newMob = new DungeonMobDefinition
|
|
{
|
|
Name = Mob.Name + " (Copy)",
|
|
Description = Mob.Description ?? "",
|
|
Type = Mob.Type,
|
|
Category = Mob.Category,
|
|
MinTier = Mob.MinTier,
|
|
MaxTier = Mob.MaxTier,
|
|
BaseHealth = Mob.BaseHealth,
|
|
BaseMana = Mob.BaseMana,
|
|
BasePhysicalDamage = Mob.BasePhysicalDamage,
|
|
BaseMagicDamage = Mob.BaseMagicDamage,
|
|
BaseArmor = Mob.BaseArmor,
|
|
BaseMagicResist = Mob.BaseMagicResist,
|
|
MoveSpeed = Mob.MoveSpeed,
|
|
AttackRange = Mob.AttackRange,
|
|
AttackSpeed = Mob.AttackSpeed,
|
|
AggroRange = Mob.AggroRange,
|
|
LeashRange = Mob.LeashRange,
|
|
HealthPerTier = Mob.HealthPerTier,
|
|
DamagePerTier = Mob.DamagePerTier,
|
|
ArmorPerTier = Mob.ArmorPerTier,
|
|
BaseXp = Mob.BaseXp,
|
|
XpPerTier = Mob.XpPerTier,
|
|
TintColor = Mob.TintColor,
|
|
Scale = Mob.Scale,
|
|
AnimationSpeed = Mob.AnimationSpeed,
|
|
SpriteConfigJson = Mob.SpriteConfigJson,
|
|
ResistancesJson = Mob.ResistancesJson,
|
|
Behavior = Mob.Behavior,
|
|
PreferredRange = Mob.PreferredRange,
|
|
FleeThreshold = Mob.FleeThreshold,
|
|
CallForHelpRadius = Mob.CallForHelpRadius,
|
|
IsEnabled = Mob.IsEnabled
|
|
};
|
|
_db.DungeonMobDefinitions.Add(newMob);
|
|
await _db.SaveChangesAsync();
|
|
return RedirectToPage("/Mobs/Edit", new { id = newMob.Id });
|
|
}
|
|
|
|
if (Mob.Id == 0)
|
|
{
|
|
_db.DungeonMobDefinitions.Add(Mob);
|
|
await _db.SaveChangesAsync();
|
|
Message = $"Mob '{Mob.Name}' created. Now assign loot tables below.";
|
|
return RedirectToPage("/Mobs/Edit", new { id = Mob.Id });
|
|
}
|
|
else
|
|
{
|
|
var existing = await _db.DungeonMobDefinitions.FindAsync(Mob.Id);
|
|
if (existing == null)
|
|
{
|
|
Message = "Mob not found.";
|
|
IsError = true;
|
|
return Page();
|
|
}
|
|
|
|
existing.Name = Mob.Name;
|
|
existing.Description = Mob.Description;
|
|
existing.Type = Mob.Type;
|
|
existing.Category = Mob.Category;
|
|
existing.MinTier = Mob.MinTier;
|
|
existing.MaxTier = Mob.MaxTier;
|
|
existing.BaseHealth = Mob.BaseHealth;
|
|
existing.BaseMana = Mob.BaseMana;
|
|
existing.BasePhysicalDamage = Mob.BasePhysicalDamage;
|
|
existing.BaseMagicDamage = Mob.BaseMagicDamage;
|
|
existing.BaseArmor = Mob.BaseArmor;
|
|
existing.BaseMagicResist = Mob.BaseMagicResist;
|
|
existing.MoveSpeed = Mob.MoveSpeed;
|
|
existing.AttackRange = Mob.AttackRange;
|
|
existing.AttackSpeed = Mob.AttackSpeed;
|
|
existing.AggroRange = Mob.AggroRange;
|
|
existing.LeashRange = Mob.LeashRange;
|
|
existing.HealthPerTier = Mob.HealthPerTier;
|
|
existing.DamagePerTier = Mob.DamagePerTier;
|
|
existing.ArmorPerTier = Mob.ArmorPerTier;
|
|
existing.BaseXp = Mob.BaseXp;
|
|
existing.XpPerTier = Mob.XpPerTier;
|
|
existing.TintColor = Mob.TintColor;
|
|
existing.Scale = Mob.Scale;
|
|
existing.AnimationSpeed = Mob.AnimationSpeed;
|
|
existing.SpriteConfigJson = Mob.SpriteConfigJson;
|
|
existing.ResistancesJson = Mob.ResistancesJson;
|
|
existing.IsEnabled = Mob.IsEnabled;
|
|
|
|
await _db.SaveChangesAsync();
|
|
Mob = existing;
|
|
|
|
MobLootTables = await _db.DungeonMobLootTables
|
|
.Include(m => m.LootTable)
|
|
.ThenInclude(t => t!.Entries)
|
|
.Where(m => m.MobDefinitionId == Mob.Id)
|
|
.OrderBy(m => m.Priority)
|
|
.ToListAsync();
|
|
|
|
Message = "Changes saved successfully.";
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Message = $"Error: {ex.Message}";
|
|
IsError = true;
|
|
}
|
|
|
|
return Page();
|
|
}
|
|
|
|
public async Task<IActionResult> OnPostAddLootAsync(int mobId, int lootTableId, int priority, float rollChance)
|
|
{
|
|
var mapping = new DungeonMobLootTable
|
|
{
|
|
MobDefinitionId = mobId,
|
|
LootTableId = lootTableId,
|
|
Priority = priority,
|
|
RollChance = rollChance
|
|
};
|
|
|
|
_db.DungeonMobLootTables.Add(mapping);
|
|
await _db.SaveChangesAsync();
|
|
|
|
return RedirectToPage("/Mobs/Edit", new { id = mobId });
|
|
}
|
|
|
|
public async Task<IActionResult> OnPostRemoveLootAsync(int mappingId, int mobId)
|
|
{
|
|
var mapping = await _db.DungeonMobLootTables.FindAsync(mappingId);
|
|
if (mapping != null)
|
|
{
|
|
_db.DungeonMobLootTables.Remove(mapping);
|
|
await _db.SaveChangesAsync();
|
|
}
|
|
|
|
return RedirectToPage("/Mobs/Edit", new { id = mobId });
|
|
}
|
|
|
|
public async Task<IActionResult> OnPostAddAbilityAsync(int mobId, int abilityId, int priority, int phase, string? animationKey)
|
|
{
|
|
// Check if already assigned
|
|
var existing = await _db.MobAbilityAssignments
|
|
.FirstOrDefaultAsync(a => a.MobDefinitionId == mobId && a.AbilityDefinitionId == abilityId);
|
|
|
|
if (existing != null)
|
|
{
|
|
TempData["Error"] = "This ability is already assigned to this mob.";
|
|
return RedirectToPage("/Mobs/Edit", new { id = mobId });
|
|
}
|
|
|
|
var assignment = new MobAbilityAssignment
|
|
{
|
|
MobDefinitionId = mobId,
|
|
AbilityDefinitionId = abilityId,
|
|
PriorityOverride = priority > 0 ? priority : null,
|
|
Phase = phase,
|
|
IsEnabled = true
|
|
};
|
|
|
|
_db.MobAbilityAssignments.Add(assignment);
|
|
await _db.SaveChangesAsync();
|
|
|
|
if (!string.IsNullOrWhiteSpace(animationKey))
|
|
{
|
|
var mapping = new MobAbilityAnimationMapping
|
|
{
|
|
AbilityAssignmentId = assignment.Id,
|
|
AnimationKey = animationKey.Trim()
|
|
};
|
|
_db.Set<MobAbilityAnimationMapping>().Add(mapping);
|
|
await _db.SaveChangesAsync();
|
|
}
|
|
|
|
return RedirectToPage("/Mobs/Edit", new { id = mobId });
|
|
}
|
|
|
|
public async Task<IActionResult> OnPostRemoveAbilityAsync(int assignmentId, int mobId)
|
|
{
|
|
var assignment = await _db.MobAbilityAssignments.FindAsync(assignmentId);
|
|
if (assignment != null)
|
|
{
|
|
var mappings = await _db.Set<MobAbilityAnimationMapping>()
|
|
.Where(m => m.AbilityAssignmentId == assignmentId)
|
|
.ToListAsync();
|
|
if (mappings.Count > 0)
|
|
{
|
|
_db.Set<MobAbilityAnimationMapping>().RemoveRange(mappings);
|
|
}
|
|
|
|
_db.MobAbilityAssignments.Remove(assignment);
|
|
await _db.SaveChangesAsync();
|
|
}
|
|
|
|
return RedirectToPage("/Mobs/Edit", new { id = mobId });
|
|
}
|
|
|
|
public async Task<IActionResult> OnPostToggleAbilityAsync(int assignmentId, int mobId)
|
|
{
|
|
var assignment = await _db.MobAbilityAssignments.FindAsync(assignmentId);
|
|
if (assignment != null)
|
|
{
|
|
assignment.IsEnabled = !assignment.IsEnabled;
|
|
await _db.SaveChangesAsync();
|
|
}
|
|
|
|
return RedirectToPage("/Mobs/Edit", new { id = mobId });
|
|
}
|
|
|
|
public async Task<IActionResult> OnPostAddAnimationAsync(int mobId, int animationId, string? overrideKey, int priority)
|
|
{
|
|
// Check if already assigned
|
|
var existing = await _db.MobAnimationAssignments
|
|
.FirstOrDefaultAsync(a => a.MobDefinitionId == mobId && a.AnimationDefinitionId == animationId);
|
|
|
|
if (existing != null)
|
|
{
|
|
TempData["Error"] = "This animation is already assigned to this mob.";
|
|
return RedirectToPage("/Mobs/Edit", new { id = mobId });
|
|
}
|
|
|
|
var assignment = new MobAnimationAssignment
|
|
{
|
|
MobDefinitionId = mobId,
|
|
AnimationDefinitionId = animationId,
|
|
OverrideKey = string.IsNullOrWhiteSpace(overrideKey) ? null : overrideKey,
|
|
Priority = priority,
|
|
IsEnabled = true
|
|
};
|
|
|
|
_db.MobAnimationAssignments.Add(assignment);
|
|
await _db.SaveChangesAsync();
|
|
|
|
return Redirect($"/admin/mobs/edit?id={mobId}#animations-section");
|
|
}
|
|
|
|
public async Task<IActionResult> OnPostRemoveAnimationAsync(int assignmentId, int mobId)
|
|
{
|
|
var assignment = await _db.MobAnimationAssignments.FindAsync(assignmentId);
|
|
if (assignment != null)
|
|
{
|
|
_db.MobAnimationAssignments.Remove(assignment);
|
|
await _db.SaveChangesAsync();
|
|
}
|
|
|
|
return Redirect($"/admin/mobs/edit?id={mobId}#animations-section");
|
|
}
|
|
|
|
public async Task<IActionResult> OnPostToggleAnimationAsync(int assignmentId, int mobId)
|
|
{
|
|
var assignment = await _db.MobAnimationAssignments.FindAsync(assignmentId);
|
|
if (assignment != null)
|
|
{
|
|
assignment.IsEnabled = !assignment.IsEnabled;
|
|
await _db.SaveChangesAsync();
|
|
}
|
|
|
|
return Redirect($"/admin/mobs/edit?id={mobId}#animations-section");
|
|
}
|
|
|
|
private static List<string> BuildAvailableAbilityAnimationKeys(IEnumerable<MobAnimationAssignment> assignments)
|
|
{
|
|
return assignments
|
|
.Select(a => !string.IsNullOrWhiteSpace(a.OverrideKey) ? a.OverrideKey : a.AnimationDefinition?.Key)
|
|
.Where(k => !string.IsNullOrWhiteSpace(k))
|
|
.Select(k => k!.Trim())
|
|
.Distinct(StringComparer.OrdinalIgnoreCase)
|
|
.OrderBy(k => k)
|
|
.ToList();
|
|
}
|
|
}
|