Files
systemrevivalserver/Services/Admin/Pages/Mobs/Edit.cshtml.cs
T

481 lines
18 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();
// 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();
}
}
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)
{
// 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();
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)
{
_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");
}
}