mirror of
https://gitlab.com/YuukiPS/GC-Resources.git
synced 2025-05-19 01:15:23 +00:00
693 lines
24 KiB
JavaScript
693 lines
24 KiB
JavaScript
const path = require('path');
|
|
const fs = require('fs');
|
|
|
|
const textMapFolderPath = path.resolve('../Resources/TextMap');
|
|
const textMapFiles = fs.readdirSync(textMapFolderPath);
|
|
|
|
const getHashEN = readJsonFile('../Resources/TextMap/TextMapEN.json');
|
|
const getHashCN = readJsonFile('../Resources/TextMap/TextMapCHS.json'); // beta stuff
|
|
|
|
// TODO: API IMAGE
|
|
|
|
function runAvatar(lang, getHashLANG) {
|
|
const saveAvatar = lang + `avatar.json`;
|
|
const getAvatar = readJsonFile('../Resources/ExcelBinOutput/AvatarExcelConfigData.json');
|
|
var dataAvatar = [];
|
|
for (const data of Object.values(getAvatar)) {
|
|
|
|
if (data && data.nameTextMapHash && data.nameTextMapHash) {
|
|
const hash = data.nameTextMapHash;
|
|
const id = data.id;
|
|
|
|
if (id < 10000002 || id >= 11000000) continue;
|
|
|
|
const iconName = data.iconName;
|
|
|
|
const name = getHashLANG[hash] || getHashCN[hash] || `N/A`;
|
|
|
|
var objAvatar = new Object();
|
|
objAvatar["id"] = id;
|
|
objAvatar["name"] = name;
|
|
objAvatar['img'] = `https://upload-os-bbs.mihoyo.com/game_record/genshin/character_icon/${iconName}.png` // TODO: download all image to localhost or just dump it bruh
|
|
dataAvatar.push(objAvatar)
|
|
|
|
} else {
|
|
console.log("skip", data);
|
|
}
|
|
|
|
}
|
|
fs.writeFileSync(saveAvatar, JSON.stringify(dataAvatar, null, 2));
|
|
dataAvatar = []; // cleanup
|
|
console.log(`done avatar: ` + saveAvatar)
|
|
}
|
|
function runScene(lang, getHashLANG) {
|
|
const saveScene = lang + `scene.json`;
|
|
const getScene = readJsonFile('../Resources/ExcelBinOutput/SceneExcelConfigData.json');
|
|
var dataScene = [];
|
|
for (const data of Object.values(getScene)) {
|
|
|
|
if (data && data.id) {
|
|
|
|
const id = data.id;
|
|
const name = `${data.scriptData}` + (data.levelEntityConfig == "" ? "" : " (" + data.levelEntityConfig + ")")
|
|
|
|
var objScene = new Object();
|
|
objScene["id"] = id;
|
|
objScene["name"] = `${name}`;
|
|
|
|
dataScene.push(objScene)
|
|
|
|
} else {
|
|
console.log("skip", data);
|
|
}
|
|
|
|
}
|
|
console.log(`Done scene: ` + saveScene)
|
|
fs.writeFileSync(saveScene, JSON.stringify(dataScene, null, 2));
|
|
dataScene = []; // cleanup
|
|
|
|
/*
|
|
const saveStage = lang + `stage.json`;
|
|
const getStage = readJsonFile('../Resources/ExcelOutput/StageConfig.json');
|
|
for (const data of Object.values(getStage)) {
|
|
|
|
if (data && data.StageName && data.StageName.Hash) {
|
|
const hash = data.StageName.Hash;
|
|
const id = data.StageID;
|
|
|
|
const name = getHashLANG[hash] || getHashCN[hash] || `N/A`;
|
|
|
|
var objScene = new Object();
|
|
objScene["id"] = id;
|
|
objScene["name"] = `${name} (${data.StageType} #${data.Level})`;
|
|
dataScene.push(objScene)
|
|
|
|
} else {
|
|
console.log("skip", data);
|
|
}
|
|
|
|
}
|
|
console.log(`Done stage: ` + saveStage)
|
|
fs.writeFileSync(saveStage, JSON.stringify(dataScene, null, 2));
|
|
dataScene = []; // cleanup
|
|
*/
|
|
}
|
|
function runMonster(lang, getHashLANG) {
|
|
const saveMonster = lang + 'monster.json';
|
|
const getMonster = readJsonFile('../Resources/ExcelBinOutput/MonsterExcelConfigData.json');
|
|
var dataMonster = [];
|
|
for (const data of Object.values(getMonster)) {
|
|
|
|
if (data && data.nameTextMapHash) {
|
|
const hash = data.nameTextMapHash;
|
|
const id = data.id;
|
|
|
|
const name = getHashLANG[hash] || getHashCN[hash] || data.monsterName || `N/A`;
|
|
|
|
var objMonster = new Object();
|
|
objMonster["id"] = id;
|
|
objMonster["name"] = name;
|
|
dataMonster.push(objMonster)
|
|
|
|
} else {
|
|
console.log("skip", data);
|
|
}
|
|
|
|
}
|
|
fs.writeFileSync(saveMonster, JSON.stringify(dataMonster, null, 2));
|
|
dataMonster = []; // cleanup
|
|
console.log(`done monster: ` + saveMonster)
|
|
}
|
|
function runProp(lang, getHashLANG) {
|
|
const saveProp = lang + 'prop.json';
|
|
const getProp = readJsonFile('../Resources/ExcelBinOutput/GadgetExcelConfigData.json');
|
|
var dataProp = [];
|
|
for (const data of Object.values(getProp)) {
|
|
|
|
if (data && data.nameTextMapHash) {
|
|
const hash = data.nameTextMapHash;
|
|
const hash2 = data.interactNameTextMapHash;
|
|
const id = data.id;
|
|
const NamePath = data.jsonName;
|
|
|
|
const name = (getHashLANG[hash] || getHashCN[hash] || getHashLANG[hash2] || getHashCN[hash2] || `N/A`) + (NamePath == "" ? "" : " (" + NamePath + ")")
|
|
|
|
var objProp = new Object();
|
|
objProp["id"] = id;
|
|
objProp["name"] = name;
|
|
dataProp.push(objProp)
|
|
|
|
} else {
|
|
console.log("skip", data);
|
|
}
|
|
|
|
}
|
|
fs.writeFileSync(saveProp, JSON.stringify(dataProp, null, 2));
|
|
dataProp = []; // cleanup
|
|
console.log(`done Prop: ` + saveProp)
|
|
}
|
|
function runItem(lang, getHashLANG) {
|
|
|
|
const saveItem = lang + 'item.json';
|
|
var dataItem = [];
|
|
|
|
const filePaths = [
|
|
'../Resources/ExcelBinOutput/MaterialExcelConfigData.json',
|
|
// '../Resources/ExcelBinOutput/WeaponExcelConfigData.json',
|
|
//'../Resources/ExcelBinOutput/ReliquaryExcelConfigData.json',
|
|
'../Resources/ExcelBinOutput/HomeWorldFurnitureExcelConfigData.json'
|
|
];
|
|
|
|
filePaths.forEach(filePath => {
|
|
const getItem = readJsonFile(filePath);
|
|
for (const data of Object.values(getItem)) {
|
|
if (data && data.nameTextMapHash) {
|
|
const hash = data.nameTextMapHash;
|
|
const id = data.id;
|
|
|
|
const name = getHashLANG[hash] || getHashCN[hash] || `N/A`;
|
|
|
|
var iconPath = data.icon; // UI_EquipIcon_${item.type}_${item.id}
|
|
var image = `https://upload-os-bbs.mihoyo.com/game_record/genshin/equip/${iconPath}.png`;
|
|
|
|
var objItem = new Object();
|
|
objItem["id"] = id;
|
|
objItem["name"] = `${name}`;
|
|
objItem["type"] = data.itemType;
|
|
objItem["rank"] = data.rank;
|
|
objItem["img"] = image
|
|
|
|
dataItem.push(objItem);
|
|
|
|
} else {
|
|
console.log("skip", data);
|
|
}
|
|
}
|
|
});
|
|
|
|
fs.writeFileSync(saveItem, JSON.stringify(dataItem, null, 2));
|
|
dataItem = []; // cleanup
|
|
console.log(`done item: ` + saveItem)
|
|
}
|
|
function runWeapon(lang, getHashLANG) {
|
|
|
|
const saveItem = lang + 'weapon.json';
|
|
var dataItem = [];
|
|
|
|
const filePaths = [
|
|
'../Resources/ExcelBinOutput/WeaponExcelConfigData.json' // light cone ?
|
|
];
|
|
|
|
filePaths.forEach(filePath => {
|
|
const getItem = readJsonFile(filePath);
|
|
for (const data of Object.values(getItem)) {
|
|
if (data && data.nameTextMapHash) {
|
|
const hash = data.nameTextMapHash;
|
|
const id = data.id;
|
|
|
|
const name = getHashLANG[hash] || getHashCN[hash] || `N/A`;
|
|
|
|
var subType = data.weaponType;
|
|
var iconPath = data.icon;
|
|
var image = `https://upload-os-bbs.mihoyo.com/game_record/genshin/equip/${iconPath}.png`;
|
|
|
|
var objItem = new Object();
|
|
objItem["id"] = id;
|
|
objItem["name"] = `${name}`;
|
|
objItem["type_main"] = data.itemType;
|
|
objItem["type_sub"] = subType;
|
|
objItem["rank"] = data.rankLevel;
|
|
objItem["img"] = image
|
|
|
|
dataItem.push(objItem);
|
|
|
|
} else {
|
|
console.log("skip", data);
|
|
}
|
|
}
|
|
});
|
|
|
|
fs.writeFileSync(saveItem, JSON.stringify(dataItem, null, 2));
|
|
dataItem = []; // cleanup
|
|
console.log(`done wp: ` + saveItem)
|
|
}
|
|
|
|
const getRelicConfig = readJsonFile('../Resources/ExcelBinOutput/ReliquaryExcelConfigData.json');
|
|
|
|
|
|
const getRelicSub = readJsonFile('../Resources/ExcelBinOutput/ReliquaryAffixExcelConfigData.json'); // sub
|
|
|
|
const getAvatarProp = readJsonFile('../Resources/ExcelBinOutput/AvatarCurveExcelConfigData.json');
|
|
const getHasIndex1 = readJsonFile(`../Resources/ExcelBinOutput/ManualTextMapConfigData.json`)
|
|
|
|
// Main
|
|
const getRelicMain = readJsonFile('../Resources/ExcelBinOutput/ReliquaryMainPropExcelConfigData.json');
|
|
const levelConfig = readJsonFile(`../Resources/ExcelBinOutput/ReliquaryLevelExcelConfigData.json`)
|
|
|
|
// Simulator
|
|
// /give 76544 lv1 x1 15001 501064,1 501204,1 501224,1 501234,1
|
|
function runGiveEmu(cmd) {
|
|
|
|
const parts = cmd.split(" ");
|
|
const action = parts[1];
|
|
|
|
const item_id = parseInt(action);
|
|
|
|
let level = 1;
|
|
let item_count = 1;
|
|
let refined_count = 0;
|
|
let main_prop_id = 0;
|
|
let propDataCount = 0;
|
|
var maxStep = false;
|
|
var maxLevel = 999;
|
|
|
|
if (parts.length > 2) {
|
|
let currentParamIndex = 2;
|
|
while (currentParamIndex < parts.length) {
|
|
|
|
const param = parts[currentParamIndex];
|
|
//console.log(param)
|
|
|
|
if (param.startsWith("x")) {
|
|
item_count = parseInt(param.replace("x", ""));
|
|
} else if (param.startsWith("s")) {
|
|
//main_prop_id = parseInt(param.replace("s", ""));
|
|
} else if (param.startsWith("lv")) {
|
|
level = parseInt(param.replace("lv", "")) + 1;
|
|
console.log(`found level: ` + level)
|
|
} else if (param.startsWith("r")) {
|
|
refined_count = parseInt(param.replace("r", "")) + 1;
|
|
} else if (param.startsWith("sorted")) {
|
|
//continue
|
|
} else if (param.startsWith("-maxsteps")) {
|
|
maxStep = true;
|
|
//console.log(`found max`)
|
|
} else {
|
|
|
|
main_prop_id = parseInt(param)
|
|
|
|
var dataRelic = getRelicConfig.find(entry => entry.id == item_id);
|
|
console.log(dataRelic)
|
|
|
|
var dataRelicMain = getRelicMain.find(entry => entry.id == main_prop_id);
|
|
if (dataRelicMain) {
|
|
|
|
//console.log(dataRelicMain)
|
|
//console.log(`RelicMainAffixConfig ${dataRelic.MainAffixGroup} > ${main_prop_id}`)
|
|
|
|
// Get Name
|
|
var mainPropHash = getHasIndex1.find(item =>
|
|
item.textMapId === dataRelicMain.propType
|
|
).textMapContentTextMapHash;
|
|
|
|
const nameMain = getHashEN[mainPropHash] || getHashCN[mainPropHash] || `N/A`;
|
|
|
|
//console.log(dataRelic.rankLevel)
|
|
|
|
var valueMain = 0;
|
|
var TesLevel = levelConfig.find(entry =>
|
|
entry.level === level &&
|
|
entry.rank === dataRelic.rankLevel &&
|
|
entry.addProps.some(prop => prop.propType === dataRelicMain.propType)
|
|
);
|
|
|
|
if (!TesLevel) {
|
|
//var tus1 = getRelicSub.find(entry => entry.propType == dataRelicMain.propType);
|
|
//valueMain = tus1.propValue
|
|
//console.log(`${dataRelicMain.propType} > ${main_prop_id} > ${valueMain}`, tus1)
|
|
//continue;
|
|
console.log('not found data...')
|
|
return
|
|
} else {
|
|
var tus2 = TesLevel.addProps.find(prop => prop.propType === dataRelicMain.propType);
|
|
//console.log(tus2)
|
|
valueMain = tus2.value;
|
|
}
|
|
|
|
var lo = CaC(dataRelicMain.propType, valueMain);
|
|
console.log(`Main ${nameMain}: ${lo}`)
|
|
|
|
// Add sub prop
|
|
for (let i = currentParamIndex; i < parts.length; i++) {
|
|
|
|
const propData = parts[i].split(/[,:;.]/);
|
|
const prop_id = parseInt(propData[0]);
|
|
let prop_count = parseInt(propData[1]);
|
|
if (isNaN(prop_count)) {
|
|
continue
|
|
}
|
|
|
|
//console.log(`${prop_id} > ${prop_count}`)
|
|
|
|
var SubData = getRelicSub.find(prop => prop.id === prop_id);
|
|
if (!SubData) continue
|
|
//console.log(SubData)
|
|
|
|
// limit count base level max art
|
|
const maxCount = Math.floor(maxLevel / 3) + 1; // or just use 15 ?
|
|
const count = Math.min(prop_count, maxCount);
|
|
|
|
// fix step count
|
|
var finalValue = SubData.propValue;
|
|
if (count >= 2) {
|
|
finalValue = finalValue * count
|
|
}
|
|
|
|
// Get Name
|
|
var subPropHash = getHasIndex1.find(item =>
|
|
item.textMapId === SubData.propType
|
|
).textMapContentTextMapHash;
|
|
const nameSub = getHashEN[subPropHash] || getHashCN[subPropHash] || `N/A`;
|
|
|
|
var lo = CaC(SubData.propType, finalValue);
|
|
console.log(`Sub ${nameSub}: ${lo}`)
|
|
|
|
propDataCount++;
|
|
}
|
|
} else {
|
|
console.log(`not found`)
|
|
}
|
|
|
|
break;
|
|
}
|
|
currentParamIndex++;
|
|
}
|
|
} else {
|
|
return console.log(`bad cmd`)
|
|
}
|
|
|
|
//console.log(extra_params)
|
|
|
|
console.log(`${cmd}`)
|
|
}
|
|
|
|
function CaC(name, finalValue) {
|
|
if (name.includes('PERCENT') || name.includes('CRITICAL') || name.includes('CHARGE') || name.includes('HURT') || name.includes('HEAL')) {
|
|
return `${(finalValue * 100).toFixed(2)}%`
|
|
} else {
|
|
return `+${Math.floor(finalValue)}`
|
|
}
|
|
}
|
|
|
|
function runRelic(lang, getHashLANG) {
|
|
|
|
// lock basic stats
|
|
var maxLevel = 21;
|
|
var maxRank = 5;
|
|
|
|
const saveMainRelic = lang + 'relic_main.json';
|
|
var dataMainRelic = [];
|
|
for (const data of Object.values(getRelicMain)) {
|
|
|
|
var id = data.id;
|
|
var name = data.propType;
|
|
|
|
// Get Name
|
|
var mainPropHash = getHasIndex1.find(item => item.textMapId === name).textMapContentTextMapHash;
|
|
const nameMain = getHashLANG[mainPropHash] || getHashCN[mainPropHash] || `N/A`;
|
|
|
|
var valueMain = 0;
|
|
var TesLevel = levelConfig.find(entry =>
|
|
entry.level === maxLevel &&
|
|
entry.rank === maxRank &&
|
|
entry.addProps.some(prop => prop.propType === name)
|
|
);
|
|
if (!TesLevel) {
|
|
//valueMain = getRelicSub.find(entry => entry.propType == name).propValue
|
|
continue;
|
|
} else {
|
|
valueMain = TesLevel.addProps.find(prop => prop.propType === name).value;
|
|
}
|
|
|
|
var bonus = CaC(name, valueMain)
|
|
|
|
var objMainRelic = new Object();
|
|
objMainRelic["id"] = id;
|
|
objMainRelic["grup"] = data.propDepotId
|
|
objMainRelic["name"] = `${nameMain} (${bonus} > R${maxRank}LV${maxLevel})`;
|
|
dataMainRelic.push(objMainRelic)
|
|
|
|
}
|
|
fs.writeFileSync(saveMainRelic, JSON.stringify(dataMainRelic, null, 2));
|
|
dataMainRelic = []; // cleanup
|
|
console.log(`done MainRelic: ` + saveMainRelic)
|
|
|
|
const saveSubRelic = lang + 'relic_sub.json';
|
|
var dataSubRelic = [];
|
|
|
|
for (const sub of Object.values(getRelicSub)) {
|
|
|
|
var id = sub.id;
|
|
var name = sub.propType;
|
|
|
|
var mainPropHash = getHasIndex1.find(item => item.textMapId === name).textMapContentTextMapHash;
|
|
const nameMain = getHashLANG[mainPropHash] || getHashCN[mainPropHash] || `N/A`;
|
|
|
|
var bonus = CaC(name, sub.propValue)
|
|
|
|
var objSubRelic = new Object();
|
|
objSubRelic["id"] = id;
|
|
objSubRelic["grup"] = sub.depotId
|
|
objSubRelic["name"] = `${nameMain} (${bonus})`;
|
|
dataSubRelic.push(objSubRelic)
|
|
}
|
|
|
|
fs.writeFileSync(saveSubRelic, JSON.stringify(dataSubRelic, null, 2));
|
|
dataSubRelic = []; // cleanup
|
|
console.log(`done SubRelic: ` + saveSubRelic)
|
|
|
|
const saveItemRelic = lang + 'relic_item.json';
|
|
const getItemRelic = readJsonFile('../Resources/ExcelBinOutput/ReliquaryExcelConfigData.json');
|
|
var dataItemRelic = [];
|
|
const uniqueMainSub = new Set();
|
|
for (const data of Object.values(getItemRelic)) {
|
|
|
|
const hash = data.nameTextMapHash;
|
|
const id = data.id;
|
|
|
|
//var config = getRelicConfig[id];
|
|
|
|
const name = getHashLANG[hash] || getHashCN[hash] || `N/A`;
|
|
|
|
// var subType = data.ItemSubType;
|
|
var iconPath = data.icon;
|
|
var image = `https://upload-os-bbs.mihoyo.com/game_record/genshin/equip/${iconPath}.png`;
|
|
|
|
var IndexCheck = getHasIndex1.find(item => item.textMapId === data.equipType);
|
|
if (!IndexCheck) {
|
|
console.log(data.equipType)
|
|
continue;
|
|
}
|
|
|
|
var indexType = IndexCheck.textMapContentTextMapHash
|
|
const IndexName = getHashLANG[indexType] || getHashCN[indexType] || `N/A`;
|
|
|
|
//var idgu = data.appendPropNum ?? 0;
|
|
|
|
var main = data.mainPropDepotId;
|
|
var sub = data.appendPropDepotId;
|
|
var rank = data.rankLevel;
|
|
|
|
var subp = `${name} (${IndexName}) (R${rank})`;
|
|
|
|
if (!uniqueMainSub.has(subp)) {
|
|
uniqueMainSub.add(subp);
|
|
var objItem = new Object();
|
|
objItem["id"] = id;
|
|
//objItem["num"] = idgu;
|
|
objItem["name"] = subp;
|
|
objItem["rarity"] = data.Rarity;
|
|
objItem["rank"] = rank;
|
|
objItem["main"] = main;
|
|
objItem["sub"] = sub;
|
|
objItem["type"] = data.equipType;
|
|
objItem["img"] = image
|
|
dataItemRelic.push(objItem)
|
|
}
|
|
}
|
|
fs.writeFileSync(saveItemRelic, JSON.stringify(dataItemRelic, null, 2));
|
|
dataItemRelic = []; // cleanup
|
|
console.log(`done Item Relic: ` + saveItemRelic)
|
|
}
|
|
|
|
async function runMappings(version = 1) {
|
|
var dataMappings = {};
|
|
const saveMappings = '../Tool/data/mappings.json';
|
|
|
|
for (const textMapFile of textMapFiles) {
|
|
|
|
var lang = textMapFile.replace("TextMap", "").replace(".json", "");
|
|
|
|
if (version == 1) {
|
|
const textMapFilePath = path.resolve(textMapFolderPath, textMapFile);
|
|
const textMapData = await readJsonFileAsync(textMapFilePath);
|
|
|
|
|
|
// Initialize the object if it's undefined
|
|
if (!dataMappings[mapLanguageCode(lang, true)]) {
|
|
dataMappings[mapLanguageCode(lang, true)] = {};
|
|
}
|
|
|
|
const filePaths = [
|
|
'../Resources/ExcelBinOutput/AvatarExcelConfigData.json',
|
|
'../Resources/ExcelBinOutput/WeaponExcelConfigData.json'
|
|
];
|
|
|
|
for (const filePath of filePaths) {
|
|
try {
|
|
const getAvatar = await readJsonFileAsync(filePath);
|
|
for (const data of Object.values(getAvatar)) {
|
|
if (data && data.nameTextMapHash) {
|
|
const hash = data.nameTextMapHash;
|
|
var id = data.id;
|
|
const rank = getColorByRankLevel(data.qualityType || data.rankLevel.toString());
|
|
const name = textMapData[hash] || `N/A`;
|
|
|
|
var nameType = "idk";
|
|
if (filePath.includes(`AvatarExcelConfigData`)) {
|
|
|
|
/*
|
|
if (id >= 11000000) {
|
|
continue // skip test avatar
|
|
}
|
|
*/
|
|
|
|
id = id % 1000 + 1000;
|
|
|
|
nameType = textMapData[`4233146695`] || `N/A`;
|
|
} else if (filePath.includes(`WeaponExcelConfigData`)) {
|
|
|
|
/*
|
|
if (id <= 11101 || id >= 20000) {
|
|
continue // skip non weapon items
|
|
}
|
|
*/
|
|
|
|
nameType = textMapData[`4231343903`] || `N/A`;
|
|
}
|
|
|
|
dataMappings[mapLanguageCode(lang, true)][id] = [`${name} (${nameType})`, rank];
|
|
} else {
|
|
console.log("skip", data);
|
|
}
|
|
}
|
|
} catch (error) {
|
|
console.error("Error processing file:", error);
|
|
}
|
|
}
|
|
|
|
// Type Banner
|
|
dataMappings[mapLanguageCode(lang, true)][200] = textMapData[`332935371`] || `N/A`; // Standard Wish
|
|
dataMappings[mapLanguageCode(lang, true)][301] = textMapData[`2272170627`] || `N/A`; // Character Event Wish
|
|
dataMappings[mapLanguageCode(lang, true)][400] = textMapData[`3352513147`] || `N/A`; // Character Event Wish-2
|
|
dataMappings[mapLanguageCode(lang, true)][302] = textMapData[`2864268523`] || `N/A`; // Weapon Event Wish
|
|
} else {
|
|
|
|
const langDirectory = `../Tool/resources/${mapLanguageCode(lang, false)}/`;
|
|
|
|
if (!fs.existsSync(langDirectory)) {
|
|
fs.mkdirSync(langDirectory, { recursive: true });
|
|
}
|
|
|
|
const getHashLANG = readJsonFile(`../Resources/TextMap/TextMap${lang}.json`);
|
|
|
|
runAvatar(langDirectory, getHashLANG)
|
|
runScene(langDirectory, getHashLANG)
|
|
runMonster(langDirectory, getHashLANG)
|
|
runItem(langDirectory, getHashLANG)
|
|
runRelic(langDirectory, getHashLANG)
|
|
runWeapon(langDirectory, getHashLANG)
|
|
runProp(langDirectory, getHashLANG)
|
|
}
|
|
|
|
}
|
|
|
|
if (version == 1) {
|
|
await writeFileAsync(saveMappings, JSON.stringify(dataMappings, null, 2), 'utf-8');
|
|
}
|
|
}
|
|
|
|
//runAvatar();
|
|
//runScene();
|
|
//runMonster();
|
|
//runItem();
|
|
//runRelic();
|
|
//runWeapon();
|
|
//runProp();
|
|
//runMappings(2);
|
|
runMappings(1);
|
|
//runGiveEmu(`/give 76544 lv19 x1 15001 501064,10 501204,10 501224,10 501234,10`);
|
|
//runGiveEmu(`/give 63036 lv15 s1 1:99 2:1 3:1 4:1`);
|
|
//runGiveEmu(`/give 63116 lv15 s4 4:1 7:2 8:1 9:5`);
|
|
//runGiveEmu(`/give 63115 lv15 s10 5:1 7:1 8:1 9:6`);
|
|
//runGiveEmu(`/give 61013 lv20 s1 1:10000000 5:100000000 7:100000 10:100000`)
|
|
|
|
// Function to read and parse JSON file
|
|
function readJsonFile(filePath) {
|
|
const fileContent = fs.readFileSync(filePath, 'utf-8');
|
|
return JSON.parse(fileContent);
|
|
}
|
|
|
|
async function readJsonFileAsync(filePath) {
|
|
try {
|
|
const fileContent = await new Promise((resolve, reject) => {
|
|
fs.readFile(filePath, 'utf-8', (err, data) => {
|
|
if (err) reject(err);
|
|
else resolve(data);
|
|
});
|
|
});
|
|
return JSON.parse(fileContent);
|
|
} catch (error) {
|
|
console.error(`Error reading JSON file at ${filePath}:`, error);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
async function writeFileAsync(filePath, content, encoding = 'utf-8') {
|
|
return new Promise((resolve, reject) => {
|
|
fs.writeFile(filePath, content, encoding, (err) => {
|
|
if (err) reject(err);
|
|
else resolve();
|
|
});
|
|
});
|
|
}
|
|
|
|
function mapLanguageCode(languageCode, useLowerCase = false) {
|
|
// http://www.lingoes.net/en/translator/langcode.htm
|
|
const languageMap = {
|
|
CHS: 'zh_CN',
|
|
CHT: 'zh_TW',
|
|
DE: 'de_DE', // TODO
|
|
EN: 'en_US',
|
|
ES: 'es_ES',
|
|
FR: 'fr_FR',
|
|
ID: 'id_ID',
|
|
JP: 'ja_JP',
|
|
KR: 'ko_KR',
|
|
PT: 'pt_PT', // TODO
|
|
RU: 'ru_RU',
|
|
TH: 'th_TH',
|
|
VI: 'vi_VN',
|
|
IT: 'it_IT', // TODO
|
|
TR: `tr_TR` // TODO
|
|
};
|
|
// Check if the language code has a mapping, otherwise use the original code
|
|
var tus = languageMap[languageCode] || languageCode;
|
|
if (useLowerCase) {
|
|
tus = tus.toLowerCase();
|
|
}
|
|
return tus;
|
|
}
|
|
|
|
function getColorByRankLevel(rankLevel) {
|
|
switch (rankLevel) {
|
|
case "3", "QUALITY_BLUE":
|
|
return "blue";
|
|
case "4", "QUALITY_PURPLE":
|
|
return "purple";
|
|
case "5", "QUALITY_ORANGE":
|
|
return "yellow";
|
|
default:
|
|
return "";
|
|
}
|
|
} |