public static void Generate(string filePattern)
{
var di = new DirectoryInfo(Core.BaseDirectory);
var files = di.GetFiles(filePattern, SearchOption.AllDirectories);
if (files.Length == 0)
{
World.Broadcast(0x35, true, "GenerateSpawners: No files found matching the pattern");
return;
}
var options = JsonConfig.GetOptions(new TextDefinitionConverterFactory());
foreach (var file in files)
{
World.Broadcast(0x35, true, "GenerateSpawners: Generating spawners for {0}...", file.Name);
try
{
var spawners = JsonConfig.Deserialize <List <DynamicJson> >(file.FullName);
ParseSpawnerList(spawners, options);
}
catch (JsonException)
{
World.Broadcast(0x35, true, "GenerateSpawners: Exception parsing {0}, file may not be in the correct format.",
file.FullName);
}
}
}
public override void ExecuteList(CommandEventArgs e, List <object> list)
{
string path = e.Arguments.Length == 0 ? string.Empty : e.Arguments[0].Trim();
string condition = e.Arguments.Length == 2 ? e.Arguments[1].Trim() : string.Empty;
if (string.IsNullOrEmpty(path))
{
path = Path.Combine(Core.BaseDirectory, $"Data/Spawns/{Utility.GetTimeStamp()}.json");
}
else
{
var directory = Path.GetDirectoryName(Path.GetFullPath(path !)) !;
if (!Path.IsPathRooted(path))
{
path = Path.Combine(Core.BaseDirectory, path);
PathUtility.EnsureDirectory(directory);
}
else if (!Directory.Exists(directory))
{
LogFailure("Directory doesn't exist.");
return;
}
}
NetState.FlushAll();
var options = JsonConfig.GetOptions(new TextDefinitionConverterFactory());
var spawnRecords = new List <DynamicJson>(list.Count);
for (var i = 0; i < list.Count; i++)
{
if (list[i] is BaseSpawner spawner)
{
if (!string.IsNullOrEmpty(spawner.Name) && spawner.Name.StartsWith(
condition,
StringComparison.OrdinalIgnoreCase
))
{
var dynamicJson = DynamicJson.Create(spawner.GetType());
spawner.ToJson(dynamicJson, options);
spawnRecords.Add(dynamicJson);
}
}
}
if (spawnRecords.Count == 0)
{
LogFailure("No matching spawners found.");
return;
}
e.Mobile.SendMessage("Exporting spawners...");
JsonConfig.Serialize(path, spawnRecords, options);
e.Mobile.SendMessage($"Spawners exported to {path}");
}
private static void LoadQuests(Mobile from)
{
if (Quests.Count > 0)
{
Quests.Clear();
}
var di = new DirectoryInfo(Core.BaseDirectory);
var files = di.GetFiles("questsystemadvanced.json", SearchOption.AllDirectories);
if (files.Length == 0)
{
if (from != null)
{
from.SendMessage("QuestSystem: No files found.");
}
return;
}
var options = JsonConfig.GetOptions(new TextDefinitionConverterFactory());
for (var i = 0; i < files.Length; i++)
{
var file = files[i];
if (from != null)
{
from.SendMessage("Generating quests from: {0}", file.Name);
}
NetState.FlushAll();
try
{
var quests = JsonConfig.Deserialize <List <DynamicJson> >(file.FullName);
ParseQuestList(from, quests, options);
}
catch (JsonException)
{
if (from != null)
{
from.SendMessage(
"QuestSystem: Exception parsing {0}, file may not be in the correct format.",
file.FullName
);
}
}
}
}
protected SpellConfiguration()
{
var circleConfig = ZhConfig.DeserializeJsonConfig <SpellCircle[]>("Data/Magic/circles.json");
SpellCircles = circleConfig.ToDictionary(v => v.Id, v => v);
var config = ZhConfig.DeserializeJsonConfig <Dictionary <SpellEntry, SpellInfo> >(
"Data/Magic/spells.json",
JsonConfig.GetOptions(new SpellCircleConverterFactory(SpellCircles.Values))
);
SpellInfos = config.ToDictionary(kv => kv.Value.Type, kv => kv.Value);
SpellTypes = config.ToDictionary(kv => kv.Key, kv => kv.Value.Type);
}
private static void GenerateSpawners_OnCommand(CommandEventArgs e)
{
var from = e.Mobile;
if (e.Arguments.Length == 0)
{
from.SendMessage("Usage: [GenerateSpawners <path|search pattern>");
return;
}
var di = new DirectoryInfo(Core.BaseDirectory);
var files = di.GetFiles(e.Arguments[0], SearchOption.AllDirectories);
if (files.Length == 0)
{
from.SendMessage("GenerateSpawners: No files found matching the pattern");
return;
}
var options = JsonConfig.GetOptions(new TextDefinitionConverterFactory());
for (var i = 0; i < files.Length; i++)
{
var file = files[i];
from.SendMessage("GenerateSpawners: Generating spawners for {0}...", file.Name);
NetState.FlushAll();
try
{
var spawners = JsonConfig.Deserialize <List <DynamicJson> >(file.FullName);
ParseSpawnerList(from, spawners, options);
}
catch (JsonException)
{
from.SendMessage(
"GenerateSpawners: Exception parsing {0}, file may not be in the correct format.",
file.FullName
);
}
}
}
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 = new List <(FileInfo, string)>();
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 {0}...", stem);
NetState.FlushAll();
try
{
var stemDir = stem[..^ file.Name.Length];
private static void TestSerialization_OnCommand(CommandEventArgs eventArgs)
{
var path = Path.Combine(Core.BaseDirectory, "test.json");
var jsOpts = JsonConfig.GetOptions(new TextDefinitionConverterFactory(), new EnchantmentConverterFactory());
JsonConfig.Serialize(path, new IEnchantmentValue[]
{
new AirProtection {
Value = 100
},
new DurabilityBonus {
Value = 10
},
new HealingBonus {
Value = 25
}
}, jsOpts);
var config = JsonConfig.Deserialize <IEnchantmentValue[]>(path, jsOpts);
config.ToString();
}
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 = new List <FileInfo>();
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 {0}...", file.Name);
logger.Information($"{from} is generating spawners 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 {0}, file may not be in the correct format.",
file.FullName
);
}
}
watch.Stop();
logger.Information("Generated {0} spawners ({1:F2} seconds, {2} failures)");
from.SendMessage(
"GenerateSpawners: Generated {0} spawners ({1:F2} seconds, {2} failures)",
totalGenerated,
watch.Elapsed.TotalSeconds,
totalFailures
);
}
