262 lines
8.5 KiB
C++
262 lines
8.5 KiB
C++
#include "asset_resolver.h"
|
||
#include "m2_tokvec.h" // fmt::read_file（host 可注入 FileAccess）
|
||
|
||
#include <algorithm>
|
||
#include <cctype>
|
||
#include <filesystem>
|
||
#include <sstream>
|
||
|
||
namespace fmt {
|
||
|
||
namespace fs = std::filesystem;
|
||
|
||
namespace {
|
||
|
||
std::string lower(std::string s) {
|
||
std::transform(s.begin(), s.end(), s.begin(),
|
||
[](unsigned char c) { return (char)std::tolower(c); });
|
||
return s;
|
||
}
|
||
|
||
// "a/b/./c/../d" -> "a/b/d"（不越过根；越根的 ".." 直接丢）
|
||
std::string collapse(const std::string& in) {
|
||
std::vector<std::string> parts;
|
||
std::string cur;
|
||
auto flush = [&] {
|
||
if (cur.empty()) return;
|
||
if (cur == ".") {
|
||
} else if (cur == "..") {
|
||
if (!parts.empty()) parts.pop_back();
|
||
} else {
|
||
parts.push_back(cur);
|
||
}
|
||
cur.clear();
|
||
};
|
||
for (char c : in) {
|
||
if (c == '/') flush();
|
||
else cur += c;
|
||
}
|
||
flush();
|
||
std::string out;
|
||
for (size_t i = 0; i < parts.size(); ++i) {
|
||
if (i) out += '/';
|
||
out += parts[i];
|
||
}
|
||
return out;
|
||
}
|
||
|
||
const char* kYmir = "ymir work/";
|
||
|
||
// 若 path 含 "ymir work/"，返回从那里起的后缀，否则 ""。
|
||
std::string ymir_suffix(const std::string& norm) {
|
||
auto p = norm.find(kYmir);
|
||
if (p == std::string::npos) return "";
|
||
return norm.substr(p);
|
||
}
|
||
|
||
// 一级目录归类：0=基础(在 priority 里)，1=普通，2=patch/补丁
|
||
int pack_rank(const std::string& top, const std::vector<std::string>& prio) {
|
||
std::string t = lower(top);
|
||
for (size_t i = 0; i < prio.size(); ++i)
|
||
if (lower(prio[i]) == t) return (int)i; // 0..N-1
|
||
if (t.rfind("metin2_patch_", 0) == 0 || t.rfind("patch", 0) == 0) return 100000;
|
||
return 50000;
|
||
}
|
||
|
||
} // namespace
|
||
|
||
std::vector<std::string> AssetResolver::default_priority() {
|
||
return {"Zone", "Terrain", "ETC", "PC", "Tree", "Property", "Effect",
|
||
"Monster", "NPC", "season2", "season3_eu"};
|
||
}
|
||
|
||
std::string AssetResolver::normalize(const std::string& vp) {
|
||
std::string s = vp;
|
||
for (char& c : s)
|
||
if (c == '\\') c = '/';
|
||
s = lower(s);
|
||
// 去盘符 "d:/..." / "d:..."
|
||
if (s.size() >= 2 && std::isalpha((unsigned char)s[0]) && s[1] == ':')
|
||
s = s.substr(2);
|
||
while (!s.empty() && s[0] == '/') s.erase(s.begin());
|
||
return collapse(s);
|
||
}
|
||
|
||
bool AssetResolver::build(const std::string& root, const std::vector<std::string>& prio,
|
||
std::string* err) {
|
||
assets_root = root;
|
||
std::error_code ec;
|
||
if (!fs::exists(root, ec)) {
|
||
if (err) *err = "assets 根不存在: " + root;
|
||
return false;
|
||
}
|
||
|
||
// 收集 (rank, real_path, rel_norm) 后按 rank 稳定排序 —— 保证先注册者 = 高优先级
|
||
struct Rec {
|
||
int rank;
|
||
std::string real, rel;
|
||
};
|
||
std::vector<Rec> recs;
|
||
fs::path base(root);
|
||
for (auto it = fs::recursive_directory_iterator(
|
||
root, fs::directory_options::skip_permission_denied, ec);
|
||
it != fs::recursive_directory_iterator(); it.increment(ec)) {
|
||
if (ec) { ec.clear(); continue; }
|
||
if (!it->is_regular_file(ec)) continue;
|
||
std::string rel_real = fs::relative(it->path(), base, ec).generic_string();
|
||
std::string rel = lower(rel_real);
|
||
if (rel.empty()) continue;
|
||
std::string top = rel.substr(0, rel.find('/'));
|
||
// real_path 存**相对** assets_root（保留原始大小写）；resolve() 拼回。
|
||
recs.push_back({pack_rank(top, prio), rel_real, rel});
|
||
}
|
||
std::stable_sort(recs.begin(), recs.end(),
|
||
[](const Rec& a, const Rec& b) { return a.rank < b.rank; });
|
||
|
||
std::vector<std::string> seen_conflicts;
|
||
for (auto& r : recs) {
|
||
++files_indexed;
|
||
// by_rel
|
||
{
|
||
auto& e = by_rel[r.rel];
|
||
if (e.real_path.empty()) e.real_path = r.real;
|
||
e.all_candidates.push_back(r.real);
|
||
}
|
||
// by_ymir
|
||
std::string suf = ymir_suffix(r.rel);
|
||
if (!suf.empty()) {
|
||
auto& e = by_ymir[suf];
|
||
if (e.real_path.empty()) {
|
||
e.real_path = r.real;
|
||
} else {
|
||
++ymir_conflicts;
|
||
if (seen_conflicts.size() < 50 &&
|
||
std::find(seen_conflicts.begin(), seen_conflicts.end(), suf) ==
|
||
seen_conflicts.end()) {
|
||
seen_conflicts.push_back(suf);
|
||
conflict_keys.push_back(suf);
|
||
}
|
||
}
|
||
e.all_candidates.push_back(r.real);
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
std::string AssetResolver::resolve(const std::string& vp, std::string* reason) const {
|
||
// The 40250 pack manager already resolves its own virtual paths and patch priority.
|
||
// Keep the drive prefix: CEterPackManager indexes "d:/ymir work/..." as such.
|
||
if (assets_root == "pack://") {
|
||
std::string name = lower(vp);
|
||
std::replace(name.begin(), name.end(), '\\', '/');
|
||
if (name.rfind("pack://", 0) == 0) name.erase(0, 7);
|
||
if (name.empty()) {
|
||
if (reason) *reason = "empty pack path";
|
||
return "";
|
||
}
|
||
return assets_root + name;
|
||
}
|
||
auto join = [this](const std::string& rel) {
|
||
if (rel.empty()) return std::string();
|
||
if (assets_root.empty()) return rel;
|
||
std::string r = assets_root;
|
||
if (r.back() != '/') r += '/';
|
||
return r + rel;
|
||
};
|
||
std::string norm = normalize(vp);
|
||
std::string suf = ymir_suffix(norm);
|
||
if (!suf.empty()) {
|
||
auto it = by_ymir.find(suf);
|
||
if (it != by_ymir.end()) return join(it->second.real_path);
|
||
if (reason) *reason = "未在 ymir 索引找到: " + suf;
|
||
return "";
|
||
}
|
||
auto it = by_rel.find(norm);
|
||
if (it != by_rel.end()) return join(it->second.real_path);
|
||
if (reason) *reason = "未在相对路径索引找到: " + norm;
|
||
return "";
|
||
}
|
||
|
||
// --- 索引烘焙 / 装载 ---------------------------------------------------
|
||
|
||
std::string AssetResolver::save_index() const {
|
||
// 行式：MTIDX1 头 + 每行 "Y|R\t<key>\t<rel>"。只存被采用的 real_path。
|
||
std::ostringstream ss;
|
||
ss << "MTIDX1\n";
|
||
for (const auto& kv : by_ymir) {
|
||
ss << "Y\t" << kv.first << '\t' << kv.second.real_path << '\n';
|
||
}
|
||
for (const auto& kv : by_rel) {
|
||
ss << "R\t" << kv.first << '\t' << kv.second.real_path << '\n';
|
||
}
|
||
return ss.str();
|
||
}
|
||
|
||
bool AssetResolver::load_index(const std::string& root, const std::string& text,
|
||
std::string* err) {
|
||
by_ymir.clear();
|
||
by_rel.clear();
|
||
files_indexed = 0;
|
||
ymir_conflicts = 0;
|
||
conflict_keys.clear();
|
||
assets_root = root;
|
||
|
||
std::istringstream in(text);
|
||
std::string line;
|
||
if (!std::getline(in, line) || line.rfind("MTIDX1", 0) != 0) {
|
||
if (err) *err = "asset_index：坏头（期望 MTIDX1）";
|
||
return false;
|
||
}
|
||
while (std::getline(in, line)) {
|
||
if (line.empty() || line[0] == '#') continue;
|
||
// tag \t key \t rel
|
||
size_t t1 = line.find('\t');
|
||
size_t t2 = (t1 == std::string::npos) ? std::string::npos : line.find('\t', t1 + 1);
|
||
if (t2 == std::string::npos) continue;
|
||
std::string tag = line.substr(0, t1);
|
||
std::string key = line.substr(t1 + 1, t2 - t1 - 1);
|
||
std::string rel = line.substr(t2 + 1);
|
||
if (!rel.empty() && rel.back() == '\r') rel.pop_back();
|
||
if (key.empty() || rel.empty()) continue;
|
||
Entry e;
|
||
e.real_path = rel;
|
||
if (tag == "Y") {
|
||
by_ymir.emplace(std::move(key), std::move(e));
|
||
} else if (tag == "R") {
|
||
by_rel.emplace(std::move(key), std::move(e));
|
||
}
|
||
++files_indexed;
|
||
}
|
||
if (by_ymir.empty() && by_rel.empty()) {
|
||
if (err) *err = "asset_index：空索引";
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool AssetResolver::build_or_load(const std::string& root,
|
||
const std::vector<std::string>& prio, std::string* err) {
|
||
if (root == "pack://") {
|
||
assets_root = root;
|
||
return true;
|
||
}
|
||
std::string text;
|
||
if (read_file(root + "/asset_index.txt", text) && text.rfind("MTIDX1", 0) == 0) {
|
||
return load_index(root, text, err);
|
||
}
|
||
return build(root, prio, err);
|
||
}
|
||
|
||
bool AssetResolver::exists(const std::string& vp) const {
|
||
return !resolve(vp, nullptr).empty();
|
||
}
|
||
|
||
std::vector<std::string> AssetResolver::all_rel() const {
|
||
std::vector<std::string> out;
|
||
out.reserve(by_rel.size());
|
||
for (const auto& kv : by_rel) out.push_back(kv.second.real_path);
|
||
return out;
|
||
}
|
||
|
||
} // namespace fmt
|