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

10.6.2 #611

Merged
uberwald merged 7 commits from VincentVk/foundryvtt-reve-de-dragon:v10 into v10 2023-01-18 08:40:41 +01:00
Conversation 0 Commits 7 Files Changed 51 +107 -204
9 changed files with 107 additions and 204 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 4df04fe06f - Show all commits

127
module/environnement.js
View File

@ -1,109 +1,78 @@
import { SYSTEM_RDD } from "./constants.js"; import { SYSTEM_RDD } from "./constants.js";
import { Grammar } from "./grammar.js"; import { Grammar } from "./grammar.js";
import { HtmlUtility } from "./html-utility.js";
import { Misc } from "./misc.js"; import { Misc } from "./misc.js";
import { CompendiumTableHelpers, CompendiumTable } from "./settings/system-compendiums.js"; import { CompendiumTableHelpers, CompendiumTable, SystemCompendiums } from "./settings/system-compendiums.js";
import { RdDRaretes } from "./tirage/raretes.js"; import { RdDRaretes } from "./tirage/raretes.js";
const SETTINGS_LISTE_MILIEUX = "liste-milieux";
const MILIEUX = [ const COMPENDIUMS_RECHERCHE = 'compendiums-recherche';
"Collines", const TYPE_ITEMS_NATURELS = ["faune", "herbe", "plante", "ingredient"];
"Cours d'eau",
"Déserts",
"Forêts",
"Marais",
"Maritimes",
"Montagnes",
"Plaines",
"Sous-sols"
]
const ITEM_ENVIRONNEMENT_TYPES = [
'herbe', 'plante', 'ingredient', 'faune'
]
export class Environnement { export class Environnement {
static typesEnvironnement() {
return ITEM_ENVIRONNEMENT_TYPES
}
static init() { static init() {
game.settings.register(SYSTEM_RDD, SETTINGS_LISTE_MILIEUX, { game.settings.register(SYSTEM_RDD, COMPENDIUMS_RECHERCHE, {
name: "Liste des milieux proposés", name: COMPENDIUMS_RECHERCHE,
hint: "Liste des milieux proposés pour la faune&flore, séparés par des virgules", default: [
SystemCompendiums.getCompendium('faune-flore-mineraux'),
SystemCompendiums.getCompendium('equipement')
],
scope: "world", scope: "world",
config: true, config: false,
default: MILIEUX.reduce(Misc.joining(',')), type: Object
type: String
}); });
game.system.rdd.environnement = new Environnement(); game.system.rdd.environnement = new Environnement();
Hooks.once('ready', () => game.system.rdd.environnement.onReady());
} }
constructor() { constructor() {
this.table = new CompendiumTable('faune-flore-mineraux', 'Item', ITEM_ENVIRONNEMENT_TYPES) this.compendiums = [];
this.compendiumTables = [];
this.mapMilieux = {}
}
async onReady() {
await this.$prepareCompendiums()
} }
async milieux() { async milieux() {
return Object.values(await this.mapMilieux()); return Object.values(this.mapMilieux);
} }
async mapMilieux() { async saveCompendiums(compendiumIds) {
const compendiumItems = await this.getElements(it => 1, it => ITEM_ENVIRONNEMENT_TYPES.includes(it.type)); game.settings.set(SYSTEM_RDD, COMPENDIUMS_RECHERCHE, compendiumIds);
return Misc.indexLowercase(this.getMilieuxSettings().concat(Environnement.listMilieux(compendiumItems))); await this.$prepareCompendiums();
} }
static listMilieux(items) { async $prepareCompendiums() {
return Misc.concat(items.map(it => Environnement.$itemToMilieux(it).filter(m => m))); this.compendiums = game.settings.get(SYSTEM_RDD, COMPENDIUMS_RECHERCHE);
this.compendiumTables = this.compendiums.map(it => new CompendiumTable(it, 'Item'));
const compendiumItems = await this.getElements(it => 1, it => it.isInventaire());
const fromCompendiums = Misc.concat(compendiumItems.map(it => it.getMilieux().filter(m => m)));
this.mapMilieux = Misc.indexLowercase(fromCompendiums);
} }
async autresMilieux(item) { async autresMilieux(item) {
const mapMilieux = await this.mapMilieux(); const milieuxExistants = item.getMilieux().map(it => Grammar.toLowerCaseNoAccent(it));
const milieuxExistants = Environnement.$itemToMilieux(item).map(it => Grammar.toLowerCaseNoAccent(it)); return Object.keys(this.mapMilieux)
return Object.keys(mapMilieux)
.filter(it => !milieuxExistants.includes(it)) .filter(it => !milieuxExistants.includes(it))
.map(it => mapMilieux[it]); .map(it => this.mapMilieux[it]);
}
static $itemToMilieux(item) {
return item.system.environnement.map(env => env.milieu);
}
getMilieuxSettings() {
return game.settings.get(SYSTEM_RDD, SETTINGS_LISTE_MILIEUX).split(',').map(it => it.trim()).filter(it => it != '');
}
async findEnvironnementsLike(search) {
const milieux = await this.mapMilieux();
const searchLower = Grammar.toLowerCaseNoAccent(search);
const keys = Object.keys(milieux).filter(it => it.includes(searchLower));
if (keys.length > 1) {
const milieuExact = milieux[searchLower];
if (milieuExact) {
return [milieuExact];
}
}
return keys.map(k => milieux[k]);
}
async searchToChatMessage(milieux, typeName) {
const table = await this.buildEnvironnementTable(milieux, it => it.isEnvironnement());
await CompendiumTableHelpers.tableToChatMessage(table, 'Item', ITEM_ENVIRONNEMENT_TYPES, typeName);
return true
}
async getRandom(milieux, typeName) {
const table = await this.buildEnvironnementTable(milieux, it => it.isEnvironnement());
return await CompendiumTableHelpers.getRandom(table, 'Item', ITEM_ENVIRONNEMENT_TYPES, undefined, typeName);
}
async buildEnvironnementTable(milieux, filter) {
if (!milieux) {
milieux = await this.milieux()
}
return await this.table.buildTable(it => it.getFrequence(), filter);
} }
async getElements(itemFrequence, filter) { async getElements(itemFrequence, filter) {
return await this.table.getContent(itemFrequence, filter); const compendiumsElement = await Promise.all(
this.compendiumTables.map(async compTable => await compTable.getContent(itemFrequence, filter))
);
return compendiumsElement.reduce((a, b) => a.concat(b))
}
async buildTable(itemFrequence, filter = it => true) {
if (!itemFrequence) {
itemFrequence = it => it.getFrequence()
}
const elements = await this.getElements(itemFrequence, filter);;
return CompendiumTableHelpers.buildTable(elements, itemFrequence);
} }
} }
@ -130,6 +99,8 @@ export class EnvironmentSheetHelper {
} }
static activateListeners(sheet) { static activateListeners(sheet) {
HtmlUtility.showControlWhen(sheet.html.find("div.description-milieu"), TYPE_ITEMS_NATURELS.includes(sheet.item.type));
if (!sheet.options.editable) return; if (!sheet.options.editable) return;
sheet.html.find("input.input-selection-milieu").keypress(event => { sheet.html.find("input.input-selection-milieu").keypress(event => {

30
module/item.js
View File

@ -35,7 +35,7 @@ const typesObjetsConnaissance = ["meditation", "recettealchimique", "sort"]
const typesObjetsEffet = ["possession", "poison", "maladie"] const typesObjetsEffet = ["possession", "poison", "maladie"]
const typesObjetsCompetence = ["competence", "competencecreature"] const typesObjetsCompetence = ["competence", "competencecreature"]
const typesObjetsTemporels = ["poison", "maladie", "queue", "ombre", "souffle", "signedraconique", "rencontre"] const typesObjetsTemporels = ["poison", "maladie", "queue", "ombre", "souffle", "signedraconique", "rencontre"]
const typesEnvironnement = Environnement.typesEnvironnement(); const typesEnvironnement = typesInventaireMateriel;
const encBrin = 0.00005; // un brin = 1 décigramme = 1/10g = 1/10000kg = 1/20000 enc const encBrin = 0.00005; // un brin = 1 décigramme = 1/10g = 1/10000kg = 1/20000 enc
const encPepin = 0.0007; /* un pépin de gemme = 1/10 cm3 = 1/1000 l = 3.5/1000 kg = 7/2000 kg = 7/1000 enc const encPepin = 0.0007; /* un pépin de gemme = 1/10 cm3 = 1/1000 l = 3.5/1000 kg = 7/2000 kg = 7/1000 enc
densité 3.5 (~2.3 à 4, parfois plus) -- https://www.juwelo.fr/guide-des-pierres/faits-et-chiffres/ densité 3.5 (~2.3 à 4, parfois plus) -- https://www.juwelo.fr/guide-des-pierres/faits-et-chiffres/
@ -174,31 +174,33 @@ export class RdDItem extends Item {
isConnaissance() { return typesObjetsConnaissance.includes(this.type) } isConnaissance() { return typesObjetsConnaissance.includes(this.type) }
isInventaire(mode = 'materiel') { return RdDItem.getItemTypesInventaire(mode).includes(this.type); } isInventaire(mode = 'materiel') { return RdDItem.getItemTypesInventaire(mode).includes(this.type); }
isBoisson() { return this.isNourritureBoisson() && this.system.boisson; }
isAlcool() { return this.isNourritureBoisson() && this.system.boisson && this.system.alcoolise; } isAlcool() { return this.isNourritureBoisson() && this.system.boisson && this.system.alcoolise; }
isHerbeAPotion() { return this.type == 'herbe' && (this.system.categorie == 'Soin' || this.system.categorie == 'Repos'); } isHerbeAPotion() { return this.type == 'herbe' && (this.system.categorie == 'Soin' || this.system.categorie == 'Repos'); }
isEnvironnement() { return RdDItem.getItemTypesEnvironnement().includes(this.type) }
isPresentDansMilieux(milieux) { isPresentDansMilieux(milieux) {
return this.getEnvironnements(milieux).length > 0 return this.getEnvironnement(milieux).length > 0
}
getEnvironnements(milieux = undefined) {
return this.isEnvironnement()
? this.system?.environnement.filter(env => !milieux || milieux.includes(env.milieu))
: []
} }
getEnvironnement(milieux = undefined) {
const environnements = this.isInventaire() ? this.system?.environnement ?? [] : [];
return environnements.filter(env => !milieux || milieux.includes(env.milieu))
}
getMilieux() {
return this.getEnvironnement().map(env => env.milieu);
}
getRarete(milieux = undefined) { getRarete(milieux = undefined) {
if (this.isEnvironnement()) {
return RdDRaretes.rareteEnvironnement(this, milieux)
}
if (this.isInventaire()) { if (this.isInventaire()) {
return RdDRaretes.rareteEquipement(this) return RdDRaretes.selonEnvironnement(this, milieux)
} }
return RdDRaretes.rareteFrequente(); return RdDRaretes.rareteFrequente();
} }
getFrequence(milieux = undefined) { getFrequence(milieux = undefined) {
return this.getRarete(milieux)?.frequence ?? 0; return this.getRarete(milieux)?.frequence ?? 0;
} }
getItemGroup() { getItemGroup() {
@ -249,6 +251,7 @@ export class RdDItem extends Item {
console.log(`${this.actor.name}: l'objet ${this.name} a expiré et été supprimé`); console.log(`${this.actor.name}: l'objet ${this.name} a expiré et été supprimé`);
await this.actor?.deleteEmbeddedDocuments('Item', [this.id]); await this.actor?.deleteEmbeddedDocuments('Item', [this.id]);
} }
getUtilisation() { getUtilisation() {
switch (this.type) { switch (this.type) {
case 'nourritureboisson': case 'nourritureboisson':
@ -268,6 +271,7 @@ export class RdDItem extends Item {
} }
return ''; return '';
} }
getUtilisationCuisine() { getUtilisationCuisine() {
if (this.getUtilisation() == 'cuisine') { if (this.getUtilisation() == 'cuisine') {
switch (this.type) { switch (this.type) {

1
module/misc.js
View File

@ -85,6 +85,7 @@ export class Misc {
list.forEach(it => addToObj(obj, it)) list.forEach(it => addToObj(obj, it))
return obj; return obj;
} }
static concat(lists) { static concat(lists) {
return lists.reduce((a, b) => a.concat(b), []); return lists.reduce((a, b) => a.concat(b), []);
} }

28
module/rdd-commands.js
View File

@ -64,7 +64,6 @@ export class RdDCommands {
<br><strong>/table rencontre deso</strong> affiche la table des rencontres en Désolation <br><strong>/table rencontre deso</strong> affiche la table des rencontres en Désolation
<br><strong>/table rencontre mauvaise</strong> affiche la table des mauvaises rencontres` <br><strong>/table rencontre mauvaise</strong> affiche la table des mauvaises rencontres`
}); });
this.registerCommand({ path: ["/table", "milieu"], func: (content, msg, params) => this.tableMilieu(msg, params, 'liste'), descr: "Affiche la table des ressource naturelles pour un milieu donné" });
this.registerCommand({ path: ["/tirer", "comp"], func: (content, msg, params) => RdDRollTables.getCompetence('chat'), descr: "Tire une compétence au hasard" }); this.registerCommand({ path: ["/tirer", "comp"], func: (content, msg, params) => RdDRollTables.getCompetence('chat'), descr: "Tire une compétence au hasard" });
this.registerCommand({ path: ["/tirer", "queue"], func: (content, msg, params) => RdDRollTables.getQueue('chat'), descr: "Tire une Queue de Dragon" }); this.registerCommand({ path: ["/tirer", "queue"], func: (content, msg, params) => RdDRollTables.getQueue('chat'), descr: "Tire une Queue de Dragon" });
@ -76,7 +75,6 @@ export class RdDCommands {
this.registerCommand({ path: ["/tirer", "ideefixe"], func: (content, msg, params) => RdDRollTables.getIdeeFixe('chat'), descr: "Tire une Idée fixe" }); this.registerCommand({ path: ["/tirer", "ideefixe"], func: (content, msg, params) => RdDRollTables.getIdeeFixe('chat'), descr: "Tire une Idée fixe" });
this.registerCommand({ path: ["/tirer", "desir"], func: (content, msg, params) => RdDRollTables.getDesirLancinant('chat'), descr: "Tire un Désir Lancinant" }); this.registerCommand({ path: ["/tirer", "desir"], func: (content, msg, params) => RdDRollTables.getDesirLancinant('chat'), descr: "Tire un Désir Lancinant" });
this.registerCommand({ path: ["/tirer", "rencontre"], func: (content, msg, params) => this.getRencontreTMR(params), descr: `Détermine une rencontre dans les TMR (synonyme de "/tmrr")` }); this.registerCommand({ path: ["/tirer", "rencontre"], func: (content, msg, params) => this.getRencontreTMR(params), descr: `Détermine une rencontre dans les TMR (synonyme de "/tmrr")` });
this.registerCommand({ path: ["/tirer", "milieu"], func: (content, msg, params) => this.tableMilieu(msg, params, 'chat'), descr: "Effectue un tirage dans la table des ressource naturelles pour un milieu donné" });
this.registerCommand({ path: ["/tirage"], func: (content, msg, params) => this.tirage(), descr: "Ouvre la fenêtre de recherche et tirage" }); this.registerCommand({ path: ["/tirage"], func: (content, msg, params) => this.tirage(), descr: "Ouvre la fenêtre de recherche et tirage" });
this.registerCommand({ path: ["/meteo"], func: (content, msg, params) => this.getMeteo(msg, params), descr: "Propose une météo marine" }); this.registerCommand({ path: ["/meteo"], func: (content, msg, params) => this.getMeteo(msg, params), descr: "Propose une météo marine" });
@ -397,32 +395,6 @@ export class RdDCommands {
return false; return false;
} }
async tableMilieu(msg, params, toChat) {
if (params && params.length > 0) {
const search = Misc.join(params, ' ');
const milieux = await game.system.rdd.environnement.findEnvironnementsLike(search);
if (milieux.length == 0) {
const tous = Object.values(await game.system.rdd.environnement.milieux());
return RdDCommands._chatAnswer(msg, `<strong>Aucun milieu correspondant à '${search}'.</strong>
<br>Milieux disponibles:
<br><ul class="chat-list"><li>${tous.reduce(Misc.joining('</li><li>'))}</li></ul>`);
}
if (milieux.length > 1) {
ui.notifications.warn(`<strong>Plusieurs milieux correspondent à '${search}'</strong>:
<br><ul class="chat-list"><li>${milieux.reduce(Misc.joining('</li><li>'))}</li></ul>`);
}
const tableName = `ressources en ${milieux.reduce(Misc.joining(', '))}`;
if (toChat == 'liste') {
return await game.system.rdd.environnement.searchToChatMessage(milieux, tableName);
}
else {
const row = await game.system.rdd.environnement.getRandom(milieux, tableName);
await CompendiumTableHelpers.tableRowToChatMessage(row, 'Item');
return true;
}
}
return false;
}
/* -------------------------------------------- */ /* -------------------------------------------- */
getCoutXpComp(msg, params) { getCoutXpComp(msg, params) {
if (params && (params.length == 1 || params.length == 2)) { if (params && (params.length == 1 || params.length == 2)) {

1
module/rdd-main.js
View File

@ -183,7 +183,6 @@ export class SystemReveDeDragon {
RdDPossession.init(); RdDPossession.init();
TMRRencontres.init(); TMRRencontres.init();
Environnement.init(); Environnement.init();
FenetreRechercheTirage.init();
Hooks.once('ready', () => this.onReady()); Hooks.once('ready', () => this.onReady());
} }

97
module/tirage/fenetre-recherche-tirage.js
View File

@ -1,9 +1,8 @@
import { RdDItem } from '../item.js'; import { RdDItem } from '../item.js';
import { HtmlUtility } from '../html-utility.js'; import { HtmlUtility } from '../html-utility.js';
import { Misc } from "../misc.js"; import { Misc } from "../misc.js";
import { CompendiumTable, CompendiumTableHelpers, SystemCompendiums } from '../settings/system-compendiums.js'; import { CompendiumTableHelpers } from '../settings/system-compendiums.js';
import { RdDRaretes } from './raretes.js'; import { RdDRaretes } from './raretes.js';
import { SYSTEM_RDD } from '../constants.js';
const FILTER_GROUPS = [ const FILTER_GROUPS = [
{ group: 'type', label: "Type d'objet" }, { group: 'type', label: "Type d'objet" },
@ -17,18 +16,17 @@ const FILTER_GROUPS = [
] ]
const FILTERS = [ const FILTERS = [
{ group: 'comestible', code: 'pret', label: 'Préparé', check: item => item.getUtilisationCuisine() == 'pret' },
{ group: 'comestible', code: 'comestible', label: 'Comestible', check: item => item.getUtilisation() == 'cuisine' }, { group: 'comestible', code: 'comestible', label: 'Comestible', check: item => item.getUtilisation() == 'cuisine' },
{ group: 'comestible', code: 'boisson', label: 'Boisson', check: item => item.isNourritureBoisson() && item.system.boisson }, { group: 'comestible', code: 'pret', label: 'Préparé', check: item => item.getUtilisationCuisine() == 'pret' },
{ group: 'comestible', code: 'alcool', label: 'Alcool', check: item => item.isAlcool() },
{ group: 'comestible', code: 'brut', label: 'A préparer', check: item => item.getUtilisationCuisine() == 'brut' }, { group: 'comestible', code: 'brut', label: 'A préparer', check: item => item.getUtilisationCuisine() == 'brut' },
{ group: 'comestible', code: 'non', label: 'Immangeable', check: item => item.isEnvironnement() && !item.getUtilisationCuisine() }, { group: 'comestible', code: 'boisson', label: 'Boisson', check: item => item.isBoisson() },
{ group: 'comestible', code: 'alcool', label: 'Alcool', check: item => item.isAlcool() },
{ group: 'comestible', code: 'immangeable', label: 'Immangeable', check: item => item.isInventaire() && item.getUtilisation() != 'cuisine' },
{ group: 'categorie', code: 'alchimie', label: 'Alchimique', check: item => item.isEnvironnement() && item.getUtilisation() == 'alchimie' }, { group: 'categorie', code: 'alchimie', label: 'Alchimique', check: item => item.isInventaire() && item.getUtilisation() == 'alchimie' },
{ group: 'categorie', code: 'cuisine', label: 'Cuisine', check: item => item.isEnvironnement() && item.getUtilisation() == 'cuisine' }, { group: 'categorie', code: 'soins', label: 'Médical', check: item => item.isInventaire() && item.getUtilisation() == 'soins' },
{ group: 'categorie', code: 'soins', label: 'Médical', check: item => item.isEnvironnement() && item.getUtilisation() == 'soins' }, { group: 'categorie', code: 'poison', label: 'Toxique', check: item => item.isInventaire() && item.getUtilisation() == 'poison' },
{ group: 'categorie', code: 'cpoison', label: 'Toxique', check: item => item.isEnvironnement() && item.getUtilisation() == 'poison' }, { group: 'categorie', code: 'autres', label: 'Autres', check: item => !item.isInventaire() || item.getUtilisation() == '' },
{ group: 'categorie', code: 'autres', label: 'Autres', check: item => !item.isEnvironnement() || item.getUtilisation() == '' },
{ group: "qualite", code: "mauvaise", label: "Mauvaise (négative)", check: item => item.isInventaire() && item.system.qualite < 0 }, { group: "qualite", code: "mauvaise", label: "Mauvaise (négative)", check: item => item.isInventaire() && item.system.qualite < 0 },
{ group: "qualite", code: "quelconque", label: "Quelconque (0)", check: item => item.isInventaire() && item.system.qualite == 0 }, { group: "qualite", code: "quelconque", label: "Quelconque (0)", check: item => item.isInventaire() && item.system.qualite == 0 },
@ -45,13 +43,12 @@ const FILTERS = [
{ group: "enc", code: "anemort", label: "Un âne mort (plus de 10)", check: item => item.isInventaire() && 10 < item.system.encombrement }, { group: "enc", code: "anemort", label: "Un âne mort (plus de 10)", check: item => item.isInventaire() && 10 < item.system.encombrement },
{ group: "prix", code: "gratuit", label: "Gratuit", check: item => item.isInventaire() && item.system.cout == 0 }, { group: "prix", code: "gratuit", label: "Gratuit", check: item => item.isInventaire() && item.system.cout == 0 },
{ group: "prix", code: "deniers", label: "Deniers (étain) 1-9", check: item => item.isInventaire() && 0 < item.system.cout && item.system.cout < 0.1 }, { group: "prix", code: "deniers", label: "Deniers (étain)", check: item => item.isInventaire() && 0 < item.system.cout && item.system.cout < 0.1 },
{ group: "prix", code: "bronze", label: "Bronzes 1-9", check: item => item.isInventaire() && 0.1 <= item.system.cout && item.system.cout < 1 }, { group: "prix", code: "bronze", label: "Sous (bronze)", check: item => item.isInventaire() && 0.1 <= item.system.cout && item.system.cout < 1 },
{ group: "prix", code: "sols", label: "Sols (argent) 1-9", check: item => item.isInventaire() && 1 <= item.system.cout && item.system.cout < 10 }, { group: "prix", code: "sols", label: "Sols (argent)", check: item => item.isInventaire() && 1 <= item.system.cout && item.system.cout < 10 },
{ group: "prix", code: "dragons", label: "Dragons (or) 1+ ", check: item => item.isInventaire() && 10 <= item.system.cout }, { group: "prix", code: "dragons", label: "Dragons (or)", check: item => item.isInventaire() && 10 <= item.system.cout },
] ]
const COMPENDIUMS_RECHERCHE = 'compendiums-recherche';
function $typeToFilter(type) { return { group: 'type', code: type, label: Misc.typeName('Item', type), check: item => item.type == type }; } function $typeToFilter(type) { return { group: 'type', code: type, label: Misc.typeName('Item', type), check: item => item.type == type }; }
@ -66,12 +63,7 @@ function $filterRarete() {
} }
function $filterTypes() { function $filterTypes() {
return [ return RdDItem.getItemTypesInventaire().map(it => $typeToFilter(it));
{ group: 'type', code: 'inventaire', label: 'Inventaire', check: item => item.isInventaire() && !item.isEnvironnement() },
]
.concat(['arme', 'armure'].map(it => $typeToFilter(it)))
.concat([{ group: 'type', code: 'environement', label: 'Faune, Flore, Ingrédients', check: item => item.isEnvironnement() }])
.concat(RdDItem.getItemTypesEnvironnement().map(it => $typeToFilter(it)))
} }
function $getAllFilters(milieux) { function $getAllFilters(milieux) {
@ -106,20 +98,6 @@ function $loadFilters(parameters) {
export class FenetreRechercheTirage extends Application { export class FenetreRechercheTirage extends Application {
static init() {
game.settings.register(SYSTEM_RDD, COMPENDIUMS_RECHERCHE, {
name: COMPENDIUMS_RECHERCHE,
default: [
SystemCompendiums.getCompendium('faune-flore-mineraux'),
SystemCompendiums.getCompendium('equipement')
],
scope: "world",
config: false,
type: Object
});
}
static get defaultOptions() { static get defaultOptions() {
return mergeObject(super.defaultOptions, { return mergeObject(super.defaultOptions, {
template: "systems/foundryvtt-reve-de-dragon/templates/tirage/fenetre-recherche-tirage.hbs", template: "systems/foundryvtt-reve-de-dragon/templates/tirage/fenetre-recherche-tirage.hbs",
@ -146,12 +124,6 @@ export class FenetreRechercheTirage extends Application {
constructor(parameters, options) { constructor(parameters, options) {
super(options); super(options);
this.parameters = parameters; this.parameters = parameters;
this.buildCompendiumTables();
}
buildCompendiumTables() {
this.parameters.compendiums = game.settings.get(SYSTEM_RDD, COMPENDIUMS_RECHERCHE);
this.parameters.compendiumTables = this.parameters.compendiums.map(it => new CompendiumTable(it, 'Item'));
} }
async getData() { async getData() {
@ -219,11 +191,7 @@ export class FenetreRechercheTirage extends Application {
} }
async buildTable() { async buildTable() {
const filter = this.buildCheckedItemsFilter(); return await game.system.rdd.environnement.buildTable(it => it.getFrequence(), this.buildCheckedItemsFilter())
const allTables = await Promise.all(
this.parameters.compendiumTables.map(async compTable => await compTable.buildTable(it => it.getFrequence(), filter))
);
return CompendiumTableHelpers.concatTables(...allTables);
} }
buildCheckedItemsFilter() { buildCheckedItemsFilter() {
@ -271,30 +239,21 @@ export class FenetreRechercheTirage extends Application {
} }
async configurer() { async configurer() {
const itemPacks = game.packs.filter(it => it.metadata.type == 'Item'); FenetreRechercheConfiguration.create();
console.log('packs1', itemPacks);
const configuration = {
compendiums: itemPacks.map(it => duplicate(it.metadata)).map(it => mergeObject(it, { selected: this.parameters.compendiums.includes(it.id) }))
}
FenetreRechercheConfiguration.create(configuration, c => this.setConfiguration(c));
} }
setConfiguration(configuration) {
const compendiums = configuration.compendiums.filter(it => it.selected).map(it => it.id);
game.settings.set(SYSTEM_RDD, COMPENDIUMS_RECHERCHE, compendiums);
this.buildCompendiumTables()
}
} }
class FenetreRechercheConfiguration extends Dialog { class FenetreRechercheConfiguration extends Dialog {
static async create(configuration, onSave) { static async create() {
const configuration = {
compendiums: game.packs.filter(it => it.metadata.type == 'Item').map(it => it.metadata)
.map(it => mergeObject({ selected: game.system.rdd.environnement.compendiums.includes(it.id) }, it))
}
const html = await renderTemplate("systems/foundryvtt-reve-de-dragon/templates/tirage/fenetre-recherche-configuration.hbs", configuration); const html = await renderTemplate("systems/foundryvtt-reve-de-dragon/templates/tirage/fenetre-recherche-configuration.hbs", configuration);
new FenetreRechercheConfiguration(html, configuration, onSave).render(true); new FenetreRechercheConfiguration(html).render(true);
} }
constructor(html, configuration, onSave) { constructor(html) {
const options = { const options = {
classes: ["fenetre-recherche-configuration"], classes: ["fenetre-recherche-configuration"],
width: 600, width: 600,
@ -307,12 +266,12 @@ class FenetreRechercheConfiguration extends Dialog {
title: 'Configuration de la recherche', title: 'Configuration de la recherche',
content: html, content: html,
buttons: { buttons: {
"Sauvegarder": { label: "Sauvegarder", callback: async it => { await this.sauvegarder(); } }
} }
}; };
super(conf, options) super(conf, options)
this.configuration = configuration;
this.onSave = onSave;
} }
activateListeners(html) { activateListeners(html) {
this.html = html; this.html = html;
super.activateListeners(html); super.activateListeners(html);
@ -323,9 +282,7 @@ class FenetreRechercheConfiguration extends Dialog {
const compendiumIds = jQuery.map(this.html.find("input.select-compendium:checked"), it => { const compendiumIds = jQuery.map(this.html.find("input.select-compendium:checked"), it => {
return this.html.find(it).data('id'); return this.html.find(it).data('id');
}); });
this.configuration.compendiums.forEach(c => { await game.system.rdd.environnement.saveCompendiums(compendiumIds);
c.selected = compendiumIds.includes(c.id) this.close();
})
this.onSave(this.configuration)
} }
} }

22
module/tirage/raretes.js
View File

@ -1,3 +1,4 @@
const RARETE_COMMUNE = { code: 'Commune', label: 'Commune', frequence: 54, min: 27, max: 108 }; const RARETE_COMMUNE = { code: 'Commune', label: 'Commune', frequence: 54, min: 27, max: 108 };
const RARETE_FREQUENTE = { code: 'Frequente', label: 'Fréquente', frequence: 18, min: 9, max: 36 }; const RARETE_FREQUENTE = { code: 'Frequente', label: 'Fréquente', frequence: 18, min: 9, max: 36 };
const RARETE_RARE = { code: 'Rare', label: 'Rare', frequence: 6, min: 3, max: 12 }; const RARETE_RARE = { code: 'Rare', label: 'Rare', frequence: 6, min: 3, max: 12 };
@ -31,19 +32,20 @@ export class RdDRaretes {
return RARETES; return RARETES;
} }
static frequenceEquipement(item) { static selonEnvironnement(item, milieux = undefined) {
return RdDRaretes.rareteEquipement(item).frequence const list = item.getEnvironnement(milieux);
}
static rareteEnvironnement(item, milieux = undefined) {
const list = item.getEnvironnements(milieux);
const freqMax = Math.max(0, ...list.map(env => env.frequence)); const freqMax = Math.max(0, ...list.map(env => env.frequence));
const env = list.find(env => env.frequence == freqMax); const env = list.find(env => env.frequence == freqMax);
return env ? RdDRaretes.getRarete(env.rarete) : RARETE_INEXISTANT; if (env) {
return RdDRaretes.getRarete(env.rarete)
}
if (milieux == undefined) {
return RdDRaretes.selonQualite(item)
}
return RARETE_INEXISTANT;
} }
static rareteEquipement(item) {
static selonQualite(item) {
const qualite = item.system.qualite ?? 0; const qualite = item.system.qualite ?? 0;
if (qualite <= 0) { if (qualite <= 0) {
return RARETE_COMMUNE return RARETE_COMMUNE

2
templates/item/partial-environnement.html
View File

@ -1,6 +1,6 @@
{{>'systems/foundryvtt-reve-de-dragon/templates/scripts/autocomplete-script.hbs'}} {{>'systems/foundryvtt-reve-de-dragon/templates/scripts/autocomplete-script.hbs'}}
<div class="tab items" data-group="primary" data-tab="environnement"> <div class="tab items" data-group="primary" data-tab="environnement">
<div class="form-group"> <div class="form-group description-milieu">
<label>Description du milieu</label> <label>Description du milieu</label>
<span class="flexrow"> <span class="flexrow">
<input class="attribute-value" type="text" name="system.milieu" value="{{system.milieu}}" data-dtype="String" /> <input class="attribute-value" type="text" name="system.milieu" value="{{system.milieu}}" data-dtype="String" />

3
templates/tirage/fenetre-recherche-configuration.hbs
View File

@ -15,8 +15,5 @@
{{/each}} {{/each}}
</ul> </ul>
</div> </div>
<div class="form-group">
<button class="configuration-save">Sauvegarder</button>
</div>
</form> </form>