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

190 lines
7.1 KiB
JavaScript
Raw Normal View History

/* -------------------------------------------- */
import { RdDCombat } from "./rdd-combat.js";
import { RdDResolutionTable } from "./rdd-resolution-table.js";
import { RdDRoll } from "./rdd-roll.js";
import { RdDItemCompetenceCreature } from "./item-competencecreature.js";
/* -------------------------------------------- */
/* On part du principe qu'une entité démarre tjs
une possession via le MJ (ie un joueur ne controle pas une entité)
Donc la compétence Possession ne peut être démarrée que par le MJ.
*/
/* -------------------------------------------- */
export class RdDPossession {
/* -------------------------------------------- */
2022-05-14 17:28:27 +02:00
static init() {
}
/* -------------------------------------------- */
2021-11-21 12:04:42 +01:00
static searchPossessionFromEntite( attacker, defender) {
let poss = attacker.data.items.find( poss => poss.type == 'possession' && poss.data.data.possedeid == defender.data._id);
if (!poss) {
poss = defender.data.items.find( poss => poss.type == 'possession' && poss.data.data.possedeid == defender.data._id);
}
return poss && duplicate(poss) || undefined;
}
/* -------------------------------------------- */
2021-11-21 12:04:42 +01:00
static updateEtatPossession( possession ) {
2022-05-14 20:25:47 +02:00
possession.ptsConjuration = 0
possession.ptsPossession = 0
console.log("Possession", possession)
2021-11-21 12:04:42 +01:00
if ( possession.data.compteur > 0) {
2022-05-14 17:28:27 +02:00
possession.ptsPossession = possession.data.compteur
2021-11-21 12:04:42 +01:00
}
if ( possession.data.compteur < 0) {
2022-05-14 17:28:27 +02:00
possession.ptsConjuration = Math.abs(possession.data.compteur)
2021-11-21 12:04:42 +01:00
}
2022-05-14 20:25:47 +02:00
possession.isPosseder = false
possession.isConjurer = false
2021-11-21 12:04:42 +01:00
if (possession.ptsPossession >= 2 ) {
2022-05-14 20:25:47 +02:00
possession.isPosseder = true
2021-11-21 12:04:42 +01:00
}
if (possession.ptsConjuration <= -2 ) {
2022-05-14 20:25:47 +02:00
possession.isConjurer = true
2021-11-21 12:04:42 +01:00
}
}
2021-11-21 12:04:42 +01:00
/* -------------------------------------------- */
static async resultConjuration( rollData) {
2022-05-14 17:28:27 +02:00
console.log("RollData!!!", rollData)
if ( !rollData.rolled.isSuccess ) {
if( rollData.isECNIDefender) {
rollData.possession.data.compteur--
} else {
rollData.possession.data.compteur++
}
let actor = game.actors.get(rollData.possession.data.possedeid)
let update = { _id: rollData.possession._id, "data.compteur": rollData.possession.data.compteur }
2022-05-14 20:25:47 +02:00
await actor.updateEmbeddedDocuments('Item', [update])
2021-11-21 12:04:42 +01:00
}
2022-05-14 17:28:27 +02:00
this.updateEtatPossession(rollData.possession)
await RdDResolutionTable.displayRollData(rollData, this, 'chat-resultat-possession.html')
2021-11-21 12:04:42 +01:00
}
/* -------------------------------------------- */
2022-05-14 17:28:27 +02:00
static async onDefensePossession( attackerId, defenderId, possessionId) {
let attacker = game.actors.get(attackerId)
let defender = game.actors.get(defenderId)
let possession = attacker.items.find( item => item.type =='possession' && item.data.data.possessionid == possessionId)
if ( !possession ) {
possession = defender.items.find( item => item.type =='possession' && item.data.data.possessionid == possessionId)
if ( !possession) {
ui.notifications.warn("Une erreur s'est produite : Aucune possession trouvée !!")
return
}
}
possession = duplicate(possession)
2021-11-21 12:04:42 +01:00
// Update for draconic roll
let rollData = {
possession: possession
}
2022-05-14 17:28:27 +02:00
rollData.actor = defender
if ( defender.type == "personnage") {
rollData.competence = duplicate(defender.getDraconicOrZero())
rollData.competence.data.defaut_carac = 'reve-actuel'
2022-05-14 20:25:47 +02:00
rollData.forceCarac = { 'reve-actuel': { label: "Rêve Actuel", value: defender.getReveActuel() } }
2022-05-14 17:28:27 +02:00
rollData.selectedCarac = defender.data.data.carac.reve
rollData.isECNIDefender = false
} else {
rollData.competence = duplicate(defender.getCompetence("Possession"))
rollData.competence.data.defaut_carac = "reve"
rollData.forceCarac = { 'reve': { label: "Rêve", value: defender.data.data.carac.reve.value } }
rollData.selectedCarac = defender.data.data.carac.reve
rollData.isECNIDefender = true
//RdDItemCompetenceCreature.setRollDataCreature( rollData )
}
rollData.mode = "conjuration"
rollData.possesseur = attacker.name
const dialog = await RdDRoll.create(defender, rollData,
2021-11-21 12:04:42 +01:00
{
html: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-defense-possession.html',
options: { height: 400 }
},
{
name: 'conjurer',
label: 'Conjurer une Possession',
callbacks: [
{ action: async r => await this.resultConjuration(r) }
2021-11-21 12:04:42 +01:00
]
}
);
2022-05-14 17:28:27 +02:00
dialog.render(true)
2021-11-21 12:04:42 +01:00
}
/* -------------------------------------------- */
static async _onRollPossession( rollData, isSuccess ) {
2022-05-14 17:28:27 +02:00
let possession = rollData.possession
possession.isSuccess = isSuccess
this.updateEtatPossession( possession)
await RdDResolutionTable.displayRollData(rollData, this, 'chat-resultat-possession.html');
}
/* -------------------------------------------- */
2022-05-14 17:28:27 +02:00
static async managePossession(attacker, competence, possession=undefined) {
2022-05-14 17:28:27 +02:00
const target = RdDCombat.getTarget()
if (target == undefined) {
ui.notifications.warn((game.user.targets?.size ?? 0) > 1
? "Vous devez choisir <strong>une seule</strong> cible à posséder!"
: "Vous devez choisir une cible à posséder!");
return;
}
2022-05-14 17:28:27 +02:00
const defender = target.actor
2021-11-21 12:04:42 +01:00
if ( !possession) {
2022-05-14 17:28:27 +02:00
possession = this.searchPossessionFromEntite( attacker, defender)
if ( !possession) {
2022-05-14 20:25:47 +02:00
possession = await this.createPossession(attacker, defender)
2022-05-14 17:28:27 +02:00
}
}
2022-05-14 17:28:27 +02:00
possession = duplicate(possession)
2022-05-14 17:28:27 +02:00
this.updateEtatPossession(possession)
let rollData = {
competence: competence,
2021-11-21 12:04:42 +01:00
possession: possession,
possede: defender.name,
possesseur: attacker.name,
attackerId: attacker.data._id,
defenderId: defender.data._id,
mode: "possession"
};
if ( attacker.isCreature()) {
2022-05-14 17:28:27 +02:00
RdDItemCompetenceCreature.setRollDataCreature(rollData)
}
const dialog = await RdDRoll.create( attacker, rollData,
{
html: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-competence.html',
options: { height: 540 }
}, {
name: 'jet-possession',
label: 'Possession: ',
callbacks: [
{ condition: r => (r.rolled.isSuccess), action: async r => await this._onRollPossession(r, true) },
{ condition: r => (r.rolled.isEchec), action: async r => await this._onRollPossession(r, false) },
]
});
2022-05-14 17:28:27 +02:00
dialog.render(true)
}
/* -------------------------------------------- */
2021-11-21 12:04:42 +01:00
static async createPossession( attacker, defender ) {
2022-05-14 17:28:27 +02:00
let possessionData = {
name: "Possession en cours de " + attacker.name, type: 'possession',
2021-11-21 12:04:42 +01:00
img: "systems/foundryvtt-reve-de-dragon/icons/entites/possession2.webp",
2022-05-14 17:28:27 +02:00
data: { description: "", typepossession: attacker.name, possede: false, possessionid: randomID(16), possesseurid: attacker.data._id, possedeid: defender.data._id, date: 0, compteur: 0 }
2021-11-21 12:04:42 +01:00
}
2022-05-14 17:28:27 +02:00
// Creates only the possession on the personnage side
let poss = await defender.createEmbeddedDocuments('Item', [possessionData])
return duplicate(poss[0])
}
}