/// <summary>
/// The dissect meta.
/// </summary>
/// <param name="m">The m.</param>
/// <remarks></remarks>
public static void DissectMeta(ref Meta m)
{
object tempobject = Results[m.type];
if (tempobject == null)
{
MetaResult mr = new MetaResult();
IFPIO io = IFPHashMap.GetIfp(m.type, m.Map.HaloVersion);
mr.IFP = io;
Results.Add(m.type, mr);
tempobject = Results[m.type];
}
MetaResult CurrentResult = tempobject as MetaResult;
// figure out headersize for current meta
int headersize = m.size;
for (int x = 0; x < m.items.Count; x++)
{
if (m.items[x].type == Meta.ItemType.Reflexive)
{
Meta.Reflexive tempr = m.items[x] as Meta.Reflexive;
if (tempr.translation < headersize && tempr.intag == m.TagIndex)
{
headersize = tempr.translation;
}
}
}
if (CurrentResult.HeaderSizes.IndexOf(headersize) == -1)
{
CurrentResult.HeaderSizes.Add(headersize);
}
//
AnalyzeReferences(ref m);
}
/// <summary>
/// The fix reflexives.
/// </summary>
/// <param name="metas">The metas.</param>
/// <param name="map">The map.</param>
/// <remarks></remarks>
public static void FixReflexives(ArrayList metas, Map map)
{
int where = map.MapHeader.indexOffset + map.MapHeader.metaStart;
int howfar = 0;
int[] oldoffset = (int[])map.MetaInfo.Offset.Clone();
int padding = 0;
for (int x = 0; x < metas.Count; x++)
{
Meta m = (Meta)metas[x];
int f**k = map.IndexHeader.tagsOffset + (x * 16);
int offset = oldoffset[x] + padding;
if (x > map.ChunkTools.TagIndex)
{
offset += map.ChunkTools.SizeOfShift;
}
int offsetwithmagic = offset + map.SecondaryMagic;
int size = m.size;
if (m.type == "phmo" | m.type == "coll" | m.type == "spas")
{
int tempoffset = offset;
do
{
string tempss = tempoffset.ToString("X");
char[] tempc = tempss.ToCharArray();
int xxx = tempc.Length;
if (m.padding == tempc[xxx - 1])
{
int diff = tempoffset - offset;
byte[] tempb = new byte[diff];
map.BW.BaseStream.Position = offset;
map.BW.Write(tempb);
int tempsize = ((Meta)metas[x - 1]).size;
tempsize += diff;
int temploc = map.IndexHeader.tagsOffset + ((x - 1) * 16) + 12;
map.BW.BaseStream.Position = temploc;
map.BW.Write(tempsize);
offset = tempoffset;
howfar += diff;
padding += diff;
break;
}
tempoffset++;
}while (f**k != -54454);
}
if (m.type != "sbsp" && m.type != "ltmp")
{
}
else
{
continue;
}
howfar += size;
map.BW.BaseStream.Position = offset;
map.BW.BaseStream.Write(m.MS.ToArray(), 0, m.size);
map.MetaInfo.Offset[x] = offset;
// if (x == 0x334) { MessageBox.Show("test"); }
// if (x == 0) {
// map.BW.BaseStream.Position = f**k + 8;
// map.BW.Write(offsetwithmagic);
// map.BW.Write(size);
// continue; }
// if (oldoffset[x-1] == oldoffset[x]) {
// map.MetaInfo.Offset[x] = map.MetaInfo.Offset[x - 1];
// }
offsetwithmagic = map.MetaInfo.Offset[x] + map.SecondaryMagic;
map.BW.BaseStream.Position = f**k + 8;
map.BW.Write(offsetwithmagic);
map.BW.Write(size);
}
for (int x = 0; x < metas.Count; x++)
{
Meta m = (Meta)metas[x];
if (m.type == "sbsp" || m.type == "ltmp")
{
continue;
}
int offset = map.MetaInfo.Offset[x];
for (int xx = 0; xx < m.items.Count; xx++)
{
Meta.Item i = m.items[xx];
switch (i.type)
{
case Meta.ItemType.Reflexive:
Meta.Reflexive reflex = (Meta.Reflexive)i;
int newreflex = reflex.translation + offset + map.SecondaryMagic;
if (reflex.intag != m.TagIndex)
{
continue;
}
if (reflex.pointstoTagIndex != m.TagIndex)
{
newreflex = map.MetaInfo.Offset[reflex.pointstoTagIndex] + reflex.translation +
map.SecondaryMagic;
// if (reflex.pointstoTagIndex > ChunkAdder.TagIndex) { newreflex += ChunkAdder.SizeOfShift; }
}
map.BW.BaseStream.Position = offset + reflex.offset;
map.BW.Write(reflex.chunkcount);
map.BW.Write(newreflex);
break;
}
}
}
int prevsize = map.MapHeader.fileSize - (map.MapHeader.indexOffset + map.MapHeader.metaStart);
int paddingx = map.Functions.Padding(howfar, 512);
byte[] tempbb = new byte[paddingx];
map.BW.BaseStream.Position = map.MapHeader.indexOffset + map.MapHeader.metaStart + howfar;
map.BW.Write(tempbb);
howfar += paddingx;
int sizediff = howfar - prevsize;
int newfilesize = map.MapHeader.fileSize + sizediff;
map.BW.BaseStream.Position = 8;
map.BW.Write(newfilesize);
int metasize = map.MapHeader.metaSize + sizediff;
int combined = map.MapHeader.combinedSize + sizediff;
map.BW.BaseStream.Position = 24;
map.BW.Write(metasize);
map.BW.Write(combined);
map.FS.SetLength(newfilesize);
}
/// <summary>
/// The map rebuilder.
/// </summary>
/// <param name="layout">The layout.</param>
/// <remarks></remarks>
public void MapRebuilder(ref MapLayout layout)
{
int totalshift = 0;
// find new strings
///
///
ArrayList strings = new ArrayList();
foreach (string s in map.Strings.Name)
{
strings.Add(s);
}
for (int x = 0; x < MetaList.Count; x++)
{
Meta m = (Meta)MetaList[x];
for (int y = 0; y < m.items.Count; y++)
{
Meta.Item ii = m.items[y];
if (ii.type == Meta.ItemType.String)
{
Meta.String iii = (Meta.String)ii;
if (strings.IndexOf(iii.name) == -1)
{
strings.Add(iii.name);
}
}
}
}
///read ugh to meta
///
///
map.OpenMap(MapTypes.Internal);
Meta ughmeta = new Meta(map);
ughmeta.ReadMetaFromMap(map.IndexHeader.metaCount - 1, false);
IFPIO ifp = IFPHashMap.GetIfp("ugh!", map.HaloVersion);
ughmeta.headersize = ifp.headerSize;
ughmeta.scanner.ScanWithIFP(ref ifp);
MetaList.Add(ughmeta);
string temps = string.Empty;
///get model info
int tempint = layout.FindByType(RawDataContainerType.Model);
LayOutChunk loc = (LayOutChunk)layout.chunks[tempint];
//////////////////////////////////////
///model raw data
///
int modeshift = 0;
loc.startoffset += totalshift;
for (int x = 0; x < MetaList.Count; x++)
{
Meta m = (Meta)MetaList[x];
if (m.rawType == RawDataContainerType.Model)
{
BinaryWriter BW = new BinaryWriter(m.MS);
for (int y = 0; y < m.raw.rawChunks.Count; y++)
{
RawDataChunk r = m.raw.rawChunks[y];
if (r.rawLocation != MapTypes.Internal)
{
int tempintxx = r.offset;
if (r.rawLocation == MapTypes.MPShared)
{
tempintxx |= int.Parse("80000000", NumberStyles.HexNumber);
}
else if (r.rawLocation == MapTypes.SPShared)
{
tempintxx |= int.Parse("C0000000", NumberStyles.HexNumber);
}
else if (r.rawLocation == MapTypes.MainMenu)
{
tempintxx |= int.Parse("40000000", NumberStyles.HexNumber);
}
// writes new pointer to loaded meta
BW.BaseStream.Position = r.pointerMetaOffset;
BW.Write(tempintxx);
BW.Write(r.size);
continue;
}
int tempintx = loc.startoffset + modeshift;
// writes new pointer to loaded meta
BW.BaseStream.Position = r.pointerMetaOffset;
BW.Write(tempintx);
BW.Write(r.size);
// writes raw to map file
map.BW.BaseStream.Position = tempintx;
map.BW.BaseStream.Write(r.MS.ToArray(), 0, r.size);
// write padding
int tempinty = map.Functions.Padding(r.size, 512);
byte[] tempbytes = new byte[tempinty];
map.BW.Write(tempbytes);
modeshift += r.size + tempinty;
}
MetaList[x] = m;
}
}
loc.size = modeshift;
loc.endoffset = loc.startoffset + loc.size;
layout.chunks[tempint] = loc;
int curroffset = loc.endoffset;
/////////////////////////////////////
/// bsp raw
///
int bspcount = 0;
int[] bspmagic = new int[20];
int[] bspmagicreflexive = new int[20];
int[] bsprawoffset = new int[20];
int[] bsprawsize = new int[20];
int totalbsprawsize = 0;
bool found = false;
for (int x = 0; x < MetaList.Count; x++)
{
Meta m = (Meta)MetaList[x];
if (m.type == "sbsp")
{
BinaryWriter BW = new BinaryWriter(m.MS);
int[] tempoff = new int[m.raw.rawChunks.Count];
int thisbsprawsize = 0;
for (int y = 0; y < m.raw.rawChunks.Count; y++)
{
found = false;
RawDataChunk r = m.raw.rawChunks[y];
for (int yy = 0; yy < y; yy++)
{
RawDataChunk rr = m.raw.rawChunks[yy];
if (rr.offset == r.offset && rr.rawLocation == r.rawLocation)
{
tempoff[y] = tempoff[yy];
// writes new pointer to loaded meta
BW.BaseStream.Position = r.pointerMetaOffset;
BW.Write(tempoff[y]);
BW.Write(r.size);
found = true;
break;
}
}
if (found)
{
continue;
}
tempoff[y] = curroffset + thisbsprawsize;
// writes new pointer to loaded meta
BW.BaseStream.Position = r.pointerMetaOffset;
BW.Write(tempoff[y]);
BW.Write(r.size);
// writes raw to map file
map.BW.BaseStream.Position = curroffset + thisbsprawsize;
map.BW.BaseStream.Write(r.MS.ToArray(), 0, r.size);
// write padding
int tempinty = map.Functions.Padding(r.size, 512);
byte[] tempbytes = new byte[tempinty];
map.BW.Write(tempbytes);
thisbsprawsize += r.size + tempinty;
totalbsprawsize += r.size + tempinty;
}
bsprawsize[bspcount] = thisbsprawsize;
bspmagic[bspcount] = m.magic;
bspmagicreflexive[bspcount] = m.magic + m.offset;
curroffset += bsprawsize[bspcount];
// bspmagic=m.magic;
// newmagicreflexive=bspmagic+m.offset;
bspcount += 1;
MetaList[x] = m;
}
}
//////////////////////////////////////
///weather raw data
///
int weathershift = 0;
for (int x = 0; x < MetaList.Count; x++)
{
Meta m = (Meta)MetaList[x];
if (m.rawType == RawDataContainerType.Weather)
{
BinaryWriter BW = new BinaryWriter(m.MS);
for (int y = 0; y < m.raw.rawChunks.Count; y++)
{
RawDataChunk r = m.raw.rawChunks[y];
if (r.rawLocation != MapTypes.Internal)
{
int tempintxx = r.offset;
if (r.rawLocation == MapTypes.MPShared)
{
tempintxx |= int.Parse("80000000", NumberStyles.HexNumber);
}
else if (r.rawLocation == MapTypes.SPShared)
{
tempintxx |= int.Parse("C0000000", NumberStyles.HexNumber);
}
else if (r.rawLocation == MapTypes.MainMenu)
{
tempintxx |= int.Parse("40000000", NumberStyles.HexNumber);
}
// writes new pointer to loaded meta
BW.BaseStream.Position = r.pointerMetaOffset;
BW.Write(tempintxx);
BW.Write(r.size);
continue;
}
int tempintx = curroffset + weathershift;
// writes new pointer to loaded meta
BW.BaseStream.Position = r.pointerMetaOffset;
BW.Write(tempintx);
BW.Write(r.size);
// writes raw to map file
map.BW.BaseStream.Position = tempintx;
map.BW.BaseStream.Write(r.MS.ToArray(), 0, r.size);
// write padding
int tempinty = map.Functions.Padding(r.size, 512);
byte[] tempbytes = new byte[tempinty];
map.BW.Write(tempbytes);
weathershift += r.size + tempinty;
}
MetaList[x] = m;
}
}
curroffset += weathershift;
//////////////////////////////////////
///decr raw data
///
int decrshift = 0;
for (int x = 0; x < MetaList.Count; x++)
{
Meta m = (Meta)MetaList[x];
if (m.rawType == RawDataContainerType.DECR)
{
BinaryWriter BW = new BinaryWriter(m.MS);
for (int y = 0; y < m.raw.rawChunks.Count; y++)
{
RawDataChunk r = m.raw.rawChunks[y];
if (r.rawLocation != MapTypes.Internal)
{
int tempintxx = r.offset;
if (r.rawLocation == MapTypes.MPShared)
{
tempintxx |= int.Parse("80000000", NumberStyles.HexNumber);
}
else if (r.rawLocation == MapTypes.SPShared)
{
tempintxx |= int.Parse("C0000000", NumberStyles.HexNumber);
}
else if (r.rawLocation == MapTypes.MainMenu)
{
tempintxx |= int.Parse("40000000", NumberStyles.HexNumber);
}
// writes new pointer to loaded meta
BW.BaseStream.Position = r.pointerMetaOffset;
BW.Write(tempintxx);
BW.Write(r.size);
continue;
}
int tempintx = curroffset + decrshift;
// writes new pointer to loaded meta
BW.BaseStream.Position = r.pointerMetaOffset;
BW.Write(tempintx);
BW.Write(r.size);
// writes raw to map file
map.BW.BaseStream.Position = tempintx;
map.BW.BaseStream.Write(r.MS.ToArray(), 0, r.size);
// write padding
int tempinty = map.Functions.Padding(r.size, 512);
byte[] tempbytes = new byte[tempinty];
map.BW.Write(tempbytes);
decrshift += r.size + tempinty;
}
MetaList[x] = m;
}
}
curroffset += decrshift;
//////////////////////////////////////
///prtm raw data
///
int prtmshift = 0;
for (int x = 0; x < MetaList.Count; x++)
{
Meta m = (Meta)MetaList[x];
if (m.rawType == RawDataContainerType.PRTM)
{
BinaryWriter BW = new BinaryWriter(m.MS);
for (int y = 0; y < m.raw.rawChunks.Count; y++)
{
RawDataChunk r = m.raw.rawChunks[y];
if (r.rawLocation != MapTypes.Internal)
{
int tempintxx = r.offset;
if (r.rawLocation == MapTypes.MPShared)
{
tempintxx |= int.Parse("80000000", NumberStyles.HexNumber);
}
else if (r.rawLocation == MapTypes.SPShared)
{
tempintxx |= int.Parse("C0000000", NumberStyles.HexNumber);
}
else if (r.rawLocation == MapTypes.MainMenu)
{
tempintxx |= int.Parse("40000000", NumberStyles.HexNumber);
}
// writes new pointer to loaded meta
BW.BaseStream.Position = r.pointerMetaOffset;
BW.Write(tempintxx);
BW.Write(r.size);
continue;
}
int tempintx = curroffset + prtmshift;
// writes new pointer to loaded meta
BW.BaseStream.Position = r.pointerMetaOffset;
BW.Write(tempintx);
BW.Write(r.size);
// writes raw to map file
map.BW.BaseStream.Position = tempintx;
map.BW.BaseStream.Write(r.MS.ToArray(), 0, r.size);
// write padding
int tempinty = map.Functions.Padding(r.size, 512);
byte[] tempbytes = new byte[tempinty];
map.BW.Write(tempbytes);
prtmshift += r.size + tempinty;
}
MetaList[x] = m;
}
}
curroffset += prtmshift;
//////////////////////////////////////
///jmad raw data
///
int jmadshift = 0;
for (int x = 0; x < MetaList.Count; x++)
{
Meta m = (Meta)MetaList[x];
if (m.rawType == RawDataContainerType.Animation)
{
BinaryWriter BW = new BinaryWriter(m.MS);
for (int y = 0; y < m.raw.rawChunks.Count; y++)
{
RawDataChunk r = m.raw.rawChunks[y];
if (r.rawLocation != MapTypes.Internal)
{
int tempintxx = r.offset;
if (r.rawLocation == MapTypes.MPShared)
{
tempintxx |= int.Parse("80000000", NumberStyles.HexNumber);
}
else if (r.rawLocation == MapTypes.SPShared)
{
tempintxx |= int.Parse("C0000000", NumberStyles.HexNumber);
}
else if (r.rawLocation == MapTypes.MainMenu)
{
tempintxx |= int.Parse("40000000", NumberStyles.HexNumber);
}
// writes new pointer to loaded meta
BW.BaseStream.Position = r.pointerMetaOffset - 4;
BW.Write(r.size);
BW.Write(tempintxx);
continue;
}
int tempintx = curroffset + jmadshift;
// writes new pointer to loaded meta
BW.BaseStream.Position = r.pointerMetaOffset - 4;
BW.Write(r.size);
BW.Write(tempintx);
// writes raw to map file
map.BW.BaseStream.Position = tempintx;
map.BW.BaseStream.Write(r.MS.ToArray(), 0, r.size);
// write padding
int tempinty = map.Functions.Padding(r.size, 512);
byte[] tempbytes = new byte[tempinty];
map.BW.Write(tempbytes);
jmadshift += r.size + tempinty;
}
MetaList[x] = m;
}
}
curroffset += jmadshift;
//////////////////////////////////////
///bsp meta data
///
int[] bspmetaoffset = new int[20];
int[] bspmetasize = new int[20];
int tempcount = 0;
for (int x = 0; x < MetaList.Count; x++)
{
Meta m = (Meta)MetaList[x];
if (m.type == "sbsp")
{
Meta mm = (Meta)MetaList[3];
if (mm.type == "scnr")
{
BinaryWriter BWX = new BinaryWriter(mm.MS);
int tempoffx = map.BSP.sbsp[tempcount].pointerOffset;
BWX.BaseStream.Position = tempoffx;
BWX.Write(curroffset);
BWX.Write(m.size);
BWX.Write(bspmagicreflexive[tempcount]);
MetaList[3] = mm;
}
map.BW.BaseStream.Position = curroffset;
map.BW.BaseStream.Write(m.MS.ToArray(), 0, m.size);
bspmetasize[tempcount] = m.size;
bspmetaoffset[tempcount] = curroffset;
curroffset += m.size;
tempcount++;
}
}
////stringnames1
///
byte[] tempb = new byte[strings.Count * 128];
map.BW.BaseStream.Position = curroffset;
map.BW.BaseStream.Write(tempb, 0, strings.Count * 128);
for (int x = 0; x < strings.Count; x++)
{
map.BW.BaseStream.Position = curroffset + (x * 128);
char[] tempc = ((String)strings[x]).ToCharArray();
map.BW.Write(tempc);
}
map.BW.BaseStream.Position = 352;
map.BW.Write(curroffset);
int newcount = strings.Count;
map.BW.Write(newcount);
curroffset += strings.Count * 128;
int padding = map.Functions.Padding(curroffset, 512);
tempb = new byte[padding];
map.BW.BaseStream.Position = curroffset;
map.BW.BaseStream.Write(tempb, 0, padding);
curroffset += padding;
////stringsindex
///
int tempnewsrsize = strings.Count * 4;
map.BW.BaseStream.Position = curroffset;
int temporary = 0;
for (int x = 0; x < strings.Count; x++)
{
map.BW.BaseStream.Position = curroffset + (x * 4);
map.BW.Write(temporary);
temporary += ((String)strings[x]).Length + 1;
}
map.BW.BaseStream.Position = 364;
map.BW.Write(curroffset);
curroffset += tempnewsrsize;
padding = map.Functions.Padding(curroffset, 512);
tempb = new byte[padding];
map.BW.BaseStream.Position = curroffset;
map.BW.BaseStream.Write(tempb, 0, padding);
curroffset += padding;
////strings2
///
temporary = 0;
byte zero = 0;
for (int x = 0; x < strings.Count; x++)
{
map.BW.BaseStream.Position = curroffset + temporary;
char[] h = ((String)strings[x]).ToCharArray();
map.BW.Write(h);
map.BW.Write(zero);
temporary += ((String)strings[x]).Length + 1;
}
map.BW.BaseStream.Position = 360;
map.BW.Write(temporary);
map.BW.BaseStream.Position = 368;
map.BW.Write(curroffset);
curroffset += temporary;
padding = map.Functions.Padding(curroffset, 512);
tempb = new byte[padding];
map.BW.BaseStream.Position = curroffset;
map.BW.BaseStream.Write(tempb, 0, padding);
curroffset += padding;
////file names
///
temporary = 0;
for (int x = 0; x < MetaList.Count; x++)
{
map.BW.BaseStream.Position = curroffset + temporary;
char[] h = ((Meta)MetaList[x]).name.ToCharArray();
map.BW.Write(h);
map.BW.Write(zero);
temporary += ((Meta)MetaList[x]).name.Length + 1;
}
map.BW.BaseStream.Position = 704;
newcount = MetaList.Count;
map.BW.Write(newcount);
map.BW.Write(curroffset);
map.BW.Write(temporary);
curroffset += temporary;
padding = map.Functions.Padding(curroffset, 512);
tempb = new byte[padding];
map.BW.BaseStream.Position = curroffset;
map.BW.BaseStream.Write(tempb, 0, padding);
curroffset += padding;
////files index
///
temporary = 0;
for (int x = 0; x < MetaList.Count; x++)
{
map.BW.BaseStream.Position = curroffset + (x * 4);
map.BW.Write(temporary);
temporary += ((Meta)MetaList[x]).name.Length + 1;
}
map.BW.BaseStream.Position = 716;
map.BW.Write(curroffset);
curroffset += MetaList.Count * 4;
padding = map.Functions.Padding(curroffset, 512);
tempb = new byte[padding];
map.BW.BaseStream.Position = curroffset;
map.BW.BaseStream.Write(tempb, 0, padding);
curroffset += padding;
tempint = layout.FindByType(RawDataContainerType.UnicodeNamesIndex);
for (int x = 0; x < 9; x++)
{
map.Unicode.ut[x].indexOffset = curroffset;
if (x != 8)
{
loc = (LayOutChunk)layout.chunks[tempint + (x * 2)];
loc.startoffset = curroffset;
loc.endoffset = loc.startoffset + loc.size;
map.BW.BaseStream.Position = loc.startoffset;
map.BW.BaseStream.Write(loc.MS.ToArray(), 0, loc.size);
layout.chunks[tempint + (x * 2)] = loc;
curroffset += loc.size;
}
map.Unicode.ut[x].tableOffset = curroffset;
if (x != 8)
{
LayOutChunk loc2 = (LayOutChunk)layout.chunks[tempint + (x * 2) + 1];
loc2.startoffset = curroffset;
loc2.endoffset = loc2.startoffset + loc.size;
map.BW.BaseStream.Position = loc2.startoffset;
map.BW.BaseStream.Write(loc2.MS.ToArray(), 0, loc2.size);
layout.chunks[tempint + (x * 2) + 1] = loc2;
curroffset += loc2.size;
}
}
Meta tempmatg = (Meta)MetaList[0];
BinaryWriter BWXX = new BinaryWriter(tempmatg.MS);
for (int x = 0; x < 9; x++)
{
BWXX.BaseStream.Position = map.Unicode.ut[x].indexPointerOffset;
BWXX.Write(map.Unicode.ut[x].indexOffset);
BWXX.Write(map.Unicode.ut[x].tableOffset);
}
MetaList[0] = tempmatg;
tempint = layout.FindByType(RawDataContainerType.Crazy);
loc = (LayOutChunk)layout.chunks[tempint];
loc.startoffset = curroffset;
// loc.endoffset+=totalshift;
map.BW.BaseStream.Position = loc.startoffset;
map.BW.BaseStream.Write(loc.MS.ToArray(), 0, loc.size);
map.BW.BaseStream.Position = 344;
map.BW.Write(loc.startoffset);
layout.chunks[tempint] = loc;
curroffset += loc.size;
//////////////////////////////////////
///bitmap raw data
///
int bitmshift = 0;
for (int x = 0; x < MetaList.Count; x++)
{
Meta m = (Meta)MetaList[x];
if (m.rawType == RawDataContainerType.Bitmap)
{
BinaryWriter BW = new BinaryWriter(m.MS);
for (int y = 0; y < m.raw.rawChunks.Count; y++)
{
RawDataChunk r = m.raw.rawChunks[y];
if (r.rawLocation != MapTypes.Internal)
{
int tempintxx = r.offset;
if (r.rawLocation == MapTypes.MPShared)
{
tempintxx |= int.Parse("80000000", NumberStyles.HexNumber);
}
else if (r.rawLocation == MapTypes.SPShared)
{
tempintxx |= int.Parse("C0000000", NumberStyles.HexNumber);
}
else if (r.rawLocation == MapTypes.MainMenu)
{
tempintxx |= int.Parse("40000000", NumberStyles.HexNumber);
}
// writes new pointer to loaded meta
BW.BaseStream.Position = r.pointerMetaOffset;
BW.Write(tempintxx);
BW.BaseStream.Position = r.pointerMetaOffset + 24;
BW.Write(r.size);
continue;
}
int tempintx = curroffset + bitmshift;
// writes new pointer to loaded meta
BW.BaseStream.Position = r.pointerMetaOffset;
BW.Write(tempintx);
BW.BaseStream.Position = r.pointerMetaOffset + 24;
BW.Write(r.size);
// writes raw to map file
map.BW.BaseStream.Position = tempintx;
map.BW.BaseStream.Write(r.MS.ToArray(), 0, r.size);
// write padding
int tempinty = map.Functions.Padding(r.size, 512);
byte[] tempbytes = new byte[tempinty];
map.BW.Write(tempbytes);
bitmshift += r.size + tempinty;
}
MetaList[x] = m;
}
}
curroffset += bitmshift;
tempint = layout.FindByType(RawDataContainerType.MetaIndex);
loc = (LayOutChunk)layout.chunks[tempint];
loc.startoffset = curroffset;
map.BW.BaseStream.Position = loc.startoffset;
map.BW.BaseStream.Write(loc.MS.ToArray(), 0, loc.size);
map.BW.BaseStream.Position = 16;
map.BW.Write(loc.startoffset);
newcount = MetaList.Count;
map.BW.BaseStream.Position = loc.startoffset + 24;
map.BW.Write(newcount);
int tagsoff = map.IndexHeader.tagsOffset - map.MapHeader.indexOffset;
map.PrimaryMagic = map.IndexHeader.constant - (curroffset + 32);
map.SecondaryMagic = map.PrimaryMagic + bspmetasize[0];
// map.SecondaryMagic=map.BR.ReadInt32()-(loc.startoffset+map.MapHeader.metaStart);
int where = curroffset + map.MapHeader.metaStart;
tempcount = 0;
int howfar = 0;
int[] newoffset = new int[MetaList.Count];
int[] newident = new int[MetaList.Count];
for (int x = 0; x < MetaList.Count; x++)
{
Meta m = (Meta)MetaList[x];
int f**k = curroffset + tagsoff + (x * 16);
char[] metatype = m.type.ToCharArray();
Array.Reverse(metatype);
int ident = map.MetaInfo.Ident[0] + (x * 65537);
int offset = where + howfar;
if (x == MetaList.Count - 1)
{
int wherex = curroffset + map.MapHeader.metaStart + 756;
map.BW.BaseStream.Position = wherex;
map.BW.Write(ident);
}
if (m.type == "phmo" | m.type == "coll" | m.type == "spas")
{
int tempoffset = offset;
do
{
string tempss = tempoffset.ToString("X");
char[] tempc = tempss.ToCharArray();
int xxx = tempc.Length;
if (m.padding == tempc[xxx - 1])
{
int diff = tempoffset - offset;
tempb = new byte[diff];
map.BW.BaseStream.Position = offset;
map.BW.Write(tempb);
int tempsize = ((Meta)MetaList[x - 1]).size;
tempsize += diff;
int temploc = f**k - 4;
map.BW.BaseStream.Position = temploc;
map.BW.Write(tempsize);
offset = tempoffset;
howfar += diff;
break;
}
tempoffset++;
}while (temps != null);
}
newoffset[x] = offset;
newident[x] = ident;
int offsetwithmagic = offset + map.SecondaryMagic;
int size = m.size;
map.BW.BaseStream.Position = f**k;
map.BW.Write(metatype);
map.BW.Write(ident);
if (m.type != "sbsp" && m.type != "ltmp")
{
map.BW.Write(offsetwithmagic);
map.BW.Write(size);
howfar += m.size;
map.BW.BaseStream.Position = offset;
map.BW.BaseStream.Write(m.MS.ToArray(), 0, m.size);
}
else
{
int zeroi = 0;
map.BW.Write(zeroi);
map.BW.Write(zeroi);
if (m.type == "sbsp")
{
offset = bspmetaoffset[tempcount];
newoffset[x] = offset;
tempcount++;
}
else
{
continue;
}
}
}
for (int x = 0; x < MetaList.Count; x++)
{
Meta m = (Meta)MetaList[x];
for (int xx = 0; xx < m.items.Count; xx++)
{
Meta.Item i = m.items[xx];
for (int e = 0; e < MetaList.Count; e++)
{
Meta tempm = (Meta)MetaList[e];
if (tempm.name == i.intagname && tempm.type == i.intagtype)
{
i.intag = e;
break;
}
}
if (i.intag != x)
{
continue;
}
switch (i.type)
{
case Meta.ItemType.Ident:
Meta.Ident id = (Meta.Ident)i;
id.ident = -1;
for (int e = 0; e < MetaList.Count; e++)
{
Meta tempm = (Meta)MetaList[e];
if (tempm.name == id.pointstotagname && tempm.type == id.pointstotagtype)
{
id.ident = newident[e];
break;
}
}
map.BW.BaseStream.Position = newoffset[x] + id.offset;
map.BW.Write(id.ident);
break;
case Meta.ItemType.Reflexive:
if (m.type != "sbsp")
{
Meta.Reflexive reflex = (Meta.Reflexive)i;
for (int e = 0; e < MetaList.Count; e++)
{
Meta tempm = (Meta)MetaList[e];
if (reflex.pointstotagname == tempm.name && reflex.pointstotagtype == tempm.type)
{
reflex.pointstoTagIndex = e;
break;
}
}
int newreflex = reflex.translation + newoffset[reflex.pointstoTagIndex] +
map.SecondaryMagic;
map.BW.BaseStream.Position = newoffset[x] + reflex.offset;
map.BW.Write(reflex.chunkcount);
map.BW.Write(newreflex);
}
break;
case Meta.ItemType.String:
Meta.String s = (Meta.String)i;
short stringnum = 0;
byte stringlength = 0;
for (int e = 0; e < strings.Count; e++)
{
if (s.name == (string)strings[e])
{
stringnum = (short)e;
stringlength = (byte)((string)strings[e]).Length;
break;
}
}
map.BW.BaseStream.Position = newoffset[x] + s.offset;
map.BW.Write(stringnum);
map.BW.Write(zero);
map.BW.Write(stringlength);
break;
}
}
}
// totalshift+=howfar;
int tempfilesize = curroffset + map.MapHeader.metaStart + howfar;
// map.MapHeader.fileSize+totalshift+howfar-map.MetaInfo.Size [map.IndexHeader.metaCount-1];
padding = map.Functions.Padding(tempfilesize, 512);
tempb = new byte[padding];
map.BW.BaseStream.Position = tempfilesize;
map.BW.Write(tempb);
tempfilesize += padding;
int olddifference = map.MapHeader.fileSize - (map.MapHeader.indexOffset);
int difference = tempfilesize - (map.MapHeader.indexOffset + totalshift);
int metasize = tempfilesize - (curroffset + map.MapHeader.metaStart);
int combined = bspmetasize[0] + (tempfilesize - curroffset);
map.BW.BaseStream.Position = 8;
map.BW.Write(tempfilesize);
map.BW.BaseStream.Position = 24;
map.BW.Write(metasize);
map.BW.Write(combined);
map.BW.BaseStream.SetLength(tempfilesize);
map.CloseMap();
}
