Beispiel #1
0
        public object GetColumnData(UTF utf, int row, string Name)
        {
            object result = null;

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



            return(result);
        }
Beispiel #2
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);
            }

            //br.BaseStream.Seek(0xC, SeekOrigin.Current); //skip header data

            ReadUTFData(br);

            ETOC_packet = utf_packet;

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

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

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

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

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

            List <FileEntry> fileEntries = FileTable.Where(x => x.FileType == "FILE").ToList();

            for (int i = 0; i < fileEntries.Count; i++)
            {
                FileTable[i].LocalDir = GetColumnData(files, i, "LocalDir");
                var tUpdateDateTime = GetColumnData(files, i, "UpdateDateTime");
                if (tUpdateDateTime == null)
                {
                    tUpdateDateTime = 0;
                }
                FileTable[i].UpdateDateTime = (ulong)tUpdateDateTime;
            }

            return(true);
        }
Beispiel #3
0
        public object GetColumsData2(UTF utf, int row, string Name, int type)
        {
            object Temp = GetColumnData(utf, row, Name);

            if (Temp == 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);
                }
            }

            if (Temp is ulong)
            {
                return((Temp == null) ? 0xFFFFFFFFFFFFFFFF : (ulong)Temp);
            }

            if (Temp is uint)
            {
                return((Temp == null) ? 0xFFFFFFFF : (uint)Temp);
            }

            if (Temp is ushort)
            {
                return((Temp == null) ? (ushort)0xFFFF : (ushort)Temp);
            }

            return(0);
        }
Beispiel #4
0
        public Type GetColumnType(UTF utf, int row, string Name)
        {
            Type result = null;

            try
            {
                for (int i = 0; i < utf.num_columns; i++)
                {
                    if (utf.columns[i].name == Name)
                    {
                        result = utf.rows[row].rows[i].GetType();
                        break;
                    }
                }
            }
            catch (Exception ex)
            {
                //MessageBox.Show(ex.ToString());
                Console.WriteLine(ex.ToString());
                return(null);
            }

            return(result);
        }
Beispiel #5
0
        public long GetColumnPostion(UTF utf, int row, string Name)
        {
            long result = -1;

            try
            {
                for (int i = 0; i < utf.num_columns; i++)
                {
                    if (utf.columns[i].name == Name)
                    {
                        result = utf.rows[row].rows[i].position;
                        break;
                    }
                }
            }
            catch (Exception ex)
            {
                //MessageBox.Show(ex.ToString());
                Console.WriteLine(ex.ToString());
                return(-1);
            }

            return(result);
        }
Beispiel #6
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;

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

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

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

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

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

            //uint FilesL = (uint)GetColumnData(files, 0, "FilesL");
            //uint FilesH = (uint)GetColumnData(files, 0, "FilesH");
            byte[] DataL    = (byte[])GetColumnData(files, 0, "DataL");
            long   DataLPos = GetColumnPostion(files, 0, "DataL");

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

            //MemoryStream ms;
            //EndianReader ir;
            UTF utfDataL, utfDataH;
            Dictionary <int, uint> SizeTable, CSizeTable;
            Dictionary <int, long> SizePosTable, CSizePosTable;
            Dictionary <int, Type> SizeTypeTable, CSizeTypeTable;

            List <int> 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 (int i = 0; i < utfDataL.num_rows; i++)
                {
                    ID    = (ushort)GetColumnData(utfDataL, i, "ID");
                    size1 = (ushort)GetColumnData(utfDataL, i, "FileSize");
                    SizeTable.Add((int)ID, (uint)size1);

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

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

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

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

                        type = GetColumnType(utfDataL, i, "ExtractSize");
                        CSizeTypeTable.Add((int)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 (int 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((int)ID, pos + DataHPos);

                    type = GetColumnType(utfDataH, i, "FileSize");
                    SizeTypeTable.Add((int)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((int)ID, pos + DataHPos);

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

                    IDs.Add(ID);
                }
            }

            FileEntry temp;
            //int id = 0;
            uint  value = 0, value2 = 0;
            ulong baseoffset = ContentOffset;

            // Seems ITOC can mix up the IDs..... but they'll alwaysy be in order...
            IDs = IDs.OrderBy(x => x).ToList();


            for (int i = 0; i < IDs.Count; i++)
            {
                int id = IDs[i];

                temp = new FileEntry();
                SizeTable.TryGetValue(id, out value);
                CSizeTable.TryGetValue(id, out value2);

                temp.TOCName = "ITOC";

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

                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;
                }


                //id++;
            }

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

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


            return(true);
        }
Beispiel #7
0
        public bool ReadCPK(string sPath, Encoding encoding = null)
        {
            if (File.Exists(sPath))
            {
                uint   Files;
                ushort Align;

                EndianReader 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;

                FileEntry 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, encoding))
                {
                    br.Close();
                    return(false);
                }

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

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

                try
                {
                    for (int i = 0; i < utf.columns.Count; i++)
                    {
                        cpkdata.Add(utf.columns[i].name, utf.rows[0].rows[i].GetValue());
                    }
                }
                catch (Exception ex)
                {
                    //MessageBox.Show(ex.ToString());
                    Console.WriteLine(ex.ToString());
                }

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

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

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

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

                ContentOffset = (ulong)GetColumsData2(utf, 0, "ContentOffset", 3);
                long 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)
                {
                    FileEntry entry = CreateFileEntry("TOC_HDR", TocOffset, typeof(ulong), TocOffsetPos, "CPK", "HDR", false);
                    FileTable.Add(entry);

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

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

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

                if (ItocOffset != 0xFFFFFFFFFFFFFFFF)
                {
                    //FileEntry ITOC_entry = new FileEntry {
                    //    FileName = "ITOC_HDR",
                    //    FileOffset = ItocOffset, FileOffsetType = typeof(ulong), FileOffsetPos = ITocOffsetPos,
                    //    TOCName = "CPK",
                    //    FileType = "FILE", Encrypted = true,
                    //};

                    FileEntry 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)
                {
                    FileEntry entry = CreateFileEntry("GTOC_HDR", GtocOffset, typeof(ulong), GTocOffsetPos, "CPK", "HDR", false);
                    FileTable.Add(entry);

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

                br.Close();

                // at this point, we should have all needed file info

                //utf = null;
                files = null;
                return(true);
            }
            return(false);
        }
Beispiel #8
0
        public bool ReadTOC(EndianReader br, ulong TocOffset, ulong ContentOffset, Encoding encoding = null)
        {
            ulong fTocOffset = TocOffset;
            ulong add_offset = 0;

            if (fTocOffset > (ulong)0x800)
            {
                fTocOffset = (ulong)0x800;
            }


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

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

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

            ReadUTFData(br);

            // Store unencrypted TOC
            TOC_packet = utf_packet;

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

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

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

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

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

            FileEntry temp;

            for (int i = 0; i < files.num_rows; i++)
            {
                temp = new FileEntry();

                temp.TOCName = "TOC";

                temp.DirName  = GetColumnData(files, i, "DirName");
                temp.FileName = GetColumnData(files, i, "FileName");

                temp.FileSize     = GetColumnData(files, i, "FileSize");
                temp.FileSizePos  = GetColumnPostion(files, i, "FileSize");
                temp.FileSizeType = GetColumnType(files, i, "FileSize");

                temp.ExtractSize     = GetColumnData(files, i, "ExtractSize");
                temp.ExtractSizePos  = GetColumnPostion(files, i, "ExtractSize");
                temp.ExtractSizeType = GetColumnType(files, i, "ExtractSize");

                temp.FileOffset     = ((ulong)GetColumnData(files, i, "FileOffset") + (ulong)add_offset);
                temp.FileOffsetPos  = GetColumnPostion(files, i, "FileOffset");
                temp.FileOffsetType = GetColumnType(files, i, "FileOffset");

                temp.FileType = "FILE";

                temp.Offset = add_offset;

                temp.ID         = GetColumnData(files, i, "ID");
                temp.UserString = GetColumnData(files, i, "UserString");

                FileTable.Add(temp);
            }
            files = null;

            return(true);
        }