401 lines
14 KiB
JavaScript
401 lines
14 KiB
JavaScript
/**
|
|
* sotc-battle-show-ability — SpeedDiePanelApp
|
|
* Fenêtre Application FoundryVTT affichant le panneau d'un Dé de Vitesse.
|
|
*
|
|
* Architecture SotC :
|
|
* - 1 token avec N dés de vitesse → N combatants dans le tracker
|
|
* - Combatant principal : flags.sotc.isSpeedDieClone absent/false
|
|
* - Clones : flags.sotc.isSpeedDieClone = true, flags.sotc.speedDieIndex = i
|
|
* - État utilisé : combatant.flags.sotc.used (boolean)
|
|
* - Compétence assignée : flag module "sotc-battle-show-ability" → "assignedSkillId"
|
|
*/
|
|
|
|
export class SpeedDiePanelApp extends Application {
|
|
|
|
constructor(combatantId, options = {}) {
|
|
super(options);
|
|
this.combatantId = combatantId;
|
|
this._activeTab = "skills";
|
|
this._previewSkillId = null;
|
|
}
|
|
|
|
static get defaultOptions() {
|
|
return foundry.utils.mergeObject(super.defaultOptions, {
|
|
id: "sotc-bsa-panel",
|
|
title: game.i18n.localize("SOTC_BSA.Panel.Title"),
|
|
template: "modules/sotc-battle-show-ability/templates/speed-die-panel.hbs",
|
|
classes: ["sotc-bsa-window"],
|
|
width: 320,
|
|
height: "auto",
|
|
resizable: false,
|
|
popOut: true
|
|
});
|
|
}
|
|
|
|
/* ------------------------------------------------------------------ */
|
|
/* Helpers */
|
|
/* ------------------------------------------------------------------ */
|
|
|
|
get combatant() {
|
|
return game.combat?.combatants.get(this.combatantId) ?? null;
|
|
}
|
|
|
|
get actor() {
|
|
return this.combatant?.actor ?? null;
|
|
}
|
|
|
|
get dieNumber() {
|
|
// Position visuelle 1-based dans l'ordre SIO (tri par initiative décroissante)
|
|
return this.sioMarkerIndex + 1;
|
|
}
|
|
|
|
get dieState() {
|
|
const c = this.combatant;
|
|
if (!c) return 0;
|
|
// Si une compétence est assignée, l'état est toujours forcé à 3 (Assigned)
|
|
if (this.assignedSkillId) return 3;
|
|
const state = c.getFlag("sotc-battle-show-ability", "dieState");
|
|
if (state === undefined || state === null) {
|
|
return c.getFlag("sotc", "used") ? 1 : 0;
|
|
}
|
|
return state;
|
|
}
|
|
|
|
get assignedSkillId() {
|
|
return this.combatant?.getFlag("sotc-battle-show-ability", "assignedSkillId") ?? null;
|
|
}
|
|
|
|
/**
|
|
* Calcule l'index du marqueur SIO pour ce combatant.
|
|
* SIO trie les combatants par initiative décroissante — le combatant avec
|
|
* la plus haute initiative est à l'index 0 (marqueur le plus à gauche).
|
|
* speedDieIndex est fixe à la création et ne reflète pas cet ordre.
|
|
*/
|
|
get sioMarkerIndex() {
|
|
const combatant = this.combatant;
|
|
if (!combatant) return 0;
|
|
const tokenId = combatant.tokenId;
|
|
const sorted = game.combat.combatants
|
|
.filter(c => c.tokenId === tokenId)
|
|
.sort((a, b) => (b.initiative ?? -Infinity) - (a.initiative ?? -Infinity));
|
|
const idx = sorted.findIndex(c => c.id === combatant.id);
|
|
return idx === -1 ? 0 : idx;
|
|
}
|
|
|
|
/* ------------------------------------------------------------------ */
|
|
/* getData */
|
|
/* ------------------------------------------------------------------ */
|
|
|
|
async getData(options = {}) {
|
|
const actor = this.actor;
|
|
const combatant = this.combatant;
|
|
|
|
if (!actor || !combatant) return { error: true };
|
|
|
|
const sys = actor.system;
|
|
|
|
const hpValue = sys.health?.value ?? 0;
|
|
const hpMax = sys.health?.max ?? 1;
|
|
const staggerValue = sys.stagger?.value ?? 0;
|
|
const staggerMax = sys.stagger?.max ?? 1;
|
|
const lightValue = sys.light?.value ?? 0;
|
|
const lightMax = sys.light?.max ?? 1;
|
|
const emotion = sys.emotion ?? 0;
|
|
|
|
const assignedId = this.assignedSkillId;
|
|
|
|
const mapItem = (item) => {
|
|
const lc = item.system.light_cost ?? 0;
|
|
const ec = item.system.emotion_cost ?? 0;
|
|
return {
|
|
id: item.id,
|
|
name: item.name,
|
|
img: item.img,
|
|
lightCost: lc,
|
|
emotionCost: ec,
|
|
canAffordLight: lightValue >= lc,
|
|
canAffordEmotion: emotion >= ec,
|
|
selected: item.id === this._previewSkillId,
|
|
weight: item.system.weight ?? 0
|
|
};
|
|
};
|
|
|
|
const skills = actor.items.filter(i => i.type === "skill").map(mapItem);
|
|
const egos = actor.items.filter(i => i.type === "ego").map(mapItem);
|
|
|
|
let assignedSkill = null;
|
|
if (assignedId) {
|
|
const item = actor.items.get(assignedId);
|
|
if (item) assignedSkill = { id: item.id, name: item.name, img: item.img };
|
|
}
|
|
|
|
let selectedSkillPreview = null;
|
|
if (this._previewSkillId) {
|
|
const item = actor.items.get(this._previewSkillId);
|
|
if (item) {
|
|
const rawDice = item.system.dice?.die ?? [];
|
|
const diceArr = Array.isArray(rawDice) ? rawDice : Object.values(rawDice);
|
|
selectedSkillPreview = {
|
|
name: item.name,
|
|
dice: diceArr.map(d => ({
|
|
type: d.type ?? "slash",
|
|
formula: d.formula ?? "",
|
|
mods: Array.isArray(d.mods) ? d.mods.filter(m => m) : Object.values(d.mods ?? {}).filter(m => m)
|
|
})),
|
|
modules: item.system.skill_modules?.mods
|
|
? (Array.isArray(item.system.skill_modules.mods)
|
|
? item.system.skill_modules.mods.filter(m => m).join(" | ")
|
|
: String(item.system.skill_modules.mods))
|
|
: ""
|
|
};
|
|
}
|
|
}
|
|
|
|
const arrowStore = globalThis.sotcClashArrow?.ArrowStore ?? null;
|
|
const sioIdx = this.sioMarkerIndex;
|
|
const hasArrows = arrowStore && combatant?.tokenId
|
|
? arrowStore.all().some(a => a.fromToken === combatant.tokenId && a.fromDie === sioIdx)
|
|
: false;
|
|
|
|
return {
|
|
tokenId: combatant.tokenId,
|
|
combatantId: this.combatantId,
|
|
actorId: actor.id,
|
|
tokenName: combatant.name,
|
|
tokenImg: actor.img,
|
|
isClone: !!combatant.getFlag("sotc", "isSpeedDieClone"),
|
|
dieNumber: this.dieNumber,
|
|
hpValue, hpMax,
|
|
hpPercent: Math.max(0, Math.min(100, Math.round((hpValue / hpMax) * 100))),
|
|
staggerValue, staggerMax,
|
|
staggerPercent: Math.max(0, Math.min(100, Math.round((staggerValue / staggerMax) * 100))),
|
|
lightValue, lightMax,
|
|
emotion,
|
|
skills,
|
|
egos,
|
|
assignedSkill,
|
|
selectedSkillPreview,
|
|
dieState: this.dieState,
|
|
activeTab: this._activeTab,
|
|
hasArrows,
|
|
};
|
|
}
|
|
|
|
/* ------------------------------------------------------------------ */
|
|
/* Listeners */
|
|
/* ------------------------------------------------------------------ */
|
|
|
|
activateListeners(html) {
|
|
super.activateListeners(html);
|
|
|
|
html.find(".open-sheet").click(ev => {
|
|
const actorId = ev.currentTarget.dataset.actorId;
|
|
const actor = game.actors.get(actorId);
|
|
actor?.sheet?.render(true);
|
|
});
|
|
|
|
html.find(".bsa-tab").click(ev => {
|
|
const tab = ev.currentTarget.dataset.tab;
|
|
this._activeTab = tab;
|
|
html.find(".bsa-tab").removeClass("active");
|
|
html.find(".bsa-tab-content").removeClass("active");
|
|
ev.currentTarget.classList.add("active");
|
|
html.find(`.bsa-tab-${tab}`).addClass("active");
|
|
});
|
|
|
|
html.find(".bsa-skill-row").click(ev => {
|
|
if (ev.target.closest(".bsa-btn-assign")) return;
|
|
const skillId = ev.currentTarget.dataset.skillId;
|
|
this._previewSkillId = (this._previewSkillId === skillId) ? null : skillId;
|
|
this.render(false);
|
|
});
|
|
|
|
html.find(".bsa-btn-assign").click(ev => {
|
|
ev.stopPropagation();
|
|
const skillId = ev.currentTarget.dataset.skillId;
|
|
this._onAssignSkill(skillId);
|
|
});
|
|
|
|
html.find(".bsa-btn-unassign").click(() => {
|
|
this._onUnassignSkill();
|
|
});
|
|
|
|
html.find(".bsa-btn-remove-arrows").click(() => {
|
|
this._onRemoveArrows();
|
|
});
|
|
|
|
html.find(".bsa-state-btn").click(ev => {
|
|
const state = parseInt(ev.currentTarget.dataset.state);
|
|
this._onSetDieState(state);
|
|
});
|
|
}
|
|
|
|
/* ------------------------------------------------------------------ */
|
|
/* Actions */
|
|
/* ------------------------------------------------------------------ */
|
|
|
|
// Gérer l'assignation d'une compétence au dé de vitesse
|
|
async _onAssignSkill(skillId) {
|
|
const actor = this.actor;
|
|
const combatant = this.combatant;
|
|
if (!actor || !combatant) return;
|
|
|
|
const item = actor.items.get(skillId);
|
|
if (!item) return;
|
|
|
|
if (this.assignedSkillId) {
|
|
ui.notifications.warn(game.i18n.localize("SOTC_BSA.Panel.AlreadyAssigned"));
|
|
return;
|
|
}
|
|
|
|
const lightCost = item.system.light_cost ?? 0;
|
|
const emotionCost = item.system.emotion_cost ?? 0;
|
|
const currentLight = actor.system.light?.value ?? 0;
|
|
const currentEmotion = actor.system.emotion ?? 0;
|
|
|
|
if (lightCost > 0 && currentLight < lightCost) {
|
|
ui.notifications.error(
|
|
game.i18n.format("SOTC_BSA.Panel.InsufficientLight", { cost: lightCost, current: currentLight })
|
|
);
|
|
return;
|
|
}
|
|
|
|
if (emotionCost > 0 && currentEmotion < emotionCost) {
|
|
ui.notifications.error(
|
|
game.i18n.format("SOTC_BSA.Panel.InsufficientEmotion", { cost: emotionCost, current: currentEmotion })
|
|
);
|
|
return;
|
|
}
|
|
|
|
const updates = {};
|
|
if (lightCost > 0) updates["system.light.value"] = Math.max(0, currentLight - lightCost);
|
|
if (emotionCost > 0) updates["system.emotion"] = Math.max(0, currentEmotion - emotionCost);
|
|
if (Object.keys(updates).length > 0) await actor.update(updates);
|
|
|
|
await combatant.setFlag("sotc-battle-show-ability", "assignedSkillId", skillId);
|
|
// Toujours forcer l'état à 3 (Assigned) dès qu'une compétence est assignée
|
|
await combatant.setFlag("sotc-battle-show-ability", "dieState", 3);
|
|
await combatant.setFlag("sotc", "used", true);
|
|
|
|
// Mettre le marqueur SIO à l'état 3 (DiceSlotIcon4) pour indiquer l'assignation
|
|
const tokenDocAssign = combatant.token;
|
|
if (tokenDocAssign && game.modules.get("stars-initiative-overlay")?.active) {
|
|
const dieIndexAssign = this.sioMarkerIndex;
|
|
const numDiceAssign = combatant.actor?.system?.speed_dice?.num_dice ?? 1;
|
|
const statesAssign = [...(tokenDocAssign.getFlag("stars-initiative-overlay", "diceStates") || [])];
|
|
while (statesAssign.length < numDiceAssign) statesAssign.push(0);
|
|
statesAssign[dieIndexAssign] = 3;
|
|
await tokenDocAssign.setFlag("stars-initiative-overlay", "diceStates", statesAssign);
|
|
}
|
|
|
|
ui.notifications.info(game.i18n.localize("SOTC_BSA.Panel.AssignSuccess"));
|
|
this._previewSkillId = null;
|
|
this.render(false);
|
|
}
|
|
|
|
// Gérer la désassignation de la compétence du dé de vitesse
|
|
async _onUnassignSkill() {
|
|
const combatant = this.combatant;
|
|
const actor = this.actor;
|
|
if (!combatant || !actor) return;
|
|
|
|
const skillId = this.assignedSkillId;
|
|
if (skillId) {
|
|
const item = actor.items.get(skillId);
|
|
if (item) {
|
|
const lightCost = item.system.light_cost ?? 0;
|
|
const emotionCost = item.system.emotion_cost ?? 0;
|
|
const updates = {};
|
|
|
|
if (lightCost > 0) {
|
|
const currentLight = actor.system.light?.value ?? 0;
|
|
const maxLight = actor.system.light?.max ?? currentLight;
|
|
updates["system.light.value"] = Math.min(currentLight + lightCost, maxLight);
|
|
}
|
|
if (emotionCost > 0) {
|
|
const currentEmotion = actor.system.emotion ?? 0;
|
|
updates["system.emotion"] = currentEmotion + emotionCost;
|
|
}
|
|
|
|
if (Object.keys(updates).length > 0) await actor.update(updates);
|
|
}
|
|
}
|
|
|
|
// On force l'ordre : d'abord on retire l'assignation, puis on met l'état à 0
|
|
await combatant.unsetFlag("sotc-battle-show-ability", "assignedSkillId");
|
|
await combatant.setFlag("sotc-battle-show-ability", "dieState", 0);
|
|
await combatant.setFlag("sotc", "used", false);
|
|
|
|
// Synchronisation SIO
|
|
const tokenDoc = combatant.token;
|
|
if (tokenDoc && game.modules.get("stars-initiative-overlay")?.active) {
|
|
const dieIndex = this.sioMarkerIndex;
|
|
const numDice = combatant.actor?.system?.speed_dice?.num_dice ?? 1;
|
|
const states = [...(tokenDoc.getFlag("stars-initiative-overlay", "diceStates") || [])];
|
|
while (states.length < numDice) states.push(0);
|
|
states[dieIndex] = 0; // on force explicitement à Unused
|
|
|
|
await tokenDoc.setFlag("stars-initiative-overlay", "diceStates", states);
|
|
}
|
|
|
|
this._previewSkillId = null;
|
|
this.render(false);
|
|
}
|
|
|
|
// Gérer le changement d'état du dé de vitesse (Unused, Used, Saved, Assigned)
|
|
_onRemoveArrows() {
|
|
const arrowStore = globalThis.sotcClashArrow?.ArrowStore ?? null;
|
|
if (!arrowStore) { ui.notifications.warn("sotc-clash-arrow n'est pas actif."); return; }
|
|
const combatant = this.combatant;
|
|
if (!combatant) return;
|
|
const tokenId = combatant.tokenId;
|
|
const sioIdx = this.sioMarkerIndex;
|
|
const toRemove = arrowStore.all()
|
|
.filter(a => a.fromToken === tokenId && a.fromDie === sioIdx)
|
|
.map(a => a.id);
|
|
if (toRemove.length === 0) { ui.notifications.info("Aucune flèche à retirer pour ce dé."); return; }
|
|
for (const id of toRemove) arrowStore.removeArrow(id);
|
|
ui.notifications.info(`${toRemove.length} flèche(s) retirée(s).`);
|
|
this.render(false);
|
|
}
|
|
|
|
async _onSetDieState(state) {
|
|
const combatant = this.combatant;
|
|
if (!combatant) return;
|
|
|
|
// Si une compétence est assignée, l'état est verrouillé à 3
|
|
const effectiveState = this.assignedSkillId ? 3 : state;
|
|
|
|
await combatant.setFlag("sotc-battle-show-ability", "dieState", effectiveState);
|
|
|
|
const isUsed = (effectiveState === 1 || effectiveState === 2 || effectiveState === 3);
|
|
await combatant.setFlag("sotc", "used", isUsed);
|
|
|
|
// Synchroniser le flag SIO pour mettre à jour l'icône PIXI
|
|
const tokenDoc = combatant.token;
|
|
if (tokenDoc && game.modules.get("stars-initiative-overlay")?.active) {
|
|
const dieIndex = this.sioMarkerIndex;
|
|
const numDice = combatant.actor?.system?.speed_dice?.num_dice ?? 1;
|
|
const currentStates = tokenDoc.getFlag("stars-initiative-overlay", "diceStates") || [];
|
|
const states = [...currentStates];
|
|
while (states.length < numDice) states.push(0);
|
|
states[dieIndex] = effectiveState;
|
|
await tokenDoc.setFlag("stars-initiative-overlay", "diceStates", states);
|
|
}
|
|
|
|
ui.notifications.info(game.i18n.localize("SOTC_BSA.Panel.StateChanged"));
|
|
this.render(false);
|
|
}
|
|
|
|
/* ------------------------------------------------------------------ */
|
|
/* Validité */
|
|
/* ------------------------------------------------------------------ */
|
|
|
|
_checkStillValid() {
|
|
if (!game.combat || !this.combatant) {
|
|
this.close();
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
}
|