public override void Execute(ModScriptDatabaseHelper database)
{
VltCollection collection = GetCollection(database, ClassName, CollectionName);
VltClassField field = GetField(collection.Class, FieldName);
if (!field.IsArray)
{
throw new ModScriptCommandExecutionException($"Field {ClassName}[{FieldName}] is not an array!");
}
if (!collection.HasEntry(FieldName))
{
throw new ModScriptCommandExecutionException($"Collection {collection.ShortPath} does not have an entry for {FieldName}.");
}
VLTArrayType array = collection.GetRawValue <VLTArrayType>(FieldName);
if (array.Items.Count == array.Capacity && field.IsInLayout)
{
throw new ModScriptCommandExecutionException("Cannot append to a full array when it is a layout field");
}
if (array.Items.Count + 1 > field.MaxCount)
{
throw new ModScriptCommandExecutionException("Appending to this array would cause it to exceed the maximum number of allowed elements.");
}
var itemToEdit = TypeRegistry.ConstructInstance(array.ItemType, collection.Class, field, collection);
if (_hasValue)
{
switch (itemToEdit)
{
case PrimitiveTypeBase primitiveTypeBase:
ValueConversionUtils.DoPrimitiveConversion(primitiveTypeBase, Value);
break;
case IStringValue stringValue:
stringValue.SetString(Value);
break;
case BaseRefSpec refSpec:
// NOTE: This is a compatibility feature for certain types, such as GCollectionKey, which are technically a RefSpec.
refSpec.CollectionKey = Value;
break;
default:
throw new ModScriptCommandExecutionException($"Object stored in {collection.Class.Name}[{field.Name}] is not a simple type and cannot be used in a value-append command");
}
}
array.Items.Add(itemToEdit);
if (!field.IsInLayout)
{
array.Capacity++;
}
}
public override void Execute(ModScriptDatabaseHelper database)
{
VltCollection collection = GetCollection(database, ClassName, CollectionName);
if (GetCollection(database, ClassName, NewName, false) != null)
{
throw new InvalidDataException($"rename_node failed because there is already a collection called '{NewName}'");
}
database.RenameCollection(collection, NewName);
}
public override void Execute(ModScriptDatabaseHelper database)
{
VltCollection srcCollection = GetCollection(database, ClassName, SourceCollectionName);
VltCollection dstCollection = GetCollection(database, ClassName, DestinationCollectionName);
Dictionary <VltClassField, VLTBaseType> values = new Dictionary <VltClassField, VLTBaseType>();
if ((Options & CopyOptions.Base) != 0)
{
foreach (var baseField in srcCollection.Class.BaseFields)
{
values.Add(baseField,
ValueCloningUtils.CloneValue(database.Database, srcCollection.GetRawValue(baseField.Name), srcCollection.Class,
baseField, dstCollection));
}
}
if ((Options & CopyOptions.Optional) != 0)
{
foreach (var(key, value) in srcCollection.GetData())
{
var field = srcCollection.Class[key];
if (!field.IsInLayout)
{
values.Add(field, ValueCloningUtils.CloneValue(database.Database, value, srcCollection.Class, field, dstCollection));
}
}
}
// base will always overwrite
// optional by itself will copy anything that doesn't exist
// optional + overwrite will copy nonexistent fields and overwrite the other ones(optional only)
if ((Options & CopyOptions.Base) != 0)
{
foreach (var(key, value) in values)
{
if (key.IsInLayout)
{
dstCollection.SetRawValue(key.Name, value);
}
}
}
if ((Options & CopyOptions.Optional) != 0)
{
foreach (var(field, value) in values)
{
if (!field.IsInLayout && (!dstCollection.HasEntry(field.Name) || (Options & CopyOptions.OverwriteOptional) != 0))
{
dstCollection.SetRawValue(field.Name, value);
}
}
}
}
public override void Execute(ModScriptDatabaseHelper database)
{
VltCollection collection = GetCollection(database, ClassName, CollectionName);
Vault vault;
try
{
vault = database.Database.FindVault(VaultName);
}
catch (InvalidOperationException e)
{
throw new ModScriptCommandExecutionException($"Cannot find vault '{VaultName}'", e);
}
collection.SetVault(vault);
}
public override void Execute(ModScriptDatabaseHelper database)
{
VltCollection collection = GetCollection(database, ClassName, CollectionName);
VltClassField field = GetField(collection.Class, FieldName);
if (!field.IsArray)
{
throw new ModScriptCommandExecutionException($"Field {ClassName}[{FieldName}] is not an array!");
}
if (field.MaxCount < NewCapacity)
{
throw new ModScriptCommandExecutionException(
$"Cannot resize field {ClassName}[{FieldName}] beyond maximum count (requested {NewCapacity} but limit is {field.MaxCount})");
}
if (!collection.HasEntry(FieldName))
{
throw new ModScriptCommandExecutionException($"Collection {collection.ShortPath} does not have an entry for {FieldName}.");
}
VLTArrayType array = collection.GetRawValue <VLTArrayType>(FieldName);
if (NewCapacity < array.Items.Count)
{
while (NewCapacity < array.Items.Count)
{
array.Items.RemoveAt(array.Items.Count - 1);
}
}
else if (NewCapacity > array.Items.Count)
{
while (NewCapacity > array.Items.Count)
{
array.Items.Add(TypeRegistry.ConstructInstance(array.ItemType, collection.Class, field, collection));
}
}
if (!field.IsInLayout)
{
array.Capacity = NewCapacity;
}
}
public override void Execute(ModScriptDatabaseHelper database)
{
VltCollection collection = GetCollection(database, ClassName, CollectionName);
if (collection.HasEntry(FieldName))
{
collection.RemoveValue(FieldName);
}
else
{
string hashed = $"0x{VLT32Hasher.Hash(FieldName):X8}";
if (collection.HasEntry(hashed))
{
collection.RemoveValue(hashed);
}
else
{
throw new ModScriptCommandExecutionException($"Could not delete field: {ClassName}/{CollectionName}[{FieldName}]");
}
}
}
public override void Execute(ModScriptDatabaseHelper database)
{
VltCollection collection = GetCollection(database, ClassName, CollectionName);
VltClassField field = collection.Class[FieldName];
if (field.IsInLayout)
{
throw new InvalidDataException($"add_field failed because field '{field.Name}' is a base field");
}
if (collection.HasEntry(field.Name))
{
throw new InvalidDataException($"add_field failed because collection '{collection.ShortPath}' already has field '{field.Name}'");
}
var vltBaseType = TypeRegistry.CreateInstance(database.Database.Options.GameId, collection.Class, field, collection);
if (vltBaseType is VLTArrayType array)
{
if (ArrayCapacity > field.MaxCount)
{
throw new ModScriptCommandExecutionException(
$"Cannot add field {ClassName}[{FieldName}] with capacity beyond maximum (requested {ArrayCapacity} but limit is {field.MaxCount})");
}
array.Capacity = ArrayCapacity;
array.ItemAlignment = field.Alignment;
array.FieldSize = field.Size;
array.Items = new List <VLTBaseType>();
for (var i = 0; i < ArrayCapacity; i++)
{
array.Items.Add(TypeRegistry.ConstructInstance(array.ItemType, collection.Class, field, collection));
}
}
collection.SetRawValue(field.Name, vltBaseType);
}
public override void Execute(ModScriptDatabaseHelper database)
{
VltCollection collection = GetCollection(database, ClassName, CollectionName);
database.RemoveCollection(collection);
}
public override void Execute(ModScriptDatabaseHelper database)
{
//
}
private static int RunApplyModScript(ApplyScriptOptions opts)
{
if (!Directory.Exists(opts.InputDirectory))
{
throw new Exception($"Non-existent input directory: {opts.InputDirectory}");
}
if (!Directory.Exists(opts.OutputDirectory))
{
Directory.CreateDirectory(opts.OutputDirectory);
}
if (string.IsNullOrEmpty(opts.ModScriptPath))
{
throw new Exception("Missing modscript path!");
}
var profile = ResolveProfile(opts.ProfileName);
if (profile == null)
{
Console.WriteLine("ERROR: Unknown profile {0}", opts.ProfileName);
Console.WriteLine("AVAILABLE PROFILES:");
foreach (var baseProfile in Profiles)
{
Console.WriteLine("\tNAME: {0}", baseProfile.GetName());
}
return(1);
}
var database = new Database(new DatabaseOptions(profile.GetGame(), profile.GetDatabaseType()));
var deserializer = new DatabaseDeserializer(database, opts.InputDirectory);
var stopwatch = Stopwatch.StartNew();
var loadedDatabase = deserializer.Deserialize();
stopwatch.Stop();
Console.WriteLine("Loaded database from {2} in {0}ms ({1:f2}s)", stopwatch.ElapsedMilliseconds,
stopwatch.ElapsedMilliseconds / 1000f, opts.InputDirectory);
stopwatch.Restart();
var modScriptParser = new ModScriptParser(opts.ModScriptPath);
var cmdStopwatch = Stopwatch.StartNew();
var modScriptDatabase = new ModScriptDatabaseHelper(database);
var commandCount = 0;
foreach (var command in modScriptParser.Parse())
{
#if !DEBUG
try
{
#endif
cmdStopwatch.Restart();
command.Execute(modScriptDatabase);
commandCount++;
//Console.WriteLine("Executed command in {1}ms: {0}", command.Line, cmdStopwatch.ElapsedMilliseconds);
#if !DEBUG
}
catch (Exception e)
{
throw new ModScriptCommandExecutionException($"Failed to execute command: {command.Line}", e);
}
#endif
}
stopwatch.Stop();
var commandsPerSecond = commandCount / (stopwatch.ElapsedMilliseconds / 1000.0f);
Console.WriteLine("Applied script from {2} in {0}ms ({1:f2}s) ({4} commands @ ~{3:f2} commands/sec)",
stopwatch.ElapsedMilliseconds,
stopwatch.ElapsedMilliseconds / 1000f, opts.ModScriptPath, commandsPerSecond, commandCount);
if (opts.MakeBackup)
{
stopwatch.Restart();
Console.WriteLine("Making backup");
Directory.Move(opts.InputDirectory,
$"{opts.InputDirectory.TrimEnd('/', '\\')}_{DateTimeOffset.Now.ToUnixTimeSeconds()}");
Directory.CreateDirectory(opts.InputDirectory);
stopwatch.Stop();
Console.WriteLine("Made backup in {0}ms ({1:f2}s)", stopwatch.ElapsedMilliseconds,
stopwatch.ElapsedMilliseconds / 1000f);
}
stopwatch.Restart();
new DatabaseSerializer(database, opts.InputDirectory).Serialize(loadedDatabase.Files);
//deserializer.GenerateFiles(profile, args.OutputDirectory);
stopwatch.Stop();
Console.WriteLine("Exported YML files to {2} in {0}ms ({1:f2}s)", stopwatch.ElapsedMilliseconds,
stopwatch.ElapsedMilliseconds / 1000f, opts.InputDirectory);
if (opts.GenerateBins)
{
stopwatch.Restart();
deserializer.GenerateFiles(profile, opts.OutputDirectory);
stopwatch.Stop();
Console.WriteLine("Exported VLT files to {2} in {0}ms ({1:f2}s)", stopwatch.ElapsedMilliseconds,
stopwatch.ElapsedMilliseconds / 1000f, opts.OutputDirectory);
}
return(0);
}
private static void RunApplyModScript(ProgramArgs args, BaseProfile profile)
{
if (string.IsNullOrEmpty(args.ModScriptPath))
{
throw new Exception("Missing modscript path!");
}
var database = new Database(new DatabaseOptions(profile.GetGame(), profile.GetDatabaseType()));
var deserializer = new DatabaseDeserializer(database, args.InputDirectory);
Stopwatch stopwatch = Stopwatch.StartNew();
var loadedDatabase = deserializer.Deserialize();
stopwatch.Stop();
Console.WriteLine("Loaded database from {2} in {0}ms ({1:f2}s)", stopwatch.ElapsedMilliseconds,
stopwatch.ElapsedMilliseconds / 1000f, args.InputDirectory);
stopwatch.Restart();
var modScriptParser = new ModScriptParser(args.ModScriptPath);
var cmdStopwatch = Stopwatch.StartNew();
var modScriptDatabase = new ModScriptDatabaseHelper(database);
int commandCount = 0;
foreach (var command in modScriptParser.Parse())
{
#if !DEBUG
try
{
#endif
cmdStopwatch.Restart();
command.Execute(modScriptDatabase);
commandCount++;
//Console.WriteLine("Executed command in {1}ms: {0}", command.Line, cmdStopwatch.ElapsedMilliseconds);
#if !DEBUG
}
catch (Exception e)
{
throw new ModScriptCommandExecutionException($"Failed to execute command: {command.Line}", e);
}
#endif
}
stopwatch.Stop();
float commandsPerSecond = commandCount / (stopwatch.ElapsedMilliseconds / 1000.0f);
Console.WriteLine("Applied script from {2} in {0}ms ({1:f2}s) ({4} commands @ ~{3:f2} commands/sec)", stopwatch.ElapsedMilliseconds,
stopwatch.ElapsedMilliseconds / 1000f, args.ModScriptPath, commandsPerSecond, commandCount);
stopwatch.Restart();
Console.WriteLine("Making backup");
Directory.Move(args.InputDirectory, $"{args.InputDirectory.TrimEnd('/', '\\')}_{DateTimeOffset.Now.ToUnixTimeSeconds()}");
Directory.CreateDirectory(args.InputDirectory);
stopwatch.Stop();
Console.WriteLine("Made backup in {0}ms ({1:f2}s)", stopwatch.ElapsedMilliseconds,
stopwatch.ElapsedMilliseconds / 1000f);
stopwatch.Restart();
new DatabaseSerializer(database, args.InputDirectory).Serialize(loadedDatabase.Files);
//deserializer.GenerateFiles(profile, args.OutputDirectory);
stopwatch.Stop();
Console.WriteLine("Exported YML files to {2} in {0}ms ({1:f2}s)", stopwatch.ElapsedMilliseconds,
stopwatch.ElapsedMilliseconds / 1000f, args.InputDirectory);
stopwatch.Restart();
deserializer.GenerateFiles(profile, args.OutputDirectory);
stopwatch.Stop();
Console.WriteLine("Exported VLT files to {2} in {0}ms ({1:f2}s)", stopwatch.ElapsedMilliseconds,
stopwatch.ElapsedMilliseconds / 1000f, args.OutputDirectory);
}
