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

167 lines
5.6 KiB
JavaScript
Raw Normal View History

2024-09-26 00:55:08 +02:00
import { Grammar } from "./grammar.js";
import { RdDItemCompetence } from "./item-competence.js";
import { ITEM_TYPES } from "./item.js";
import { Misc } from "./misc.js";
2020-12-04 20:52:04 +01:00
import { TMRUtility } from "./tmr-utility.js";
2024-09-26 00:55:08 +02:00
const VOIES_DRACONIC = [
{ code: 'O', label: "Voie d'Oniros", short: 'Oniros', ordre: 'a' },
{ code: 'H', label: "Voie d'Hypnos", short: 'Hypnos', ordre: 'b' },
{ code: 'N', label: "Voie de Narcos", short: 'Narcos', ordre: 'c' },
{ code: 'T', label: "Voie de Thanatos", short: 'Thanatos', ordre: 'd' },
{ code: 'O/H/N/T', label: "Oniros/Hypnos/Narcos/Thanatos", short: 'Oniros/Hypnos/Narcos/Thanatos', ordre: 'e' },
{ code: 'O/H/N', label: "Oniros/Hypnos/Narcos", short: "Oniros/Hypnos/Narcos", ordre: 'f' }
2024-09-26 00:55:08 +02:00
]
2020-12-04 20:52:04 +01:00
/* -------------------------------------------- */
export class RdDItemSort extends Item {
2024-09-26 00:55:08 +02:00
static getDraconicsSort(draconicList, sort) {
switch (Grammar.toLowerCaseNoAccent(sort.name)) {
case "lecture d'aura":
case "detection d'aura":
return draconicList;
case "annulation de magie":
return draconicList.filter(it => !RdDItemCompetence.isThanatos(it));
}
return [RdDItemCompetence.getVoieDraconic(draconicList, sort.system.draconic)];
}
static getOrdreCode(code) {
return (VOIES_DRACONIC.find(it => it.code == code)?.ordre ?? '?')
}
static getVoieCode(voie) {
return VOIES_DRACONIC.find(it => voie.name.includes(it.short))?.code ?? '?'
}
static getCodeDraconic(sort, voies = ['O', 'H', 'N', 'T']) {
2024-09-26 00:55:08 +02:00
switch (Grammar.toLowerCaseNoAccent(sort.name)) {
case "lecture d'aura":
case "detection d'aura":
return RdDItemSort.$voiesConnues('O/H/N/T', voies)
2024-09-26 00:55:08 +02:00
case "annulation de magie":
return RdDItemSort.$voiesConnues('O/H/N', voies)
2024-09-26 00:55:08 +02:00
}
const voie = VOIES_DRACONIC.find(it => it.label.includes(sort.system.draconic))
return voie?.code ?? sort.system.draconic
}
static $voiesConnues(voiesSort, voies) {
const codes = voies.filter(it => voiesSort.includes(it))
.sort(Misc.ascending(it => RdDItemSort.getOrdreCode(it)))
return Misc.join(codes ?? [''], '/');
}
2020-12-04 20:52:04 +01:00
/* -------------------------------------------- */
static isDifficulteVariable(sort) {
2022-09-07 09:01:23 +02:00
return sort && (sort.system.difficulte.toLowerCase() == "variable");
}
2020-12-04 20:52:04 +01:00
/* -------------------------------------------- */
static isCoutVariable(sort) {
2022-09-07 09:01:23 +02:00
return sort && (sort.system.ptreve.toLowerCase() == "variable" || sort.system.ptreve.indexOf("+") >= 0);
}
2020-12-04 20:52:04 +01:00
/* -------------------------------------------- */
static setCoutReveReel(sort) {
if (sort) {
2022-06-12 08:17:59 +02:00
sort.system.ptreve_reel = this.isCoutVariable(sort) ? 1 : sort.system.ptreve;
}
}
2020-12-04 20:52:04 +01:00
/* -------------------------------------------- */
static getDifficulte(sort, variable) {
if (sort && !RdDItemSort.isDifficulteVariable(sort)) {
return Misc.toInt(sort.system.difficulte);
}
return variable;
}
2020-12-04 20:52:04 +01:00
/* -------------------------------------------- */
static buildBonusCaseList(bonuscase, newCase) {
2024-09-27 02:33:01 +02:00
const list = RdDItemSort.bonuscaseStringToList(bonuscase)
if (newCase) {
list.push({ case: "Nouvelle", bonus: 0 })
2020-12-04 20:52:04 +01:00
}
return list;
}
2020-12-04 20:52:04 +01:00
/**
* Retourne une liste de bonus/case pour un item-sheet
* @param {} item
*/
static getBonusCaseList(item, newCase = false) {
// Gestion spéciale case bonus
if (item.type == ITEM_TYPES.sort) {
return RdDItemSort.buildBonusCaseList(item.system.bonuscase, newCase);
2020-12-04 20:52:04 +01:00
}
return undefined;
}
/* -------------------------------------------- */
/** Met à jour les données de formulaire
* si static des bonus de cases sont présents
* */
static buildBonuscaseFromArrays(bonuses, coords) {
if (bonuses) {
const list = [];
const caseCheck = {};
for (let i = 0; i < bonuses.length && i < coords.length; i++) {
const coord = coords[i] == 'Fleuve' ? 'Fleuve' : (coords[i]?.toUpperCase() ?? 'A1');
const bonus = bonuses[i] || 0;
if (TMRUtility.verifyTMRCoord(coord) && bonus > 0 && caseCheck[coord] == undefined) {
caseCheck[coord] = bonus;
list.push({ case: coord, bonus: bonus });
2020-12-04 20:52:04 +01:00
}
}
return RdDItemSort._bonuscaseListToString(list);
}
return undefined;
2020-12-04 20:52:04 +01:00
}
2020-12-04 20:52:04 +01:00
/* -------------------------------------------- */
static incrementBonusCase(actor, sort, coord) {
if (TMRUtility.getTMR(coord).type == "fleuve") {
coord = 'Fleuve';
}
const list = RdDItemSort.buildBonusCaseList(sort.system.bonuscase, false);
const bonus = Number(list.find(it => it.case == coord)?.bonus ?? 0);
const modified = { case: coord, bonus: bonus + 1 };
const bonuscase = RdDItemSort._bonuscaseListToString(
list.filter(it => it.case != coord).concat(modified)
);
// Sauvegarde/update
actor.updateEmbeddedDocuments('Item', [{ _id: sort._id, 'system.bonuscase': bonuscase }]);
2020-12-04 20:52:04 +01:00
}
2020-12-04 20:52:04 +01:00
/* -------------------------------------------- */
static getCaseBonus(sort, coord) {
const isFleuve = TMRUtility.getTMR(coord).type == "fleuve";
let bc = RdDItemSort.buildBonusCaseList(sort.system.bonuscase, false)
.filter(it => it.case == coord || (isFleuve && it.case == 'Fleuve'))
.find(it => true)
return Number(bc?.bonus ?? 0);
}
static _bonuscaseListToString(list) {
return list.map(it => `${it.case}:${it.bonus}`)
.sort(Misc.ascending())
.join(',');
}
2024-09-27 02:33:01 +02:00
static bonuscaseStringToList(bonuscase) {
if (bonuscase == undefined || bonuscase == '') {
return []
}
return bonuscase.split(',').map(it => {
const b = it.split(':');
return { case: b[0], bonus: b[1] };
});
2020-12-04 20:52:04 +01:00
}
}