2021-11-11 09:37:00 +01:00
|
|
|
/* -------------------------------------------- */
|
|
|
|
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-11 09:37:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
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-11 09:37:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
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
|
|
|
}
|
2022-05-14 20:39:01 +02: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-11 09:37:00 +01:00
|
|
|
}
|
2021-11-21 12:04:42 +01:00
|
|
|
|
2021-11-11 09:37:00 +01:00
|
|
|
/* -------------------------------------------- */
|
2022-01-29 18:50:37 +01:00
|
|
|
static async resultConjuration( rollData) {
|
2022-05-14 20:39:01 +02:00
|
|
|
let actor = game.actors.get(rollData.possession.data.possedeid)
|
2022-05-14 17:28:27 +02:00
|
|
|
if ( !rollData.rolled.isSuccess ) {
|
|
|
|
if( rollData.isECNIDefender) {
|
|
|
|
rollData.possession.data.compteur--
|
|
|
|
} else {
|
|
|
|
rollData.possession.data.compteur++
|
|
|
|
}
|
|
|
|
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')
|
2022-05-14 20:39:01 +02:00
|
|
|
if ( rollData.possession.isPosseder || rollData.possession.isConjurer) {
|
|
|
|
actor.deleteEmbeddedDocuments("Item", [rollData.possession._id])
|
|
|
|
}
|
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: [
|
2022-01-29 18:50:37 +01:00
|
|
|
{ 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
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
2022-01-29 18:50:37 +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)
|
2022-01-29 18:50:37 +01:00
|
|
|
await RdDResolutionTable.displayRollData(rollData, this, 'chat-resultat-possession.html');
|
2021-11-11 09:37:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
2022-05-14 17:28:27 +02:00
|
|
|
static async managePossession(attacker, competence, possession=undefined) {
|
2021-11-11 09:37:00 +01:00
|
|
|
|
2022-05-14 17:28:27 +02:00
|
|
|
const target = RdDCombat.getTarget()
|
2021-11-11 09:37:00 +01:00
|
|
|
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-06-25 18:59:20 +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
|
|
|
}
|
2021-11-11 09:37:00 +01:00
|
|
|
}
|
2022-06-25 18:59:20 +02:00
|
|
|
possession = duplicate(possession);
|
2021-11-11 09:37:00 +01:00
|
|
|
|
2022-05-14 17:28:27 +02:00
|
|
|
this.updateEtatPossession(possession)
|
2021-11-11 09:37:00 +01:00
|
|
|
let rollData = {
|
2022-06-25 18:59:20 +02:00
|
|
|
competence: competence.data.data.niveau >=0 ? competence : RdDPossession.competenceNonHautRevant(),
|
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"
|
2021-11-11 09:37:00 +01:00
|
|
|
};
|
|
|
|
if ( attacker.isCreature()) {
|
2022-05-14 17:28:27 +02:00
|
|
|
RdDItemCompetenceCreature.setRollDataCreature(rollData)
|
2021-11-11 09:37:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
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: [
|
2022-01-29 18:50:37 +01:00
|
|
|
{ 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) },
|
2021-11-11 09:37:00 +01:00
|
|
|
]
|
|
|
|
});
|
2022-05-14 17:28:27 +02:00
|
|
|
dialog.render(true)
|
2021-11-11 09:37:00 +01:00
|
|
|
}
|
|
|
|
|
2022-06-25 18:59:20 +02:00
|
|
|
static competenceNonHautRevant() {
|
|
|
|
return {
|
|
|
|
img: 'systems/foundryvtt-reve-de-dragon/icons/competence_vigilance.webp',
|
|
|
|
name: 'non Haut-rêvant',
|
|
|
|
data: {
|
|
|
|
data: {
|
|
|
|
niveau: 0,
|
|
|
|
defaut_carac: "reve",
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2021-11-11 09:37:00 +01:00
|
|
|
/* -------------------------------------------- */
|
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])
|
2021-11-11 09:37:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|