foundryvtt-reve-de-dragon/module/item-competence.js

307 lines
11 KiB
JavaScript
Raw Permalink Normal View History

import { Grammar } from "./grammar.js";
2021-03-29 18:08:18 +02:00
import { Misc } from "./misc.js";
const competenceTroncs = [["Esquive", "Dague", "Corps à corps"],
["Epée à 1 main", "Epée à 2 mains", "Hache à 1 main", "Hache à 2 mains", "Lance", "Masse à 1 main", "Masse à 2 mains"]];
2021-03-29 18:08:18 +02:00
const xp_par_niveau = [5, 5, 5, 10, 10, 10, 10, 15, 15, 15, 15, 20, 20, 20, 20, 30, 30, 40, 40, 60, 60, 100, 100, 100, 100, 100, 100, 100, 100, 100];
const niveau_max = xp_par_niveau.length - 10;
/* -------------------------------------------- */
const limitesArchetypes = [
2023-06-20 02:58:51 +02:00
{ niveau: 0, nombreMax: 100 },
{ niveau: 1, nombreMax: 10 },
{ niveau: 2, nombreMax: 9 },
{ niveau: 3, nombreMax: 8 },
{ niveau: 4, nombreMax: 7 },
{ niveau: 5, nombreMax: 6 },
{ niveau: 6, nombreMax: 5 },
{ niveau: 7, nombreMax: 4 },
{ niveau: 8, nombreMax: 3 },
{ niveau: 9, nombreMax: 2 },
{ niveau: 10, nombreMax: 1 },
{ niveau: 11, nombreMax: 1 },
];
/* -------------------------------------------- */
const categoriesCompetences = {
"generale": { base: -4, label: "Générales" },
"particuliere": { base: -8, label: "Particulières" },
"specialisee": { base: -11, label: "Spécialisées" },
"connaissance": { base: -11, label: "Connaissances" },
"draconic": { base: -11, label: "Draconics" },
"melee": { base: -6, label: "Mêlée" },
"tir": { base: -8, label: "Tir" },
"lancer": { base: -8, label: "Lancer" }
}
function _buildCumulXP() {
let cumulXP = { "-11": 0 };
let cumul = 0;
2021-03-29 18:08:18 +02:00
for (let i = 0; i <= xp_par_niveau.length; i++) {
let level = i - 10;
2021-03-29 18:08:18 +02:00
cumul += xp_par_niveau[i];
cumulXP[level] = cumul;
}
return cumulXP;
}
const competence_xp_cumul = _buildCumulXP();
export class RdDItemCompetence extends Item {
/* -------------------------------------------- */
static getCategories() {
return categoriesCompetences;
}
/* -------------------------------------------- */
static getLabelCategorie(category) {
return categoriesCompetences[category].label;
}
/* -------------------------------------------- */
static getNiveauBase(category, categories = categoriesCompetences) {
return categories[category]?.base ?? 0;
}
2021-03-29 18:08:18 +02:00
/* -------------------------------------------- */
static getCategorie(competence) {
2022-06-12 09:46:58 +02:00
return competence?.system.categorie;
2021-03-29 18:08:18 +02:00
}
static isDraconic(competence) {
2022-06-12 09:46:58 +02:00
return competence?.system.categorie == 'draconic';
2021-03-29 18:08:18 +02:00
}
/* -------------------------------------------- */
static getVoieDraconic(competences, voie) {
return RdDItemCompetence.findFirstItem(competences, voie, {
2022-10-31 15:19:08 +01:00
preFilter: it => it.isCompetence() && RdDItemCompetence.isDraconic(it),
description: 'Draconic',
});
}
/* -------------------------------------------- */
static isCompetenceArme(competence) {
if (competence.isCompetence() && !competence.isCorpsACorps() && !competence.isEsquive()) {
switch (competence.system.categorie) {
case 'melee':
case 'tir':
case 'lancer':
return true;
}
}
return false;
}
/* -------------------------------------------- */
static isArmeUneMain(competence) {
return competence.isCompetenceArme() && competence.name.toLowerCase().includes("1 main");
}
static isArme2Main(competence) {
return competence.isCompetenceArme() && competence.name.toLowerCase().includes("2 main");
}
static isThanatos(competence) {
return competence.isCompetencePersonnage() && Grammar.toLowerCaseNoAccent(competence.name).includes('thanatos');
}
/* -------------------------------------------- */
2020-12-20 21:54:09 +01:00
static isMalusEncombrementTotal(competence) {
2022-06-12 12:14:55 +02:00
return competence?.name.toLowerCase().match(/(natation|acrobatie)/) || 0;
2020-12-20 21:54:09 +01:00
}
2021-01-01 22:25:32 +01:00
/* -------------------------------------------- */
static getListTronc(compName) {
for (let troncList of competenceTroncs) {
for (let troncName of troncList) {
if (troncName == compName)
return troncList;
}
}
return [];
}
/* -------------------------------------------- */
static computeTotalXP(competences) {
const total = competences.map(c => RdDItemCompetence.computeXP(c))
2021-03-29 18:08:18 +02:00
.reduce(Misc.sum(), 0);
const economieTronc = RdDItemCompetence.computeEconomieXPTronc(competences);
return total - economieTronc;
}
/* -------------------------------------------- */
static computeXP(competence) {
const factor = RdDItemCompetence.isThanatos(competence) ? 2 : 1; // Thanatos compte double !
2022-06-12 08:17:59 +02:00
const xpNiveau = RdDItemCompetence.computeDeltaXP(competence.system.base, competence.system.niveau ?? competence.system.base);
const xp = competence.system.xp ?? 0;
const xpSort = competence.system.xp_sort ?? 0;
return factor * (xpNiveau + xp) + xpSort;
}
/* -------------------------------------------- */
static computeEconomieXPTronc(competences) {
return competenceTroncs.map(
list => list.map(name => RdDItemCompetence.findCompetence(competences, name))
// calcul du coût xp jusqu'au niveau 0 maximum
2022-04-30 19:15:55 +02:00
.map(it => RdDItemCompetence.computeDeltaXP(it?.system.base ?? -11, Math.min(it?.system.niveau ?? -11, 0)))
.sort(Misc.ascending())
.splice(0, list.length - 1) // prendre toutes les valeurs sauf l'une des plus élevées
.reduce(Misc.sum(), 0)
2021-03-29 18:08:18 +02:00
).reduce(Misc.sum(), 0);
}
/* -------------------------------------------- */
static computeDeltaXP(from, to) {
RdDItemCompetence._valideNiveau(from);
RdDItemCompetence._valideNiveau(to);
return competence_xp_cumul[to] - competence_xp_cumul[from];
}
/* -------------------------------------------- */
static computeCompetenceXPCost(competence) {
2022-06-12 08:17:59 +02:00
let xp = RdDItemCompetence.getDeltaXp(competence.system.base, competence.system.niveau ?? competence.system.base);
xp += competence.system.xp ?? 0;
2021-03-29 18:08:18 +02:00
if (compData.name.includes('Thanatos')) xp *= 2; /// Thanatos compte double !
2022-06-12 08:17:59 +02:00
xp += competence.system.xp_sort ?? 0;
return xp;
}
2021-02-06 23:51:04 +01:00
/* -------------------------------------------- */
static computeEconomieCompetenceTroncXP(competences) {
let economie = 0;
for (let troncList of competenceTroncs) {
let list = troncList.map(name => RdDItemCompetence.findCompetence(competences, name))
2022-06-12 09:46:58 +02:00
.sort(Misc.descending(c => this.system.niveau)); // tri du plus haut au plus bas
list.splice(0, 1); // ignorer la plus élevée
2022-06-12 08:17:59 +02:00
list.map(c => c).forEach(c => {
economie += RdDItemCompetence.getDeltaXp(c.system.base, Math.min(c.system.niveau, 0))
});
}
return economie;
}
/* -------------------------------------------- */
static levelUp(item, stressTransforme) {
item.system.xpNext = RdDItemCompetence.getCompetenceNextXp(item.system.niveau);
const xpManquant = item.system.xpNext - item.system.xp;
item.system.isLevelUp = xpManquant <= 0;
item.system.isStressLevelUp = (xpManquant > 0 && stressTransforme >= xpManquant && item.system.niveau < item.system.niveau_archetype);
item.system.stressXpMax = 0;
if (xpManquant > 0 && stressTransforme > 0 && item.system.niveau < item.system.niveau_archetype) {
2022-10-31 15:19:08 +01:00
item.system.stressXpMax = Math.min(xpManquant, stressTransforme);
}
}
/* -------------------------------------------- */
static isNiveauBase(item) {
return Number(item.system.niveau) == RdDItemCompetence.getNiveauBase(item.system.categorie, item.getCategories());
}
/* -------------------------------------------- */
static findCompetence(list, idOrName, options = {}) {
2022-10-31 15:19:08 +01:00
if (idOrName == undefined || idOrName == "") {
return RdDItemCompetence.sansCompetence();
}
options = foundry.utils.mergeObject(options, { preFilter: it => it.isCompetence(), description: 'compétence' }, { overwrite: false, inplace: false });
return RdDItemCompetence.findFirstItem(list, idOrName, options);
}
/* -------------------------------------------- */
static findCompetences(list, name) {
return Misc.findAllLike(name, list, { filter: it => it.isCompetence(), description: 'compétence' });
}
2022-10-31 15:19:08 +01:00
static sansCompetence() {
return {
name: "Sans compétence",
type: "competence",
img: "systems/foundryvtt-reve-de-dragon/icons/templates/icone_parchement_vierge.webp",
system: {
niveau: 0,
default_diffLibre: 0,
base: 0,
categorie: "Aucune",
description: "",
descriptionmj: "",
defaut_carac: "",
}
};
}
static findFirstItem(list, idOrName, options) {
return list.find(it => it.id == idOrName && options.preFilter(it))
?? Misc.findFirstLike(idOrName, list, options);
}
/* -------------------------------------------- */
static getCompetenceNextXp(niveau) {
return RdDItemCompetence.getCompetenceXp(niveau + 1);
}
2021-02-06 23:51:04 +01:00
/* -------------------------------------------- */
static getCompetenceXp(niveau) {
RdDItemCompetence._valideNiveau(niveau);
2021-03-29 18:08:18 +02:00
return niveau < -10 ? 0 : xp_par_niveau[niveau + 10];
}
2021-02-06 23:51:04 +01:00
/* -------------------------------------------- */
static getDeltaXp(from, to) {
RdDItemCompetence._valideNiveau(from);
RdDItemCompetence._valideNiveau(to);
return competence_xp_cumul[to] - competence_xp_cumul[from];
}
2021-02-06 23:51:04 +01:00
/* -------------------------------------------- */
static _valideNiveau(niveau) {
2021-03-29 18:08:18 +02:00
if (niveau < -11 || niveau > niveau_max) {
console.warn(`Niveau ${niveau} en dehors des niveaux de compétences: [-11, ${niveau_max} ]`);
}
}
/* -------------------------------------------- */
static computeResumeArchetype(competences) {
2024-05-02 14:08:02 +02:00
const computed = foundry.utils.duplicate(limitesArchetypes);
2023-06-20 02:58:51 +02:00
computed.forEach(it => { it.nombre = 0; it.reste = it.nombreMax; });
2022-06-12 08:17:59 +02:00
competences.map(it => Math.max(0, it.system.niveau_archetype))
.filter(n => n > 0)
.forEach(n => {
2023-06-20 02:58:51 +02:00
computed[n] = computed[n] ?? { niveau: n, nombreMax: 0, reste: 0, nombre: 0 };
computed[n].reste--;
computed[n].nombre++;
2021-03-29 18:08:18 +02:00
});
2023-06-20 02:58:51 +02:00
return computed.filter(it => it.niveau > 0);
}
/* -------------------------------------------- */
2022-12-05 15:29:00 +01:00
static triVisible(competences) {
return competences.filter(it => !it.system.isHidden)
.sort((a, b) => RdDItemCompetence.compare(a, b))
2022-12-05 15:29:00 +01:00
}
static $positionTri(comp) {
if (comp.name.startsWith("Survie")) {
if (comp.name.includes("Cité")) return 0;
if (comp.name.includes("Extérieur")) return 1;
return 2;
}
if (comp.system.categorie.startsWith("melee")) {
if (comp.name.includes("Corps")) return 0;
if (comp.name.includes("Dague")) return 1;
if (comp.name.includes("Esquive")) return 2;
return 3;
}
if (comp.system.categorie.startsWith("draconic")) {
if (comp.name.includes("Oniros")) return 0;
if (comp.name.includes("Hypnos")) return 1;
if (comp.name.includes("Narcos")) return 2;
if (comp.name.includes("Thanatos")) return 3;
return 4;
}
return 0;
}
static compare(a, b) {
2022-12-05 15:29:00 +01:00
const diff = RdDItemCompetence.$positionTri(a) - RdDItemCompetence.$positionTri(b);
return diff ? diff : a.name.localeCompare(b.name);
}
}