2026-04-28T16:25:12Z

Gurren1:

Teste

2026-04-28T16:22:43Z

Gurren1: Página substituída por '{{ReportWiki}}'

Predefinição:ReportWiki

2026-04-28T16:22:30Z

Gurren1: Criou página com '<includeonly>{{#widget:ReportWiki}}</includeonly>'

<includeonly>{{#widget:ReportWiki}}</includeonly>

Widget:ReportWiki

2026-04-28T16:21:55Z

Gurren1:

<style>
.report-wiki-shell {
width: 100%;
max-width: 560px;
margin: 0.75em 0;
clear: both;
box-sizing: border-box;
}

.report-wiki-shell iframe.report-wiki-frame {
display: block;
border: 0;
border-radius: 12px;
width: 100%;
min-height: 480px;
background: #0f172a;
}
</style>
<div class="report-wiki-shell">
<iframe class="report-wiki-frame" title="Reports GLA" src="{{{url|https://gla.squareweb.app/reports}}}" width="100%"
height="{{{height|980}}}" loading="lazy" referrerpolicy="strict-origin-when-cross-origin"
allowfullscreen="allowfullscreen" style="border:0;border-radius:12px;width:100%"></iframe>
</div>
<script>
(function () {
function init() {
var wrap = document.querySelector(".report-wiki-shell:last-of-type");
if (!wrap || wrap.dataset.reportWikiInit) return;
wrap.dataset.reportWikiInit = "1";
var frame = wrap.querySelector("iframe.report-wiki-frame");
if (!frame) return;
try {
var h = parseInt(frame.getAttribute("height") || "980", 10);
if (h > 200 && h < 4000) frame.style.minHeight = h + "px";
} catch (e) { /* */ }
}
if (document.readyState === "loading") {
document.addEventListener("DOMContentLoaded", init);
} else {
init();
}
})();
</script>

Widget:ReportWiki

2026-04-28T16:21:02Z

Gurren1: Criou página com '<style> .report-wiki-shell { width: 100%; max-width: 560px; margin: 0.75em 0; clear: both; box-sizing: border-box; } .repo...'

Teste

2026-04-28T16:10:32Z

Gurren1:

{{#widget:Teste}}



== Formulário de report ==

Este bloco só funciona na tua wiki se ela '''permitir a tag iframe'''. Se remover na gravação, usa o widget ou pede aos admins para permitir iframe só em páginas confiáveis.

<iframe src="https://gla.squareweb.app/reports" title="Reports Wiki GLA" width="100%" height="980" style="max-width:560px;border:0;border-radius:12px;display:block;color-scheme:auto"></iframe>

Teste

2026-04-28T16:09:06Z

Gurren1:

{{#widget:Teste}}



== Formulário de report ==

Este bloco só funciona na tua wiki se ela '''permitir a tag iframe'''. Se remover na gravação, usa o widget ou pede aos admins para permitir iframe só em páginas confiáveis.

<iframe src="https://COLOQUE_AQUI_URL_DO_editor/reports" title="Reports Wiki GLA" width="100%" height="980" style="max-width:560px;border:0;border-radius:12px;display:block;color-scheme:auto"></iframe>

Módulo:Teste

2026-04-28T16:07:25Z

Gurren1:

--[[
Módulo: opcional para inserir o widget via {{#invoke}}.

Na wiki: criar página Módulo:GlaReportEmbed com este código.

Uso num modelo ou página:
{{#invoke:GlaReportEmbed|embed|api_base=https://teu-deploy.com}}

Parâmetros nomeados (opcionais):
|heading=Título da caixa
|wid=2

Requer a extensão Scribunto e o widget {{#widget:ReportModal|...}} registrado.
]]

local p = {}

function p.embed(frame)
local pargs = (frame:getParent() and frame:getParent().args) or {}
local args = frame.args or {}
local base = (
args.api_base
or pargs.api_base
or args[1]
or pargs[1]
or ""
):gsub("^%s+", ""):gsub("%s+$", "")
if base == "" then
return '<span class="error">GlaReportEmbed: falta <code>api_base</code>.</span>'
end

local heading = args.heading or pargs.heading or ""
local wid = args.wid or pargs.wid or ""

local wikitext = "{{#widget:ReportModal|api_base=" .. base
if heading ~= "" then
wikitext = wikitext .. "|heading=" .. heading
end
if wid ~= "" then
wikitext = wikitext .. "|wid=" .. wid
end
wikitext = wikitext .. "}}"

return frame:preprocess(wikitext)
end

return p

Widget:Teste

2026-04-28T16:07:18Z

Gurren1:

<noinclude>

</noinclude>
<div class="gla-report-widget-root" data-gla-init="0" data-gla-api="{{{api_base|}}}" data-gla-wid="{{{wid|1}}}"
data-gla-heading="{{{heading|}}}"></div>
<script>
/*<![CDATA[*/
(function () {
"use strict";

var roots = document.currentScript.previousElementSibling;
if (!roots || !roots.classList || !roots.classList.contains("gla-report-widget-root")) {
roots = document.querySelector(".gla-report-widget-root:not([data-gla-init])");
}
if (!roots || roots.getAttribute("data-gla-init")) return;
roots.setAttribute("data-gla-init", "1");

var REPORTS_API_BASE = (roots.getAttribute("data-gla-api") || "").replace(/\/$/, "");
var wid = String(roots.getAttribute("data-gla-wid") || "1").replace(/[^a-zA-Z0-9_-]/g, "");
var HEADING = roots.getAttribute("data-gla-heading") || "";
if (!HEADING) HEADING = "Report ou sugestão";

var MAX_TITLE = 60;
var MAX_BYTES = 5 * 1024 * 1024;

function esc(s) {
var d = document.createElement("div");
d.textContent = s == null ? "" : String(s);
return d.innerHTML;
}

function byId(id) {
return document.getElementById(id);
}

function css() {
if (byId("gla-reports-inline-css-global")) return;
var st = document.createElement("style");
st.id = "gla-reports-inline-css-global";
st.textContent =
".gla-report-widget-root{width:100%;max-width:520px;margin:1rem 0;display:block;clear:both}" +
".gla-reports-inline{max-width:100%;box-sizing:border-box;background:#111827;color:#f9fafb;border-radius:12px;padding:18px 20px;font:14px/1.45 system-ui,sans-serif;border:1px solid #374151;box-shadow:0 8px 24px rgba(0,0,0,.15)}" +
".gla-reports-inline-h2{font-size:1.1rem;margin:0 0 14px;color:#fff;font-weight:600}" +
".gla-r-field{margin-bottom:12px}" +
".gla-r-field label{display:block;font-size:.8rem;color:#d1d5db;margin-bottom:4px}" +
".gla-r-field input[type=text],.gla-r-field select,.gla-r-field textarea{width:100%;box-sizing:border-box;border-radius:8px;border:1px solid #4b5563;background:#1f2937;color:#fff;padding:8px 10px;font:inherit}" +
".gla-r-field textarea{min-height:120px;resize:vertical}" +
".gla-r-actions{display:flex;gap:8px;margin-top:16px;flex-wrap:wrap;align-items:center}" +
".gla-r-actions button{border-radius:8px;padding:10px 16px;font:inherit;border:0;cursor:pointer}" +
".gla-r-primary{background:#6366f1;color:#fff}" +
".gla-r-muted{background:#374151;color:#e5e7eb}" +
".gla-r-msg{margin-top:12px;font-size:.85rem;min-height:1.2em}" +
".gla-r-msg.gla-r-ok{color:#6ee7b7}" +
".gla-r-msg.gla-r-err{color:#fca5a5}";
document.head.appendChild(st);
}

var mid = "gla-form-" + wid;

function buildFormBody() {
return (
'<section class="gla-reports-inline" aria-labelledby="' +
mid +
'-tit">' +
'<h2 class="gla-reports-inline-h2" id="' +
mid +
'-tit">' +
esc(HEADING) +
"</h2>" +
'<form id="' +
mid +
'-f" novalidate>' +
'<div class="gla-r-field"><label for="' +
mid +
'-title">Título <span style="opacity:.65">(opcional, até ' +
MAX_TITLE +
" caracteres)</span></label>" +
'<input type="text" id="' +
mid +
'-title" name="name" maxlength="' +
MAX_TITLE +
'" autocomplete="off" placeholder="Ex.: erro na página X"/></div>' +
'<div class="gla-r-field"><label for="' +
mid +
'-cat">Categoria</label>' +
'<select id="' +
mid +
'-cat" name="category" required>' +
'<option value="report">' +
esc("Report") +
"</option>" +
'<option value="suggestion">' +
esc("Sugestão") +
"</option>" +
"</select></div>" +
'<div class="gla-r-field"><label for="' +
mid +
'-desc">Descrição <span style="color:#fca5a5">*</span></label>' +
'<textarea id="' +
mid +
'-desc" name="description" maxlength="8000" required placeholder="Descrição detalhada"></textarea></div>' +
'<div class="gla-r-field"><label for="' +
mid +
'-img">Imagem (opcional)</label>' +
'<input type="file" id="' +
mid +
'-img" accept="image/png,image/jpeg,image/gif"/></div>' +
'<div class="gla-r-actions">' +
'<button type="submit" class="gla-r-primary" id="' +
mid +
'-send">' +
esc("Enviar") +
"</button>" +
'<button type="reset" class="gla-r-muted" id="' +
mid +
'-reset">' +
esc("Limpar") +
"</button></div>" +
'<p class="gla-r-msg" id="' +
mid +
'-msg" role="status"></p>' +
"</form></section>"
);
}

function localFileOk(f) {
var t = (f.type || "").toLowerCase();
var n = (f.name || "").toLowerCase();
if (/^image\/(png|jpeg|gif)$/.test(t)) return true;
if (/\.(png|jpe?g|gif)$/.test(n)) return true;
return false;
}

css();
roots.innerHTML = buildFormBody();

var form = byId(mid + "-f");
var btnSend = byId(mid + "-send");
var msg = byId(mid + "-msg");

if (!REPORTS_API_BASE) {
if (btnSend) btnSend.disabled = true;
if (msg) {
msg.textContent = "Configura api_base na wiki: api_base=https://…";
msg.className = "gla-r-msg gla-r-err";
}
return;
}

form.addEventListener("submit", function (e) {
e.preventDefault();
var title = (byId(mid + "-title").value || "").trim();
var cat = byId(mid + "-cat").value;
var desc = (byId(mid + "-desc").value || "").trim();
var fileIn = byId(mid + "-img");

msg.textContent = "";
msg.className = "gla-r-msg";

if (!desc) {
msg.textContent = "Preencha a descrição.";
msg.className = "gla-r-msg gla-r-err";
return;
}
if (title.length > MAX_TITLE) {
msg.textContent = "Título longo demais.";
msg.className = "gla-r-msg gla-r-err";
return;
}

var fd = new FormData();
if (title) fd.append("name", title);
fd.append("category", cat);
fd.append("description", desc);
if (fileIn.files && fileIn.files[0]) {
var f = fileIn.files[0];
if (f.size > MAX_BYTES) {
msg.textContent = "Imagem acima de 5 MB.";
msg.className = "gla-r-msg gla-r-err";
return;
}
if (!localFileOk(f)) {
msg.textContent = "Só PNG, JPG ou GIF.";
msg.className = "gla-r-msg gla-r-err";
return;
}
fd.append("image", f);
}

btnSend.disabled = true;
var url = REPORTS_API_BASE + "/api/reports";

fetch(url, { method: "POST", body: fd })
.then(function (r) {
return r.text().then(function (text) {
var body = {};
try {
body = text ? JSON.parse(text) : {};
} catch (ignore) {
body = { _raw: text };
}
return { ok: r.ok, status: r.status, body: body, raw: text };
});
})
.then(function (result) {
if (result.ok) {
msg.textContent = "Enviado. Obrigado!";
msg.className = "gla-r-msg gla-r-ok";
form.reset();
} else {
var detail =
(result.body && result.body.error) ||
(result.raw && result.raw.slice(0, 200)) ||
"";
msg.textContent = detail
? detail + " (" + result.status + ")"
: "Erro " + result.status;
msg.className = "gla-r-msg gla-r-err";
}
})
.catch(function () {
msg.textContent =
"Rede ou CORS: confirma api_base e REPORTS_CORS_ORIGINS no servidor.";
msg.className = "gla-r-msg gla-r-err";
})
.then(function () {
btnSend.disabled = false;
});
});
})();
/*]]>*/
</script>

Widget:C.Skills

2026-04-20T22:33:28Z

Gurren1:

<script>
(function () {
const $ = (s, root = document) => root.querySelector(s);
const $$ = (s, root = document) => Array.from(root.querySelectorAll(s));
const ensureRemoved = (sel) => {
Array.from(document.querySelectorAll(sel)).forEach((n) => n.remove());
};
const onceFlag = (el, key) => {
if (!el) return false;
if (el.dataset[key]) return false;
el.dataset[key] = "1";
return true;
};
const addOnce = (el, ev, fn, options = {}) => {
if (!el) return;
const attr = `data-wired-${ev}`;
if (el.hasAttribute(attr)) return;
el.addEventListener(ev, fn, options);
el.setAttribute(attr, "1");
};
const FLAG_ICON_FILES = {
aggro: "Enemyaggro-icon.png",
bridge: "Bridgemaker-icon.png",
wall: "Destroywall-icon.png",
quickcast: "Quickcast-icon.png",
wallpass: "Passthroughwall-icon.png",
};
const subBarTemplateCache =
window.__skillSubBarTemplateCache ||
(window.__skillSubBarTemplateCache = new Map());
const imagePreloadCache =
window.__skillImagePreloadCache ||
(window.__skillImagePreloadCache = new Map());
const videoPreloadCache =
window.__skillVideoPreloadCache ||
(window.__skillVideoPreloadCache = new Set());
const flagRowCache =
window.__skillFlagRowCache || (window.__skillFlagRowCache = new Map());
const flagIconURLCache =
window.__skillFlagIconURLCache ||
(window.__skillFlagIconURLCache = new Map());

// Sistema de múltiplas formas (genérico)
let currentForm = null; // null = primeira forma, depois nome da forma atual
let formsData = {};
let fixedSkills = []; // Skills que sempre aparecem (Change Form, Guard Point, etc.)

// Sistema genérico de swap de personagens (ex: Buchi & Sham, futuros personagens)
let activeCharacter = null; // null = personagem padrão, depois nome do personagem ativo (ex: "Buchi", "Sham")

function showFormTransitionVideo(changeFormIconEl) {
const skillsRoot = document.getElementById("skills");
if (!skillsRoot) return;

// Busca videoBox
let videoBox = skillsRoot.querySelector(".video-container");
if (!videoBox) {
const skillsContainer = skillsRoot.querySelector(".skills-container");
if (skillsContainer) {
videoBox = skillsContainer.querySelector(".video-container");
}
}
if (!videoBox) return;

try {
// Lê dados de forms para determinar forma atual e próxima
const formsJSON = skillsRoot.dataset.forms || "{}";
if (formsJSON && formsJSON !== "{}") {
const tempFormsData = JSON.parse(formsJSON);
const formNames = Object.keys(tempFormsData);

// Determina forma atual e próxima
const currentIdx = currentForm ? formNames.indexOf(currentForm) : -1;
const nextIdx = (currentIdx + 1) % formNames.length;
const nextForm = formNames[nextIdx];

// Busca vídeo de transição na skill Change Form
// form_videos[forma_atual] = "video.mp4" (vídeo da transição atual → próxima)
const formVideosRaw =
changeFormIconEl.dataset.formVideos ||
changeFormIconEl.getAttribute("data-form-videos");
if (formVideosRaw) {
try {
const videos = JSON.parse(formVideosRaw);
const transitionVideo = videos[currentForm] || "";

if (transitionVideo && transitionVideo.trim() !== "") {
const videoURL = filePathURL(transitionVideo);
if (videoURL) {
// Busca ou cria elemento de vídeo para esta transição
const videoKey = `form_transition:${currentForm}:${nextForm}`;
let v = videosCache.get(videoKey);

if (!v) {
// Cria novo elemento de vídeo
v = document.createElement("video");
v.className = "skill-video";
v.src = videoURL;
v.preload = "auto";
v.controls = false;
v.muted = false;
v.loop = false;
v.playsInline = true;
videoBox.appendChild(v);
videosCache.set(videoKey, v);
}

// Mostra e reproduz o vídeo
Array.from(
videoBox.querySelectorAll("video.skill-video")
).forEach((vid) => {
try {
vid.pause();
} catch (e) { }
vid.style.display = "none";
});

videoBox.style.display = "block";
v.style.display = "block";
try {
v.currentTime = 0;
v.play().catch(() => { });
} catch (e) { }
}
}
} catch (e) {
console.error("[Forms] Erro ao parsear form_videos:", e);
}
}
}
} catch (e) {
console.error("[Forms] Erro ao processar vídeo de transição:", e);
}
}

// Sistema genérico de swap de personagens (ex: Buchi & Sham, futuros personagens)
// Detecta quais personagens estão disponíveis baseado nas skills
function detectAvailableCharacters() {
const iconBar = document.querySelector(".icon-bar");
const skillsRoot = document.getElementById("skills");
if (!iconBar) return [];

const characters = new Set();
Array.from(
iconBar.querySelectorAll(".skill-icon[data-only-character]")
).forEach((icon) => {
const character = (icon.dataset.onlyCharacter || "").trim();
if (character) {
characters.add(character);
}
});

const arr = Array.from(characters);
const explicitDefault = (
skillsRoot?.dataset?.defaultCharacter || ""
).trim();
if (explicitDefault && arr.includes(explicitDefault)) {
const rest = arr.filter((c) => c !== explicitDefault).sort();
return [explicitDefault, ...rest];
}
return arr.sort();
}

// Inicializa o personagem padrão (deve ser chamado quando a página carrega)
function initializeActiveCharacter() {
const availableCharacters = detectAvailableCharacters();
if (availableCharacters.length > 0 && activeCharacter === null) {
// Inicializa com o primeiro personagem disponível (padrão)
activeCharacter = availableCharacters[0];
// Aplica o estado inicial (habilita/desabilita skills)
applyCharacterSwapState();
rebuildMainSkillsMetaFromBar();
}
}

// Aplica o estado de swap nas skills (habilita/desabilita, vídeo, stats e descrição por personagem)
function applyCharacterSwapState() {
const iconBar = document.querySelector(".icon-bar");
if (!iconBar) return;

Array.from(iconBar.querySelectorAll(".skill-icon[data-index]")).forEach(
(icon) => {
const onlyCharacter = (icon.dataset.onlyCharacter || "").trim();
const hasCharacterVideos =
icon.dataset.characterVideos &&
icon.dataset.characterVideos.trim() !== "";
const hasCharSkills =
icon.dataset.characterSkills &&
icon.dataset.characterSkills.trim() !== "";

if (onlyCharacter) {
if (onlyCharacter === activeCharacter) {
icon.style.opacity = "1";
icon.style.filter = "";
icon.style.pointerEvents = "";
icon.classList.remove("disabled-skill");
} else {
icon.style.opacity = "0.3";
icon.style.filter = "grayscale(100%)";
icon.style.pointerEvents = "none";
icon.classList.add("disabled-skill");
}
return;
}

icon.style.opacity = "1";
icon.style.filter = "";
icon.style.pointerEvents = "";
icon.classList.remove("disabled-skill");

if (!hasCharSkills && !hasCharacterVideos) {
return;
}

if (!icon.dataset.swapBaselineStored) {
icon.dataset.swapBaselineStored = "1";
icon.dataset.swapBaselineAtr = icon.dataset.atr || "";
icon.dataset.swapBaselineDescPt = icon.dataset.descPt || "";
icon.dataset.swapBaselineDescEn = icon.dataset.descEn || "";
icon.dataset.swapBaselineDescEs = icon.dataset.descEs || "";
icon.dataset.swapBaselineDescPl = icon.dataset.descPl || "";
icon.dataset.swapBaselineLevel = icon.dataset.level || "";
icon.dataset.swapBaselineVideoFile = (
icon.dataset.videoFile || ""
).trim();
icon.dataset.swapBaselineVideo = (icon.dataset.video || "").trim();
if (
hasCharacterVideos &&
!icon.dataset.originalVideoFile
) {
icon.dataset.originalVideoFile =
icon.dataset.swapBaselineVideoFile ||
icon.dataset.swapBaselineVideo ||
"";
}
}

const oAtr = parseAttrString(
icon.dataset.swapBaselineAtr || icon.dataset.atr || ""
);
let pve = oAtr.powerpve;
let pvp = oAtr.powerpvp;
let en = oAtr.energy;
let cd = oAtr.cooldown;
let dPt = icon.dataset.swapBaselineDescPt || "";
let dEn = icon.dataset.swapBaselineDescEn || "";
let dEs = icon.dataset.swapBaselineDescEs || "";
let dPl = icon.dataset.swapBaselineDescPl || "";
let lvl = icon.dataset.swapBaselineLevel || "";
let vFile = icon.dataset.swapBaselineVideoFile || "";
let vUrl = icon.dataset.swapBaselineVideo || "";

if (hasCharSkills && activeCharacter) {
try {
const cs = JSON.parse(icon.dataset.characterSkills);
const co = cs[activeCharacter] || {};
if (
co.powerpve !== undefined &&
co.powerpve !== null &&
co.powerpve !== ""
)
pve = String(co.powerpve);
if (
co.powerpvp !== undefined &&
co.powerpvp !== null &&
co.powerpvp !== ""
)
pvp = String(co.powerpvp);
if (
co.energy !== undefined &&
co.energy !== null &&
co.energy !== ""
)
en = String(co.energy);
if (
co.cooldown !== undefined &&
co.cooldown !== null &&
co.cooldown !== ""
)
cd = String(co.cooldown);
if (co.level !== undefined && co.level !== null && co.level !== "")
lvl = String(co.level);
const di = co.desc_i18n || co.desc;
if (di) {
if (di.pt) dPt = di.pt;
if (di.en) dEn = di.en;
if (di.es) dEs = di.es;
if (di.pl) dPl = di.pl;
}
if (co.video && String(co.video).trim()) {
const vf = String(co.video).trim();
vFile = vf;
vUrl = filePathURL(vf) || vf;
}
} catch (e) {
console.error("[Swap] Erro ao processar character_skills:", e);
}
}

if (hasCharacterVideos && activeCharacter) {
try {
const cv = JSON.parse(icon.dataset.characterVideos);
const cvv = cv[activeCharacter];
if (cvv && String(cvv).trim()) {
const vf = String(cvv).trim();
vFile = vf;
vUrl = filePathURL(vf) || vf;
}
} catch (e) {
console.error("[Swap] Erro ao processar character_videos:", e);
}
} else if (
hasCharacterVideos &&
activeCharacter === null &&
icon.dataset.originalVideoFile
) {
const originalVideo = icon.dataset.originalVideoFile || "";
if (originalVideo) {
vFile =
extractFileNameFromURL(originalVideo) || originalVideo;
vUrl = filePathURL(vFile) || originalVideo;
}
}

icon.dataset.atr = makeAttrString(pve, pvp, en, cd);
icon.dataset.descPt = dPt;
icon.dataset.descEn = dEn;
icon.dataset.descEs = dEs;
icon.dataset.descPl = dPl;
if (lvl && String(lvl).toUpperCase() !== "NIVEL") {
icon.dataset.level = lvl;
} else {
delete icon.dataset.level;
}
icon.dataset.videoFile = vFile;
icon.dataset.video = vUrl;
}
);
}

// Troca entre personagens (genérico)
function handleSwapCharacter(swapIconEl) {
if (!swapIconEl) return;

const iconBar = document.querySelector(".icon-bar");
if (!iconBar) return;

const availableCharacters = detectAvailableCharacters();
if (availableCharacters.length === 0) {
return;
}

if (activeCharacter === null) {
activeCharacter = availableCharacters[0];
} else {
const currentIndex = availableCharacters.indexOf(activeCharacter);
const nextIndex = (currentIndex + 1) % availableCharacters.length;
activeCharacter = availableCharacters[nextIndex];
}

applyCharacterSwapState();
rebuildMainSkillsMetaFromBar();
}

// Detecta qual forma está atualmente visível no DOM
function detectCurrentForm() {
const iconBar = document.querySelector(".icon-bar");
if (!iconBar || !formsData || Object.keys(formsData).length === 0)
return null;

// Coleta todas as skills de form que estão visíveis no DOM
const allFormSkillNames = new Set();
Object.values(formsData).forEach((form) => {
if (form.order && Array.isArray(form.order)) {
form.order.forEach((skillName) => allFormSkillNames.add(skillName));
}
});

const visibleFormSkillNames = new Set();
Array.from(iconBar.querySelectorAll(".skill-icon[data-index]")).forEach(
(icon) => {
const name = (icon.dataset.nome || "").trim();
if (name && allFormSkillNames.has(name)) {
visibleFormSkillNames.add(name);
}
}
);

// Compara com cada forma para ver qual corresponde
for (const [formName, formData] of Object.entries(formsData)) {
if (formData.order && Array.isArray(formData.order)) {
const formSkillSet = new Set(formData.order);
// Verifica se todas as skills desta forma estão visíveis
let allMatch = true;
for (const skillName of formData.order) {
if (!visibleFormSkillNames.has(skillName)) {
allMatch = false;
break;
}
}
if (
allMatch &&
formData.order.length === visibleFormSkillNames.size
) {
return formName;
}
}
}

return null;
}

function getNextFormName() {
const formNames = Object.keys(formsData);
if (formNames.length === 0) return null;

let cur = currentForm;
if (cur === null) {
cur = detectCurrentForm();
}
if (!cur && formNames.length > 0) {
cur = formNames[0];
}

let orderedFormNames = [];
if (cur === "Brain Point" && formNames.length === 3 &&
formNames.includes("Kung Fu Point") && formNames.includes("Heavy Point")) {
orderedFormNames = ["Brain Point", "Kung Fu Point", "Heavy Point"];
} else if (cur === "Kung Fu Point" && formNames.length === 3 &&
formNames.includes("Heavy Point") && formNames.includes("Brain Point")) {
orderedFormNames = ["Kung Fu Point", "Heavy Point", "Brain Point"];
} else if (cur === "Heavy Point" && formNames.length === 3 &&
formNames.includes("Brain Point") && formNames.includes("Kung Fu Point")) {
orderedFormNames = ["Heavy Point", "Brain Point", "Kung Fu Point"];
}

if (orderedFormNames.length === 0) {
orderedFormNames = [...formNames].sort();
if (cur) {
const idx = orderedFormNames.indexOf(cur);
if (idx !== -1) {
orderedFormNames = [
...orderedFormNames.slice(idx),
...orderedFormNames.slice(0, idx),
];
}
}
}

const idx = orderedFormNames.indexOf(cur);
if (idx === -1) return null;
return orderedFormNames[(idx + 1) % orderedFormNames.length];
}

function switchForm() {
const skillsRoot = document.getElementById("skills");
if (!skillsRoot) return;

// Lê dados de forms do atributo data-forms
try {
const formsJSON = skillsRoot.dataset.forms || "{}";
if (formsJSON && formsJSON !== "{}") {
formsData = JSON.parse(formsJSON);
}
} catch (e) {
console.error("[Forms] Erro ao parsear forms:", e);
return;
}

if (!formsData || Object.keys(formsData).length === 0) {
return; // Não tem forms, não faz nada
}

// Identifica skills fixas (sempre presentes)
const iconBar = document.querySelector(".icon-bar");
if (!iconBar) return;

// Busca a skill com form_switch dinamicamente (genérico)
const changeFormIcon = Array.from(
iconBar.querySelectorAll(".skill-icon[data-index]")
).find(
(icon) =>
icon.dataset.formSwitch === "true" ||
icon.getAttribute("data-form-switch") === "true"
);
if (changeFormIcon) {
changeFormIcon.classList.add("active");
}

// Determina skills fixas dinamicamente: todas que não estão em nenhuma forms
const allFormSkillNames = new Set();
Object.values(formsData).forEach((form) => {
if (form.order && Array.isArray(form.order)) {
form.order.forEach((skillName) => allFormSkillNames.add(skillName));
}
});

// Skills fixas = todas as skills na barra que não estão em nenhuma forms
fixedSkills = Array.from(
iconBar.querySelectorAll(".skill-icon[data-index]")
)
.filter((icon) => {
const name = (icon.dataset.nome || "").trim();
return name && !allFormSkillNames.has(name);
})
.map((icon) => snapshotIconData(icon));

// Obtém lista de formas disponíveis
const formNames = Object.keys(formsData);
if (formNames.length === 0) return;

if (currentForm === null) {
currentForm = detectCurrentForm();
if (!currentForm && formNames.length > 0) {
currentForm = formNames[0];
}
}

const nextForm = getNextFormName();
if (!nextForm) return;

currentForm = nextForm;

// Atualiza barra de skills (que vai remover o active depois da animação)
updateSkillsBarForForm(nextForm, formsData[nextForm], changeFormIcon);
}

function snapshotIconData(icon) {
const img = icon.querySelector("img");
const iconURL = img ? img.src : "";
const subsRaw = icon.dataset.subs || icon.getAttribute("data-subs") || "";
let subs = null;
try {
subs = subsRaw ? JSON.parse(subsRaw) : null;
} catch {
subs = null;
}
let flags = null;
if (icon.dataset.flags) {
try {
flags = JSON.parse(icon.dataset.flags);
} catch (e) { }
}
let weapon = null;
if (icon.dataset.weapon) {
try {
weapon = JSON.parse(icon.dataset.weapon);
} catch (e) { }
}
return {
name: icon.dataset.nome || icon.dataset.name || "",
index: icon.dataset.index || "",
level: icon.dataset.level || "",
desc: icon.dataset.desc || "",
descPt: icon.dataset.descPt || "",
descEn: icon.dataset.descEn || "",
descEs: icon.dataset.descEs || "",
descPl: icon.dataset.descPl || "",
attrs: icon.dataset.atr || icon.dataset.attrs || "",
video: icon.dataset.video || "",
iconURL,
iconFile: icon.dataset.iconFile || "",
subs,
flags,
weapon,
formSwitch: icon.dataset.formSwitch || "",
};
}

function updateSkillsBarForForm(formName, formData, changeFormIconEl) {
const iconBar = document.querySelector(".icon-bar");
if (!iconBar || !formData || !formData.skills) return;

// Determina skills fixas dinamicamente: todas que não estão em nenhuma forms
const allFormSkillNames = new Set();
Object.values(formsData).forEach((form) => {
if (form.order && Array.isArray(form.order)) {
form.order.forEach((skillName) => allFormSkillNames.add(skillName));
}
});

// Remove skills de forma antigas (que não são fixas) com animação de saída

const existingIcons = Array.from(
iconBar.querySelectorAll(".skill-icon[data-index]")
);
const iconsToRemove = [];
existingIcons.forEach((icon) => {
const name = (icon.dataset.nome || "").trim();
if (name && allFormSkillNames.has(name)) {
iconsToRemove.push(icon);
}
});

// Anima saída das skills antigas
iconsToRemove.forEach((icon) => {
icon.style.transition = "opacity .15s ease, transform .15s ease";
icon.style.opacity = "0";
icon.style.transform = "translateY(-6px)";
});

// Encontra a skill com form_switch dinamicamente (genérico)
const changeFormIcon = Array.from(
iconBar.querySelectorAll(".skill-icon[data-index]")
).find(
(icon) =>
icon.dataset.formSwitch === "true" ||
icon.getAttribute("data-form-switch") === "true"
);

// Encontra a próxima skill fixa depois do form_switch dinamicamente
let nextFixedSkillIcon = null;
if (changeFormIcon) {
const allIcons = Array.from(
iconBar.querySelectorAll(".skill-icon[data-index]")
).sort((a, b) => {
return (
parseInt(a.dataset.index || "0", 10) -
parseInt(b.dataset.index || "0", 10)
);
});
const changeFormIndex = allIcons.indexOf(changeFormIcon);
const allFormSkillNames = new Set();
Object.values(formsData).forEach((form) => {
if (form.order && Array.isArray(form.order)) {
form.order.forEach((skillName) => allFormSkillNames.add(skillName));
}
});

// Procura a próxima skill fixa (que não está em forms)
for (let i = changeFormIndex + 1; i < allIcons.length; i++) {
const icon = allIcons[i];
const name = (icon.dataset.nome || "").trim();
if (name && !allFormSkillNames.has(name)) {
nextFixedSkillIcon = icon;
break;
}
}
}

if (!changeFormIcon || !nextFixedSkillIcon) {
console.warn(
"[Forms] Skill com form_switch ou próxima skill fixa não encontrada"
);
return;
}

const formSkills = formData.skills || [];
const formOrder = formData.order || [];

// Primeira skill da forma (vai ANTES do Change Form)
const firstSkillName = formOrder[0];
const firstSkillData = formSkills.find((s) => s.name === firstSkillName);

// Terceira skill da forma (vai DEPOIS do Change Form, ANTES do Guard Point)
const thirdSkillName = formOrder[1]; // Segunda na ordem = terceira skill (índice 1)
const thirdSkillData = formSkills.find((s) => s.name === thirdSkillName);

// Skills "extras" da forma (order[2..N]) vão DEPOIS do Guard Point,
// em sequência contígua. Para forms com 3 skills (caso clássico do Chopper)
// isso insere apenas order[2] (quinta skill) mantendo o layout antigo.
// Para forms com 4+ skills, as demais ocupam os slots seguintes.
const extraSkillsData = [];
for (let i = 2; i < formOrder.length; i++) {
const nm = formOrder[i];
const dt = formSkills.find((s) => s.name === nm);
if (dt) extraSkillsData.push(dt);
}

// Cria fragments para inserir
const firstFragment = document.createDocumentFragment();
const thirdFragment = document.createDocumentFragment();
const extrasFragment = document.createDocumentFragment();

if (firstSkillData) {
const iconElement = createSkillIconElement(firstSkillData, 1);
firstFragment.appendChild(iconElement);
}
if (thirdSkillData) {
const changeFormIndex = parseInt(
changeFormIcon.dataset.index || "2",
10
);
const iconElement = createSkillIconElement(
thirdSkillData,
changeFormIndex + 1
);
thirdFragment.appendChild(iconElement);
}
if (extraSkillsData.length > 0) {
const nextFixedSkillIndex = parseInt(
nextFixedSkillIcon.dataset.index || "4",
10
);
extraSkillsData.forEach((dt, offset) => {
const iconElement = createSkillIconElement(
dt,
nextFixedSkillIndex + 1 + offset
);
extrasFragment.appendChild(iconElement);
});
}

// Remove os ícones antigos do DOM após animação
setTimeout(() => {
iconsToRemove.forEach((icon) => {
if (icon.parentNode) {
icon.remove();
}
});

// Insere a primeira skill ANTES da skill com form_switch
if (firstFragment.hasChildNodes()) {
iconBar.insertBefore(firstFragment, changeFormIcon);
}

// Insere a terceira skill DEPOIS da skill com form_switch, ANTES da próxima skill fixa
if (thirdFragment.hasChildNodes()) {
iconBar.insertBefore(thirdFragment, nextFixedSkillIcon);
}

// Insere as skills extras (order[2..N]) DEPOIS da próxima skill fixa,
// em sequência contígua.
if (extrasFragment.hasChildNodes()) {
if (nextFixedSkillIcon.nextSibling) {
iconBar.insertBefore(extrasFragment, nextFixedSkillIcon.nextSibling);
} else {
iconBar.appendChild(extrasFragment);
}
}

// Anima entrada das novas skills (similar a animateIconsBarEntrance)
const newIconsInBar = Array.from(
iconBar.querySelectorAll(".skill-icon[data-index]")
).filter((icon) => {
const name = (icon.dataset.nome || "").trim();
return name && allFormSkillNames.has(name);
});

newIconsInBar.forEach((icon, idx) => {
icon.style.opacity = "0";
icon.style.transform = "translateY(6px)";
requestAnimationFrame(() => {
setTimeout(() => {
icon.style.transition = "opacity .18s ease, transform .18s ease";
icon.style.opacity = "1";
icon.style.transform = "translateY(0)";
}, idx * 24);
});
});

// Remove slots de descrição das skills de forma antigas e cria novos
const descBox = document.querySelector(".skills-details .desc-box");
if (descBox) {
// Encontra os slots de descrição dos elementos fixos
const changeFormIndex = parseInt(
changeFormIcon.dataset.index || "1",
10
);
const nextFixedSkillIndex = parseInt(
nextFixedSkillIcon.dataset.index || "1",
10
);
const changeFormDescSlot = descBox.querySelector(
`.skill-desc[data-index="${changeFormIndex}"]`
);
const nextFixedSkillDescSlot = descBox.querySelector(
`.skill-desc[data-index="${nextFixedSkillIndex}"]`
);

// Cria slot para primeira skill (antes do Change Form)
if (firstSkillData && changeFormDescSlot) {
const descSlot = document.createElement("div");
descSlot.className = "skill-desc";
descSlot.setAttribute("data-index", changeFormIndex);
descBox.insertBefore(descSlot, changeFormDescSlot);
}

// Cria slot para terceira skill (depois da skill com form_switch, antes da próxima skill fixa)
if (thirdSkillData && nextFixedSkillDescSlot) {
const descSlot = document.createElement("div");
descSlot.className = "skill-desc";
descSlot.setAttribute("data-index", nextFixedSkillIndex);
descBox.insertBefore(descSlot, nextFixedSkillDescSlot);
}

// Cria slots para TODAS as skills extras (depois da próxima skill fixa),
// em sequência contígua. Cada uma recebe um data-index incremental.
if (extraSkillsData.length > 0 && nextFixedSkillDescSlot) {
// anchor mantém a referência de inserção: cada novo slot entra
// logo depois do anterior, preservando a ordem visual.
let anchor = nextFixedSkillDescSlot;
extraSkillsData.forEach((_, offset) => {
const descSlot = document.createElement("div");
descSlot.className = "skill-desc";
descSlot.setAttribute("data-index", nextFixedSkillIndex + 1 + offset);
if (anchor.nextSibling) {
descBox.insertBefore(descSlot, anchor.nextSibling);
} else {
descBox.appendChild(descSlot);
}
anchor = descSlot;
});
}
}

// Re-numera todas as skills na ordem do DOM
const allIcons = Array.from(
iconBar.querySelectorAll(".skill-icon[data-index]")
);
let currentIndex = 1;
allIcons.forEach((icon) => {
const oldIndex = icon.dataset.index;
icon.setAttribute("data-index", currentIndex);

// Atualiza slot de descrição
if (descBox && oldIndex) {
const descSlot = descBox.querySelector(
`.skill-desc[data-index="${oldIndex}"]`
);
if (descSlot) {
descSlot.setAttribute("data-index", currentIndex);
}
}
currentIndex++;
});

// Re-wire eventos
wireClicksForCurrentBar();
wireTooltipsForNewIcons();

// Remove active do Change Form após animação completar
setTimeout(() => {
if (changeFormIconEl) {
changeFormIconEl.classList.remove("active");
}
}, newIconsInBar.length * 24 + 180);
}, 150);
}

function createSkillIconElement(skill, index) {
const iconWrap = document.createElement("div");
iconWrap.className = "skill-icon";
iconWrap.setAttribute("data-index", index);
iconWrap.setAttribute("data-nome", skill.name || "");
iconWrap.setAttribute("data-desc", "");
iconWrap.setAttribute(
"data-atr",
makeAttrString(
skill.powerpve,
skill.powerpvp,
skill.energy,
skill.cooldown
)
);
iconWrap.setAttribute(
"data-video",
skill.video ? filePathURL(skill.video) : ""
);
iconWrap.setAttribute("data-video-preload", "auto");
iconWrap.setAttribute("data-icon-file", skill.icon || "");
iconWrap.setAttribute("data-video-file", skill.video || "");

if (
skill.level &&
skill.level !== "" &&
String(skill.level).toUpperCase() !== "NIVEL"
) {
iconWrap.setAttribute("data-level", skill.level);
}

if (skill.desc_i18n) {
if (skill.desc_i18n.pt)
iconWrap.setAttribute("data-desc-pt", skill.desc_i18n.pt);
if (skill.desc_i18n.en)
iconWrap.setAttribute("data-desc-en", skill.desc_i18n.en);
if (skill.desc_i18n.es)
iconWrap.setAttribute("data-desc-es", skill.desc_i18n.es);
if (skill.desc_i18n.pl)
iconWrap.setAttribute("data-desc-pl", skill.desc_i18n.pl);
}

if (skill.subs && Array.isArray(skill.subs) && skill.subs.length > 0) {
iconWrap.setAttribute("data-subs", JSON.stringify(skill.subs));
}
if (
skill.suborder &&
Array.isArray(skill.suborder) &&
skill.suborder.length > 0
) {
iconWrap.setAttribute("data-suborder", JSON.stringify(skill.suborder));
}

if (skill.flags && Array.isArray(skill.flags) && skill.flags.length > 0) {
iconWrap.setAttribute("data-flags", JSON.stringify(skill.flags));
}

if (
skill.weapon &&
typeof skill.weapon === "object" &&
Object.keys(skill.weapon).length > 0
) {
iconWrap.setAttribute("data-weapon", JSON.stringify(skill.weapon));
}
if (skill.effect && typeof skill.effect === "object") {
try {
iconWrap.setAttribute("data-effect", JSON.stringify(skill.effect));
} catch (e) { }
}

if (skill.formSwitch) {
iconWrap.setAttribute("data-form-switch", skill.formSwitch);
}
if (skill.formVideos && typeof skill.formVideos === "string" && skill.formVideos.trim() !== "") {
iconWrap.setAttribute("data-form-videos", skill.formVideos);
}

const img = document.createElement("img");
img.className = "skill-icon-img";
img.src = filePathURL(skill.icon || "");
img.alt = "";
iconWrap.appendChild(img);

return iconWrap;
}

function createSkillIcon(skill, index, container) {
// Cria ícone similar ao que é gerado pelo servidor
const iconWrap = document.createElement("div");
iconWrap.className = "skill-icon";
iconWrap.setAttribute("data-index", index);
iconWrap.setAttribute("data-nome", skill.name || "");
iconWrap.setAttribute("data-desc", "");
iconWrap.setAttribute(
"data-atr",
makeAttrString(
skill.powerpve,
skill.powerpvp,
skill.energy,
skill.cooldown
)
);
iconWrap.setAttribute(
"data-video",
skill.video ? filePathURL(skill.video) : ""
);
iconWrap.setAttribute("data-video-preload", "auto");
iconWrap.setAttribute("data-icon-file", skill.icon || "");
iconWrap.setAttribute("data-video-file", skill.video || "");

if (
skill.level &&
skill.level !== "" &&
String(skill.level).toUpperCase() !== "NIVEL"
) {
iconWrap.setAttribute("data-level", skill.level);
}

if (skill.desc_i18n) {
if (skill.desc_i18n.pt)
iconWrap.setAttribute("data-desc-pt", skill.desc_i18n.pt);
if (skill.desc_i18n.en)
iconWrap.setAttribute("data-desc-en", skill.desc_i18n.en);
if (skill.desc_i18n.es)
iconWrap.setAttribute("data-desc-es", skill.desc_i18n.es);
if (skill.desc_i18n.pl)
iconWrap.setAttribute("data-desc-pl", skill.desc_i18n.pl);
}

if (skill.subs && Array.isArray(skill.subs) && skill.subs.length > 0) {
iconWrap.setAttribute("data-subs", JSON.stringify(skill.subs));
}
if (
skill.suborder &&
Array.isArray(skill.suborder) &&
skill.suborder.length > 0
) {
iconWrap.setAttribute("data-suborder", JSON.stringify(skill.suborder));
}

if (skill.flags && Array.isArray(skill.flags) && skill.flags.length > 0) {
iconWrap.setAttribute("data-flags", JSON.stringify(skill.flags));
}

if (
skill.weapon &&
typeof skill.weapon === "object" &&
Object.keys(skill.weapon).length > 0
) {
iconWrap.setAttribute("data-weapon", JSON.stringify(skill.weapon));
}
if (skill.effect && typeof skill.effect === "object") {
try {
iconWrap.setAttribute("data-effect", JSON.stringify(skill.effect));
} catch (e) { }
}

if (skill.formSwitch) {
iconWrap.setAttribute("data-form-switch", skill.formSwitch);
}
if (skill.formVideos && typeof skill.formVideos === "string" && skill.formVideos.trim() !== "") {
iconWrap.setAttribute("data-form-videos", skill.formVideos);
}

const img = document.createElement("img");
img.className = "skill-icon-img";
img.src = filePathURL(skill.icon || "");
img.alt = "";
iconWrap.appendChild(img);

container.appendChild(iconWrap);
}

function makeAttrString(pve, pvp, energy, cd) {
const parts = [
pve !== undefined && pve !== null && pve !== "" ? String(pve) : "-",
pvp !== undefined && pvp !== null && pvp !== "" ? String(pvp) : "-",
energy !== undefined && energy !== null && energy !== ""
? String(energy)
: "-",
cd !== undefined && cd !== null && cd !== "" ? String(cd) : "-",
];
return parts.join(", ");
}

function filePathURL(fileName) {
// Evita requisições para valores vazios
if (!fileName || fileName.trim() === "") {
return "";
}
const f = encodeURIComponent(fileName.replace(/^Arquivo:|^File:/, ""));
const base =
window.mw && mw.util && typeof mw.util.wikiScript === "function"
? mw.util.wikiScript()
: window.mw && window.mw.config
? mw.config.get("wgScript") || "/index.php"
: "/index.php";
// Garante HTTPS para evitar Mixed Content
let url = `${base}?title=Especial:FilePath/${f}`;
if (window.location.protocol === "https:" && url.startsWith("http://")) {
url = url.replace("http://", "https://");
}
return url;
}
function slugify(s) {
if (!s) return "";
return String(s)
.toLowerCase()
.normalize("NFD")
.replace(/[\u0300-\u036f]/g, "")
.replace(/[^\w\s-]/g, "")
.replace(/[\s:/\-]+/g, "-")
.replace(/^-+|-+$/g, "")
.replace(/-+/g, "-");
}
window.__skillSlugify = slugify;
function getLangKey() {
const skillsRoot = document.getElementById("skills");
const raw = (
document.documentElement.lang ||
skillsRoot?.dataset.i18nDefault ||
"pt"
).toLowerCase();
return raw === "pt-br" ? "pt" : raw.split("-")[0] || "pt";
}
function chooseDescFrom(obj) {
const lang = getLangKey();
// Aceita tanto desc_i18n quanto desc para compatibilidade
const pack = obj.desc_i18n ||
obj.desc || {
pt: obj.descPt,
en: obj.descEn,
es: obj.descEs,
pl: obj.descPl,
};
return (
(pack && (pack[lang] || pack.pt || pack.en || pack.es || pack.pl)) || ""
);
}
function renderSubAttributesFromObj(s, L) {
const chip = (label, val) =>
val
? `<div class="attr-row"><span class="attr-label">${label}</span><span class="attr-value">${val}</span></div>`
: "";
const pve = (s.powerpve || "").toString().trim();
const pvp = (s.powerpvp || "").toString().trim();
const en = (s.energy || "").toString().trim();
const cd = (s.cooldown || "").toString().trim();
const rows = [
cd ? chip(L.cooldown, cd) : "",
en
? chip(
en.startsWith("-") ? L.energy_cost : L.energy_gain,
en.startsWith("-") ? en.replace(/^-/, "") : en.replace(/^\+?/, "")
)
: "",
pve ? chip(L.power, pve) : "",
pvp ? chip(L.power_pvp, pvp) : "",
].filter(Boolean);
return rows.length ? `<div class="attr-list">${rows.join("")}</div>` : "";
}
function getFlagIconURL(key) {
const keyNorm = String(key || "").trim().toLowerCase();
if (!keyNorm || !FLAG_ICON_FILES[keyNorm]) return "";
if (!flagIconURLCache.has(keyNorm)) {
flagIconURLCache.set(keyNorm, filePathURL(FLAG_ICON_FILES[keyNorm]));
}
return flagIconURLCache.get(keyNorm);
}
function renderFlagsRow(flags) {
const arr = (flags || []).filter(Boolean).map((k) => String(k || "").trim().toLowerCase());
const arrFiltered = arr.filter(Boolean);
if (!arrFiltered.length) return "";
const cacheKey = arrFiltered.join("|");
if (flagRowCache.has(cacheKey)) {
return flagRowCache.get(cacheKey);
}
const items = arrFiltered
.map((k) => {
const url = getFlagIconURL(k);
return url
? `<img class="skill-flag" data-flag="${k}" alt="" src="${url}">`
: "";
})
.join("");
const html = items
? `<div class="skill-flags" role="group" aria-label="Características">${items}</div>`
: "";
if (html) flagRowCache.set(cacheKey, html);
return html;
}
function applyFlagTooltips(container) {
const skillsRoot = document.getElementById("skills");
if (!skillsRoot) return;
let pack = {};
try {
pack = JSON.parse(skillsRoot.dataset.i18nFlags || "{}");
} catch (e) { }
const lang = getLangKey();
const dict = pack[lang] || pack.pt || {};
const flags = container.querySelectorAll(
".skill-flags .skill-flag[data-flag]"
);
const tooltip = window.__globalSkillTooltip;
if (!tooltip) return;
flags.forEach((el) => {
const key = el.getAttribute("data-flag");
const tip = (dict && dict[key]) || "";
if (!tip) return;
if (el.dataset.flagTipWired) return;
el.dataset.flagTipWired = "1";
el.setAttribute("aria-label", tip);
if (el.hasAttribute("title")) el.removeAttribute("title");
el.addEventListener("mouseenter", () => {
const tipEl = document.querySelector(".skill-tooltip");
if (tipEl) tipEl.classList.add("flag-tooltip");
tooltip.show(el, tip);
});
el.addEventListener("mousemove", () => {
if (performance.now() >= tooltip.lockUntil.value) {
tooltip.measureAndPos(el);
}
});
el.addEventListener("click", () => {
tooltip.lockUntil.value = performance.now() + 240;
tooltip.measureAndPos(el);
});
el.addEventListener("mouseleave", () => {
const tipEl = document.querySelector(".skill-tooltip");
if (tipEl) tipEl.classList.remove("flag-tooltip");
tooltip.hide();
});
});
}

// ====== Skill/Subskill inheritance helpers ======
const mainSkillsMeta = {
byIndex: new Map(),
byName: new Map(),
ready: false,
};

function normalizeFileURL(raw, fallback = "") {
if (!raw) return fallback;
const val = String(raw).trim();
if (!val) return fallback;
if (
/^(https?:)?\/\//i.test(val) ||
val.startsWith("data:") ||
val.includes("Especial:FilePath/")
) {
return val;
}
return filePathURL(val);
}

function extractFileNameFromURL(url) {
if (!url) return "";
const match = String(url).match(/(?:FilePath\/)([^&?]+)/i);
return match ? decodeURIComponent(match[1]) : "";
}

function parseAttrString(raw) {
const parts = (raw || "").split(",").map((v) => v.trim());
const safe = (idx) => {
const val = parts[idx] || "";
return val && val !== "-" ? val : "";
};
return {
powerpve: safe(0),
powerpvp: safe(1),
energy: safe(2),
cooldown: safe(3),
};
}

function hasText(value) {
return typeof value === "string"
? value.trim() !== ""
: value !== undefined && value !== null;
}

function pickFilled(current, fallback) {
if (current === 0 || current === "0") return current;
if (!hasText(current)) return fallback;
return current;
}

function buildMainSkillsMeta(nodes) {
if (mainSkillsMeta.ready) {
return mainSkillsMeta;
}
(nodes || []).forEach((icon) => {
const index = (icon.dataset.index || "").trim();
if (!index) return;
const name = (icon.dataset.nome || icon.dataset.name || "").trim();
const attrs = parseAttrString(icon.dataset.atr || "");
let iconFile = (icon.dataset.iconFile || "").trim();
if (!iconFile) {
const imgSrc = icon.querySelector("img")?.src || "";
const iconMatch = imgSrc.match(/(?:FilePath|images)\/([^\/?]+)$/);
iconFile = iconMatch ? decodeURIComponent(iconMatch[1]) : "";
}
let videoFile = (icon.dataset.videoFile || "").trim();
if (!videoFile) {
videoFile = extractFileNameFromURL(icon.dataset.video || "");
}
let flags = null;
if (icon.dataset.flags) {
try {
flags = JSON.parse(icon.dataset.flags);
if (!Array.isArray(flags) || flags.length === 0) flags = null;
} catch (e) { flags = null; }
}
const meta = {
index,
name,
icon: iconFile || "",
level: icon.dataset.level || "",
video: videoFile || "",
powerpve: attrs.powerpve || "",
powerpvp: attrs.powerpvp || "",
energy: attrs.energy || "",
cooldown: attrs.cooldown || "",
desc: icon.dataset.desc || "",
descPt: icon.dataset.descPt || "",
descEn: icon.dataset.descEn || "",
descEs: icon.dataset.descEs || "",
descPl: icon.dataset.descPl || "",
flags: flags || null,
};
mainSkillsMeta.byIndex.set(index, meta);
mainSkillsMeta.byIndex.set(parseInt(index, 10), meta);
if (name) {
mainSkillsMeta.byName.set(name, meta);
}
});
mainSkillsMeta.ready = true;
return mainSkillsMeta;
}

function rebuildMainSkillsMetaFromBar() {
const iconBar = document.querySelector(".icon-bar");
if (!iconBar) return;
mainSkillsMeta.ready = false;
mainSkillsMeta.byIndex.clear();
mainSkillsMeta.byName.clear();
buildMainSkillsMeta(
Array.from(iconBar.querySelectorAll(".skill-icon[data-index]"))
);
}

function inheritSubskillFromMain(sub, meta) {
if (!sub || !meta) return sub;
// Verifica se herança está desabilitada
const shouldInherit = !(
sub.inherit === false ||
sub.inherit === "no" ||
sub.inherit === "false"
);

// Suporta refS (novo) e refM (legado)
const refS = ((sub.refS || sub.S || sub.s || "") + "").trim();
const refIndex = ((sub.refM || sub.M || sub.m || "") + "").trim();
let name = (sub.name || sub.n || "").trim();
let main = null;

// Se herança está desabilitada, não busca a skill principal
if (!shouldInherit) {
return { ...sub };
}

// Primeiro tenta por refS
if (refS) {
main = meta.byIndex.get(refS) || meta.byIndex.get(parseInt(refS, 10));
}
// Depois por refM
if (!main && refIndex) {
main =
meta.byIndex.get(refIndex) ||
meta.byIndex.get(parseInt(refIndex, 10));
}
// Por último pelo nome
if (!main && name) {
main = meta.byName.get(name);
}
if (!main) {
return sub;
}

const hydrated = { ...sub };
if (!name && main.name) {
name = main.name;
}
hydrated.name = name || hydrated.name || main.name || "";
hydrated.icon = pickFilled(hydrated.icon, main.icon || "");
hydrated.level = pickFilled(hydrated.level, main.level || "");

// Vídeo NUNCA é herdado da skill principal
const hasOwnVideo = Object.prototype.hasOwnProperty.call(sub, "video");
hydrated.video = hasOwnVideo ? sub.video || "" : "";

hydrated.powerpve = pickFilled(hydrated.powerpve, main.powerpve || "");
hydrated.powerpvp = pickFilled(hydrated.powerpvp, main.powerpvp || "");
hydrated.energy = pickFilled(hydrated.energy, main.energy || "");
hydrated.cooldown = pickFilled(hydrated.cooldown, main.cooldown || "");

// Flags: herda da skill principal se a subskill não tiver
if (
(!hydrated.flags || !Array.isArray(hydrated.flags) || hydrated.flags.length === 0) &&
main.flags && Array.isArray(main.flags) && main.flags.length > 0
) {
hydrated.flags = main.flags;
}

// Descrição: sempre vem da subskill, nunca herda
// PROTEÇÃO TOTAL: Remove qualquer descrição que possa ter sido copiada do main
if (
!sub.desc &&
!sub.descPt &&
!sub.descEn &&
!sub.descEs &&
!sub.descPl &&
!sub.desc_i18n
) {
hydrated.desc = undefined;
hydrated.descPt = undefined;
hydrated.descEn = undefined;
hydrated.descEs = undefined;
hydrated.descPl = undefined;
hydrated.desc_i18n = undefined;
} else {
// Se subskill tem descrição, normaliza para desc_i18n
if (
!hydrated.desc_i18n &&
(hydrated.descPt ||
hydrated.descEn ||
hydrated.descEs ||
hydrated.descPl)
) {
hydrated.desc_i18n = {
pt: hydrated.descPt || "",
en: hydrated.descEn || "",
es: hydrated.descEs || "",
pl: hydrated.descPl || "",
};
}
}

return hydrated;
}

function inheritSubskillTree(subs, meta) {
if (!Array.isArray(subs)) return [];
return subs.map((sub) => {
const hydrated = inheritSubskillFromMain(sub, meta);
if (Array.isArray(hydrated.subs)) {
hydrated.subs = inheritSubskillTree(hydrated.subs, meta);
}
return hydrated;
});
}

function collectAssetsFromSubs(subs, iconsSet, videosSet, flagsSet) {
if (!Array.isArray(subs)) return;
subs.forEach((sub) => {
const iconURL = normalizeFileURL(sub.icon || "", "");
if (iconURL && iconURL !== "") iconsSet.add(iconURL);
// Vídeo normal
if (sub.video && sub.video.trim() !== "") {
const videoURL = normalizeFileURL(sub.video);
if (videoURL) videosSet.add(videoURL);
}
// Vídeo de weapon
if (
sub.weapon &&
typeof sub.weapon === "object" &&
sub.weapon.video &&
sub.weapon.video.trim() !== ""
) {
const weaponVideoURL = normalizeFileURL(sub.weapon.video);
if (weaponVideoURL) videosSet.add(weaponVideoURL);
}
if (Array.isArray(sub.flags)) {
sub.flags.forEach((flagKey) => {
const url = getFlagIconURL(flagKey);
if (url) flagsSet.add(url);
});
}
if (Array.isArray(sub.subs)) {
collectAssetsFromSubs(sub.subs, iconsSet, videosSet, flagsSet);
}
});
}
function buildAssetManifest() {
if (window.__skillAssetManifest && window.__skillAssetManifest.ready) {
return window.__skillAssetManifest;
}
const iconsSet = new Set();
const videosSet = new Set();
const flagsSet = new Set();
iconItems.forEach((el) => {
const img = el.querySelector("img");
if (img && img.src) {
iconsSet.add(img.src);
} else if (el.dataset.iconFile) {
const iconURL = normalizeFileURL(el.dataset.iconFile);
if (iconURL) iconsSet.add(iconURL);
}
// Vídeo normal da skill
const videoRaw = (
el.dataset.videoFile ||
el.dataset.video ||
""
).trim();
if (videoRaw) {
const videoURL = normalizeFileURL(videoRaw);
if (videoURL) videosSet.add(videoURL);
}
// Vídeo de weapon da skill
if (el.dataset.weapon) {
try {
const weaponData = JSON.parse(el.dataset.weapon);
if (
weaponData &&
weaponData.video &&
weaponData.video.trim() !== ""
) {
const weaponVideoURL = normalizeFileURL(weaponData.video);
if (weaponVideoURL) videosSet.add(weaponVideoURL);
}
} catch (e) { }
}
if (el.dataset.flags) {
try {
const parsedFlags = JSON.parse(el.dataset.flags);
(parsedFlags || []).forEach((flagKey) => {
const url = getFlagIconURL(flagKey);
if (url) flagsSet.add(url);
});
} catch (e) { }
}
if (el.dataset.subs) {
try {
const subs = JSON.parse(el.dataset.subs);
collectAssetsFromSubs(subs, iconsSet, videosSet, flagsSet);
} catch (e) { }
}
});
Object.keys(FLAG_ICON_FILES).forEach((flagKey) => {
const url = getFlagIconURL(flagKey);
if (url) flagsSet.add(url);
});
const manifest = {
icons: iconsSet,
videos: videosSet,
flags: flagsSet,
ready: true,
};
window.__skillAssetManifest = manifest;
return manifest;
}
const subskillVideosCache = new Map();
window.__subskillVideosCache = subskillVideosCache;

// Cache de vídeos que falharam (404) para evitar tentativas repetidas
const failedVideosCache = new Set();
const missingVideosReported = new Set(); // Para avisar apenas uma vez sobre vídeos faltantes

// Cache de parsing JSON para evitar re-parsear os mesmos dados
const jsonParseCache = new WeakMap();
function getCachedJSON(el, key) {
if (!el) return null;
const cache = jsonParseCache.get(el) || {};
if (cache[key] !== undefined) return cache[key];
const raw = el.dataset[key] || el.getAttribute(`data-${key}`);
if (!raw) {
cache[key] = null;
jsonParseCache.set(el, cache);
return null;
}
try {
const parsed = JSON.parse(raw);
cache[key] = parsed;
jsonParseCache.set(el, cache);
return parsed;
} catch (e) {
cache[key] = null;
jsonParseCache.set(el, cache);
return null;
}
}

let assetManifest = null;
const skillsTab = $("#skills");
const skinsTab = $("#skins");
ensureRemoved(".top-rail");
// NÃO remove .content-card aqui - será gerenciado abaixo
// ensureRemoved('.content-card'); // REMOVIDO - pode estar removendo skills-container
ensureRemoved(".video-placeholder");
Array.from(
document.querySelectorAll(
".card-skins-title, .card-skins .card-skins-title, .cardskins-title, .rail-title"
)
).forEach((t) => {
if ((t.textContent || "").trim().toLowerCase().includes("skins")) {
t.remove();
}
});
if (skillsTab) {
const iconBar = skillsTab.querySelector(".icon-bar");
if (iconBar) {
const rail = document.createElement("div");
rail.className = "top-rail skills";
// Criar wrapper de scroll para permitir glow sem clipping
if (
!iconBar.parentElement ||
!iconBar.parentElement.classList.contains("icon-scroll-x")
) {
const scrollWrapper = document.createElement("div");
scrollWrapper.className = "icon-scroll-x";
scrollWrapper.appendChild(iconBar);
rail.appendChild(scrollWrapper);
} else {
rail.appendChild(iconBar.parentElement);
}
skillsTab.prepend(rail);
}

// Busca skills-container criado pelo Lua
const skillsContainer = skillsTab.querySelector(".skills-container");

// Busca skills-details e video-container (podem estar dentro de skills-container ou soltos)
let details = skillsTab.querySelector(".skills-details");
if (!details && skillsContainer) {
details = skillsContainer.querySelector(".skills-details");
}
if (!details) {
details = document.createElement("div");
details.className = "skills-details";
}

// Busca ou cria desc-box dentro de details
let descBoxEl = details.querySelector(".desc-box");
if (!descBoxEl) {
descBoxEl = document.createElement("div");
descBoxEl.className = "desc-box";
details.appendChild(descBoxEl);
}

// Busca video-container
let videoContainer = skillsTab.querySelector(".video-container");
if (!videoContainer && skillsContainer) {
videoContainer = skillsContainer.querySelector(".video-container");
}
if (!videoContainer) {
videoContainer = document.createElement("div");
videoContainer.className = "video-container";
}

// Cria ou atualiza content-card skills-grid (estrutura esperada pelo CSS)
let card = skillsTab.querySelector(".content-card.skills-grid");
if (!card) {
card = document.createElement("div");
card.className = "content-card skills-grid";
skillsTab.appendChild(card);
}

// Move details e videoContainer para dentro do card (estrutura correta)
// Remove skills-container se existir (não é necessário para o layout)
if (skillsContainer && skillsContainer.parentNode) {
// Move os elementos filhos de skills-container para o card
if (details.parentNode === skillsContainer) {
skillsContainer.removeChild(details);
}
if (videoContainer.parentNode === skillsContainer) {
skillsContainer.removeChild(videoContainer);
}
// Remove skills-container se estiver vazio
if (skillsContainer.children.length === 0) {
skillsContainer.remove();
}
}

// Garante que details e videoContainer estão no card na ordem correta
// skills-details deve vir ANTES de video-container para o grid funcionar
if (details.parentNode !== card) {
// Se videoContainer já está no card, insere details antes dele
if (videoContainer.parentNode === card) {
card.insertBefore(details, videoContainer);
} else {
card.appendChild(details);
}
}
if (videoContainer.parentNode !== card) {
card.appendChild(videoContainer);
}

// Garante ordem: details primeiro, videoContainer depois
if (details.parentNode === card && videoContainer.parentNode === card) {
if (details.nextSibling !== videoContainer) {
card.insertBefore(details, videoContainer);
}
}
}
// Função para obter iconsBar de forma segura (com retry)
function getIconsBar() {
const skillsEl = document.getElementById("skills");
if (!skillsEl) return null;
return skillsEl.querySelector(".icon-bar");
}
const iconsBar = getIconsBar();
const skillsTopRail = iconsBar
? iconsBar.closest(".top-rail.skills")
: null;
const iconItems = iconsBar
? Array.from(iconsBar.querySelectorAll(".skill-icon"))
: [];
buildMainSkillsMeta(iconItems);
// Verifica se há weapon em skills principais OU em subskills
function checkHasAnyWeapon() {
// Verifica skills principais
const hasMainWeapon = iconItems.some((el) => {
const weapon = el.dataset.weapon;
return weapon && weapon.trim() !== "" && weapon !== "{}";
});
if (hasMainWeapon) {
return true;
}
// Verifica subskills
for (const el of iconItems) {
const subsRaw = el.getAttribute("data-subs");
if (!subsRaw) continue;
try {
const subs = JSON.parse(subsRaw);
if (
Array.isArray(subs) &&
subs.some(
(s) =>
s &&
s.weapon &&
typeof s.weapon === "object" &&
Object.keys(s.weapon).length > 0
)
) {
return true;
}
} catch (e) { }
}
return false;
}
const hasWeaponSkillAvailable = checkHasAnyWeapon();
let weaponToggleBtn = null;
if (!assetManifest) {
assetManifest = buildAssetManifest();
// Pré-carrega apenas ícones e flags críticos
if (assetManifest.icons && assetManifest.icons.size) {
assetManifest.icons.forEach((url) => {
if (!url || imagePreloadCache.has(url)) return;
const img = new Image();
img.decoding = "async";
img.loading = "eager";
img.referrerPolicy = "same-origin";
img.src = url;
imagePreloadCache.set(url, img);
});
}
if (assetManifest.flags && assetManifest.flags.size) {
assetManifest.flags.forEach((url) => {
if (!url || imagePreloadCache.has(url)) return;
const img = new Image();
img.decoding = "async";
img.loading = "eager";
img.referrerPolicy = "same-origin";
img.src = url;
imagePreloadCache.set(url, img);
});
}
}
// Busca descBox e videoBox após a estrutura estar organizada
const descBox = $("#skills") ? $(".desc-box", $("#skills")) : null;
let videoBox = $("#skills") ? $(".video-container", $("#skills")) : null;
// Busca dinâmica do videoBox (pode não existir no momento da inicialização)
function getVideoBox() {
if (videoBox && videoBox.isConnected) return videoBox;
const skillsRoot = document.getElementById("skills");
if (!skillsRoot) return null;
videoBox = skillsRoot.querySelector(".video-container") ||
skillsRoot.querySelector(".skills-container .video-container") ||
skillsRoot.querySelector(".content-card .video-container");
return videoBox;
}
const videosCache = new Map();
const nestedVideoElByIcon = new WeakMap();
const barStack = [];
window.__barStack = barStack;
let initialBarSnapshot = null;
let totalVideos = 0,
loadedVideos = 0,
autoplay = false;
window.__lastActiveSkillIcon = null;
let userHasInteracted = false;
let globalWeaponEnabled = false;
try {
if (localStorage.getItem("glaWeaponEnabled") === "1") {
globalWeaponEnabled = true;
}
} catch (err) { }
const weaponStateListeners = new Set();
let showWeaponPopupFn = null;
let popupShouldOpen = false;
function attachWeaponPopupFn(fn) {
if (typeof fn !== "function") return;
showWeaponPopupFn = fn;
if (popupShouldOpen) {
popupShouldOpen = false;
try {
showWeaponPopupFn();
} catch (err) { }
}
}
attachWeaponPopupFn(window.__glaWeaponShowPopup);
function requestWeaponPopupDisplay() {
try {
if (localStorage.getItem("glaWeaponPopupDismissed") === "1") return;
} catch (err) { }
if (typeof showWeaponPopupFn === "function") {
showWeaponPopupFn();
return;
}
popupShouldOpen = true;
}
function onWeaponStateChange(fn) {
if (typeof fn !== "function") return;
weaponStateListeners.add(fn);
}
function syncWeaponButtonState(enabled) {
if (!weaponToggleBtn || !weaponToggleBtn.isConnected) return;
// Usa .weapon-active em vez de .active para não conflitar com skills
weaponToggleBtn.classList.toggle("weapon-active", !!enabled);
weaponToggleBtn.classList.remove("active"); // Garante que .active nunca seja aplicado
weaponToggleBtn.setAttribute("aria-pressed", enabled ? "true" : "false");
weaponToggleBtn.setAttribute(
"aria-label",
enabled ? "Desativar Arma Especial" : "Ativar Arma Especial"
);
}
function syncWeaponRailState(enabled) {
if (skillsTopRail) {
skillsTopRail.classList.toggle("weapon-mode-on", !!enabled);
}
}
function notifyWeaponStateListeners(enabled) {
weaponStateListeners.forEach((listener) => {
try {
listener(enabled);
} catch (err) { }
});
}
let pendingWeaponState = null;
window.addEventListener("weapon:ready", (ev) => {
if (ev && ev.detail && ev.detail.showPopup) {
attachWeaponPopupFn(ev.detail.showPopup);
}
if (pendingWeaponState === null) return;
if (typeof window.__applyWeaponState === "function") {
const target = pendingWeaponState;
pendingWeaponState = null;
window.__applyWeaponState(target);
}
});
window.__setGlobalWeaponEnabled = (enabled) => {
globalWeaponEnabled = enabled;
notifyWeaponStateListeners(enabled);
};
function requestWeaponState(targetState) {
if (typeof window.__applyWeaponState === "function") {
pendingWeaponState = null;
window.__applyWeaponState(targetState);
return;
}
pendingWeaponState = targetState;
}
onWeaponStateChange(syncWeaponButtonState);
function reapplyWeaponClassesToBar() {
// SISTEMA UNIFICADO: Aplica em skills E subskills (sempre, não só quando weapon está ativo)
// Obtém iconsBar dinamicamente (pode não estar pronto ainda quando há flags)
const currentIconsBar = getIconsBar();
if (!currentIconsBar) {
return;
}
// Busca em skills principais (dentro de iconsBar)
currentIconsBar
.querySelectorAll(".skill-icon[data-weapon]")
.forEach((el) => {
const weapon = el.dataset.weapon;
if (weapon && weapon.trim() !== "" && weapon !== "{}") {
try {
const weaponObj = JSON.parse(weapon);
if (
weaponObj &&
typeof weaponObj === "object" &&
Object.keys(weaponObj).length > 0
) {
if (!el.classList.contains("has-weapon-available")) {
el.classList.add("has-weapon-available");
}
if (!el.querySelector(".weapon-indicator")) {
const ind = document.createElement("div");
ind.className = "weapon-indicator";
el.appendChild(ind);
}
}
} catch (e) {
// Se não for JSON válido, não adiciona a classe
}
}
});
// Busca em subskills (dentro de subskills-rail)
document
.querySelectorAll(".subskills-rail .subicon[data-weapon]")
.forEach((el) => {
const weapon = el.dataset.weapon;
if (weapon && weapon.trim() !== "" && weapon !== "{}") {
try {
const weaponObj = JSON.parse(weapon);
if (
weaponObj &&
typeof weaponObj === "object" &&
Object.keys(weaponObj).length > 0
) {
if (!el.classList.contains("has-weapon-available")) {
el.classList.add("has-weapon-available");
}
}
} catch (e) {
// Se não for JSON válido, não adiciona a classe
}
}
});
}
// Aplica classes de weapon imediatamente ao carregar
reapplyWeaponClassesToBar();
// REMOVIDO: setupWeaponBarToggle - O toggle de weapon agora é criado apenas pelo C.WeaponToggle.html no header
// Não cria mais botão na barra de skills - apenas aplica classes visuais
onWeaponStateChange(syncWeaponRailState);
// Reaplica classes quando o estado do weapon muda (para garantir que funcione mesmo quando toggle é ativado fora da barra)
onWeaponStateChange(() => {
// Usa setTimeout para garantir que o DOM foi atualizado
setTimeout(() => {
reapplyWeaponClassesToBar();
}, 50);
});
syncWeaponRailState(globalWeaponEnabled);
(function injectWeaponStyles() {
if (document.getElementById("weapon-toggle-styles")) return;
const style = document.createElement("style");
style.id = "weapon-toggle-styles";
style.textContent = `
/* ========== ESTILOS DE WEAPON - NOVO SISTEMA ========== */

/* Animação simples para borda */
@keyframes weapon-border-flow {
0% { background-position: 0% 0%; }
100% { background-position: 200% 0%; }
}

/* Animação sutil para brilho */
@keyframes weapon-glow-breathe {
0%, 100% { opacity: 0.7; }
50% { opacity: 1; }
}

/* Animação do gradiente (sem girar a borda) */
@property --effect-spin {
syntax: "<angle>";
inherits: false;
initial-value: 0deg;
}
@keyframes effect-border-spin {
from { --effect-spin: 0deg; }
to { --effect-spin: 360deg; }
}

/* ===== ÍCONE COM ARMA - Só mostra efeitos quando weapon-mode-on está ativo ===== */
/* Quando NÃO está em weapon-mode-on, os ícones com arma devem ser normais (mesma borda padrão) */
.character-box .top-rail.skills .icon-bar .skill-icon.has-weapon-available:not(.weapon-bar-toggle) {
/* Remove borda sólida base que aparece na transição do toggle */
border-color: transparent !important;
box-shadow: none !important;
}
.character-box .top-rail.skills:not(.weapon-mode-on) .icon-bar .skill-icon.has-weapon-available:not(.weapon-bar-toggle) {
/* Remove transform scale quando toggle está desativado */
transform: none !important;
transition: transform 0.15s ease !important;
}
.character-box .top-rail.skills:not(.weapon-mode-on) .icon-bar .skill-icon.has-weapon-available:not(.weapon-bar-toggle)::after {
/* Reseta COMPLETAMENTE para borda padrão quando toggle está desativado */
/* Remove background, padding e mask INSTANTANEAMENTE (sem transição) */
background: none !important;
background-size: unset !important;
padding: 0 !important;
-webkit-mask: none !important;
mask: none !important;
mask-composite: unset !important;
-webkit-mask-composite: unset !important;
animation: none !important;
/* Apenas box-shadow tem transição suave */
box-shadow: inset 0 0 0 var(--icon-ring-w) var(--icon-idle) !important;
/* SEM transição no background/padding/mask para evitar "flash" durante a mudança */
transition: box-shadow 0.15s ease !important;
}
.character-box .top-rail.skills:not(.weapon-mode-on) .icon-bar .skill-icon.has-weapon-available:not(.weapon-bar-toggle)::before {
/* Remove efeitos de glow quando toggle está desativado - com transição suave */
opacity: 0 !important;
transition: opacity 0.15s ease !important;
}
/* Quando ativo mas toggle desativado, usa borda padrão de ativo */
.character-box .top-rail.skills:not(.weapon-mode-on) .icon-bar .skill-icon.has-weapon-available:not(.weapon-bar-toggle).active {
/* Mantém o zoom padrão mesmo quando toggle está desativado */
transform: scale(1.10) translateZ(0) !important;
transition: transform 0.15s ease !important;
}
.character-box .top-rail.skills:not(.weapon-mode-on) .icon-bar .skill-icon.has-weapon-available:not(.weapon-bar-toggle).active::after {
/* Reseta COMPLETAMENTE para borda padrão de ativo */
/* Remove background, padding e mask INSTANTANEAMENTE (sem transição) */
background: none !important;
background-size: unset !important;
padding: 0 !important;
-webkit-mask: none !important;
mask: none !important;
mask-composite: unset !important;
-webkit-mask-composite: unset !important;
animation: none !important;
/* Apenas box-shadow tem transição suave */
box-shadow: inset 0 0 0 var(--icon-ring-w) var(--icon-active) !important;
/* SEM transição no background/padding/mask para evitar "flash" durante a mudança */
transition: box-shadow 0.15s ease !important;
}
.character-box .top-rail.skills:not(.weapon-mode-on) .icon-bar .skill-icon.has-weapon-available:not(.weapon-bar-toggle).active::before {
/* Sem glow amarelo no modo normal para skills com weapon */
opacity: 0 !important;
box-shadow: none !important;
transition: opacity 0.15s ease !important;
}

/* ===== MODO WEAPON ON - INATIVO ===== */
.character-box .top-rail.skills.weapon-mode-on .icon-bar .skill-icon.has-weapon-available:not(.weapon-bar-toggle):not(.active)::after {
pointer-events: none !important;
box-shadow: none !important;
background: linear-gradient(90deg,
#FF3333 0%,
#FF0000 50%,
#FF3333 100%) !important;
background-size: 200% 100% !important;
animation: weapon-border-flow 3s linear infinite !important;
-webkit-mask: linear-gradient(#fff 0 0) content-box, linear-gradient(#fff 0 0) !important;
mask: linear-gradient(#fff 0 0) content-box, linear-gradient(#fff 0 0) !important;
-webkit-mask-composite: xor !important;
mask-composite: exclude !important;
padding: 2px !important;
/* SEM transição para permitir remoção instantânea quando toggle é desativado */
transition: none !important;
}

.character-box .top-rail.skills.weapon-mode-on .icon-bar .skill-icon.has-weapon-available:not(.weapon-bar-toggle):not(.active)::before {
pointer-events: none !important;
inset: 0 !important;
border-radius: inherit !important;
z-index: 1 !important;
animation: weapon-glow-breathe 2s ease-in-out infinite !important;
box-shadow:
0 0 8px 0 rgba(255, 0, 0, 0.4),
0 0 12px 0 rgba(255, 51, 51, 0.3),
0 0 16px 0 rgba(255, 0, 0, 0.2) !important;
opacity: 1 !important;
}

/* ===== MODO WEAPON ON - ATIVO ===== */
.character-box .top-rail.skills.weapon-mode-on .icon-bar .skill-icon.has-weapon-available:not(.weapon-bar-toggle).active {
transform: scale(1.10) !important;
z-index: 5 !important;
}

.character-box .top-rail.skills.weapon-mode-on .icon-bar .skill-icon.has-weapon-available:not(.weapon-bar-toggle).active::after {
pointer-events: none !important;
box-shadow: none !important;
background: linear-gradient(90deg,
#FFEB3B 0%,
#FFD700 50%,
#FFEB3B 100%) !important;
background-size: 200% 100% !important;
animation: weapon-border-flow 2s linear infinite !important;
-webkit-mask: linear-gradient(#fff 0 0) content-box, linear-gradient(#fff 0 0) !important;
mask: linear-gradient(#fff 0 0) content-box, linear-gradient(#fff 0 0) !important;
-webkit-mask-composite: xor !important;
mask-composite: exclude !important;
padding: 2px !important;
/* SEM transição para permitir remoção instantânea quando toggle é desativado */
transition: none !important;
}

.character-box .top-rail.skills.weapon-mode-on .icon-bar .skill-icon.has-weapon-available:not(.weapon-bar-toggle).active::before {
pointer-events: none !important;
inset: 0 !important;
border-radius: inherit !important;
z-index: 1 !important;
animation: weapon-glow-breathe 1.5s ease-in-out infinite !important;
box-shadow:
0 0 10px 0 rgba(255, 215, 0, 0.5),
0 0 16px 0 rgba(255, 235, 59, 0.4),
0 0 22px 0 rgba(255, 215, 0, 0.3) !important;
opacity: 1 !important;
}

.character-box .top-rail.skills .icon-bar {
position: relative;
}
.character-box .top-rail.skills .icon-bar .skill-icon {
z-index: 2;
}
.character-box .top-rail.skills .icon-bar .skill-icon.effect-active:not(.weapon-bar-toggle):not(.active) {
border-color: transparent !important;
outline: 2px solid rgba(210, 60, 60, 0.95) !important;
outline-offset: -2px;
animation: effect-child-outline 1.6s ease-in-out infinite !important;
}
.character-box .top-rail.skills .icon-bar .skill-icon.effect-active:not(.weapon-bar-toggle):not(.active)::after {
box-shadow:
inset 0 0 0 var(--icon-ring-w) rgba(210, 60, 60, 0.95),
0 0 6px rgba(255, 60, 60, 0.45),
0 0 10px rgba(120, 20, 20, 0.6) !important;
animation: effect-child-ring 1.6s ease-in-out infinite !important;
opacity: 1 !important;
}
.character-box .top-rail.skills .icon-bar .skill-icon.effect-active:not(.weapon-bar-toggle):not(.active)::before {
inset: 0 !important;
border-radius: inherit !important;
z-index: 1 !important;
opacity: 1 !important;
box-shadow:
0 0 8px rgba(255, 60, 60, 0.35),
0 0 14px rgba(120, 20, 20, 0.45);
animation: effect-child-glow 1.6s ease-in-out infinite !important;
}
.character-box .top-rail.skills.effect-mode-on .icon-bar .skill-icon.effect-active:not(.weapon-bar-toggle):not(.active)::after {
box-shadow:
inset 0 0 0 var(--icon-ring-w) rgba(210, 60, 60, 0.95),
0 0 6px rgba(255, 60, 60, 0.45),
0 0 10px rgba(120, 20, 20, 0.6) !important;
animation: effect-child-ring 1.6s ease-in-out infinite !important;
opacity: 1 !important;
}
.character-box .top-rail.skills.effect-mode-on .icon-bar .skill-icon.effect-active:not(.weapon-bar-toggle):not(.active)::before {
inset: 0 !important;
border-radius: inherit !important;
z-index: 1 !important;
opacity: 1 !important;
box-shadow:
0 0 8px rgba(255, 60, 60, 0.35),
0 0 14px rgba(120, 20, 20, 0.45);
animation: effect-child-glow 1.6s ease-in-out infinite !important;
}
@keyframes effect-child-ring {
0% {
box-shadow:
inset 0 0 0 var(--icon-ring-w) rgba(210, 60, 60, 0.95),
0 0 6px rgba(255, 60, 60, 0.45),
0 0 10px rgba(120, 20, 20, 0.6);
}
50% {
box-shadow:
inset 0 0 0 var(--icon-ring-w) rgba(120, 20, 20, 0.95),
0 0 9px rgba(255, 70, 70, 0.65),
0 0 14px rgba(20, 0, 0, 0.8);
}
100% {
box-shadow:
inset 0 0 0 var(--icon-ring-w) rgba(210, 60, 60, 0.95),
0 0 6px rgba(255, 60, 60, 0.45),
0 0 10px rgba(120, 20, 20, 0.6);
}
}
@keyframes effect-child-outline {
0% {
outline-color: rgba(210, 60, 60, 0.95);
}
50% {
outline-color: rgba(120, 20, 20, 0.95);
}
100% {
outline-color: rgba(210, 60, 60, 0.95);
}
}
@keyframes effect-child-glow {
0% {
box-shadow:
0 0 8px rgba(255, 60, 60, 0.35),
0 0 14px rgba(120, 20, 20, 0.45);
}
50% {
box-shadow:
0 0 12px rgba(255, 70, 70, 0.55),
0 0 18px rgba(20, 0, 0, 0.75);
}
100% {
box-shadow:
0 0 8px rgba(255, 60, 60, 0.35),
0 0 14px rgba(120, 20, 20, 0.45);
}
}
.character-box .top-rail.skills .effect-lines-layer {
position: absolute;
left: 0;
top: 0;
width: 100%;
height: 100%;
pointer-events: none;
z-index: 0;
overflow: visible;
}
.character-box .top-rail.skills .effect-lines-layer .effect-line {
fill: none;
stroke-linecap: round;
stroke-linejoin: round;
}
.character-box .top-rail.skills .effect-lines-layer .effect-line-glow {
stroke: rgba(120, 20, 20, 0.7);
stroke-width: 5;
filter: drop-shadow(0 0 6px rgba(255, 60, 60, 0.45));
animation: none;
}
.character-box .top-rail.skills .effect-lines-layer .effect-line-core {
stroke: rgba(210, 60, 60, 0.95);
stroke-width: 2.2;
animation: none;
}
.character-box .top-rail.skills .effect-lines-layer .effect-line.effect-line-returning {
animation: effect-line-return var(--effect-return-duration, 1.1s) ease forwards;
animation-delay: var(--effect-return-delay, 0s);
}
@keyframes effect-line-pulse {
0% {
stroke: rgba(210, 60, 60, 0.95);
stroke-width: 2.1;
}
50% {
stroke: rgba(120, 20, 20, 0.95);
stroke-width: 2.7;
}
100% {
stroke: rgba(220, 70, 70, 0.95);
stroke-width: 2.1;
}
}
@keyframes effect-line-glow {
0% {
stroke: rgba(140, 25, 25, 0.65);
filter: drop-shadow(0 0 5px rgba(255, 80, 80, 0.35));
}
50% {
stroke: rgba(20, 0, 0, 0.85);
filter: drop-shadow(0 0 9px rgba(255, 70, 70, 0.65));
}
100% {
stroke: rgba(140, 25, 25, 0.65);
filter: drop-shadow(0 0 5px rgba(255, 80, 80, 0.35));
}
}
@keyframes effect-line-return {
0% {
stroke-dasharray: var(--effect-line-length, 0) var(--effect-line-length, 0);
stroke-dashoffset: 0;
opacity: 1;
}
100% {
stroke-dasharray: 0 var(--effect-line-length, 0);
stroke-dashoffset: calc(var(--effect-line-length, 0) * -1);
opacity: 0;
}
}
@media (prefers-reduced-motion: reduce) {
.character-box .top-rail.skills .effect-lines-layer .effect-line {
animation: none;
}
}

.character-box .top-rail.skills.effect-mode-on .icon-bar .skill-icon.effect-active:not(.weapon-bar-toggle).active::before {
pointer-events: none !important;
inset: 0 !important;
border-radius: inherit !important;
z-index: 1 !important;
animation: weapon-glow-breathe 1.4s ease-in-out infinite !important;
box-shadow:
0 0 10px 0 rgba(220, 220, 220, 0.5),
0 0 16px 0 rgba(190, 190, 190, 0.4),
0 0 22px 0 rgba(220, 220, 220, 0.3) !important;
opacity: 1 !important;
}

/* ========== ESTILOS DE SWAP DE PERSONAGENS (Sistema Genérico) ========== */
/* Skills desabilitadas quando o personagem ativo não pode usá-las */
.character-box .top-rail.skills .icon-bar .skill-icon.disabled-skill {
opacity: 0.3 !important;
filter: grayscale(100%) !important;
cursor: not-allowed !important;
pointer-events: none !important;
transition: opacity 0.2s ease, filter 0.2s ease !important;
}
`;
document.head.appendChild(style);
})();
function applyWeaponBadge(el, weaponData, equipped) {
// Apenas gerencia a classe weapon-equipped (badge visual removido)
if (equipped && weaponData) {
el.classList.add("weapon-equipped");
} else {
el.classList.remove("weapon-equipped");
}
}
function getWeaponKey(el) {
return (
(el.dataset.index || "") +
":" +
(el.dataset.nome || el.dataset.name || "")
);
}
function isWeaponModeOn() {
try {
return localStorage.getItem("glaWeaponEnabled") === "1";
} catch (e) {
return false;
}
}
function getWeaponDataForIcon(iconEl) {
if (!iconEl || !iconEl.dataset.weapon) return null;
// Usa cache de parsing JSON
return getCachedJSON(iconEl, "weapon");
}
const effectState = {
skills: new Set(),
videos: new Map(),
expiresAt: 0,
sourceIcon: null,
timer: null,
};
let effectLinesLayer = null;
let effectLinesRAF = null;
let effectLinesCleanupTimer = null;
let effectLinesScrollWrap = null;
let effectLinesBound = false;
let effectLinesLastState = null;
function getSkillNameFromIcon(iconEl) {
return (iconEl?.dataset?.nome || iconEl?.dataset?.name || "").trim();
}
function getEffectVideoKey(iconEl, videoValue) {
if (!iconEl) return "";
const baseIndex = iconEl.dataset.index || "";
const subName =
iconEl.dataset.subName ||
iconEl.dataset.nome ||
iconEl.dataset.name ||
"";
const namePart = baseIndex || subName || "";
const videoPart = String(videoValue || "").trim();
if (!namePart || !videoPart) return "";
return `effect:${namePart}:${videoPart}`;
}
function normalizeEffectData(raw) {
if (!raw || typeof raw !== "object") return null;
const rawSkills = raw.skills;
const timeValue = Number(raw.time ?? raw.duration ?? 0);
const timeMs = Number.isFinite(timeValue) ? timeValue * 1000 : 0;
if (!timeMs || timeMs <= 0) return null;
const skills = Array.isArray(rawSkills)
? rawSkills.map((s) => String(s || "").trim()).filter(Boolean)
: [];
if (!skills.length) return null;
const videos = new Map();
if (raw.videos && typeof raw.videos === "object") {
Object.keys(raw.videos).forEach((k) => {
const key = String(k || "").trim();
const val = String(raw.videos[k] || "").trim();
if (key && val) videos.set(key, val);
});
}
return { skills, timeMs, videos };
}
function handleEffectLinesScroll() {
scheduleEffectLinesUpdate();
}
function bindEffectLinesEvents() {
if (!effectLinesBound) {
window.addEventListener("resize", scheduleEffectLinesUpdate);
window.addEventListener("scroll", scheduleEffectLinesUpdate, {
passive: true,
});
effectLinesBound = true;
}
const rail = document.querySelector(".top-rail.skills");
const scrollWrap = rail ? rail.querySelector(".icon-scroll-x") : null;
if (scrollWrap && scrollWrap !== effectLinesScrollWrap) {
if (effectLinesScrollWrap) {
effectLinesScrollWrap.removeEventListener(
"scroll",
handleEffectLinesScroll
);
}
scrollWrap.addEventListener("scroll", handleEffectLinesScroll, {
passive: true,
});
effectLinesScrollWrap = scrollWrap;
}
}
function scheduleEffectLinesUpdate() {
if (effectLinesRAF) return;
effectLinesRAF = requestAnimationFrame(() => {
effectLinesRAF = null;
updateEffectLines();
});
}
function getEffectLinesLayer() {
const rail = document.querySelector(".top-rail.skills");
if (!rail) return null;
const iconBar = rail.querySelector(".icon-bar");
if (!iconBar) return null;
if (effectLinesLayer && effectLinesLayer.isConnected) {
return effectLinesLayer;
}
const existing = iconBar.querySelector(".effect-lines-layer");
if (existing) {
effectLinesLayer = existing;
return effectLinesLayer;
}
const svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
svg.classList.add("effect-lines-layer");
svg.setAttribute("aria-hidden", "true");
iconBar.insertBefore(svg, iconBar.firstChild);
effectLinesLayer = svg;
return effectLinesLayer;
}
function updateEffectLines() {
if (!effectState.sourceIcon || !effectState.sourceIcon.isConnected) {
clearEffectLines();
return;
}
if (effectState.expiresAt <= Date.now()) {
clearEffectLines();
return;
}
const layer = getEffectLinesLayer();
if (!layer) return;
const rail = layer.closest(".top-rail.skills");
if (!rail) return;
const iconBar = rail.querySelector(".icon-bar");
if (!iconBar) return;

bindEffectLinesEvents();

const barRect = iconBar.getBoundingClientRect();
const width = Math.max(1, Math.round(iconBar.scrollWidth || barRect.width));
const height = Math.max(1, Math.round(iconBar.clientHeight || barRect.height));
layer.style.left = "0px";
layer.style.top = "0px";
layer.setAttribute("width", String(width));
layer.setAttribute("height", String(height));
layer.setAttribute("viewBox", `0 0 ${width} ${height}`);
layer.classList.remove("effect-lines-returning");

const srcRect = effectState.sourceIcon.getBoundingClientRect();
const startX =
srcRect.left + srcRect.width / 2 - barRect.left + iconBar.scrollLeft;
const startY = srcRect.top + srcRect.height / 2 - barRect.top;

const allIcons = Array.from(
document.querySelectorAll(".icon-bar .skill-icon[data-index]")
).filter((icon) => !icon.classList.contains("weapon-bar-toggle"));
const targets = allIcons.filter((icon) => {
if (icon === effectState.sourceIcon) return false;
const name = getSkillNameFromIcon(icon);
return name && effectState.skills.has(name);
});

if (!targets.length) {
clearEffectLines();
return;
}

const frag = document.createDocumentFragment();
const baselinePadding = 10;
const baselineExtra = 12;
const baselineY = Math.max(
startY,
height - baselinePadding + baselineExtra
);
const targetPoints = targets.map((target) => {
const tgtRect = target.getBoundingClientRect();
const endX =
tgtRect.left + tgtRect.width / 2 - barRect.left + iconBar.scrollLeft;
const endY = tgtRect.top + tgtRect.height / 2 - barRect.top;
return { x: endX, y: endY };
});
const xs = targetPoints.map((p) => p.x);
const minX = Math.min(startX, ...xs);
const maxX = Math.max(startX, ...xs);
effectLinesLastState = {
startX,
startY,
baselineY,
targets: targetPoints.map((p) => ({
x: p.x,
y: p.y,
dist: Math.hypot(p.x - startX, p.y - startY),
})),
};
const dParts = [
`M ${startX} ${startY}`,
`L ${startX} ${baselineY}`,
`L ${minX} ${baselineY}`,
`L ${maxX} ${baselineY}`,
];
targetPoints.forEach((p) => {
dParts.push(`M ${p.x} ${baselineY} L ${p.x} ${p.y}`);
});
const d = dParts.join(" ");

const glow = document.createElementNS(
"http://www.w3.org/2000/svg",
"path"
);
glow.setAttribute("d", d);
glow.classList.add("effect-line", "effect-line-glow");

const core = document.createElementNS(
"http://www.w3.org/2000/svg",
"path"
);
core.setAttribute("d", d);
core.classList.add("effect-line", "effect-line-core");

frag.appendChild(glow);
frag.appendChild(core);

requestAnimationFrame(() => {
const length = Math.max(1, Math.round(core.getTotalLength()));
[core, glow].forEach((path) => {
path.style.setProperty("--effect-line-length", `${length}`);
path.style.strokeDasharray = `${length}`;
path.style.strokeDashoffset = "0";
});
});
layer.replaceChildren(frag);
}
function animateEffectLinesReturn() {
const layer =
(effectLinesLayer && effectLinesLayer.isConnected
? effectLinesLayer
: document.querySelector(".effect-lines-layer")) || null;
if (!layer || !effectLinesLastState) {
clearEffectLines();
return;
}
const { startX, startY, baselineY, targets } = effectLinesLastState;
const sortedTargets = [...targets].sort((a, b) => b.dist - a.dist);
const returnDuration = 1.1;
const returnStagger = 0.22;
const frag = document.createDocumentFragment();
sortedTargets.forEach((target, idx) => {
const d = [
`M ${startX} ${startY}`,
`L ${startX} ${baselineY}`,
`L ${target.x} ${baselineY}`,
`L ${target.x} ${target.y}`,
].join(" ");

const glow = document.createElementNS(
"http://www.w3.org/2000/svg",
"path"
);
glow.setAttribute("d", d);
glow.classList.add(
"effect-line",
"effect-line-glow",
"effect-line-returning"
);
glow.style.setProperty("--effect-return-duration", `${returnDuration}s`);
glow.style.setProperty("--effect-return-delay", `${idx * returnStagger}s`);

const core = document.createElementNS(
"http://www.w3.org/2000/svg",
"path"
);
core.setAttribute("d", d);
core.classList.add(
"effect-line",
"effect-line-core",
"effect-line-returning"
);
core.style.setProperty("--effect-return-duration", `${returnDuration}s`);
core.style.setProperty("--effect-return-delay", `${idx * returnStagger}s`);

frag.appendChild(glow);
frag.appendChild(core);
});
layer.replaceChildren(frag);

requestAnimationFrame(() => {
const paths = Array.from(layer.querySelectorAll("path.effect-line"));
paths.forEach((path) => {
const length = Math.max(1, Math.round(path.getTotalLength()));
path.style.setProperty("--effect-line-length", `${length}`);
path.style.strokeDasharray = `${length} ${length}`;
path.style.strokeDashoffset = "0";
});
});
if (effectLinesCleanupTimer) {
clearTimeout(effectLinesCleanupTimer);
}
effectLinesCleanupTimer = setTimeout(() => {
clearEffectLines();
}, (returnDuration + returnStagger * Math.max(0, targets.length - 1)) * 1000 + 120);
}
function clearEffectLines() {
if (effectLinesCleanupTimer) {
clearTimeout(effectLinesCleanupTimer);
effectLinesCleanupTimer = null;
}
const layer =
(effectLinesLayer && effectLinesLayer.isConnected
? effectLinesLayer
: document.querySelector(".effect-lines-layer")) || null;
if (layer) layer.remove();
effectLinesLayer = null;
}
function applyEffectClasses() {
const isActive = effectState.expiresAt > Date.now();
const rail = document.querySelector(".top-rail.skills");
if (rail) rail.classList.toggle("effect-mode-on", isActive);
document
.querySelectorAll(".icon-bar .skill-icon[data-index]")
.forEach((icon) => {
if (icon.classList.contains("weapon-bar-toggle")) return;
const name = getSkillNameFromIcon(icon);
const should =
isActive && name && effectState.skills.has(name);
icon.classList.toggle("effect-active", !!should);
if (!should) {
icon.style.removeProperty("--effect-strength");
}
});
if (isActive) {
bindEffectLinesEvents();
scheduleEffectLinesUpdate();
}
}
function clearEffectState() {
const activeIcon = document.querySelector(
".icon-bar .skill-icon.active"
);
const activeName = getSkillNameFromIcon(activeIcon);
const wasAffected =
activeName && effectState.skills.has(activeName);

animateEffectLinesReturn();
if (effectState.timer) {
clearTimeout(effectState.timer);
effectState.timer = null;
}
effectState.skills.clear();
effectState.videos.clear();
effectState.expiresAt = 0;
effectState.sourceIcon = null;
applyEffectClasses();

if (wasAffected && activeIcon) {
activeIcon.dispatchEvent(new Event("click", { bubbles: true }));
}
}
function activateEffectFromIcon(iconEl) {
const effectRaw = getCachedJSON(iconEl, "effect");
const normalized = normalizeEffectData(effectRaw);
if (!normalized) return;

effectState.skills = new Set(normalized.skills);
effectState.videos = normalized.videos;
effectState.expiresAt = Date.now() + normalized.timeMs;
effectState.sourceIcon = iconEl;

if (effectState.timer) clearTimeout(effectState.timer);
effectState.timer = setTimeout(() => {
clearEffectState();
}, normalized.timeMs + 5);

applyEffectClasses();
}
function getEffectVideoForIcon(iconEl) {
if (!iconEl) return "";
if (effectState.expiresAt <= Date.now()) return "";
const name = getSkillNameFromIcon(iconEl);
if (!name || !effectState.skills.has(name)) return "";
if (effectState.videos.has(name)) return effectState.videos.get(name) || "";
return "";
}
function getEffectiveSkillVideoFromIcon(iconEl) {
const weaponOn = globalWeaponEnabled;
const weaponData = getWeaponDataForIcon(iconEl);
const baseVideoFile = (iconEl.dataset.videoFile || "").trim();
const baseVideoURL = (iconEl.dataset.video || "").trim();

// console.log('[Skills DEBUG]', {
// skillName: iconEl.dataset.nome || iconEl.dataset.name,
// weaponOn,
// hasWeaponData: !!weaponData,
// weaponData: weaponData,
// baseVideoFile,
// baseVideoURL
// });

const effectVideo = getEffectVideoForIcon(iconEl);
if (effectVideo && effectVideo.trim() !== "") {
return effectVideo.trim();
}

if (weaponOn && weaponData) {
// console.log('[Skills] checking weapon video', {
// skillName: iconEl.dataset.nome || iconEl.dataset.name,
// hasVideo: !!(weaponData.video),
// videoValue: weaponData.video,
// videoTrimmed: weaponData.video ? weaponData.video.trim() : ''
// });
if (weaponData.video && weaponData.video.trim() !== "") {
// console.log('[Skills] video escolhido (weapon)', iconEl.dataset.nome || iconEl.dataset.name, weaponData.video);
return weaponData.video.trim();
}
}

// Sistema genérico de swap: verifica character_videos se houver personagem ativo
if (activeCharacter !== null && iconEl.dataset.characterVideos) {
try {
const characterVideos = JSON.parse(iconEl.dataset.characterVideos);
const characterVideo = characterVideos[activeCharacter];
if (characterVideo && characterVideo.trim() !== "") {
return characterVideo.trim();
}
} catch (e) {
console.warn("[Swap] Erro ao processar character_videos:", e);
}
}

// form_switch (Change Form): usa vídeo da PRÓXIMA forma (transição atual → próxima)
const isFormSwitch =
iconEl.dataset.formSwitch === "true" ||
iconEl.getAttribute("data-form-switch") === "true";
if (isFormSwitch) {
const formVideosRaw =
iconEl.dataset.formVideos || iconEl.getAttribute("data-form-videos");
if (formVideosRaw) {
try {
const videos = JSON.parse(formVideosRaw);
let formVideo = "";
const nextForm = typeof getNextFormName === "function" ? getNextFormName() : null;
if (nextForm) {
formVideo = videos[nextForm] || "";
}
// Fallback: se nextForm for null (formsData ainda não carregado), usa primeiro vídeo disponível
if ((!formVideo || formVideo.trim() === "") && Object.keys(videos).length > 0) {
const firstKey = Object.keys(videos)[0];
formVideo = videos[firstKey] || "";
}
if (formVideo && formVideo.trim() !== "") {
return formVideo.trim();
}
} catch (e) {
console.warn("[Forms] Erro ao parsear form_videos em getEffectiveSkillVideoFromIcon:", e);
}
}
}

// Prioriza videoFile (nome do arquivo), mas se estiver vazio, usa video (pode ser URL completa)
const result = baseVideoFile || baseVideoURL || "";
// console.log('[Skills] video escolhido (base)', iconEl.dataset.nome || iconEl.dataset.name, result);
return result;
}
function createVideoElement(videoURL, extraAttrs = {}) {
// Se o vídeo já falhou antes, não cria novo elemento
if (failedVideosCache.has(videoURL)) {
return null;
}

const v = document.createElement("video");
v.className = "skill-video";
v.setAttribute("controls", "");
v.setAttribute("preload", "auto"); // Mudado de 'metadata' para 'auto' para carregar tudo imediatamente
v.setAttribute("playsinline", "");
v.style.display = "none";
v.style.width = "100%";
v.style.height = "auto";
v.style.aspectRatio = "16/9";
v.style.objectFit = "cover";
Object.keys(extraAttrs).forEach((k) => {
v.dataset[k] = extraAttrs[k];
});
// Detectar formato do vídeo pela extensão
const ext = (videoURL.split(".").pop() || "").toLowerCase().split("?")[0];
const mimeTypes = {
mp4: "video/mp4",
m4v: "video/mp4",
webm: "video/webm",
ogv: "video/ogg",
ogg: "video/ogg",
mov: "video/quicktime",
};
const mimeType = mimeTypes[ext] || "video/mp4";

const src = document.createElement("source");
src.src = videoURL;
src.type = mimeType;
v.appendChild(src);

// Fallback para Safari/iOS mais antigos
v.setAttribute("webkit-playsinline", "");
v.setAttribute("x-webkit-airplay", "allow");

// Tratamento silencioso de erros - marca como falhado e não tenta mais
let errorHandled = false;
v.addEventListener(
"error",
(e) => {
if (errorHandled) return;
errorHandled = true;
// Marca o vídeo como falhado para não tentar carregar novamente
failedVideosCache.add(videoURL);
// Remove o vídeo do DOM se estiver lá
if (v.parentNode) {
v.parentNode.removeChild(v);
}
// Avisa apenas uma vez sobre vídeos faltantes
if (!missingVideosReported.has(videoURL)) {
missingVideosReported.add(videoURL);
// Extrai nome do arquivo da URL para o aviso
const fileName =
videoURL.split("/").pop().split("?")[0] || videoURL;
console.info(
`[Skills] Vídeo não encontrado na wiki: ${decodeURIComponent(
fileName
)}. Este aviso aparecerá apenas uma vez.`
);
}
},
{ once: true }
);

return v;
}

// Função recursiva para carregar TODOS os vídeos de subskills (incluindo sub-subskills)
function preloadSubskillVideosRecursively(
subs,
parentIdx,
parentPath = ""
) {
const vb = getVideoBox();
if (!vb || !Array.isArray(subs)) return 0;
let createdCount = 0;
subs.forEach((s) => {
const subName = (s.name || s.n || "").trim();
const currentPath = parentPath ? `${parentPath}:${subName}` : subName;

// Vídeo normal da subskill
if (s.video && s.video.trim() !== "") {
const key = `sub:${parentIdx}:${currentPath}`;
if (!subskillVideosCache.has(key)) {
const videoURL = normalizeFileURL(s.video);
if (
videoURL &&
videoURL.trim() !== "" &&
!failedVideosCache.has(videoURL)
) {
const v = createVideoElement(videoURL, {
sub: "1",
parentIndex: parentIdx,
subName: currentPath,
cacheKey: key,
});
if (v) {
// Só adiciona se o vídeo foi criado (não estava no cache de falhas)
vb.appendChild(v);
subskillVideosCache.set(key, v);
createdCount++;
// FORÇA carregamento imediatamente (apenas uma vez)
v.load();
}
}
}
}

// Vídeo de weapon da subskill (sempre carrega, independente do toggle)
if (
s.weapon &&
typeof s.weapon === "object" &&
s.weapon.video &&
s.weapon.video.trim() !== ""
) {
const weaponKey = `sub:${parentIdx}:${currentPath}:weapon`;
if (!subskillVideosCache.has(weaponKey)) {
const weaponVideoURL = normalizeFileURL(s.weapon.video);
if (
weaponVideoURL &&
weaponVideoURL.trim() !== "" &&
!failedVideosCache.has(weaponVideoURL)
) {
const v = createVideoElement(weaponVideoURL, {
sub: "1",
parentIndex: parentIdx,
subName: currentPath,
weapon: "1",
cacheKey: weaponKey,
});
if (v) {
// Só adiciona se o vídeo foi criado (não estava no cache de falhas)
vb.appendChild(v);
subskillVideosCache.set(weaponKey, v);
createdCount++;
// FORÇA carregamento imediatamente (apenas uma vez)
v.load();
}
}
}
}

// RECURSÃO: processa sub-subskills (SEMPRE processa, mesmo se o vídeo já estiver no cache)
if (Array.isArray(s.subs) && s.subs.length > 0) {
createdCount += preloadSubskillVideosRecursively(
s.subs,
parentIdx,
currentPath
);
}
});
return createdCount;
}

function precreateSubskillVideos() {
if (!getVideoBox()) return;
let createdCount = 0;
iconItems.forEach((parentIcon) => {
const subs = getCachedJSON(parentIcon, "subs");
if (!Array.isArray(subs)) return;
const parentIdx = parentIcon.dataset.index || "";
createdCount += preloadSubskillVideosRecursively(subs, parentIdx);
});
}

// Função para pré-carregar TODOS os vídeos recursivamente (principais, subskills, weapon, sub-subskills)
function preloadAllVideosRecursively() {
const vb = getVideoBox();
if (!vb || !iconItems.length) return;

// 1. Carregar vídeos de skills principais
iconItems.forEach((el) => {
const idx = el.dataset.index || "";
if (!idx) return;

// Vídeo normal da skill principal
// form_switch com form_videos: NÃO pré-carrega o vídeo base (ex: Change Form-Video.mp4) pois pode não existir
const isFormSwitchPreload =
el.dataset.formSwitch === "true" ||
el.getAttribute("data-form-switch") === "true";
const hasFormVideos =
(el.dataset.formVideos || el.getAttribute("data-form-videos") || "").trim() !== "";
const skipBaseVideo = isFormSwitchPreload && hasFormVideos;

let src = "";
if (!skipBaseVideo) {
src = (el.dataset.videoFile || "").trim();
if (!src) {
const videoAttr = (el.dataset.video || "").trim();
if (videoAttr) {
src = videoAttr.includes("/") || videoAttr.startsWith("http")
? videoAttr
: videoAttr;
}
}
}
if (src && !videosCache.has(idx)) {
const videoURL = normalizeFileURL(src);
if (videoURL && !failedVideosCache.has(videoURL)) {
const v = createVideoElement(videoURL, {
index: idx,
});
if (v) {
// Só adiciona se o vídeo foi criado (não estava no cache de falhas)
totalVideos++;
v.style.maxWidth = "100%";
v.addEventListener(
"canplaythrough",
() => {
loadedVideos++;
if (!userHasInteracted && loadedVideos === 1) {
try {
v.pause();
v.currentTime = 0;
} catch (e) { }
}
if (loadedVideos === totalVideos) autoplay = true;
},
{
once: true,
}
);
v.addEventListener(
"error",
() => {
loadedVideos++;
if (loadedVideos === totalVideos) autoplay = true;
},
{
once: true,
}
);
vb.appendChild(v);
videosCache.set(idx, v);
nestedVideoElByIcon.set(el, v);
// Força carregamento imediatamente (apenas uma vez)
v.load();
}
}
}

// form_switch: pré-carrega TODOS os vídeos de form_videos para transições
const isFormSwitch =
el.dataset.formSwitch === "true" ||
el.getAttribute("data-form-switch") === "true";
if (isFormSwitch) {
const formVideosRaw =
el.dataset.formVideos || el.getAttribute("data-form-videos");
if (formVideosRaw) {
try {
const videos = JSON.parse(formVideosRaw);
Object.keys(videos).forEach((formName) => {
const videoFile = videos[formName];
if (videoFile && videoFile.trim() !== "") {
const videoKey = idx + ":" + videoFile;
if (!videosCache.has(videoKey)) {
const videoURL = normalizeFileURL(videoFile);
if (videoURL && !failedVideosCache.has(videoURL)) {
const v = createVideoElement(videoURL, { index: idx });
if (v) {
totalVideos++;
v.addEventListener(
"canplaythrough",
() => {
loadedVideos++;
if (loadedVideos === totalVideos) autoplay = true;
},
{ once: true }
);
v.addEventListener(
"error",
() => {
loadedVideos++;
if (loadedVideos === totalVideos) autoplay = true;
},
{ once: true }
);
vb.appendChild(v);
videosCache.set(videoKey, v);
v.load();
}
}
}
}
});
} catch (e) {
console.warn("[Forms] Erro ao pré-carregar form_videos:", e);
}
}
}

// Vídeo de weapon (sempre carrega, independente do toggle)
const weaponData = getCachedJSON(el, "weapon");
if (
weaponData &&
weaponData.video &&
weaponData.video.trim() !== ""
) {
const weaponKey = `weapon:${idx}:${(
el.dataset.nome ||
el.dataset.name ||
""
).trim()}`;
if (!videosCache.has(weaponKey)) {
const weaponVideoURL = normalizeFileURL(weaponData.video);
if (weaponVideoURL && !failedVideosCache.has(weaponVideoURL)) {
const v = createVideoElement(weaponVideoURL, {
index: idx,
weapon: "1",
});
if (v) {
// Só adiciona se o vídeo foi criado (não estava no cache de falhas)
totalVideos++;
v.style.maxWidth = "100%";
v.addEventListener(
"canplaythrough",
() => {
loadedVideos++;
if (loadedVideos === totalVideos) autoplay = true;
},
{
once: true,
}
);
v.addEventListener(
"error",
() => {
loadedVideos++;
if (loadedVideos === totalVideos) autoplay = true;
},
{
once: true,
}
);
vb.appendChild(v);
videosCache.set(weaponKey, v);
// Força carregamento imediatamente (apenas uma vez)
v.load();
}
}
}
}
});

// 2. Carregar vídeos de subskills (recursivamente)
precreateSubskillVideos();
}

// Função para pré-carregar TODOS os ícones recursivamente
function preloadAllIconsRecursively() {
const iconCache = new Set();

// Função recursiva para processar subskills
function processSubskillsRecursively(subs) {
if (!Array.isArray(subs)) return;
subs.forEach((s) => {
const icon = (s.icon || "").trim();
if (icon) {
const iconURL = normalizeFileURL(icon);
if (iconURL && !iconCache.has(iconURL)) {
iconCache.add(iconURL);
const img = new Image();
img.decoding = "async";
img.loading = "eager";
img.referrerPolicy = "same-origin";
img.src = iconURL;
imagePreloadCache.set(iconURL, img);
}
}
// Recursão para sub-subskills
if (Array.isArray(s.subs)) {
processSubskillsRecursively(s.subs);
}
});
}

// Carregar ícones de skills principais
iconItems.forEach((el) => {
const img = el.querySelector("img");
if (img && img.src) {
const iconURL = img.src;
if (iconURL && !iconCache.has(iconURL)) {
iconCache.add(iconURL);
// Já está no DOM, mas força pré-carregamento
const preloadImg = new Image();
preloadImg.decoding = "async";
preloadImg.loading = "eager";
preloadImg.referrerPolicy = "same-origin";
preloadImg.src = iconURL;
imagePreloadCache.set(iconURL, preloadImg);
}
}

// Carregar ícones de subskills recursivamente
const subs = getCachedJSON(el, "subs");
if (Array.isArray(subs)) {
processSubskillsRecursively(subs);
}
});
}

// Função principal que carrega TUDO imediatamente
function preloadAllAssets() {
// Carregar TUDO imediatamente - sem lazy loading
// 1. Carregar TODOS os vídeos (principais, subskills, weapon, sub-subskills)
preloadAllVideosRecursively();

// 2. Carregar TODOS os ícones (principais, subskills, sub-subskills)
preloadAllIconsRecursively();
}

// Executa pré-carregamento imediatamente
preloadAllAssets();
function wireTooltipsForNewIcons() {
const tip = document.querySelector(".skill-tooltip");
if (!tip) return;
let lockUntil2 = 0;
Array.from(document.querySelectorAll(".icon-bar .skill-icon")).forEach(
(icon) => {
if (
icon.dataset.weaponToggle === "1" ||
icon.classList.contains("weapon-bar-toggle")
)
return;
if (icon.dataset.tipwired) return;
icon.dataset.tipwired = "1";
const label =
icon.dataset.nome || icon.dataset.name || icon.title || "";
if (label && !icon.hasAttribute("aria-label"))
icon.setAttribute("aria-label", label);
if (icon.hasAttribute("title")) icon.removeAttribute("title");
const img = icon.querySelector("img");
if (img) {
const imgAlt = img.getAttribute("alt") || "";
const imgTitle = img.getAttribute("title") || "";
if (!label && (imgAlt || imgTitle))
icon.setAttribute("aria-label", imgAlt || imgTitle);
img.setAttribute("alt", "");
if (img.hasAttribute("title")) img.removeAttribute("title");
}
const measureAndPos = (el) => {
if (!el || tip.getAttribute("aria-hidden") === "true") return;
tip.style.left = "0px";
tip.style.top = "0px";
const rect = el.getBoundingClientRect();
const tr = tip.getBoundingClientRect();
let left = Math.round(rect.left + (rect.width - tr.width) / 2);
left = Math.max(
8,
Math.min(left, window.innerWidth - tr.width - 8)
);
const coarse =
(window.matchMedia && matchMedia("(pointer: coarse)").matches) ||
window.innerWidth <= 600;
let top = coarse
? Math.round(rect.bottom + 10)
: Math.round(rect.top - tr.height - 8);
if (top < 8) top = Math.round(rect.bottom + 10);
tip.style.left = left + "px";
tip.style.top = top + "px";
};
const show = (el, text) => {
tip.textContent = text || "";
tip.setAttribute("aria-hidden", "false");
measureAndPos(el);
tip.style.opacity = "1";
};
const hide = () => {
tip.setAttribute("aria-hidden", "true");
tip.style.opacity = "0";
tip.style.left = "-9999px";
tip.style.top = "-9999px";
};
icon.addEventListener("mouseenter", () =>
show(icon, icon.dataset.nome || icon.dataset.name || "")
);
icon.addEventListener("mousemove", () => {
if (performance.now() >= lockUntil2) measureAndPos(icon);
});
icon.addEventListener("click", () => {
lockUntil2 = performance.now() + 240;
measureAndPos(icon);
});
icon.addEventListener("mouseleave", hide);
}
);
}
function showVideoForIcon(el) {
userHasInteracted = true;
const videoBox = getVideoBox();
if (!videoBox) return;
const effectiveVideo = getEffectiveSkillVideoFromIcon(el);
if (!effectiveVideo || effectiveVideo.trim() === "") {
videoBox.style.display = "none";
return;
}
const videoURL = normalizeFileURL(effectiveVideo);
if (!videoURL || videoURL.trim() === "") {
videoBox.style.display = "none";
return;
}
Array.from(videoBox.querySelectorAll("video.skill-video")).forEach(
(v) => {
try {
v.pause();
} catch (e) { }
v.style.display = "none";
}
);
if (window.__subskills) window.__subskills.hideAll?.(videoBox);
const hasIdx = !!el.dataset.index;
const weaponOn = globalWeaponEnabled;
const weaponData = getWeaponDataForIcon(el);
const isWeaponVideo =
weaponOn &&
weaponData &&
weaponData.video &&
weaponData.video.trim() !== "";
const effectVideo = getEffectVideoForIcon(el);
const isEffectVideo = !!(effectVideo && effectVideo.trim() !== "");
const effectKey = isEffectVideo
? getEffectVideoKey(el, effectiveVideo)
: "";

// console.log('[Skills] showVideoForIcon chamado', {
// skillName: el.dataset.nome || el.dataset.name,
// weaponOn,
// isWeaponVideo,
// effectiveVideo: getEffectiveSkillVideoFromIcon(el)
// });
const videoKey = isWeaponVideo
? `weapon:${getWeaponKey(el)}`
: isEffectVideo
? effectKey
: el.dataset.index || "";
const isSubskill = !hasIdx || el.dataset.nested === "1";
const parentIdx = el.dataset.parentIndex || "";
const subName =
el.dataset.subName || el.dataset.nome || el.dataset.name || "";

if (
hasIdx &&
!isWeaponVideo &&
!isEffectVideo &&
videosCache.has(el.dataset.index)
) {
const v = videosCache.get(el.dataset.index);
// Verifica se o vídeo cacheado corresponde ao vídeo atual da skill
// (ao trocar de form, o índice é reutilizado mas o vídeo muda)
const cachedSrc = v.querySelector("source")?.getAttribute("src") || "";
const currentVideoFile = (el.dataset.videoFile || "").trim();
const currentVideoURL = currentVideoFile ? normalizeFileURL(currentVideoFile) : "";
const decodeCached = decodeURIComponent(cachedSrc.split("/").pop().split("?")[0] || "");
const decodeTarget = decodeURIComponent((currentVideoURL || currentVideoFile).split("/").pop().split("?")[0] || "");
const srcMismatch = decodeTarget && decodeCached && decodeCached !== decodeTarget;
if (!srcMismatch) {
videoBox.style.display = "block";
v.style.display = "block";
try {
v.currentTime = 0;
} catch (e) { }
const suppress = document.body.dataset.suppressSkillPlay === "1";
if (!suppress) {
v.play().catch(() => { });
} else {
try {
v.pause();
} catch (e) { }
}
return;
}
// Vídeo não corresponde - remove do cache e do DOM
v.style.display = "none";
try { v.pause(); } catch (e) { }
if (v.parentNode) v.parentNode.removeChild(v);
videosCache.delete(el.dataset.index);
}
// Para form_switch, permite criação dinâmica de vídeos (transições de forma)
// Vídeos normais devem estar pré-carregados
const isFormSwitch =
el.dataset.formSwitch === "true" ||
el.getAttribute("data-form-switch") === "true";
let v = null;
if (isWeaponVideo) {
const weaponKeyFull = `weapon:${getWeaponKey(el)}`;
v = videosCache.get(weaponKeyFull);
if (!v && isSubskill && parentIdx && subName) {
// Tenta buscar vídeo de weapon de subskill
// O cache usa o formato: sub:${parentIdx}:${path}:weapon onde path NÃO inclui o nome da skill principal
// O subName agora já está no formato correto (sem nome da skill principal)

// Tenta buscar diretamente com o subName
let subWeaponKey = `sub:${parentIdx}:${subName}:weapon`;
v = subskillVideosCache.get(subWeaponKey);

// Se não encontrou, tenta buscar recursivamente
if (!v) {
const basePattern = `sub:${parentIdx}:`;
const weaponSuffix = ":weapon";
const searchName = subName.split(":").pop();
for (const [key, video] of subskillVideosCache.entries()) {
if (key.startsWith(basePattern) && key.endsWith(weaponSuffix)) {
const pathInKey = key.substring(
basePattern.length,
key.length - weaponSuffix.length
);
// Tenta match exato, ou se termina com o nome da skill
if (
pathInKey === subName ||
pathInKey.endsWith(`:${searchName}`) ||
pathInKey === searchName
) {
v = video;
break;
}
}
}
}
}
if (!v) {
// Tenta buscar pelo padrão antigo também
v = videoBox.querySelector(`video[data-weapon-key="${videoKey}"]`);
}
} else if (isEffectVideo && effectKey) {
v = videosCache.get(effectKey);
} else {
if (isSubskill && parentIdx && subName) {
// Busca vídeo de subskill no cache correto
// O cache usa o formato: sub:${parentIdx}:${path} onde path NÃO inclui o nome da skill principal
// O subName agora já está no formato correto (sem nome da skill principal)

// Tenta buscar diretamente com o subName
let subKey = `sub:${parentIdx}:${subName}`;
v = subskillVideosCache.get(subKey);

// Se não encontrou, tenta buscar recursivamente todas as chaves que começam com o padrão
// Isso é útil caso haja alguma diferença no formato do caminho
if (!v) {
const basePattern = `sub:${parentIdx}:`;
const searchName = subName.split(":").pop(); // Último segmento do caminho
// Tenta também buscar apenas pelo último segmento (útil para sub-subskills)
const lastSegmentKey = `sub:${parentIdx}:${searchName}`;
v = subskillVideosCache.get(lastSegmentKey);

// Se ainda não encontrou, faz busca mais ampla
if (!v) {
for (const [key, video] of subskillVideosCache.entries()) {
if (key.startsWith(basePattern)) {
const pathInKey = key.substring(basePattern.length);
// Tenta match exato, ou se termina com o nome da skill, ou se contém o caminho completo
if (
pathInKey === subName ||
pathInKey.endsWith(`:${searchName}`) ||
pathInKey === searchName ||
(subName.includes(":") && pathInKey.includes(subName)) ||
(subName.includes(":") &&
pathInKey.endsWith(
subName.split(":").slice(-2).join(":")
))
) {
v = video;
break;
}
}
}
}
}
} else {
v = videosCache.get(el.dataset.index);
if (!v) {
v = nestedVideoElByIcon.get(el);
}
}
}

// Se vídeo não foi encontrado no cache, verifica se falhou antes
if (!v) {
// Se o vídeo já foi marcado como falhado, não mostra aviso repetido
if (failedVideosCache.has(videoURL)) {
videoBox.style.display = "none";
return;
}
// Para effect, cria vídeo dinamicamente (vídeo alternativo por tempo)
if (isEffectVideo && videoURL) {
const baseIndex = el.dataset.index || "";
const effectCacheKey =
effectKey || `effect:${effectiveVideo || videoURL}`;
v = videosCache.get(effectCacheKey);
if (!v) {
v = createVideoElement(videoURL, {
index: baseIndex,
effect: "1",
});
if (v) {
videoBox.appendChild(v);
videosCache.set(effectCacheKey, v);
v.load();
} else {
videoBox.style.display = "none";
return;
}
}
}
// Para form_switch, cria vídeo dinamicamente (transições de forma são dinâmicas)
// Usa uma chave única que inclui o nome do arquivo do vídeo para garantir que cada vídeo diferente seja cacheado separadamente
else if (isFormSwitch && videoURL) {
const baseIndex = el.dataset.index || "";
const videoFileName = effectiveVideo || "";
// Chave única: index + nome do arquivo do vídeo
const videoKey = baseIndex + ":" + videoFileName;
v = videosCache.get(videoKey);
if (!v) {
v = createVideoElement(videoURL, { index: baseIndex });
if (v) {
videoBox.appendChild(v);
videosCache.set(videoKey, v);
v.load();
} else {
videoBox.style.display = "none";
return;
}
}
}
// Vídeos de form skills ou outros que não estão no cache - cria dinamicamente
else if (videoURL) {
const idx = el.dataset.index || "";
v = createVideoElement(videoURL, { index: idx });
if (v) {
videoBox.appendChild(v);
if (idx) videosCache.set(idx, v);
v.load();
} else {
videoBox.style.display = "none";
return;
}
} else {
videoBox.style.display = "none";
return;
}
}
videoBox.style.display = "block";
v.style.display = "block";
try {
v.currentTime = 0;
} catch (e) { }
const suppress = document.body.dataset.suppressSkillPlay === "1";
if (!suppress) {
v.play().catch(() => { });
} else {
try {
v.pause();
} catch (e) { }
}
}
function activateSkill(el, options = {}) {
const { openSubs = true } = options;
const tip = document.querySelector(".skill-tooltip");
if (tip) {
tip.setAttribute("aria-hidden", "true");
tip.style.opacity = "0";
tip.style.left = "-9999px";
tip.style.top = "-9999px";
}
const skillsRoot = document.getElementById("skills");
const i18nMap = skillsRoot
? JSON.parse(skillsRoot.dataset.i18nAttrs || "{}")
: {};
const L = i18nMap[getLangKey()] ||
i18nMap.pt || {
cooldown: "Recarga",
energy_gain: "Ganho de energia",
energy_cost: "Custo de energia",
power: "Poder",
power_pvp: "Poder PvP",
level: "Nível",
};
const name = el.dataset.nome || el.dataset.name || "";
if (el.dataset.effect) {
activateEffectFromIcon(el);
}
let weaponData = null;
if (el.dataset.weapon) {
try {
const parsed = JSON.parse(el.dataset.weapon);
// Só considera weapon válido se for um objeto não vazio
if (
parsed &&
typeof parsed === "object" &&
Object.keys(parsed).length > 0
) {
weaponData = parsed;
}
} catch (e) {
weaponData = null;
}
}
const hasWeapon = !!weaponData;
const weaponEquipped = hasWeapon && globalWeaponEnabled;
// Level: usa o level da weapon se estiver ativa e tiver level, senão usa o level da skill base
let level = (el.dataset.level || "").trim();
if (weaponEquipped && weaponData) {
// Verifica se weapon tem level definido (pode ser número ou string)
const weaponLevel = weaponData.level;
if (
weaponLevel !== undefined &&
weaponLevel !== null &&
weaponLevel !== ""
) {
level = weaponLevel.toString().trim();
}
}
const lang = getLangKey();
const baseDescPack = {
pt: el.dataset.descPt || "",
en: el.dataset.descEn || "",
es: el.dataset.descEs || "",
pl: el.dataset.descPl || "",
};
const baseDesc =
baseDescPack[lang] ||
baseDescPack.pt ||
baseDescPack.en ||
baseDescPack.es ||
baseDescPack.pl ||
el.dataset.desc ||
"";
// Aceita tanto desc_i18n quanto desc para compatibilidade
let weaponDescPack = {};
if (weaponData) {
if (weaponData.desc_i18n) {
weaponDescPack = weaponData.desc_i18n;
} else if (weaponData.desc) {
weaponDescPack = weaponData.desc;
} else {
weaponDescPack = {
pt: weaponData.descPt || "",
en: weaponData.descEn || "",
es: weaponData.descEs || "",
pl: weaponData.descPl || "",
};
}
}
const weaponDesc =
weaponDescPack[lang] ||
weaponDescPack.pt ||
weaponDescPack.en ||
weaponDescPack.es ||
weaponDescPack.pl ||
"";
const chosenDesc = weaponEquipped && weaponDesc ? weaponDesc : baseDesc;
const descHtml = chosenDesc.replace(/'''(.*?)'''/g, "<b>$1</b>");
let attrsHTML = "";
if (weaponEquipped && weaponData) {
// Faz merge: usa atributos da skill base e substitui apenas os que existem no weapon
// Parse dos atributos da skill base (formato: "pve, pvp, energy, cooldown" ou "pve, pvp, energy, cooldown")
const baseAttrsStr = el.dataset.atr || "";
// Suporta tanto ", " quanto "," como separador
const baseAttrs = baseAttrsStr.split(/\s*,\s*/).map((a) => a.trim());
const basePve =
baseAttrs[0] && baseAttrs[0] !== "-" ? baseAttrs[0] : "";
const basePvp =
baseAttrs[1] && baseAttrs[1] !== "-" ? baseAttrs[1] : "";
const baseEnergy =
baseAttrs[2] && baseAttrs[2] !== "-" ? baseAttrs[2] : "";
const baseCd = baseAttrs[3] && baseAttrs[3] !== "-" ? baseAttrs[3] : "";

// Valores do weapon (substituem os da skill base se existirem)
const wPve =
weaponData.powerpve !== undefined &&
weaponData.powerpve !== null &&
weaponData.powerpve !== ""
? weaponData.powerpve.toString().trim()
: basePve;
const wPvp =
weaponData.powerpvp !== undefined &&
weaponData.powerpvp !== null &&
weaponData.powerpvp !== ""
? weaponData.powerpvp.toString().trim()
: basePvp;
const wEnergy =
weaponData.energy !== undefined &&
weaponData.energy !== null &&
weaponData.energy !== ""
? weaponData.energy.toString().trim()
: baseEnergy;
const wCd =
weaponData.cooldown !== undefined &&
weaponData.cooldown !== null &&
weaponData.cooldown !== ""
? weaponData.cooldown.toString().trim()
: baseCd;

// Monta string de atributos mesclados
const mergedAttrs = [wPve, wPvp, wEnergy, wCd].join(",");
attrsHTML = renderAttributes(mergedAttrs);
} else {
attrsHTML = el.dataset.atr
? renderAttributes(el.dataset.atr)
: el.dataset.subattrs
? renderSubAttributesFromObj(JSON.parse(el.dataset.subattrs), L)
: "";
}
let flagsHTML = "";
// Debug: verifica se é uma skill do Urouge (verifica pela URL da página ou pelo contexto)
const isUrougePage =
window.location.href &&
window.location.href.toLowerCase().includes("urouge");
if (el.dataset.flags) {
try {
const flags = JSON.parse(el.dataset.flags);
if (flags && Array.isArray(flags) && flags.length > 0) {
flagsHTML = renderFlagsRow(flags);
// Debug para Urouge
if (isUrougePage) {
console.log("[Skills] Urouge - Flags processadas:", {
skill: name || el.dataset.nome,
flags: flags,
htmlLength: flagsHTML ? flagsHTML.length : 0,
hasHTML: !!flagsHTML,
});
}
} else {
if (isUrougePage) {
console.warn("[Skills] Urouge - Flags inválidas:", {
skill: name || el.dataset.nome,
flags: flags,
rawData: el.dataset.flags,
});
}
}
} catch (e) {
console.warn(
"[Skills] Erro ao processar flags:",
e,
"flags data:",
el.dataset.flags,
"skill:",
name || el.dataset.nome
);
if (isUrougePage) {
console.error(
"[Skills] Urouge - Erro ao processar flags:",
e,
"element:",
el
);
}
}
} else {
// Debug: verifica se deveria ter flags mas não tem (apenas para Urouge)
if (isUrougePage) {
console.warn("[Skills] Urouge - Skill sem data-flags:", {
skill: name || el.dataset.nome,
element: el,
allAttributes: Array.from(el.attributes).map(
(attr) => attr.name + "=" + attr.value
),
});
}
}
if (descBox) {
descBox.innerHTML = `<div class="skill-title"><h3>${name}</h3></div>${level
? `<div class="skill-level-line"><span class="attr-label">${L.level} ${level}</span></div>`
: ""
}${attrsHTML}<div class="desc">${descHtml}</div>`;
}
if (hasWeapon) {
applyWeaponBadge(el, weaponData, weaponEquipped);
}
const vb = getVideoBox();
if (vb) {
const oldFlags = vb.querySelector(".skill-flags");
if (oldFlags) oldFlags.remove();
if (flagsHTML) {
vb.insertAdjacentHTML("beforeend", flagsHTML);
applyFlagTooltips(vb);
}
}
const currIcons = Array.from(iconsBar.querySelectorAll(".skill-icon"));
currIcons.forEach((i) => i.classList.remove("active"));
const subsRaw = el.dataset.subs || el.getAttribute("data-subs");
const isFormSwitch =
el.dataset.formSwitch === "true" ||
el.getAttribute("data-form-switch") === "true";
const isSwap =
el.dataset.swap === "true" || el.getAttribute("data-swap") === "true";

// Se for skill de swap, troca personagem (não marca como ativo, não processa como back)
if (isSwap && !isFormSwitch) {
handleSwapCharacter(el);
// Não marca como ativo (similar ao form_switch)
return;
}

// Não marca como ativo se for form_switch (Change Form)
if (!isFormSwitch) {
el.classList.add("active");
if (!autoplay && loadedVideos > 0) autoplay = true;
window.__lastActiveSkillIcon = el;
// Lógica de vídeo: usa função centralizada que já considera weapon
showVideoForIcon(el);
}
const isBack =
el.dataset.back === "true" ||
el.getAttribute("data-back") === "true" ||
el.dataset.back === "yes" ||
el.getAttribute("data-back") === "yes" ||
el.dataset.back === "1" ||
el.getAttribute("data-back") === "1";

// Se for form_switch, alterna forma (não processa como back)
if (isFormSwitch) {
try {
const formsJSON = skillsRoot.dataset.forms || "{}";
if (formsJSON && formsJSON !== "{}") {
if (Object.keys(formsData).length === 0) {
formsData = JSON.parse(formsJSON);
}
}

// Inicializa currentForm se necessário
if (currentForm === null) {
currentForm = detectCurrentForm();
const formNames = Object.keys(formsData);
if (!currentForm && formNames.length > 0) {
currentForm = formNames[0];
}
}

// Calcula a próxima forma ANTES de trocar
const nextForm = getNextFormName();

// Vídeo de transição: usa o vídeo da PRÓXIMA forma
const formVideosRaw =
el.dataset.formVideos || el.getAttribute("data-form-videos");
if (formVideosRaw && nextForm) {
const videos = JSON.parse(formVideosRaw);
const transitionVideo = videos[nextForm] || "";
if (transitionVideo && transitionVideo.trim() !== "") {
el.dataset.videoFile = transitionVideo;
}
}
} catch (e) {
console.error("[Forms] Erro ao processar transição:", e);
}

showVideoForIcon(el);
switchForm();
return;
}

if (isBack && !isFormSwitch && barStack.length) {
const prev = barStack.pop();
// Restaura currentForm se estava salvo no snapshot
if (prev.currentForm !== undefined) {
currentForm = prev.currentForm;
}
renderBarFromItems(prev);
const btn = document.querySelector(".skills-back-wrapper");
if (btn) btn.style.display = barStack.length ? "block" : "none";
return;
}
if (openSubs && subsRaw && subsRaw.trim() !== "") {
if (barStack.length && barStack[barStack.length - 1].parentIcon === el)
return;
try {
const subs = JSON.parse(subsRaw);
pushSubBarFrom(subs, el);
} catch { }
}
}
function wireClicksForCurrentBar() {
const currIcons = Array.from(iconsBar.querySelectorAll(".skill-icon"));
currIcons.forEach((el) => {
if (
el.dataset.weaponToggle === "1" ||
el.classList.contains("weapon-bar-toggle")
)
return;
if (el.dataset.wired) return;
el.dataset.wired = "1";
const label = el.dataset.nome || el.dataset.name || "";
el.setAttribute("aria-label", label);
if (el.hasAttribute("title")) el.removeAttribute("title");
const img = el.querySelector("img");
if (img) {
img.setAttribute("alt", "");
if (img.hasAttribute("title")) img.removeAttribute("title");
}
el.addEventListener("click", () => {
activateSkill(el, {
openSubs: true,
});
});
});
wireTooltipsForNewIcons();
applyEffectClasses();
}
function animateIconsBarEntrance() {
Array.from(iconsBar.children).forEach((c, i) => {
c.style.opacity = "0";
c.style.transform = "translateY(6px)";
requestAnimationFrame(() => {
setTimeout(() => {
c.style.transition = "opacity .18s ease, transform .18s ease";
c.style.opacity = "1";
c.style.transform = "translateY(0)";
}, i * 24);
});
});
}
function snapshotCurrentBarItemsFromDOM() {
const items = Array.from(iconsBar.querySelectorAll(".skill-icon"))
.filter((el) => el.dataset.weaponToggle !== "1")
.map((el) => {
const img = el.querySelector("img");
const iconURL = img ? img.src : "";
const subsRaw = el.dataset.subs || el.getAttribute("data-subs") || "";
let subs = null;
try {
subs = subsRaw ? JSON.parse(subsRaw) : null;
} catch {
subs = null;
}
const subattrsRaw = el.dataset.subattrs || "";
let flags = null;
if (el.dataset.flags) {
try {
flags = JSON.parse(el.dataset.flags);
} catch (e) { }
}
let weapon = null;
if (el.dataset.weapon) {
try {
weapon = JSON.parse(el.dataset.weapon);
} catch (e) { }
}
let effect = null;
if (el.dataset.effect) {
try {
effect = JSON.parse(el.dataset.effect);
} catch (e) { }
}
// Preserva data-form-videos para poder restaurar depois
const formVideos =
el.dataset.formVideos || el.getAttribute("data-form-videos") || "";
return {
name: el.dataset.nome || el.dataset.name || "",
index: el.dataset.index || "",
level: el.dataset.level || "",
desc: el.dataset.desc || "",
descPt: el.dataset.descPt || "",
descEn: el.dataset.descEn || "",
descEs: el.dataset.descEs || "",
descPl: el.dataset.descPl || "",
attrs: el.dataset.atr || el.dataset.attrs || "",
video: el.dataset.video || "",
iconURL,
subs,
subattrsStr: subattrsRaw,
flags: flags,
weapon: weapon,
effect: effect,
nested: el.dataset.nested || "",
subName: el.dataset.subName || "",
parentIndex: el.dataset.parentIndex || "",
formSwitch:
el.dataset.formSwitch ||
el.getAttribute("data-form-switch") ||
"",
formVideos: formVideos,
};
});
// Retorna objeto com items e currentForm para poder restaurar depois
return { items, currentForm: currentForm };
}
function ensureBackButton() {
const rail = iconsBar.closest(".top-rail.skills");
if (!rail) return null;
let wrap = rail.parentElement;
if (
!wrap ||
!wrap.classList ||
!wrap.classList.contains("skills-rail-wrap")
) {
const parentNode = rail.parentNode;
const newWrap = document.createElement("div");
newWrap.className = "skills-rail-wrap";
parentNode.insertBefore(newWrap, rail);
newWrap.appendChild(rail);
wrap = newWrap;
}
let backWrap = wrap.querySelector(".skills-back-wrapper");
if (!backWrap) {
backWrap = document.createElement("div");
backWrap.className = "skills-back-wrapper";
const btnInner = document.createElement("button");
btnInner.className = "skills-back";
btnInner.type = "button";
btnInner.setAttribute("aria-label", "Voltar");
btnInner.innerHTML =
'<svg class="back-chevron" width="100%" height="100%" viewBox="0 0 36 32" fill="none" xmlns="http://www.w3.org/2000/svg" aria-hidden="true" preserveAspectRatio="xMidYMid meet"><path d="M10 2L4 16L10 30" stroke="currentColor" stroke-width="2.8" stroke-linecap="round" stroke-linejoin="round"/><path d="M20 2L14 16L20 30" stroke="currentColor" stroke-width="2.8" stroke-linecap="round" stroke-linejoin="round"/><path d="M30 2L24 16L30 30" stroke="currentColor" stroke-width="2.8" stroke-linecap="round" stroke-linejoin="round"/></svg>';
backWrap.appendChild(btnInner);
wrap.insertBefore(backWrap, rail);
btnInner.addEventListener("click", () => {
if (!barStack.length) return;
const prev = barStack.pop();
renderBarFromItems(prev);
backWrap.style.display = barStack.length ? "block" : "none";
wrap.classList.toggle("has-sub-bar", barStack.length > 0);
if (!barStack.length) btnInner.classList.remove("peek");
});
}
backWrap.style.display = barStack.length ? "block" : "none";
wrap.classList.toggle("has-sub-bar", barStack.length > 0);
const btnInner = backWrap.querySelector(".skills-back");

// Calcula a posição do botão baseado na posição real do top-rail
function updateBackButtonPosition() {
if (!rail || !backWrap) return;
const railRect = rail.getBoundingClientRect();
const wrapRect = wrap.getBoundingClientRect();
// Calcula a posição relativa do rail dentro do wrap
const railLeft = railRect.left - wrapRect.left;
// Posiciona o wrapper na borda esquerda do rail
// O botão interno usa translateX(-97%) para ficar atrás da barra
backWrap.style.left = railLeft + "px";
}

// Atualiza a posição quando necessário
if (backWrap.style.display !== "none") {
// Usa requestAnimationFrame para garantir que o DOM foi atualizado
requestAnimationFrame(() => {
updateBackButtonPosition();
});

// Recalcula em resize e scroll
if (!backWrap.dataset.positionWired) {
backWrap.dataset.positionWired = "1";
const updateOnResize = () => {
if (backWrap.style.display !== "none") {
updateBackButtonPosition();
}
};
window.addEventListener("resize", updateOnResize);
const observer = new ResizeObserver(() => {
if (backWrap.style.display !== "none") {
updateBackButtonPosition();
}
});
if (rail) observer.observe(rail);
observer.observe(wrap);
}
}

return btnInner;
}
function renderBarFromItems(itemsOrSnapshot) {
// Suporta tanto o formato antigo (array) quanto o novo (objeto com items e currentForm)
let items, savedCurrentForm;
if (Array.isArray(itemsOrSnapshot)) {
items = itemsOrSnapshot;
savedCurrentForm = null;
} else if (itemsOrSnapshot && itemsOrSnapshot.items) {
items = itemsOrSnapshot.items;
savedCurrentForm = itemsOrSnapshot.currentForm;
} else {
items = [];
savedCurrentForm = null;
}
// Restaura currentForm se estava salvo
if (savedCurrentForm !== undefined && savedCurrentForm !== null) {
currentForm = savedCurrentForm;
}
const tip = document.querySelector(".skill-tooltip");
if (tip) {
tip.setAttribute("aria-hidden", "true");
tip.style.opacity = "0";
tip.style.left = "-9999px";
tip.style.top = "-9999px";
}
iconsBar.innerHTML = "";
items.forEach((it, idx) => {
const node = document.createElement("div");
node.className = "skill-icon";
node.dataset.nome = it.name || "";
if (it.index) node.dataset.index = it.index;
if (it.level) node.dataset.level = it.level;
if (it.desc) node.dataset.desc = it.desc;
if (it.descPt) node.dataset.descPt = it.descPt;
if (it.descEn) node.dataset.descEn = it.descEn;
if (it.descEs) node.dataset.descEs = it.descEs;
if (it.descPl) node.dataset.descPl = it.descPl;
if (it.attrs) node.dataset.atr = it.attrs;
if (it.video) node.dataset.video = it.video;
if (it.subs) node.dataset.subs = JSON.stringify(it.subs);
if (it.subattrsStr) node.dataset.subattrs = it.subattrsStr;
if (it.flags) node.dataset.flags = JSON.stringify(it.flags);
if (
it.weapon &&
typeof it.weapon === "object" &&
Object.keys(it.weapon).length > 0
) {
node.dataset.weapon = JSON.stringify(it.weapon);
}
if (it.effect && typeof it.effect === "object") {
try {
node.dataset.effect = JSON.stringify(it.effect);
} catch (e) { }
}
// Restaura informações de subskill importantes para busca de vídeos
if (it.nested) node.dataset.nested = it.nested;
if (it.subName) node.dataset.subName = it.subName;
if (it.parentIndex) node.dataset.parentIndex = it.parentIndex;
if (!it.index && !it.nested) node.dataset.nested = "1";
// Restaura formSwitch (Change Form)
if (it.formSwitch) {
node.dataset.formSwitch = it.formSwitch;
node.setAttribute("data-form-switch", it.formSwitch);
}
// Restaura formVideos (vídeos de transição de forma)
if (it.formVideos) {
node.dataset.formVideos = it.formVideos;
node.setAttribute("data-form-videos", it.formVideos);
}
const img = document.createElement("img");
img.alt = "";
img.src = it.iconURL || (it.icon ? filePathURL(it.icon) : "");
img.decoding = "async";
img.loading = "lazy";
img.width = 50;
img.height = 50;
node.appendChild(img);
iconsBar.appendChild(node);
});
animateIconsBarEntrance();
wireClicksForCurrentBar();
// Remove qualquer toggle antigo que possa aparecer
const oldToggle = iconsBar.querySelector(".weapon-bar-toggle");
if (oldToggle) oldToggle.remove();
// Reaplica classes de weapon após renderizar barra
reapplyWeaponClassesToBar();
const b = ensureBackButton();
if (b) b.classList.add("peek");
// Atualiza a posição do botão back após a barra ser renderizada
requestAnimationFrame(() => {
const backWrap = document.querySelector(".skills-back-wrapper");
if (backWrap && backWrap.style.display !== "none") {
const rail = iconsBar.closest(".top-rail.skills");
const wrap = rail ? rail.parentElement : null;
if (rail && wrap && wrap.classList.contains("skills-rail-wrap")) {
const railRect = rail.getBoundingClientRect();
const wrapRect = wrap.getBoundingClientRect();
const railLeft = railRect.left - wrapRect.left;
// Posiciona na borda esquerda do rail (botão fica atrás com translateX)
backWrap.style.left = railLeft + "px";
}
}
});
}
function pushSubBarFrom(subs, parentIconEl) {
const tip = document.querySelector(".skill-tooltip");
if (tip) {
tip.setAttribute("aria-hidden", "true");
tip.style.opacity = "0";
tip.style.left = "-9999px";
tip.style.top = "-9999px";
}
const parentNameSnapshot = parentIconEl
? parentIconEl.dataset.nome || parentIconEl.dataset.name || ""
: "";
// Para subskills, usa parentIndex; para skills principais, usa index
const parentIndexSnapshot = parentIconEl
? parentIconEl.dataset.nested === "1"
? parentIconEl.dataset.parentIndex || ""
: parentIconEl.dataset.index || ""
: "";
const snapshot = snapshotCurrentBarItemsFromDOM();
barStack.push({
items: snapshot.items,
currentForm: snapshot.currentForm,
parentIcon: parentIconEl,
parentName: parentNameSnapshot,
parentIndex: parentIndexSnapshot,
});
ensureBackButton();
const langKey = getLangKey();
let cacheKey = null;
if (parentIconEl) {
cacheKey = parentIconEl.dataset.subCacheKey || null;
if (!cacheKey) {
if (parentIconEl.dataset.index) {
cacheKey = `idx:${parentIconEl.dataset.index}`;
} else {
const slug = slugify(
parentIconEl.dataset.nome || parentIconEl.dataset.name || ""
);
if (slug) cacheKey = `slug:${slug}`;
}
if (cacheKey) parentIconEl.dataset.subCacheKey = cacheKey;
}
}
if (cacheKey) {
const cached = subBarTemplateCache.get(cacheKey);
if (cached && cached.lang === langKey) {
iconsBar.innerHTML = "";
const clone = cached.template.cloneNode(true);
iconsBar.appendChild(clone);
animateIconsBarEntrance();
wireClicksForCurrentBar();
// Remove qualquer toggle antigo que possa aparecer
const oldToggle2 = iconsBar.querySelector(".weapon-bar-toggle");
if (oldToggle2) oldToggle2.remove();
// Reaplica classes de weapon após renderizar do cache
reapplyWeaponClassesToBar();
const cachedBtn = ensureBackButton();
if (cachedBtn) cachedBtn.classList.add("peek");
return;
}
}
const skillsRoot = document.getElementById("skills");
const i18nMap = skillsRoot
? JSON.parse(skillsRoot.dataset.i18nAttrs || "{}")
: {};
const L = i18nMap[getLangKey()] ||
i18nMap.pt || {
cooldown: "Recarga",
energy_gain: "Ganho de energia",
energy_cost: "Custo de energia",
power: "Poder",
power_pvp: "Poder PvP",
level: "Nível",
};
const hydratedSubs = inheritSubskillTree(subs, mainSkillsMeta);
const items = (hydratedSubs || [])
.filter((s) => {
// Filtra só se não tem nada útil
const hasName = (s.name || s.n || "").trim() !== "";
const hasIcon = (s.icon || "").trim() !== "";
const hasRef = (s.refS || s.refM || "").toString().trim() !== "";
return hasName || hasIcon || hasRef;
})
.map((s) => {
const name = (s.name || s.n || "").trim();
const desc = chooseDescFrom(s).replace(/'''(.*?)'''/g, "<b>$1</b>");
const attrsHTML = renderSubAttributesFromObj(s, L);
return {
name,
level: (s.level || "").toString().trim(),
desc,
descPt: s.descPt || (s.desc_i18n && s.desc_i18n.pt) || "",
descEn: s.descEn || (s.desc_i18n && s.desc_i18n.en) || "",
descEs: s.descEs || (s.desc_i18n && s.desc_i18n.es) || "",
descPl: s.descPl || (s.desc_i18n && s.desc_i18n.pl) || "",
attrs: "",
icon: s.icon || "",
iconURL: s.icon ? filePathURL(s.icon) : "",
video: s.video ? filePathURL(s.video) : "",
subs: Array.isArray(s.subs) ? s.subs : null,
subattrs: s,
flags: Array.isArray(s.flags) ? s.flags : null,
back:
s.back === true ||
s.back === "true" ||
s.back === "yes" ||
s.back === "1"
? "true"
: null,
weapon: s.weapon || null,
};
});
const fragment = document.createDocumentFragment();
items.forEach((it, iIdx) => {
const node = document.createElement("div");
node.className = "skill-icon";
node.dataset.nested = "1";
node.dataset.nome = it.name || "";
node.dataset.parentIndex = parentIndexSnapshot;
// Constrói o caminho completo para sub-subskills
// IMPORTANTE: O cache NÃO inclui o nome da skill principal no caminho
// Formato do cache: "SubskillName" ou "SubskillName:SubSubskillName" (sem o nome da skill principal)
let fullPath = it.name || "";
if (parentIconEl) {
// Se o pai é uma subskill (tem nested), adiciona o nome do pai ao caminho
if (parentIconEl.dataset.nested === "1") {
// Se o pai tem subName, usa ele (já está no formato correto, sem nome da skill principal)
if (
parentIconEl.dataset.subName &&
parentIconEl.dataset.subName.trim() !== ""
) {
fullPath = `${parentIconEl.dataset.subName}:${it.name || ""}`;
} else {
// Se o pai não tem subName, é a primeira subskill, então usa apenas o nome do pai
const parentName = (
parentIconEl.dataset.nome ||
parentIconEl.dataset.name ||
""
).trim();
fullPath = `${parentName}:${it.name || ""}`;
}
}
// Se o pai é uma skill principal (não é nested), o caminho é apenas o nome da subskill atual
// (já está definido como it.name acima)
}
node.dataset.subName = fullPath;
const subSlug = slugify(it.name || "");
if (subSlug) node.dataset.slug = subSlug;
if (it.level) node.dataset.level = it.level;
if (it.desc) node.dataset.desc = it.desc;
if (it.descPt) node.dataset.descPt = it.descPt;
if (it.descEn) node.dataset.descEn = it.descEn;
if (it.descEs) node.dataset.descEs = it.descEs;
if (it.descPl) node.dataset.descPl = it.descPl;
if (it.video) node.dataset.video = it.video;
if (it.subs) node.dataset.subs = JSON.stringify(it.subs);
if (it.subattrs) node.dataset.subattrs = JSON.stringify(it.subattrs);
if (it.flags) node.dataset.flags = JSON.stringify(it.flags);
if (it.back) node.dataset.back = it.back;
if (
it.weapon &&
typeof it.weapon === "object" &&
Object.keys(it.weapon).length > 0
) {
try {
node.dataset.weapon = JSON.stringify(it.weapon);
} catch (e) {
console.error(
"[Skills] Erro ao serializar weapon de subskill",
it.name,
e
);
}
}
const img = document.createElement("img");
img.alt = "";
img.src = it.iconURL;
img.decoding = "async";
img.loading = "lazy";
img.width = 50;
img.height = 50;
node.appendChild(img);
fragment.appendChild(node);
});
const templateClone = fragment.cloneNode(true);
iconsBar.innerHTML = "";
iconsBar.appendChild(fragment);
animateIconsBarEntrance();
wireClicksForCurrentBar();
// Remove qualquer toggle antigo que possa aparecer
const oldToggle3 = iconsBar.querySelector(".weapon-bar-toggle");
if (oldToggle3) oldToggle3.remove();
// Reaplica classes de weapon após renderizar subskills
reapplyWeaponClassesToBar();
const b2 = ensureBackButton();
if (b2) b2.classList.add("peek");
// Atualiza a posição do botão back após subskills serem renderizadas
requestAnimationFrame(() => {
const backWrap = document.querySelector(".skills-back-wrapper");
if (backWrap && backWrap.style.display !== "none") {
const rail = iconsBar.closest(".top-rail.skills");
const wrap = rail ? rail.parentElement : null;
if (rail && wrap && wrap.classList.contains("skills-rail-wrap")) {
const railRect = rail.getBoundingClientRect();
const wrapRect = wrap.getBoundingClientRect();
const railLeft = railRect.left - wrapRect.left;
// Posiciona na borda esquerda do rail (botão fica atrás com translateX)
backWrap.style.left = railLeft + "px";
}
}
});
if (cacheKey) {
subBarTemplateCache.set(cacheKey, {
template: templateClone,
lang: langKey,
});
}
}
window.addEventListener("gla:langChanged", () => {
subBarTemplateCache.clear();
const skillsRoot = document.getElementById("skills");
const i18nMap = skillsRoot
? JSON.parse(skillsRoot.dataset.i18nAttrs || "{}")
: {};
const lang = getLangKey();
Array.from(iconsBar.querySelectorAll(".skill-icon")).forEach((icon) => {
const pack = {
pt: icon.dataset.descPt || "",
en: icon.dataset.descEn || "",
es: icon.dataset.descEs || "",
pl: icon.dataset.descPl || "",
};
const chosen = (
pack[lang] ||
pack.pt ||
pack.en ||
pack.es ||
pack.pl ||
icon.dataset.desc ||
""
).trim();
if (chosen) icon.dataset.desc = chosen;
});
barStack.forEach((frame) => {
(frame.items || []).forEach((it) => {
const pack = {
pt: it.descPt,
en: it.descEn,
es: it.descEs,
pl: it.descPl,
};
const chosen =
pack[lang] ||
pack.pt ||
pack.en ||
pack.es ||
pack.pl ||
it.desc ||
"";
it.desc = chosen;
});
});
if (descBox) {
applyFlagTooltips(descBox);
}
const activeIcon = window.__lastActiveSkillIcon;
if (activeIcon && activeIcon.dataset.weapon) {
activateSkill(activeIcon, {
openSubs: false,
});
}
});
wireClicksForCurrentBar();

// Inicializa o sistema de swap de personagens (genérico)
// Aguarda um pouco para garantir que todos os ícones foram renderizados
setTimeout(() => {
initializeActiveCharacter();
}, 100);

const b0 = ensureBackButton();
if (b0) {
b0.classList.add("peek");
b0.style.alignSelf = "stretch";
}

// Move inicialização de tooltip para requestIdleCallback (não crítico)
if ("requestIdleCallback" in window) {
requestIdleCallback(
() => {
(function initSkillTooltip() {
if (document.querySelector(".skill-tooltip")) return;
const tip = document.createElement("div");
tip.className = "skill-tooltip";
tip.setAttribute("role", "tooltip");
tip.setAttribute("aria-hidden", "true");
document.body.appendChild(tip);
const lockUntilRef = {
value: 0,
};
function measureAndPos(el) {
if (!el || tip.getAttribute("aria-hidden") === "true") return;
tip.style.left = "0px";
tip.style.top = "0px";
const rect = el.getBoundingClientRect();
const tr = tip.getBoundingClientRect();
let left = Math.round(rect.left + (rect.width - tr.width) / 2);
left = Math.max(
8,
Math.min(left, window.innerWidth - tr.width - 8)
);
const coarse =
(window.matchMedia &&
matchMedia("(pointer: coarse)").matches) ||
window.innerWidth <= 600;
let top = coarse
? Math.round(rect.bottom + 10)
: Math.round(rect.top - tr.height - 8);
if (top < 8) top = Math.round(rect.bottom + 10);
tip.style.left = left + "px";
tip.style.top = top + "px";
}
function show(el, text) {
tip.textContent = text || "";
tip.setAttribute("aria-hidden", "false");
measureAndPos(el);
tip.style.opacity = "1";
}
function hide() {
tip.setAttribute("aria-hidden", "true");
tip.style.opacity = "0";
tip.style.left = "-9999px";
tip.style.top = "-9999px";
}
window.__globalSkillTooltip = {
show,
hide,
measureAndPos,
lockUntil: lockUntilRef,
};
Array.from(
document.querySelectorAll(".icon-bar .skill-icon")
).forEach((icon) => {
if (
icon.dataset.weaponToggle === "1" ||
icon.classList.contains("weapon-bar-toggle")
)
return;
if (icon.dataset.tipwired) return;
icon.dataset.tipwired = "1";
const label =
icon.dataset.nome || icon.dataset.name || icon.title || "";
if (label && !icon.hasAttribute("aria-label"))
icon.setAttribute("aria-label", label);
if (icon.hasAttribute("title")) icon.removeAttribute("title");
const img = icon.querySelector("img");
if (img) {
const imgAlt = img.getAttribute("alt") || "";
const imgTitle = img.getAttribute("title") || "";
if (!label && (imgAlt || imgTitle))
icon.setAttribute("aria-label", imgAlt || imgTitle);
img.setAttribute("alt", "");
if (img.hasAttribute("title")) img.removeAttribute("title");
}
icon.addEventListener("mouseenter", () => show(icon, label));
icon.addEventListener("mousemove", () => {
if (performance.now() >= lockUntilRef.value)
measureAndPos(icon);
});
icon.addEventListener("click", () => {
lockUntilRef.value = performance.now() + 240;
measureAndPos(icon);
});
icon.addEventListener("mouseleave", hide);
});
Array.from(
document.querySelectorAll(".subskills-rail .subicon")
).forEach((sub) => {
if (sub.dataset.tipwired) return;
sub.dataset.tipwired = "1";
const label =
sub.getAttribute("title") ||
sub.getAttribute("aria-label") ||
"";
if (label && !sub.hasAttribute("aria-label"))
sub.setAttribute("aria-label", label);
if (sub.hasAttribute("title")) sub.removeAttribute("title");
sub.addEventListener("mouseenter", () => show(sub, label));
sub.addEventListener("mousemove", () => {
if (performance.now() >= lockUntilRef.value) measureAndPos(sub);
});
sub.addEventListener("click", () => {
lockUntilRef.value = performance.now() + 240;
measureAndPos(sub);
});
sub.addEventListener("mouseleave", hide);
});
window.addEventListener(
"scroll",
() => {
const visible = document.querySelector(
'.skill-tooltip[aria-hidden="false"]'
);
if (!visible) return;
const target =
document.querySelector(".subskills-rail .subicon:hover") ||
document.querySelector(".subskills-rail .subicon.active") ||
document.querySelector(".icon-bar .skill-icon:hover") ||
document.querySelector(".icon-bar .skill-icon.active");
measureAndPos(target);
},
true
);
window.addEventListener("resize", () => {
const target =
document.querySelector(".subskills-rail .subicon:hover") ||
document.querySelector(".subskills-rail .subicon.active") ||
document.querySelector(".icon-bar .skill-icon:hover") ||
document.querySelector(".icon-bar .skill-icon.active");
measureAndPos(target);
});
})();
},
{ timeout: 2000 }
);
} else {
// Fallback para navegadores sem requestIdleCallback
setTimeout(() => {
(function initSkillTooltip() {
if (document.querySelector(".skill-tooltip")) return;
const tip = document.createElement("div");
tip.className = "skill-tooltip";
tip.setAttribute("role", "tooltip");
tip.setAttribute("aria-hidden", "true");
document.body.appendChild(tip);
window.__globalSkillTooltip = {
show: (el, text) => {
if (!el || !text) return;
tip.textContent = text;
tip.setAttribute("aria-hidden", "false");
measureAndPos(el);
},
hide: () => {
tip.setAttribute("aria-hidden", "true");
tip.style.left = "-9999px";
tip.style.top = "-9999px";
},
measureAndPos: (el) => {
if (!el || tip.getAttribute("aria-hidden") === "true") return;
const rect = el.getBoundingClientRect();
const tipRect = tip.getBoundingClientRect();
let left = rect.left + rect.width / 2 - tipRect.width / 2;
let top = rect.top - tipRect.height - 8;
if (left < 8) left = 8;
if (left + tipRect.width > window.innerWidth - 8)
left = window.innerWidth - tipRect.width - 8;
if (top < 8) top = rect.bottom + 8;
tip.style.left = left + "px";
tip.style.top = top + "px";
},
lockUntil: { value: 0 },
};
const { measureAndPos } = window.__globalSkillTooltip;
window.addEventListener(
"scroll",
() => {
const visible = document.querySelector(
'.skill-tooltip[aria-hidden="false"]'
);
if (!visible) return;
const target =
document.querySelector(".subskills-rail .subicon:hover") ||
document.querySelector(".subskills-rail .subicon.active") ||
document.querySelector(".icon-bar .skill-icon:hover") ||
document.querySelector(".icon-bar .skill-icon.active");
measureAndPos(target);
},
true
);
window.addEventListener("resize", () => {
const target =
document.querySelector(".subskills-rail .subicon:hover") ||
document.querySelector(".subskills-rail .subicon.active") ||
document.querySelector(".icon-bar .skill-icon:hover") ||
document.querySelector(".icon-bar .skill-icon.active");
measureAndPos(target);
});
})();
}, 100);
}

(function initTabs() {
const tabs = Array.from(document.querySelectorAll(".tab-btn"));
if (!tabs.length) return;
const contents = Array.from(document.querySelectorAll(".tab-content"));
const characterBox = document.querySelector(".character-box");
let wrapper = characterBox.querySelector(".tabs-height-wrapper");
if (!wrapper) {
wrapper = document.createElement("div");
wrapper.className = "tabs-height-wrapper";
contents.forEach((c) => {
wrapper.appendChild(c);
});
const tabsElement = characterBox.querySelector(".character-tabs");
if (tabsElement && tabsElement.nextSibling) {
characterBox.insertBefore(wrapper, tabsElement.nextSibling);
} else {
characterBox.appendChild(wrapper);
}
}
async function smoothHeightTransition(fromTab, toTab) {
if (!wrapper) return Promise.resolve();
const scrollY = window.scrollY;
const currentHeight = wrapper.getBoundingClientRect().height;
await new Promise((resolve) => {
const videoContainers = toTab.querySelectorAll(".video-container");
const contentCard = toTab.querySelector(".content-card");
if (videoContainers.length === 0) {
requestAnimationFrame(() => {
requestAnimationFrame(() => {
requestAnimationFrame(() => resolve());
});
});
return;
}
let lastHeight = 0;
let stableCount = 0;
const checksNeeded = 3;
let totalChecks = 0;
const maxChecks = 15;
function checkStability() {
totalChecks++;
const currentTabHeight = toTab.scrollHeight;
if (Math.abs(currentTabHeight - lastHeight) < 5) {
stableCount++;
} else {
stableCount = 0;
}
lastHeight = currentTabHeight;
if (stableCount >= checksNeeded || totalChecks >= maxChecks) {
resolve();
} else {
setTimeout(checkStability, 50);
}
}
setTimeout(checkStability, 50);
});
const nextHeight = toTab.getBoundingClientRect().height;
const finalHeight = Math.max(nextHeight, 100);
if (Math.abs(finalHeight - currentHeight) < 30) {
wrapper.style.height = "";
return Promise.resolve();
}
wrapper.style.overflow = "hidden";
wrapper.style.height = currentHeight + "px";
wrapper.offsetHeight;
wrapper.style.transition = "height 0.3s cubic-bezier(0.4, 0, 0.2, 1)";
requestAnimationFrame(() => {
wrapper.style.height = finalHeight + "px";
});
return new Promise((resolve) => {
setTimeout(() => {
wrapper.style.height = "";
wrapper.style.transition = "";
wrapper.style.overflow = "";
resolve();
}, 320);
});
}
tabs.forEach((btn) => {
if (btn.dataset.wiredTab) return;
btn.dataset.wiredTab = "1";
btn.addEventListener("click", () => {
const target = btn.getAttribute("data-tab");
const currentActive = contents.find((c) =>
c.classList.contains("active")
);
const nextActive = contents.find((c) => c.id === target);
if (currentActive === nextActive) return;
document.body.classList.add("transitioning-tabs");
if (currentActive) {
currentActive.style.opacity = "0";
currentActive.style.transform = "translateY(-8px)";
}
setTimeout(async () => {
contents.forEach((c) => {
if (c !== nextActive) {
c.style.display = "none";
c.classList.remove("active");
}
});
tabs.forEach((b) => b.classList.toggle("active", b === btn));
if (nextActive) {
nextActive.classList.add("active");
nextActive.style.display = "block";
nextActive.style.opacity = "0";
nextActive.style.visibility = "hidden";
nextActive.offsetHeight;
try {
if (target === "skills") {
const tabEl = document.getElementById(target);
if (tabEl) {
const allIcons = tabEl.querySelectorAll(
".icon-bar .skill-icon"
);
const activeIcon = tabEl.querySelector(
".icon-bar .skill-icon.active"
);
const firstIcon = tabEl.querySelector(
".icon-bar .skill-icon"
);
const isFormSwitch = (el) =>
el?.dataset?.formSwitch === "true" ||
el?.getAttribute?.("data-form-switch") === "true";
let toClick = activeIcon && !isFormSwitch(activeIcon)
? activeIcon
: null;
if (!toClick)
for (const icon of allIcons || [])
if (!isFormSwitch(icon)) {
toClick = icon;
break;
}
if (!toClick) toClick = firstIcon;
if (toClick) {
const had = document.body.dataset.suppressSkillPlay;
document.body.dataset.suppressSkillPlay = "1";
toClick.click();
if (had) document.body.dataset.suppressSkillPlay = had;
}
}
}
} catch (e) { }
}
if (currentActive && nextActive) {
await smoothHeightTransition(currentActive, nextActive);
}
if (nextActive) {
nextActive.style.visibility = "";
nextActive.style.transform = "translateY(12px)";
requestAnimationFrame(() => {
nextActive.style.opacity = "1";
nextActive.style.transform = "translateY(0)";
setTimeout(() => {
nextActive.style.opacity = "";
nextActive.style.transform = "";
document.body.classList.remove("transitioning-tabs");
try {
delete document.body.dataset.suppressSkillPlay;
} catch { }
}, 300);
});
}
}, 120);
setTimeout(() => {
syncDescHeight();
if (target === "skins") {
videosCache.forEach((v) => {
try {
v.pause();
} catch (e) { }
v.style.display = "none";
});
const vb = getVideoBox();
if (vb) {
vb.querySelectorAll("video.skill-video").forEach((v) => {
try {
v.pause();
} catch (e) { }
v.style.display = "none";
});
}
if (window.__subskills) window.__subskills.hideAll?.(getVideoBox());
const placeholder = getVideoBox()?.querySelector(".video-placeholder");
const vb2 = getVideoBox();
if (vb2 && placeholder) {
placeholder.style.display = "none";
placeholder.classList.add("fade-out");
}
} else {
const activeIcon = document.querySelector(
".icon-bar .skill-icon.active"
);
const isFormSwitch = (el) =>
el?.dataset?.formSwitch === "true" ||
el?.getAttribute?.("data-form-switch") === "true";
if (activeIcon && !isFormSwitch(activeIcon)) activeIcon.click();
else {
const first = document.querySelector(
".icon-bar .skill-icon:not([data-form-switch='true'])"
);
if (first) first.click();
}
}
}, 450);
});
});
})();
(function initSkinsArrows() {
const carousel = $(".skins-carousel");
const wrapper = $(".skins-carousel-wrapper");
const left = $(".skins-arrow.left");
const right = $(".skins-arrow.right");
if (!carousel || !left || !right || !wrapper) return;
if (wrapper.dataset.wired) return;
wrapper.dataset.wired = "1";
const scrollAmt = () => Math.round(carousel.clientWidth * 0.6);
function setState() {
const max = carousel.scrollWidth - carousel.clientWidth;
const x = carousel.scrollLeft;
const hasLeft = x > 5,
hasRight = x < max - 5;
left.style.display = hasLeft ? "inline-block" : "none";
right.style.display = hasRight ? "inline-block" : "none";
wrapper.classList.toggle("has-left", hasLeft);
wrapper.classList.toggle("has-right", hasRight);
carousel.style.justifyContent = !hasLeft && !hasRight ? "center" : "";
}
function go(dir) {
const max = carousel.scrollWidth - carousel.clientWidth;
const next =
dir < 0
? Math.max(0, carousel.scrollLeft - scrollAmt())
: Math.min(max, carousel.scrollLeft + scrollAmt());
carousel.scrollTo({
left: next,
behavior: "smooth",
});
}
left.addEventListener("click", () => go(-1));
right.addEventListener("click", () => go(1));
carousel.addEventListener("scroll", setState);
new ResizeObserver(setState).observe(carousel);
setState();
})();
function renderAttributes(str) {
const skillsRoot = document.getElementById("skills");
const i18nMap = skillsRoot
? JSON.parse(skillsRoot.dataset.i18nAttrs || "{}")
: {};
const langRaw = (
document.documentElement.lang ||
skillsRoot?.dataset.i18nDefault ||
"pt"
).toLowerCase();
const langKey = i18nMap[langRaw]
? langRaw
: i18nMap[langRaw.split("-")[0]]
? langRaw.split("-")[0]
: "pt";
const L = i18nMap[langKey] ||
i18nMap.pt || {
cooldown: "Recarga",
energy_gain: "Ganho de energia",
energy_cost: "Custo de energia",
power: "Poder",
power_pvp: "Poder PvP",
level: "Nível",
};
const vals = (str || "").split(",").map((v) => v.trim());
// Processa valores, tratando strings vazias e "-" como NaN
// IMPORTANTE: ordem fixa é [powerpve, powerpvp, energy, cooldown]
const parseValue = (val) => {
if (!val || val === "" || val === "-") return NaN;
const parsed = parseFloat(val);
return isNaN(parsed) ? NaN : parsed;
};
const pve = parseValue(vals[0]);
const pvp = parseValue(vals[1]);
const ene = parseValue(vals[2]);
const cd = parseValue(vals[3]);
// Debug: log se houver problema na ordem
if (str && str.includes(",") && !isNaN(cd) && !isNaN(pvp) && cd === pvp) {
console.warn(
"[Skills] renderAttributes: possível problema na ordem dos atributos",
{ str, vals, pve, pvp, ene, cd }
);
}
const rows = [];
// Ordem de exibição: cooldown, energy, power, power_pvp
if (!isNaN(cd)) rows.push([L.cooldown, cd]);
if (!isNaN(ene) && ene !== 0) {
const label = ene > 0 ? L.energy_gain : L.energy_cost;
rows.push([label, Math.abs(ene)]);
}
if (!isNaN(pve)) rows.push([L.power, pve]);
if (!isNaN(pvp)) rows.push([L.power_pvp, pvp]);
// Debug: log se houver valores suspeitos (desabilitado para performance)
// if (str && str.includes(',')) {
// console.log('[Skills] renderAttributes processed', {
// str,
// vals: vals.slice(0, 4),
// parsed: { pve, pvp, ene, cd },
// rows: rows.map(r => r[0])
// });
// }
if (!rows.length) return "";
const html = rows
.map(
([rowLabel, rowValue]) =>
`<div class="attr-row"><span class="attr-label">${rowLabel}</span><span class="attr-value">${rowValue}</span></div>`
)
.join("");
return `<div class="attr-list">${html}</div>`;
}
function syncDescHeight() { }
window.addEventListener("resize", syncDescHeight);
const vbInit = getVideoBox();
if (vbInit) new ResizeObserver(syncDescHeight).observe(vbInit);
iconItems.forEach((el) => {
const wired = !!el.dataset._sync_wired;
if (wired) return;
el.dataset._sync_wired = "1";
el.addEventListener("click", () => {
Promise.resolve().then(syncDescHeight);
});
});
if (iconsBar) {
const scrollWrapper =
iconsBar.closest(".icon-scroll-x") || iconsBar.parentElement;
const scrollContainer =
scrollWrapper && scrollWrapper.classList.contains("icon-scroll-x")
? scrollWrapper
: iconsBar;
addOnce(
scrollContainer,
"wheel",
(e) => {
if (e.deltaY) {
e.preventDefault();
scrollContainer.scrollLeft += e.deltaY;
}
},
{ passive: false }
); // passive: false necessário porque usamos preventDefault()
}
(function maybeInjectFormSkillsOnLoad() {
try {
const skillsRoot = document.getElementById("skills");
if (skillsRoot && iconsBar && iconItems.length > 0) {
const formsJSON = skillsRoot.dataset.forms || "{}";
if (formsJSON && formsJSON !== "{}") {
formsData = JSON.parse(formsJSON);
const firstIcon = iconItems[0];
const isFormSwitch =
firstIcon?.dataset?.formSwitch === "true" ||
firstIcon?.getAttribute?.("data-form-switch") === "true";
if (
formsData &&
Object.keys(formsData).length > 0 &&
isFormSwitch
) {
const firstFormName = Object.keys(formsData)[0];
const firstFormData = formsData[firstFormName];
if (firstFormData) {
updateSkillsBarForForm(firstFormName, firstFormData, firstIcon);
setTimeout(() => {
wireClicksForCurrentBar();
const freshIcons = Array.from(
iconsBar.querySelectorAll(".skill-icon")
);
const isFS = (el) =>
el?.dataset?.formSwitch === "true" ||
el?.getAttribute?.("data-form-switch") === "true";
const firstNonSwitch = freshIcons.find((el) => !isFS(el));
if (firstNonSwitch)
activateSkill(firstNonSwitch, { openSubs: false });
}, 200);
return;
}
}
}
}
} catch (e) {
console.error("[Forms] init inject error", e);
}
wireClicksForCurrentBar();
if (iconItems.length) {
const isFormSwitch = (el) =>
el?.dataset?.formSwitch === "true" ||
el?.getAttribute?.("data-form-switch") === "true";
let first = null;
for (const el of iconItems) {
if (!isFormSwitch(el)) {
first = el;
break;
}
}
if (!first) first = iconItems[0];
if (first) {
activateSkill(first, {
openSubs: false,
});
}
}
})();

// Aplica lazy loading em imagens fora do viewport inicial
(function applyLazyLoading() {
if ("IntersectionObserver" in window) {
const imageObserver = new IntersectionObserver((entries, observer) => {
entries.forEach((entry) => {
if (entry.isIntersecting) {
const img = entry.target;
if (img.tagName === "IMG" && !img.hasAttribute("loading")) {
img.loading = "lazy";
}
observer.unobserve(img);
}
});
});

// Observa imagens que não estão no viewport inicial
document
.querySelectorAll("img:not(.topbar-icon):not([loading])")
.forEach((img) => {
const rect = img.getBoundingClientRect();
if (rect.bottom > window.innerHeight || rect.top < 0) {
imageObserver.observe(img);
}
});
}
})();

setTimeout(() => {
Array.from(document.querySelectorAll(".skill-icon")).forEach((el) => { });
videosCache.forEach((v, idx) => {
const src = v.querySelector("source")
? v.querySelector("source").src
: v.src;
v.addEventListener("error", (ev) => { });
v.addEventListener("loadedmetadata", () => { });
});
}, 600);
})();
</script>

Módulo:I.Skills

2026-04-20T22:33:14Z

Gurren1: chopper ts diabolico

-- Módulo:I.Skills — skill(), skin() com suporte nativo a subskills recursivas
local p = {}

local utils = require("Módulo:I.Utils")
local trim = utils.trim
local colorize = utils.colorize

-- Fallback se colorize não existir
if not colorize or type(colorize) ~= "function" then
colorize = function(txt)
if not txt or txt == "" then
return ""
end
-- Versão simplificada sem colorização
return tostring(txt)
end
end

local cUtils = require("Módulo:C.Utils")
local requireCharModule = cUtils.requireCharModule

-- FASE 2: Normaliza descrição para formato i18n
-- Aceita desc (table com pt/en/es/pl) ou campos legados (descPt, descEn, etc)
-- Sempre retorna desc_i18n no formato { pt: "...", en: "...", ... }
local function normalizeDesc(desc, descPt, descEn, descEs, descPl)
local desc_i18n = {}

-- Se desc é uma table, processa diretamente
if desc and type(desc) == "table" then
for code, text in pairs(desc) do
if type(text) == "string" and text ~= "" then
desc_i18n[code] = colorize(text)
end
end
elseif type(desc) == "string" and desc ~= "" then
-- Se desc é string, assume português
desc_i18n.pt = colorize(desc)
end

-- Processa campos legados (descPt, descEn, etc) se existirem
if descPt and type(descPt) == "string" and descPt ~= "" then
desc_i18n.pt = colorize(descPt)
end
if descEn and type(descEn) == "string" and descEn ~= "" then
desc_i18n.en = colorize(descEn)
end
if descEs and type(descEs) == "string" and descEs ~= "" then
desc_i18n.es = colorize(descEs)
end
if descPl and type(descPl) == "string" and descPl ~= "" then
desc_i18n.pl = colorize(descPl)
end

return next(desc_i18n) and desc_i18n or nil
end

-- Processa descrição (desc table → desc_i18n)
-- Mantido para compatibilidade, agora usa normalizeDesc internamente
local function processDesc(desc)
if not desc then return nil end
return normalizeDesc(desc)
end

-- Processa weapon (aplica colorize nas descrições)
local function processWeapon(weapon)
if not weapon or type(weapon) ~= "table" then
return weapon
end

local processed = {}
-- Copia todos os campos do weapon
for k, v in pairs(weapon) do
processed[k] = v
end

-- FASE 2: Processa descrição do weapon usando normalizeDesc (normaliza campos legados)
if weapon.desc or weapon.descPt or weapon.descEn or weapon.descEs or weapon.descPl then
processed.desc_i18n = normalizeDesc(weapon.desc, weapon.descPt, weapon.descEn, weapon.descEs, weapon.descPl)
-- Remove campos legados se desc_i18n foi criado (para evitar duplicação)
if processed.desc_i18n then
processed.desc = nil
processed.descPt = nil
processed.descEn = nil
processed.descEs = nil
processed.descPl = nil
end
end

-- Se o weapon processado estiver vazio (sem campos), retorna nil
-- Isso evita que weapons vazios {} sejam considerados válidos
if next(processed) == nil then
return nil
end

return processed
end

-- Variações por personagem (swap): PvE/PvP/energia/CD/vídeo/desc por nome do líder
local function processCharacterSkills(cs)
if not cs or type(cs) ~= "table" then
return nil
end
local out = {}
for charName, row in pairs(cs) do
if type(charName) == "string" and charName ~= "" and type(row) == "table" then
local piece = {}
if row.energy ~= nil then
piece.energy = row.energy
end
if row.powerpve ~= nil then
piece.powerpve = row.powerpve
end
if row.powerpvp ~= nil then
piece.powerpvp = row.powerpvp
end
if row.cooldown ~= nil then
piece.cooldown = row.cooldown
end
if row.level ~= nil and row.level ~= "" then
piece.level = row.level
end
if row.video and type(row.video) == "string" and row.video ~= "" then
piece.video = row.video
end
local di = normalizeDesc(row.desc, row.descPt, row.descEn, row.descEs, row.descPl)
if di then
piece.desc_i18n = di
end
if next(piece) then
out[charName] = piece
end
end
end
return next(out) and out or nil
end

-- Processa subskills recursivamente (suporte ilimitado a níveis)
-- parentSkillsById: mapa de skills principais por ID (moduleName.skillName)
-- parentSkillsByName: mapa de skills principais por nome (compatibilidade)
-- parentPath: caminho hierárquico para gerar IDs únicos (ex: "skill1.subskill2")
-- moduleName: nome do módulo para gerar IDs únicos
local function processSubskills(subskills, suborder, parentSkillsById, parentSkillsByName, parentPath, moduleName)
if not subskills or not suborder or type(subskills) ~= "table" or type(suborder) ~= "table" then
return nil
end

local arr = {}
for idx, subName in ipairs(suborder) do
local sub = subskills[subName]
if type(sub) == "table" then
-- Gera ID único baseado no caminho hierárquico
-- Se parentPath existe, usa "parentPath.subName", senão usa apenas "subName"
-- Adiciona índice para garantir unicidade mesmo com nomes duplicados
local uniqueId = parentPath and (parentPath .. "." .. subName .. "." .. tostring(idx)) or
(subName .. "." .. tostring(idx))
-- FASE 1: Herança explícita com suporte a ID
-- inherit_from_id: ID da skill para herdar (prioridade)
-- inherit_from: Nome da skill para herdar (fallback legado)
-- inherit_fields: O QUE herdar (array de campos, obrigatório para herdar)
-- Se não especificar ambos, não herda nada (mais seguro)

local inheritFromId = sub.inherit_from_id -- ID da skill (prioridade)
local inheritFrom = sub.inherit_from -- Nome da skill (fallback legado)
local inheritFields = sub.inherit_fields or {} -- O QUE herdar (array)

-- Converte inheritFields para set para busca rápida
local inheritFieldsSet = {}
if type(inheritFields) == "table" then
for _, field in ipairs(inheritFields) do
if type(field) == "string" then
inheritFieldsSet[field] = true
end
end
end

-- FASE 1: Busca skill principal por ID primeiro, depois por nome (fallback)
local parentSkill = nil
if inheritFromId and parentSkillsById and type(parentSkillsById) == "table" then
parentSkill = parentSkillsById[inheritFromId]
end
-- Fallback legado: busca por nome
if not parentSkill and inheritFrom and parentSkillsByName and type(parentSkillsByName) == "table" then
parentSkill = parentSkillsByName[inheritFrom]
end

-- Função auxiliar: verifica se um campo DEVE ser herdado
-- Só herda se inherit_from E inherit_fields estiverem definidos E o campo estiver na lista
local function shouldInheritField(fieldName)
if not inheritFrom or not parentSkill then
return false -- Sem inherit_from ou parentSkill, não herda
end
return inheritFieldsSet[fieldName] == true -- Só herda se estiver em inherit_fields
end

-- Valida flags: deve ser uma tabela com pelo menos um elemento, senão nil
-- Flags herdam apenas se "flags" estiver em inherit_fields
-- Fallback: se sub.flags é string "aggro,bridge" (formato corrompido), converte para table
local subFlagsRaw = (sub.flags ~= nil) and sub.flags or
(shouldInheritField("flags") and parentSkill and parentSkill.flags)
local subFlags = subFlagsRaw
if type(subFlagsRaw) == "string" and subFlagsRaw:match("%S") then
local parts = {}
for part in (subFlagsRaw .. ","):gmatch("([^,]*)") do
part = trim(part)
if part ~= "" then table.insert(parts, part) end
end
if #parts > 0 then subFlags = parts end
end
local validSubFlags = (type(subFlags) == "table" and #subFlags > 0) and subFlags or nil

-- Cria o objeto da subskill, herdando apenas campos explicitamente listados em inherit_fields
local subObj = {
id = uniqueId, -- ID único para evitar colisão de nomes
display_name = subName, -- Nome para exibição (sem função lógica)
name = subName, -- Mantido para compatibilidade
n = subName, -- Mantido para compatibilidade
-- Herda icon apenas se "icon" estiver em inherit_fields
icon = sub.icon or (shouldInheritField("icon") and parentSkill and parentSkill.icon) or "",
-- Herda level apenas se "level" estiver em inherit_fields
level = sub.level or (shouldInheritField("level") and parentSkill and parentSkill.level) or "",
-- Herda energy apenas se "energy" estiver em inherit_fields
energy = (sub.energy ~= nil) and sub.energy or
(shouldInheritField("energy") and parentSkill and parentSkill.energy),
-- Herda powerpve apenas se "powerpve" estiver em inherit_fields
powerpve = (sub.powerpve ~= nil) and sub.powerpve or
(shouldInheritField("powerpve") and parentSkill and parentSkill.powerpve),
-- Herda powerpvp apenas se "powerpvp" estiver em inherit_fields
powerpvp = (sub.powerpvp ~= nil) and sub.powerpvp or
(shouldInheritField("powerpvp") and parentSkill and parentSkill.powerpvp),
-- Herda cooldown apenas se "cooldown" estiver em inherit_fields
cooldown = (sub.cooldown ~= nil) and sub.cooldown or
(shouldInheritField("cooldown") and parentSkill and parentSkill.cooldown),
-- Video sempre vem da subskill (nunca herda)
video = sub.video or "",
-- Descrição: sempre vem da subskill (nunca herda)
desc_i18n = nil, -- Será definido depois
-- Flags: herda apenas se "flags" estiver em inherit_fields
flags = validSubFlags,
-- Herda weapon apenas se "weapon" estiver em inherit_fields
weapon = (sub.weapon and processWeapon(sub.weapon)) or
(shouldInheritField("weapon") and parentSkill and processWeapon(parentSkill.weapon)),
-- Herda back apenas se "back" estiver em inherit_fields
back = (sub.back ~= nil) and sub.back or
(shouldInheritField("back") and parentSkill and parentSkill.back),
-- Inclui campos de herança para o frontend
inherit_from_id = inheritFromId or inheritFrom, -- ID ou nome (compatibilidade)
inherit_from = inheritFrom, -- Mantido para compatibilidade
inherit_fields = inheritFields
}

-- Descrição: sempre vem da subskill, nunca herda
-- PROTEÇÃO TOTAL: NUNCA copia descrição do parentSkill, mesmo que subskill não tenha
if sub.desc ~= nil or sub.descPt ~= nil or sub.descEn ~= nil or sub.descEs ~= nil or sub.descPl ~= nil then
subObj.desc_i18n = normalizeDesc(sub.desc, sub.descPt, sub.descEn, sub.descEs, sub.descPl)
else
subObj.desc_i18n = nil
end
-- GARANTIA: Remove qualquer campo legado de descrição que possa ter sido copiado acidentalmente
subObj.desc = nil
subObj.descPt = nil
subObj.descEn = nil
subObj.descEs = nil
subObj.descPl = nil

-- RECURSÃO NATIVA: processa sub-subskills (e sub-sub-subskills, etc.)
-- Passa parentSkillsById e parentSkillsByName para recursão (herança sempre vem das skills principais)
-- Passa uniqueId como parentPath para manter unicidade na hierarquia
if type(sub.subskills) == "table" and type(sub.suborder) == "table" then
subObj.subs = processSubskills(sub.subskills, sub.suborder, parentSkillsById, parentSkillsByName,
uniqueId, moduleName)
subObj.suborder = sub.suborder
end

table.insert(arr, subObj)
end
end

return #arr > 0 and arr or nil
end

-- Gera JSON de skills a partir do módulo
function p.skill(frame)
local parent = frame:getParent() or frame
local args = parent.args or {}

local moduleName = trim(args.module or "")
if moduleName == "" then
return "[]"
end

local data = requireCharModule(moduleName) or {}
if not data.order or not data.skills then
return "[]"
end

local skillsArr = {}

-- Se houver forms, obtém a primeira forma (usa forms_order se existir, ex: Chopper TS inicia em Brain Point)
local firstForm = nil
local firstFormName = nil
if type(data.forms) == "table" then
if type(data.forms_order) == "table" and #data.forms_order > 0 then
for _, formName in ipairs(data.forms_order) do
local formData = data.forms[formName]
if type(formData) == "table" and type(formData.skills) == "table" and type(formData.order) == "table" then
firstForm = formData
firstFormName = formName
break
end
end
end
if not firstForm then
for formName, formData in pairs(data.forms) do
if type(formData) == "table" and type(formData.skills) == "table" and type(formData.order) == "table" then
firstForm = formData
firstFormName = formName
break
end
end
end
end

-- Encontra a skill com form_switch = true (genérico)
local formSwitchSkillName = nil
local nextFixedSkillAfterFormSwitch = nil
if type(data.skills) == "table" then
for skillName, sk in pairs(data.skills) do
if type(sk) == "table" and sk.form_switch == true then
formSwitchSkillName = skillName
break
end
end

-- Encontra a próxima skill fixa depois do form_switch no order
if formSwitchSkillName and type(data.order) == "table" then
local foundFormSwitch = false
for _, skillName in ipairs(data.order) do
if foundFormSwitch then
-- Esta é a próxima skill fixa depois do form_switch
nextFixedSkillAfterFormSwitch = skillName
break
end
if skillName == formSwitchSkillName then
foundFormSwitch = true
end
end
end
end

-- FASE 1: Cria mapa de IDs das skills principais para lookup por ID
-- Este mapa será usado por processSubskills para buscar skills por ID
-- IMPORTANTE: Deve ser criado ANTES de processar forms para que possa ser usado em subskills de forms
local mainSkillsById = {}
local mainSkillsByName = {}

-- Pre-popula o mapa com todas as skills principais (necessário para forms também)
for skillName, sk in pairs(data.skills) do
if type(sk) == "table" then
local skillId = moduleName .. "." .. skillName
mainSkillsById[skillId] = sk
mainSkillsByName[skillName] = sk
end
end

-- Se houver forms, insere a primeira skill da forma ANTES da skill com form_switch
if firstForm and type(firstForm.skills) == "table" and type(firstForm.order) == "table" and #firstForm.order > 0 then
local firstSkillName = firstForm.order[1]
local formSk = firstForm.skills[firstSkillName]
if type(formSk) == "table" then
-- Valida flags: deve ser uma tabela com pelo menos um elemento, senão nil
local formFlags = nil
if type(formSk.flags) == "table" and #formSk.flags > 0 then
formFlags = formSk.flags
end

local formSkillObj = {
id = "form." .. firstSkillName, -- ID único para skills de forma
display_name = firstSkillName, -- Nome para exibição
name = firstSkillName, -- Mantido para compatibilidade
n = firstSkillName, -- Mantido para compatibilidade
icon = (formSk.icon and formSk.icon ~= "") and formSk.icon or "",
level = formSk.level or "NIVEL",
energy = formSk.energy,
powerpve = formSk.powerpve,
powerpvp = formSk.powerpvp,
cooldown = formSk.cooldown,
video = formSk.video or "",
desc_i18n = normalizeDesc(formSk.desc, formSk.descPt, formSk.descEn, formSk.descEs, formSk.descPl),
flags = formFlags,
weapon = processWeapon(formSk.weapon),
effect = formSk.effect
}
if type(formSk.subskills) == "table" and type(formSk.suborder) == "table" then
-- Para skills de forma, usa mainSkillsById e mainSkillsByName
formSkillObj.subs = processSubskills(formSk.subskills, formSk.suborder, mainSkillsById, mainSkillsByName,
formSkillObj.id, "form")
formSkillObj.suborder = formSk.suborder
end
table.insert(skillsArr, formSkillObj)
end
end

-- Itera sobre order para manter ordem correta (skills fixas)
local nextFixedSkillIndex = -1
for idx, skillName in ipairs(data.order) do
local sk = data.skills[skillName]
if type(sk) == "table" then
-- Valida flags: deve ser uma tabela com pelo menos um elemento, senão nil
-- Fallback: se flags veio como string "aggro,bridge" (formato corrompido pelo editor antigo), converte para table
local flagsToValidate = sk.flags
if type(sk.flags) == "string" and sk.flags:match("%S") then
local parts = {}
for part in (sk.flags .. ","):gmatch("([^,]*)") do
part = trim(part)
if part ~= "" then table.insert(parts, part) end
end
if #parts > 0 then flagsToValidate = parts end
end
local validFlags = nil
if type(flagsToValidate) == "table" and #flagsToValidate > 0 then
-- Verifica se todos os elementos são strings válidas
local allValid = true
for i, flag in ipairs(flagsToValidate) do
if type(flag) ~= "string" or flag == "" then
allValid = false
break
end
end
if allValid then
validFlags = flagsToValidate
else
-- Se houver elementos inválidos, cria uma cópia limpa
local cleanFlags = {}
for i, flag in ipairs(flagsToValidate) do
if type(flag) == "string" and flag ~= "" then
table.insert(cleanFlags, flag)
end
end
if #cleanFlags > 0 then
validFlags = cleanFlags
end
end
end

-- FASE 1: ID único obrigatório para skills principais
-- Usa moduleName como prefixo para garantir unicidade global
local skillId = moduleName .. "." .. skillName

local skillObj = {
id = skillId, -- ID único global (moduleName.skillName)
display_name = skillName, -- Nome para exibição (sem função lógica)
name = skillName, -- Mantido para compatibilidade
n = skillName, -- Mantido para compatibilidade
icon = (sk.icon and sk.icon ~= "") and sk.icon or "",
level = sk.level or "NIVEL",
energy = sk.energy,
powerpve = sk.powerpve,
powerpvp = sk.powerpvp,
cooldown = sk.cooldown,
video = sk.video or "",
desc_i18n = normalizeDesc(sk.desc, sk.descPt, sk.descEn, sk.descEs, sk.descPl),
flags = validFlags,
weapon = processWeapon(sk.weapon),
effect = sk.effect,
weaponicon = data.weaponicon,
form_switch = sk.form_switch,
form_videos = sk.form_videos,
-- Sistema genérico de swap de personagens (ex: Buchi & Sham, futuros personagens)
swap = sk.swap, -- true = skill de troca entre personagens
only_character = sk.only_character or "", -- String: nome do personagem que pode usar (ex: "Buchi", "Sham")
character_videos = sk.character_videos or
{} -- Tabela: { "CharacterName": "video.mp4" } - vídeos por personagem
}
local csProcessed = processCharacterSkills(sk.character_skills)
if csProcessed then
skillObj.character_skills = csProcessed
end

-- Processa subskills recursivamente (suporte nativo ilimitado)
-- Passa mainSkillsById e mainSkillsByName para lookup por ID ou nome
-- Passa skillObj.id como parentPath para gerar IDs únicos para subskills
if type(sk.subskills) == "table" and type(sk.suborder) == "table" then
skillObj.subs = processSubskills(sk.subskills, sk.suborder, mainSkillsById, mainSkillsByName, skillObj
.id, moduleName)
skillObj.suborder = sk.suborder
end

-- Valida flags antes de inserir no array (proteção extra)
if skillObj.flags and (type(skillObj.flags) ~= "table" or #skillObj.flags == 0) then
skillObj.flags = nil
end

table.insert(skillsArr, skillObj)

-- Se for a skill com form_switch e houver forms, adiciona a terceira skill da forma logo após
if skillName == formSwitchSkillName and firstForm and type(firstForm.skills) == "table" and type(firstForm.order) == "table" and #firstForm.order >= 2 then
local thirdSkillName = firstForm.order[2] -- Segunda na ordem = terceira skill (1, 2, 3)
local formSk = firstForm.skills[thirdSkillName]
if type(formSk) == "table" then
-- Valida flags: deve ser uma tabela com pelo menos um elemento, senão nil
local formFlags3 = nil
if type(formSk.flags) == "table" and #formSk.flags > 0 then
formFlags3 = formSk.flags
end

local formSkillObj = {
id = "form." .. thirdSkillName, -- ID único para skills de forma
display_name = thirdSkillName, -- Nome para exibição
name = thirdSkillName, -- Mantido para compatibilidade
n = thirdSkillName, -- Mantido para compatibilidade
icon = (formSk.icon and formSk.icon ~= "") and formSk.icon or "",
level = formSk.level or "NIVEL",
energy = formSk.energy,
powerpve = formSk.powerpve,
powerpvp = formSk.powerpvp,
cooldown = formSk.cooldown,
video = formSk.video or "",
desc_i18n = normalizeDesc(formSk.desc, formSk.descPt, formSk.descEn, formSk.descEs, formSk
.descPl),
flags = formFlags3,
weapon = processWeapon(formSk.weapon),
effect = formSk.effect
}
if type(formSk.subskills) == "table" and type(formSk.suborder) == "table" then
formSkillObj.subs = processSubskills(formSk.subskills, formSk.suborder, mainSkillsById,
mainSkillsByName, formSkillObj.id, "form")
formSkillObj.suborder = formSk.suborder
end
table.insert(skillsArr, formSkillObj)
end
end

-- Guarda índice da próxima skill fixa depois do form_switch para inserir a quinta skill depois
if skillName == nextFixedSkillAfterFormSwitch then
nextFixedSkillIndex = #skillsArr
end

-- Se for a próxima skill fixa depois do form_switch e houver forms,
-- adiciona TODAS as skills de forma a partir da 3ª posição (order[3..N])
-- em sequência contígua. Para forms com 3 skills isto equivale ao
-- comportamento antigo (inseria apenas order[3] = "quinta skill").
-- Para forms com 4+ skills, as extras ficam nos slots 6, 7, ...
if skillName == nextFixedSkillAfterFormSwitch and firstForm and type(firstForm.skills) == "table" and type(firstForm.order) == "table" and #firstForm.order >= 3 then
for extraIdx = 3, #firstForm.order do
local extraSkillName = firstForm.order[extraIdx]
local formSk = firstForm.skills[extraSkillName]
if type(formSk) == "table" then
local formFlagsExtra = nil
if type(formSk.flags) == "table" and #formSk.flags > 0 then
formFlagsExtra = formSk.flags
end

local formSkillObj = {
id = "form." .. extraSkillName,
display_name = extraSkillName,
name = extraSkillName,
n = extraSkillName,
icon = (formSk.icon and formSk.icon ~= "") and formSk.icon or "",
level = formSk.level or "NIVEL",
energy = formSk.energy,
powerpve = formSk.powerpve,
powerpvp = formSk.powerpvp,
cooldown = formSk.cooldown,
video = formSk.video or "",
desc_i18n = normalizeDesc(formSk.desc, formSk.descPt, formSk.descEn, formSk.descEs,
formSk.descPl),
flags = formFlagsExtra,
weapon = processWeapon(formSk.weapon),
effect = formSk.effect
}
if type(formSk.subskills) == "table" and type(formSk.suborder) == "table" then
formSkillObj.subs = processSubskills(formSk.subskills, formSk.suborder, mainSkillsById,
mainSkillsByName, formSkillObj.id, "form")
formSkillObj.suborder = formSk.suborder
end
table.insert(skillsArr, formSkillObj)
end
end
end
end
end

-- Adiciona emote no final (se existir no módulo)
if type(data.emote) == "table" and data.emote.video and data.emote.video ~= "" then
local emoteObj = {
id = moduleName .. ".Emote",
display_name = "Emote",
name = "Emote",
n = "Emote",
icon = "Emote.png",
level = "25",
video = data.emote.video or "",
desc = "",
desc_i18n = nil
}
table.insert(skillsArr, emoteObj)
end

-- Proteção contra erros no jsonEncode (especialmente para flags)
-- Limpa flags problemáticas ANTES de tentar serializar
-- NOTA: Não remove flags válidas, apenas valida e limpa flags inválidas
for _, skill in ipairs(skillsArr) do
if skill.flags then
if type(skill.flags) ~= "table" or #skill.flags == 0 then
skill.flags = nil
else
-- Limpa flags inválidas (não strings ou vazias)
local cleanFlags = {}
for i, flag in ipairs(skill.flags) do
if type(flag) == "string" and flag ~= "" then
table.insert(cleanFlags, flag)
end
end
if #cleanFlags > 0 then
skill.flags = cleanFlags
else
skill.flags = nil
end
end
end
-- Limpa flags em subskills também
if skill.subs and type(skill.subs) == "table" then
for _, sub in ipairs(skill.subs) do
if sub.flags then
if type(sub.flags) ~= "table" or #sub.flags == 0 then
sub.flags = nil
else
local cleanSubFlags = {}
for i, flag in ipairs(sub.flags) do
if type(flag) == "string" and flag ~= "" then
table.insert(cleanSubFlags, flag)
end
end
if #cleanSubFlags > 0 then
sub.flags = cleanSubFlags
else
sub.flags = nil
end
end
end
end
end
end

local ok, jsonResult = pcall(function()
return mw.text.jsonEncode(skillsArr)
end)
if ok and jsonResult then
return jsonResult
else
-- Última tentativa: remove TODAS as flags
for _, skill in ipairs(skillsArr) do
skill.flags = nil
if skill.subs and type(skill.subs) == "table" then
for _, sub in ipairs(skill.subs) do
sub.flags = nil
end
end
end
return mw.text.jsonEncode(skillsArr)
end
end

-- Gera JSON de forms a partir do módulo
function p.forms(frame)
local parent = frame:getParent() or frame
local args = parent.args or {}

local moduleName = trim(args.module or "")
if moduleName == "" then
return "{}"
end

local data = requireCharModule(moduleName) or {}
if not data.forms or type(data.forms) ~= "table" then
return "{}"
end

local formsData = {}
local function addForm(formName, formData)
if type(formData) ~= "table" or type(formData.skills) ~= "table" or type(formData.order) ~= "table" then
return
end
if formsData[formName] then return end -- já adicionado
local formSkills = {}
for _, skillName in ipairs(formData.order) do
local sk = formData.skills[skillName]
if type(sk) == "table" then
local formSkillFlags = nil
if type(sk.flags) == "table" and #sk.flags > 0 then
formSkillFlags = sk.flags
end
local skillObj = {
name = skillName,
n = skillName,
icon = (sk.icon and sk.icon ~= "") and sk.icon or "",
level = sk.level or "NIVEL",
energy = sk.energy,
powerpve = sk.powerpve,
powerpvp = sk.powerpvp,
cooldown = sk.cooldown,
video = sk.video or "",
desc_i18n = normalizeDesc(sk.desc, sk.descPt, sk.descEn, sk.descEs, sk.descPl),
flags = formSkillFlags,
weapon = processWeapon(sk.weapon)
}
if type(sk.subskills) == "table" and type(sk.suborder) == "table" then
skillObj.subs = processSubskills(sk.subskills, sk.suborder, data.skills)
skillObj.suborder = sk.suborder
end
table.insert(formSkills, skillObj)
end
end
formsData[formName] = { order = formData.order, skills = formSkills }
end

-- Usa forms_order se existir (ex: Chopper TS = Brain Point primeiro) para ordem consistente no JSON
if type(data.forms_order) == "table" and #data.forms_order > 0 then
for _, formName in ipairs(data.forms_order) do
local formData = data.forms[formName]
if formData then addForm(formName, formData) end
end
end
for formName, formData in pairs(data.forms) do
addForm(formName, formData)
end

return mw.text.jsonEncode(formsData)
end

-- Gera JSON de skins a partir do módulo
function p.skin(frame)
local parent = frame:getParent() or frame
local args = parent.args or {}

local moduleName = trim(args.module or "")
if moduleName == "" then
return "[]"
end

local data = requireCharModule(moduleName) or {}
if not data.skins or type(data.skins) ~= "table" then
return "[]"
end

-- Processa skins do módulo
local skinsArr = {}
for _, skin in ipairs(data.skins) do
if type(skin) == "table" then
local skinObj = {
name = skin.name or "",
sprite = skin.sprite or "",
tooltip = skin.tooltip or "",
offset_x = skin.offset_x,
tile = skin.tile or "",
tile_x = skin.tile_x,
tile_y = skin.tile_y,
youtube = skin.youtube
}

-- Se tooltip é table, converte para JSON string
if type(skin.tooltip) == "table" then
skinObj.tooltip = mw.text.jsonEncode(skin.tooltip)
end

table.insert(skinsArr, skinObj)
end
end

return mw.text.jsonEncode(skinsArr)
end

return p

Melhoria de Navio 5

2026-04-20T11:23:35Z

Gurren1: /* O Sedativo mais Forte */

[[Arquivo:Local Crocus.png|miniaturadaimagem|link=|Localização do '''Crocus''': ilha de Twin Cape.]]
{{Quest
|localizacao = Grand Line, em Twin Cape
|requisitos = Um personagem de nível 28, Navio nível 4
}}
__TOC__

= Sedativo para Laboon =
----
Crocus pediu para você coletar '''3 Flores Roxas Misteriosas''' e '''15 Frutas Amarelas Misteriosas'''. Elas podem ser encontradas em uma ilha a '''leste''' de Twin Cape.

<center>
<div style="display:flex; flex-wrap:wrap; justify-content:center; gap:8px;">
<div style="box-sizing:border-box;">
[[Arquivo:LocalFloresShipLv5.png|link=|commoldura|Ilha onde é possível coletar os itens necessários para o sedativo]]
</div>
<div style="box-sizing:border-box;">
[[File:ItensMisteriosos1.png|link=|commoldura|Primeiro andar: 2 Flores Roxas Misteriosas e 1 Fruta Amarela Misteriosa]]
</div>
<div style="box-sizing:border-box;">
[[File:ItensMisteriosos2.png|link=|commoldura|Segundo andar: 2 Frutas Amarelas Misteriosas e 1 Flor Roxa Misteriosa]]
</div>
</div>
</center>

Depois de coletar os itens, volte para Twin Cape e entregue para Crocus. Ele vai te recompensar com:

{{Reward|itens=Cotton;38, oak_log;30, Berries.gif;2000}}

= O Sedativo mais Forte =
----
Crocus precisa que você faça um '''sedativo''' para Laboon. Ele irá te entregar os seguintes itens:

{{Reward|ignore=1|itens=Pétalas Misteriosas;20, Parte de Fruta Misteriosa;30}}

Antes de começar a receita, compre os seguintes ingredientes:

{{Reward|ignore=1|itens=Água;1, alecrim;1, mel;1, camomila;1}}

Agora siga a receita para preparar o sedativo:

#Amasse os pedaços de Fruta Misteriosa no '''pilão''' para obter o item '''Suco Misterioso''' {{Icon|IconMysterious Juice.png|align=2px}}
#'''Ferva''' a '''Água''' com as '''Pétalas Misteriosas''' para criar '''Água Misteriosa''' {{Icon|IconMysterious Water.png|align=2px}}
#'''Misture''' o '''Suco Misterioso''' e a '''Água Misteriosa''' na '''tábua''' para formar a '''Mistura Misteriosa''' {{Icon|IconMix Mysterious.png|align=2px}}
#Coloque a Mistura Misteriosa, Camomila, Mel e Alecrim no '''Erlenmeyer''' para completar o Sedativo {{Icon|IconSedative.png|align=2px}}

[[Arquivo:MisturaCrocusFinal.png|centro|link=|commoldura|Última etapa da receita: combinando tudo no Erlenmeyer]]

Entregue o '''Sedativo''' {{Icon|IconSedative.png|align=2px}} para Crocus. Ele vai te recompensar com:

{{Reward|itens=berries.gif;10000, cola;1, iron ore;24, superior gun powder;5}}

= Cuidando do Laboon =
----
Crocus pediu para você entrar no estômago de Laboon, derrotar os monstros e aplicar o medicamento nos ferimentos internos.

Vá até o mar e entre na '''boca de Laboon'''. Uma missão especial será iniciada. Seu objetivo será:

* Derrotar os '''Reis dos Mares''' dentro do corpo de Laboon
* Aplicar o sedativo nos '''três ferimentos internos'''

Você pode aplicar o sedativo nos ferimentos '''sem precisar derrotar os monstros próximos''', mas para concluir a missão é necessário eliminar todos os inimigos.

<center>
<div style="display:flex; flex-wrap:wrap; justify-content:center; gap:8px;">
<div style="box-sizing:border-box;">
[[Arquivo:LocalBocaLaboonShipLv5.png|link=|commoldura|Entrada da missão]]
</div>
<div style="box-sizing:border-box;">
[[Arquivo:FerimentosLaboon.png|link=|commoldura|Localização dos '''3 ferimentos''' no corpo de Laboon e visual dos monstros que aparecem na missão]]
</div>
<div style="box-sizing:border-box;">
[[Arquivo:LocalFerimentoLaboonShipLv5.png|link=|commoldura|Visual do '''ferimento'''. Basta interagir com ele para aplicar o sedativo]]
</div>
</div>
</center>

Depois de curar os três ferimentos e eliminar os monstros, volte até '''Crocus''' para encerrar a missão. Ele vai te recompensar com:

{{Reward|itens=Cotton;20, oak_log;30, Berries.gif;800}}

= Procurando o Norio =
----
Crocus pediu para você encontrar '''Norio''' ao sudeste. Siga até o local demarcado no mapa.

[[Arquivo:LocalNorioShipLv5.png|centro|link=|commoldura|Localização de '''Norio''', ao sudeste de Twin Cape]]

Fale com '''Norio''' para concluir esta etapa.

== Escolta do Norio ==
----
Norio vai pedir sua ajuda para retornar com segurança até '''Twin Cape'''. Essa é uma missão especial onde '''morrer não gera penalidade'''.

Durante o trajeto da missão, você enfrentará '''6 monstros'''.

Ao concluir a escolta, você receberá:

{{Reward|itens=oak log;20, Cotton;23, Berries.gif;808}}

Depois de chegar em Twin Cape, fale com '''Crocus'''. Ele vai te recompensar com:

{{Reward|itens=Berries;2000, Pose;1|ilha=Twin Cape}}

= A Carga Roubada =
----
Norio contou que seu navio foi danificado e talvez nunca mais volte a navegar. Crocus pede para você investigar os destroços e descobrir para onde foi levada a carga que ele aguardava.

Os saqueadores seguiram rumo ao sudoeste. Interaja com os destroços para avançar.

[[Arquivo:LocalDestroçosShipLv5.png|centro|link=|commoldura|Interaja com os '''destroços''' ao sudoeste para iniciar a investigação.]]

== A Carga Roubada – Rastreando as pistas (Partes 2, 3 e 4) ==
----
Continue a investigação seguindo os locais marcados com o ícone da lupa {{Icon|IconLupaquest.png|align=1px}}.

Você não precisa realizar nenhuma ação além de chegar até cada ponto e interagir com o local. Ao chegar na última pista, a missão avançará automaticamente para a Parte 5.

== A Carga Roubada – Parte 5 ==
----
Siga para o esconderijo dos ladrões localizado mais ao '''sudoeste''' e entre nele.

<center>
<div style="display: flex; flex-wrap: wrap; justify-content: center; gap: 8px;">
<div style="box-sizing: border-box;">
[[Arquivo:EsconderijoShipLv5.png|link=|commoldura|Entrada do esconderijo dos ladrões]]
</div>
<div style="box-sizing: border-box;">
[[Arquivo:EscadasEsconderijoShipLv5.png|link=|commoldura|Você encontrará vários '''BW Millions'''. É recomendado estar pelo menos '''nível 70''']]
</div>
<div style="box-sizing: border-box;">
[[Arquivo:CaminhoEsconderijoShipLv5.png|link=|commoldura|No último andar, siga pelo corredor à direita até encontrar a '''Miss Wednesday''']]
</div>
</div>
</center>

Interaja com ela e '''ameace''' até que ela revele o paradeiro da carga.

== A Carga Roubada – Parte 6 ==
----
Miss Wednesday contará que '''Mr. 9''' levou a carga para '''Whisky Peak'''. A carga está marcada com a letra '''C'''.

Procure pelo navio da Baroque Works nos arredores.

<center>
<div style="display:flex; flex-wrap:wrap; justify-content:center; gap:8px;">
<div style="box-sizing:border-box;">
[[Arquivo:NavioBaroqueWorksShipLv5.png|link=|commoldura|Derrote o navio. Quando ele piscar em vermelho, '''interaja/clique''' para entrar na missão instanciada.]]
</div>
<div style="box-sizing:border-box;">
[[Arquivo:InstanciaNavioBWShipLv5.png|link=|commoldura|Dentro do navio, derrote os '''BW Millions''' e desça as escadas até encontrar a carga]]
</div>
<div style="box-sizing:border-box;">
[[Arquivo:LocalCargaCrocusShipLv5.png|link=|commoldura|
<div style="text-align:center;">
Vá até o local marcado para pegar a carga roubada. As celas podem ser destruídas para libertar piratas que vão ajudar a derrotar os BW Millions nesse andar.
</div>]]
</div>
</div>
</center>Após recuperar a carga, suba as escadas e saia pela lateral direita do navio

== A Carga Roubada – Final ==
----
Volte para Twin Cape e entregue o carregamento recuperado para Crocus. Ele irá te recompensar com:

{{Reward|itens=Superior gun powder;5, iron ore;20, Cotton;25, Berries.gif;2000}}

=Navegador Destemido=
----
Crocus pediu para você provar que sabe navegar na Grand Line, e para isso, precisará derrotar:
*7x Thunong
*7x Shaking
*7x Serpion
[[Arquivo:UpgradeShipQuestFinal.png|link=|centro|commoldura|Você pode encontrar '''Serpions''' ao norte de Whisky Peak, '''Thunongs''' podem ser facilmente encontrados em Boin Archipelago, e '''Shakings''' podem ser encontrados do lado Oeste próximos de Whisky Peak.]]

Após derrotar todos os monstros volte para falar com Crocus.
{{Reward|itens=Berries.gif;5000, Cola;3, Superior gun powder;10, Cannon ball;4, Iron ore;60, Cotton;85, Oak log;70}}

<br>
{{Achievement
|imagem = Tecnologia_de_navio
|titulo = Tecnologia de Navio V
|descricao = Desbloqueou o Arsenal nível 5!
|itens = Chest key piece:1, Profile icon box:1
}}

Baby 5

2026-04-20T03:59:09Z

Gurren1:

Baby 5

2026-04-20T03:57:22Z

Gurren1:

Usuário:Gurren1

2026-04-14T17:26:05Z

Gurren1: inicio da página sobre o site do suporte gla

__NOTOC__

Suporte GLA:

= Donate =

* alternativa para fazer doações por pix, boleto efí, pagbank e cielo fora do jogo
* histórico das ultimas doações
* saiba mais sobre doações aqui (ancora)

= Tickets =

* criação de tickets
* histórico recente de tickets, pode ser limpado periodicamente
* importante para verificar tickets respondidos, fazer tickets sobre bugs, denúncias, doações, recuperação de conta ou dúvidas objetivas sobre o jogo. exclusivamente para essas categorias, qualquer coisa fora desse escopo a equipe vai orientar o canal correto.
* saiba mais sobre os tickets (ancora)

= Authorized Machines =

* lista de máquinas autorizadas
* pode remover máquinas autorizadas caso desconfie de um dispositivo que foi comprometido e ainda faz parte dos acessos da conta
* saiba mais como autorizar seu dispositivo (PC/Mobile) aqui (ancora)

= Account Settings =

* detalhes da conta como e-mail, status da VIP, saldo de gemas da conta e status do e-mail.
* pode trocar o e-mail da conta através dessa página, se não tiver acesso a conta mas souber e-mail e senha pode acessar a página e realizar a troca manualmente pelo site.

Criadores de Conteúdo

2026-04-14T17:11:40Z

Gurren1:

__NOTOC__

Há um programa de parceria voltado a criadores de conteúdo que produzem conteúdos sobre o jogo, com '''recompensas exclusivas''', formas de destaque dentro da comunidade e também recursos que ajudam a movimentar e divulgar esses conteúdos, como chaves para sorteio e possíveis convites para transmissões de eventos especiais do jogo.

<div style="font-size: 1.8em; font-weight: normal; margin: 0 0 0.2em 0;">
Informações Importantes
</div>
*Todo canal é avaliado pela equipe. Atualmente, as recompensas da parceria são voltadas apenas para canais da '''Twitch''' e do '''YouTube'''.
*A solicitação da parceria deve ser realizada por meio de um [https://support.gla.com.br/tickets '''<big>Ticket</big>''']. No pedido, envie o nome ou link do canal. No caso da Twitch, os VODs devem estar disponíveis para que a equipe consiga avaliar as transmissões anteriores.
*Não é obrigatório utilizar ambas as plataformas ('''Twitch''' e '''YouTube''') para ser elegível às recompensas.
*Canais que exibirem conteúdo incompatível com o perfil buscado pela equipe, especialmente quando houver violação das regras do jogo ou incentivo a esse tipo de conduta, não serão elegíveis às recompensas.
*'''Canais parceiros''' cujo responsável violar as regras do jogo, ou que transmitirem conteúdo relacionado à violação das regras e termos do jogo, poderão ter a parceria e as recompensas revogadas.

=Recompensas e Requisitos=
----
Antes de conferir os requisitos de cada recompensa, é importante destacar que um dos principais critérios avaliados pela equipe é o '''bom histórico''' do criador de conteúdo dentro do jogo e também em nossa comunidade no Discord.

As recompensas são enviadas por correio ao criador de conteúdo. Com exceção das chaves de baú da Twitch, todas as demais recompensas são '''itens exclusivos para a conta do jogador'''.
<tabber>
|-|Skin de Navio=
{{#widget:CreatorReward
| sprite = The Streamer.png
| title = Skin de navio
| desc = Skins exclusivas para o criador de conteúdo, uma de cada plataforma.
| yt_req = *500 inscritos *2 vídeos/mês
| tw_req = *500 seguidores *3 transmissões/mês
| gif = CreatorBoats.gif
}}
|-|Cargo Content Creator=
{{#widget:CreatorReward
| sprite = Discord_Mini_Icon.png
| title = Cargo "Content Creator"
| desc = Cargo exclusivo no servidor oficial do Discord.
| yt_req = *500 inscritos *2 vídeos/mês
| tw_req = *250 seguidores *3 transmissões/mês
}}
|-|Chaves para Sorteio=
{{#widget:CreatorReward
| sprite = Twitch_Chest_Key.png
| title = Chave de Baú da Twitch
| desc = Chaves exclusivas, enviadas para apoiar nos sorteios das transmissões. Esse item pode ser trocado entre jogadores ou vendido/comprado no Market.
| yt_req = *800 inscritos
| yt_note = Avaliação é feita com base na frequência de vídeos e média de views.
| tw_req = *800 seguidores *8 transmissões/mês *média de 25 viewers
}}
|-|Ícone Exclusivo=
{{#widget:CreatorReward
| sprite = Profile_Icon_Exclusive.png
| title = Ícone de Perfil
| desc = Recompensa exclusiva para criadores de conteúdo parceiros.
| yt_req = *1.000 inscritos
| yt_note = Avaliação é feita com base na frequência de vídeos e média de views.
| tw_req = *1.000 seguidores *8+ transmissões/mês *média 25–30 viewers *transmitindo GLA há 2+ meses
}}
</tabber>

Usuário:Gurren1

2026-04-14T17:11:21Z

Gurren1:

Usuário:Gurren1

2026-04-13T23:13:05Z

2026-04-13T22:44:50Z

Gurren1: