2022-12-26 00:33:13 +01:00
|
|
|
/* -------------------------------------------- */
|
|
|
|
import { HeritiersUtility } from "./heritiers-utility.js";
|
|
|
|
import { HeritiersRollDialog } from "./heritiers-roll-dialog.js";
|
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
|
|
|
|
const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
|
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
/**
|
|
|
|
* Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
|
|
|
|
* @extends {Actor}
|
|
|
|
*/
|
|
|
|
export class HeritiersActor 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;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (data.type == 'personnage') {
|
2023-01-18 16:16:18 +01:00
|
|
|
const skills = await HeritiersUtility.loadCompendium("fvtt-les-heritiers.competences")
|
2023-03-08 23:44:19 +01:00
|
|
|
data.items = []
|
|
|
|
for (let skill of skills) {
|
|
|
|
if (skill.system.categorie == "utile") {
|
2023-03-09 13:16:19 +01:00
|
|
|
data.items.push(skill.toObject())
|
|
|
|
}
|
2023-03-08 23:44:19 +01:00
|
|
|
}
|
2022-12-26 00:33:13 +01:00
|
|
|
}
|
2023-03-13 09:00:49 +01:00
|
|
|
if (data.type == 'pnj') {
|
2022-12-26 00:33:13 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return super.create(data, options);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
prepareArme(arme) {
|
|
|
|
arme = duplicate(arme)
|
|
|
|
let combat = this.getCombatValues()
|
|
|
|
if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
|
2023-01-18 16:16:18 +01:00
|
|
|
let bonusDefense = 0
|
|
|
|
arme.system.competence = duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
|
2022-12-26 00:33:13 +01:00
|
|
|
arme.system.attrKey = "pui"
|
|
|
|
arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
|
|
|
|
arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
|
|
|
|
arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense
|
|
|
|
arme.system.isdefense = true
|
|
|
|
}
|
|
|
|
if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
|
|
|
|
arme.system.competence = duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
|
|
|
|
arme.system.attrKey = "adr"
|
|
|
|
arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
|
|
|
|
arme.system.totalDegats = arme.system.degats
|
|
|
|
if (arme.system.isdefense) {
|
|
|
|
arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return arme
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
getWeapons() {
|
|
|
|
let armes = []
|
|
|
|
for (let arme of this.items) {
|
|
|
|
if (arme.type == "arme") {
|
|
|
|
armes.push(this.prepareArme(arme))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return armes
|
|
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
getMonnaies() {
|
2023-01-18 16:16:18 +01:00
|
|
|
return this.items.filter(it => it.type == "monnaie")
|
2022-12-26 00:33:13 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* ----------------------- --------------------- */
|
2023-01-18 16:16:18 +01:00
|
|
|
addMember(actorId) {
|
2022-12-26 00:33:13 +01:00
|
|
|
let members = duplicate(this.system.members)
|
2023-01-18 16:16:18 +01:00
|
|
|
members.push({ id: actorId })
|
|
|
|
this.update({ 'system.members': members })
|
2022-12-26 00:33:13 +01:00
|
|
|
}
|
2023-01-18 16:16:18 +01:00
|
|
|
async removeMember(actorId) {
|
|
|
|
let members = this.system.members.filter(it => it.id != actorId)
|
|
|
|
this.update({ 'system.members': members })
|
2022-12-26 00:33:13 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* ----------------------- --------------------- */
|
2023-03-10 13:21:06 +01:00
|
|
|
getItemSorted( types) {
|
|
|
|
let items = this.items.filter(item => types.includes(item.type )) || []
|
|
|
|
HeritiersUtility.sortArrayObjectsByName(items)
|
|
|
|
return items
|
|
|
|
}
|
2022-12-26 00:33:13 +01:00
|
|
|
getEquipments() {
|
2023-03-10 13:21:06 +01:00
|
|
|
return this.getItemSorted( ["equipement", "accessoire"] )
|
2022-12-26 00:33:13 +01:00
|
|
|
}
|
2023-01-20 15:19:04 +01:00
|
|
|
getAvantages() {
|
2023-03-10 13:21:06 +01:00
|
|
|
return this.getItemSorted( ["avantage"])
|
2023-01-20 15:19:04 +01:00
|
|
|
}
|
|
|
|
getDesavantages() {
|
2023-03-10 13:21:06 +01:00
|
|
|
return this.getItemSorted( ["desavantage"])
|
2022-12-26 00:33:13 +01:00
|
|
|
}
|
|
|
|
getMonnaies() {
|
2023-03-10 13:21:06 +01:00
|
|
|
return this.getItemSorted( ["monnaie"])
|
2022-12-26 00:33:13 +01:00
|
|
|
}
|
|
|
|
getArmors() {
|
2023-03-10 13:21:06 +01:00
|
|
|
return this.getItemSorted( ["protection"])
|
2022-12-26 00:33:13 +01:00
|
|
|
}
|
|
|
|
getTalents() {
|
2023-03-10 13:21:06 +01:00
|
|
|
return this.getItemSorted( ["talent"])
|
2022-12-26 00:33:13 +01:00
|
|
|
}
|
|
|
|
getContacts() {
|
2023-03-10 13:21:06 +01:00
|
|
|
return this.getItemSorted( ["contact"])
|
2022-12-26 00:33:13 +01:00
|
|
|
}
|
2023-01-20 15:19:04 +01:00
|
|
|
getAtouts() {
|
2023-03-10 13:21:06 +01:00
|
|
|
return this.getItemSorted( ["atoutfeerique"])
|
2023-01-20 15:19:04 +01:00
|
|
|
}
|
|
|
|
getCapacites() {
|
2023-03-10 13:21:06 +01:00
|
|
|
return this.getItemSorted( ["capacitenaturelle"])
|
2023-01-20 15:19:04 +01:00
|
|
|
}
|
2023-03-07 19:33:12 +01:00
|
|
|
getFee() {
|
2023-03-11 12:11:27 +01:00
|
|
|
return this.items.find(item => item.type =="fee")
|
2023-03-07 19:33:12 +01:00
|
|
|
}
|
2023-03-08 16:58:11 +01:00
|
|
|
getProfils() {
|
2023-03-10 13:21:06 +01:00
|
|
|
return this.getItemSorted( ["profil"])
|
2023-03-08 16:58:11 +01:00
|
|
|
}
|
2023-03-08 23:44:19 +01:00
|
|
|
getPouvoirs() {
|
2023-03-10 13:21:06 +01:00
|
|
|
return this.getItemSorted( ["pouvoir"])
|
2023-03-08 23:44:19 +01:00
|
|
|
}
|
2022-12-26 00:33:13 +01:00
|
|
|
/* -------------------------------------------- */
|
|
|
|
getSkills() {
|
|
|
|
let comp = []
|
|
|
|
for (let item of this.items) {
|
|
|
|
item = duplicate(item)
|
|
|
|
if (item.type == "competence") {
|
|
|
|
comp.push(item)
|
|
|
|
}
|
|
|
|
}
|
2023-01-18 16:16:18 +01:00
|
|
|
return HeritiersUtility.sortByName(comp)
|
|
|
|
}
|
|
|
|
|
2023-03-08 16:58:11 +01:00
|
|
|
/* -------------------------------------------- */
|
|
|
|
prepareUtileSkill(item) {
|
|
|
|
let specList = []
|
2023-04-08 18:49:54 +02:00
|
|
|
if (item && item.system.categorie && item.system.categorie == "utile") {
|
2023-03-09 13:16:19 +01:00
|
|
|
for (let spec of item.system.specialites) {
|
2023-03-08 16:58:11 +01:00
|
|
|
specList.push(spec.name)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
item.nbSpec = specList.length
|
|
|
|
item.specList = specList.toString()
|
|
|
|
}
|
|
|
|
|
2023-01-18 16:16:18 +01:00
|
|
|
/* -------------------------------------------- */
|
2023-03-11 12:11:27 +01:00
|
|
|
organizeUtileSkills(kind = "mental") {
|
2023-01-18 16:16:18 +01:00
|
|
|
let comp = {}
|
|
|
|
for (let key in game.system.lesheritiers.config.competenceProfil) {
|
2023-03-11 12:11:27 +01:00
|
|
|
if ( game.system.lesheritiers.config.competenceProfil[key].kind == kind)
|
2023-03-13 09:00:49 +01:00
|
|
|
comp[key] = { skills: [], niveau: this.system.competences[key].niveau }
|
2023-01-18 16:16:18 +01:00
|
|
|
}
|
|
|
|
for (let item of this.items) {
|
|
|
|
if (item.type == "competence") {
|
2023-03-11 12:11:27 +01:00
|
|
|
if (item.system.categorie == "utile" && comp[item.system.profil]) {
|
2023-03-08 16:58:11 +01:00
|
|
|
this.prepareUtileSkill(item)
|
2023-03-13 09:00:49 +01:00
|
|
|
comp[item.system.profil].skills.push(item)
|
2023-01-18 16:16:18 +01:00
|
|
|
}
|
2022-12-26 00:33:13 +01:00
|
|
|
}
|
2023-01-18 16:16:18 +01:00
|
|
|
}
|
2023-03-11 12:11:27 +01:00
|
|
|
|
2023-03-09 00:26:52 +01:00
|
|
|
for (let key in comp) {
|
2023-03-13 09:00:49 +01:00
|
|
|
HeritiersUtility.sortArrayObjectsByName(comp[key].skills)
|
2023-03-09 00:26:52 +01:00
|
|
|
}
|
2023-03-11 12:11:27 +01:00
|
|
|
return Object.fromEntries(Object.entries(comp).sort())
|
2023-01-18 16:16:18 +01:00
|
|
|
}
|
2023-03-08 16:58:11 +01:00
|
|
|
/* -------------------------------------------- */
|
2023-03-09 13:16:19 +01:00
|
|
|
organizeContacts() {
|
2023-03-08 16:58:11 +01:00
|
|
|
let contactList = {}
|
|
|
|
for (let item of this.items) {
|
|
|
|
if (item.type == "contact") {
|
|
|
|
let c = contactList[item.system.contacttype] || { label: game.system.lesheritiers.config.contactType[item.system.contacttype], list: [] }
|
2023-03-09 13:16:19 +01:00
|
|
|
c.list.push(item)
|
2023-03-08 16:58:11 +01:00
|
|
|
contactList[item.system.contacttype] = c
|
|
|
|
}
|
|
|
|
}
|
2023-03-10 13:21:06 +01:00
|
|
|
for (let key in contactList) {
|
|
|
|
HeritiersUtility.sortArrayObjectsByName(contactList[key].list)
|
|
|
|
}
|
2023-03-08 16:58:11 +01:00
|
|
|
return contactList
|
|
|
|
}
|
2023-01-18 16:16:18 +01:00
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
organizeFutileSkills() {
|
|
|
|
let comp = []
|
|
|
|
for (let item of this.items) {
|
|
|
|
if (item.type == "competence") {
|
|
|
|
if (item.system.categorie == "futile") {
|
|
|
|
comp.push(item)
|
|
|
|
}
|
2022-12-26 00:33:13 +01:00
|
|
|
}
|
2023-01-18 16:16:18 +01:00
|
|
|
}
|
2023-03-09 00:04:23 +01:00
|
|
|
HeritiersUtility.sortArrayObjectsByName(comp)
|
2023-01-18 16:16:18 +01:00
|
|
|
return HeritiersUtility.sortByName(comp)
|
2022-12-26 00:33:13 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
getDefenseBase() {
|
|
|
|
return Math.max(this.system.attributs.tre.value, this.system.attributs.pui.value)
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
getVitesseBase() {
|
|
|
|
return 5 + __vitesseBonus[this.system.attributs.adr.value]
|
|
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
getProtection() {
|
|
|
|
let equipProtection = 0
|
2023-01-18 16:16:18 +01:00
|
|
|
for (let armor in this.items) {
|
2022-12-26 00:33:13 +01:00
|
|
|
if (armor.type == "protection" && armor.system.equipped) {
|
|
|
|
equipProtection += Number(armor.system.protection)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (equipProtection < 4) {
|
|
|
|
return 4 + equipProtection // Cas des boucliers + sans armure
|
|
|
|
}
|
|
|
|
return equipProtection // Uniquement la protection des armures + boucliers
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
getCombatValues() {
|
|
|
|
let combat = {
|
|
|
|
}
|
|
|
|
return combat
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
prepareBaseData() {
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
async prepareData() {
|
|
|
|
super.prepareData();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
prepareDerivedData() {
|
|
|
|
|
|
|
|
if (this.type == 'personnage') {
|
|
|
|
}
|
|
|
|
|
|
|
|
super.prepareDerivedData()
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
_preUpdate(changed, options, user) {
|
|
|
|
|
|
|
|
super._preUpdate(changed, options, user);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
getItemById(id) {
|
|
|
|
let item = this.items.find(item => item.id == id);
|
|
|
|
if (item) {
|
|
|
|
item = duplicate(item)
|
|
|
|
}
|
|
|
|
return item;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
async equipItem(itemId) {
|
|
|
|
let item = this.items.find(item => item.id == itemId)
|
|
|
|
if (item && item.system) {
|
|
|
|
let update = { _id: item.id, "system.equipped": !item.system.equipped }
|
|
|
|
await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
editItemField(itemId, itemType, itemField, dataType, value) {
|
|
|
|
let item = this.items.find(item => item.id == itemId)
|
|
|
|
if (item) {
|
|
|
|
console.log("Item ", item, itemField, dataType, value)
|
2023-03-10 09:08:10 +01:00
|
|
|
if (dataType) {
|
|
|
|
if (dataType.toLowerCase() == "number") {
|
|
|
|
value = Number(value)
|
|
|
|
} else {
|
|
|
|
value = String(value)
|
|
|
|
}
|
2022-12-26 00:33:13 +01:00
|
|
|
}
|
|
|
|
let update = { _id: item.id, [`system.${itemField}`]: value };
|
|
|
|
this.updateEmbeddedDocuments("Item", [update])
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
2023-01-20 15:19:04 +01:00
|
|
|
getPvMalus() {
|
|
|
|
if (this.system.pv.value > 0) {
|
|
|
|
if (this.system.pv.value < this.system.pv.max / 2) {
|
|
|
|
return -1
|
2022-12-26 00:33:13 +01:00
|
|
|
}
|
2023-01-20 15:19:04 +01:00
|
|
|
if (this.system.pv.value < 5) {
|
|
|
|
return -2
|
2022-12-26 00:33:13 +01:00
|
|
|
}
|
2023-01-20 15:19:04 +01:00
|
|
|
return 0
|
2022-12-26 00:33:13 +01:00
|
|
|
}
|
2023-01-20 15:19:04 +01:00
|
|
|
return "Moribond(e)"
|
2022-12-26 00:33:13 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
compareName(a, b) {
|
|
|
|
if (a.name < b.name) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (a.name > b.name) {
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
2023-01-18 16:16:18 +01:00
|
|
|
getCarac(attrKey) {
|
|
|
|
return duplicate(this.system.caracteristiques)
|
2022-12-26 00:33:13 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
getBonusDegats() {
|
2023-01-18 16:16:18 +01:00
|
|
|
return 0;
|
2022-12-26 00:33:13 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
async equipGear(equipmentId) {
|
|
|
|
let item = this.items.find(item => item.id == equipmentId);
|
|
|
|
if (item && item.system.data) {
|
|
|
|
let update = { _id: item.id, "system.equipped": !item.system.equipped };
|
|
|
|
await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
getSubActors() {
|
|
|
|
let subActors = [];
|
|
|
|
for (let id of this.system.subactors) {
|
|
|
|
subActors.push(duplicate(game.actors.get(id)));
|
|
|
|
}
|
|
|
|
return subActors;
|
|
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
async addSubActor(subActorId) {
|
|
|
|
let subActors = duplicate(this.system.subactors);
|
|
|
|
subActors.push(subActorId);
|
|
|
|
await this.update({ 'system.subactors': subActors });
|
|
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
async delSubActor(subActorId) {
|
|
|
|
let newArray = [];
|
|
|
|
for (let id of this.system.subactors) {
|
|
|
|
if (id != subActorId) {
|
|
|
|
newArray.push(id);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
await this.update({ 'system.subactors': newArray });
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
getTotalAdversite() {
|
|
|
|
return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
async incDecAdversite(adv, incDec = 0) {
|
|
|
|
let adversite = duplicate(this.system.adversite)
|
|
|
|
adversite[adv] += Number(incDec)
|
|
|
|
adversite[adv] = Math.max(adversite[adv], 0)
|
|
|
|
this.update({ 'system.adversite': adversite })
|
|
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
async incDecQuantity(objetId, incDec = 0) {
|
|
|
|
let objetQ = this.items.get(objetId)
|
|
|
|
if (objetQ) {
|
|
|
|
let newQ = objetQ.system.quantite + incDec
|
|
|
|
newQ = Math.max(newQ, 0)
|
|
|
|
const updated = await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
computeRichesse() {
|
|
|
|
let valueSC = 0
|
2023-01-18 16:16:18 +01:00
|
|
|
for (let monnaie of this.items) {
|
2022-12-26 00:33:13 +01:00
|
|
|
if (monnaie.type == "monnaie") {
|
2023-01-18 16:16:18 +01:00
|
|
|
valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
|
2022-12-26 00:33:13 +01:00
|
|
|
}
|
|
|
|
}
|
2023-01-18 16:16:18 +01:00
|
|
|
return HeritiersUtility.computeMonnaieDetails(valueSC)
|
2022-12-26 00:33:13 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
computeValeurEquipement() {
|
|
|
|
let valueSC = 0
|
2023-01-18 16:16:18 +01:00
|
|
|
for (let equip of this.items) {
|
2022-12-26 00:33:13 +01:00
|
|
|
if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
|
2023-01-18 16:16:18 +01:00
|
|
|
valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
|
|
|
|
valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
|
|
|
|
valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
|
2022-12-26 00:33:13 +01:00
|
|
|
}
|
|
|
|
}
|
2023-01-18 16:16:18 +01:00
|
|
|
return HeritiersUtility.computeMonnaieDetails(valueSC)
|
2022-12-26 00:33:13 +01:00
|
|
|
}
|
2023-01-18 16:16:18 +01:00
|
|
|
|
2022-12-26 00:33:13 +01:00
|
|
|
/* -------------------------------------------- */
|
|
|
|
getCompetence(compId) {
|
|
|
|
return this.items.get(compId)
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
async setPredilectionUsed(compId, predIdx) {
|
|
|
|
let comp = this.items.get(compId)
|
|
|
|
let pred = duplicate(comp.system.predilections)
|
|
|
|
pred[predIdx].used = true
|
|
|
|
await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
getInitiativeScore() {
|
|
|
|
let init = this.getFlag("world", "last-initiative")
|
|
|
|
return init || -1
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
getBestDefenseValue() {
|
|
|
|
let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
|
|
|
|
let maxDef = 0
|
|
|
|
let bestArme
|
|
|
|
for (let arme of defenseList) {
|
2023-01-18 16:16:18 +01:00
|
|
|
if (arme.type == "arme") {
|
2022-12-26 00:33:13 +01:00
|
|
|
arme = this.prepareArme(arme)
|
|
|
|
}
|
|
|
|
if (arme.system.totalDefensif > maxDef) {
|
|
|
|
maxDef = arme.system.totalDefensif
|
|
|
|
bestArme = duplicate(arme)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return bestArme
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
searchRelevantTalents(competence) {
|
|
|
|
let talents = []
|
|
|
|
|
|
|
|
for (let talent of this.items) {
|
|
|
|
if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
|
|
|
|
for (let auto of talent.system.automations) {
|
|
|
|
if (auto.eventtype === "prepare-roll") {
|
|
|
|
if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
|
|
|
|
talent = duplicate(talent)
|
|
|
|
talent.system.bonus = auto.bonus
|
|
|
|
talent.system.baCost = auto.baCost
|
|
|
|
talents.push(talent)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return talents
|
|
|
|
}
|
2023-04-08 18:49:54 +02:00
|
|
|
/* -------------------------------------------- */
|
|
|
|
getCurrentParade() {
|
|
|
|
if ( this.system.statutmasque == "masque") {
|
|
|
|
return this.system.combat.parade.masquee
|
|
|
|
}
|
|
|
|
return this.system.combat.parade.demasquee
|
|
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
getCurrentEsquive() {
|
|
|
|
if ( this.system.statutmasque == "masque") {
|
|
|
|
return this.system.combat.esquive.masquee
|
|
|
|
}
|
|
|
|
return this.system.combat.esquive.demasquee
|
|
|
|
}
|
2022-12-26 00:33:13 +01:00
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
2023-01-18 21:08:32 +01:00
|
|
|
getTricherie() {
|
|
|
|
return this.system.rang.tricherie.value
|
|
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
getHeritages() {
|
|
|
|
return this.system.rang.heritage.value
|
2022-12-26 00:33:13 +01:00
|
|
|
}
|
2023-01-20 15:19:04 +01:00
|
|
|
/* -------------------------------------------- */
|
|
|
|
incDecTricherie(value) {
|
|
|
|
let tricherie = this.system.rang.tricherie
|
|
|
|
tricherie.value += value
|
|
|
|
tricherie.value = Math.max(tricherie.value, 0)
|
|
|
|
tricherie.value = Math.min(tricherie.value, tricherie.max)
|
|
|
|
this.update({ 'system.rang.tricherie': tricherie })
|
|
|
|
}
|
2022-12-26 00:33:13 +01:00
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
2023-01-18 16:16:18 +01:00
|
|
|
getCommonRollData(compId = undefined, compName = undefined) {
|
2022-12-26 00:33:13 +01:00
|
|
|
let rollData = HeritiersUtility.getBasicRollData()
|
|
|
|
rollData.alias = this.name
|
|
|
|
rollData.actorImg = this.img
|
|
|
|
rollData.actorId = this.id
|
|
|
|
rollData.tokenId = this.token?.id
|
|
|
|
rollData.img = this.img
|
2023-01-18 16:16:18 +01:00
|
|
|
rollData.caracList = this.getCarac()
|
|
|
|
rollData.caracKey = "agi"
|
2023-01-18 21:08:32 +01:00
|
|
|
rollData.tricherie = this.getTricherie()
|
|
|
|
rollData.heritage = this.getHeritages()
|
|
|
|
rollData.useTricherie = false
|
2023-03-08 16:58:11 +01:00
|
|
|
rollData.useSpecialite = false
|
2023-01-18 21:08:32 +01:00
|
|
|
rollData.useHeritage = false
|
2023-01-20 15:19:04 +01:00
|
|
|
rollData.pvMalus = this.getPvMalus()
|
2023-01-18 16:16:18 +01:00
|
|
|
|
2022-12-26 00:33:13 +01:00
|
|
|
if (compId) {
|
|
|
|
rollData.competence = duplicate(this.items.get(compId) || {})
|
2023-03-08 16:58:11 +01:00
|
|
|
this.prepareUtileSkill(rollData.competence)
|
2022-12-26 00:33:13 +01:00
|
|
|
rollData.actionImg = rollData.competence?.img
|
|
|
|
}
|
|
|
|
if (compName) {
|
|
|
|
rollData.competence = duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
|
2023-04-08 18:49:54 +02:00
|
|
|
if (rollData.competence && rollData.competence.name) {
|
|
|
|
this.prepareUtileSkill(rollData.competence)
|
|
|
|
rollData.actionImg = rollData.competence?.img
|
|
|
|
} else {
|
|
|
|
rollData.competence = undefined
|
|
|
|
}
|
2022-12-26 00:33:13 +01:00
|
|
|
}
|
2023-04-08 18:49:54 +02:00
|
|
|
HeritiersUtility.updateWithTarget(rollData)
|
|
|
|
|
2022-12-26 00:33:13 +01:00
|
|
|
return rollData
|
|
|
|
}
|
2023-03-01 22:12:27 +01:00
|
|
|
/* -------------------------------------------- */
|
|
|
|
async rollInitiative() {
|
|
|
|
let rollData = this.getCommonRollData(undefined, "Art de la guerre")
|
2023-03-09 13:16:19 +01:00
|
|
|
rollData.mode = "init"
|
2023-03-01 22:12:27 +01:00
|
|
|
if (this.system.caracteristiques["san"].value > this.system.caracteristiques["per"].value) {
|
|
|
|
rollData.caracKey = "san"
|
|
|
|
} else {
|
|
|
|
rollData.caracKey = "per"
|
|
|
|
}
|
|
|
|
rollData.carac = this.system.caracteristiques[rollData.caracKey]
|
|
|
|
let rollDialog = await HeritiersRollDialog.create(this, rollData)
|
|
|
|
rollDialog.render(true)
|
|
|
|
}
|
2023-03-09 13:16:19 +01:00
|
|
|
|
2022-12-26 00:33:13 +01:00
|
|
|
/* -------------------------------------------- */
|
2023-01-20 15:19:04 +01:00
|
|
|
async rollCarac(key, isInit = false) {
|
|
|
|
let rollData = this.getCommonRollData()
|
2023-03-09 13:16:19 +01:00
|
|
|
rollData.mode = "carac"
|
2023-01-20 15:19:04 +01:00
|
|
|
rollData.carac = this.system.caracteristiques[key]
|
|
|
|
rollData.caracKey = key
|
2022-12-26 00:33:13 +01:00
|
|
|
let rollDialog = await HeritiersRollDialog.create(this, rollData)
|
|
|
|
rollDialog.render(true)
|
|
|
|
}
|
|
|
|
|
2023-03-11 12:11:27 +01:00
|
|
|
/* -------------------------------------------- */
|
|
|
|
async rollRang(key, isInit = false) {
|
|
|
|
let rollData = this.getCommonRollData()
|
|
|
|
rollData.mode = "rang"
|
|
|
|
rollData.rang = this.system.rang[key]
|
|
|
|
rollData.rangKey = key
|
|
|
|
let rollDialog = await HeritiersRollDialog.create(this, rollData)
|
|
|
|
rollDialog.render(true)
|
|
|
|
}
|
2023-03-13 09:00:49 +01:00
|
|
|
/* -------------------------------------------- */
|
|
|
|
async rollRootCompetence(compKey) {
|
|
|
|
let rollData = this.getCommonRollData()
|
|
|
|
rollData.mode = "competence"
|
|
|
|
console.log("Compkey", compKey)
|
|
|
|
rollData.competence = {name: this.system.competences[compKey].label, system: { niveau: this.system.competences[compKey].niveau }}
|
|
|
|
console.log("RollDatra", rollData)
|
|
|
|
let rollDialog = await HeritiersRollDialog.create(this, rollData)
|
|
|
|
rollDialog.render(true)
|
|
|
|
}
|
2023-03-11 12:11:27 +01:00
|
|
|
|
2022-12-26 00:33:13 +01:00
|
|
|
/* -------------------------------------------- */
|
2023-01-18 16:16:18 +01:00
|
|
|
async rollCompetence(compId) {
|
|
|
|
let rollData = this.getCommonRollData(compId)
|
2023-01-20 15:19:04 +01:00
|
|
|
rollData.mode = "competence"
|
2022-12-26 00:33:13 +01:00
|
|
|
console.log("RollDatra", rollData)
|
|
|
|
let rollDialog = await HeritiersRollDialog.create(this, rollData)
|
|
|
|
rollDialog.render(true)
|
|
|
|
}
|
2023-03-09 00:26:52 +01:00
|
|
|
/* -------------------------------------------- */
|
|
|
|
async rollAttaqueArme(armeId) {
|
|
|
|
let arme = this.items.get(armeId)
|
|
|
|
if (arme) {
|
|
|
|
let competenceName = "Tir"
|
|
|
|
let key = "prec"
|
|
|
|
if (arme.system.categorie == "blanche" || arme.system.categorie == "improvise") {
|
|
|
|
competenceName = "Mêlée"
|
|
|
|
key = "agi"
|
|
|
|
}
|
2023-03-09 13:16:19 +01:00
|
|
|
let rollData = this.getCommonRollData(undefined, competenceName)
|
2023-03-09 00:26:52 +01:00
|
|
|
rollData.carac = this.system.caracteristiques[key]
|
|
|
|
rollData.caracKey = key
|
2023-03-09 13:16:19 +01:00
|
|
|
rollData.arme = duplicate(arme)
|
2023-03-09 00:26:52 +01:00
|
|
|
rollData.mode = "arme"
|
|
|
|
let rollDialog = await HeritiersRollDialog.create(this, rollData)
|
|
|
|
rollDialog.render(true)
|
2023-03-09 13:16:19 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
async rollPouvoir(pouvoirId) {
|
|
|
|
let pouvoir = this.items.get(pouvoirId)
|
|
|
|
if (pouvoir) {
|
|
|
|
let rollData = this.getCommonRollData(undefined, undefined)
|
|
|
|
if ( pouvoir.system.feeriemasque != "autre") {
|
|
|
|
rollData.pouvoirBase = duplicate(this.system.rang[pouvoir.system.feeriemasque.toLowerCase()])
|
|
|
|
rollData.pouvoirBase.label = "Féerie"
|
|
|
|
rollData.carac = duplicate(this.system.caracteristiques[pouvoir.system.carac])
|
|
|
|
rollData.caracKey = pouvoir.system.carac
|
2023-03-09 00:26:52 +01:00
|
|
|
}
|
2023-03-09 13:16:19 +01:00
|
|
|
rollData.pouvoir = duplicate(pouvoir)
|
|
|
|
rollData.mode = "pouvoir"
|
|
|
|
let rollDialog = await HeritiersRollDialog.create(this, rollData)
|
|
|
|
rollDialog.render(true)
|
|
|
|
}
|
|
|
|
|
2023-03-09 00:26:52 +01:00
|
|
|
}
|
2022-12-26 00:33:13 +01:00
|
|
|
/* -------------------------------------------- */
|
|
|
|
async rollArmeOffensif(armeId) {
|
|
|
|
let arme = this.items.get(armeId)
|
|
|
|
if (arme.type == "arme") {
|
|
|
|
arme = this.prepareArme(arme)
|
|
|
|
}
|
|
|
|
let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
|
|
|
|
rollData.arme = arme
|
|
|
|
HeritiersUtility.updateWithTarget(rollData)
|
|
|
|
console.log("ARME!", rollData)
|
|
|
|
let rollDialog = await HeritiersRollDialog.create(this, rollData)
|
|
|
|
rollDialog.render(true)
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
async rollArmeDegats(armeId, targetVigueur = undefined) {
|
|
|
|
let arme = this.items.get(armeId)
|
|
|
|
if (arme.type == "arme") {
|
|
|
|
arme = this.prepareArme(arme)
|
|
|
|
}
|
|
|
|
console.log("DEGATS", arme)
|
2023-01-18 16:16:18 +01:00
|
|
|
let roll = new Roll("1d10+" + arme.system.totalDegats).roll({ async: false })
|
2022-12-26 00:33:13 +01:00
|
|
|
await HeritiersUtility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
|
2023-01-18 16:16:18 +01:00
|
|
|
let nbEtatPerdus = 0
|
2022-12-26 00:33:13 +01:00
|
|
|
if (targetVigueur) {
|
|
|
|
nbEtatPerdus = Math.floor(roll.total / targetVigueur)
|
|
|
|
}
|
|
|
|
let rollData = {
|
|
|
|
arme: arme,
|
|
|
|
finalResult: roll.total,
|
|
|
|
alias: this.name,
|
|
|
|
actorImg: this.img,
|
|
|
|
actorId: this.id,
|
|
|
|
actionImg: arme.img,
|
|
|
|
targetVigueur: targetVigueur,
|
|
|
|
nbEtatPerdus: nbEtatPerdus
|
|
|
|
}
|
|
|
|
HeritiersUtility.createChatWithRollMode(rollData.alias, {
|
|
|
|
content: await renderTemplate(`systems/fvtt-les-heritiers/templates/chat-degats-result.html`, rollData)
|
|
|
|
})
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|