warrentyexpired/ModernUO
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 1

fix: Fixes codegenned spawners and adds RunUO spawner import support (#1682)

Browse source 
> [!IMPORTANT]  
> This code change includes important fixes for all spawners after they were converted to codegen!

> [!NOTE] 
> **Developer Note**
> Usage/Description/Aliases attributes were moved to the core so they can be used by the command registration system.

### Summary
- **Fixes spawners not registering their spawns on world load**
- Changes `[GenerateSpawners` to `[ImportSpawners`
- Removes `ConvertPremiumSpawners`
- Adds Premium spawner import support to `[ImportSpawners`
- Adds RunUO XML import support: https://github.com/ruaduck/xmlspawner/blob/ServUOMaster/XmlSpawner/XmlSpawner%20Core/SpawnerExporter.cs
- Fixed an issue where not manually registering an alias meant it wasn't available as a command
This commit is contained in:
Kamron Batman 2024-02-17 10:46:55 -08:00 • committed by GitHub
parent cc064a27a5
commit d0d7be8de0
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
12 changed files with 568 additions and 522 deletions
Download patch file Download diff file Expand all files Collapse all files

24
Projects/Server/Attributes.cs
View file

@ -125,6 +125,30 @@ public class ConstructibleAttribute : Attribute
public AccessLevel AccessLevel { get; set; }
}
[AttributeUsage(AttributeTargets.Method)]
public class UsageAttribute : Attribute
{
public UsageAttribute(string usage) => Usage = usage;
public string Usage { get; }
}
[AttributeUsage(AttributeTargets.Method)]
public class DescriptionAttribute : Attribute
{
public DescriptionAttribute(string description) => Description = description;
public string Description { get; }
}
[AttributeUsage(AttributeTargets.Method)]
public class AliasesAttribute : Attribute
{
public AliasesAttribute(params string[] aliases) => Aliases = aliases;
public string[] Aliases { get; }
}
[AttributeUsage(AttributeTargets.Property)]
public class CommandPropertyAttribute : Attribute
{

38
Projects/Server/Commands.cs
View file

@ -15,6 +15,9 @@
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Runtime.InteropServices;
using Server.Logging;
namespace Server;
@ -125,6 +128,8 @@ public class CommandInfoSorter : IComparer<CommandInfo>
public static class CommandSystem
{
private static readonly ILogger logger = LogFactory.GetLogger(typeof(CommandSystem));
public static string Prefix { get; set; } = "[";
public static Dictionary<string, CommandEntry> Entries { get; } = new(StringComparer.OrdinalIgnoreCase);
@ -194,7 +199,38 @@ public static class CommandSystem
public static void Register(string command, AccessLevel access, CommandEventHandler handler)
{
Entries[command] = new CommandEntry(command, handler, access);
DoRegister(command, access, handler);
var mi = handler.Method;
var aliasesAttr = mi.GetCustomAttribute(typeof(AliasesAttribute), false) as AliasesAttribute;
var aliases = aliasesAttr?.Aliases;
if (aliases == null)
{
return;
}
foreach (var alias in aliases)
{
DoRegister(alias, access, handler);
}
}
private static void DoRegister(string command, AccessLevel accessLevel, CommandEventHandler handler)
{
ref var commandEntry = ref CollectionsMarshal.GetValueRefOrAddDefault(Entries, command, out var exists);
if (exists)
{
if (commandEntry.AccessLevel == accessLevel && commandEntry.Handler == handler)
{
return;
}
logger.Warning("Command {Command} already registered to {Handler}.", command, commandEntry.Handler.Method.Name);
return;
}
commandEntry = new CommandEntry(command, handler, accessLevel);
}
public static bool Handle(Mobile from, string text, MessageType type = MessageType.Regular)

1
Projects/Server/Json/JsonConfig.cs
View file

@ -49,6 +49,7 @@ public static class JsonConfig
options.Converters.Add(new IPEndPointConverterFactory());
options.Converters.Add(new TypeConverterFactory());
options.Converters.Add(new WorldLocationConverterFactory());
options.Converters.Add(new TextDefinitionConverterFactory());
for (var i = 0; i < converters.Length; i++)
{

28
Projects/UOContent/Commands/Attributes.cs
View file

@ -1,28 +0,0 @@
using System;
namespace Server
{
[AttributeUsage(AttributeTargets.Method)]
public class UsageAttribute : Attribute
{
public UsageAttribute(string usage) => Usage = usage;
public string Usage { get; }
}
[AttributeUsage(AttributeTargets.Method)]
public class DescriptionAttribute : Attribute
{
public DescriptionAttribute(string description) => Description = description;
public string Description { get; }
}
[AttributeUsage(AttributeTargets.Method)]
public class AliasesAttribute : Attribute
{
public AliasesAttribute(params string[] aliases) => Aliases = aliases;
public string[] Aliases { get; }
}
}

18
Projects/UOContent/Commands/Handlers.cs
View file

@ -33,7 +33,6 @@ namespace Server.Commands
Register("Where", AccessLevel.Counselor, Where_OnCommand);
Register("AutoPageNotify", AccessLevel.Counselor, APN_OnCommand);
Register("APN", AccessLevel.Counselor, APN_OnCommand);
Register("Animate", AccessLevel.GameMaster, Animate_OnCommand);
@ -47,12 +46,8 @@ namespace Server.Commands
Register("Client", AccessLevel.Counselor, Client_OnCommand);
Register("SMsg", AccessLevel.Counselor, StaffMessage_OnCommand);
Register("SM", AccessLevel.Counselor, StaffMessage_OnCommand);
Register("S", AccessLevel.Counselor, StaffMessage_OnCommand);
Register("BCast", AccessLevel.GameMaster, BroadcastMessage_OnCommand);
Register("BC", AccessLevel.GameMaster, BroadcastMessage_OnCommand);
Register("B", AccessLevel.GameMaster, BroadcastMessage_OnCommand);
Register("Bank", AccessLevel.GameMaster, Bank_OnCommand);
@ -736,14 +731,16 @@ namespace Server.Commands
}
}
[Usage("SMsg <text>"), Aliases("S", "SM")]
[Usage("SMsg <text>")]
[Aliases("S", "SM")]
[Description("Broadcasts a message to all online staff.")]
public static void StaffMessage_OnCommand(CommandEventArgs e)
{
BroadcastMessage(AccessLevel.Counselor, e.Mobile.SpeechHue, $"[{e.Mobile.Name}] {e.ArgString}");
}
[Usage("BCast <text>"), Aliases("B", "BC")]
[Usage("BCast <text>")]
[Aliases("B", "BC")]
[Description("Broadcasts a message to everyone online.")]
public static void BroadcastMessage_OnCommand(CommandEventArgs e)
{
@ -764,7 +761,8 @@ namespace Server.Commands
}
}
[Usage("AutoPageNotify"), Aliases("APN")]
[Usage("AutoPageNotify")]
[Aliases("APN")]
[Description("Toggles your auto-page-notify status.")]
public static void APN_OnCommand(CommandEventArgs e)
{
@ -782,8 +780,8 @@ namespace Server.Commands
}
}
[Usage("Animate <action> <frameCount> <repeatCount> <forward> <repeat> <delay>"),
Description("Makes your character do a specified animation.")]
[Usage("Animate <action> <frameCount> <repeatCount> <forward> <repeat> <delay>")]
[Description("Makes your character do a specified animation.")]
public static void Animate_OnCommand(CommandEventArgs e)
{
if (e.Length == 6)

33
Projects/UOContent/Engines/Spawners/BaseSpawner.cs
View file

@ -1,6 +1,5 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Reflection;
using System.Text.Json;
using ModernUO.Serialization;
@ -216,11 +215,8 @@ public abstract partial class BaseSpawner : Item, ISpawner
if (spawn != null)
{
Spawned.TryGetValue(spawn, out var entry);
entry?.Spawned.Remove(spawn);
Spawned.Remove(spawn);
Spawned.Remove(spawn, out var entry);
entry?.RemoveFromSpawned(spawn);
}
if (_running && !IsFull && _timer?.Running == false)
@ -419,12 +415,7 @@ public abstract partial class BaseSpawner : Item, ISpawner
};
}
if (remove)
{
Spawned.Remove(spawned);
}
return remove;
return remove && Spawned.Remove(spawned);
}
public void OnTick()
@ -683,7 +674,7 @@ public abstract partial class BaseSpawner : Item, ISpawner
if (entity is Mobile m)
{
Spawned.Add(m, entry);
entry.Spawned.Add(m);
entry.AddToSpawned(m);
var loc = m is BaseVendor ? Location : GetSpawnPosition(m, map);
@ -712,7 +703,7 @@ public abstract partial class BaseSpawner : Item, ISpawner
else if (entity is Item item)
{
Spawned.Add(item, entry);
entry.Spawned.Add(item);
entry.AddToSpawned(item);
var loc = GetSpawnPosition(item, map);
@ -884,8 +875,6 @@ public abstract partial class BaseSpawner : Item, ISpawner
private void Deserialize(IGenericReader reader, int version)
{
Spawned = new Dictionary<ISpawnable, SpawnerEntry>();
_guid = reader.ReadGuid();
_returnOnDeactivate = reader.ReadBool();
_entries = new List<SpawnerEntry>(reader.ReadInt());
@ -910,9 +899,19 @@ public abstract partial class BaseSpawner : Item, ISpawner
_end = _running ? reader.ReadDeltaTime() : Core.Now;
}
[AfterDeserialization(false)]
[AfterDeserialization]
private void AfterDeserialization()
{
Spawned = new Dictionary<ISpawnable, SpawnerEntry>();
foreach (var entry in Entries)
{
foreach (var spawned in entry.Spawned)
{
Spawned.Add(spawned, entry);
}
}
if (_running && _end > Core.Now)
{
DoTimer(_end - Core.Now);

257
Projects/UOContent/Engines/Spawners/Commands/ConvertPremiumSpawners.cs
View file

@ -1,257 +0,0 @@
/*************************************************************************
* ModernUO *
* Copyright 2019-2023 - ModernUO Development Team *
* Email: hi@modernuo.com *
* File: ConvertPremiumSpawners.cs *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
*************************************************************************/
using System;
using System.Collections.Generic;
using System.IO;
using System.Text.Json;
using Microsoft.Extensions.FileSystemGlobbing;
using Microsoft.Extensions.FileSystemGlobbing.Abstractions;
using Server.Json;
using Server.Logging;
using Server.Network;
namespace Server.Engines.Spawners;
public static class ConvertPremiumSpawners
{
private static readonly ILogger logger = LogFactory.GetLogger(typeof(ConvertPremiumSpawners));
public static void Configure()
{
CommandSystem.Register("ConvertPremiumSpawners", AccessLevel.Developer, ConvertPremiumSpawners_OnCommand);
}
[Usage("ConvertPremiumSpawners <relative search pattern to distribution> <output directory relative to distribution>")]
[Description("Converts Nerun's Premium Spawners to JSON.")]
private static void ConvertPremiumSpawners_OnCommand(CommandEventArgs args)
{
var from = args.Mobile;
if (args.Arguments.Length != 2)
{
from.SendMessage("Usage: [ConvertPremiumSpawners <relative search pattern to distribution> <output directory relative to distribution>");
return;
}
var inputDi = new DirectoryInfo(Core.BaseDirectory);
var patternMatches = new Matcher()
.AddInclude(args.Arguments[0])
.Execute(new DirectoryInfoWrapper(inputDi))
.Files;
List<(FileInfo, string)> files = [];
foreach (var match in patternMatches)
{
files.Add((new FileInfo(match.Path), match.Stem));
}
if (files.Count == 0)
{
from.SendMessage("ConvertPremiumSpawners: No files found.");
return;
}
var outputDir = Path.Combine(Core.BaseDirectory, args.Arguments[1]);
var options = JsonConfig.GetOptions(new TextDefinitionConverterFactory());
for (var i = 0; i < files.Count; i++)
{
var (file, stem) = files[i];
from.SendMessage($"ConvertPremiumSpawners: Converting spawners for {stem}...");
NetState.FlushAll();
try
{
var stemDir = stem[..^file.Name.Length];
var fullOutputDir = Path.Combine(outputDir, stemDir);
PathUtility.EnsureDirectory(fullOutputDir);
var outputFileName = $"{file.Name.AsSpan(0, file.Name.Length - file.Extension.Length)}.json";
ParsePremiumSpawnerFile(file.FullName, Path.Combine(fullOutputDir, outputFileName), options);
}
catch (Exception e)
{
logger.Error(e.ToString());
from.SendMessage($"ConvertPremiumSpawners: Exception parsing {stem}, file may not be in the correct format.");
}
}
}
private static void ParsePremiumSpawnerFile(string inputFile, string outputFile, JsonSerializerOptions options)
{
var lines = File.ReadAllLines(inputFile);
TimeSpan minTime = TimeSpan.MinValue;
TimeSpan maxTime = TimeSpan.MinValue;
int mapId = -1;
string spawnerId = null;
var json = new List<DynamicJson>();
foreach (var line in lines)
{
if (line.StartsWithOrdinal("#"))
{
continue;
}
if (line.StartsWith('*'))
{
var spawners = ParsePremiumSpawner(line.Split('|'), spawnerId, mapId, minTime, maxTime);
foreach (var spawner in spawners)
{
var dynamicJson = new DynamicJson
{
Type = "Spawner",
Data = new Dictionary<string, JsonElement>()
};
spawner.ToJson(dynamicJson, options);
json.Add(dynamicJson);
spawner.Delete();
}
spawners.Clear();
continue;
}
var over = line.Split(' ');
switch (over[0].ToLowerInvariant())
{
case "overrideid":
{
spawnerId = over[1];
break;
}
case "overridemap":
{
mapId = int.Parse(over[1]);
break;
}
case "overridemintime":
{
minTime = GetTimeSpan(over[1]);
break;
}
case "overridemaxtime":
{
maxTime = GetTimeSpan(over[1]);
break;
}
}
}
JsonConfig.Serialize(outputFile, json, options);
}
private static List<Spawner> ParsePremiumSpawner(
string[] parts,
string spawnerIdOverride,
int mapIdOverride,
TimeSpan minTimeOverride,
TimeSpan maxTimeOverride
)
{
var spawnersList = new List<Spawner>();
var mapId = mapIdOverride != -1 ? mapIdOverride : int.Parse(parts[10]);
Map[] maps = mapId == 0 ? [Map.Felucca, Map.Trammel] : [Map.Maps[mapId - 1]];
foreach (var map in maps)
{
var spawner = new Spawner
{
X = int.Parse(parts[7]),
Y = int.Parse(parts[8]),
Z = int.Parse(parts[9]),
Map = map,
MinDelay = minTimeOverride != TimeSpan.MinValue ? minTimeOverride : GetTimeSpan(parts[11]),
MaxDelay = maxTimeOverride != TimeSpan.MinValue ? maxTimeOverride : GetTimeSpan(parts[12]),
WalkingRange = int.Parse(parts[13]),
HomeRange = int.Parse(parts[14]),
Name = $"Spawner ({spawnerIdOverride ?? parts[15]})",
Guid = Guid.NewGuid()
};
var totalCount = 0;
for (var i = 0; i < 6; i++)
{
var count = int.Parse(parts[i + 16]);
totalCount += count;
spawner.Entries.AddRange(CreateSpawnerEntries(spawner, parts[i + 1], count));
}
if (spawner.Entries.Count == 0)
{
spawner.Delete();
continue;
}
spawner.Count = totalCount;
spawnersList.Add(spawner);
}
return spawnersList;
}
private static List<SpawnerEntry> CreateSpawnerEntries(BaseSpawner spawner, string typeList, int maxCount)
{
var list = new List<SpawnerEntry>();
if (string.IsNullOrWhiteSpace(typeList))
{
return list;
}
foreach (var spawnType in typeList.Split(':'))
{
var actualType = AssemblyHandler.FindTypeByName(ConvertType(spawnType))?.Name ?? spawnType;
list.Add(new SpawnerEntry(spawner, actualType, 100, maxCount));
}
return list;
}
private static TimeSpan GetTimeSpan(string time)
{
if (string.IsNullOrEmpty(time))
{
return TimeSpan.MinValue;
}
return char.ToLowerInvariant(time[^1]) switch
{
'h' => TimeSpan.FromHours(double.Parse(time.AsSpan(0, time.Length - 1))),
'm' => TimeSpan.FromMinutes(double.Parse(time.AsSpan(0, time.Length - 1))),
's' => TimeSpan.FromSeconds(double.Parse(time.AsSpan(0, time.Length - 1))),
_ => TimeSpan.FromMinutes(double.Parse(time))
};
}
private static string ConvertType(string type)
{
return type.ToLowerInvariant() switch
{
"treasurelevel1" => "treasurechestlevel1",
"treasurelevel2" => "treasurechestlevel2",
"treasurelevel3" => "treasurechestlevel3",
"treasurelevel4" => "treasurechestlevel4",
"treasurelevel5" => "treasurechestlevel5",
_ => type
};
}
}

203
Projects/UOContent/Engines/Spawners/Commands/GenerateSpawnersCommand.cs
View file

@ -1,203 +0,0 @@
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Text.Json;
using Microsoft.Extensions.FileSystemGlobbing;
using Microsoft.Extensions.FileSystemGlobbing.Abstractions;
using Server.Collections;
using Server.Json;
using Server.Logging;
using Server.Network;
using Server.Utilities;
namespace Server.Engines.Spawners;
public static class GenerateSpawnersCommand
{
private static readonly ILogger logger = LogFactory.GetLogger(typeof(GenerateSpawnersCommand));
public static void Configure()
{
CommandSystem.Register("GenerateSpawners", AccessLevel.Developer, GenerateSpawners_OnCommand);
}
[Usage("GenerateSpawners <relative search pattern to distribution>")]
[Aliases("ImportSpawners", "GenSpawners", "GenSpawns")]
[Description("Generates spawners from JSON files. Supports basic globbing.")]
private static void GenerateSpawners_OnCommand(CommandEventArgs e)
{
var from = e.Mobile;
if (e.Arguments.Length == 0)
{
from.SendMessage("Usage: [GenerateSpawners <relative search pattern to distribution>");
return;
}
var di = new DirectoryInfo(Core.BaseDirectory);
var patternMatches = new Matcher()
.AddInclude(e.Arguments[0])
.Execute(new DirectoryInfoWrapper(di))
.Files;
List<FileInfo> files = [];
foreach (var match in patternMatches)
{
files.Add(new FileInfo(match.Path));
}
if (files.Count == 0)
{
from.SendMessage("GenerateSpawners: No files found matching the pattern");
return;
}
var watch = Stopwatch.StartNew();
var allSpawners = new Dictionary<Guid, ISpawner>();
foreach (var item in World.Items.Values)
{
if (item is ISpawner spawner)
{
allSpawners[spawner.Guid] = spawner;
}
}
var options = JsonConfig.GetOptions(new TextDefinitionConverterFactory());
var totalGenerated = 0;
var totalFailures = 0;
for (var i = 0; i < files.Count; i++)
{
var file = files[i];
from.SendMessage($"GenerateSpawners: Generating spawners from {file.Name}...");
logger.Information("{User} is generating spawners from {File}", from, file.FullName);
NetState.FlushAll();
try
{
var spawners = JsonConfig.Deserialize<List<DynamicJson>>(file.FullName);
ParseSpawnerList(spawners, options, allSpawners, out var generated, out var failed);
totalGenerated += generated;
totalFailures += failed;
}
catch (JsonException)
{
from.SendMessage(
$"GenerateSpawners: Exception parsing {file.FullName}, file may not be in the correct format."
);
}
}
watch.Stop();
logger.Information(
"Generated {Count} spawners ({Duration:F2} seconds, {Failures} failures)",
totalGenerated,
watch.Elapsed.TotalSeconds,
totalFailures
);
from.SendMessage(
$"GenerateSpawners: Generated {totalGenerated} spawners ({watch.Elapsed.TotalSeconds:F2} seconds, {totalFailures} failures)"
);
}
private static void ParseSpawnerList(
List<DynamicJson> spawners,
JsonSerializerOptions options,
Dictionary<Guid, ISpawner> allSpawners,
out int totalGenerated,
out int failureCount
)
{
failureCount = 0;
totalGenerated = 0;
using var queue = PooledRefQueue<Item>.Create();
for (var i = 0; i < spawners.Count; i++)
{
var json = spawners[i];
var type = AssemblyHandler.FindTypeByName(json.Type);
if (type == null || !typeof(BaseSpawner).IsAssignableFrom(type))
{
logger.Error($"Invalid spawner type {json.Type ?? "(-null-)"} ({i}).");
failureCount++;
continue;
}
json.GetProperty("location", options, out Point3D location);
json.GetProperty("map", options, out Map map);
// Delete all spawners at this location.
// Probably shouldn't do this outside of migrations? Is there a better way to find/fix spawners?
foreach (var spawner in map.GetItemsAt<BaseSpawner>(location))
{
if (spawner.GetType() == type)
{
queue.Enqueue(spawner);
allSpawners.Remove(spawner.Guid);
}
}
while (queue.Count > 0)
{
queue.Dequeue().Delete();
}
try
{
var spawner = type.CreateInstance<ISpawner>(json, options);
spawner!.MoveToWorld(location, map);
spawner!.Respawn();
if (allSpawners.Remove(spawner.Guid, out var oldSpawner))
{
oldSpawner.Delete();
}
allSpawners.Add(spawner.Guid, spawner);
totalGenerated++;
}
catch (Exception ex)
{
json.GetProperty("guid", options, out Guid guid);
TraceException(ex, $"Failed to generate spawner {guid}.");
failureCount++;
}
}
}
private static void TraceException(Exception ex, string message = "")
{
try
{
using var op = new StreamWriter("spawner-errors.log", true);
op.WriteLine("# {0}", Core.Now);
if (!string.IsNullOrEmpty(message))
{
op.WriteLine(message);
}
op.WriteLine(ex);
op.WriteLine();
op.WriteLine();
}
catch
{
// ignored
}
#if DEBUG
logger.Error(ex, message);
#endif
}
}

469
Projects/UOContent/Engines/Spawners/Commands/ImportSpawnersCommand.cs Normal file
View file

@ -0,0 +1,469 @@
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Runtime.CompilerServices;
using System.Text.Json;
using System.Xml;
using Microsoft.Extensions.FileSystemGlobbing;
using Microsoft.Extensions.FileSystemGlobbing.Abstractions;
using Server.Collections;
using Server.Json;
using Server.Logging;
using Server.Network;
using Server.Utilities;
namespace Server.Engines.Spawners;
public static class ImportSpawnersCommand
{
private static readonly ILogger logger = LogFactory.GetLogger(typeof(ImportSpawnersCommand));
public static void Configure()
{
CommandSystem.Register("ImportSpawners", AccessLevel.Developer, GenerateSpawners_OnCommand);
}
[Usage("ImportSpawners <relative search pattern to distribution>")]
[Aliases("ImportSpawner", "GenerateSpawners", "GenSpawners")]
[Description("Imports JSON, Nerun Premium, and RunUO spawner files. Supports basic globbing.")]
private static void GenerateSpawners_OnCommand(CommandEventArgs e)
{
var from = e.Mobile;
if (e.Arguments.Length == 0)
{
from.SendMessage("Usage: [GenerateSpawners <relative search pattern to distribution>");
return;
}
var di = new DirectoryInfo(Core.BaseDirectory);
var patternMatches = new Matcher()
.AddInclude(e.Arguments[0])
.Execute(new DirectoryInfoWrapper(di))
.Files;
List<FileInfo> files = [];
foreach (var match in patternMatches)
{
files.Add(new FileInfo(match.Path));
}
if (files.Count == 0)
{
from.SendMessage("GenerateSpawners: No files found matching the pattern.");
return;
}
var watch = Stopwatch.StartNew();
var allSpawners = new Dictionary<Guid, ISpawner>();
foreach (var item in World.Items.Values)
{
if (item is ISpawner spawner)
{
allSpawners[spawner.Guid] = spawner;
}
}
var totalGenerated = 0;
var totalFailures = 0;
for (var i = 0; i < files.Count; i++)
{
var file = files[i];
from.SendMessage($"GenerateSpawners: Generating spawners from {file.Name}...");
logger.Information("{User} is generating spawners from {File}", from, file.FullName);
NetState.FlushAll();
if (file.Extension == ".json")
{
ImportJsonSpawners(from, file, allSpawners, ref totalGenerated, ref totalFailures);
}
else if (file.Extension == ".xml")
{
ImportXmlSpawners(from, file, allSpawners, ref totalGenerated, ref totalFailures);
}
else if (file.Extension == ".map")
{
ImportPremiumSpawners(from, file, allSpawners, ref totalGenerated, ref totalFailures);
}
else
{
from.SendMessage($"GenerateSpawners: Unsupported file type {file.Extension}.");
}
}
watch.Stop();
logger.Information(
"Generated {Count} spawners ({Duration:F2} seconds, {Failures} failures)",
totalGenerated,
watch.Elapsed.TotalSeconds,
totalFailures
);
from.SendMessage(
$"GenerateSpawners: Generated {totalGenerated} spawners ({watch.Elapsed.TotalSeconds:F2} seconds, {totalFailures} failures)"
);
}
private static void ImportXmlSpawners(
Mobile from,
FileInfo file,
Dictionary<Guid, ISpawner> allSpawners,
ref int totalGenerated,
ref int totalFailures
)
{
XmlDocument doc = new XmlDocument();
doc.Load(file.FullName);
XmlElement root = doc["spawners"];
if (root == null)
{
return;
}
var index = 0;
foreach (XmlElement node in root.GetElementsByTagName("spawner"))
{
try
{
int count = int.Parse(Utility.GetText(node["count"], "1"));
int homeRange = int.Parse(Utility.GetText(node["homerange"], "4"));
int walkingRange = int.Parse(Utility.GetText(node["walkingrange"], "-1"));
int team = int.Parse(Utility.GetText(node["team"], "0"));
TimeSpan maxDelay = TimeSpan.Parse(Utility.GetText(node["maxdelay"], "10:00"));
TimeSpan minDelay = TimeSpan.Parse(Utility.GetText(node["mindelay"], "05:00"));
var creaturesNameNode = node["creaturesname"];
List<string> creatureNames = [];
if (creaturesNameNode != null)
{
foreach (XmlElement ele in creaturesNameNode.GetElementsByTagName("creaturename"))
{
if (ele != null)
{
creatureNames.Add(ele.InnerText);
}
}
}
string name = Utility.GetText(node["name"], "Spawner");
Point3D location = Point3D.Parse(Utility.GetText(node["location"], "Error"));
Map map = Map.Parse(Utility.GetText(node["map"], "Error"));
Spawner spawner = new Spawner(count, minDelay, maxDelay, team, homeRange, creatureNames.ToArray());
if (walkingRange >= 0)
{
spawner.WalkingRange = walkingRange;
}
spawner.Name = name;
spawner.MoveToWorld(location, map);
if (spawner.Map == Map.Internal)
{
spawner.Delete();
totalFailures++;
throw new Exception("Spawner created on Internal map.");
}
spawner.Respawn();
allSpawners.Add(spawner.Guid, spawner);
totalGenerated++;
}
catch (Exception ex)
{
TraceException(ex, $"Failed to generate spawner {index} in {file.FullName}.");
from.SendMessage(
$"GenerateSpawners: Exception parsing {file.FullName}, file may not be in the correct format."
);
}
index++;
}
}
private static void ImportJsonSpawners(
Mobile from,
FileInfo file,
Dictionary<Guid, ISpawner> allSpawners,
ref int totalGenerated,
ref int totalFailures
)
{
var options = JsonConfig.GetOptions();
try
{
var spawners = JsonConfig.Deserialize<List<DynamicJson>>(file.FullName);
using var queue = PooledRefQueue<Item>.Create();
for (var i = 0; i < spawners.Count; i++)
{
var json = spawners[i];
var type = AssemblyHandler.FindTypeByName(json.Type);
if (type == null || !typeof(BaseSpawner).IsAssignableFrom(type))
{
logger.Error($"Invalid spawner type {json.Type ?? "(-null-)"} ({i}).");
totalFailures++;
continue;
}
json.GetProperty("location", options, out Point3D location);
json.GetProperty("map", options, out Map map);
// Delete all spawners at this location.
// Probably shouldn't do this outside of migrations? Is there a better way to find/fix spawners?
foreach (var spawner in map.GetItemsAt<BaseSpawner>(location))
{
if (spawner.GetType() == type)
{
queue.Enqueue(spawner);
allSpawners.Remove(spawner.Guid);
}
}
while (queue.Count > 0)
{
queue.Dequeue().Delete();
}
try
{
var spawner = type.CreateInstance<ISpawner>(json, options);
spawner!.MoveToWorld(location, map);
spawner!.Respawn();
if (allSpawners.Remove(spawner.Guid, out var oldSpawner))
{
oldSpawner.Delete();
}
allSpawners.Add(spawner.Guid, spawner);
totalGenerated++;
}
catch (Exception ex)
{
json.GetProperty("guid", options, out Guid guid);
TraceException(ex, $"Failed to generate spawner {guid}.");
totalFailures++;
}
}
}
catch (JsonException)
{
from.SendMessage(
$"GenerateSpawners: Exception parsing {file.FullName}, file may not be in the correct format."
);
}
}
private static void TraceException(Exception ex, string message = "")
{
try
{
using var op = new StreamWriter("spawner-errors.log", true);
op.WriteLine("# {0}", Core.Now);
if (!string.IsNullOrEmpty(message))
{
op.WriteLine(message);
}
op.WriteLine(ex);
op.WriteLine();
op.WriteLine();
}
catch
{
// ignored
}
#if DEBUG
logger.Error(ex, message);
#endif
}
private static void ImportPremiumSpawners(
Mobile from,
FileInfo file,
Dictionary<Guid, ISpawner> allSpawners,
ref int totalGenerated,
ref int totalFailures
)
{
var lines = File.ReadAllLines(file.FullName);
TimeSpan minTimeOverride = TimeSpan.MinValue;
TimeSpan maxTimeOverride = TimeSpan.MinValue;
int mapIdOverride = -1;
string spawnerIdOverride = null;
for (var i = 0; i < lines.Length; i++)
{
var line = lines[i];
if (line.StartsWithOrdinal("#"))
{
continue;
}
try
{
if (line.StartsWith('*'))
{
var parts = line.Split('|');
var mapId = mapIdOverride != -1 ? mapIdOverride : int.Parse(parts[10]);
Map[] maps = mapId == 0 ? [Map.Felucca, Map.Trammel] : [Map.Maps[mapId - 1]];
foreach (var map in maps)
{
try
{
List<(string, int)> spawnerEntries = [];
var totalCount = 0;
for (var j = 0; j < 6; j++)
{
var count = int.Parse(parts[j + 16]);
totalCount += count;
spawnerEntries.AddRange(CreateSpawnerEntries(parts[j + 1], count));
}
if (spawnerEntries.Count == 0)
{
continue;
}
var minDelay = GetTimeSpan(minTimeOverride, parts[11]);
var maxDelay = GetTimeSpan(maxTimeOverride, parts[12]);
var homeRange = int.Parse(parts[14]);
var spawner = new Spawner(totalCount, minDelay, maxDelay, 0, homeRange)
{
WalkingRange = int.Parse(parts[13]),
Name = $"Spawner ({spawnerIdOverride ?? parts[15]})"
};
foreach (var (type, amount) in spawnerEntries)
{
spawner.AddEntry(type, amount: amount);
}
spawner.MoveToWorld(
new Point3D(int.Parse(parts[7]), int.Parse(parts[8]), int.Parse(parts[9])),
map
);
spawner.Respawn();
allSpawners.Add(spawner.Guid, spawner);
totalGenerated++;
}
catch (Exception ex)
{
TraceException(ex, $"Failed to generate spawner on line {i} in {file.FullName}.");
from.SendMessage(
$"GenerateSpawners: Exception parsing {file.FullName}, file may not be in the correct format."
);
totalFailures++;
}
}
continue;
}
var over = line.Split(' ');
switch (over[0].ToLowerInvariant())
{
case "overrideid":
{
spawnerIdOverride = over[1];
break;
}
case "overridemap":
{
mapIdOverride = int.Parse(over[1]);
break;
}
case "overridemintime":
{
minTimeOverride = GetTimeSpan(over[1]);
break;
}
case "overridemaxtime":
{
maxTimeOverride = GetTimeSpan(over[1]);
break;
}
}
}
catch (Exception ex)
{
TraceException(ex, $"Failed to generate spawner on line {i} in {file.FullName}.");
from.SendMessage(
$"GenerateSpawners: Exception parsing {file.FullName}, file may not be in the correct format."
);
return;
}
}
}
private static List<(string, int)> CreateSpawnerEntries(string typeList, int maxCount)
{
var list = new List<(string, int)>();
if (string.IsNullOrWhiteSpace(typeList))
{
return list;
}
foreach (var spawnType in typeList.Split(':'))
{
var actualType = AssemblyHandler.FindTypeByName(ConvertType(spawnType))?.Name ?? spawnType;
list.Add((actualType, maxCount));
}
return list;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static TimeSpan GetTimeSpan(TimeSpan timeOverride, string time) =>
timeOverride != TimeSpan.MinValue ? timeOverride : GetTimeSpan(time);
private static TimeSpan GetTimeSpan(string time)
{
if (string.IsNullOrEmpty(time))
{
return TimeSpan.MinValue;
}
return char.ToLowerInvariant(time[^1]) switch
{
'h' => TimeSpan.FromHours(double.Parse(time.AsSpan(0, time.Length - 1))),
'm' => TimeSpan.FromMinutes(double.Parse(time.AsSpan(0, time.Length - 1))),
's' => TimeSpan.FromSeconds(double.Parse(time.AsSpan(0, time.Length - 1))),
_ => TimeSpan.FromMinutes(double.Parse(time))
};
}
private static string ConvertType(string type)
{
return type.ToLowerInvariant() switch
{
"treasurelevel1" => "treasurechestlevel1",
"treasurelevel2" => "treasurechestlevel2",
"treasurelevel3" => "treasurechestlevel3",
"treasurelevel4" => "treasurechestlevel4",
"treasurelevel5" => "treasurechestlevel5",
_ => type
};
}
}

13
Projects/UOContent/Engines/Spawners/SpawnerEntry.cs
View file

@ -76,14 +76,20 @@ public partial class SpawnerEntry
if (e != null)
{
e.Spawner = _parent;
Spawned.Add(e);
_parent.Spawned.TryAdd(e, this);
}
}
}
[AfterDeserialization]
private void AfterDeserialization()
{
foreach (var e in Spawned)
{
e.Spawner = _parent;
}
}
[JsonIgnore]
public EntryFlags Valid { get; set; }
@ -99,6 +105,7 @@ public partial class SpawnerEntry
if (parent.OnDefragSpawn(spawned, false))
{
Spawned.RemoveAt(i--);
_parent.MarkDirty();
}
}
}

6
Projects/UOContent/Gumps/WhoGump.cs
View file

@ -43,12 +43,12 @@ namespace Server.Gumps
public static void Configure()
{
CommandSystem.Register("Who", AccessLevel.Counselor, WhoList_OnCommand);
CommandSystem.Register("WhoList", AccessLevel.Counselor, WhoList_OnCommand);
}
[Usage("WhoList [filter]"), Aliases("Who"),
Description("Lists all connected clients. Optionally filters results by name.")]
[Usage("WhoList [filter]")]
[Aliases("Who")]
[Description("Lists all connected clients. Optionally filters results by name.")]
private static void WhoList_OnCommand(CommandEventArgs e)
{
e.Mobile.SendGump(new WhoGump(e.Mobile, e.ArgString));

BIN
docs/commands/commands.7z
View file

Binary file not shown.