private BitArray LoadBitArray(StructureValueCollection values, string countName, string addressName, IReader reader)
{
if (!values.HasInteger(countName) || !values.HasInteger(addressName))
{
return(new BitArray(0));
}
var count = (int)values.GetInteger(countName);
uint address = values.GetInteger(addressName);
if (count <= 0 || address == 0)
{
return(new BitArray(0));
}
var ints = new int[count];
reader.SeekTo(_metaArea.PointerToOffset(address));
for (int i = 0; i < count; i++)
{
ints[i] = reader.ReadInt32();
}
return(new BitArray(ints));
}
private void Load(StructureValueCollection values, FileSegmenter segmenter, FileSegmentGroup localeArea)
{
StringCount = (int)values.GetInteger("string count");
if (StringCount > 0)
{
// Index table offset, segment, and pointer
int localeIndexTableOffset = localeArea.PointerToOffset((uint)values.GetInteger("locale index table offset"));
LocaleIndexTable = segmenter.WrapSegment(localeIndexTableOffset, StringCount * 8, 8, SegmentResizeOrigin.End);
LocaleIndexTableLocation = localeArea.AddSegment(LocaleIndexTable);
// Data offset, segment, and pointer
int localeDataOffset = localeArea.PointerToOffset((uint)values.GetInteger("locale data index offset"));
var localeDataSize = (int)values.GetInteger("locale table size");
LocaleData = segmenter.WrapSegment(localeDataOffset, localeDataSize, _sizeAlign, SegmentResizeOrigin.End);
LocaleDataLocation = localeArea.AddSegment(LocaleData);
// Load hashes if they exist
if (values.HasRaw("index table hash"))
{
IndexTableHash = values.GetRaw("index table hash");
}
if (values.HasRaw("string data hash"))
{
StringDataHash = values.GetRaw("string data hash");
}
}
}
private byte[] LoadResourceInfoBuffer(StructureValueCollection values, IReader reader)
{
var size = (int)values.GetInteger("resource info buffer size");
uint address = values.GetInteger("resource info buffer address");
if (size <= 0 || address == 0)
{
return(new byte[0]);
}
int offset = _metaArea.PointerToOffset(address);
reader.SeekTo(offset);
return(reader.ReadBlock(size));
}
public static StructureValueCollection[] ReadReflexive(IReader reader, int count, uint address,
StructureLayout entryLayout, FileSegmentGroup metaArea)
{
if (entryLayout.Size == 0)
{
throw new ArgumentException("The entry layout must have a size associated with it.");
}
// Handle null pointers
if (count <= 0)
{
return(new StructureValueCollection[0]);
}
// Convert the address to an offset and seek to it
int offset = metaArea.PointerToOffset(address);
reader.SeekTo(offset);
// Read the entries
var result = new StructureValueCollection[count];
for (int i = 0; i < count; i++)
{
result[i] = StructureReader.ReadStructure(reader, entryLayout);
}
return(result);
}
/// <summary>
/// Writes data to a block at a particular address.
/// </summary>
/// <param name="elements">The entries to write.</param>
/// <param name="address">The address to write to.</param>
/// <param name="layout">The layout of the data to write.</param>
/// <param name="metaArea">The meta area of the cache file.</param>
/// <param name="writer">The stream to write to.</param>
public static void WriteTagBlock(IEnumerable <StructureValueCollection> elements, long address, StructureLayout layout,
FileSegmentGroup metaArea, IWriter writer)
{
int offset = metaArea.PointerToOffset(address);
int index = 0;
foreach (StructureValueCollection element in elements)
{
writer.SeekTo(offset + index * layout.Size);
StructureWriter.WriteStructure(element, layout, writer);
index++;
}
}
/// <summary>
/// Writes data to a reflexive at a particular address.
/// </summary>
/// <param name="entries">The entries to write.</param>
/// <param name="address">The address to write to.</param>
/// <param name="layout">The layout of the data to write.</param>
/// <param name="metaArea">The meta area of the cache file.</param>
/// <param name="writer">The stream to write to.</param>
public static void WriteReflexive(IEnumerable <StructureValueCollection> entries, uint address, StructureLayout layout,
FileSegmentGroup metaArea, IWriter writer)
{
int offset = metaArea.PointerToOffset(address);
int index = 0;
foreach (StructureValueCollection entry in entries)
{
writer.SeekTo(offset + index * layout.Size);
StructureWriter.WriteStructure(entry, layout, writer);
index++;
}
}
public static void WriteContractedTagBlock(IEnumerable <StructureValueCollection> elements, uint address, StructureLayout layout,
FileSegmentGroup metaArea, IWriter writer, IPointerExpander expander)
{
long cont = expander.Expand(address);
int offset = metaArea.PointerToOffset(address);
int index = 0;
foreach (StructureValueCollection entry in elements)
{
writer.SeekTo(offset + index * layout.Size);
StructureWriter.WriteStructure(entry, layout, writer);
index++;
}
}
private CachedStringTable LoadStrings(IReader reader, StructureValueCollection values, StringTableReader stringReader)
{
var stringsSize = (int)values.GetInteger("script string table size");
if (stringsSize == 0)
{
return(new CachedStringTable());
}
var result = new CachedStringTable();
int tableOffset = _metaArea.PointerToOffset(values.GetInteger("script string table address"));
stringReader.ReadRequestedStrings(reader, tableOffset, result);
return(result);
}
private void SaveData(IStream stream, EffectInteropType type)
{
long pointer;
byte[] data;
switch (type)
{
case EffectInteropType.Effect:
pointer = _effePointer;
data = _effe.SelectMany(a => a).ToArray();
break;
case EffectInteropType.Beam:
pointer = _beamPointer;
data = _beam.SelectMany(a => a).ToArray();
break;
case EffectInteropType.Contrail:
pointer = _cntlPointer;
data = _cntl.SelectMany(a => a).ToArray();
break;
case EffectInteropType.LightVolume:
pointer = _ltvlPointer;
data = _ltvl.SelectMany(a => a).ToArray();
break;
default:
return;
}
var pointerLayout = _buildInfo.Layouts.GetLayout("data reference");
stream.SeekTo(_metaArea.PointerToOffset(pointer));
var pointerData = StructureReader.ReadStructure(stream, pointerLayout);
var oldSize = (int)pointerData.GetInteger("size");
var oldAddress = (uint)pointerData.GetInteger("pointer");
var oldExpand = _expander.Expand(oldAddress);
if (oldExpand >= 0 && oldSize > 0)
{
_allocator.Free(oldExpand, oldSize);
}
long newAddress = 0;
if (data.Length > 0)
{
newAddress = _allocator.Allocate(data.Length, 0x10, stream);
stream.SeekTo(_metaArea.PointerToOffset(newAddress));
stream.WriteBlock(data);
}
uint cont = _expander.Contract(newAddress);
pointerData.SetInteger("size", (ulong)data.Length);
pointerData.SetInteger("pointer", cont);
stream.SeekTo(_metaArea.PointerToOffset(pointer));
StructureWriter.WriteStructure(pointerData, pointerLayout, stream);
}