Fix: messages et insomnie

Amélioration des messages de sommeil (nombre d'heure, seulement les
récupérations de rêve effectives, ...)

Les insomnies ne durent bien que 12h draconique à partir du prochain
chateau dormant (elles pouvaient durer 3 jours par erreur).
This commit is contained in:
2023-02-10 02:01:43 +01:00
parent 0c1b70f3f0
commit 4cf428f630
6 changed files with 162 additions and 173 deletions

View File

@ -360,31 +360,19 @@ export class RdDActor extends RdDBaseActor {
dialog.render(true);
}
async prepareChateauDormant(finChateauDormant, consignes) {
if (consignes.ignorer) {
async prepareChateauDormant(consigne) {
if (consigne.ignorer) {
return;
}
if (consignes.stress.valeur > 0) {
await this.distribuerStress('stress', consignes.stress.valeur, consignes.stress.motif);
}
if (!consignes.sommeil?.insomnie) {
await this.update({
"system.sommeil": {
nouveaujour: true,
date: finChateauDormant,
moral: consignes.sommeil?.moral ?? 'neutre',
heures: consignes.sommeil?.heures ?? 4
}
})
if (consigne.stress.valeur > 0) {
await this.distribuerStress('stress', consigne.stress.valeur, consigne.stress.motif);
}
await this.update({ 'system.sommeil': consigne.sommeil })
}
async onTimeChanging(oldTimestamp, newTimestamp) {
await super.onTimeChanging(oldTimestamp, newTimestamp);
const insomnie = EffetsDraconiques.isSujetInsomnie(this);
if (!this.system.sommeil || this.system.sommeil.insomnie || insomnie) {
await this.update({ 'system.sommeil.insomnie': insomnie });
}
await this.setInfoSommeilInsomnie();
}
async repos() {
@ -409,22 +397,15 @@ export class RdDActor extends RdDBaseActor {
await this.transformerStress();
this.bonusRecuperationPotion = 0; // Reset potion
}
await this.update({
"system.sommeil": {
nouveaujour: false,
moral: "neutre",
heures: 0
}
})
await this.resetInfoSommeil()
ChatMessage.create(message);
this.sheet.render(true);
}
async _recuperationSante(message) {
const maladiesPoisons = this._maladiePoisons(message);
this._messageRecuperationMaladiePoisons(maladiesPoisons, message);
const isMaladeEmpoisonne = maladiesPoisons.length > 0;
this._messageRecuperationMaladiePoisons(maladiesPoisons, message);
const blessures = duplicate(this.system.blessures);
await this._recupererBlessures(message, "legere", blessures.legeres.liste.filter(b => b.active), [], isMaladeEmpoisonne);
await this._recupererBlessures(message, "grave", blessures.graves.liste.filter(b => b.active), blessures.legeres.liste, isMaladeEmpoisonne);
@ -438,10 +419,10 @@ export class RdDActor extends RdDBaseActor {
return actifs;
}
_messageRecuperationMaladiePoisons(actifs, message) {
if (actifs.length > 0) {
const identifies = actifs.filter(it => it.system.identifie);
const nonIdentifies = actifs.filter(it => !it.system.identifie);
_messageRecuperationMaladiePoisons(maladiesPoisons, message) {
if (maladiesPoisons.length > 0) {
const identifies = maladiesPoisons.filter(it => it.system.identifie);
const nonIdentifies = maladiesPoisons.filter(it => !it.system.identifie);
message.content += 'Vous souffrez';
switch (nonIdentifies.length) {
case 0: break;
@ -460,7 +441,7 @@ export class RdDActor extends RdDBaseActor {
/* -------------------------------------------- */
async dormirChateauDormant() {
if (!ReglesOptionelles.isUsing("chateau-dormant-gardien") || !this.system.sommeil || this.system.sommeil?.nouveaujour) {
if (!ReglesOptionelles.isUsing("chateau-dormant-gardien") || !this.system.sommeil || this.system.sommeil.nouveaujour) {
const message = {
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
content: ""
@ -469,9 +450,7 @@ export class RdDActor extends RdDBaseActor {
await this._recuperationSante(message)
await this._jetDeMoralChateauDormant(message);
await this._recupereChance();
if (!this.system.sommeil?.insomnie) {
await this.transformerStress();
}
await this.transformerStress();
await this.retourSeuilDeReve(message);
this.bonusRecuperationPotion = 0; // Reset potion
await this.retourSust(message);
@ -480,17 +459,31 @@ export class RdDActor extends RdDBaseActor {
message.content = `A la fin Chateau Dormant, ${message.content}<br>Un nouveau jour se lève`;
ChatMessage.create(message);
}
await this.update({
"system.sommeil": {
nouveaujour: false,
moral: "neutre",
heures: 0
}
});
await this.resetInfoSommeil();
this.sheet.render(true);
}
}
async resetInfoSommeil() {
await this.update({
'system.sommeil': {
nouveaujour: false,
date: game.system.rdd.calendrier.getTimestamp(),
moral: "neutre",
heures: 0,
insomnie: EffetsDraconiques.isSujetInsomnie(this)
}
});
}
async setInfoSommeilInsomnie() {
await this.update({ 'system.sommeil.insomnie': EffetsDraconiques.isSujetInsomnie(this) });
}
async setInfoSommeilMoral(situationMoral) {
await this.update({ 'system.sommeil.moral': situationMoral });
}
/* -------------------------------------------- */
async _recupereChance() {
// On ne récupère un point de chance que si aucun appel à la chance dans la journée
@ -639,50 +632,32 @@ export class RdDActor extends RdDBaseActor {
}
/* -------------------------------------------- */
async dormir(sommeilHeures, options = { grisReve: false, chateauDormant: false }) {
const sommeil = !this.system.sommeil?.insomnie || options.grisReve;
async dormir(heures, options = { grisReve: false, chateauDormant: false }) {
const message = {
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
content: ""
content: this.name + ': '
};
await this.recupereEndurance(message);
let sep = ""
let recuperationReve = "";
let heuresDormies = 0;
for (; heuresDormies < sommeilHeures; heuresDormies++) {
await this._recupererEthylisme(message);
if (sommeil) {
await this.recupererFatigue(message);
if (!options.grisReve) {
if (sommeil) {
let r = await this.recuperationReve(message);
if (r >= 0) {
recuperationReve += sep + r;
sep = "+";
}
if (r >= 0 && EffetsDraconiques.isDonDoubleReve(this)) {
r = await this.recuperationReve(message);
if (r >= 0) {
recuperationReve += sep + r;
}
}
if (r < 0) {
heuresDormies++;// rêve de dragon pendant l'heure en cours
break;
}
}
}
}
if (this.system.sommeil?.insomnie || heures == 0) {
message.content += 'Vous ne trouvez pas le sommeil';
}
else {
let jetsReve = [];
let dormi = await this.dormirDesHeures(jetsReve, message, heures, options);
message.content += `Vous dormez ${dormi.heures <= 1 ? 'une heure' : (dormi.heures + ' heures')}. `;
if (jetsReve.length > 0) {
message.content += `Vous récupérez ${jetsReve.filter(it => it >= 0).reduce(Misc.joining("+"))} Points de rêve. `;
}
if (dormi.etat == 'eveil') {
message.content += 'Vous êtes réveillé par un Rêve de Dragon.'
}
options.chateauDormant = options.chateauDormant && dormi.heures == heures;
}
if (!options.grisReve) {
const repos = this.system.sommeil?.insomnie ? "vous reposez" : "dormez"
message.content = `${this.name}: Vous ${repos} ${heuresDormies <= 1 ? 'une heure' : (heuresDormies + ' heures')}. `
+ (recuperationReve == "" ? "" : `Vous récupérez ${recuperationReve} Points de rêve. `)
+ message.content;
ChatMessage.create(message);
}
if (options.chateauDormant && heuresDormies == sommeilHeures) {
if (options.chateauDormant) {
await this.dormirChateauDormant();
}
else {
@ -690,6 +665,43 @@ export class RdDActor extends RdDBaseActor {
}
}
async dormirDesHeures(jetsReve, message, heures, options) {
const dormi = { heures: 1, etat: 'dort' };
for (; dormi.heures <= heures && dormi.etat == 'dort'; dormi.heures++) {
await this._recupererEthylisme(message);
if (options.grisReve) {
await this.recupererFatigue(message);
}
else if (!this.system.sommeil?.insomnie) {
await this.recupererFatigue(message);
dormi.etat = await this.jetRecuperationReve(jetsReve, message);
if (dormi.etat == 'dort' && EffetsDraconiques.isDonDoubleReve(this)) {
dormi.etat = await this.jetRecuperationReve(jetsReve, message);
}
}
}
return dormi;
}
/* -------------------------------------------- */
async jetRecuperationReve(jetsReve, message) {
if (this.getReveActuel() < this.system.reve.seuil.value) {
let reve = await RdDDice.rollTotal("1dr");
if (reve >= 7) {
// Rêve de Dragon !
message.content += `Vous faites un <strong>Rêve de Dragon</strong> de ${reve} Points de rêve qui vous réveille! `;
await this.combattreReveDeDragon(reve);
jetsReve.push(-1);
return 'eveil';
}
else {
await this.reveActuelIncDec(reve);
jetsReve.push(reve);
}
}
return 'dort';
}
/* -------------------------------------------- */
async _recupererEthylisme(message) {
let value = Math.min(Number.parseInt(this.system.compteurs.ethylisme.value) + 1, 1);
@ -750,27 +762,6 @@ export class RdDActor extends RdDBaseActor {
return cumul;
}
/* -------------------------------------------- */
async recuperationReve(message) {
const seuil = this.system.reve.seuil.value;
const reveActuel = this.getReveActuel();
if (reveActuel < seuil) {
let deRecuperation = await RdDDice.rollTotal("1dr");
console.log("recuperationReve", deRecuperation);
if (deRecuperation >= 7) {
// Rêve de Dragon !
message.content += `Vous faites un <strong>Rêve de Dragon</strong> de ${deRecuperation} Points de rêve qui vous réveille! `;
await this.combattreReveDeDragon(deRecuperation);
return -1;
}
else {
await this.reveActuelIncDec(deRecuperation);
return deRecuperation;
}
}
return 0;
}
/* -------------------------------------------- */
async retourSeuilDeReve(message) {
const seuil = this.system.reve.seuil.value;
@ -1922,7 +1913,7 @@ export class RdDActor extends RdDBaseActor {
/* -------------------------------------------- */
async transformerStress() {
const stress = Number(this.system.compteurs.stress.value);
if (stress <= 0) {
if (this.system.sommeil?.insomnie || stress <= 0) {
return;
}
@ -3841,7 +3832,7 @@ export class RdDActor extends RdDBaseActor {
await draconique.onActorCreateOwned(this, item)
this.notifyGestionTeteSouffleQueue(item, draconique.manualMessage());
}
await this.update({ 'system.sommeil.insomnie': EffetsDraconiques.isSujetInsomnie(this) });
await this.setInfoSommeilInsomnie();
}
}