1493 lines
47 KiB
C#
1493 lines
47 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using System.Linq;
|
||
using System.Text;
|
||
using System.IO;
|
||
using System.Runtime.InteropServices;
|
||
using LibCRIComp;
|
||
|
||
namespace LibCPK
|
||
{
|
||
public class CPK
|
||
{
|
||
public List<FileEntry> FileTable;
|
||
public Dictionary<string, object> cpkdata;
|
||
public UTF utf;
|
||
|
||
Tools tools;
|
||
UTF files;
|
||
|
||
public CPK(Tools tool)
|
||
{
|
||
tools = tool;
|
||
isUtfEncrypted = false;
|
||
FileTable = new List<FileEntry>();
|
||
}
|
||
|
||
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;
|
||
}
|
||
|
||
FileEntry CreateFileEntry(string FileName, ulong FileOffset, Type FileOffsetType, long FileOffsetPos, string TOCName, string FileType, bool encrypted)
|
||
{
|
||
FileEntry entry = new FileEntry
|
||
{
|
||
FileName = FileName,
|
||
FileOffset = FileOffset,
|
||
FileOffsetType = FileOffsetType,
|
||
FileOffsetPos = FileOffsetPos,
|
||
TOCName = TOCName,
|
||
FileType = FileType,
|
||
Encrypted = encrypted,
|
||
};
|
||
|
||
return entry;
|
||
}
|
||
|
||
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;
|
||
}
|
||
|
||
public void WriteCPK(BinaryWriter cpk)
|
||
{
|
||
WritePacket(cpk, "CPK ", 0, CPK_packet);
|
||
|
||
cpk.BaseStream.Seek(0x800 - 6, SeekOrigin.Begin);
|
||
cpk.Write(Encoding.ASCII.GetBytes("(c)CRI"));
|
||
if ((TocOffset > 0x800) && TocOffset < 0x8000)
|
||
{
|
||
//部分cpk是从0x2000开始TOC，所以
|
||
//需要计算 cpk padding
|
||
cpk.Write(new byte[TocOffset - 0x800]);
|
||
}
|
||
}
|
||
|
||
public void WriteTOC(BinaryWriter cpk)
|
||
{
|
||
WritePacket(cpk, "TOC ", TocOffset, TOC_packet);
|
||
}
|
||
|
||
public void WriteITOC(BinaryWriter cpk)
|
||
{
|
||
WritePacket(cpk, "ITOC", ItocOffset, ITOC_packet);
|
||
}
|
||
|
||
public void WriteETOC(BinaryWriter cpk, ulong currentEtocOffset)
|
||
{
|
||
WritePacket(cpk, "ETOC", currentEtocOffset, ETOC_packet);
|
||
}
|
||
|
||
public void WriteGTOC(BinaryWriter cpk)
|
||
{
|
||
WritePacket(cpk, "GTOC", GtocOffset, GTOC_packet);
|
||
}
|
||
|
||
public void WritePacket(BinaryWriter cpk, string ID, ulong position, byte[] packet)
|
||
{
|
||
if (position != 0xffffffffffffffff)
|
||
{
|
||
cpk.BaseStream.Seek((long)position, SeekOrigin.Begin);
|
||
byte[] encrypted;
|
||
if (isUtfEncrypted == true)
|
||
{
|
||
encrypted = DecryptUTF(packet); // Yes it says decrypt...
|
||
}
|
||
else
|
||
{
|
||
encrypted = packet;
|
||
}
|
||
|
||
cpk.Write(Encoding.ASCII.GetBytes(ID));
|
||
cpk.Write((Int32)0xff);
|
||
cpk.Write((UInt64)encrypted.Length);
|
||
cpk.Write(encrypted);
|
||
}
|
||
}
|
||
|
||
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;
|
||
}
|
||
|
||
private void ReadUTFData(EndianReader br)
|
||
{
|
||
isUtfEncrypted = false;
|
||
br.IsLittleEndian = true;
|
||
|
||
unk1 = br.ReadInt32();
|
||
utf_size = br.ReadInt64();
|
||
utf_packet = br.ReadBytes((int)utf_size);
|
||
|
||
if (utf_packet[0] != 0x40 && utf_packet[1] != 0x55 && utf_packet[2] != 0x54 && utf_packet[3] != 0x46) //@UTF
|
||
{
|
||
utf_packet = DecryptUTF(utf_packet);
|
||
isUtfEncrypted = true;
|
||
}
|
||
|
||
br.IsLittleEndian = false;
|
||
}
|
||
|
||
public bool ReadGTOC(EndianReader br, ulong startoffset)
|
||
{
|
||
br.BaseStream.Seek((long)startoffset, SeekOrigin.Begin);
|
||
|
||
if (tools.ReadCString(br, 4) != "GTOC")
|
||
{
|
||
br.Close();
|
||
return false;
|
||
}
|
||
|
||
//br.BaseStream.Seek(0xC, SeekOrigin.Current); //skip header data
|
||
ReadUTFData(br);
|
||
|
||
GTOC_packet = utf_packet;
|
||
FileEntry gtoc_entry = FileTable.Where(x => x.FileName.ToString() == "GTOC_HDR").Single();
|
||
gtoc_entry.Encrypted = isUtfEncrypted;
|
||
gtoc_entry.FileSize = GTOC_packet.Length;
|
||
|
||
|
||
return true;
|
||
}
|
||
|
||
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");
|
||
FileTable[i].UpdateDateTime = (ulong)GetColumnData(files, i, "UpdateDateTime");
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
public byte[] DecryptUTF(byte[] input)
|
||
{
|
||
byte[] result = new byte[input.Length];
|
||
|
||
int m, t;
|
||
byte d;
|
||
|
||
m = 0x0000655f;
|
||
t = 0x00004115;
|
||
|
||
for (int i = 0; i < input.Length; i++)
|
||
{
|
||
d = input[i];
|
||
d = (byte)(d ^ (byte)(m & 0xff));
|
||
result[i] = d;
|
||
m *= t;
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
/*unsafe public int CRICompress(byte* dest, int* destLen, byte* src, int srcLen)
|
||
{
|
||
int n = srcLen - 1, m = *destLen - 0x1, T = 0, d = 0;
|
||
|
||
int p, q = 0, i, j, k;
|
||
byte* odest = dest;
|
||
for (; n >= 0x100; )
|
||
{
|
||
j = n + 3 + 0x2000;
|
||
if (j > srcLen) j = srcLen;
|
||
for (i = n + 3, p = 0; i < j; i++)
|
||
{
|
||
for (k = 0; k <= n - 0x100; k++)
|
||
{
|
||
if (*(src + n - k) != *(src + i - k)) break;
|
||
}
|
||
if (k > p)
|
||
{
|
||
q = i - n - 3;
|
||
p = k;
|
||
}
|
||
}
|
||
if (p < 3)
|
||
{
|
||
d = (d << 9) | (*(src + n--));
|
||
T += 9;
|
||
}
|
||
else
|
||
{
|
||
d = (((d << 1) | 1) << 13) | q;
|
||
|
||
T += 14; n -= p;
|
||
if (p < 6)
|
||
{
|
||
d = (d << 2) | (p - 3); T += 2;
|
||
}
|
||
else if (p < 13)
|
||
{
|
||
d = (((d << 2) | 3) << 3) | (p - 6); T += 5;
|
||
}
|
||
else if (p < 44)
|
||
{
|
||
d = (((d << 5) | 0x1f) << 5) | (p - 13); T += 10;
|
||
}
|
||
else
|
||
{
|
||
d = ((d << 10) | 0x3ff); T += 10; p -= 44;
|
||
for (; ; )
|
||
{
|
||
for (; T >= 8; )
|
||
{
|
||
*(dest + m--) = (byte)((d >> (T - 8)) & 0xff);
|
||
T -= 8; d = d & ((1 << T) - 1);
|
||
}
|
||
if (p < 255) break;
|
||
d = (d << 8) | 0xff; T += 8; p = p - 0xff;
|
||
}
|
||
d = (d << 8) | p; T += 8;
|
||
}
|
||
}
|
||
for (; T >= 8; )
|
||
{
|
||
*(dest + m--) = (byte)((d >> (T - 8)) & 0xff);
|
||
T -= 8;
|
||
d = d & ((1 << T) - 1);
|
||
}
|
||
}
|
||
if (T != 0)
|
||
{
|
||
*(dest + m--) = (byte)(d << (8 - T));
|
||
}
|
||
|
||
*(dest + m--) = 0; *(dest + m) = 0;
|
||
for (; ; )
|
||
{
|
||
if (((*destLen - m) & 3) == 0) break;
|
||
*(dest + m--) = 0;
|
||
}
|
||
|
||
*destLen = *destLen - m;
|
||
dest += m;
|
||
|
||
int[] l = { 0x4c495243, 0x414c5941, srcLen - 0x100, *destLen };
|
||
|
||
for (j = 0; j < 4; j++)
|
||
{
|
||
for (i = 0; i < 4; i++)
|
||
{
|
||
*(odest + i + j * 4) = (byte)(l[j] & 0xff);
|
||
l[j] >>= 8;
|
||
}
|
||
}
|
||
for (j = 0, odest += 0x10; j < *destLen; j++)
|
||
{
|
||
*(odest++) = *(dest + j);
|
||
}
|
||
for (j = 0; j < 0x100; j++)
|
||
{
|
||
*(odest++) = *(src + j);
|
||
}
|
||
*destLen += 0x110;
|
||
|
||
return *destLen;
|
||
}*/
|
||
// unsafe指针在.NET 4.5下似乎很不稳定，有时出现“尝试读取或写入受保护的内存， 这通常指示其它内存已损坏”的错误
|
||
// 目前将CRICompress方法移动到了CLR类库中使用。
|
||
unsafe public byte[] CompressCRILAYLA(byte[] input)
|
||
{
|
||
unsafe
|
||
{
|
||
fixed (byte* src = input, dst = new byte[input.Length])
|
||
{
|
||
//Move cricompress to CLR
|
||
int destLength = (int)input.Length;
|
||
|
||
int result = LibCRIComp.CriCompression.CRIcompress(dst, &destLength, src, input.Length);
|
||
byte[] arr = new byte[destLength];
|
||
Marshal.Copy((IntPtr)dst, arr, 0, destLength);
|
||
return arr;
|
||
}
|
||
}
|
||
|
||
/*unsafe
|
||
{
|
||
|
||
int destLength = (int)input.Length;
|
||
fixed (byte* src = input)
|
||
fixed (byte* dest = new byte[input.Length])
|
||
{
|
||
|
||
destLength = CRICompress(dest, &destLength, src, input.Length);
|
||
byte[] arr = new byte[destLength];
|
||
Marshal.Copy((IntPtr)dest, arr, 0, destLength);
|
||
|
||
|
||
return arr;
|
||
}
|
||
}*/
|
||
|
||
}
|
||
|
||
public byte[] DecompressCRILAYLA(byte[] input, int USize)
|
||
{
|
||
byte[] result;// = new byte[USize];
|
||
|
||
MemoryStream ms = new MemoryStream(input);
|
||
EndianReader br = new EndianReader(ms, true);
|
||
|
||
br.BaseStream.Seek(8, SeekOrigin.Begin); // Skip CRILAYLA
|
||
int uncompressed_size = br.ReadInt32();
|
||
int uncompressed_header_offset = br.ReadInt32();
|
||
|
||
result = new byte[uncompressed_size + 0x100];
|
||
|
||
// do some error checks here.........
|
||
|
||
// copy uncompressed 0x100 header to start of file
|
||
Array.Copy(input, uncompressed_header_offset + 0x10, result, 0, 0x100);
|
||
|
||
int input_end = input.Length - 0x100 - 1;
|
||
int input_offset = input_end;
|
||
int output_end = 0x100 + uncompressed_size - 1;
|
||
byte bit_pool = 0;
|
||
int bits_left = 0, bytes_output = 0;
|
||
int[] vle_lens = new int[4] { 2, 3, 5, 8 };
|
||
|
||
while (bytes_output < uncompressed_size)
|
||
{
|
||
if (get_next_bits(input, ref input_offset, ref bit_pool, ref bits_left, 1) > 0)
|
||
{
|
||
int backreference_offset = output_end - bytes_output + get_next_bits(input, ref input_offset, ref bit_pool, ref bits_left, 13) + 3;
|
||
int backreference_length = 3;
|
||
int vle_level;
|
||
|
||
for (vle_level = 0; vle_level < vle_lens.Length; vle_level++)
|
||
{
|
||
int this_level = get_next_bits(input, ref input_offset, ref bit_pool, ref bits_left, vle_lens[vle_level]);
|
||
backreference_length += this_level;
|
||
if (this_level != ((1 << vle_lens[vle_level]) - 1)) break;
|
||
}
|
||
|
||
if (vle_level == vle_lens.Length)
|
||
{
|
||
int this_level;
|
||
do
|
||
{
|
||
this_level = get_next_bits(input, ref input_offset, ref bit_pool, ref bits_left, 8);
|
||
backreference_length += this_level;
|
||
} while (this_level == 255);
|
||
}
|
||
|
||
for (int i = 0; i < backreference_length; i++)
|
||
{
|
||
result[output_end - bytes_output] = result[backreference_offset--];
|
||
bytes_output++;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// verbatim byte
|
||
result[output_end - bytes_output] = (byte)get_next_bits(input, ref input_offset, ref bit_pool, ref bits_left, 8);
|
||
bytes_output++;
|
||
}
|
||
}
|
||
|
||
br.Close();
|
||
ms.Close();
|
||
|
||
return result;
|
||
}
|
||
|
||
public byte[] DecompressLegacyCRI(byte[] input, int USize)
|
||
{
|
||
byte[] result;// = new byte[USize];
|
||
|
||
MemoryStream ms = new MemoryStream(input);
|
||
EndianReader br = new EndianReader(ms, true);
|
||
|
||
br.BaseStream.Seek(8, SeekOrigin.Begin); // Skip CRILAYLA
|
||
int uncompressed_size = br.ReadInt32();
|
||
int uncompressed_header_offset = br.ReadInt32();
|
||
|
||
result = new byte[uncompressed_size + 0x100];
|
||
|
||
// do some error checks here.........
|
||
|
||
// copy uncompressed 0x100 header to start of file
|
||
Array.Copy(input, uncompressed_header_offset + 0x10, result, 0, 0x100);
|
||
|
||
int input_end = input.Length - 0x100 - 1;
|
||
int input_offset = input_end;
|
||
int output_end = 0x100 + uncompressed_size - 1;
|
||
byte bit_pool = 0;
|
||
int bits_left = 0, bytes_output = 0;
|
||
int[] vle_lens = new int[4] { 2, 3, 5, 8 };
|
||
|
||
while (bytes_output < uncompressed_size)
|
||
{
|
||
if (get_next_bits(input, ref input_offset, ref bit_pool, ref bits_left, 1) > 0)
|
||
{
|
||
int backreference_offset = output_end - bytes_output + get_next_bits(input, ref input_offset, ref bit_pool, ref bits_left, 13) + 3;
|
||
int backreference_length = 3;
|
||
int vle_level;
|
||
|
||
for (vle_level = 0; vle_level < vle_lens.Length; vle_level++)
|
||
{
|
||
int this_level = get_next_bits(input, ref input_offset, ref bit_pool, ref bits_left, vle_lens[vle_level]);
|
||
backreference_length += this_level;
|
||
if (this_level != ((1 << vle_lens[vle_level]) - 1)) break;
|
||
}
|
||
|
||
if (vle_level == vle_lens.Length)
|
||
{
|
||
int this_level;
|
||
do
|
||
{
|
||
this_level = get_next_bits(input, ref input_offset, ref bit_pool, ref bits_left, 8);
|
||
backreference_length += this_level;
|
||
} while (this_level == 255);
|
||
}
|
||
|
||
for (int i = 0; i < backreference_length; i++)
|
||
{
|
||
result[output_end - bytes_output] = result[backreference_offset--];
|
||
bytes_output++;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// verbatim byte
|
||
result[output_end - bytes_output] = (byte)get_next_bits(input, ref input_offset, ref bit_pool, ref bits_left, 8);
|
||
bytes_output++;
|
||
}
|
||
}
|
||
|
||
br.Close();
|
||
ms.Close();
|
||
|
||
return result;
|
||
}
|
||
|
||
private ushort get_next_bits(byte[] input, ref int offset_p, ref byte bit_pool_p, ref int bits_left_p, int bit_count)
|
||
{
|
||
ushort out_bits = 0;
|
||
int num_bits_produced = 0;
|
||
int bits_this_round;
|
||
|
||
while (num_bits_produced < bit_count)
|
||
{
|
||
if (bits_left_p == 0)
|
||
{
|
||
bit_pool_p = input[offset_p];
|
||
bits_left_p = 8;
|
||
offset_p--;
|
||
}
|
||
|
||
if (bits_left_p > (bit_count - num_bits_produced))
|
||
bits_this_round = bit_count - num_bits_produced;
|
||
else
|
||
bits_this_round = bits_left_p;
|
||
|
||
out_bits <<= bits_this_round;
|
||
|
||
out_bits |= (ushort)((ushort)(bit_pool_p >> (bits_left_p - bits_this_round)) & ((1 << bits_this_round) - 1));
|
||
|
||
bits_left_p -= bits_this_round;
|
||
num_bits_produced += bits_this_round;
|
||
}
|
||
|
||
return out_bits;
|
||
}
|
||
|
||
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;
|
||
}
|
||
|
||
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;
|
||
}
|
||
|
||
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;
|
||
}
|
||
|
||
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;
|
||
}
|
||
|
||
public void UpdateFileEntry(FileEntry fileEntry)
|
||
{
|
||
if (fileEntry.FileType == "FILE" || fileEntry.FileType == "HDR")
|
||
{
|
||
byte[] updateMe = null;
|
||
switch (fileEntry.TOCName)
|
||
{
|
||
case "CPK":
|
||
updateMe = CPK_packet;
|
||
break;
|
||
case "TOC":
|
||
updateMe = TOC_packet;
|
||
break;
|
||
case "ITOC":
|
||
updateMe = ITOC_packet;
|
||
break;
|
||
case "ETOC":
|
||
updateMe = ETOC_packet;
|
||
break;
|
||
case "GTOC":
|
||
updateMe = GTOC_packet;
|
||
break;
|
||
default:
|
||
throw new Exception("I need to implement this TOC!");
|
||
|
||
}
|
||
|
||
|
||
//Update ExtractSize
|
||
if (fileEntry.ExtractSizePos > 0)
|
||
UpdateValue(ref updateMe, fileEntry.ExtractSize, fileEntry.ExtractSizePos, fileEntry.ExtractSizeType);
|
||
|
||
//Update FileSize
|
||
if (fileEntry.FileSizePos > 0)
|
||
UpdateValue(ref updateMe, fileEntry.FileSize, fileEntry.FileSizePos, fileEntry.FileSizeType);
|
||
|
||
//Update FileOffset
|
||
if (fileEntry.FileOffsetPos > 0)
|
||
if (fileEntry.TOCName == "TOC")
|
||
{
|
||
UpdateValue(ref updateMe, fileEntry.FileOffset - (ulong)TocOffset, fileEntry.FileOffsetPos, fileEntry.FileOffsetType);
|
||
}
|
||
else
|
||
{
|
||
UpdateValue(ref updateMe, fileEntry.FileOffset, fileEntry.FileOffsetPos, fileEntry.FileOffsetType);
|
||
}
|
||
|
||
switch (fileEntry.TOCName)
|
||
{
|
||
case "CPK":
|
||
CPK_packet = updateMe;
|
||
break;
|
||
case "TOC":
|
||
TOC_packet = updateMe;
|
||
break;
|
||
case "ITOC":
|
||
ITOC_packet = updateMe;
|
||
break;
|
||
case "ETOC":
|
||
updateMe = ETOC_packet;
|
||
break;
|
||
case "GTOC":
|
||
updateMe = GTOC_packet;
|
||
break;
|
||
default:
|
||
throw new Exception("I need to implement this TOC!");
|
||
|
||
}
|
||
}
|
||
}
|
||
|
||
public void UpdateValue(ref byte[] packet, object value, long pos, Type type)
|
||
{
|
||
MemoryStream temp = new MemoryStream();
|
||
temp.Write(packet, 0, packet.Length);
|
||
|
||
EndianWriter toc = new EndianWriter(temp, false);
|
||
toc.Seek((int)pos, SeekOrigin.Begin);
|
||
|
||
value = Convert.ChangeType(value, type);
|
||
|
||
if (type == typeof(Byte))
|
||
{
|
||
toc.Write((Byte)value);
|
||
}
|
||
else if (type == typeof(UInt16))
|
||
{
|
||
toc.Write((UInt16)value);
|
||
}
|
||
else if (type == typeof(UInt32))
|
||
{
|
||
toc.Write((UInt32)value);
|
||
}
|
||
else if (type == typeof(UInt64))
|
||
{
|
||
toc.Write((UInt64)value);
|
||
}
|
||
else if (type == typeof(Single))
|
||
{
|
||
toc.Write((Single)value);
|
||
}
|
||
else
|
||
{
|
||
throw new Exception("Not supported type!");
|
||
}
|
||
|
||
toc.Close();
|
||
|
||
MemoryStream myStream = (MemoryStream)toc.BaseStream;
|
||
packet = myStream.ToArray();
|
||
|
||
}
|
||
|
||
public bool isUtfEncrypted { get; set; }
|
||
public int unk1 { get; set; }
|
||
public long utf_size { get; set; }
|
||
public byte[] utf_packet { get; set; }
|
||
|
||
public byte[] CPK_packet { get; set; }
|
||
public byte[] TOC_packet { get; set; }
|
||
public byte[] ITOC_packet { get; set; }
|
||
public byte[] ETOC_packet { get; set; }
|
||
public byte[] GTOC_packet { get; set; }
|
||
|
||
public ulong TocOffset, EtocOffset, ItocOffset, GtocOffset, ContentOffset;
|
||
}
|
||
|
||
public class UTF
|
||
{
|
||
public enum COLUMN_FLAGS : int
|
||
{
|
||
STORAGE_MASK = 0xf0,
|
||
STORAGE_NONE = 0x00,
|
||
STORAGE_ZERO = 0x10,
|
||
STORAGE_CONSTANT = 0x30,
|
||
STORAGE_PERROW = 0x50,
|
||
|
||
|
||
TYPE_MASK = 0x0f,
|
||
TYPE_DATA = 0x0b,
|
||
TYPE_STRING = 0x0a,
|
||
TYPE_FLOAT = 0x08,
|
||
TYPE_8BYTE2 = 0x07,
|
||
TYPE_8BYTE = 0x06,
|
||
TYPE_4BYTE2 = 0x05,
|
||
TYPE_4BYTE = 0x04,
|
||
TYPE_2BYTE2 = 0x03,
|
||
TYPE_2BYTE = 0x02,
|
||
TYPE_1BYTE2 = 0x01,
|
||
TYPE_1BYTE = 0x00,
|
||
}
|
||
|
||
public List<COLUMN> columns;
|
||
public List<ROWS> rows;
|
||
|
||
Tools tools;
|
||
|
||
public UTF(Tools tool)
|
||
{
|
||
tools = tool;
|
||
}
|
||
|
||
public bool ReadUTF(EndianReader br ,Encoding encoding = null)
|
||
{
|
||
long offset = br.BaseStream.Position;
|
||
|
||
if (tools.ReadCString(br, 4) != "@UTF")
|
||
{
|
||
return false;
|
||
}
|
||
|
||
table_size = br.ReadInt32();
|
||
rows_offset = br.ReadInt32();
|
||
strings_offset = br.ReadInt32();
|
||
data_offset = br.ReadInt32();
|
||
|
||
// CPK Header & UTF Header are ignored, so add 8 to each offset
|
||
rows_offset += (offset + 8);
|
||
strings_offset += (offset + 8);
|
||
data_offset += (offset + 8);
|
||
|
||
table_name = br.ReadInt32();
|
||
num_columns = br.ReadInt16();
|
||
row_length = br.ReadInt16();
|
||
num_rows = br.ReadInt32();
|
||
|
||
//read Columns
|
||
columns = new List<COLUMN>();
|
||
COLUMN column;
|
||
|
||
for (int i = 0; i < num_columns; i++)
|
||
{
|
||
column = new COLUMN();
|
||
column.flags = br.ReadByte();
|
||
if (column.flags == 0)
|
||
{
|
||
br.BaseStream.Seek(3, SeekOrigin.Current);
|
||
column.flags = br.ReadByte();
|
||
}
|
||
|
||
column.name = tools.ReadCString(br, -1, (long)(br.ReadInt32() + strings_offset), encoding);
|
||
columns.Add(column);
|
||
}
|
||
|
||
//read Rows
|
||
|
||
rows = new List<ROWS>();
|
||
ROWS current_entry;
|
||
ROW current_row;
|
||
int storage_flag;
|
||
|
||
for (int j = 0; j < num_rows; j++)
|
||
{
|
||
br.BaseStream.Seek(rows_offset + (j * row_length), SeekOrigin.Begin);
|
||
|
||
current_entry = new ROWS();
|
||
|
||
for (int i = 0; i < num_columns; i++)
|
||
{
|
||
current_row = new ROW();
|
||
|
||
storage_flag = (columns[i].flags & (int)COLUMN_FLAGS.STORAGE_MASK);
|
||
|
||
if (storage_flag == (int)COLUMN_FLAGS.STORAGE_NONE) // 0x00
|
||
{
|
||
current_entry.rows.Add(current_row);
|
||
continue;
|
||
}
|
||
|
||
if (storage_flag == (int)COLUMN_FLAGS.STORAGE_ZERO) // 0x10
|
||
{
|
||
current_entry.rows.Add(current_row);
|
||
continue;
|
||
}
|
||
|
||
if (storage_flag == (int)COLUMN_FLAGS.STORAGE_CONSTANT) // 0x30
|
||
{
|
||
current_entry.rows.Add(current_row);
|
||
continue;
|
||
}
|
||
|
||
// 0x50
|
||
|
||
current_row.type = columns[i].flags & (int)COLUMN_FLAGS.TYPE_MASK;
|
||
|
||
current_row.position = br.BaseStream.Position;
|
||
|
||
switch (current_row.type)
|
||
{
|
||
case 0:
|
||
case 1:
|
||
current_row.uint8 = br.ReadByte();
|
||
break;
|
||
|
||
case 2:
|
||
case 3:
|
||
current_row.uint16 = br.ReadUInt16();
|
||
break;
|
||
|
||
case 4:
|
||
case 5:
|
||
current_row.uint32 = br.ReadUInt32();
|
||
break;
|
||
|
||
case 6:
|
||
case 7:
|
||
current_row.uint64 = br.ReadUInt64();
|
||
break;
|
||
|
||
case 8:
|
||
current_row.ufloat = br.ReadSingle();
|
||
break;
|
||
|
||
case 0xA:
|
||
current_row.str = tools.ReadCString(br, -1, br.ReadInt32() + strings_offset , encoding);
|
||
break;
|
||
|
||
case 0xB:
|
||
long position = br.ReadInt32() + data_offset;
|
||
current_row.position = position;
|
||
current_row.data = tools.GetData(br, position, br.ReadInt32());
|
||
break;
|
||
|
||
default: throw new NotImplementedException();
|
||
}
|
||
|
||
|
||
current_entry.rows.Add(current_row);
|
||
}
|
||
|
||
rows.Add(current_entry);
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
public int table_size { get; set; }
|
||
|
||
public long rows_offset { get; set; }
|
||
public long strings_offset { get; set; }
|
||
public long data_offset { get; set; }
|
||
public int table_name { get; set; }
|
||
public short num_columns { get; set; }
|
||
public short row_length { get; set; }
|
||
public int num_rows { get; set; }
|
||
}
|
||
|
||
public class COLUMN
|
||
{
|
||
public COLUMN()
|
||
{
|
||
}
|
||
|
||
public byte flags { get; set; }
|
||
public string name { get; set; }
|
||
}
|
||
|
||
public class ROWS
|
||
{
|
||
public List<ROW> rows;
|
||
|
||
public ROWS()
|
||
{
|
||
rows = new List<ROW>();
|
||
}
|
||
}
|
||
|
||
public class ROW
|
||
{
|
||
public ROW()
|
||
{
|
||
type = -1;
|
||
}
|
||
|
||
public int type { get; set; }
|
||
|
||
public object GetValue()
|
||
{
|
||
object result = -1;
|
||
|
||
switch (this.type)
|
||
{
|
||
case 0:
|
||
case 1: return this.uint8;
|
||
|
||
case 2:
|
||
case 3: return this.uint16;
|
||
|
||
case 4:
|
||
case 5: return this.uint32;
|
||
|
||
case 6:
|
||
case 7: return this.uint64;
|
||
|
||
case 8: return this.ufloat;
|
||
|
||
case 0xA: return this.str;
|
||
|
||
case 0xB: return this.data;
|
||
|
||
default: return null;
|
||
}
|
||
}
|
||
|
||
public new Type GetType()
|
||
{
|
||
object result = -1;
|
||
|
||
switch (this.type)
|
||
{
|
||
case 0:
|
||
case 1: return this.uint8.GetType();
|
||
|
||
case 2:
|
||
case 3: return this.uint16.GetType();
|
||
|
||
case 4:
|
||
case 5: return this.uint32.GetType();
|
||
|
||
case 6:
|
||
case 7: return this.uint64.GetType();
|
||
|
||
case 8: return this.ufloat.GetType();
|
||
|
||
case 0xA: return this.str.GetType();
|
||
|
||
case 0xB: return this.data.GetType();
|
||
|
||
default: return null;
|
||
}
|
||
}
|
||
|
||
//column based datatypes
|
||
public byte uint8 { get; set; }
|
||
public ushort uint16 { get; set; }
|
||
public uint uint32 { get; set; }
|
||
public ulong uint64 { get; set; }
|
||
public float ufloat { get; set; }
|
||
public string str { get; set; }
|
||
public byte[] data { get; set; }
|
||
public long position { get; set; }
|
||
}
|
||
|
||
public class FileEntry
|
||
{
|
||
public FileEntry()
|
||
{
|
||
DirName = null;
|
||
FileName = null;
|
||
FileSize = null;
|
||
ExtractSize = null;
|
||
ID = null;
|
||
UserString = null;
|
||
LocalDir = null;
|
||
|
||
FileOffset = 0;
|
||
UpdateDateTime = 0;
|
||
}
|
||
|
||
public object DirName { get; set; } // string
|
||
public object FileName { get; set; } // string
|
||
|
||
public object FileSize { get; set; }
|
||
public long FileSizePos { get; set; }
|
||
public Type FileSizeType { get; set; }
|
||
|
||
public object ExtractSize { get; set; } // int
|
||
public long ExtractSizePos { get; set; }
|
||
public Type ExtractSizeType { get; set; }
|
||
|
||
public ulong FileOffset { get; set; }
|
||
public long FileOffsetPos { get; set; }
|
||
public Type FileOffsetType { get; set; }
|
||
|
||
|
||
public ulong Offset { get; set; }
|
||
public object ID { get; set; } // int
|
||
public object UserString { get; set; } // string
|
||
public ulong UpdateDateTime { get; set; }
|
||
public object LocalDir { get; set; } // string
|
||
public string TOCName { get; set; }
|
||
|
||
public bool Encrypted { get; set; }
|
||
|
||
public string FileType { get; set; }
|
||
}
|
||
}
|