/// <summary> /// Initializes a new instance of the <see cref="BSPConvert"/> class. /// </summary> /// <param name="map">The map.</param> /// <param name="test">The test.</param> /// <remarks></remarks> public H1BSPConvert(Map map, ref PropertyGrid test) { switch (map.HaloVersion) { case HaloVersionEnum.Halo1: case HaloVersionEnum.HaloCE: map.OpenMap(MapTypes.Internal); H1SBSP h1bsp = new H1SBSP(map.BSP.sbsp[0].TagIndex, map); test.SelectedObject = h1bsp.Header; map.CloseMap(); break; case HaloVersionEnum.Halo2: case HaloVersionEnum.Halo2Vista: MessageBox.Show("Open an H1 Map first"); break; } // OpenFileDialog open = new OpenFileDialog(); // open.Filter = "*.map|*.map"; // if (open.ShowDialog() == DialogResult.Cancel) return; // int h2map=Maps.Add(open.FileName); // Halo2BSP h2bsp = new Halo2BSP(h2map); // Maps.Remove(h2map); }
/// <summary> /// The halo ce container. /// </summary> /// <param name="map">The map.</param> /// <remarks></remarks> public void HaloCEContainer(Map map) { map.OpenMap(MapTypes.Internal); map.BR.BaseStream.Position = map.MetaInfo.Offset[0] + 1444; bspcount = map.BR.ReadInt32(); int tempr = map.BR.ReadInt32() - map.PrimaryMagic; sbsp = new BSPInfo[bspcount]; for (int x = 0; x < bspcount; x++) { sbsp[x] = new BSPInfo(); sbsp[x].pointerOffset = tempr + (x * 32) - map.MetaInfo.Offset[0]; map.BR.BaseStream.Position = tempr + (x * 32); sbsp[x].offset = map.BR.ReadInt32(); sbsp[x].size = map.BR.ReadInt32(); sbsp[x].magic = map.BR.ReadInt32() - sbsp[x].offset; map.BR.BaseStream.Position = tempr + (x * 32) + 28; sbsp[x].ident = map.BR.ReadInt32(); sbsp[x].TagIndex = map.Functions.ForMeta.FindMetaByID(sbsp[x].ident); map.MetaInfo.Offset[sbsp[x].TagIndex] = sbsp[x].offset; map.MetaInfo.Size[sbsp[x].TagIndex] = sbsp[x].size; map.BR.BaseStream.Position = sbsp[x].offset + 4; sbsp[x].Halo1VerticeCount = map.BR.ReadInt32(); sbsp[x].lightmapoffset = 24; map.BR.BaseStream.Position = sbsp[x].lightmapoffset + 12; sbsp[x].lightmapident = map.BR.ReadInt32(); sbsp[x].lightmapTagIndex = map.Functions.ForMeta.FindMetaByID(sbsp[x].ident); } map.CloseMap(); }
/// <summary> /// Loads a .map file and returns it as /// a map object /// </summary> /// <param name="fileName">The file Name.</param> /// <returns></returns> /// <remarks></remarks> public static Map LoadFromFile(string fileName) { // create the map object and give it the map filename Map map = new Map(fileName); // open the map map.OpenMap(MapTypes.Internal); // if the open failed, nothing we can do further if (!map.isOpen) { return(null); } // Get map version, (what halo this is) map.BR.BaseStream.Position = 4; int version = map.BR.ReadInt32(); // set the halo game type in the map object switch (version) { case 609: map.HaloVersion = HaloVersionEnum.HaloCE; break; case 8: map.HaloVersion = HaloVersionEnum.Halo2; map.BR.BaseStream.Position = 0x24; switch (map.BR.ReadInt32()) { case -1: map.HaloVersion = HaloVersionEnum.Halo2Vista; break; case 0: map.HaloVersion = HaloVersionEnum.Halo2; break; } break; case 5: map.HaloVersion = HaloVersionEnum.Halo1; break; // if we dont support the map, dont open it default: MessageBox.Show("This is not a supported map type."); map.CloseMap(); return(null); } // read from the map map.LoadMap(); // close file and return map obj map.CloseMap(); return(map); }
/// <summary> /// The get meta from tag index. /// </summary> /// <param name="tag">The tag.</param> /// <param name="map">The map.</param> /// <param name="manualScan">The manual scan.</param> /// <param name="parse">The parse.</param> /// <returns></returns> /// <remarks></remarks> public static Meta GetMetaFromTagIndex(int tag, Map map, bool manualScan, bool parse) { map.OpenMap(MapTypes.Internal); Meta meta = new Meta(map); meta.TagIndex = tag; meta.ScanMetaItems(manualScan, parse); map.CloseMap(); meta.SortItemsByOffset(); return(meta); }
/// <summary> /// Initializes a new instance of the <see cref="Scripts"/> class. /// </summary> /// <param name="map">The map.</param> /// <remarks></remarks> public Scripts(Map map) { map.OpenMap(MapTypes.Internal); map.BR.BaseStream.Position = map.MetaInfo.Offset[3] + 568; int tempc = map.BR.ReadInt32(); int tempr = map.BR.ReadInt32() - map.SecondaryMagic; syntaxes = new Syntax[tempc]; map.BR.BaseStream.Position = tempr; for (int x = 0; x < tempc; x++) { syntaxes[x] = new Syntax(ref map.BR); } map.CloseMap(); }
/// <summary> /// The write palettes. /// </summary> /// <param name="map">The map.</param> /// <remarks></remarks> public void WritePalettes(Map map) { map.OpenMap(MapTypes.Internal); map.BW.BaseStream.Position = palettesoffset; foreach (BSPContainer.Palette_Color[] palette in LightMap_Palettes) { for (int x = 0; x < 256; x++) { map.BW.Write((byte)palette[x].r); map.BW.Write((byte)palette[x].g); map.BW.Write((byte)palette[x].b); map.BW.Write((byte)palette[x].a); } } map.CloseMap(); }
/// <summary> /// Initializes a new instance of the <see cref="BitmapControl"/> class. /// </summary> /// <param name="map">The map.</param> /// <remarks></remarks> public BitmapControl(Map map) { InitializeComponent(); this.map = map; map.OpenMap(MapTypes.Internal); pm = new ParsedBitmap(ref map.SelectedMeta, map); for (int x = 0; x < pm.Properties.Length; x++) { TreeNode tn = new TreeNode("Bitmap #" + x); tn.Tag = "BITMAP"; for (int i = 0; i < map.SelectedMeta.raw.rawChunks.Count; i++) { int count = pm.Properties[x].mipMapCount; BitmapRawDataChunk bmRaw = (BitmapRawDataChunk)map.SelectedMeta.raw.rawChunks[i]; if (bmRaw.inchunk == x) { TreeNode chunknode = new TreeNode("Chunk #" + bmRaw.num); chunknode.Tag = "CHUNK"; int chunkWidth = pm.Properties[x].width >> bmRaw.num; int mipcount = 0; while (chunkWidth > 1 && count > 0) { TreeNode mipnode = new TreeNode("Mipmap #" + (mipcount++)); mipnode.Tag = "MIPMAP"; chunknode.Nodes.Add(mipnode); chunkWidth >>= 1; count--; } tn.Nodes.Add(chunknode); } } treeView1.Nodes.Add(tn); } map.CloseMap(); DisplayBitmap(0, 0, 0); }
/// <summary> /// Initializes a new instance of the <see cref="hlmtContainer"/> class. /// </summary> /// <param name="tagIndex">Index of the tag.</param> /// <param name="map">The map.</param> /// <remarks></remarks> public hlmtContainer(int tagIndex, Map map) { bool alreadyOpen = true; if (!(map.isOpen && map.openMapType == MapTypes.Internal)) { map.OpenMap(MapTypes.Internal); alreadyOpen = false; } this.TagIndex = tagIndex; Permutations = new PermutationInfo(); Permutations.Name = map.FileNames.Name[TagIndex]; map.BR.BaseStream.Position = map.MetaInfo.Offset[TagIndex] + 112; int tempc = map.BR.ReadInt32(); int tempr = map.BR.ReadInt32() - map.SecondaryMagic; Permutations.Piece = new PermutationInfo.PermutationPiece[tempc]; for (int x = 0; x < tempc; x++) { Permutations.Piece[x] = new PermutationInfo.PermutationPiece(); map.BR.BaseStream.Position = tempr + (x * 16); Permutations.Piece[x].PieceName = map.Strings.Name[map.BR.ReadInt16()]; map.BR.BaseStream.Position = tempr + (x * 16) + 8; int tempc2 = map.BR.ReadInt32(); int tempr2 = map.BR.ReadInt32() - map.SecondaryMagic; Permutations.Piece[x].Permutation = new PermutationInfo.PermutationPiece.PermutationVariation[tempc2]; for (int xx = 0; xx < tempc2; xx++) { Permutations.Piece[x].Permutation[xx] = new PermutationInfo.PermutationPiece.PermutationVariation(); map.BR.BaseStream.Position = tempr2 + (xx * 8); string temps2 = map.Strings.Name[map.BR.ReadInt16()]; Permutations.Piece[x].Permutation[xx].PermutationNameX = temps2; } } if (!alreadyOpen) { map.CloseMap(); } }
/// <summary> /// Loads the strings from "stringListIdent" into "strings" /// </summary> /// <param name="map"></param> /// <returns></returns> public bool getStrings(Map map) { if (!isPopulated | stringsListIdent == -1) return false; Meta m = Map.GetMetaFromTagIndex(map.Functions.ForMeta.FindMetaByID(stringsListIdent), map, false, false); BinaryReader br = new BinaryReader(m.MS); br.BaseStream.Position = 16; // English only... int offset = br.ReadUInt16(); int count = br.ReadUInt16(); int uiOffset = map.Unicode.ut[0].indexOffset; int utOffset = map.Unicode.ut[0].tableOffset; if (map.Unicode.ut[0].SIDs == null) map.Unicode.ut[0].Read(); map.OpenMap(MapTypes.Internal); br = new BinaryReader(map.FS); for (int i = 0; i < count; i++) { br.BaseStream.Position = utOffset + map.Unicode.ut[0].US[offset + i].offset; strings.Add( new entity.MetaFuncs.MEStringsSelector.Unicode( offset + i, map.Unicode.ut[0].US[offset + i].uString, map.Unicode.ut[0].US[offset + i].size, map.Unicode.ut[0].US[offset + i].offset, null)); } //new string(br.ReadChars(map.Unicode.ut[0].US[offset + i].size)); map.CloseMap(); return true; }
/// <summary> /// The halo 2 bsp container. /// </summary> /// <param name="map">The map.</param> /// <remarks></remarks> public void Halo2BSPContainer(Map map) { map.OpenMap(MapTypes.Internal); map.BR.BaseStream.Position = map.MetaInfo.Offset[3] + 528; bspcount = map.BR.ReadInt32(); int tempr = map.BR.ReadInt32() - map.SecondaryMagic; sbsp = new BSPInfo[bspcount]; for (int x = 0; x < bspcount; x++) { sbsp[x] = new BSPInfo(); sbsp[x].pointerOffset = tempr + (x * 68) - map.MetaInfo.Offset[3]; map.BR.BaseStream.Position = tempr + (x * 68); sbsp[x].offset = map.BR.ReadInt32(); map.Functions.ParsePointer(ref sbsp[x].offset, ref sbsp[x].location); sbsp[x].size = map.BR.ReadInt32(); sbsp[x].magic = map.BR.ReadInt32() - sbsp[x].offset; map.BR.BaseStream.Position = tempr + (x * 68) + 20; sbsp[x].ident = map.BR.ReadInt32(); // MessageBox.Show(sbsp[x].ident.ToString("X")); sbsp[x].TagIndex = map.Functions.ForMeta.FindMetaByID(sbsp[x].ident); map.MetaInfo.Offset[sbsp[x].TagIndex] = sbsp[x].offset; map.MetaInfo.Size[sbsp[x].TagIndex] = sbsp[x].size; map.BR.BaseStream.Position = tempr + (x * 68) + 28; sbsp[x].lightmapident = map.BR.ReadInt32(); sbsp[x].lightmapTagIndex = map.Functions.ForMeta.FindMetaByID(sbsp[x].lightmapident); if (sbsp[x].lightmapTagIndex == -1) { continue; } map.BR.BaseStream.Position = sbsp[x].offset + 8; sbsp[x].lightmapoffset = map.BR.ReadInt32(); if (sbsp[x].lightmapoffset == 0) { sbsp[x].lightmapident = -1; sbsp[x].lightmapTagIndex = -1; if ( MessageBox.Show( "There is no lightmap for this bsp and the scenario is currently linked to a broken ID.\n Would you like Entity to fix it?", "Error", MessageBoxButtons.YesNo) == DialogResult.Yes) { map.BW.BaseStream.Position = tempr + (x * 68) + 28; map.BW.Write(int.Parse("FFFFFFFF", NumberStyles.HexNumber)); } continue; } sbsp[x].lightmapoffset += -sbsp[x].magic; sbsp[x].lightmapsize = sbsp[x].size + sbsp[x].offset - sbsp[x].lightmapoffset; map.MetaInfo.Offset[sbsp[x].lightmapTagIndex] = sbsp[x].lightmapoffset; map.MetaInfo.Size[sbsp[x].lightmapTagIndex] = sbsp[x].lightmapsize; // light map bitmap map.BR.BaseStream.Position = sbsp[x].lightmapoffset + 128; int tempc = map.BR.ReadInt32(); int temprx = map.BR.ReadInt32() - sbsp[x].magic; map.BR.BaseStream.Position = temprx + 28; sbsp[x].LightMap_TagNumber = map.Functions.ForMeta.FindMetaByID(map.BR.ReadInt32()); ///light map palettes map.BR.BaseStream.Position = temprx + 8; int tempc2 = map.BR.ReadInt32(); int tempr2 = map.BR.ReadInt32() - sbsp[x].magic; sbsp[x].palettesoffset = tempr2; for (int y = 0; y < tempc2; y++) { map.BR.BaseStream.Position = tempr2 + (y * 1024); Palette_Color[] pc = new Palette_Color[256]; for (int z = 0; z < 256; z++) { pc[z] = new Palette_Color(); pc[z].r = map.BR.ReadByte(); pc[z].g = map.BR.ReadByte(); pc[z].b = map.BR.ReadByte(); pc[z].a = map.BR.ReadByte(); } sbsp[x].LightMap_Palettes.Add(pc); } map.BR.BaseStream.Position = temprx + 40; tempc2 = map.BR.ReadInt32(); tempr2 = map.BR.ReadInt32() - sbsp[x].magic; sbsp[x].VisualChunk_Bitmap_Index = new int[tempc2]; sbsp[x].VisualChunk_LightMap_Index = new int[tempc2]; if (tempc2 != 0) { map.BR.BaseStream.Position = tempr2; for (int y = 0; y < tempc2; y++) { sbsp[x].VisualChunk_Bitmap_Index[y] = map.BR.ReadInt16(); sbsp[x].VisualChunk_LightMap_Index[y] = map.BR.ReadInt16(); } } map.BR.BaseStream.Position = temprx + 72; tempc2 = map.BR.ReadInt32(); tempr2 = map.BR.ReadInt32() - sbsp[x].magic; sbsp[x].SceneryChunk_Bitmap_Index = new int[tempc2]; sbsp[x].SceneryChunk_LightMap_Index = new int[tempc2]; if (tempc2 > 0) { map.BR.BaseStream.Position = tempr2; for (int y = 0; y < tempc2; y++) { sbsp[x].SceneryChunk_Bitmap_Index[y] = map.BR.ReadInt16(); sbsp[x].SceneryChunk_LightMap_Index[y] = map.BR.ReadInt16(); } } } map.CloseMap(); }
/// <summary> /// The split with ifp. /// </summary> /// <param name="ifp">The ifp.</param> /// <param name="meta">The meta.</param> /// <param name="map">The map.</param> /// <remarks></remarks> public void SplitWithIFP(ref IFPIO ifp, ref Meta meta, Map map) { this.type = meta.type; this.TagIndex = meta.TagIndex; this.name = meta.name; this.offset = meta.offset; this.magic = meta.magic; this.raw = meta.raw; this.rawtype = meta.rawType; map.OpenMap(MapTypes.Internal); if (ifp.items != null) { map.BR.BaseStream.Position = meta.offset; Header = new SplitReflexive(); Header.offset = 0; Header.Chunks = new List<SplitReflexive>(); Header.translation = 0; // Header.MS = new MemoryStream(ifp.headerSize); // Header.MS.Write(map.BR.ReadBytes(ifp.headerSize), 0, ifp.headerSize); Header.chunksize = ifp.headerSize; Header.chunkcount = 1; Header.splitReflexiveType = SplitReflexive.SplitReflexiveType.Container; Header.realtranslation = meta.offset; if (meta.type == "sbsp") { int p = map.BSP.FindBSPNumberByBSPIdent(meta.ident); CycleElements( ref Header, ifp.items, ref meta, meta.offset, map, meta.TagIndex, map.BSP.sbsp[p].magic); } else if (meta.type == "ltmp") { int p = map.BSP.FindBSPNumberByLightMapIdent(meta.ident); CycleElements( ref Header, ifp.items, ref meta, meta.offset, map, meta.TagIndex, map.BSP.sbsp[p].magic); } else { // not "sbsp" or "ltmp" CycleElements(ref Header, ifp.items, ref meta, meta.offset, map, meta.TagIndex, map.SecondaryMagic); } } map.CloseMap(); }
/// <summary> /// The build meta. /// </summary> /// <param name="metasplit">The metasplit.</param> /// <param name="map">The map.</param> /// <returns></returns> /// <remarks></remarks> public static Meta BuildMeta(MetaSplitter metasplit, Map map) { metasize = 0; MetaStream = new MemoryStream(metasplit.Header.chunksize); BinaryWriter BW = new BinaryWriter(MetaStream); // BW.BaseStream.Position = 0; // BW.Write(metasplit.Header.MS.ToArray(), 0, metasplit.Header.chunksize); metasize += metasplit.Header.chunksize; TagIndex = metasplit.TagIndex; Meta m = new Meta(map); List<Meta.Item> NewItems = new List<Meta.Item>(); // Major error here! Size is not calculated right! RecursivelyAddPiecesToMeta(metasplit.Header, ref NewItems, ref BW); m.items = NewItems; if (MetaStream.Length % 4 != 0) { metasize += (int)MetaStream.Length % 4; MetaStream.SetLength(MetaStream.Length + MetaStream.Length % 4); } m.MS = MetaStream; m.size = metasize; m.type = metasplit.type; m.name = metasplit.name; m.rawType = metasplit.rawtype; m.raw = metasplit.raw; m.magic = metasplit.magic; m.offset = metasplit.offset; m.TagIndex = TagIndex; m.RelinkReferences(); m.WriteReferences(); // m.items.Clear(); // MetaScanner Ms = new MetaScanner(); if (m.rawType != RawDataContainerType.Empty) { map.OpenMap(MapTypes.Internal); m.raw = map.Functions.ForMeta.ReadRaw(m.TagIndex, false); map.CloseMap(); } // map.OpenMap(MapTypes.Internal); // IFPIO ifp=IFP.IFPHashMap.GetIfp(m.type); // m.parsed = true; // Ms.ScanWithIFP(ref ifp, ref m, map) ; // map.CloseMap(); return m; }
/// <summary> /// The h 2 spawn info. /// </summary> /// <param name="map">The map.</param> /// <remarks></remarks> public void H2SpawnInfo(Map map) { map.OpenMap(MapTypes.Internal); // find default mc model map.BR.BaseStream.Position = map.MetaInfo.Offset[0] + 308; int tempr = map.BR.ReadInt32() - map.SecondaryMagic; map.BR.BaseStream.Position = tempr + 4; int tempbipdtag = map.Functions.ForMeta.FindMetaByID(map.BR.ReadInt32()); //map.CloseMap(); int bipdmodeltag = map.Functions.FindModelByBaseClass(tempbipdtag); // Find objective models //map.OpenMap(MapTypes.Internal); map.BR.BaseStream.Position = map.MetaInfo.Offset[ map.Functions.ForMeta.FindByNameAndTagType("mulg", "multiplayer\\multiplayer_globals")] + 12; tempr = map.BR.ReadInt32(); int ctfmodeltag = -1; int ballmodeltag = -1; int juggernautdmodeltag = -1; int assultmodeltag = -1; if (tempr != 0) { tempr -= map.SecondaryMagic; map.BR.BaseStream.Position = tempr + 4; int tempCtftag = map.Functions.ForMeta.FindMetaByID(map.BR.ReadInt32()); map.BR.BaseStream.Position = tempr + 12; int tempBalltag = map.Functions.ForMeta.FindMetaByID(map.BR.ReadInt32()); map.BR.BaseStream.Position = tempr + 36; int tempHillShader = map.Functions.ForMeta.FindMetaByID(map.BR.ReadInt32()); // I believe the Hill Shader above is not used, but just in case. Otherwise, load the usual one below if (tempHillShader == -1) { map.BR.BaseStream.Position = tempr + 1332; int tempr2 = map.BR.ReadInt32(); if (tempr2 != 0) { tempr2 -= map.SecondaryMagic; map.BR.BaseStream.Position = tempr2 + 196; tempHillShader = map.Functions.ForMeta.FindMetaByID(map.BR.ReadInt32()); } } map.BR.BaseStream.Position = tempr + 52; int tempJuggernauttag = map.Functions.ForMeta.FindMetaByID(map.BR.ReadInt32()); map.BR.BaseStream.Position = tempr + 60; int tempAssaulttag = map.Functions.ForMeta.FindMetaByID(map.BR.ReadInt32()); //map.CloseMap(); ctfmodeltag = map.Functions.FindModelByBaseClass(tempCtftag); ballmodeltag = map.Functions.FindModelByBaseClass(tempBalltag); // *** This is not right. It's a shader, not a model. But I don't know how to display a shader... hillshadertag = map.Functions.ForMeta.FindMetaByID(tempHillShader); juggernautdmodeltag = map.Functions.FindModelByBaseClass(tempJuggernauttag); assultmodeltag = map.Functions.FindModelByBaseClass(tempAssaulttag); } #region //// Player Spawns //// //map.OpenMap(MapTypes.Internal); map.BR.BaseStream.Position = map.MetaInfo.Offset[3] + 256; int tempc = map.BR.ReadInt32(); tempr = map.BR.ReadInt32() - map.SecondaryMagic; for (int x = 0; x < tempc; x++) { map.BR.BaseStream.Position = tempr + (52 * x); PlayerSpawn ps = new PlayerSpawn(); ps.offset = tempr + (52 * x); ps.X = map.BR.ReadSingle(); ps.Y = map.BR.ReadSingle(); ps.Z = map.BR.ReadSingle(); ps.RotationDirection = map.BR.ReadSingle(); ps.ModelTagNumber = bipdmodeltag; ps.ModelName = map.FileNames.Name[ps.ModelTagNumber]; Spawn.Add(ps); } #endregion #region //// death zones //// map.BR.BaseStream.Position = map.MetaInfo.Offset[3] + 264; tempc = map.BR.ReadInt32(); tempr = map.BR.ReadInt32() - map.SecondaryMagic; for (int x = 0; x < tempc; x++) { DeathZone ps = new DeathZone(); // Load the deathzone name map.BR.BaseStream.Position = tempr + (68 * x); ps.Name = map.Strings.Name[map.BR.ReadInt16()]; // We set the offset to 36 b/c we don't care about saving the name... right now anyways. ps.offset = tempr + (68 * x) + 36; // Load the deathzone coordinates map.BR.BaseStream.Position = tempr + (68 * x) + 36; ps.X = map.BR.ReadSingle(); ps.Y = map.BR.ReadSingle(); ps.Z = map.BR.ReadSingle(); // Use ABS() to make sure our sizes are always positive ps.width = Math.Abs(map.BR.ReadSingle()); ps.height = Math.Abs(map.BR.ReadSingle()); ps.length = Math.Abs(map.BR.ReadSingle()); // Deathzones are saved with a centre point and Width, Length, Height ps.X += ps.width / 2; ps.Y += ps.height / 2; ps.Z += ps.length / 2; Spawn.Add(ps); } #endregion #region //// lights //// //// palette //// map.BR.BaseStream.Position = map.MetaInfo.Offset[3] + 240; int[] temppalette = new int[map.BR.ReadInt32()]; int[] temppalette2 = new int[temppalette.Length]; tempr = map.BR.ReadInt32() - map.SecondaryMagic; for (int x = 0; x < temppalette.Length; x++) { map.BR.BaseStream.Position = tempr + (x * 40) + 4; int tempbase = map.Functions.ForMeta.FindMetaByID(map.BR.ReadInt32()); temppalette2[x] = tempbase; temppalette[x] = tempbase; } //// placement //// map.BR.BaseStream.Position = map.MetaInfo.Offset[3] + 232; tempc = map.BR.ReadInt32(); tempr = map.BR.ReadInt32() - map.SecondaryMagic; for (int x = 0; x < tempc; x++) { map.BR.BaseStream.Position = tempr + (108 * x); short tempshort = map.BR.ReadInt16(); if (tempshort == -1) { continue; } map.BR.BaseStream.Position = tempr + (108 * x) + 8; LightSpawn vs = new LightSpawn(); vs.offset = tempr + (108 * x) + 8; vs.X = map.BR.ReadSingle(); vs.Y = map.BR.ReadSingle(); vs.Z = map.BR.ReadSingle(); vs.Roll = map.BR.ReadSingle(); vs.Pitch = map.BR.ReadSingle(); vs.Yaw = map.BR.ReadSingle(); vs.Scale = map.BR.ReadSingle(); vs.TagPath = map.FileNames.Name[temppalette2[tempshort]]; vs.ModelTagNumber = temppalette[tempshort]; if (vs.ModelTagNumber == -1) { continue; } vs.ModelName = map.FileNames.Name[vs.ModelTagNumber]; Spawn.Add(vs); } #endregion #region //// sounds //// //// Sound Scenery palette //// map.BR.BaseStream.Position = map.MetaInfo.Offset[3] + 224; // temppalette variables declared in Lights section above temppalette = new int[map.BR.ReadInt32()]; temppalette2 = new int[temppalette.Length]; tempr = map.BR.ReadInt32() - map.SecondaryMagic; for (int x = 0; x < temppalette.Length; x++) { map.BR.BaseStream.Position = tempr + (x * 40) + 4; int tempbase = map.Functions.ForMeta.FindMetaByID(map.BR.ReadInt32()); temppalette2[x] = tempbase; temppalette[x] = tempbase; } //// placement //// map.BR.BaseStream.Position = map.MetaInfo.Offset[3] + 216; tempc = map.BR.ReadInt32(); tempr = map.BR.ReadInt32() - map.SecondaryMagic; for (int x = 0; x < tempc; x++) { map.BR.BaseStream.Position = tempr + (80 * x); short tempshort = map.BR.ReadInt16(); if (tempshort == -1) { continue; } SoundSpawn vs = new SoundSpawn(); map.BR.BaseStream.Position = tempr + (80 * x) + 8; vs.offset = tempr + (80 * x) + 8; vs.X = map.BR.ReadSingle(); vs.Y = map.BR.ReadSingle(); vs.Z = map.BR.ReadSingle(); vs.Roll = map.BR.ReadSingle(); vs.Pitch = map.BR.ReadSingle(); vs.Yaw = map.BR.ReadSingle(); vs.Scale = map.BR.ReadSingle(); map.BR.BaseStream.Position = tempr + (80 * x) + 54; vs.VolumeType = map.BR.ReadInt16(); vs.Height = map.BR.ReadSingle(); vs.DistanceBoundsLower = map.BR.ReadSingle(); vs.DistanceBoundsUpper = map.BR.ReadSingle(); vs.ConeAngleLower = map.BR.ReadSingle(); vs.ConeAngleUpper = map.BR.ReadSingle(); vs.OuterConeGain = map.BR.ReadSingle(); if (temppalette2[tempshort] == -1) { vs.TagPath = "Nulled Out"; } else { vs.TagPath = map.FileNames.Name[temppalette2[tempshort]]; } vs.ModelTagNumber = temppalette[tempshort]; if (vs.ModelTagNumber == -1) { // { continue; } vs.ModelName = null; } else { vs.ModelName = map.FileNames.Name[vs.ModelTagNumber]; } Spawn.Add(vs); } #endregion #region //// objectives //// map.BR.BaseStream.Position = map.MetaInfo.Offset[3] + 280; tempc = map.BR.ReadInt32(); tempr = map.BR.ReadInt32() - map.SecondaryMagic; for (int x = 0; x < tempc; x++) { ObjectiveSpawn ps = new ObjectiveSpawn(); ps.offset = tempr + (32 * x); map.BR.BaseStream.Position = tempr + (32 * x); ps.X = map.BR.ReadSingle(); ps.Y = map.BR.ReadSingle(); ps.Z = map.BR.ReadSingle(); ps.RotationDirection = map.BR.ReadSingle(); ps.ObjectiveType = (ObjectiveSpawn.ObjectiveTypeEnum)map.BR.ReadInt16(); ps.Team = (ObjectiveSpawn.TeamType)map.BR.ReadInt16(); ps.number = map.BR.ReadInt16(); if (ps.ObjectiveType == ObjectiveSpawn.ObjectiveTypeEnum.OddballSpawn && ballmodeltag != -1) { ps.ModelTagNumber = ballmodeltag; } else if (ps.ObjectiveType == ObjectiveSpawn.ObjectiveTypeEnum.CTFRespawn && ctfmodeltag != -1) { ps.ModelTagNumber = ctfmodeltag; } else if ( ps.ObjectiveType.ToString().StartsWith( ObjectiveSpawn.ObjectiveTypeEnum.KingOfTheHill_1.ToString().Substring(0, 13)) && ctfmodeltag != -1) { ps.ModelTagNumber = ctfmodeltag; } else if (ps.ObjectiveType == ObjectiveSpawn.ObjectiveTypeEnum.AssaultRespawn && assultmodeltag != -1) { ps.ModelTagNumber = assultmodeltag; } else { ps.ModelTagNumber = bipdmodeltag; } ps.ModelName = map.FileNames.Name[ps.ModelTagNumber]; Spawn.Add(ps); } #endregion #region //// vehicles //// map.BR.BaseStream.Position = map.MetaInfo.Offset[3] + 120; temppalette = new int[map.BR.ReadInt32()]; temppalette2 = new int[temppalette.Length]; tempr = map.BR.ReadInt32() - map.SecondaryMagic; for (int x = 0; x < temppalette.Length; x++) { //map.OpenMap(MapTypes.Internal); map.BR.BaseStream.Position = tempr + (x * 40) + 4; int tempbase = map.Functions.ForMeta.FindMetaByID(map.BR.ReadInt32()); //map.CloseMap(); temppalette2[x] = tempbase; temppalette[x] = map.Functions.FindModelByBaseClass(tempbase); } //map.OpenMap(MapTypes.Internal); map.BR.BaseStream.Position = map.MetaInfo.Offset[3] + 112; tempc = map.BR.ReadInt32(); tempr = map.BR.ReadInt32() - map.SecondaryMagic; for (int x = 0; x < tempc; x++) { map.BR.BaseStream.Position = tempr + (84 * x); short tempshort = map.BR.ReadInt16(); if (tempshort == -1) { continue; } map.BR.BaseStream.Position = tempr + (84 * x) + 8; VehicleSpawn vs = new VehicleSpawn(); vs.offset = tempr + (84 * x) + 8; vs.X = map.BR.ReadSingle(); vs.Y = map.BR.ReadSingle(); vs.Z = map.BR.ReadSingle(); vs.Roll = map.BR.ReadSingle(); vs.Pitch = map.BR.ReadSingle(); vs.Yaw = map.BR.ReadSingle(); vs.Scale = map.BR.ReadSingle(); vs.TagPath = map.FileNames.Name[temppalette2[tempshort]]; vs.ModelTagNumber = temppalette[tempshort]; if (vs.ModelTagNumber == -1) { continue; } vs.ModelName = map.FileNames.Name[vs.ModelTagNumber]; Spawn.Add(vs); } #endregion #region //// equipment //// map.BR.BaseStream.Position = map.MetaInfo.Offset[3] + 136; temppalette = new int[map.BR.ReadInt32()]; temppalette2 = new int[temppalette.Length]; tempr = map.BR.ReadInt32() - map.SecondaryMagic; for (int x = 0; x < temppalette.Length; x++) { //map.OpenMap(MapTypes.Internal); map.BR.BaseStream.Position = tempr + (x * 40) + 4; int tempbase = map.Functions.ForMeta.FindMetaByID(map.BR.ReadInt32()); //map.CloseMap(); temppalette2[x] = tempbase; temppalette[x] = map.Functions.FindModelByBaseClass(tempbase); } //map.OpenMap(MapTypes.Internal); map.BR.BaseStream.Position = map.MetaInfo.Offset[3] + 128; tempc = map.BR.ReadInt32(); tempr = map.BR.ReadInt32() - map.SecondaryMagic; for (int x = 0; x < tempc; x++) { map.BR.BaseStream.Position = tempr + (56 * x); short tempshort = map.BR.ReadInt16(); if (tempshort == -1) { continue; } map.BR.BaseStream.Position = tempr + (56 * x) + 8; EquipmentSpawn vs = new EquipmentSpawn(); vs.offset = tempr + (56 * x) + 8; vs.X = map.BR.ReadSingle(); vs.Y = map.BR.ReadSingle(); vs.Z = map.BR.ReadSingle(); // vs.RotationDirection = map.BR.ReadSingle(); vs.Roll = map.BR.ReadSingle(); vs.Pitch = map.BR.ReadSingle(); vs.Yaw = map.BR.ReadSingle(); vs.Scale = map.BR.ReadSingle(); vs.TagPath = map.FileNames.Name[temppalette2[tempshort]]; vs.ModelTagNumber = temppalette[tempshort]; if (vs.ModelTagNumber == -1) { continue; } vs.ModelName = map.FileNames.Name[vs.ModelTagNumber]; Spawn.Add(vs); } #endregion #region //// bipeds //// map.BR.BaseStream.Position = map.MetaInfo.Offset[3] + 104; temppalette = new int[map.BR.ReadInt32()]; temppalette2 = new int[temppalette.Length]; tempr = map.BR.ReadInt32() - map.SecondaryMagic; for (int x = 0; x < temppalette.Length; x++) { //map.OpenMap(MapTypes.Internal); map.BR.BaseStream.Position = tempr + (x * 40) + 4; int tempbase = map.Functions.ForMeta.FindMetaByID(map.BR.ReadInt32()); //map.CloseMap(); temppalette2[x] = tempbase; temppalette[x] = map.Functions.FindModelByBaseClass(tempbase); } //map.OpenMap(MapTypes.Internal); map.BR.BaseStream.Position = map.MetaInfo.Offset[3] + 96; tempc = map.BR.ReadInt32(); tempr = map.BR.ReadInt32() - map.SecondaryMagic; for (int x = 0; x < tempc; x++) { map.BR.BaseStream.Position = tempr + (84 * x); short tempshort = map.BR.ReadInt16(); if (tempshort == -1) { continue; } map.BR.BaseStream.Position = tempr + (84 * x) + 8; BipedSpawn vs = new BipedSpawn(); vs.offset = tempr + (84 * x) + 8; vs.X = map.BR.ReadSingle(); vs.Y = map.BR.ReadSingle(); vs.Z = map.BR.ReadSingle(); vs.Roll = map.BR.ReadSingle(); vs.Pitch = map.BR.ReadSingle(); vs.Yaw = map.BR.ReadSingle(); vs.Scale = map.BR.ReadSingle(); vs.TagPath = map.FileNames.Name[temppalette2[tempshort]]; vs.ModelTagNumber = temppalette[tempshort]; if (vs.ModelTagNumber == -1) { continue; } vs.ModelName = map.FileNames.Name[vs.ModelTagNumber]; Spawn.Add(vs); } #endregion #region //// control //// map.BR.BaseStream.Position = map.MetaInfo.Offset[3] + 192; temppalette = new int[map.BR.ReadInt32()]; temppalette2 = new int[temppalette.Length]; tempr = map.BR.ReadInt32() - map.SecondaryMagic; for (int x = 0; x < temppalette.Length; x++) { //map.OpenMap(MapTypes.Internal); map.BR.BaseStream.Position = tempr + (x * 40) + 4; int tempbase = map.Functions.ForMeta.FindMetaByID(map.BR.ReadInt32()); //map.CloseMap(); temppalette2[x] = tempbase; temppalette[x] = map.Functions.FindModelByBaseClass(tempbase); } //map.OpenMap(MapTypes.Internal); map.BR.BaseStream.Position = map.MetaInfo.Offset[3] + 184; tempc = map.BR.ReadInt32(); tempr = map.BR.ReadInt32() - map.SecondaryMagic; for (int x = 0; x < tempc; x++) { map.BR.BaseStream.Position = tempr + (68 * x); short tempshort = map.BR.ReadInt16(); if (tempshort == -1) { continue; } map.BR.BaseStream.Position = tempr + (68 * x) + 8; ControlSpawn vs = new ControlSpawn(); vs.offset = tempr + (68 * x) + 8; vs.X = map.BR.ReadSingle(); vs.Y = map.BR.ReadSingle(); vs.Z = map.BR.ReadSingle(); // vs.RotationDirection = map.BR.ReadSingle(); vs.Roll = map.BR.ReadSingle(); vs.Pitch = map.BR.ReadSingle(); vs.Yaw = map.BR.ReadSingle(); vs.Scale = map.BR.ReadSingle(); vs.TagPath = map.FileNames.Name[temppalette2[tempshort]]; vs.ModelTagNumber = temppalette[tempshort]; if (vs.ModelTagNumber == -1) { continue; } vs.ModelName = map.FileNames.Name[vs.ModelTagNumber]; Spawn.Add(vs); } #endregion #region //// machines //// map.BR.BaseStream.Position = map.MetaInfo.Offset[3] + 176; temppalette = new int[map.BR.ReadInt32()]; temppalette2 = new int[temppalette.Length]; tempr = map.BR.ReadInt32() - map.SecondaryMagic; for (int x = 0; x < temppalette.Length; x++) { //map.OpenMap(MapTypes.Internal); map.BR.BaseStream.Position = tempr + (x * 40) + 4; int tempbase = map.Functions.ForMeta.FindMetaByID(map.BR.ReadInt32()); //map.CloseMap(); temppalette2[x] = tempbase; temppalette[x] = map.Functions.FindModelByBaseClass(tempbase); } //map.OpenMap(MapTypes.Internal); map.BR.BaseStream.Position = map.MetaInfo.Offset[3] + 168; tempc = map.BR.ReadInt32(); tempr = map.BR.ReadInt32() - map.SecondaryMagic; for (int x = 0; x < tempc; x++) { map.BR.BaseStream.Position = tempr + (72 * x); short tempshort = map.BR.ReadInt16(); if (tempshort == -1) { continue; } map.BR.BaseStream.Position = tempr + (72 * x) + 8; MachineSpawn vs = new MachineSpawn(); vs.offset = tempr + (72 * x) + 8; vs.X = map.BR.ReadSingle(); vs.Y = map.BR.ReadSingle(); vs.Z = map.BR.ReadSingle(); vs.Roll = map.BR.ReadSingle(); vs.Pitch = map.BR.ReadSingle(); vs.Yaw = map.BR.ReadSingle(); vs.Scale = map.BR.ReadSingle(); if (temppalette2[tempshort] == -1 || temppalette[tempshort] == -1) { continue; } vs.TagPath = map.FileNames.Name[temppalette2[tempshort]]; vs.ModelTagNumber = temppalette[tempshort]; if (vs.ModelTagNumber == -1) { continue; } vs.ModelName = map.FileNames.Name[vs.ModelTagNumber]; Spawn.Add(vs); } #endregion #region //// scenery //// map.BR.BaseStream.Position = map.MetaInfo.Offset[3] + 88; temppalette = new int[map.BR.ReadInt32()]; temppalette2 = new int[temppalette.Length]; tempr = map.BR.ReadInt32() - map.SecondaryMagic; for (int x = 0; x < temppalette.Length; x++) { //map.OpenMap(MapTypes.Internal); map.BR.BaseStream.Position = tempr + (x * 40) + 4; int tempbase = map.Functions.ForMeta.FindMetaByID(map.BR.ReadInt32()); //map.CloseMap(); temppalette2[x] = tempbase; temppalette[x] = map.Functions.FindModelByBaseClass(tempbase); } //map.OpenMap(MapTypes.Internal); map.BR.BaseStream.Position = map.MetaInfo.Offset[3] + 80; tempc = map.BR.ReadInt32(); tempr = map.BR.ReadInt32() - map.SecondaryMagic; for (int x = 0; x < tempc; x++) { map.BR.BaseStream.Position = tempr + (92 * x); short tempshort = map.BR.ReadInt16(); if (tempshort == -1) { continue; } map.BR.BaseStream.Position = tempr + (92 * x) + 8; ScenerySpawn vs = new ScenerySpawn(); vs.offset = tempr + (92 * x) + 8; vs.X = map.BR.ReadSingle(); vs.Y = map.BR.ReadSingle(); vs.Z = map.BR.ReadSingle(); vs.Roll = map.BR.ReadSingle(); vs.Pitch = map.BR.ReadSingle(); vs.Yaw = map.BR.ReadSingle(); vs.Scale = map.BR.ReadSingle(); if (temppalette2[tempshort] == -1 || temppalette[tempshort] == -1) { continue; } vs.TagPath = map.FileNames.Name[temppalette2[tempshort]]; vs.ModelTagNumber = temppalette[tempshort]; if (vs.ModelTagNumber == -1) { continue; } vs.ModelName = map.FileNames.Name[vs.ModelTagNumber]; Spawn.Add(vs); } #endregion #region //// weapons //// map.BR.BaseStream.Position = map.MetaInfo.Offset[3] + 152; temppalette = new int[map.BR.ReadInt32()]; temppalette2 = new int[temppalette.Length]; tempr = map.BR.ReadInt32() - map.SecondaryMagic; for (int x = 0; x < temppalette.Length; x++) { //map.OpenMap(MapTypes.Internal); map.BR.BaseStream.Position = tempr + (x * 40) + 4; int tempbase = map.Functions.ForMeta.FindMetaByID(map.BR.ReadInt32()); //map.CloseMap(); temppalette2[x] = tempbase; temppalette[x] = map.Functions.FindModelByBaseClass(tempbase); } //map.OpenMap(MapTypes.Internal); map.BR.BaseStream.Position = map.MetaInfo.Offset[3] + 144; tempc = map.BR.ReadInt32(); tempr = map.BR.ReadInt32() - map.SecondaryMagic; for (int x = 0; x < tempc; x++) { map.BR.BaseStream.Position = tempr + (84 * x); short tempshort = map.BR.ReadInt16(); if (tempshort == -1) { continue; } map.BR.BaseStream.Position = tempr + (84 * x) + 8; WeaponSpawn vs = new WeaponSpawn(); vs.offset = tempr + (84 * x) + 8; vs.X = map.BR.ReadSingle(); vs.Y = map.BR.ReadSingle(); vs.Z = map.BR.ReadSingle(); vs.Roll = map.BR.ReadSingle(); vs.Pitch = map.BR.ReadSingle(); vs.Yaw = map.BR.ReadSingle(); vs.Scale = map.BR.ReadSingle(); vs.TagPath = map.FileNames.Name[temppalette2[tempshort]]; vs.ModelTagNumber = temppalette[tempshort]; if (vs.ModelTagNumber == -1) { continue; } vs.ModelName = map.FileNames.Name[vs.ModelTagNumber]; Spawn.Add(vs); } #endregion #region //// obstacles //// map.BR.BaseStream.Position = map.MetaInfo.Offset[3] + 816; temppalette = new int[map.BR.ReadInt32()]; temppalette2 = new int[temppalette.Length]; tempr = map.BR.ReadInt32() - map.SecondaryMagic; for (int x = 0; x < temppalette.Length; x++) { //map.OpenMap(MapTypes.Internal); map.BR.BaseStream.Position = tempr + (x * 40) + 4; int tempbase = map.Functions.ForMeta.FindMetaByID(map.BR.ReadInt32()); //map.CloseMap(); temppalette2[x] = tempbase; temppalette[x] = map.Functions.FindModelByBaseClass(tempbase); } //map.OpenMap(MapTypes.Internal); map.BR.BaseStream.Position = map.MetaInfo.Offset[3] + 808; tempc = map.BR.ReadInt32(); tempr = map.BR.ReadInt32() - map.SecondaryMagic; for (int x = 0; x < tempc; x++) { map.BR.BaseStream.Position = tempr + (76 * x); short tempshort = map.BR.ReadInt16(); if (tempshort == -1) { continue; } map.BR.BaseStream.Position = tempr + (76 * x) + 8; ObstacleSpawn vs = new ObstacleSpawn(); vs.offset = tempr + (76 * x) + 8; vs.X = map.BR.ReadSingle(); vs.Y = map.BR.ReadSingle(); vs.Z = map.BR.ReadSingle(); vs.Roll = map.BR.ReadSingle(); vs.Pitch = map.BR.ReadSingle(); vs.Yaw = map.BR.ReadSingle(); vs.Scale = map.BR.ReadSingle(); if (temppalette2[tempshort] == -1) { continue; } vs.TagPath = map.FileNames.Name[temppalette2[tempshort]]; vs.ModelTagNumber = temppalette[tempshort]; if (vs.ModelTagNumber == -1) { continue; } vs.ModelName = map.FileNames.Name[vs.ModelTagNumber]; Spawn.Add(vs); } #endregion #region //// collections //// map.BR.BaseStream.Position = map.MetaInfo.Offset[3] + 288; tempc = map.BR.ReadInt32(); tempr = map.BR.ReadInt32() - map.SecondaryMagic; for (int x = 0; x < tempc; x++) { //map.OpenMap(MapTypes.Internal); Collection vs = new Collection(); map.BR.BaseStream.Position = tempr + (144 * x) + 4; vs.SpawnsInMode = (Collection.SpawnsInEnum)map.BR.ReadInt32(); // Why do they make the offset + 64? That just confuses stuff!! map.BR.BaseStream.Position = tempr + (144 * x) + 64; vs.offset = tempr + (144 * x) + 64; vs.X = map.BR.ReadSingle(); vs.Y = map.BR.ReadSingle(); vs.Z = map.BR.ReadSingle(); vs.Roll = map.BR.ReadSingle(); vs.Pitch = map.BR.ReadSingle(); vs.Yaw = map.BR.ReadSingle(); // test // if (vs.Pitch > 0) { vs.Pitch = -vs.Pitch; vs.isWeird = true; } else { vs.isWeird = false; } map.BR.BaseStream.Position = tempr + (144 * x) + 88; // ID Type char[] c = map.BR.ReadChars(4); vs.TagType = c[3].ToString() + c[2] + c[1] + c[0]; // Tag Path ID int tempbase = map.Functions.ForMeta.FindMetaByID(map.BR.ReadInt32()); if (tempbase == -1) { continue; } //map.CloseMap(); vs.TagPath = map.FileNames.Name[tempbase]; vs.ModelTagNumber = map.Functions.FindModelByBaseClass(tempbase); if (vs.ModelTagNumber == -1) { continue; } vs.ModelName = map.FileNames.Name[vs.ModelTagNumber]; Spawn.Add(vs); } #endregion #region //// cameras //// //map.OpenMap(MapTypes.Internal); map.BR.BaseStream.Position = map.MetaInfo.Offset[3] + 488; tempc = map.BR.ReadInt32(); tempr = map.BR.ReadInt32() - map.SecondaryMagic; for (int x = 0; x < tempc; x++) { //map.OpenMap(MapTypes.Internal); CameraSpawn vs = new CameraSpawn(); map.BR.BaseStream.Position = tempr + (64 * x) + 36; vs.offset = tempr + (64 * x) + 36; vs.X = map.BR.ReadSingle(); vs.Y = map.BR.ReadSingle(); vs.Z = map.BR.ReadSingle(); vs.Roll = map.BR.ReadSingle(); vs.Pitch = map.BR.ReadSingle(); vs.Yaw = map.BR.ReadSingle(); vs.fov = map.BR.ReadSingle(); vs.ModelTagNumber = -1; Spawn.Add(vs); } #endregion #region //// AI_Squads //// map.BR.BaseStream.Position = map.MetaInfo.Offset[3] + 376; temppalette = new int[map.BR.ReadInt32()]; temppalette2 = new int[temppalette.Length]; tempr = map.BR.ReadInt32() - map.SecondaryMagic; for (int x = 0; x < temppalette.Length; x++) { map.BR.BaseStream.Position = tempr + (x * 8) + 4; int tempbase = map.Functions.ForMeta.FindMetaByID(map.BR.ReadInt32()); temppalette2[x] = tempbase; temppalette[x] = map.Functions.FindModelByBaseClass(tempbase); } // Reading ai squads reflexive map.BR.BaseStream.Position = map.MetaInfo.Offset[3] + 352; tempc = map.BR.ReadInt32(); tempr = map.BR.ReadInt32() - map.SecondaryMagic; for (int x = 0; x < tempc; x++) { // Reads AI Squad palette chunk map.BR.BaseStream.Position = tempr + (x * 116) + 54; short charNum = map.BR.ReadInt16(); // Reading locations sub reflexive map.BR.BaseStream.Position = tempr + 72; int locc = map.BR.ReadInt32(); int locr = map.BR.ReadInt32() - map.SecondaryMagic; AI_Squads vs = new AI_Squads(); // chunk size * x and starting position map.BR.BaseStream.Position = locr + (100 * x); vs.offset = tempr + (100 * x); vs.ModelName = map.Strings.Name[(Int16)map.BR.ReadInt32()]; vs.X = map.BR.ReadSingle(); vs.Y = map.BR.ReadSingle(); vs.Z = map.BR.ReadSingle(); // facing direction map.BR.BaseStream.Position = locr + (100 * x) + 20; vs.RotationDirection = map.BR.ReadSingle(); if (charNum != -1) { vs.TagPath = map.FileNames.Name[temppalette2[charNum]]; vs.ModelTagNumber = temppalette[charNum]; if (vs.ModelTagNumber == -1) { continue; } // vs.ModelName = map.FileNames.Name[vs.ModelTagNumber]; Spawn.Add(vs); } } #endregion map.CloseMap(); }
/// <summary> /// Loads a .map file and returns it as /// a map object /// </summary> /// <param name="fileName">The file Name.</param> /// <returns></returns> /// <remarks></remarks> public static Map LoadFromFile(string fileName) { // create the map object and give it the map filename Map map = new Map(fileName); // open the map map.OpenMap(MapTypes.Internal); // if the open failed, nothing we can do further if (!map.isOpen) { return null; } // Get map version, (what halo this is) map.BR.BaseStream.Position = 4; int version = map.BR.ReadInt32(); // set the halo game type in the map object switch (version) { case 609: map.HaloVersion = HaloVersionEnum.HaloCE; break; case 8: map.HaloVersion = HaloVersionEnum.Halo2; map.BR.BaseStream.Position = 0x24; switch (map.BR.ReadInt32()) { case -1: map.HaloVersion = HaloVersionEnum.Halo2Vista; break; case 0: map.HaloVersion = HaloVersionEnum.Halo2; break; } break; case 5: map.HaloVersion = HaloVersionEnum.Halo1; break; // if we dont support the map, dont open it default: MessageBox.Show("This is not a supported map type."); map.CloseMap(); return null; } // read from the map map.LoadMap(); // close file and return map obj map.CloseMap(); return map; }
/// <summary> /// The scan map for lay out. /// </summary> /// <param name="map">The map.</param> /// <param name="addexternalchunks">The addexternalchunks.</param> /// <returns></returns> /// <remarks></remarks> public MapLayout ScanMapForLayOut(Map map, bool addexternalchunks) { MapLayout layout = new MapLayout(); for (int x = 0; x < map.BSP.sbsp.Length; x++) { LayOutChunk l = new LayOutChunk(0); l.rawType = RawDataContainerType.BSPMeta; l.startoffset = map.BSP.sbsp[x].offset; l.endoffset = map.BSP.sbsp[x].offset + map.BSP.sbsp[x].size; l.size = map.BSP.sbsp[x].size; layout.chunks.Add(l); } LayOutChunk lo = new LayOutChunk(0); lo.rawType = RawDataContainerType.Header; lo.startoffset = 0; lo.size = 2048; lo.endoffset = lo.startoffset + lo.size; layout.chunks.Add(lo); if (map.HaloVersion == HaloVersionEnum.Halo2 || map.HaloVersion == HaloVersionEnum.Halo2Vista) { lo = new LayOutChunk(0); lo.rawType = RawDataContainerType.StringsIndex; lo.startoffset = map.MapHeader.offsetToStringIndex; lo.size = map.MapHeader.scriptReferenceCount * 4; lo.size += map.Functions.Padding(lo.size, 512); lo.endoffset = lo.startoffset + lo.size; layout.chunks.Add(lo); lo = new LayOutChunk(0); lo.rawType = RawDataContainerType.Strings1; lo.startoffset = map.MapHeader.offsetToStringNames1; lo.size = map.MapHeader.scriptReferenceCount * 128; lo.size += map.Functions.Padding(lo.size, 512); lo.endoffset = lo.startoffset + lo.size; layout.chunks.Add(lo); lo = new LayOutChunk(0); lo.rawType = RawDataContainerType.Strings2; lo.startoffset = map.MapHeader.offsetToStringNames2; lo.size = map.MapHeader.sizeOfScriptReference; lo.size += map.Functions.Padding(lo.size, 512); lo.endoffset = lo.startoffset + lo.size; layout.chunks.Add(lo); lo = new LayOutChunk(0); lo.rawType = RawDataContainerType.Crazy; lo.startoffset = map.MapHeader.offsetToCrazy; lo.size = map.MapHeader.sizeOfCrazy; lo.size += map.Functions.Padding(lo.size, 512); lo.endoffset = lo.startoffset + lo.size; layout.chunks.Add(lo); lo = new LayOutChunk(0); lo.rawType = RawDataContainerType.FileNamesIndex; lo.startoffset = map.MapHeader.offsetTofileIndex; lo.size = map.MapHeader.fileCount * 4; lo.size += map.Functions.Padding(lo.size, 512); lo.endoffset = lo.startoffset + lo.size; layout.chunks.Add(lo); } lo = new LayOutChunk(0); lo.rawType = RawDataContainerType.FileNames; lo.startoffset = map.MapHeader.offsetTofileNames; lo.size = map.MapHeader.fileNamesSize; if (map.HaloVersion == HaloVersionEnum.Halo2 || map.HaloVersion == HaloVersionEnum.Halo2Vista) { lo.size += map.Functions.Padding(lo.size, 512); } lo.endoffset = lo.startoffset + lo.size; layout.chunks.Add(lo); lo = new LayOutChunk(0); lo.rawType = RawDataContainerType.MetaIndex; lo.startoffset = map.MapHeader.indexOffset; if (map.HaloVersion == HaloVersionEnum.Halo2 || map.HaloVersion == HaloVersionEnum.Halo2Vista) { lo.size = map.MapHeader.metaStart; lo.size += map.Functions.Padding(lo.size, 512); // map.MapHeader.fileSize - map.MapHeader.indexOffset; } else { lo.size = map.MapHeader.offsetTofileNames - map.MapHeader.indexOffset; // map.MetaInfo.Offset[map.IndexHeader.metaCount - 1] + map.MetaInfo.Size[map.IndexHeader.metaCount-1]; } lo.endoffset = lo.startoffset + lo.size; layout.chunks.Add(lo); lo = new LayOutChunk(0); lo.rawType = RawDataContainerType.MetaData; lo.startoffset = map.MetaInfo.Offset[0]; // How can you adjust for padding past the end of the file??? lo.size = map.MapHeader.fileSize - lo.startoffset; if (map.HaloVersion == HaloVersionEnum.Halo2 || map.HaloVersion == HaloVersionEnum.Halo2Vista) { int padding = map.Functions.Padding(lo.startoffset + lo.size, 4096); lo.size += padding; } lo.endoffset = lo.startoffset + lo.size; layout.chunks.Add(lo); if (map.HaloVersion == HaloVersionEnum.Halo2 || map.HaloVersion == HaloVersionEnum.Halo2Vista) { for (int x = 0; x < map.Unicode.ut.Length; x++) { lo = new LayOutChunk(0); lo.rawType = RawDataContainerType.UnicodeNamesIndex; lo.startoffset = map.Unicode.ut[x].indexOffset; lo.size = map.Unicode.ut[x].count * 8; lo.size += map.Functions.Padding(lo.size, 512); lo.endoffset = lo.startoffset + lo.size; layout.chunks.Add(lo); lo = new LayOutChunk(0); lo.rawType = RawDataContainerType.UnicodeNames; lo.startoffset = map.Unicode.ut[x].tableOffset; lo.size = map.Unicode.ut[x].tableSize; lo.size += map.Functions.Padding(lo.size, 512); lo.endoffset = lo.startoffset + lo.size; layout.chunks.Add(lo); } } map.OpenMap(MapTypes.Internal); for (int x = 0; x < map.IndexHeader.metaCount; x++) { if (map.HaloVersion == HaloVersionEnum.Halo2 || map.HaloVersion == HaloVersionEnum.Halo2Vista) { if (map.MetaInfo.TagType[x] == "snd!" | map.MetaInfo.TagType[x] == "ltmp") { continue; } Application.DoEvents(); } Meta m = new Meta(map); m.offset = map.MetaInfo.Offset[x]; // checks if type has raw data m.rawType = map.Functions.ForMeta.CheckForRaw(map.MetaInfo.TagType[x]); if (m.rawType != RawDataContainerType.Empty) { m.raw = map.Functions.ForMeta.ReadRaw(x, true); LayOutChunk l = new LayOutChunk(map.MapHeader.fileSize); int tempint = layout.FindByType(m.rawType); if (tempint == -1) { l = new LayOutChunk(map.MapHeader.fileSize); l.rawType = m.rawType; layout.chunks.Add(l); tempint = layout.FindByType(m.rawType); } else { l = (LayOutChunk)layout.chunks[tempint]; } for (int y = 0; y < m.raw.rawChunks.Count; y++) { RawDataChunk r = m.raw.rawChunks[y]; if (r.offset == -1) { continue; } if (r.rawLocation == MapTypes.Internal) { RawInfoChunk tempr = new RawInfoChunk(); tempr.offset = (uint)r.offset; tempr.size = r.size; tempr.rawType = r.rawDataType; tempr.location = r.rawLocation; tempr.offsetOfPointer = m.offset + r.pointerMetaOffset; l.rawPieces.Add(tempr); } else if (addexternalchunks) { RawInfoChunk tempr = new RawInfoChunk(); tempr.offset = (uint)r.offset; tempr.size = r.size; tempr.rawType = r.rawDataType; tempr.location = r.rawLocation; tempr.offsetOfPointer = m.offset + r.pointerMetaOffset; l.rawPieces.Add(tempr); } if (r.offset < l.startoffset && r.rawLocation == MapTypes.Internal) { l.startoffset = r.offset; l.size = l.endoffset - l.startoffset; layout.chunks[tempint] = l; } if (r.offset + r.size > l.endoffset && r.rawLocation == MapTypes.Internal) { l.endoffset = r.offset + r.size; l.endoffset += map.Functions.Padding(l.endoffset, 512); l.size = l.endoffset - l.startoffset; layout.chunks[tempint] = l; } } } m = null; GC.WaitForPendingFinalizers(); // GC.Collect(); } map.CloseMap(); if (map.HaloVersion == HaloVersionEnum.Halo2 || map.HaloVersion == HaloVersionEnum.Halo2Vista) { lo = new LayOutChunk(0); LayOutChunk templo = (LayOutChunk)layout.chunks[layout.FindByType(RawDataContainerType.Model)]; lo.rawType = RawDataContainerType.Sound; lo.startoffset = 2048; lo.size = templo.startoffset - 2048; lo.size += map.Functions.Padding(lo.size, 512); lo.endoffset = lo.startoffset + lo.size; layout.chunks.Add(lo); } for (int y = 0; y < layout.chunks.Count; y++) { LayOutChunk l = (LayOutChunk)layout.chunks[y]; if (l.size == 0) { layout.chunks.RemoveAt(y); y--; } } layout.SortChunksByOffset(); layout.SortRawByOffset(); return layout; }
/// <summary> /// The read h 2 sound data. /// </summary> /// <param name="TagIndex">The TagIndex.</param> /// <param name="map">The map.</param> /// <param name="dontreadraw">The dontreadraw.</param> /// <remarks></remarks> public void ReadH2SoundData(int TagIndex, Map map, bool dontreadraw) { map.BR.BaseStream.Position = map.MetaInfo.Offset[TagIndex] + 8; index = map.BR.ReadInt16(); count = 1; // map.BR.ReadInt16(); Permutations = new ugh_.SoundPermutationChunk[count]; for (int x = 0; x < count; x++) { int currentindex = index + x; Permutations[x] = map.ugh.Permutations[currentindex]; for (int xx = 0; xx < map.ugh.Permutations[currentindex].choicecount; xx++) { int choiceindexx = map.ugh.Permutations[currentindex].choiceindex + xx; Permutations[x].Choices.Add(map.ugh.Choices[choiceindexx]); for (int xxx = 0; xxx < map.ugh.Choices[choiceindexx].soundcount; xxx++) { int soundindex = map.ugh.Choices[choiceindexx].soundindex + xxx; Permutations[x].Choices[xx].SoundChunks1.Add(map.ugh.SoundChunks1[soundindex]); RawDataChunk Raw = new RawDataChunk(); Raw.rawDataType = RawDataType.snd1; Raw.offset = map.ugh.SoundChunks1[soundindex].offset; Raw.size = map.ugh.SoundChunks1[soundindex].size & 0x3FFFFFFF; Raw.rawLocation = map.ugh.SoundChunks1[soundindex].rawLocation; if (dontreadraw == false) { map.OpenMap(Raw.rawLocation); map.BR.BaseStream.Position = Raw.offset; Raw.MS = new MemoryStream(Raw.size); Raw.MS.Write(map.BR.ReadBytes(Raw.size), 0, Raw.size); map.OpenMap(MapTypes.Internal); } this.rawChunks.Add(Raw); } } } }
/// <summary> /// The read h 2 bitmap raw. /// </summary> /// <param name="TagIndex">The TagIndex.</param> /// <param name="map">The map.</param> /// <param name="dontreadraw">The dontreadraw.</param> /// <remarks></remarks> public void ReadH2BitmapRaw(int TagIndex, Map map, bool dontreadraw) { // Offset 68 = Bitmap Data reflexive map.BR.BaseStream.Position = map.MetaInfo.Offset[TagIndex] + 68; int tempc = map.BR.ReadInt32(); int tempr = map.BR.ReadInt32() - map.SecondaryMagic; for (int x = 0; x < tempc; x++) { // Bitmap Data reflexive is 116 bytes large // Offset 4 in BD reflexive is (short) width map.BR.BaseStream.Position = tempr + (x * 116) + 4; int width = map.BR.ReadInt16(); // Offset 6 in BD reflexive is (short) width int height = map.BR.ReadInt16(); // Offset 8 in BD reflexive is (short) width int depth = map.BR.ReadInt16(); // Offset 10 in BD reflexive is (short) type int type = map.BR.ReadInt16(); // Offset 12 in BD reflexive is (short) format int format = map.BR.ReadInt16(); // Offset 20 in BD reflexive is (short) mipmap Count map.BR.BaseStream.Position = tempr + (x * 116) + 20; int mipmapCount = map.BR.ReadInt16(); for (int xx = 0; xx < 6; xx++) { BitmapRawDataChunk Raw = new BitmapRawDataChunk(); Raw.inchunk = x; Raw.num = xx; Raw.pointerMetaOffset = tempr + (x * 116) + 28 + (xx * 4) - map.MetaInfo.Offset[TagIndex]; Raw.rawDataType = RawDataType.bitm; map.BR.BaseStream.Position = map.MetaInfo.Offset[TagIndex] + Raw.pointerMetaOffset; Raw.offset = map.BR.ReadInt32(); if (Raw.offset == -1) { break; } map.BR.BaseStream.Position = map.MetaInfo.Offset[TagIndex] + Raw.pointerMetaOffset + 24; Raw.size = map.BR.ReadInt32(); map.Functions.ParsePointer(ref Raw.offset, ref Raw.rawLocation); if (dontreadraw == false) { map.OpenMap(Raw.rawLocation); map.BR.BaseStream.Position = Raw.offset; Raw.MS = new MemoryStream(Raw.size); Raw.MS.Write(map.BR.ReadBytes(Raw.size), 0, Raw.size); #region mipmap loading section int offset = 0; int Bpp = 4; // 32 bit switch (format) { case 0: case 1: case 2: case 17: Bpp = 1; // 8 bit break; case 3: case 6: case 8: case 9: case 22: Bpp = 2; // 16 bit break; } for (int xxx = xx; xxx < mipmapCount; xxx++) { mipmapDataChunk mipmapDC = new mipmapDataChunk(); mipmapDC.width = width >> xxx; mipmapDC.height = height >> xxx; mipmapDC.depth = depth >> xxx != 0 ? depth >> xxx : 1; mipmapDC.offset = offset; mipmapDC.size = mipmapDC.width * mipmapDC.height * mipmapDC.depth * Bpp; // if (type == 2) // Cubemap, 6 sides // mipmapDC.size *= 6; switch (format) { case 14: // DXT1 mipmapDC.size /= 8; break; case 15: // DXT3 case 16: // DXT5 mipmapDC.size /= 4; break; } offset += mipmapDC.size; Raw.mipmaps.Add(mipmapDC); } #endregion map.OpenMap(MapTypes.Internal); } this.rawChunks.Add(Raw); } } }
/// <summary> /// The read. /// </summary> /// <param name="TagIndex">The TagIndex.</param> /// <param name="map">The map.</param> /// <param name="dontreadraw">The dontreadraw.</param> /// <remarks></remarks> public override void Read(int TagIndex, Map map, bool dontreadraw) { RawDataChunk Raw = new RawDataChunk(); Raw.rawDataType = RawDataType.DECR; Raw.pointerMetaOffset = 56; map.BR.BaseStream.Position = map.MetaInfo.Offset[TagIndex] + 56; Raw.offset = map.BR.ReadInt32(); Raw.size = map.BR.ReadInt32(); map.Functions.ParsePointer(ref Raw.offset, ref Raw.rawLocation); if (dontreadraw == false) { map.OpenMap(Raw.rawLocation); map.BR.BaseStream.Position = Raw.offset; Raw.MS = new MemoryStream(Raw.size); Raw.MS.Write(map.BR.ReadBytes(Raw.size), 0, Raw.size); map.OpenMap(MapTypes.Internal); } this.rawChunks.Add(Raw); }
/// <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 write palettes. /// </summary> /// <param name="map">The map.</param> /// <remarks></remarks> public void WritePalettes(Map map) { map.OpenMap(MapTypes.Internal); map.BW.BaseStream.Position = palettesoffset; foreach (BSPContainer.Palette_Color[] palette in LightMap_Palettes) { for (int x = 0; x < 256; x++) { map.BW.Write((byte)palette[x].r); map.BW.Write((byte)palette[x].g); map.BW.Write((byte)palette[x].b); map.BW.Write((byte)palette[x].a); } } 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 halo ce container. /// </summary> /// <param name="map">The map.</param> /// <remarks></remarks> public void HaloCEContainer(Map map) { map.OpenMap(MapTypes.Internal); map.BR.BaseStream.Position = map.MetaInfo.Offset[0] + 1444; bspcount = map.BR.ReadInt32(); int tempr = map.BR.ReadInt32() - map.PrimaryMagic; sbsp = new BSPInfo[bspcount]; for (int x = 0; x < bspcount; x++) { sbsp[x] = new BSPInfo(); sbsp[x].pointerOffset = tempr + (x * 32) - map.MetaInfo.Offset[0]; map.BR.BaseStream.Position = tempr + (x * 32); sbsp[x].offset = map.BR.ReadInt32(); sbsp[x].size = map.BR.ReadInt32(); sbsp[x].magic = map.BR.ReadInt32() - sbsp[x].offset; map.BR.BaseStream.Position = tempr + (x * 32) + 28; sbsp[x].ident = map.BR.ReadInt32(); sbsp[x].TagIndex = map.Functions.ForMeta.FindMetaByID(sbsp[x].ident); map.MetaInfo.Offset[sbsp[x].TagIndex] = sbsp[x].offset; map.MetaInfo.Size[sbsp[x].TagIndex] = sbsp[x].size; map.BR.BaseStream.Position = sbsp[x].offset + 4; sbsp[x].Halo1VerticeCount = map.BR.ReadInt32(); sbsp[x].lightmapoffset = 24; map.BR.BaseStream.Position = sbsp[x].lightmapoffset + 12; sbsp[x].lightmapident = map.BR.ReadInt32(); sbsp[x].lightmapTagIndex = map.Functions.ForMeta.FindMetaByID(sbsp[x].ident); } map.CloseMap(); }
/// <summary> /// The save to xml. /// </summary> /// <param name="path">The path.</param> /// <param name="map">The map.</param> /// <remarks></remarks> public void SaveToXml(string path, Map map) { XmlTextWriter xtw = new XmlTextWriter(path, Encoding.Default); xtw.Formatting = Formatting.Indented; xtw.WriteStartElement("MapLayOut"); xtw.WriteAttributeString("Map", map.filePath); int tempindex = path.LastIndexOf("\\"); string tempfilepath = path.Substring(0, tempindex) + "\\" + path.Substring(tempindex + 1, path.Length - tempindex - 1) + " - Meta Chunks\\"; Directory.CreateDirectory(tempfilepath); map.OpenMap(MapTypes.Internal); for (int x = 0; x < chunks.Count; x++) { LayOutChunk c = (LayOutChunk)chunks[x]; // c.Read(map); FileStream FS = new FileStream( tempfilepath + "MapMetaChunk[" + x + "] - " + c.rawType + ".meta", FileMode.Create); BinaryWriter BW = new BinaryWriter(FS); // BW.Write(c.MS.ToArray()); // c.Write(BW, 0); map.BR.BaseStream.Position = c.startoffset; map.BufferReadWrite(ref map.BR, ref BW, c.size); BW.Close(); FS.Close(); xtw.WriteStartElement("LayOutChunk"); xtw.WriteAttributeString("Type", c.rawType.ToString()); xtw.WriteAttributeString("StartOffset", c.startoffset.ToString("X")); xtw.WriteAttributeString("EndOffset", c.endoffset.ToString("X")); xtw.WriteAttributeString("Size", c.size.ToString("X")); for (int xx = 0; xx < c.rawPieces.Count; xx++) { RawInfoChunk cc = (RawInfoChunk)c.rawPieces[xx]; xtw.WriteStartElement("RawDataPiece"); xtw.WriteAttributeString("Type", cc.rawType.ToString()); xtw.WriteAttributeString("Offset", cc.offset.ToString("X")); xtw.WriteAttributeString("Size", cc.size.ToString("X")); xtw.WriteAttributeString("PointerOffset", cc.offsetOfPointer.ToString("X")); xtw.WriteEndElement(); } xtw.WriteEndElement(); } xtw.WriteEndElement(); xtw.Close(); map.CloseMap(); }
/// <summary> /// The read h 1 model raw. /// </summary> /// <param name="TagIndex">The TagIndex.</param> /// <param name="map">The map.</param> /// <param name="dontreadraw">The dontreadraw.</param> /// <remarks></remarks> public void ReadH1ModelRaw(int TagIndex, Map map, bool dontreadraw) { map.BR.BaseStream.Position = map.MetaInfo.Offset[TagIndex] + 208; int tempc = map.BR.ReadInt32(); int tempr = map.BR.ReadInt32() - map.PrimaryMagic; for (int y = 0; y < tempc; y++) { map.BR.BaseStream.Position = tempr + (y * 48) + 36; int tempcc = map.BR.ReadInt32(); int temprc = map.BR.ReadInt32() - map.PrimaryMagic; for (int x = 0; x < tempcc; x++) { RawDataChunk Raw = new RawDataChunk(); map.BR.BaseStream.Position = temprc + (x * 104) + 4; Raw.shadernumber = map.BR.ReadInt16(); Raw.pointerMetaOffset = temprc + (x * 104) + 76 - map.MetaInfo.Offset[TagIndex]; map.BR.BaseStream.Position = map.MetaInfo.Offset[TagIndex] + Raw.pointerMetaOffset - 4; Raw.rawDataType = RawDataType.HaloCEIndices; Raw.size = (map.BR.ReadInt32() + 2) * 2; Raw.offset = map.BR.ReadInt32() - map.PrimaryMagic; if (dontreadraw == false) { map.OpenMap(Raw.rawLocation); map.BR.BaseStream.Position = Raw.offset; Raw.MS = new MemoryStream(Raw.size); Raw.MS.Write(map.BR.ReadBytes(Raw.size), 0, Raw.size); map.OpenMap(MapTypes.Internal); } this.rawChunks.Add(Raw); Raw = new RawDataChunk(); Raw.rawDataType = RawDataType.HaloCEVertices; Raw.pointerMetaOffset = temprc + (x * 104) + 100 - map.MetaInfo.Offset[TagIndex]; map.BR.BaseStream.Position = map.MetaInfo.Offset[TagIndex] + Raw.pointerMetaOffset - 12; Raw.size = map.BR.ReadInt32(); Raw.size *= 32; map.BR.BaseStream.Position = map.MetaInfo.Offset[TagIndex] + Raw.pointerMetaOffset; this.IntermediatePointerOffset = map.BR.ReadInt32() - map.PrimaryMagic; map.BR.BaseStream.Position = this.IntermediatePointerOffset + 4; Raw.offset = map.BR.ReadInt32() - map.PrimaryMagic; if (dontreadraw == false) { map.OpenMap(Raw.rawLocation); map.BR.BaseStream.Position = Raw.offset; Raw.MS = new MemoryStream(Raw.size); Raw.MS.Write(map.BR.ReadBytes(Raw.size), 0, Raw.size); map.OpenMap(MapTypes.Internal); } this.rawChunks.Add(Raw); } } }
/// <summary> /// The get ugh container info. /// </summary> /// <param name="map">The map.</param> /// <remarks></remarks> public static void GetUghContainerInfo(Map map) { Meta.Meta tempughmeta = new Meta.Meta(map); map.OpenMap(MapTypes.Internal); tempughmeta.ReadMetaFromMap(map.IndexHeader.metaCount - 1, true); map.ugh = new ugh_(ref tempughmeta); map.CloseMap(); }
/// <summary> /// The read. /// </summary> /// <param name="TagIndex">The TagIndex.</param> /// <param name="map">The map.</param> /// <param name="dontreadraw">The dontreadraw.</param> /// <remarks></remarks> public override void Read(int TagIndex, Map map, bool dontreadraw) { map.BR.BaseStream.Position = map.MetaInfo.Offset[TagIndex] + 172; int tempc = map.BR.ReadInt32(); int tempr = map.BR.ReadInt32() - map.SecondaryMagic; for (int x = 0; x < tempc; x++) { RawDataChunk Raw = new RawDataChunk(); Raw.rawDataType = RawDataType.jmad; Raw.pointerMetaOffset = tempr + (x * 20) + 8 - map.MetaInfo.Offset[TagIndex]; map.BR.BaseStream.Position = map.MetaInfo.Offset[TagIndex] + Raw.pointerMetaOffset - 4; Raw.size = map.BR.ReadInt32(); Raw.offset = map.BR.ReadInt32(); map.Functions.ParsePointer(ref Raw.offset, ref Raw.rawLocation); if (dontreadraw == false) { map.OpenMap(Raw.rawLocation); map.BR.BaseStream.Position = Raw.offset; Raw.MS = new MemoryStream(Raw.size); Raw.MS.Write(map.BR.ReadBytes(Raw.size), 0, Raw.size); map.OpenMap(MapTypes.Internal); } this.rawChunks.Add(Raw); } }
/// <summary> /// The h 1 spawn info. /// </summary> /// <param name="map">The map.</param> /// <remarks></remarks> public void H1SpawnInfo(Map map) { map.OpenMap(MapTypes.Internal); // collections map.BR.BaseStream.Position = map.MetaInfo.Offset[0] + 900; int tempc = map.BR.ReadInt32(); int tempr = map.BR.ReadInt32() - map.PrimaryMagic; for (int x = 0; x < tempc; x++) { //map.OpenMap(MapTypes.Internal); H1Collection vs = new H1Collection(); map.BR.BaseStream.Position = tempr + (144 * x) + 4; vs.SpawnsInMode = (H1Collection.H1CollectionTypeEnum)map.BR.ReadInt32(); map.BR.BaseStream.Position = tempr + (144 * x) + 64; vs.offset = tempr + (144 * x) + 64; vs.X = map.BR.ReadSingle(); vs.Y = map.BR.ReadSingle(); vs.Z = map.BR.ReadSingle(); vs.RotationDirection = Renderer.DegreeToRadian(map.BR.ReadSingle()); map.BR.BaseStream.Position = tempr + (144 * x) + 92; int tempbase = map.Functions.ForMeta.FindMetaByID(map.BR.ReadInt32()); if (tempbase == -1) { continue; } //map.CloseMap(); vs.TagPath = map.FileNames.Name[tempbase]; vs.ModelTagNumber = map.Functions.FindModelByBaseClass(tempbase); if (vs.ModelTagNumber == -1) { continue; } vs.ModelName = map.FileNames.Name[vs.ModelTagNumber]; Spawn.Add(vs); } // vehicle //map.OpenMap(MapTypes.Internal); map.BR.BaseStream.Position = map.MetaInfo.Offset[0] + 588; int[] temppalette = new int[map.BR.ReadInt32()]; int[] temppalette2 = new int[temppalette.Length]; tempr = map.BR.ReadInt32() - map.PrimaryMagic; for (int x = 0; x < temppalette.Length; x++) { //map.OpenMap(MapTypes.Internal); map.BR.BaseStream.Position = tempr + (x * 48) + 12; int tempbase = map.Functions.ForMeta.FindMetaByID(map.BR.ReadInt32()); //map.CloseMap(); temppalette2[x] = tempbase; temppalette[x] = map.Functions.FindModelByBaseClass(tempbase); } //map.OpenMap(MapTypes.Internal); map.BR.BaseStream.Position = map.MetaInfo.Offset[0] + 576; tempc = map.BR.ReadInt32(); tempr = map.BR.ReadInt32() - map.PrimaryMagic; for (int x = 0; x < tempc; x++) { map.BR.BaseStream.Position = tempr + (120 * x); short tempshort = map.BR.ReadInt16(); if (tempshort == -1) { continue; } map.BR.BaseStream.Position = tempr + (120 * x) + 8; VehicleSpawn vs = new VehicleSpawn(); vs.offset = tempr + (120 * x) + 8; vs.X = map.BR.ReadSingle(); vs.Y = map.BR.ReadSingle(); vs.Z = map.BR.ReadSingle(); vs.Yaw = Renderer.DegreeToRadian(map.BR.ReadSingle()); vs.Pitch = Renderer.DegreeToRadian(map.BR.ReadSingle()); vs.Roll = Renderer.DegreeToRadian(map.BR.ReadSingle()); vs.ModelTagNumber = temppalette[tempshort]; if (vs.ModelTagNumber == -1) { continue; } vs.TagPath = map.FileNames.Name[temppalette2[tempshort]]; vs.ModelName = map.FileNames.Name[vs.ModelTagNumber]; Spawn.Add(vs); } //map.OpenMap(MapTypes.Internal); map.BR.BaseStream.Position = map.MetaInfo.Offset[0] + 540; temppalette = new int[map.BR.ReadInt32()]; temppalette2 = new int[temppalette.Length]; tempr = map.BR.ReadInt32() - map.PrimaryMagic; for (int x = 0; x < temppalette.Length; x++) { //map.OpenMap(MapTypes.Internal); map.BR.BaseStream.Position = tempr + (x * 48) + 12; int tempbase = map.Functions.ForMeta.FindMetaByID(map.BR.ReadInt32()); //map.CloseMap(); temppalette2[x] = tempbase; temppalette[x] = map.Functions.FindModelByBaseClass(tempbase); } //map.OpenMap(MapTypes.Internal); map.BR.BaseStream.Position = map.MetaInfo.Offset[0] + 528; tempc = map.BR.ReadInt32(); tempr = map.BR.ReadInt32() - map.PrimaryMagic; for (int x = 0; x < tempc; x++) { map.BR.BaseStream.Position = tempr + (72 * x); short tempshort = map.BR.ReadInt16(); if (tempshort == -1) { continue; } map.BR.BaseStream.Position = tempr + (72 * x) + 8; ScenerySpawn vs = new ScenerySpawn(); vs.offset = tempr + (72 * x) + 8; vs.X = map.BR.ReadSingle(); vs.Y = map.BR.ReadSingle(); vs.Z = map.BR.ReadSingle(); vs.Yaw = Renderer.DegreeToRadian(map.BR.ReadSingle()); vs.Pitch = Renderer.DegreeToRadian(map.BR.ReadSingle()); vs.Roll = Renderer.DegreeToRadian(map.BR.ReadSingle()); vs.ModelTagNumber = temppalette[tempshort]; if (vs.ModelTagNumber == -1) { continue; } vs.TagPath = map.FileNames.Name[temppalette2[tempshort]]; vs.ModelName = map.FileNames.Name[vs.ModelTagNumber]; Spawn.Add(vs); } }
/// <summary> /// The h 2 read. /// </summary> /// <param name="TagIndex">The TagIndex.</param> /// <param name="map">The map.</param> /// <param name="dontreadraw">The dontreadraw.</param> /// <remarks></remarks> public void H2Read(int TagIndex, Map map, bool dontreadraw) { int w = map.BSP.FindBSPNumberByBSPIdent(map.MetaInfo.Ident[TagIndex]); // bsp model 1 map.BR.BaseStream.Position = map.MetaInfo.Offset[TagIndex] + 172; int tempc = map.BR.ReadInt32(); int tempr = map.BR.ReadInt32() - map.BSP.sbsp[w].magic; for (int x = 0; x < tempc; x++) { RawDataChunk Raw = new RawDataChunk(); Raw.rawDataType = RawDataType.bsp1; Raw.pointerMetaOffset = tempr + (x * 176) + 40 - map.MetaInfo.Offset[TagIndex]; map.BR.BaseStream.Position = tempr + (x * 176) + 40; Raw.offset = map.BR.ReadInt32(); Raw.size = map.BR.ReadInt32(); if (Raw.offset == -1) { this.rawChunks.Add(Raw); continue; } map.Functions.ParsePointer(ref Raw.offset, ref Raw.rawLocation); if (dontreadraw == false) { map.OpenMap(Raw.rawLocation); map.BR.BaseStream.Position = Raw.offset; Raw.MS = new MemoryStream(Raw.size); Raw.MS.Write(map.BR.ReadBytes(Raw.size), 0, Raw.size); map.OpenMap(MapTypes.Internal); } this.rawChunks.Add(Raw); } // bsp model 2 map.BR.BaseStream.Position = map.MetaInfo.Offset[TagIndex] + 328; tempc = map.BR.ReadInt32(); tempr = map.BR.ReadInt32() - map.BSP.sbsp[w].magic; for (int x = 0; x < tempc; x++) { RawDataChunk Raw = new RawDataChunk(); Raw.rawDataType = RawDataType.bsp2; Raw.pointerMetaOffset = tempr + (x * 200) + 40 - map.MetaInfo.Offset[TagIndex]; map.BR.BaseStream.Position = tempr + (x * 200) + 40; Raw.offset = map.BR.ReadInt32(); Raw.size = map.BR.ReadInt32(); if (Raw.offset == -1) { this.rawChunks.Add(Raw); continue; } map.Functions.ParsePointer(ref Raw.offset, ref Raw.rawLocation); if (dontreadraw == false) { map.OpenMap(Raw.rawLocation); map.BR.BaseStream.Position = Raw.offset; Raw.MS = new MemoryStream(Raw.size); Raw.MS.Write(map.BR.ReadBytes(Raw.size), 0, Raw.size); map.OpenMap(MapTypes.Internal); } this.rawChunks.Add(Raw); } // light map if (map.BSP.sbsp[w].lightmapident != -1) { map.BR.BaseStream.Position = map.MetaInfo.Offset[TagIndex] + 8; tempr = map.BR.ReadInt32(); if (tempr == 0) { goto skiplightmap; } tempr -= map.BSP.sbsp[w].magic; map.BR.BaseStream.Position = tempr + 128; tempc = map.BR.ReadInt32(); tempr = map.BR.ReadInt32() - map.BSP.sbsp[w].magic; map.BR.BaseStream.Position = tempr + 64; tempc = map.BR.ReadInt32(); tempr = map.BR.ReadInt32() - map.BSP.sbsp[w].magic; for (int x = 0; x < tempc; x++) { RawDataChunk Raw = new RawDataChunk(); Raw.rawDataType = RawDataType.ltmp; Raw.pointerMetaOffset = tempr + (x * 56) + 12 - map.MetaInfo.Offset[TagIndex]; map.BR.BaseStream.Position = tempr + (x * 56) + 12; Raw.offset = map.BR.ReadInt32(); Raw.size = map.BR.ReadInt32(); if (Raw.offset == -1) { this.rawChunks.Add(Raw); continue; } map.Functions.ParsePointer(ref Raw.offset, ref Raw.rawLocation); if (dontreadraw == false) { map.OpenMap(Raw.rawLocation); map.BR.BaseStream.Position = Raw.offset; Raw.MS = new MemoryStream(Raw.size); Raw.MS.Write(map.BR.ReadBytes(Raw.size), 0, Raw.size); map.OpenMap(MapTypes.Internal); } this.rawChunks.Add(Raw); } } skiplightmap: // bsp model 3 map.BR.BaseStream.Position = map.MetaInfo.Offset[TagIndex] + 580; tempc = map.BR.ReadInt32(); tempr = map.BR.ReadInt32() - map.BSP.sbsp[w].magic; // if (tempc==0){return;} map.BR.BaseStream.Position = tempr + 16; tempc = map.BR.ReadInt32(); tempr = map.BR.ReadInt32() - map.BSP.sbsp[w].magic; for (int x = 0; x < tempc; x++) { RawDataChunk Raw = new RawDataChunk(); Raw.rawDataType = RawDataType.bsp3; Raw.pointerMetaOffset = tempr + (x * 44) - map.MetaInfo.Offset[TagIndex]; map.BR.BaseStream.Position = tempr + (x * 44); Raw.offset = map.BR.ReadInt32(); Raw.size = map.BR.ReadInt32(); if (Raw.offset == -1) { this.rawChunks.Add(Raw); continue; } map.Functions.ParsePointer(ref Raw.offset, ref Raw.rawLocation); if (dontreadraw == false) { map.OpenMap(Raw.rawLocation); map.BR.BaseStream.Position = Raw.offset; Raw.MS = new MemoryStream(Raw.size); Raw.MS.Write(map.BR.ReadBytes(Raw.size), 0, Raw.size); map.OpenMap(MapTypes.Internal); } this.rawChunks.Add(Raw); } // bsp model 4 map.BR.BaseStream.Position = map.MetaInfo.Offset[TagIndex] + 548; tempc = map.BR.ReadInt32(); tempr = map.BR.ReadInt32() - map.BSP.sbsp[w].magic; for (int x = 0; x < tempc; x++) { RawDataChunk Raw = new RawDataChunk(); Raw.rawDataType = RawDataType.bsp4; Raw.pointerMetaOffset = tempr + (x * 172) + 16 - map.MetaInfo.Offset[TagIndex]; map.BR.BaseStream.Position = tempr + (x * 172) + 16; Raw.offset = map.BR.ReadInt32(); if (Raw.offset == -1) { continue; } Raw.size = map.BR.ReadInt32(); map.Functions.ParsePointer(ref Raw.offset, ref Raw.rawLocation); if (dontreadraw == false) { map.OpenMap(Raw.rawLocation); map.BR.BaseStream.Position = Raw.offset; Raw.MS = new MemoryStream(Raw.size); Raw.MS.Write(map.BR.ReadBytes(Raw.size), 0, Raw.size); map.OpenMap(MapTypes.Internal); } this.rawChunks.Add(Raw); } }
/// <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 h 2 read. /// </summary> /// <param name="TagIndex">The TagIndex.</param> /// <param name="map">The map.</param> /// <param name="dontreadraw">The dontreadraw.</param> /// <remarks></remarks> public void H2Read(int TagIndex, Map map, bool dontreadraw) { int w = map.BSP.FindBSPNumberByLightMapIdent(map.MetaInfo.Ident[TagIndex]); // light map if (map.BSP.sbsp[w].lightmapident != -1) { int tempr = map.MetaInfo.Offset[TagIndex]; map.BR.BaseStream.Position = tempr + 128; int tempc = map.BR.ReadInt32(); tempr = map.BR.ReadInt32() - map.BSP.sbsp[w].magic; map.BR.BaseStream.Position = tempr + 64; tempc = map.BR.ReadInt32(); tempr = map.BR.ReadInt32() - map.BSP.sbsp[w].magic; for (int x = 0; x < tempc; x++) { RawDataChunk Raw = new RawDataChunk(); Raw.rawDataType = RawDataType.ltmp; Raw.pointerMetaOffset = tempr + (x * 56) + 12 - map.MetaInfo.Offset[TagIndex]; map.BR.BaseStream.Position = tempr + (x * 56) + 12; Raw.offset = map.BR.ReadInt32(); Raw.size = map.BR.ReadInt32(); if (Raw.offset == -1) { this.rawChunks.Add(Raw); continue; } map.Functions.ParsePointer(ref Raw.offset, ref Raw.rawLocation); if (dontreadraw == false) { map.OpenMap(Raw.rawLocation); map.BR.BaseStream.Position = Raw.offset; Raw.MS = new MemoryStream(Raw.size); Raw.MS.Write(map.BR.ReadBytes(Raw.size), 0, Raw.size); map.OpenMap(MapTypes.Internal); } this.rawChunks.Add(Raw); } } }
/// <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 read chunks. /// </summary> /// <param name="map">The map.</param> /// <remarks></remarks> public void ReadChunks(Map map) { map.OpenMap(MapTypes.Internal); for (int x = 0; x < chunks.Count; x++) { LayOutChunk l = (LayOutChunk)chunks[x]; l.Read(map); GC.Collect(0); GC.WaitForPendingFinalizers(); } map.CloseMap(); }
/// <summary> /// The get meta from tag index. /// </summary> /// <param name="tag">The tag.</param> /// <param name="map">The map.</param> /// <param name="manualScan">The manual scan.</param> /// <param name="parse">The parse.</param> /// <returns></returns> /// <remarks></remarks> public static Meta GetMetaFromTagIndex(int tag, Map map, bool manualScan, bool parse) { map.OpenMap(MapTypes.Internal); Meta meta = new Meta(map); meta.TagIndex = tag; meta.ScanMetaItems(manualScan, parse); map.CloseMap(); meta.SortItemsByOffset(); return meta; }
/// <summary> /// Internalizes a bitmap by passing raw data. This was primarily written for the bitmap internalization /// in the mainmenu editor. /// </summary> /// <param name="raw">Entity.RawDataContainer</param> /// <param name="map">Map to add data to</param> /// <remarks></remarks> public static void bitmapInternalizeRaw(ref RawDataContainer raw, Map map) { map.OpenMap(MapTypes.Internal, false); long rawSize = biGetRawTotalSize(raw, false); shift(map.FS, map.MapHeader.indexOffset, rawSize); //long offsetInShared; long offsetToWrite = map.MapHeader.indexOffset; map.BW.BaseStream.Position = offsetToWrite; //byte[] rawData; // loop for each tag //int tempRawSize; // loop for each chunk for (int j = 0; j < raw.rawChunks.Count; j++) { // loop for each LOD { // for (int k = 0; k < bitmapMeta.raw.rawChunks.lod.Count; k++) raw.rawChunks[j].offset = (int)map.BW.BaseStream.Position; raw.rawChunks[j].rawLocation = MapTypes.Internal; map.BW.Write(raw.rawChunks[j].MS.ToArray(), 0, raw.rawChunks[j].size); // writes padding after chunk int paddingSize = genPaddingSize(raw.rawChunks[j].size, 512); map.BW.Write(genPadding(paddingSize, 0)); offsetToWrite += raw.rawChunks[j].size + paddingSize; } } biUpdateMapInfo(map, (int)rawSize); map.CloseMap(); }
/// <summary> /// The halo 2 bsp container. /// </summary> /// <param name="map">The map.</param> /// <remarks></remarks> public void Halo2BSPContainer(Map map) { map.OpenMap(MapTypes.Internal); map.BR.BaseStream.Position = map.MetaInfo.Offset[3] + 528; bspcount = map.BR.ReadInt32(); int tempr = map.BR.ReadInt32() - map.SecondaryMagic; sbsp = new BSPInfo[bspcount]; for (int x = 0; x < bspcount; x++) { sbsp[x] = new BSPInfo(); sbsp[x].pointerOffset = tempr + (x * 68) - map.MetaInfo.Offset[3]; map.BR.BaseStream.Position = tempr + (x * 68); sbsp[x].offset = map.BR.ReadInt32(); map.Functions.ParsePointer(ref sbsp[x].offset, ref sbsp[x].location); sbsp[x].size = map.BR.ReadInt32(); sbsp[x].magic = map.BR.ReadInt32() - sbsp[x].offset; map.BR.BaseStream.Position = tempr + (x * 68) + 20; sbsp[x].ident = map.BR.ReadInt32(); // MessageBox.Show(sbsp[x].ident.ToString("X")); sbsp[x].TagIndex = map.Functions.ForMeta.FindMetaByID(sbsp[x].ident); map.MetaInfo.Offset[sbsp[x].TagIndex] = sbsp[x].offset; map.MetaInfo.Size[sbsp[x].TagIndex] = sbsp[x].size; map.BR.BaseStream.Position = tempr + (x * 68) + 28; sbsp[x].lightmapident = map.BR.ReadInt32(); sbsp[x].lightmapTagIndex = map.Functions.ForMeta.FindMetaByID(sbsp[x].lightmapident); if (sbsp[x].lightmapTagIndex == -1) { continue; } map.BR.BaseStream.Position = sbsp[x].offset + 8; sbsp[x].lightmapoffset = map.BR.ReadInt32(); if (sbsp[x].lightmapoffset == 0) { sbsp[x].lightmapident = -1; sbsp[x].lightmapTagIndex = -1; if ( MessageBox.Show( "There is no lightmap for this bsp and the scenario is currently linked to a broken ID.\n Would you like Entity to fix it?", "Error", MessageBoxButtons.YesNo) == DialogResult.Yes) { map.BW.BaseStream.Position = tempr + (x * 68) + 28; map.BW.Write(int.Parse("FFFFFFFF", NumberStyles.HexNumber)); } continue; } sbsp[x].lightmapoffset += -sbsp[x].magic; sbsp[x].lightmapsize = sbsp[x].size + sbsp[x].offset - sbsp[x].lightmapoffset; map.MetaInfo.Offset[sbsp[x].lightmapTagIndex] = sbsp[x].lightmapoffset; map.MetaInfo.Size[sbsp[x].lightmapTagIndex] = sbsp[x].lightmapsize; // light map bitmap map.BR.BaseStream.Position = sbsp[x].lightmapoffset + 128; int tempc = map.BR.ReadInt32(); int temprx = map.BR.ReadInt32() - sbsp[x].magic; map.BR.BaseStream.Position = temprx + 28; sbsp[x].LightMap_TagNumber = map.Functions.ForMeta.FindMetaByID(map.BR.ReadInt32()); ///light map palettes map.BR.BaseStream.Position = temprx + 8; int tempc2 = map.BR.ReadInt32(); int tempr2 = map.BR.ReadInt32() - sbsp[x].magic; sbsp[x].palettesoffset = tempr2; for (int y = 0; y < tempc2; y++) { map.BR.BaseStream.Position = tempr2 + (y * 1024); Palette_Color[] pc = new Palette_Color[256]; for (int z = 0; z < 256; z++) { pc[z] = new Palette_Color(); pc[z].r = map.BR.ReadByte(); pc[z].g = map.BR.ReadByte(); pc[z].b = map.BR.ReadByte(); pc[z].a = map.BR.ReadByte(); } sbsp[x].LightMap_Palettes.Add(pc); } map.BR.BaseStream.Position = temprx + 40; tempc2 = map.BR.ReadInt32(); tempr2 = map.BR.ReadInt32() - sbsp[x].magic; sbsp[x].VisualChunk_Bitmap_Index = new int[tempc2]; sbsp[x].VisualChunk_LightMap_Index = new int[tempc2]; if (tempc2 != 0) { map.BR.BaseStream.Position = tempr2; for (int y = 0; y < tempc2; y++) { sbsp[x].VisualChunk_Bitmap_Index[y] = map.BR.ReadInt16(); sbsp[x].VisualChunk_LightMap_Index[y] = map.BR.ReadInt16(); } } map.BR.BaseStream.Position = temprx + 72; tempc2 = map.BR.ReadInt32(); tempr2 = map.BR.ReadInt32() - sbsp[x].magic; sbsp[x].SceneryChunk_Bitmap_Index = new int[tempc2]; sbsp[x].SceneryChunk_LightMap_Index = new int[tempc2]; if (tempc2 > 0) { map.BR.BaseStream.Position = tempr2; for (int y = 0; y < tempc2; y++) { sbsp[x].SceneryChunk_Bitmap_Index[y] = map.BR.ReadInt16(); sbsp[x].SceneryChunk_LightMap_Index[y] = map.BR.ReadInt16(); } } } map.CloseMap(); }