Vincent Vandemeulebrouck
441a5965c7
Au lieu de minimiser les TMRs, les actions dans les TMRs sont bloquées tant qu'une action liée au TMRs est en cours.
3900 lines
141 KiB
JavaScript
3900 lines
141 KiB
JavaScript
import { RdDUtility } from "./rdd-utility.js";
|
|
import { TMRUtility } from "./tmr-utility.js";
|
|
import { RdDRollDialogEthylisme } from "./rdd-roll-ethylisme.js";
|
|
import { RdDRoll } from "./rdd-roll.js";
|
|
import { RdDTMRDialog } from "./rdd-tmr-dialog.js";
|
|
import { Misc } from "./misc.js";
|
|
import { RdDResolutionTable } from "./rdd-resolution-table.js";
|
|
import { RdDDice } from "./rdd-dice.js";
|
|
import { RdDRollTables } from "./rdd-rolltables.js";
|
|
import { ChatUtility } from "./chat-utility.js";
|
|
import { RdDItemSort } from "./item-sort.js";
|
|
import { Grammar } from "./grammar.js";
|
|
import { RdDEncaisser } from "./rdd-roll-encaisser.js";
|
|
import { RdDCombat } from "./rdd-combat.js";
|
|
import { RdDItemCompetence } from "./item-competence.js";
|
|
import { RdDItemArme } from "./item-arme.js";
|
|
import { RdDAlchimie } from "./rdd-alchimie.js";
|
|
import { STATUSES, StatusEffects } from "./settings/status-effects.js";
|
|
import { RdDItemCompetenceCreature } from "./item-competencecreature.js";
|
|
import { RdDItemSigneDraconique } from "./item/signedraconique.js";
|
|
import { ReglesOptionnelles } from "./settings/regles-optionnelles.js";
|
|
import { EffetsDraconiques } from "./tmr/effets-draconiques.js";
|
|
import { Draconique } from "./tmr/draconique.js";
|
|
import { RdDCarac } from "./rdd-carac.js";
|
|
import { DialogConsommer } from "./dialog-item-consommer.js";
|
|
import { DialogFabriquerPotion } from "./dialog-fabriquer-potion.js";
|
|
import { RollDataAjustements } from "./rolldata-ajustements.js";
|
|
import { RdDPossession } from "./rdd-possession.js";
|
|
import { ENTITE_INCARNE, ENTITE_NONINCARNE, SHOW_DICE, SYSTEM_RDD, SYSTEM_SOCKET_ID } from "./constants.js";
|
|
import { RdDConfirm } from "./rdd-confirm.js";
|
|
import { DialogValidationEncaissement } from "./dialog-validation-encaissement.js";
|
|
import { RdDRencontre } from "./item/rencontre.js";
|
|
import { Targets } from "./targets.js";
|
|
import { DialogRepos } from "./sommeil/dialog-repos.js";
|
|
import { RdDBaseActor } from "./actor/base-actor.js";
|
|
import { RdDTimestamp } from "./time/rdd-timestamp.js";
|
|
import { RdDItemBlessure } from "./item/blessure.js";
|
|
import { AppAstrologie } from "./sommeil/app-astrologie.js";
|
|
import { RdDEmpoignade } from "./rdd-empoignade.js";
|
|
import { ExperienceLog, XP_TOPIC } from "./actor/experience-log.js";
|
|
import { TYPES } from "./item.js";
|
|
|
|
const POSSESSION_SANS_DRACONIC = {
|
|
img: 'systems/foundryvtt-reve-de-dragon/icons/entites/possession.webp',
|
|
name: 'Sans draconic',
|
|
system: {
|
|
niveau: 0,
|
|
defaut_carac: "reve-actuel",
|
|
}
|
|
};
|
|
|
|
export const MAINS_DIRECTRICES = ['Droitier', 'Gaucher', 'Ambidextre']
|
|
|
|
/* -------------------------------------------- */
|
|
/**
|
|
* Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
|
|
* @extends {Actor}
|
|
*/
|
|
export class RdDActor extends RdDBaseActor {
|
|
|
|
/* -------------------------------------------- */
|
|
prepareData() {
|
|
super.prepareData();
|
|
|
|
// Dynamic computing fields
|
|
this.encTotal = 0;
|
|
// TODO: separate derived/base data preparation
|
|
// TODO: split by actor class
|
|
|
|
// Make separate methods for each Actor type (character, npc, etc.) to keep
|
|
// things organized.
|
|
if (this.isPersonnage()) this._prepareCharacterData(this)
|
|
if (this.isCreatureEntite()) this._prepareCreatureData(this)
|
|
if (this.isVehicule()) this._prepareVehiculeData(this)
|
|
this.computeEtatGeneral();
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
_prepareCreatureData(actorData) {
|
|
this.computeEncTotal();
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
_prepareVehiculeData(actorData) {
|
|
this.computeEncTotal();
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
/**
|
|
* Prepare Character type specific data
|
|
*/
|
|
async _prepareCharacterData(actorData) {
|
|
// Initialize empty items
|
|
RdDCarac.computeCarac(actorData.system)
|
|
this.computeIsHautRevant();
|
|
await this.cleanupConteneurs();
|
|
await this.computeEncTotal();
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async cleanupConteneurs() {
|
|
let updates = this.itemTypes['conteneur']
|
|
.filter(c => c.system.contenu.filter(id => this.getItem(id) == undefined).length > 0)
|
|
.map(c => { return { _id: c._id, 'system.contenu': c.system.contenu.filter(id => this.getItem(id) != undefined) } });
|
|
if (updates.length > 0) {
|
|
await this.updateEmbeddedDocuments("Item", updates)
|
|
}
|
|
}
|
|
|
|
canReceive(item) {
|
|
if (this.isCreature()) {
|
|
return item.type == TYPES.competencecreature || item.isInventaire();
|
|
}
|
|
if (this.isEntite()) {
|
|
return item.type == 'competencecreature';
|
|
}
|
|
if (this.isVehicule()) {
|
|
return item.isInventaire();
|
|
}
|
|
if (this.isPersonnage()) {
|
|
switch (item.type) {
|
|
case 'competencecreature': case 'tarot': case 'service':
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
isHautRevant() {
|
|
return this.isPersonnage() && this.system.attributs.hautrevant.value != ""
|
|
}
|
|
/* -------------------------------------------- */
|
|
getFatigueActuelle() {
|
|
if (ReglesOptionnelles.isUsing("appliquer-fatigue") && this.isPersonnage()) {
|
|
return this.system.sante.fatigue?.value;
|
|
}
|
|
return 0;
|
|
}
|
|
/* -------------------------------------------- */
|
|
getFatigueMax() {
|
|
if (!this.isPersonnage()) {
|
|
return 1;
|
|
}
|
|
return Misc.toInt(this.system.sante.fatigue?.max);
|
|
}
|
|
/* -------------------------------------------- */
|
|
getReveActuel() {
|
|
switch (this.type) {
|
|
case 'personnage':
|
|
return Misc.toInt(this.system.reve?.reve?.value ?? this.carac.reve.value);
|
|
case 'creature':
|
|
case 'entite':
|
|
return Misc.toInt(this.system.carac.reve?.value)
|
|
case 'vehicule':
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
getChanceActuel() {
|
|
return Misc.toInt(this.system.compteurs.chance?.value ?? 10);
|
|
}
|
|
/* -------------------------------------------- */
|
|
getTaille() {
|
|
return Misc.toInt(this.system.carac.taille?.value);
|
|
}
|
|
/* -------------------------------------------- */
|
|
getForce() {
|
|
if (this.isEntite()) {
|
|
return Misc.toInt(this.system.carac.reve?.value);
|
|
}
|
|
return Misc.toInt(this.system.carac.force?.value);
|
|
}
|
|
/* -------------------------------------------- */
|
|
getAgilite() {
|
|
switch (this.type) {
|
|
case 'personnage': return Misc.toInt(this.system.carac.agilite?.value);
|
|
case 'creature': return Misc.toInt(this.system.carac.force?.value);
|
|
case 'entite': return Misc.toInt(this.system.carac.reve?.value);
|
|
}
|
|
return 10;
|
|
}
|
|
/* -------------------------------------------- */
|
|
getChance() {
|
|
return Number(this.system.carac.chance?.value ?? 10);
|
|
}
|
|
getMoralTotal() {
|
|
return Number(this.system.compteurs.moral?.value ?? 0);
|
|
}
|
|
/* -------------------------------------------- */
|
|
getBonusDegat() {
|
|
// TODO: gérer séparation et +dom créature/entité indépendament de la compétence
|
|
return Number(this.system.attributs.plusdom.value ?? 0);
|
|
}
|
|
/* -------------------------------------------- */
|
|
getProtectionNaturelle() {
|
|
return Number(this.system.attributs.protection.value ?? 0);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
getEtatGeneral(options = { ethylisme: false }) {
|
|
let etatGeneral = Misc.toInt(this.system.compteurs.etat?.value)
|
|
if (options.ethylisme) {
|
|
// Pour les jets d'Ethylisme, on ignore le degré d'éthylisme (p.162)
|
|
etatGeneral -= Math.min(0, this.system.compteurs.ethylisme.value)
|
|
}
|
|
return etatGeneral
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
getActivePoisons() {
|
|
return duplicate(this.items.filter(item => item.type == 'poison' && item.system.active))
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
getMalusArmure() {
|
|
if (this.isPersonnage()) {
|
|
return this.itemTypes[TYPES.armure].filter(it => it.system.equipe)
|
|
.map(it => it.system.malus)
|
|
.reduce(Misc.sum(), 0);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
getEncTotal() {
|
|
return Math.floor(this.encTotal ?? 0);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
getCompetence(idOrName, options = {}) {
|
|
return RdDItemCompetence.findCompetence(this.items, idOrName, options)
|
|
}
|
|
|
|
getCompetences(name) {
|
|
return RdDItemCompetence.findCompetences(this.items, name)
|
|
}
|
|
/* -------------------------------------------- */
|
|
getTache(id) {
|
|
return this.findItemLike(id, 'tache');
|
|
}
|
|
getMeditation(id) {
|
|
return this.findItemLike(id, 'meditation');
|
|
}
|
|
getChant(id) {
|
|
return this.findItemLike(id, 'chant');
|
|
}
|
|
getDanse(id) {
|
|
return this.findItemLike(id, 'danse');
|
|
}
|
|
getMusique(id) {
|
|
return this.findItemLike(id, 'musique');
|
|
}
|
|
getOeuvre(id, type = 'oeuvre') {
|
|
return this.findItemLike(id, type);
|
|
}
|
|
getJeu(id) {
|
|
return this.findItemLike(id, 'jeu');
|
|
}
|
|
getRecetteCuisine(id) {
|
|
return this.findItemLike(id, 'recettecuisine');
|
|
}
|
|
/* -------------------------------------------- */
|
|
getDraconicList() {
|
|
return this.itemTypes[TYPES.competence].filter(it => it.system.categorie == 'draconic')
|
|
}
|
|
/* -------------------------------------------- */
|
|
getBestDraconic() {
|
|
const list = this.getDraconicList()
|
|
.sort(Misc.descending(it => it.system.niveau))
|
|
return duplicate(list[0])
|
|
}
|
|
|
|
getDraconicOuPossession() {
|
|
const possession = this.itemTypes[TYPES.competencecreature].filter(it => it.system.categorie == 'possession')
|
|
.sort(Misc.descending(it => it.system.niveau))
|
|
.find(it => true);
|
|
if (possession) {
|
|
return possession;
|
|
}
|
|
const draconics = [...this.getDraconicList().filter(it => it.system.niveau >= 0),
|
|
POSSESSION_SANS_DRACONIC]
|
|
.sort(Misc.descending(it => it.system.niveau));
|
|
return draconics[0];
|
|
}
|
|
|
|
getPossession(possessionId) {
|
|
return this.items.find(it => it.type == TYPES.possession && it.system.possessionid == possessionId);
|
|
}
|
|
getPossessions() {
|
|
return this.items.filter(it => it.type == TYPES.possession);
|
|
}
|
|
getEmpoignades() {
|
|
return this.items.filter(it => it.type == TYPES.empoignade);
|
|
}
|
|
getDemiReve() {
|
|
return this.system.reve.tmrpos.coord;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async verifierPotionsEnchantees() {
|
|
let potionsEnchantees = this.filterItems(it => it.type == 'potion' && it.system.categorie.toLowerCase().includes('enchant'));
|
|
for (let potion of potionsEnchantees) {
|
|
if (!potion.system.prpermanent) {
|
|
console.log(potion);
|
|
let newPr = (potion.system.pr > 0) ? potion.system.pr - 1 : 0;
|
|
let update = { _id: potion._id, 'system.pr': newPr };
|
|
const updated = await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
|
|
|
|
let messageData = {
|
|
pr: newPr,
|
|
alias: this.name,
|
|
potionName: potion.name,
|
|
potionImg: potion.img
|
|
}
|
|
ChatMessage.create({
|
|
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
|
|
content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-potionenchantee-chateaudormant.html`, messageData)
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
getSurprise(isCombat = undefined) {
|
|
let niveauSurprise = this.getEffects()
|
|
.map(effect => StatusEffects.valeurSurprise(effect, isCombat))
|
|
.reduce(Misc.sum(), 0);
|
|
if (niveauSurprise > 1) {
|
|
return 'totale';
|
|
}
|
|
if (niveauSurprise == 1) {
|
|
return 'demi';
|
|
}
|
|
return '';
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
hasArmeeMeleeEquipee() { // Return true si l'acteur possède au moins 1 arme de mêlée équipée
|
|
return this.itemTypes['arme'].find(it => it.system.equipe && it.system.competence != "")
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async roll() {
|
|
RdDEmpoignade.checkEmpoignadeEnCours(this)
|
|
|
|
const carac = mergeObject(duplicate(this.system.carac),
|
|
{
|
|
'reve-actuel': this.getCaracReveActuel(),
|
|
'chance-actuelle': this.getCaracChanceActuelle()
|
|
});
|
|
|
|
await this._openRollDialog({
|
|
name: `jet-${this.id}`,
|
|
label: `Jet de ${this.name}`,
|
|
template: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll.html',
|
|
rollData: {
|
|
carac: carac,
|
|
selectedCarac: carac.apparence,
|
|
selectedCaracName: 'apparence',
|
|
competences: this.itemTypes['competence']
|
|
},
|
|
callbackAction: r => this.$onRollCaracResult(r)
|
|
});
|
|
}
|
|
|
|
async _openRollDialog({ name, label, template, rollData, callbackAction }) {
|
|
const dialog = await RdDRoll.create(this, rollData,
|
|
{ html: template, close: html => { this.tmrApp?.restoreTMRAfterAction() } },
|
|
{
|
|
name: name,
|
|
label: label,
|
|
callbacks: [
|
|
this.createCallbackExperience(),
|
|
this.createCallbackAppelAuMoral(),
|
|
{ action: callbackAction }
|
|
]
|
|
});
|
|
dialog.render(true);
|
|
return dialog
|
|
}
|
|
|
|
|
|
async prepareChateauDormant(consigne) {
|
|
if (consigne.ignorer) {
|
|
return;
|
|
}
|
|
if (consigne.stress.valeur > 0) {
|
|
await this.distribuerStress('stress', consigne.stress.valeur, consigne.stress.motif);
|
|
}
|
|
await this.update({ 'system.sommeil': consigne.sommeil })
|
|
const player = this.findPlayer();
|
|
if (player) {
|
|
ChatUtility.notifyUser(player.id, 'info', `Vous pouvez gérer la nuit de ${this.name}`);
|
|
}
|
|
}
|
|
|
|
findPlayer() {
|
|
return game.users.players.find(player => player.active && player.character?.id == this.id);
|
|
}
|
|
|
|
async onTimeChanging(oldTimestamp, newTimestamp) {
|
|
await super.onTimeChanging(oldTimestamp, newTimestamp);
|
|
await this.setInfoSommeilInsomnie();
|
|
}
|
|
|
|
async repos() {
|
|
await DialogRepos.create(this);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async grisReve(nGrisReve) {
|
|
let message = {
|
|
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
|
|
content: `${nGrisReve} jours de gris rêve sont passés. `
|
|
};
|
|
for (let i = 0; i < nGrisReve; i++) {
|
|
await this.dormir(4, { grisReve: true });
|
|
await this._recuperationSante(message);
|
|
|
|
const moralActuel = Misc.toInt(this.system.compteurs.moral.value);
|
|
if (moralActuel != 0) {
|
|
await this.moralIncDec(-Math.sign(moralActuel));
|
|
}
|
|
await this._recupereChance();
|
|
await this.transformerStress();
|
|
await this.setBonusPotionSoin(0);
|
|
}
|
|
await this.resetInfoSommeil()
|
|
ChatMessage.create(message);
|
|
this.sheet.render(true);
|
|
}
|
|
|
|
async _recuperationSante(message) {
|
|
const maladiesPoisons = this._maladiePoisons(message);
|
|
const isMaladeEmpoisonne = maladiesPoisons.length > 0;
|
|
this._messageRecuperationMaladiePoisons(maladiesPoisons, message);
|
|
|
|
await this._recuperationBlessures(message, isMaladeEmpoisonne);
|
|
await this._recupererVie(message, isMaladeEmpoisonne);
|
|
}
|
|
|
|
_maladiePoisons(message) {
|
|
const actifs = this.items.filter(item => item.type == 'maladie' || (item.type == 'poison' && item.system.active));
|
|
return actifs;
|
|
}
|
|
|
|
_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;
|
|
case 1: message.content += ` d'un mal inconnu`; break;
|
|
default: message.content += ` de ${nonIdentifies.length} maux inconnus`; break;
|
|
}
|
|
if (identifies.length > 0) {
|
|
if (nonIdentifies > 0) {
|
|
message.content += ' et';
|
|
} else {
|
|
message.content += ' de ' + identifies.map(it => it.name).reduce(Misc.joining(', '));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async dormirChateauDormant() {
|
|
if (!ReglesOptionnelles.isUsing("chateau-dormant-gardien") || !this.system.sommeil || this.system.sommeil.nouveaujour) {
|
|
const message = {
|
|
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
|
|
content: ""
|
|
};
|
|
|
|
await this._recuperationSante(message)
|
|
await this._jetDeMoralChateauDormant(message);
|
|
await this._recupereChance();
|
|
await this.transformerStress();
|
|
await this.retourSeuilDeReve(message);
|
|
await this.setBonusPotionSoin(0);
|
|
await this.retourSust(message);
|
|
await this.verifierPotionsEnchantees();
|
|
if (message.content != "") {
|
|
message.content = `A la fin Chateau Dormant, ${message.content}<br>Un nouveau jour se lève`;
|
|
ChatMessage.create(message);
|
|
}
|
|
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
|
|
if (this.getChanceActuel() < this.getChance() && !this.getFlag(SYSTEM_RDD, 'utilisationChance')) {
|
|
await this.chanceActuelleIncDec(1);
|
|
}
|
|
// Nouveau jour, suppression du flag
|
|
await this.unsetFlag(SYSTEM_RDD, 'utilisationChance');
|
|
}
|
|
|
|
async _jetDeMoralChateauDormant(message) {
|
|
const etatMoral = this.system.sommeil?.moral ?? 'neutre';
|
|
const jetMoral = await this._jetDeMoral(etatMoral);
|
|
message.content += ` -- le jet de moral est ${etatMoral}, le moral ` + this._messageAjustementMoral(jetMoral.ajustement);
|
|
}
|
|
|
|
_messageAjustementMoral(ajustement) {
|
|
switch (Math.sign(ajustement)) {
|
|
case 1:
|
|
return `remonte de ${ajustement}`;
|
|
case -1:
|
|
return `diminue de ${-ajustement}`;
|
|
case 0:
|
|
return 'reste stable';
|
|
default:
|
|
console.error(`Le signe de l'ajustement de moral ${ajustement} est ${Math.sign(ajustement)}, ce qui est innatendu`)
|
|
return `est ajusté de ${ajustement} (bizarre)`;
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async _recuperationBlessures(message, isMaladeEmpoisonne) {
|
|
const timestamp = game.system.rdd.calendrier.getTimestamp()
|
|
const blessures = this.filterItems(it => it.system.gravite > 0, 'blessure').sort(Misc.ascending(it => it.system.gravite))
|
|
|
|
await Promise.all(blessures.map(b => b.recuperationBlessure({
|
|
actor: this,
|
|
timestamp,
|
|
message,
|
|
isMaladeEmpoisonne,
|
|
blessures
|
|
})));
|
|
|
|
await this.supprimerBlessures(it => it.system.gravite <= 0);
|
|
}
|
|
|
|
async supprimerBlessures(filterToDelete) {
|
|
const toDelete = this.filterItems(filterToDelete, 'blessure')
|
|
.map(it => it.id);
|
|
await this.deleteEmbeddedDocuments('Item', toDelete);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async _recupererVie(message, isMaladeEmpoisonne) {
|
|
const tData = this.system
|
|
let blessures = this.filterItems(it => it.system.gravite > 0, 'blessure');
|
|
if (blessures.length > 0) {
|
|
return
|
|
}
|
|
let vieManquante = tData.sante.vie.max - tData.sante.vie.value;
|
|
if (vieManquante > 0) {
|
|
let rolled = await this.jetRecuperationConstitution(0, message)
|
|
if (!isMaladeEmpoisonne && rolled.isSuccess) {
|
|
const gain = Math.min(rolled.isPart ? 2 : 1, vieManquante);
|
|
message.content += " -- récupération de vie: " + gain;
|
|
await this.santeIncDec("vie", gain);
|
|
}
|
|
else if (rolled.isETotal) {
|
|
message.content += " -- perte de vie: 1";
|
|
await this.santeIncDec("vie", -1);
|
|
}
|
|
else {
|
|
message.content += " -- vie stationnaire ";
|
|
}
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async jetRecuperationConstitution(bonusSoins, message = undefined) {
|
|
let difficulte = Math.min(0, this.system.sante.vie.value - this.system.sante.vie.max) + bonusSoins + this.system.sante.bonusPotion;
|
|
let rolled = await RdDResolutionTable.roll(this.system.carac.constitution.value, difficulte);
|
|
if (message) {
|
|
message.content = await renderTemplate("systems/foundryvtt-reve-de-dragon/templates/roll/explain.hbs", {
|
|
actor: this,
|
|
carac: this.system.carac.constitution,
|
|
rolled
|
|
})
|
|
}
|
|
return rolled;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async remiseANeuf() {
|
|
if (this.isEntite([ENTITE_NONINCARNE])) {
|
|
return;
|
|
}
|
|
ChatMessage.create({
|
|
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
|
|
content: 'Remise à neuf de ' + this.name
|
|
});
|
|
const updates = {
|
|
'system.sante.endurance.value': this.system.sante.endurance.max
|
|
};
|
|
if (this.isPersonnage() || this.isCreature()) {
|
|
await this.supprimerBlessures(it => true);
|
|
updates['system.sante.vie.value'] = this.system.sante.vie.max;
|
|
updates['system.sante.fatigue.value'] = 0;
|
|
}
|
|
if (this.isPersonnage()) {
|
|
updates['system.compteurs.ethylisme'] = { value: 1, nb_doses: 0, jet_moral: false };
|
|
}
|
|
await this.update(updates);
|
|
await this.removeEffects(e => e.flags.core.statusId !== STATUSES.StatusDemiReve);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async dormir(heures, options = { grisReve: false, chateauDormant: false }) {
|
|
const message = {
|
|
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
|
|
content: this.name + ': '
|
|
};
|
|
const insomnie = this.system.sommeil?.insomnie || heures == 0;
|
|
await this.recupereEndurance({ message: message, demi: insomnie });
|
|
if (insomnie) {
|
|
message.content += 'Vous ne trouvez pas le sommeil';
|
|
}
|
|
else {
|
|
let jetsReve = [];
|
|
let dormi = await this.dormirDesHeures(jetsReve, message, heures, options);
|
|
if (jetsReve.length > 0) {
|
|
message.content += `Vous récupérez ${jetsReve.map(it => it < 0 ? '(dragon)' : it).reduce(Misc.joining("+"))} Points de rêve. `;
|
|
}
|
|
if (dormi.etat == 'eveil') {
|
|
await this.reveilReveDeDragon(message, dormi.heures);
|
|
}
|
|
options.chateauDormant = options.chateauDormant && dormi.heures >= heures;
|
|
message.content += `Vous avez dormi ${dormi.heures <= 1 ? 'une heure' : (dormi.heures + ' heures')}. `;
|
|
}
|
|
|
|
if (!options.grisReve) {
|
|
ChatMessage.create(message);
|
|
}
|
|
if (options.chateauDormant) {
|
|
await this.dormirChateauDormant();
|
|
}
|
|
else {
|
|
this.sheet.render(true);
|
|
}
|
|
}
|
|
|
|
async reveilReveDeDragon(message, heures) {
|
|
message.content += 'Vous êtes réveillé par un Rêve de Dragon.';
|
|
const restant = Math.max(this.system.sommeil?.heures - heures, 0)
|
|
if (restant > 0) {
|
|
await this.update({ 'system.sommeil': { heures: restant } });
|
|
}
|
|
}
|
|
|
|
async dormirDesHeures(jetsReve, message, heures, options) {
|
|
const dormi = { heures: 0, 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);
|
|
if (value <= 0) {
|
|
message.content += `Vous dégrisez un peu (${RdDUtility.getNomEthylisme(value)}). `;
|
|
}
|
|
await this.update({
|
|
"system.compteurs.ethylisme": {
|
|
nb_doses: 0,
|
|
jet_moral: false,
|
|
value: value
|
|
}
|
|
});
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async recupereEndurance({ message, demi }) {
|
|
let max = this._computeEnduranceMax();
|
|
if (demi) {
|
|
max = Math.floor(max / 2);
|
|
}
|
|
const manquant = max - this.system.sante.endurance.value;
|
|
|
|
if (manquant > 0) {
|
|
await this.santeIncDec("endurance", manquant);
|
|
message.content += `Vous récuperez ${manquant} points d'endurance. `;
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async recupererFatigue(message) {
|
|
if (ReglesOptionnelles.isUsing("appliquer-fatigue")) {
|
|
let fatigue = this.system.sante.fatigue.value;
|
|
const fatigueMin = this._computeFatigueMin();
|
|
if (fatigue <= fatigueMin) {
|
|
return;
|
|
}
|
|
fatigue = Math.max(fatigueMin, this._calculRecuperationSegment(fatigue));
|
|
await this.update({ "system.sante.fatigue.value": fatigue });
|
|
if (fatigue == 0) {
|
|
message.content += "Vous êtes complêtement reposé. ";
|
|
}
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
_calculRecuperationSegment(actuel) {
|
|
const segments = RdDUtility.getSegmentsFatigue(this.system.sante.endurance.max);
|
|
let cumul = 0;
|
|
let i;
|
|
for (i = 0; i < 11; i++) {
|
|
cumul += segments[i];
|
|
let diff = cumul - actuel;
|
|
if (diff >= 0) {
|
|
const limit2Segments = Math.floor(segments[i] / 2);
|
|
if (diff > limit2Segments && i > 0) {
|
|
cumul -= segments[i - 1]; // le segment est à moins de la moitié, il est récupéré
|
|
}
|
|
cumul -= segments[i];
|
|
break;
|
|
}
|
|
};
|
|
return cumul;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async retourSeuilDeReve(message) {
|
|
const seuil = this.system.reve.seuil.value;
|
|
const reveActuel = this.getReveActuel();
|
|
if (reveActuel > seuil) {
|
|
message.content += `<br>Votre rêve redescend vers son seuil naturel (${seuil}, nouveau rêve actuel ${(reveActuel - 1)})`;
|
|
await this.reveActuelIncDec(-1);
|
|
}
|
|
}
|
|
|
|
async retourSust(message) {
|
|
const tplData = this.system;
|
|
const sustNeeded = tplData.attributs.sust.value;
|
|
const sustConsomme = tplData.compteurs.sust.value;
|
|
const eauConsomme = tplData.compteurs.eau.value;
|
|
if (game.settings.get(SYSTEM_RDD, "appliquer-famine-soif").includes('famine') && sustConsomme < sustNeeded) {
|
|
const perte = sustConsomme < Math.min(0.5, sustNeeded) ? 3 : (sustConsomme <= (sustNeeded / 2) ? 2 : 1);
|
|
message.content += `<br>Vous ne vous êtes sustenté que de ${sustConsomme} pour un appétit de ${sustNeeded}, vous avez faim!
|
|
La famine devrait vous faire ${perte} points d'endurance non récupérables, notez le cumul de côté et ajustez l'endurance`;
|
|
}
|
|
|
|
if (game.settings.get(SYSTEM_RDD, "appliquer-famine-soif").includes('soif') && eauConsomme < sustNeeded) {
|
|
const perte = eauConsomme < Math.min(0.5, sustNeeded) ? 12 : (eauConsomme <= (sustNeeded / 2) ? 6 : 3);
|
|
message.content += `<br>Vous n'avez bu que ${eauConsomme} doses de liquide pour une soif de ${sustNeeded}, vous avez soif!
|
|
La soif devrait vous faire ${perte} points d'endurance non récupérables, notez le cumul de côté et ajustez l'endurance`;
|
|
}
|
|
await this.updateCompteurValue('sust', 0);
|
|
await this.updateCompteurValue('eau', 0);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async combattreReveDeDragon(force) {
|
|
let rollData = {
|
|
actor: this,
|
|
competence: this.getDraconicOuPossession(),
|
|
canClose: false,
|
|
rencontre: await game.system.rdd.rencontresTMR.getReveDeDragon(force),
|
|
tmr: true,
|
|
use: { libre: false, conditions: false },
|
|
forceCarac: { 'reve-actuel': { label: "Rêve Actuel", value: this.getReveActuel() } }
|
|
}
|
|
rollData.competence.system.defaut_carac = 'reve-actuel';
|
|
|
|
const dialog = await RdDRoll.create(this, rollData,
|
|
{ html: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-reve-de-dragon.html' },
|
|
{
|
|
name: 'maitrise',
|
|
label: 'Maîtriser le Rêve de Dragon',
|
|
callbacks: [
|
|
{ action: async r => this.resultCombatReveDeDragon(r) }
|
|
]
|
|
}
|
|
);
|
|
dialog.render(true);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async resultCombatReveDeDragon(rollData) {
|
|
const result = rollData.rolled.isSuccess
|
|
? rollData.rencontre.system.succes
|
|
: rollData.rencontre.system.echec;
|
|
|
|
RdDRencontre.appliquer(result.effets, {}, rollData)
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async sortMisEnReserve(sort, draconic, coord, ptreve) {
|
|
await this.createEmbeddedDocuments("Item", [{
|
|
type: 'sortreserve',
|
|
name: sort.name,
|
|
img: sort.img,
|
|
system: { sortid: sort._id, draconic: (draconic?.name ?? sort.system.draconic), ptreve: ptreve, coord: coord, heurecible: 'Vaisseau' }
|
|
}],
|
|
{ renderSheet: false });
|
|
this.tmrApp.updateTokens();
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async updateCarac(caracName, to) {
|
|
if (caracName == "force") {
|
|
if (Number(to) > this.getTaille() + 4) {
|
|
ui.notifications.warn("Votre FORCE doit être au maximum de TAILLE+4");
|
|
return;
|
|
}
|
|
}
|
|
if (caracName == "reve") {
|
|
if (to > Misc.toInt(this.system.reve.seuil.value)) {
|
|
this.setPointsDeSeuil(to);
|
|
}
|
|
}
|
|
if (caracName == "chance") {
|
|
if (to > Misc.toInt(this.system.compteurs.chance.value)) {
|
|
this.setPointsDeChance(to);
|
|
}
|
|
}
|
|
let selectedCarac = RdDActor._findCaracByName(this.system.carac, caracName);
|
|
const from = selectedCarac.value
|
|
await this.update({ [`system.carac.${caracName}.value`]: to });
|
|
await ExperienceLog.add(this, XP_TOPIC.CARAC, from, to, caracName);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async updateCaracXP(caracName, to) {
|
|
if (caracName == 'Taille') {
|
|
return;
|
|
}
|
|
let selectedCarac = RdDActor._findCaracByName(this.system.carac, caracName);
|
|
if (!selectedCarac.derivee) {
|
|
const from = Number(selectedCarac.xp);
|
|
await this.update({ [`system.carac.${caracName}.xp`]: to });
|
|
await ExperienceLog.add(this, XP_TOPIC.XPCARAC, from, to, caracName);
|
|
}
|
|
this.checkCaracXP(caracName);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async updateCaracXPAuto(caracName) {
|
|
if (caracName == 'Taille') {
|
|
return;
|
|
}
|
|
let carac = RdDActor._findCaracByName(this.system.carac, caracName);
|
|
if (carac) {
|
|
carac = duplicate(carac);
|
|
const fromXp = Number(carac.xp);
|
|
const fromValue = Number(carac.value);
|
|
let toXp = fromXp;
|
|
let toValue = fromValue;
|
|
while (toXp >= RdDCarac.getCaracNextXp(toValue) && toXp > 0) {
|
|
toXp -= RdDCarac.getCaracNextXp(toValue);
|
|
toValue++;
|
|
}
|
|
carac.xp = toXp;
|
|
carac.value = toValue;
|
|
await this.update({ [`system.carac.${caracName}`]: carac });
|
|
await ExperienceLog.add(this, XP_TOPIC.XPCARAC, fromXp, toXp, caracName);
|
|
await ExperienceLog.add(this, XP_TOPIC.CARAC, fromValue, toValue, caracName);
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async updateCompetenceXPAuto(idOrName) {
|
|
let competence = this.getCompetence(idOrName);
|
|
if (competence) {
|
|
const fromXp = Number(competence.system.xp);
|
|
const fromNiveau = Number(competence.system.niveau);
|
|
let toXp = fromXp;
|
|
let toNiveau = fromNiveau;
|
|
while (toXp >= RdDItemCompetence.getCompetenceNextXp(toNiveau) && toXp > 0) {
|
|
toXp -= RdDItemCompetence.getCompetenceNextXp(toNiveau);
|
|
toNiveau++;
|
|
}
|
|
await competence.update({
|
|
"system.xp": toXp,
|
|
"system.niveau": toNiveau,
|
|
});
|
|
await ExperienceLog.add(this, XP_TOPIC.XP, fromXp, toXp, competence.name);
|
|
await ExperienceLog.add(this, XP_TOPIC.NIVEAU, fromNiveau, toNiveau, competence.name);
|
|
}
|
|
}
|
|
|
|
async updateCompetenceStress(idOrName) {
|
|
const competence = this.getCompetence(idOrName);
|
|
if (!competence) {
|
|
return;
|
|
}
|
|
const fromXp = competence.system.xp;
|
|
const fromXpStress = this.system.compteurs.experience.value;
|
|
const fromNiveau = Number(competence.system.niveau);
|
|
const xpSuivant = RdDItemCompetence.getCompetenceNextXp(fromNiveau);
|
|
const xpRequis = xpSuivant - fromXp;
|
|
if (fromXpStress <= 0 || fromNiveau >= competence.system.niveau_archetype) {
|
|
ui.notifications.info(`La compétence ne peut pas augmenter!
|
|
stress disponible: ${fromXpStress}
|
|
expérience requise: ${xpRequis}
|
|
niveau : ${fromNiveau}
|
|
archétype : ${competence.system.niveau_archetype}`);
|
|
return;
|
|
}
|
|
const xpUtilise = Math.max(0, Math.min(fromXpStress, xpRequis));
|
|
const gainNiveau = (xpUtilise >= xpRequis || xpRequis <= 0) ? 1 : 0;
|
|
const toNiveau = fromNiveau + gainNiveau;
|
|
const newXp = gainNiveau > 0 ? Math.max(fromXp - xpSuivant, 0) : (fromXp + xpUtilise);
|
|
await competence.update({
|
|
"system.xp": newXp,
|
|
"system.niveau": toNiveau,
|
|
});
|
|
const toXpStress = Math.max(0, fromXpStress - xpUtilise);
|
|
await this.update({ "system.compteurs.experience.value": toXpStress });
|
|
|
|
await ExperienceLog.add(this, XP_TOPIC.TRANSFORM, fromXpStress, toXpStress, `Dépense stress`);
|
|
await ExperienceLog.add(this, XP_TOPIC.XP, fromXp, newXp, competence.name);
|
|
await ExperienceLog.add(this, XP_TOPIC.NIVEAU, fromNiveau, toNiveau, competence.name);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async updateCreatureCompetence(idOrName, fieldName, value) {
|
|
let competence = this.getCompetence(idOrName);
|
|
if (competence) {
|
|
function getPath(fieldName) {
|
|
switch (fieldName) {
|
|
case "niveau": return 'system.niveau';
|
|
case "dommages": return 'system.dommages';
|
|
case "carac_value": return 'system.carac_value';
|
|
}
|
|
return undefined
|
|
}
|
|
const path = getPath(fieldName);
|
|
if (path) {
|
|
await this.updateEmbeddedDocuments('Item', [{ _id: competence.id, [path]: value }]); // updates one EmbeddedEntity
|
|
}
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async updateCompetence(idOrName, compValue) {
|
|
const competence = this.getCompetence(idOrName);
|
|
if (competence) {
|
|
const toNiveau = compValue ?? RdDItemCompetence.getNiveauBase(competence.system.categorie, competence.getCategories());
|
|
this.notifyCompetencesTronc(competence, toNiveau);
|
|
const fromNiveau = competence.system.niveau;
|
|
await this.updateEmbeddedDocuments('Item', [{ _id: competence.id, 'system.niveau': toNiveau }]);
|
|
await ExperienceLog.add(this, XP_TOPIC.NIVEAU, fromNiveau, toNiveau, competence.name, true);
|
|
} else {
|
|
console.log("Competence not found", idOrName);
|
|
}
|
|
}
|
|
|
|
notifyCompetencesTronc(competence, toNiveau) {
|
|
const listTronc = RdDItemCompetence.getListTronc(competence.name).filter(it => {
|
|
const autreComp = this.getCompetence(it);
|
|
const niveauTr = autreComp?.system.niveau ?? 0;
|
|
return niveauTr < 0 && niveauTr < toNiveau;
|
|
});
|
|
if (listTronc.length > 0) {
|
|
ui.notifications.info(
|
|
"Vous avez modifié une compétence 'tronc'. Vérifiez que les compétences suivantes évoluent ensemble jusqu'au niveau 0 : <br>"
|
|
+ Misc.join(listTronc, '<br>'));
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async updateCompetenceXP(idOrName, toXp) {
|
|
let competence = this.getCompetence(idOrName);
|
|
if (competence) {
|
|
if (isNaN(toXp) || typeof (toXp) != 'number') toXp = 0;
|
|
const fromXp = competence.system.xp;
|
|
this.checkCompetenceXP(idOrName, toXp);
|
|
await this.updateEmbeddedDocuments('Item', [{ _id: competence.id, 'system.xp': toXp }]);
|
|
await ExperienceLog.add(this, XP_TOPIC.XP, fromXp, toXp, competence.name, true);
|
|
if (toXp > fromXp) {
|
|
RdDUtility.checkThanatosXP(idOrName);
|
|
}
|
|
} else {
|
|
console.log("Competence not found", idOrName);
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async updateCompetenceXPSort(idOrName, toXpSort) {
|
|
let competence = this.getCompetence(idOrName);
|
|
if (competence) {
|
|
if (isNaN(toXpSort) || typeof (toXpSort) != 'number') toXpSort = 0;
|
|
const fromXpSort = competence.system.xp_sort;
|
|
await this.updateEmbeddedDocuments('Item', [{ _id: competence.id, 'system.xp_sort': toXpSort }]);
|
|
await ExperienceLog.add(this, XP_TOPIC.XPSORT, fromXpSort, toXpSort, competence.name, true);
|
|
if (toXpSort > fromXpSort) {
|
|
RdDUtility.checkThanatosXP(idOrName);
|
|
}
|
|
} else {
|
|
console.log("Competence not found", idOrName);
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async updateCompetenceArchetype(idOrName, compValue) {
|
|
let competence = this.getCompetence(idOrName);
|
|
if (competence) {
|
|
await this.updateEmbeddedDocuments('Item', [{ _id: competence.id, 'system.niveau_archetype': Math.max(compValue ?? 0, 0) }]);
|
|
} else {
|
|
console.log("Competence not found", idOrName);
|
|
}
|
|
}
|
|
|
|
async deleteExperienceLog(from, count) {
|
|
if (from >= 0 && count > 0) {
|
|
let expLog = duplicate(this.system.experiencelog);
|
|
expLog.splice(from, count);
|
|
await this.update({ [`system.experiencelog`]: expLog });
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async updateCompteurValue(fieldName, to) {
|
|
const from = this.system.compteurs[fieldName].value
|
|
await this.update({ [`system.compteurs.${fieldName}.value`]: to });
|
|
await this.addStressExperienceLog(fieldName, from, to, fieldName, true);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async addCompteurValue(fieldName, add, raison) {
|
|
let from = this.system.compteurs[fieldName].value;
|
|
const to = Number(from) + Number(add);
|
|
await this.update({ [`system.compteurs.${fieldName}.value`]: to });
|
|
await this.addStressExperienceLog(fieldName, from, to, raison);
|
|
}
|
|
|
|
async addStressExperienceLog(topic, from, to, raison, manuel) {
|
|
switch (topic) {
|
|
case 'stress':
|
|
return await ExperienceLog.add(this, XP_TOPIC.STRESS, from, to, raison, manuel)
|
|
case 'experience':
|
|
return await ExperienceLog.add(this, XP_TOPIC.TRANSFORM, from, to, raison, manuel)
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async distribuerStress(compteur, stress, motif) {
|
|
if (game.user.isGM && this.hasPlayerOwner && this.isPersonnage()) {
|
|
switch (compteur) {
|
|
case 'stress': case 'experience':
|
|
await this.addCompteurValue(compteur, stress, motif);
|
|
const message = `${this.name} a reçu ${stress} points ${compteur == 'stress' ? "de stress" : "d'expérience"} (raison : ${motif})`;
|
|
ui.notifications.info(message);
|
|
game.users.players.filter(player => player.active && player.character?.id == this.id)
|
|
.forEach(player => ChatUtility.notifyUser(player.id, 'info', message));
|
|
}
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async updateAttributeValue(fieldName, fieldValue) {
|
|
await this.update({ [`system.attributs.${fieldName}.value`]: fieldValue });
|
|
}
|
|
|
|
|
|
|
|
isSurenc() {
|
|
return this.isPersonnage() ? (this.computeMalusSurEncombrement() < 0) : false
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
computeMalusSurEncombrement() {
|
|
switch (this.type) {
|
|
case 'entite': case 'vehicule':
|
|
return 0;
|
|
}
|
|
return Math.min(0, Math.floor(this.getEncombrementMax() - this.encTotal));
|
|
}
|
|
|
|
getMessageSurEncombrement() {
|
|
return this.computeMalusSurEncombrement() < 0 ? "Sur-Encombrement!" : "";
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
getEncombrementMax() {
|
|
switch (this.type) {
|
|
case 'vehicule':
|
|
return this.system.capacite_encombrement;
|
|
case 'entite':
|
|
return 0;
|
|
default:
|
|
return this.system.attributs.encombrement.value
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
computeIsHautRevant() {
|
|
if (this.isPersonnage()) {
|
|
this.system.attributs.hautrevant.value = this.itemTypes['tete'].find(it => Grammar.equalsInsensitive(it.name, 'don de haut-reve'))
|
|
? "Haut rêvant"
|
|
: "";
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
computeResumeBlessure() {
|
|
const blessures = this.filterItems(it => it.system.gravite > 0, 'blessure')
|
|
|
|
const nbLegeres = blessures.filter(it => it.isLegere()).length;
|
|
const nbGraves = blessures.filter(it => it.isGrave()).length;
|
|
const nbCritiques = blessures.filter(it => it.isCritique()).length;
|
|
|
|
if (nbLegeres + nbGraves + nbCritiques == 0) {
|
|
return "Aucune blessure";
|
|
}
|
|
let resume = "Blessures:";
|
|
if (nbLegeres > 0) {
|
|
resume += " " + nbLegeres + " légère" + (nbLegeres > 1 ? "s" : "");
|
|
}
|
|
if (nbGraves > 0) {
|
|
if (nbLegeres > 0)
|
|
resume += ",";
|
|
resume += " " + nbGraves + " grave" + (nbGraves > 1 ? "s" : "");
|
|
}
|
|
if (nbCritiques > 0) {
|
|
if (nbGraves > 0 || nbLegeres > 0)
|
|
resume += ",";
|
|
resume += " une CRITIQUE !";
|
|
}
|
|
return resume;
|
|
}
|
|
|
|
recompute() {
|
|
this.computeEtatGeneral();
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
computeEtatGeneral() {
|
|
// Pas d'état général pour les entités forçage à 0
|
|
if (this.type == 'vehicule') {
|
|
return
|
|
}
|
|
if (this.type == 'entite') {
|
|
this.system.compteurs.etat.value = 0;
|
|
return
|
|
}
|
|
// Pour les autres
|
|
let state = Math.min(this.system.sante.vie.value - this.system.sante.vie.max, 0);
|
|
if (ReglesOptionnelles.isUsing("appliquer-fatigue") && this.system.sante.fatigue) {
|
|
state += RdDUtility.currentFatigueMalus(this.system.sante.fatigue.value, this.system.sante.endurance.max);
|
|
}
|
|
// Ajout de l'éthylisme
|
|
state += Math.min(0, (this.system.compteurs.ethylisme?.value ?? 0));
|
|
|
|
this.system.compteurs.etat.value = state;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async actionRefoulement(item) {
|
|
const refoulement = item?.system.refoulement ?? 0;
|
|
if (refoulement > 0) {
|
|
RdDConfirm.confirmer({
|
|
settingConfirmer: "confirmation-refouler",
|
|
content: `<p>Prennez-vous le risque de refouler ${item.name} pour ${refoulement} points de refoulement ?</p>`,
|
|
title: 'Confirmer la refoulement',
|
|
buttonLabel: 'Refouler',
|
|
onAction: async () => {
|
|
await this.ajouterRefoulement(refoulement, `une queue ${item.name}`);
|
|
await item.delete();
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async ajouterRefoulement(value = 1, refouler) {
|
|
const refoulement = this.system.reve.refoulement.value + value;
|
|
const roll = new Roll("1d20");
|
|
await roll.evaluate({ async: true });
|
|
await roll.toMessage({ flavor: `${this.name} refoule ${refouler} pour ${value} points de refoulement (total: ${refoulement})` });
|
|
if (roll.total <= refoulement) {
|
|
refoulement = 0;
|
|
await this.ajouterSouffle({ chat: true });
|
|
}
|
|
await this.update({ "system.reve.refoulement.value": refoulement });
|
|
return roll;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async ajouterSouffle(options = { chat: false }) {
|
|
let souffle = await RdDRollTables.getSouffle()
|
|
//souffle.id = undefined; //TBC
|
|
await this.createEmbeddedDocuments('Item', [souffle]);
|
|
if (options.chat) {
|
|
ChatMessage.create({
|
|
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
|
|
content: this.name + " subit un Souffle de Dragon : " + souffle.name
|
|
});
|
|
}
|
|
return souffle;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async ajouterQueue(options = { chat: false }) {
|
|
let queue;
|
|
if (this.system.reve.reve.thanatosused) {
|
|
queue = await RdDRollTables.getOmbre();
|
|
await this.update({ "system.reve.reve.thanatosused": false });
|
|
}
|
|
else {
|
|
queue = await RdDRollTables.getQueue();
|
|
}
|
|
await this.createEmbeddedDocuments('Item', [queue]);
|
|
if (options.chat) {
|
|
ChatMessage.create({
|
|
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
|
|
content: this.name + " subit une Queue de Dragon : " + queue.name
|
|
});
|
|
}
|
|
return queue;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
/* -------------------------------------------- */
|
|
async changeTMRVisible() {
|
|
await this.setTMRVisible(this.system.reve.tmrpos.cache ? true : false);
|
|
}
|
|
|
|
async setTMRVisible(newState) {
|
|
await this.update({ 'system.reve.tmrpos.cache': !newState });
|
|
this.notifyRefreshTMR();
|
|
}
|
|
|
|
isTMRCache() {
|
|
return this.system.reve.tmrpos.cache;
|
|
}
|
|
|
|
notifyRefreshTMR() {
|
|
game.socket.emit(SYSTEM_SOCKET_ID, {
|
|
msg: "msg_tmr_move", data: {
|
|
actorId: this._id,
|
|
tmrPos: this.system.reve.tmrpos
|
|
}
|
|
});
|
|
}
|
|
|
|
|
|
/* -------------------------------------------- */
|
|
async reinsertionAleatoire(raison, accessible = tmr => true) {
|
|
const innaccessible = this.buildTMRInnaccessible();
|
|
let tmr = await TMRUtility.getTMRAleatoire(tmr => accessible(tmr) && !innaccessible.includes(tmr.coord));
|
|
ChatMessage.create({
|
|
content: `${raison} : ré-insertion aléatoire.`,
|
|
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name)
|
|
});
|
|
await this.forcerPositionTMRInconnue(tmr);
|
|
return tmr;
|
|
}
|
|
|
|
async forcerPositionTMRInconnue(tmr) {
|
|
await this.setTMRVisible(false);
|
|
await this.updateCoordTMR(tmr.coord);
|
|
this.notifyRefreshTMR();
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
buildTMRInnaccessible() {
|
|
const tmrInnaccessibles = this.filterItems(it => Draconique.isCaseTMR(it) &&
|
|
EffetsDraconiques.isInnaccessible(it));
|
|
return tmrInnaccessibles.map(it => it.system.coord);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
getTMRRencontres() {
|
|
return this.itemTypes['rencontre'];
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async deleteTMRRencontreAtPosition() {
|
|
const demiReve = this.getDemiReve()
|
|
let rencontreIds = this.items.filter(it => it.type == 'rencontre' && it.system.coord == demiReve).map(it => it.id);
|
|
if (rencontreIds.length > 0) {
|
|
await this.deleteEmbeddedDocuments('Item', rencontreIds);
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async addTMRRencontre(currentRencontre) {
|
|
const toCreate = currentRencontre.toObject();
|
|
console.log('actor.addTMRRencontre(', toCreate, ')');
|
|
this.createEmbeddedDocuments('Item', [toCreate]);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async updateCoordTMR(coord) {
|
|
await this.update({ "system.reve.tmrpos.coord": coord });
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async reveActuelIncDec(value) {
|
|
let reve = Math.max(this.system.reve.reve.value + value, 0);
|
|
await this.update({ "system.reve.reve.value": reve });
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async regainPointDeSeuil() {
|
|
const seuil = Misc.toInt(this.system.reve.seuil.value);
|
|
const seuilMax = Misc.toInt(this.system.carac.reve.value)
|
|
+ 2 * EffetsDraconiques.countAugmentationSeuil(this);
|
|
|
|
if (seuil < seuilMax) {
|
|
await this.setPointsDeSeuil(Math.min(seuil + 1, seuilMax));
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async setPointsDeSeuil(seuil) {
|
|
await this.update({ "system.reve.seuil.value": seuil });
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async setPointsDeChance(chance) {
|
|
await this.updateCompteurValue("chance", chance);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
getSonne() {
|
|
return this.getEffect(STATUSES.StatusStunned);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async finDeRound(options = { terminer: false }) {
|
|
await this.$finDeRoundSuppressionEffetsTermines(options);
|
|
await this.$finDeRoundBlessuresGraves();
|
|
await this.$finDeRoundSupprimerObsoletes();
|
|
await this.$finDeRoundEmpoignade();
|
|
}
|
|
|
|
async $finDeRoundSuppressionEffetsTermines(options) {
|
|
for (let effect of this.getEffects()) {
|
|
if (effect.duration.type !== 'none' && (effect.duration.remaining <= 0 || options.terminer)) {
|
|
await effect.delete();
|
|
ChatMessage.create({ content: `${this.name} n'est plus ${Misc.lowerFirst(game.i18n.localize(effect.system.label))} !` });
|
|
}
|
|
}
|
|
}
|
|
|
|
async $finDeRoundBlessuresGraves() {
|
|
if (this.isPersonnage() || this.isCreature()) {
|
|
const nbGraves = this.filterItems(it => it.isGrave(), 'blessure').length;
|
|
if (nbGraves > 0) {
|
|
// Gestion blessure graves : -1 pt endurance par blessure grave
|
|
await this.santeIncDec("endurance", -nbGraves);
|
|
}
|
|
}
|
|
}
|
|
|
|
async $finDeRoundSupprimerObsoletes() {
|
|
const obsoletes = []
|
|
.concat(this.itemTypes[TYPES.empoignade].filter(it => it.system.pointsemp <= 0))
|
|
.concat(this.itemTypes[TYPES.possession].filter(it => it.system.compteur < -2 || it.system.compteur > 2))
|
|
.map(it => it.id);
|
|
await this.deleteEmbeddedDocuments('Item', obsoletes);
|
|
}
|
|
|
|
async $finDeRoundEmpoignade() {
|
|
const immobilisations = this.itemTypes[TYPES.empoignade].filter(it => it.system.pointsemp >= 2 && it.system.empoigneurid == this.id);
|
|
immobilisations.forEach(emp => RdDEmpoignade.onImmobilisation(this,
|
|
game.actors.get(emp.system.empoigneid),
|
|
emp
|
|
))
|
|
}
|
|
/* -------------------------------------------- */
|
|
async setSonne(sonne = true) {
|
|
if (this.isEntite()) {
|
|
return;
|
|
}
|
|
if (!game.combat && sonne) {
|
|
ui.notifications.info("Le personnage est hors combat, il ne reste donc pas sonné");
|
|
return;
|
|
}
|
|
await this.setEffect(STATUSES.StatusStunned, sonne);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
getSConst() {
|
|
if (this.isEntite()) {
|
|
return 0;
|
|
}
|
|
return RdDCarac.calculSConst(this.system.carac.constitution.value)
|
|
}
|
|
|
|
|
|
async ajoutXpConstitution(xp) {
|
|
await this.update({ "system.carac.constitution.xp": Misc.toInt(this.system.carac.constitution.xp) + xp });
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
countBlessures(filter = it => !it.isContusion()) {
|
|
return this.filterItems(filter, 'blessure').length
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async testSiSonne(endurance) {
|
|
const result = await this._jetEndurance(endurance);
|
|
if (result.roll.total == 1) {
|
|
ChatMessage.create({ content: await this._gainXpConstitutionJetEndurance() });
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async jetEndurance() {
|
|
const endurance = this.system.sante.endurance.value;
|
|
|
|
const result = await this._jetEndurance(this.system.sante.endurance.value)
|
|
const message = {
|
|
content: "Jet d'Endurance : " + result.roll.total + " / " + endurance + "<br>",
|
|
whisper: ChatMessage.getWhisperRecipients(this.name)
|
|
};
|
|
if (result.sonne) {
|
|
message.content += `${this.name} a échoué son Jet d'Endurance et devient Sonné`;
|
|
}
|
|
else if (result.roll.total == 1) {
|
|
message.content += await this._gainXpConstitutionJetEndurance();
|
|
}
|
|
else {
|
|
message.content += `${this.name} a réussi son Jet d'Endurance !`;
|
|
}
|
|
|
|
ChatMessage.create(message);
|
|
}
|
|
|
|
async _gainXpConstitutionJetEndurance() {
|
|
await this.ajoutXpConstitution(1); // +1 XP !
|
|
return `${this.name} a obtenu 1 sur son Jet d'Endurance et a gagné 1 point d'Expérience en Constitution. Ce point d'XP a été ajouté automatiquement.`;
|
|
}
|
|
|
|
async _jetEndurance(endurance) {
|
|
const roll = await RdDDice.roll("1d20");
|
|
let result = {
|
|
roll: roll,
|
|
sonne: roll.total > endurance || roll.total == 20 // 20 is always a failure
|
|
}
|
|
if (result.sonne) {
|
|
await this.setSonne();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async jetVie() {
|
|
let roll = await RdDDice.roll("1d20");
|
|
let msgText = "Jet de Vie : " + roll.total + " / " + this.system.sante.vie.value + "<br>";
|
|
if (roll.total <= this.system.sante.vie.value) {
|
|
msgText += "Jet réussi, pas de perte de point de vie (prochain jet dans 1 round pour 1 critique, SC minutes pour une grave)";
|
|
if (roll.total == 1) {
|
|
msgText += "La durée entre 2 jets de vie est multipliée par 20 (20 rounds pour une critique, SCx20 minutes pour une grave)";
|
|
}
|
|
} else {
|
|
msgText += "Jet échoué, vous perdez 1 point de vie";
|
|
await this.santeIncDec("vie", -1);
|
|
if (roll.total == 20) {
|
|
msgText += "Votre personnage est mort !!!!!";
|
|
}
|
|
}
|
|
const message = {
|
|
content: msgText,
|
|
whisper: ChatMessage.getWhisperRecipients(this.name)
|
|
};
|
|
ChatMessage.create(message);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async santeIncDec(name, inc, isCritique = false) {
|
|
if (name == 'fatigue' && !ReglesOptionnelles.isUsing("appliquer-fatigue")) {
|
|
return;
|
|
}
|
|
const sante = duplicate(this.system.sante)
|
|
let compteur = sante[name];
|
|
if (!compteur) {
|
|
return;
|
|
}
|
|
let result = {
|
|
sonne: false,
|
|
};
|
|
|
|
let minValue = name == "vie" ? -this.getSConst() - 1 : 0;
|
|
|
|
result.newValue = Math.max(minValue, Math.min(compteur.value + inc, compteur.max));
|
|
//console.log("New value ", inc, minValue, result.newValue);
|
|
let fatigue = 0;
|
|
if (name == "endurance" && !this.isEntite()) {
|
|
if (result.newValue == 0 && inc < 0 && !isCritique) { // perte endurance et endurance devient 0 (sauf critique) -> -1 vie
|
|
sante.vie.value--;
|
|
result.perteVie = true;
|
|
}
|
|
result.newValue = Math.max(0, result.newValue);
|
|
if (inc > 0) { // le max d'endurance s'applique seulement à la récupération
|
|
result.newValue = Math.min(result.newValue, this._computeEnduranceMax())
|
|
}
|
|
const perte = compteur.value - result.newValue;
|
|
result.perte = perte;
|
|
if (perte > 1) {
|
|
// Peut-être sonné si 2 points d'endurance perdus d'un coup
|
|
const testIsSonne = await this.testSiSonne(result.newValue);
|
|
result.sonne = testIsSonne.sonne;
|
|
result.jetEndurance = testIsSonne.roll.total;
|
|
} else if (inc > 0) {
|
|
await this.setSonne(false);
|
|
}
|
|
if (sante.fatigue && inc < 0) { // Each endurance lost -> fatigue lost
|
|
fatigue = perte;
|
|
}
|
|
}
|
|
compteur.value = result.newValue;
|
|
// If endurance lost, then the same amount of fatigue cannot be recovered
|
|
if (ReglesOptionnelles.isUsing("appliquer-fatigue") && sante.fatigue && fatigue > 0) {
|
|
sante.fatigue.value = Math.max(sante.fatigue.value + fatigue, this._computeFatigueMin());
|
|
}
|
|
await this.update({ "system.sante": sante })
|
|
if (this.isDead()) {
|
|
await this.setEffect(STATUSES.StatusComma, true);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
async vehicleIncDec(name, inc) {
|
|
if (!this.isVehicule() || !['resistance', 'structure'].includes(name)) {
|
|
return
|
|
}
|
|
const value = this.system.etat[name].value;
|
|
const max = this.system.etat[name].max;
|
|
const newValue = value + inc;
|
|
if (0 <= newValue && newValue <= max) {
|
|
await this.update({ [`system.etat.${name}.value`]: newValue })
|
|
}
|
|
}
|
|
|
|
isDead() {
|
|
return !this.isEntite() && this.system.sante.vie.value < -this.getSConst()
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
_computeFatigueMin() {
|
|
return this.system.sante.endurance.max - this.system.sante.endurance.value;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
_computeEnduranceMax() {
|
|
const diffVie = this.system.sante.vie.max - this.system.sante.vie.value;
|
|
const maxEndVie = this.system.sante.endurance.max - (diffVie * 2);
|
|
const nbGraves = this.countBlessures(it => it.isGrave()) > 0
|
|
const nbCritiques = this.countBlessures(it => it.isCritique()) > 0
|
|
const maxEndGraves = Math.floor(this.system.sante.endurance.max / (2 * nbGraves));
|
|
const maxEndCritiques = nbCritiques > 0 ? 1 : this.system.sante.endurance.max;
|
|
return Math.max(0, Math.min(maxEndVie, maxEndGraves, maxEndCritiques));
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async jetDeMoral(situation, messageReussi = undefined, messageManque = undefined) {
|
|
const jetMoral = await this._jetDeMoral(situation);
|
|
const finMessage = (jetMoral.succes ? messageReussi : messageManque) ?? (jetMoral.ajustement == 0 ? "Vous gardez votre moral" : jetMoral.ajustement > 0 ? "Vous gagnez du moral" : "Vous perdez du moral");
|
|
ChatMessage.create({
|
|
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
|
|
content: `${finMessage} - jet ${jetMoral.succes ? "réussi" : "manqué"} en situation ${situation} (${jetMoral.jet}/${jetMoral.difficulte}).`
|
|
});
|
|
return jetMoral.ajustement;
|
|
}
|
|
|
|
async _jetDeMoral(situation) {
|
|
const moralActuel = Misc.toInt(this.system.compteurs.moral.value);
|
|
const jet = await RdDDice.rollTotal("1d20");
|
|
const difficulte = 10 + moralActuel;
|
|
const succes = jet <= difficulte;
|
|
const jetMoral = {
|
|
actuel: moralActuel,
|
|
jet: jet,
|
|
situation: situation,
|
|
difficulte: difficulte,
|
|
succes: succes,
|
|
ajustement: this._calculAjustementMoral(succes, moralActuel, situation)
|
|
};
|
|
await this.moralIncDec(jetMoral.ajustement);
|
|
return jetMoral;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async moralIncDec(ajustementMoral) {
|
|
if (ajustementMoral != 0) {
|
|
ajustementMoral = Math.sign(ajustementMoral)
|
|
let moral = Misc.toInt(this.system.compteurs.moral.value) + ajustementMoral
|
|
if (moral > 3) { // exaltation
|
|
const exaltation = Misc.toInt(this.system.compteurs.exaltation.value) + ajustementMoral;
|
|
await this.updateCompteurValue('exaltation', exaltation);
|
|
}
|
|
if (moral < -3) { // dissolution
|
|
const dissolution = Misc.toInt(this.system.compteurs.dissolution.value) - ajustementMoral;
|
|
await this.updateCompteurValue('dissolution', dissolution);
|
|
}
|
|
moral = Math.max(-3, Math.min(moral, 3));
|
|
await this.updateCompteurValue('moral', moral);
|
|
}
|
|
return this.system.compteurs.moral.value;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
_calculAjustementMoral(succes, moral, situation) {
|
|
switch (situation) {
|
|
case 'heureux': case 'heureuse': return succes ? 1 : 0;
|
|
case 'malheureuse': case 'malheureux': return succes ? 0 : -1;
|
|
case 'neutre':
|
|
if (succes && moral < 0) return 1;
|
|
if (!succes && moral > 0) return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async setEthylisme(degre) {
|
|
let ethylisme = duplicate(this.system.compteurs.ethylisme);
|
|
ethylisme.value = degre;
|
|
ethylisme.nb_doses = 0;
|
|
if (degre == 1) {
|
|
ethylisme.jet_moral = false;
|
|
}
|
|
await this.update({ "system.compteurs.ethylisme": ethylisme });
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async jetEthylisme() {
|
|
let rollData = {
|
|
vie: this.system.sante.vie.max,
|
|
forceAlcool: 0,
|
|
etat: this.getEtatGeneral({ ethylisme: true }),
|
|
diffNbDoses: -Number(this.system.compteurs.ethylisme.nb_doses || 0),
|
|
finalLevel: 0,
|
|
diffConditions: 0,
|
|
ajustementsForce: CONFIG.RDD.difficultesLibres,
|
|
}
|
|
let html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/dialog-roll-ethylisme.html', rollData);
|
|
new RdDRollDialogEthylisme(html, rollData, this, r => this.saouler(r.forceAlcool)).render(true);
|
|
}
|
|
|
|
async actionNourritureboisson(item, onActionItem) {
|
|
switch (item.getUtilisationCuisine()) {
|
|
case 'brut': {
|
|
let d = new Dialog({
|
|
title: "Nourriture brute",
|
|
content: `Que faire de votre ${item.name}`,
|
|
buttons: {
|
|
'cuisiner': { icon: '<i class="fas fa-check"></i>', label: 'Cuisiner', callback: async () => await this.preparerNourriture(item) },
|
|
'manger': { icon: '<i class="fas fa-check"></i>', label: 'Manger cru', callback: async () => await this.mangerNourriture(item, onActionItem) }
|
|
}
|
|
});
|
|
d.render(true);
|
|
return true;
|
|
}
|
|
case 'pret':
|
|
await this.mangerNourriture(item, onActionItem);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
async mangerNourriture(item, onActionItem) {
|
|
return (await DialogConsommer.create(this, item, onActionItem)).render(true);
|
|
}
|
|
|
|
async actionLire(item) {
|
|
const tache = await this.creerTacheDepuisLivre(item, { renderSheet: false });
|
|
if (tache) {
|
|
await this.rollTache(tache.id);
|
|
}
|
|
}
|
|
|
|
async actionHerbe(item, onActionItem = async () => { }) {
|
|
if (item.isHerbeAPotion()) {
|
|
return DialogFabriquerPotion.create(this, item, onActionItem);
|
|
}
|
|
return;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async consommer(item, choix) {
|
|
switch (item.type) {
|
|
case 'nourritureboisson':
|
|
case 'herbe': case 'faune':
|
|
return await this.consommerNourritureboisson(item.id, choix);
|
|
case 'potion':
|
|
return await this.consommerPotion(item)
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async consommerNourritureboisson(itemId, choix = { doses: 1, seForcer: false, supprimerSiZero: false }, userId = undefined) {
|
|
if (userId != undefined && userId != game.user.id) {
|
|
RdDBaseActor.remoteActorCall({
|
|
tokenId: this.token?.id,
|
|
actorId: this.id,
|
|
method: 'consommerNourritureboisson',
|
|
args: [itemId, choix, userId]
|
|
},
|
|
userId)
|
|
return;
|
|
}
|
|
const item = this.getItem(itemId)
|
|
if (!item.getUtilisationCuisine()) {
|
|
return;
|
|
}
|
|
if (choix.doses > item.system.quantite) {
|
|
ui.notifications.warn(`Il n'y a pas assez de ${item.name} pour manger ${choix.doses}`)
|
|
return;
|
|
}
|
|
if (!this._apprecierCuisine(item, choix.seForcer)) {
|
|
ui.notifications.info(`${this.name} ne n'arrive pas à manger de ${item.name}`)
|
|
return;
|
|
}
|
|
await this.manger(item, choix.doses, { diminuerQuantite: false });
|
|
await this.boire(item, choix.doses, { diminuerQuantite: false });
|
|
await item.diminuerQuantite(choix.doses, choix);
|
|
}
|
|
|
|
async _apprecierCuisine(item, seForcer) {
|
|
const surmonteExotisme = await this._surmonterExotisme(item, seForcer);
|
|
if (surmonteExotisme) {
|
|
await this.apprecier('gout', 'cuisine', item.system.qualite, item.system.boisson ? "apprécie la boisson" : "apprécie le plat");
|
|
}
|
|
else if (seForcer) {
|
|
await this.jetDeMoral('malheureux');
|
|
}
|
|
else {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async _surmonterExotisme(item) {
|
|
const exotisme = Math.min(item.system.exotisme, item.system.qualite, 0);
|
|
if (exotisme < 0) {
|
|
const rolled = await this.doRollCaracCompetence('volonte', 'cuisine', exotisme, { title: `tente de surmonter l'exotisme de ${item.name}` });
|
|
return rolled.isSuccess;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async apprecier(carac, compName, qualite, title) {
|
|
const rolled = await this.doRollCaracCompetence(carac, compName, qualite, { title: title, apprecier: true });
|
|
if (rolled?.isSuccess) {
|
|
await this.jetDeMoral('heureux');
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async manger(item, doses, options = { diminuerQuantite: true }) {
|
|
const sust = item.system.sust
|
|
if (sust > 0) {
|
|
await this.updateCompteurValue('sust', RdDActor.$calculNewSust(this.system.compteurs.sust.value, sust, doses));
|
|
}
|
|
await item.diminuerQuantite(doses, options);
|
|
}
|
|
|
|
|
|
/* -------------------------------------------- */
|
|
async boire(item, doses, options = { diminuerQuantite: true }) {
|
|
const desaltere = item.system.desaltere;
|
|
if (desaltere > 0) {
|
|
await this.updateCompteurValue('eau', RdDActor.$calculNewSust(this.system.compteurs.eau.value, desaltere, doses));
|
|
}
|
|
if (item.isAlcool()) {
|
|
for (let i = 0; i < doses; i++) {
|
|
await this.saouler(item.system.force, item);
|
|
}
|
|
}
|
|
await item.diminuerQuantite(doses, options);
|
|
}
|
|
|
|
static $calculNewSust(value, sust, doses) {
|
|
return Misc.keepDecimals(Number(value) + Number(sust) * Number(doses), 1);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async saouler(forceAlcool, alcool = undefined) {
|
|
let ethylisme = duplicate(this.system.compteurs.ethylisme);
|
|
|
|
const etat = this.getEtatGeneral({ ethylisme: true });
|
|
const nbDoses = Number(this.system.compteurs.ethylisme.nb_doses || 0);
|
|
const ethylismeData = {
|
|
alias: this.name,
|
|
actor: this,
|
|
vie: this.system.sante.vie.max,
|
|
alcool: alcool,
|
|
jetVie: {
|
|
forceAlcool: forceAlcool,
|
|
nbDoses: nbDoses,
|
|
selectedCarac: this.system.sante.vie,
|
|
jetResistance: 'ethylisme',
|
|
carac: this.system.carac,
|
|
caracValue: this.system.sante.vie.max,
|
|
finalLevel: etat + forceAlcool - nbDoses
|
|
},
|
|
}
|
|
|
|
await RdDResolutionTable.rollData(ethylismeData.jetVie);
|
|
this._appliquerExperienceRollData(ethylismeData.jetVie);
|
|
RollDataAjustements.calcul(ethylismeData.jetVie, this);
|
|
if (ethylismeData.jetVie.rolled.isSuccess) {
|
|
ethylisme.nb_doses++;
|
|
} else {
|
|
ethylisme.value = Math.max(ethylisme.value - 1, -7);
|
|
ethylisme.nb_doses = 0;
|
|
|
|
let perte = await RdDDice.rollTotal("1d6");
|
|
ethylismeData.perteEndurance = await this.santeIncDec("endurance", -perte);
|
|
|
|
if (!ethylisme.jet_moral) {
|
|
ethylismeData.jetMoral = await this._jetDeMoral('heureuse');
|
|
if (ethylismeData.jetMoral.ajustement == 1) {
|
|
ethylismeData.moralAlcool = 'heureux';
|
|
ethylisme.jet_moral = true;
|
|
} else if (ethylisme.value == -1) {
|
|
ethylismeData.jetMoral.ajustement = -1;
|
|
ethylismeData.moralAlcool = 'triste';
|
|
ethylisme.jet_moral = true;
|
|
await this.moralIncDec(-1);
|
|
}
|
|
}
|
|
if (ethylisme.value < 0) {
|
|
// Qui a bu boira (p 164)
|
|
ethylismeData.jetVolonte = {
|
|
selectedCarac: this.system.carac.volonte,
|
|
caracValue: this.system.carac.volonte.value,
|
|
ethylisme: Number(ethylisme.value),
|
|
finalLevel: Number(ethylisme.value) + Number(this.system.compteurs.moral.value)
|
|
}
|
|
await RdDResolutionTable.rollData(ethylismeData.jetVolonte);
|
|
this._appliquerExperienceRollData(ethylismeData.jetVolonte);
|
|
RollDataAjustements.calcul(ethylismeData.jetVolonte, this);
|
|
}
|
|
}
|
|
ethylismeData.ajustementEthylique = ethylisme.value;
|
|
ethylismeData.nomEthylisme = RdDUtility.getNomEthylisme(ethylisme.value);
|
|
ethylismeData.doses = ethylisme.nb_doses;
|
|
|
|
await this.update({ 'system.compteurs.ethylisme': ethylisme });
|
|
await RdDResolutionTable.displayRollData(ethylismeData, this, 'chat-resultat-ethylisme.html');
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async jetGoutCuisine() {
|
|
console.info('Jet de Gout/Cuisine');
|
|
return true;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async transformerStress() {
|
|
const fromStress = Number(this.system.compteurs.stress.value);
|
|
if (this.system.sommeil?.insomnie || fromStress <= 0) {
|
|
return;
|
|
}
|
|
|
|
const stressRoll = await this._stressRoll(this.getReveActuel());
|
|
|
|
const conversion = Math.floor(fromStress * stressRoll.factor / 100);
|
|
let dissolution = Math.max(0, Number(this.system.compteurs.dissolution.value));
|
|
let exaltation = Math.max(0, Number(this.system.compteurs.exaltation.value));
|
|
const annule = Math.min(dissolution, exaltation);
|
|
dissolution -= annule;
|
|
exaltation -= annule;
|
|
const perteDissolution = Math.max(0, Math.min(dissolution, conversion));
|
|
|
|
let stressRollData = {
|
|
alias: this.name,
|
|
selectedCarac: this.system.carac.reve,
|
|
rolled: stressRoll,
|
|
stress: fromStress,
|
|
perte: Math.min(conversion, fromStress),
|
|
convertis: conversion - perteDissolution,
|
|
xp: conversion - perteDissolution + exaltation,
|
|
dissolution: dissolution,
|
|
exaltation: exaltation
|
|
};
|
|
|
|
ChatMessage.create({
|
|
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
|
|
content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-resultat-transformer-stress.html`, stressRollData)
|
|
});
|
|
|
|
const toStress = Math.max(fromStress - stressRollData.perte - 1, 0);
|
|
const fromXpSress = Number(this.system.compteurs.experience.value);
|
|
const toXpStress = fromXpSress + Number(stressRollData.xp);
|
|
const updates = {
|
|
"system.compteurs.stress.value": toStress,
|
|
"system.compteurs.experience.value": toXpStress,
|
|
"system.compteurs.dissolution.value": dissolution - perteDissolution,
|
|
"system.compteurs.exaltation.value": 0
|
|
}
|
|
await this.update(updates);
|
|
await ExperienceLog.add(this, XP_TOPIC.STRESS, fromStress, toStress, 'Transformation')
|
|
await ExperienceLog.add(this, XP_TOPIC.TRANSFORM, fromXpSress, toXpStress, 'Transformation')
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async _stressRoll(reveActuel) {
|
|
let result = await RdDResolutionTable.roll(reveActuel, 0);
|
|
if (result.isPart) {
|
|
result.second = await RdDResolutionTable.roll(reveActuel, 0);
|
|
}
|
|
result.factor = this._getFacteurStress(result);
|
|
return result;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
_getFacteurStress(stressRoll) {
|
|
switch (stressRoll.code) {
|
|
case "sign": return 75;
|
|
case "norm": return 50;
|
|
case "echec": return 20;
|
|
case "epart": return 10;
|
|
case "etotal": return 0;
|
|
case "part":
|
|
if (stressRoll.second.isSign) {
|
|
stressRoll.quality = "Double Particulière";
|
|
return 150;
|
|
}
|
|
return 100;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
createCallbackExperience() {
|
|
return {
|
|
condition: r => r.rolled.isPart && r.finalLevel < 0 && game.settings.get("core", "rollMode") != 'selfroll',
|
|
action: r => this.appliquerAjoutExperience(r)
|
|
};
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
createCallbackAppelAuMoral() { /* Si l'appel au moral est utilisé, on l'affiche dans le chat et on diminue éventuellement le moral */
|
|
return {
|
|
condition: r => r.use.appelAuMoral && game.settings.get("core", "rollMode") != 'selfroll',
|
|
action: r => this._appliquerAppelMoral(r)
|
|
};
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async checkCaracXP(caracName, display = true) {
|
|
let carac = RdDActor._findCaracByName(this.system.carac, caracName);
|
|
if (carac && carac.xp > 0) {
|
|
const niveauSuivant = Number(carac.value) + 1;
|
|
let xpNeeded = RdDCarac.getCaracNextXp(niveauSuivant);
|
|
if (carac.xp >= xpNeeded) {
|
|
carac = duplicate(carac);
|
|
carac.value = niveauSuivant;
|
|
|
|
let checkXp = {
|
|
alias: this.name,
|
|
carac: caracName,
|
|
value: niveauSuivant,
|
|
xp: carac.xp
|
|
}
|
|
if (display) {
|
|
ChatMessage.create({
|
|
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
|
|
content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-actor-carac-xp.html`, checkXp)
|
|
});
|
|
}
|
|
return checkXp;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async checkCompetenceXP(compName, newXP, display = true) {
|
|
let compData = this.getCompetence(compName);
|
|
if (compData && newXP && newXP == compData.system.xp) { // Si édition, mais sans changement XP
|
|
return;
|
|
}
|
|
newXP = (newXP) ? newXP : compData.system.xp;
|
|
if (compData && newXP > 0) {
|
|
let xpNeeded = RdDItemCompetence.getCompetenceNextXp(compData.system.niveau + 1);
|
|
if (newXP >= xpNeeded) {
|
|
let newCompData = duplicate(compData);
|
|
newCompData.system.niveau += 1;
|
|
newCompData.system.xp = newXP;
|
|
let checkXp = {
|
|
alias: this.name,
|
|
competence: newCompData.name,
|
|
niveau: newCompData.system.niveau,
|
|
xp: newCompData.system.xp,
|
|
archetype: newCompData.system.niveau_archetype,
|
|
archetypeWarning: newCompData.system.niveau > compData.system.niveau_archetype
|
|
}
|
|
if (display) {
|
|
ChatMessage.create({
|
|
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
|
|
content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-actor-competence-xp.html`, checkXp)
|
|
});
|
|
}
|
|
return checkXp;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async appliquerAjoutExperience(rollData, hideChatMessage = 'show') {
|
|
if (!this.isPersonnage()) return;
|
|
hideChatMessage = hideChatMessage == 'hide' || (Misc.isRollModeHiddenToPlayer() && !game.user.isGM)
|
|
let xpData = await this._appliquerExperience(rollData.rolled, rollData.selectedCarac.label, rollData.competence, rollData.jetResistance);
|
|
if (xpData) {
|
|
const content = await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-actor-gain-xp.html`, xpData);
|
|
if (hideChatMessage) {
|
|
ChatUtility.blindMessageToGM({ content: content });
|
|
}
|
|
else {
|
|
ChatMessage.create({
|
|
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
|
|
content: content
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async _appliquerAppelMoral(rollData) {
|
|
if (!this.isPersonnage()) return;
|
|
if (!rollData.use.moral) return;
|
|
if (rollData.rolled.isEchec ||
|
|
(rollData.ajustements.diviseurSignificative && (rollData.rolled.roll * rollData.ajustements.diviseurSignificative > rollData.score))) {
|
|
rollData.perteMoralEchec = rollData.moral <= -3 ? 'dissolution' : 'perte';
|
|
rollData.moral = await this.moralIncDec(-1); /* L'appel au moral a échoué. Le personnage perd un point de moral */
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
$filterSortList(sortList, coord) {
|
|
let tmr = TMRUtility.getTMR(coord);
|
|
let filtered = []
|
|
for (let sort of sortList) {
|
|
if (sort.system.caseTMR.toLowerCase().includes('variable')) {
|
|
filtered.push(sort);
|
|
} else if (sort.system.caseTMRspeciale.toLowerCase().includes('variable')) {
|
|
filtered.push(sort);
|
|
} else if (sort.system.caseTMR.toLowerCase() == tmr.type) {
|
|
filtered.push(sort);
|
|
} else if (sort.system.caseTMR.toLowerCase().includes('special') && sort.system.caseTMRspeciale.toLowerCase().includes(coord.toLowerCase())) {
|
|
filtered.push(sort);
|
|
}
|
|
}
|
|
return filtered;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
computeDraconicAndSortIndex(sortList) {
|
|
let draconicList = this.getDraconicList();
|
|
for (let sort of sortList) {
|
|
let draconicsSort = this.getDraconicsSort(draconicList, sort).map(it => it.name);
|
|
for (let index = 0; index < draconicList.length && sort.system.listIndex == undefined; index++) {
|
|
if (draconicsSort.includes(draconicList[index].name)) {
|
|
sort.system.listIndex = index;
|
|
}
|
|
}
|
|
}
|
|
return draconicList;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
getDraconicsSort(draconicList, sort) {
|
|
//console.log(draconicList, bestDraconic, draconic, voie);
|
|
switch (Grammar.toLowerCaseNoAccent(sort.name)) {
|
|
case "lecture d'aura":
|
|
case "detection d'aura":
|
|
return draconicList;
|
|
case "annulation de magie":
|
|
return draconicList.filter(it => !RdDItemCompetence.isThanatos(it));
|
|
}
|
|
return [RdDItemCompetence.getVoieDraconic(draconicList, sort.system.draconic)];
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async rollUnSort(coord) {
|
|
RdDEmpoignade.checkEmpoignadeEnCours(this)
|
|
if (EffetsDraconiques.isSortImpossible(this)) {
|
|
ui.notifications.error("Une queue ou un souffle vous empèche de lancer de sort!");
|
|
return;
|
|
}
|
|
// Duplication car les pts de reve sont modifiés dans le sort
|
|
let sorts = duplicate(this.$filterSortList(this.itemTypes['sort'], coord));
|
|
if (sorts.length == 0) {
|
|
ui.notifications.info(`Aucun sort disponible en ${TMRUtility.getTMR(coord).label} !`);
|
|
return;
|
|
}
|
|
|
|
|
|
const draconicList = this.computeDraconicAndSortIndex(sorts);
|
|
const reve = duplicate(this.system.carac.reve);
|
|
|
|
const dialog = await this._openRollDialog({
|
|
name: 'lancer-un-sort',
|
|
label: 'Lancer un sort',
|
|
template: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-sort.html',
|
|
rollData: {
|
|
carac: { 'reve': reve },
|
|
forceCarac: { 'reve': reve },
|
|
selectedCarac: reve,
|
|
draconicList: draconicList,
|
|
competence: draconicList[0],
|
|
sortList: sorts,
|
|
selectedSort: sorts[0],
|
|
tmr: TMRUtility.getTMR(coord),
|
|
diffLibre: RdDItemSort.getDifficulte(sorts[0], -7), // Per default at startup
|
|
coutreve: Array(30).fill().map((item, index) => 1 + index),
|
|
},
|
|
callbackAction: r => this._rollUnSortResult(r)
|
|
});
|
|
this.tmrApp?.setTMRPendingAction(dialog);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
isMauvaiseRencontre() { // Gestion queue/souffle 'Mauvaise Rencontre en Perpective'
|
|
let addMsg = "";
|
|
let rencSpecial = EffetsDraconiques.mauvaiseRencontre(this);
|
|
if (rencSpecial) {
|
|
if (rencSpecial.type != 'souffle') {
|
|
this.deleteEmbeddedDocuments('Item', [rencSpecial.id]); // Suppression dans la liste des queues
|
|
addMsg = " La queue a été supprimée de votre fiche automatiquement";
|
|
} else {
|
|
addMsg = " Vous devez gérer manuellement le décompte de mauvaises rencontres.";
|
|
}
|
|
ChatMessage.create({
|
|
content: "Vous êtes sous le coup d'une Mauvaise Rencontre en Persective." + addMsg,
|
|
whisper: ChatMessage.getWhisperRecipients(this.name)
|
|
});
|
|
}
|
|
return rencSpecial;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
getTMRFatigue() { // Pour l'instant uniquement Inertie Draconique
|
|
let countInertieDraconique = EffetsDraconiques.countInertieDraconique(this);
|
|
if (countInertieDraconique > 0) {
|
|
ChatMessage.create({
|
|
content: `Vous êtes sous le coup d'Inertie Draconique : vous perdrez ${countInertieDraconique + 1} cases de Fatigue par déplacement au lieu d'une.`,
|
|
whisper: ChatMessage.getWhisperRecipients(this.name)
|
|
});
|
|
}
|
|
return countInertieDraconique + 1;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async checkSoufflePeage(tmr) {
|
|
if ((tmr.type == 'pont' || tmr.type == 'cite') && EffetsDraconiques.isPeage(this)) {
|
|
await this.reveActuelIncDec(-1);
|
|
ChatMessage.create({
|
|
content: "Vous êtes sous le coup d'un Péage : l'entrée sur cette case vous a coûté 1 Point de Rêve (déduit automatiquement).",
|
|
whisper: ChatMessage.getWhisperRecipients(this.name)
|
|
});
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async _rollUnSortResult(rollData) {
|
|
let rolled = rollData.rolled;
|
|
let selectedSort = rollData.selectedSort;
|
|
|
|
rollData.isSortReserve = rollData.mettreEnReserve && !selectedSort.system.isrituel;
|
|
rollData.show = {}
|
|
rollData.depenseReve = Number(selectedSort.system.ptreve_reel);
|
|
|
|
if (rollData.competence.name.includes('Thanatos')) { // Si Thanatos
|
|
await this.update({ "system.reve.reve.thanatosused": true });
|
|
}
|
|
let reveActuel = this.system.reve.reve.value;
|
|
if (rolled.isSuccess) { // Réussite du sort !
|
|
if (rolled.isPart) {
|
|
rollData.depenseReve = Math.max(Math.floor(rollData.depenseReve / 2), 1);
|
|
}
|
|
if (rollData.isSortReserve) {
|
|
rollData.depenseReve++;
|
|
}
|
|
if (reveActuel > rollData.depenseReve) {
|
|
// Incrémenter/gére le bonus de case
|
|
RdDItemSort.incrementBonusCase(this, selectedSort, rollData.tmr.coord);
|
|
|
|
if (rollData.isSortReserve) {
|
|
await this.sortMisEnReserve(selectedSort, rollData.competence, rollData.tmr.coord, Number(selectedSort.system.ptreve_reel));
|
|
}
|
|
}
|
|
else {
|
|
rollData.depenseReve = 0;
|
|
rollData.show.reveInsuffisant = true;
|
|
mergeObject(rollData.rolled, RdDResolutionTable.getResultat("echec"), { overwrite: true });
|
|
}
|
|
} else {
|
|
if (rolled.isETotal) { // Echec total !
|
|
rollData.depenseReve = Math.min(reveActuel, Math.floor(rollData.depenseReve * 1.5))
|
|
// TODO: mise en réserve d'un échec total...
|
|
// await dialog mse en réserve, pour traitement échec total
|
|
} else {
|
|
rollData.depenseReve = 0
|
|
}
|
|
}
|
|
|
|
reveActuel = Math.max(reveActuel - rollData.depenseReve, 0);
|
|
await this.update({ "system.reve.reve.value": reveActuel });
|
|
|
|
if (rollData.isSortReserve) {
|
|
this.tmrApp.maximize(); // Re-display TMR
|
|
} else {
|
|
this.tmrApp.close(); // Close TMR !
|
|
}
|
|
// Final chat message
|
|
await RdDResolutionTable.displayRollData(rollData, this, 'chat-resultat-sort.html');
|
|
|
|
if (reveActuel == 0) { // 0 points de reve
|
|
ChatMessage.create({ content: this.name + " est réduit à 0 Points de Rêve, et tombe endormi !" });
|
|
closeTMR = true;
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async rollCarac(caracName, jetResistance = undefined) {
|
|
RdDEmpoignade.checkEmpoignadeEnCours(this)
|
|
let selectedCarac = this.getCaracByName(caracName)
|
|
await this._openRollDialog({
|
|
name: 'jet-' + caracName,
|
|
label: 'Jet ' + Grammar.apostrophe('de', selectedCarac.label),
|
|
template: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-carac.html',
|
|
rollData: {
|
|
selectedCarac: selectedCarac,
|
|
competences: this.itemTypes['competence'],
|
|
jetResistance: jetResistance ? caracName : undefined
|
|
},
|
|
callbackAction: r => this.$onRollCaracResult(r)
|
|
});
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async $onRollCaracResult(rollData) {
|
|
// Final chat message
|
|
await RdDResolutionTable.displayRollData(rollData, this, 'chat-resultat-general.html');
|
|
}
|
|
|
|
/**
|
|
* Méthode pour faire un jet prédéterminer sans ouvrir la fenêtre de dialogue
|
|
* @param {*} caracName
|
|
* @param {*} compName
|
|
* @param {*} diff
|
|
* @param {*} options
|
|
* @returns
|
|
*/
|
|
async doRollCaracCompetence(caracName, compName, diff, options = { title: "", apprecier: false }) {
|
|
const carac = this.getCaracByName(caracName);
|
|
if (!carac) {
|
|
ui.notifications.warn(`${this.name} n'a pas de caractéristique correspondant à ${caracName}`)
|
|
return;
|
|
}
|
|
const competence = this.getCompetence(compName);
|
|
if (options.apprecier && competence) {
|
|
const minQualite = Math.max(0, competence.system.niveau);
|
|
if (diff <= minQualite) {
|
|
ui.notifications.info(`${this.name} a un niveau ${competence.system.niveau} en ${competence.name}, trop élevé pour apprécier la qualité de ${diff}`)
|
|
return;
|
|
}
|
|
}
|
|
let rollData = {
|
|
alias: this.name,
|
|
caracValue: Number(carac.value),
|
|
selectedCarac: carac,
|
|
competence: competence,
|
|
diffLibre: diff,
|
|
show: { title: options?.title ?? '' }
|
|
};
|
|
RollDataAjustements.calcul(rollData, this);
|
|
await RdDResolutionTable.rollData(rollData);
|
|
this._appliquerExperienceRollData(rollData);
|
|
await RdDResolutionTable.displayRollData(rollData, this)
|
|
return rollData.rolled;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
_appliquerExperienceRollData(rollData) {
|
|
const callback = this.createCallbackExperience();
|
|
if (callback.condition(rollData)) {
|
|
callback.action(rollData);
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async rollCompetence(idOrName, options = { tryTarget: true }) {
|
|
RdDEmpoignade.checkEmpoignadeEnCours(this)
|
|
let rollData = {
|
|
carac: this.system.carac,
|
|
competence: this.getCompetence(idOrName)
|
|
}
|
|
if (rollData.competence.type == TYPES.competencecreature) {
|
|
const arme = RdDItemCompetenceCreature.armeCreature(rollData.competence)
|
|
if (arme && options.tryTarget && Targets.hasTargets()) {
|
|
Targets.selectOneToken(target => {
|
|
if (arme.action == "possession") {
|
|
RdDPossession.onAttaquePossession(target, this, rollData.competence)
|
|
}
|
|
else {
|
|
RdDCombat.rddCombatTarget(target, this).attaque(competence, arme)
|
|
}
|
|
});
|
|
return;
|
|
}
|
|
// Transformer la competence de créature
|
|
RdDItemCompetenceCreature.setRollDataCreature(rollData)
|
|
}
|
|
|
|
await this._openRollDialog({
|
|
name: 'jet-competence',
|
|
label: 'Jet ' + Grammar.apostrophe('de', rollData.competence.name),
|
|
template: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-competence.html',
|
|
rollData: rollData,
|
|
callbackAction: r => this.$onRollCompetence(r, options)
|
|
});
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async $onRollCompetence(rollData, options) {
|
|
await RdDResolutionTable.displayRollData(rollData, this, 'chat-resultat-competence.html')
|
|
if (options?.onRollAutomate) {
|
|
options.onRollAutomate(rollData);
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async creerTacheDepuisLivre(item, options = { renderSheet: true }) {
|
|
const nomTache = "Lire " + item.name;
|
|
const filterTacheLecture = it => it.type == 'tache' && it.name == nomTache;
|
|
let tachesExistantes = this.filterItems(filterTacheLecture);
|
|
if (tachesExistantes.length == 0) {
|
|
const tache = {
|
|
name: nomTache, type: 'tache',
|
|
system: {
|
|
carac: 'intellect',
|
|
competence: 'Ecriture',
|
|
difficulte: item.system.difficulte,
|
|
periodicite: "60 minutes",
|
|
fatigue: 2,
|
|
points_de_tache: item.system.points_de_tache,
|
|
points_de_tache_courant: 0,
|
|
description: "Lecture du livre " + item.name + " - XP : " + item.system.xp + " - Compétences : " + item.system.competence
|
|
}
|
|
}
|
|
await this.createEmbeddedDocuments('Item', [tache], options);
|
|
tachesExistantes = this.filterItems(filterTacheLecture);
|
|
}
|
|
return tachesExistantes.length > 0 ? tachesExistantes[0] : undefined;
|
|
}
|
|
|
|
blessuresASoigner() {
|
|
// TODO or not TODO: filtrer les blessures poour lesquels on ne peut plus faire de premiers soins?
|
|
return this.filterItems(it => it.system.gravite > 0 && it.system.gravite <= 6 && !(it.system.premierssoins.done && it.system.soinscomplets.done), 'blessure')
|
|
}
|
|
|
|
async getTacheBlessure(blesse, blessure) {
|
|
const gravite = blessure?.system.gravite ?? 0;
|
|
if (gravite > 0) {
|
|
const tache = this.itemTypes['tache'].find(it => it.system.itemId == blessure.id)
|
|
?? await RdDItemBlessure.createTacheSoinBlessure(this, gravite);
|
|
await blessure?.updateTacheSoinBlessure(tache);
|
|
return tache
|
|
}
|
|
return undefined;
|
|
}
|
|
|
|
async rollCaracCompetence(caracName, compName, diff, options = { title: "" }) {
|
|
RdDEmpoignade.checkEmpoignadeEnCours(this)
|
|
const competence = this.getCompetence(compName);
|
|
await this._openRollDialog({
|
|
name: 'jet-competence',
|
|
label: 'Jet ' + Grammar.apostrophe('de', competence.name),
|
|
template: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-competence.html',
|
|
rollData: {
|
|
alias: this.name,
|
|
carac: this.system.carac,
|
|
selectedCarac: this.getCaracByName(caracName),
|
|
selectedCaracName: caracName,
|
|
diffLibre: diff,
|
|
competence: competence,
|
|
show: { title: options?.title ?? '' }
|
|
},
|
|
callbackAction: r => this.$onRollCompetence(r, options)
|
|
});
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async rollTache(id, options = {}) {
|
|
RdDEmpoignade.checkEmpoignadeEnCours(this)
|
|
const tacheData = this.getTache(id)
|
|
const compData = this.getCompetence(tacheData.system.competence)
|
|
compData.system.defaut_carac = tacheData.system.carac; // Patch !
|
|
|
|
await this._openRollDialog({
|
|
name: 'jet-competence',
|
|
label: 'Jet de Tâche ' + tacheData.name,
|
|
template: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-competence.html',
|
|
rollData: {
|
|
competence: compData,
|
|
tache: tacheData,
|
|
diffLibre: tacheData.system.difficulte,
|
|
diffConditions: 0,
|
|
use: { libre: false, conditions: true },
|
|
carac: {
|
|
[tacheData.system.carac]: duplicate(this.system.carac[tacheData.system.carac])
|
|
}
|
|
},
|
|
callbackAction: r => this._tacheResult(r, options)
|
|
});
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async _tacheResult(rollData, options) {
|
|
// Mise à jour de la tache
|
|
rollData.appliquerFatigue = ReglesOptionnelles.isUsing("appliquer-fatigue");
|
|
rollData.tache = duplicate(rollData.tache);
|
|
rollData.tache.system.points_de_tache_courant += rollData.rolled.ptTache;
|
|
if (rollData.rolled.isETotal) {
|
|
rollData.tache.system.difficulte--;
|
|
}
|
|
if (rollData.rolled.isSuccess) {
|
|
rollData.tache.system.nb_jet_succes++;
|
|
} else {
|
|
rollData.tache.system.nb_jet_echec++;
|
|
}
|
|
rollData.tache.system.tentatives = rollData.tache.system.nb_jet_succes + rollData.tache.system.nb_jet_echec;
|
|
|
|
this.updateEmbeddedDocuments('Item', [rollData.tache]);
|
|
this.santeIncDec("fatigue", rollData.tache.system.fatigue);
|
|
|
|
await RdDResolutionTable.displayRollData(rollData, this, 'chat-resultat-tache.html');
|
|
if (options?.onRollAutomate) {
|
|
options.onRollAutomate(rollData);
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async _rollArt(artData, selected, oeuvre, callbackAction = r => this._resultArt(r)) {
|
|
oeuvre.system.niveau = oeuvre.system.niveau ?? 0;
|
|
mergeObject(artData,
|
|
{
|
|
oeuvre: oeuvre,
|
|
art: oeuvre.type,
|
|
competence: duplicate(this.getCompetence(artData.compName ?? oeuvre.system.competence ?? artData.art)),
|
|
diffLibre: - oeuvre.system.niveau,
|
|
diffConditions: 0,
|
|
use: { libre: false, conditions: true, surenc: false },
|
|
selectedCarac: duplicate(this.system.carac[selected])
|
|
},
|
|
{ overwrite: false });
|
|
artData.competence.system.defaut_carac = selected;
|
|
if (!artData.forceCarac) {
|
|
artData.forceCarac = {};
|
|
artData.forceCarac[selected] = duplicate(this.system.carac[selected]);
|
|
}
|
|
|
|
await this._openRollDialog({
|
|
name: `jet-${artData.art}`,
|
|
label: `${artData.verbe} ${oeuvre.name}`,
|
|
template: `systems/foundryvtt-reve-de-dragon/templates/dialog-roll-${oeuvre.type}.html`,
|
|
rollData: artData,
|
|
callbackAction: callbackAction
|
|
});
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async _resultArt(artData) {
|
|
const niveau = artData.oeuvre.system.niveau ?? 0;
|
|
const baseQualite = (artData.rolled.isSuccess ? niveau : artData.competence.system.niveau);
|
|
artData.qualiteFinale = Math.min(baseQualite, niveau) + artData.rolled.ptQualite;
|
|
|
|
await RdDResolutionTable.displayRollData(artData, this.name, `chat-resultat-${artData.art}.html`);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async rollChant(id) {
|
|
const artData = { art: 'chant', verbe: 'Chanter' };
|
|
const oeuvre = duplicate(this.getChant(id));
|
|
await this._rollArt(artData, "ouie", oeuvre);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async rollDanse(id) {
|
|
const artData = { art: 'danse', verbe: 'Danser', forceCarac: {} };
|
|
const oeuvre = duplicate(this.findItemLike(id, artData.art));
|
|
if (oeuvre.system.agilite) {
|
|
artData.forceCarac['agilite'] = duplicate(this.system.carac.agilite);
|
|
}
|
|
if (oeuvre.system.apparence) {
|
|
artData.forceCarac['apparence'] = duplicate(this.system.carac.apparence);
|
|
}
|
|
const selectedCarac = this._getCaracDanse(oeuvre);
|
|
await this._rollArt(artData, selectedCarac, oeuvre);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
_getCaracDanse(oeuvre) {
|
|
if (oeuvre.system.agilite) { return "agilite"; }
|
|
else if (oeuvre.system.apparence) { return "apparence"; }
|
|
const compData = this.getCompetence(oeuvre.system.competence);
|
|
return compData.system.defaut_carac;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async rollMusique(id) {
|
|
const artData = { art: 'musique', verbe: 'Jouer' };
|
|
const oeuvre = this.findItemLike(id, artData.art);
|
|
await this._rollArt(artData, "ouie", oeuvre);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async rollRecetteCuisine(id) {
|
|
const oeuvre = this.getRecetteCuisine(id);
|
|
const artData = {
|
|
verbe: 'Cuisiner',
|
|
compName: 'cuisine',
|
|
proportions: 1,
|
|
ajouterEquipement: false
|
|
};
|
|
await this._rollArt(artData, 'odoratgout', oeuvre, r => this._resultRecetteCuisine(r));
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async _resultRecetteCuisine(cuisine) {
|
|
const niveauRecette = cuisine.oeuvre.system.niveau ?? 0;
|
|
const baseQualite = (cuisine.rolled.isSuccess ? niveauRecette : cuisine.competence.system.niveau);
|
|
cuisine.qualiteFinale = Math.min(baseQualite, niveauRecette) + cuisine.rolled.ptQualite;
|
|
cuisine.exotismeFinal = Math.min(Math.min(cuisine.qualiteFinale, cuisine.oeuvre.system.exotisme ?? 0), 0);
|
|
cuisine.sust = cuisine.oeuvre.system.sust * Math.min(cuisine.proportions, cuisine.proportionsMax ?? cuisine.proportions)
|
|
const platCuisine = {
|
|
name: cuisine.oeuvre.name,
|
|
type: 'nourritureboisson',
|
|
img: 'systems/foundryvtt-reve-de-dragon/icons/objets/provision_cuite.webp',
|
|
system: {
|
|
"description": cuisine.oeuvre.system.description,
|
|
"sust": 1,
|
|
"qualite": cuisine.qualiteFinale,
|
|
"exotisme": cuisine.exotismeFinal,
|
|
"encombrement": 0.1,
|
|
"quantite": Math.max(1, Math.floor(cuisine.sust)),
|
|
"cout": Math.max(cuisine.qualiteFinale) * 0.01
|
|
}
|
|
}
|
|
if (cuisine.ajouterEquipement) {
|
|
await this.createEmbeddedDocuments('Item', [platCuisine]);
|
|
ui.notifications.info(`${platCuisine.system.quantite} rations de ${platCuisine.name} ont été ajoutés à votre équipement`);
|
|
}
|
|
cuisine.platCuisine = platCuisine;
|
|
await RdDResolutionTable.displayRollData(cuisine, this.name, `chat-resultat-${cuisine.art}.html`);
|
|
}
|
|
|
|
async preparerNourriture(item) {
|
|
if (item.getUtilisationCuisine() == 'brut') {
|
|
const nourriture = {
|
|
name: 'Plat de ' + item.name,
|
|
type: 'recettecuisine',
|
|
img: item.img,
|
|
system: {
|
|
sust: 1,
|
|
exotisme: item.system.exotisme,
|
|
ingredients: item.name
|
|
}
|
|
};
|
|
const artData = {
|
|
verbe: 'Préparer',
|
|
compName: 'cuisine',
|
|
proportions: 1,
|
|
proportionsMax: Math.min(50, item.system.sust),
|
|
ajouterEquipement: true
|
|
};
|
|
await this._rollArt(artData, 'odoratgout', nourriture, async (cuisine) => {
|
|
await this._resultRecetteCuisine(cuisine);
|
|
const remaining = Math.max(item.system.quantite - cuisine.proportions, 0);
|
|
if (remaining > 0) {
|
|
await item.update({ 'system.quantite': remaining })
|
|
}
|
|
else {
|
|
await this.deleteEmbeddedDocuments('Item', [item.id]);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async rollJeu(id) {
|
|
const oeuvre = this.getJeu(id);
|
|
|
|
const listCarac = oeuvre.system.caraccomp.toLowerCase().split(/[.,:\/-]/).map(it => it.trim());
|
|
const carac = listCarac.length > 0 ? listCarac[0] : 'chance'
|
|
const artData = {
|
|
art: 'jeu', verbe: 'Jeu',
|
|
use: { libre: true, conditions: true, },
|
|
competence: duplicate(this.getCompetence('jeu')),
|
|
forceCarac: {}
|
|
};
|
|
listCarac.forEach(c => artData.forceCarac[c] = this.system.carac[c]);
|
|
artData.competence.system.niveauReel = artData.competence.system.niveau;
|
|
artData.competence.system.niveau = Math.max(artData.competence.system.niveau, oeuvre.system.base);
|
|
await this._rollArt(artData, carac, oeuvre);
|
|
}
|
|
|
|
async rollOeuvre(id) {
|
|
const artData = { art: 'oeuvre', verbe: 'Interpréter' }
|
|
const oeuvre = duplicate(this.findItemLike(id, artData.art))
|
|
await this._rollArt(artData, oeuvre.system.default_carac, oeuvre)
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async rollMeditation(id) {
|
|
const meditation = duplicate(this.getMeditation(id));
|
|
const competence = duplicate(this.getCompetence(meditation.system.competence));
|
|
competence.system.defaut_carac = "intellect"; // Meditation = toujours avec intellect
|
|
let meditationData = {
|
|
competence: competence,
|
|
meditation: meditation,
|
|
conditionMeditation: { isHeure: false, isVeture: false, isComportement: false, isPurification: false },
|
|
diffConditions: 0,
|
|
use: { libre: false, conditions: true, },
|
|
carac: { "intellect": this.system.carac.intellect }
|
|
};
|
|
|
|
const dialog = await RdDRoll.create(this, meditationData,
|
|
{ html: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-meditation.html' },
|
|
{
|
|
name: 'jet-meditation',
|
|
label: "Jet de méditation",
|
|
callbacks: [
|
|
this.createCallbackExperience(),
|
|
{ condition: r => r.rolled.isEPart, action: r => this._meditationEPart(r) },
|
|
{ action: r => this._meditationResult(r) }
|
|
]
|
|
});
|
|
dialog.render(true);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async _meditationResult(meditationRoll) {
|
|
this.santeIncDec("fatigue", 2);
|
|
|
|
if (meditationRoll.rolled.isSuccess) {
|
|
await this.createEmbeddedDocuments("Item", [RdDItemSigneDraconique.prepareSigneDraconiqueMeditation(meditationRoll.meditation, meditationRoll.rolled)]);
|
|
}
|
|
|
|
await RdDResolutionTable.displayRollData(meditationRoll, this.name, 'chat-resultat-meditation.html');
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
_meditationEPart(meditationRoll) {
|
|
this.updateEmbeddedDocuments('Item', [{ _id: meditationRoll.meditation._id, 'system.malus': meditationRoll.meditation.system.malus - 1 }]);
|
|
}
|
|
|
|
|
|
/* -------------------------------------------- */
|
|
_getSignesDraconiques(coord) {
|
|
const type = TMRUtility.getTMRType(coord);
|
|
return this.itemTypes["signedraconique"].filter(it => it.system.typesTMR.includes(type));
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
isResonanceSigneDraconique(coord) {
|
|
return this._getSignesDraconiques(coord).length > 0;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async rollLireSigneDraconique(coord) {
|
|
if (!this.isHautRevant()) {
|
|
ui.notifications.info("Seul un haut rêvant peut lire un signe draconique!");
|
|
return;
|
|
}
|
|
let signes = this._getSignesDraconiques(coord);
|
|
if (signes.length == 0) {
|
|
ui.notifications.info(`Aucun signe draconiques en ${coord} !`);
|
|
return;
|
|
}
|
|
let draconicList = this.getDraconicList()
|
|
.map(draconic => {
|
|
let draconicLecture = duplicate(draconic);
|
|
draconicLecture.system.defaut_carac = "intellect";
|
|
return draconicLecture;
|
|
});
|
|
|
|
const intellect = this.system.carac.intellect;
|
|
let rollData = {
|
|
carac: { 'intellect': intellect },
|
|
selectedCarac: intellect,
|
|
competence: draconicList[0],
|
|
draconicList: draconicList,
|
|
signe: signes[0],
|
|
signes: signes,
|
|
tmr: TMRUtility.getTMR(coord),
|
|
diffLibre: signes[0].system.difficulte,
|
|
}
|
|
|
|
const dialog = await RdDRoll.create(this, rollData,
|
|
{
|
|
html: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-signedraconique.html',
|
|
close: html => { this.tmrApp?.restoreTMRAfterAction() }
|
|
},
|
|
{
|
|
name: 'lire-signe-draconique',
|
|
label: 'Lire le signe draconique',
|
|
callbacks: [
|
|
this.createCallbackExperience(),
|
|
{ action: r => this._rollLireSigneDraconique(r) }
|
|
]
|
|
}
|
|
);
|
|
dialog.render(true);
|
|
this.tmrApp?.setTMRPendingAction(dialog);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async _rollLireSigneDraconique(rollData) {
|
|
const compData = rollData.competence;
|
|
if (!RdDItemCompetence.isDraconic(compData)) {
|
|
ui.notifications.error(`La compétence ${compData.name} n'est pas une compétence draconique`);
|
|
return;
|
|
}
|
|
rollData.xpSort = RdDItemSigneDraconique.getXpSortSigneDraconique(rollData.rolled.code, rollData.signe);
|
|
if (rollData.xpSort > 0) {
|
|
const fromXp = Number(compData.system.xp_sort);
|
|
const toXp = fromXp + rollData.xpSort;
|
|
await this.updateEmbeddedDocuments("Item", [{ _id: compData._id, 'system.xp_sort': toXp }]);
|
|
await ExperienceLog.add(this, XP_TOPIC.XPSORT, fromXp, toXp, `${rollData.competence.name} : signe draconique`);
|
|
}
|
|
await this.deleteEmbeddedDocuments("Item", [rollData.signe._id]);
|
|
await RdDResolutionTable.displayRollData(rollData, this.name, 'chat-resultat-lecture-signedraconique.html');
|
|
this.tmrApp.close();
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async rollAppelChance(onSuccess = () => { }, onEchec = () => { }) {
|
|
await this._openRollDialog({
|
|
name: 'appelChance',
|
|
label: 'Appel à la chance',
|
|
template: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-carac.html',
|
|
rollData: { selectedCarac: this.getCaracByName('chance-actuelle'), surprise: '' },
|
|
callbackAction: r => this._appelChanceResult(r, onSuccess, onEchec)
|
|
});
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async _appelChanceResult(rollData, onSuccess, onEchec) {
|
|
await RdDResolutionTable.displayRollData(rollData, this, 'chat-resultat-appelchance.html')
|
|
if (rollData.rolled.isSuccess) {
|
|
await this.setFlag(SYSTEM_RDD, 'utilisationChance', true);
|
|
await this.chanceActuelleIncDec(-1);
|
|
onSuccess();
|
|
}
|
|
else {
|
|
onEchec();
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async chanceActuelleIncDec(value) {
|
|
const chance = Math.min(this.getChance(), Math.max(this.getChanceActuel() + value, 0));
|
|
await this.updateCompteurValue("chance", chance);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async appelDestinee(onSuccess = () => { }, onEchec = () => { }) {
|
|
let destinee = this.system.compteurs.destinee?.value ?? 0;
|
|
if (destinee > 0) {
|
|
ChatMessage.create({ content: `<span class="rdd-roll-part">${this.name} a fait appel à la Destinée !</span>` });
|
|
destinee--;
|
|
await this.updateCompteurValue("destinee", destinee);
|
|
onSuccess();
|
|
}
|
|
else {
|
|
onEchec();
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
getHeureNaissance() {
|
|
if (this.isPersonnage()) {
|
|
return this.system.heure;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
ajustementAstrologique() {
|
|
if (this.isCreatureEntite()) {
|
|
return 0;
|
|
}
|
|
// selon l'heure de naissance...
|
|
return game.system.rdd.calendrier.getAjustementAstrologique(this.system.heure, this.name)
|
|
}
|
|
/* -------------------------------------------- */
|
|
checkDesirLancinant() {
|
|
let queue = this.filterItems(it => it.type == 'queue' || it.type == 'ombre')
|
|
.filter(it => it.system.categorie == 'lancinant');
|
|
return (queue.length > 0);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async _appliquerExperience(rolled, caracName, competence, jetResistance) {
|
|
if (!this.isPersonnage()) return;
|
|
// Pas d'XP
|
|
if (!rolled.isPart || rolled.finalLevel >= 0) {
|
|
return undefined;
|
|
}
|
|
if (this.checkDesirLancinant()) {
|
|
// Cas de désir lancinant, pas d'expérience sur particulière
|
|
ChatMessage.create({
|
|
content: `Vous souffrez au moins d'un Désir Lancinant, vous ne pouvez pas gagner d'expérience sur une Particulière tant que le désir n'est pas assouvi`,
|
|
whisper: ChatMessage.getWhisperRecipients(this.name)
|
|
});
|
|
return undefined;
|
|
}
|
|
if (caracName == 'Vie') caracName = 'constitution';
|
|
if (caracName == 'derobee') caracName = 'agilite';
|
|
if (caracName == 'reve-actuel') caracName = 'reve';
|
|
let xp = Math.abs(rolled.finalLevel);
|
|
// impair: arrondi inférieur en carac
|
|
let xpCarac = competence ? Math.floor(xp / 2) : Math.max(Math.floor(xp / 2), 1);
|
|
|
|
const xpCompetence = competence ? xp - xpCarac : 0;
|
|
if (jetResistance) {
|
|
const message = `Jet de résistance ${jetResistance}, l'expérience est limitée à 1`;
|
|
ui.notifications.info(message);
|
|
console.log(message)
|
|
// max 1 xp sur jets de résistance
|
|
xpCarac = Math.min(1, xpCarac);
|
|
}
|
|
let xpData = { alias: this.name, caracName, xpCarac, competence, xpCompetence };
|
|
|
|
await this._xpCompetence(xpData);
|
|
await this._xpCarac(xpData);
|
|
return xpData;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async _xpCompetence(xpData) {
|
|
if (xpData.competence) {
|
|
const from = Number(xpData.competence.system.xp);
|
|
const to = from + xpData.xpCompetence;
|
|
let update = { _id: xpData.competence._id, 'system.xp': to };
|
|
await this.updateEmbeddedDocuments('Item', [update]);
|
|
xpData.checkComp = await this.checkCompetenceXP(xpData.competence.name, undefined, false);
|
|
await ExperienceLog.add(this, XP_TOPIC.XP, from, to, xpData.competence.name);
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async _xpCarac(xpData) {
|
|
if (xpData.xpCarac > 0) {
|
|
let carac = duplicate(this.system.carac);
|
|
let selectedCarac = RdDActor._findCaracByName(carac, xpData.caracName);
|
|
if (!selectedCarac.derivee) {
|
|
const from = Number(selectedCarac.xp);
|
|
const to = from + xpData.xpCarac;
|
|
selectedCarac.xp = to;
|
|
await this.update({ "system.carac": carac });
|
|
xpData.checkCarac = await this.checkCaracXP(selectedCarac.label, false);
|
|
await ExperienceLog.add(this, XP_TOPIC.XPCARAC, from, to, xpData.caracName);
|
|
} else {
|
|
xpData.caracRepartitionManuelle = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async resetNombresAstraux() {
|
|
const deletions = this.itemTypes['nombreastral'].map(it => it._id);
|
|
await this.deleteEmbeddedDocuments("Item", deletions);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async ajouteNombreAstral(callData) {
|
|
const indexDate = Number.parseInt(callData.date);
|
|
// Ajout du nombre astral
|
|
const item = {
|
|
name: "Nombre Astral", type: "nombreastral", system:
|
|
{
|
|
value: callData.nbAstral,
|
|
istrue: callData.isvalid,
|
|
jourindex: indexDate,
|
|
jourlabel: RdDTimestamp.formatIndexDate(indexDate)
|
|
}
|
|
};
|
|
await this.createEmbeddedDocuments("Item", [item]);
|
|
game.system.rdd.calendrier.notifyChangeNombresAstraux();
|
|
}
|
|
|
|
async supprimerAnciensNombresAstraux() {
|
|
const calendrier = game.system.rdd.calendrier;
|
|
if (calendrier) {
|
|
const toDelete = this.itemTypes['nombreastral']
|
|
.filter(it => calendrier.isAfterIndexDate(it.system.jourindex))
|
|
.map(it => it._id);
|
|
await this.deleteEmbeddedDocuments("Item", toDelete);
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async astrologieNombresAstraux() {
|
|
await this.supprimerAnciensNombresAstraux();
|
|
await AppAstrologie.create(this);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
getCaracByName(name) {
|
|
switch (Grammar.toLowerCaseNoAccent(name)) {
|
|
case 'reve-actuel': case 'reve actuel':
|
|
return this.getCaracReveActuel();
|
|
case 'chance-actuelle': case 'chance-actuelle':
|
|
return this.getCaracChanceActuelle();
|
|
}
|
|
return RdDActor._findCaracByName(this.system.carac, name);
|
|
}
|
|
|
|
getCaracChanceActuelle() {
|
|
return {
|
|
label: 'Chance actuelle',
|
|
value: this.getChanceActuel(),
|
|
type: "number"
|
|
};
|
|
}
|
|
|
|
getCaracReveActuel() {
|
|
return {
|
|
label: 'Rêve actuel',
|
|
value: this.getReveActuel(),
|
|
type: "number"
|
|
};
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
static _findCaracByName(carac, name) {
|
|
name = Grammar.toLowerCaseNoAccent(name);
|
|
switch (name) {
|
|
case 'reve-actuel': case 'reve actuel':
|
|
return carac.reve;
|
|
case 'chance-actuelle': case 'chance actuelle':
|
|
return carac.chance;
|
|
}
|
|
|
|
const caracList = Object.entries(carac);
|
|
let entry = Misc.findFirstLike(name, caracList, { mapper: it => it[0], description: 'caractéristique' });
|
|
if (!entry || entry.length == 0) {
|
|
entry = Misc.findFirstLike(name, caracList, { mapper: it => it[1].label, description: 'caractéristique' });
|
|
}
|
|
return entry && entry.length > 0 ? carac[entry[0]] : undefined;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
countMonteeLaborieuse() { // Return +1 par queue/ombre/souffle Montée Laborieuse présente
|
|
let countMonteeLaborieuse = EffetsDraconiques.countMonteeLaborieuse(this);
|
|
if (countMonteeLaborieuse > 0) {
|
|
ChatMessage.create({
|
|
content: `Vous êtes sous le coup d'une Montée Laborieuse : vos montées en TMR coûtent ${countMonteeLaborieuse} Point de Rêve de plus.`,
|
|
whisper: ChatMessage.getWhisperRecipients(this.name)
|
|
});
|
|
}
|
|
return countMonteeLaborieuse;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
refreshTMRView() {
|
|
if (this.tmrApp) {
|
|
this.tmrApp.externalRefresh();
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async displayTMR(mode = "normal") {
|
|
if (this.tmrApp) {
|
|
ui.notifications.warn("Vous êtes déja dans les TMR....");
|
|
this.tmrApp.forceTMRDisplay();
|
|
return
|
|
}
|
|
if (mode != 'visu' && this.getEffect(STATUSES.StatusDemiReve)) {
|
|
ui.notifications.warn("Le joueur ou le MJ est déja dans les Terres Médianes avec ce personnage ! Visualisation uniquement");
|
|
mode = "visu"; // bascule le mode en visu automatiquement
|
|
}
|
|
RdDConfirm.confirmer({
|
|
bypass: mode == 'visu',
|
|
settingConfirmer: "confirmation-tmr",
|
|
content: `<p>Voulez vous monter dans les TMR en mode ${mode}?</p>`,
|
|
title: 'Confirmer la montée dans les TMR',
|
|
buttonLabel: 'Monter dans les TMR',
|
|
onAction: async () => await this._doDisplayTMR(mode)
|
|
});
|
|
}
|
|
|
|
async _doDisplayTMR(mode) {
|
|
let isRapide = mode == "rapide";
|
|
if (mode != "visu") {
|
|
let minReveValue = (isRapide && !EffetsDraconiques.isDeplacementAccelere(this) ? 3 : 2) + this.countMonteeLaborieuse();
|
|
if (this.getReveActuel() < minReveValue) {
|
|
ChatMessage.create({
|
|
content: `Vous n'avez les ${minReveValue} Points de Reve nécessaires pour monter dans les Terres Médianes`,
|
|
whisper: ChatMessage.getWhisperRecipients(this.name)
|
|
});
|
|
return;
|
|
}
|
|
await this.setEffect(STATUSES.StatusDemiReve, true);
|
|
}
|
|
|
|
const fatigue = this.system.sante.fatigue.value;
|
|
const endurance = this.system.sante.endurance.max;
|
|
let tmrFormData = {
|
|
mode: mode,
|
|
fatigue: RdDUtility.calculFatigueHtml(fatigue, endurance),
|
|
draconic: this.getDraconicList(),
|
|
sort: this.itemTypes['sort'],
|
|
signes: this.itemTypes['signedraconique'],
|
|
caracReve: this.system.carac.reve.value,
|
|
pointsReve: this.getReveActuel(),
|
|
isRapide: isRapide,
|
|
isGM: game.user.isGM,
|
|
hasPlayerOwner: this.hasPlayerOwner
|
|
}
|
|
|
|
this.tmrApp = await RdDTMRDialog.create(this, tmrFormData);
|
|
this.tmrApp.render(true);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
getArmeCompetence(arme, competenceName) {
|
|
let comp = arme.system[competenceName]
|
|
if (!comp || comp.name == "") {
|
|
comp = arme.system[competenceName]
|
|
}
|
|
if ( !comp || comp.name == "") {
|
|
comp = arme.system[competenceName]
|
|
}
|
|
return comp
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
rollArme(arme, competenceName = "competence") {
|
|
let compToUse = this.getArmeCompetence(arme, competenceName)
|
|
if (!Targets.hasTargets()) {
|
|
RdDConfirm.confirmer({
|
|
settingConfirmer: "confirmer-combat-sans-cible",
|
|
content: `<p>Voulez vous faire un jet de compétence ${competenceName} sans choisir de cible valide?
|
|
<br>Tous les jets de combats devront être gérés à la main
|
|
</p>`,
|
|
title: 'Ne pas utiliser les automatisation de combat',
|
|
buttonLabel: "Pas d'automatisation",
|
|
onAction: async () => {
|
|
this.rollCompetence(compToUse, { tryTarget: false })
|
|
}
|
|
});
|
|
return;
|
|
}
|
|
|
|
Targets.selectOneToken(target => {
|
|
if (Targets.isTargetEntite(target)) {
|
|
ui.notifications.warn(`Vous ne pouvez pas attaquer une entité non incarnée avec votre ${arme.name}!!!!`);
|
|
return;
|
|
}
|
|
|
|
const competence = this.getCompetence(compToUse)
|
|
//console.log("RollArme", competence, arme)
|
|
if (competence.isCompetencePossession()) {
|
|
return RdDPossession.onAttaquePossession(target, this, competence);
|
|
}
|
|
RdDCombat.rddCombatTarget(target, this).attaque(competence, arme);
|
|
})
|
|
}
|
|
|
|
async rollSoins(blesse, blessureId) {
|
|
const blessure = blesse.blessuresASoigner().find(it => it.id == blessureId);
|
|
if (blessure) {
|
|
if (!blessure.system.premierssoins.done) {
|
|
const tache = await this.getTacheBlessure(blesse, blessure);
|
|
return await this.rollTache(tache.id, {
|
|
onRollAutomate: async r => blesse.onRollTachePremiersSoins(blessureId, r)
|
|
});
|
|
}
|
|
if (!blessure.system.soinscomplets.done) {
|
|
const diff = blessure.system.difficulte + (blessure.system.premierssoins.bonus ?? 0);
|
|
return await this.rollCaracCompetence("dexterite", "Chirurgie", diff, {
|
|
title: "Soins complets",
|
|
onRollAutomate: r => blesse.onRollSoinsComplets(blessureId, r)
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
async onRollTachePremiersSoins(blessureId, rollData) {
|
|
if (!this.isOwner) {
|
|
return RdDBaseActor.remoteActorCall({ tokenId: this.token?.id, actorId: this.id, method: 'onRollTachePremiersSoins', args: [blessureId, rollData] });
|
|
}
|
|
const blessure = this.getItem(blessureId, 'blessure')
|
|
console.log('TODO update blessure', this, blessureId, rollData, rollData.tache);
|
|
if (blessure && !blessure.system.premierssoins.done) {
|
|
const tache = rollData.tache;
|
|
if (rollData.rolled.isETotal) {
|
|
await blessure.update({
|
|
'system.difficulte': blessure.system.difficulte - 1,
|
|
'system.premierssoins.tache': Math.max(0, tache.system.points_de_tache_courant)
|
|
})
|
|
}
|
|
else {
|
|
const bonus = tache.system.points_de_tache_courant - tache.system.points_de_tache
|
|
await blessure.update({
|
|
'system.premierssoins': {
|
|
done: (bonus >= 0),
|
|
bonus: Math.max(0, bonus),
|
|
tache: Math.max(0, tache.system.points_de_tache_courant)
|
|
}
|
|
})
|
|
if (bonus >= 0) {
|
|
await this.deleteEmbeddedDocuments('Item', [tache.id])
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
async onRollSoinsComplets(blessureId, rollData) {
|
|
if (!this.isOwner) {
|
|
return RdDBaseActor.remoteActorCall({ tokenId: this.token?.id, actorId: this.id, method: 'onRollSoinsComplets', args: [blessureId, rollData] });
|
|
}
|
|
const blessure = this.getItem(blessureId, 'blessure')
|
|
if (blessure && blessure.system.premierssoins.done && !blessure.system.soinscomplets.done) {
|
|
// TODO: update de la blessure: passer par le MJ!
|
|
if (rollData.rolled.isETotal) {
|
|
await blessure.setSoinsBlessure({
|
|
difficulte: blessure.system.difficulte - 1,
|
|
premierssoins: { done: false, bonus: 0 }, soinscomplets: { done: false, bonus: 0 },
|
|
})
|
|
}
|
|
else {
|
|
// soins complets finis
|
|
await blessure.setSoinsBlessure({
|
|
soinscomplets: { done: true, bonus: Math.max(0, rollData.rolled.ptTache) },
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
conjurerPossession(possession) {
|
|
RdDPossession.onConjurerPossession(this, possession)
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
getArmeParade(armeParadeId) {
|
|
const item = armeParadeId ? this.getEmbeddedDocument('Item', armeParadeId) : undefined;
|
|
return RdDItemArme.getArme(item);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
verifierForceMin(item) {
|
|
if (item.type == 'arme' && item.system.force > this.system.carac.force.value) {
|
|
ChatMessage.create({
|
|
content: `<strong>${this.name} s'est équipé(e) de l'arme ${item.name}, mais n'a pas une force suffisante pour l'utiliser normalement </strong>
|
|
(${item.system.force} nécessaire pour une Force de ${this.system.carac.force.value})`
|
|
});
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async equiperObjet(itemID) {
|
|
let item = this.getEmbeddedDocument('Item', itemID);
|
|
if (item?.isEquipable()) {
|
|
const isEquipe = !item.system.equipe;
|
|
await this.updateEmbeddedDocuments('Item', [{ _id: item.id, "system.equipe": isEquipe }]);
|
|
this.computeEncTotal(); // Mise à jour encombrement
|
|
if (isEquipe)
|
|
this.verifierForceMin(item);
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async computeArmure(attackerRoll) {
|
|
let dmg = (attackerRoll.dmg.dmgArme ?? 0) + (attackerRoll.dmg.dmgActor ?? 0);
|
|
let armeData = attackerRoll.arme;
|
|
let protection = 0;
|
|
const armures = this.items.filter(it => it.type == "armure" && it.system.equipe);
|
|
for (const armure of armures) {
|
|
protection += await RdDDice.rollTotal(armure.system.protection.toString());
|
|
if (dmg > 0 && attackerRoll.dmg.encaisserSpecial != "noarmure") {
|
|
armure.deteriorerArmure(dmg);
|
|
dmg = 0;
|
|
}
|
|
}
|
|
const penetration = Misc.toInt(armeData?.system.penetration ?? 0);
|
|
protection = Math.max(protection - penetration, 0);
|
|
protection += this.getProtectionNaturelle();
|
|
// Gestion des cas particuliers sur la fenêtre d'encaissement
|
|
if (attackerRoll.dmg.encaisserSpecial == "noarmure") {
|
|
protection = 0;
|
|
}
|
|
if (attackerRoll.dmg.encaisserSpecial == "chute") {
|
|
protection = Math.min(protection, 2);
|
|
}
|
|
console.log("Final protect", protection, attackerRoll);
|
|
return protection;
|
|
}
|
|
|
|
|
|
/* -------------------------------------------- */
|
|
async encaisser() {
|
|
await RdDEncaisser.encaisser(this);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async encaisserDommages(rollData, attacker = undefined, show = undefined) {
|
|
if (attacker && !await attacker.accorder(this, 'avant-encaissement')) {
|
|
return;
|
|
}
|
|
const attackerId = attacker?.id;
|
|
if (ReglesOptionnelles.isUsing('validation-encaissement-gr') && !game.user.isGM) {
|
|
RdDBaseActor.remoteActorCall({
|
|
tokenId: this.token?.id,
|
|
actorId: this.id,
|
|
method: 'appliquerEncaissement',
|
|
args: [rollData, show, attackerId]
|
|
});
|
|
return;
|
|
}
|
|
await this.appliquerEncaissement(rollData, show, attackerId);
|
|
}
|
|
|
|
async appliquerEncaissement(rollData, show, attackerId) {
|
|
const armure = await this.computeArmure(rollData);
|
|
if (ReglesOptionnelles.isUsing('validation-encaissement-gr')) {
|
|
DialogValidationEncaissement.validerEncaissement(this, rollData, armure, show, attackerId, (encaissement, show, attackerId) => this._appliquerEncaissement(encaissement, show, attackerId));
|
|
}
|
|
else {
|
|
let encaissement = await RdDUtility.jetEncaissement(rollData, armure, { showDice: SHOW_DICE });
|
|
await this._appliquerEncaissement(encaissement, show, attackerId);
|
|
}
|
|
}
|
|
|
|
async _appliquerEncaissement(encaissement, show, attackedId) {
|
|
const attacker = attackedId ? game.actors.get(attackedId) : undefined
|
|
let santeOrig = duplicate(this.system.sante);
|
|
|
|
const blessure = await this.ajouterBlessure(encaissement, attacker); // Will update the result table
|
|
const perteVie = this.isEntite()
|
|
? { newValue: 0 }
|
|
: await this.santeIncDec("vie", -encaissement.vie);
|
|
const perteEndurance = await this.santeIncDec("endurance", -encaissement.endurance, blessure?.isCritique());
|
|
|
|
mergeObject(encaissement, {
|
|
alias: this.name,
|
|
hasPlayerOwner: this.hasPlayerOwner,
|
|
resteEndurance: this.system.sante.endurance.value,
|
|
sonne: perteEndurance.sonne,
|
|
jetEndurance: perteEndurance.jetEndurance,
|
|
endurance: santeOrig.endurance.value - perteEndurance.newValue,
|
|
vie: this.isEntite() ? 0 : (santeOrig.vie.value - perteVie.newValue),
|
|
blessure: blessure,
|
|
show: show ?? {}
|
|
});
|
|
|
|
await ChatUtility.createChatWithRollMode(this.name, {
|
|
roll: encaissement.roll,
|
|
content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-resultat-encaissement.html', encaissement)
|
|
});
|
|
|
|
if (!encaissement.hasPlayerOwner && encaissement.endurance != 0) {
|
|
encaissement = duplicate(encaissement);
|
|
encaissement.isGM = true;
|
|
ChatMessage.create({
|
|
whisper: ChatMessage.getWhisperRecipients("GM"),
|
|
content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-resultat-encaissement.html', encaissement)
|
|
});
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async ajouterBlessure(encaissement, attacker = undefined) {
|
|
if (this.isEntite()) return; // Une entité n'a pas de blessures
|
|
if (encaissement.gravite < 0) return;
|
|
if (encaissement.gravite > 0) {
|
|
while (this.countBlessures(it => it.system.gravite == encaissement.gravite) >= RdDItemBlessure.maxBlessures(encaissement.gravite) && encaissement.gravite <= 6) {
|
|
// Aggravation
|
|
encaissement.gravite += 2
|
|
if (encaissement.gravite > 2) {
|
|
encaissement.vie += 2;
|
|
}
|
|
}
|
|
}
|
|
const endActuelle = Number(this.system.sante.endurance.value);
|
|
const blessure = await RdDItemBlessure.createBlessure(this, encaissement.gravite, encaissement.dmg.loc.label, attacker);
|
|
if (blessure.isCritique()) {
|
|
encaissement.endurance = endActuelle;
|
|
}
|
|
|
|
if (blessure.isMort()) {
|
|
this.setEffect(STATUSES.StatusComma, true);
|
|
encaissement.mort = true;
|
|
ChatMessage.create({
|
|
content: `<img class="chat-icon" src="icons/svg/skull.svg" alt="charge" />
|
|
<strong>${this.name} vient de succomber à une seconde blessure critique ! Que les Dragons gardent son Archétype en paix !</strong>`
|
|
});
|
|
}
|
|
return blessure;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
/** @override */
|
|
getRollData() {
|
|
const rollData = super.getRollData();
|
|
return rollData;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async resetItemUse() {
|
|
await this.unsetFlag(SYSTEM_RDD, 'itemUse');
|
|
await this.setFlag(SYSTEM_RDD, 'itemUse', {});
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async incDecItemUse(itemId, inc = 1) {
|
|
let itemUse = duplicate(this.getFlag(SYSTEM_RDD, 'itemUse') ?? {});
|
|
itemUse[itemId] = (itemUse[itemId] ?? 0) + inc;
|
|
await this.setFlag(SYSTEM_RDD, 'itemUse', itemUse);
|
|
console.log("ITEM USE INC", inc, itemUse);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
getItemUse(itemId) {
|
|
let itemUse = this.getFlag(SYSTEM_RDD, 'itemUse') ?? {};
|
|
console.log("ITEM USE GET", itemUse);
|
|
return itemUse[itemId] ?? 0;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
/* -- entites -- */
|
|
/* retourne true si on peut continuer, false si on ne peut pas continuer */
|
|
async targetEntiteNonAccordee(target, when = 'avant-encaissement') {
|
|
if (target) {
|
|
return !await this.accorder(target.actor, when);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async accorder(entite, when = 'avant-encaissement') {
|
|
if (when != game.settings.get(SYSTEM_RDD, "accorder-entite-cauchemar")
|
|
|| entite == undefined
|
|
|| !entite.isEntite([ENTITE_INCARNE])
|
|
|| entite.isEntiteAccordee(this)) {
|
|
return true;
|
|
}
|
|
const rolled = await RdDResolutionTable.roll(this.getReveActuel(), - Number(entite.system.carac.niveau.value));
|
|
const rollData = {
|
|
alias: this.name,
|
|
rolled: rolled,
|
|
entite: entite.name,
|
|
selectedCarac: this.system.carac.reve
|
|
};
|
|
|
|
if (rolled.isSuccess) {
|
|
await entite.setEntiteReveAccordee(this);
|
|
}
|
|
|
|
await RdDResolutionTable.displayRollData(rollData, this, 'chat-resultat-accorder-cauchemar.html');
|
|
if (rolled.isPart) {
|
|
await this.appliquerAjoutExperience(rollData, true);
|
|
}
|
|
return rolled.isSuccess;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
isEntite(typeentite = []) {
|
|
return this.type == 'entite' && (typeentite.length == 0 || typeentite.includes(this.system.definition.typeentite));
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
isEntiteAccordee(attaquant) {
|
|
if (!this.isEntite([ENTITE_INCARNE])) { return true; }
|
|
let resonnance = this.system.sante.resonnance;
|
|
return (resonnance.actors.find(it => it == attaquant.id));
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async setEntiteReveAccordee(attaquant) {
|
|
if (!this.isEntite([ENTITE_INCARNE])) {
|
|
ui.notifications.error("Impossible de s'accorder à " + this.name + ": ce n'est pas une entite de cauchemer/rêve");
|
|
return;
|
|
}
|
|
let resonnance = duplicate(this.system.sante.resonnance);
|
|
if (resonnance.actors.find(it => it == attaquant.id)) {
|
|
// déjà accordé
|
|
return;
|
|
}
|
|
resonnance.actors.push(attaquant.id);
|
|
await this.update({ "system.sante.resonnance": resonnance });
|
|
return;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async effectuerTacheAlchimie(recetteId, tacheAlchimie, texteTache) {
|
|
let recetteData = this.findItemLike(recetteId, 'recettealchimique');
|
|
if (recetteData) {
|
|
if (tacheAlchimie != "couleur" && tacheAlchimie != "consistance") {
|
|
ui.notifications.warn(`L'étape alchimique ${tacheAlchimie} - ${texteTache} est inconnue`);
|
|
return;
|
|
}
|
|
|
|
const sansCristal = tacheAlchimie == "couleur" && this.items.filter(it => it.isCristalAlchimique()).length == 0;
|
|
const caracTache = RdDAlchimie.getCaracTache(tacheAlchimie);
|
|
const alchimieData = this.getCompetence("alchimie");
|
|
|
|
let rollData = {
|
|
recette: recetteData,
|
|
carac: { [caracTache]: this.system.carac[caracTache] },
|
|
selectedCarac: this.system.carac[caracTache],
|
|
competence: alchimieData,
|
|
diffLibre: RdDAlchimie.getDifficulte(texteTache),
|
|
diffConditions: sansCristal ? -4 : 0,
|
|
alchimie: {
|
|
tache: Misc.upperFirst(tacheAlchimie),
|
|
texte: texteTache,
|
|
sansCristal: sansCristal
|
|
}
|
|
}
|
|
rollData.competence.system.defaut_carac = caracTache;
|
|
|
|
const dialog = await RdDRoll.create(this, rollData,
|
|
{ html: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-alchimie.html' },
|
|
{
|
|
name: 'tache-alchimique',
|
|
label: 'Tache Alchimique',
|
|
callbacks: [
|
|
this.createCallbackExperience(),
|
|
this.createCallbackAppelAuMoral(),
|
|
{ action: async r => await this._alchimieResult(r, false) }
|
|
]
|
|
}
|
|
);
|
|
dialog.render(true);
|
|
}
|
|
}
|
|
|
|
isCristalAlchimique(it) {
|
|
return it.type == 'objet' && Grammar.toLowerCaseNoAccent(it.name) == 'cristal alchimique' && it.system.quantite > 0;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async _alchimieResult(rollData) {
|
|
await RdDResolutionTable.displayRollData(rollData, this, 'chat-resultat-alchimie.html');
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
listeVehicules() {
|
|
const listeVehichules = this.system.subacteurs?.vehicules ?? [];
|
|
return this._buildActorLinksList(listeVehichules, vehicle => RdDActor._vehicleData(vehicle));
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
listeSuivants() {
|
|
return this._buildActorLinksList(this.system.subacteurs?.suivants ?? []);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
listeMontures() {
|
|
return this._buildActorLinksList(this.system.subacteurs?.montures ?? []);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
_buildActorLinksList(links, actorTransformation = it => RdDActor._buildActorData(it)) {
|
|
return links.map(link => game.actors.get(link.id))
|
|
.filter(it => it != undefined)
|
|
.map(actorTransformation);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
static _vehicleData(vehicle) {
|
|
return {
|
|
id: vehicle.id,
|
|
name: vehicle.name,
|
|
img: vehicle.img,
|
|
system: {
|
|
categorie: vehicle.system.categorie,
|
|
etat: vehicle.system.etat
|
|
}
|
|
};
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
static _buildActorData(it) {
|
|
return { id: it.id, name: it.name, img: it.img };
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async pushSubacteur(actor, dataArray, dataPath, dataName) {
|
|
let alreadyPresent = dataArray.find(attached => attached.id == actor._id);
|
|
if (!alreadyPresent) {
|
|
let newArray = duplicate(dataArray);
|
|
newArray.push({ id: actor._id });
|
|
await this.update({ [dataPath]: newArray });
|
|
} else {
|
|
ui.notifications.warn(dataName + " est déja attaché à ce Personnage.");
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
addSubActeur(subActor) {
|
|
if (subActor?.id == this.id) {
|
|
ui.notifications.warn("Vous ne pouvez pas attacher un acteur à lui même")
|
|
}
|
|
else if (!subActor?.isOwner) {
|
|
ui.notifications.warn("Vous n'avez pas les droits sur l'acteur que vous attachez.")
|
|
}
|
|
else {
|
|
if (subActor.type == 'vehicule') {
|
|
this.pushSubacteur(subActor, this.system.subacteurs.vehicules, 'system.subacteurs.vehicules', 'Ce Véhicule');
|
|
} else if (subActor.type == 'creature') {
|
|
this.pushSubacteur(subActor, this.system.subacteurs.montures, 'system.subacteurs.montures', 'Cette Monture');
|
|
} else if (subActor.type == 'personnage') {
|
|
this.pushSubacteur(subActor, this.system.subacteurs.suivants, 'system.subacteurs.suivants', 'Ce Suivant');
|
|
}
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async removeSubacteur(actorId) {
|
|
let newVehicules = this.system.subacteurs.vehicules.filter(function (obj, index, arr) { return obj.id != actorId });
|
|
let newSuivants = this.system.subacteurs.suivants.filter(function (obj, index, arr) { return obj.id != actorId });
|
|
let newMontures = this.system.subacteurs.montures.filter(function (obj, index, arr) { return obj.id != actorId });
|
|
await this.update({ 'system.subacteurs.vehicules': newVehicules }, { renderSheet: false });
|
|
await this.update({ 'system.subacteurs.suivants': newSuivants }, { renderSheet: false });
|
|
await this.update({ 'system.subacteurs.montures': newMontures }, { renderSheet: false });
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async buildPotionGuerisonList(pointsGuerison) {
|
|
const pointsGuerisonInitial = pointsGuerison;
|
|
const blessures = this.filterItems(it => it.system.gravite > 0, 'blessure').sort(Misc.descending(it => it.system.gravite))
|
|
const ids = []
|
|
const guerisonData = { list: [], pointsConsommes: 0 }
|
|
for (let blessure of blessures) {
|
|
if (pointsGuerison >= blessure.system.gravite) {
|
|
pointsGuerison -= blessure.system.gravite;
|
|
guerisonData.list.push(`1 Blessure ${blessure.system.label} (${blessure.system.gravite} points)`);
|
|
ids.push(blessure.id)
|
|
}
|
|
}
|
|
if (ids.length > 0) {
|
|
await this.supprimerBlessures(it => ids.includes(it.id));
|
|
}
|
|
if (blessures.length == ids.length) {
|
|
let pvManquants = this.system.sante.vie.max - this.system.sante.vie.value;
|
|
let pvSoignees = Math.min(pvManquants, Math.floor(pointsGuerison / 2));
|
|
pointsGuerison -= pvSoignees * 2;
|
|
guerisonData.list.push(pvSoignees + " Points de Vie soignés");
|
|
await this.santeIncDec('vie', +pvSoignees, false);
|
|
}
|
|
guerisonData.pointsConsommes = pointsGuerisonInitial - pointsGuerison;
|
|
return guerisonData;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async consommerPotionSoin(potionData) {
|
|
potionData.alias = this.name;
|
|
potionData.supprimer = true;
|
|
|
|
if (potionData.system.magique) {
|
|
// Gestion de la résistance:
|
|
potionData.rolled = await RdDResolutionTable.roll(this.getReveActuel(), -8);
|
|
if (potionData.rolled.isEchec) {
|
|
await this.reveActuelIncDec(-1);
|
|
potionData.guerisonData = await this.buildPotionGuerisonList(potionData.system.puissance);
|
|
potionData.guerisonMinutes = potionData.guerisonData.pointsConsommes * 5;
|
|
}
|
|
}
|
|
if (!potionData.system.magique || potionData.rolled.isSuccess) {
|
|
await this.setBonusPotionSoin(potionData.system.herbebonus);
|
|
}
|
|
ChatMessage.create({
|
|
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
|
|
content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-consommer-potion-soin.html`, potionData)
|
|
});
|
|
}
|
|
|
|
async setBonusPotionSoin(bonus) {
|
|
await this.update({ 'system.sante.bonusPotion': bonus });
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async consommerPotionRepos(potionData) {
|
|
potionData.alias = this.name;
|
|
potionData.supprimer = true;
|
|
|
|
if (potionData.system.magique) {
|
|
// Gestion de la résistance:
|
|
potionData.rolled = await RdDResolutionTable.roll(this.getReveActuel(), -8);
|
|
if (potionData.rolled.isEchec) {
|
|
await this.reveActuelIncDec(-1);
|
|
let fatigueActuelle = this.getFatigueActuelle();
|
|
potionData.caseFatigueReel = Math.min(fatigueActuelle, potionData.system.puissance);
|
|
potionData.guerisonDureeUnite = (potionData.system.reposalchimique) ? "rounds" : "minutes";
|
|
potionData.guerisonDureeValue = (potionData.system.reposalchimique) ? potionData.caseFatigueReel : potionData.caseFatigueReel * 5;
|
|
potionData.aphasiePermanente = false;
|
|
if (potionData.system.reposalchimique) {
|
|
let chanceAphasie = await RdDDice.rollTotal("1d100");
|
|
if (chanceAphasie <= potionData.system.pr) {
|
|
potionData.aphasiePermanente = true;
|
|
}
|
|
}
|
|
await this.santeIncDec("fatigue", -potionData.caseFatigueReel);
|
|
}
|
|
}
|
|
if (!potionData.system.magique || potionData.rolled.isSuccess) {
|
|
this.bonusRepos = potionData.system.herbebonus;
|
|
}
|
|
ChatMessage.create({
|
|
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
|
|
content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-consommer-potion-repos.html`, potionData)
|
|
});
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async fabriquerPotion(herbeData) {
|
|
let newPotion = {
|
|
name: `Potion de ${herbeData.system.categorie} (${herbeData.name})`, type: 'potion',
|
|
img: "systems/foundryvtt-reve-de-dragon/icons/objets/fiole_verre.webp",
|
|
system: {
|
|
quantite: 1, cout: 0, encombrement: 0.1,
|
|
categorie: herbeData.system.categorie,
|
|
herbe: herbeData.name,
|
|
rarete: herbeData.system.rarete,
|
|
herbebrins: herbeData.nbBrins,
|
|
herbebonus: herbeData.herbebonus,
|
|
description: ""
|
|
}
|
|
}
|
|
await this.createEmbeddedDocuments('Item', [newPotion], { renderSheet: true });
|
|
|
|
let newQuantite = herbeData.system.quantite - herbeData.nbBrins;
|
|
let messageData = {
|
|
alias: this.name,
|
|
nbBrinsReste: newQuantite,
|
|
potion: newPotion,
|
|
herbe: herbeData
|
|
}
|
|
this.diminuerQuantiteObjet(herbeData._id, herbeData.nbBrins);
|
|
|
|
ChatMessage.create({
|
|
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
|
|
content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-fabriquer-potion-base.html`, messageData)
|
|
});
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async diminuerQuantiteObjet(id, nb, options = { supprimerSiZero: false }) {
|
|
const item = this.getItem(id);
|
|
if (item) {
|
|
await item.diminuerQuantite(nb, options);
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async consommerPotionGenerique(potionData) {
|
|
potionData.alias = this.name;
|
|
|
|
if (potionData.system.magique) {
|
|
// Gestion de la résistance:
|
|
potionData.rolled = await RdDResolutionTable.roll(this.getReveActuel(), -8);
|
|
if (potionData.rolled.isEchec) {
|
|
await this.reveActuelIncDec(-1);
|
|
}
|
|
}
|
|
ChatMessage.create({
|
|
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
|
|
content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-consommer-potion-generique.html`, potionData)
|
|
});
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async consommerPotion(potion, onActionItem = async () => { }) {
|
|
const potionData = potion
|
|
|
|
if (potionData.system.categorie.includes('Soin')) {
|
|
this.consommerPotionSoin(potionData);
|
|
} else if (potionData.system.categorie.includes('Repos')) {
|
|
this.consommerPotionRepos(potionData);
|
|
} else {
|
|
this.consommerPotionGenerique(potionData);
|
|
}
|
|
await this.diminuerQuantiteObjet(potion.id, 1, { supprimerSiZero: potionData.supprimer });
|
|
await onActionItem()
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async onUpdateActor(update, options, actorId) {
|
|
const updatedEndurance = update?.system?.sante?.endurance
|
|
if (updatedEndurance && options.diff) {
|
|
await this.setEffect(STATUSES.StatusUnconscious, updatedEndurance.value == 0)
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
getEffects(filter = e => true) {
|
|
return this.getEmbeddedCollection("ActiveEffect").filter(filter);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
getEffect(statusId) {
|
|
return this.getEmbeddedCollection("ActiveEffect").find(it => it.flags?.core?.statusId == statusId);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async setEffect(statusId, status) {
|
|
if (this.isEntite() || this.isVehicule()) {
|
|
return;
|
|
}
|
|
console.log("setEffect", statusId, status)
|
|
const effect = this.getEffect(statusId);
|
|
if (!status && effect) {
|
|
await this.deleteEmbeddedDocuments('ActiveEffect', [effect.id]);
|
|
}
|
|
if (status && !effect) {
|
|
await this.createEmbeddedDocuments("ActiveEffect", [StatusEffects.status(statusId)]);
|
|
}
|
|
}
|
|
|
|
async removeEffect(statusId) {
|
|
const effect = this.getEffect(statusId);
|
|
if (effect) {
|
|
await this.deleteEmbeddedDocuments('ActiveEffect', [effect.id]);
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async removeEffects(filter = e => true) {
|
|
if (game.user.isGM) {
|
|
const ids = this.getEffects(filter).map(it => it.id);
|
|
await this.deleteEmbeddedDocuments('ActiveEffect', ids);
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async onPreUpdateItem(item, change, options, id) {
|
|
if (item.isCompetencePersonnage() && item.system.defaut_carac && item.system.xp) {
|
|
await this.checkCompetenceXP(item.name, item.system.xp);
|
|
}
|
|
}
|
|
/* -------------------------------------------- */
|
|
async onCreateItem(item, options, id) {
|
|
switch (item.type) {
|
|
case 'tete':
|
|
case 'queue':
|
|
case 'ombre':
|
|
case 'souffle':
|
|
await this.onCreateOwnedDraconique(item, options, id);
|
|
break;
|
|
}
|
|
await item.onCreateItemTemporel(this);
|
|
await item.onCreateDecoupeComestible(this);
|
|
}
|
|
|
|
async onDeleteItem(item, options, id) {
|
|
switch (item.type) {
|
|
case 'tete':
|
|
case 'queue':
|
|
case 'ombre':
|
|
case 'souffle':
|
|
await this.onDeleteOwnedDraconique(item, options, id);
|
|
break;
|
|
case 'casetmr':
|
|
await this.onDeleteOwnedCaseTmr(item, options, id);
|
|
break;
|
|
case 'empoignade':
|
|
await RdDEmpoignade.deleteLinkedEmpoignade(this.id, item)
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async onCreateOwnedDraconique(item, options, id) {
|
|
if (Misc.isUniqueConnectedGM()) {
|
|
let draconique = Draconique.all().find(it => it.match(item));
|
|
if (draconique) {
|
|
await draconique.onActorCreateOwned(this, item)
|
|
this.notifyGestionTeteSouffleQueue(item, draconique.manualMessage());
|
|
}
|
|
await this.setInfoSommeilInsomnie();
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async onDeleteOwnedDraconique(item, options, id) {
|
|
if (Misc.isUniqueConnectedGM()) {
|
|
let draconique = Draconique.all().find(it => it.match(item));
|
|
if (draconique) {
|
|
await draconique.onActorDeleteOwned(this, item)
|
|
}
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async onDeleteOwnedCaseTmr(item, options, id) {
|
|
if (Misc.isUniqueConnectedGM()) {
|
|
let draconique = Draconique.all().find(it => it.isCase(item));
|
|
if (draconique) {
|
|
await draconique.onActorDeleteCaseTmr(this, item)
|
|
}
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
notifyGestionTeteSouffleQueue(item, manualMessage = true) {
|
|
ChatMessage.create({
|
|
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
|
|
content: `${this.name} a reçu un/une ${item.type}: ${item.name}, qui ${manualMessage ? "n'est pas" : "est"} géré(e) automatiquement. ${manualMessage ? manualMessage : ''}`
|
|
});
|
|
}
|
|
|
|
async nouvelleIncarnation() {
|
|
let incarnation = this.toObject();
|
|
|
|
incarnation.items = Array.from(this.items.filter(it => it.type == TYPES.competence),
|
|
it => {
|
|
it = it.toObject();
|
|
it.id = undefined;
|
|
it.system.niveau = it.system.base;
|
|
it.system.niveau_archetype = Math.max(it.system.niveau + (it.system.xp > 0 ? 1 : 0), it.system.niveau_archetype);
|
|
it.system.xp = 0;
|
|
it.system.xp_sort = 0;
|
|
it.system.default_diffLibre = 0;
|
|
return it;
|
|
});
|
|
|
|
incarnation.name = 'Réincarnation de ' + incarnation.name
|
|
incarnation.system = {
|
|
carac: duplicate(this.system.carac),
|
|
heure: RdDTimestamp.defHeure(await RdDDice.rollTotal("1dh", { rollMode: "selfroll", showDice: SHOW_DICE })).key,
|
|
age: 18,
|
|
biographie: '',
|
|
notes: '',
|
|
experiencelog: [],
|
|
'compteurs.experience.value': 3000,
|
|
'reve.seuil.value': this.system.carac.reve.value,
|
|
'reve.reve.value': this.system.carac.reve.value,
|
|
subacteurs: { suivants: [], montures: [], vehicules: [] },
|
|
}
|
|
incarnation = await RdDBaseActor.create(incarnation);
|
|
await incarnation.deleteEmbeddedDocuments('ActiveEffect', incarnation.getEmbeddedCollection("ActiveEffect").map(it => it.id));
|
|
await incarnation.remiseANeuf();
|
|
incarnation.sheet.render(true);
|
|
}
|
|
}
|
|
|