foundryvtt-reve-de-dragon/module/tmr/draconique.js

170 lines
5.2 KiB
JavaScript
Raw Normal View History

import { TYPES } from "../item.js";
import { TMRUtility } from "../tmr-utility.js";
import { PixiTMR } from "./pixi-tmr.js";
const registeredEffects = [
]
/**
* Définition des informations d'une "draconique" (queue, ombre, tête, souffle) qui influence les TMR
*/
export class Draconique {
static isCaseTMR(item) { return item.type == TYPES.casetmr; }
static isQueueDragon(item) { return item.isQueueDragon(); }
2023-10-20 22:18:37 +02:00
static isSouffleDragon(item) { return item.type == TYPES.souffle; }
static isTeteDragon(item) { return item.type == TYPES.tete; }
static isQueueSouffle(item) { return Draconique.isQueueDragon(item) || Draconique.isSouffleDragon(item); }
2022-06-12 12:14:55 +02:00
tmrLabel(linkData) { return TMRUtility.getTMRLabel(linkData.system.coord); }
static register(draconique) {
registeredEffects[draconique.code()] = draconique;
if (draconique.img()) {
PixiTMR.register(draconique.code(), draconique.img())
}
return draconique;
}
static all() {
return Object.values(registeredEffects);
}
static get(code) {
return registeredEffects[code];
}
/**
* @param item un Item quelconque
* @returns true si l'item correspond
*/
match(item) {
return Draconique.isQueueDragon(item) || Draconique.isSouffleDragon(item) || Draconique.isTeteDragon(item);
}
/**
* @returns un message à afficher si la draconique doit être gérée manuellement.
*/
manualMessage() {
return false;
}
/**
* Méthode responsable de gérer une draconique (par exemple, ajouter des casetmr pour la fermeture des cités).
* @param actor auquel la draconique est ajoutée
*/
async onActorCreateOwned(actor, item) {
return false;
}
async onActorDeleteOwned(actor, item) {
this.deleteCasesTmr(actor, item);
return false;
}
async onActorDeleteCaseTmr(actor, casetmr) {
return false;
}
/**
* @return le code interne utilisé pour les casetmr correpondant
*/
code() { return undefined }
/**
* @param {*} linkData données associées au token pixi (une casetmr, un sort en réserve, une rencontre en attente)
* @returns un tooltip à afficher au dessus du token
*/
tooltip(linkData) { return undefined }
/**
* @param {*} img l'url du fichier image à utiliser pour le token. Si indéfini (et si createSprite n'est pas surchargé),
* un disque est utilisé.
2023-10-20 22:18:37 +02:00
*/
img() { return undefined }
/**
2023-10-20 22:18:37 +02:00
* factory d'élément graphique PIXI correspondant à l'objet draconique
* @param {*} pixiTMR instance de PixiTMR qui gère les tooltips, les méthodes de création de sprite standard, les clicks.
2023-10-20 22:18:37 +02:00
*/
token(pixiTMR, linkData, coordTMR, type = undefined) {
const token = {
sprite: this.createSprite(pixiTMR),
coordTMR: coordTMR
};
token[type ?? this.code()] = linkData;
2023-10-20 22:18:37 +02:00
this.linkData = linkData;
if (this.tooltip(linkData)) {
pixiTMR.addTooltip(token.sprite, (e, s) => this.computeTooltip(e, s));
}
return token;
}
2023-10-20 22:18:37 +02:00
/**
* methode en charge de recalculer le tooltip lorsque la souris bouge
* @param {*} event evenement contenant les coordonnées
* @param {*} sprite sprite pour laquelle calculer le tooltip
*/
computeTooltip(event, sprite) {
if (sprite.isOver) {
const oddq = TMRUtility.computeEventOddq(event);
const coord = TMRUtility.oddqToCoordTMR(oddq);
const tmr = TMRUtility.getTMR(coord)
if (tmr){
const label = TMRUtility.getTMRLabel(coord);
const text = this.tooltip(this.linkData);
return text ? `${coord}: ${label}\n${text}` : `${coord}: ${label}`
}
}
return '';
}
/**
* factory d'élément graphique PIXI correpsondant à l'objet draconique
* @param {*} pixiTMR instance de PixiTMR qui gère les tooltips, les méthodes de création de sprite standard, les clicks.
*/
createSprite(pixiTMR) {
if (this.img()) {
return pixiTMR.sprite(this.code());
}
else {
return pixiTMR.circle()
}
}
/**
*
* @param {*} item un item à tester
* @param {*} coord les coordonnées d'une case. Si undefined toute case du type correspondra,
*/
isCase(item, coord = undefined) {
2022-06-12 12:14:55 +02:00
return Draconique.isCaseTMR(item) && item.system.specific == this.code() && (coord ? item.system.coord == coord : true);
}
2023-10-20 22:18:37 +02:00
find(list, coord = undefined) {
2022-06-12 12:14:55 +02:00
return list.find(c => this.isCase(c, coord));
}
2023-10-20 22:18:37 +02:00
async createCaseTmr(actor, label, tmr, sourceId = undefined) {
const casetmrData = {
name: label, type: 'casetmr', img: this.img(),
2022-06-12 12:14:55 +02:00
system: { coord: tmr.coord, specific: this.code(), sourceid: sourceId }
};
await actor.createEmbeddedDocuments('Item', [casetmrData]);
}
2023-10-20 22:18:37 +02:00
async deleteCasesTmr(actor, draconique) {
2022-06-12 12:14:55 +02:00
let caseTmrs = actor.items.filter(it => this.isCaseForSource(it, draconique));
await actor.deleteEmbeddedDocuments('Item', caseTmrs.map(it => it.id));
}
2023-10-20 22:18:37 +02:00
isCaseForSource(item, draconique) {
2022-06-12 12:14:55 +02:00
return Draconique.isCaseTMR(item) && item.system.specific == this.code() && item.system.sourceid == draconique.id;
}
async onVisiteSupprimer(actor, tmr, onRemoveToken) {
2022-06-12 12:14:55 +02:00
let existants = actor.items.filter(it => this.isCase(it, tmr.coord));
await actor.deleteEmbeddedDocuments('Item', existants.map(it => it.id));
for (let casetmr of existants) {
onRemoveToken(tmr, casetmr);
}
}
}