Пример #1
0
        public bool ReadETOC(EndianReader br, ulong startoffset)
        {
            br.BaseStream.Seek((long)startoffset, SeekOrigin.Begin);

            if (tools.ReadCString(br, 4) != "ETOC")
            {
                br.Close();
                return(false);
            }


            ReadUTFData(br);

            ETOC_packet = utf_packet;

            var etoc_entry = FileTable.Where(x => x.FileName.ToString() == "ETOC_HDR").Single();

            etoc_entry.Encrypted = isUtfEncrypted;
            etoc_entry.FileSize  = ETOC_packet.Length;

            var ms   = new MemoryStream(utf_packet);
            var utfr = new EndianReader(ms, false);

            files = new UTF(tools);
            if (!files.ReadUTF(utfr))
            {
                br.Close();
                return(false);
            }

            utfr.Close();
            ms.Close();

            var fileEntries = FileTable.Where(x => x.FileType == "FILE").ToList();

            for (var i = 0; i < fileEntries.Count; i++)
            {
                FileTable[i].LocalDir = GetColumnData(files, i, "LocalDir");
            }

            return(true);
        }
Пример #2
0
        public Type GetColumnType(UTF utf, int row, string Name)
        {
            Type result = null;

            try
            {
                for (var i = 0; i < utf.num_columns; i++)
                {
                    if (utf.columns[i].name == Name)
                    {
                        result = utf.rows[row].rows[i].GetType();
                        break;
                    }
                }
            }
            catch (Exception)
            {
                return(null);
            }

            return(result);
        }
Пример #3
0
        public long GetColumnPostion(UTF utf, int row, string Name)
        {
            long result = -1;

            try
            {
                for (var i = 0; i < utf.num_columns; i++)
                {
                    if (utf.columns[i].name == Name)
                    {
                        result = utf.rows[row].rows[i].position;
                        break;
                    }
                }
            }
            catch (Exception)
            {
                return(-1);
            }

            return(result);
        }
Пример #4
0
        public object GetColumnData(UTF utf, int row, string Name)
        {
            object result = null;

            try
            {
                for (var i = 0; i < utf.num_columns; i++)
                {
                    if (utf.columns[i].name == Name)
                    {
                        result = utf.rows[row].rows[i].GetValue();
                        break;
                    }
                }
            }
            catch (Exception)
            {
                return(null);
            }


            return(result);
        }
Пример #5
0
        public object GetColumsData2(UTF utf, int row, string Name, int type)
        {
            var Temp = GetColumnData(utf, row, Name);

            switch (Temp)
            {
            case null:
                switch (type)
                {
                case 0:         // byte
                    return((byte)0xFF);

                case 1:         // short
                    return((ushort)0xFFFF);

                case 2:         // int
                    return(0xFFFFFFFF);

                case 3:         // long
                    return(0xFFFFFFFFFFFFFFFF);
                }

                break;

            case ulong temp:
                return(Temp == null ? 0xFFFFFFFFFFFFFFFF : temp);

            case uint temp:
                return(Temp == null ? 0xFFFFFFFF : temp);

            case ushort temp:
                return(Temp == null ? (ushort)0xFFFF : temp);
            }

            return(0);
        }
Пример #6
0
        public bool ReadCPK(string sPath)
        {
            if (!File.Exists(sPath))
            {
                return(false);
            }
            uint   Files;
            ushort Align;

            var          br = new EndianReader(File.OpenRead(sPath), true);
            MemoryStream ms;
            EndianReader utfr;

            if (tools.ReadCString(br, 4) != "CPK ")
            {
                br.Close();
                return(false);
            }

            ReadUTFData(br);

            CPK_packet = utf_packet;

            var CPAK_entry = new FileEntry
            {
                FileName      = "CPK_HDR",
                FileOffsetPos = br.BaseStream.Position + 0x10,
                FileSize      = CPK_packet.Length,
                Encrypted     = isUtfEncrypted,
                FileType      = "CPK"
            };

            FileTable.Add(CPAK_entry);

            ms   = new MemoryStream(utf_packet);
            utfr = new EndianReader(ms, false);

            utf = new UTF(tools);
            if (!utf.ReadUTF(utfr))
            {
                br.Close();
                return(false);
            }

            utfr.Close();
            ms.Close();

            cpkdata = new Dictionary <string, object>();

            try
            {
                for (var i = 0; i < utf.columns.Count; i++)
                {
                    cpkdata.Add(utf.columns[i].name, utf.rows[0].rows[i].GetValue());
                }
            }
            catch (Exception)
            {
                //ignore
            }

            TocOffset = (ulong)GetColumsData2(utf, 0, "TocOffset", 3);
            var TocOffsetPos = GetColumnPostion(utf, 0, "TocOffset");

            EtocOffset = (ulong)GetColumsData2(utf, 0, "EtocOffset", 3);
            var ETocOffsetPos = GetColumnPostion(utf, 0, "EtocOffset");

            ItocOffset = (ulong)GetColumsData2(utf, 0, "ItocOffset", 3);
            var ITocOffsetPos = GetColumnPostion(utf, 0, "ItocOffset");

            GtocOffset = (ulong)GetColumsData2(utf, 0, "GtocOffset", 3);
            var GTocOffsetPos = GetColumnPostion(utf, 0, "GtocOffset");

            ContentOffset = (ulong)GetColumsData2(utf, 0, "ContentOffset", 3);
            var ContentOffsetPos = GetColumnPostion(utf, 0, "ContentOffset");

            FileTable.Add(CreateFileEntry("CONTENT_OFFSET", ContentOffset, typeof(ulong), ContentOffsetPos, "CPK",
                                          "CONTENT", false));

            Files = (uint)GetColumsData2(utf, 0, "Files", 2);
            Align = (ushort)GetColumsData2(utf, 0, "Align", 1);

            if (TocOffset != 0xFFFFFFFFFFFFFFFF)
            {
                var entry = CreateFileEntry("TOC_HDR", TocOffset, typeof(ulong), TocOffsetPos, "CPK", "HDR", false);
                FileTable.Add(entry);

                if (!ReadTOC(br, TocOffset, ContentOffset))
                {
                    return(false);
                }
            }

            if (EtocOffset != 0xFFFFFFFFFFFFFFFF)
            {
                var entry = CreateFileEntry("ETOC_HDR", EtocOffset, typeof(ulong), ETocOffsetPos, "CPK", "HDR",
                                            false);
                FileTable.Add(entry);

                if (!ReadETOC(br, EtocOffset))
                {
                    return(false);
                }
            }

            if (ItocOffset != 0xFFFFFFFFFFFFFFFF)
            {
                var entry = CreateFileEntry("ITOC_HDR", ItocOffset, typeof(ulong), ITocOffsetPos, "CPK", "HDR",
                                            false);
                FileTable.Add(entry);

                if (!ReadITOC(br, ItocOffset, ContentOffset, Align))
                {
                    return(false);
                }
            }

            if (GtocOffset != 0xFFFFFFFFFFFFFFFF)
            {
                var entry = CreateFileEntry("GTOC_HDR", GtocOffset, typeof(ulong), GTocOffsetPos, "CPK", "HDR",
                                            false);
                FileTable.Add(entry);

                if (!ReadGTOC(br, GtocOffset))
                {
                    return(false);
                }
            }

            br.Close();

            files = null;
            return(true);
        }
Пример #7
0
        public bool ReadITOC(EndianReader br, ulong startoffset, ulong ContentOffset, ushort Align)
        {
            br.BaseStream.Seek((long)startoffset, SeekOrigin.Begin);

            if (tools.ReadCString(br, 4) != "ITOC")
            {
                br.Close();
                return(false);
            }

            ReadUTFData(br);

            ITOC_packet = utf_packet;

            var itoc_entry = FileTable.Where(x => x.FileName.ToString() == "ITOC_HDR").Single();

            itoc_entry.Encrypted = isUtfEncrypted;
            itoc_entry.FileSize  = ITOC_packet.Length;

            var ms   = new MemoryStream(utf_packet);
            var utfr = new EndianReader(ms, false);

            files = new UTF(tools);
            if (!files.ReadUTF(utfr))
            {
                br.Close();
                return(false);
            }

            utfr.Close();
            ms.Close();

            var DataL    = (byte[])GetColumnData(files, 0, "DataL");
            var DataLPos = GetColumnPostion(files, 0, "DataL");

            var DataH    = (byte[])GetColumnData(files, 0, "DataH");
            var DataHPos = GetColumnPostion(files, 0, "DataH");

            UTF utfDataL, utfDataH;
            Dictionary <int, uint> SizeTable, CSizeTable;
            Dictionary <int, long> SizePosTable, CSizePosTable;
            Dictionary <int, Type> SizeTypeTable, CSizeTypeTable;

            var IDs = new List <int>();

            SizeTable     = new Dictionary <int, uint>();
            SizePosTable  = new Dictionary <int, long>();
            SizeTypeTable = new Dictionary <int, Type>();

            CSizeTable     = new Dictionary <int, uint>();
            CSizePosTable  = new Dictionary <int, long>();
            CSizeTypeTable = new Dictionary <int, Type>();

            ushort ID, size1;
            uint   size2;
            long   pos;
            Type   type;

            if (DataL != null)
            {
                ms       = new MemoryStream(DataL);
                utfr     = new EndianReader(ms, false);
                utfDataL = new UTF(tools);
                utfDataL.ReadUTF(utfr);

                for (var i = 0; i < utfDataL.num_rows; i++)
                {
                    ID    = (ushort)GetColumnData(utfDataL, i, "ID");
                    size1 = (ushort)GetColumnData(utfDataL, i, "FileSize");
                    SizeTable.Add(ID, size1);

                    pos = GetColumnPostion(utfDataL, i, "FileSize");
                    SizePosTable.Add(ID, pos + DataLPos);

                    type = GetColumnType(utfDataL, i, "FileSize");
                    SizeTypeTable.Add(ID, type);

                    if (GetColumnData(utfDataL, i, "ExtractSize") != null)
                    {
                        size1 = (ushort)GetColumnData(utfDataL, i, "ExtractSize");
                        CSizeTable.Add(ID, size1);

                        pos = GetColumnPostion(utfDataL, i, "ExtractSize");
                        CSizePosTable.Add(ID, pos + DataLPos);

                        type = GetColumnType(utfDataL, i, "ExtractSize");
                        CSizeTypeTable.Add(ID, type);
                    }

                    IDs.Add(ID);
                }
            }

            if (DataH != null)
            {
                ms       = new MemoryStream(DataH);
                utfr     = new EndianReader(ms, false);
                utfDataH = new UTF(tools);
                utfDataH.ReadUTF(utfr);

                for (var i = 0; i < utfDataH.num_rows; i++)
                {
                    ID    = (ushort)GetColumnData(utfDataH, i, "ID");
                    size2 = (uint)GetColumnData(utfDataH, i, "FileSize");
                    SizeTable.Add(ID, size2);

                    pos = GetColumnPostion(utfDataH, i, "FileSize");
                    SizePosTable.Add(ID, pos + DataHPos);

                    type = GetColumnType(utfDataH, i, "FileSize");
                    SizeTypeTable.Add(ID, type);

                    if (GetColumnData(utfDataH, i, "ExtractSize") != null)
                    {
                        size2 = (uint)GetColumnData(utfDataH, i, "ExtractSize");
                        CSizeTable.Add(ID, size2);

                        pos = GetColumnPostion(utfDataH, i, "ExtractSize");
                        CSizePosTable.Add(ID, pos + DataHPos);

                        type = GetColumnType(utfDataH, i, "ExtractSize");
                        CSizeTypeTable.Add(ID, type);
                    }

                    IDs.Add(ID);
                }
            }

            FileEntry temp;
            uint      value = 0, value2 = 0;
            var       baseoffset = ContentOffset;

            IDs = IDs.OrderBy(x => x).ToList();


            foreach (var id in IDs)
            {
                temp = new FileEntry();
                SizeTable.TryGetValue(id, out value);
                CSizeTable.TryGetValue(id, out value2);

                temp.TOCName = "ITOC";

                temp.DirName  = null;
                temp.FileName = id.ToString("D4");

                temp.FileSize     = value;
                temp.FileSizePos  = SizePosTable[id];
                temp.FileSizeType = SizeTypeTable[id];

                if (CSizeTable.Count > 0 && CSizeTable.ContainsKey(id))
                {
                    temp.ExtractSize     = value2;
                    temp.ExtractSizePos  = CSizePosTable[id];
                    temp.ExtractSizeType = CSizeTypeTable[id];
                }

                temp.FileType = "FILE";


                temp.FileOffset = baseoffset;
                temp.ID         = id;
                temp.UserString = null;

                FileTable.Add(temp);

                if (value % Align > 0)
                {
                    baseoffset += value + (Align - value % Align);
                }
                else
                {
                    baseoffset += value;
                }
            }

            files    = null;
            utfDataL = null;
            utfDataH = null;

            ms.Close();
            utfr.Close();


            return(true);
        }
Пример #8
0
        public bool ReadTOC(EndianReader br, ulong TocOffset, ulong ContentOffset)
        {
            ulong add_offset = 0;

            if (ContentOffset < 0)
            {
                add_offset = TocOffset;
            }
            else
            {
                if (TocOffset < 0)
                {
                    add_offset = ContentOffset;
                }
                else
                {
                    add_offset = ContentOffset < TocOffset ? ContentOffset : TocOffset;
                }
            }

            br.BaseStream.Seek((long)TocOffset, SeekOrigin.Begin);

            if (tools.ReadCString(br, 4) != "TOC ")
            {
                br.Close();
                return(false);
            }

            ReadUTFData(br);

            TOC_packet = utf_packet;

            var toc_entry = FileTable.Where(x => x.FileName.ToString() == "TOC_HDR").Single();

            toc_entry.Encrypted = isUtfEncrypted;
            toc_entry.FileSize  = TOC_packet.Length;

            var ms   = new MemoryStream(utf_packet);
            var utfr = new EndianReader(ms, false);

            files = new UTF(tools);
            if (!files.ReadUTF(utfr))
            {
                br.Close();
                return(false);
            }

            utfr.Close();
            ms.Close();

            FileEntry temp;

            for (var i = 0; i < files.num_rows; i++)
            {
                temp = new FileEntry
                {
                    TOCName         = "TOC",
                    DirName         = GetColumnData(files, i, "DirName"),
                    FileName        = GetColumnData(files, i, "FileName"),
                    FileSize        = GetColumnData(files, i, "FileSize"),
                    FileSizePos     = GetColumnPostion(files, i, "FileSize"),
                    FileSizeType    = GetColumnType(files, i, "FileSize"),
                    ExtractSize     = GetColumnData(files, i, "ExtractSize"),
                    ExtractSizePos  = GetColumnPostion(files, i, "ExtractSize"),
                    ExtractSizeType = GetColumnType(files, i, "ExtractSize"),
                    FileOffset      = (ulong)GetColumnData(files, i, "FileOffset") + add_offset,
                    FileOffsetPos   = GetColumnPostion(files, i, "FileOffset"),
                    FileOffsetType  = GetColumnType(files, i, "FileOffset"),
                    FileType        = "FILE",
                    Offset          = add_offset,
                    ID         = GetColumnData(files, i, "ID"),
                    UserString = GetColumnData(files, i, "UserString")
                };

                FileTable.Add(temp);
            }

            files = null;

            return(true);
        }