vermine2047/docs/technical/ARCHITECTURE.md

Vermine2047 System - Architecture Technique

Table des matières

1. Introduction
2. Structure du Projet
3. Configuration du Système
4. Documents
5. Fiches (Sheets)
6. Système de Dés
7. Combat
8. Gestion des Groupes
9. Synchronisation
10. Templates
11. Traductions

---

Introduction

Vermine2047 est un système pour FoundryVTT (Virtual Tabletop) qui implémente les règles du jeu de rôle Vermine 2047. Ce document décrit l'architecture technique du système.

Technologies utilisées

• FoundryVTT: v14 (compatible v11+)
• Langage: JavaScript (ES Modules)
• Templates: Handlebars
• CSS: Vanilla CSS avec Flexbox/Grid

Version actuelle

• Version: 0.1.14 (après mise à jour)
• Compatibilité: FoundryVTT v11-v14

---

Structure du Projet

vermine2047/
├── module/
│   ├── vermine2047.mjs              # Point d'entrée principal
│   ├── documents/
│   │   ├── actor.mjs                # Classe Actor étendue
│   │   └── item.mjs                 # Classe Item étendue
│   ├── sheets/
│   │   ├── actor-sheet.mjs          # Classe de base des feuilles d'acteur
│   │   ├── character-sheet.mjs      # Feuille de personnage
│   │   ├── npc-sheet.mjs            # Feuille de PNJ
│   │   ├── creature-sheet.mjs       # Feuille de créature
│   │   └── npc-group.mjs            # Feuille de groupe
│   │   └── item-sheet.mjs           # Feuille d'item
│   └── system/
│       ├── config.mjs               # Configuration du système
│       ├── hooks.mjs                # Hooks FoundryVTT
│       ├── roll.mjs                 # Logique des jets de dés
│       ├── dice3d.mjs               # Intégration Dice So Nice
│       ├── dialogs/
│       │   └── rollDialog.mjs       # Dialogue de jet de dés
│       ├── functions.mjs            # Fonctions utilitaires
│       ├── fight.mjs                # Système de combat
│       ├── effects.mjs              # Gestion des effets
│       ├── settings.mjs             # Paramètres du système
│       ├── tour.mjs                 # Visite guidée
│       ├── applications.mjs         # Applications (sélecteurs)
│       └── group-link.mjs           # Gestion des liens de groupe
├── templates/
│   ├── actor/
│   │   ├── actor-character-sheet.hbs
│   │   ├── actor-npc-sheet.hbs
│   │   ├── actor-creature-sheet.hbs
│   │   └── actor-group-sheet.hbs
│   ├── dialogs/
│   │   ├── roll-dialog.hbs
│   │   └── min-max-edit.hbs
│   ├── item/
│   │   └── chatCards/              # Templates de chat pour items
│   │       ├── *.hbs               # Par type d'item
│   └── roll-message.hbs            # Template de message de jet
├── lang/
│   ├── fr.json                      # Traductions françaises
│   └── en.json                      # Traductions anglaises
├── assets/
│   ├── icons/                      # Icônes
│   ├── images/                     # Images
│   └── style/                      # Styles CSS
├── packs/                          # Compendiums
├── system.json                     # Métadonnées du système
└── template.json                   # Structure des données

---

Configuration du Système

CONFIG.VERMINE

Toutes les configurations du système sont définies dans module/system/config.mjs et sont accessibles via CONFIG.VERMINE.

Catégories principales

1. Niveaux d'âge (AgeTypes)

   • Jeune (0-17 ans)
   • Adulte (18-46 ans)
   • Vieux (47+ ans)

2. Niveaux de compétence (SkillLevels)

   • 0: Incompétent
   • 1: Débutant
   • 2: Compétent
   • 3: Expert
   • 4: Maître
   • 5: Légende

3. Niveaux de difficulté (DifficultyLevels)

   • 1: Evidente (3+)
   • 2: Facile (5+)
   • 3: Difficile (7+)
   • 4: Très difficile (9+)
   • 5: Impossible (10+)

4. Niveaux de menace (ThreatLevels) - Pour les PNJ

   • 1: Mineure
   • 2: Sérieuse
   • 3: Majeure
   • 4: Mortelle

5. Niveaux d'expérience (ExperienceLevels) - Pour les PNJ

   • 1: Débutant
   • 2: Compétent
   • 3: Expert
   • 4: Maître

6. Niveaux de rôle (RoleLevels) - Pour les PNJ

   • 1: Mineur
   • 2: Secondaire
   • 3: Important
   • 4: Majeur

7. Niveaux de gabarit (PatternLevels) - Pour les créatures

   • 1: Insecte
   • 2: Rat
   • 3: Chien
   • 4: Ours

8. Niveaux de taille (SizeLevels) - Pour les créatures

   • 1: Petit
   • 2: Moyen
   • 3: Grand

9. Niveaux de meute (PackLevels) - Pour les créatures

   • 0: Solitaire
   • 1: Petit groupe
   • 2: Groupe
   • 3: Grande meute

10. Catégories de caractéristiques (abilityCategories)

    • physical: Physique
    • manual: Manuel
    • mental: Mental
    • social: Social

11. Caractéristiques (abilities)

    • vigor: Vigueur
    • health: Santé
    • precision: Précision
    • reflexes: Réflexes
    • knowledge: Connaissance
    • perception: Perception
    • will: Volonté
    • empathy: Empathie

12. Catégories de compétences (skillCategories)

    • man: Humain
    • animal: Animal
    • tool: Outil
    • weapon: Arme
    • survival: Survie
    • world: Monde

13. Totems (totems)

    • human: Humain
    • predator: Prédateur
    • scavenger: Charognard
    • symbiote: Symbiote
    • parasite: Parasite
    • builder: Bâtisseur
    • horde: Horde
    • hive: Ruche
    • loner: Solitaire
    • adapted: Adapté

14. Totems opposés (totem_opposites)

    • human ↔ adapted
    • predator ↔ scavenger
    • symbiote ↔ parasite
    • builder ↔ horde
    • hive ↔ loner

15. Domaines des totems (totemDomains) - NOUVEAU Chaque totem a des domaines de prédilection qui accordent des bonus

    • human: ["man", "world"]
    • adapted: ["animal", "survival"]
    • etc.

16. Origines (origins) Liste des origines possibles pour les personnages

17. Traits (traits) Liste des traits disponibles pour les items avec leurs descriptions

18. Types de dégâts (damageTypes)

    • choc
    • lame
    • feu
    • balle

19. Statuts de combat (combatStatus)

    • offensif: 5
    • actif: 7
    • passif: 9

---

Documents

VermineActor

La classe VermineActor étend la classe Actor de FoundryVTT et ajoute des fonctionnalités spécifiques à Vermine2047.

Méthodes principales

• prepareData(): Prépare les données de l'acteur
• prepareBaseData(): Prépare les données de base
• prepareDerivedData(): Prépare les données dérivées
• _prepareCharacterData(): Prépare les données spécifiques aux personnages
• _prepareNpcData(): Prépare les données spécifiques aux PNJ
• getRollData(): Retourne les données pour les jets de dés
• prepareCombatStatus(): Prépare le statut de combat

Propriétés calculées

• ageType: Type d'âge basé sur l'âge du personnage
• modFromAgeSelfControl: Modificateur de Sang-Froid basé sur l'âge
• modFromAgeEffort: Modificateur d'Effort basé sur l'âge
• modFromAgeWounds: Modificateurs de blessures basés sur l'âge

Données d'un Personnage (character)

{
  "adaptation": {
    "value": 1,
    "totems": {
      "human": { "value": 1, "min": 0, "max": 3 },
      "adapted": { "value": 1, "min": 0, "max": 3 }
    }
  },
  "identity": {
    "height": 0,
    "weight": 0,
    "totem": "",
    "age": 15,
    "ageType": 2,
    "profile": "",
    "theme": "",
    "instincts": "",
    "prohibits": "",
    "objectives": "",
    "relations": "",
    "biography": ""
  },
  "attributes": {
    "xp": { "value": 0, "max": 10 },
    "reputation": { "value": 0, "max": 10 },
    "self_control": { "value": 0, "min": 0, "max": 5 },
    "effort": { "value": 0, "min": 0, "max": 5 }
  },
  "abilities": {
    "vigor": { "value": 1, "min": 0, "max": 5, "category": "physical" },
    "health": { "value": 1, "min": 0, "max": 5, "category": "physical" },
    "precision": { "value": 1, "min": 0, "max": 5, "category": "manual" },
    "reflexes": { "value": 1, "min": 0, "max": 5, "category": "manual" },
    "knowledge": { "value": 1, "min": 0, "max": 5, "category": "mental" },
    "perception": { "value": 1, "min": 0, "max": 5, "category": "mental" },
    "will": { "value": 1, "min": 0, "max": 5, "category": "social" },
    "empathy": { "value": 1, "min": 0, "max": 5, "category": "social" }
  },
  "skills": { ... }, // 30+ compétences avec valeur (0-5)
  "skill_categories": {
    "preferred": "",
    "man": { "label": "VERMINE.skill_category.man", "preferred": false },
    "animal": { ... },
    "tool": { ... },
    "weapon": { ... },
    "survival": { ... },
    "world": { ... }
  },
  "encounters": [], // NOUVEAU: Liste des groupes/rencontres
  "combatStatus": { "label": "", "difficulty": 7 },
  "minorWound": { "threshold": 1, "value": 0, "min": 0, "max": 5 },
  "majorWound": { "threshold": 4, "value": 0, "min": 0, "max": 4 },
  "deadlyWound": { "threshold": 8, "value": 0, "min": 0, "max": 2 }
}

Données d'un PNJ (npc)

{
  "age": 15,
  "skills": "",
  "threat": { "value": 1, "min": 1, "max": 4 },
  "experience": { "value": 1, "min": 1, "max": 4 },
  "role": { "value": 1, "min": 1, "max": 4 }
}

Données d'un Groupe (group)

{
  "identity": {
    "totem": "",
    "profile": "",
    "origin": "",
    "theme": "",
    "instincts": "",
    "prohibits": "",
    "major_objectives": "",
    "minor_objectives": "",
    "notes": ""
  },
  "level": { "value": 0, "min": 0, "max": 3 },
  "reputation": { "value": 10, "min": 2, "max": 10 },
  "morale": { "level": "high", "value": 7, "min": 1, "max": 7 },
  "members": [],
  "encounters": []
}

Données d'une Créature (creature)

{
  "skills": "",
  "modes": {
    "survival": true,
    "nightmare": true,
    "apocalypse": false
  },
  "pattern": { "value": 1, "min": 1, "max": 4 },
  "size": { "value": 1, "min": 1, "max": 4 },
  "role": { "value": 1, "min": 1, "max": 4 },
  "pack": { "value": 0, "min": 0, "max": 3 }
}

VermineItem

La classe VermineItem étend la classe Item de FoundryVTT.

Types d'items

1. item: Objet général
2. weapon: Arme
3. defense: Protection
4. vehicle: Véhicule
5. ability: Capacité
6. specialty: Spécialité
7. background: Historique
8. trauma: Traumatisme
9. evolution: Évolution
10. rumor: Rumeur
11. target: Cible
12. rite: Rite

Méthodes principales

• prepareData(): Prépare les données de l'item
• prepareBaseData(): Prépare les données de base
• getRollData(): Retourne les données pour les jets de dés
• roll(): Effectue un jet de dés pour l'item

Données communes à tous les items

{
  "description": "",
  "rarity": { "value": 3, "handicap": 0 },
  "reliability": 3,
  "handicap": 0,
  "quantity": 1,
  "weight": 0,
  "traits": {},
  "damages": {
    "value": 0,
    "min": 0,
    "max": 5,
    "pannes": ["mineure", "mineure", "grave", "grave", "critique"],
    "state": ["endommagé", "endommagé", "défectueux", "défectueux", "hors d'usage"],
    "effect": ["bonus annulé", "bonus annulé", "malus 1D", "malus 1D", "inutilisable"]
  }
}

Données spécifiques par type

weapon:

{
  "min_range": 0,
  "max_range": 0,
  "damage": { "value": 0, "type": "", "addVigor": false },
  "ammo": 0
}

defense:

{
  "level": 0,
  "specificLevel": { "label": "", "level": 0 },
  "mobility": 0,
  "isShield": false
}

ability:

{
  "type": "",
  "totem": "",
  "learn": { "threshold": 5, "hindrance": 0 },
  "level": { "value": 1, "min": 1, "max": 3 },
  "effects": []
}

specialty:

{
  "skill": ""
}

rite:

{
  "rituel": "",
  "transe": "",
  "ability": "",
  "effect": ""
}

---

Fiches (Sheets)

Hierarchie des classes

ActorSheet (FoundryVTT)
└── VermineActorSheet
    ├── VermineCharacterSheet
    ├── VermineNpcSheet
    ├── VermineCreatureSheet
    └── VermineGroupSheet

ItemSheet (FoundryVTT)
└── VermineItemSheet

VermineCharacterSheet

Fiche pour les personnages joueurs.

Onglets

1. Caractéristiques et compétences (abilities)
   • Caractéristiques (8)
   • Compétences (30+) groupées par catégorie
   • Domaines de prédilection
   • Spécialités
2. Totem et ajustements (totem)
   • Sélection du totem
   • Dés de totem (humain/adapté)
   • Capacités de totem
   • Capacités
   • Spécialités
   • Historiques
   • Traumatismes
   • Évolutions
3. Combat et réserves (combat)
   • Statuts de combat (offensif/actif/passif)
   • Réserves (Effort, Sang-Froid)
   • Blessures
4. Matériel (equipment)
   • Armes
   • Protections
   • Véhicules
   • Objets
5. Histoire (stories)
   • Identity (nom, âge, origine, etc.)
   • Objectifs
   • Relations
   • Biographie

Fonctionnalités

• Création de spécialités depuis les compétences
• Gestion des dés de totem (cliquables)
• Mode jeu/edit (désactive les inputs en mode jeu)
• Roll sur les caractéristiques et compétences

VermineNpcSheet

Fiche pour les PNJ.

Sélecteurs

• Menace: 1-4 (sélecteur)
• Expérience: 1-4 (sélecteur)
• Rôle: 1-4 (sélecteur)

Onglets

1. Caractéristiques et compétences
   • Menace (attaque, vigueur, blessures)
   • Expérience (action, spécialités, relances, contact)
   • Rôle (réaction, réserves, matériel, protection)
2. Matériel
3. Combat

VermineCreatureSheet

Fiche pour les créatures.

Sélecteurs

• Gabarit: 1-4 (sélecteur)
• Taille: 1-3 (sélecteur)
• Rôle: 1-4 (sélecteur)
• Groupe: 0-3 (sélecteur)
• Modes: Survie, Cauchemar, Apocalypse (checkboxes)

Onglets

1. Caractéristiques et compétences
   • Gabarit (attaque, dégâts, blessures)
   • Taille (attaque, vigueur, blessures)
   • Rôle (réaction, réserves, matériel, protection)
   • Meute (attaque, dégâts, blessures)
2. Combat

VermineGroupSheet

Fiche pour les groupes.

Fonctionnalités

• Sélection du totem
• Gestion des membres (ajout/suppression)
• Gestion des rencontres (ajout/suppression)

Synchronisation

• Les membres sont stockés dans system.members (IDs)
• Les rencontres sont stockées dans system.encounters (IDs)
• Les groupes d'un acteur sont stockés dans system.encounters (IDs)

VermineItemSheet

Fiche pour les items.

Types gérés

• item
• weapon
• defense
• vehicle
• ability
• specialty
• background
• trauma
• evolution
• rumor
• target
• rite

---

Système de Dés

VermineUtils.roll()

Méthode principale pour effectuer un jet de dés.

Paramètres

{
  actor: Actor,          // L'acteur qui lance les dés
  NoD: number,          // Nombre de dés de base
  Reroll: number,       // Nombre de relances autorisées
  difficulty: number,    // Difficulté du jet (3-10)
  self_control: number, // Sang-Froid utilisé
  rollLabel: string,    // Libellé du jet
  totems: object,        // { human: boolean, adapted: boolean }
  max_effort: number,    // Effort maximum
  skillCategory: string, // Catégorie de compétence pour les bonus de domaine
  keepTotem: string,     // Totem à garder ('human' ou 'adapted')
  skillLevel: number,    // Niveau de la compétence pour les réussites automatiques
  hasSpecialty: boolean   // Si une spécialité est utilisée
}

Fonctionnement

1. Calcul des bonus/malus de totem

   • Si une catégorie de compétence est spécifiée, calcule les bonus/malus basés sur le domaine de prédilection
   • Bonus: +1 dé si le domaine de prédilection est dans les domaines du totem
   • Malus: -1 dé si le domaine de prédilection est dans les domaines du totem opposé

2. Réussites automatiques

   • Niveau 2 (Compétent) + spécialité: +1 réussite automatique
   • Niveau 3 (Expert): +1 réussite automatique
   • Niveau 4 (Maître) + spécialité: +2 réussites automatiques
   • Niveau 5 (Légende): +2 réussites automatiques

3. Seuils automatiques

   • Niveau 0 (Incompétent): seuil = 9 (très difficile)
   • Niveau 1 (Débutant): seuil = 7 (difficile)
   • Niveau >= 2: utilise la difficulté spécifiée

4. Gestion des totems

   • Chaque totem utilisé ajoute un dé spécial avec double réussite possible
   • Le totem humain et adapté peuvent être utilisés simultanément
   • Si keepTotem est spécifié, seul un totem est utilisé

5. Formule de jet

   • Base: {NoD}d10cs>={difficulty}[regular_{user}]
   • Avec totem humain: + (1d10cs>={difficulty}[human_{user}]*2)
   • Avec totem adapté: + (1d10cs>={difficulty}[adapted_{user}]*2)

Exemple

// Jet de compétence avec totem humain
VermineUtils.roll({
  actor: character,
  NoD: 3,                    // 3 dés de base
  difficulty: 7,             // Difficulté 7
  skillCategory: 'survival', // Catégorie de compétence
  skillLevel: 3,             // Niveau Expert
  hasSpecialty: true,        // Avec spécialité
  totems: { human: true, adapted: false } // Totem humain seulement
});
// Résultat: 4d10cs>=7[regular_user] + (1d10cs>=7[human_user]*2)
// avec 1 réussite automatique (niveau 3)

RollDialog

Dialogue de jet de dés avancé.

Fonctionnalités

• Sélection de la caractéristique
• Sélection de la compétence
• Sélection de la spécialité (+1D)
• Sélection de la difficulté
• Sélection du handicap
• Bonus:
  • Entraide (+1D)
  • Groupe (0-5D)
  • Sang-Froid (0-5D, basé sur la caractéristique)
  • Équipement (+1D)
  • Dés de totem (humain/adapté)
• Affichage du total du pool de dés
• Choix du totem à garder (si les deux sont activés)

Structure du template

• Utilise <details>/<summary> pour une interface compacte
• Sections principales:
  • Sélection caractéristique + compétence
  • Difficulté + Handicap (section ouverte par défaut)
  • Bonus (section pliable)
  • Total du pool de dés

---

Combat

VermineCombat

Classe étendue de Combat de FoundryVTT.

Formules

• Initiative: @abilities.reflexes.value + @skills.alertness.value)d10cs>=@combatStatus.difficulty
• Difficulté dynamique:
  • Offensif: 5
  • Actif: 7
  • Passif: 9

Classes

• VermineCombat: Gestion du combat
• VermineCombatTracker: Tracker de combat personnalisé
• VermineCombatant: Combatant personnalisé

Statuts de combat

Chaque acteur a un combatStatus avec:

• label: "Offensif", "Actif", ou "Passif"
• difficulty: 5, 7, ou 9

VermineFight

Classe pour la gestion des confrontations (ancien système).

À migrer vers le nouveau système de combat.

---

Gestion des Groupes

GroupLink

Classe pour la synchronisation bidirectionnelle entre acteurs et groupes.

Fonctionnalités

1. Synchronisation automatique

   • Quand un groupe est mis à jour, les acteurs membres sont notifiés
   • Quand un acteur est mis à jour, ses groupes sont notifiés

2. Hooks enregistrés

   • updateActor: Synchronise les groupes quand un acteur est mis à jour
   • createActor: Nettoie les références invalides
   • deleteActor: Retire l'acteur de tous ses groupes

3. Méthodes utilitaires

   • getActorObjects(actorIds): Retourne les objets Actor pour une liste d'IDs
   • getGroupMembers(group): Retourne les membres d'un groupe
   • getGroupEncounters(group): Retourne les rencontres d'un groupe
   • getActorGroups(actor): Retourne les groupes d'un acteur
   • getActorEncounters(actor): Retourne les rencontres d'un acteur
   • addActorToGroup(actorId, groupId): Ajoute un acteur à un groupe
   • removeActorFromGroup(actorId, groupId): Retire un acteur d'un groupe

Exemple d'utilisation

// Ajouter un acteur à un groupe
GroupLink.addActorToGroup('actor123', 'group456');

// Retirer un acteur d'un groupe
GroupLink.removeActorFromGroup('actor123', 'group456');

// Obtenir les membres d'un groupe
const members = GroupLink.getGroupMembers(group);

---

Synchronisation

Hooks principaux

Dans module/vermine2047.mjs

• Initialisation des classes globales
• Enregistrement des hooks GroupLink
• Pré-chargement des templates Handlebars
• Configuration de l'interface utilisateur (mode de jeu)

Dans module/system/hooks.mjs

• diceSoNiceReady: Configuration des dés 3D
• renderChatMessage: Gestion des relances de dés
• updateUser: Mise à jour des dés 3D pour l'utilisateur
• ready: Initialisation du système
• renderPause: Personnalisation de l'écran de pause
• hotbarDrop: Gestion du glisser-déposer sur la barre d'outils
• getSceneControlButtons: Ajout du bouton de lancer de dés
• preCreateActor: Image par défaut pour les acteurs
• preCreateItem: Image par défaut pour les items

Hooks GroupLink

Voir Gestion des Groupes.

---

Templates

Structure

Tous les templates sont en format Handlebars (.hbs) et sont situés dans le dossier templates/.

Types de templates

1. Templates principaux

   • templates/actor/actor-*.hbs: Fiches d'acteurs
   • templates/item/item-sheet.hbs: Fiche d'item
   • templates/roll-message.hbs: Message de jet de dés
   • templates/combat-tracker.hbs: Tracker de combat

2. Templates de dialogue

   • templates/dialogs/roll-dialog.hbs: Dialogue de jet de dés
   • templates/dialogs/min-max-edit.hbs: Édition min/max

3. Partials

   • templates/actor/parts/*: Parties réutilisables des feuilles d'acteur
   • templates/actor/character/*: Parties spécifiques aux personnages
   • templates/actor/group/*: Parties spécifiques aux groupes
   • templates/actor/npc/*: Parties spécifiques aux PNJ
   • templates/actor/creature/*: Parties spécifiques aux créatures
   • templates/item/partials/*: Parties réutilisables des feuilles d'item

4. Chat Cards

   • templates/item/chatCards/*.hbs: Cartes de chat pour chaque type d'item

Helpers Handlebars

Tous les helpers sont définis dans module/system/handlebars-manager.mjs.

Helpers de traduction

• smarttl(arrayLabel, objectLabel, key): Traduction intelligente
• smarttlk(arrayLabel, objectLabel, key): Traduction avec clé
• smartcfg(configLabel, objectLabel): Traduction de configuration

Helpers de niveau

• skillLevel(property, level): Propriété d'un niveau de compétence
• diffLevel(property, level): Propriété d'un niveau de difficulté
• threatLevel(property, level): Propriété d'un niveau de menace
• experienceLevel(property, level): Propriété d'un niveau d'expérience
• roleLevel(property, level): Propriété d'un niveau de rôle
• patternLevel(property, level): Propriété d'un niveau de gabarit
• sizeLevel(property, level): Propriété d'un niveau de taille
• packLevel(property, level): Propriété d'un niveau de meute
• ageType(property, level): Propriété d'un type d'âge
• npcThreatLevel(property, level): Propriété d'un niveau de menace PNJ
• npcExperienceLevel(property, level): Propriété d'un niveau d'expérience PNJ
• npcRoleLevel(property, level): Propriété d'un niveau de rôle PNJ
• creaturePatternLevel(property, level): Propriété d'un niveau de gabarit créature
• creatureSizeLevel(property, level): Propriété d'un niveau de taille créature
• creatureRoleLevel(property, level): Propriété d'un niveau de rôle créature
• creaturePackLevel(property, level): Propriété d'un niveau de meute créature

Helpers de données

• getDamagesData(damageObject, prop): Données de dégâts
• concat(...args): Concatenation de chaînes
• lower(str): Convertit en minuscules
• toLowerCase(str): Convertit en minuscules
• romanNumber(numb): Convertit un nombre en chiffre romain (I, II, III, etc.)

Helpers de comparaison

• ife(arg1, arg2, options): Si égal
• ifgt(a, b, options): Si supérieur
• iflt(a, b, options): Si inférieur
• ifgteq(a, b, options): Si supérieur ou égal
• iflteq(a, b, options): Si inférieur ou égal
• ifincludes(arg1, arg2, options): Si contient

Helpers mathématiques

• math_add(a, b): Addition
• math_subs(a, b): Soustraction
• math_mult(a, b): Multiplication
• math_div(a, b): Division

Helpers de boucle

• repeat(times, start, indexLabel, block): Boucle avec index
• setVar(varName, varValue, options): Définit une variable

---

Traductions

Structure

Les traductions sont définies dans les fichiers:

• lang/fr.json: Français
• lang/en.json: Anglais

Namespaces principaux

• SETTINGS: Paramètres du monde
• VERMINE: Termes spécifiques au système
  • ability: Caractéristiques
  • skills_title: Compétences
  • wounds: Blessures
  • tabs: Onglets
• ABILITIES: Caractéristiques
• SKILLS: Compétences
• SKILL_LEVELS: Niveaux de compétence
• DIFFICULTY_LEVELS: Niveaux de difficulté
• THREAT_LEVELS: Niveaux de menace
• EXPERIENCE_LEVELS: Niveaux d'expérience
• ROLE_LEVELS: Niveaux de rôle
• PATTERN_LEVELS: Niveaux de gabarit
• AGE_TYPES: Types d'âge
• ATTITUDES: Attitudes de combat
• ADVERSITY: Adversité (PNJ/Créature)
• TOTEMS: Totems
• GAME_MODES: Modes de jeu
• IDENTITY: Identité
• UI: Interface utilisateur
• ITEMS: Items

Ajout de traductions

Pour ajouter une nouvelle traduction:

1. Ajouter la clé dans les deux fichiers (fr.json et en.json)
2. Utiliser la clé avec game.i18n.localize('NAMESPACE.key') ou {{localize 'NAMESPACE.key'}} dans les templates

Exemple:

{
  "VERMINE": {
    "new_feature": "Nouvelle fonctionnalité"
  }
}

---

Bonnes pratiques

Développement

1. Always use strict mode
2. Use async/await for asynchronous operations
3. Error handling: Always catch and handle errors
4. Data validation: Validate input data
5. Performance: Be mindful of performance in hooks

Code style

1. Naming: Use camelCase for variables and functions, PascalCase for classes
2. Comments: Use JSDoc for functions and classes
3. Imports: Group related imports together
4. Exports: Use named exports for utility functions

Templates

1. Keep templates simple: Move complex logic to helpers
2. Use partials: Reuse common template parts
3. Accessibility: Use proper labels and ARIA attributes
4. Responsive: Design for different screen sizes

Internationalization

1. Always use localization: Never hardcode text
2. Context: Provide context in translation keys
3. Fallback: Provide fallback text for missing translations

---

Dépendances

Modules externes

• Dice So Nice: Pour les dés 3D
  • Configuration dans module/system/dice3d.mjs
  • Dé différents pour Vermine2047

Compatibilité

• FoundryVTT: v11-v14
• Testé avec: v12, v14

---

Résolution des problèmes

Problèmes courants

1. Templates not found

   • Vérifier que le template existe dans le bon dossier
   • Vérifier que l'extension est .hbs
   • Vérifier que le template est pré-chargé dans handlebars-manager.mjs

2. Translations missing

   • Vérifier que la clé existe dans le fichier de langue
   • Vérifier que le namespace est correct
   • Utiliser game.i18n.localize() pour déboguer

3. Hooks not firing

   • Vérifier que le hook est bien enregistré
   • Vérifier que le hook est appelé au bon moment
   • Utiliser CONFIG.debug.hooks = true pour déboguer

4. Data not updating

   • Vérifier que les données sont bien modifiées
   • Vérifier que actor.update() ou item.update() est appelé
   • Vérifier que les hooks de synchronisation sont actifs

Outils de débogage

1. Console.log

   console.log('Debug:', data);
   

2. Notifications

   ui.notifications.info('Message d'information');
   ui.notifications.warn('Avertissement');
   ui.notifications.error('Erreur');
   

3. Dialogues de débogage

   new Dialog({
     title: 'Debug',
     content: `<pre>${JSON.stringify(data, null, 2)}</pre>`,
     buttons: { ok: { label: 'OK' } }
   }).render(true);
   

---

Contribution

Comment contribuer

1. Fork le dépôt
2. Create une branche pour votre fonctionnalité
3. Commit vos changements
4. Push à la branche
5. Open une Pull Request

Guidelines

1. Suivre le style de code existant
2. Ajouter des tests si possible
3. Mettre à jour la documentation
4. Utiliser des messages de commit clairs

---

Historique des versions

Voir CHANGELOG.md pour l'historique complet.

---

Licence

Voir LICENSE.txt pour les détails de la licence.

---

Auteurs

• François-Xavier Guillois
• Rwanoux (Discord: rwanoux)
• Pretre (Discord: pretre)

---

Documentation générée: 2026-06-04 Version: 0.1.14