821 lines
30 KiB
JavaScript
821 lines
30 KiB
JavaScript
/* -------------------------------------------- */
|
|
import { YggdrasillUtility } from "./yggdrasill-utility.js";
|
|
import { YggdrasillRoll } from "./yggdrasill-roll-dialog.js";
|
|
|
|
/* -------------------------------------------- */
|
|
const statusEffects = [
|
|
{ yggdrasill: true, id: 'epuise', label: 'Epuisé', icon: 'icons/svg/stoned.svg' },
|
|
{ yggdrasill: true, id: 'blesse', label: 'Blessé', icon: 'icons/svg/blood.svg' },
|
|
{ yggdrasill: true, id: 'meurtri', label: 'Meurtri', icon: 'icons/svg/falling.svg' }
|
|
]
|
|
const armeCategorieToCompetence = { "lutte": "Lutte", "improvisee": "Armes Improvisées", "courte":"Armes courtes", "longue": "Armes longues", "deuxmains": "Armes à deux mains",
|
|
"hast": "Armes d'Hast", "tir": "Armes de tir", "jet": "Lancer" }
|
|
const attackMode = {
|
|
"classique": {
|
|
"categName": "corps",
|
|
"caracName": "agilite",
|
|
"malus": 0,
|
|
"protection": 0,
|
|
"bonusdegats": 0,
|
|
"label": "Attaque Classique",
|
|
"description": "Attaque classique"
|
|
},
|
|
"force": {
|
|
"categName": "corps",
|
|
"caracName": "puissance",
|
|
"malus": 0,
|
|
"protection": 0,
|
|
"bonusdegats": "puissance;1",
|
|
"label": "Attaque en Force",
|
|
"description": "Attaque en Force : Malus: 0, +PUI en dégats"
|
|
},
|
|
"devastatrice": {
|
|
"categName": "corps",
|
|
"caracName": "puissance",
|
|
"malus": "puissance;1",
|
|
"bonusdegats": "puissance;3",
|
|
"protection": 0,
|
|
"label": "Attaque Dévastatrice",
|
|
"description": "Attaque Dévastratrice : Malus -PUI, +PUI*3 en dégats"
|
|
},
|
|
"precise": {
|
|
"categName": "esprit",
|
|
"caracName": "perception",
|
|
"malus": "0",
|
|
"bonusdegats": 0,
|
|
"protection": "perception;1",
|
|
"label": "Attaque Précise",
|
|
"description": "Attaque précise : Malus : 0, protection réduite de -PER"
|
|
},
|
|
"visee": {
|
|
"categName": "esprit",
|
|
"caracName": "perception",
|
|
"malus": "perception;1",
|
|
"bonusdegats": 0,
|
|
"protection": "perception;3",
|
|
"label": "Attaque Visée",
|
|
"description": "Attaque visée : Malus : -PER, protection réduite de -PER"
|
|
}
|
|
}
|
|
const tirMode = {
|
|
"pose": {
|
|
"categName": "corps",
|
|
"caracName": "agilite",
|
|
"malus": 0,
|
|
"protection": 0,
|
|
"bonusdegats": 0,
|
|
"label": "Tir posé",
|
|
"description": "Tir posé"
|
|
},
|
|
"arrettir": {
|
|
"categName": "ame",
|
|
"caracName": "instinct",
|
|
"malus": 0,
|
|
"protection": 0,
|
|
"bonusdegats": "instinct;1",
|
|
"label": "Tir d'Arrêt (Tir)",
|
|
"description": "Tir d'Arrêt (Tir) : Malus: 0, +INS en dégats"
|
|
},
|
|
"arretjet": {
|
|
"categName": "corps",
|
|
"caracName": "puissance",
|
|
"malus": 0,
|
|
"protection": 0,
|
|
"bonusdegats": "puissance;1",
|
|
"label": "Tir d'Arrêt (Jet)",
|
|
"description": "Tir d'Arrêt (Jet) : Malus: 0, +PUI en dégats"
|
|
},
|
|
"impacttir": {
|
|
"categName": "ame",
|
|
"caracName": "instinct",
|
|
"malus": "instinct;1",
|
|
"protection": 0,
|
|
"bonusdegats": "instinct;3",
|
|
"label": "Tir d'Impact (Tir)",
|
|
"description": "Tir d'Impact (Tir) : Malus: -INS, +INS*3 en dégats"
|
|
},
|
|
"impactjet": {
|
|
"categName": "corps",
|
|
"caracName": "puissance",
|
|
"malus": "puissance;1",
|
|
"protection": 0,
|
|
"bonusdegats": "puissance;3",
|
|
"label": "Attaque d'Impact (Jet)",
|
|
"description": "Attaque d'Impact (Jet) : Malus: -PUI, +PUI*3 en dégats"
|
|
},
|
|
"precision": {
|
|
"categName": "esprit",
|
|
"caracName": "perception",
|
|
"malus": "0",
|
|
"bonusdegats": 0,
|
|
"protection": "perception;1",
|
|
"label": "Tir de Précision",
|
|
"description": "Tir de Précision : Malus : 0, protection réduite de -PER"
|
|
},
|
|
"vise": {
|
|
"categName": "esprit",
|
|
"caracName": "perception",
|
|
"malus": "perception;1",
|
|
"bonusdegats": 0,
|
|
"protection": "perception;3",
|
|
"label": "Tir Visée",
|
|
"description": "Tir visée : Malus : -PER, protection réduite de -PER"
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
/* -------------------------------------------- */
|
|
/**
|
|
* Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
|
|
* @extends {Actor}
|
|
*/
|
|
export class YggdrasillActor extends Actor {
|
|
|
|
/* -------------------------------------------- */
|
|
/**
|
|
* Override the create() function to provide additional SoS functionality.
|
|
*
|
|
* This overrided create() function adds initial items
|
|
* Namely: Basic skills, money,
|
|
*
|
|
* @param {Object} data Barebones actor data which this function adds onto.
|
|
* @param {Object} options (Unused) Additional options which customize the creation workflow.
|
|
*
|
|
*/
|
|
|
|
static async create(data, options) {
|
|
|
|
// Case of compendium global import
|
|
if (data instanceof Array) {
|
|
return super.create(data, options);
|
|
}
|
|
// If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
|
|
if (data.items) {
|
|
let actor = super.create(data, options);
|
|
return actor;
|
|
}
|
|
|
|
const competencesGen = await YggdrasillUtility.loadCompendium("fvtt-yggdrasill.competences-generales");
|
|
const competencesMar = await YggdrasillUtility.loadCompendium("fvtt-yggdrasill.competences-martiales");
|
|
const competencesMag = await YggdrasillUtility.loadCompendium("fvtt-yggdrasill.competences-magiques");
|
|
const competences = competencesGen.concat(competencesMar).concat(competencesMag);
|
|
data.items = competences.map(i => i.toObject());
|
|
|
|
return super.create(data, options);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
prepareBaseData() {
|
|
if ( this.type == "personnage") {
|
|
this.computeCaracSecondaire();
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async prepareData() {
|
|
if ( this.type == "personnage") {
|
|
this.computeCaracSecondaire();
|
|
if (this.system.furor.value == 0)
|
|
await this.setEpuise();
|
|
else
|
|
await this.cleanEpuise();
|
|
if ( this.system.caracsecondaire.pv.value < (this.system.caracsecondaire.pv.max/4) )
|
|
await this.setMeurtri();
|
|
else
|
|
await this.cleanMeurtri();
|
|
if ( this.system.caracsecondaire.pv.value < (this.system.caracsecondaire.pv.max/2) )
|
|
await this.setBlesse();
|
|
else
|
|
await this.cleanBlesse();
|
|
}
|
|
super.prepareData();
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
_preUpdate(changed, options, user) {
|
|
if ( changed.system?.caracsecondaire?.pv?.value ) {
|
|
if ( changed.system.caracsecondaire.pv.value < 0 )
|
|
changed.system.caracsecondaire.pv.value = 0;
|
|
if ( changed.system.caracsecondaire.pv.value > this.system.caracsecondaire.pv.max )
|
|
changed.system.caracsecondaire.pv.value = this.system.caracsecondaire.pv.max;
|
|
}
|
|
|
|
if ( changed.system?.furor?.value ) {
|
|
if ( changed.system.furor.value < 0 )
|
|
changed.system.furor.value = 0;
|
|
if ( changed.system.furor.value > this.system.furor.max )
|
|
changed.system.furor.value = this.system.furor.max;
|
|
}
|
|
super._preUpdate(changed, options, user);
|
|
}
|
|
/* -------------------------------------------- */
|
|
getCompetences() {
|
|
let comp = this.items.filter( item => item.type == 'competence');
|
|
return comp;
|
|
}
|
|
/* -------------------------------------------- */
|
|
compareName( a, b) {
|
|
if ( a.name < b.name ) {
|
|
return -1;
|
|
}
|
|
if ( a.name > b.name ) {
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
/* -------------------------------------------- */
|
|
getInitiativeScore() {
|
|
if ( this.type == 'personnage') {
|
|
return this.system.caracsecondaire.reaction.max;
|
|
} else {
|
|
return this.system.attributs.physique.values.defaut.value;
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
getCompetencesGenerales() {
|
|
let comp = this.items.filter( item => item.type == 'competence' && item.system.categorie == 'generale');
|
|
return comp.sort( this.compareName );
|
|
}
|
|
/* -------------------------------------------- */
|
|
getCompetencesMartiales() {
|
|
let comp = this.items.filter( item => item.type == 'competence' && item.system.categorie == 'martiale');
|
|
return comp.sort( this.compareName );
|
|
}
|
|
/* -------------------------------------------- */
|
|
getCompetencesMagiques() {
|
|
let comp = this.items.filter( item => item.type == 'competence' && item.system.categorie == 'magique');
|
|
return comp.sort( this.compareName );
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
getDons( ) {
|
|
let dons = this.items.filter( item => item.type == 'don');
|
|
return dons.sort( this.compareName );
|
|
}
|
|
/* -------------------------------------------- */
|
|
getEffetsMagiques( ) {
|
|
let effets = this.items.filter( item => item.type == 'effetmagique');
|
|
return effets.sort( this.compareName );
|
|
}
|
|
/* -------------------------------------------- */
|
|
getEffetsDeRunes( ) {
|
|
let effets = this.items.filter( item => item.type == 'effetderune');
|
|
return effets.sort( this.compareName );
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
getMonnaies( ) {
|
|
let monnaies = this.items.filter( item => item.type == 'monnaie');
|
|
return monnaies.sort( this.compareName );
|
|
}
|
|
/* -------------------------------------------- */
|
|
getFaiblesses( ) {
|
|
let faib = this.items.filter( item => item.type == 'faiblesse');
|
|
return faib.sort( this.compareName );
|
|
}
|
|
/* -------------------------------------------- */
|
|
getBlessures( ) {
|
|
return this.items.filter( item => item.type == 'blessure');
|
|
}
|
|
/* -------------------------------------------- */
|
|
getToutEquipements() {
|
|
return this.items.filter( item => item.type == 'equipement' || item.type == 'armure' || item.type == 'armecc' || item.type == 'armedist' || item.type == 'bouclier');
|
|
}
|
|
/* -------------------------------------------- */
|
|
getArmes() {
|
|
return this.items.filter( item => (item.type == 'armecc' || item.type == 'armedist') && item.system.equipe );
|
|
}
|
|
/* -------------------------------------------- */
|
|
getArmures() {
|
|
return this.items.filter( item => item.type == 'armure' && item.system.equipe );
|
|
}
|
|
getBoucliers() {
|
|
return this.items.filter( item => item.type == 'bouclier' && item.system.equipe );
|
|
}
|
|
getProuessesMartiales() {
|
|
let prouesse = this.items.filter( item => item.type == 'prouesse' );
|
|
return prouesse.sort( this.compareName );
|
|
}
|
|
getSortsSejdr() {
|
|
let sort = this.items.filter( item => item.type == 'sortsejdr' );
|
|
return sort.sort( this.compareName );
|
|
}
|
|
getSortsGaldr() {
|
|
let sort = this.items.filter( item => item.type == 'sortgaldr' );
|
|
return sort.sort( this.compareName );
|
|
}
|
|
getRunes() {
|
|
let sort = this.items.filter( item => item.type == 'rune' );
|
|
return sort.sort( this.compareName );
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async setEpuise( ) {
|
|
if (!this.system.status.epuise) {
|
|
await this.update({ 'system.status.epuise': true});
|
|
this.system.status.epuise = true;
|
|
}
|
|
/*let effect = this.getEffectByLabel('Epuisé');
|
|
if ( !effect ) {
|
|
let effect = statusEffects.find( ef => ef.id == 'epuise');
|
|
await this.createEmbeddedDocuments("ActiveEffect", [ effect ] );
|
|
}*/
|
|
}
|
|
/* -------------------------------------------- */
|
|
async cleanEpuise() {
|
|
if (this.system.status.epuise) {
|
|
await this.update({ 'system.status.epuise': false});
|
|
this.system.status.epuise = false;
|
|
}
|
|
/*let effect = this.getEffectByLabel('Epuisé');
|
|
if ( effect ) {
|
|
await this.deleteEmbeddedDocuments("ActiveEffect", [ effect.id ]);
|
|
}*/
|
|
}
|
|
/* -------------------------------------------- */
|
|
async toggleEpuise( ) {
|
|
if ( this.system.status.epuise ) {
|
|
await this.cleanEpuise();
|
|
} else {
|
|
await this.setEpuise();
|
|
}
|
|
}
|
|
/* -------------------------------------------- */
|
|
isEpuise() {
|
|
return this.system.status.epuise;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async setBlesse( ) {
|
|
if (!this.system.status.blesse) {
|
|
await this.update({ 'system.status.blesse': true} );
|
|
this.system.status.blesse = true;
|
|
}
|
|
/*let effect = this.getEffectByLabel('Blessé');
|
|
if ( !effect ) {
|
|
let effect = statusEffects.find( ef => ef.id == 'blesse');
|
|
await this.createEmbeddedDocuments("ActiveEffect", [ effect ] );
|
|
}*/
|
|
}
|
|
/* -------------------------------------------- */
|
|
async cleanBlesse() {
|
|
if (this.system.status.blesse) {
|
|
await this.update({ 'system.status.blesse': false} );
|
|
this.system.status.blesse = false;
|
|
}
|
|
/*let effect = this.getEffectByLabel('Blessé');
|
|
if ( effect ) {
|
|
await this.deleteEmbeddedDocuments("ActiveEffect", [ effect.id ]);
|
|
}*/
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
isBlesse() {
|
|
return this.system.status.blesse;
|
|
//return this.getEffectByLabel('Blessé');
|
|
}
|
|
/* -------------------------------------------- */
|
|
async setMeurtri( ) {
|
|
await this.setBlesse();
|
|
if (!this.system.status.meurtri) {
|
|
await this.update({ 'system.status.meurtri': true});
|
|
this.system.status.meurtri = true;
|
|
}
|
|
}
|
|
/* -------------------------------------------- */
|
|
async cleanMeurtri() {
|
|
if (this.system.status.meurtri) {
|
|
await this.update({ 'system.status.meurtri': false});
|
|
this.system.status.meurtri = false;
|
|
}
|
|
}
|
|
/* -------------------------------------------- */
|
|
isMeurtri() {
|
|
return this.system.status.meurtri;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async decrementFuror( nbFuror) {
|
|
await this.update( { 'system.furor.value': this.system.furor.value - nbFuror } );
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
getCurrentFuror() {
|
|
return this.system.furor.value;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
getActiveEffects(matching = it => true) {
|
|
let array = Array.from(this.getEmbeddedCollection("ActiveEffect").values());
|
|
return Array.from(this.getEmbeddedCollection("ActiveEffect").values()).filter(it => matching(it));
|
|
}
|
|
/* -------------------------------------------- */
|
|
getEffectByLabel(label) {
|
|
return this.getActiveEffects().find(it => it.data.label == label);
|
|
}
|
|
/* -------------------------------------------- */
|
|
getEffectById(id) {
|
|
return this.getActiveEffects().find(it => it.id == id);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
getCarac( caracName ) {
|
|
for( let key in this.system.carac) {
|
|
let categ = this.system.carac[key];
|
|
for( let carac in categ.carac) {
|
|
if (carac.toLowerCase() == caracName.toLowerCase() ) {
|
|
return deepClone(categ.carac[carac]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
computeCaracSecondaire( ) {
|
|
if ( this.type == "personnage") {
|
|
let basecorps = this.system.carac.corps.carac;
|
|
let sumcorps = basecorps.puissance.value + basecorps.agilite.value + basecorps.vigueur.value
|
|
let baseesprit = this.system.carac.esprit.carac;
|
|
let sumesprit = baseesprit.intellect.value + baseesprit.perception.value + baseesprit.tenacite.value
|
|
let baseame = this.system.carac.ame.carac;
|
|
let sumame = baseame.charisme.value + baseame.communication.value + baseame.instinct.value
|
|
|
|
let newPV = (sumcorps*3) + (sumesprit *2) + sumame;
|
|
if ( newPV != this.system.caracsecondaire.pv.max) {
|
|
this.system.caracsecondaire.pv.max = newPV;
|
|
this.update( { 'system.caracsecondaire.pv.max': newPV });
|
|
}
|
|
|
|
this.system.caracsecondaire.reaction.value = baseesprit.intellect.value + baseesprit.perception.value + baseame.instinct.value;
|
|
let newReac = baseesprit.intellect.value + baseesprit.perception.value + baseame.instinct.value;
|
|
if ( newReac != this.system.caracsecondaire.reaction.max) {
|
|
this.system.caracsecondaire.reaction.max = newReac
|
|
this.update( { 'system.caracsecondaire.reaction.max': newReac });
|
|
}
|
|
|
|
this.system.caracsecondaire.defensephy.value = basecorps.agilite.value + basecorps.vigueur.value + baseame.instinct.value;
|
|
let newDef = basecorps.agilite.value + basecorps.vigueur.value + baseame.instinct.value;
|
|
if ( newDef != this.system.caracsecondaire.defensephy.max) {
|
|
this.system.caracsecondaire.defensephy.max = newDef
|
|
this.update( { 'system.caracsecondaire.defensephy.max': newDef });
|
|
}
|
|
|
|
this.system.caracsecondaire.defensemen.value = baseesprit.tenacite.value + baseame.instinct.value + baseesprit.intellect.value;
|
|
newDef = baseesprit.tenacite.value + baseame.instinct.value + baseesprit.intellect.value;
|
|
if ( newDef != this.system.caracsecondaire.defensemen.max) {
|
|
this.system.caracsecondaire.defensemen.max = newDef
|
|
this.update( { 'system.caracsecondaire.defensemen.max': newDef });
|
|
}
|
|
|
|
this.system.caracsecondaire.deplacement.value = basecorps.agilite.value + basecorps.vigueur.value;
|
|
let depl = basecorps.agilite.value + basecorps.vigueur.value;
|
|
if ( depl != this.system.caracsecondaire.deplacement.max) {
|
|
this.system.caracsecondaire.deplacement.max = depl
|
|
this.update( { 'system.caracsecondaire.deplacement.max': depl });
|
|
}
|
|
|
|
this.system.caracsecondaire.capaenc.value = (basecorps.puissance.value * 2) + basecorps.vigueur.value;
|
|
let enc = (basecorps.puissance.value * 2) + basecorps.vigueur.value;
|
|
if ( enc != this.system.caracsecondaire.capaenc.max ) {
|
|
this.system.caracsecondaire.capaenc.max = enc
|
|
this.update( { 'system.caracsecondaire.capaenc.max': enc });
|
|
}
|
|
|
|
//console.log("CARAC SEC", this.system.caracsecondaire)
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async equiperObject( equipementId ) {
|
|
let item = this.items.find( item => item.id == equipementId );
|
|
if (item && item.system) {
|
|
let update = { _id: item.id, "data.equipe": !item.system.equipe };
|
|
await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
|
|
}
|
|
}
|
|
/* -------------------------------------------- */
|
|
async updateCompetence( compId, niveau) {
|
|
let comp = this.items.find( item => item.type == 'competence' && item.id == compId);
|
|
console.log("Comp updated!!!!", compId, niveau);
|
|
if (comp) {
|
|
const update = { _id: comp.id, 'system.niveau': niveau };
|
|
await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
|
|
} else {
|
|
ui.notifications.warn("Compétence inconnue", compId)
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
buildListeActionsCombat( ) {
|
|
let armes = [];
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async rollAttribute( attrkey, subAttrKey = 'defaut') {
|
|
let attr = duplicate(this.system.attributs[attrkey]);
|
|
console.log("ATTR : ", attr, attrkey, subAttrKey);
|
|
let subAttr = duplicate(this.system.attributs[attrkey].values[subAttrKey] );
|
|
if ( attr ) {
|
|
subAttr.label = subAttr.label || "";
|
|
let title = `Attribut : ${attr.label} ${subAttr.label} : ${subAttr.value}`;
|
|
let rollData = {
|
|
mode: "attribut",
|
|
alias: this.name,
|
|
actorImg: this.img,
|
|
actorId: this.id,
|
|
attr: attr,
|
|
valuePhysique: this.system.attributs["physique"].values["defaut"].value,
|
|
subAttr: subAttr,
|
|
rollMode: game.settings.get("core", "rollMode"),
|
|
title: title,
|
|
isBlesse: this.system.etat.etat == "blesse",
|
|
optionsBonusMalus: YggdrasillUtility.buildListOptions(-15, +15),
|
|
bonusMalus: 0,
|
|
bonusdefense: 0,
|
|
optionsBD: YggdrasillUtility.buildListOptions(0, +15),
|
|
optionsSR: YggdrasillUtility.buildSROptions( ),
|
|
sr: 0
|
|
}
|
|
let rollDialog = await YggdrasillRoll.create( this, rollData);
|
|
console.log(rollDialog);
|
|
rollDialog.render( true );
|
|
} else {
|
|
ui.notifications.warn("Attribut non trouvée");
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async rollCarac( categName, caracName) {
|
|
let carac = duplicate(this.system.carac[categName].carac[caracName]);
|
|
console.log("CARAC : ", carac, this.system.carac);
|
|
if ( carac) {
|
|
let rollData = {
|
|
mode: "carac",
|
|
alias: this.name,
|
|
actorImg: this.img,
|
|
actorId: this.id,
|
|
img: `systems/fvtt-yggdrasill/images/icons/icon_carac_${categName}.png`,
|
|
rollMode: game.settings.get("core", "rollMode"),
|
|
title: `Caractéristique ${carac.label} : ${carac.value}`,
|
|
selectedCarac: carac,
|
|
isEpuise: this.isEpuise(),
|
|
isBlesse: this.isBlesse(),
|
|
isMeurtri: this.isMeurtri(),
|
|
optionsBonusMalus: YggdrasillUtility.buildListOptions(-15, +15),
|
|
bonusMalus: 0,
|
|
optionsFuror: YggdrasillUtility.buildListOptions(0, this.getCurrentFuror() ),
|
|
furorUsage: 0,
|
|
optionsSR: YggdrasillUtility.buildSROptions( ),
|
|
optionsBD: YggdrasillUtility.buildListOptions(0, +15),
|
|
sr: 0
|
|
}
|
|
let rollDialog = await YggdrasillRoll.create( this, rollData);
|
|
console.log(rollDialog);
|
|
rollDialog.render( true );
|
|
} else {
|
|
ui.notifications.warn("Caractéristique non trouvée");
|
|
}
|
|
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async rollCompetence( competenceId ) {
|
|
let competence = this.items.find( item => item.type == 'competence' && item.id == competenceId);
|
|
if ( competence) {
|
|
let rollData = {
|
|
mode: "competence",
|
|
alias: this.name,
|
|
actorImg: this.img,
|
|
actorId: this.id,
|
|
img: competence.img,
|
|
rollMode: game.settings.get("core", "rollMode"),
|
|
title: `Compétence ${competence.name} : ${competence.system.niveau}`,
|
|
competence: duplicate(competence),
|
|
isEpuise: this.isEpuise(),
|
|
isBlesse: this.isBlesse(),
|
|
isMeurtri: this.isMeurtri(),
|
|
optionsBonusMalus: YggdrasillUtility.buildListOptions(-15, +15),
|
|
bonusMalus: 0,
|
|
optionsFuror: YggdrasillUtility.buildListOptions(0, this.getCurrentFuror() ),
|
|
furorUsage: 0,
|
|
optionsSR: YggdrasillUtility.buildSROptions( ),
|
|
sr: 0
|
|
}
|
|
let rollDialog = await YggdrasillRoll.create( this, rollData);
|
|
console.log(rollDialog);
|
|
rollDialog.render( true );
|
|
} else {
|
|
ui.notifications.warn("Compétence non trouvée");
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
getAttaqueData( mode ) {
|
|
let attackData = duplicate(attackMode[mode]);
|
|
if ( attackData){
|
|
attackData.mode = mode;
|
|
attackData.carac = duplicate(this.system.carac[attackData.categName].carac[attackData.caracName]);
|
|
if ( attackData.malus != 0) {
|
|
let malusTab = attackData.malus.split(';');
|
|
attackData.malus = this.system.carac[attackData.categName].carac[malusTab[0]].value * Number(malusTab[1])
|
|
}
|
|
if ( attackData.protection != 0) {
|
|
let malusTab = attackData.protection.split(';');
|
|
attackData.protection = this.system.carac[attackData.categName].carac[malusTab[0]].value * Number(malusTab[1])
|
|
}
|
|
if ( attackData.bonusdegats != 0) {
|
|
let malusTab = attackData.bonusdegats.split(';');
|
|
attackData.bonusdegats = this.system.carac[attackData.categName].carac[malusTab[0]].value * Number(malusTab[1])
|
|
}
|
|
}
|
|
return attackData;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
getTirData( mode) {
|
|
let attackData = duplicate( tirMode[mode] );
|
|
if ( attackData){
|
|
attackData.mode = mode;
|
|
attackData.carac = duplicate(this.system.carac[attackData.categName].carac[attackData.caracName]);
|
|
if ( attackData.malus != 0) {
|
|
let malusTab = attackData.malus.split(';');
|
|
attackData.malus = this.system.carac[attackData.categName].carac[malusTab[0]].value * Number(malusTab[1])
|
|
}
|
|
if ( attackData.protection != 0) {
|
|
let malusTab = attackData.protection.split(';');
|
|
attackData.protection = this.system.carac[attackData.categName].carac[malusTab[0]].value * Number(malusTab[1])
|
|
}
|
|
if ( attackData.bonusdegats != 0) {
|
|
let malusTab = attackData.bonusdegats.split(';');
|
|
attackData.bonusdegats = this.system.carac[attackData.categName].carac[malusTab[0]].value * Number(malusTab[1])
|
|
}
|
|
}
|
|
return attackData;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async rollSort( sortId, magie) {
|
|
let sort = this.items.find( item => item.id == sortId);
|
|
let competence = this.items.find( item => item.type == 'competence' && item.name.toLowerCase().includes(magie));
|
|
console.log("SORT :", sortId, sort, competence );
|
|
|
|
let carac;
|
|
if ( magie == "sejdr") {
|
|
carac = duplicate(this.system.carac.ame.carac.instinct);
|
|
} else if ( magie == "rune") {
|
|
carac = duplicate(this.system.carac.ame.carac.communication);
|
|
} else {
|
|
carac = duplicate(this.system.carac.ame.carac.charisme);
|
|
}
|
|
|
|
if ( sort && competence) {
|
|
|
|
let rollData = {
|
|
mode: magie,
|
|
isMagie: true,
|
|
alias: this.name,
|
|
actorImg: this.img,
|
|
actorId: this.id,
|
|
img: sort.img,
|
|
rollMode: game.settings.get("core", "rollMode"),
|
|
title: magie + " - " + sort.name,
|
|
selectedCarac: carac,
|
|
agiliteCarac: duplicate(this.system.carac.corps.carac.agilite),
|
|
instinctCarac: duplicate(this.system.carac.ame.carac.instinct),
|
|
sort: duplicate(sort),
|
|
competence: duplicate(competence),
|
|
dureeGaldr: "1d5a",
|
|
nbCibles: "1",
|
|
zoneGaldr: "INS10cm3",
|
|
bonusdefense: 0,
|
|
isEpuise: this.isEpuise(),
|
|
isBlesse: this.isBlesse(),
|
|
isMeurtri: this.isMeurtri(),
|
|
optionsBonusMalus: YggdrasillUtility.buildListOptions(-15, +15),
|
|
optionsBD: YggdrasillUtility.buildListOptions(0, +15),
|
|
bonusMalus: 0,
|
|
optionsFuror: YggdrasillUtility.buildListOptions(0, this.getCurrentFuror() ),
|
|
furorUsage: 0,
|
|
optionsSR: YggdrasillUtility.buildSROptions( ),
|
|
sr: 14,
|
|
puissanceRune: 1,
|
|
optionsPuissanceRune: YggdrasillUtility.buildListOptions(1, 15),
|
|
supportRune: "peau",
|
|
}
|
|
let rollDialog = await YggdrasillRoll.create( this, rollData);
|
|
console.log(rollDialog);
|
|
rollDialog.render( true );
|
|
} else {
|
|
ui.notifications.warn("Sortilège ou Compétence non trouvée !", sort, compName);
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async rollArme( armeId ) {
|
|
let arme = this.items.find( item => item.id == armeId);
|
|
let compName = armeCategorieToCompetence[arme.system.categorie];
|
|
let competence = this.items.find( item => item.type == 'competence' && item.name == compName);
|
|
console.log("ARME :", armeId, arme, competence );
|
|
|
|
if ( arme && competence) {
|
|
|
|
let attackDef
|
|
if (arme.type == 'armecc') {
|
|
attackDef = this.getAttaqueData("classique");
|
|
} else {
|
|
attackDef = this.getTirData("pose");
|
|
}
|
|
|
|
let rollData = {
|
|
mode: arme.type,
|
|
attackDef: attackDef,
|
|
alias: this.name,
|
|
actorImg: this.img,
|
|
actorId: this.id,
|
|
img: competence.img,
|
|
rollMode: game.settings.get("core", "rollMode"),
|
|
title: "Attaque !",
|
|
selectedCarac: duplicate(this.system.carac.corps.carac.agilite),
|
|
arme: duplicate(arme),
|
|
competence: duplicate(competence),
|
|
bonusdefense: 0,
|
|
isEpuise: this.isEpuise(),
|
|
isBlesse: this.isBlesse(),
|
|
isMeurtri: this.isMeurtri(),
|
|
optionsBonusMalus: YggdrasillUtility.buildListOptions(-15, +15),
|
|
optionsBD: YggdrasillUtility.buildListOptions(0, +15),
|
|
bonusMalus: 0,
|
|
optionsFuror: YggdrasillUtility.buildListOptions(0, this.getCurrentFuror() ),
|
|
furorUsage: 0,
|
|
optionsSR: YggdrasillUtility.buildSROptions( ),
|
|
sr: 14
|
|
}
|
|
let rollDialog = await YggdrasillRoll.create( this, rollData);
|
|
console.log(rollDialog);
|
|
rollDialog.render( true );
|
|
} else {
|
|
ui.notifications.warn("Arme ou Compétence Martiale non trouvée !", arme, compName);
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
getEncTotal( ) {
|
|
let encTotal = 0;
|
|
for( let item of this.items) {
|
|
if (item.type == "equipement" || item.type == "armecc"
|
|
|| item.type == "armedist" || item.type == "armure" || item.type == "monnaie" || item.type == "bouclier") {
|
|
encTotal += (item.system.enc * item.system.quantite);
|
|
}
|
|
}
|
|
for( let item of this.items) {
|
|
if (item.type == "bouclier" && item.system.equipe) {
|
|
encTotal -= (item.system.enc * item.system.quantite);
|
|
encTotal += (item.system.enccomb * item.system.quantite);
|
|
}
|
|
}
|
|
return encTotal;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
getProtectionTotal( ) {
|
|
let protectionTotal = 0;
|
|
for( let item of this.items) {
|
|
if (item.type == "armure" && item.system.equipe) {
|
|
protectionTotal += Number(item.system.protection);
|
|
}
|
|
}
|
|
return protectionTotal;
|
|
}
|
|
/* -------------------------------------------- */
|
|
getDpBouclier( ) {
|
|
let dpBouclier = 0;
|
|
for( let item of this.items) {
|
|
if (item.type == "bouclier" && item.system.equipe) {
|
|
dpBouclier += Number(item.system.defensebonus);
|
|
}
|
|
}
|
|
return dpBouclier;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async incrementeQuantite( objetId ) {
|
|
let objetQ = this.items.find( item => item.id == objetId );
|
|
if (objetQ) {
|
|
let newQ = objetQ.system.quantite + 1;
|
|
const updated = await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async decrementeQuantite( objetId ) {
|
|
let objetQ = this.items.find( item => item.id == objetId );
|
|
if (objetQ) {
|
|
let newQ = objetQ.system.quantite - 1;
|
|
newQ = (newQ <= 0) ? 0 : newQ;
|
|
const updated = await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
|
|
}
|
|
}
|
|
|
|
}
|