mirror of https://github.com/AxioDL/metaforce.git
283 lines
9.6 KiB
C++
283 lines
9.6 KiB
C++
#include <utility>
|
|
#include <stdio.h>
|
|
|
|
#define NOD_ATHENA 1
|
|
#include "SpecBase.hpp"
|
|
#include "DNAMP1/PAK.hpp"
|
|
#include "DNAMP1/MLVL.hpp"
|
|
#include "DNAMP1/STRG.hpp"
|
|
|
|
namespace Retro
|
|
{
|
|
|
|
static LogVisor::LogModule Log("Retro::SpecMP1");
|
|
|
|
struct SpecMP1 : SpecBase
|
|
{
|
|
bool checkStandaloneID(const char* id) const
|
|
{
|
|
if (!memcmp(id, "GM8", 3))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
struct DiscPAK
|
|
{
|
|
const NOD::DiscBase::IPartition::Node& node;
|
|
DNAMP1::PAK pak;
|
|
DiscPAK(const NOD::DiscBase::IPartition::Node& n) : node(n) {}
|
|
};
|
|
std::vector<DiscPAK> m_paks;
|
|
std::map<std::string, DiscPAK*, CaseInsensitiveCompare> m_orderedPaks;
|
|
|
|
void buildPaks(NOD::DiscBase::IPartition::Node& root,
|
|
const std::vector<HECL::SystemString>& args,
|
|
ExtractReport& rep)
|
|
{
|
|
m_paks.clear();
|
|
for (const NOD::DiscBase::IPartition::Node& child : root)
|
|
{
|
|
const std::string& name = child.getName();
|
|
std::string lowerName = name;
|
|
std::transform(lowerName.begin(), lowerName.end(), lowerName.begin(), tolower);
|
|
if (name.size() > 4)
|
|
{
|
|
std::string::iterator extit = lowerName.end() - 4;
|
|
if (!std::string(extit, lowerName.end()).compare(".pak"))
|
|
{
|
|
/* This is a pak */
|
|
std::string lowerBase(lowerName.begin(), extit);
|
|
|
|
/* Needs filter */
|
|
bool good = true;
|
|
if (args.size())
|
|
{
|
|
good = false;
|
|
if (!lowerName.compare(0, 7, "metroid"))
|
|
{
|
|
HECL::SystemChar idxChar = lowerName[7];
|
|
for (const HECL::SystemString& arg : args)
|
|
{
|
|
if (arg.size() == 1 && iswdigit(arg[0]))
|
|
if (arg[0] == idxChar)
|
|
good = true;
|
|
}
|
|
}
|
|
else
|
|
good = true;
|
|
|
|
if (!good)
|
|
{
|
|
for (const HECL::SystemString& arg : args)
|
|
{
|
|
#if HECL_UCS2
|
|
std::string lowerArg = HECL::WideToUTF8(arg);
|
|
#else
|
|
std::string lowerArg = arg;
|
|
#endif
|
|
std::transform(lowerArg.begin(), lowerArg.end(), lowerArg.begin(), tolower);
|
|
if (!lowerArg.compare(0, lowerBase.size(), lowerBase))
|
|
good = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (good)
|
|
{
|
|
m_paks.emplace_back(child);
|
|
NOD::AthenaPartReadStream rs(child.beginReadStream());
|
|
m_paks.back().pak.read(rs);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Sort PAKs alphabetically */
|
|
m_orderedPaks.clear();
|
|
for (DiscPAK& dpak : m_paks)
|
|
m_orderedPaks[dpak.node.getName()] = &dpak;
|
|
|
|
/* Assemble extract report */
|
|
for (const std::pair<std::string, DiscPAK*>& item : m_orderedPaks)
|
|
{
|
|
rep.childOpts.emplace_back();
|
|
ExtractReport& childRep = rep.childOpts.back();
|
|
childRep.name = item.first;
|
|
|
|
DNAMP1::PAK& pak = item.second->pak;
|
|
for (DNAMP1::PAK::Entry& entry : pak.m_entries)
|
|
{
|
|
if (entry.type == MLVL)
|
|
{
|
|
PAKEntryReadStream rs = entry.beginReadStream(item.second->node);
|
|
DNAMP1::MLVL mlvl;
|
|
mlvl.read(rs);
|
|
const DNAMP1::PAK::Entry* nameEnt = pak.lookupEntry(mlvl.worldNameId);
|
|
if (nameEnt)
|
|
{
|
|
PAKEntryReadStream rs = nameEnt->beginReadStream(item.second->node);
|
|
DNAMP1::STRG mlvlName;
|
|
mlvlName.read(rs);
|
|
if (childRep.desc.size())
|
|
childRep.desc += _S(", ");
|
|
childRep.desc += mlvlName.getSystemString(ENGL, 0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool checkFromStandaloneDisc(NOD::DiscBase& disc,
|
|
const HECL::SystemString& regstr,
|
|
const std::vector<HECL::SystemString>& args,
|
|
std::vector<ExtractReport>& reps)
|
|
{
|
|
NOD::DiscGCN::IPartition* partition = disc.getDataPartition();
|
|
std::unique_ptr<uint8_t[]> dolBuf = partition->getDOLBuf();
|
|
const char* buildInfo = (char*)memmem(dolBuf.get(), partition->getDOLSize(), "MetroidBuildInfo", 16) + 19;
|
|
|
|
/* Root Report */
|
|
reps.emplace_back();
|
|
ExtractReport& rep = reps.back();
|
|
rep.name = _S("MP1");
|
|
rep.desc = _S("Metroid Prime ") + regstr;
|
|
if (buildInfo)
|
|
{
|
|
std::string buildStr(buildInfo);
|
|
HECL::SystemStringView buildView(buildStr);
|
|
rep.desc += _S(" (") + buildView.sys_str() + _S(")");
|
|
}
|
|
|
|
/* Iterate PAKs and build level options */
|
|
NOD::DiscBase::IPartition::Node& root = partition->getFSTRoot();
|
|
buildPaks(root, args, rep);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool checkFromTrilogyDisc(NOD::DiscBase& disc,
|
|
const HECL::SystemString& regstr,
|
|
const std::vector<HECL::SystemString>& args,
|
|
std::vector<ExtractReport>& reps)
|
|
{
|
|
std::vector<HECL::SystemString> mp1args;
|
|
if (args.size())
|
|
{
|
|
/* Needs filter */
|
|
for (const HECL::SystemString& arg : args)
|
|
{
|
|
size_t slashPos = arg.find(_S('/'));
|
|
if (slashPos == HECL::SystemString::npos)
|
|
slashPos = arg.find(_S('\\'));
|
|
if (slashPos != HECL::SystemString::npos)
|
|
{
|
|
HECL::SystemString lowerArg(arg.begin(), arg.begin() + slashPos);
|
|
HECL::ToLower(lowerArg);
|
|
if (!lowerArg.compare(_S("mp1")))
|
|
mp1args.emplace_back(HECL::SystemString(arg.begin() + slashPos + 1, arg.end()));
|
|
}
|
|
}
|
|
}
|
|
|
|
NOD::DiscGCN::IPartition* partition = disc.getDataPartition();
|
|
NOD::DiscBase::IPartition::Node& root = partition->getFSTRoot();
|
|
NOD::DiscBase::IPartition::Node::DirectoryIterator dolIt = root.find("rs5mp1_p.dol");
|
|
if (dolIt == root.end())
|
|
return false;
|
|
|
|
std::unique_ptr<uint8_t[]> dolBuf = dolIt->getBuf();
|
|
const char* buildInfo = (char*)memmem(dolBuf.get(), dolIt->size(), "MetroidBuildInfo", 16) + 19;
|
|
|
|
/* Root Report */
|
|
reps.emplace_back();
|
|
ExtractReport& rep = reps.back();
|
|
rep.name = _S("MP1");
|
|
rep.desc = _S("Metroid Prime ") + regstr;
|
|
if (buildInfo)
|
|
{
|
|
std::string buildStr(buildInfo);
|
|
HECL::SystemStringView buildView(buildStr);
|
|
rep.desc += _S(" (") + buildView.sys_str() + _S(")");
|
|
}
|
|
|
|
/* Iterate PAKs and build level options */
|
|
NOD::DiscBase::IPartition::Node::DirectoryIterator mp1It = root.find("MP1");
|
|
if (mp1It == root.end())
|
|
return false;
|
|
buildPaks(*mp1It, mp1args, rep);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool extractFromDisc(NOD::DiscBase& disc, const HECL::Database::Project& project)
|
|
{
|
|
HECL::ProjectPath mp1Path(project.getProjectRootPath(), "MP1");
|
|
|
|
for (const DiscPAK& pak : m_paks)
|
|
{
|
|
const std::string& name = pak.node.getName();
|
|
std::string::const_iterator extit = name.end() - 4;
|
|
std::string baseName(name.begin(), extit);
|
|
|
|
HECL::ProjectPath pakPath(mp1Path, baseName);
|
|
|
|
for (const std::pair<UniqueID32, DNAMP1::PAK::Entry*>& item : pak.pak.m_idMap)
|
|
{
|
|
if (item.second->type == STRG)
|
|
{
|
|
DNAMP1::STRG strg;
|
|
PAKEntryReadStream strgIn = item.second->beginReadStream(pak.node);
|
|
strg.read(strgIn);
|
|
|
|
HECL::SystemChar strgPath[1024];
|
|
HECL::SNPrintf(strgPath, 1024, _S("%s/%08X.strg"), pakPath.getAbsolutePath().c_str(), item.second->id.toUint32());
|
|
std::ofstream strgOut(strgPath);
|
|
strg.writeAngelScript(strgOut);
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool checkFromProject(HECL::Database::Project& proj)
|
|
{
|
|
}
|
|
bool readFromProject(HECL::Database::Project& proj)
|
|
{
|
|
}
|
|
|
|
bool visitGameObjects(std::function<bool(const HECL::Database::ObjectBase&)>)
|
|
{
|
|
}
|
|
struct LevelSpec : public ILevelSpec
|
|
{
|
|
bool visitLevelObjects(std::function<bool(const HECL::Database::ObjectBase&)>)
|
|
{
|
|
}
|
|
struct AreaSpec : public IAreaSpec
|
|
{
|
|
bool visitAreaObjects(std::function<bool(const HECL::Database::ObjectBase&)>)
|
|
{
|
|
}
|
|
};
|
|
bool visitAreas(std::function<bool(const IAreaSpec&)>)
|
|
{
|
|
}
|
|
};
|
|
bool visitLevels(std::function<bool(const ILevelSpec&)>)
|
|
{
|
|
}
|
|
};
|
|
|
|
HECL::Database::DataSpecEntry SpecMP1 =
|
|
{
|
|
_S("MP1"),
|
|
_S("Data specification for original Metroid Prime engine"),
|
|
[](HECL::Database::DataSpecTool) -> HECL::Database::IDataSpec* {return new struct SpecMP1;}
|
|
};
|
|
|
|
}
|
|
|
|
|