public void InternalizeRawChunk(int rawPoolIndex)
{
//Get the raw chunk data
byte[] rawChunk = Map.RawInformation.GetCompressedRawDataFromPoolIndex(rawPoolIndex);
//Calculate the size to insert
int paddingSize = ExtraFunctions.CalculatePadding((int)rawChunk.Length, 0x1000);
//Block size to insert into the raw table
int blockSize = paddingSize + (int)rawChunk.Length;
//Open our IO
Map.OpenIO();
//Go to our external map index offset.
Map.IO.Out.BaseStream.Position = Map.RawInformation.RawPools[rawPoolIndex].ChunkOffset + 4;
//Write our value
Map.IO.Out.Write((short)-1);
//Skip 2 bytes
Map.IO.Out.BaseStream.Position += 2;
//Write our new raw data chunk offset.
Map.IO.Out.Write((uint)Map.MapHeader.RawTableSize);
//Close our IO
Map.CloseIO();
//Create our array for our bytes to insert
byte[] dataToInsert = new byte[blockSize];
for (int i = 0; i < dataToInsert.Length; i++)
{
dataToInsert[i] = 0xFF;
}
Array.Copy(rawChunk, dataToInsert, (int)rawChunk.Length);
//Time to start inserting the block..
ExtraFunctions.InsertBytes(Map.FileName, Map.MapHeader.RawTableOffset + Map.MapHeader.RawTableSize, dataToInsert);
Map.OpenIO();
Map.IO.Out.BaseStream.Position = 1160;
Map.IO.Out.Write((map.MapHeader.RawTableSize + blockSize));
Map.IO.Out.BaseStream.Position = 1144;
Map.IO.Out.Write((map.MapHeader.localeTableAddressModifier + blockSize));
Map.CloseIO();
}
public void SaveLocale(int LocaleTableIndex, int StringIndex, string strName)
{
//Get our Locale Table
LocaleHandler.LocaleTable selectedTable = LocaleTables[LocaleTableIndex];
//Compare our string lengths.
if (selectedTable.LocaleStrings[StringIndex].Name.Length == strName.Length)
{
//Open our IO
Map.OpenIO();
//Go to that locale's position
Map.IO.Out.BaseStream.Position = selectedTable.LocaleTableOffset +
selectedTable.LocaleStrings[StringIndex].Offset;
//Write our new locale.
Map.IO.Out.WriteAsciiString(strName, strName.Length);
//Close our IO
Map.CloseIO();
}
else
{
//Get our variables
int differenceStringLength = strName.Length - selectedTable.LocaleStrings[StringIndex].Name.Length;
int oldTableSize = selectedTable.LocaleTableSize;
int newTableSize = selectedTable.LocaleTableSize + differenceStringLength;
int oldTableSizePadded = oldTableSize + ExtraFunctions.CalculatePadding(oldTableSize, 0x1000);
int newTableSizePadded = newTableSize + ExtraFunctions.CalculatePadding(newTableSize, 0x1000);
int differenceTableSize = newTableSizePadded - oldTableSizePadded;
//Let's recalculate some variables.
//Open our IO
Map.OpenIO();
//Go to our following string index's position
Map.IO.Out.BaseStream.Position = selectedTable.LocaleTableIndexOffset + ((StringIndex + 1) * 8);
//Loop for every string after.
for (int i = StringIndex + 1; i < selectedTable.LocaleCount; i++)
{
//Skip 4 bytes
Map.IO.Out.BaseStream.Position += 4;
//Write our new index
Map.IO.Out.Write(selectedTable.LocaleStrings[i].Offset + differenceStringLength);
}
//Let's shift our other tables
//Loop for each table after this one.
for (int i = LocaleTableIndex + 1; i < LocaleTables.Count; i++)
{
//Go to that table's offset.
Map.IO.Out.BaseStream.Position = LocaleTables[i].Offset + 8;
//Shift our values
LocaleTables[i].LocaleTableOffset += differenceTableSize;
LocaleTables[i].LocaleTableIndexOffset += differenceTableSize;
//Write our values.
Map.IO.Out.Write((LocaleTables[i].LocaleTableIndexOffset - Map.MapHeader.localeTableAddressModifier));
Map.IO.Out.Write((LocaleTables[i].LocaleTableOffset - Map.MapHeader.localeTableAddressModifier));
}
byte[] restOfTable = new byte[0];
try
{
//Read the rest of our table after we'll insert
Map.IO.In.BaseStream.Position = selectedTable.LocaleTableOffset + selectedTable.LocaleStrings[StringIndex + 1].Offset;
restOfTable = Map.IO.In.ReadBytes(oldTableSize - selectedTable.LocaleStrings[StringIndex].Offset);
}
catch { }
//Close our IO
Map.CloseIO();
//Check our difference.
if (differenceTableSize > 0)
{
//Insert
ExtraFunctions.InsertBytes(Map.FileName, selectedTable.LocaleTableOffset + oldTableSizePadded, differenceTableSize);
}
else if (differenceTableSize < 0)
{
//Delete
ExtraFunctions.DeleteBytes(Map.FileName, selectedTable.LocaleTableOffset + newTableSizePadded, oldTableSizePadded - newTableSizePadded);
}
//Open our IO
Map.OpenIO();
//Let's write our new strings name.
Map.IO.Out.BaseStream.Position = selectedTable.LocaleTableOffset + selectedTable.LocaleStrings[StringIndex].Offset;
Map.IO.Out.WriteAsciiString(strName, strName.Length + 1);
//Write the ending of our table
Map.IO.Out.Write(restOfTable);
Map.IO.Out.Write(new byte[newTableSizePadded - newTableSize]);
//Lets go write our new locale table size
Map.IO.Out.BaseStream.Position = selectedTable.Offset + 4;
//Write our new size.
Map.IO.Out.Write(newTableSize);
//Close our IO
Map.CloseIO();
//Set our new table size
selectedTable.LocaleTableSize = newTableSize;
}
//Open our IO
Map.OpenIO();
//Go back to the beginning of the table
Map.IO.SeekTo(selectedTable.LocaleTableOffset);
byte[] hash = SHA1.Create().ComputeHash(Map.IO.In.ReadBytes(
selectedTable.LocaleTableSize));
//Seek to where the hash is
Map.IO.SeekTo(selectedTable.Offset + 0x24);
//Write it
Map.IO.Out.Write(hash);
//Go back to the beginning of the index table
Map.IO.SeekTo(selectedTable.LocaleTableIndexOffset);
hash = SHA1.Create().ComputeHash(Map.IO.In.ReadBytes(0x08 * selectedTable.LocaleCount));
//Seek to where the hash is
Map.IO.SeekTo(selectedTable.Offset + 0x10);
//Write it
Map.IO.Out.Write(hash);
//Close our IO
Map.CloseIO();
}
/// <summary>
/// This function renames a tag.
/// </summary>
/// <param name="tagIndex">The index of the tag to rename.</param>
/// <param name="newName">The new name of the tag to rename as.</param>
public void RenameTag(int tagIndex, string newName)
{
//Get our tag instance
HaloMap.TagItem tagItem = map.IndexItems[tagIndex];
//Compare our string lengths..
if (tagItem.Name.Length == newName.Length)
{
//They are the same length. Let's write our new string.
//Open our IO
map.OpenIO();
//Go to our tag_name_index_entry
map.IO.In.BaseStream.Position = map.MapHeader.fileTableIndexOffset + (tagIndex * 4);
//Read our tagnameoffset
int tagNameOffset = map.IO.In.ReadInt32() + map.MapHeader.fileTableOffset;
//Go to this position
map.IO.In.BaseStream.Position = tagNameOffset;
//Write our tagname
map.IO.Out.WriteAsciiString(newName, tagItem.Name.Length);
//Close our IO
map.CloseIO();
//Set our tagname.
map.IndexItems[tagIndex].Name = newName;
}
else
{
//Calculate our table difference.
int differenceInStringLength = (tagItem.Name.Length - newName.Length);
int newTableSizeUnpadded = map.MapHeader.fileTableSize - differenceInStringLength;
int newTableSize = newTableSizeUnpadded + ExtraFunctions.CalculatePadding(newTableSizeUnpadded, 0x1000);
int oldTableSize = map.MapHeader.fileTableSize + ExtraFunctions.CalculatePadding(map.MapHeader.fileTableSize, 0x1000);
int differenceInSize = oldTableSize - newTableSize;
//Open our IO
map.OpenIO();
//Go to our tag_name_index_entry
map.IO.In.BaseStream.Position = map.MapHeader.fileTableIndexOffset + (tagIndex * 4);
//Read our tagnameoffset
int tagNameOffset = map.IO.In.ReadInt32() + map.MapHeader.fileTableOffset;
//Loop for each tag_name_index after it.
for (int i = tagIndex + 1; i < map.IndexHeader.tagCount; i++)
{
//Go to our tag_name_index_entry
map.IO.In.BaseStream.Position = map.MapHeader.fileTableIndexOffset + (i * 4);
//Read our tagindex
int tagOff = map.IO.In.ReadInt32();
//Recalculate it.
tagOff -= differenceInStringLength;
//Go to our tag_name_index_entry
map.IO.Out.BaseStream.Position = map.MapHeader.fileTableIndexOffset + (i * 4);
//Write it
map.IO.Out.Write(tagOff);
}
//Close our IO
map.CloseIO();
//If it's any different.
if (differenceInSize > 0)
{
ExtraFunctions.DeleteBytes(map.FileName, map.MapHeader.fileTableOffset + newTableSize, oldTableSize - newTableSize);
}
else
{
ExtraFunctions.InsertBytes(map.FileName, map.MapHeader.fileTableOffset + oldTableSize, newTableSize - oldTableSize);
}
//Open our IO
map.OpenIO();
//Go to this position
map.IO.Out.BaseStream.Position = tagNameOffset;
//Write our tagname
map.IO.Out.WriteAsciiString(newName, newName.Length);
map.IO.Out.Write((byte)0);
for (int i = tagIndex + 1; i < map.IndexHeader.tagCount; i++)
{
//Write the tagname
map.IO.Out.WriteAsciiString(map.IndexItems[i].Name, map.IndexItems[i].Name.Length);
map.IO.Out.Write((byte)0);
}
//For the rest of our table, write the padding.
byte[] padding = new byte[newTableSize - newTableSizeUnpadded];
//Write our padding
map.IO.Out.Write(padding);
//Recalculate some header values.
map.IO.Out.BaseStream.Position = 20;
map.IO.Out.Write(((map.MapHeader.virtSegmentStart - differenceInSize) + map.MapHeader.headerMagic));
map.IO.Out.BaseStream.Position = 700;
map.IO.Out.Write(newTableSizeUnpadded);
map.IO.Out.BaseStream.Position = 704;
map.IO.Out.Write(((map.MapHeader.fileTableIndexOffset - differenceInSize) + map.MapHeader.headerMagic));
map.IO.Out.BaseStream.Position = 1136;
map.IO.Out.Write((map.MapHeader.RawTableOffset - differenceInSize));
map.IO.Out.BaseStream.Position = 1144;
map.IO.Out.Write((map.MapHeader.localeTableAddressModifier - differenceInSize));
//Close our IO
map.CloseIO();
//Reload our map
map.Reload();
}
}
public List <MetaHeader_DataBlock> GetMetaHeaderDataBlocksMapped(bool FindVoids, bool FindIdents, bool FindChildren)
{
int num;
Plugin_Scanning_Regions = new List <PluginScanningRegion>();
Plugin_Data_Blocks = new List <PluginDataBlock>();
MetaHeader_Data_Blocks = new List <MetaHeader_DataBlock>();
Tag_Idents = new List <Tag_Ident>();
Tag_Voids = new List <Tag_Void>();
PluginScanningRegion region = new PluginScanningRegion {
Offset = Map.Map_Header.RawTableOffset + Map.Map_Header.RawTableSize
};
region.Size = Map.Index_Header.tagInfoHeaderOffset - region.Offset;
Plugin_Scanning_Regions.Add(region);
PluginScanningRegion region2 = new PluginScanningRegion {
Offset = (Map.Map_Header.indexOffset + 0x2c) + ExtraFunctions.CalculatePadding(Map.Map_Header.indexOffset + 0x2c, 0x1000)
};
region2.Size = new LocaleHandler(Map).LocaleTables[0].LocaleTableIndexOffset - region2.Offset;
Plugin_Scanning_Regions.Add(region2);
foreach (HaloMap.TagItem item in Map.Index_Items)
{
MetaHeader_DataBlock block = new MetaHeader_DataBlock(item);
Plugin_Data_Blocks.Add(block);
MetaHeader_Data_Blocks.Add(block);
Application.DoEvents();
}
Map.OpenIO();
for (num = 0; num < Plugin_Scanning_Regions.Count; num++)
{
PluginScanningRegion region3 = Plugin_Scanning_Regions[num];
Map.IO.In.BaseStream.Position = region3.Offset;
while (Map.IO.In.BaseStream.Position < (region3.Offset + region3.Size))
{
double num2 = ((Map.IO.In.BaseStream.Position - region3.Offset) / ((double)region3.Size)) * 100.0;
int count = Map.IO.In.ReadInt32();
int pointer = Map.IO.In.ReadInt32() - Map.Map_Header.mapMagic;
int num5 = Map.IO.In.ReadInt32();
if (((num5 == 0) && ((count > 0) && (count < 0x927c0))) && PointerIsInRegions(count, pointer))
{
Reflexive_DataBlock block2 = new Reflexive_DataBlock {
Count = count,
Offset = (int)(Map.IO.In.BaseStream.Position - 12L),
Pointer = pointer
};
Plugin_Data_Blocks.Add(block2);
}
else if ((PointerIsInRegions(pointer + Map.Map_Header.mapMagic, num5 - Map.Map_Header.mapMagic) && ((pointer + Map.Map_Header.mapMagic) > 0)) && ((pointer + Map.Map_Header.mapMagic) < 0x927c0))
{
Stream baseStream = Map.IO.In.BaseStream;
baseStream.Position -= 8L;
}
else if (FindIdents)
{
Stream stream2 = Map.IO.In.BaseStream;
stream2.Position -= 12L;
string str = Map.IO.In.ReadAsciiString(4);
Stream stream3 = Map.IO.In.BaseStream;
stream3.Position += 8L;
int num6 = Map.IO.In.ReadInt32();
int tagIndexByIdent = Map.GetTagIndexByIdent(num6);
if ((tagIndexByIdent != -1) && (Map.Index_Items[tagIndexByIdent].Class == str))
{
Tag_Ident ident = new Tag_Ident {
Offset = ((int)Map.IO.In.BaseStream.Position) - 0x10
};
Tag_Idents.Add(ident);
}
else
{
Stream stream4 = Map.IO.In.BaseStream;
stream4.Position -= 12L;
if (FindVoids)
{
Stream stream5 = Map.IO.In.BaseStream;
stream5.Position -= 4L;
uint num8 = Map.IO.In.ReadUInt32();
int num9 = Map.IO.In.ReadInt32();
int num10 = Map.IO.In.ReadInt32();
pointer = Map.IO.In.ReadInt32() - Map.Map_Header.mapMagic;
int num11 = Map.IO.In.ReadInt32();
if (((PointerIsInRegions((int)num8, pointer) && (num8 > 0)) && ((num9 == 0) && (num10 == 0))) && (num11 == 0))
{
Tag_Void @void = new Tag_Void {
Offset = ((int)Map.IO.In.BaseStream.Position) - 20
};
Tag_Voids.Add(@void);
}
else
{
Stream stream6 = Map.IO.In.BaseStream;
stream6.Position -= 0x10L;
}
}
else
{
Stream stream7 = Map.IO.In.BaseStream;
stream7.Position -= 4L;
}
}
}
}
}
Map.CloseIO();
for (num = 0; num < Plugin_Data_Blocks.Count; num++)
{
CalculateStructureSize(Plugin_Data_Blocks[num]);
}
if (FindChildren)
{
for (num = 0; num < Plugin_Data_Blocks.Count; num++)
{
MapChildren(Plugin_Data_Blocks[num]);
}
}
return(MetaHeader_Data_Blocks);
}
public List <MetaHeader_DataBlock> GetMetaHeaderDataBlocksMapped(bool FindIdents, bool FindChildren)
{
//Let's initialize our lists.
Plugin_Scanning_Regions = new List <PluginScanningRegion>();
Plugin_Data_Blocks = new List <PluginDataBlock>();
MetaHeader_Data_Blocks = new List <MetaHeader_DataBlock>();
Tag_Idents = new List <Tag_Ident>();
//Let's make our first region
PluginScanningRegion pluginScanRegion = new PluginScanningRegion();
pluginScanRegion.Offset = Map.MapHeader.RawTableOffset + Map.MapHeader.RawTableSize;
pluginScanRegion.Size = Map.IndexHeader.tagInfoHeaderOffset - pluginScanRegion.Offset;
//Add it to our list
Plugin_Scanning_Regions.Add(pluginScanRegion);
//Let's make our second region
PluginScanningRegion pluginScanRegion2 = new PluginScanningRegion();
pluginScanRegion2.Offset = Map.MapHeader.indexOffset + 40 + ExtraFunctions.CalculatePadding(Map.MapHeader.indexOffset + 40, 0x1000);
pluginScanRegion2.Size = new LocaleHandler(Map).LocaleTables[0].LocaleTableIndexOffset - pluginScanRegion2.Offset;
//Add it to our list
Plugin_Scanning_Regions.Add(pluginScanRegion2);
//Loop through each of our tags
foreach (HaloMap.TagItem tagItem in Map.IndexItems)
{
//Initialize our metaheader_datablock
MetaHeader_DataBlock mhdb = new MetaHeader_DataBlock(tagItem);
//Add it to our list
Plugin_Data_Blocks.Add(mhdb);
MetaHeader_Data_Blocks.Add(mhdb);
//Unfreeze
Application.DoEvents();
}
//Open our IO
Map.OpenIO();
//Loop through each scan region
for (int i = 0; i < Plugin_Scanning_Regions.Count; i++)
{
//Set our plugin scanning region
PluginScanningRegion scanRegion = Plugin_Scanning_Regions[i];
//Make our IO go to the scan regions position
Map.IO.In.BaseStream.Position = scanRegion.Offset;
while (Map.IO.In.BaseStream.Position < (scanRegion.Offset + scanRegion.Size))
{
double percent = (((double)Map.IO.In.BaseStream.Position - scanRegion.Offset) / (double)scanRegion.Size) * 100;
//Possible count
int count = Map.IO.In.ReadInt32();
int pointer = Map.IO.In.ReadInt32() - Map.MapHeader.mapMagic;
int zeros = Map.IO.In.ReadInt32();
//If our zero data = 0
if (zeros == 0)
{
//If our count is valid.
if (count > 0 && count < 600000)
{
//If our pointer is valid.
if (PointerIsInRegions(count, pointer))
{
//Let's initialize our reflexive data block
Reflexive_DataBlock rdb = new Reflexive_DataBlock();
rdb.Count = count;
rdb.Offset = (int)(Map.IO.In.BaseStream.Position - 12);
rdb.Pointer = pointer;
//Add it to our list
Plugin_Data_Blocks.Add(rdb);
//Go to our FoundAReflexive location
goto FoundAReflexive;
}
}
}
//Determine how much to jump back
if (PointerIsInRegions(pointer + Map.MapHeader.mapMagic, zeros - Map.MapHeader.mapMagic) && pointer + Map.MapHeader.mapMagic > 0 && pointer + Map.MapHeader.mapMagic < 600000)
{
//There's a potential reflexive 8 bytes back!
Map.IO.In.BaseStream.Position -= 8;
}
else
{
//If we are to find idents.
if (FindIdents)
{
//Didn't find anything. Go back and scan for idents
Map.IO.In.BaseStream.Position -= 12;
//Read our 4 values
string tagClass = Map.IO.In.ReadAsciiString(4);
//Skip 4 bytes
Map.IO.In.BaseStream.Position += 8;
//Read our id
int ident = Map.IO.In.ReadInt32();
//Get our index
int index = Map.GetTagIndexByIdent(ident);
//If our index isn't -1
if (index != -1)
{
//If our tag's class == tagclass
if (Map.IndexItems[index].Class == tagClass)
{
//Initialize our new ident
Tag_Ident id = new Tag_Ident();
//Set our offset.
id.Offset = ((int)Map.IO.In.BaseStream.Position - 16);
//Add it to our list
Tag_Idents.Add(id);
//Go to our found ident spot
goto FoundIdent;
}
}
//We didn't find an ident. Go back
Map.IO.In.BaseStream.Position -= 12;
//Where we go if we found an ident
FoundIdent :;
}
else
{
//If we aren't to find idents.
//Go 4 bytes back.
Map.IO.In.BaseStream.Position -= 4;
}
}
//Where we'll jump to if we found a reflex, so we dont go back 8 bytes for no reason, wasting time.
FoundAReflexive :;
}
}
//Close our IO
Map.CloseIO();
//Let's calculate our sizes.. Loop through each data block
for (int i = 0; i < Plugin_Data_Blocks.Count; i++)
{
CalculateStructureSize(Plugin_Data_Blocks[i]);
}
//If we are to map children.
if (FindChildren)
{
//Let's map our children. Loop through each plugin data block
for (int i = 0; i < Plugin_Data_Blocks.Count; i++)
{
MapChildren(Plugin_Data_Blocks[i]);
}
}
//Return our meta blocks
return(MetaHeader_Data_Blocks);
}