public IActionResult ExtractFilesFromArk([FromBody] ScanRequest request, bool extractMilos, bool extractDTAs, bool convertTextures)
{
Archive ark;
if (!System.IO.File.Exists(request.InputPath))
{
// Open as directory if available
if (Directory.Exists(request.InputPath))
{
ark = ArkFileSystem.FromDirectory(request.InputPath);
}
else
{
return(BadRequest($"File \"{request.InputPath}\" does not exist!"));
}
}
else
{
// Open as archive
ark = ArkFile.FromFile(request.InputPath);
}
if (request.OutputPath == null)
{
return(BadRequest($"Output directory cannot be null!"));
}
string CombinePath(string basePath, string path)
{
// Consistent slash
basePath = (request.OutputPath ?? "").Replace("/", "\\");
path = (path ?? "").Replace("/", "\\");
Regex dotRegex = new Regex(@"[.]+[\\]");
if (dotRegex.IsMatch(path))
{
// Replaces dotdot path
path = dotRegex.Replace(path, x => $"({x.Value.Substring(0, x.Value.Length - 1)})\\");
}
return(Path.Combine(basePath, path));
}
string GetNonGenPath(string path)
{
// Consistent slash
path = (path ?? "").Replace("/", "\\");
Regex genRegex = new Regex(@"gen\\[^\\]+$", RegexOptions.IgnoreCase);
Regex platformRegex = new Regex(@"_[^_]+$", RegexOptions.IgnoreCase); // TODO: Revisit for Forge extensions
if (genRegex.IsMatch(path))
{
var splitPath = path.Split('\\');
var dir = string.Join("\\", splitPath.SkipLast(2));
var file = platformRegex.Replace(splitPath.Last(), "");
path = $"{dir}\\{file}";
}
return(path);
}
void SaveAsFile(MiloObjectBytes miloEntry, string basePath)
{
var fileName = SanitizeFileName(miloEntry.Name);
var filePath = basePath = Path.Combine(basePath, miloEntry.Type, fileName);
if (!Directory.Exists(Path.GetDirectoryName(filePath)))
{
Directory.CreateDirectory(Path.GetDirectoryName(filePath));
}
System.IO.File.WriteAllBytes(filePath, miloEntry.Data);
Console.WriteLine($"Wrote \"{filePath}\"");
}
// Extract everything
if (!extractDTAs && !extractMilos && !convertTextures)
{
foreach (var arkEntry in ark.Entries)
{
var filePath = CombinePath(request.OutputPath, arkEntry.FullPath);
if (!Directory.Exists(Path.GetDirectoryName(filePath)))
{
Directory.CreateDirectory(Path.GetDirectoryName(filePath));
}
using (var fs = System.IO.File.Open(filePath, FileMode.OpenOrCreate, FileAccess.Write))
{
using (var stream = ark.GetArkEntryFileStream(arkEntry))
{
stream.CopyTo(fs);
}
}
Console.WriteLine($"Wrote \"{filePath}\"");
}
return(Ok());
}
string SanitizeFileName(string fileName)
{
// Sanitize file name
var invalidChars = new Regex($"[{new string(Path.GetInvalidFileNameChars())}]", RegexOptions.IgnoreCase);
return(invalidChars.Replace(fileName, ""));
}
void ProcessMiloArkEntry(ArkEntry miloArkEntry)
{
var filePath = CombinePath(request.OutputPath, GetNonGenPath(miloArkEntry.FullPath));
using (var stream = ark.GetArkEntryFileStream(miloArkEntry))
{
var milo = MiloFile.ReadFromStream(stream);
var miloSerializer = new MiloSerializer(new SystemInfo()
{
Version = milo.Version,
BigEndian = milo.BigEndian,
Platform = Enum.Parse <Platform>(request.Platform)
});
var miloDir = new MiloObjectDir();
using (var ms = new MemoryStream(milo.Data))
{
miloSerializer.ReadFromStream(ms, miloDir);
}
if (convertTextures)
{
var textureEntries = miloDir.Entries
.Where(x => x.Type == "Tex")
.Select(x => x is Tex ? x as Tex : miloSerializer.ReadFromMiloObjectBytes <Tex>(x as MiloObjectBytes))
.Where(x => x.Bitmap != null && x.Bitmap.RawData?.Length > 0)
.ToList();
if (textureEntries.Count <= 0)
{
return;
}
foreach (var texEntry in textureEntries)
{
var entryName = Path.GetFileNameWithoutExtension(SanitizeFileName(texEntry.Name));
var pngName = $"{entryName}.png";
var pngPath = Path.Combine(filePath, texEntry.Type, pngName);
texEntry.Bitmap.SaveAs(miloSerializer.Info, pngPath);
Console.WriteLine($"Wrote \"{pngPath}\"");
// Write DTA script to file
var scriptName = texEntry?.ScriptName ?? "";
if (texEntry.Script != null)
{
var dtaName = (string.IsNullOrEmpty(scriptName))
? $"{entryName}.dta"
: $"{entryName}_{scriptName}.dta";
var dtaPath = Path.Combine(filePath, texEntry.Type, dtaName);
var parent = new ParentItem(ParentType.Default);
foreach (var item in texEntry.Script.Items)
{
parent.Add(item);
}
texEntry.Script.Items.Clear();
texEntry.Script.Items.Add(parent);
System.IO.File.WriteAllText(dtaPath, texEntry.Script.ToString());
Console.WriteLine($"Wrote \"{dtaPath}\"");
}
}
}
if (extractMilos)
{
if (miloDir.Entries.Count <= 0)
{
return;
}
if (!Directory.Exists(Path.GetDirectoryName(filePath)))
{
Directory.CreateDirectory(Path.GetDirectoryName(filePath));
}
// Saves milo entries
miloDir.Entries.ForEach(x =>
{
SaveAsFile(x as MiloObjectBytes, filePath);
Console.WriteLine($"Wrote \"{filePath}\"");
});
if (miloDir.Extras.ContainsKey("DirectoryEntry"))
{
SaveAsFile(miloDir.Extras["DirectoryEntry"] as MiloObjectBytes, filePath);
Console.WriteLine($"Wrote \"{filePath}\"");
}
}
}
}
void ProcessBitmapArkEntry(ArkEntry bitmapArkEntry)
{
var arkPath = GetNonGenPath(bitmapArkEntry.FullPath);
var filePath = CombinePath(request.OutputPath, $"{Path.GetDirectoryName(arkPath)}\\{Path.GetFileNameWithoutExtension(bitmapArkEntry.FileName)}.png");
using (var stream = ark.GetArkEntryFileStream(bitmapArkEntry))
{
var miloSerializer = new MiloSerializer(new SystemInfo()
{
Version = 25, // 10 = gh1, 24 = gh2
BigEndian = false, // Even on PPC it's LE
Platform = Enum.Parse <Platform>(request.Platform)
});
var bitmap = miloSerializer.ReadFromStream <HMXBitmap>(stream);
bitmap.SaveAs(miloSerializer.Info, filePath);
Console.WriteLine($"Wrote \"{filePath}\"");
}
}
// Extract milos
if (extractMilos || convertTextures)
{
var miloEntries = ark.Entries.Where(x => _miloRegex.IsMatch(x.FullPath));
Parallel.ForEach(miloEntries, (entry) =>
{
ProcessMiloArkEntry(entry);
});
//foreach (var entry in miloEntries) ProcessMiloArkEntry(entry);
}
// Convert textures
if (convertTextures)
{
var bitmapArkEntries = ark.Entries.Where(x => _bitmapRegex.IsMatch(x.FullPath));
Parallel.ForEach(bitmapArkEntries, (entry) =>
{
ProcessBitmapArkEntry(entry);
});
//foreach (var entry in bitmapArkEntries) ProcessBitmapArkEntry(entry);
}
return(Ok());
}
public void Parse(Ark2DirOptions op)
{
var scriptRegex = new Regex("(?i).((dtb)|(dta)|(([A-Z]+)(_dta_)([A-Z0-9]+)))$");
var scriptForgeRegex = new Regex("(?i)(_dta_)([A-Z0-9]+)$");
var csvRegex = new Regex("(?i).csv_([A-Z0-9]+)$");
var dtaRegex = new Regex("(?i).dta$");
var miloRegex = new Regex("(?i).milo(_[A-Z0-9]+)?$");
var genPathedFile = new Regex(@"(?i)(([^\/\\]+[\/\\])*)(gen[\/\\])([^\/\\]+)$");
var platformExtRegex = new Regex(@"(?i)_([A-Z0-9]+)$");
Archive ark;
int arkVersion;
bool arkEncrypted;
if (Directory.Exists(op.InputPath))
{
// Open as directory
ark = ArkFileSystem.FromDirectory(op.InputPath);
// TODO: Get from args probably
arkVersion = 10;
arkEncrypted = true;
}
else
{
// Open as ark
var arkFile = ArkFile.FromFile(op.InputPath);
arkVersion = (int)arkFile.Version;
arkEncrypted = arkFile.Encrypted;
ark = arkFile;
}
var scriptsToConvert = ark.Entries
.Where(x => op.ConvertScripts &&
scriptRegex.IsMatch(x.FullPath))
.ToList();
var csvsToConvert = ark.Entries
.Where(x => op.ConvertScripts &&
csvRegex.IsMatch(x.FullPath))
.ToList();
var milosToInflate = ark.Entries
.Where(x => op.InflateMilos &&
miloRegex.IsMatch(x.FullPath))
.ToList();
var entriesToExtract = ark.Entries
.Where(x => op.ExtractAll)
.Except(scriptsToConvert)
.Except(milosToInflate)
.ToList();
foreach (var arkEntry in entriesToExtract)
{
var filePath = ExtractEntry(ark, arkEntry, CombinePath(op.OutputPath, arkEntry.FullPath));
Console.WriteLine($"Wrote \"{filePath}\"");
}
// Create temp path
var tempDir = Path.Combine(Path.GetTempPath(), Path.GetFileNameWithoutExtension(Path.GetRandomFileName()));
if (Directory.Exists(tempDir))
{
Directory.Delete(tempDir, true);
}
foreach (var miloEntry in milosToInflate)
{
var filePath = ExtractEntry(ark, miloEntry, CombinePath(op.OutputPath, miloEntry.FullPath));
// Inflate milo
var milo = MiloFile.ReadFromFile(filePath);
milo.Structure = BlockStructure.MILO_A;
milo.WriteToFile(filePath);
Console.WriteLine($"Wrote \"{filePath}\"");
}
foreach (var csvEntry in csvsToConvert)
{
var csvStream = ark.GetArkEntryFileStream(csvEntry);
var csv = CSVFile.FromForgeCSVStream(csvStream);
// Write to file
var csvPath = CombinePath(op.OutputPath, csvEntry.FullPath);
csvPath = platformExtRegex.Replace(csvPath, "");
csv.SaveToFileAsCSV(csvPath);
Console.WriteLine($"Wrote \"{csvPath}\"");
}
var successDtas = 0;
foreach (var scriptEntry in scriptsToConvert)
{
// Just extract file if dta script
if (dtaRegex.IsMatch(scriptEntry.FullPath))
{
var filePath = ExtractEntry(ark, scriptEntry, CombinePath(op.OutputPath, scriptEntry.FullPath));
Console.WriteLine($"Wrote \"{filePath}\"");
continue;
}
// Creates output path
var dtaPath = CombinePath(op.OutputPath, scriptEntry.FullPath);
dtaPath = !scriptForgeRegex.IsMatch(dtaPath)
? $"{dtaPath.Substring(0, dtaPath.Length - 1)}a" // Simply change b -> a
: scriptForgeRegex.Replace(dtaPath, "");
// Removes gen sub directory
if (genPathedFile.IsMatch(dtaPath))
{
var match = genPathedFile.Match(dtaPath);
dtaPath = $"{match.Groups[1]}{match.Groups[4]}";
}
var tempDtbPath = ExtractEntry(ark, scriptEntry, Path.Combine(tempDir, Path.GetRandomFileName()));
try
{
ScriptHelper.ConvertDtbToDta(tempDtbPath, tempDir, arkEncrypted, arkVersion, dtaPath);
Console.WriteLine($"Wrote \"{dtaPath}\"");
successDtas++;
}
catch (DTBParseException ex)
{
Console.WriteLine($"Unable to convert to script, skipping \'{scriptEntry.FullPath}\'");
if (File.Exists(dtaPath))
{
File.Delete(dtaPath);
}
}
catch (Exception ex)
{
}
}
if (scriptsToConvert.Count > 0)
{
Console.WriteLine($"Converted {successDtas} of {scriptsToConvert.Count} scripts");
}
// Clean up temp files
if (Directory.Exists(tempDir))
{
Directory.Delete(tempDir, true);
}
}
public void Parse(Ark2DirOptions op)
{
var scriptRegex = new Regex("(?i).((dtb)|(dta)|(([A-Z]+)(_dta_)([A-Z0-9]+)))$");
var scriptForgeRegex = new Regex("(?i)(_dta_)([A-Z0-9]+)$");
var csvRegex = new Regex("(?i).csv_([A-Z0-9]+)$");
var dtaRegex = new Regex("(?i).dta$");
var textureRegex = new Regex("(?i).((bmp)|(png))(_[A-Z0-9]+)$");
var miloRegex = new Regex("(?i).((gh)|(milo)|(rnd))(_[A-Z0-9]+)?$");
var genPathedFile = new Regex(@"(?i)(([^\/\\]+[\/\\])*)(gen[\/\\])([^\/\\]+)$");
var platformExtRegex = new Regex(@"(?i)_([A-Z0-9]+)$");
Archive ark;
int arkVersion;
bool arkEncrypted;
if (Directory.Exists(op.InputPath))
{
// Open as directory
ark = ArkFileSystem.FromDirectory(op.InputPath);
// TODO: Get from args probably
arkVersion = 10;
arkEncrypted = true;
}
else
{
// Open as ark
var arkFile = ArkFile.FromFile(op.InputPath);
arkVersion = (int)arkFile.Version;
arkEncrypted = arkFile.Encrypted;
ark = arkFile;
}
var scriptsToConvert = ark.Entries
.Where(x => op.ConvertScripts &&
arkVersion >= 3 && // Amp dtbs not supported right now
scriptRegex.IsMatch(x.FullPath))
.ToList();
var csvsToConvert = ark.Entries
.Where(x => op.ConvertScripts &&
csvRegex.IsMatch(x.FullPath))
.ToList();
var texturesToConvert = ark.Entries
.Where(x => op.ConvertTextures &&
textureRegex.IsMatch(x.FullPath))
.ToList();
var milosToInflate = ark.Entries
.Where(x => op.InflateMilos &&
!op.ExtractMilos &&
miloRegex.IsMatch(x.FullPath))
.ToList();
var milosToExtract = ark.Entries
.Where(x => op.ExtractMilos &&
miloRegex.IsMatch(x.FullPath))
.ToList();
var entriesToExtract = ark.Entries
.Where(x => op.ExtractAll)
.Except(scriptsToConvert)
.Except(texturesToConvert)
.Except(milosToInflate)
.ToList();
foreach (var arkEntry in entriesToExtract)
{
var filePath = ExtractEntry(ark, arkEntry, CombinePath(op.OutputPath, arkEntry.FullPath));
Console.WriteLine($"Wrote \"{filePath}\"");
}
// Create temp path
var tempDir = Path.Combine(Path.GetTempPath(), Path.GetFileNameWithoutExtension(Path.GetRandomFileName()));
if (Directory.Exists(tempDir))
{
Directory.Delete(tempDir, true);
}
foreach (var textureEntry in texturesToConvert)
{
using var arkEntryStream = ark.GetArkEntryFileStream(textureEntry);
var filePath = CombinePath(op.OutputPath, textureEntry.FullPath);
var pngPath = Path.Combine(Path.GetDirectoryName(Path.GetFullPath(filePath)), Path.GetFileNameWithoutExtension(filePath) + ".png");
// Removes gen sub directory
if (genPathedFile.IsMatch(pngPath))
{
var match = genPathedFile.Match(pngPath);
pngPath = $"{match.Groups[1]}{match.Groups[4]}";
}
var info = new SystemInfo()
{
Version = 10,
Platform = Platform.PS2,
BigEndian = false
};
var serializer = new MiloSerializer(info);
var bitmap = serializer.ReadFromStream <HMXBitmap>(arkEntryStream);
bitmap.SaveAs(info, pngPath);
Console.WriteLine($"Wrote \"{pngPath}\"");
}
foreach (var miloEntry in milosToInflate)
{
var filePath = ExtractEntry(ark, miloEntry, CombinePath(op.OutputPath, miloEntry.FullPath));
// Inflate milo
var milo = MiloFile.ReadFromFile(filePath);
milo.Structure = BlockStructure.MILO_A;
milo.WriteToFile(filePath);
Console.WriteLine($"Wrote \"{filePath}\"");
}
foreach (var miloEntry in milosToExtract)
{
var filePath = ExtractEntry(ark, miloEntry, CombinePath(op.OutputPath, miloEntry.FullPath));
var dirPath = Path.GetDirectoryName(filePath);
var tempPath = filePath + "_temp";
File.Move(filePath, tempPath, true);
var extPath = Path.Combine(
Path.GetDirectoryName(filePath),
Path.GetFileName(filePath));
var state = new AppState(dirPath);
state.ExtractMiloContents(
Path.GetFileName(tempPath),
extPath,
op.ConvertTextures);
// TODO: Refactor IDirectory and remove temp file write/delete
File.Delete(tempPath);
Console.WriteLine($"Wrote \"{extPath}\"");
}
foreach (var csvEntry in csvsToConvert)
{
var csvStream = ark.GetArkEntryFileStream(csvEntry);
var csv = CSVFile.FromForgeCSVStream(csvStream);
// Write to file
var csvPath = CombinePath(op.OutputPath, csvEntry.FullPath);
csvPath = platformExtRegex.Replace(csvPath, "");
csv.SaveToFileAsCSV(csvPath);
Console.WriteLine($"Wrote \"{csvPath}\"");
}
var successDtas = 0;
foreach (var scriptEntry in scriptsToConvert)
{
// Just extract file if dta script
if (dtaRegex.IsMatch(scriptEntry.FullPath))
{
var filePath = ExtractEntry(ark, scriptEntry, CombinePath(op.OutputPath, scriptEntry.FullPath));
Console.WriteLine($"Wrote \"{filePath}\"");
continue;
}
// Creates output path
var dtaPath = CombinePath(op.OutputPath, scriptEntry.FullPath);
dtaPath = !scriptForgeRegex.IsMatch(dtaPath)
? $"{dtaPath.Substring(0, dtaPath.Length - 1)}a" // Simply change b -> a
: scriptForgeRegex.Replace(dtaPath, "");
// Removes gen sub directory
if (genPathedFile.IsMatch(dtaPath))
{
var match = genPathedFile.Match(dtaPath);
dtaPath = $"{match.Groups[1]}{match.Groups[4]}";
}
var tempDtbPath = ExtractEntry(ark, scriptEntry, Path.Combine(tempDir, Path.GetRandomFileName()));
try
{
ScriptHelper.ConvertDtbToDta(tempDtbPath, tempDir, arkEncrypted, arkVersion, dtaPath, op.IndentSize);
Console.WriteLine($"Wrote \"{dtaPath}\"");
successDtas++;
}
catch (DTBParseException ex)
{
Console.WriteLine($"Unable to convert to script, skipping \'{scriptEntry.FullPath}\'");
if (File.Exists(dtaPath))
{
File.Delete(dtaPath);
}
}
catch (Exception ex)
{
}
}
if (scriptsToConvert.Count > 0)
{
Console.WriteLine($"Converted {successDtas} of {scriptsToConvert.Count} scripts");
}
// Clean up temp files
if (Directory.Exists(tempDir))
{
Directory.Delete(tempDir, true);
}
}
