/// <summary> /// Initializes a new instance of the <see cref="MetaItemComparer"/> class. /// </summary> /// <param name="currentForm">The current form.</param> /// <remarks></remarks> public MetaItemComparer(MapForm currentForm) { Map map = currentForm.map; int counter = 0; for (counter = 0; counter < map.MapHeader.fileCount; counter++) { currentForm.SetProgressBar(counter * 100 / map.MapHeader.fileCount); ifpMeta = new Meta(map); manualMeta = new Meta(map); manualMeta.ReadMetaFromMap(counter, false); ifpMeta.ReadMetaFromMap(counter, false); // parse ifp and scan meta with it try { IFPIO io = IFPHashMap.GetIfp(ifpMeta.type, map.HaloVersion); ifpMeta.headersize = io.headerSize; manualMeta.headersize = io.headerSize; try { ifpMeta.scanner.ScanWithIFP(ref io); } catch (Exception ex) { Global.ShowErrorMsg("Broken IFP - " + ifpMeta.type, ex); } manualMeta.scanner.ScanManually(); check(map); } catch (Exception ex) { Globals.Global.ShowErrorMsg(string.Empty, ex); } } currentForm.SetProgressBar(0); }
public void Populate(int iOffset, int iIndexedReflexiveOffset) { this.isNulledOutReflexive = false; System.IO.BinaryReader BR = new System.IO.BinaryReader(meta.MS); int mapMetaOffset = meta.offset; if (this._EntIndex.reflexiveTagType + this._EntIndex.reflexiveTagName != string.Empty) { int tagNum = map.Functions.ForMeta.FindByNameAndTagType(this._EntIndex.reflexiveTagType, this._EntIndex.reflexiveTagName); if (tagNum != -1) { Meta meta2 = new Meta(map); map.OpenMap(MapTypes.Internal); meta2.ReadMetaFromMap(tagNum, true); map.CloseMap(); mapMetaOffset = meta2.offset; this._EntIndex.reflexiveLayer = "root"; } } if (this._EntIndex.reflexiveLayer.ToLower() == "root") this._IndexedReflexiveOffset = mapMetaOffset + this._EntIndex.ReflexiveOffset; else if (this._EntIndex.reflexiveLayer.ToLower() == "oneup") this._IndexedReflexiveOffset = iIndexedReflexiveOffset + this._EntIndex.ReflexiveOffset; /* bool openedMap = false; if (map.isOpen == false) { map.OpenMap(MapTypes.Internal); openedMap = true; } map.BA.Position = iOffset + this.chunkOffset; */ BR.BaseStream.Position = iOffset + this.chunkOffset; this.offsetInMap = meta.offset + iOffset + this.chunkOffset; switch (_ValueType) { case IFPIO.ObjectEnum.Short: { this.Value = (int)BR.ReadInt16(); break; } case IFPIO.ObjectEnum.Int: { this.Value = BR.ReadInt32(); break; } case IFPIO.ObjectEnum.UShort: { this.Value = (int)BR.ReadUInt16(); break; } case IFPIO.ObjectEnum.UInt: { this.Value = (int)BR.ReadUInt32(); break; } case IFPIO.ObjectEnum.Byte: { this.Value = (int)BR.ReadByte(); break; } } UpdateSelectionList(false); /* if (openedMap == true) map.CloseMap(); */ }
/// <summary> /// The over write. /// </summary> /// <param name="map">The map.</param> /// <param name="tagIndex">Index of the tag.</param> /// <param name="newMeta">The new meta.</param> /// <remarks></remarks> public static void OverWrite(Map map, int tagIndex, ref Meta newMeta) { TagIndex = tagIndex; if (map.MetaInfo.TagType[tagIndex] == "sbsp") { MessageBox.Show("Can't OverWrite The Bsp"); return; } newMeta.RelinkReferences(); ArrayList metas = new ArrayList(0); map.OpenMap(MapTypes.Internal); for (int x = 0; x < map.IndexHeader.metaCount; x++) { if (tagIndex == x) { newMeta.type = map.MetaInfo.TagType[x]; newMeta.name = map.FileNames.Name[x]; SizeOfShift = newMeta.size - map.MetaInfo.Size[x]; metas.Add(newMeta); continue; } Meta m = new Meta(map); m.ReadMetaFromMap(x, true); try { IFPIO ifpx = IFPHashMap.GetIfp(m.type, map.HaloVersion); m.headersize = ifpx.headerSize; m.scanner.ScanWithIFP(ref ifpx); // metaScanner.ScanManually(ref m, ref map); metas.Add(m); } catch (System.Exception ex) { Globals.Global.ShowErrorMsg(string.Empty, ex); } } FixReflexives(metas, map); map.CloseMap(); }
/// <summary> /// The save recursive function. /// </summary> /// <param name="meta">The meta.</param> /// <param name="metas">The metas.</param> /// <param name="parsed">The parsed.</param> /// <param name="pb">The pb.</param> /// <param name="percent">The percent.</param> /// <param name="percentsize">The percentsize.</param> /// <remarks></remarks> private void SaveRecursiveFunction( Meta meta, ref ArrayList metas, bool parsed, ToolStripProgressBar pb, float percent, float percentsize) { int wtf = metas.Count; if (meta.items.Count == 0) { return; } float test = meta.items.Count; float currentpercentsize = percentsize / test; Item i = null; try { for (int x = 0; x < meta.items.Count; x++) { i = meta.items[x]; if (i.type != ItemType.Ident) { continue; } float currentpercentage = percent + (currentpercentsize * x); pb.Value = (int)currentpercentage; Application.DoEvents(); Ident id = (Ident)i; if (id.ident == -1) { continue; } if (id.ident == 0) { int tagIndex = Map.Functions.ForMeta.FindByNameAndTagType("sbsp", i.intagname); id.ident = Map.MetaInfo.Ident[tagIndex]; } bool exists = false; for (int e = 0; e < metas.Count; e++) { Meta tempmeta = (Meta)metas[e]; // if (id.pointstotagtype ==tempmeta.type&&id.pointstotagname ==tempmeta.name ) if (id.ident == tempmeta.ident) { exists = true; break; } } if (exists) { continue; } // Drag & drop w/ recursive locks up. num == -1 int num = Map.Functions.ForMeta.FindMetaByID(id.ident); if (num < 0) { MessageBox.Show("ERROR! Not Found!"); } Meta m = new Meta(Map); if (parsed) { m.parsed = true; } m.ReadMetaFromMap(num, false); if (m.type == "ltmp" | m.type == "matg") { continue; } if (m.type == "phmo" | m.type == "coll" | m.type == "jmad") { m.parsed = false; } if (m.type != "jmad") { IFPIO ifp = IFPHashMap.GetIfp(m.type, Map.HaloVersion); m.headersize = ifp.headerSize; m.scanner.ScanWithIFP(ref ifp); } else { m.scanner.ScanManually(); } m.SortItemsByOffset(); metas.Add(m); Application.DoEvents(); SaveRecursiveFunction(m, ref metas, parsed, pb, currentpercentage, currentpercentsize); } } catch (Exception e) { string addOn = "\nin [" + meta.type + "] " + meta.name; if (i.type == ItemType.Ident) { addOn = "\n" + i.description + ", Ident: " + ((Ident)i).ident + addOn; } throw new Exception(e.Message + addOn, e.InnerException); } }
/// <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(); }
/// <summary> /// The load scenery. /// </summary> /// <param name="SceneryList">The scenery list.</param> /// <remarks></remarks> public void LoadScenery(ref List<SceneryInfo> SceneryList) { if (SceneryList == null) { SceneryList = new List<SceneryInfo>(); } else { SceneryList.Clear(); } map.OpenMap(MapTypes.Internal); // Lists all Scenery for (int i = 0; i < map.MapHeader.fileCount; i++) { if (map.MetaInfo.TagType[i] == "scnr") { Meta m = new Meta(map); // Base address of SCNR tag, offset of Scenery Palette pointer (+88) map.BR.BaseStream.Position = map.MetaInfo.Offset[i] + 88; int chunkCount = map.BR.ReadInt32(); int chunkOffset = map.BR.ReadInt32() - map.SecondaryMagic; // Scenery Palette Objects for (int a = 0; a < chunkCount; a++) { SceneryInfo Scenery = new SceneryInfo(); // The Palette Chunk # Scenery.ScenPalNumber = a; // Each chunk is 40 bytes apart map.BR.BaseStream.Position = chunkOffset + a * 40; char[] tagName = map.BR.ReadChars(4); Scenery.ScenTagNumber = map.Functions.ForMeta.FindMetaByID(map.BR.ReadInt32()); try { // Retrieve the Model HLMT tag from the Scenery tag (+56) map.BR.BaseStream.Position = map.MetaInfo.Offset[Scenery.ScenTagNumber] + 56; Scenery.HlmtTagNumber = map.Functions.ForMeta.FindMetaByID(map.BR.ReadInt32()); // Base address of HLMT tag, offset of MODE pointer (+4) map.BR.BaseStream.Position = map.MetaInfo.Offset[Scenery.HlmtTagNumber] + 4; Scenery.ModelTagNumber = map.Functions.ForMeta.FindMetaByID(map.BR.ReadInt32()); if (Scenery.ModelTagNumber != -1) { m.ReadMetaFromMap(Scenery.ModelTagNumber, false); Scenery.Model = new ParsedModel(ref m); } else { Scenery.Model = null; } ParsedModel.DisplayedInfo.LoadDirectXTexturesAndBuffers(ref device, ref Scenery.Model); string[] s = map.FileNames.Name[Scenery.ScenTagNumber].Split('\\'); Scenery.Name = s[s.Length - 1]; Scenery.TagPath = map.FileNames.Name[Scenery.ScenTagNumber]; Scenery.TagType = map.MetaInfo.TagType[Scenery.ScenTagNumber]; SceneryList.Add(Scenery); } catch { } } break; } } map.CloseMap(); }
private void tsExternalReferenceAdd_Click(object sender, EventArgs e) { TreeNode tn = treeViewTagReflexives.SelectedNode; reflexiveData rd = (reflexiveData)tn.Tag; if (rd.reflexive == null) { MessageBox.Show("Not a reflexive!"); return; } WinMetaEditor.references refs = new WinMetaEditor.references(); if (rd.inTagNumber == this.meta.TagIndex) { refs.ident = this.meta.offset + rd.baseOffset + this.meta.magic; refs.offset = rd.baseOffset; refs.tagIndex = this.meta.TagIndex; refs.tagName = this.meta.name; refs.tagType = this.meta.type; } else { refs.tagIndex = map.Functions.ForMeta.FindMetaByOffset(rd.baseOffset); Meta m = new Meta(map); map.OpenMap(MapTypes.Internal); m.ReadMetaFromMap(refs.tagIndex, true); map.CloseMap(); refs.ident = rd.baseOffset + m.magic; refs.offset = rd.baseOffset; refs.tagName = m.name; refs.tagType = m.type; m.Dispose(); } refs.chunkCount = rd.chunkCount; refs.size = rd.reflexive.chunkSize; refs.name = rd.reflexive.name; // Check for duplicates & remove List<WinMetaEditor.references> refList = ((WinMetaEditor)this.ParentForm).reflexiveReferences; for (int i = 0; i < refList.Count; i++) { if (refList[i].ident == refs.ident) refList.RemoveAt(i--); } // Always add to top of list refList.Insert(0, refs); }
/// <summary> /// The ce shader info. /// </summary> /// <param name="TagIndex">The TagIndex.</param> /// <param name="map">The map.</param> /// <remarks></remarks> public void CEShaderInfo(int TagIndex, Map map) { this.TagIndex = TagIndex; if (this.TagIndex == -1) { return; } this.shaderName = map.FileNames.Name[this.TagIndex]; map.OpenMap(MapTypes.Internal); int mainid = 0; int primarydetail = -1; int secondarydetail = -1; int micro = -1; switch (map.MetaInfo.TagType[TagIndex]) { case "schi": map.BR.BaseStream.Position = map.MetaInfo.Offset[TagIndex] + 228; mainid = map.BR.ReadInt32(); break; case "soso": map.BR.BaseStream.Position = map.MetaInfo.Offset[TagIndex] + 176; mainid = map.BR.ReadInt32(); break; case "sgla": map.BR.BaseStream.Position = map.MetaInfo.Offset[TagIndex] + 356; mainid = map.BR.ReadInt32(); break; case "scex": map.BR.BaseStream.Position = map.MetaInfo.Offset[TagIndex] + 900; mainid = map.BR.ReadInt32(); break; case "senv": map.BR.BaseStream.Position = map.MetaInfo.Offset[TagIndex] + 148; mainid = map.BR.ReadInt32(); map.BR.BaseStream.Position = map.MetaInfo.Offset[TagIndex] + 180; this.primarydetailuscale = map.BR.ReadSingle(); this.primarydetailvscale = this.primarydetailuscale; this.primarydetailwscale = 1; map.BR.BaseStream.Position = map.MetaInfo.Offset[TagIndex] + 196; primarydetail = map.BR.ReadInt32(); map.BR.BaseStream.Position = map.MetaInfo.Offset[TagIndex] + 200; this.secondarydetailuscale = map.BR.ReadSingle(); this.secondarydetailvscale = this.secondarydetailuscale; this.secondarydetailwscale = 1; map.BR.BaseStream.Position = map.MetaInfo.Offset[TagIndex] + 216; secondarydetail = map.BR.ReadInt32(); map.BR.BaseStream.Position = map.MetaInfo.Offset[TagIndex] + 248; this.microdetailuscale = map.BR.ReadSingle(); this.microdetailvscale = this.secondarydetailuscale; this.microdetailwscale = 1; map.BR.BaseStream.Position = map.MetaInfo.Offset[TagIndex] + 264; micro = map.BR.ReadInt32(); map.BR.BaseStream.Position = map.MetaInfo.Offset[TagIndex] + 40; byte alphatest = map.BR.ReadByte(); int test = alphatest & 1; if (test != 0) { this.Alpha = AlphaType.AlphaTest; } break; case "swat": map.BR.BaseStream.Position = map.MetaInfo.Offset[TagIndex] + 88; mainid = map.BR.ReadInt32(); break; case "smet": map.BR.BaseStream.Position = map.MetaInfo.Offset[TagIndex] + 88; mainid = map.BR.ReadInt32(); break; } map.CloseMap(); mainid = map.Functions.ForMeta.FindMetaByID(mainid); primarydetail = map.Functions.ForMeta.FindMetaByID(primarydetail); secondarydetail = map.Functions.ForMeta.FindMetaByID(secondarydetail); micro = map.Functions.ForMeta.FindMetaByID(micro); if (mainid == -1) { return; } if (map.MetaInfo.external[mainid]) { map.OpenMap(MapTypes.Bitmaps); } else { map.OpenMap(MapTypes.Internal); } Meta tempmeta = new Meta(map); tempmeta.ReadMetaFromMap(mainid, false); map.CloseMap(); ParsedBitmap pm = new ParsedBitmap(ref tempmeta, map); // Attempt to load LOD2, if that fails, load LOD0 try { this.MainBitmap = pm.FindChunkAndDecode(0, 2, 0, ref tempmeta, map, 0, 0); } catch { this.MainBitmap = pm.FindChunkAndDecode(0, 0, 0, ref tempmeta, map, 0, 0); } this.MainName = map.FileNames.Name[mainid]; if (primarydetail != -1) { if (map.MetaInfo.external[primarydetail]) { map.OpenMap(MapTypes.Bitmaps); } else { map.OpenMap(MapTypes.Internal); } tempmeta = new Meta(map); tempmeta.ReadMetaFromMap(primarydetail, false); map.CloseMap(); pm = new ParsedBitmap(ref tempmeta, map); this.primarydetailBitmap = pm.FindChunkAndDecode(0, 0, 0, ref tempmeta, map, 0, 0); this.primarydetailName = map.FileNames.Name[primarydetail]; } if (secondarydetail != -1) { if (map.MetaInfo.external[secondarydetail]) { map.OpenMap(MapTypes.Bitmaps); } else { map.OpenMap(MapTypes.Internal); } tempmeta = new Meta(map); tempmeta.ReadMetaFromMap(secondarydetail, false); map.CloseMap(); pm = new ParsedBitmap(ref tempmeta, map); this.secondarydetailBitmap = pm.FindChunkAndDecode(0, 0, 0, ref tempmeta, map, 0, 0); this.secondarydetailName = map.FileNames.Name[secondarydetail]; } if (micro != -1) { if (map.MetaInfo.external[micro]) { map.OpenMap(MapTypes.Bitmaps); } else { map.OpenMap(MapTypes.Internal); } tempmeta = new Meta(map); tempmeta.ReadMetaFromMap(micro, false); map.CloseMap(); pm = new ParsedBitmap(ref tempmeta, map); this.microdetailBitmap = pm.FindChunkAndDecode(0, 0, 0, ref tempmeta, map, 0, 0); this.microdetailName = map.FileNames.Name[micro]; } }
/// <summary> /// The get map bitmap meta. /// </summary> /// <param name="map">The map.</param> /// <returns></returns> /// <remarks></remarks> public static Meta GetMapBitmapMeta(Map map) { Meta m = null; map.BR.BaseStream.Position = map.MetaInfo.Offset[3] + 920; int tempc2 = map.BR.ReadInt32(); int tempr2 = map.BR.ReadInt32() - map.SecondaryMagic; map.BR.BaseStream.Position = tempr2 + 16; int tempc = map.BR.ReadInt32(); int tempr = map.BR.ReadInt32() - map.SecondaryMagic; if (tempc != 0) { map.BR.BaseStream.Position = tempr + 8; int temptag = map.Functions.ForMeta.FindMetaByID(map.BR.ReadInt32()); m = new Meta(map); m.ReadMetaFromMap(temptag, false); } else { map.BR.BaseStream.Position = tempr2 + 8; tempc = map.BR.ReadInt32(); if (tempc != 0) { tempr = map.BR.ReadInt32() - map.SecondaryMagic; map.BR.BaseStream.Position = tempr + 12; int temptag = map.Functions.ForMeta.FindMetaByID(map.BR.ReadInt32()); m = new Meta(map); m.ReadMetaFromMap(temptag, false); } } return m; }
/// <summary> /// The fix system link tool strip menu item_ click. /// </summary> /// <param name="sender">The sender.</param> /// <param name="e">The e.</param> /// <remarks></remarks> private void fixSystemLinkToolStripMenuItem_Click(object sender, EventArgs e) { int count = 0; List<int> ids = new List<int>(); for (int x = 0; x < map.IndexHeader.metaCount; x++) { switch (map.MetaInfo.TagType[x]) { case "bipd": case "bloc": case "ctrl": case "jpt!": case "mach": case "scen": case "ssce": case "vehi": ids.Add(map.MetaInfo.Ident[x]); count++; break; case "eqip": case "garb": case "proj": ids.Add(map.MetaInfo.Ident[x]); ids.Add(map.MetaInfo.Ident[x]); count += 2; break; case "weap": ids.Add(map.MetaInfo.Ident[x]); ids.Add(map.MetaInfo.Ident[x]); ids.Add(map.MetaInfo.Ident[x]); count += 3; break; } } map.OpenMap(MapTypes.Internal); Meta m = new Meta(map); m.ReadMetaFromMap(3, true); try { IFPIO io = IFPHashMap.GetIfp("scnr", map.HaloVersion); m.headersize = io.headerSize; m.scanner.ScanWithIFP(ref io); MetaSplitter metasplit = new MetaSplitter(); metasplit.SplitWithIFP(ref io, ref m, map); for (int x = 0; x < metasplit.Header.Chunks[0].ChunkResources.Count; x++) { // Offset 984 = [SCNR] Predicted Resources if (metasplit.Header.Chunks[0].ChunkResources[x].offset == 984) { MetaSplitter.SplitReflexive reflex = (MetaSplitter.SplitReflexive)metasplit.Header.Chunks[0].ChunkResources[x]; // count = # of chunks incl. added/removed // reflex.Chunks.Count = # of chunks listed in Predicted Resources (?) int diff = count - reflex.Chunks.Count; // Add/Remove chunks to match the difference for (int y = 0; y < diff; y++) { MetaSplitter.SplitReflexive MetaChunk = new MetaSplitter.SplitReflexive(); MetaChunk.splitReflexiveType = MetaSplitter.SplitReflexive.SplitReflexiveType.Chunk; MetaChunk.chunksize = 4; MetaChunk.MS = new MemoryStream(4); reflex.Chunks.Add(MetaChunk); } for (int y = 0; y < reflex.Chunks.Count; y++) { BinaryWriter BW = new BinaryWriter(reflex.Chunks[y].MS); BW.Write(ids[y]); } metasplit.Header.Chunks[0].ChunkResources[x] = reflex; break; } } Meta newmeta = MetaBuilder.BuildMeta(metasplit, map); map.OpenMap(MapTypes.Internal); map.ChunkTools.Add(newmeta); map.CloseMap(); // info.OpenMap(MapTypes.Internal); // info.BW.BaseStream.Position = m.offset + r.translation; // for (int x = 0; x < count; x++) // { // info.BW.Write(ids[x]); // } // info.CloseMap(); map = Map.Refresh(map); MessageBox.Show("Done"); } catch (Exception ex) { Global.ShowErrorMsg(string.Empty, ex); } }
/// <summary> /// The load spawns. /// </summary> /// <remarks></remarks> public void LoadSpawns() { spawns = new SpawnLoads(map, bsp, render.device); SpawnModel = new List<ParsedModel>(); spawnmodelindex = new int[bsp.Spawns.Spawn.Count]; BoundingBoxModel = new Mesh[bsp.Spawns.Spawn.Count]; map.OpenMap(MapTypes.Internal); int blockCount = 0; int scenCount = 0; for (int x = 0; x < bsp.Spawns.Spawn.Count; x++) { // Display loading information if (x % 7 == 0) { this.label3.Text = ".:Loading Spawns [" + x.ToString() + "/" + bsp.Spawns.Spawn.Count.ToString() + "]:."; // Every 5 updates, refresh whole window, otherwise just update the label if (x % 35 == 0) Application.DoEvents(); else this.label3.Refresh(); } // This is the only way I could think of doing it right now... // Used for saving Obstacle & Scenery to their original places if (bsp.Spawns.Spawn[x] is SpawnInfo.ObstacleSpawn) { ((SpawnInfo.ObstacleSpawn)bsp.Spawns.Spawn[x]).BlocNumber = blockCount++; } else if (bsp.Spawns.Spawn[x] is SpawnInfo.ScenerySpawn) { ((SpawnInfo.ScenerySpawn)bsp.Spawns.Spawn[x]).ScenNumber = scenCount++; } if (bsp.Spawns.Spawn[x] is SpawnInfo.BoundingBoxSpawn) { BoundingBoxModel[x] = loadBoundingBoxSpawn(bsp.Spawns.Spawn[x]); continue; } #region CameraSpawn if (bsp.Spawns.Spawn[x] is SpawnInfo.CameraSpawn) { BoundingBoxModel[x] = loadCameraSpawn(bsp.Spawns.Spawn[x]); continue; } #endregion #region LightSpawn if (bsp.Spawns.Spawn[x] is SpawnInfo.LightSpawn) { SpawnInfo.LightSpawn tempbox; tempbox = bsp.Spawns.Spawn[x] as SpawnInfo.LightSpawn; tempbox.LightInfo = new HaloLight(tempbox.ModelTagNumber, map); bsp.Spawns.Spawn[x] = tempbox; BoundingBoxModel[x] = Mesh.Cylinder(render.device, 0.5f, 0.0f, 1f, 10, 10); if (render.lighting) { render.device.Lights[HaloLightCount].Type = LightType.Point; render.device.Lights[HaloLightCount].Position = new Vector3(tempbox.X, tempbox.Y, tempbox.Z); render.device.Lights[HaloLightCount].Direction = new Vector3( -tempbox.Yaw, -tempbox.Pitch, -tempbox.Roll); render.device.Lights[HaloLightCount].Range = 10f; // render.device.Lights[HaloLightCount].=0.5f; // render.device.Lights[HaloLightCount].p = 1.0f; render.device.Lights[HaloLightCount].Falloff = 1.0f; render.device.Lights[HaloLightCount].Attenuation0 = 1.0f; render.device.Lights[HaloLightCount].Diffuse = Color.FromArgb( tempbox.LightInfo.r, tempbox.LightInfo.g, tempbox.LightInfo.b); render.device.Lights[HaloLightCount].Update(); render.device.Lights[HaloLightCount].Enabled = true; } HaloLightCount++; continue; } #endregion #region SoundSpawn if (bsp.Spawns.Spawn[x] is SpawnInfo.SoundSpawn) { BoundingBoxModel[x] = loadSoundSpawn(bsp.Spawns.Spawn[x]); continue; } #endregion #region SpawnZone if (bsp.Spawns.Spawn[x] is SpawnInfo.SpawnZone) { BoundingBoxModel[x] = loadSpawnZone(bsp.Spawns.Spawn[x]); continue; } #endregion SpawnInfo.RotationSpawn tempspawn = bsp.Spawns.Spawn[x] as SpawnInfo.RotationSpawn; #region ScanForExistingModels bool found = false; for (int xx = 0; xx < x; xx++) { SpawnInfo.RotationSpawn tempspawn2 = bsp.Spawns.Spawn[xx] as SpawnInfo.RotationSpawn; if (bsp.Spawns.Spawn[xx] is SpawnInfo.BoundingBoxSpawn) { continue; } if (tempspawn.ModelTagNumber == tempspawn2.ModelTagNumber) { BoundingBoxModel[x] = BoundingBoxModel[xx]; spawnmodelindex[x] = spawnmodelindex[xx]; bsp.Spawns.Spawn[x].bbXDiff = bsp.Spawns.Spawn[xx].bbXDiff; bsp.Spawns.Spawn[x].bbYDiff = bsp.Spawns.Spawn[xx].bbYDiff; bsp.Spawns.Spawn[x].bbZDiff = bsp.Spawns.Spawn[xx].bbZDiff; found = true; break; } } if (found) { continue; } #endregion #region ReadSpawnMeta Meta m = new Meta(map); if (tempspawn.ModelTagNumber == -1) { MessageBox.Show("Test"); } m.ReadMetaFromMap(tempspawn.ModelTagNumber, false); #endregion #region DirectXModel ParsedModel pm = new ParsedModel(ref m); // pm.PermutationString=pm.hlmt.Permutations[pm.hlmt.FindPermutationByBaseClass, ParsedModel.DisplayedInfo.LoadDirectXTexturesAndBuffers(ref render.device, ref pm); SpawnModel.Add(pm); spawnmodelindex[x] = SpawnModel.Count - 1; m.Dispose(); #endregion #region BoundingBox float boxwidth = pm.BoundingBox.MaxX - pm.BoundingBox.MinX; float boxheight = pm.BoundingBox.MaxY - pm.BoundingBox.MinY; float boxdepth = pm.BoundingBox.MaxZ - pm.BoundingBox.MinZ; try { BoundingBoxModel[x] = Mesh.Box(render.device, boxwidth, boxheight, boxdepth); } catch (Exception ex) { Global.ShowErrorMsg("Failure to create Bounding Box Mesh for " + pm.name + "\nWidth : " + boxwidth.ToString() + "\nHeight: " + boxheight.ToString() + "\nLength: " + boxdepth.ToString(), ex); } // Used for fixing position of bounding boxes bsp.Spawns.Spawn[x].bbXDiff = pm.BoundingBox.MaxX + pm.BoundingBox.MinX; bsp.Spawns.Spawn[x].bbYDiff = pm.BoundingBox.MaxY + pm.BoundingBox.MinY; bsp.Spawns.Spawn[x].bbZDiff = pm.BoundingBox.MaxZ + pm.BoundingBox.MinZ; #endregion } if (render.device.DeviceCaps.RasterCaps.SupportsFogTable && bsp.sky.fogenabled && bsp.sky.fog.FogThickness != 0) { int a = (int)(bsp.sky.fog.A * 255); int r = (int)(bsp.sky.fog.R * 255); int g = (int)(bsp.sky.fog.G * 255); int b = (int)(bsp.sky.fog.B * 255); render.device.RenderState.FogColor = Color.FromArgb(a, r, g, b); render.device.RenderState.FogStart = bsp.sky.fog.Start; render.device.RenderState.FogEnd = bsp.sky.fog.End; render.device.RenderState.FogDensity = bsp.sky.fog.FogThickness; // bsp.sky.fog.FogThickness; render.device.RenderState.FogTableMode = FogMode.Linear; render.device.RenderState.FogEnable = true; } // render.device.RenderState.FogVertexMode = FogMode.Linear; /* this.label3.Text = ".:Loading Weapons Collection:."; this.ResumeLayout(); this.SuspendLayout(); #region LoadAllWeaponsForCollectionChangeBox WeaponsList.Clear(); // Lists all weapons for (int i = 0; i < map.MetaInfo.TagType.Length; i++) if ((map.MetaInfo.TagType[i] == "itmc") || (map.MetaInfo.TagType[i] == "vehc")) { CollectionInfo Weapon = new CollectionInfo(); Meta m = new Meta(map); m.ReadMetaFromMap(i, map, false); Weapon.ItmcTagNumber = i; // Base address of ITMC tag, offset of WEAP pointer (+20) map.BR.BaseStream.Position = map.MetaInfo.Offset[Weapon.ItmcTagNumber] + 20; Weapon.WeapTagNumber = map.Functions.Meta.FindMetaByID(map.BR.ReadInt32(), map); if (Weapon.WeapTagNumber == -1) { continue; } // Base address of WEAP tag, offset of HLMT pointer (+56) map.BR.BaseStream.Position = map.MetaInfo.Offset[Weapon.WeapTagNumber] + 56; Weapon.HlmtTagNumber = map.Functions.Meta.FindMetaByID(map.BR.ReadInt32(), map); if (Weapon.HlmtTagNumber != -1) { // Base address of HLMT tag, offset of MODE pointer (+4) map.BR.BaseStream.Position = map.MetaInfo.Offset[Weapon.HlmtTagNumber] + 4; Weapon.ModelTagNumber = map.Functions.Meta.FindMetaByID(map.BR.ReadInt32(), map); m.ReadMetaFromMap(Weapon.ModelTagNumber, map, false); Weapon.Model = new ParsedModel(ref m, map); Raw.ParsedModel.DisplayedInfo.LoadDirectXTexturesAndBuffers(ref render.device, ref Weapon.Model); // Store names into Weapon Weapon.TagPath = map.FileNames.Name[i]; Weapon.TagType = map.MetaInfo.TagType[i]; int xx = map.Functions.Meta.FindByNameAndTagType(Weapon.TagType, Weapon.TagPath, map); string[] NameSplit = map.FileNames.Name[xx].Split('\\'); Weapon.Name = NameSplit[NameSplit.Length - 1]; Weapon.Name = Weapon.Name.Replace('_', ' '); WeaponsList.Add(Weapon); } } #endregion #region LoadAllObjectsForObstacleAndSceneryChangeBox SceneryList.Clear(); ObstacleList.Clear(); // Lists all Scenery & Obstacles for (int i = 0; i < map.MapHeader.fileCount; i++) { if ((map.MetaInfo.TagType[i] == "scnr")) { Meta m = new Meta(map); //m.ReadMetaFromMap(i, map, false); // Base address of SCNR tag, offset of Scenery Palette pointer (+88) map.BR.BaseStream.Position = map.MetaInfo.Offset[i] + 88; int chunkCount = map.BR.ReadInt32(); int chunkOffset = map.BR.ReadInt32() - map.SecondaryMagic; #region Scenery Palette Objects // Scenery Palette Objects for (int a = 0; a < chunkCount; a++) { SceneryInfo Scenery = new SceneryInfo(); // The Palette Chunk # Scenery.ScenPalNumber = a; // Each chunk is 40 bytes apart map.BR.BaseStream.Position = chunkOffset + a * 40; char[] tagName = map.BR.ReadChars(4); Scenery.ScenTagNumber = map.Functions.Meta.FindMetaByID(map.BR.ReadInt32(), map); try { // Retrieve the Model HLMT tag from the Scenery tag (+56) map.BR.BaseStream.Position = map.MetaInfo.Offset[Scenery.ScenTagNumber] + 56; Scenery.HlmtTagNumber = map.Functions.Meta.FindMetaByID(map.BR.ReadInt32(), map); // Base address of HLMT tag, offset of MODE pointer (+4) map.BR.BaseStream.Position = map.MetaInfo.Offset[Scenery.HlmtTagNumber] + 4; Scenery.ModelTagNumber = map.Functions.Meta.FindMetaByID(map.BR.ReadInt32(), map); if (Scenery.ModelTagNumber != -1) { m.ReadMetaFromMap(Scenery.ModelTagNumber, map, false); Scenery.Model = new ParsedModel(ref m, map); } else Scenery.Model = null; Raw.ParsedModel.DisplayedInfo.LoadDirectXTexturesAndBuffers(ref render.device, ref Scenery.Model); string[] s = map.FileNames.Name[Scenery.ScenTagNumber].Split('\\'); Scenery.Name = s[s.Length - 1]; Scenery.TagPath = map.FileNames.Name[Scenery.ScenTagNumber]; Scenery.TagType = map.MetaInfo.TagType[Scenery.ScenTagNumber]; SceneryList.Add(Scenery); } catch { } } #endregion // Base address of SCNR tag, offset of Sound Scenery Palette pointer (+224) map.BR.BaseStream.Position = map.MetaInfo.Offset[i] + 224; chunkCount = map.BR.ReadInt32(); chunkOffset = map.BR.ReadInt32() - map.SecondaryMagic; #region Sound Scenery Palette Objects // Scenery Palette Objects for (int a = 0; a < chunkCount; a++) { SceneryInfo Sound = new SceneryInfo(); // The Palette Chunk # Sound.ScenPalNumber = a; // Each chunk is 40 bytes apart map.BR.BaseStream.Position = chunkOffset + a * 40; char[] tagName = map.BR.ReadChars(4); Sound.ScenTagNumber = map.Functions.Meta.FindMetaByID(map.BR.ReadInt32(), map); if (Sound.ScenTagNumber != -1) { string[] s = map.FileNames.Name[Sound.ScenTagNumber].Split('\\'); Sound.Name = s[s.Length - 1]; Sound.TagPath = map.FileNames.Name[Sound.ScenTagNumber]; Sound.TagType = map.MetaInfo.TagType[Sound.ScenTagNumber]; SoundsList.Add(Sound); } } #endregion // Base address of SCNR tag, offset of Crate Palette pointer (+816) map.BR.BaseStream.Position = map.MetaInfo.Offset[i] + 816; chunkCount = map.BR.ReadInt32(); chunkOffset = map.BR.ReadInt32() - map.SecondaryMagic; #region Crate Palette Objects // Crate (Obstacle) Palette Objects for (int a = 0; a < chunkCount; a++) { SceneryInfo Obstacle = new SceneryInfo(); // The Palette Chunk # Obstacle.ScenPalNumber = a; // Each chunk is 40 bytes apart map.BR.BaseStream.Position = chunkOffset + a * 40; char[] tagName = map.BR.ReadChars(4); Obstacle.ScenTagNumber = map.Functions.Meta.FindMetaByID(map.BR.ReadInt32(), map); if (Obstacle.ScenTagNumber != -1) { // Retrieve the Model HLMT tag from the Scenery tag (+56) map.BR.BaseStream.Position = map.MetaInfo.Offset[Obstacle.ScenTagNumber] + 56; Obstacle.HlmtTagNumber = map.Functions.Meta.FindMetaByID(map.BR.ReadInt32(), map); // Base address of HLMT tag, offset of MODE pointer (+4) map.BR.BaseStream.Position = map.MetaInfo.Offset[Obstacle.HlmtTagNumber] + 4; Obstacle.ModelTagNumber = map.Functions.Meta.FindMetaByID(map.BR.ReadInt32(), map); m.ReadMetaFromMap(Obstacle.ModelTagNumber, map, false); Obstacle.Model = new ParsedModel(ref m, map); Raw.ParsedModel.DisplayedInfo.LoadDirectXTexturesAndBuffers(ref render.device, ref Obstacle.Model); string[] s = map.FileNames.Name[Obstacle.ScenTagNumber].Split('\\'); Obstacle.Name = s[s.Length - 1]; Obstacle.TagPath = map.FileNames.Name[Obstacle.ScenTagNumber]; Obstacle.TagType = map.MetaInfo.TagType[Obstacle.ScenTagNumber]; ObstacleList.Add(Obstacle); } } #endregion break; } } #endregion */ map.CloseMap(); }
/// <summary> /// The add. /// </summary> /// <param name="tagIndex">Index of the tag.</param> /// <param name="metasplit">The metasplit.</param> /// <remarks></remarks> public void Add(int tagIndex, MetaSplitter metasplit) { // TagIndex - Global Variable this.TagIndex = tagIndex; ArrayList metas = new ArrayList(0); for (int x = 0; x < map.IndexHeader.metaCount; x++) { // sender.setProgressBar(x / map.IndexHeader.metaCount); Meta m = new Meta(map); m.ReadMetaFromMap(x, true); // Read meta layout of TAG from .ENT file IFPIO ifpx = IFPHashMap.GetIfp(m.type, map.HaloVersion); m.headersize = ifpx.headerSize; if (m.type == "sbsp") { } else { // anything but "sbsp" m.scanner.ScanWithIFP(ref ifpx); // metaScanner.ScanManually(ref m, ref map); } metas.Add(m); } // sender.setProgressBar(0); Meta targetTag = (Meta)metas[tagIndex]; Meta tempm = MetaBuilder.BuildMeta(metasplit, map); // (Meta) metas[TagIndex]; metas[tagIndex] = tempm; // ((Meta)metas[TagIndex]).RelinkReferences(map); SizeOfShift = tempm.size - targetTag.size; // Map IS already open? I guess it's a safety check. map.OpenMap(MapTypes.Internal); FixReflexives(metas); map.CloseMap(); }
/// <summary> /// The add. /// </summary> /// <param name="meta">The meta.</param> /// <remarks></remarks> public void Add(Meta meta) { TagIndex = meta.TagIndex; ArrayList metas = new ArrayList(0); for (int x = 0; x < meta.Map.IndexHeader.metaCount; x++) { if (TagIndex == x) { metas.Add(meta); continue; } Meta m = new Meta(meta.Map); m.ReadMetaFromMap(x, true); IFPIO ifpx = IFPHashMap.GetIfp(m.type, meta.Map.HaloVersion); m.headersize = ifpx.headerSize; if (m.type == "sbsp") { } else { m.scanner.ScanWithIFP(ref ifpx); } // metaScanner.ScanManually(ref m, ref meta.Map); metas.Add(m); } int diff = meta.size - meta.Map.MetaInfo.Size[TagIndex]; SizeOfShift = diff; meta.Map.OpenMap(MapTypes.Internal); FixReflexives(metas); meta.Map.CloseMap(); }
/// <summary> /// The to dir. /// </summary> /// <param name="map">The map.</param> /// <param name="path">The path.</param> /// <remarks></remarks> public static void ToDir(Map map, string path) { if (path[path.Length - 1] != '\\') { path += "\\"; } Results = new Hashtable(); List<Meta> metas = new List<Meta>(); for (int x = 0; x < map.IndexHeader.metaCount; x++) { Meta m = new Meta(map); m.ReadMetaFromMap(x, true); m.scanner.ScanManually(); metas.Add(m); } for (int x = 0; x < metas.Count; x++) { Meta m = metas[x]; DissectMeta(ref m); metas[x] = m; } }
/// <summary> /// The recursively check metas. /// </summary> /// <param name="tn">The tn.</param> /// <remarks></remarks> private void RecursivelyCheckMetas(TreeNode tn) { foreach (TreeNode n in tn.Nodes) { if (n.Checked == false) { continue; } if (n.Text.IndexOf('.') == -1) { RecursivelyCheckMetas(n); continue; } StatusLabel1.Text = "Processing: " + n.Text + "..."; Application.DoEvents(); int id = 0; for (int xx = 0; xx < map.IndexHeader.metaCount; xx++) { string[] tempn = map.FileNames.Name[xx].Split('\\'); string tempi = tempn[tempn.Length - 1] + "." + map.MetaInfo.TagType[xx]; int i = map.FileNames.Name[xx].LastIndexOf('\\'); string tempp = string.Empty; if (i != -1) { tempp = map.FileNames.Name[xx].Substring(0, i) + "\\"; } if (n.Text == tempi && n.Tag.ToString() == map.FileNames.Name[xx] + "." + map.MetaInfo.TagType[xx]) { id = xx; break; } } if (map.MetaInfo.TagType[id] == "ltmp") { Meta templtmp = new Meta(map); templtmp.TagIndex = id; templtmp.type = map.MetaInfo.TagType[id]; templtmp.name = map.FileNames.Name[id]; templtmp.offset = 0; templtmp.size = 0; templtmp.ident = map.MetaInfo.Ident[id]; templtmp.MS = new MemoryStream(0); templtmp.rawType = RawDataContainerType.Empty; templtmp.items = new List<Meta.Item>(); MetaList.Add(templtmp); continue; } if (map.MetaInfo.TagType[id] == "ugh!") { continue; } if (map.MetaInfo.TagType[id] == "snd!") { // dontscanraw = true; } Meta m = new Meta(map); m.ReadMetaFromMap(id, false); if (m.type != "sbsp" && m.type != "jmad") { IFPIO ifp = IFPHashMap.GetIfp(m.type, map.HaloVersion); // m.parsed = true; m.headersize = ifp.headerSize; m.scanner.ScanWithIFP(ref ifp); } else { m.scanner.ScanManually(); } switch (m.type.Trim()) { case "matg": matg = m; break; case "sncl": sncl = m; break; case "spk!": spk = m; break; case "scnr": scnr = m; break; case "sky": this.Skies.Add(m); skycount++; break; default: MetaList.Add(m); count++; break; } RecursivelyCheckMetas(n); } }
/// <summary> /// The map builder. /// </summary> /// <param name="metas">The metas.</param> /// <param name="layout">The layout.</param> /// <param name="map">The map.</param> /// <param name="addsounds">The addsounds.</param> /// <remarks></remarks> public void MapBuilder(ArrayList metas, ref MapLayout layout, Map map, bool addsounds) { string[] filestofix = new string[0]; if (map.MapHeader.mapType != MapTypes.Internal) { if ( MessageBox.Show( "This map is an external resource and updating it will effect all the other maps. Continue?", string.Empty, MessageBoxButtons.OKCancel) == DialogResult.Cancel) { return; } OpenFileDialog openfiles = new OpenFileDialog(); openfiles.Multiselect = true; openfiles.Filter = "Halo 2 Map (*.map)| *.map"; openfiles.ShowDialog(); filestofix = openfiles.FileNames; } if (addsounds == false) { for (int x = 0; x < metas.Count; x++) { if (((Meta)metas[x]).type == "snd!") { metas.RemoveAt(x); x--; } } } int totalshift = 0; ArrayList strings = new ArrayList(); for (int x = 0; x < metas.Count; x++) { Meta m = (Meta)metas[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 (Array.IndexOf(map.Strings.Name, iii.name) == -1) { if (strings.IndexOf(iii.name) == -1) { strings.Add(iii.name); } } } } } map.OpenMap(MapTypes.Internal); Meta ughmeta = new Meta(map); ughmeta.ReadMetaFromMap(map.IndexHeader.metaCount - 1, true); IFPIO ifp = IFPHashMap.GetIfp("ugh!", map.HaloVersion); ughmeta.rawType = RawDataContainerType.Empty; ughmeta.headersize = ifp.headerSize; ughmeta.scanner.ScanWithIFP(ref ifp); #region get model info int tempint = layout.FindByType(RawDataContainerType.Model); LayOutChunk loc = (LayOutChunk)layout.chunks[tempint]; #endregion #region sound raw data int sndshift = 0; int sndpermcount = 0; int sndchoicecount = 0; int sndchunk1count = 0; int addedsoundnames = 0; MetaSplitter metasplit = new MetaSplitter(); metasplit.SplitWithIFP(ref ifp, ref ughmeta, map); map.OpenMap(MapTypes.Internal); int soundnameindex = 0; int soundpermutationindex = 0; int soundchoiceindex = 0; int soundchunk1index = 0; for (int x = 0; x < metasplit.Header.Chunks[0].ChunkResources.Count; x++) { if (metasplit.Header.Chunks[0].ChunkResources[x].type == Meta.ItemType.Reflexive) { Meta.Reflexive r = (Meta.Reflexive)metasplit.Header.Chunks[0].ChunkResources[x]; if (r.offset == 16) { soundnameindex = x; } if (r.offset == 32) { soundpermutationindex = x; } if (r.offset == 40) { soundchoiceindex = x; } if (r.offset == 64) { soundchunk1index = x; } } } MetaSplitter.SplitReflexive soundnamereflexive = metasplit.Header.Chunks[0].ChunkResources[soundnameindex] as MetaSplitter.SplitReflexive; MetaSplitter.SplitReflexive soundpermutationreflexive = metasplit.Header.Chunks[0].ChunkResources[soundpermutationindex] as MetaSplitter.SplitReflexive; MetaSplitter.SplitReflexive soundchoicereflexive = metasplit.Header.Chunks[0].ChunkResources[soundchoiceindex] as MetaSplitter.SplitReflexive; MetaSplitter.SplitReflexive soundchunk1reflexive = metasplit.Header.Chunks[0].ChunkResources[soundchunk1index] as MetaSplitter.SplitReflexive; for (int x = 0; x < metas.Count; x++) { Meta m = (Meta)metas[x]; if (m.rawType == RawDataContainerType.Sound) { Sound tempsound = (Sound)m.raw; BinaryWriter BW = new BinaryWriter(m.MS); int y = 0; // writes new index to meta BW.BaseStream.Position = 8; ushort temppermindex = (ushort)(map.ugh.Permutations.Count + sndpermcount); BW.Write(temppermindex); for (int e = 0; e < tempsound.Permutations.Length; e++) { for (int ee = 0; ee < tempsound.Permutations[e].choicecount; ee++) { int nindex = map.ugh.SoundNames.IndexOf(tempsound.Permutations[e].Choices[ee].Name); if (nindex == -1) { int nindex2 = strings.IndexOf(tempsound.Permutations[e].Choices[ee].Name); if (nindex2 == -1) { strings.Add(tempsound.Permutations[e].Choices[ee].Name); nindex2 = strings.Count - 1; } nindex2 += map.Strings.Name.Length; map.ugh.SoundNames.Add(tempsound.Permutations[e].Choices[ee].Name); tempsound.Permutations[e].Choices[ee].NameIndex = (ushort)(map.ugh.SoundNames.Count - 1); MetaSplitter.SplitReflexive tempss = new MetaSplitter.SplitReflexive(); tempss.chunksize = soundnamereflexive.Chunks[0].chunksize; tempss.MS = new MemoryStream(tempss.chunksize); BinaryWriter soundnameBW = new BinaryWriter(tempss.MS); soundnameBW.BaseStream.Position = 0; byte z = 0; soundnameBW.Write((ushort)nindex2); soundnameBW.Write(z); soundnameBW.Write((byte)tempsound.Permutations[e].Choices[ee].Name.Length); soundnamereflexive.Chunks.Add(tempss); addedsoundnames++; } else { tempsound.Permutations[e].Choices[ee].NameIndex = (ushort)nindex; } } } // cycle through permutations and write them for (int e = 0; e < tempsound.Permutations.Length; e++) { MetaSplitter.SplitReflexive tempss = new MetaSplitter.SplitReflexive(); tempss.chunksize = soundpermutationreflexive.Chunks[0].chunksize; tempss.MS = new MemoryStream(tempss.chunksize); BinaryWriter permBW = new BinaryWriter(tempss.MS); permBW.BaseStream.Position = 0; permBW.Write(tempsound.Permutations[e].unknown1); permBW.Write(tempsound.Permutations[e].unknown2); tempsound.Permutations[e].choiceindex = (ushort)(map.ugh.Choices.Count + sndchoicecount); permBW.Write(tempsound.Permutations[e].choiceindex); permBW.Write(tempsound.Permutations[e].choicecount); soundpermutationreflexive.Chunks.Add(tempss); for (int ee = 0; ee < tempsound.Permutations[e].choicecount; ee++) { MetaSplitter.SplitReflexive tempsss = new MetaSplitter.SplitReflexive(); tempsss.chunksize = soundchoicereflexive.Chunks[0].chunksize; tempsss.MS = new MemoryStream(tempsss.chunksize); BinaryWriter choiceBW = new BinaryWriter(tempsss.MS); choiceBW.BaseStream.Position = 0; choiceBW.Write(tempsound.Permutations[e].Choices[ee].NameIndex); choiceBW.Write(tempsound.Permutations[e].Choices[ee].unknown1); choiceBW.Write(tempsound.Permutations[e].Choices[ee].unknown2); choiceBW.Write(tempsound.Permutations[e].Choices[ee].unknown3); tempsound.Permutations[e].Choices[ee].soundindex = (ushort)(map.ugh.SoundChunks1.Count + sndchunk1count); choiceBW.Write(tempsound.Permutations[e].Choices[ee].soundindex); choiceBW.Write(tempsound.Permutations[e].Choices[ee].soundcount); soundchoicereflexive.Chunks.Add(tempsss); for (int eee = 0; eee < tempsound.Permutations[e].Choices[ee].soundcount; eee++) { RawDataChunk r = m.raw.rawChunks[y]; // write raw to map int tempintx = loc.startoffset + sndshift; 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); sndshift += r.size + tempinty; y++; MetaSplitter.SplitReflexive tempssss = new MetaSplitter.SplitReflexive(); tempssss.chunksize = soundchoicereflexive.Chunks[0].chunksize; tempssss.MS = new MemoryStream(tempssss.chunksize); BinaryWriter sndchnk1BW = new BinaryWriter(tempssss.MS); sndchnk1BW.BaseStream.Position = 0; sndchnk1BW.Write(tempintx); sndchnk1BW.Write(tempsound.Permutations[e].Choices[ee].SoundChunks1[eee].size); sndchnk1BW.Write(tempsound.Permutations[e].Choices[ee].SoundChunks1[eee].unknown1); sndchnk1BW.Write(tempsound.Permutations[e].Choices[ee].SoundChunks1[eee].unknown2); soundchunk1reflexive.Chunks.Add(tempssss); sndchunk1count++; } sndchoicecount++; } sndpermcount++; } metas[x] = m; } } totalshift += sndshift; if (sndshift > 0) { metasplit.Header.Chunks[0].ChunkResources[soundnameindex] = soundnamereflexive; metasplit.Header.Chunks[0].ChunkResources[soundpermutationindex] = soundpermutationreflexive; metasplit.Header.Chunks[0].ChunkResources[soundchoiceindex] = soundchoicereflexive; metasplit.Header.Chunks[0].ChunkResources[soundchunk1index] = soundchunk1reflexive; ughmeta = MetaBuilder.BuildMeta(metasplit, map); } metas.Add(ughmeta); #endregion #region model raw data int modeshift = 0; loc.startoffset += totalshift; loc.endoffset = loc.startoffset + loc.size; map.BW.BaseStream.Position = loc.startoffset; map.BW.BaseStream.Write(loc.MS.ToArray(), 0, loc.size); for (int x = 0; x < metas.Count; x++) { Meta m = (Meta)metas[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]; int tempintx = loc.endoffset + 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; } metas[x] = m; } } loc.size += modeshift; loc.endoffset = loc.startoffset + loc.size; layout.chunks[tempint] = loc; totalshift += modeshift; #endregion #region bsp raw tempint = layout.FindByType(RawDataContainerType.BSP); loc = (LayOutChunk)layout.chunks[tempint]; loc.startoffset += totalshift; int tempint2 = layout.FindByType(RawDataContainerType.BSPMeta); LayOutChunk loc2 = (LayOutChunk)layout.chunks[tempint2]; uint bsprawsize = (uint)loc.size; uint oldbspsize = (uint)loc.size; int bspshift = 0; int bspmagic = map.BSP.sbsp[0].magic; int newmagicreflexive = bspmagic + loc2.startoffset; bool found = false; Meta tempbspmeta = new Meta(map); bool foundbsptoimport = false; for (int x = 0; x < metas.Count; x++) { Meta m = (Meta)metas[x]; if (m.type == "sbsp") { foundbsptoimport = true; bsprawsize = 0; BinaryWriter BW = new BinaryWriter(m.MS); int[] tempoff = new int[m.raw.rawChunks.Count]; 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] = loc.startoffset + (int)bsprawsize; // MessageBox.Show("Test"); // 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 = loc.startoffset + bsprawsize; 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); bsprawsize += (uint)(r.size + tempinty); } totalshift += (int)(bsprawsize - oldbspsize); bspshift += (int)(bsprawsize - oldbspsize); loc.size = (int)bsprawsize; loc.endoffset = (int)(loc.startoffset + bsprawsize); layout.chunks[tempint] = loc; loc2.MS = m.MS; loc2.size = m.size; loc2.endoffset = loc2.startoffset + m.size; layout.chunks[tempint2] = loc2; bspmagic = m.magic; newmagicreflexive = bspmagic + m.offset; tempbspmeta = m; metas.RemoveAt(x); break; } if (x == metas.Count - 1) { map.BW.BaseStream.Position = loc.startoffset; map.BW.BaseStream.Write(loc.MS.ToArray(), 0, loc.size); loc.endoffset = loc.startoffset + loc.size; layout.chunks[tempint] = loc; } } #endregion #region weather raw data int weathershift = 0; tempint = layout.FindByType(RawDataContainerType.Weather); if (tempint != -1) { loc = (LayOutChunk)layout.chunks[tempint]; loc.startoffset += totalshift; map.BW.BaseStream.Position = loc.startoffset; map.BW.BaseStream.Write(loc.MS.ToArray(), 0, loc.size); } else { loc = new LayOutChunk(0); loc.rawType = RawDataContainerType.Weather; int tx = layout.FindByType(RawDataContainerType.BSP); loc.startoffset = ((LayOutChunk)layout.chunks[tx]).endoffset; loc.size = 0; } for (int x = 0; x < metas.Count; x++) { Meta m = (Meta)metas[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]; int tempintx = loc.startoffset + loc.size + 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; } metas[x] = m; } } loc.size += weathershift; loc.endoffset = loc.startoffset + loc.size; if (tempint == -1) { if (weathershift > 0) { layout.chunks.Add(loc); } ; } else { layout.chunks[tempint] = loc; } totalshift += weathershift; #endregion #region decr raw data int decrshift = 0; tempint = layout.FindByType(RawDataContainerType.DECR); if (tempint != -1) { loc = (LayOutChunk)layout.chunks[tempint]; loc.startoffset += totalshift; map.BW.BaseStream.Position = loc.startoffset; map.BW.BaseStream.Write(loc.MS.ToArray(), 0, loc.size); } else { loc = new LayOutChunk(0); loc.rawType = RawDataContainerType.DECR; int tx = layout.FindByType(RawDataContainerType.Weather); if (tx == -1) { tx = layout.FindByType(RawDataContainerType.BSP); } loc.startoffset = ((LayOutChunk)layout.chunks[tx]).endoffset; loc.size = 0; } for (int x = 0; x < metas.Count; x++) { Meta m = (Meta)metas[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]; int tempintx = loc.startoffset + loc.size + 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; } metas[x] = m; } } loc.size += decrshift; loc.endoffset = loc.startoffset + loc.size; if (tempint == -1) { if (decrshift > 0) { layout.chunks.Add(loc); } ; } else { layout.chunks[tempint] = loc; } totalshift += decrshift; #endregion #region prtm raw data int prtmshift = 0; tempint = layout.FindByType(RawDataContainerType.PRTM); if (tempint != -1) { loc = (LayOutChunk)layout.chunks[tempint]; loc.startoffset += totalshift; map.BW.BaseStream.Position = loc.startoffset; map.BW.BaseStream.Write(loc.MS.ToArray(), 0, loc.size); } else { loc = new LayOutChunk(0); loc.rawType = RawDataContainerType.PRTM; int tx = layout.FindByType(RawDataContainerType.DECR); if (tx == -1) { tx = layout.FindByType(RawDataContainerType.Weather); if (tx == -1) { tx = layout.FindByType(RawDataContainerType.BSP); } } loc.startoffset = ((LayOutChunk)layout.chunks[tx]).endoffset; loc.size = 0; } for (int x = 0; x < metas.Count; x++) { Meta m = (Meta)metas[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]; int tempintx = loc.startoffset + loc.size + 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; } metas[x] = m; } } loc.size += prtmshift; loc.endoffset = loc.startoffset + loc.size; if (tempint == -1) { if (prtmshift > 0) { layout.chunks.Add(loc); } ; } else { layout.chunks[tempint] = loc; } totalshift += prtmshift; #endregion #region jmad raw data int jmadshift = 0; tempint = layout.FindByType(RawDataContainerType.Animation); if (tempint != -1) { loc = (LayOutChunk)layout.chunks[tempint]; loc.startoffset += totalshift; map.BW.BaseStream.Position = loc.startoffset; map.BW.BaseStream.Write(loc.MS.ToArray(), 0, loc.size); } else { loc = new LayOutChunk(0); loc.rawType = RawDataContainerType.Animation; int tx = layout.FindByType(RawDataContainerType.PRTM); if (tx == -1) { tx = layout.FindByType(RawDataContainerType.DECR); if (tx == -1) { tx = layout.FindByType(RawDataContainerType.Weather); if (tx == -1) { tx = layout.FindByType(RawDataContainerType.BSP); } } } loc.startoffset = ((LayOutChunk)layout.chunks[tx]).endoffset; loc.size = 0; } for (int x = 0; x < metas.Count; x++) { Meta m = (Meta)metas[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]; int tempintx = loc.startoffset + loc.size + 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; } metas[x] = m; } } loc.size += jmadshift; loc.endoffset = loc.startoffset + loc.size; if (tempint == -1) { if (jmadshift > 0) { layout.chunks.Add(loc); } ; } else { layout.chunks[tempint] = loc; } totalshift += jmadshift; #endregion #region bsp meta data uint bspmetasize = 0; int bspmetashift = 0; uint oldbspmetasize = (uint)map.BSP.sbsp[0].size; tempint = layout.FindByType(RawDataContainerType.BSPMeta); loc = (LayOutChunk)layout.chunks[tempint]; loc.startoffset += totalshift; loc.endoffset += totalshift; bspmetasize = (uint)loc.size; int tempinteger = layout.FindByType(RawDataContainerType.MetaData); loc2 = (LayOutChunk)layout.chunks[tempinteger]; int tempintxx = loc.startoffset; if (foundbsptoimport == false) { int tempint3 = layout.FindByType(RawDataContainerType.BSP); LayOutChunk loc3 = (LayOutChunk)layout.chunks[tempint3]; BinaryWriter BWZ = new BinaryWriter(loc.MS); for (int w = 0; w < loc3.rawPieces.Count; w++) { RawInfoChunk r = (RawInfoChunk)loc3.rawPieces[w]; BWZ.BaseStream.Position = r.offsetOfPointer - map.BSP.sbsp[0].offset; r.offset += (uint)(modeshift + sndshift); BWZ.Write(r.offset); } layout.chunks[tempint3] = loc3; } #endregion Should this be here or lower, didn't really look ???? // writes new pointer and magic and size to scenario meta BinaryWriter BWX = new BinaryWriter(loc2.MS); int tempoffx = map.MetaInfo.Offset[3] - map.MapHeader.metaStart - map.MapHeader.indexOffset + map.BSP.sbsp[0].pointerOffset; BWX.BaseStream.Position = tempoffx; BWX.Write(tempintxx); BWX.Write(loc.size); BWX.Write(newmagicreflexive); // writes raw to map file int bspoffset = tempintxx; map.BW.BaseStream.Position = tempintxx; map.BW.BaseStream.Write(loc.MS.ToArray(), 0, loc.size); // write padding layout.chunks[tempint] = loc; totalshift += (int)(bspmetasize - oldbspmetasize); bspmetashift = (int)(bspmetasize - oldbspmetasize); if (bspmetashift < 0) { bspmetashift = 0; } else { byte[] tempbytesxxxx = new byte[bspmetashift]; map.BW.Write(tempbytesxxxx); totalshift += bspmetashift; } #region stringnames1 tempint = layout.FindByType(RawDataContainerType.Strings1); loc = (LayOutChunk)layout.chunks[tempint]; loc.startoffset += totalshift; int tempoldsize = map.MapHeader.scriptReferenceCount * 128; int oldpadding = map.Functions.Padding(tempoldsize, 512); int tempnewsrsize = strings.Count * 128; map.BW.BaseStream.Position = loc.startoffset; map.BW.BaseStream.Write(loc.MS.ToArray(), 0, tempoldsize); byte[] tempb = new byte[tempnewsrsize]; map.BW.BaseStream.Write(tempb, 0, tempnewsrsize); int padding = map.Functions.Padding(tempoldsize + tempnewsrsize, 512); tempb = new byte[padding]; map.BW.BaseStream.Write(tempb, 0, padding); for (int x = 0; x < strings.Count; x++) { map.BW.BaseStream.Position = loc.startoffset + tempoldsize + (x * 128); char[] tempc = ((String)strings[x]).ToCharArray(); map.BW.Write(tempc); } loc.size += -oldpadding + tempnewsrsize + padding; loc.endoffset = loc.startoffset + loc.size; totalshift += -oldpadding + tempnewsrsize + padding; map.BW.BaseStream.Position = 352; map.BW.Write(loc.startoffset); int newcount = map.MapHeader.scriptReferenceCount + strings.Count; map.BW.Write(newcount); layout.chunks[tempint] = loc; #endregion // MessageBox.Show("Test"); #region stringsindex tempint = layout.FindByType(RawDataContainerType.StringsIndex); loc = (LayOutChunk)layout.chunks[tempint]; loc.startoffset += totalshift; tempoldsize = map.MapHeader.scriptReferenceCount * 4; oldpadding = map.Functions.Padding(tempoldsize, 512); tempnewsrsize = strings.Count * 4; map.BW.BaseStream.Position = loc.startoffset; map.BW.BaseStream.Write(loc.MS.ToArray(), 0, tempoldsize); tempb = new byte[tempnewsrsize]; map.BW.BaseStream.Write(tempb, 0, tempnewsrsize); padding = map.Functions.Padding(tempoldsize + tempnewsrsize, 512); tempb = new byte[padding]; map.BW.BaseStream.Write(tempb, 0, padding); int temporary = map.MapHeader.sizeOfScriptReference; for (int x = 0; x < strings.Count; x++) { map.BW.BaseStream.Position = loc.startoffset + tempoldsize + (x * 4); map.BW.Write(temporary); temporary += ((String)strings[x]).Length + 1; } loc.size += -oldpadding + tempnewsrsize + padding; loc.endoffset = loc.startoffset + loc.size; totalshift += -oldpadding + tempnewsrsize + padding; map.BW.BaseStream.Position = 364; map.BW.Write(loc.startoffset); layout.chunks[tempint] = loc; #endregion #region strings2 tempint = layout.FindByType(RawDataContainerType.Strings2); loc = (LayOutChunk)layout.chunks[tempint]; loc.startoffset += totalshift; tempoldsize = map.MapHeader.sizeOfScriptReference; oldpadding = map.Functions.Padding(tempoldsize, 512); tempnewsrsize = temporary - map.MapHeader.sizeOfScriptReference; map.BW.BaseStream.Position = loc.startoffset; map.BW.BaseStream.Write(loc.MS.ToArray(), 0, tempoldsize); tempb = new byte[tempnewsrsize]; map.BW.BaseStream.Write(tempb, 0, tempnewsrsize); padding = map.Functions.Padding(tempoldsize + tempnewsrsize, 512); tempb = new byte[padding]; map.BW.BaseStream.Write(tempb, 0, padding); temporary = loc.startoffset + map.MapHeader.sizeOfScriptReference; byte zero = 0; for (int x = 0; x < strings.Count; x++) { map.BW.BaseStream.Position = temporary; char[] h = ((String)strings[x]).ToCharArray(); map.BW.Write(h); map.BW.Write(zero); temporary += ((String)strings[x]).Length + 1; } loc.size += -oldpadding + tempnewsrsize + padding; loc.endoffset = loc.startoffset + loc.size; totalshift += -oldpadding + tempnewsrsize + padding; int bleh = loc.size - padding; map.BW.BaseStream.Position = 360; map.BW.Write(bleh); map.BW.BaseStream.Position = 368; map.BW.Write(loc.startoffset); layout.chunks[tempint] = loc; #endregion #region file names tempint = layout.FindByType(RawDataContainerType.FileNames); loc = (LayOutChunk)layout.chunks[tempint]; loc.startoffset += totalshift; tempoldsize = map.MapHeader.fileNamesSize; oldpadding = map.Functions.Padding(tempoldsize, 512); map.BW.BaseStream.Position = loc.startoffset; map.BW.BaseStream.Write( loc.MS.ToArray(), 0, tempoldsize - map.FileNames.Length[map.IndexHeader.metaCount - 1] - 1); temporary = loc.startoffset + tempoldsize - map.FileNames.Length[map.IndexHeader.metaCount - 1] - 1; zero = 0; for (int x = 0; x < metas.Count; x++) { map.BW.BaseStream.Position = temporary; char[] h = ((Meta)metas[x]).name.ToCharArray(); map.BW.Write(h); map.BW.Write(zero); temporary += ((Meta)metas[x]).name.Length + 1; } tempnewsrsize = temporary - loc.startoffset - tempoldsize; padding = map.Functions.Padding(tempoldsize + tempnewsrsize, 512); tempb = new byte[padding]; map.BW.BaseStream.Write(tempb, 0, padding); loc.size += -oldpadding + tempnewsrsize + padding; loc.endoffset = loc.startoffset + loc.size; totalshift += -oldpadding + tempnewsrsize + padding; map.BW.BaseStream.Position = 704; newcount = map.MapHeader.fileCount + metas.Count - 1; map.BW.Write(newcount); map.BW.Write(loc.startoffset); int hhh = temporary - loc.startoffset; map.BW.Write(hhh); layout.chunks[tempint] = loc; #endregion #region files index tempint = layout.FindByType(RawDataContainerType.FileNamesIndex); loc = (LayOutChunk)layout.chunks[tempint]; loc.startoffset += totalshift; tempoldsize = map.MapHeader.fileCount * 4; oldpadding = map.Functions.Padding(tempoldsize, 512); tempnewsrsize = (metas.Count * 4) - 4; map.BW.BaseStream.Position = loc.startoffset; map.BW.BaseStream.Write(loc.MS.ToArray(), 0, tempoldsize); tempb = new byte[tempnewsrsize]; map.BW.BaseStream.Write(tempb, 0, tempnewsrsize); padding = map.Functions.Padding(tempoldsize + tempnewsrsize, 512); tempb = new byte[padding]; map.BW.BaseStream.Write(tempb, 0, padding); temporary = map.MapHeader.fileNamesSize - map.FileNames.Length[map.IndexHeader.metaCount - 1] - 1; for (int x = 0; x < metas.Count; x++) { map.BW.BaseStream.Position = loc.startoffset + tempoldsize + (x * 4) - 4; map.BW.Write(temporary); temporary += ((Meta)metas[x]).name.Length + 1; } loc.size += -oldpadding + tempnewsrsize + padding; loc.endoffset = loc.startoffset + loc.size; totalshift += -oldpadding + tempnewsrsize + padding; map.BW.BaseStream.Position = 716; map.BW.Write(loc.startoffset); layout.chunks[tempint] = loc; tempint = layout.FindByType(RawDataContainerType.UnicodeNamesIndex); for (int x = 0; x < 8; x++) { loc = (LayOutChunk)layout.chunks[tempint + (x * 2)]; loc.startoffset += totalshift; loc.endoffset += totalshift; map.BW.BaseStream.Position = loc.startoffset; map.BW.BaseStream.Write(loc.MS.ToArray(), 0, loc.size); layout.chunks[tempint + (x * 2)] = loc; loc2 = (LayOutChunk)layout.chunks[tempint + (x * 2) + 1]; loc2.startoffset += totalshift; loc2.endoffset += totalshift; map.BW.BaseStream.Position = loc2.startoffset; map.BW.BaseStream.Write(loc2.MS.ToArray(), 0, loc2.size); layout.chunks[tempint + (x * 2) + 1] = loc2; } tempint = layout.FindByType(RawDataContainerType.MetaData); for (int x = 0; x < 9; x++) { loc = (LayOutChunk)layout.chunks[tempint]; BinaryWriter BW = new BinaryWriter(loc.MS); BW.BaseStream.Position = map.MetaInfo.Offset[0] - map.MapHeader.metaStart - map.MapHeader.indexOffset + map.Unicode.ut[x].indexPointerOffset; map.Unicode.ut[x].indexOffset += totalshift; map.Unicode.ut[x].tableOffset += totalshift; BW.Write(map.Unicode.ut[x].indexOffset); BW.Write(map.Unicode.ut[x].tableOffset); layout.chunks[tempint] = loc; } tempint = layout.FindByType(RawDataContainerType.Crazy); loc = (LayOutChunk)layout.chunks[tempint]; loc.startoffset += totalshift; 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; #endregion int bitmshift = 0; tempint = layout.FindByType(RawDataContainerType.Bitmap); loc = (LayOutChunk)layout.chunks[tempint]; loc.startoffset += totalshift; map.BW.BaseStream.Position = loc.startoffset; map.BW.BaseStream.Write(loc.MS.ToArray(), 0, loc.size); int bitmappad = 0; for (int x = 0; x < metas.Count; x++) { Meta m = (Meta)metas[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]; int tempintx = loc.startoffset + loc.size + bitmshift; // 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); bitmshift += r.size + tempinty; bitmappad = tempinty; } metas[x] = m; } } totalshift += bitmshift; loc.size += bitmshift; loc.endoffset = loc.startoffset + loc.size; layout.chunks[tempint] = loc; tempint = layout.FindByType(RawDataContainerType.MetaIndex); loc = (LayOutChunk)layout.chunks[tempint]; loc.startoffset += totalshift; loc.endoffset += totalshift; tempint = layout.FindByType(RawDataContainerType.MetaData); loc2 = (LayOutChunk)layout.chunks[tempint]; loc2.startoffset += totalshift; loc2.endoffset += totalshift; map.BW.BaseStream.Position = loc.startoffset; map.BW.BaseStream.Write(loc.MS.ToArray(), 0, loc.size); map.BW.BaseStream.Position = loc2.startoffset; // Changed this line to include Min(MS.Length) as it would pad past end of file. ??? map.BW.BaseStream.Write(loc2.MS.ToArray(), 0, Math.Min(loc2.size, (int)loc2.MS.Length)); map.BW.BaseStream.Position = 16; map.BW.Write(loc.startoffset); newcount = metas.Count + map.IndexHeader.metaCount - 1; map.BW.BaseStream.Position = loc.startoffset + 24; map.BW.Write(newcount); map.BR.BaseStream.Position = map.IndexHeader.tagsOffset + totalshift + 8; map.SecondaryMagic = map.BR.ReadInt32() - (loc.startoffset + map.MapHeader.metaStart); int where = map.MetaInfo.Offset[map.IndexHeader.metaCount - 1] + totalshift; int howfar = 0; // Recreate Meta Table Index int metaTableStart = map.IndexHeader.tagsOffset + ((map.IndexHeader.metaCount - 1) * 16); for (int x = 0; x < metas.Count; x++) { Meta m = (Meta)metas[x]; int metaOffset = metaTableStart + totalshift + (x * 16); char[] metatype = m.type.ToCharArray(); Array.Reverse(metatype); // Create Ident Values? int ident = map.MetaInfo.Ident[map.IndexHeader.metaCount - 1] + (x * 65537); int offset = where + howfar; if (x == metas.Count - 1) { int wherex = map.MetaInfo.Offset[0] + totalshift + 756; map.BW.BaseStream.Position = wherex; map.BW.Write(ident); } // I believe this aligns the folowing tags on a boundry of 16 as is // very important for all HAVOK tags & data #region alignment fix if (m.type == "phmo" | m.type == "coll" | m.type == "spas") { int tempoffset = offset; do { // convert our 'tempoffset', which is our offset increased until the padding lines up, to a hex string tempss = tempoffset.ToString("X"); char[] tempc = tempss.ToCharArray(); // We use the last hex digit to see if our padding is right (0-15) for 16 byte alignment? if (m.padding == tempc[tempc.Length - 1]) { // If we had to add bytes to get our offset to line up, figure out how many and pad // the end of the last tag int diff = tempoffset - offset; tempb = new byte[diff]; map.BW.BaseStream.Position = offset; map.BW.Write(tempb); int tempsize; if (x == 0) { // The first tag has no tag before it, so we pad the MetaInfo instead tempsize = map.MetaInfo.Size[map.IndexHeader.metaCount - 2]; // int temploc = map.IndexHeader.tagsOffset + ((map.IndexHeader.metaCount - 2) * 16) + totalshift + 12; } else { // Retrieve the last tags size and add the difference onto it tempsize = ((Meta)metas[x - 1]).size; // int temploc = metaTableStart + totalshift + ((x - 1) * 16) + 12; } // Update the size of previous tag int temploc = metaTableStart + totalshift + ((x - 1) * 16) + 12; tempsize += diff; map.BW.BaseStream.Position = temploc; map.BW.Write(tempsize); offset = tempoffset; howfar += diff; break; } tempoffset++; } while (0 != 1); } #endregion int offsetwithmagic = offset + map.SecondaryMagic; // each record 16 bytes map.BW.BaseStream.Position = metaOffset; map.BW.Write(metatype); // Offset 0 map.BW.Write(ident); // Offset 4 map.BW.Write(offsetwithmagic); // Offset 8 map.BW.Write(m.size); // Offset 12 howfar += m.size; map.BW.BaseStream.Position = offset; map.BW.BaseStream.Write(m.MS.ToArray(), 0, m.size); for (int xx = 0; xx < m.items.Count; xx++) { Meta.Item i = m.items[xx]; switch (i.type) { case Meta.ItemType.Ident: Meta.Ident id = (Meta.Ident)i; if (id.pointstoTagIndex == -1 | x == metas.Count - 1) { for (int e = 0; e < metas.Count; e++) { Meta tempm = (Meta)metas[e]; if (tempm.name == id.pointstotagname && tempm.type == id.pointstotagtype) { id.ident = map.MetaInfo.Ident[map.IndexHeader.metaCount - 1] + (e * 65537); break; } if (e == metas.Count - 1) { if (id.pointstotagname != "Null") { int sss = Array.IndexOf(map.MetaInfo.TagType, id.pointstotagtype); id.ident = sss != -1 ? map.MetaInfo.Ident[sss] : -1; // id.ident=-1; } else { id.ident = -1; } } } } else { id.ident = map.MetaInfo.Ident[id.pointstoTagIndex]; } map.BW.BaseStream.Position = offset + id.offset; map.BW.Write(id.ident); break; case Meta.ItemType.Reflexive: Meta.Reflexive reflex = (Meta.Reflexive)i; int newreflex = reflex.translation + offset + map.SecondaryMagic; // Handle referenced reflexives if (reflex.pointstoTagIndex != m.TagIndex) { newreflex = totalshift + reflex.translation + map.MetaInfo.Offset[reflex.pointstoTagIndex] + map.SecondaryMagic; } map.BW.BaseStream.Position = offset + 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 < map.MapHeader.scriptReferenceCount; e++) { if (s.name == map.Strings.Name[e]) { stringnum = (short)e; stringlength = (byte)map.Strings.Length[e]; } } for (int e = 0; e < strings.Count; e++) { if (((string)strings[e]) == s.name) { stringnum = (short)(map.MapHeader.scriptReferenceCount + e); stringlength = (byte)s.name.Length; } } map.BW.BaseStream.Position = offset + s.offset; map.BW.Write(stringnum); map.BW.Write(zero); map.BW.Write(stringlength); break; } } } // totalshift+=howfar; int tempfilesize = map.MapHeader.fileSize + totalshift + howfar - map.MetaInfo.Size[map.IndexHeader.metaCount - 1]; // (int)map.BW.BaseStream.Length; // 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 = map.MapHeader.metaSize + howfar - map.MetaInfo.Size[map.IndexHeader.metaCount - 1] + padding; // int combined = map.MapHeader.combinedSize + difference; int combined = map.MapHeader.combinedSize - olddifference + difference; // (int)bspmetasize + difference; // MessageBox.Show("test"); // combined // metasize -= bspmetashift; // map.MapHeader.combinedSize + howfar - map.MetaInfo.Size[map.IndexHeader.metaCount - 1] + padding; // (int)bspmetasize + difference - bspmetashift; 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); if (bspmagic == map.BSP.sbsp[0].magic) { } else { int tempbspmagic = map.BSP.sbsp[0].magic + map.BSP.sbsp[0].offset - bspoffset; for (int xx = 0; xx < tempbspmeta.items.Count; xx++) { Meta.Item i = tempbspmeta.items[xx]; switch (i.type) { case Meta.ItemType.Ident: Meta.Ident id = (Meta.Ident)i; if (id.pointstoTagIndex == -1) { for (int e = 0; e < metas.Count; e++) { Meta tempm = (Meta)metas[e]; if (tempbspmeta.name == id.pointstotagname && tempbspmeta.type == id.pointstotagtype) { id.ident = map.BSP.sbsp[0].ident; break; } else if (tempm.name == id.pointstotagname && tempm.type == id.pointstotagtype) { id.ident = map.MetaInfo.Ident[map.IndexHeader.metaCount - 1] + (e * 65537); break; } if (e == metas.Count - 1) { int sss = Array.IndexOf(map.MetaInfo.TagType, id.intagtype); id.ident = sss != -1 ? map.MetaInfo.Ident[sss] : -1; } } } else { id.ident = map.MetaInfo.Ident[id.pointstoTagIndex]; } map.BW.BaseStream.Position = bspoffset + id.offset; map.BW.Write(id.ident); break; case Meta.ItemType.String: Meta.String s = (Meta.String)i; short stringnum = 0; byte stringlength = 0; for (int e = 0; e < map.MapHeader.scriptReferenceCount; e++) { if (s.name == map.Strings.Name[e]) { stringnum = (short)e; stringlength = (byte)map.Strings.Length[e]; } } for (int e = 0; e < strings.Count; e++) { if (((string)strings[e]) == s.name) { stringnum = (short)(map.MapHeader.scriptReferenceCount + e); stringlength = (byte)s.name.Length; } } map.BW.BaseStream.Position = bspoffset + s.offset; map.BW.Write(stringnum); map.BW.Write(new byte()); map.BW.Write(stringlength); break; case Meta.ItemType.Reflexive: Meta.Reflexive rr = (Meta.Reflexive)i; int newreflex = bspoffset + rr.translation + tempbspmagic; map.BW.BaseStream.Position = bspoffset + rr.offset + 4; // map.BW.Write(newreflex); break; } } } for (int x = 0; x < layout.chunks.Count; x++) { loc = (LayOutChunk)layout.chunks[x]; for (int xx = 0; xx < loc.rawPieces.Count; xx++) { RawInfoChunk r = (RawInfoChunk)loc.rawPieces[xx]; r.offsetOfPointer += totalshift; map.BW.BaseStream.Position = r.offsetOfPointer; switch (r.rawType) { case RawDataType.bitm: r.offset += (uint)(totalshift - bitmshift); map.BW.Write(r.offset); break; case RawDataType.DECR: r.offset += (uint)(sndshift + modeshift + bspshift + weathershift); map.BW.Write(r.offset); break; // case RawDataType.snd2: case RawDataType.jmad: r.offset += (uint)(sndshift + modeshift + bspshift + weathershift + decrshift + prtmshift); map.BW.Write(r.offset); break; case RawDataType.mode1: r.offset += (uint)sndshift; map.BW.Write(r.offset); break; case RawDataType.mode2: r.offset += (uint)sndshift; map.BW.Write(r.offset); break; case RawDataType.PRTM: r.offset += (uint)(sndshift + modeshift + bspshift + weathershift + decrshift); map.BW.Write(r.offset); break; case RawDataType.weat: r.offset += (uint)(sndshift + modeshift + bspshift); map.BW.Write(r.offset); break; } } } layout.chunks[tempint] = loc; // layout.SortChunksByOffset(); map.CloseMap(); for (int y = 0; y < filestofix.Length; y++) { Map mapid = Map.LoadFromFile(filestofix[y]); MapAnalyzer analyze = new MapAnalyzer(); MapLayout lo = analyze.ScanMapForLayOut(mapid, true); mapid.OpenMap(MapTypes.Internal); for (int x = 0; x < lo.chunks.Count; x++) { loc = (LayOutChunk)lo.chunks[x]; for (int xx = 0; xx < loc.rawPieces.Count; xx++) { RawInfoChunk r = (RawInfoChunk)loc.rawPieces[xx]; if (r.location != map.MapHeader.mapType) { continue; } mapid.BW.BaseStream.Position = r.offsetOfPointer; switch (r.rawType) { case RawDataType.bitm: r.offset += (uint)(totalshift - bitmshift); r.offset |= 0X40000000; mapid.BW.Write(r.offset); break; case RawDataType.DECR: r.offset += (uint)(sndshift + modeshift + bspshift + weathershift); r.offset |= 0X40000000; mapid.BW.Write(r.offset); break; case RawDataType.snd2: case RawDataType.jmad: r.offset += (uint)(sndshift + modeshift + bspshift + weathershift + decrshift + prtmshift); r.offset |= 0X40000000; mapid.BW.Write(r.offset); break; case RawDataType.mode1: r.offset += (uint)sndshift; r.offset |= 0X40000000; mapid.BW.Write(r.offset); break; case RawDataType.mode2: r.offset += (uint)sndshift; r.offset |= 0X40000000; mapid.BW.Write(r.offset); break; case RawDataType.PRTM: r.offset += (uint)(sndshift + modeshift + bspshift + weathershift + decrshift); r.offset |= 0X40000000; mapid.BW.Write(r.offset); break; case RawDataType.weat: r.offset += (uint)(sndshift + modeshift + bspshift); r.offset |= 0X40000000; mapid.BW.Write(r.offset); break; } } } mapid.CloseMap(); mapid.Sign(); } }
/// <summary> /// The load weapons. /// </summary> /// <param name="WeaponsList">The weapons list.</param> /// <remarks></remarks> public void LoadWeapons(ref List<CollectionInfo> WeaponsList) { if (WeaponsList == null) { WeaponsList = new List<CollectionInfo>(); } else { WeaponsList.Clear(); } map.OpenMap(MapTypes.Internal); // Lists all weapons for (int i = 0; i < map.MetaInfo.TagType.Length; i++) { if ((map.MetaInfo.TagType[i] == "itmc") || (map.MetaInfo.TagType[i] == "vehc")) { CollectionInfo Weapon = new CollectionInfo(); Meta m = new Meta(map); m.ReadMetaFromMap(i, false); Weapon.ModelTagNumber = map.Functions.FindModelByBaseClass(i); if (Weapon.ModelTagNumber != -1) { m.ReadMetaFromMap(Weapon.ModelTagNumber, false); Weapon.Model = new ParsedModel(ref m); ParsedModel.DisplayedInfo.LoadDirectXTexturesAndBuffers(ref device, ref Weapon.Model); // Store names into Weapon Weapon.TagPath = map.FileNames.Name[i]; Weapon.TagType = map.MetaInfo.TagType[i]; int xx = map.Functions.ForMeta.FindByNameAndTagType(Weapon.TagType, Weapon.TagPath); string[] NameSplit = map.FileNames.Name[xx].Split('\\'); Weapon.Name = NameSplit[NameSplit.Length - 1]; Weapon.Name = Weapon.Name.Replace('_', ' '); WeaponsList.Add(Weapon); } } } map.CloseMap(); }
/// <summary> /// The tree view 1_ before expand. /// </summary> /// <param name="sender">The sender.</param> /// <param name="e">The e.</param> /// <remarks></remarks> private void treeView1_BeforeExpand(object sender, TreeViewCancelEventArgs e) { if (metaView != FormFunctions.MetaView.InfoView) { return; } string[] mReflex = e.Node.Text.Split('.'); if (mReflex.Length != 3) { return; } for (int x = 0; x < map.IndexHeader.metaCount; x++) { if ((mReflex[2] == map.FileNames.Name[x]) && (mReflex[1] == "[" + map.MetaInfo.TagType[x] + "]")) { map.OpenMap(MapTypes.Internal); Meta m = new Meta(map); m.ReadMetaFromMap(x, false); try { IFPIO ifpx = IFPHashMap.GetIfp(m.type, map.HaloVersion); m.headersize = ifpx.headerSize; // Scans IFP and loads IDENTS, REFLEXIVES & STRINGS into "m" for Reference List m.scanner.ScanWithIFP(ref ifpx); MetaSplitter metasplit = new MetaSplitter(); metasplit.SplitWithIFP(ref ifpx, ref m, map); e.Node.Nodes.Clear(); if (map.MetaInfo.TagType[x] != "sbsp") { DisplaySplit(metasplit.Header, e.Node); } } catch (Exception ex) { Global.ShowErrorMsg(string.Empty, ex); } map.CloseMap(); } } }
/// <summary> /// The h 2 shader info. /// </summary> /// <param name="TagIndex">The TagIndex.</param> /// <param name="map">The map.</param> /// <remarks></remarks> public void H2ShaderInfo(int TagIndex, Map map) { bool alreadyOpen = true; if (!(map.isOpen && map.openMapType == MapTypes.Internal)) { map.OpenMap(MapTypes.Internal); alreadyOpen = false; } this.TagIndex = TagIndex; if (this.TagIndex == -1) { return; } this.shaderName = map.FileNames.Name[this.TagIndex]; map.BR.BaseStream.Position = map.MetaInfo.Offset[this.TagIndex] + 4; int tempstem = map.Functions.ForMeta.FindMetaByID(map.BR.ReadInt32()); if (tempstem != -1) { if (map.FileNames.Name[tempstem].IndexOf("alphatest") != -1) { this.Alpha = AlphaType.AlphaTest; } else if (map.FileNames.Name[tempstem].IndexOf("alpha") != -1) { this.Alpha = AlphaType.AlphaBlend; } else if (map.FileNames.Name[tempstem].IndexOf("water") != -1) { this.Alpha = AlphaType.AlphaBlend; } else { this.Alpha = AlphaType.None; } } else { this.Alpha = AlphaType.None; } map.BR.BaseStream.Position = map.MetaInfo.Offset[this.TagIndex] + 12; int tempc2 = map.BR.ReadInt32(); int tempr2 = map.BR.ReadInt32() - map.SecondaryMagic; if (tempc2 != 0) { map.BR.BaseStream.Position = tempr2 + 4; int tempcrap = map.Functions.ForMeta.FindMetaByID(map.BR.ReadInt32()); if (tempcrap != -1) { Meta tempmeta = new Meta(map); tempmeta.ReadMetaFromMap(tempcrap, false); ParsedBitmap pm = new ParsedBitmap(ref tempmeta, map); this.MainBitmap = pm.FindChunkAndDecode(0, 0, 0, ref tempmeta, map, 0, 0); this.MainName = map.FileNames.Name[tempcrap]; this.levels = pm.Properties[0].mipMapCount; } } //map.OpenMap(MapTypes.Internal); map.BR.BaseStream.Position = map.MetaInfo.Offset[this.TagIndex] + 32; tempc2 = map.BR.ReadInt32(); tempr2 = map.BR.ReadInt32() - map.SecondaryMagic; map.BR.BaseStream.Position = tempr2 + 24; int fuckr = map.BR.ReadInt32(); if (fuckr != 0) { fuckr -= map.SecondaryMagic; map.BR.BaseStream.Position = fuckr; this.primarydetailuscale = map.BR.ReadSingle(); this.primarydetailvscale = map.BR.ReadSingle(); this.primarydetailwscale = map.BR.ReadSingle(); map.BR.ReadSingle(); this.secondarydetailuscale = map.BR.ReadSingle(); this.secondarydetailvscale = map.BR.ReadSingle(); this.secondarydetailwscale = map.BR.ReadSingle(); } map.BR.BaseStream.Position = tempr2 + 4; tempc2 = map.BR.ReadInt32(); tempr2 = map.BR.ReadInt32() - map.SecondaryMagic; /* for (int x = 0; x < tempc2; x++) { map.BR.BaseStream.Position = tempr2 + (x * 12); int tempcrap = map.Functions.Meta.FindMetaByID(map.BR.ReadInt32(), map); if (tempcrap == -1) { continue; } Meta tempmeta = new Meta(map); tempmeta.ReadMetaFromMap(tempcrap, map, false); Raw.ParsedBitmap pm = new Raw.ParsedBitmap(ref tempmeta, map); Bitmaps.Add(pm.FindChunkAndDecode(0, 0, 0, ref tempmeta, map, 0)); BitmapNames.Add(map.FileNames.Name[tempcrap]); } */ // map.BR.BaseStream.Position = tempr + 20; // tempc2 = map.BR.ReadInt32(); // tempr2 = map.BR.ReadInt32() - map.SecondaryMagic; // tempc2 = tempc; // tempr2 = tempr; if (tempc2 != 0) { map.BR.BaseStream.Position = tempr2; int tempcrap = map.Functions.ForMeta.FindMetaByID(map.BR.ReadInt32()); if (tempcrap != -1) { int test = map.FileNames.Name[tempcrap].IndexOf("reflection_maps"); if (map.FileNames.Name[tempcrap].IndexOf("_bump") != -1) { Meta tempmeta = new Meta(map); tempmeta.ReadMetaFromMap(tempcrap, false); ParsedBitmap pm = new ParsedBitmap(ref tempmeta, map); // this.BumpMapBitmap = pm.FindChunkAndDecode(0, 0, 0, ref tempmeta, map, 0, 0); this.BumpMapName = map.FileNames.Name[tempcrap]; } else if (map.FileNames.Name[tempcrap].IndexOf("_cube_map") != -1) { Meta tempmeta = new Meta(map); tempmeta.ReadMetaFromMap(tempcrap, false); ParsedBitmap pm = new ParsedBitmap(ref tempmeta, map); // this.CubeMapBitmap = pm.FindChunkAndDecode(0, 0, 0, ref tempmeta, map, 0, 0); this.CubeMapName = map.FileNames.Name[tempcrap]; } else if (map.FileNames.Name[tempcrap].IndexOf("default_") == -1 && this.MainBitmap == null && test == -1) { Meta tempmeta = new Meta(map); tempmeta.ReadMetaFromMap(tempcrap, false); ParsedBitmap pm = new ParsedBitmap(ref tempmeta, map); // Try to load LOD2-MIP3 if that fails, load LOD2-MIP0, otherwise LOD0-MIP0 this.MainBitmap = pm.FindChunkAndDecode(0, 2, 3, ref tempmeta, map, 0, 0); if (this.MainBitmap == null) { this.MainBitmap = pm.FindChunkAndDecode(0, 2, 0, ref tempmeta, map, 0, 0); if (this.MainBitmap == null) this.MainBitmap = pm.FindChunkAndDecode(0, 0, 0, ref tempmeta, map, 0, 0); } this.MainName = map.FileNames.Name[tempcrap]; this.levels = pm.Properties[0].mipMapCount; } else if (test != -1) { map.BR.BaseStream.Position += 8; tempcrap = map.Functions.ForMeta.FindMetaByID(map.BR.ReadInt32()); Meta tempmeta = new Meta(map); tempmeta.ReadMetaFromMap(tempcrap, false); ParsedBitmap pm = new ParsedBitmap(ref tempmeta, map); // this.MainBitmap = pm.FindChunkAndDecode(0, 0, 0, ref tempmeta, map); // this.MainName = map.FileNames.Name[tempcrap]; } } map.BR.BaseStream.Position = tempr2 + 24; tempcrap = map.Functions.ForMeta.FindMetaByID(map.BR.ReadInt32()); if (tempcrap != -1 && this.MainBitmap == null) { Meta tempmeta = new Meta(map); tempmeta.ReadMetaFromMap(tempcrap, false); ParsedBitmap pm = new ParsedBitmap(ref tempmeta, map); this.MainBitmap = pm.FindChunkAndDecode(0, 0, 0, ref tempmeta, map, 0, 0); this.MainName = map.FileNames.Name[tempcrap]; this.levels = pm.Properties[0].mipMapCount; } else if (this.MainBitmap == null) { map.BR.BaseStream.Position = tempr2 + 12; tempcrap = map.Functions.ForMeta.FindMetaByID(map.BR.ReadInt32()); if (tempcrap != -1) { Meta tempmeta = new Meta(map); tempmeta.ReadMetaFromMap(tempcrap, false); ParsedBitmap pm = new ParsedBitmap(ref tempmeta, map); this.MainBitmap = pm.FindChunkAndDecode(0, 0, 0, ref tempmeta, map, 0, 0); this.MainName = map.FileNames.Name[tempcrap]; this.levels = pm.Properties[0].mipMapCount; } } } if (!alreadyOpen) { map.CloseMap(); } }
/// <summary> /// The split ifp. /// </summary> /// <remarks></remarks> private void SplitIFP() { Meta m = new Meta(map); // Reads the current TAGNumber Meta m.ReadMetaFromMap(TagNumber, false); try { IFPIO ifpx = IFPHashMap.GetIfp(m.type, map.HaloVersion); m.headersize = ifpx.headerSize; // Scans IFP and loads IDENTS, REFLEXIVES & STRINGS into "m" for Reference List m.scanner.ScanWithIFP(ref ifpx); metasplit = new MetaSplitter(); metasplit.SplitWithIFP(ref ifpx, ref m, map); } catch (Exception ex) { Globals.Global.ShowErrorMsg(string.Empty, ex); } }
/// <summary> /// The save recursive function. /// </summary> /// <param name="meta">The meta.</param> /// <param name="metas">The metas.</param> /// <param name="parsed">The parsed.</param> /// <param name="pb">The pb.</param> /// <param name="percent">The percent.</param> /// <param name="percentsize">The percentsize.</param> /// <remarks></remarks> private void SaveRecursiveFunction( Meta meta, ref ArrayList metas, bool parsed, ToolStripProgressBar pb, float percent, float percentsize) { int wtf = metas.Count; if (meta.items.Count == 0) { return; } float test = meta.items.Count; float currentpercentsize = percentsize / test; Item i = null; try { for (int x = 0; x < meta.items.Count; x++) { i = meta.items[x]; if (i.type != ItemType.Ident) { continue; } float currentpercentage = percent + (currentpercentsize * x); pb.Value = (int)currentpercentage; Application.DoEvents(); Ident id = (Ident)i; if (id.ident == -1) { continue; } if (id.ident == 0) { int tagIndex = Map.Functions.ForMeta.FindByNameAndTagType("sbsp", i.intagname); id.ident = Map.MetaInfo.Ident[tagIndex]; } bool exists = false; for (int e = 0; e < metas.Count; e++) { Meta tempmeta = (Meta)metas[e]; // if (id.pointstotagtype ==tempmeta.type&&id.pointstotagname ==tempmeta.name ) if (id.ident == tempmeta.ident) { exists = true; break; } } if (exists) { continue; } // Drag & drop w/ recursive locks up. num == -1 int num = Map.Functions.ForMeta.FindMetaByID(id.ident); if (num < 0) { MessageBox.Show("ERROR! Not Found!"); } Meta m = new Meta(Map); if (parsed) { m.parsed = true; } m.ReadMetaFromMap(num, false); if (m.type == "ltmp" | m.type == "matg") { continue; } if (m.type == "phmo" | m.type == "coll" | m.type == "jmad") { m.parsed = false; } if (m.type != "jmad") { IFPIO ifp = IFPHashMap.GetIfp(m.type, Map.HaloVersion); m.headersize = ifp.headerSize; m.scanner.ScanWithIFP(ref ifp); } else { m.scanner.ScanManually(); } m.SortItemsByOffset(); metas.Add(m); Application.DoEvents(); SaveRecursiveFunction(m, ref metas, parsed, pb, currentpercentage, currentpercentsize); } } catch (Exception e) { string addOn = "\nin [" + meta.type + "] " + meta.name; if (i.type == ItemType.Ident) addOn = "\n" + i.description + ", Ident: " + ((Ident)i).ident + addOn; throw new Exception(e.Message + addOn, e.InnerException); } }
/// <summary> /// The load lightmaps. /// </summary> /// <remarks></remarks> public void LoadLightmaps() { if (map.BSP.sbsp[this.BspNumber].LightMap_TagNumber == -1) { LightMapBitmap = new Bitmap[this.BSPRawDataMetaChunks.Length]; SceneryLightMapBitmap = new Bitmap[this.PermutationInfo.Length]; return; } map.OpenMap(MapTypes.Internal); Meta m = new Meta(map); m.ReadMetaFromMap(map.BSP.sbsp[this.BspNumber].LightMap_TagNumber, false); ParsedBitmap pb = new ParsedBitmap(ref m, map); LightMapBitmap = new Bitmap[this.BSPRawDataMetaChunks.Length]; for (int x = 0; x < this.BSPRawDataMetaChunks.Length; x++) { int visualchunk = map.BSP.sbsp[this.BspNumber].VisualChunk_Bitmap_Index[x]; if (visualchunk == -1) { LightMapBitmap[x] = null; continue; } LightMapBitmap[x] = pb.FindChunkAndDecode(visualchunk, 0, 0, ref m, m.Map, x, this.BspNumber); } SceneryLightMapBitmap = new Bitmap[this.PermutationInfo.Length]; for (int x = 0; x < this.PermutationInfo.Length; x++) { int visualchunk = map.BSP.sbsp[this.BspNumber].SceneryChunk_Bitmap_Index[x]; if (visualchunk == -1) { SceneryLightMapBitmap[x] = null; continue; } SceneryLightMapBitmap[x] = pb.FindChunkAndDecode( visualchunk, 0, 0, ref m, m.Map, -x - 1, this.BspNumber); } map.CloseMap(); }
/// <summary> /// The load weapons. /// </summary> /// <param name="WeaponsList">The weapons list.</param> /// <remarks></remarks> public void LoadWeapons(ref List<CollectionInfo> WeaponsList) { if (WeaponsList == null) { WeaponsList = new List<CollectionInfo>(); } else { WeaponsList.Clear(); } map.OpenMap(MapTypes.Internal); // Lists all weapons for (int i = 0; i < map.MetaInfo.TagType.Length; i++) { if ((map.MetaInfo.TagType[i] == "itmc") || (map.MetaInfo.TagType[i] == "vehc")) { CollectionInfo Weapon = new CollectionInfo(); Meta m = new Meta(map); m.ReadMetaFromMap(i, false); Weapon.ItmcTagNumber = i; // Base address of ITMC tag, offset of WEAP pointer (+20) map.BR.BaseStream.Position = map.MetaInfo.Offset[Weapon.ItmcTagNumber] + 20; Weapon.WeapTagNumber = map.Functions.ForMeta.FindMetaByID(map.BR.ReadInt32()); if (Weapon.WeapTagNumber == -1) { continue; } // Base address of WEAP tag, offset of HLMT pointer (+56) map.BR.BaseStream.Position = map.MetaInfo.Offset[Weapon.WeapTagNumber] + 56; Weapon.HlmtTagNumber = map.Functions.ForMeta.FindMetaByID(map.BR.ReadInt32()); if (Weapon.HlmtTagNumber != -1) { // Base address of HLMT tag, offset of MODE pointer (+4) map.BR.BaseStream.Position = map.MetaInfo.Offset[Weapon.HlmtTagNumber] + 4; Weapon.ModelTagNumber = map.Functions.ForMeta.FindMetaByID(map.BR.ReadInt32()); m.ReadMetaFromMap(Weapon.ModelTagNumber, false); Weapon.Model = new ParsedModel(ref m); ParsedModel.DisplayedInfo.LoadDirectXTexturesAndBuffers(ref device, ref Weapon.Model); // Store names into Weapon Weapon.TagPath = map.FileNames.Name[i]; Weapon.TagType = map.MetaInfo.TagType[i]; int xx = map.Functions.ForMeta.FindByNameAndTagType(Weapon.TagType, Weapon.TagPath); string[] NameSplit = map.FileNames.Name[xx].Split('\\'); Weapon.Name = NameSplit[NameSplit.Length - 1]; Weapon.Name = Weapon.Name.Replace('_', ' '); WeaponsList.Add(Weapon); } } } map.CloseMap(); }
/// <summary> /// The load sky. /// </summary> /// <param name="meta">The meta.</param> /// <remarks></remarks> public void LoadSky(ref Meta meta) { map.OpenMap(MapTypes.Internal); map.BR.BaseStream.Position = map.MetaInfo.Offset[3] + 8; int tempc = map.BR.ReadInt32(); int tempr = map.BR.ReadInt32() - map.SecondaryMagic; if (tempc == 0) { return; } map.BR.BaseStream.Position = tempr + 4; int tempident = map.Functions.ForMeta.FindMetaByID(map.BR.ReadInt32()); if (tempident != -1) { sky = new Sky(tempident, map); map.BR.BaseStream.Position = map.MetaInfo.Offset[tempident] + 4; tempident = map.Functions.ForMeta.FindMetaByID(map.BR.ReadInt32()); if (tempident != -1) { Meta tempmeta = new Meta(map); tempmeta.ReadMetaFromMap(tempident, false); SkyBox = new ParsedModel(ref tempmeta); } } map.CloseMap(); }