foundryvtt-reve-de-dragon/module/rdd-calendrier.js

521 lines
20 KiB
JavaScript
Raw Normal View History

2020-09-20 16:36:39 +02:00
/* -------------------------------------------- */
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-11 02:20:41 +01:00
import { HtmlUtility } from "./html-utility.js";
2020-12-12 23:31:19 +01:00
import { RdDResolutionTable } from "./rdd-resolution-table.js";
import { RdDUtility } from "./rdd-utility.js";
2020-12-08 21:40:41 +01:00
/* -------------------------------------------- */
2020-12-11 02:20:41 +01:00
const dossierIconesHeures = 'systems/foundryvtt-reve-de-dragon/icons/heures/'
2020-12-08 21:40:41 +01:00
const heuresList = [ "vaisseau", "sirene", "faucon", "couronne", "dragon", "epees", "lyre", "serpent", "poissonacrobate", "araignee", "roseau", "chateaudormant" ];
2020-12-11 02:20:41 +01:00
const heuresDef = { "vaisseau": { label: "Vaisseau", lettreFont: 'v', saison: "printemps", heure: 0, icon: 'hd01.svg' },
"sirene": { label: "Sirène", lettreFont: 'S', saison: "printemps", heure: 1, icon: 'hd02.svg' },
"faucon": { label: "Faucon", lettreFont: 'f', saison: "printemps", heure: 2, icon: 'hd03.svg' },
"couronne": { label: "Couronne", lettreFont: 'C', saison: "ete", heure: 3, icon: 'hd04.svg' },
"dragon": { label: "Dragon", lettreFont: 'd', saison: "ete", heure: 4, icon: 'hd05.svg' },
"epees": { label: "Epées", lettreFont: 'e', saison: "ete", heure: 5, icon: 'hd06.svg' },
"lyre": { label: "Lyre", lettreFont: 'l', saison: "automne", heure: 6, icon: 'hd07.svg' },
"serpent": { label: "Serpent", lettreFont: 's', saison: "automne", heure: 7, icon: 'hd08.svg' },
"poissonacrobate": { label: "Poisson Acrobate", lettreFont: 'p', saison: "automne", heure: 8, icon: 'hd09.svg' },
"araignee": { label: "Araignée", lettreFont: 'a', saison: "hiver", heure: 9, icon: 'hd10.svg' },
"roseau": { label: "Roseau", lettreFont: 'r', saison: "hiver", heure: 10, icon: 'hd11.svg' },
"chateaudormant": { label: "Château Dormant", lettreFont: 'c', saison: "hiver", heure: 11, icon: 'hd12.svg' }
2020-12-08 21:40:41 +01:00
};
const saisonsDef = { "printemps": { label: "Printemps"},
"ete": { label: "Eté"},
"automne": { label: "Automne"},
"hiver": { label: "Hiver"}
};
const RDD_JOUR_PAR_MOIS = 28;
2020-12-11 08:29:24 +01:00
const MAX_NOMBRE_ASTRAL = 12;
2020-09-20 16:36:39 +02:00
/* -------------------------------------------- */
export class RdDCalendrier extends Application {
2020-12-08 21:40:41 +01:00
/* -------------------------------------------- */
async initCalendrier() {
// Calendrier
this.calendrier = duplicate(game.settings.get("foundryvtt-reve-de-dragon", "calendrier"));
console.log("CALENDRIER", this.calendrier);
if ( this.calendrier == undefined || this.calendrier.moisRdD == undefined) {
this.calendrier.heureRdD = 0; // Index dans heuresList
this.calendrier.heuresRelative = 0;
this.calendrier.minutesRelative = 0;
this.calendrier.moisRdD = 0; // Index dans heuresList
2020-12-11 08:29:24 +01:00
this.calendrier.jour = 0;
2020-12-08 21:40:41 +01:00
if ( game.user.isGM) { // Uniquement si GM
game.settings.set("foundryvtt-reve-de-dragon", "calendrier", this.calendrier );
}
}
// position
this.calendrierPos = duplicate(game.settings.get("foundryvtt-reve-de-dragon", "calendrier-pos"));
if ( this.calendrierPos == undefined || this.calendrierPos.top == undefined) {
this.calendrierPos.top = 200;
this.calendrierPos.left = 200;
if ( game.user.isGM) { // Uniquement si GM
game.settings.set("foundryvtt-reve-de-dragon", "calendrier-pos", this.calendrierPos );
}
}
// nombre astral
if ( game.user.isGM) {
this.listeNombreAstral = this._loadListNombreAstral();
2020-12-09 00:01:02 +01:00
this.rebuildListeNombreAstral(); // Ensure always up-to-date
}
2020-12-08 23:35:44 +01:00
console.log(this.calendrier, this.calendrierPos, this.listeNombreAstral);
2020-12-08 21:40:41 +01:00
}
/* -------------------------------------------- */
_loadListNombreAstral() {
return Object.values(game.settings.get("foundryvtt-reve-de-dragon", "liste-nombre-astral"));
}
/* -------------------------------------------- */
2020-12-08 21:40:41 +01:00
static get defaultOptions() {
const options = super.defaultOptions;
options.template = "systems/foundryvtt-reve-de-dragon/templates/calendar-template.html";
options.popOut = false;
options.resizable = false;
return options;
}
2020-12-08 23:28:29 +01:00
2020-12-10 20:14:35 +01:00
/* -------------------------------------------- */
getDateFromIndex( index ) {
2020-12-11 08:29:24 +01:00
let month = Math.floor(index / 28);
let day = (index - (month*28)) + 1;
return day+" "+heuresList[month];
2020-12-10 20:14:35 +01:00
}
2020-12-09 00:01:02 +01:00
/* -------------------------------------------- */
getCurrentDayIndex( ) {
return (this.calendrier.moisRdD * 28) + this.calendrier.jour;
}
2020-12-12 23:31:19 +01:00
/* -------------------------------------------- */
getJoursSuivants( num) {
let jours = [];
let index = this.getCurrentDayIndex();
for (let i=0; i<num; i++) {
jours[i] = { label: this.getDateFromIndex(index), index: index };
index += 1;
}
return jours;
}
2020-12-08 23:28:29 +01:00
/* -------------------------------------------- */
2020-12-11 03:23:34 +01:00
ajouterNombreAstral(index) {
2020-12-08 23:28:29 +01:00
return {
nombreAstral: new Roll("1d12").roll().total,
valeursFausses: [],
index: index
}
}
2020-12-09 00:01:02 +01:00
/* -------------------------------------------- */
getCurrentNombreAstral() {
let index = this.getCurrentDayIndex();
return this.getNombreAstral(index);
2020-12-09 00:01:02 +01:00
}
2020-12-12 23:31:19 +01:00
/* -------------------------------------------- */
getNombreAstral( index ) {
const liste = this.listeNombreAstral || this._loadListNombreAstral();
let astralData = liste.find( (nombreAstral, i) => nombreAstral.index == index );
if ( astralData == undefined ) {
this.rebuildListeNombreAstral();
astralData = liste.find( (nombreAstral, i) => nombreAstral.index == index );
}
2020-12-12 23:31:19 +01:00
return astralData.nombreAstral || "N/A";
}
2020-12-08 23:28:29 +01:00
/* -------------------------------------------- */
rebuildListeNombreAstral() {
// Auto-create if needed
if ( this.listeNombreAstral == undefined)
2020-12-11 08:29:24 +01:00
this.listeNombreAstral = [];
2020-12-08 23:28:29 +01:00
// Nettoyage des nombres astraux anciens
let jourCourant = this.getCurrentDayIndex();
let jourFin = jourCourant + 12;
let newList = this.listeNombreAstral.filter( (nombreAstral, i) => nombreAstral && nombreAstral.index >= jourCourant && nombreAstral.index < jourFin);
2020-12-11 08:29:24 +01:00
//console.log("LSTES", this.listeNombreAstral, newList );
let lastDay = jourCourant;
for (let i=0; i < MAX_NOMBRE_ASTRAL; i++) {
let nombreAstral = newList[i];
if ( nombreAstral ) {
lastDay = nombreAstral.index + 1;
} else {
newList.push( this.ajouterNombreAstral( lastDay) );
lastDay += 1;
2020-12-08 23:28:29 +01:00
}
}
2020-12-11 08:29:24 +01:00
this.listeNombreAstral = newList;
2020-12-08 23:28:29 +01:00
game.settings.set("foundryvtt-reve-de-dragon", "liste-nombre-astral", this.listeNombreAstral );
}
2020-12-08 21:40:41 +01:00
/* -------------------------------------------- */
incrementTime(heure, minute = 0) {
this.calendrier.minutesRelative += minute;
if (this.calendrier.minutesRelative >= 60 ) {
this.calendrier.minutesRelative -= 60;
heure += 1;
}
this.calendrier.heuresRelative += heure;
if (this.calendrier.heuresRelative >= 2) {
this.calendrier.heuresRelative -= 2;
this.calendrier.heureRdD += 1;
}
if ( this.calendrier.heureRdD > 11 ) {
this.calendrier.heureRdD -= 12;
2020-12-08 23:28:29 +01:00
this.incrementerJour();
2020-12-08 21:40:41 +01:00
}
game.settings.set("foundryvtt-reve-de-dragon", "calendrier", duplicate(this.calendrier) );
// Notification aux joueurs
game.socket.emit("system.foundryvtt-reve-de-dragon", {
msg: "msg_sync_time",
data: duplicate(this.calendrier)
} );
2020-12-08 21:40:41 +01:00
}
2020-12-08 23:28:29 +01:00
/* -------------------------------------------- */
incrementerJour( ) {
this.calendrier.jour += 1;
2020-12-11 08:29:24 +01:00
if ( this.calendrier.jour >= RDD_JOUR_PAR_MOIS) {
2020-12-08 23:28:29 +01:00
this.calendrier.jour -= RDD_JOUR_PAR_MOIS;
if ( this.calendrier.jour <= 0)
2020-12-11 08:29:24 +01:00
this.calendrier.jour = 0;
2020-12-08 23:28:29 +01:00
this.calendrier.moisRdD += 1;
// Reconstruire les nombres astraux
}
2020-12-11 08:29:24 +01:00
this.rebuildListeNombreAstral();
2020-12-08 23:28:29 +01:00
}
2020-12-08 21:40:41 +01:00
/* -------------------------------------------- */
syncPlayerTime( calendrier ) {
this.calendrier = duplicate(calendrier); // Local copy update
this.updateDisplay(); // Then update
}
/* -------------------------------------------- */
positionnerHeure( indexHeure ) {
if ( indexHeure <= this.calendrier.heureRdD )
2020-12-08 23:28:29 +01:00
this.incrementerJour();
2020-12-08 21:40:41 +01:00
this.calendrier.heureRdD = indexHeure;
this.calendrier.minutesRelative = 0;
this.calendrier.heuresRelative = 0;
game.settings.set("foundryvtt-reve-de-dragon", "calendrier", duplicate(this.calendrier) );
}
/* -------------------------------------------- */
fillCalendrierData( data = {} ) {
let moisKey = heuresList[this.calendrier.moisRdD];
let heureKey = heuresList[this.calendrier.heureRdD];
2020-12-11 02:20:41 +01:00
const mois = heuresDef[moisKey];
const heure = heuresDef[heureKey];
2020-12-08 21:40:41 +01:00
//console.log(moisKey, heureKey);
data.heureKey = heureKey;
data.moisKey = moisKey;
2020-12-11 08:29:24 +01:00
data.jourMois = this.calendrier.jour + 1;
2020-12-11 02:20:41 +01:00
data.nomMois = mois.label; // heures et mois nommés identiques
data.iconMois = dossierIconesHeures + mois.icon;
data.nomHeure = heure.label;
data.iconHeure = dossierIconesHeures + heure.icon;
data.nomSaison = saisonsDef[mois.saison].label;
2020-12-08 21:40:41 +01:00
data.heuresRelative = this.calendrier.heuresRelative;
data.minutesRelative = this.calendrier.minutesRelative;
data.isGM = game.user.isGM;
return data;
}
2020-12-12 23:31:19 +01:00
/* -------------------------------------------- */
getLectureAstrologieDifficulte( dateIndex ) {
let indexNow = this.getCurrentDayIndex();
let diffDay = dateIndex - indexNow;
return - Math.floor(diffDay / 2);
}
/* -------------------------------------------- */
async requestNombreAstral( request) {
if ( game.user.isGM) { // Only GM
console.log( request );
let jourDiff = this.getLectureAstrologieDifficulte( request.date);
2020-12-13 23:11:58 +01:00
let niveau = Number(request.astrologie.data.niveau) + Number(request.conditions) + Number(jourDiff) + Number(request.etat);
2020-12-17 00:05:32 +01:00
let rolled = await RdDResolutionTable.rollData({
caracValue: request.carac_vue,
finalLevel: niveau,
showDice: false});
2020-12-12 23:31:19 +01:00
let nbAstral = this.getNombreAstral( request.date );
let nbAstralFaux = nbAstral;
request.isValid = true;
2020-12-13 23:32:16 +01:00
request.rolled = rolled;
2020-12-12 23:31:19 +01:00
if ( !rolled .isSuccess ) {
request.isValid = false;
while ( nbAstralFaux == nbAstral ) {
nbAstralFaux = new Roll("1d12").roll().total;
}
nbAstral = nbAstralFaux;
2020-12-12 23:41:04 +01:00
// Mise à jour des nombres astraux du joueur
let astralData = this.listeNombreAstral.find( (nombreAstral, i) => nombreAstral.index == request.date );
astralData.valeursFausses.push( {actorId: request.id, nombreAstral: nbAstralFaux});
game.settings.set("foundryvtt-reve-de-dragon", "liste-nombre-astral", this.listeNombreAstral );
2020-12-12 23:31:19 +01:00
}
request.nbAstral = nbAstral;
if ( game.user.isGM) {
RdDUtility.responseNombreAstral( request );
} else {
game.socket.emit("system.foundryvtt-reve-de-dragon", {
msg: "msg_response_nombre_astral",
data: request
} );
}
}
}
2020-12-11 16:19:19 +01:00
/* -------------------------------------------- */
getAjustementAstrologique(heureNaissance, name='inconnu')
2020-12-11 03:23:34 +01:00
{
if (heureNaissance && heuresDef[heureNaissance]) {
let hn = heuresDef[heureNaissance].heure;
let chiffreAstral = this.getCurrentNombreAstral();
let heureCourante = this.calendrier.heureRdD;
let ecartChance = (hn + chiffreAstral - heureCourante)%12;
switch (ecartChance)
{
case 0: return 4;
case 4: case 8: return 2;
case 6: return -4;
case 3: case 9: return -2;
}
}
else {
2020-12-15 23:53:32 +01:00
ui.notifications.warn(this.data.name + " n'a pas d'heure de naissance, ou elle est incorrecte");
2020-12-11 03:23:34 +01:00
}
return 0;
}
2020-12-08 21:40:41 +01:00
/* -------------------------------------------- */
getData() {
let data = super.getData();
this.fillCalendrierData(data);
this.setPos( this.calendrierPos );
return data;
}
/* -------------------------------------------- */
setPos(pos) {
return new Promise(resolve => {
function check() {
let elmnt = document.getElementById("calendar-time-container");
if (elmnt) {
elmnt.style.bottom = null;
let xPos = (pos.left) > window.innerWidth ? window.innerWidth-200 : pos.left;
let yPos = (pos.top) > window.innerHeight-20 ? window.innerHeight-100 : pos.top;
elmnt.style.top = (yPos) + "px";
elmnt.style.left = (xPos) + "px";
elmnt.style.position = 'fixed';
elmnt.style.zIndex = 100;
resolve();
} else {
setTimeout(check, 30);
}
}
check();
});
}
/* -------------------------------------------- */
updateDisplay() {
let data = this.fillCalendrierData( );
// Rebuild data
2020-12-21 20:54:24 +01:00
let dateHTML = `Jour ${data.jourMois} de ${data.nomMois} (${data.nomSaison})`;
if (game.user.isGM) {
dateHTML = dateHTML + " - NA: "+this.getCurrentNombreAstral();
}
document.getElementById("calendar--move-handle").innerHTML = dateHTML;
2020-12-11 02:20:41 +01:00
document.getElementById("calendar-heure-texte").innerHTML = `${data.nomHeure}`;
2020-12-08 21:40:41 +01:00
document.getElementById("calendar-time").innerHTML = `${data.heuresRelative}:${data.minutesRelative}`;
2020-12-11 02:20:41 +01:00
document.getElementById("calendar-heure-img").src = data.iconHeure;
2020-12-08 21:40:41 +01:00
}
/* -------------------------------------------- */
saveEditeur( calendrierData ) {
this.calendrier.heuresRelative = Number(calendrierData.heuresRelative);
this.calendrier.minutesRelative = Number(calendrierData.minutesRelative);
2020-12-11 08:29:24 +01:00
this.calendrier.jour = Number(calendrierData.jourMois) - 1;
2020-12-08 21:40:41 +01:00
this.calendrier.moisRdD = heuresList.findIndex(mois => mois === calendrierData.moisKey);
this.calendrier.heureRdD = heuresList.findIndex(heure => heure === calendrierData.heureKey);; // Index dans heuresList
game.settings.set("foundryvtt-reve-de-dragon", "calendrier", duplicate(this.calendrier) );
2020-12-08 23:28:29 +01:00
this.rebuildListeNombreAstral();
2020-12-08 21:40:41 +01:00
this.updateDisplay();
}
/* -------------------------------------------- */
2020-12-10 20:14:35 +01:00
async showCalendarEditor() {
2020-12-08 21:40:41 +01:00
let calendrierData = duplicate( this.fillCalendrierData( ) );
if ( this.editeur == undefined ) {
calendrierData.jourMoisOptions = Array(28).fill().map((item, index) => 1 + index);
calendrierData.heuresOptions = [0, 1];
calendrierData.minutesOptions = Array(60).fill().map((item, index) => 0 + index);
let html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/calendar-editor-template.html', calendrierData );
this.editeur = new RdDCalendrierEditeur(html, this, calendrierData )
}
this.editeur.updateData( calendrierData );
this.editeur.render(true);
}
2020-12-10 20:14:35 +01:00
/* -------------------------------------------- */
async showAstrologieEditor() {
2020-12-11 08:29:24 +01:00
let calendrierData = duplicate( this.fillCalendrierData( ) );
let astrologieArray = [];
for (let astralData of this.listeNombreAstral ) {
astralData.humanDate = this.getDateFromIndex( astralData.index );
2020-12-13 23:11:58 +01:00
for (let vf of astralData.valeursFausses) {
let actor = game.actors.get( vf.actorId);
console.log(vf.actorId, actor );
vf.actorName = (actor) ? actor.name : "Inconnu";
}
2020-12-11 08:29:24 +01:00
astrologieArray.push( duplicate(astralData ) );
2020-12-10 20:14:35 +01:00
}
2020-12-11 08:29:24 +01:00
//console.log("ASTRO", astrologieArray);
calendrierData.astrologieData = astrologieArray;
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 );
astrologieEditeur.render(true);
2020-12-10 20:14:35 +01:00
}
2020-12-08 21:40:41 +01:00
/* -------------------------------------------- */
/** @override */
activateListeners(html) {
super.activateListeners(html);
2020-12-20 02:05:47 +01:00
HtmlUtility._showControlWhen($(".gm-only"), game.user.isGM);
2020-12-11 02:20:41 +01:00
2020-12-08 21:40:41 +01:00
this.updateDisplay();
html.find('#calendar-btn-1min').click(ev => {
ev.preventDefault();
this.incrementTime(0, 1);
this.updateDisplay();
});
html.find('#calendar-btn-5min').click(ev => {
ev.preventDefault();
this.incrementTime(0, 5);
this.updateDisplay();
});
html.find('#calendar-btn-10min').click(ev => {
ev.preventDefault();
this.incrementTime(0, 10);
this.updateDisplay();
});
html.find('#calendar-btn-20min').click(ev => {
ev.preventDefault();
this.incrementTime(0, 20);
this.updateDisplay();
});
html.find('#calendar-btn-30min').click(ev => {
ev.preventDefault();
this.incrementTime(0, 30);
this.updateDisplay();
});
html.find('#calendar-btn-1heure').click(ev => {
ev.preventDefault();
this.incrementTime(2, 0);
this.updateDisplay();
});
html.find('#calendar-btn-vaisseau').click(ev => {
ev.preventDefault();
this.positionnerHeure(0); // 0 -> vaisseau
this.updateDisplay();
});
html.find('#calendar-btn-lyre').click(ev => {
ev.preventDefault();
this.positionnerHeure(6); // 6 -> lyre
this.updateDisplay();
});
html.find('#calendar-btn-edit').click(ev => {
ev.preventDefault();
this.showCalendarEditor();
});
2020-12-10 20:14:35 +01:00
html.find('#astrologie-btn-edit').click(ev => {
ev.preventDefault();
this.showAstrologieEditor();
});
2020-12-08 21:40:41 +01:00
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;
2020-09-20 16:36:39 +02:00
2020-12-08 21:40:41 +01:00
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 = null
elmnt.style.top = (elmnt.offsetTop - pos2) + "px";
elmnt.style.left = (elmnt.offsetLeft - pos1) + "px";
elmnt.style.position = 'fixed';
elmnt.style.zIndex = 100;
}
function closeDragElement() {
// stop moving when mouse button is released:
elmnt.onmousedown = null;
document.onmouseup = null;
document.onmousemove = null;
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;
game.settings.set("foundryvtt-reve-de-dragon", "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;
game.settings.set("foundryvtt-reve-de-dragon", "calendrier-pos", duplicate(game.system.rdd.calendrier.calendrierPos) );
this.setPos(game.system.rdd.calendrier.calendrierPos);
}
});
}
2020-09-20 16:36:39 +02:00
}