private static unsafe void LoadColors()
{
Debug.TimeBlock("Initializing Radar");
m_Colors = new short[0x8000];
byte[] buffer = new byte[0x10000];
Stream stream = Engine.FileManager.OpenMUL("RadarCol.mul");
Engine.NativeRead((FileStream)stream, buffer, 0, buffer.Length);
stream.Close();
fixed(byte *numRef = buffer)
{
fixed(short *numRef2 = m_Colors)
{
ushort *numPtr = (ushort *)numRef;
ushort *numPtr2 = (ushort *)numRef2;
int num = 0;
while (num++ < 0x8000)
{
numPtr2++;
numPtr++;
numPtr2[0] = (ushort)(numPtr[0] | 0x8000);
}
for (int i = 0; i < 0x4000; i++)
{
numRef2[i] = numRef2[TextureTable.m_Table[i]];
}
}
}
Debug.EndBlock();
}
public static unsafe void LoadSpeechTable()
{
string path = Engine.FileManager.ResolveMUL("Speech.mul");
if (!File.Exists(path))
{
m_Speech = new SpeechEntry[0];
Debug.Trace("File '{0}' not found, speech will not be encoded.", path);
}
else
{
byte[] buffer = new byte[0x400];
fixed(byte *numRef = buffer)
{
ArrayList list = new ArrayList();
FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read);
int num = 0;
while ((num = Engine.NativeRead(fs, (void *)numRef, 4)) > 0)
{
int idKeyword = numRef[1] | (numRef[0] << 8);
int bytes = numRef[3] | (numRef[2] << 8);
if (bytes > 0)
{
Engine.NativeRead(fs, (void *)numRef, bytes);
list.Add(new SpeechEntry(idKeyword, new string((sbyte *)numRef, 0, bytes)));
}
}
fs.Close();
m_Speech = (SpeechEntry[])list.ToArray(typeof(SpeechEntry));
}
}
}
public unsafe ItemArt()
{
FileStream fs = new FileStream(Engine.FileManager.ResolveMUL(Files.ArtIdx), FileMode.Open, FileAccess.Read, FileShare.Read);
fs.Seek(0x30000L, SeekOrigin.Begin);
fixed(Entry3D *entrydRef = this.m_Index)
{
Engine.NativeRead(fs, (void *)entrydRef, 0x30000);
}
fs.Close();
this.m_Stream = new FileStream(Engine.FileManager.ResolveMUL(Files.ArtMul), FileMode.Open, FileAccess.Read, FileShare.Read);
this.m_Verdata = new FileStream(Engine.FileManager.ResolveMUL(Files.Verdata), FileMode.Open, FileAccess.Read, FileShare.Read);
int num = 0;
Engine.NativeRead(this.m_Verdata, (void *)&num, 4);
if (num > 0)
{
Entry5D[] entrydArray = new Entry5D[num];
fixed(Entry5D *entrydRef2 = entrydArray)
{
Engine.NativeRead(this.m_Verdata, (void *)entrydRef2, num * 20);
for (int k = 0; k < num; k++)
{
Entry5D entryd = entrydRef2[k];
if (((entryd.m_FileID == 4) && (entryd.m_BlockID >= 0x4000)) && (entryd.m_BlockID < 0x8000))
{
entryd.m_BlockID &= 0x3fff;
this.m_Index[entryd.m_BlockID].m_Lookup = entryd.m_Lookup;
this.m_Index[entryd.m_BlockID].m_Length = entryd.m_Length;
this.m_Index[entryd.m_BlockID].m_Extra = entryd.m_Extra;
}
}
}
}
ArtTableEntry[] entries = ArtTable.m_Entries;
for (int i = 0; i < this.m_Translate.Length; i++)
{
this.m_Translate[i] = i;
}
int length = entries.Length;
for (int j = 0; j < length; j++)
{
ArtTableEntry entry = entries[j];
if ((entry.m_OldID >= 0x4000) && (entry.m_NewID >= 0x4000))
{
this.m_Translate[entry.m_NewID & 0x3fff] = entry.m_OldID & 0x3fff;
if (this.m_Index[entry.m_NewID & 0x3fff].m_Lookup == -1)
{
this.m_Index[entry.m_NewID & 0x3fff].m_Lookup = j | -2147483648;
this.m_Index[entry.m_NewID & 0x3fff].m_Length = this.m_Index[entry.m_OldID & 0x3fff].m_Length;
}
}
}
}
protected override unsafe void CoreProcessImage(int width, int height, int stride, ushort *pLine, ushort *pLineEnd, ushort *pImageEnd, int lineDelta, int lineEndDelta)
{
int num = this.m_Land.m_Lookup[this.m_LandID];
if (num != -1)
{
this.m_Land.m_Stream.Seek((long)num, SeekOrigin.Begin);
fixed(byte *numRef = this.m_Buffer)
{
Engine.NativeRead((FileStream)this.m_Land.m_Stream, (void *)numRef, 0x800);
int * numPtr = (int *)numRef;
short *numPtr2 = (short *)pLine;
int num2 = 11;
fixed(int *numRef2 = this.m_Offset)
{
fixed(int *numRef3 = this.m_Length)
{
int *numPtr3 = numRef2;
for (int *numPtr4 = numRef3; --num2 >= 0; numPtr4 += 4)
{
int *numPtr5 = (int *)(pLine + numPtr3[0]);
int num3 = numPtr4[0];
this.m_Hue.CopyPixels((void *)numPtr, (void *)numPtr5, num3 << 1);
numPtr += num3;
pLine += lineEndDelta;
numPtr5 = (int *)(pLine + numPtr3[1]);
num3 = numPtr4[1];
this.m_Hue.CopyPixels((void *)numPtr, (void *)numPtr5, num3 << 1);
numPtr += num3;
pLine += lineEndDelta;
numPtr5 = (int *)(pLine + numPtr3[2]);
num3 = numPtr4[2];
this.m_Hue.CopyPixels((void *)numPtr, (void *)numPtr5, num3 << 1);
numPtr += num3;
pLine += lineEndDelta;
numPtr5 = (int *)(pLine + numPtr3[3]);
num3 = numPtr4[3];
this.m_Hue.CopyPixels((void *)numPtr, (void *)numPtr5, num3 << 1);
numPtr += num3;
pLine += lineEndDelta;
numPtr3 += 4;
}
}
}
}
}
}
protected override unsafe void CoreProcessImage(int width, int height, int stride, ushort *pLine, ushort *pLineEnd, ushort *pImageEnd, int lineDelta, int lineEndDelta)
{
int num = this.m_Textures.m_Lookup[this.m_TextureID];
if (num != -1)
{
int length = (width * height) * 2;
this.m_Textures.m_Stream.Seek((long)(num & 0x7fffffff), SeekOrigin.Begin);
Engine.NativeRead((FileStream)this.m_Textures.m_Stream, this.m_Buffer, 0, length);
fixed(byte *numRef = this.m_Buffer)
{
this.m_Hue.CopyPixels((void *)numRef, (void *)pLine, width * height);
}
}
}
protected override bool CoreLookup()
{
FileStream verdata;
Entry3D entryd = this.m_Items.m_Index[this.m_ItemID];
int lookup = entryd.m_Lookup;
int length = entryd.m_Length;
if (lookup == -1)
{
return(false);
}
bool flag = (length & -2147483648) != 0;
if ((lookup & -2147483648) != 0)
{
lookup &= 0x7fffffff;
ArtTableEntry entry = ArtTable.m_Entries[lookup];
lookup = this.m_Items.m_Index[entry.m_OldID & 0x3fff].m_Lookup;
if (lookup == -1)
{
return(false);
}
}
if (flag)
{
length &= 0x7fffffff;
this.m_Items.m_Verdata.Seek((long)lookup, SeekOrigin.Begin);
verdata = this.m_Items.m_Verdata;
}
else
{
this.m_Items.m_Stream.Seek((long)lookup, SeekOrigin.Begin);
verdata = this.m_Items.m_Stream;
}
if ((this.m_Buffer == null) || (length > this.m_Buffer.Length))
{
this.m_Buffer = new byte[length];
}
if (Engine.NativeRead(verdata, this.m_Buffer, 0, length) != length)
{
return(false);
}
int num4 = this.m_Buffer[4] | (this.m_Buffer[5] << 8);
int num5 = this.m_Buffer[6] | (this.m_Buffer[7] << 8);
return((num4 > 0) && (num5 > 0));
}
public unsafe UnicodeFont(int FontID)
{
this.m_FileName = string.Format("UniFont{0}.mul", (FontID != 0) ? FontID.ToString() : "");
this.m_FontID = FontID;
this.m_Stream = Engine.FileManager.OpenMUL(this.m_FileName);
this.m_Lookup = new int[0x10000];
fixed(int *numRef = this.m_Lookup)
{
Engine.NativeRead((FileStream)this.m_Stream, (void *)numRef, 0x40000);
}
this.m_4Bytes = new byte[4];
this.m_Cache = new FontCache[8];
for (int i = 0; i < this.m_Cache.Length; i++)
{
this.m_Cache[i] = new FontCache(this);
}
}
private unsafe ArrayList ReadFromDisk(int multiID)
{
BinaryReader reader = new BinaryReader(Engine.FileManager.OpenMUL(Files.MultiIdx));
reader.BaseStream.Seek((long)(multiID * 12), SeekOrigin.Begin);
int num = reader.ReadInt32();
int num2 = reader.ReadInt32();
reader.Close();
if (num == -1)
{
return(new ArrayList());
}
Stream stream = Engine.FileManager.OpenMUL(Files.MultiMul);
stream.Seek((long)num, SeekOrigin.Begin);
byte[] buffer = new byte[num2];
Engine.NativeRead((FileStream)stream, buffer, 0, buffer.Length);
stream.Close();
int num3 = num2 / 12;
MultiItem[] c = new MultiItem[num3];
fixed(byte *numRef = buffer)
{
MultiItem *itemPtr = (MultiItem *)numRef;
MultiItem *itemPtr2 = itemPtr + num3;
fixed(MultiItem *itemRef = c)
{
MultiItem *itemPtr3 = itemRef;
while (itemPtr < itemPtr2)
{
itemPtr->ItemID = (short)(itemPtr->ItemID & 0x3fff);
itemPtr->ItemID = (short)(itemPtr->ItemID + 0x4000);
itemPtr3++;
itemPtr++;
itemPtr3[0] = itemPtr[0];
}
}
}
return(new ArrayList(c));
}
public unsafe LandArt()
{
Stream stream = Engine.FileManager.OpenMUL(Files.ArtIdx);
byte[] buffer = new byte[0x30000];
Engine.NativeRead((FileStream)stream, buffer, 0, buffer.Length);
stream.Close();
fixed(byte *numRef = buffer)
{
int *numPtr = (int *)numRef;
int num = 0;
while (num < 0x4000)
{
this.m_Lookup[num++] = numPtr[0];
numPtr += 3;
}
}
this.m_Length = new int[] {
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0x10,
0x11, 0x12, 0x13, 20, 0x15, 0x16, 0x16, 0x15, 20, 0x13, 0x12, 0x11, 0x10, 15, 14, 13,
12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1
};
this.m_Offset = new int[] {
0x15, 20, 0x13, 0x12, 0x11, 0x10, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6,
5, 4, 3, 2, 1, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
10, 11, 12, 13, 14, 15, 0x10, 0x11, 0x12, 0x13, 20, 0x15
};
this.m_Stream = Engine.FileManager.OpenMUL(Files.ArtMul);
ArtTableEntry[] entries = ArtTable.m_Entries;
int length = entries.Length;
for (int i = 0; i < length; i++)
{
ArtTableEntry entry = entries[i];
if (((entry.m_OldID < 0x4000) && (entry.m_NewID < 0x4000)) && (this.m_Lookup[entry.m_OldID & 0x3fff] >= 0))
{
this.m_Lookup[entry.m_NewID & 0x3fff] = this.m_Lookup[entry.m_OldID & 0x3fff];
}
}
}
public unsafe TextureArt()
{
Stream stream = Engine.FileManager.OpenMUL(Files.TexIdx);
byte[] buffer = new byte[0xc000];
Engine.NativeRead((FileStream)stream, buffer, 0, buffer.Length);
stream.Close();
fixed(byte *numRef = buffer)
{
int *numPtr = (int *)numRef;
int index = 0;
do
{
this.m_Lookup[index] = numPtr[0] | (numPtr[2] << 0x1f);
numPtr += 3;
}while (++index < 0x1000);
}
this.m_Stream = Engine.FileManager.OpenMUL(Files.TexMul);
}
private unsafe Tile[] ReadLandBlock(int x, int y)
{
FileStream landData;
int num = 0;
int[][] landBlockRefs = this.m_Patch.LandBlockRefs;
if ((landBlockRefs != null) && (landBlockRefs[x] != null))
{
num = landBlockRefs[x][y];
}
if (num < 0)
{
landData = this.m_Patch.LandData;
if (landData == null)
{
return(new Tile[0x40]);
}
landData.Seek((long)(4 + (0xc4 * ~num)), SeekOrigin.Begin);
}
else
{
landData = this.m_Map;
if (landData == null)
{
return(new Tile[0x40]);
}
landData.Seek((long)(4 + (0xc4 * ((x * this.m_BlockHeight) + y))), SeekOrigin.Begin);
}
Tile[] tileArray = new Tile[0x40];
fixed(Tile *tileRef = tileArray)
{
Engine.NativeRead(landData, (void *)tileRef, 0xc0);
}
return(tileArray);
}
private unsafe HuedTile[][][] ReadStaticBlock(int x, int y)
{
BinaryReader staticLookupReader;
FileStream staticData;
int num = 0;
int[][] staticBlockRefs = this.m_Patch.StaticBlockRefs;
if ((staticBlockRefs != null) && (staticBlockRefs[x] != null))
{
num = staticBlockRefs[x][y];
}
if (num < 0)
{
staticLookupReader = this.m_Patch.StaticLookupReader;
staticData = this.m_Patch.StaticData;
if ((staticLookupReader == null) || (staticData == null))
{
return(this.m_EmptyStaticBlock);
}
staticLookupReader.BaseStream.Seek((long)(12 * ~num), SeekOrigin.Begin);
}
else
{
staticLookupReader = this.m_IndexReader;
staticData = this.m_Statics;
if ((staticLookupReader == null) || (staticData == null))
{
return(this.m_EmptyStaticBlock);
}
staticLookupReader.BaseStream.Seek((long)(((x * this.m_BlockHeight) + y) * 12), SeekOrigin.Begin);
}
int num2 = staticLookupReader.ReadInt32();
int bytes = staticLookupReader.ReadInt32();
if ((num2 < 0) || (bytes <= 0))
{
return(this.m_EmptyStaticBlock);
}
int num4 = bytes / 7;
staticData.Seek((long)num2, SeekOrigin.Begin);
StaticTile[] tileArray = new StaticTile[num4];
fixed(StaticTile *tileRef = tileArray)
{
Engine.NativeRead(staticData, (void *)tileRef, bytes);
if (m_Lists == null)
{
m_Lists = new TileList[8][];
for (int j = 0; j < 8; j++)
{
m_Lists[j] = new TileList[8];
for (int k = 0; k < 8; k++)
{
m_Lists[j][k] = new TileList();
}
}
}
TileList[][] lists = m_Lists;
StaticTile * tilePtr = tileRef;
StaticTile * tilePtr2 = tileRef + num4;
while (tilePtr < tilePtr2)
{
lists[tilePtr->m_X & 7][tilePtr->m_Y & 7].Add((short)((tilePtr->m_ID & 0x3fff) + 0x4000), tilePtr->m_Hue, tilePtr->m_Z);
tilePtr++;
}
HuedTile[][][] tileArray2 = new HuedTile[8][][];
for (int i = 0; i < 8; i++)
{
tileArray2[i] = new HuedTile[8][];
for (int m = 0; m < 8; m++)
{
tileArray2[i][m] = lists[i][m].ToArray();
}
}
return(tileArray2);
}
}
public unsafe Font(int fid)
{
this.m_FontID = fid;
this.m_Cache = new FontCache(this);
this.m_Images = new FontImage[0xe0];
string path = Engine.FileManager.BasePath("Data/QuickLoad/Fonts.mul");
if (!File.Exists(path))
{
Reformat();
}
FileStream input = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read);
BinaryReader reader = new BinaryReader(input);
if (DateTime.FromFileTime(reader.ReadInt64()) != new FileInfo(Engine.FileManager.ResolveMUL(Files.Fonts)).LastWriteTime)
{
reader.Close();
Reformat();
input = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.None);
reader = new BinaryReader(input);
}
input.Seek((long)(12 + (fid * 8)), SeekOrigin.Begin);
int num = reader.ReadInt32();
int bytes = reader.ReadInt32();
input.Seek((long)num, SeekOrigin.Begin);
if ((m_Buffer == null) || (bytes > m_Buffer.Length))
{
m_Buffer = new byte[bytes];
}
fixed(byte *numRef = m_Buffer)
{
Engine.NativeRead(input, (void *)numRef, bytes);
byte *numPtr = numRef;
for (int i = 0; i < 0xe0; i++)
{
int xWidth = numPtr[0];
int yHeight = numPtr[1];
numPtr += 3;
FontImage image = new FontImage(xWidth, yHeight);
int xDelta = image.xDelta;
fixed(byte *numRef2 = image.xyPixels)
{
byte *numPtr2 = numRef2;
int num7 = 0;
while (num7 < yHeight)
{
int num6 = 0;
byte *numPtr3 = numPtr2;
while (num6 < xWidth)
{
*(numPtr3++) = *(numPtr++);
num6++;
}
num7++;
numPtr2 += xDelta;
}
}
this.m_Images[i] = image;
}
int num9 = *((int *)numPtr);
numPtr += 4;
short *numPtr4 = (short *)numPtr;
this.m_Palette = new short[num9];
for (int j = 0; j < num9; j++)
{
numPtr4++;
this.m_Palette[j] = numPtr4[0];
}
numPtr = (byte *)numPtr4;
}
reader.Close();
}
public unsafe Skills()
{
byte[] buffer = new byte[0xc00];
Stream stream = Engine.FileManager.OpenMUL(Files.SkillIdx);
Engine.NativeRead((FileStream)stream, buffer, 0, 0xc00);
stream.Close();
byte[] buffer2 = null;
Stream stream2 = Engine.FileManager.OpenMUL(Files.SkillMul);
buffer2 = new byte[stream2.Length];
Engine.NativeRead((FileStream)stream2, buffer2, 0, buffer2.Length);
stream2.Close();
fixed(byte *numRef = buffer)
{
int *numPtr = (int *)numRef;
fixed(byte *numRef2 = buffer2)
{
this.m_Skills = new Skill[0x100];
int index = 0;
while (index < 0x100)
{
int num2 = numPtr[0];
if (num2 < 0)
{
numPtr += 3;
index++;
}
else
{
StringBuilder builder;
byte * numPtr2 = numRef2 + num2;
int capacity = numPtr[1];
if (capacity < 1)
{
numPtr += 3;
index++;
continue;
}
bool action = *(numPtr2++) != 0;
if (capacity < 1)
{
builder = new StringBuilder();
}
else
{
capacity--;
builder = new StringBuilder(capacity);
for (int i = 0; (i < capacity) && (numPtr2[i] != 0); i++)
{
builder.Append(*((char *)(numPtr2 + i)));
}
}
this.m_Skills[index] = new Skill(index, action, builder.ToString());
numPtr += 3;
index++;
}
}
}
}
string path = Engine.FileManager.ResolveMUL("SkillGrp.mul");
if (!File.Exists(path))
{
this.m_Groups = new SkillGroup[] { new SkillGroup("Skills", 0) };
for (int j = 0; j < 0x100; j++)
{
this.m_Skills[j].Group = this.m_Groups[0];
}
}
else
{
FileStream input = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read);
BinaryReader reader = new BinaryReader(input);
int num5 = reader.ReadInt32();
bool flag2 = false;
if (num5 == -1)
{
flag2 = true;
num5 = reader.ReadInt32();
}
this.m_Groups = new SkillGroup[num5];
this.m_Groups[0] = new SkillGroup("Miscellaneous", 0);
for (int k = 1; k < num5; k++)
{
int num7;
input.Seek((long)((flag2 ? 8 : 4) + ((k - 1) * (flag2 ? 0x22 : 0x11))), SeekOrigin.Begin);
StringBuilder builder2 = new StringBuilder(0x12);
if (flag2)
{
while ((num7 = reader.ReadInt16()) != 0)
{
builder2.Append((char)num7);
}
}
else
{
while ((num7 = reader.ReadByte()) != 0)
{
builder2.Append((char)num7);
}
}
this.m_Groups[k] = new SkillGroup(builder2.ToString(), k);
}
input.Seek((long)((flag2 ? 8 : 4) + ((num5 - 1) * (flag2 ? 0x22 : 0x11))), SeekOrigin.Begin);
for (int m = 0; m < 0x100; m++)
{
Skill skill = this.m_Skills[m];
if (skill == null)
{
break;
}
try
{
int num9 = reader.ReadInt32();
skill.Group = this.m_Groups[num9];
skill.Group.Skills.Add(skill);
}
catch
{
break;
}
}
reader.Close();
}
}
private unsafe void Thread_Start()
{
string path = Engine.FileManager.BasePath(string.Format("Data/QuickLoad/Anim{0}.mul", this.m_Index));
string str2 = Engine.FileManager.ResolveMUL(string.Format("Anim{0}.mul", (this.m_Index == 1) ? "" : this.m_Index.ToString()));
string str3 = Engine.FileManager.ResolveMUL(string.Format("Anim{0}.idx", (this.m_Index == 1) ? "" : this.m_Index.ToString()));
if (!File.Exists(str2) || !File.Exists(str3))
{
if (this.m_Index == 1)
{
this.m_Owner.m_Index = new Entry3D[0];
this.m_Owner.m_Count = 0;
}
else if (this.m_Index == 2)
{
this.m_Owner.m_Index2 = new Entry3D[0];
this.m_Owner.m_Count2 = 0;
}
else if (this.m_Index == 3)
{
this.m_Owner.m_Index3 = new Entry3D[0];
this.m_Owner.m_Count3 = 0;
}
else
{
this.m_Owner.m_Index4 = new Entry3D[0];
this.m_Owner.m_Count4 = 0;
}
}
else
{
if (File.Exists(path))
{
using (FileStream stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read))
{
if (stream.Length >= 0x15L)
{
BinaryReader reader = new BinaryReader(stream);
if (reader.ReadBoolean())
{
DateTime timeStamp = Engine.GetTimeStamp(str2);
DateTime time2 = Engine.GetTimeStamp(str3);
DateTime time3 = DateTime.FromFileTime(reader.ReadInt64());
DateTime time4 = DateTime.FromFileTime(reader.ReadInt64());
if ((timeStamp == time3) && (time2 == time4))
{
int num = reader.ReadInt32();
if (reader.BaseStream.Length >= (0x15 + (num * 12)))
{
Entry3D[] entrydArray = new Entry3D[num];
entrydArray = new Entry3D[num];
fixed(Entry3D *entrydRef = entrydArray)
{
Engine.NativeRead((FileStream)reader.BaseStream, (void *)entrydRef, num * 12);
}
if (this.m_Index == 1)
{
this.m_Owner.m_Index = entrydArray;
this.m_Owner.m_Count = num;
}
else if (this.m_Index == 2)
{
this.m_Owner.m_Index2 = entrydArray;
this.m_Owner.m_Count2 = num;
}
else if (this.m_Index == 3)
{
this.m_Owner.m_Index3 = entrydArray;
this.m_Owner.m_Count3 = num;
}
else
{
this.m_Owner.m_Index4 = entrydArray;
this.m_Owner.m_Count4 = num;
}
return;
}
}
}
}
}
}
using (FileStream stream2 = new FileStream(str3, FileMode.Open, FileAccess.Read, FileShare.Read))
{
int num2 = (int)(stream2.Length / 12L);
Entry3D[] entrydArray2 = new Entry3D[num2];
fixed(Entry3D *entrydRef2 = entrydArray2)
{
Engine.NativeRead(stream2, (void *)entrydRef2, num2 * 12);
using (FileStream stream3 = new FileStream(str2, FileMode.Open, FileAccess.Read, FileShare.Read))
{
BinaryReader reader2 = new BinaryReader(stream3);
Entry3D * entrydPtr = entrydRef2;
Entry3D * entrydPtr2 = entrydRef2 + num2;
while (entrydPtr < entrydPtr2)
{
if (entrydPtr->m_Lookup >= 0)
{
reader2.BaseStream.Seek((long)(entrydPtr->m_Lookup + 0x200), SeekOrigin.Begin);
int num3 = reader2.ReadInt32() & 0xff;
int num4 = 0;
int num5 = -10000;
while (num4 < num3)
{
reader2.BaseStream.Seek((long)((entrydPtr->m_Lookup + 0x204) + (num4 << 2)), SeekOrigin.Begin);
reader2.BaseStream.Seek((long)((entrydPtr->m_Lookup + 0x202) + reader2.ReadInt32()), SeekOrigin.Begin);
int num6 = reader2.ReadInt16();
int num7 = reader2.ReadInt32() >> 0x10;
if ((num7 + num6) > num5)
{
num5 = num7 + num6;
}
num4++;
}
entrydPtr->m_Extra = num3 | (num5 << 8);
}
entrydPtr++;
}
}
using (FileStream stream4 = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.None))
{
BinaryWriter writer = new BinaryWriter(stream4);
writer.Write(false);
writer.Write(Engine.GetTimeStamp(str2).ToFileTime());
writer.Write(Engine.GetTimeStamp(str3).ToFileTime());
writer.Write(num2);
Engine.NativeWrite((FileStream)writer.BaseStream, (void *)entrydRef2, num2 * 12);
writer.Seek(0, SeekOrigin.Begin);
writer.Write(true);
}
}
if (this.m_Index == 1)
{
this.m_Owner.m_Index = entrydArray2;
this.m_Owner.m_Count = num2;
}
else if (this.m_Index == 2)
{
this.m_Owner.m_Index2 = entrydArray2;
this.m_Owner.m_Count2 = num2;
}
else if (this.m_Index == 3)
{
this.m_Owner.m_Index3 = entrydArray2;
this.m_Owner.m_Count3 = num2;
}
else
{
this.m_Owner.m_Index4 = entrydArray2;
this.m_Owner.m_Count4 = num2;
}
}
}
}
