Example #1
0
        public void WriteDidX(BinaryWriter bw)
        {
            WemList = new List <Wem>(WemList.OrderBy(i => i.ID));

            bw.Write(DidXTypeString);
            bw.Write(WemList.Count * 12);

            int DataLength = 0;

            int Offset = (int)bw.BaseStream.Position + (WemList.Count * 12);

            for (int i = 0; i < WemList.Count; i++)
            {
                Wem wem = WemList[i];

                if (i == 0)
                {
                    wem.Offset = 0;
                }
                else
                {
                    Wem prevWem = WemList[i - 1];

                    wem.Offset = (uint)(prevWem.Offset + prevWem.File.Length);
                }

                bw.Write((uint)wem.ID);
                bw.Write(wem.Offset);
                bw.Write(wem.File.Length);
                long workingOffset = bw.BaseStream.Position;
                bw.Seek((int)wem.Offset + Offset + 8, SeekOrigin.Begin);
                bw.Write(wem.File);
                bw.Seek((int)workingOffset, SeekOrigin.Begin);
                DataLength += wem.File.Length;
            }

            bw.Write(DATATypeString);
            bw.Write(DataLength);

            Wem lastWem = WemList[WemList.Count - 1];

            bw.Seek((int)lastWem.Offset + (int)lastWem.File.Length + Offset + 8, SeekOrigin.Begin);
        }
Example #2
0
        public void ReadDidX(BinaryReader br)
        {
            uint headerLen = br.ReadUInt32();

            Wems = new DidX(headerLen);
            uint wemCount = headerLen / 12;

            for (int i = 0; i < wemCount; i++)
            {
                uint DidXID     = br.ReadUInt32();
                uint DidXOffset = br.ReadUInt32();
                uint DidXLength = br.ReadUInt32();
                Wems.Data.Add(new DIDXChunk(DidXID, DidXOffset, DidXLength));
            }
            Wems.Offset = br.BaseStream.Position;

            uint DataStartString = br.ReadUInt32();

            if (DataStartString != 1096040772)
            {
                throw new Exception("Failed to read DATA!");
            }

            uint DataLength = br.ReadUInt32();
            long initPos    = br.BaseStream.Position;

            uint ii = 0;

            foreach (DIDXChunk chunk in Wems.Data)
            {
                ii++;
                br.BaseStream.Seek(initPos + chunk.ChunkOffset, SeekOrigin.Begin);
                byte[] file = br.ReadBytes((int)chunk.ChunkLength);
                string name = "Imported_Wem_" + ii;

                Wem newWem = new Wem(name, chunk.ChunkID, file, 0, chunk.ChunkOffset);
                WemList.Add(newWem);
            }
        }
Example #3
0
        public PCK(string fileName)
        {
            using (BinaryReader br = new BinaryReader(new FileStream(fileName, FileMode.Open), Encoding.ASCII))
            {
                char[] MagicBytes = br.ReadChars(4);
                uint   headerLen  = br.ReadUInt32();
                HeaderLength    = headerLen;
                Version         = br.ReadUInt32();
                LanguageLength  = br.ReadUInt32();
                BnkTableLength  = br.ReadUInt32();
                WemATableLength = br.ReadUInt32();
                WemBTableLength = br.ReadUInt32();
                long stringHeaderStart = br.BaseStream.Position;
                uint stringCount       = br.ReadUInt32();

                for (int i = 0; i < stringCount; i++)
                {
                    PCKString stringData = new PCKString(br, stringHeaderStart);
                    PckStrings.Add(stringData);
                }

                br.BaseStream.Seek(stringHeaderStart + LanguageLength, SeekOrigin.Begin);

                uint BnksCount = br.ReadUInt32();

                uint wemACount = br.ReadUInt32();

                for (int i = 0; i < wemACount; i++)
                {
                    ulong ID = br.ReadUInt32();
                    Multiplier = br.ReadUInt32();
                    uint Length        = br.ReadUInt32();
                    uint Offset        = br.ReadUInt32() * Multiplier;
                    uint languageEnum  = br.ReadUInt32();
                    int  workingOffset = (int)br.BaseStream.Position;
                    br.BaseStream.Seek(Offset, SeekOrigin.Begin);
                    byte[] file = br.ReadBytes((int)Length);
                    br.BaseStream.Seek(workingOffset, SeekOrigin.Begin);
                    string name   = "Imported_Wem_" + i;
                    Wem    newWem = new Wem(name, ID, file, languageEnum, Offset);
                    WemList.Add(newWem);
                }

                uint wemBCount = br.ReadUInt32();

                for (int i = 0; i < wemBCount; i++)
                {
                    ulong ID = br.ReadUInt64();
                    Multiplier = br.ReadUInt32();
                    int  Length       = br.ReadInt32();
                    uint Offset       = br.ReadUInt32() * Multiplier;
                    uint languageEnum = br.ReadUInt32();

                    int workingOffset = (int)br.BaseStream.Position;

                    br.BaseStream.Seek(Offset, SeekOrigin.Begin);

                    byte[] file = br.ReadBytes(Length);

                    br.BaseStream.Seek(workingOffset, SeekOrigin.Begin);

                    string name = "Imported_Wem_" + i;

                    Wem newWem = new Wem(name, ID, file, languageEnum, Offset);
                    WemList.Add(newWem);
                }
            }
        }
Example #4
0
        public void WriteToFile(BinaryWriter bw, string BnkPath)
        {
            if (LoadedBNK != null)
            {
                File.Copy(BnkPath, BnkPath + "_old", true);
                using (BinaryWriter bnkWrite = new BinaryWriter(File.Open(BnkPath, FileMode.Create)))
                {
                    LoadedBNK.WriteToFile(bnkWrite);
                }
            }

            if (Multiplier == 0)
            {
                Multiplier = 16;
            }

            WemList = new List <Wem>(WemList.OrderBy(i => i.ID));

            WemAList = new List <int>();
            WemBList = new List <int>();


            foreach (Wem wem in WemList)
            {
                if (wem.ID == (uint)wem.ID)
                {
                    WemAList.Add(WemList.IndexOf(wem));
                }
                else
                {
                    WemBList.Add(WemList.IndexOf(wem));
                }
            }

            for (int i = 0; i < WemList.Count; i++)
            {
                Wem wem = WemList[i];

                if (i == 0)
                {
                    wem.Offset = (uint)Math.Ceiling((decimal)MathHelpers.RoundUp16((int)(40 + WemAList.Count * 20 + WemBList.Count * 24 + LanguageLength), false) / Multiplier);
                }
                else
                {
                    Wem lastWem = WemList[i - 1];
                    wem.Offset = (uint)Math.Ceiling((decimal)MathHelpers.RoundUp16((int)((lastWem.Offset * Multiplier) + lastWem.File.Length), false) / Multiplier);
                }
            }

            List <byte> languageBytes = GenerateLanguageBytes();

            WemATableLength = (uint)(WemAList.Count * 20) + 4;
            WemBTableLength = (uint)(WemBList.Count * 24) + 4;
            BnkTableLength  = 4; //Const in Mafia games
            HeaderLength    = (uint)(WemATableLength + 20 + languageBytes.Count + BnkTableLength + WemBTableLength);

            bw.Write(Magic);
            bw.Write(HeaderLength);
            bw.Write(Version);
            bw.Write(languageBytes.Count);
            bw.Write(BnkTableLength);
            bw.Write(WemATableLength);
            bw.Write(WemBTableLength);

            for (int i = 0; i < languageBytes.Count; i++)
            {
                bw.Write(languageBytes[i]);
            }

            bw.Write(0);

            bw.Write(WemAList.Count);

            foreach (int ID in WemAList)
            {
                Wem wem = WemList[ID];

                bw.Write((uint)wem.ID);
                bw.Write(Multiplier);
                bw.Write(wem.File.Length);
                bw.Write(wem.Offset);
                int workingOffset = (int)bw.BaseStream.Position;
                bw.Seek((int)(wem.Offset * Multiplier), SeekOrigin.Begin);
                bw.Write(wem.File);
                bw.Seek(workingOffset, SeekOrigin.Begin);
                bw.Write(wem.LanguageEnum);
            }

            bw.Write(WemBList.Count);

            foreach (int ID in WemBList)
            {
                Wem wem = WemList[ID];

                bw.Write(wem.ID);
                bw.Write(Multiplier);
                bw.Write(wem.File.Length);
                bw.Write(wem.Offset);
                int workingOffset = (int)bw.BaseStream.Position;
                bw.Seek((int)(wem.Offset * Multiplier), SeekOrigin.Begin);
                bw.Write(wem.File);
                bw.Seek(workingOffset, SeekOrigin.Begin);
                bw.Write(wem.LanguageEnum);
            }

            bw.Close();
        }