internal void HandleSubrecord(
MainRecord rec, PluginFileSource source, ref int defIndex
)
{
var subrecord = source.currentSubrecord;
var def = GetMemberDef(subrecord.signature, ref defIndex);
if (def == null)
{
rec._unexpectedSubrecords.Add(subrecord);
source.SubrecordHandled();
}
else if (def.IsSubrecord())
{
def.ReadElement(rec, source, subrecord.dataSize);
source.SubrecordHandled();
defIndex++;
}
else
{
var container = (Container)def.PrepareElement(rec);
def.SubrecordFound(container, source);
defIndex++;
}
}
public void Add(PluginFile file, MainRecord record)
{
if (!_plugins.ContainsKey(file))
{
AddMap(file);
}
_plugins[file].Add(record);
}
internal StructElement HeaderToStructElement(
MainRecord rec, PluginFileSource source
)
{
var method = recordHeaderType.GetMethod("ToStructElement");
var args = new object[] { rec, source };
return((StructElement)method.Invoke(rec.header, args));
}
public override int Decide(Container container)
{
MainRecord owner = (MainRecord)container?.GetElement("@Owner");
return(owner?.signature switch {
"NPC_" => 1,
"FACT" => 2,
_ => 0
});
internal void WriteSourceTo(MainRecord rec, PluginFileOutput output)
{
var source = rec._file.source;
source.stream.Position = rec.bodyOffset - recordHeaderSize;
int size = (int)(recordHeaderSize + rec.header.dataSize);
source.PipeTo(output.writer, size);
}
private static void TestElementBuildTime(MainRecord rec)
{
var sw = Stopwatch.StartNew();
Assert.IsNotNull(rec.count);
sw.Stop();
var elapsedTime = sw.ElapsedTicks / (double)Stopwatch.Frequency * 1000;
Console.WriteLine($"Built elements for {rec.signature} in {elapsedTime:N3}ms");
}
public void Add(MainRecord rec)
{
var editorId = rec.editorId;
if (editorId == null)
{
return;
}
_map[editorId] = rec;
}
private static void TestRecordValues(JObject json, MainRecord rec)
{
TestElementBuildTime(rec);
TestContainerValues(rec, json.Value <JArray>("elements"));
if (json.ContainsKey("Child Group"))
{
var src = json.Value <JObject>("Child Group");
TestGroupValues(src, rec.childGroup);
}
}
internal void ReadElements(MainRecord rec, PluginFileSource source)
{
rec._internalElements = new List <Element>();
rec._unexpectedSubrecords = new List <Subrecord>();
InitContainedInElements(rec.container as GroupRecord, rec);
ReadHeader(rec, source);
source.WithRecordData(rec, () => {
ReadSubrecords(rec, source);
rec.ElementsReady();
});
}
internal void ReadFileHeader(PluginFile plugin)
{
var source = plugin.source;
if (plugin.header != null)
{
return;
}
plugin.header = MainRecord.Read(plugin, source, Signatures.TES4);
plugin.InitMasters();
plugin.InitRecordMaps();
}
internal void WithRecordData(MainRecord rec, Action callback)
{
if (rec.compressed && !rec.Decompress(this))
{
throw new Exception("Failed to decompress content.");
}
try {
callback();
} finally {
DiscardDecompressedStream();
}
}
internal void WriteElementsTo(MainRecord rec, PluginFileOutput output)
{
int index = GetFirstRealElementIndex(rec);
var headerElement = rec._internalElements[index++];
UpdateDataSize(headerElement, rec.size - recordHeaderSize);
headerElement.WriteTo(output);
output.WriteRecordData(rec, () => {
for (; index < rec._internalElements.Count; index++)
{
rec._internalElements[index].WriteTo(output);
}
});
}
private void ReadSubrecords(MainRecord rec, PluginFileSource source)
{
int defIndex = 0;
source.StartRead(rec.dataSize);
while (true)
{
if (!source.NextSubrecord())
{
break;
}
HandleSubrecord(rec, source, ref defIndex);
}
source.EndRead();
}
internal void InitElement(MainRecord rec)
{
foreach (var def in memberDefs)
{
if (!def.required)
{
continue;
}
if (rec._internalElements.Any(e => e.def == def))
{
continue;
}
var e = def.NewElement(rec);
e.Initialize();
}
}
internal void UpdateContainedIn(GroupRecord group, MainRecord rec)
{
if (group == null || !group.hasRecordParent)
{
return;
}
var parentRec = group.GetParentRecord();
var containedInDef = parentRec.mrDef.containedInDef;
if (containedInDef == null)
{
return;
}
var element = (ValueElement)rec.FindElementForDef(containedInDef);
element._data = FormId.FromSource(parentRec._file, parentRec.fileFormId);
}
public static MainDto ToDTO(this MainRecord entity)
{
if (entity == null)
{
return(null);
}
var dto = new MainDto();
dto.key = entity.Id;
dto.title = entity.Title;
dto.mainType = entity.MainTypeRecord.ToDTO();
entity.OnDTO(dto);
return(dto);
}
internal void WriteRecordData(MainRecord rec, Action callback)
{
var compressed = rec.compressed;
if (compressed)
{
StartCompression();
}
try {
callback();
if (compressed)
{
WriteCompressedData();
}
} finally {
DiscardCompressedStream();
}
}
public TintEntries Get(MainRecord race, bool?female)
{
if (race == null || female == null)
{
return(null);
}
var raceId = race.editorId;
var entries = cache.Find(e => {
return(e.raceId == raceId && e.female == female);
});
if (entries == null)
{
entries = new TintEntries(race, raceId, (bool)female);
cache.Add(entries);
}
return(entries);
}
public static MainRecord ToEntity(this MainDto dto)
{
if (dto == null)
{
return(null);
}
var entity = new MainRecord();
entity.Id = dto.key;
entity.ParentId = dto.parentId;
entity.Title = dto.title;
entity.MainTypeRecord = dto.mainType.ToEntity();
dto.OnEntity(entity);
return(entity);
}
internal void ReadChildren(GroupRecord group, PluginFileSource source)
{
var file = group.file;
source.ReadMultiple(group.dataSize, () => {
var sig = Signature.Read(source);
source.stream.Position -= 4;
if (sig == Signatures.GRUP)
{
GroupRecord.Read(group, source);
}
else
{
var rec = MainRecord.Read(group, source, sig);
file.IndexRecord(rec);
}
});
group.internalElements.TrimExcess();
}
public StructElement ToStructElement(
MainRecord rec, PluginFileSource source
)
{
var headerDef = rec.mrDef.headerDef;
var structElement = new StructElement(rec, headerDef);
var defs = headerDef.elementDefs;
int i = 0;
ValueElement.Init(structElement, defs[i++], signature.ToString());
ValueElement.Init(structElement, defs[i++], dataSize);
ValueElement.Init(structElement, defs[i++], flags);
var targetFile = rec.file.OrdinalToFile((byte)(formId >> 24), false);
var fid = new FormId(targetFile, formId & 0xFFFFFF);
ValueElement.Init(structElement, defs[i++], fid);
source.stream.Position += 16;
for (; i < defs.Count; i++)
{
defs[i].ReadElement(structElement, source);
}
return(structElement);
}
private Element GetMatchingStage(MainRecord rec, int index)
{
return(rec.GetElements("Stages").FirstOrDefault(stage => {
return stage.GetData(@"INDX\Stage Index") == index;
}));
}
public static bool GetRecordFlag(this MainRecord m, string flag)
{
return(m.GetFlag(@"Record Header\Record Flags", flag));
}
private ReadOnlyCollection <Element> GetAliases(MainRecord questRef)
{
return(questRef.GetElements("Aliases"));
}
public void Add(MainRecord rec)
{
_map[rec.localFormId] = rec;
}
static partial void OnDTO(this MainRecord entity, MainDto dto);
static partial void OnEntity(this MainDto dto, MainRecord entity);
private void ReadHeader(MainRecord rec, PluginFileSource source)
{
source.stream.Position = rec.bodyOffset - recordHeaderSize;
headerManager.HeaderToStructElement(rec, source);
}
internal int GetFirstRealElementIndex(MainRecord rec)
{
return(rec._internalElements.FindIndex(e => e.name == "Record Header"));
}
