VincentVk/foundryvtt-reve-de-dragon
0
0
Fork 0
forked from public/foundryvtt-reve-de-dragon
Code Issues Pull Requests Projects Releases Wiki Activity

Fix interaction endurance/fatigue

Browse Source 
* la fatigue est au moins l'endurance manquante
* l'endurance ne peut pas remonter au dessus du max, mais
 elle peut être au dessus (cas d'une blessure grave avec perte de 2 d'endurance...)
*  recupération d'endurance: on n'est plus sonné
This commit is contained in:
Vincent Vandemeulebrouck 2020-11-20 11:38:27 +01:00
parent 163e85a82f
commit 29dbeeb4db
1 changed files with 58 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

105
module/actor.js
View File

@ -332,39 +332,47 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */ /* -------------------------------------------- */
async dormir(heures=1) { async dormir(heures=1) {
let message = { title : "Récupération", content :"Vous dormez " + heures + " heure" + (heures > 1 ? "s": "") }; let message = { title : "Récupération", content :"Vous dormez " + heures + " heure" + (heures > 1 ? "s": "") };
this.recupereEndurance(message); await this.recupereEndurance(message);
for (let i=0; i<heures; i++) { for (let i=0; i<heures; i++) {
await this.recupererFatigueUneHeure(message); await this.recupererFatigue(message);
this.recuperationReve(message); await this.recuperationReve(message);
} }
ChatMessage.create( message ); ChatMessage.create( message );
} }
/* -------------------------------------------- */ /* -------------------------------------------- */
recupereEndurance(message) { async recupereEndurance(message) {
const avant = this.data.data.sante.endurance.value; const manquant = this._computeEnduranceMax() - this.data.data.sante.endurance.value;
this.santeIncDec("endurance", this.data.data.sante.endurance.max - avant); if (manquant > 0) {
const recupere = this.data.data.sante.endurance.value - avant; await this.santeIncDec("endurance", manquant);
if (recupere>0) { message.content += "<br>Vous récuperez " + manquant + " points d'endurance";
message.content += "<br>Vous récuperez " + recupere + " points d'endurance";
} }
} }
/* -------------------------------------------- */ /* -------------------------------------------- */
async recupererFatigueUneHeure(message) { async recupererFatigue(message) {
let fatigue = duplicate(this.data.data.sante.fatigue) let fatigue = duplicate(this.data.data.sante.fatigue)
if (fatigue.value == 0) { const fatigueMin = this._computeFatigueMin();
if (fatigue.value <= fatigueMin) {
message.content += "<br>Vous êtes déjà reposé"; message.content += "<br>Vous êtes déjà reposé";
return; return;
} }
fatigue.value = Math.max(fatigueMin, this._calculRecuperationSegment(fatigue.value));
console.log("recupererFatigue", fatigue)
await this.update( {"data.sante.fatigue": fatigue } );
if (fatigue.value == 0)
{
message.content += "<br>Vous êtes bien reposé";
}
}
_calculRecuperationSegment(actuel)
{
const segments = RdDUtility.getSegmentsFatigue(this.data.data.sante.endurance.max); const segments = RdDUtility.getSegmentsFatigue(this.data.data.sante.endurance.max);
let cumul = 0; let cumul = 0;
console.log("recupererFatigue", segments);
let i; let i;
for (i=0; i <11; i++) { for (i=0; i <11; i++) {
cumul += segments[i]; cumul += segments[i];
let diff = cumul - fatigue.value ; let diff = cumul - actuel;
if (diff >= 0) if (diff >= 0)
{ {
const limit2Segments = Math.floor(segments[i] / 2); const limit2Segments = Math.floor(segments[i] / 2);
@ -374,17 +382,11 @@ export class RdDActor extends Actor {
cumul -= segments[i]; cumul -= segments[i];
break; break;
} }
} };
fatigue.value = cumul; return cumul;
await this.update( {"data.sante.fatigue": fatigue } );
if (fatigue.value == 0)
{
message.content += "<br>Vous êtes bien reposé";
}
} }
/* -------------------------------------------- */ /* -------------------------------------------- */
recuperationReve(message) { async recuperationReve(message) {
const seuil = this.data.data.reve.seuil.value; const seuil = this.data.data.reve.seuil.value;
const reve = this.getReveActuel(); const reve = this.getReveActuel();
if (reve >= seuil) { if (reve >= seuil) {
@ -740,9 +742,9 @@ export class RdDActor extends Actor {
testSiSonne( sante, endurance ) testSiSonne( sante, endurance )
{ {
let result = new Roll("d20").roll().total; let result = new Roll("d20").roll().total;
if ( result <= endurance.value) if ( result <= endurance)
sante.sonne.value = false; sante.sonne.value = false;
if ( result > endurance.value || result == 20) // 20 is always a failure if ( result > endurance || result == 20) // 20 is always a failure
sante.sonne.value = true; sante.sonne.value = true;
if (result == 1) { if (result == 1) {
sante.sonne.value = false; sante.sonne.value = false;
@ -766,44 +768,51 @@ export class RdDActor extends Actor {
async santeIncDec(name, inc ) { async santeIncDec(name, inc ) {
const sante = duplicate(this.data.data.sante); const sante = duplicate(this.data.data.sante);
let data = sante[name]; let data = sante[name];
let lastValue = data.value; // Useful for Endurance and Sonné let minValue = name == "vie" ? - this.data.data.attributs.sconst : 0;
data.value = data.value + inc; let newValue = Math.max(minValue, Math.min(data.value + inc, data.max));
if ( data.value > data.max ) data.value = data.max;
if ( data.value < 0 ) data.value = 0;
if (name == "endurance" && this.data.type != 'entite' ) { if (name == "endurance" && this.data.type != 'entite' ) {
if ( sante.fatigue && inc < 0 ) { // Each endurance lost -> fatigue lost if ( sante.fatigue && inc < 0 ) { // Each endurance lost -> fatigue lost
sante.fatigue.value = sante.fatigue.value - inc sante.fatigue.value = sante.fatigue.value - inc
} }
// If endurance is 0 -> -1 vie if ( newValue == 0 && inc < 0) { // perte endurance et endurance devient 0 -> -1 vie
if ( data.value == 0 && sante.vie.value > 0) {
sante.vie.value = sante.vie.value - 1; sante.vie.value = sante.vie.value - 1;
} }
let diffVie = sante.vie.max - sante.vie.value; newValue = Math.max(0, newValue);
if ( data.value > data.max - (diffVie*2) ) { if (inc>0) { // le max d'endurance s'applique seulement à la récupération
data.value = data.max - (diffVie*2); newValue = Math.max(newValue, this._computeEnduranceMax())
}
if (data.value - newValue > 1) {
this.testSiSonne(sante, newValue); // Peut-être sonné si 2 points d'endurance perdus d'un coup
} else if (inc>0) {
sante.sonne.value = false;
} }
if ( data.value < 0 ) data.value = 0; // Security
let blessures = this.data.data.blessures;
let nbGraves = this.GetNumberBlessures(blessures.graves.liste);
let nbCritiques = this.GetNumberBlessures(blessures.critiques.liste);
let maxEnd = Math.floor( data.max / (2*nbGraves));
if (data.value > maxEnd ) data.value = maxEnd;
if ( nbCritiques > 0 && data.value > 1) data.value = 1;
if (lastValue - data.value > 1) this.testSiSonne(sante, data); // Peut-être sonné si 2 points d'endurance perdus d'un coup
} }
data.value = newValue;
//console.log(name, inc, data.value); //console.log(name, inc, data.value);
if ( sante.fatigue) { // If endurance lost, then the same amount of fatigue cannot be recovered
let diffEndurance = sante.endurance.max - this.data.data.sante.endurance.value; sante.fatigue.value = Math.max(sante.fatigue.value, this._computeFatigueMin());
if ( sante.fatigue && sante.fatigue.value < diffEndurance) // If endurance lost, then the same amount of fatigue cannot be recovered }
sante.fatigue.value = diffEndurance;
//console.log("SANTE::::", sante); //console.log("SANTE::::", sante);
await this.update( {"data.sante": sante } ); await this.update( {"data.sante": sante } );
} }
_computeFatigueMin() {
return this.data.data.sante.endurance.max - this.data.data.sante.endurance.value;
}
_computeEnduranceMax() {
let blessures = this.data.data.blessures;
let diffVie = this.data.data.sante.vie.max - this.data.data.sante.vie.value;
let maxEndVie = this.data.data.sante.endurance.max - (diffVie * 2);
let nbGraves = this.GetNumberBlessures(blessures.graves.liste);
let nbCritiques = this.GetNumberBlessures(blessures.critiques.liste);
let maxEndGraves = Math.floor(this.data.data.sante.endurance.max / (2 * nbGraves));
let maxEndCritiques = nbCritiques > 0 ? 1 : this.data.data.sante.endurance.max;
return Math.max(0, Math.min(maxEndVie, maxEndGraves, maxEndCritiques));
}
/* -------------------------------------------- */ /* -------------------------------------------- */
async manageBlessureFromSheet( bType, index, active ) { async manageBlessureFromSheet( bType, index, active ) {
let bList = duplicate(this.data.data.blessures); let bList = duplicate(this.data.data.blessures);