// Constructor.
public Globalizer(uint baseRam, uint baseRom, byte[] romFile)
{
_decompressor.SetGame(GE.GECompression.BANJOKAZOOIE);
this._baseRam = baseRam;
this._baseRom = baseRom;
foreach (int id in _levelIDArray)
{
// Instantiate Level File Objects
_asmFiles.Enqueue(new AsmFile(id, C.LevelAsmAddress.laa[id], C.LevelObjectsAddress.loa[id]));
_objectsFiles.Enqueue(new ObjectsFile(id, C.LevelObjectsAddress.loa[id], C.LevelObjectsAddress.loa[id + 1]));
// Instantiate Object Variable Arrays.
_variableSpaceArrays.Enqueue(C.VariableSpaceConstants.vsc[id]);
}
// Copy romFile contents to class _rom field.
_rom = new byte[romFile.Length];
for (int i = 0; i < romFile.Length; i++)
{
_rom[i] = romFile[i];
}
// Setup buffer for F37F90 file.
var globalsAsm = new AsmFile(1, 0xF37F90, 0xFA3FD0);
byte[] temp = DecompressFile(globalsAsm);
_F37F90 = new byte[temp.Length];
for (int i = 0; i < temp.Length; i++)
{
_F37F90[i] = temp[i];
}
}
private void UpdateF37F90(AsmFile fileObj)
{
uint jr = 0x03E00008;
uint cmd;
if (fileObj.Id == (int)_levelID.CC)
{
cmd = ASM.GetCommand(_F37F90, 0x5DA20);
UpdateJAL(_F37F90, cmd, 0x5DA20);
}
for (int j = 0; j < C.AsmGlobalsFuncsOffsets.afo[fileObj.Id].Length; j++)
{
int pos = C.AsmGlobalsFuncsOffsets.afo[fileObj.Id][j];
// Step thru all commands in subroutine and check for JALs.
while (ASM.GetCommand(_F37F90, pos) != jr)
{
cmd = ASM.GetCommand(_F37F90, pos);
if (ASM.GetOpcode(cmd) == C.JALCMD)
{
UpdateJAL(_F37F90, cmd, pos);
}
pos += 4;
}
}
}
private void UpdateAsmFile(AsmFile fileObj)
{
// Local Variables
var objectsFile = (ObjectsFile)_objectsFiles.Peek();
// Update current offset.
AsmFile.CurrentFileOffset = RomFile.TotalOffset;
_subOffArray.Add((uint)(RomFile.TotalOffset + _subOffsets[fileObj.Id] + _baseRam));
// Create a local byte[] and pass it decompressed file info.
byte[] asmFile = DecompressFile(fileObj);
// Get _upperRAM value
byte[] objFile = DecompressFile(objectsFile);
_upperRAM = (uint)(_BASERAM + asmFile.Length + objFile.Length + objectsFile.ReservedLength);
// Update JAL and LUI commands.
ProcessCommands(asmFile);
// Update F39F90 JALs
UpdateF37F90(fileObj);
RomFile.UpdateTotalsOffset(asmFile.Length, 0);
// Update file buffer.
_fileBuffer.Add(asmFile);
}
/// <summary>
/// Parses the asm_pc files in the packfile, and stores data about them in AsmFiles.
/// Allows viewing of the files in str2_pc files in vpp_pc files, without extracting them.
/// </summary>
/// <param name="outputPath">Folder to extract the asm_pc file(s) to.</param>
public void ParseAsmFiles(string outputPath)
{
if (!MetadataWasRead || !ContainsAsmFiles)
{
return;
}
Directory.CreateDirectory(outputPath);
foreach (var entry in DirectoryEntries)
{
if (entry.Extension != ".asm_pc")
{
continue;
}
if (!TryExtractSingleFile(entry.FileName, $"{outputPath}{entry.FileName}"))
{
ExtractFileData(outputPath);
}
var asmFile = new AsmFile();
asmFile.ReadFromBinary($"{outputPath}{entry.FileName}");
AsmFiles.Add(asmFile);
}
}
private void GenerateAsmData(AsmFile asmData)
{
}
public static void Main(string[] args)
{
var verbose = false;
var showHelp = false;
var options = new OptionSet()
{
{
"v|verbose",
"be verbose",
v => verbose = v != null
},
{
"h|help",
"show this message and exit",
v => showHelp = v != null
},
};
List <string> extras;
try
{
extras = options.Parse(args);
}
catch (OptionException e)
{
Console.Write("{0}: ", GetExecutableName());
Console.WriteLine(e.Message);
Console.WriteLine("Try `{0} --help' for more information.", GetExecutableName());
return;
}
if (extras.Count < 2 || extras.Count > 3 || showHelp == true)
{
Console.WriteLine("Usage: {0} [OPTIONS]+ [output_file] asm_file containers_dir", GetExecutableName());
Console.WriteLine("Update ASM file.");
Console.WriteLine();
Console.WriteLine("Options:");
options.WriteOptionDescriptions(Console.Out);
return;
}
var inputPath = extras.Count >= 3 ? extras[1] : extras[0];
var outputPath = extras.Count >= 3 ? extras[0] : inputPath;
var filePath = extras.Count >= 3 ? extras[2] : extras[1];
var asm = new AsmFile();
using (var input = File.OpenRead(inputPath))
{
asm.Deserialize(input);
}
foreach (var container in asm.Containers)
{
var containerName = Path.ChangeExtension(container.Name, ".str2_pc");
var containerPath = Path.Combine(filePath, containerName);
if (File.Exists(containerPath) == false)
{
if (verbose == true)
{
Console.WriteLine("Warning: Container '{0}' not found in directory.",
container.Name);
}
continue;
}
//if (verbose == true)
{
Console.WriteLine("=> '{0}'", container.Name);
}
if (container.Sizes.Count !=
container.Primitives.Count)
{
Console.WriteLine("Error: count mismatch in container?");
return;
}
var pkg = new PackageFileV6();
using (var input = File.OpenRead(containerPath))
{
pkg.Deserialize(input);
container.DataOffset = (uint)pkg.DataOffset;
container.CompressedSize = pkg.CompressedSize;
var fileNames = pkg.Entries.Select(e => e.Name.ToLowerInvariant()).ToList();
var primitiveNames = container.Primitives.Select(p => p.Name.ToLowerInvariant()).ToList();
for (int i = 0; i < container.Primitives.Count; i++)
{
var primitive = container.Primitives[i];
//if (verbose == true)
{
Console.WriteLine("==> '{0}'", primitive.Name);
}
string headerName;
string dataName;
switch (primitive.Type)
{
// character meshes
case 5:
{
var extension = Path.GetExtension(primitive.Name);
if (extension == ".ccmesh_pc")
{
headerName = primitive.Name;
dataName = Path.ChangeExtension(headerName, ".gcmesh_pc");
}
else
{
Console.WriteLine("Error: unexpected character mesh extension '{0}'",
extension);
return;
}
break;
}
// pegs
case 16:
{
var extension = Path.GetExtension(primitive.Name);
if (extension == ".cvbm_pc")
{
headerName = primitive.Name;
dataName = Path.ChangeExtension(headerName, ".gvbm_pc");
}
else if (extension == ".cpeg_pc")
{
headerName = primitive.Name;
dataName = Path.ChangeExtension(headerName, ".gpeg_pc");
}
else
{
Console.WriteLine("Error: unexpected PEG extension '{0}'",
extension);
return;
}
break;
}
// static mesh
case 19:
{
var extension = Path.GetExtension(primitive.Name);
if (extension == ".csmesh_pc")
{
headerName = primitive.Name;
dataName = Path.ChangeExtension(headerName, ".gsmesh_pc");
}
else
{
Console.WriteLine("Error: unexpected static mesh extension '{0}'",
extension);
return;
}
break;
}
case 7: // .cmorph_pc
case 15: // .cefc_pc
case 20: // .rig_pc
case 22: // .matlib_pc
case 26: // .vint_doc
case 27: // .lua
{
headerName = primitive.Name;
dataName = null;
break;
}
default:
{
Console.WriteLine("Error: unsupported primitive type {0} ('{1}')",
primitive.Type,
asm.PrimitiveTypes.SingleOrDefault(p => p.Id == primitive.Type).Name);
return;
}
}
if (headerName != null)
{
headerName = headerName.ToLowerInvariant();
var entry = pkg.Entries.SingleOrDefault(
e => e.Name.ToLowerInvariant() == headerName);
if (entry == null)
{
Console.WriteLine("Error: container '{0}' is missing primitive header '{1}'",
container.Name,
headerName);
return;
}
container.Sizes[i].CPUSize = (int)entry.UncompressedSize;
primitive.CPUSize = (int)entry.UncompressedSize;
primitiveNames.Remove(headerName);
fileNames.Remove(headerName);
}
if (dataName != null)
{
dataName = dataName.ToLowerInvariant();
var entry = pkg.Entries.SingleOrDefault(
e => e.Name.ToLowerInvariant() == dataName);
if (entry == null)
{
Console.WriteLine("Error: container '{0}' is missing primitive data '{1}'",
container.Name,
dataName);
return;
}
container.Sizes[i].GPUSize = (int)entry.UncompressedSize;
primitive.GPUSize = (int)entry.UncompressedSize;
primitiveNames.Remove(dataName);
fileNames.Remove(dataName);
}
}
if (fileNames.Count > 0)
{
Console.WriteLine("Error: container '{0}' is missing primitives for",
container.Name);
foreach (var name in fileNames)
{
Console.WriteLine(" '{0}'", name);
}
return;
}
if (primitiveNames.Count > 0)
{
Console.WriteLine("Error: package '{0}' is missing files for",
container.Name);
foreach (var name in primitiveNames)
{
Console.WriteLine(" '{0}'", name);
}
return;
}
}
}
using (var output = File.Create(outputPath))
{
asm.Serialize(output);
}
}
public static void Main(string[] args)
{
var mode = Mode.Unknown;
var showHelp = false;
var options = new OptionSet()
{
{
"a|xml2asm",
"convert xml to asm",
v => mode = v != null ? Mode.ToASM : mode
},
{
"x|asm2xml",
"convert asm to xml",
v => mode = v != null ? Mode.ToXML : mode
},
{
"h|help",
"show this message and exit",
v => showHelp = v != null
},
};
List <string> extras;
try
{
extras = options.Parse(args);
}
catch (OptionException e)
{
Console.Write("{0}: ", GetExecutableName());
Console.WriteLine(e.Message);
Console.WriteLine("Try `{0} --help' for more information.", GetExecutableName());
return;
}
if (extras.Count != 2 || showHelp == true || mode == Mode.Unknown)
{
Console.WriteLine("Usage: {0} [OPTIONS]+ -a|-x input_file output_file", GetExecutableName());
Console.WriteLine(".asm_pc file conversions.");
Console.WriteLine();
Console.WriteLine("Options:");
options.WriteOptionDescriptions(Console.Out);
return;
}
var inputPath = extras[0];
var outputPath = extras[1];
if (mode == Mode.ToXML)
{
using (var input = File.OpenRead(inputPath))
{
var asm = new AsmFile();
asm.Deserialize(input);
using (var output = File.Create(outputPath))
{
var serializer = new XmlSerializer(typeof(AsmFile));
serializer.Serialize(output, asm);
}
}
}
else if (mode == Mode.ToASM)
{
using (var input = File.OpenRead(inputPath))
{
var serializer = new XmlSerializer(typeof(AsmFile));
var asm = (AsmFile)serializer.Deserialize(input);
using (var output = File.Create(outputPath))
{
asm.Serialize(output);
}
}
}
else
{
throw new NotSupportedException();
}
}
public static void Main(string[] args)
{
bool showHelp = false;
bool overwriteFiles = false;
bool xml2asm = false;
bool asm2xml = false;
var options = new OptionSet()
{
{
"o|overwrite",
"overwrite files if they already exist",
v => overwriteFiles = v != null
},
{
"a|xml2asm",
"convert xml to asm",
v => xml2asm = v != null
},
{
"x|asm2xml",
"convert asm to xml",
v => asm2xml = v != null
},
{
"h|help",
"show this message and exit",
v => showHelp = v != null
},
};
List <string> extra;
try
{
extra = options.Parse(args);
}
catch (OptionException e)
{
Console.Write("{0}: ", GetExecutableName());
Console.WriteLine(e.Message);
Console.WriteLine("Try `{0} --help' for more information.", GetExecutableName());
return;
}
if (extra.Count != 2 || showHelp == true || asm2xml == xml2asm)
{
Console.WriteLine("Usage: {0} [OPTIONS]+ -a|-x input_file output_file", GetExecutableName());
Console.WriteLine(".asm_pc file conversions.");
Console.WriteLine();
Console.WriteLine("Options:");
options.WriteOptionDescriptions(Console.Out);
return;
}
string inputPath = extra[0];
string outputPath = extra[1];
if (File.Exists(outputPath) && overwriteFiles == false)
{
return;
}
if (asm2xml == true)
{
using (var input = File.OpenRead(inputPath))
{
var asm = new AsmFile();
asm.Deserialize(input);
using (var output = File.Create(outputPath))
{
var serializer = new XmlSerializer(typeof(AsmFile));
serializer.Serialize(output, asm);
}
}
}
else if (xml2asm == true)
{
using (var input = File.OpenRead(inputPath))
{
var serializer = new XmlSerializer(typeof(AsmFile));
var asm = (AsmFile)serializer.Deserialize(input);
using (var output = File.Create(outputPath))
{
asm.Serialize(output);
}
}
}
}