public/foundryvtt-reve-de-dragon
1
1
Fork 1
Code Issues 4 Pull Requests Projects Releases 140 Wiki Activity

Bonus de sorts en fleuve

Browse Source 
Le bonus de sort en fleuve est identique pour toutes les cases fleuve.
This commit is contained in:
Vincent Vandemeulebrouck 2023-03-30 01:31:41 +02:00
parent c57f140c54
commit 2aa62cffe9
3 changed files with 67 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
module/item-sheet.js
View File

@ -239,9 +239,8 @@ export class RdDItemSheet extends ItemSheet {
_updateObject(event, formData) { _updateObject(event, formData) {
if (this.item.type == 'sort') { if (this.item.type == 'sort') {
// Données de bonus de cases ? // Données de bonus de cases ?
formData['system.bonuscase'] = RdDItemSort.buildBonusCaseStringFromFormData(formData.bonusValue, formData.caseValue); formData['system.bonuscase'] = RdDItemSort.buildBonuscaseFromArrays(formData.bonusValue, formData.caseValue);
} }
return this.item.update(formData); return this.item.update(formData);
} }

110
module/item-sort.js
View File

@ -1,4 +1,3 @@
/* -------------------------------------------- */
import { Misc } from "./misc.js"; import { Misc } from "./misc.js";
import { TMRUtility } from "./tmr-utility.js"; import { TMRUtility } from "./tmr-utility.js";
@ -16,7 +15,7 @@ export class RdDItemSort extends Item {
} }
/* -------------------------------------------- */ /* -------------------------------------------- */
static setCoutReveReel(sort){ static setCoutReveReel(sort) {
if (sort) { if (sort) {
sort.system.ptreve_reel = this.isCoutVariable(sort) ? 1 : sort.system.ptreve; sort.system.ptreve_reel = this.isCoutVariable(sort) ? 1 : sort.system.ptreve;
} }
@ -25,36 +24,28 @@ export class RdDItemSort extends Item {
/* -------------------------------------------- */ /* -------------------------------------------- */
static getDifficulte(sort, variable) { static getDifficulte(sort, variable) {
if (sort && !RdDItemSort.isDifficulteVariable(sort)) { if (sort && !RdDItemSort.isDifficulteVariable(sort)) {
return Misc.toInt(sort.system.difficulte); return Misc.toInt(sort.system.difficulte);
} }
return variable; return variable;
} }
/* -------------------------------------------- */ /* -------------------------------------------- */
static buildBonusCaseList( caseBonusString, newCase ) { static buildBonusCaseList(bonuscase, newCase) {
if (caseBonusString == undefined) { const list = RdDItemSort._bonuscaseStringToList(bonuscase)
return []; if (newCase) {
} return list.concat({ case: "Nouvelle", bonus: 0 });
let bonusCaseList = [];
let bonusCaseArray = caseBonusString == undefined ? [] : caseBonusString.split(',');
for( let bonusCase of bonusCaseArray) {
let bonusSplit = bonusCase.split(':');
bonusCaseList.push( { case: bonusSplit[0], bonus: bonusSplit[1] } );
}
if ( newCase )
bonusCaseList.push( {case: "Nouvelle", bonus: 0} );
return bonusCaseList;
} }
return list;
}
/* -------------------------------------------- */
/** /**
* Retourne une liste de bonus/case pour un item-sheet * Retourne une liste de bonus/case pour un item-sheet
* @param {} item * @param {} item
*/ */
static getBonusCaseList( item, newCase = false ) { static getBonusCaseList(item, newCase = false) {
// Gestion spéciale case bonus // Gestion spéciale case bonus
if ( item.type == 'sort') { if (item.type == 'sort') {
return this.buildBonusCaseList(item.system.bonuscase, newCase ); return RdDItemSort.buildBonusCaseList(item.system.bonuscase, newCase);
} }
return undefined; return undefined;
} }
@ -63,56 +54,61 @@ export class RdDItemSort extends Item {
/** Met à jour les données de formulaire /** Met à jour les données de formulaire
* si static des bonus de cases sont présents * si static des bonus de cases sont présents
* */ * */
static buildBonusCaseStringFromFormData( bonuses, cases ) { static buildBonuscaseFromArrays(bonuses, coords) {
if ( bonuses ) { if (bonuses) {
let list = []; const list = [];
let caseCheck = {}; const caseCheck = {};
for (let i=0; i<bonuses.length; i++) { for (let i = 0; i < bonuses.length && i < coords.length; i++) {
let coord = cases[i]?.toUpperCase() || 'A1'; const coord = coords[i] == 'Fleuve' ? 'Fleuve' : (coords[i]?.toUpperCase() ?? 'A1');
let bonus = bonuses[i] || 0; const bonus = bonuses[i] || 0;
if ( TMRUtility.verifyTMRCoord( coord ) && bonus > 0 && caseCheck[coord] == undefined ) { if (TMRUtility.verifyTMRCoord(coord) && bonus > 0 && caseCheck[coord] == undefined) {
caseCheck[coord] = bonus; caseCheck[coord] = bonus;
list.push( coord+":"+bonus ); list.push({ case: coord, bonus: bonus });
} }
} }
return list.toString(); return RdDItemSort._bonuscaseListToString(list);
} }
return undefined; return undefined;
} }
/* -------------------------------------------- */ /* -------------------------------------------- */
static incrementBonusCase( actor, sort, coord ) { static incrementBonusCase(actor, sort, coord) {
let bonusCaseList = this.buildBonusCaseList(sort.system.bonuscase, false); if (TMRUtility.getTMR(coord).type == "fleuve") {
//console.log("ITEMSORT", sort, bonusCaseList); 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 };
let found = false; const bonuscase = RdDItemSort._bonuscaseListToString(
let StringList = []; list.filter(it => it.case != coord).concat(modified)
for( let bc of bonusCaseList) { );
if (bc.case == coord) { // Case existante
found = true;
bc.bonus = Number(bc.bonus) + 1;
}
StringList.push( bc.case+':'+bc.bonus );
}
if ( !found) { //Nouvelle case, bonus de 1
StringList.push(coord+':1');
}
// Sauvegarde/update // Sauvegarde/update
let bonuscase = StringList.toString(); actor.updateEmbeddedDocuments('Item', [{ _id: sort._id, 'system.bonuscase': bonuscase }]);
//console.log("Bonus cae :", bonuscase);
actor.updateEmbeddedDocuments('Item', [{ _id: sort._id, 'system.bonuscase': bonuscase }] );
} }
/* -------------------------------------------- */ /* -------------------------------------------- */
static getCaseBonus( sort, coord) { static getCaseBonus(sort, coord) {
let bonusCaseList = this.buildBonusCaseList(sort.system.bonuscase, false); const isFleuve = TMRUtility.getTMR(coord).type == "fleuve";
for( let bc of bonusCaseList) {
if (bc.case == coord) { // Case existante let bc = RdDItemSort.buildBonusCaseList(sort.system.bonuscase, false)
return Number(bc.bonus); .filter(it => it.case == coord || (isFleuve && it.case == 'Fleuve'))
} .find(it => true)
} return Number(bc?.bonus ?? 0);
return 0; }
static _bonuscaseListToString(list) {
return list.map(it => `${it.case}:${it.bonus}`)
.sort(Misc.ascending())
.join(',');
}
static _bonuscaseStringToList(bonuscase) {
return (bonuscase ?? '').split(',').map(it => {
const b = it.split(':');
return { case: b[0], bonus: b[1] };
});
} }
} }

22
module/tmr-utility.js
View File

@ -226,9 +226,6 @@ export const TMRType = {
desolation: { name: "désolation", genre: "f" } desolation: { name: "désolation", genre: "f" }
} }
/* -------------------------------------------- */
const caseSpecificModes = ["attache", "trounoir", "debordement", "reserve_extensible", "maitrisee"];
/* -------------------------------------------- */ /* -------------------------------------------- */
const tmrRandomMovePatten = const tmrRandomMovePatten =
[{ name: 'top', col: 0, row: -1 }, [{ name: 'top', col: 0, row: -1 },
@ -239,8 +236,6 @@ const tmrRandomMovePatten =
{ name: 'topleft', col: -1, row: -1 } { name: 'topleft', col: -1, row: -1 }
] ]
/* -------------------------------------------- */
/* -------------------------------------------- */ /* -------------------------------------------- */
export class TMRUtility { export class TMRUtility {
static init() { static init() {
@ -258,32 +253,25 @@ export class TMRUtility {
/* -------------------------------------------- */ /* -------------------------------------------- */
static verifyTMRCoord(coord) { static verifyTMRCoord(coord) {
let TMRregexp = new RegExp(/([A-M])(\d+)/g); return Grammar.equalsInsensitive(coord, 'Fleuve') || TMRUtility.getTMR(coord);
let res = TMRregexp.exec(coord);
if (res && res[1] && res[2]) {
if (res[2] > 0 && res[2] < 16) {
return true;
}
}
return false;
} }
/* -------------------------------------------- */ /* -------------------------------------------- */
static getTMR(coord) { static getTMR(coord) {
return TMRMapping[coord]; return coord == 'Fleuve' ? TMRMapping['D1'] : TMRMapping[coord];
} }
static getTMRLabel(coord) { static getTMRLabel(coord) {
return TMRMapping[coord]?.label ?? (coord + ": case inconnue"); return TMRUtility.getTMR(coord)?.label ?? (coord + ": case inconnue");
} }
static getTMRType(coord) { static getTMRType(coord) {
const tmr = TMRMapping[coord]; const tmr = TMRUtility.getTMR(coord);
return Misc.upperFirst(TMRType[tmr.type].name); return Misc.upperFirst(TMRType[tmr.type].name);
} }
static getTMRDescr(coord) { static getTMRDescr(coord) {
const tmr = TMRMapping[coord]; const tmr = TMRUtility.getTMR(coord);
return Grammar.articleDetermine(tmr.type) + ' ' + tmr.label; return Grammar.articleDetermine(tmr.type) + ' ' + tmr.label;
} }