private static void SerialOffsetting(Span <byte> span, Int32 sizeChange, Int32 sizeChangeOffset)
{
Int32 exportsCount = DOLib.Int32FromSpanOffset(span, exportsCountOffset);
Int32 exportsMapOffset = DOLib.Int32FromSpanOffset(span, exportsMapOffsetOffset);
Int32 currentReferenceOffset = exportsMapOffset;
bool applyOffsetChange = false;
int processedReferences = 0;
while (processedReferences < exportsCount)
{
if (!applyOffsetChange)
{
RelativeSizeChangeDirection direction = CheckOffsetAffected(span, sizeChangeOffset, currentReferenceOffset);
if (direction == RelativeSizeChangeDirection.here)
{
ApplySerialSizeChange(span, sizeChange, currentReferenceOffset);
applyOffsetChange = true;
}
if (direction == RelativeSizeChangeDirection.before)
{
ApplySerialOffsetChange(span, sizeChange, currentReferenceOffset);
applyOffsetChange = true;
}
}
else
{
ApplySerialOffsetChange(span, sizeChange, currentReferenceOffset);
}
currentReferenceOffset += exportReferenceSize;
processedReferences++;
}
}
protected override void LocalOffSet(Span <byte> span, Dictionary <RequiredOffSettingData, int> args)
{
foreach (Int32 offset in nameCountOffsets)
{
DOLib.AddToInt32ByOffset(span, args[RequiredOffSettingData.CountChange], offset);
}
}
protected override string ReplaceOperation(List <string> args, int replaceAtOffset, out bool useStandardBackup)
{
useStandardBackup = true;
Int32?package = GetNameIndex(Program.runData.uasset, args);
Int32?_class = GetNameIndex(Program.runData.uasset, args);
Int32?outerIndex = GetImportIndex(Program.runData.uasset, args);
Int32?name = GetNameIndex(Program.runData.uasset, args);
Int32 replacementIndex = (replaceAtOffset - BitConverter.ToInt32(Program.runData.uasset, OffsetConstants.importOffsetOffset)) / OffsetConstants.importDefSize;
if (package != null)
{
DOLib.WriteInt32IntoOffset(Program.runData.uasset, package.Value, replaceAtOffset + OffsetConstants.importPackageOffset);
Program.runData.importMap[replacementIndex].packageName = package.Value;
}
if (_class != null)
{
DOLib.WriteInt32IntoOffset(Program.runData.uasset, _class.Value, replaceAtOffset + OffsetConstants.importClassOffset);
Program.runData.importMap[replacementIndex].className = _class.Value;
}
if (outerIndex != null)
{
DOLib.WriteInt32IntoOffset(Program.runData.uasset, outerIndex.Value, replaceAtOffset + OffsetConstants.importOuterIndexOffset);
Program.runData.importMap[replacementIndex].outerIndex = outerIndex.Value;
}
if (name != null)
{
Program.runData.importMap[replacementIndex].importName = name.Value;
DOLib.WriteInt32IntoOffset(Program.runData.uasset, name.Value, replaceAtOffset + OffsetConstants.importNameOffset);
}
return("");
}
protected override string AddOperation(List <string> args, int addAtOffset, out bool useStandardBackup)
{
useStandardBackup = false;
Int32 _class = GetImportExportIndex(Program.runData.uasset, args).Value;
Int32 super = Int32.Parse(args.TakeArg());
Int32 template = GetImportExportIndex(Program.runData.uasset, args).Value;
Int32 outer = GetImportExportIndex(Program.runData.uasset, args).Value;
Int32 name = GetNameIndex(Program.runData.uasset, args).Value;
Int32 nameAug = Int32.Parse(args.TakeArg());
Int32 flags = Int32.Parse(args.TakeArg());
Int32 serialOffset = BitConverter.ToInt32(Program.runData.uasset, addAtOffset - OffsetConstants.exportDefSize + relativeSerialOffsetOffset) +
BitConverter.ToInt32(Program.runData.uasset, addAtOffset - OffsetConstants.exportDefSize + relativeSerialSizeOffset);
List <Int32> other = new List <int>();
for (int i = 0; i < otherDataInt32Count; i++)
{
other.Add(Int32.Parse(args.TakeArg()));
}
Program.runData.uasset = Insert(Program.runData.uasset, MakeExportDef(_class, super, template, outer, name, nameAug, flags, 0, serialOffset, other), addAtOffset);
if (File.Exists(Program.runData.uassetFileName + ".AddExportDefBackup"))
{
File.Delete(Program.runData.uassetFileName + ".AddExportDefBackup");
}
Directory.Move(Program.runData.uassetFileName, Program.runData.uassetFileName + ".AddExportDefBackup");
File.WriteAllBytes(Program.runData.uassetFileName, Program.runData.uasset);
Program.CallOffSetterWithArgs(" -edef 104 1 -r -m");
Program.runData.uasset = File.ReadAllBytes(Program.runData.uassetFileName);
byte[] uexp = File.ReadAllBytes(Program.runData.uexpFileName);
Int32 newExportSerialOffset = BitConverter.ToInt32(Program.runData.uasset, addAtOffset + relativeSerialOffsetOffset);
Int32 newExportFileOffset = newExportSerialOffset - BitConverter.ToInt32(Program.runData.uasset, headerSizeOffset);
byte[] stubExport = new byte[12];
DOLib.WriteInt32IntoOffset(stubExport, FindNameIndex(Program.runData.uasset, "None").Value, 0);
uexp = Insert(uexp, stubExport, newExportFileOffset);
if (File.Exists(Program.runData.uexpFileName + ".AddStubExportBackup"))
{
File.Delete(Program.runData.uexpFileName + ".AddStubExportBackup");
}
File.Move(Program.runData.uexpFileName, Program.runData.uexpFileName + ".AddStubExportBackup");
File.WriteAllBytes(Program.runData.uexpFileName, uexp);
Program.CallOffSetterWithArgs($" -e 12 {newExportSerialOffset} -r -m");
Program.runData.uasset = File.ReadAllBytes(Program.runData.uassetFileName);
return("");
}
private static byte[] MakeNameDef(string name)
{
byte[] result = new byte[OffsetConstants.nameHashesSize + OffsetConstants.stringSizeDesignationSize + 1];
result = Insert(result, StringToBytes(name), 4);
DOLib.WriteInt32IntoOffset(result, name.Length + 1, 0);
return(result);
}
private static byte[] MakeImportDef(Int32 package, Int32 _class, Int32 outerIndex, Int32 name)
{
byte[] result = new byte[OffsetConstants.importDefSize];
DOLib.WriteInt32IntoOffset(result, package, OffsetConstants.importPackageOffset);
DOLib.WriteInt32IntoOffset(result, _class, OffsetConstants.importClassOffset);
DOLib.WriteInt32IntoOffset(result, outerIndex, OffsetConstants.importOuterIndexOffset);
DOLib.WriteInt32IntoOffset(result, name, OffsetConstants.importNameOffset);
return(result);
}
public void OffSet(Span <byte> span, Dictionary <RequiredOffSettingData, Int32> args)
{
if (args.ContainsKey(RequiredOffSettingData.SizeChange))
{
foreach (Int32 offset in GetAffectedGlobalOffsets())
{
DOLib.AddToInt32ByOffset(span, args[RequiredOffSettingData.SizeChange], offset);
}
}
LocalOffSet(span, args);
}
private static void ContextReturnProcesser(ReadingContext upperContext, ReadingContext finishedContext)
{
upperContext.sizeChange += finishedContext.sizeChange;
if (finishedContext.contextDeclaredSizeOffset != 0)
{
DOLib.AddToInt32ByOffset(Program.runData.uexp, finishedContext.sizeChange, finishedContext.contextDeclaredSizeOffset);
}
if (customRunDara.taskComplete)
{
upperContext.targetContext.Clear();
upperContext.pattern.Clear();
}
}
private static RelativeSizeChangeDirection CheckOffsetAffected(Span <byte> span, Int32 sizeChangeSerialOffset, Int32 referenceOffset)
{
Int32 serialOffset = DOLib.Int32FromSpanOffset(span, referenceOffset + relativeSerialOffsetOffset);
if (serialOffset > sizeChangeSerialOffset)
{
return(RelativeSizeChangeDirection.before);
}
else if (serialOffset == sizeChangeSerialOffset)
{
return(RelativeSizeChangeDirection.here);
}
else /*if (serialOffset < sizeChangeSerialOffset)*/ return {
(RelativeSizeChangeDirection.after);
}
}
/// <summary>
///
/// </summary>
/// <param name="_class"></param>
/// <param name="super"></param>
/// <param name="template"></param>
/// <param name="outer"></param>
/// <param name="name"></param>
/// <param name="nameAug">Name Augmentation. Seems to be a number sometimes used to distinguish objects sharing same "base" name</param>
/// <param name="flags"></param>
/// <param name="size">aka SerialSize, usually set to 0 in DAUM, actual value set after by OffSetter</param>
/// <param name="serialOffset"></param>
/// <param name="other">other is assumed to be 15 elements, less elements will cause exception!</param>
/// <returns>byte[] with ExportDefinition </returns>
private static byte[] MakeExportDef(Int32 _class, Int32 super, Int32 template, Int32 outer, Int32 name, Int32 nameAug, Int32 flags,
Int32 size, Int32 serialOffset, List <Int32> other)
{
byte[] result = new byte[exportDefinitionSize];
DOLib.WriteInt32IntoOffset(result, _class, relativeClassOffset);
DOLib.WriteInt32IntoOffset(result, super, relativeSuperOffset);
DOLib.WriteInt32IntoOffset(result, template, relativeTemlateOffset);
DOLib.WriteInt32IntoOffset(result, outer, relativeOuterOffset);
DOLib.WriteInt32IntoOffset(result, name, relativeObjectNameOffset);
DOLib.WriteInt32IntoOffset(result, nameAug, relativeObjectNameOffset + 4);
DOLib.WriteInt32IntoOffset(result, flags, relativeObjectFlagsOffset);
DOLib.WriteInt32IntoOffset(result, size, relativeSerialSizeOffset);
DOLib.WriteInt32IntoOffset(result, serialOffset, relativeSerialOffsetOffset);
Int32 currentOtherOffset = relativeOtherDataOffset;
for (int i = 0; i < otherDataInt32Count; i++)
{
DOLib.WriteInt32IntoOffset(result, other[i], currentOtherOffset);
currentOtherOffset += 4;
}
return(result);
}
private static void ApplySerialOffsetChange(Span <byte> span, Int32 sizeChange, Int32 referenceOffset)
{
DOLib.AddToInt32ByOffset(span, sizeChange, referenceOffset + relativeSerialOffsetOffset);
}