public override void ReadFromStream(AwesomeReader ar, ISerializable data)
{
var env = data as Environ;
int version = ReadMagic(ar, data);
MiloSerializer.ReadFromStream(ar.BaseStream, env.Draw);
// Read lights
var lightCount = ar.ReadInt32();
env.Lights.Clear();
env.Lights.AddRange(RepeatFor(lightCount, () => ar.ReadString()));
env.AmbientColor = new Color4()
{
R = ar.ReadSingle(),
G = ar.ReadSingle(),
B = ar.ReadSingle(),
A = ar.ReadSingle()
};
env.FogStart = ar.ReadSingle();
env.FogEnd = ar.ReadSingle();
env.FogColor = new Color4()
{
R = ar.ReadSingle(),
G = ar.ReadSingle(),
B = ar.ReadSingle(),
A = ar.ReadSingle()
};
env.EnableFog = ar.ReadBoolean();
}
public override void ReadFromStream(AwesomeReader ar, ISerializable data)
{
var cam = data as Cam;
int version = ReadMagic(ar, data);
MiloSerializer.ReadFromStream(ar.BaseStream, cam.Trans);
MiloSerializer.ReadFromStream(ar.BaseStream, cam.Draw);
cam.NearPlane = ar.ReadSingle();
cam.FarPlane = ar.ReadSingle();
cam.FOV = ar.ReadSingle();
// Read screen area
cam.ScreenArea = new Rectangle()
{
X = ar.ReadSingle(),
Y = ar.ReadSingle(),
Width = ar.ReadSingle(),
Height = ar.ReadSingle()
};
// Read z-range
cam.ZRange = new Vector2()
{
X = ar.ReadSingle(),
Y = ar.ReadSingle()
};
cam.TargetTexture = ar.ReadString();
}
public static T ReadFromMiloObjectBytes <T>(this MiloSerializer serializer, MiloObjectBytes entry) where T : ISerializable, new()
{
using (var ms = new MemoryStream(entry.Data))
{
var obj = serializer.ReadFromStream <T>(ms);
(obj as MiloObject).Name = entry.Name;
return(obj);
}
}
public override void ReadFromStream(AwesomeReader ar, ISerializable data)
{
var view = data as View;
int version = ReadMagic(ar, data);
var meta = ReadMeta(ar);
MiloSerializer.ReadFromStream(ar.BaseStream, view.Anim);
MiloSerializer.ReadFromStream(ar.BaseStream, view.Trans);
MiloSerializer.ReadFromStream(ar.BaseStream, view.Draw);
if (version >= 11)
{
// Read draw group
var drawableCount = ar.ReadInt32();
view.Draw.Drawables.Clear();
view.Draw.Drawables.AddRange(RepeatFor(drawableCount, () => ar.ReadString()));
}
view.MainView = ar.ReadString();
if (version == 11)
{
// Has less data at end of file
return;
}
// Ratio is usually 4:3
view.LODHeight = ar.ReadSingle();
view.LODWidth = ar.ReadSingle();
// 9 extra bytes for v14?
/*
* if (view.ScreenHeight > 0.0f && (view.ScreenWidth / view.ScreenHeight) != (4.0f / 3.0f))
* throw new Exception($"Aspect ratio should be {(4.0f / 3.0f):F2}, got {(view.ScreenWidth / view.ScreenHeight):F2}");
*/
}
public override void ReadFromStream(AwesomeReader ar, ISerializable data)
{
var mesh = data as Mesh;
int version = ReadMagic(ar, data);
var meta = ReadMeta(ar);
MiloSerializer.ReadFromStream(ar.BaseStream, mesh.Trans);
MiloSerializer.ReadFromStream(ar.BaseStream, mesh.Draw);
mesh.Material = ar.ReadString();
mesh.MainMesh = ar.ReadString();
mesh.Unknown = ar.ReadInt32();
switch (mesh.Unknown)
{
case 0:
case 31:
case 33:
case 37:
case 63:
break;
default:
throw new Exception($"Unexpected number, got {mesh.Unknown}");
}
var num = ar.ReadInt32();
if (!(num == 0 || num == 1))
{
throw new Exception($"This should be 0 or 1, got {num}");
}
num = ar.ReadByte();
if (num != 0)
{
throw new Exception($"This should be 0, got {num}");
}
// Read vertices
var count = ar.ReadInt32();
if (version >= 36)
{
ar.BaseStream.Position += 9; // Skips unknown stuff
}
mesh.Vertices.Clear();
mesh.Vertices.AddRange(RepeatFor(count, () =>
{
var vertex = new Vertex3();
vertex.X = ar.ReadSingle();
vertex.Y = ar.ReadSingle();
vertex.Z = ar.ReadSingle();
if (version == 34)
{
ar.BaseStream.Position += 4; // Skip W for RB1
}
if (version < 35)
{
// Single precision
vertex.NormalX = ar.ReadSingle();
vertex.NormalY = ar.ReadSingle();
vertex.NormalZ = ar.ReadSingle();
if (version == 34)
{
ar.BaseStream.Position += 4; // Skip W for RB1
}
vertex.ColorR = ar.ReadSingle();
vertex.ColorG = ar.ReadSingle();
vertex.ColorB = ar.ReadSingle();
vertex.ColorA = ar.ReadSingle();
vertex.U = ar.ReadSingle();
vertex.V = ar.ReadSingle();
if (version == 34)
{
ar.BaseStream.Position += 24; // Skip unknown bytes for RB1
}
}
else
{
// Half precision
vertex.U = ar.ReadHalf();
vertex.V = ar.ReadHalf();
// Not sure what this value is but it's usually pretty high
ar.BaseStream.Position += 8;
// Skip reading normals for now
//vertex.NormalX = ar.ReadHalf();
//vertex.NormalY = ar.ReadHalf();
//vertex.NormalZ = ar.ReadHalf();
vertex.NormalX = 1.0f;
vertex.NormalY = 1.0f;
vertex.NormalZ = 1.0f;
vertex.ColorR = ar.ReadByte();
vertex.ColorG = ar.ReadByte();
vertex.ColorB = ar.ReadByte();
vertex.ColorA = ar.ReadByte();
// Skip unknown bytes
ar.BaseStream.Position += 8;
}
return(vertex);
}));
// Read face indicies
count = ar.ReadInt32();
mesh.Faces.Clear();
mesh.Faces.AddRange(RepeatFor(count, () => new Face()
{
V1 = ar.ReadUInt16(),
V2 = ar.ReadUInt16(),
V3 = ar.ReadUInt16(),
}));
// Read groups
count = ar.ReadInt32();
var groupSizes = RepeatFor(count, () => ar.ReadByte()).ToArray();
if (groupSizes.Select(x => (int)x).Sum() != mesh.Faces.Count)
{
throw new Exception("Sum should equal count of faces");
}
var charCount = ar.ReadInt32();
ar.BaseStream.Position -= 4;
// Read bones
mesh.Bones.Clear();
if (charCount > 0)
{
if (version >= 36)
{
// Uses variable length bone count
ar.BaseStream.Position += 4;
mesh.Bones
.AddRange(RepeatFor(charCount, () => new Bone()
{
Name = ar.ReadString(),
Mat = ReadMatrix(ar)
}));
}
else
{
// Uses constant length bone count
const int boneCount = 4; // Always 4?
var boneNames = RepeatFor(boneCount, () => ar.ReadString()).ToArray(); // Either 3 or none (Last one is always empty?)
var boneMats = RepeatFor(boneCount, () => ReadMatrix(ar)).ToArray();
for (int i = 0; i < boneCount; i++)
{
mesh.Bones.Add(new Bone()
{
Name = boneNames[i],
Mat = boneMats[i]
});
}
}
}
else
{
// Skips zero
ar.BaseStream.Position += 4;
}
if (version == 36)
{
ar.BaseStream.Position += 1;
}
else if (version >= 37)
{
ar.BaseStream.Position += 2;
}
mesh.Groups.Clear();
if (count <= 0 || groupSizes[0] <= 0 || ar.BaseStream.Length == ar.BaseStream.Position)
{
mesh.Groups.AddRange(groupSizes
.Select(x => new FaceGroup()
{
Size = x,
Sections = new List <int>(),
VertexIndicies = new List <int>()
}));
return;
}
// Read face groups
mesh.Groups.AddRange(Enumerable.Range(0, count).Select(x =>
{
var sectionCount = ar.ReadInt32();
var vertCount = ar.ReadInt32();
return(new FaceGroup()
{
Size = groupSizes[x],
Sections = Enumerable.Range(0, sectionCount)
.Select(y => ar.ReadInt32())
.ToList(),
VertexIndicies = Enumerable.Range(0, vertCount)
.Select(y => (int)ar.ReadUInt16())
.ToList(),
});
}));
}
public override void ReadFromStream(AwesomeReader ar, ISerializable data)
{
var tex = data as Tex;
int version = ReadMagic(ar, data);
// Skips zeros
if (version >= 10 && MiloSerializer.Info.Version == 24)
{
ar.BaseStream.Position += 9; // GH2 PS2
}
else if (version >= 10)
{
// GH2 360 (13 bytes when no script)
ar.BaseStream.Position += 4; // Revision number? Usually 1 or 2
tex.ScriptName = ar.ReadString(); // Script name?
var hasDtb = ar.ReadBoolean();
if (hasDtb)
{
ar.BaseStream.Position -= 1;
tex.Script = DTBFile.FromStream(ar, DTBEncoding.Classic);
}
// Extra meta (comment?)
var meta = ar.ReadString();
if (version >= 11)
{
ar.BaseStream.Position += 1; // Not sure why it has an extra byte
}
}
tex.Width = ar.ReadInt32();
tex.Height = ar.ReadInt32();
tex.Bpp = ar.ReadInt32();
tex.ExternalPath = ar.ReadString();
tex.IndexF = ar.ReadSingle();
if (tex.IndexF < -13.0f || (tex.IndexF > 0.0f && tex.IndexF != 666.0f))
{
throw new NotSupportedException($"Expected number between -13.0 <-> 0.0, got {tex.IndexF}");
}
tex.Index = ar.ReadInt32();
switch (tex.Index)
{
case 1:
case 2:
case 4:
case 8: // krpa
case 34:
break;
default:
throw new NotSupportedException($"Unexpected number, got {tex.Index}");
}
tex.UseExternal = ar.ReadBoolean();
tex.Bitmap = null;
if (ar.BaseStream.Position == ar.BaseStream.Length)
{
return;
}
tex.Bitmap = MiloSerializer.ReadFromStream <HMXBitmap>(ar.BaseStream);
}
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 IActionResult ScanArkPost([FromBody] ScanRequest request)
{
_miloContext.Database.EnsureCreated();
var sw = Stopwatch.StartNew();
// Updates games (arks)
var game = _miloContext.Arks.FirstOrDefault(x => x.Title == request.GameTitle &&
x.Platform == request.Platform &&
x.Region == request.Region);
if (game == null)
{
// Create game
game = new Data.MiloEntities.Ark()
{
Title = request.GameTitle,
Platform = request.Platform,
Region = request.Region
};
_miloContext.Arks.Add(game);
_miloContext.SaveChanges();
}
var ark = ArkFile.FromFile(request.InputPath);
game.ArkVersion = (int)ark.Version;
var miloEntries = new List <Data.MiloEntities.ArkEntry>();
var totalMiloEntries = 0;
// Updates ark entries
foreach (var arkEntry in ark.Entries)
{
var entry = arkEntry as OffsetArkEntry;
var contextEntry = _miloContext.ArkEntries.FirstOrDefault(x => x.Ark == game && x.Path == entry.FullPath);
if (contextEntry == null)
{
contextEntry = new Data.MiloEntities.ArkEntry()
{
Ark = game,
Path = entry.FullPath
};
_miloContext.ArkEntries.Add(contextEntry);
_miloContext.SaveChanges();
}
contextEntry.Part = entry.Part;
contextEntry.Offset = entry.Offset;
contextEntry.Size = (int)entry.Size;
contextEntry.InflatedSize = (int)entry.InflatedSize;
if (_miloRegex.IsMatch(contextEntry.Path))
{
miloEntries.Add(contextEntry);
}
_miloContext.Update(contextEntry);
}
// Updates milos
foreach (var miloEntry in miloEntries)
{
var arkEntry = ark.Entries.First(x => x.FullPath == miloEntry.Path);
var mf = MiloFile.ReadFromStream(ark.GetArkEntryFileStream(arkEntry));
var serializer = new MiloSerializer(new SystemInfo()
{
BigEndian = mf.BigEndian, Version = mf.Version
});
MiloObjectDir milo;
using (var ms = new MemoryStream(mf.Data))
{
milo = serializer.ReadFromStream <MiloObjectDir>(ms);
}
totalMiloEntries += milo.Entries.Count;
var contextEntry = _miloContext.Milos.FirstOrDefault(x => x.ArkEntry == miloEntry);
if (contextEntry == null)
{
contextEntry = new Data.MiloEntities.Milo()
{
ArkEntry = miloEntry
};
_miloContext.Milos.Add(contextEntry);
_miloContext.SaveChanges();
}
contextEntry.Version = mf.Version;
contextEntry.TotalSize = mf.Data.Length;
contextEntry.Name = milo.Name ?? "";
contextEntry.Type = milo.Type ?? "";
var dirEntry = milo.Entries
.Where(x => ((string)x.Type).EndsWith("Dir") && x is MiloObjectBytes)
.Select(x => x as MiloObjectBytes)
.FirstOrDefault();
if (dirEntry != null)
{
contextEntry.Size = dirEntry.Data.Length;
contextEntry.Magic = dirEntry.GetMagic();
}
else
{
contextEntry.Size = -1;
contextEntry.Magic = -1;
}
// Updates milo entries
foreach (var mEntry in milo.Entries.Where(x => x is MiloObjectBytes && x != dirEntry).Select(y => y as MiloObjectBytes))
{
var contextMEntry = _miloContext.MiloEntries.FirstOrDefault(x => x.Milo == contextEntry && x.Name == mEntry.Name && x.Type == mEntry.Type);
if (contextMEntry == null)
{
contextMEntry = new Data.MiloEntities.MiloEntry()
{
Milo = contextEntry
};
_miloContext.MiloEntries.Add(contextMEntry);
_miloContext.SaveChanges();
}
contextMEntry.Name = mEntry.Name ?? "";
contextMEntry.Type = mEntry.Type ?? "";
contextMEntry.Size = mEntry.Data.Length;
contextMEntry.Magic = mEntry.GetMagic();
_miloContext.Update(contextMEntry);
}
_miloContext.Update(contextEntry);
}
_miloContext.SaveChanges();
sw.Stop();
return(Ok(new ScanResult()
{
TotalArkEntries = ark.Entries.Count,
TotalMilos = miloEntries.Count,
TotalMiloEntries = totalMiloEntries,
TimeElapsed = sw.ElapsedMilliseconds
}));
}
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);
}
}