887 lines
31 KiB
JavaScript
887 lines
31 KiB
JavaScript
/**
|
|
* Extend the base Dialog entity by defining a custom window to perform spell.
|
|
* @extends {Dialog}
|
|
*/
|
|
import { RollDataAjustements } from "./rolldata-ajustements.js";
|
|
import { RdDUtility } from "./rdd-utility.js";
|
|
import { poesieCaseHumide, TMRUtility } from "./tmr-utility.js";
|
|
import { tmrConstants } from "./tmr-utility.js";
|
|
import { RdDResolutionTable } from "./rdd-resolution-table.js";
|
|
import { RdDTMRRencontreDialog } from "./rdd-tmr-rencontre-dialog.js";
|
|
import { TMRRencontres } from "./tmr-rencontres.js";
|
|
import { ChatUtility } from "./chat-utility.js";
|
|
import { RdDRoll } from "./rdd-roll.js";
|
|
|
|
|
|
/* -------------------------------------------- */
|
|
export class RdDTMRDialog extends Dialog {
|
|
|
|
/* -------------------------------------------- */
|
|
constructor(html, actor, tmrData, mode) {
|
|
const dialogConf = {
|
|
title: "Terres Médianes de Rêve",
|
|
content: html,
|
|
buttons: {
|
|
closeButton: { label: "Fermer", callback: html => this.close(html) }
|
|
},
|
|
default: "closeButton"
|
|
}
|
|
|
|
const dialogOptions = {
|
|
classes: ["tmrdialog"],
|
|
width: 920, height: 980,
|
|
'z-index': 20
|
|
}
|
|
super(dialogConf, dialogOptions);
|
|
|
|
this.tmrdata = duplicate(tmrData);
|
|
this.actor = actor;
|
|
this.actor.tmrApp = this; // reference this app in the actor structure
|
|
this.viewOnly = mode == "visu"
|
|
this.fatigueParCase = this.viewOnly ? 0 : this.actor.getTMRFatigue();
|
|
this.cumulFatigue = 0;
|
|
this.rencontresExistantes = duplicate(this.actor.data.data.reve.rencontre.list);
|
|
this.sortReserves = duplicate(this.actor.data.data.reve.reserve.list);
|
|
this.casesSpeciales = this.actor.data.items.filter(item => item.type == 'casetmr');
|
|
this.allTokens = [];
|
|
this.rencontreState = 'aucune';
|
|
this.pixiApp = new PIXI.Application({ width: 720, height: 860 });
|
|
if (!this.viewOnly) {
|
|
this.actor.setStatusDemiReve(true);
|
|
this._tellToGM(this.actor.name + " monte dans les terres médianes (" + mode + ")");
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
close() {
|
|
this.actor.santeIncDec("fatigue", this.cumulFatigue).then(super.close()); // moving 1 cell costs 1 fatigue
|
|
this.actor.tmrApp = undefined; // Cleanup reference
|
|
this.actor.setStatusDemiReve(false);
|
|
if (!this.viewOnly) {
|
|
this._tellToGM(this.actor.name + " a quitté les terres médianes");
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
displaySortReserve() {
|
|
console.debug("displaySortReserve", this.sortReserves);
|
|
for (let sort of this.sortReserves) {
|
|
this._trackToken(this._tokenSortEnReserve(sort));
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
displaySpecificCase() {
|
|
for (let caseSpeciale of this.casesSpeciales) {
|
|
console.log("SPEC CASE ", caseSpeciale);
|
|
if (caseSpeciale.data.specific == 'trounoir') {
|
|
this._trackToken(this._tokenTrouNoir(caseSpeciale.data.coord));
|
|
} else if (caseSpeciale.data.specific == 'attache') {
|
|
this._trackToken(this._tokenTerreAttache(caseSpeciale.data.coord));
|
|
} else if (caseSpeciale.data.specific == 'debordement') {
|
|
this._trackToken(this._tokenDebordement(caseSpeciale.data.coord));
|
|
} else if (caseSpeciale.data.specific == 'maitrisee') {
|
|
this._trackToken(this._tokenMaitrisee(caseSpeciale.data.coord));
|
|
}
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
displayPreviousRencontres() {
|
|
console.debug("displayPreviousRencontres", this.rencontresExistantes);
|
|
for (let rencontre of this.rencontresExistantes) {
|
|
this._trackToken(this._tokenRencontre(rencontre));
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
updatePreviousRencontres() {
|
|
this._removeTokens(t => t.rencontre != undefined);
|
|
this.rencontresExistantes = duplicate(this.actor.data.data.reve.rencontre.list);
|
|
this.displayPreviousRencontres();
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
updateSortReserve() {
|
|
this._removeTokens(t => t.sort != undefined);
|
|
this.sortReserves = duplicate(this.actor.data.data.reve.reserve.list);
|
|
this.displaySortReserve();
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async derober() {
|
|
await this.actor.addTMRRencontre(this.currentRencontre);
|
|
console.log("-> derober", this.currentRencontre);
|
|
this._tellToGM(this.actor.name + " s'est dérobé et quitte les TMR.");
|
|
this.close();
|
|
}
|
|
/* -------------------------------------------- */
|
|
async refouler() {
|
|
this._tellToGM(this.actor.name + " a refoulé : " + this.currentRencontre.name);
|
|
await this.actor.deleteTMRRencontreAtPosition(); // Remove the stored rencontre if necessary
|
|
await this.actor.ajouterRefoulement(this.currentRencontre.refoulement ?? 1);
|
|
this.updatePreviousRencontres();
|
|
console.log("-> refouler", this.currentRencontre)
|
|
this.updateValuesDisplay();
|
|
this.nettoyerRencontre();
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async ignorerRencontre() {
|
|
this._tellToGM(this.actor.name + " a ignoré : " + this.currentRencontre.name);
|
|
await this.actor.deleteTMRRencontreAtPosition(); // Remove the stored rencontre if necessary
|
|
this.updatePreviousRencontres();
|
|
this.updateValuesDisplay();
|
|
this.nettoyerRencontre();
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
colorierZoneRencontre(locList) {
|
|
this.currentRencontre.graphics = []; // Keep track of rectangles to delete it
|
|
this.currentRencontre.locList = duplicate(locList); // And track of allowed location
|
|
for (let loc of locList) {
|
|
let rect = this._getCaseRectangleCoord(loc);
|
|
var rectDraw = new PIXI.Graphics();
|
|
rectDraw.beginFill(0xFFFF00, 0.3);
|
|
// set the line style to have a width of 5 and set the color to red
|
|
rectDraw.lineStyle(5, 0xFF0000);
|
|
// draw a rectangle
|
|
rectDraw.drawRect(rect.x, rect.y, rect.w, rect.h);
|
|
this.pixiApp.stage.addChild(rectDraw);
|
|
this.currentRencontre.graphics.push(rectDraw); // garder les objets pour gestion post-click
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
// garder la trace de l'état en cours
|
|
setStateRencontre(state) {
|
|
this.rencontreState = state;
|
|
}
|
|
|
|
async choisirCasePortee(coord, portee) {
|
|
// Récupère la liste des cases à portées
|
|
let locList = TMRUtility.getTMRPortee(coord, portee);
|
|
this.colorierZoneRencontre(locList);
|
|
}
|
|
|
|
async choisirCaseType(type) {
|
|
const locList = TMRUtility.getListCoordTMR(type);
|
|
this.colorierZoneRencontre(locList);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
checkQuitterTMR() {
|
|
|
|
if (this.actor.isDead()) {
|
|
this._tellToGM("Vous êtes mort : vous quittez les Terres médianes !");
|
|
this.close();
|
|
return true;
|
|
}
|
|
const resteAvantInconscience = this.actor.getFatigueMax() - this.actor.getFatigueActuelle() - this.cumulFatigue;
|
|
if (resteAvantInconscience <= 0) {
|
|
this._tellToGM("Vous vous écroulez de fatigue : vous quittez les Terres médianes !");
|
|
this.quitterLesTMRInconscient();
|
|
return true;
|
|
}
|
|
if (this.actor.getReveActuel() == 0) {
|
|
this._tellToGM("Vos Points de Rêve sont à 0 : vous quittez les Terres médianes !");
|
|
this.quitterLesTMRInconscient();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
async quitterLesTMRInconscient() {
|
|
if (this.currentRencontre?.isPersistant) {
|
|
await this.refouler();
|
|
}
|
|
this.close();
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async maitriser() {
|
|
this.actor.deleteTMRRencontreAtPosition();
|
|
this.updatePreviousRencontres();
|
|
|
|
let rencontreData = {
|
|
actor: this.actor,
|
|
alias: this.actor.name,
|
|
reveDepart: this.actor.getReveActuel(),
|
|
competence: this.actor.getBestDraconic(),
|
|
rencontre: this.currentRencontre,
|
|
nbRounds: 1,
|
|
canClose: false,
|
|
tmr: TMRUtility.getTMR(this.actor.data.data.reve.tmrpos.coord)
|
|
}
|
|
|
|
await this._tentativeMaitrise(rencontreData);
|
|
}
|
|
|
|
async _tentativeMaitrise(rencontreData) {
|
|
console.log("-> matriser", rencontreData);
|
|
|
|
rencontreData.reve = this.actor.getReveActuel();
|
|
rencontreData.etat = this.actor.getEtatGeneral();
|
|
|
|
RollDataAjustements.calcul(rencontreData, this.actor);
|
|
|
|
rencontreData.rolled = await RdDResolutionTable.roll(rencontreData.reve, RollDataAjustements.sum(rencontreData.ajustements));
|
|
|
|
let postProcess = await TMRRencontres.gererRencontre(this, rencontreData);
|
|
|
|
ChatMessage.create({
|
|
whisper: ChatUtility.getWhisperRecipientsAndGMs(game.user.name),
|
|
content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-rencontre-tmr.html`, rencontreData)
|
|
});
|
|
|
|
if (postProcess) {
|
|
/** Gère les rencontres avec du post-processing (passeur, messagers, tourbillons, ...) */
|
|
await postProcess(this, rencontreData);
|
|
}
|
|
else {
|
|
this.currentRencontre = undefined;
|
|
}
|
|
|
|
this.updateValuesDisplay();
|
|
if (this.checkQuitterTMR()) {
|
|
return;
|
|
}
|
|
else if (rencontreData.rolled.isEchec && rencontreData.rencontre.isPersistant) {
|
|
setTimeout(() => {
|
|
rencontreData.nbRounds++;
|
|
this.cumulFatigue += this.fatigueParCase;
|
|
this._tentativeMaitrise(rencontreData);
|
|
this._deleteTmrMessages(rencontreData.actor, rencontreData.nbRounds);
|
|
}, 2000);
|
|
}
|
|
}
|
|
|
|
_deleteTmrMessages(actor, nbRounds = -1) {
|
|
setTimeout(() => {
|
|
if (nbRounds < 0) {
|
|
ChatUtility.removeChatMessageContaining(`<h4 data-categorie="tmr" data-actor-id="${actor._id}"`);
|
|
}
|
|
else {
|
|
for (let i = 1; i < nbRounds; i++) {
|
|
ChatUtility.removeChatMessageContaining(`<h4 data-categorie="tmr" data-actor-id="${actor._id}" data-rencontre-round="${i}">`);
|
|
}
|
|
}
|
|
}, 500);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
_tellToUser(message) {
|
|
ChatMessage.create({ content: message, user: game.user._id, whisper: [game.user._id] });
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
_tellToGM(message) {
|
|
ChatMessage.create({ content: message, user: game.user._id, whisper: ChatMessage.getWhisperRecipients("GM") });
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async manageRencontre(tmr, postRencontre) {
|
|
if (this.viewOnly) {
|
|
return;
|
|
}
|
|
this.currentRencontre = undefined;
|
|
let rencontre = await this._jetDeRencontre(tmr);
|
|
|
|
if (rencontre) { // Manages it
|
|
if (rencontre.rencontre) rencontre = rencontre.rencontre; // Manage stored rencontres
|
|
console.log("manageRencontre", rencontre);
|
|
this.currentRencontre = duplicate(rencontre);
|
|
|
|
let dialog = new RdDTMRRencontreDialog("", this, this.currentRencontre, postRencontre);
|
|
dialog.render(true);
|
|
}
|
|
else {
|
|
postRencontre();
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async _jetDeRencontre(tmr) {
|
|
let rencontre = this.rencontresExistantes.find(prev => prev.coord == tmr.coord);
|
|
if (rencontre) {
|
|
return rencontre;
|
|
}
|
|
let myRoll = new Roll("1d7").evaluate().total;
|
|
if (TMRUtility.isForceRencontre() || myRoll== 7) {
|
|
return await this.rencontreTMRRoll(tmr, this.actor.isRencontreSpeciale());
|
|
}
|
|
this._tellToUser(myRoll + ": Pas de rencontre en " + tmr.label + " (" + tmr.coord + ")");
|
|
}
|
|
|
|
|
|
/* -------------------------------------------- */
|
|
async rencontreTMRRoll(tmr, isMauvaise = false) {
|
|
let rencontre = TMRUtility.utiliseForceRencontre() ??
|
|
isMauvaise ? await TMRRencontres.getMauvaiseRencontre()
|
|
: await TMRRencontres.getRencontreAleatoire(tmr.type);
|
|
rencontre.coord = tmr.coord;
|
|
return rencontre;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
updateValuesDisplay() {
|
|
let ptsreve = document.getElementById("tmr-pointsreve-value");
|
|
ptsreve.innerHTML = this.actor.data.data.reve.reve.value;
|
|
|
|
let tmrpos = document.getElementById("tmr-pos");
|
|
let tmr = TMRUtility.getTMR(this.actor.data.data.reve.tmrpos.coord);
|
|
tmrpos.innerHTML = this.actor.data.data.reve.tmrpos.coord + " (" + tmr.label + ")";
|
|
|
|
let etat = document.getElementById("tmr-etatgeneral-value");
|
|
etat.innerHTML = this.actor.getEtatGeneral();
|
|
|
|
let refoulement = document.getElementById("tmr-refoulement-value");
|
|
refoulement.innerHTML = this.actor.data.data.reve.refoulement.value;
|
|
|
|
let fatigueItem = document.getElementById("tmr-fatigue-table");
|
|
//console.log("Refresh : ", this.actor.data.data.sante.fatigue.value);
|
|
fatigueItem.innerHTML = "<table class='table-fatigue'>" + RdDUtility.makeHTMLfatigueMatrix(this.actor.data.data.sante.fatigue.value, this.actor.data.data.sante.endurance.max).html() + "</table>";
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async manageCaseSpeciale(tmr) {
|
|
for (let caseTMR of this.casesSpeciales) {
|
|
if (caseTMR.data.coord == tmr.coord) { // Match !
|
|
if (caseTMR.data.specific == 'trounoir') {
|
|
let newTMR = TMRUtility.getTMRAleatoire();
|
|
let tmrPos = duplicate(this.actor.data.data.reve.tmrpos);
|
|
tmrPos.coord = newTMR.coord;
|
|
await this.actor.update({ "data.reve.tmrpos": tmrPos });
|
|
ChatMessage.create({
|
|
content: "Vous êtes rentré sur un Trou Noir : ré-insertion aléatoire.",
|
|
whisper: ChatMessage.getWhisperRecipients(game.user.name)
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async manageCaseHumide(tmr) {
|
|
if (this.viewOnly || this.currentRencontre) {
|
|
return;
|
|
}
|
|
if (this.isCaseHumide(tmr)) {
|
|
let rollData = {
|
|
actor: this.actor,
|
|
competence: duplicate(this.actor.getBestDraconic()),
|
|
tmr: tmr,
|
|
canClose: false,
|
|
diffLibre: -7,
|
|
forceCarac: { "reveactuel": { label: "Rêve Actuel", value: this.actor.getReveActuel() } }
|
|
}
|
|
rollData.competence.data.defaut_carac = "reveactuel";
|
|
|
|
await this._rollMaitriseCaseHumide(rollData);
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
isCaseHumide(tmr) {
|
|
if (this.isCaseMaitrisee(tmr.coord)) {
|
|
ChatMessage.create({
|
|
content: tmr.label + ": cette case humide est déja maitrisée grâce à votre Tête <strong>Quête des Eaux</strong>",
|
|
whisper: ChatMessage.getWhisperRecipients(game.user.name)
|
|
});
|
|
return false;
|
|
}
|
|
if (this.actor.isCaseHumideAdditionelle(tmr)) {
|
|
return true;
|
|
}
|
|
return tmr.type == "lac" || tmr.type == "fleuve" || tmr.type == "marais";
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
isCaseMaitrisee(coordTMR) {
|
|
return this.casesSpeciales.find(it => it.data.coord = coordTMR && it.data.specific == 'maitrisee');
|
|
}
|
|
|
|
async _rollMaitriseCaseHumide(rollData) {
|
|
this.minimize(); // Hide
|
|
const dialog = await RdDRoll.create(this.actor, rollData,
|
|
{
|
|
html: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-tmr-humide.html',
|
|
options:{ height: 350 },
|
|
close: html => { this.maximize(); } // Re-display TMR
|
|
},
|
|
{
|
|
name: 'maitrise',
|
|
label: 'Maîtriser le fleuve',
|
|
callbacks: [
|
|
this.actor.createCallbackExperience(),
|
|
{ action: r => this._maitriseCaseHumide(r) }
|
|
]
|
|
}
|
|
);
|
|
dialog.render(true);
|
|
}
|
|
|
|
async _maitriseCaseHumide(rollData) {
|
|
if (rollData.rolled.isETotal) {
|
|
rollData.souffle = await this.actor.ajouterSouffle({ chat: false });
|
|
}
|
|
this.toclose = rollData.rolled.isEchec;
|
|
if (rollData.rolled.isSuccess) {
|
|
if (!rollData.previous && this.actor.isDoubleResistanceFleuve()) {
|
|
ChatMessage.create({
|
|
content: `Double résistance du fleuve: `,
|
|
whisper: ChatUtility.getWhisperRecipientsAndGMs(game.user.name)
|
|
});
|
|
rollData.previous = [rollData.rolled];
|
|
await this._rollMaitriseCaseHumide(rollData);
|
|
return;
|
|
}
|
|
}
|
|
rollData.poesie = poesieCaseHumide[new Roll("1d" + poesieCaseHumide.length).evaluate().total - 1];
|
|
const whisperTo = ChatUtility.getWhisperRecipientsAndGMs(game.user.name);
|
|
const content = await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-fleuve-tmr.html`, rollData);
|
|
ChatMessage.create({
|
|
whisper: whisperTo,
|
|
content: content
|
|
});
|
|
if (rollData.rolled.isEchec) {
|
|
this.close();
|
|
}
|
|
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
isReserveExtensible(coordTMR) {
|
|
for (let caseTMR of this.casesSpeciales) {
|
|
if (caseTMR.data.specific == 'reserve_extensible' && caseTMR.data.coord == coordTMR)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async declencheSortEnReserve(coordTMR) {
|
|
if (this.viewOnly) {
|
|
return;
|
|
}
|
|
|
|
let sortReserveList = TMRUtility.getSortReserveList(this.sortReserves, coordTMR);
|
|
if (sortReserveList.length > 0) {
|
|
if (this.actor.isReserveEnSecurite() || this.isReserveExtensible(coordTMR)) {
|
|
let msg = "Vous êtes sur une case avec un Sort en Réserve. Grâce à votre Tête <strong>Reserve en Sécurité</strong> ou <strong>Réserve Exensible</strong>, vous pouvez contrôler le déclenchement. Cliquez si vous souhaitez le déclencher : <ul>";
|
|
for (let sortReserve of sortReserveList) {
|
|
msg += "<li><a class='chat-card-button' id='sort-reserve' data-actor-id='" + this.actor._id + "' data-tmr-coord='" + coordTMR + "' data-sort-id='" + sortReserve.sort._id + "'>" + sortReserve.sort.name + "</a></li>";
|
|
}
|
|
msg += "</ol>";
|
|
ChatMessage.create({
|
|
content: msg,
|
|
whisper: ChatMessage.getWhisperRecipients(game.user.name)
|
|
});
|
|
} else {
|
|
await this.processSortReserve(sortReserveList[0]);
|
|
}
|
|
}
|
|
}
|
|
/* -------------------------------------------- */
|
|
lancerSortEnReserve(coordTMR, sortId) {
|
|
let sortReserveList = TMRUtility.getSortReserveList(this.sortReserves, coordTMR);
|
|
let sortReserve = sortReserveList.find(sortReserve => sortReserve.sort._id == sortId);
|
|
//console.log("SORT RESA", sortReserveList, coordTMR, sortId, sortReserve);
|
|
if (sortReserve) {
|
|
this.processSortReserve(sortReserve);
|
|
} else {
|
|
ChatMessage.create({
|
|
content: "Une erreur est survenue : impossible de récupérer le sort en réserve demandé.",
|
|
whisper: ChatMessage.getWhisperRecipients(game.user.name)
|
|
});
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async processSortReserve(sortReserve) {
|
|
await this.actor.deleteSortReserve(sortReserve);
|
|
this.updateSortReserve();
|
|
console.log("declencheSortEnReserve", sortReserve)
|
|
const declenchementSort = "Vous avez déclenché le sort <strong>" + sortReserve.sort.name
|
|
+ "</strong> en réserve en " + sortReserve.coord + " (" + TMRUtility.getTMR(sortReserve.coord).label
|
|
+ ") avec " + sortReserve.sort.data.ptreve_reel + " points de Rêve";
|
|
this._tellToGM(declenchementSort);
|
|
this.close();
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
nettoyerRencontre() {
|
|
if (!this.currentRencontre) return; // Sanity check
|
|
if (this.currentRencontre.graphics) {
|
|
for (let drawRect of this.currentRencontre.graphics) { // Suppression des dessins des zones possibles
|
|
this.pixiApp.stage.removeChild(drawRect);
|
|
}
|
|
}
|
|
this.currentRencontre = undefined; // Nettoyage de la structure
|
|
this.rencontreState = 'aucune'; // Et de l'état
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
processClickPostRencontre(coord) {
|
|
if (this.rencontreState == 'passeur' || this.rencontreState == 'messager' || this.rencontreState == 'changeur') {
|
|
console.log("Searching", this.currentRencontre.locList, coord);
|
|
let isInArea = this.currentRencontre.locList.find(locCoord => locCoord == coord);
|
|
if (isInArea) { // OK !
|
|
return (this.rencontreState == 'messager') ? 'messager' : 'saut';
|
|
}
|
|
}
|
|
return "erreur";
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
isTerreAttache(coordTMR) {
|
|
for (let caseTMR of this.casesSpeciales) {
|
|
if (caseTMR.data.specific == 'attache' && caseTMR.data.coord == coordTMR) { // Match !
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
checkConnaissanceFleuve(currentTMR, nextTMR) {
|
|
if (this.actor.isConnaissanceFleuve()) {
|
|
//console.log(currentTMR, nextTMR );
|
|
if (TMRUtility.getTMR(currentTMR).type == 'fleuve' && TMRUtility.getTMR(nextTMR).type == 'fleuve') {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async onClickTMR(event) {
|
|
if (this.viewOnly) {
|
|
return;
|
|
}
|
|
|
|
let origEvent = event.data.originalEvent;
|
|
let tmrObject = event.target.tmrObject;
|
|
|
|
let eventPos = RdDTMRDialog._computeEventPos(origEvent);
|
|
await tmrObject._onClickTMRPos(eventPos); // Vérifier l'état des compteurs reve/fatigue/vie
|
|
}
|
|
|
|
async _onClickTMRPos(eventPos) {
|
|
let currentPos = TMRUtility.convertToCellPos(this.actor.data.data.reve.tmrpos.coord);
|
|
|
|
console.log("deplacerDemiReve >>>>", currentPos, eventPos);
|
|
|
|
let targetCoordTMR = TMRUtility.convertToTMRCoord(eventPos);
|
|
let currentCoordTMR = TMRUtility.convertToTMRCoord(currentPos);
|
|
|
|
// Validation de la case de destination (gestion du cas des rencontres qui peuvent téléporter)
|
|
let deplacementType = 'erreur';
|
|
if (this.rencontreState == 'aucune') { // Pas de recontre en post-processing, donc deplacement normal
|
|
if (!RdDTMRDialog._horsDePortee(currentPos, eventPos) || this.isTerreAttache(targetCoordTMR) || this.checkConnaissanceFleuve(currentCoordTMR, targetCoordTMR)) {
|
|
deplacementType = 'normal';
|
|
}
|
|
} else {
|
|
deplacementType = this.processClickPostRencontre(targetCoordTMR);
|
|
}
|
|
// Si le deplacement est valide
|
|
if (deplacementType == 'normal' || deplacementType == 'saut') {
|
|
await this._deplacerDemiReve(targetCoordTMR, deplacementType);
|
|
|
|
} else if (deplacementType == 'messager') { // Dans ce cas, ouverture du lancement de sort sur la case visée
|
|
/*
|
|
TODO: si la case a un sort en réserve, lancer ce sort.
|
|
Si la case est le demi-rêve, ne pas lancer de sort.
|
|
Si un lancement de sort est en cours, trouver un moyen de réafficher cette fenêtre si on essaie de lancer un sort (ou bloquer le lancer de sort)
|
|
*/
|
|
await this._messagerDemiReve(targetCoordTMR);
|
|
|
|
} else {
|
|
ui.notifications.error("Vous ne pouvez vous déplacer que sur des cases adjacentes à votre position ou valides dans le cas d'une rencontre");
|
|
console.log("STATUS :", this.rencontreState, this.currentRencontre);
|
|
}
|
|
|
|
this.checkQuitterTMR();
|
|
}
|
|
|
|
async _messagerDemiReve(targetCoordTMR) {
|
|
await this.actor.rollUnSort(targetCoordTMR);
|
|
this.nettoyerRencontre();
|
|
}
|
|
|
|
async _deplacerDemiReve(targetCoord, deplacementType) {
|
|
if (this.currentRencontre != 'normal') {
|
|
this.nettoyerRencontre();
|
|
}
|
|
let tmr = TMRUtility.getTMR(targetCoord);
|
|
|
|
await this.manageCaseSpeciale(tmr); // Gestion cases spéciales type Trou noir, etc
|
|
|
|
console.log("deplacerDemiReve: TMR is", tmr, this);
|
|
|
|
let tmrPos = duplicate(this.actor.data.data.reve.tmrpos);
|
|
tmrPos.coord = targetCoord;
|
|
await this.actor.update({ "data.reve.tmrpos": tmrPos });
|
|
|
|
this._updateDemiReve();
|
|
this.cumulFatigue += this.fatigueParCase;
|
|
this.updateValuesDisplay();
|
|
game.socket.emit("system.foundryvtt-reve-de-dragon", {
|
|
msg: "msg_tmr_move", data: {
|
|
actorId: this.actor.data._id,
|
|
tmrPos: tmrPos
|
|
}
|
|
});
|
|
|
|
if (deplacementType == 'normal') { // Pas de rencontres après un saut de type passeur/changeur/...
|
|
await this.manageRencontre(tmr, () => this.postRencontre(tmr));
|
|
}
|
|
else {
|
|
await this.postRencontre(tmr);
|
|
}
|
|
}
|
|
|
|
async postRencontre(tmr) {
|
|
await this.manageCaseHumide(tmr);
|
|
await this.declencheSortEnReserve(tmr.coord);
|
|
await this.actor.checkSoufflePeage(tmr);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async forceDemiRevePositionView(coordTMR) {
|
|
this._updateDemiReve();
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async forceDemiRevePosition(coordTMR) {
|
|
await this.actor.updateCoordTMR(coordTMR);
|
|
this._updateDemiReve();
|
|
let tmr = TMRUtility.getTMR(coordTMR);
|
|
this.manageCaseHumide(tmr);
|
|
await this.declencheSortEnReserve(tmr.coord);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async activateListeners(html) {
|
|
super.activateListeners(html);
|
|
|
|
var row = document.getElementById("tmrrow1");
|
|
var cell1 = row.insertCell(1);
|
|
cell1.append(this.pixiApp.view);
|
|
|
|
if (this.viewOnly) {
|
|
html.find('#lancer-sort').remove();
|
|
}
|
|
else {
|
|
// Roll Sort
|
|
html.find('#lancer-sort').click((event) => {
|
|
this.actor.rollUnSort(this.actor.data.data.reve.tmrpos.coord);
|
|
});
|
|
}
|
|
|
|
// load the texture we need
|
|
await this.pixiApp.loader
|
|
.add('tmr', 'systems/foundryvtt-reve-de-dragon/styles/img/ui/tmp_main_r1.webp')
|
|
.add('demi-reve', "icons/svg/sun.svg")
|
|
.load((loader, resources) => {
|
|
|
|
// This creates a texture from a TMR image
|
|
const mytmr = new PIXI.Sprite(resources.tmr.texture);
|
|
// Setup the position of the TMR
|
|
mytmr.x = 0;
|
|
mytmr.y = 0;
|
|
mytmr.width = 720;
|
|
mytmr.height = 860;
|
|
// Rotate around the center
|
|
mytmr.anchor.x = 0;
|
|
mytmr.anchor.y = 0;
|
|
mytmr.interactive = true;
|
|
mytmr.buttonMode = true;
|
|
mytmr.tmrObject = this;
|
|
if (!this.viewOnly) {
|
|
mytmr.on('pointerdown', this.onClickTMR);
|
|
}
|
|
this.pixiApp.stage.addChild(mytmr);
|
|
|
|
this._addDemiReve();
|
|
this.displayPreviousRencontres();
|
|
this.displaySortReserve();
|
|
this.displaySpecificCase();
|
|
});
|
|
|
|
if (this.viewOnly) {
|
|
return;
|
|
}
|
|
|
|
// Gestion du cout de montée en points de rêve
|
|
let reveCout = (this.tmrdata.isRapide && !this.actor.checkTeteDeplacementAccelere()) ? -2 : -1;
|
|
this.cumulFatigue += this.fatigueParCase;
|
|
reveCout -= this.actor.checkMonteeLaborieuse();
|
|
await this.actor.reveActuelIncDec(reveCout);
|
|
// Le reste...
|
|
this.updateValuesDisplay();
|
|
let tmr = TMRUtility.getTMR(this.actor.data.data.reve.tmrpos.coord);
|
|
await this.manageRencontre(tmr, () => {
|
|
this.postRencontre(tmr);
|
|
this.actor.displayTMRQueueSouffleInformation();
|
|
});
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
static _computeEventPos(origEvent) {
|
|
let canvasRect = origEvent.target.getBoundingClientRect();
|
|
let x = origEvent.clientX - canvasRect.left;
|
|
let y = origEvent.clientY - canvasRect.top;
|
|
let cellx = Math.floor(x / tmrConstants.cellw); // [From 0 -> 12]
|
|
y -= (cellx % 2 == 0) ? tmrConstants.col1_y : tmrConstants.col2_y;
|
|
let celly = Math.floor(y / tmrConstants.cellh); // [From 0 -> 14]
|
|
return { x: cellx, y: celly };
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
static _horsDePortee(origin, target) {
|
|
return Math.abs(target.x - origin.x) > 1
|
|
|| Math.abs(target.y - origin.y) > 1
|
|
|| (origin.y == 0 && target.y > origin.y && target.x != origin.x && origin.x % 2 == 0)
|
|
|| (target.y == 0 && target.y < origin.y && target.x != origin.x && origin.x % 2 == 1);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
_tokenRencontre(rencontre) {
|
|
let sprite = new PIXI.Graphics();
|
|
sprite.beginFill(0x767610, 0.6);
|
|
sprite.drawCircle(0, 0, 6);
|
|
sprite.endFill();
|
|
sprite.decallage = {
|
|
x: (tmrConstants.cellw / 2) - 16,
|
|
y: 16 - (tmrConstants.cellh / 2)
|
|
};
|
|
return { sprite: sprite, rencontre: rencontre, coordTMR: () => rencontre.coord };
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
_tokenTrouNoir(coord) {
|
|
let sprite = new PIXI.Graphics();
|
|
sprite.beginFill(0x050505, 0.8);
|
|
sprite.drawCircle(0, 0, (tmrConstants.cellw / 2) - 2);
|
|
sprite.endFill();
|
|
sprite.decallage = {
|
|
x: 0,
|
|
y: 2
|
|
}
|
|
return { sprite: sprite, coordTMR: () => coord }
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
_tokenDebordement(coord) {
|
|
let sprite = new PIXI.Graphics();
|
|
sprite.beginFill(0x0101FE, 0.3);
|
|
sprite.drawCircle(0, 0, (tmrConstants.cellw / 2) - 2);
|
|
sprite.endFill();
|
|
sprite.decallage = {
|
|
x: 0,
|
|
y: 2
|
|
}
|
|
return { sprite: sprite, coordTMR: () => coord }
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
_tokenMaitrisee(coord) {
|
|
let sprite = new PIXI.Graphics();
|
|
sprite.beginFill(0x1010F0, 0.8);
|
|
sprite.drawCircle(0, 0, 6);
|
|
sprite.endFill();
|
|
sprite.decallage = {
|
|
x: 16 - (tmrConstants.cellw / 2),
|
|
y: 16 - (tmrConstants.cellh / 2)
|
|
}
|
|
return { sprite: sprite, coordTMR: () => coord }
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
_tokenTerreAttache(coord) {
|
|
let sprite = new PIXI.Graphics();
|
|
sprite.beginFill(0x10F010, 0.8);
|
|
sprite.drawCircle(0, 0, 6);
|
|
sprite.endFill();
|
|
sprite.decallage = {
|
|
x: 16 - (tmrConstants.cellw / 2),
|
|
y: 16 - (tmrConstants.cellh / 2)
|
|
}
|
|
return { sprite: sprite, coordTMR: () => coord }
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
_tokenSortEnReserve(sort) {
|
|
let sprite = new PIXI.Graphics();
|
|
sprite.beginFill(0x101010, 0.8);
|
|
sprite.drawCircle(0, 0, 6);
|
|
sprite.endFill();
|
|
sprite.decallage = {
|
|
x: 16 - (tmrConstants.cellw / 2),
|
|
y: 16 - (tmrConstants.cellh / 2)
|
|
}
|
|
return { sprite: sprite, sort: sort, coordTMR: () => sort.coord }
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
_tokenDemiReve() {
|
|
let texture = PIXI.utils.TextureCache['demi-reve'];
|
|
let sprite = new PIXI.Sprite(texture);
|
|
sprite.width = tmrConstants.cellw * 0.7;
|
|
sprite.height = tmrConstants.cellh * 0.7;
|
|
sprite.anchor.set(0.5);
|
|
sprite.tint = 0x00FFEE;
|
|
return { sprite: sprite, actor: this.actor, coordTMR: () => this.actor.data.data.reve.tmrpos.coord }
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
_addDemiReve() {
|
|
this.demiReve = this._tokenDemiReve();
|
|
this._setTokenPosition(this.demiReve);
|
|
this.pixiApp.stage.addChild(this.demiReve.sprite);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
_updateDemiReve() {
|
|
this._setTokenPosition(this.demiReve);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
/** Retourne les coordonnées x, h, w, h du rectangle d'une case donnée */
|
|
_getCaseRectangleCoord(coord) {
|
|
let coordXY = TMRUtility.convertToCellPos(coord);
|
|
let decallagePairImpair = (coordXY.x % 2 == 0) ? tmrConstants.col1_y : tmrConstants.col2_y;
|
|
let x = tmrConstants.gridx + (coordXY.x * tmrConstants.cellw) - (tmrConstants.cellw / 2);
|
|
let y = tmrConstants.gridy + (coordXY.y * tmrConstants.cellh) - (tmrConstants.cellh / 2) + decallagePairImpair;
|
|
return { x: x, y: y, w: tmrConstants.cellw, h: tmrConstants.cellh }
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
_setTokenPosition(token) {
|
|
let coordXY = TMRUtility.convertToCellPos(token.coordTMR());
|
|
let decallagePairImpair = (coordXY.x % 2 == 0) ? tmrConstants.col1_y : tmrConstants.col2_y;
|
|
let dx = (token.sprite.decallage == undefined) ? 0 : token.sprite.decallage.x;
|
|
let dy = (token.sprite.decallage == undefined) ? 0 : token.sprite.decallage.y;
|
|
token.sprite.x = tmrConstants.gridx + (coordXY.x * tmrConstants.cellw) + dx;
|
|
token.sprite.y = tmrConstants.gridy + (coordXY.y * tmrConstants.cellh) + dy + decallagePairImpair;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
_removeTokens(filter) {
|
|
const tokensToRemove = this.allTokens.filter(filter);
|
|
for (let token of tokensToRemove) {
|
|
this.pixiApp.stage.removeChild(token.sprite);
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
_trackToken(token) {
|
|
this.allTokens.push(token)
|
|
this._setTokenPosition(token);
|
|
this.pixiApp.stage.addChild(token.sprite);
|
|
}
|
|
|
|
}
|
|
|