2020-12-08 21:40:41 +01:00
|
|
|
import { RdDCalendrierEditeur } from "./rdd-calendrier-editeur.js";
|
2020-12-10 20:14:35 +01:00
|
|
|
import { RdDAstrologieEditeur } from "./rdd-astrologie-editeur.js";
|
2020-12-12 23:31:19 +01:00
|
|
|
import { RdDResolutionTable } from "./rdd-resolution-table.js";
|
|
|
|
import { RdDUtility } from "./rdd-utility.js";
|
2021-05-19 23:04:34 +02:00
|
|
|
import { RdDDice } from "./rdd-dice.js";
|
2021-06-09 00:00:15 +02:00
|
|
|
import { Misc } from "./misc.js";
|
2022-01-29 22:49:34 +01:00
|
|
|
import { HIDE_DICE, SHOW_DICE, SYSTEM_RDD, SYSTEM_SOCKET_ID } from "./constants.js";
|
2022-11-04 20:41:16 +01:00
|
|
|
import { DialogChronologie } from "./dialog-chronologie.js";
|
2023-01-07 20:06:04 +01:00
|
|
|
import { RdDTimestamp, WORLD_TIMESTAMP_SETTING } from "./rdd-timestamp.js";
|
2023-02-07 18:06:45 +01:00
|
|
|
import { DialogChateauDormant } from "./sommeil/dialog-chateau-dormant.js";
|
|
|
|
import { ReglesOptionelles } from "./settings/regles-optionelles.js";
|
2021-06-09 00:00:15 +02:00
|
|
|
|
2023-01-05 00:55:04 +01:00
|
|
|
const RDD_JOUR_PAR_MOIS = 28;
|
2021-06-09 00:00:15 +02:00
|
|
|
const RDD_HEURES_PAR_JOUR = 12;
|
2020-12-11 08:29:24 +01:00
|
|
|
const MAX_NOMBRE_ASTRAL = 12;
|
2023-01-05 00:55:04 +01:00
|
|
|
const JOURS_DU_MOIS = Array(RDD_JOUR_PAR_MOIS).fill().map((item, index) => 1 + index);
|
2020-09-20 16:36:39 +02:00
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
export class RdDCalendrier extends Application {
|
2020-12-08 21:40:41 +01:00
|
|
|
|
2022-12-09 02:00:31 +01:00
|
|
|
static get defaultOptions() {
|
|
|
|
return mergeObject(super.defaultOptions, {
|
|
|
|
template: "systems/foundryvtt-reve-de-dragon/templates/calendar-template.html",
|
|
|
|
popOut: false,
|
|
|
|
resizable: false
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2021-06-08 14:11:23 +02:00
|
|
|
static createCalendrierPos() {
|
|
|
|
return { top: 200, left: 200 };
|
|
|
|
}
|
2021-06-08 14:09:40 +02:00
|
|
|
|
2021-07-09 01:01:12 +02:00
|
|
|
constructor() {
|
|
|
|
super();
|
2020-12-08 21:40:41 +01:00
|
|
|
// position
|
2021-11-11 02:43:38 +01:00
|
|
|
this.calendrierPos = duplicate(game.settings.get(SYSTEM_RDD, "calendrier-pos"));
|
2021-03-14 16:02:31 +01:00
|
|
|
if (this.calendrierPos == undefined || this.calendrierPos.top == undefined) {
|
2021-06-08 14:11:23 +02:00
|
|
|
this.calendrierPos = RdDCalendrier.createCalendrierPos();
|
2021-11-11 02:43:38 +01:00
|
|
|
game.settings.set(SYSTEM_RDD, "calendrier-pos", this.calendrierPos);
|
2021-07-09 01:01:12 +02:00
|
|
|
}
|
|
|
|
// Calendrier
|
2023-01-07 20:06:04 +01:00
|
|
|
this.timestamp = RdDTimestamp.getWorldTime();
|
2021-07-09 01:01:12 +02:00
|
|
|
|
2021-11-26 00:45:21 +01:00
|
|
|
if (Misc.isUniqueConnectedGM()) { // Uniquement si GM
|
2023-01-05 00:55:04 +01:00
|
|
|
RdDTimestamp.setWorldTime(this.timestamp);
|
2021-07-09 01:01:12 +02:00
|
|
|
this.listeNombreAstral = this.getListeNombreAstral();
|
2022-11-25 03:17:07 +01:00
|
|
|
this.rebuildListeNombreAstral(HIDE_DICE); // Ensure always up-to-date
|
2020-12-08 23:12:43 +01:00
|
|
|
}
|
2023-01-07 23:28:30 +01:00
|
|
|
console.log('RdDCalendrier.constructor()', this.timestamp, this.timestamp.toCalendrier(), this.calendrierPos, this.listeNombreAstral);
|
2023-01-07 20:06:04 +01:00
|
|
|
Hooks.on('updateSetting', async (setting, update, options, id) => this.onUpdateSetting(setting, update, options, id));
|
2023-01-05 00:55:04 +01:00
|
|
|
}
|
|
|
|
|
2023-01-07 20:06:04 +01:00
|
|
|
async onUpdateSetting(setting, update, options, id) {
|
|
|
|
if (setting.key == SYSTEM_RDD + '.' + WORLD_TIMESTAMP_SETTING) {
|
|
|
|
this.timestamp = RdDTimestamp.getWorldTime();
|
|
|
|
this.updateDisplay();
|
|
|
|
}
|
2020-12-08 21:40:41 +01:00
|
|
|
}
|
2021-03-14 16:02:31 +01:00
|
|
|
|
2020-12-21 15:14:49 +01:00
|
|
|
/* -------------------------------------------- */
|
2022-12-09 02:00:31 +01:00
|
|
|
/** @override */
|
|
|
|
async activateListeners(html) {
|
|
|
|
super.activateListeners(html);
|
|
|
|
this.html = html;
|
2020-12-17 19:42:25 +01:00
|
|
|
|
2022-12-09 02:00:31 +01:00
|
|
|
this.updateDisplay();
|
|
|
|
|
|
|
|
this.html.find('.ajout-chronologie').click(ev => DialogChronologie.create());
|
|
|
|
|
|
|
|
this.html.find('.calendar-btn').click(ev => this.onCalendarButton(ev));
|
|
|
|
|
|
|
|
this.html.find('.calendar-btn-edit').click(ev => {
|
|
|
|
ev.preventDefault();
|
|
|
|
this.showCalendarEditor();
|
|
|
|
});
|
|
|
|
|
|
|
|
this.html.find('.astrologie-btn-edit').click(ev => {
|
|
|
|
ev.preventDefault();
|
|
|
|
this.showAstrologieEditor();
|
2021-07-09 01:01:12 +02:00
|
|
|
});
|
2022-12-09 02:00:31 +01:00
|
|
|
|
|
|
|
this.html.find('#calendar-move-handle').mousedown(ev => {
|
|
|
|
ev.preventDefault();
|
|
|
|
ev = ev || window.event;
|
|
|
|
let isRightMB = false;
|
|
|
|
if ("which" in ev) { // Gecko (Firefox), WebKit (Safari/Chrome) & Opera
|
|
|
|
isRightMB = ev.which == 3;
|
|
|
|
} else if ("button" in ev) { // IE, Opera
|
|
|
|
isRightMB = ev.button == 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!isRightMB) {
|
|
|
|
dragElement(document.getElementById("calendar-time-container"));
|
|
|
|
let pos1 = 0, pos2 = 0, pos3 = 0, pos4 = 0;
|
|
|
|
|
|
|
|
function dragElement(elmnt) {
|
|
|
|
elmnt.onmousedown = dragMouseDown;
|
|
|
|
function dragMouseDown(e) {
|
|
|
|
e = e || window.event;
|
|
|
|
e.preventDefault();
|
|
|
|
pos3 = e.clientX;
|
|
|
|
pos4 = e.clientY;
|
|
|
|
|
|
|
|
document.onmouseup = closeDragElement;
|
|
|
|
document.onmousemove = elementDrag;
|
|
|
|
}
|
|
|
|
|
|
|
|
function elementDrag(e) {
|
|
|
|
e = e || window.event;
|
|
|
|
e.preventDefault();
|
|
|
|
// calculate the new cursor position:
|
|
|
|
pos1 = pos3 - e.clientX;
|
|
|
|
pos2 = pos4 - e.clientY;
|
|
|
|
pos3 = e.clientX;
|
|
|
|
pos4 = e.clientY;
|
|
|
|
// set the element's new position:
|
|
|
|
elmnt.style.bottom = undefined
|
|
|
|
elmnt.style.top = (elmnt.offsetTop - pos2) + "px";
|
|
|
|
elmnt.style.left = (elmnt.offsetLeft - pos1) + "px";
|
|
|
|
}
|
|
|
|
|
|
|
|
function closeDragElement() {
|
|
|
|
// stop moving when mouse button is released:
|
|
|
|
elmnt.onmousedown = undefined;
|
|
|
|
document.onmouseup = undefined;
|
|
|
|
document.onmousemove = undefined;
|
|
|
|
let xPos = (elmnt.offsetLeft - pos1) > window.innerWidth ? window.innerWidth - 200 : (elmnt.offsetLeft - pos1);
|
|
|
|
let yPos = (elmnt.offsetTop - pos2) > window.innerHeight - 20 ? window.innerHeight - 100 : (elmnt.offsetTop - pos2)
|
|
|
|
xPos = xPos < 0 ? 0 : xPos;
|
|
|
|
yPos = yPos < 0 ? 0 : yPos;
|
|
|
|
if (xPos != (elmnt.offsetLeft - pos1) || yPos != (elmnt.offsetTop - pos2)) {
|
|
|
|
elmnt.style.top = (yPos) + "px";
|
|
|
|
elmnt.style.left = (xPos) + "px";
|
|
|
|
}
|
|
|
|
game.system.rdd.calendrier.calendrierPos.top = yPos;
|
|
|
|
game.system.rdd.calendrier.calendrierPos.left = xPos;
|
|
|
|
if (game.user.isGM) {
|
|
|
|
game.settings.set(SYSTEM_RDD, "calendrier-pos", duplicate(game.system.rdd.calendrier.calendrierPos));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (isRightMB) {
|
|
|
|
game.system.rdd.calendrier.calendrierPos.top = 200;
|
|
|
|
game.system.rdd.calendrier.calendrierPos.left = 200;
|
|
|
|
if (game.user.isGM) {
|
|
|
|
game.settings.set(SYSTEM_RDD, "calendrier-pos", duplicate(game.system.rdd.calendrier.calendrierPos));
|
|
|
|
}
|
|
|
|
this.setPos(game.system.rdd.calendrier.calendrierPos);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
getListeNombreAstral() {
|
|
|
|
return game.settings.get(SYSTEM_RDD, "liste-nombre-astral") ?? [];
|
2020-12-08 21:40:41 +01:00
|
|
|
}
|
2020-12-08 23:28:29 +01:00
|
|
|
|
2020-12-10 20:14:35 +01:00
|
|
|
/* -------------------------------------------- */
|
2023-01-05 00:55:04 +01:00
|
|
|
dateCourante() {
|
|
|
|
return this.timestamp.formatDate();
|
2020-12-10 20:14:35 +01:00
|
|
|
}
|
|
|
|
|
2023-01-05 00:55:04 +01:00
|
|
|
isAfterIndexDate(indexDate) {
|
2023-01-07 20:06:04 +01:00
|
|
|
// TODO: standardize
|
2023-01-05 00:55:04 +01:00
|
|
|
return indexDate < this.timestamp.indexDate;
|
2021-04-04 18:37:16 +02:00
|
|
|
}
|
|
|
|
|
2021-01-16 18:54:07 +01:00
|
|
|
/* -------------------------------------------- */
|
2023-01-05 00:55:04 +01:00
|
|
|
heureCourante() { return RdDTimestamp.definition(this.timestamp.heure); }
|
2021-01-16 18:54:07 +01:00
|
|
|
|
2020-12-09 00:01:02 +01:00
|
|
|
/* -------------------------------------------- */
|
2023-01-05 00:55:04 +01:00
|
|
|
getCurrentMinute() { return this.timestamp.indexMinute; }
|
|
|
|
|
|
|
|
getTimestampFinChateauDormant(nbJours = 0) {
|
2023-02-07 18:06:45 +01:00
|
|
|
return this.timestamp.nouveauJour().addJours(nbJours);
|
2023-01-05 00:55:04 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
getTimestampFinHeure(nbHeures = 0) {
|
|
|
|
return this.timestamp.nouvelleHeure().addHeures(nbHeures);
|
2020-12-09 00:01:02 +01:00
|
|
|
}
|
2021-03-14 16:02:31 +01:00
|
|
|
|
2021-04-04 18:37:16 +02:00
|
|
|
/* -------------------------------------------- */
|
|
|
|
getIndexFromDate(jour, mois) {
|
2023-01-05 00:55:04 +01:00
|
|
|
const addYear = mois < this.timestamp.mois || (mois == this.timestamp.mois && jour < this.timestamp.jour)
|
|
|
|
const time = RdDTimestamp.timestamp(this.timestamp.annee + (addYear ? 1 : 0), mois, jour);
|
|
|
|
return time.indexDate;
|
2021-04-04 18:37:16 +02:00
|
|
|
}
|
2023-01-05 00:55:04 +01:00
|
|
|
|
2020-12-12 23:31:19 +01:00
|
|
|
/* -------------------------------------------- */
|
2023-01-05 00:55:04 +01:00
|
|
|
getJoursSuivants(count) {
|
2020-12-12 23:31:19 +01:00
|
|
|
let jours = [];
|
2023-01-05 00:55:04 +01:00
|
|
|
let indexDate = this.timestamp.indexDate;
|
|
|
|
for (let i = 0; i < count; i++, indexDate++) {
|
|
|
|
jours[i] = { label: RdDTimestamp.formatIndexDate(indexDate), index: indexDate };
|
2020-12-12 23:31:19 +01:00
|
|
|
}
|
|
|
|
return jours;
|
|
|
|
}
|
2021-03-14 16:02:31 +01:00
|
|
|
|
2020-12-08 23:28:29 +01:00
|
|
|
/* -------------------------------------------- */
|
2023-01-05 00:55:04 +01:00
|
|
|
async ajouterNombreAstral(indexDate, showDice = SHOW_DICE) {
|
2021-12-03 22:53:38 +01:00
|
|
|
const nombreAstral = await RdDDice.rollTotal("1dh", { showDice: showDice, rollMode: "selfroll" });
|
2023-01-05 00:55:04 +01:00
|
|
|
const dateFuture = RdDTimestamp.formatIndexDate(indexDate);
|
2021-12-03 22:53:38 +01:00
|
|
|
if (showDice != HIDE_DICE) {
|
2021-07-09 01:01:12 +02:00
|
|
|
ChatMessage.create({
|
2021-06-25 14:40:25 +02:00
|
|
|
whisper: ChatMessage.getWhisperRecipients("GM"),
|
|
|
|
content: `Le chiffre astrologique du ${dateFuture} sera le ${nombreAstral}`
|
|
|
|
});
|
|
|
|
}
|
2020-12-08 23:28:29 +01:00
|
|
|
return {
|
2021-05-19 23:04:34 +02:00
|
|
|
nombreAstral: nombreAstral,
|
2020-12-08 23:28:29 +01:00
|
|
|
valeursFausses: [],
|
2023-01-05 00:55:04 +01:00
|
|
|
index: indexDate
|
2020-12-08 23:28:29 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-25 10:08:40 +02:00
|
|
|
/* -------------------------------------------- */
|
2021-05-19 23:04:34 +02:00
|
|
|
resetNombreAstral() {
|
2021-04-25 10:08:40 +02:00
|
|
|
this.listeNombreAstral = [];
|
2023-01-09 23:20:51 +01:00
|
|
|
game.settings.set(SYSTEM_RDD, "liste-nombre-astral", []);
|
2021-06-01 21:58:40 +02:00
|
|
|
|
2022-01-29 22:49:34 +01:00
|
|
|
game.socket.emit(SYSTEM_SOCKET_ID, {
|
2021-06-01 21:58:40 +02:00
|
|
|
msg: "msg_reset_nombre_astral",
|
|
|
|
data: {}
|
|
|
|
});
|
2021-04-25 10:08:40 +02:00
|
|
|
}
|
|
|
|
|
2021-06-09 00:00:15 +02:00
|
|
|
/* -------------------------------------------- */
|
2023-01-09 23:20:51 +01:00
|
|
|
/**
|
|
|
|
*
|
|
|
|
* @param {*} indexDate la date pour laquelle obtenir le nombre astral. Si undefined, on prend la date du jour
|
|
|
|
* @returns le nombre astral pour la date, ou pour la date du jour si la date n'est pas fournie.
|
|
|
|
* Si aucun nombre astral n'est trouvé, retourne 0 (cas où l'on demanderait un nombre astral en dehors des 12 jours courant et à venir)
|
|
|
|
*/
|
|
|
|
getNombreAstral(indexDate = undefined) {
|
|
|
|
if (indexDate == undefined) {
|
|
|
|
indexDate = this.timestamp.indexDate;
|
|
|
|
}
|
2022-11-25 03:17:07 +01:00
|
|
|
const listNombreAstral = this.getListeNombreAstral();
|
|
|
|
let astralData = listNombreAstral.find((nombreAstral, i) => nombreAstral.index == indexDate);
|
2023-01-09 23:20:51 +01:00
|
|
|
return astralData?.nombreAstral ?? 0;
|
2020-12-12 23:31:19 +01:00
|
|
|
}
|
2021-02-04 01:00:17 +01:00
|
|
|
|
2020-12-08 23:28:29 +01:00
|
|
|
/* -------------------------------------------- */
|
2022-11-25 03:17:07 +01:00
|
|
|
async rebuildListeNombreAstral(showDice = HIDE_DICE) {
|
2021-11-26 00:45:21 +01:00
|
|
|
if (Misc.isUniqueConnectedGM()) {
|
2021-05-20 21:36:20 +02:00
|
|
|
let newList = [];
|
2021-06-09 00:00:15 +02:00
|
|
|
for (let i = 0; i < MAX_NOMBRE_ASTRAL; i++) {
|
2023-01-05 00:55:04 +01:00
|
|
|
let dayIndex = this.timestamp.indexDate + i;
|
2021-06-09 00:00:15 +02:00
|
|
|
let na = this.listeNombreAstral.find(n => n.index == dayIndex);
|
|
|
|
if (na) {
|
2021-07-09 01:01:12 +02:00
|
|
|
newList[i] = na;
|
2021-06-07 22:52:42 +02:00
|
|
|
} else {
|
2021-07-09 01:01:12 +02:00
|
|
|
newList[i] = await this.ajouterNombreAstral(dayIndex, showDice);
|
2021-05-20 21:36:20 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
this.listeNombreAstral = newList;
|
2023-01-05 00:55:04 +01:00
|
|
|
game.settings.set(SYSTEM_RDD, "liste-nombre-astral", newList);
|
2020-12-08 23:28:29 +01:00
|
|
|
}
|
2021-03-14 16:02:31 +01:00
|
|
|
}
|
2021-06-09 16:38:52 +02:00
|
|
|
|
2021-03-14 16:02:31 +01:00
|
|
|
/* -------------------------------------------- */
|
2023-01-05 00:55:04 +01:00
|
|
|
async setNewTimestamp(newTimestamp) {
|
2023-02-07 18:06:45 +01:00
|
|
|
const oldTimestamp = this.timestamp;
|
|
|
|
game.actors.forEach(actor => actor.onTimeChanging(oldTimestamp, newTimestamp));
|
2023-01-05 00:55:04 +01:00
|
|
|
RdDTimestamp.setWorldTime(newTimestamp);
|
2023-02-07 18:06:45 +01:00
|
|
|
if (oldTimestamp.indexDate + 1 == newTimestamp.indexDate && ReglesOptionelles.isUsing("chateau-dormant-gardien")) {
|
|
|
|
await DialogChateauDormant.create();
|
|
|
|
}
|
2023-01-05 00:55:04 +01:00
|
|
|
this.timestamp = newTimestamp;
|
|
|
|
await this.rebuildListeNombreAstral();
|
2021-06-05 20:53:43 +02:00
|
|
|
this.updateDisplay();
|
2020-12-08 23:28:29 +01:00
|
|
|
}
|
|
|
|
|
2020-12-08 21:40:41 +01:00
|
|
|
/* -------------------------------------------- */
|
2023-01-05 00:55:04 +01:00
|
|
|
async onCalendarButton(ev) {
|
|
|
|
ev.preventDefault();
|
|
|
|
const calendarAvance = ev.currentTarget.attributes['data-calendar-avance'];
|
|
|
|
const calendarSet = ev.currentTarget.attributes['data-calendar-set'];
|
|
|
|
if (calendarAvance) {
|
|
|
|
await this.incrementTime(Number(calendarAvance.value));
|
2022-12-29 02:31:29 +01:00
|
|
|
}
|
2023-01-05 00:55:04 +01:00
|
|
|
else if (calendarSet) {
|
|
|
|
this.positionnerHeure(Number(calendarSet.value));
|
2020-12-08 21:40:41 +01:00
|
|
|
}
|
2023-01-05 00:55:04 +01:00
|
|
|
this.updateDisplay();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
async incrementTime(minutes = 0) {
|
|
|
|
await this.setNewTimestamp(this.timestamp.addMinutes(minutes));
|
2020-12-08 21:40:41 +01:00
|
|
|
}
|
2021-03-14 16:02:31 +01:00
|
|
|
|
2020-12-08 23:28:29 +01:00
|
|
|
/* -------------------------------------------- */
|
2021-07-09 01:01:12 +02:00
|
|
|
async incrementerJour() {
|
2023-01-05 00:55:04 +01:00
|
|
|
await this.setNewTimestamp(this.timestamp.nouveauJour());
|
2020-12-08 23:28:29 +01:00
|
|
|
}
|
|
|
|
|
2020-12-08 21:40:41 +01:00
|
|
|
/* -------------------------------------------- */
|
2023-01-08 23:20:54 +01:00
|
|
|
async positionnerHeure(heure) {
|
|
|
|
const indexDate = this.timestamp.indexDate;
|
|
|
|
const addDay = this.timestamp.heure < heure ? 0 : 1;
|
2023-02-07 18:06:45 +01:00
|
|
|
const newTimestamp = new RdDTimestamp({ indexDate: indexDate + addDay}).addHeures(heure);
|
|
|
|
await this.setNewTimestamp(newTimestamp)
|
2020-12-08 21:40:41 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
2021-03-16 22:56:57 +01:00
|
|
|
fillCalendrierData(formData = {}) {
|
2023-01-07 23:28:30 +01:00
|
|
|
mergeObject(formData, this.timestamp.toCalendrier());
|
2021-03-16 22:56:57 +01:00
|
|
|
formData.isGM = game.user.isGM;
|
|
|
|
return formData;
|
2020-12-08 21:40:41 +01:00
|
|
|
}
|
|
|
|
|
2020-12-12 23:31:19 +01:00
|
|
|
/* -------------------------------------------- */
|
2021-03-14 16:02:31 +01:00
|
|
|
getLectureAstrologieDifficulte(dateIndex) {
|
2023-01-05 00:55:04 +01:00
|
|
|
let indexNow = this.timestamp.indexDate;
|
2020-12-12 23:31:19 +01:00
|
|
|
let diffDay = dateIndex - indexNow;
|
|
|
|
return - Math.floor(diffDay / 2);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
2021-03-14 16:02:31 +01:00
|
|
|
async requestNombreAstral(request) {
|
2022-12-29 02:31:29 +01:00
|
|
|
const actor = game.actors.get(request.id);
|
2021-11-26 00:45:21 +01:00
|
|
|
if (Misc.isUniqueConnectedGM()) { // Only once
|
2021-03-14 16:02:31 +01:00
|
|
|
console.log(request);
|
|
|
|
let jourDiff = this.getLectureAstrologieDifficulte(request.date);
|
2022-06-12 12:14:55 +02:00
|
|
|
let niveau = Number(request.astrologie.system.niveau) + Number(request.conditions) + Number(jourDiff) + Number(request.etat);
|
2021-05-19 23:04:34 +02:00
|
|
|
let rollData = {
|
2020-12-17 00:05:32 +01:00
|
|
|
caracValue: request.carac_vue,
|
|
|
|
finalLevel: niveau,
|
2021-12-03 22:53:38 +01:00
|
|
|
showDice: HIDE_DICE,
|
2021-06-13 21:56:01 +02:00
|
|
|
rollMode: "blindroll"
|
2021-04-01 00:01:37 +02:00
|
|
|
};
|
|
|
|
await RdDResolutionTable.rollData(rollData);
|
|
|
|
request.rolled = rollData.rolled;
|
2022-12-29 02:31:29 +01:00
|
|
|
request.isValid = request.rolled.isSuccess;
|
|
|
|
request.nbAstral = this.getNombreAstral(request.date);
|
2023-01-05 00:55:04 +01:00
|
|
|
|
2022-12-29 02:31:29 +01:00
|
|
|
if (request.rolled.isSuccess) {
|
2023-01-05 00:55:04 +01:00
|
|
|
if (request.rolled.isPart) {
|
2022-12-29 02:31:29 +01:00
|
|
|
// Gestion expérience (si existante)
|
|
|
|
request.competence = actor.getCompetence("astrologie")
|
|
|
|
request.selectedCarac = actor.system.carac["vue"];
|
|
|
|
actor.appliquerAjoutExperience(request, 'hide');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
request.nbAstral = await RdDDice.rollTotal("1dhr" + request.nbAstral, {
|
|
|
|
rollMode: "selfroll", showDice: HIDE_DICE
|
|
|
|
});
|
2020-12-12 23:41:04 +01:00
|
|
|
// Mise à jour des nombres astraux du joueur
|
2022-12-29 02:31:29 +01:00
|
|
|
this.addNbAstralIncorect(request.id, request.date, request.nbAstral);
|
2020-12-12 23:31:19 +01:00
|
|
|
}
|
2022-12-29 02:31:29 +01:00
|
|
|
|
2021-11-26 00:45:21 +01:00
|
|
|
if (Misc.getActiveUser(request.userId)?.isGM) {
|
2021-03-14 16:02:31 +01:00
|
|
|
RdDUtility.responseNombreAstral(request);
|
|
|
|
} else {
|
2022-01-29 22:49:34 +01:00
|
|
|
game.socket.emit(SYSTEM_SOCKET_ID, {
|
2020-12-12 23:31:19 +01:00
|
|
|
msg: "msg_response_nombre_astral",
|
2021-03-14 16:02:31 +01:00
|
|
|
data: request
|
|
|
|
});
|
2020-12-12 23:31:19 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-12-29 02:31:29 +01:00
|
|
|
addNbAstralIncorect(actorId, date, nbAstral) {
|
|
|
|
let astralData = this.listeNombreAstral.find((nombreAstral, i) => nombreAstral.index == date);
|
|
|
|
astralData.valeursFausses.push({ actorId: actorId, nombreAstral: nbAstral });
|
|
|
|
game.settings.set(SYSTEM_RDD, "liste-nombre-astral", this.listeNombreAstral);
|
|
|
|
}
|
|
|
|
|
2023-01-09 23:20:51 +01:00
|
|
|
static ecartHeureChance(heureNaissance, nombreAstral, heure) {
|
|
|
|
return (heureNaissance + nombreAstral - heure) % RDD_HEURES_PAR_JOUR;
|
2021-10-11 11:09:30 +02:00
|
|
|
}
|
2021-06-04 18:30:06 +02:00
|
|
|
|
2020-12-11 16:19:19 +01:00
|
|
|
/* -------------------------------------------- */
|
2021-06-04 18:30:06 +02:00
|
|
|
getAjustementAstrologique(heureNaissance, name = undefined) {
|
2023-01-05 00:55:04 +01:00
|
|
|
let defHeure = RdDTimestamp.findHeure(heureNaissance);
|
2021-06-04 18:30:06 +02:00
|
|
|
if (defHeure) {
|
2023-01-09 23:20:51 +01:00
|
|
|
return RdDCalendrier.ajustementAstrologiqueHeure(defHeure.heure, this.getNombreAstral(), this.timestamp.heure);
|
2020-12-15 23:28:59 +01:00
|
|
|
}
|
2021-06-04 18:30:06 +02:00
|
|
|
else if (name) {
|
2021-01-16 18:54:07 +01:00
|
|
|
ui.notifications.warn(name + " n'a pas d'heure de naissance, ou elle est incorrecte : " + heureNaissance);
|
2020-12-11 03:23:34 +01:00
|
|
|
}
|
2021-06-09 00:00:15 +02:00
|
|
|
else {
|
|
|
|
ui.notifications.warn(heureNaissance + " ne correspond pas à une heure de naissance");
|
2021-06-04 18:30:06 +02:00
|
|
|
}
|
2020-12-11 03:23:34 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2023-01-09 23:20:51 +01:00
|
|
|
static ajustementAstrologiqueHeure(hn, nbAstral, heure) {
|
|
|
|
switch (RdDCalendrier.ecartHeureChance(hn, nbAstral, heure)) {
|
|
|
|
case 0: return 4;
|
|
|
|
case 4: case 8: return 2;
|
|
|
|
case 6: return -4;
|
|
|
|
case 3: case 9: return -2;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-12-08 21:40:41 +01:00
|
|
|
/* -------------------------------------------- */
|
|
|
|
getData() {
|
2021-03-16 22:56:57 +01:00
|
|
|
let formData = super.getData();
|
|
|
|
this.fillCalendrierData(formData);
|
2021-03-14 16:02:31 +01:00
|
|
|
this.setPos(this.calendrierPos);
|
2021-03-16 22:56:57 +01:00
|
|
|
return formData;
|
2020-12-08 21:40:41 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
setPos(pos) {
|
|
|
|
return new Promise(resolve => {
|
|
|
|
function check() {
|
|
|
|
let elmnt = document.getElementById("calendar-time-container");
|
|
|
|
if (elmnt) {
|
2022-11-05 18:06:30 +01:00
|
|
|
elmnt.style.bottom = undefined;
|
2021-03-14 16:02:31 +01:00
|
|
|
let xPos = (pos.left) > window.innerWidth ? window.innerWidth - 200 : pos.left;
|
|
|
|
let yPos = (pos.top) > window.innerHeight - 20 ? window.innerHeight - 100 : pos.top;
|
2020-12-08 21:40:41 +01:00
|
|
|
elmnt.style.top = (yPos) + "px";
|
|
|
|
elmnt.style.left = (xPos) + "px";
|
|
|
|
resolve();
|
|
|
|
} else {
|
|
|
|
setTimeout(check, 30);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
check();
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
2021-05-27 01:08:17 +02:00
|
|
|
updateDisplay() {
|
2022-09-07 18:47:56 +02:00
|
|
|
let calendrier = this.fillCalendrierData();
|
|
|
|
// Rebuild text du calendrier
|
2023-01-08 20:41:50 +01:00
|
|
|
let dateHTML = `${calendrier.jourDuMois} ${calendrier.mois.label} (${calendrier.mois.saison}) de l'année ${calendrier.annee}`
|
2020-12-21 20:54:24 +01:00
|
|
|
if (game.user.isGM) {
|
2023-01-09 23:20:51 +01:00
|
|
|
dateHTML = dateHTML + "<br>Nombre Astral: " + (this.getNombreAstral() ?? "?");
|
2021-03-14 16:02:31 +01:00
|
|
|
}
|
2021-03-31 23:59:31 +02:00
|
|
|
for (let handle of document.getElementsByClassName("calendar-date-rdd")) {
|
2021-03-14 16:02:31 +01:00
|
|
|
handle.innerHTML = dateHTML;
|
|
|
|
}
|
|
|
|
for (let heure of document.getElementsByClassName("calendar-heure-texte")) {
|
2023-01-07 20:06:04 +01:00
|
|
|
heure.innerHTML = calendrier.heure.label;
|
2021-03-14 16:02:31 +01:00
|
|
|
}
|
|
|
|
for (const minute of document.getElementsByClassName("calendar-time-disp")) {
|
2023-01-07 20:06:04 +01:00
|
|
|
minute.innerHTML = `${calendrier.minute} minutes`;
|
2021-03-14 16:02:31 +01:00
|
|
|
}
|
|
|
|
for (const heureImg of document.getElementsByClassName("calendar-heure-img")) {
|
2023-01-07 20:06:04 +01:00
|
|
|
heureImg.src = calendrier.heure.icon;
|
2020-12-21 20:54:24 +01:00
|
|
|
}
|
2020-12-08 21:40:41 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
2021-05-19 23:04:34 +02:00
|
|
|
async saveEditeur(calendrierData) {
|
2023-01-05 00:55:04 +01:00
|
|
|
const newTimestamp = RdDTimestamp.timestamp(
|
|
|
|
Number.parseInt(calendrierData.annee),
|
2023-01-07 20:06:04 +01:00
|
|
|
calendrierData.mois.heure,
|
2023-01-05 00:55:04 +01:00
|
|
|
Number.parseInt(calendrierData.jourMois),
|
2023-01-07 20:06:04 +01:00
|
|
|
calendrierData.heure.heure,
|
|
|
|
Number.parseInt(calendrierData.minutes)
|
2023-01-05 00:55:04 +01:00
|
|
|
);
|
|
|
|
await this.setNewTimestamp(newTimestamp);
|
2020-12-08 21:40:41 +01:00
|
|
|
}
|
2021-03-14 16:02:31 +01:00
|
|
|
|
2020-12-08 21:40:41 +01:00
|
|
|
/* -------------------------------------------- */
|
2021-03-14 16:02:31 +01:00
|
|
|
async showCalendarEditor() {
|
2023-01-05 00:55:04 +01:00
|
|
|
let calendrierData = this.fillCalendrierData();
|
2021-03-14 16:02:31 +01:00
|
|
|
if (this.editeur == undefined) {
|
|
|
|
let html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/calendar-editor-template.html', calendrierData);
|
|
|
|
this.editeur = new RdDCalendrierEditeur(html, this, calendrierData)
|
2020-12-08 21:40:41 +01:00
|
|
|
}
|
2021-03-14 16:02:31 +01:00
|
|
|
this.editeur.updateData(calendrierData);
|
2020-12-08 21:40:41 +01:00
|
|
|
this.editeur.render(true);
|
|
|
|
}
|
|
|
|
|
2023-01-05 00:55:04 +01:00
|
|
|
static buildJoursMois() { return JOURS_DU_MOIS; }
|
2021-06-09 00:00:15 +02:00
|
|
|
|
2020-12-10 20:14:35 +01:00
|
|
|
/* -------------------------------------------- */
|
|
|
|
async showAstrologieEditor() {
|
2023-01-05 00:55:04 +01:00
|
|
|
const calendrierData = duplicate(this.fillCalendrierData());
|
2021-12-18 09:45:36 +01:00
|
|
|
this.listeNombreAstral = this.listeNombreAstral || [];
|
2023-01-05 00:55:04 +01:00
|
|
|
|
|
|
|
calendrierData.astrologieData = this.listeNombreAstral.map(astro => {
|
|
|
|
const timestamp = new RdDTimestamp({ indexDate: astro.index });
|
|
|
|
astro.date = { mois: timestamp.mois, jour: timestamp.jour + 1 }
|
|
|
|
for (let vf of astro.valeursFausses) {
|
2021-03-14 16:02:31 +01:00
|
|
|
let actor = game.actors.get(vf.actorId);
|
2020-12-13 23:11:58 +01:00
|
|
|
vf.actorName = (actor) ? actor.name : "Inconnu";
|
|
|
|
}
|
2023-01-05 00:55:04 +01:00
|
|
|
return astro;
|
|
|
|
});
|
|
|
|
|
2023-01-09 23:20:51 +01:00
|
|
|
const nbAstral = this.getNombreAstral()
|
|
|
|
calendrierData.heures = Array.from(Array(RDD_HEURES_PAR_JOUR).keys());
|
|
|
|
calendrierData.ajustementsActeur = game.actors.filter(it => it.isPersonnage() && it.hasPlayerOwner).map(actor => {
|
|
|
|
return {
|
|
|
|
actor,
|
|
|
|
ajustements: calendrierData.heures.map(heure => {
|
|
|
|
const hn = RdDTimestamp.findHeure(actor.getHeureNaissance())?.heure;
|
|
|
|
return {
|
|
|
|
heure,
|
|
|
|
ajustement: RdDCalendrier.ajustementAstrologiqueHeure(hn, nbAstral, heure)
|
|
|
|
}
|
|
|
|
})
|
2022-12-29 02:31:29 +01:00
|
|
|
}
|
2023-01-09 23:20:51 +01:00
|
|
|
});
|
|
|
|
|
2021-03-14 16:02:31 +01:00
|
|
|
let html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/calendar-astrologie-template.html', calendrierData);
|
|
|
|
let astrologieEditeur = new RdDAstrologieEditeur(html, this, calendrierData)
|
|
|
|
astrologieEditeur.updateData(calendrierData);
|
2020-12-11 08:29:24 +01:00
|
|
|
astrologieEditeur.render(true);
|
2020-12-10 20:14:35 +01:00
|
|
|
}
|
2020-09-20 16:36:39 +02:00
|
|
|
}
|