private sFolder Unpack_Sound(string file, string name)
{
BinaryReader br = new BinaryReader(File.OpenRead(file));
sFolder unpacked = new sFolder();
unpacked.files = new List <sFile>();
uint fat_size = br.ReadUInt32();
uint num_files = fat_size / 0x08;
for (int i = 0; i < num_files; i++)
{
sFile newFile = new sFile();
newFile.name = name + '_' + i.ToString() + ".bin";
newFile.offset = br.ReadUInt32();
if (i + 1 != num_files)
{
newFile.size = br.ReadUInt32() - newFile.offset;
}
newFile.offset += fat_size + 4;
if (i + 1 == num_files)
{
newFile.size = (uint)br.BaseStream.Length - newFile.offset;
}
newFile.path = file;
unpacked.files.Add(newFile);
}
br.Close();
return(unpacked);
}
public sFolder Decompress_LZSS(sFile file)
{
sFolder unpacked = new sFolder();
unpacked.files = new List <sFile>();
string temp = pluginHost.Get_TempFolder() + Path.DirectorySeparatorChar + Path.GetRandomFileName();
Byte[] compressFile = new Byte[(new FileInfo(file.path).Length) - 4];
Array.Copy(File.ReadAllBytes(file.path), 4, compressFile, 0, compressFile.Length);
File.WriteAllBytes(temp, compressFile);
// Get the decompressed file
string fileIn = Path.GetDirectoryName(temp) + Path.DirectorySeparatorChar + "de" + Path.DirectorySeparatorChar + Path.GetFileName(temp);
Directory.CreateDirectory(Path.GetDirectoryName(fileIn));
DSDecmp.Main.Decompress(temp, fileIn, DSDecmp.Main.Get_Format(temp));
File.Delete(temp);
sFile fileOut = new sFile
{
path = fileIn,
name = file.name,
size = (uint)new FileInfo(fileIn).Length
};
unpacked.files.Add(fileOut);
return(unpacked);
}
public sFolder Unpack(sFile file)
{
string tempFile = pluginHost.Get_TempFile();
Stream strin = File.OpenRead(file.path);
MemoryStream strout = AT6P.Decode(strin);
FileStream strfile = File.OpenWrite(tempFile);
strout.WriteTo(strfile);
strfile.Flush();
sFolder unpack = new sFolder();
unpack.files = new List <sFile>();
sFile newFile = new sFile();
newFile.name = file.name;
newFile.offset = 0;
newFile.path = tempFile;
newFile.size = (uint)strfile.Length;
unpack.files.Add(newFile);
strin.Dispose();
strout.Dispose();
strfile.Dispose();
return(unpack);
}
public sFolder Get_Files()
{
sFolder devuelta = extraidos;
extraidos = new sFolder();
return(devuelta);
}
public static sFolder Unpack_ARCHIVE(string file, string name)
{
BinaryReader br = new BinaryReader(File.OpenRead(file));
sFolder unpacked = new sFolder();
unpacked.files = new List <sFile>();
uint number_files = br.ReadUInt32() / 8;
br.BaseStream.Position = 0;
for (int i = 0; i < number_files; i++)
{
sFile newFile = new sFile();
newFile.name = name + '_' + i.ToString();
newFile.offset = br.ReadUInt32();
newFile.size = br.ReadUInt32();
newFile.path = file;
unpacked.files.Add(newFile);
}
br.Close();
return(unpacked);
}
private static sFolder AddFile(sFile newFile, sFolder currfolder)
{
if (currfolder.files is List <sFile> )
{
if (newFile.id >= currfolder.id && newFile.id < (currfolder.id + currfolder.files.Capacity))
{
if (!(currfolder.files is List <sFile>))
{
currfolder.files = new List <sFile>();
}
currfolder.files.Add(newFile);
return(currfolder);
}
}
if (currfolder.folders is List <sFolder> )
{
for (int i = 0; i < currfolder.folders.Count; i++)
{
sFolder returnFolder = AddFile(newFile, currfolder.folders[i]);
if (returnFolder.name is string)
{
currfolder.folders[i] = returnFolder;
return(currfolder);
}
}
}
return(new sFolder());
}
public sFolder Unpack(sFile file)
{
if (file.id >= 0x23 && file.id <= 0x93)
{
sFolder unpack = new sFolder();
unpack.files = new List <sFile>();
BinaryReader br = new BinaryReader(File.OpenRead(file.path));
for (int i = 0; i < 0x17; i++)
{
sFile cfile = new sFile();
cfile.name = "Block " + i.ToString() + ".bin";
cfile.path = file.path;
br.BaseStream.Position = 0x14 + i * 4;
cfile.offset = br.ReadUInt32();
br.BaseStream.Position = 0x70 + i * 4;
cfile.size = br.ReadUInt32();
unpack.files.Add(cfile);
}
br.Close();
br = null;
return(unpack);
}
return(new sFolder());
}
private sFile Get_File(int id, uint newOffset, string path, sFolder currFolder)
{
if (currFolder.files is List <sFile> )
{
for (int i = 0; i < currFolder.files.Count; i++)
{
if (currFolder.files[i].id == id)
{
sFile original = currFolder.files[i];
sFile newFile = currFolder.files[i];
newFile.offset = newOffset;
newFile.path = path;
currFolder.files[i] = newFile;
return(original);
}
}
}
if (currFolder.folders is List <sFolder> )
{
foreach (sFolder subFolder in currFolder.folders)
{
sFile currFile = Get_File(id, newOffset, path, subFolder);
if (currFile.name is string)
{
return(currFile);
}
}
}
return(new sFile());
}
public static sFolder Unpack(sFile file)
{
BinaryReader br = new BinaryReader(File.OpenRead(file.path));
sFolder unpack = new sFolder();
unpack.files = new List <sFile>();
br.BaseStream.Position = 0x10; // Header
const int num_files = 0x1246;
for (int i = 0; i < num_files; i++)
{
sFile newFile = new sFile();
newFile.name = "File_" + i.ToString() + '.';
newFile.size = br.ReadUInt32();
newFile.offset = br.ReadUInt32();
newFile.path = file.path;
long currPos = br.BaseStream.Position;
br.BaseStream.Position = newFile.offset;
string ext = new String(br.ReadChars(3));
if (ext != "IMY" && ext != "MAP")
{
ext = "BIN";
}
newFile.name += ext;
br.BaseStream.Position = currPos;
unpack.files.Add(newFile);
}
br.Close();
return(unpack);
}
public static sFolder Unpack_PKH2(sFile pkb, sFile pkh)
{
BinaryReader br = new BinaryReader(File.OpenRead(pkh.path));
sFolder unpacked = new sFolder();
unpacked.files = new List <sFile>();
int num_files = (int)br.BaseStream.Length / 0x10;
for (int i = 0; i < num_files; i++)
{
br.ReadUInt32(); // Unknown - ID¿?
sFile newFile = new sFile();
newFile.name = pkb.name + '_' + i.ToString() + ".pac_";
newFile.offset = br.ReadUInt32();
newFile.size = br.ReadUInt32();
newFile.path = pkb.path;
br.ReadUInt32(); // First four bytes that indicates the type of compression and the final size
unpacked.files.Add(newFile);
}
br.Close();
return(unpacked);
}
public string Pack(ref sFolder unpacked, sFile file)
{
string output = pluginHost.Get_TempFile();
Packs.Pack(output, ref unpacked);
return(output);
}
private static sFile[] GetFiles(sFolder folder)
{
List <sFile> files = new List <sFile>();
Queue <sFolder> queue = new Queue <sFolder>();
folder.name = string.Empty;
queue.Enqueue(folder);
do
{
sFolder currentFolder = queue.Dequeue();
foreach (sFolder f in currentFolder.folders)
{
sFolder subfolder = f;
if (!string.IsNullOrEmpty(currentFolder.name))
{
subfolder.name = currentFolder.name + '\\' + subfolder.name;
}
queue.Enqueue(subfolder);
}
foreach (sFile f in currentFolder.files)
{
sFile file = f;
if (!string.IsNullOrEmpty(currentFolder.name))
{
file.name = currentFolder.name + '\\' + file.name;
}
files.Add(file);
}
} while (queue.Count != 0);
return(files.ToArray());
}
public String Pack(ref sFolder unpacked, sFile file)
{
if (file.name.EndsWith(".pcm"))
{
string fileOut = pluginHost.Get_TempFile();
PCM.Pack(fileOut, unpacked);
return(fileOut);
}
if (gameCode == "BLFE")
{
if (file.name.ToUpper().EndsWith(".DENC"))
{
string fileOut = pluginHost.Get_TempFile() + ".denc";
DENC.Pack(fileOut, unpacked);
return(fileOut);
}
else if (file.name.ToUpper().EndsWith(".DARC"))
{
string fileOut = pluginHost.Get_TempFile() + ".darc";
DARC.Pack(fileOut, ref unpacked);
return(fileOut);
}
}
return(null);
}
private sFolder Unpack_Images(string file)
{
BinaryReader br = new BinaryReader(File.OpenRead(file));
sFolder unpacked = new sFolder();
unpacked.files = new List <sFile>();
uint unknown = br.ReadUInt32(); // Constant? 0x00015618
ushort num_files = br.ReadUInt16();
ushort header_size = br.ReadUInt16();
uint unknown2 = br.ReadUInt32(); // Type of pack file
if (unknown2 != 0)
{
System.Windows.Forms.MessageBox.Show("File not supported");
return(new sFolder());
}
for (int i = 0; i < num_files; i++)
{
sFile newFile = new sFile();
newFile.path = file;
newFile.offset = br.ReadUInt32();
newFile.size = br.ReadUInt32();
uint decompressed_size = br.ReadUInt32();
newFile.name = new String(br.ReadChars(0x20)).Replace("\0", "");
unpacked.files.Add(newFile);
}
br.Close();
return(unpacked);
}
public static sFolder Decrypt(sFile item, int blockSize, IPluginHost pluginHost)
{
sFolder unpacked = new sFolder();
unpacked.files = new List <sFile>();
byte[] data = File.ReadAllBytes(item.path);
int numBlocks = data.Length / blockSize;
for (int i = 0; i < numBlocks; i++)
{
byte[] block = new byte[blockSize];
Array.Copy(data, i * blockSize, block, 0, blockSize);
Decrypt(ref block);
Array.Copy(block, 0, data, i * blockSize, blockSize);
}
string fileout = pluginHost.Get_TempFile();
File.WriteAllBytes(fileout, data);
sFile newItem = new sFile();
newItem.path = fileout;
newItem.offset = 0;
newItem.name = item.name;
newItem.size = (uint)data.Length;
unpacked.files.Add(newItem);
return(unpacked);
}
public sFolder Unpack(sFile file)
{
if (file.name.EndsWith(".pk1") || file.name.EndsWith(".pk2") || file.name.EndsWith(".pk"))
{
sFolder unpack = new sFolder();
unpack.files = new List <sFile>();
BinaryReader br = new BinaryReader(File.OpenRead(file.path));
ushort unk = br.ReadUInt16();
if (unk != 0x00)
{
System.Windows.Forms.MessageBox.Show("Different to 0!");
}
ushort num_files = br.ReadUInt16();
for (int i = 0; i < num_files; i++)
{
sFile cfile = new sFile();
cfile.name = "File" + i.ToString() + ".bin";
cfile.path = file.path;
cfile.offset = br.ReadUInt32();
cfile.size = br.ReadUInt32();
unpack.files.Add(cfile);
}
br.Close();
br = null;
return(unpack);
}
return(new sFolder());
}
private static sFolder ReorderFolder(sFolder rootFolder, sFolder newFolder, string folderPath)
{
if (folderPath.Contains('/')) // Necessary to make folders
{
string parentFolder = folderPath.Substring(0, folderPath.IndexOf('/'));
for (int i = 0; i < rootFolder.folders.Count; i++)
{
if (rootFolder.folders[i].name == parentFolder)
{
folderPath = folderPath.Substring(folderPath.IndexOf('/') + 1);
rootFolder.folders[i] = ReorderFolder(rootFolder.folders[i], newFolder, folderPath);
return(rootFolder);
}
}
}
else
{
newFolder.name = folderPath;
if (!(rootFolder.folders is List <sFolder>))
{
rootFolder.folders = new List <sFolder>();
}
rootFolder.folders.Add(newFolder);
return(rootFolder);
}
return(new sFolder());
}
/// <summary>
/// Get a "sFolder" variable with all files and folders from the main folder path.
/// </summary>
/// <param name="folderPath">Folder to read</param>
/// <param name="currFolder">Empty folder</param>
/// <returns></returns>
public static sFolder Recursive_GetDirectories(string folderPath, sFolder currFolder)
{
foreach (string file in Directory.GetFiles(folderPath))
{
sFile newFile = new sFile();
newFile.name = Path.GetFileName(file);
newFile.offset = 0x00;
newFile.path = file;
newFile.size = (uint)new FileInfo(file).Length;
if (!(currFolder.files is List <sFile>))
{
currFolder.files = new List <sFile>();
}
currFolder.files.Add(newFile);
}
foreach (string folder in Directory.GetDirectories(folderPath))
{
sFolder newFolder = new sFolder();
newFolder.name = new DirectoryInfo(folder).Name;
newFolder = Recursive_GetDirectories(folder, newFolder);
if (!(currFolder.folders is List <sFolder>))
{
currFolder.folders = new List <sFolder>();
}
currFolder.folders.Add(newFolder);
}
return(currFolder);
}
public static sFolder Unpack(string file, string name)
{
name = Path.GetFileNameWithoutExtension(name);
BinaryReader br = new BinaryReader(File.OpenRead(file));
sFolder unpack = new sFolder();
unpack.files = new List<sFile>();
char[] type = br.ReadChars(4);
uint header_size = br.ReadUInt32();
uint num_files = br.ReadUInt32();
for (int i = 0; i < num_files; i++)
{
uint offset = br.ReadUInt32();
uint size = br.ReadUInt32();
if (offset == 0x00 || size == 0x00)
continue;
sFile newFile = new sFile();
newFile.name = name + '_' + i.ToString() + Get_Extension(num_files, i);
newFile.offset = offset;
newFile.size = size;
newFile.path = file;
unpack.files.Add(newFile);
}
br.Close();
return unpack;
}
public String Pack(ref sFolder unpacked, sFile file)
{
BinaryReader br = new BinaryReader(File.OpenRead(file.path));
string ext = new String(br.ReadChars(4));
br.Close();
if (ext == "NPCK")
{
string fileOut = pluginHost.Get_TempFile();
NPCK.Pack(fileOut, ref unpacked, pluginHost);
return(fileOut);
}
else if (ext == "KPCN")
{
string fileOut = pluginHost.Get_TempFile();
KPCN.Pack(fileOut, file.path, ref unpacked, pluginHost);
return(fileOut);
}
else if (ext == "spdl")
{
string fileOut = pluginHost.Get_TempFile();
SPDL.Pack(fileOut, file.path, ref unpacked, pluginHost);
return(fileOut);
}
return(null);
}
void Change_System(string path)
{
string[] files = Directory.GetFiles(path);
sFolder ftc = pluginHost.Search_Folder(0xF378);
for (int i = 0; i < ftc.files.Count; i++)
{
string cf = Array.Find(files, a => Path.GetFileName(a) == ftc.files[i].name);
if (cf == null)
{
continue;
}
if (ftc.files[i].name == "arm9.bin")
{
byte[] d = File.ReadAllBytes(cf);
byte[] size = BitConverter.GetBytes((uint)new FileInfo(cf).Length);
d[0xB9C] = size[0];
d[0xB9D] = size[1];
d[0xB9E] = size[2];
File.WriteAllBytes(cf, d);
}
pluginHost.ChangeFile(ftc.files[i].id, cf);
}
}
public sFolder Unpack_NMDP(string fileIn, string name)
{
BinaryReader br = new BinaryReader(File.OpenRead(fileIn));
sFolder unpacked = new sFolder();
unpacked.files = new List <sFile>();
char[] header = br.ReadChars(4);
ushort header_size = br.ReadUInt16();
br.BaseStream.Position = 0x10;
uint unknown2 = br.ReadUInt32();
uint unknown1 = br.ReadUInt32();
sFile newFile = new sFile();
newFile.name = name;
newFile.size = br.ReadUInt32();
newFile.offset = br.ReadUInt32();
newFile.path = fileIn;
unpacked.files.Add(newFile);
br.Close();
return(unpacked);
}
public override void Read(string file)
{
// It's compressed
pluginHost.Decompress(file);
string dec_file;
sFolder dec_folder = pluginHost.Get_Files();
if (dec_folder.files is List <sFile> )
{
dec_file = dec_folder.files[0].path;
}
else
{
string tempFile = Path.GetTempFileName();
Byte[] compressFile = new Byte[(new FileInfo(file).Length) - 0x08];
Array.Copy(File.ReadAllBytes(file), 0x08, compressFile, 0, compressFile.Length);;
File.WriteAllBytes(tempFile, compressFile);
pluginHost.Decompress(tempFile);
dec_file = pluginHost.Get_Files().files[0].path;
}
BinaryReader br = new BinaryReader(File.OpenRead(dec_file));
NTFS[] map = new NTFS[br.BaseStream.Length / 2];
for (int i = 0; i < map.Length; i++)
{
map[i] = Actions.MapInfo(br.ReadUInt16());
}
br.Close();
Set_Map(map, false, 0x100, 0x100);
pluginHost.Set_Map(this);
}
public sFolder Unpack_SSAM(string fileIn)
{
BinaryReader br = new BinaryReader(File.OpenRead(fileIn));
sFolder unpacked = new sFolder();
unpacked.files = new List <sFile>();
char[] header = br.ReadChars(4);
uint num_files = br.ReadUInt32();
uint pos_base = num_files * 0x28 + 8;
for (int i = 0; i < num_files; i++)
{
sFile newFile = new sFile();
newFile.offset = br.ReadUInt32() + pos_base;
newFile.size = br.ReadUInt32();
newFile.name = new String(br.ReadChars(0x20)).Replace("\0", "");
newFile.path = fileIn;
unpacked.files.Add(newFile);
}
br.Close();
return(unpacked);
}
public static sFolder Unpack(string file, IPluginHost pluginHost)
{
BinaryReader br = new BinaryReader(File.OpenRead(file));
sFolder unpacked = new sFolder();
unpacked.files = new List <sFile>();
uint num_files = (br.ReadUInt32() / 0x04) - 1;
br.ReadUInt32(); // Pointer table
for (int i = 0; i < num_files; i++)
{
uint startOffset = br.ReadUInt32();
long currPos = br.BaseStream.Position;
br.BaseStream.Position = startOffset;
sFile newFile = new sFile();
newFile.name = "File " + (i + 1).ToString("X") + ".bin";
newFile.offset = startOffset + 4;
newFile.path = file;
newFile.size = br.ReadUInt32();
br.BaseStream.Position = currPos;
unpacked.files.Add(newFile);
}
br.Close();
return(unpacked);
}
public sFolder Unpack_FLSC(string fileIn, string name)
{
BinaryReader br = new BinaryReader(File.OpenRead(fileIn));
sFolder unpacked = new sFolder();
unpacked.files = new List <sFile>();
uint num_files = br.ReadUInt32();
br.BaseStream.Position = 0x10;
for (int i = 0; i < num_files; i++)
{
sFile newFile = new sFile();
newFile.name = name + '_' + i.ToString();
newFile.offset = br.ReadUInt32();
newFile.size = br.ReadUInt32();
newFile.path = fileIn;
// Get the extension
long currPos = br.BaseStream.Position;
br.BaseStream.Position = newFile.offset;
newFile.name += new String(Encoding.ASCII.GetChars(br.ReadBytes(4)));
br.BaseStream.Position = currPos;
unpacked.files.Add(newFile);
}
br.Close();
return(unpacked);
}
private static void AddFile(sFolder folder, sFile file, string filePath)
{
const char SEPARATOR = '/';
if (filePath.Contains(SEPARATOR))
{
string folderName = filePath.Substring(0, filePath.IndexOf(SEPARATOR));
sFolder subfolder = new sFolder();
foreach (sFolder f in folder.folders)
{
if (f.name == folderName)
{
subfolder = f;
}
}
if (string.IsNullOrEmpty(subfolder.name))
{
subfolder.name = folderName;
subfolder.folders = new List <sFolder>();
subfolder.files = new List <sFile>();
folder.folders.Add(subfolder);
}
AddFile(subfolder, file, filePath.Substring(filePath.IndexOf(SEPARATOR) + 1));
}
else
{
file.name = filePath;
folder.files.Add(file);
}
}
public override void Read(string file)
{
// It's compressed
pluginHost.Decompress(file);
string dec_file;
sFolder dec_folder = pluginHost.Get_Files();
if (dec_folder.files is List <sFile> )
{
dec_file = dec_folder.files[0].path;
}
else
{
string tempFile = Path.GetTempFileName();
Byte[] compressFile = new Byte[(new FileInfo(file).Length) - 0x08];
Array.Copy(File.ReadAllBytes(file), 0x08, compressFile, 0, compressFile.Length);;
File.WriteAllBytes(tempFile, compressFile);
pluginHost.Decompress(tempFile);
dec_file = pluginHost.Get_Files().files[0].path;
}
BinaryReader br = new BinaryReader(File.OpenRead(dec_file));
Byte[] tiles = br.ReadBytes((int)br.BaseStream.Length);
br.Close();
Set_Tiles(tiles, 0x100, tiles.Length / 0x100, ColorFormat.colors16, TileForm.Horizontal, false);
pluginHost.Set_Image(this);
}
public static sFolder Unpack_Type2(sFile fileIn)
{
FileStream fs = new FileStream(fileIn.path, FileMode.Open, FileAccess.Read);
BinaryReader br = new BinaryReader(fs);
sFolder unpacked = new sFolder();
unpacked.folders = new List <sFolder>();
uint numFolders = br.ReadUInt32() / 4;
for (int i = 0; i < numFolders; i++)
{
Console.WriteLine("Reading folder {0}", i);
// Get folder address
fs.Position = 4 + i * 4;
uint folderAddress = br.ReadUInt32() * 4;
sFolder folder = GetSubfolder_Type2(fs, folderAddress, fileIn.path);
folder.name = string.Format("Folder {0}", i);
if (folder.files.Count > 0 || folder.folders.Count > 0)
{
unpacked.folders.Add(folder);
}
}
br = null;
fs.Close();
fs.Dispose();
fs = null;
return(unpacked);
}
public static void Pack(string output, ref sFolder unpackedFiles)
{
BinaryWriter bw = new BinaryWriter(File.OpenWrite(output));
// Write pointers
bw.Write((uint)((unpackedFiles.files.Count + 1) * 4)); // Pointer table size
uint currOffset = 0x00; // Pointer table offset
bw.Write(currOffset);
currOffset += (uint)(unpackedFiles.files.Count + 1) * 4 + 4;
List <byte> buffer = new List <byte>();
for (int i = 0; i < unpackedFiles.files.Count; i++)
{
BinaryReader br = new BinaryReader(File.OpenRead(unpackedFiles.files[i].path));
br.BaseStream.Position = unpackedFiles.files[i].offset;
buffer.AddRange(br.ReadBytes((int)unpackedFiles.files[i].size));
br.Close();
sFile newFile = unpackedFiles.files[i];
newFile.offset = currOffset;
newFile.path = output;
unpackedFiles.files[i] = newFile;
bw.Write(currOffset);
currOffset += unpackedFiles.files[i].size;
}
// Write files
bw.Write(buffer.ToArray());
bw.Flush();
bw.Close();
}
