626 lines
20 KiB
JavaScript
626 lines
20 KiB
JavaScript
// Gachabase Data Fetcher, Parser & FreeSR Importer Module
|
|
// Supports fetching datamined/beta characters, lightcones, and relics from hsr.gachabase.net
|
|
// Integrates with GaC-srtool runtime metadata, IndexedDB cache, and FreeSR / persistent saves.
|
|
|
|
export const GACHABASE_BASE_URL = 'https://hsr.gachabase.net';
|
|
export const GACHABASE_CDN_URL = 'https://cdn.gachabase.net';
|
|
|
|
// Path ID mappings according to HSR engine / Gachabase
|
|
export const GACHABASE_PATHS = {
|
|
1: 'Destruction',
|
|
2: 'Hunt',
|
|
3: 'Erudition',
|
|
4: 'Harmony',
|
|
5: 'Nihility',
|
|
6: 'Preservation',
|
|
7: 'Abundance',
|
|
8: 'Remembrance',
|
|
9: 'Elation'
|
|
};
|
|
|
|
// Element / Type ID mappings
|
|
export const GACHABASE_ELEMENTS = {
|
|
1: 'Physical',
|
|
2: 'Fire',
|
|
4: 'Ice',
|
|
8: 'Thunder', // Lightning
|
|
16: 'Wind',
|
|
32: 'Quantum',
|
|
64: 'Imaginary'
|
|
};
|
|
|
|
// Stat ID mappings
|
|
export const GACHABASE_STATS = {
|
|
1: 'HP',
|
|
2: 'ATK',
|
|
3: 'DEF',
|
|
21: 'HP%',
|
|
22: 'ATK%',
|
|
23: 'DEF%',
|
|
31: 'Physical DMG%',
|
|
32: 'Fire DMG%',
|
|
33: 'Ice DMG%',
|
|
34: 'Lightning DMG%',
|
|
35: 'Wind DMG%',
|
|
36: 'Quantum DMG%',
|
|
37: 'Imaginary DMG%',
|
|
41: 'Break Effect%',
|
|
42: 'Outgoing Healing Boost%',
|
|
43: 'Max Energy',
|
|
44: 'Energy Regeneration Rate%',
|
|
45: 'Effect Hit Rate%',
|
|
46: 'Effect RES%',
|
|
51: 'SPD',
|
|
52: 'CRIT Rate%',
|
|
53: 'CRIT DMG%'
|
|
};
|
|
|
|
/**
|
|
* Strips rich-text tags like <color=#f29e38ff>, </color>, <b>, </b> from text strings
|
|
*/
|
|
export function cleanRichText(str) {
|
|
if (!str || typeof str !== 'string') return '';
|
|
return str
|
|
.replace(/<color=[^>]+>/gi, '')
|
|
.replace(/<\/color>/gi, '')
|
|
.replace(/<[^>]+>/g, '')
|
|
.replace(/\\n/g, '\n')
|
|
.trim();
|
|
}
|
|
|
|
/**
|
|
* Parses user input into normalized search parameters
|
|
* Handles full URLs or raw IDs
|
|
*/
|
|
export function parseGachabaseInput(input, typeHint = 'character', branch = 'beta', lang = 'en') {
|
|
const trimmed = (input || '').trim();
|
|
if (!trimmed) return null;
|
|
|
|
// Check if input is a full URL
|
|
if (trimmed.startsWith('http://') || trimmed.startsWith('https://')) {
|
|
try {
|
|
const urlObj = new URL(trimmed);
|
|
const pathname = urlObj.pathname.toLowerCase();
|
|
let detectedType = typeHint;
|
|
if (pathname.includes('/characters/') || pathname.includes('/character/')) detectedType = 'character';
|
|
else if (pathname.includes('/lightcones/') || pathname.includes('/lightcone/')) detectedType = 'lightcone';
|
|
else if (pathname.includes('/relics/') || pathname.includes('/relic/')) detectedType = 'relic';
|
|
|
|
// Pattern: /type/:id/:slug?/:branch?
|
|
const parts = pathname.split('/').filter(Boolean);
|
|
// Expected: ['characters', '1511', 'aeon-aha', 'beta']
|
|
let id = null;
|
|
let detectedBranch = urlObj.searchParams.get('branch') || branch;
|
|
let detectedLang = urlObj.searchParams.get('lang') || lang;
|
|
|
|
if (parts.length >= 2) {
|
|
id = parseInt(parts[1], 10);
|
|
}
|
|
if (parts.length >= 4) {
|
|
detectedBranch = parts[3];
|
|
}
|
|
|
|
return {
|
|
url: trimmed,
|
|
id: id || null,
|
|
type: detectedType,
|
|
branch: detectedBranch || 'beta',
|
|
lang: detectedLang || 'en'
|
|
};
|
|
} catch (e) {
|
|
// Fall through to ID parsing
|
|
}
|
|
}
|
|
|
|
// Treat as numeric ID
|
|
const numId = parseInt(trimmed, 10);
|
|
if (!isNaN(numId)) {
|
|
let resolvedType = typeHint;
|
|
// Auto-guess type if default wasn't explicitly changed
|
|
if (numId >= 20000 && numId < 30000) resolvedType = 'lightcone';
|
|
else if (numId < 1000) resolvedType = 'relic';
|
|
else if (numId >= 1000 && numId < 9000) resolvedType = 'character';
|
|
|
|
const typeSlug = resolvedType === 'lightcone' ? 'lightcones' : (resolvedType === 'relic' ? 'relics' : 'characters');
|
|
const url = `${GACHABASE_BASE_URL}/${typeSlug}/${numId}/slug/${branch}?lang=${lang}`;
|
|
|
|
return {
|
|
url,
|
|
id: numId,
|
|
type: resolvedType,
|
|
branch: branch || 'beta',
|
|
lang: lang || 'en'
|
|
};
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Fetches Gachabase HTML content
|
|
* Uses GaC-hkrpg-go API proxy if available to avoid CORS, falls back to direct fetch
|
|
*/
|
|
export async function fetchGachabaseHtml(targetUrl, apiUrl = 'http://localhost:21000') {
|
|
if (!targetUrl) throw new Error('Target URL is required for Gachabase fetch');
|
|
|
|
// 1. Try Backend Proxy
|
|
if (apiUrl) {
|
|
try {
|
|
const cleanApi = apiUrl.replace(/\/+$/, '');
|
|
const proxyUrl = `${cleanApi}/api/gachabase/fetch?url=${encodeURIComponent(targetUrl)}`;
|
|
const resp = await fetch(proxyUrl, { method: 'GET', headers: { 'Accept': 'application/json' } });
|
|
if (resp.ok) {
|
|
const json = await resp.json();
|
|
if (json && json.html) {
|
|
return { html: json.html, finalUrl: json.url || targetUrl };
|
|
}
|
|
}
|
|
} catch (err) {
|
|
console.warn('Backend Gachabase proxy unreachable, attempting direct fetch...', err);
|
|
}
|
|
}
|
|
|
|
// 2. Direct fetch fallback (works if user has CORS unblocker or runs in local browser environment)
|
|
const directResp = await fetch(targetUrl, {
|
|
method: 'GET',
|
|
headers: {
|
|
'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8'
|
|
}
|
|
});
|
|
if (!directResp.ok) {
|
|
throw new Error(`Direct fetch failed with status ${directResp.status}`);
|
|
}
|
|
const html = await directResp.text();
|
|
return { html, finalUrl: targetUrl };
|
|
}
|
|
|
|
/**
|
|
* Extracts and parses serialized SvelteKit DTO and refs from Gachabase HTML
|
|
*/
|
|
export function parseGachabaseHtml(html, fallbackLang = 'en') {
|
|
if (!html || typeof html !== 'string') {
|
|
throw new Error('Invalid HTML content received from Gachabase');
|
|
}
|
|
|
|
// Look for kit.start(...) serialized state in <script>
|
|
let kitJson = null;
|
|
const kitMatch = html.match(/kit\.start\(app,\s*element,\s*(\{.*?\})\);\s*\}\);/s);
|
|
if (kitMatch && kitMatch[1]) {
|
|
kitJson = kitMatch[1];
|
|
} else {
|
|
// Alternate pattern in newer or minified builds
|
|
const altMatch = html.match(/kit\.start\(app,\s*element,\s*(\{[\s\S]*?\})\s*\);/);
|
|
if (altMatch && altMatch[1]) {
|
|
kitJson = altMatch[1];
|
|
}
|
|
}
|
|
|
|
if (!kitJson) {
|
|
throw new Error('Could not find SvelteKit data payload in Gachabase HTML');
|
|
}
|
|
|
|
let kitData;
|
|
try {
|
|
const fn = new Function('return (' + kitJson + ')');
|
|
kitData = fn();
|
|
} catch (err) {
|
|
throw new Error('Failed to evaluate Gachabase state payload: ' + err.message);
|
|
}
|
|
|
|
if (!kitData || !Array.isArray(kitData.data)) {
|
|
throw new Error('Gachabase kitData does not contain data array');
|
|
}
|
|
|
|
// Search for the entry containing dto and refs
|
|
let targetData = null;
|
|
for (const entry of kitData.data) {
|
|
if (!entry) continue;
|
|
const cand = entry.data?.data?.data || entry.data?.data || entry.data;
|
|
if (cand && (cand.dto || cand.refs)) {
|
|
targetData = cand;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!targetData || !targetData.dto) {
|
|
throw new Error('Gachabase DTO object not found in payload');
|
|
}
|
|
|
|
const dto = targetData.dto;
|
|
const refs = targetData.refs || {};
|
|
const assetsMap = refs.assets || {};
|
|
const pathsMap = refs.paths || {};
|
|
const typesMap = refs.types || {};
|
|
|
|
// Resolve CDN URL helper
|
|
const resolveAsset = (hash) => {
|
|
if (!hash) return null;
|
|
if (assetsMap[hash] && assetsMap[hash].url) {
|
|
return assetsMap[hash].url;
|
|
}
|
|
return `${GACHABASE_CDN_URL}/hsr/assets/${hash}.png`;
|
|
};
|
|
|
|
const id = dto.id;
|
|
const rawName = dto.name?.text || dto.name || `Item ${id}`;
|
|
const rarity = dto.rarity || 5;
|
|
|
|
// Path resolution
|
|
const pathId = dto.path_id || 0;
|
|
const rawPath = pathsMap[pathId]?.name?.text || GACHABASE_PATHS[pathId] || 'Unknown';
|
|
|
|
// Type / Element resolution
|
|
const typeId = dto.type_id || 0;
|
|
const rawElement = typesMap[typeId]?.name?.text || GACHABASE_ELEMENTS[typeId] || 'Unknown';
|
|
|
|
// Determine Item Type
|
|
let itemType = 'character';
|
|
if (dto.skills !== undefined || dto.eidolons !== undefined || dto.max_energy !== undefined) {
|
|
itemType = 'character';
|
|
} else if (dto.skill !== undefined || (id >= 20000 && id < 30000)) {
|
|
itemType = 'lightcone';
|
|
} else if (id < 1000) {
|
|
itemType = 'relic';
|
|
}
|
|
|
|
// Images resolution
|
|
const images = {
|
|
splash: resolveAsset(dto.assets?.splash_art_path_hash) || resolveAsset(dto.assets?.draw_card_art_path_hash),
|
|
icon: resolveAsset(dto.assets?.round_icon_path_hash) || resolveAsset(dto.assets?.small_icon_path_hash) || resolveAsset(dto.assets?.icon_path_hash),
|
|
square: resolveAsset(dto.assets?.square_icon_path_hash) || resolveAsset(dto.assets?.big_icon_path_hash),
|
|
fullArt: resolveAsset(dto.assets?.full_art_path_hash) || resolveAsset(dto.assets?.splash_art_path_hash),
|
|
thumbnail: resolveAsset(dto.assets?.thumbnail_art_path_hash) || resolveAsset(dto.assets?.big_icon_path_hash)
|
|
};
|
|
|
|
// Skills parsing (for characters)
|
|
const skills = [];
|
|
if (Array.isArray(dto.skills)) {
|
|
dto.skills.forEach(s => {
|
|
skills.push({
|
|
id: s.id,
|
|
type: s.type?.text || s.type || 'Skill',
|
|
name: s.name?.text || s.name || '',
|
|
tag: s.tag?.text || s.tag || '',
|
|
description: cleanRichText(s.description?.text || s.description || ''),
|
|
icon: resolveAsset(s.icon_path_hash)
|
|
});
|
|
});
|
|
}
|
|
|
|
// Eidolons parsing (for characters)
|
|
const eidolons = [];
|
|
if (Array.isArray(dto.eidolons)) {
|
|
dto.eidolons.forEach((e, idx) => {
|
|
eidolons.push({
|
|
rank: e.rank || idx + 1,
|
|
name: e.name?.text || e.name || `Eidolon ${idx + 1}`,
|
|
description: cleanRichText(e.description?.text || e.description || ''),
|
|
icon: resolveAsset(e.icon_path_hash) || resolveAsset(dto.assets?.[`eidolon_${idx + 1}_path_hash`])
|
|
});
|
|
});
|
|
}
|
|
|
|
// Lightcone skill (for lightcones)
|
|
let lcSkill = null;
|
|
if (dto.skill) {
|
|
lcSkill = {
|
|
name: dto.skill.name?.text || dto.skill.name || '',
|
|
description: cleanRichText(dto.skill.description?.text || dto.skill.description || '')
|
|
};
|
|
}
|
|
|
|
// Build recommendations
|
|
const rec = dto.build_recommendations || {};
|
|
const recommendedRelics = rec.relics?.relic_ids || [];
|
|
const cavernSets = recommendedRelics.filter(rId => rId < 300);
|
|
const planarSets = recommendedRelics.filter(rId => rId >= 300);
|
|
|
|
// Recommended Lightcones
|
|
const recommendedLcs = (Array.isArray(rec.lightcone_ids) ? rec.lightcone_ids : (rec.lightcones || []).map(lc => lc.lightcone_id)).filter(Boolean);
|
|
|
|
// Main stats recommendations
|
|
const mainStats = {};
|
|
if (Array.isArray(rec.relics?.main_stats)) {
|
|
rec.relics.main_stats.forEach(m => {
|
|
const pieceId = m.piece_type_id; // 3=Body, 4=Boots, 5=Sphere, 6=Rope
|
|
const stats = (m.stat_ids || []).map(sid => GACHABASE_STATS[sid] || `Stat ${sid}`);
|
|
mainStats[pieceId] = stats;
|
|
});
|
|
}
|
|
|
|
// Sub stats recommendations
|
|
const subStats = (rec.relics?.sub_stat_ids || []).map(sid => GACHABASE_STATS[sid] || `Stat ${sid}`);
|
|
|
|
return {
|
|
id,
|
|
type: itemType,
|
|
name: rawName,
|
|
rarity,
|
|
path: rawPath,
|
|
pathId,
|
|
element: rawElement,
|
|
typeId,
|
|
maxEnergy: dto.max_energy || 0,
|
|
images,
|
|
skills,
|
|
eidolons,
|
|
lcSkill,
|
|
recommended: {
|
|
relicIds: recommendedRelics,
|
|
cavernSets,
|
|
planarSets,
|
|
lightconeIds: recommendedLcs,
|
|
signatureLcId: recommendedLcs[0] || null,
|
|
mainStats,
|
|
subStats
|
|
},
|
|
rawDto: dto
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Registers parsed item into tool runtime metadata and saves to IndexedDB
|
|
*/
|
|
export async function registerGachabaseItem(parsedItem, metadataContext = {}) {
|
|
const {
|
|
AVATAR_METADATA,
|
|
LIGHTCONE_METADATA,
|
|
RELIC_SET_METADATA,
|
|
SIGNATURE_LIGHTCONES,
|
|
idbSet
|
|
} = metadataContext;
|
|
|
|
const id = parsedItem.id;
|
|
const lang = parsedItem.lang || 'en';
|
|
|
|
if (parsedItem.type === 'character' && AVATAR_METADATA) {
|
|
if (!AVATAR_METADATA[id]) {
|
|
AVATAR_METADATA[id] = {
|
|
names: {
|
|
th: parsedItem.name,
|
|
en: parsedItem.name
|
|
},
|
|
path: parsedItem.path,
|
|
element: parsedItem.element,
|
|
rarity: parsedItem.rarity,
|
|
hasExRank: false,
|
|
isCustomGachabase: true,
|
|
images: parsedItem.images
|
|
};
|
|
} else {
|
|
// Update existing entry with high-res images and enriched data
|
|
AVATAR_METADATA[id].names = AVATAR_METADATA[id].names || {};
|
|
AVATAR_METADATA[id].names[lang] = parsedItem.name;
|
|
AVATAR_METADATA[id].names.en = AVATAR_METADATA[id].names.en || parsedItem.name;
|
|
AVATAR_METADATA[id].path = parsedItem.path;
|
|
AVATAR_METADATA[id].element = parsedItem.element;
|
|
AVATAR_METADATA[id].rarity = parsedItem.rarity;
|
|
AVATAR_METADATA[id].images = parsedItem.images;
|
|
}
|
|
|
|
if (SIGNATURE_LIGHTCONES && parsedItem.recommended.signatureLcId) {
|
|
SIGNATURE_LIGHTCONES[id] = parsedItem.recommended.signatureLcId;
|
|
}
|
|
} else if (parsedItem.type === 'lightcone' && LIGHTCONE_METADATA) {
|
|
if (!LIGHTCONE_METADATA[id]) {
|
|
LIGHTCONE_METADATA[id] = {
|
|
names: {
|
|
th: parsedItem.name,
|
|
en: parsedItem.name
|
|
},
|
|
rarity: parsedItem.rarity,
|
|
path: parsedItem.path,
|
|
isCustomGachabase: true,
|
|
images: parsedItem.images
|
|
};
|
|
} else {
|
|
LIGHTCONE_METADATA[id].names = LIGHTCONE_METADATA[id].names || {};
|
|
LIGHTCONE_METADATA[id].names[lang] = parsedItem.name;
|
|
LIGHTCONE_METADATA[id].path = parsedItem.path;
|
|
LIGHTCONE_METADATA[id].rarity = parsedItem.rarity;
|
|
LIGHTCONE_METADATA[id].images = parsedItem.images;
|
|
}
|
|
}
|
|
|
|
// Persist to IndexedDB
|
|
if (idbSet) {
|
|
try {
|
|
const cacheKey = `gac_gachabase_item_${parsedItem.type}_${id}`;
|
|
await idbSet(cacheKey, parsedItem);
|
|
|
|
// Also append to custom items registry
|
|
const regKey = 'gac_gachabase_registry';
|
|
const existing = (await (metadataContext.idbGet ? metadataContext.idbGet(regKey) : null)) || [];
|
|
const filtered = existing.filter(i => !(i.type === parsedItem.type && i.id === parsedItem.id));
|
|
filtered.push({
|
|
type: parsedItem.type,
|
|
id: parsedItem.id,
|
|
name: parsedItem.name,
|
|
path: parsedItem.path,
|
|
element: parsedItem.element,
|
|
rarity: parsedItem.rarity,
|
|
cacheKey
|
|
});
|
|
await idbSet(regKey, filtered);
|
|
} catch (e) {
|
|
console.warn('Failed to save Gachabase item to IndexedDB:', e);
|
|
}
|
|
}
|
|
|
|
return parsedItem;
|
|
}
|
|
|
|
/**
|
|
* Loads all cached Gachabase items from IndexedDB into runtime metadata
|
|
*/
|
|
export async function loadCachedGachabaseRegistry(metadataContext = {}) {
|
|
const {
|
|
AVATAR_METADATA,
|
|
LIGHTCONE_METADATA,
|
|
SIGNATURE_LIGHTCONES,
|
|
idbGet
|
|
} = metadataContext;
|
|
|
|
if (!idbGet) return;
|
|
|
|
try {
|
|
const registry = await idbGet('gac_gachabase_registry');
|
|
if (!Array.isArray(registry)) return;
|
|
|
|
for (const itemMeta of registry) {
|
|
const fullItem = await idbGet(itemMeta.cacheKey);
|
|
if (fullItem) {
|
|
await registerGachabaseItem(fullItem, metadataContext);
|
|
}
|
|
}
|
|
console.log(`[Gachabase] Successfully loaded ${registry.length} cached items from IndexedDB.`);
|
|
} catch (err) {
|
|
console.warn('[Gachabase] Failed to restore cached items from IndexedDB:', err);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Applies parsed Gachabase character, lightcone, or relics into FreeSR data structure
|
|
*/
|
|
export function applyGachabaseToFreeSR(parsedItem, fullFreesrData, options = {}) {
|
|
if (!fullFreesrData) {
|
|
throw new Error('FreeSR data is not initialized');
|
|
}
|
|
|
|
fullFreesrData.avatars = fullFreesrData.avatars || {};
|
|
fullFreesrData.lightcones = fullFreesrData.lightcones || [];
|
|
fullFreesrData.relics = fullFreesrData.relics || [];
|
|
|
|
const eLevel = options.eLevel !== undefined ? options.eLevel : 0; // 0 or 6
|
|
const sLevel = options.sLevel !== undefined ? options.sLevel : 1; // 1 or 5
|
|
const autoEquipLc = options.autoEquipLc !== false;
|
|
const autoEquipRelics = options.autoEquipRelics !== false;
|
|
|
|
const results = {
|
|
avatarAdded: false,
|
|
lcAdded: false,
|
|
relicsAdded: 0
|
|
};
|
|
|
|
// If character:
|
|
if (parsedItem.type === 'character') {
|
|
const aid = parsedItem.id;
|
|
|
|
// Generate maxed traces & skills map
|
|
const skillsMap = {};
|
|
if (Array.isArray(parsedItem.skills) && parsedItem.skills.length > 0) {
|
|
parsedItem.skills.forEach(s => {
|
|
if (s.id) {
|
|
skillsMap[String(s.id)] = 10;
|
|
}
|
|
});
|
|
}
|
|
// Add standard fallback combat traces
|
|
skillsMap[`${aid}001`] = 6; // Basic ATK
|
|
skillsMap[`${aid}002`] = 10; // Skill
|
|
skillsMap[`${aid}003`] = 10; // Ultimate
|
|
skillsMap[`${aid}004`] = 10; // Talent
|
|
skillsMap[`${aid}007`] = 1; // Technique
|
|
|
|
if (!fullFreesrData.avatars[aid]) {
|
|
fullFreesrData.avatars[aid] = {
|
|
owner_uid: 0,
|
|
avatar_id: aid,
|
|
level: 80,
|
|
promotion: 6,
|
|
techniques: [],
|
|
sp_max: parsedItem.maxEnergy || 140,
|
|
sp_value: Math.floor((parsedItem.maxEnergy || 140) / 2),
|
|
data: {
|
|
rank: eLevel,
|
|
skills: skillsMap
|
|
}
|
|
};
|
|
} else {
|
|
const av = fullFreesrData.avatars[aid];
|
|
av.level = 80;
|
|
av.promotion = 6;
|
|
av.data = av.data || {};
|
|
av.data.rank = eLevel;
|
|
av.data.skills = Object.assign(av.data.skills || {}, skillsMap);
|
|
}
|
|
results.avatarAdded = true;
|
|
|
|
// Equip Signature Lightcone if available
|
|
const sigLcId = parsedItem.recommended.signatureLcId || (options.sigLcId || null);
|
|
if (autoEquipLc && sigLcId) {
|
|
// Check if this character already has an LC
|
|
let existingLc = fullFreesrData.lightcones.find(l => l.equip_avatar === aid);
|
|
if (existingLc) {
|
|
existingLc.item_id = sigLcId;
|
|
existingLc.level = 80;
|
|
existingLc.promotion = 6;
|
|
existingLc.rank = sLevel;
|
|
} else {
|
|
const nextUid = (fullFreesrData.lightcones.reduce((m, l) => Math.max(m, l.unique_id || 0), 0)) + 1;
|
|
fullFreesrData.lightcones.push({
|
|
unique_id: nextUid,
|
|
item_id: sigLcId,
|
|
level: 80,
|
|
promotion: 6,
|
|
rank: sLevel,
|
|
equip_avatar: aid
|
|
});
|
|
}
|
|
results.lcAdded = true;
|
|
}
|
|
|
|
// Equip Recommended Relics if available
|
|
if (autoEquipRelics && (parsedItem.recommended.cavernSets.length > 0 || parsedItem.recommended.planarSets.length > 0)) {
|
|
// Clear existing relics on this character
|
|
fullFreesrData.relics = fullFreesrData.relics.filter(r => r.equip_avatar !== aid);
|
|
|
|
const cavernSet = parsedItem.recommended.cavernSets[0] || 121;
|
|
const planarSet = parsedItem.recommended.planarSets[0] || 310;
|
|
let nextRelicUid = (fullFreesrData.relics.reduce((m, r) => Math.max(m, r.internal_uid || 0), 0)) + 1;
|
|
|
|
// 6 relic slots
|
|
for (let slot = 1; slot <= 6; slot++) {
|
|
const setId = slot <= 4 ? cavernSet : planarSet;
|
|
const relicId = 60000 + (setId * 10) + slot;
|
|
|
|
// Default smart main stats
|
|
let mainAffixId = 1;
|
|
if (slot === 3) mainAffixId = 5; // CRIT Rate% / ATK%
|
|
else if (slot === 4) mainAffixId = 5; // SPD / ATK%
|
|
else if (slot === 5) mainAffixId = 6; // Elemental DMG%
|
|
else if (slot === 6) mainAffixId = 4; // Energy Regen% / ATK%
|
|
|
|
fullFreesrData.relics.push({
|
|
internal_uid: nextRelicUid++,
|
|
relic_id: relicId,
|
|
level: 15,
|
|
equip_avatar: aid,
|
|
main_affix_id: mainAffixId,
|
|
sub_affixes: [
|
|
{ sub_affix_id: 1, cnt: 2, step: 2 },
|
|
{ sub_affix_id: 2, cnt: 3, step: 2 },
|
|
{ sub_affix_id: 3, cnt: 2, step: 2 },
|
|
{ sub_affix_id: 4, cnt: 2, step: 2 }
|
|
]
|
|
});
|
|
results.relicsAdded++;
|
|
}
|
|
}
|
|
} else if (parsedItem.type === 'lightcone') {
|
|
// Add standalone lightcone to inventory
|
|
const nextUid = (fullFreesrData.lightcones.reduce((m, l) => Math.max(m, l.unique_id || 0), 0)) + 1;
|
|
fullFreesrData.lightcones.push({
|
|
unique_id: nextUid,
|
|
item_id: parsedItem.id,
|
|
level: 80,
|
|
promotion: 6,
|
|
rank: sLevel,
|
|
equip_avatar: 0
|
|
});
|
|
results.lcAdded = true;
|
|
}
|
|
|
|
return results;
|
|
}
|