forked from public/foundryvtt-wh4-lang-fr-fr
Ajout de la commande /voyage et grosse MAJK de la commande /auberge
This commit is contained in:
@@ -82,39 +82,8 @@ const _patch_up_in_arms = () => {
|
||||
}
|
||||
|
||||
/************************************************************************************/
|
||||
/* Manages /auberge command */
|
||||
const _manage_inn_roll = async (content, msg) => {
|
||||
// Split input into arguments
|
||||
let command = content.split(" ").map(function (item) {
|
||||
return item.trim();
|
||||
})
|
||||
|
||||
console.log("COMMANDES", command);
|
||||
if (command[0] == "/auberge" && command[1]) {
|
||||
msg["type"] = 0;
|
||||
msg["rollMode"] = "gmroll";
|
||||
let compendium = game.packs.get('wh4-fr-translation.plats-dauberges')
|
||||
game.packs.get(compendium);
|
||||
let rollList = await compendium.getDocuments()
|
||||
for (const element of rollList) {
|
||||
let rollTab = element;
|
||||
console.log("Got compendium...", rollList, rollTab.name);
|
||||
if (rollTab.name.toLowerCase().includes(command[1].toLowerCase())) {
|
||||
let my_rollTable;
|
||||
await compendium.getDocument(rollTab._id).then(mytab => my_rollTable = mytab);
|
||||
my_rollTable.draw({ rollMode: "gmroll" });
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (content.includes("/auberge")) {
|
||||
msg["type"] = 0;
|
||||
msg["rollMode"] = "gmroll";
|
||||
msg["content"] = "Syntaxe : /auberge MOT_CLE, avec MOT_CLE parmi:<br>BoissonsBase, BoissonsFortes, Desserts, PlatsCommuns, PlatsExcellents, PlatsMaritimes, PlatsMédiocres, PlatsQualité, PlatsRivières<br>Des raccourcis sont possibles avec une partie du nom : /auberge Base (correspond à BoissonBase) ou /auberge Mari (correspond à PlatsMaritimes), etc."
|
||||
ChatMessage.create(msg);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
/* Module /auberge géré par modules/inn/inn-init.js */
|
||||
// L'ancienne implémentation a été migrée vers le module inn pour cohérence avec /voyage
|
||||
|
||||
/************************************************************************************/
|
||||
let __eis_tables = {
|
||||
@@ -262,17 +231,13 @@ const __check_fix_wrong_modules = (chatFlag, patchFinished) => {
|
||||
}
|
||||
} else if (game.user.isGM && patchFinished) {
|
||||
ChatMessage.create({
|
||||
content: "<div>Les modules WFRP4E ont été <strong>patchés avec succés</strong>. Vous pouvez y aller et que <strong>Shallya vous garde !</strong></div><div>Derniers changements : Support WFRP4E v8.3.X</div></ul>",
|
||||
content: "<div>Les modules WFRP4E ont été <strong>patchés avec succés</strong>. Vous pouvez y aller et que <strong>Shallya vous garde !</strong><div><div>Derniers changements : <ul><li>Ajout de la commande /voyage !</li><li>Améliorations de la commande /auberge</li></ul></div>",
|
||||
user: game.user.id,
|
||||
whisper: ChatMessage.getWhisperRecipients("GM")
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
const __history = [
|
||||
"Nouveautés 9.0.0: <ul><li>Support Foundry v13 et diverses petites corrections !</li></ul>"
|
||||
]
|
||||
|
||||
/************************************************************************************/
|
||||
const convertColumnToMulti = (table) => {
|
||||
let columns = table.columns;
|
||||
@@ -366,14 +331,8 @@ const __add_actors_translation = () => {
|
||||
|
||||
|
||||
/************************************************************************************/
|
||||
/* Hook for specific command */
|
||||
Hooks.on("chatMessage", (html, content, msg) => {
|
||||
|
||||
if (content.toLowerCase().includes('auberge')) {
|
||||
_manage_inn_roll(content, msg);
|
||||
return false;
|
||||
}
|
||||
});
|
||||
/* Hook for specific command - Module /auberge migré vers modules/inn/ */
|
||||
// La commande /auberge est désormais gérée par le module inn-init.js
|
||||
|
||||
/************************************************************************************/
|
||||
/* Additionnal hooks ready */
|
||||
|
||||
410
modules/inn/InnRoller.js
Normal file
410
modules/inn/InnRoller.js
Normal file
@@ -0,0 +1,410 @@
|
||||
/**
|
||||
* InnRoller
|
||||
* Classe de gestion des jets de tables d'auberge pour WFRP4e
|
||||
* Module de traduction française
|
||||
*/
|
||||
|
||||
export default class InnRoller {
|
||||
static tableNames = {
|
||||
'boissonsbase': 'BoissonsBase',
|
||||
'boissonsfortes': 'BoissonsFortes',
|
||||
'desserts': 'Desserts',
|
||||
'platscommuns': 'PlatsCommuns',
|
||||
'platsexcellents': 'PlatsExcellents',
|
||||
'platsmaritimes': 'PlatsMaritimes',
|
||||
'platsmediocres': 'PlatsMédiocres',
|
||||
'platsqualite': 'PlatsQualité',
|
||||
'platsrivieres': 'PlatsRivières'
|
||||
};
|
||||
|
||||
static displayNames = {
|
||||
'BoissonsBase': 'Boissons de Base',
|
||||
'BoissonsFortes': 'Boissons Fortes',
|
||||
'Desserts': 'Desserts',
|
||||
'PlatsCommuns': 'Plats Communs',
|
||||
'PlatsExcellents': 'Plats Excellents',
|
||||
'PlatsMaritimes': 'Plats Maritimes',
|
||||
'PlatsMédiocres': 'Plats Médiocres',
|
||||
'PlatsQualité': 'Plats de Qualité',
|
||||
'PlatsRivières': 'Plats de Rivières'
|
||||
};
|
||||
|
||||
/**
|
||||
* Obtient le nom d'affichage formaté pour une table
|
||||
* @param {String} tableName
|
||||
* @returns {String}
|
||||
*/
|
||||
static getDisplayName(tableName) {
|
||||
return this.displayNames[tableName] || tableName;
|
||||
}
|
||||
|
||||
/**
|
||||
* Normalise le nom d'une table (enlève accents, espaces, met en minuscules)
|
||||
* @param {String} name
|
||||
* @returns {String}
|
||||
*/
|
||||
static normalizeTableName(name) {
|
||||
return name
|
||||
.toLowerCase()
|
||||
.normalize("NFD")
|
||||
.replace(/[\u0300-\u036f]/g, "")
|
||||
.replace(/\s+/g, '');
|
||||
}
|
||||
|
||||
/**
|
||||
* Trouve la table correspondant au mot-clé
|
||||
* @param {String} keyword
|
||||
* @returns {String|null}
|
||||
*/
|
||||
static findTableByKeyword(keyword) {
|
||||
if (!keyword) return null;
|
||||
|
||||
const normalized = this.normalizeTableName(keyword);
|
||||
|
||||
// Recherche exacte
|
||||
if (this.tableNames[normalized]) {
|
||||
return this.tableNames[normalized];
|
||||
}
|
||||
|
||||
// Recherche partielle
|
||||
for (let [key, value] of Object.entries(this.tableNames)) {
|
||||
if (key.includes(normalized) || normalized.includes(key)) {
|
||||
return value;
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Lance un jet sur une table d'auberge
|
||||
* @param {String} keyword Mot-clé pour identifier la table
|
||||
*/
|
||||
static async rollInnTable(keyword) {
|
||||
console.log(`InnRoller: rollInnTable appelé avec keyword="${keyword}"`);
|
||||
|
||||
// Si pas de keyword, afficher l'aide
|
||||
if (!keyword) {
|
||||
this.displayHelp();
|
||||
return;
|
||||
}
|
||||
|
||||
// Rechercher la table
|
||||
const tableName = this.findTableByKeyword(keyword);
|
||||
|
||||
if (!tableName) {
|
||||
this.displayHelp();
|
||||
ui.notifications.warn(`Table d'auberge introuvable pour le mot-clé: "${keyword}"`);
|
||||
return;
|
||||
}
|
||||
|
||||
console.log(`InnRoller: Table trouvée: ${tableName}`);
|
||||
|
||||
// Charger le compendium
|
||||
const compendium = game.packs.get('wh4-fr-translation.plats-dauberges');
|
||||
|
||||
if (!compendium) {
|
||||
ui.notifications.error("Compendium 'plats-dauberges' introuvable");
|
||||
console.error("InnRoller: Compendium wh4-fr-translation.plats-dauberges non trouvé");
|
||||
return;
|
||||
}
|
||||
|
||||
// Récupérer les tables
|
||||
const tables = await compendium.getDocuments();
|
||||
|
||||
// Trouver la table correspondante
|
||||
const rollTable = tables.find(t => t.name === tableName);
|
||||
|
||||
if (!rollTable) {
|
||||
ui.notifications.error(`Table "${tableName}" non trouvée dans le compendium`);
|
||||
console.error(`InnRoller: Table ${tableName} non trouvée`);
|
||||
return;
|
||||
}
|
||||
|
||||
console.log(`InnRoller: Jet sur la table ${rollTable.name}`);
|
||||
|
||||
// Effectuer le jet sans affichage automatique
|
||||
try {
|
||||
const roll = await rollTable.draw({ displayChat: false });
|
||||
console.log(`InnRoller: Jet effectué avec succès`, roll);
|
||||
|
||||
// Créer un message personnalisé
|
||||
await this.displayRollResult(rollTable.name, roll);
|
||||
} catch (error) {
|
||||
console.error("InnRoller: Erreur lors du jet:", error);
|
||||
ui.notifications.error("Erreur lors du jet sur la table d'auberge");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Affiche le résultat d'un jet de table avec un style personnalisé
|
||||
* @param {String} tableName Nom de la table
|
||||
* @param {Object} rollResult Résultat du jet
|
||||
*/
|
||||
static async displayRollResult(tableName, rollResult) {
|
||||
// Déterminer l'icône en fonction du type de table
|
||||
let icon = "fa-utensils";
|
||||
let category = "Plat";
|
||||
|
||||
if (tableName.toLowerCase().includes('boisson')) {
|
||||
icon = "fa-wine-glass";
|
||||
category = "Boisson";
|
||||
} else if (tableName.toLowerCase().includes('dessert')) {
|
||||
icon = "fa-birthday-cake";
|
||||
category = "Dessert";
|
||||
}
|
||||
|
||||
// Extraire les informations du résultat
|
||||
const resultText = rollResult.results[0]?.text || "Résultat inconnu";
|
||||
const rollFormula = rollResult.roll?.formula || "1d100";
|
||||
const rollTotal = rollResult.roll?.total || 0;
|
||||
|
||||
// Construire le message HTML simplifié
|
||||
let message = `<div class="wfrp4e-inn-result">`;
|
||||
message += `<div class="message-header">`;
|
||||
message += `<i class="fas ${icon}"></i> `;
|
||||
message += `<span class="flavor-text">${category}: ${tableName}</span>`;
|
||||
message += `</div>`;
|
||||
message += `<div class="inn-dish-name">${resultText}</div>`;
|
||||
message += `<div class="inn-roll-info"><i class="fas fa-dice"></i> ${rollFormula} = ${rollTotal}</div>`;
|
||||
message += `</div>`;
|
||||
|
||||
// Créer le message dans le chat
|
||||
await ChatMessage.create({
|
||||
content: message,
|
||||
speaker: ChatMessage.getSpeaker(),
|
||||
whisper: ChatMessage.getWhisperRecipients("GM")
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Affiche l'aide pour la commande /auberge avec liste cliquable
|
||||
*/
|
||||
static displayHelp() {
|
||||
let message = `<div class="wfrp4e-inn-help">`;
|
||||
message += `<h3><i class="fas fa-utensils"></i> Aide pour /auberge</h3>`;
|
||||
message += `<p><strong>Usage:</strong> <code>/auberge [mot_clé]</code></p>`;
|
||||
|
||||
// Bouton Menu
|
||||
message += `<div style="margin: 0.8em 0;">`;
|
||||
message += `<a class="action-link inn-menu-quick-btn" data-action="clickAubergeMenu" data-quality="menu">`;
|
||||
message += `<i class="fas fa-book-open"></i> Générer un menu complet`;
|
||||
message += `</a>`;
|
||||
message += `</div>`;
|
||||
|
||||
message += `<hr>`;
|
||||
|
||||
// Section avec liste cliquable
|
||||
message += `<h4><i class="fas fa-list"></i> Tables disponibles</h4>`;
|
||||
message += `<div class="wfrp4e-inn-table-grid">`;
|
||||
|
||||
const sortedTables = Object.values(this.tableNames).sort();
|
||||
for (let tableName of sortedTables) {
|
||||
const normalized = this.normalizeTableName(tableName);
|
||||
const displayName = this.getDisplayName(tableName);
|
||||
message += `<a class="action-link inn-table-btn" data-action="clickAuberge" data-table="${normalized}">`;
|
||||
message += `<i class="fas fa-dice"></i> ${displayName}`;
|
||||
message += `</a>`;
|
||||
}
|
||||
|
||||
message += `</div>`;
|
||||
message += `<hr>`;
|
||||
message += `<p style="font-size: 0.9em; margin-top: 0.5em;"><em>Vous pouvez aussi taper <code>/auberge [mot_clé]</code> directement (ex: <code>/auberge base</code>)</em></p>`;
|
||||
message += `</div>`;
|
||||
|
||||
ChatMessage.create({
|
||||
content: message,
|
||||
whisper: ChatMessage.getWhisperRecipients("GM")
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Liste toutes les tables disponibles
|
||||
*/
|
||||
static listTables() {
|
||||
let message = `<div class="wfrp4e-inn-list">`;
|
||||
message += `<h3><i class="fas fa-list"></i> Tables d'auberge disponibles</h3>`;
|
||||
message += `<div class="wfrp4e-inn-table-grid">`;
|
||||
|
||||
const sortedTables = Object.values(this.tableNames).sort();
|
||||
for (let tableName of sortedTables) {
|
||||
const normalized = this.normalizeTableName(tableName);
|
||||
const displayName = this.getDisplayName(tableName);
|
||||
message += `<a class="action-link inn-table-btn" data-action="clickAuberge" data-table="${normalized}">`;
|
||||
message += `<i class="fas fa-dice"></i> ${displayName}`;
|
||||
message += `</a>`;
|
||||
}
|
||||
|
||||
message += `</div>`;
|
||||
message += `</div>`;
|
||||
|
||||
ChatMessage.create({
|
||||
content: message,
|
||||
whisper: ChatMessage.getWhisperRecipients("GM")
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Affiche le choix de qualité pour générer un menu complet
|
||||
*/
|
||||
static displayMenuChoice() {
|
||||
let message = `<div class="wfrp4e-inn-menu-choice">`;
|
||||
message += `<h3><i class="fas fa-book-open"></i> Menu de l'auberge</h3>`;
|
||||
message += `<p>Choisissez la qualité du menu :</p>`;
|
||||
message += `<div class="inn-menu-buttons">`;
|
||||
|
||||
message += `<a class="action-link inn-menu-btn" data-action="clickAubergeMenu" data-quality="mediocre">`;
|
||||
message += `<i class="fas fa-drumstick-bite"></i> Menu Médiocre`;
|
||||
message += `<br><span class="inn-menu-desc">Plat médiocre + Boisson de base</span>`;
|
||||
message += `</a>`;
|
||||
|
||||
message += `<a class="action-link inn-menu-btn" data-action="clickAubergeMenu" data-quality="commun">`;
|
||||
message += `<i class="fas fa-utensils"></i> Menu Commun`;
|
||||
message += `<br><span class="inn-menu-desc">Plat commun + Boisson de base + Dessert</span>`;
|
||||
message += `</a>`;
|
||||
|
||||
message += `<a class="action-link inn-menu-btn" data-action="clickAubergeMenu" data-quality="qualite">`;
|
||||
message += `<i class="fas fa-crown"></i> Menu de Qualité`;
|
||||
message += `<br><span class="inn-menu-desc">Plat de qualité + Boisson forte + Dessert</span>`;
|
||||
message += `</a>`;
|
||||
|
||||
message += `<a class="action-link inn-menu-btn" data-action="clickAubergeMenu" data-quality="fluvial">`;
|
||||
message += `<i class="fas fa-fish"></i> Menu Fluvial`;
|
||||
message += `<br><span class="inn-menu-desc">Plat de rivière + Boisson de base + Dessert</span>`;
|
||||
message += `</a>`;
|
||||
|
||||
message += `<a class="action-link inn-menu-btn" data-action="clickAubergeMenu" data-quality="maritime">`;
|
||||
message += `<i class="fas fa-anchor"></i> Menu Maritime`;
|
||||
message += `<br><span class="inn-menu-desc">Plat maritime + Boisson forte + Dessert</span>`;
|
||||
message += `</a>`;
|
||||
|
||||
message += `<a class="action-link inn-menu-btn" data-action="clickAubergeMenu" data-quality="excellent">`;
|
||||
message += `<i class="fas fa-gem"></i> Menu Excellent`;
|
||||
message += `<br><span class="inn-menu-desc">Plat excellent + Boisson forte + Dessert</span>`;
|
||||
message += `</a>`;
|
||||
|
||||
message += `</div>`;
|
||||
message += `</div>`;
|
||||
|
||||
ChatMessage.create({
|
||||
content: message,
|
||||
whisper: ChatMessage.getWhisperRecipients("GM")
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Génère un menu complet selon la qualité choisie
|
||||
* @param {String} quality - 'mediocre', 'commun', ou 'qualite'
|
||||
*/
|
||||
static async generateMenu(quality) {
|
||||
console.log(`InnRoller: generateMenu appelé avec quality="${quality}"`);
|
||||
|
||||
let tables = [];
|
||||
let menuName = "";
|
||||
|
||||
// Définir les tables à tirer selon la qualité
|
||||
switch(quality) {
|
||||
case 'mediocre':
|
||||
menuName = "Menu Médiocre";
|
||||
tables = ['PlatsMédiocres', 'BoissonsBase'];
|
||||
break;
|
||||
case 'commun':
|
||||
menuName = "Menu Commun";
|
||||
tables = ['PlatsCommuns', 'BoissonsBase', 'Desserts'];
|
||||
break;
|
||||
case 'qualite':
|
||||
menuName = "Menu de Qualité";
|
||||
tables = ['PlatsQualité', 'BoissonsFortes', 'Desserts'];
|
||||
break;
|
||||
case 'fluvial':
|
||||
menuName = "Menu Fluvial";
|
||||
tables = ['PlatsRivières', 'BoissonsBase', 'Desserts'];
|
||||
break;
|
||||
case 'maritime':
|
||||
menuName = "Menu Maritime";
|
||||
tables = ['PlatsMaritimes', 'BoissonsFortes', 'Desserts'];
|
||||
break;
|
||||
case 'excellent':
|
||||
menuName = "Menu Excellent";
|
||||
tables = ['PlatsExcellents', 'BoissonsFortes', 'Desserts'];
|
||||
break;
|
||||
default:
|
||||
ui.notifications.error(`Qualité de menu inconnue: ${quality}`);
|
||||
return;
|
||||
}
|
||||
|
||||
// Charger le compendium
|
||||
const compendium = game.packs.get('wh4-fr-translation.plats-dauberges');
|
||||
if (!compendium) {
|
||||
ui.notifications.error("Compendium 'plats-dauberges' introuvable");
|
||||
return;
|
||||
}
|
||||
|
||||
const allTables = await compendium.getDocuments();
|
||||
let results = [];
|
||||
|
||||
// Effectuer les jets sur chaque table
|
||||
for (let tableName of tables) {
|
||||
const rollTable = allTables.find(t => t.name === tableName);
|
||||
if (rollTable) {
|
||||
try {
|
||||
const roll = await rollTable.draw({ displayChat: false });
|
||||
const resultText = roll.results[0]?.text || "Résultat inconnu";
|
||||
results.push({
|
||||
category: this.getCategoryName(tableName),
|
||||
name: resultText,
|
||||
tableName: tableName
|
||||
});
|
||||
} catch (error) {
|
||||
console.error(`InnRoller: Erreur lors du jet sur ${tableName}:`, error);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Afficher le menu complet
|
||||
this.displayMenuResult(menuName, results);
|
||||
}
|
||||
|
||||
/**
|
||||
* Obtient le nom de catégorie pour une table
|
||||
* @param {String} tableName
|
||||
* @returns {String}
|
||||
*/
|
||||
static getCategoryName(tableName) {
|
||||
if (tableName.includes('Boisson')) return 'Boisson';
|
||||
if (tableName.includes('Dessert')) return 'Dessert';
|
||||
if (tableName.includes('Plat')) return 'Plat';
|
||||
return 'Item';
|
||||
}
|
||||
|
||||
/**
|
||||
* Affiche le résultat d'un menu complet
|
||||
* @param {String} menuName
|
||||
* @param {Array} results
|
||||
*/
|
||||
static async displayMenuResult(menuName, results) {
|
||||
let message = `<div class="wfrp4e-inn-menu-result">`;
|
||||
message += `<div class="message-header">`;
|
||||
message += `<i class="fas fa-book-open"></i> `;
|
||||
message += `<span class="flavor-text">${menuName}</span>`;
|
||||
message += `</div>`;
|
||||
|
||||
message += `<div class="inn-menu-items">`;
|
||||
for (let result of results) {
|
||||
message += `<div class="inn-menu-item">`;
|
||||
let icon = result.category === 'Boisson' ? 'fa-wine-glass' :
|
||||
result.category === 'Dessert' ? 'fa-birthday-cake' : 'fa-utensils';
|
||||
message += `<i class="fas ${icon}"></i> `;
|
||||
message += `<strong>${result.category}:</strong> ${result.name}`;
|
||||
message += `</div>`;
|
||||
}
|
||||
message += `</div>`;
|
||||
message += `</div>`;
|
||||
|
||||
await ChatMessage.create({
|
||||
content: message,
|
||||
speaker: ChatMessage.getSpeaker(),
|
||||
whisper: ChatMessage.getWhisperRecipients("GM")
|
||||
});
|
||||
}
|
||||
}
|
||||
148
modules/inn/README.md
Normal file
148
modules/inn/README.md
Normal file
@@ -0,0 +1,148 @@
|
||||
# Module Inn (Auberge)
|
||||
|
||||
Module de gestion des jets sur les tables d'auberge pour WFRP4e - Traduction française.
|
||||
|
||||
## Utilisation
|
||||
|
||||
### Commande `/auberge`
|
||||
|
||||
La commande `/auberge` permet d'effectuer des jets sur les tables d'auberge (plats et boissons).
|
||||
|
||||
**Syntaxe :**
|
||||
```
|
||||
/auberge [mot_clé]
|
||||
```
|
||||
|
||||
### Exemples
|
||||
|
||||
- `/auberge` - Affiche l'aide avec toutes les tables disponibles **et cliquables**
|
||||
- `/auberge help` ou `/auberge aide` - Affiche l'aide avec liste cliquable
|
||||
- `/auberge list` ou `/auberge liste` - Liste toutes les tables avec liens cliquables
|
||||
- `/auberge menu` - **Génère un menu complet** (6 types disponibles)
|
||||
- `/auberge base` - Lance un jet sur la table "BoissonsBase"
|
||||
- `/auberge fortes` - Lance un jet sur la table "BoissonsFortes"
|
||||
- `/auberge mari` - Lance un jet sur la table "PlatsMaritimes"
|
||||
|
||||
> **Note :** Quand vous tapez `/auberge` sans argument, une liste cliquable s'affiche dans le chat. Vous pouvez cliquer directement sur une table pour effectuer un jet.
|
||||
|
||||
### Génération de menus complets
|
||||
|
||||
La commande `/auberge menu` permet de générer automatiquement un menu complet :
|
||||
|
||||
1. Tapez `/auberge menu` dans le chat
|
||||
2. Cliquez sur le type de menu souhaité :
|
||||
- **Menu Médiocre** 🍗 : Plat médiocre + Boisson de base
|
||||
- **Menu Commun** 🍽️ : Plat commun + Boisson de base + Dessert
|
||||
- **Menu de Qualité** 👑 : Plat de qualité + Boisson forte + Dessert
|
||||
- **Menu Fluvial** 🐟 : Plat de rivière + Boisson de base + Dessert
|
||||
- **Menu Maritime** ⚓ : Plat maritime + Boisson forte + Dessert
|
||||
- **Menu Excellent** 💎 : Plat excellent + Boisson forte + Dessert
|
||||
3. Le menu complet est généré automatiquement avec un jet sur chaque table concernée
|
||||
|
||||
### Tables disponibles
|
||||
|
||||
- **BoissonsBase** (`boissonsbase`, `base`)
|
||||
- **BoissonsFortes** (`boissonsfortes`, `fortes`)
|
||||
- **Desserts** (`desserts`)
|
||||
- **PlatsCommuns** (`platscommuns`, `communs`)
|
||||
- **PlatsExcellents** (`platsexcellents`, `excellents`)
|
||||
- **PlatsMaritimes** (`platsmaritimes`, `maritimes`, `mari`)
|
||||
- **PlatsMédiocres** (`platsmediocres`, `mediocres`)
|
||||
- **PlatsQualité** (`platsqualite`, `qualite`)
|
||||
- **PlatsRivières** (`platsrivieres`, `rivieres`)
|
||||
|
||||
### Raccourcis
|
||||
|
||||
Le système accepte des raccourcis et ignore les accents :
|
||||
- `mari` → PlatsMaritimes
|
||||
- `qualité` ou `qualite` → PlatsQualité
|
||||
- `médiocres` ou `mediocres` → PlatsMédiocres
|
||||
|
||||
## Architecture
|
||||
|
||||
Le module suit la même architecture que le module TravelV2 (commande `/voyage`) :
|
||||
|
||||
```
|
||||
modules/inn/
|
||||
├── inn-init.js # Initialisation et enregistrement de la commande
|
||||
└── InnRoller.js # Logique métier des jets de tables
|
||||
```
|
||||
|
||||
### Affichage personnalisé
|
||||
|
||||
Les résultats des jets sont affichés avec un **rendu visuel personnalisé** :
|
||||
- 🍷 Icône adaptée au type (boisson, plat, dessert)
|
||||
- 🎨 Carte stylisée avec dégradés et bordures
|
||||
- 🎲 Affichage du jet de dés (formule et total)
|
||||
- 📋 Nom de la table et du plat mis en valeur
|
||||
- 🎉 Message de conclusion thématique
|
||||
|
||||
Le système détecte automatiquement le type de plat/boisson et adapte l'icône :
|
||||
- **Boissons** : 🍷 Verre de vin
|
||||
- **Desserts** : 🎂 Gâteau
|
||||
- **Plats** : 🍴 Couverts
|
||||
|
||||
### Fichiers principaux
|
||||
|
||||
- **inn-init.js** :
|
||||
- Enregistre la commande `/auberge` via `game.wfrp4e.commands`
|
||||
- Gère les hooks pour les clics sur les liens de tables
|
||||
- Expose `game.wfrp4e.inn` pour accès programmatique
|
||||
|
||||
- **InnRoller.js** :
|
||||
- Gestion des jets sur les tables d'auberge
|
||||
- Normalisation des noms de tables
|
||||
- Recherche par mots-clés
|
||||
- Affichage de l'aide et de la liste des tables
|
||||
|
||||
## Intégration
|
||||
|
||||
Le module est initialisé dans `wh4_fr.js` :
|
||||
|
||||
```javascript
|
||||
import { initInn } from './modules/inn/inn-init.js';
|
||||
|
||||
Hooks.once("init", function() {
|
||||
initInn();
|
||||
});
|
||||
```
|
||||
|
||||
## Dépendances
|
||||
|
||||
- Compendium : `wh4-fr-translation.plats-dauberges`
|
||||
- Système WFRP4e avec support de `game.wfrp4e.commands`
|
||||
|
||||
## Permissions
|
||||
|
||||
La commande `/auberge` est réservée au MJ (GM).
|
||||
|
||||
## API Programmatique
|
||||
|
||||
```javascript
|
||||
// Afficher l'aide
|
||||
game.wfrp4e.inn.displayHelp();
|
||||
|
||||
// Lister les tables
|
||||
game.wfrp4e.inn.listTables();
|
||||
|
||||
// Effectuer un jet
|
||||
game.wfrp4e.inn.rollInnTable('base');
|
||||
|
||||
// Trouver une table par mot-clé
|
||||
const tableName = game.wfrp4e.inn.findTableByKeyword('mari');
|
||||
```
|
||||
|
||||
## Migration depuis l'ancien système
|
||||
|
||||
L'ancienne implémentation dans `addon-register.js` (`_manage_inn_roll`) a été remplacée par ce module pour :
|
||||
- Cohérence avec le module TravelV2
|
||||
- Meilleure maintenabilité
|
||||
- Support des commandes WFRP4e natives
|
||||
- Interface utilisateur améliorée
|
||||
|
||||
## Styles CSS
|
||||
|
||||
Les styles sont définis dans `patch-styles.css` avec les classes :
|
||||
- `.wfrp4e-inn-help` - Aide de la commande
|
||||
- `.wfrp4e-inn-list` - Liste des tables
|
||||
- `.wfrp4e-inn-table-list` - Liste avec liens cliquables
|
||||
93
modules/inn/inn-init.js
Normal file
93
modules/inn/inn-init.js
Normal file
@@ -0,0 +1,93 @@
|
||||
import InnRoller from './InnRoller.js';
|
||||
|
||||
/**
|
||||
* Initialisation du module Inn (Auberge)
|
||||
*/
|
||||
export function initInn() {
|
||||
console.log("Inn: Initialisation du module d'auberge");
|
||||
|
||||
// Hook pour initialiser au démarrage
|
||||
Hooks.once('ready', async () => {
|
||||
console.log("Inn: Module d'auberge prêt");
|
||||
|
||||
// Exposer la classe globalement
|
||||
game.wfrp4e = game.wfrp4e || {};
|
||||
game.wfrp4e.inn = InnRoller;
|
||||
|
||||
console.log("Inn: Classe accessible via game.wfrp4e.inn");
|
||||
|
||||
// Enregistrer la commande dans le système WFRP4e si disponible
|
||||
if (game.wfrp4e?.commands) {
|
||||
console.log("Inn: Enregistrement de la commande /auberge");
|
||||
game.wfrp4e.commands.add({
|
||||
auberge: {
|
||||
description: "Jets sur les tables d'auberge (FR)",
|
||||
args: ["table"],
|
||||
defaultArg: "table",
|
||||
callback: (table) => {
|
||||
// Vérifier que l'utilisateur est GM
|
||||
if (!game.user.isGM) {
|
||||
ui.notifications.warn("La commande /auberge est réservée au MJ.");
|
||||
return;
|
||||
}
|
||||
|
||||
console.log(`Inn: Commande /auberge exécutée avec table="${table}"`);
|
||||
|
||||
// Convertir null en undefined
|
||||
table = table || undefined;
|
||||
|
||||
// Si pas de table spécifiée, afficher l'aide
|
||||
if (!table) {
|
||||
InnRoller.displayHelp();
|
||||
} else if (table === 'help' || table === 'aide') {
|
||||
InnRoller.displayHelp();
|
||||
} else if (table === 'list' || table === 'liste') {
|
||||
InnRoller.listTables();
|
||||
} else if (table === 'menu') {
|
||||
InnRoller.displayMenuChoice();
|
||||
} else {
|
||||
InnRoller.rollInnTable(table);
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
console.log("Inn: Commande /auberge enregistrée avec succès");
|
||||
} else {
|
||||
console.warn("Inn: game.wfrp4e.commands non disponible");
|
||||
}
|
||||
});
|
||||
|
||||
// Hook pour gérer les clics sur les liens de tables d'auberge
|
||||
Hooks.on('renderChatMessage', (message, html, data) => {
|
||||
// Ajouter un listener pour les clics sur les liens d'auberge
|
||||
html.find('a[data-action="clickAuberge"]').click((event) => {
|
||||
event.preventDefault();
|
||||
const tableKey = $(event.currentTarget).data('table');
|
||||
console.log(`Inn: Clic sur la table ${tableKey}`);
|
||||
|
||||
if (game.user.isGM) {
|
||||
InnRoller.rollInnTable(tableKey);
|
||||
} else {
|
||||
ui.notifications.warn("Seul le MJ peut utiliser les tables d'auberge.");
|
||||
}
|
||||
});
|
||||
|
||||
// Ajouter un listener pour les clics sur les boutons de menu
|
||||
html.find('a[data-action="clickAubergeMenu"]').click((event) => {
|
||||
event.preventDefault();
|
||||
const quality = $(event.currentTarget).data('quality');
|
||||
console.log(`Inn: Clic sur menu de qualité "${quality}"`);
|
||||
|
||||
if (game.user.isGM) {
|
||||
// Si quality === "menu", afficher le choix, sinon générer directement
|
||||
if (quality === 'menu') {
|
||||
InnRoller.displayMenuChoice();
|
||||
} else {
|
||||
InnRoller.generateMenu(quality);
|
||||
}
|
||||
} else {
|
||||
ui.notifications.warn("Seul le MJ peut utiliser les tables d'auberge.");
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
339
modules/travelv2/TravelDistanceV2.js
Normal file
339
modules/travelv2/TravelDistanceV2.js
Normal file
@@ -0,0 +1,339 @@
|
||||
/**
|
||||
* TravelDistanceV2
|
||||
* Classe de gestion du calcul des distances de voyage pour WFRP4e
|
||||
* Version adaptée pour le module de traduction française
|
||||
*/
|
||||
import { PathFinder } from './pathfinding.js';
|
||||
|
||||
export default class TravelDistanceV2 {
|
||||
static roadGraph = null; // Graphe pour les routes terrestres uniquement
|
||||
static waterGraph = null; // Graphe pour les voies fluviales et maritimes
|
||||
static mixedGraph = null; // Graphe combinant tous les modes de transport
|
||||
|
||||
/**
|
||||
* Charge les données de voyage depuis le fichier JSON
|
||||
*/
|
||||
static async loadTravelData() {
|
||||
try {
|
||||
console.log("TravelV2: Début du chargement des données...");
|
||||
const response = await fetch('modules/wh4-fr-translation/modules/travelv2/travel_data.json');
|
||||
|
||||
if (!response.ok) {
|
||||
throw new Error(`HTTP error! status: ${response.status}`);
|
||||
}
|
||||
|
||||
this.travel_data = await response.json();
|
||||
console.log(`TravelV2: ${this.travel_data.length} routes chargées avec succès`);
|
||||
|
||||
// Construire les 3 graphes pour le pathfinding
|
||||
this.roadGraph = PathFinder.buildGraph(this.travel_data, 'road');
|
||||
this.waterGraph = PathFinder.buildGraph(this.travel_data, 'water');
|
||||
this.mixedGraph = PathFinder.buildGraph(this.travel_data, 'mixed');
|
||||
|
||||
console.log(`TravelV2: Graphe routier: ${Object.keys(this.roadGraph).length} villes`);
|
||||
console.log(`TravelV2: Graphe fluvial/maritime: ${Object.keys(this.waterGraph).length} villes`);
|
||||
console.log(`TravelV2: Graphe mixte: ${Object.keys(this.mixedGraph).length} villes`);
|
||||
|
||||
ui.notifications.info(`TravelV2: ${this.travel_data.length} routes de voyage chargées`);
|
||||
} catch (error) {
|
||||
console.error("TravelV2: Erreur lors du chargement des données de voyage:", error);
|
||||
ui.notifications.error("Erreur lors du chargement des données de voyage. Vérifiez la console.");
|
||||
this.travel_data = []; // Initialiser avec un tableau vide pour éviter les erreurs
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Retourne une chaîne lisible pour le niveau de danger
|
||||
* @param {String} dangerLevel
|
||||
* @returns {String}
|
||||
*/
|
||||
static dangerToString(dangerLevel) {
|
||||
if (dangerLevel == "") return "Très bas";
|
||||
if (dangerLevel == '!') return "Bas";
|
||||
if (dangerLevel == '!!') return "Moyen";
|
||||
if (dangerLevel == '!!!') return "Élevé";
|
||||
return "Très élevé";
|
||||
}
|
||||
|
||||
/**
|
||||
* Arrondit la durée à une valeur entière ou .5
|
||||
* @param {Number} duration
|
||||
* @returns {Number}
|
||||
*/
|
||||
static roundDuration(duration) {
|
||||
let trunc = Math.trunc(duration);
|
||||
let frac = duration - trunc;
|
||||
let adjust = 0;
|
||||
if (frac > 0.75) adjust = 1;
|
||||
else if (frac >= 0.25) adjust = 0.5;
|
||||
return trunc + adjust;
|
||||
}
|
||||
|
||||
/**
|
||||
* Affiche les distances de voyage entre deux villes ou liste les destinations
|
||||
* @param {String} fromTown Ville de départ
|
||||
* @param {String} toTown Ville d'arrivée (optionnel)
|
||||
*/
|
||||
static displayTravelDistance(fromTown, toTown) {
|
||||
// Vérifier que les données sont chargées
|
||||
if (!this.travel_data || this.travel_data.length === 0) {
|
||||
ui.notifications.error("Les données de voyage ne sont pas encore chargées. Veuillez patienter...");
|
||||
console.error("TravelV2: travel_data n'est pas chargé");
|
||||
return;
|
||||
}
|
||||
|
||||
console.log(`TravelV2: displayTravelDistance appelé avec fromTown="${fromTown}", toTown="${toTown}"`);
|
||||
console.log(`TravelV2: fromTown type: ${typeof fromTown}, valeur falsy: ${!fromTown}`);
|
||||
console.log(`TravelV2: toTown type: ${typeof toTown}, valeur falsy: ${!toTown}`);
|
||||
console.log(`TravelV2: ${this.travel_data.length} routes disponibles`);
|
||||
|
||||
let message = "";
|
||||
|
||||
console.log("TravelV2: Vérification des conditions...");
|
||||
console.log(`TravelV2: toTown ? ${!!toTown}`);
|
||||
console.log(`TravelV2: fromTown == 'help' ? ${fromTown == 'help'}`);
|
||||
console.log(`TravelV2: fromTown ? ${!!fromTown}`);
|
||||
console.log(`TravelV2: else (pas de fromTown) ? ${!fromTown && !toTown}`);
|
||||
|
||||
if (toTown) {
|
||||
console.log("TravelV2: Branche: Affichage des détails entre deux villes");
|
||||
// Afficher les détails de voyage entre deux villes spécifiques
|
||||
const originalFrom = fromTown;
|
||||
const originalTo = toTown;
|
||||
fromTown = fromTown.toLowerCase();
|
||||
toTown = toTown.toLowerCase();
|
||||
|
||||
// Chercher d'abord une route directe
|
||||
let directRoute = null;
|
||||
for (const travel of this.travel_data) {
|
||||
if (travel.from.toLowerCase() == fromTown && travel.to.toLowerCase() == toTown) {
|
||||
directRoute = travel;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (directRoute) {
|
||||
// Route directe trouvée - affichage classique avec toutes les options
|
||||
message += this.formatDirectRoute(directRoute);
|
||||
} else {
|
||||
// Pas de route directe - calculer les 3 types de trajets
|
||||
console.log("TravelV2: Pas de route directe, calcul des itinéraires...");
|
||||
|
||||
const mixedPath = PathFinder.dijkstra(this.mixedGraph, originalFrom, originalTo, 'days');
|
||||
const roadPath = PathFinder.dijkstra(this.roadGraph, originalFrom, originalTo, 'days');
|
||||
const waterPath = PathFinder.dijkstra(this.waterGraph, originalFrom, originalTo, 'days');
|
||||
|
||||
if (!mixedPath && !roadPath && !waterPath) {
|
||||
message += `<p><strong>Aucun chemin trouvé entre ${originalFrom} et ${originalTo}</strong></p>`;
|
||||
message += `<p>Il n'existe pas de route reliant ces deux villes dans les données disponibles.</p>`;
|
||||
} else {
|
||||
message += `<div class="voyage-main-title">De ${originalFrom} à ${originalTo}</div>`;
|
||||
message += `<p><em>Différentes options de voyage disponibles :</em></p><hr class="voyage-separator">`;
|
||||
|
||||
// Option 1 : Trajet mixte optimal (le plus rapide)
|
||||
if (mixedPath) {
|
||||
message += this.formatMultiStepRoute(mixedPath, originalFrom, originalTo, 'mixed');
|
||||
message += `<hr class="voyage-separator">`;
|
||||
}
|
||||
|
||||
// Option 2 : Trajet 100% terrestre
|
||||
if (roadPath) {
|
||||
message += this.formatMultiStepRoute(roadPath, originalFrom, originalTo, 'road');
|
||||
message += `<hr class="voyage-separator">`;
|
||||
}
|
||||
|
||||
// Option 3 : Trajet 100% eau (fleuve/mer)
|
||||
if (waterPath) {
|
||||
message += this.formatMultiStepRoute(waterPath, originalFrom, originalTo, 'water');
|
||||
}
|
||||
}
|
||||
}
|
||||
} else if (fromTown && fromTown == "help") {
|
||||
console.log("TravelV2: Branche: Affichage de l'aide");
|
||||
// Afficher l'aide
|
||||
message += `<p><strong>Aide pour /voyage</strong><br>`;
|
||||
message += `Usage: <code>/voyage [ville_départ] [ville_arrivée]</code><br><br>`;
|
||||
message += `Exemples:<br>`;
|
||||
message += `<code>/voyage</code> - Liste toutes les villes de départ<br>`;
|
||||
message += `<code>/voyage Altdorf</code> - Liste les destinations depuis Altdorf<br>`;
|
||||
message += `<code>/voyage Altdorf Nuln</code> - Affiche les détails de voyage entre Altdorf et Nuln`;
|
||||
message += `</p>`;
|
||||
} else if (fromTown) {
|
||||
console.log("TravelV2: Branche: Liste des destinations depuis une ville");
|
||||
// Lister toutes les destinations possibles depuis une ville (avec pathfinding)
|
||||
const normalizedFrom = PathFinder.findCityInGraph(this.roadGraph, fromTown);
|
||||
|
||||
if (normalizedFrom) {
|
||||
message += `<div class="voyage-destinations-title">Destinations depuis ${normalizedFrom}</div>`;
|
||||
message += `<p><em>Toutes les villes accessibles (routes directes et itinéraires calculés)</em></p>`;
|
||||
|
||||
// Récupérer toutes les villes du graphe sauf la ville de départ
|
||||
const allCities = Object.keys(this.roadGraph)
|
||||
.filter(city => city.toLowerCase() !== normalizedFrom.toLowerCase())
|
||||
.sort((a, b) => a.localeCompare(b));
|
||||
|
||||
// Afficher toutes les destinations
|
||||
for (const city of allCities) {
|
||||
message += `<p><a class="action-link" data-action="clickVoyage" data-from="${normalizedFrom}" data-to="${city}"><i class="fas fa-map-marked-alt"></i> ${city}</a></p>`;
|
||||
}
|
||||
} else {
|
||||
message += `<p><strong>Ville inconnue: ${fromTown}</strong></p>`;
|
||||
message += `<p>Cette ville n'existe pas dans la base de données.</p>`;
|
||||
}
|
||||
} else {
|
||||
console.log("TravelV2: Branche: Liste de toutes les villes de départ");
|
||||
// Lister toutes les villes de départ
|
||||
message += `<div class="voyage-destinations-title">Sélectionnez une ville de départ</div>`;
|
||||
let uniqTown = {};
|
||||
|
||||
for (const travel of this.travel_data) {
|
||||
if (uniqTown[travel.from] == undefined) {
|
||||
uniqTown[travel.from] = 1;
|
||||
message += `<p><a class="action-link" data-action="clickVoyage" data-from="${travel.from}"><i class="fas fa-list"></i> ${travel.from}</a></p>`;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
console.log(`TravelV2: Message généré (longueur: ${message.length})`);
|
||||
|
||||
if (message.length === 0) {
|
||||
console.warn("TravelV2: Aucune donnée trouvée pour les critères fournis");
|
||||
ui.notifications.warn("Aucune route trouvée pour ces critères");
|
||||
return;
|
||||
}
|
||||
|
||||
ChatMessage.create({
|
||||
content: message,
|
||||
whisper: [game.user.id], // Afficher uniquement pour le GM qui a lancé la commande
|
||||
speaker: { alias: "Outil de voyage" }
|
||||
});
|
||||
|
||||
console.log("TravelV2: ChatMessage créé avec succès");
|
||||
}
|
||||
|
||||
/**
|
||||
* Gère le clic sur un lien de voyage
|
||||
* @param {Event} event
|
||||
* @param {HTMLElement} target
|
||||
*/
|
||||
static handleTravelClick(event, target) {
|
||||
let fromTown = target.dataset.from;
|
||||
let toTown = target.dataset.to;
|
||||
TravelDistanceV2.displayTravelDistance(fromTown, toTown);
|
||||
}
|
||||
|
||||
/**
|
||||
* Formate l'affichage d'une route directe
|
||||
* @param {Object} travel - Données de la route
|
||||
* @returns {String} HTML formaté
|
||||
*/
|
||||
static formatDirectRoute(travel) {
|
||||
let message = `<p><strong>De ${travel.from} à ${travel.to}</strong> (Route directe)`;
|
||||
|
||||
if (travel.road_distance != "") {
|
||||
let road_horse_heavy_days = this.roundDuration(travel.road_days * 0.8);
|
||||
let road_horse_fast_days = this.roundDuration(travel.road_days * 0.65);
|
||||
let road_feet_days = this.roundDuration(travel.road_days * 1.25);
|
||||
let road_danger_string = this.dangerToString(travel.road_danger);
|
||||
let road_danger_feet_string = this.dangerToString(travel.road_danger + "!");
|
||||
|
||||
message += `<br><br><strong>Par route:</strong>`;
|
||||
message += `<br>Distance: ${travel.road_distance} km`;
|
||||
message += `<br>Durée (chariot): ${travel.road_days} jours - Danger: ${road_danger_string}`;
|
||||
message += `<br>Durée (cheval de charge): ${road_horse_heavy_days} jours - Danger: ${road_danger_string}`;
|
||||
message += `<br>Durée (cheval rapide): ${road_horse_fast_days} jours - Danger: ${road_danger_string}`;
|
||||
message += `<br>Durée (à pied): ${road_feet_days} jours - Danger: ${road_danger_feet_string}`;
|
||||
}
|
||||
|
||||
if (travel.river_distance != "") {
|
||||
let river_danger_string = this.dangerToString(travel.river_danger);
|
||||
message += `<br><br><strong>Par rivière:</strong>`;
|
||||
message += `<br>Distance: ${travel.river_distance} km`;
|
||||
message += `<br>Durée: ${travel.river_days} jours - Danger: ${river_danger_string}`;
|
||||
}
|
||||
|
||||
if (travel.sea_distance != "") {
|
||||
let sea_danger_string = this.dangerToString(travel.sea_danger);
|
||||
message += `<br><br><strong>Par mer:</strong>`;
|
||||
message += `<br>Distance: ${travel.sea_distance} km`;
|
||||
message += `<br>Durée: ${travel.sea_days} jours - Danger: ${sea_danger_string}`;
|
||||
}
|
||||
|
||||
message += "</p>";
|
||||
return message;
|
||||
}
|
||||
|
||||
/**
|
||||
* Formate l'affichage d'une route multi-étapes
|
||||
* @param {Object} pathResult - Résultat du pathfinding
|
||||
* @param {String} fromCity - Ville de départ
|
||||
* @param {String} toCity - Ville d'arrivée
|
||||
* @param {String} routeType - Type de route ('mixed', 'road', 'water')
|
||||
* @returns {String} HTML formaté
|
||||
*/
|
||||
static formatMultiStepRoute(pathResult, fromCity, toCity, routeType = 'road') {
|
||||
// Déterminer le titre selon le type
|
||||
let routeTitle = "";
|
||||
|
||||
if (routeType === 'mixed') {
|
||||
routeTitle = "🌟 Itinéraire optimal (tous modes de transport)";
|
||||
} else if (routeType === 'road') {
|
||||
routeTitle = "🛤️ Itinéraire 100% terrestre";
|
||||
} else if (routeType === 'water') {
|
||||
routeTitle = "⛵ Itinéraire 100% fluvial/maritime";
|
||||
}
|
||||
|
||||
let message = `<div class="voyage-route-title">${routeTitle}</div>`;
|
||||
message += `<p><strong>${fromCity} → ${toCity}</strong> (${pathResult.steps} étape${pathResult.steps > 1 ? 's' : ''})`;
|
||||
|
||||
// Résumé du voyage
|
||||
const totalDistance = Math.round(pathResult.totalDistance);
|
||||
const totalDays = Math.round(pathResult.totalDays);
|
||||
const danger_string = this.dangerToString(pathResult.maxDanger);
|
||||
|
||||
// Pour les routes terrestres, afficher les variantes de durée
|
||||
const includesRoad = !pathResult.modesUsed || pathResult.modesUsed.includes('road');
|
||||
|
||||
message += `<br><br><strong>📊 Résumé du voyage:</strong>`;
|
||||
message += `<br>Distance totale: ${totalDistance} km`;
|
||||
|
||||
if (includesRoad) {
|
||||
const road_horse_heavy_days = this.roundDuration(pathResult.totalDays * 0.8);
|
||||
const road_horse_fast_days = this.roundDuration(pathResult.totalDays * 0.65);
|
||||
const road_feet_days = this.roundDuration(pathResult.totalDays * 1.25);
|
||||
const danger_feet_string = this.dangerToString(pathResult.maxDanger + "!");
|
||||
|
||||
message += `<br>Durée (chariot): ${totalDays} jours - Danger max: ${danger_string}`;
|
||||
message += `<br>Durée (cheval de charge): ${road_horse_heavy_days} jours - Danger max: ${danger_string}`;
|
||||
message += `<br>Durée (cheval rapide): ${road_horse_fast_days} jours - Danger max: ${danger_string}`;
|
||||
message += `<br>Durée (à pied): ${road_feet_days} jours - Danger max: ${danger_feet_string}`;
|
||||
} else {
|
||||
message += `<br>Durée totale: ${totalDays} jours - Danger max: ${danger_string}`;
|
||||
}
|
||||
|
||||
// Détails des étapes avec mode de transport
|
||||
message += `<br><br><strong>🗺️ Itinéraire détaillé:</strong>`;
|
||||
for (let i = 0; i < pathResult.path.length; i++) {
|
||||
const step = pathResult.path[i];
|
||||
const stepNum = i + 1;
|
||||
const stepDanger = this.dangerToString(step.danger);
|
||||
|
||||
// Icône selon le mode de transport
|
||||
let modeIcon = "🛤️";
|
||||
let modeName = "route";
|
||||
if (step.mode === 'river') {
|
||||
modeIcon = "🚣";
|
||||
modeName = "fleuve";
|
||||
} else if (step.mode === 'sea') {
|
||||
modeIcon = "⛵";
|
||||
modeName = "mer";
|
||||
}
|
||||
|
||||
message += `<br><br><em>Étape ${stepNum}:</em> ${step.from} → ${step.to}`;
|
||||
message += `<br> ${modeIcon} Par ${modeName}: ${Math.round(step.distance)} km, ${step.days} jour${step.days > 1 ? 's' : ''} - Danger: ${stepDanger}`;
|
||||
}
|
||||
|
||||
message += "</p>";
|
||||
return message;
|
||||
}
|
||||
}
|
||||
30
modules/travelv2/debug-display.js
Normal file
30
modules/travelv2/debug-display.js
Normal file
@@ -0,0 +1,30 @@
|
||||
/**
|
||||
* Script de débogage pour vérifier l'affichage du message
|
||||
*/
|
||||
|
||||
// Vérifier que les données sont chargées
|
||||
console.log("=== DEBUG DISPLAY ===");
|
||||
console.log("travel_data:", game.wfrp4e.travelv2.travel_data);
|
||||
console.log("Nombre de routes:", game.wfrp4e.travelv2.travel_data?.length);
|
||||
|
||||
// Générer le message manuellement comme le fait la fonction
|
||||
let message = "";
|
||||
message += `<h3>Sélectionnez une ville de départ</h3>`;
|
||||
let uniqTown = {};
|
||||
|
||||
for (var travel of game.wfrp4e.travelv2.travel_data) {
|
||||
if (uniqTown[travel.from] == undefined) {
|
||||
uniqTown[travel.from] = 1;
|
||||
message += `<p><a class="action-link" data-action="clickTravel2" data-from="${travel.from}"><i class="fas fa-list"></i> ${travel.from}</a></p>`;
|
||||
}
|
||||
}
|
||||
|
||||
console.log("Message généré:", message);
|
||||
console.log("Longueur du message:", message.length);
|
||||
console.log("Nombre de villes uniques:", Object.keys(uniqTown).length);
|
||||
|
||||
// Tester ChatMessage.create
|
||||
ChatMessage.create({
|
||||
content: message,
|
||||
whisper: game.user.isGM ? [] : [game.user.id]
|
||||
});
|
||||
69
modules/travelv2/diagnostic.js
Normal file
69
modules/travelv2/diagnostic.js
Normal file
@@ -0,0 +1,69 @@
|
||||
/**
|
||||
* Script de diagnostic pour TravelV2
|
||||
*
|
||||
* Copiez-collez ce code dans la console de Foundry VTT (F12)
|
||||
* pour diagnostiquer les problèmes de chargement
|
||||
*/
|
||||
|
||||
console.log("=== Diagnostic TravelV2 ===\n");
|
||||
|
||||
// Test 1: Vérifier si la classe existe
|
||||
console.log("1. Classe TravelDistanceV2 existe ?");
|
||||
if (typeof TravelDistanceV2 !== 'undefined') {
|
||||
console.log(" ✓ OUI - La classe est disponible");
|
||||
} else {
|
||||
console.log(" ✗ NON - La classe n'est pas chargée !");
|
||||
console.log(" → Vérifiez que le module est activé et rechargez (F5)");
|
||||
}
|
||||
|
||||
// Test 2: Vérifier les données
|
||||
console.log("\n2. Données chargées ?");
|
||||
if (typeof TravelDistanceV2 !== 'undefined' && TravelDistanceV2.travel_data) {
|
||||
console.log(` ✓ OUI - ${TravelDistanceV2.travel_data.length} routes chargées`);
|
||||
console.log(` → Première route: ${TravelDistanceV2.travel_data[0]?.from} → ${TravelDistanceV2.travel_data[0]?.to}`);
|
||||
} else {
|
||||
console.log(" ✗ NON - Les données ne sont pas chargées");
|
||||
console.log(" → Essayez de les charger manuellement:");
|
||||
console.log(" → await TravelDistanceV2.loadTravelData()");
|
||||
}
|
||||
|
||||
// Test 3: Tester le chargement manuel
|
||||
console.log("\n3. Test de chargement manuel:");
|
||||
console.log(" Exécutez: await TravelDistanceV2.loadTravelData()");
|
||||
console.log(" Puis vérifiez avec: TravelDistanceV2.travel_data.length");
|
||||
|
||||
// Test 4: Tester le chemin du fichier
|
||||
console.log("\n4. Vérification du chemin du fichier:");
|
||||
const path = 'modules/foundryvtt-wh4-lang-fr-fr/modules/travelv2/travel_data.json';
|
||||
console.log(` Chemin: ${path}`);
|
||||
console.log(" Test de fetch...");
|
||||
fetch(path)
|
||||
.then(response => {
|
||||
console.log(` ✓ Fichier accessible - Status: ${response.status}`);
|
||||
return response.json();
|
||||
})
|
||||
.then(data => {
|
||||
console.log(` ✓ JSON valide - ${data.length} routes trouvées`);
|
||||
})
|
||||
.catch(error => {
|
||||
console.log(` ✗ Erreur: ${error.message}`);
|
||||
console.log(" → Vérifiez que le fichier travel_data.json existe bien");
|
||||
});
|
||||
|
||||
// Test 5: Afficher l'état du module
|
||||
console.log("\n5. État du module:");
|
||||
console.log(` game.modules = ${game.modules ? 'Disponible' : 'Non disponible'}`);
|
||||
const frModule = game.modules.get('foundryvtt-wh4-lang-fr-fr');
|
||||
if (frModule) {
|
||||
console.log(` ✓ Module trouvé: ${frModule.title}`);
|
||||
console.log(` → Actif: ${frModule.active}`);
|
||||
} else {
|
||||
console.log(" ✗ Module 'foundryvtt-wh4-lang-fr-fr' non trouvé");
|
||||
}
|
||||
|
||||
console.log("\n=== Fin du diagnostic ===");
|
||||
console.log("\nCommandes utiles:");
|
||||
console.log("• Charger les données: await TravelDistanceV2.loadTravelData()");
|
||||
console.log("• Vérifier les données: TravelDistanceV2.travel_data");
|
||||
console.log("• Tester l'affichage: TravelDistanceV2.displayTravelDistance()");
|
||||
console.log("• Tester avec ville: TravelDistanceV2.displayTravelDistance('Altdorf')");
|
||||
8
modules/travelv2/index.js
Normal file
8
modules/travelv2/index.js
Normal file
@@ -0,0 +1,8 @@
|
||||
/**
|
||||
* Index du module TravelV2
|
||||
*
|
||||
* Ce fichier exporte tous les composants du module TravelV2
|
||||
*/
|
||||
|
||||
export { default as TravelDistanceV2 } from './TravelDistanceV2.js';
|
||||
export { initTravelV2 } from './travelv2-init.js';
|
||||
218
modules/travelv2/pathfinding.js
Normal file
218
modules/travelv2/pathfinding.js
Normal file
@@ -0,0 +1,218 @@
|
||||
/**
|
||||
* Algorithmes de calcul de plus court chemin pour les voyages
|
||||
*/
|
||||
|
||||
/**
|
||||
* Classe pour le calcul de plus court chemin (algorithme de Dijkstra)
|
||||
*/
|
||||
export class PathFinder {
|
||||
/**
|
||||
* Construit un graphe à partir des données de voyage
|
||||
* @param {Array} travelData - Données de voyage
|
||||
* @param {String|Array} modes - Mode(s) de transport ('road', 'river', 'sea', ['road', 'river', 'sea'], 'water')
|
||||
* @returns {Object} Graphe avec adjacence et poids
|
||||
*/
|
||||
static buildGraph(travelData, modes = 'road') {
|
||||
const graph = {};
|
||||
|
||||
// Normaliser modes en tableau
|
||||
let modeList = [];
|
||||
if (modes === 'water') {
|
||||
modeList = ['river', 'sea'];
|
||||
} else if (modes === 'mixed') {
|
||||
modeList = ['road', 'river', 'sea'];
|
||||
} else if (Array.isArray(modes)) {
|
||||
modeList = modes;
|
||||
} else {
|
||||
modeList = [modes];
|
||||
}
|
||||
|
||||
for (const route of travelData) {
|
||||
const from = route.from;
|
||||
const to = route.to;
|
||||
|
||||
// Initialiser les nœuds
|
||||
if (!graph[from]) {
|
||||
graph[from] = [];
|
||||
}
|
||||
if (!graph[to]) {
|
||||
graph[to] = [];
|
||||
}
|
||||
|
||||
// Pour chaque mode de transport disponible
|
||||
for (const mode of modeList) {
|
||||
const distanceKey = `${mode}_distance`;
|
||||
const daysKey = `${mode}_days`;
|
||||
const distance = route[distanceKey];
|
||||
const days = route[daysKey];
|
||||
|
||||
// Ignorer les routes sans ce mode de transport
|
||||
if (!distance || distance === "" || !days || days === "") {
|
||||
continue;
|
||||
}
|
||||
|
||||
// Ajouter les arêtes (bidirectionnelles)
|
||||
graph[from].push({
|
||||
destination: to,
|
||||
distance: parseFloat(distance),
|
||||
days: parseFloat(days),
|
||||
danger: route[`${mode}_danger`] || "",
|
||||
mode: mode
|
||||
});
|
||||
|
||||
graph[to].push({
|
||||
destination: from,
|
||||
distance: parseFloat(distance),
|
||||
days: parseFloat(days),
|
||||
danger: route[`${mode}_danger`] || "",
|
||||
mode: mode
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
return graph;
|
||||
}
|
||||
|
||||
/**
|
||||
* Algorithme de Dijkstra pour trouver le plus court chemin
|
||||
* @param {Object} graph - Graphe d'adjacence
|
||||
* @param {String} start - Ville de départ
|
||||
* @param {String} end - Ville d'arrivée
|
||||
* @param {String} metric - Métrique à minimiser ('distance' ou 'days')
|
||||
* @returns {Object|null} Chemin trouvé avec détails ou null si pas de chemin
|
||||
*/
|
||||
static dijkstra(graph, start, end, metric = 'days') {
|
||||
// Normaliser les noms de villes
|
||||
const normalizedStart = this.findCityInGraph(graph, start);
|
||||
const normalizedEnd = this.findCityInGraph(graph, end);
|
||||
|
||||
if (!normalizedStart || !normalizedEnd) {
|
||||
console.warn(`PathFinder: Ville non trouvée - start: ${start}, end: ${end}`);
|
||||
return null;
|
||||
}
|
||||
|
||||
// Initialisation
|
||||
const distances = {};
|
||||
const previous = {};
|
||||
const visited = new Set();
|
||||
const queue = [];
|
||||
|
||||
// Initialiser toutes les distances à l'infini
|
||||
for (const node in graph) {
|
||||
distances[node] = Infinity;
|
||||
previous[node] = null;
|
||||
}
|
||||
|
||||
distances[normalizedStart] = 0;
|
||||
queue.push({ node: normalizedStart, distance: 0 });
|
||||
|
||||
while (queue.length > 0) {
|
||||
// Trouver le nœud avec la plus petite distance
|
||||
queue.sort((a, b) => a.distance - b.distance);
|
||||
const { node: current } = queue.shift();
|
||||
|
||||
if (visited.has(current)) continue;
|
||||
visited.add(current);
|
||||
|
||||
// Si on a atteint la destination
|
||||
if (current === normalizedEnd) {
|
||||
return this.reconstructPath(previous, normalizedStart, normalizedEnd, graph, metric);
|
||||
}
|
||||
|
||||
// Explorer les voisins
|
||||
const neighbors = graph[current] || [];
|
||||
for (const neighbor of neighbors) {
|
||||
if (visited.has(neighbor.destination)) continue;
|
||||
|
||||
const weight = neighbor[metric]; // 'distance' ou 'days'
|
||||
const newDistance = distances[current] + weight;
|
||||
|
||||
if (newDistance < distances[neighbor.destination]) {
|
||||
distances[neighbor.destination] = newDistance;
|
||||
previous[neighbor.destination] = {
|
||||
from: current,
|
||||
edge: neighbor
|
||||
};
|
||||
queue.push({ node: neighbor.destination, distance: newDistance });
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Pas de chemin trouvé
|
||||
console.warn(`PathFinder: Aucun chemin trouvé entre ${start} et ${end}`);
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Trouve une ville dans le graphe (insensible à la casse)
|
||||
* @param {Object} graph - Graphe
|
||||
* @param {String} cityName - Nom de la ville
|
||||
* @returns {String|null} Nom normalisé de la ville ou null
|
||||
*/
|
||||
static findCityInGraph(graph, cityName) {
|
||||
const lowerName = cityName.toLowerCase();
|
||||
for (const city in graph) {
|
||||
if (city.toLowerCase() === lowerName) {
|
||||
return city;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Reconstruit le chemin à partir des prédécesseurs
|
||||
* @param {Object} previous - Map des prédécesseurs
|
||||
* @param {String} start - Ville de départ
|
||||
* @param {String} end - Ville d'arrivée
|
||||
* @param {Object} graph - Graphe d'adjacence
|
||||
* @param {String} metric - Métrique utilisée
|
||||
* @returns {Object} Détails du chemin
|
||||
*/
|
||||
static reconstructPath(previous, start, end, graph, metric) {
|
||||
const path = [];
|
||||
let current = end;
|
||||
let totalDistance = 0;
|
||||
let totalDays = 0;
|
||||
let maxDanger = "";
|
||||
const modesUsed = new Set();
|
||||
|
||||
// Reconstruire le chemin en remontant
|
||||
while (current !== start) {
|
||||
const prev = previous[current];
|
||||
if (!prev) break;
|
||||
|
||||
const mode = prev.edge.mode || 'road';
|
||||
modesUsed.add(mode);
|
||||
|
||||
path.unshift({
|
||||
from: prev.from,
|
||||
to: current,
|
||||
distance: prev.edge.distance,
|
||||
days: prev.edge.days,
|
||||
danger: prev.edge.danger,
|
||||
mode: mode
|
||||
});
|
||||
|
||||
totalDistance += prev.edge.distance;
|
||||
totalDays += prev.edge.days;
|
||||
|
||||
// Calculer le danger maximum
|
||||
const dangerLevel = (prev.edge.danger || "").length;
|
||||
const currentMaxLevel = maxDanger.length;
|
||||
if (dangerLevel > currentMaxLevel) {
|
||||
maxDanger = prev.edge.danger;
|
||||
}
|
||||
|
||||
current = prev.from;
|
||||
}
|
||||
|
||||
return {
|
||||
path: path,
|
||||
totalDistance: totalDistance,
|
||||
totalDays: totalDays,
|
||||
maxDanger: maxDanger,
|
||||
steps: path.length,
|
||||
modesUsed: Array.from(modesUsed)
|
||||
};
|
||||
}
|
||||
}
|
||||
53
modules/travelv2/test.js
Normal file
53
modules/travelv2/test.js
Normal file
@@ -0,0 +1,53 @@
|
||||
/**
|
||||
* Fichier de test pour le module TravelV2
|
||||
*
|
||||
* Pour tester le module dans la console de développement de Foundry VTT:
|
||||
*
|
||||
* 1. Charger le module
|
||||
* 2. Ouvrir la console (F12)
|
||||
* 3. Exécuter ces tests
|
||||
*/
|
||||
|
||||
// Test 1: Vérifier que la classe est chargée
|
||||
console.log("Test 1: Classe TravelDistanceV2 disponible?");
|
||||
console.log(typeof TravelDistanceV2 !== 'undefined' ? "✓ OK" : "✗ ÉCHEC");
|
||||
|
||||
// Test 2: Vérifier que les données sont chargées
|
||||
console.log("\nTest 2: Données de voyage chargées?");
|
||||
console.log(TravelDistanceV2.travel_data ? "✓ OK - " + TravelDistanceV2.travel_data.length + " routes trouvées" : "✗ ÉCHEC");
|
||||
|
||||
// Test 3: Tester dangerToString
|
||||
console.log("\nTest 3: Test de dangerToString");
|
||||
console.log("'' -> " + TravelDistanceV2.dangerToString(""));
|
||||
console.log("'!' -> " + TravelDistanceV2.dangerToString("!"));
|
||||
console.log("'!!' -> " + TravelDistanceV2.dangerToString("!!"));
|
||||
console.log("'!!!' -> " + TravelDistanceV2.dangerToString("!!!"));
|
||||
|
||||
// Test 4: Tester roundDuration
|
||||
console.log("\nTest 4: Test de roundDuration");
|
||||
console.log("22.1 -> " + TravelDistanceV2.roundDuration(22.1));
|
||||
console.log("22.3 -> " + TravelDistanceV2.roundDuration(22.3));
|
||||
console.log("22.5 -> " + TravelDistanceV2.roundDuration(22.5));
|
||||
console.log("22.8 -> " + TravelDistanceV2.roundDuration(22.8));
|
||||
|
||||
// Test 5: Tester displayTravelDistance avec une ville
|
||||
console.log("\nTest 5: Affichage des destinations depuis Altdorf");
|
||||
// TravelDistanceV2.displayTravelDistance("Altdorf");
|
||||
console.log("Exécutez manuellement: TravelDistanceV2.displayTravelDistance('Altdorf')");
|
||||
|
||||
// Test 6: Tester displayTravelDistance avec deux villes
|
||||
console.log("\nTest 6: Affichage du trajet Altdorf -> Nuln");
|
||||
// TravelDistanceV2.displayTravelDistance("Altdorf", "Nuln");
|
||||
console.log("Exécutez manuellement: TravelDistanceV2.displayTravelDistance('Altdorf', 'Nuln')");
|
||||
|
||||
// Test 7: Tester la commande help
|
||||
console.log("\nTest 7: Affichage de l'aide");
|
||||
// TravelDistanceV2.displayTravelDistance("help");
|
||||
console.log("Exécutez manuellement: TravelDistanceV2.displayTravelDistance('help')");
|
||||
|
||||
console.log("\n=== Tests terminés ===");
|
||||
console.log("\nPour tester la commande complète, tapez dans le chat:");
|
||||
console.log("/travel2");
|
||||
console.log("/travel2 Altdorf");
|
||||
console.log("/travel2 Altdorf Nuln");
|
||||
console.log("/travel2 help");
|
||||
2745
modules/travelv2/travel_data.json
Normal file
2745
modules/travelv2/travel_data.json
Normal file
File diff suppressed because it is too large
Load Diff
67
modules/travelv2/travelv2-init.js
Normal file
67
modules/travelv2/travelv2-init.js
Normal file
@@ -0,0 +1,67 @@
|
||||
import TravelDistanceV2 from './TravelDistanceV2.js';
|
||||
|
||||
/**
|
||||
* Initialisation du module TravelV2
|
||||
*/
|
||||
export function initTravelV2() {
|
||||
console.log("TravelV2: Initialisation du module de voyage");
|
||||
|
||||
// Hook pour charger les données au démarrage
|
||||
Hooks.once('ready', async () => {
|
||||
console.log("TravelV2: Chargement des données de voyage");
|
||||
|
||||
// Exposer la classe globalement pour accès depuis la console
|
||||
game.wfrp4e = game.wfrp4e || {};
|
||||
game.wfrp4e.travelv2 = TravelDistanceV2;
|
||||
|
||||
await TravelDistanceV2.loadTravelData();
|
||||
|
||||
console.log("TravelV2: Classe accessible via game.wfrp4e.travelv2");
|
||||
|
||||
// Enregistrer la commande dans le système WFRP4e si disponible
|
||||
if (game.wfrp4e?.commands) {
|
||||
console.log("TravelV2: Enregistrement de la commande /voyage");
|
||||
game.wfrp4e.commands.add({
|
||||
voyage: {
|
||||
description: "Outil de calcul de distances de voyage (FR)",
|
||||
args: ["from", "to"],
|
||||
defaultArg: "from",
|
||||
callback: (from, to) => {
|
||||
// Vérifier que l'utilisateur est GM
|
||||
if (!game.user.isGM) {
|
||||
ui.notifications.warn("La commande /voyage est réservée au MJ.");
|
||||
return;
|
||||
}
|
||||
|
||||
console.log(`TravelV2: Commande /voyage exécutée`);
|
||||
console.log(`TravelV2: from =`, from, `(type: ${typeof from})`);
|
||||
console.log(`TravelV2: to =`, to, `(type: ${typeof to})`);
|
||||
console.log(`TravelV2: from === null ?`, from === null);
|
||||
console.log(`TravelV2: to === null ?`, to === null);
|
||||
|
||||
// Convertir null en undefined pour que la logique fonctionne
|
||||
from = from || undefined;
|
||||
to = to || undefined;
|
||||
|
||||
TravelDistanceV2.displayTravelDistance(from, to);
|
||||
}
|
||||
}
|
||||
});
|
||||
console.log("TravelV2: Commande /voyage enregistrée avec succès");
|
||||
} else {
|
||||
console.warn("TravelV2: game.wfrp4e.commands non disponible");
|
||||
}
|
||||
});
|
||||
|
||||
// Hook pour ajouter un gestionnaire de clics sur les liens de voyage
|
||||
Hooks.on('renderChatMessage', (message, html, data) => {
|
||||
// Ajouter un listener pour les clics sur les liens de voyage
|
||||
html.find('a[data-action="clickVoyage"]').click((event) => {
|
||||
event.preventDefault();
|
||||
const target = event.currentTarget;
|
||||
TravelDistanceV2.handleTravelClick(event, target);
|
||||
});
|
||||
});
|
||||
|
||||
console.log("TravelV2: Module de voyage initialisé");
|
||||
}
|
||||
Reference in New Issue
Block a user