139 lines
4.6 KiB
JavaScript
139 lines
4.6 KiB
JavaScript
import { Grammar } from "./grammar.js";
|
|
import { RdDItemCompetence } from "./item-competence.js";
|
|
import { ITEM_TYPES } from "./item.js";
|
|
import { Misc } from "./misc.js";
|
|
import { FLEUVE_COORD, TMRType, TMRUtility } from "./tmr-utility.js";
|
|
|
|
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' }
|
|
]
|
|
|
|
/* -------------------------------------------- */
|
|
export class RdDItemSort extends Item {
|
|
|
|
static getDraconicsSort(competencesDraconic, sort) {
|
|
// se baser sur la voie du sort?
|
|
switch (Grammar.toLowerCaseNoAccent(sort.name)) {
|
|
case "lecture d'aura":
|
|
case "detection d'aura":
|
|
return competencesDraconic;
|
|
case "annulation de magie":
|
|
return competencesDraconic.filter(it => !RdDItemCompetence.isThanatos(it));
|
|
}
|
|
const voies = sort.system.draconic.split('/')
|
|
return voies.map(voie => RdDItemCompetence.getVoieDraconic(competencesDraconic, voie))
|
|
}
|
|
|
|
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']) {
|
|
switch (Grammar.toLowerCaseNoAccent(sort.name)) {
|
|
case "lecture d'aura":
|
|
case "detection d'aura":
|
|
return RdDItemSort.$voiesConnues('O/H/N/T', voies)
|
|
case "annulation de magie":
|
|
return RdDItemSort.$voiesConnues('O/H/N', voies)
|
|
}
|
|
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 ?? [''], '/');
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
static isDifficulteVariable(sort) {
|
|
return sort && (sort.system.difficulte.toLowerCase() == "variable");
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
static isCoutVariable(sort) {
|
|
return sort && (sort.system.ptreve.toLowerCase() == "variable" || sort.system.ptreve.indexOf("+") >= 0);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
static setCoutReveReel(sort) {
|
|
if (sort) {
|
|
sort.system.ptreve_reel = this.isCoutVariable(sort) ? 1 : sort.system.ptreve;
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
static getDifficulte(sort, variable) {
|
|
if (sort && !RdDItemSort.isDifficulteVariable(sort)) {
|
|
return Misc.toInt(sort.system.difficulte);
|
|
}
|
|
return variable;
|
|
}
|
|
|
|
/**
|
|
* Retourne une liste de bonus/case pour un item-sheet
|
|
* @param {} item
|
|
*/
|
|
static getBonusCaseList(item) {
|
|
// Gestion spéciale case bonus
|
|
if (item.type == ITEM_TYPES.sort) {
|
|
return RdDItemSort.stringToBonuscases(item.system.bonuscase)
|
|
}
|
|
return [];
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
static incrementBonusCase(actor, sort, coord) {
|
|
if (TMRUtility.isFleuve(coord)) {
|
|
coord = FLEUVE_COORD;
|
|
}
|
|
let list = RdDItemSort.stringToBonuscases(sort.system.bonuscase);
|
|
const existing = list.find(it => it.case == coord)
|
|
const bonus = Number(existing?.bonus ?? 0) + 1
|
|
if (existing) {
|
|
existing.bonus = bonus
|
|
}
|
|
else {
|
|
list.push({ case: coord, bonus: 1 })
|
|
}
|
|
|
|
actor.updateEmbeddedDocuments('Item', [{ _id: sort._id, 'system.bonuscase': RdDItemSort.bonuscasesToString(list) }]);
|
|
}
|
|
|
|
|
|
/* -------------------------------------------- */
|
|
static getCaseBonus(sort, coord) {
|
|
const search = TMRUtility.isFleuve(coord)
|
|
? it => it.case == 'Fleuve'
|
|
: it => it.case == coord;
|
|
const bc = RdDItemSort.stringToBonuscases(sort.system.bonuscase)
|
|
.find(search)
|
|
return Number(bc?.bonus ?? 0);
|
|
}
|
|
|
|
static bonuscasesToString(list) {
|
|
return list.map(it => `${it.case}:${it.bonus}`)
|
|
.sort(Misc.ascending())
|
|
.join(',');
|
|
}
|
|
|
|
static stringToBonuscases(bonuscase) {
|
|
if (bonuscase == undefined || bonuscase == '') {
|
|
return []
|
|
}
|
|
return bonuscase.split(',')
|
|
.map(it => it.split(':'))
|
|
.map(it => { return { case: it[0], bonus: it[1] } });
|
|
}
|
|
|
|
} |