internal async Task SavePokemonInfo(PokemonInfoTable table, ReferencedGarc garcPokeInfo)
{
Assertions.AssertVersion(this.Version, table.GameVersion);
var files = await garcPokeInfo.GetFiles();
files[garcPokeInfo.Garc.FileCount - 1] = table.Write();
await garcPokeInfo.SetFiles(files);
}
private (string, string) GetAndCreateGarcPath(ReferencedGarc garc)
{
var outPath = Path.Combine(this.path, garc.Reference.RomFsPath);
var outDir = Path.GetDirectoryName(outPath);
if (!Directory.Exists(outDir))
{
Directory.CreateDirectory(outDir);
}
return(outPath, outDir);
}
internal async Task SaveLearnsets(IEnumerable <Learnset> learnsets, ReferencedGarc garcLearnsets)
{
var list = learnsets.ToList();
foreach (var l in list)
{
Assertions.AssertVersion(this.Version, l.GameVersion);
}
var files = list.Select(l => l.Write()).ToArray();
await garcLearnsets.SetFiles(files);
}
internal async Task SaveItems(IEnumerable <Item> items, ReferencedGarc garcItems)
{
var list = items.ToList();
foreach (var i in list)
{
Assertions.AssertVersion(this.Version, i.GameVersion);
}
var files = list.Select(l => l.Write()).ToArray();
await garcItems.SetFiles(files);
}
protected async Task ForEachGarcFile(ReferencedGarc garc, Func <byte[], int, Task> action, int min = 000, int max = -1)
{
if (max < 0)
{
max = this.MaxGarcIndex;
}
for (var fileIdx = 0; fileIdx < garc.Garc.FileCount; fileIdx++)
{
var file = await garc.GetFile(fileIdx);
await action(file, fileIdx);
}
}
internal async Task SaveTrainerData(IEnumerable <TrainerData> trainerData, ReferencedGarc garcTrainerData, ReferencedGarc garcTrainerPoke)
{
var list = trainerData.ToList();
var trainerFiles = new byte[list.Count][];
var pokemonFiles = new byte[list.Count][];
for (var i = 0; i < list.Count; i++)
{
trainerFiles[i] = list[i].Write();
pokemonFiles[i] = list[i].WriteTeam();
}
await Task.WhenAll(garcTrainerData.SetFiles(trainerFiles), garcTrainerPoke.SetFiles(pokemonFiles));
}
private static async Task WriteGarc(ReferencedGarc garc, GarcReference gRef)
{
if (GarcsToSkip.Contains(gRef.RomFsPath))
{
return;
}
var garcData = await garc.Garc.Write();
await File.WriteAllBytesAsync($"Garc\\{gRef.RomFsPath.Replace( '\\', '_' )}.bin", garcData);
for (var file = 0; file < garc.Garc.FileCount; file++)
{
var fileData = await garc.GetFile(file);
await File.WriteAllBytesAsync($"Garc\\{gRef.RomFsPath.Replace( '\\', '_' )}.{file}.bin", fileData);
}
}
private async Task TestGarcStructure(ReferencedGarc garc, Func <Task> saveAction, bool failOnBadHash = true)
{
var(outPath, outDir) = this.GetAndCreateGarcPath(garc);
var fname = Path.GetFileName(outPath);
await garc.Garc.GarcData.SaveFile();
byte[] origData = (byte[])(await garc.Write()).Clone();
await saveAction();
await garc.Garc.GarcData.SaveFile();
byte[] newData = await garc.Write();
using (var md5 = MD5.Create())
using (var origFs = new FileStream(Path.Combine(outDir, $"{fname}.orig"), FileMode.Create, FileAccess.Write, FileShare.None))
using (var newFs = new FileStream(outPath, FileMode.Create, FileAccess.Write, FileShare.None))
{
await origFs.WriteAsync(origData, 0, origData.Length);
await newFs.WriteAsync(newData, 0, newData.Length);
byte[] hashOriginal = md5.ComputeHash(origData);
byte[] hashNew = md5.ComputeHash(newData);
TestContext.Out.WriteLine($"GARC {garc.Reference.RomFsPath} ({garc.Reference.Name}):");
TestContext.Out.WriteLine($"\tOld hash: {string.Join( "", hashOriginal.Select( d => d.ToString( "X2" ) ) )}");
TestContext.Out.WriteLine($"\tNew hash: {string.Join( "", hashNew.Select( d => d.ToString( "X2" ) ) )}");
try
{
Assert.AreEqual(origData, newData, $"Data for rewritten {garc.Reference.RomFsPath} did not match original");
}
catch (AssertionException ex)
{
if (failOnBadHash)
{
throw;
}
throw new InconclusiveException(ex.Message, ex);
}
}
}
internal async Task SaveMoves(IEnumerable <Move> moves, ReferencedGarc garcMoves)
{
var list = moves.ToList();
foreach (var move in list)
{
Assertions.AssertVersion(this.Version, move.GameVersion);
}
if (this.Version.IsORAS() || this.Version.IsGen7())
{
var file = Mini.PackMini(list.Select(m => m.Write()).ToArray(), "WD");
await garcMoves.SetFile(0, file);
}
else
{
await garcMoves.SetFiles(list.Select( m => m.Write()).ToArray());
}
}
internal async Task SaveTextFile(int fileNum, TextFile textFile, ReferencedGarc garcGameText)
{
await garcGameText.SetFile(fileNum, textFile.Write());
}
internal async Task SaveTextFiles(IEnumerable <TextFile> textFiles, ReferencedGarc garcGameText)
{
var files = textFiles.Select(tf => tf.Write()).ToArray();
await garcGameText.SetFiles(files);
}
internal async Task SaveEvolutions(IEnumerable <EvolutionSet> evolutions, ReferencedGarc garcEvolutions)
{
var files = evolutions.Select(e => e.Write()).ToArray();
await garcEvolutions.SetFiles(files);
}
internal async Task SaveEncounterData(IEnumerable <Gen6.EncounterWild> encounters, ReferencedGarc garcEncounters)
{
var array = encounters.ToArray();
var files = await garcEncounters.GetFiles();
var zoneDataFileIndex = garcEncounters.Garc.FileCount - this.ZoneDataPositionFromEnd;
Assertions.AssertLength(zoneDataFileIndex, array, exact: true);
for (var i = 0; i < array.Length; i++)
{
if (!array[i].HasEntries)
{
continue;
}
var encounterBuffer = array[i].Write();
if (this.Version.IsORAS()) // Have to write encounter zone data to DexNav database too
{
// Last file is dexNavData
const int Offset = 0xE;
var dexNavData = files[files.Length - 1];
var entryPointer = BitConverter.ToInt32(dexNavData, (i + 1) * sizeof(int)) + Offset;
var dataPointer = BitConverter.ToInt32(encounterBuffer, Gen6.EncounterWild.DataOffset);
dataPointer += array[i].DataStart;
var dataLength = array[i].GetAllEntries().Count() * Gen6.EncounterWild.Entry.Size;
Array.Copy(encounterBuffer, dataPointer, dexNavData, entryPointer, dataLength);
}
files[i] = encounterBuffer;
}
await garcEncounters.SetFiles(files);
}
internal async Task SaveEggMoves(IEnumerable <EggMoves> eggMoves, ReferencedGarc garcEggMoves)
{
var files = eggMoves.Select(em => em.Write()).ToArray();
await garcEggMoves.SetFiles(files);
}
