Files
2026-01-31 20:55:26 -05:00

348 lines
12 KiB
C#

using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using DataServer.Data;
using DataServer.Data.Entities;
using System.Text.Json;
namespace GameServices.Admin.Pages.TileMaps;
public class EditModel : AdminPageModel
{
private readonly GameDbContext _db;
private readonly IConfiguration _config;
public EditModel(GameDbContext db, IConfiguration config)
{
_db = db;
_config = config;
}
[BindProperty]
public TileMapSheet Sheet { get; set; } = new();
public List<TileDefinition> TileDefinitions { get; set; } = new();
public List<TileDefinitionRow> TileDefinitionRows { get; set; } = new();
public string TileDefinitionsJson => JsonSerializer.Serialize(
TileDefinitionRows.Select(r => new { id = r.Id, frameIndex = r.FrameIndex })
);
public List<ClientAsset> CdnImages { get; set; } = new();
public string CdnBaseUrl { get; set; } = "";
public string? Message { get; set; }
public bool IsError { get; set; }
public async Task OnGetAsync(int? id)
{
CdnBaseUrl = NormalizeCdnBaseUrl(_config["Cdn:BaseUrl"] ?? "https://assets.aeternalisgames.com");
CdnImages = await _db.ClientAssets
.Where(a => a.AssetType == ClientAssetType.Texture && a.IsEnabled)
.Where(a => a.FilePath.StartsWith("textures/tilemaps/") || a.FilePath.Contains("tilemap"))
.OrderBy(a => a.FilePath)
.ToListAsync();
// Also get all textures as fallback
if (CdnImages.Count == 0)
{
CdnImages = await _db.ClientAssets
.Where(a => a.AssetType == ClientAssetType.Texture && a.IsEnabled)
.OrderBy(a => a.FilePath)
.ToListAsync();
}
if (id.HasValue)
{
var sheet = await _db.TileMapSheets
.Include(s => s.Tiles)
.FirstOrDefaultAsync(s => s.Id == id.Value);
if (sheet != null)
{
Sheet = sheet;
TileDefinitions = sheet.Tiles?.OrderBy(t => t.FrameIndex).ToList() ?? new();
await LoadTileDefinitionRows();
}
}
else
{
Sheet = new TileMapSheet
{
IsEnabled = true,
TileWidth = 32,
TileHeight = 32
};
}
}
public async Task<IActionResult> OnPostAsync()
{
CdnBaseUrl = NormalizeCdnBaseUrl(_config["Cdn:BaseUrl"] ?? "https://assets.aeternalisgames.com");
try
{
if (Sheet.Id == 0)
{
Sheet.CreatedAt = DateTime.UtcNow;
Sheet.UpdatedAt = DateTime.UtcNow;
_db.TileMapSheets.Add(Sheet);
await _db.SaveChangesAsync();
Message = $"TileMap sheet '{Sheet.Name}' created.";
return RedirectToPage(new { id = Sheet.Id });
}
else
{
var existing = await _db.TileMapSheets.FindAsync(Sheet.Id);
if (existing == null)
{
Message = "TileMap sheet not found.";
IsError = true;
return Page();
}
existing.Name = Sheet.Name;
existing.CdnPath = Sheet.CdnPath;
existing.Tags = Sheet.Tags;
existing.SheetWidth = Sheet.SheetWidth;
existing.SheetHeight = Sheet.SheetHeight;
existing.TileWidth = Sheet.TileWidth;
existing.TileHeight = Sheet.TileHeight;
existing.IsEnabled = Sheet.IsEnabled;
existing.UpdatedAt = DateTime.UtcNow;
await _db.SaveChangesAsync();
Sheet = existing;
Message = "TileMap sheet updated.";
TileDefinitions = await _db.TileDefinitions
.Where(t => t.TileMapSheetId == Sheet.Id)
.OrderBy(t => t.FrameIndex)
.ToListAsync();
await LoadTileDefinitionRows();
}
}
catch (Exception ex)
{
Message = $"Error: {ex.Message}";
IsError = true;
}
CdnImages = await _db.ClientAssets
.Where(a => a.AssetType == ClientAssetType.Texture && a.IsEnabled)
.OrderBy(a => a.FilePath)
.ToListAsync();
return Page();
}
public async Task<IActionResult> OnPostSaveTileAsync(
int sheetId,
int frameIndex,
string? name,
int type,
string? tags,
bool isWalkable,
bool blocksProjectiles,
bool blocksLineOfSight,
int renderLayer,
// Socket fields
int socketN,
int socketE,
int socketS,
int socketW,
string? socketNCustom,
string? socketECustom,
string? socketSCustom,
string? socketWCustom)
{
var existing = await _db.TileDefinitions
.FirstOrDefaultAsync(t => t.TileMapSheetId == sheetId && t.FrameIndex == frameIndex);
if (existing != null)
{
existing.Name = name;
existing.Type = (TileType)type;
existing.Tags = tags;
existing.IsWalkable = isWalkable;
existing.BlocksProjectiles = blocksProjectiles;
existing.BlocksLineOfSight = blocksLineOfSight;
existing.RenderLayer = renderLayer;
// Socket fields
existing.SocketN = (SocketType)socketN;
existing.SocketE = (SocketType)socketE;
existing.SocketS = (SocketType)socketS;
existing.SocketW = (SocketType)socketW;
existing.SocketNCustom = socketN == 2 ? socketNCustom : null;
existing.SocketECustom = socketE == 2 ? socketECustom : null;
existing.SocketSCustom = socketS == 2 ? socketSCustom : null;
existing.SocketWCustom = socketW == 2 ? socketWCustom : null;
}
else
{
_db.TileDefinitions.Add(new TileDefinition
{
TileMapSheetId = sheetId,
FrameIndex = frameIndex,
Name = name,
Type = (TileType)type,
Tags = tags,
IsWalkable = isWalkable,
BlocksProjectiles = blocksProjectiles,
BlocksLineOfSight = blocksLineOfSight,
RenderLayer = renderLayer,
IsEnabled = true,
// Socket fields
SocketN = (SocketType)socketN,
SocketE = (SocketType)socketE,
SocketS = (SocketType)socketS,
SocketW = (SocketType)socketW,
SocketNCustom = socketN == 2 ? socketNCustom : null,
SocketECustom = socketE == 2 ? socketECustom : null,
SocketSCustom = socketS == 2 ? socketSCustom : null,
SocketWCustom = socketW == 2 ? socketWCustom : null
});
}
await _db.SaveChangesAsync();
return RedirectToPage(new { id = sheetId });
}
public async Task<IActionResult> OnPostDeleteTileAsync(int tileId, int sheetId)
{
var tile = await _db.TileDefinitions.FindAsync(tileId);
if (tile != null)
{
_db.TileDefinitions.Remove(tile);
await _db.SaveChangesAsync();
}
return RedirectToPage(new { id = sheetId });
}
public async Task<IActionResult> OnPostAutoGenerateAsync(int sheetId, int defaultType)
{
var sheet = await _db.TileMapSheets.FindAsync(sheetId);
if (sheet == null) return RedirectToPage();
// Generate tile definitions for all frames that don't have one
var existingFrames = await _db.TileDefinitions
.Where(t => t.TileMapSheetId == sheetId)
.Select(t => t.FrameIndex)
.ToListAsync();
var totalTiles = sheet.TotalTiles;
for (int i = 0; i < totalTiles; i++)
{
if (!existingFrames.Contains(i))
{
var tile = new TileDefinition
{
TileMapSheetId = sheetId,
FrameIndex = i,
Type = (TileType)defaultType,
IsWalkable = defaultType == 0, // Floor is walkable
IsEnabled = true
};
// Auto-configure sockets based on type
tile.AutoConfigureSockets();
_db.TileDefinitions.Add(tile);
}
}
await _db.SaveChangesAsync();
return RedirectToPage(new { id = sheetId });
}
/// <summary>
/// Auto-configure sockets for all tiles based on their type
/// </summary>
public async Task<IActionResult> OnPostAutoConfigureSocketsAsync(int sheetId)
{
var tiles = await _db.TileDefinitions
.Where(t => t.TileMapSheetId == sheetId)
.ToListAsync();
foreach (var tile in tiles)
{
tile.AutoConfigureSockets();
}
await _db.SaveChangesAsync();
Message = $"Auto-configured sockets for {tiles.Count} tiles.";
return RedirectToPage(new { id = sheetId });
}
/// <summary>
/// Bulk set all tile sockets to a specific type
/// </summary>
public async Task<IActionResult> OnPostBulkSetSocketsAsync(int sheetId, int socketType)
{
var tiles = await _db.TileDefinitions
.Where(t => t.TileMapSheetId == sheetId)
.ToListAsync();
var type = (SocketType)socketType;
foreach (var tile in tiles)
{
tile.SetAllSockets(type);
}
await _db.SaveChangesAsync();
Message = $"Set all sockets to {type} for {tiles.Count} tiles.";
return RedirectToPage(new { id = sheetId });
}
private string NormalizeCdnBaseUrl(string? baseUrl)
{
baseUrl = string.IsNullOrWhiteSpace(baseUrl)
? "https://assets.aeternalisgames.com"
: baseUrl;
baseUrl = baseUrl.TrimEnd('/');
if (!baseUrl.EndsWith("/downloads", StringComparison.OrdinalIgnoreCase))
baseUrl += "/downloads";
return baseUrl;
}
private async Task LoadTileDefinitionRows()
{
if (Sheet.Id == 0)
{
TileDefinitionRows = new();
return;
}
var tileDefs = await _db.TileDefinitions
.Where(t => t.TileMapSheetId == Sheet.Id)
.OrderBy(t => t.FrameIndex)
.ToListAsync();
var tileIds = tileDefs.Select(t => t.Id).ToList();
var bucketCounts = await _db.TileDefinitionBuckets
.Where(b => tileIds.Contains(b.TileDefinitionId))
.GroupBy(b => b.TileDefinitionId)
.Select(g => new { TileDefinitionId = g.Key, Count = g.Count() })
.ToDictionaryAsync(g => g.TileDefinitionId, g => g.Count);
TileDefinitionRows = tileDefs.Select(t => new TileDefinitionRow
{
Id = t.Id,
FrameIndex = t.FrameIndex,
Name = t.Name,
Type = t.Type.ToString(),
BucketCount = bucketCounts.TryGetValue(t.Id, out var count) ? count : 0
}).ToList();
}
public class TileDefinitionRow
{
public int Id { get; set; }
public int FrameIndex { get; set; }
public string? Name { get; set; }
public string Type { get; set; } = "";
public int BucketCount { get; set; }
}
}