# RPFM, le guide : ajouter une unité, une faction et un seigneur dans Total War: Warhammer III > RPFM (Rusted PackFile Manager) ouvre et fabrique les packs de Total War. Ce guide montre pas à pas comment s'en servir, puis déroule trois procédures complètes pour Total War: Warhammer III : ajouter une unité, une faction, un seigneur légendaire ou jouable. Les pièges viennent de la communauté et de notre chantier. Page : https://bretonia.dev/atelier/rpfm/ · Atlas de Bretonnie, atelier des moddeurs · mis à jour le 2026-09-25. Version en texte brut, pour les lecteurs et les IA ; les schémas y sont décrits en mots. Relu le 25 septembre 2026, mise à jour 9.0. Écrit contre ses sources, le code et le manuel de RPFM 5.0.6 (libellés et emplacements), les données du jeu et l'Assembly Kit au patch 8.1 ; ce que la 9.0 a changé sur notre chantier y est ajouté, le reste n'a pas été revérifié point par point. ## Ce que fait RPFM, et ce qu'est un pack Un mod de Total War est un fichier `.pack`, une archive que le jeu lit dans son dossier `data`. **RPFM** (Rusted PackFile Manager, de Frodo45127, sous licence MIT) ouvre les packs du jeu en lecture et fabrique les vôtres. Un pack range des tables (`db/`), des textes (`text/db/.loc`), des scripts Lua (`script/`), des images (`ui/`), des définitions de modèles (`variantmeshes/`) et, pour une campagne, sa position de départ (`campaigns//startpos.esf`). *Schéma : Anatomie d'un pack.* Dans le schéma : Anatomie d'un pack · `atlas_chevaliers.pack` · votre mod : une archive, posée dans le dossier data du jeu · `db/land_units_tables/` · ne jamais le renommer ni le déplacer (RPFM) · `atlas_land_units` · le vôtre, à votre préfixe ; @ ou ! devant : seulement pour modifier une ligne du jeu · `data__` · le nom de la table du jeu : jamais dans votre pack · `text/db/` · `atlas.loc` · une clé par phrase ; vaut pour toutes les langues · `script/campaign/mod/` · `atlas_script.lua` · chargé tout seul par le jeu · `ui/units/icons/` · `.png` · la carte d'unité : 60 × 130 · `ui/flags//` · les drapeaux · `ui/portraits/portholes/` · `portrait_settings*.bin` · les réglages des portraits, par art set · `variantmeshes/variantmeshdefinitions/` · `*.variantmeshdefinition` · un modèle neuf · `campaigns//` · `startpos.esf` · produit par le jeu ; un par campagne · `campaign_maps//` · `hlp_data.esf · spd_data.esf` · produits par le jeu, pour une carte neuve · `settings.rpfm_reserved · notes.rpfm_reserved` · les réglages et notes de RPFM, ignorés par le jeu · Tables et .loc : fusionnés par clé. · Autres fichiers : même chemin, un seul gagne. Un pack range chaque fichier à son chemin. Les fragments d'une même table (un dossier _tables), comme les .loc, se fusionnent par clé ; pour tout autre fichier, deux fichiers au même chemin ne se chargent pas tous les deux : un seul gagne. En or, ce que le jeu produit ; en gris, ce que seul RPFM lit. Ce guide suit RPFM **5.0.6**, dernière version stable au 24 septembre 2026, et des tables relevées sur le patch 8.1. Pour la mise à jour 9.0, sortie le même jour, les schémas de RPFM ont été publiés dès ce jour-là ; les tables citées ici n'ont pas été relues une à une depuis : dans le doute, vérifiez. Toute modification suit ces six étapes : 1. **Trouver** : La ligne du jeu la plus proche. (View → Toggle Global Search Window (Ctrl+Shift+F)) 2. **Copier** : Dans votre table (`db/_tables/`), sous une clé à vous (la même pour modifier une ligne du jeu). (clic droit sur le pack → Create… → Create DB, puis Paste as New Row) 3. **Nommer** : Les textes affichés au joueur, dans `text/db/.loc`. (clic droit sur le pack → Create… → Create Loc) 4. **Contrôler** : Références, clés, champs vides. (panneau Diagnostics → Check PackFile) 5. **Essayer** : Le pack installé dans `\data\`, en jeu. (clic droit sur la racine du pack → Install) 6. **Publier** : La version optimisée. (clic droit sur la racine du pack → Save Pack For Release… (sur une copie)) ## Les mots du métier | Mot | Sens | |---|---| | Pack | l'archive d'un mod, posée dans le dossier `data` du jeu | | Table | un tableau de la base du jeu, rangé dans `db/
_tables/` | | Clé | ce qui identifie une ligne, unique dans sa table (parfois plusieurs colonnes) | | Fragment | un fichier de table ; le jeu lit tous les fragments d'une table, les siens et ceux des mods | | Datacore | un fragment nommé comme celui du jeu (`data__`), qui remplace la table entière | | `.loc` | un fichier de textes : une clé par phrase affichée | | Schéma | la description des tables : colonnes, clés, liens (celle de RPFM, ou celle du kit : `TWaD_*.xml`) | | Cache des dépendances | les données du jeu, préparées par RPFM pour chercher et contrôler | | Assembly Kit | le kit officiel de Creative Assembly (Steam → Bibliothèque → Outils) | | Sous-type | le type exact d'un personnage (`agent_subtypes`) | | Art set | l'ensemble des apparences d'un personnage (`campaign_character_art_sets`) | | Startpos | `startpos.esf`, la sauvegarde du tour 0 d'une campagne | | Racine du pack | la première ligne de l'arbre du pack, à son nom ; son clic droit porte Install, Uninstall, Save Pack For Release… et Build Startpos | | Palette | la recherche par nom de RPFM : Ctrl+Shift+P pour une action, Ctrl+P pour un fichier | | `%APPDATA%` | le dossier des réglages de votre compte Windows : tapez `%APPDATA%` dans la barre d'adresse de l'Explorateur | | Groupe militaire | `military_group`, le groupe de recrutement d'une faction : une unité permise à un groupe l'est à toutes ses factions (chez CA, les factions de Bretonnie ont `wh_main_group_bretonnia`) | | `twad_key_deletes` | la table qui retire des lignes du jeu au lancement (Warhammer III, depuis le patch 6.3) : colonnes `table_name` et `key` | | Mixer | *MIXER – Mixu's Unlocker*, un mod de Mixu : son startpos rend jouables toutes les factions des Empires Immortels et des Royaumes du Chaos ; selon le wiki, c'est le seul mod de startpos de la plupart des joueurs | | Error / Warning / Info | les trois gravités des diagnostics : *Error*, un problème en jeu ; *Warning*, un problème probable ; *Info*, à savoir. Visez zéro *Error* | ## Installer et configurer RPFM 5.0.6 Téléchargez RPFM depuis ses [versions publiées](https://github.com/Frodo45127/rpfm/releases), puis, une fois pour toutes : 1. **PackFile → Settings.** *Game Paths* : le *Game Folder* (le dossier de l'exécutable du jeu) et l'*Assembly Kit Folder*. *Extra Paths* : le *MyMod's Folder*, **hors de Program Files**, où Windows protège l'écriture. *Default Game* : Warhammer 3. 2. **About → Check Updates**, puis, dans le gestionnaire de mises à jour, le bouton de la ligne *Schema Updates* : le schéma dit à RPFM comment lire chaque table du patch en cours (vous pouvez aussi cocher *Check Schema Updates on Start* dans les réglages). 3. **Game Selected → Generate Dependencies Cache**, quelques minutes : RPFM prépare les données du jeu pour ses recherches et ses contrôles. Sans Assembly Kit configuré, il prévient que ses diagnostics donneront de faux positifs. *Schéma : Régler RPFM : trois gestes.* Dans le schéma : Régler RPFM : trois gestes · PackFile → Settings · Settings · Game Paths · Warhammer 3 · `Game Folder` · `` · `Assembly Kit Folder` · `` · Extra Paths · `MyMod's Folder` · `` · pas dans Program Files : Windows y protège l'écriture · `Default Game` · `Warhammer 3` · About → Check Updates · Update Manager · `Program Updates:` · `Schema Updates:` · `Lua Autogen Updates:` · `Old AK Updates:` · à cocher aussi, dans Settings : Check Schema Updates on Start · Game Selected → Generate Dependencies Cache · les données du jeu · le cache · quelques minutes ; pour ses recherches et ses contrôles · Sans Assembly Kit configuré, RPFM prévient : de faux positifs dans les diagnostics. · Après une mise à jour du jeu : refaites 2 et 3. Schéma, disposition courante. Trois réglages à faire une fois, dans l'ordre : les dossiers (1), les schémas des tables (2), le cache des dépendances (3) ; après une mise à jour du jeu, on refait 2 et 3. > **Le manuel, la fenêtre et les anciens tutoriels** : Le [manuel de RPFM](https://frodo45127.github.io/rpfm/manual/) décrit la 5.0.6, mais pas toujours avec les libellés de la fenêtre : il écrit « Pack » pour le menu **PackFile** et, sur une page, « Edit → Preferences » pour **PackFile → Settings**. Les anciens tutoriels (RPFM 2 à 4) écrivent « PackFile → Preferences » et « Special Stuff → … » : ce menu n'existe plus, ses actions (Build Startpos, Optimize PackFile…) sont au **clic droit sur la racine du pack**. Certains messages de RPFM citent encore « Special Stuff » pour le cache : c'est **Game Selected → Generate Dependencies Cache**. En cas de doute, la **palette** (Ctrl+Shift+P) retrouve toute action par son nom. ## Les gestes de base La fenêtre de RPFM 5.0.6, zone par zone : *Schéma : La fenêtre de RPFM 5.0.6 et ses neuf zones.* 1. **Les menus** : PackFile, MyMod, View, Game Selected, Tools, About. Les réglages : PackFile → Settings (Ctrl+,) ; les schémas : About → Check Updates ; le cache : Game Selected → Generate Dependencies Cache. 2. **Les onglets** : un par fichier ouvert. 3. **Pack Contents** : l'arbre du pack ; sa première ligne, la racine, porte le nom du pack. 4. **Le clic droit sur la racine** : Save Pack As…, Save Pack For Release…, Install, Uninstall, Change PackFile Type, Optimize PackFile, Build Startpos (et d'autres actions) : ce qui touche au pack entier. 5. **Dependencies** : les fichiers du jeu, des mods parents et de l'Assembly Kit, en lecture seule ; clic droit → Import en amène un dans votre pack. 6. **La table ouverte** : votre ligne, surlignée ; en rouge, une référence invalide : aucune ligne de land_units ne porte encore cette clé. Le fichier atlas_main_units n'a pas de @ : il ajoute une clé neuve. 7. **Diagnostics** : Check PackFile relit le pack ; chaque ligne a sa gravité : Error, Warning ou Info. Visez zéro Error. 8. **Global Search** : masquée au départ : View → Toggle Global Search Window (Ctrl+Shift+F) ; sources Game Files ou Assembly Kit Tables. 9. **La barre d'état** : les messages brefs de la dernière opération. Schéma, disposition courante. Les réglages, les schémas et le cache sont dans les menus (1) ; ce qui touche au pack entier, au clic droit sur sa racine (4). Toute action se retrouve aussi par son nom dans la palette : Ctrl+Shift+P. Les menus Special Stuff et Edit → Preferences des anciens tutoriels n'existent pas dans la 5.0.6. ### Créer son mod **MyMod → New MyMod.** Choisissez le jeu (Warhammer 3) et un nom avec des soulignés, sans espace ni `.pack` (`auteur_description`). RPFM crée le pack `\warhammer_3\.pack` et, à côté, le dossier `\warhammer_3\\` pour vos fichiers de travail (plus un dépôt Git ou un projet VSCode si vous les cochez), puis ouvre le pack. Le dossier MyMod doit être réglé avant, sinon RPFM refuse. ### Trouver une donnée du jeu **View → Toggle Global Search Window** (Ctrl+Shift+F) : source *Game Files* (ou *Assembly Kit Tables*), type *DB* (*Loc* pour les textes), puis la clé, soulignés compris ; un clic ouvre la table à la bonne ligne, en lecture seule. Autres voies : **PackFile → Load All CA Packs** (lecture seule ; grisée quand le cache des dépendances est chargé), ou **View → Toggle Dependencies Window**, clic droit → *Import*, qui amène un fichier du jeu dans votre pack : renommez aussitôt une table amenée ainsi (F2), car sous le nom `data__` elle remplacerait celle du jeu. ### Créer une table Clic droit sur le pack → **Create… → Create DB** ; choisissez la table (`land_units_tables`) et nommez le fichier avec votre préfixe : `db/land_units_tables/atlas_land_units`. Le nom compte : quand votre fichier et celui du jeu (`data__`) donnent la même clé, celui dont le nom trie en premier gagne. Pour **ajouter** des lignes (clés neuves), tout nom à vous convient ; pour **modifier** une ligne du jeu (même clé), commencez le nom par `@` ou `!`. - **Ne renommez ni ne déplacez jamais un dossier `_tables`** (« NEVER RENAME/MOVE THE TABLE FOLDERS », écrit RPFM) : c'est lui qui dit au jeu de quelle table il s'agit. - **Ni chiffre final ni espace dans un nom de fichier de table** : selon RPFM, un chiffre final fait planter le mod chez tout le monde sauf chez son auteur, et une espace empêche parfois la table d'être chargée. ### Partir d'une ligne du jeu 1. Dans la table du jeu, sélectionnez la ligne modèle (cliquez son numéro) : **Copy… → Copy**. 2. Dans votre table : **Paste as New Row** (Ctrl+Shift+V). Pour **ajouter** une ligne, **changez la clé en premier** : sinon votre ligne n'ajoute rien, elle entre en concurrence avec celle du jeu. 3. Pour dupliquer une de vos lignes : **Clone… → Clone and Append**. ### Suivre une clé Clic droit sur une cellule → **Go To… → Go To Definition** (la ligne citée), **Go To Loc Entry** (son texte) ou **Find References** (tout ce qui cite cette clé) ; **Rename References** renomme une clé partout (le manuel l'appelle *Cascade Edition*). C'est ainsi qu'on démonte une unité ou un seigneur, table après table. *Schéma : Suivre une clé.* Dans le schéma : Suivre une clé · `atlas_chevaliers` · clic droit sur une cellule · `Go To…` · `Find References` · `Rename References` · `Go To Definition` · `Go To Loc Entry` · `building_units_allowed · unit` · `units_custom_battle_permissions · unit` · `…` · `Find References` · qui la cite · `main_units` · `unit` · `atlas_chevaliers` · `land_unit` · `atlas_chevaliers` · `Go To Definition` · la ligne citée · `land_units` · `key` · `atlas_chevaliers` · `Go To Loc Entry` · son texte · `text/db/atlas.loc` · `land_units_onscreen_name_atlas_chevaliers` · `text` · le nom affiché · Rename References : renomme la clé partout · le manuel l'appelle Cascade Edition Schéma : au clic droit sur une cellule, quatre gestes suivent une clé d'une table à l'autre : la ligne qu'elle cite (1), son texte (2), tout ce qui la cite (3) ; Rename References la renomme partout (4). Chaque cellule porte le numéro du geste qui en part. ### Écrire les textes 1. Clic droit sur le pack → **Create… → Create Loc**, par exemple `text/db/atlas.loc`. 2. Trois colonnes : *key* (la clé), *text* (le texte affiché) et *tooltip*, dont le rôle est inconnu selon le manuel de RPFM : faites comme les lignes de CA. 3. La clé a la forme `
__`. Exemple : le nom de l'unité `atlas_chevaliers` (colonne `onscreen_name` de `land_units`) a pour clé `land_units_onscreen_name_atlas_chevaliers`. 4. Clic droit sur le pack → **Generate Loc Data** produit deux fichiers. `zzz_…` : les clés qui manquent à vos tables ; renommez-le ou recopiez ses lignes dans votre `.loc`, puis remplissez-les. `aaa_…` : les textes du jeu que vos tables citent ; n'en gardez que ce que vous changez. Ne publiez aucun des deux sous son nom d'origine : RPFM les réécrit à chaque génération, et l'optimiseur retire `aaa_…` (et `zzz_…` s'il est vide). *Schéma : Une clé de texte, et Generate Loc Data.* Dans le schéma : Une clé de texte · `land_units` · la table · `+` · `_onscreen_name_` · la colonne · `+` · `atlas_chevaliers` · la clé de la ligne · `land_units_onscreen_name_atlas_chevaliers` · dans votre .loc : le nom de l'unité · Clic droit sur le pack → Generate Loc Data · `zzz_…` · vos clés sans texte : renommez-le, ou recopiez ses lignes dans votre .loc, puis remplissez-les · `aaa_…` · des textes du jeu que vos tables citent : n'en gardez que ce que vous changez · Ni l'un ni l'autre sous son nom d'origine : RPFM les réécrit à chaque génération ; l'optimiseur retire aaa_… (et zzz_… s'il est vide). Une clé de texte suit la forme
__. Generate Loc Data produit deux fichiers : zzz_… pour vos clés sans texte, aaa_… pour les textes du jeu que vos tables citent. ## Vérifier, tester, publier ### Les diagnostics **View → Toggle Diagnostics Window → Check PackFile**, avant chaque essai : un défaut repéré ici épargne un lancement du jeu pour rien. Chaque ligne porte une gravité : *Error* (un problème en jeu), *Warning* (un problème probable), *Info* (à savoir) ; visez zéro *Error*. La figure suit un mod du diagnostic jusqu'au jeu. *Schéma : Vérifier un mod, du diagnostic au jeu.* Dans le schéma : Du diagnostic au jeu · Check PackFile · dans le panneau Diagnostics · Error, Warning, Info : visez zéro Error. · Ctrl+S · enregistre les packs ouverts. · Clic droit sur la racine → Install · RPFM copie le pack dans le dossier data du jeu. · Cocher le mod · dans le lanceur, Kaedrin's Mod Manager ou Runcher. · Absent de la liste : clic droit sur la racine → Change · PackFile Type → Mod, et Index Includes Timestamp décoché. · Essayer en jeu · une unité : bataille personnalisée ; une faction, un seigneur : campagne neuve. · Le jeu plante au lancement : retour à 1 · `Invalid reference, Value Cannot be Empty,` · `Banned Table` · Un script ne fait rien : lisez son journal · `script/enable_console_logging →` · `script_log_*.txt` · Le jeu se referme à chaque lancement : une ligne restée · `user.script.txt :` · `quit_after_campaign_processing;` Cinq marches, dans l'ordre : chaque essai en jeu commence par Check PackFile. Si le jeu plante, si un script se tait ou si le jeu se referme sans cesse, la sortie rouge dit où regarder. RPFM contrôle : - **les tables** : version périmée ; référence invalide, l'une des premières causes de plantage au lancement selon RPFM ; clé vide ou en double ; ligne vide ; champ obligatoire vide, qui peut faire planter le jeu (RPFM), souvent sans message d'erreur (Casualfield) ; nom de fichier finissant par un chiffre ou contenant une espace ; table qui écrase celle du jeu (« datacoring ») ; table interdite (*Banned Table*), que le jeu vérifie et qui le fait planter si elle est modifiée ; - **les fichiers** : chemin cité mais introuvable, texte manquant ; - **les portraits** : art sets et variantes non déclarés ; - **la configuration** : cache des dépendances absent ou périmé. ### Essayer en jeu 1. Ctrl+S (enregistre les packs ouverts), puis **clic droit sur la racine du pack** (la première ligne de l'arbre, à son nom) **→ Install** : RPFM copie le pack dans `\data\`. 2. Cochez le mod dans le lanceur de Creative Assembly, ou dans un gestionnaire tiers (Kaedrin's Mod Manager, Runcher). 3. Même menu **→ Uninstall** : retire la copie. > **Notre chantier** : Vous n'en avez pas besoin pour un mod ordinaire : le lanceur suffit. Pour jouer, on coche le mod dans le lanceur ; pour générer un startpos à la main, une ligne `mod ;` par pack dans `user.script.txt` (`%APPDATA%\The Creative Assembly\Warhammer3\scripts\user.script.txt`). Notre chantier génère ainsi son startpos à partir de deux packs : le mod, et un pack réservé aux tables de départ, dont les identifiants partent de 2 140 790 001. Une ligne `quit_after_campaign_processing;` restée dans ce fichier après une génération referme le jeu à chaque lancement. La recette : [le guide des outils](https://bretonia.dev/atelier/outils/). ### Publier Gardez votre pack de travail : copiez-le d'abord (ou *Save Pack As…* sous un autre nom), car **Save Pack For Release…** enregistre la version optimisée à la place du pack ouvert. Clic droit sur la racine du pack → **Save Pack For Release…** : l'optimiseur s'ouvre, puis le pack est enregistré ; **Optimize PackFile**, au même menu, fait le même travail sans enregistrer, pour relire avant. L'optimiseur ne fait que ce que vous cochez : - retirer les fichiers et les lignes identiques au jeu, les doublons, les fichiers vides ; - compresser le pack ; - retirer les art sets et variantes inutilisés des portraits (décoché par défaut) ; - pour Warhammer III, *Import datacores into twad_key_deletes* : il inscrit dans une table `twad_key_deletes` les lignes qu'une table recopiée du jeu a supprimées. Vérifiez cette table, renommez-la (RPFM la réécrirait au prochain passage), puis supprimez vous-même la table recopiée. *Schéma : Publier sans rien casser.* Dans le schéma : Publier sans rien casser · D'abord, une copie · Pack de travail · gardé tel quel · Sa copie · celle qu'on publie · Save Pack As…, sous un autre nom, fait aussi une copie. · Dans la copie : Save Pack For Release…, au clic droit sur la racine · `atlas_chevaliers.pack` · `Save Pack As…` · `Save Pack For Release…` · `Optimize PackFile` · Optimize PackFile, au même menu : le même travail, sans enregistrer, pour relire avant. · Il enregistre la version optimisée à la place du pack ouvert. · L'optimiseur ne fait que ce qui est coché · Identiques au jeu, doublons, fichiers vides · coché par défaut · Compresser le pack · coché par défaut · Art sets et variantes inutilisés des portraits · décoché par défaut · `Import datacores into twad_key_deletes` · décoché par défaut ; cochez-le si votre pack contient une table recopiée (Warhammer III) · Après l'option des datacores · `twad_key_deletes` · `table_name · key` · vérifiez-la, puis renommez-la : RPFM la réécrirait · `db/land_units_tables/data__` · la table recopiée du jeu : supprimez-la vous-même Schéma. Save Pack For Release… remplace le pack ouvert par sa version optimisée : travaillez sur une copie. L'optimiseur ne fait que ce qui est coché (ici, ses réglages par défaut) ; son option des datacores inscrit dans twad_key_deletes les lignes retirées, et c'est à vous de supprimer ensuite la table recopiée. ### Après une mise à jour du jeu 1. **About → Check Updates**, bouton des schémas. 2. **Game Selected → Generate Dependencies Cache** : sinon RPFM compare vos tables à un jeu périmé. 3. Sur chaque table signalée *Outdated table* : clic droit → **Update Table**. 4. Relisez les colonnes nouvelles : RPFM y met des valeurs par défaut, pas forcément les bonnes pour vos lignes. À la 9.0, les schémas de RPFM sont sortis le jour même de la mise à jour. **Si vous écrivez aussi dans l'Assembly Kit** : Steam le met à jour après le jeu (chez nous, une heure plus tard) et réécrit `raw_data\db` ; les lignes que vous y aviez ajoutées disparaissent. Vérifiez-les et restaurez-les avant de régénérer le cache des dépendances et de reconstruire quoi que ce soit. ## Les règles des packs : qui passe devant qui Le jeu lit **tous les fragments** d'une table, les siens et ceux de chaque mod : tant que les clés diffèrent, les lignes s'additionnent. Quand deux fragments donnent **la même clé**, celui dont le nom trie en premier gagne ; et un fragment qui porte le chemin exact d'un fichier du jeu le remplace tout entier. La figure ci-dessous montre qui gagne quand plusieurs fragments d'une même table donnent la même clé. *Schéma : Qui gagne quand deux fragments donnent la même clé.* Dans le schéma : Les fragments d'une table · `db/land_units_tables/` · `! # $ % & ' ( ) + , - ; = @ 0-9 a-z [ ] ^ _ ` { } ~` · lus par ordre de nom, du premier au dernier (wiki, page Submodding) · `@mon_mod` · `wh_dlc07_brt_cav_knights_errant_0 · valeur A` · votre mod, trié avant le jeu · `data__` · `wh_dlc07_brt_cav_knights_errant_0 · valeur B` · la table du jeu · `zmon_mod` · perd · `wh_dlc07_brt_cav_knights_errant_0 · valeur C` · votre mod, trié après le jeu : la ligne du jeu gagne, votre valeur est ignorée · Le jeu garde la valeur A : le premier nom trié gagne. · `data__ · dans votre mod` · Même chemin que le fichier du jeu : il le remplace en entier (un « datacore »). Les mises à jour de CA sur cette table ne passent plus ; deux datacores de la même table s'excluent. · Retirer une ligne du jeu · `twad_key_deletes :` · `table_name = land_units · key = ` · clic droit sur les lignes du jeu · → Add Selection to Key Deletes · Warhammer III, depuis le patch 6.3 Trois fragments d'une même table donnent la même clé : le jeu garde celui dont le nom trie en premier, les autres sont ignorés. Un nom en z sert à des lignes neuves que d'autres mods doivent pouvoir corriger (manuel de RPFM, page Datacores). Un fragment nommé comme le fichier du jeu le remplace tout entier ; pour retirer une ligne du jeu, une table twad_key_deletes. Exemple : la table des unités de bataille du jeu est le fichier `db/land_units_tables/data__`. Selon le manuel de RPFM, `@mon_mod` passe devant, `zmon_mod` derrière, et un fragment nommé `data__` la remplace entière : c'est un « datacore », que les diagnostics signalent (« Leaving them named data__ will overwrite the base game files », prévient Casualfield). ### Quatre règles qui évitent les pires surprises - **Des noms et des clés à vous** : vos lignes s'ajoutent sans rien remplacer, et les autres campagnes comme les autres mods restent intacts. - **Ne redéfinissez pas un texte du jeu.** Le jeu charge les `.loc` d'un mod quelle que soit la langue du joueur : une clé du jeu reprise remplace le texte officiel dans toutes les langues. N'ajoutez que des clés neuves. Pour une seconde langue, un second pack : il ne contient qu'un `.loc` qui reprend vos clés, sous un nom qui commence par `!` pour passer devant le vôtre (wiki, page *Submodding*). - **Pour retirer une ligne du jeu, ne recopiez pas sa table** (un datacore) : un fragment ne retire rien aux autres. Depuis le patch 6.3, Warhammer III lit une table `twad_key_deletes` (colonnes `table_name` et `key`) qui retire les lignes nommées au lancement. Dans RPFM : créez une fois `twad_key_deletes_tables` dans votre pack (Create DB), ouvrez la table du jeu, sélectionnez les lignes, clic droit → **Add Selection to Key Deletes** → votre table. Attention : retirer une ligne encore citée par une autre table fait planter le jeu, et les diagnostics ne le voient pas encore. Deux tables seulement ont en plus une case `mod_disabled` (`character_skill_node_set_items`, `faction_agent_permitted_subtypes`), que le schéma de CA présente comme le moyen donné aux moddeurs, faute de pouvoir retirer une ligne. - **Dans le dossier `data`, un pack passe devant les fichiers en vrac** (constaté chez nous) : un fichier régénéré (un startpos, par exemple) ne compte qu'une fois remis dans le pack. *Schéma : Vos textes, dans toutes les langues.* Dans le schéma : Vos textes, dans toutes les langues · Le jeu charge vos .loc quelle que soit la langue du joueur. · Une clé neuve · `land_units_onscreen_name_atlas_chevaliers` · votre texte, dans toutes les langues · Une clé du jeu reprise · `factions_screen_name_wh_main_brt_bordeleaux` · remplace le texte officiel, dans toutes les langues · Pour une seconde langue : un second pack · dans text/db/, lus par ordre de nom : `!atlas_de.loc` · exemple : le pack de traduction, vos clés traduites ; trié avant, il gagne · `atlas.loc` · votre mod Un .loc de mod vaut pour toutes les langues : n'y mettez que des clés neuves. Pour une seconde langue, un second pack reprend vos clés dans un .loc dont le nom commence par ! (wiki, page Submodding). ## Votre premier mod, en dix minutes Avant les trois procédures, un essai court qui vérifie aussi votre installation : rendre une unité du jeu plus chère en bataille personnalisée. Le tutoriel *RPFM For Dummies* du wiki commence de même, par une modification de table trouvée avec la recherche globale. *Schéma : Un premier mod en dix minutes.* Dans le schéma : Un premier mod en dix minutes · MyMod → New MyMod · Warhammer 3 ; RPFM crée le pack, puis l'ouvre. · `moi_premier_mod.pack` · View → Toggle Global Search Window · Ctrl+Shift+F ; Game Files, DB, puis la clé : `wh_dlc07_brt_cav_knights_errant_0` · `main_units_tables` · la table du jeu, en lecture seule · Copy… → Copy · un clic sur le numéro de la ligne, puis clic droit · Create… → Create DB · clic droit sur votre pack : table main_units_tables, nom · @moi_main_units · les deux fichiers, lus par ordre de nom : `@moi_main_units` · le vôtre, trié avant : il gagne · `data__` · celui du jeu · Paste as New Row · Ctrl+Shift+V · même clé : vous modifiez l'unité du jeu · `multiplayer_cost` · `700` · `999` · son prix en bataille personnalisée ; 700 chez CA · Panneau Diagnostics → Check PackFile · aucune ligne Error · Ctrl+S, puis clic droit sur la racine → Install · cochez le mod dans le lanceur · En bataille personnalisée, les Chevaliers errants coûtent 999. Sept gestes, de la table du jeu à l'essai en jeu : votre fichier @moi_main_units trie avant celui du jeu (data__), sa ligne gagne donc, et les Chevaliers errants passent de 700 à 999 en bataille personnalisée. Pour ajouter une unité au lieu de la modifier, on change la clé : c'est la procédure 1. 1. **MyMod → New MyMod** : jeu Warhammer 3, nom `moi_premier_mod`. 2. **View → Toggle Global Search Window** (Ctrl+Shift+F) : source *Game Files*, type *DB* ; cherchez `wh_dlc07_brt_cav_knights_errant_0`, puis cliquez le résultat de `main_units_tables` : la table du jeu s'ouvre à la bonne ligne, en lecture seule. 3. Cliquez le numéro de la ligne, puis clic droit → **Copy… → Copy**. 4. Clic droit sur votre pack → **Create… → Create DB** : table `main_units_tables`, nom `@moi_main_units`. Le `@` fait trier votre fichier avant celui du jeu (`data__`) : c'est donc le vôtre qui gagne. 5. Clic droit dans la table vide → **Paste as New Row** (Ctrl+Shift+V). Gardez la clé : ici, on **modifie** l'unité du jeu. Passez `multiplayer_cost` (son prix en bataille personnalisée ; 700 chez CA) à 999. 6. Panneau Diagnostics → **Check PackFile** : aucune ligne *Error*. 7. Ctrl+S, puis clic droit sur la racine du pack → **Install** ; cochez le mod dans le lanceur. En bataille personnalisée, les Chevaliers errants de Bretonnie coûtent 999. Pour **ajouter** une unité au lieu de la modifier, on change la clé : c'est la procédure 1. ## Procédure 1 : ajouter une unité La voie sûre : copier une unité du jeu qui ressemble à la vôtre, puis changer ce qui doit changer. Exemple suivi : les Chevaliers errants de Bretonnie, `wh_dlc07_brt_cav_knights_errant_0`. ### Avant de commencer : l'unité modèle - Une unité modèle **de même squelette et de mêmes animations** que la vôtre : sinon, le rendu est déformé en jeu. - Un **préfixe de clé** à vous, pour ne jamais entrer en concurrence avec le jeu ou un autre mod. La figure suivante montre les tables d'une unité et les colonnes qui les relient. *Schéma : Les tables d'une unité et leurs liens.* Dans le schéma : Une unité · `main_units` · clé : unit · `land_unit → land_units` · `coûts, caste, ui_unit_group_land` · minimum · `land_units` · clé : key (la même que unit chez CA) · caractéristiques, armes · `man_entity → battle_entities` · `primary_melee_weapon → melee_weapons` · minimum · `unit_variants` · clé : faction + unit · `unit → land_units` · `variant → variants` · `unit_card → ui/units/icons` · minimum · `ui/units/icons/.png` · une image PNG de 60 × 130 · minimum · `variants` · clé : variant_name · seulement pour un modèle neuf · `→ .variantmeshdefinition` · facultatif · `unit_description_short_texts` · `· unit_description_historical_texts` · un texte propre à l'unité · facultatif · `units_to_groupings_military_permissions` · clés : unit, military_group · `military_group = factions.military_group` · `(wh_main_group_bretonnia)` · campagne · `building_units_allowed` · clé : key (un nombre unique) · `building → building_levels` · écuries 2 à 5 : une ligne chacune · campagne · `units_custom_battle_permissions` · clé : unit + faction + general_unit · la bataille personnalisée · `general_unit = 0` · minimum · `text/db/.loc` · `land_units_onscreen_name_` · minimum Les tables d'une unité, en arbre : chaque fiche donne sa clé et ses liens. Minimum : ce qu'il faut pour la bataille personnalisée ; campagne : en plus, pour la recruter en campagne ; facultatif : selon l'unité. La carte d'unité est une image (PNG de 60 × 130), pas une table. ### Les étapes de l'unité 1. **Global Search** sur la clé du modèle : elle figure dans 24 tables du kit ; le tableau ci-dessous donne celles qu'il faut. 2. Pour chacune : **Create DB** (un fichier à votre préfixe), **Paste as New Row**, puis changez ce qui fait l'unité et gardez le reste (voir « Ce qui change, ce qui reste »). Comme CA, donnez la même clé à `main_units.unit` et à `land_units.key`. 3. Réglez caractéristiques, coûts, apparence et carte, puis le recrutement, la bataille personnalisée et les textes. 4. Contrôle : clic droit sur votre clé → **Find References**. Le manuel de RPFM conseille ce contrôle après l'ajout d'une unité : il montre si elle est reliée partout où il faut (coûts, recrutement, factions). 5. **Diagnostics**, **Install**, essai en bataille personnalisée. | Table | À mettre | Clé | Liens | |---|---|---|---| | `main_units` | la copie ; coûts, `caste`, `ui_unit_group_land` | `unit` | `land_unit` → `land_units.key` | | `land_units` | la copie ; caractéristiques, armes | `key` | `man_entity` → `battle_entities` ; `primary_melee_weapon` → `melee_weapons` ; `short_description_text` → `unit_description_short_texts` ; `historical_description_text` → `unit_description_historical_texts` | | `unit_variants` | `name` = votre clé (comme CA), `faction` vide (= toutes les factions), `variant`, `unit_card` | `faction` + `unit` | `unit` → `land_units.key` ; `variant` → `variants.variant_name` ; la carte : `ui/units/icons/.png` | | `variants` | seulement pour un modèle neuf : `variant_filename` | `variant_name` | → `variantmeshes/variantmeshdefinitions/.variantmeshdefinition` | | `units_to_groupings_military_permissions` | l'unité et le groupe militaire | les deux colonnes | `military_group` = `factions.military_group` (par exemple `wh_main_group_bretonnia`) | | `building_units_allowed` | `building`, `unit`, `key` (un nombre unique), `faction` vide | `key` | `building` → `building_levels.level_name` ; `unit` → `main_units` | | `units_custom_battle_permissions` | la faction de bataille (chez CA : `wh_main_brt_bretonnia`), `general_unit` = 0 | `unit` + `faction` + `general_unit` | → `main_units`, `factions` | | `unit_description_short_texts`, `unit_description_historical_texts` | seulement pour un texte propre à l'unité | `key` | citées par `land_units` | *Schéma : Copier une unité : ce qui change, ce qui reste.* Dans le schéma : Copier une unité de CA · clé de CA · `wh_dlc07_brt_cav_knights_errant_0` · votre clé · `atlas_chevaliers` · En vert, ce qui change ; « gardé », la valeur de CA. · Vos fichiers : `db/
_tables/atlas_…` · sans @ : vous ajoutez · `main_units` · `unit` · clé de CA · `→` · `atlas_chevaliers` · `land_unit` · clé de CA · `→` · `atlas_chevaliers` · `caste` · `melee_cavalry` · gardé · `land_units` · `key` · clé de CA · `→` · `atlas_chevaliers` · `melee_attack` · `28` · gardé · `unit_variants` · `name` · clé de CA · `→` · `atlas_chevaliers` · `faction` · `(vide)` · gardé · `unit` · clé de CA · `→` · `atlas_chevaliers` · `variant` · `wh_dlc07_brt_knights_errant` · gardé · `unit_card` · `wh_dlc07_brt_knights_errant` · gardé · name : hors clé ; CA y met la clé de l'unité, et unit_variants_colours le cite. · `units_to_groupings_military_permissions` · `unit` · clé de CA · `→` · `atlas_chevaliers` · `military_group` · `wh_main_group_bretonnia` · gardé · `building_units_allowed` · `key` · `→` · `4 nombres neufs` · `unit` · clé de CA · `→` · `atlas_chevaliers` · `building` · `wh_main_brt_stables_2 … _5` · gardé · chez CA : 60317, 60343, 63497, 63640, une ligne par écurie ; et deux ports de Copher. · les nombres : clic droit → Generate Ids. · `units_custom_battle_permissions` · `unit` · clé de CA · `→` · `atlas_chevaliers` · `faction` · `wh_main_brt_bretonnia` · gardé · `general_unit` · `0` · gardé · `text/db/atlas.loc` · un fichier à vous · `key` · `land_units_onscreen_name_atlas_chevaliers` · `text` · le nom affiché · Une clé de CA oubliée : votre ligne concurrence celle de CA. L'exemple du guide, rempli avec les lignes de CA des Chevaliers errants (Assembly Kit, patch 8.1) : votre clé partout où figure celle de CA (name de unit_variants compris) et des nombres neufs dans building_units_allowed, en vert ; le reste gardé pour un premier essai, en gris. Contrôle : clic droit sur votre clé → Find References. ### Ce qui change, ce qui reste - **À changer** : la nouvelle clé `atlas_chevaliers` partout où figure celle de CA (`main_units.unit`, `main_units.land_unit`, `land_units.key`, `unit_variants.unit` et `unit_variants.name`, les colonnes `unit` des permissions et des bâtiments), et un **nombre neuf** dans `building_units_allowed.key` (clic droit → **Generate Ids**, à partir d'un nombre de départ à vous, sous 2³¹). La clé de `unit_variants` porte sur deux colonnes (`faction` + `unit`) : c'est `unit` qui change ; `name` n'est pas dans la clé, mais CA y met la clé de l'unité et `unit_variants_colours` s'y réfère : changez-le aussi. - **À garder pour un premier essai** : `variant` et `unit_card` de CA (`wh_dlc07_brt_knights_errant` : même modèle, même carte), le groupe militaire (`wh_main_group_bretonnia`), la faction de bataille (`wh_main_brt_bretonnia`, avec `general_unit` = 0) et les quatre écuries (`wh_main_brt_stables_2` à `wh_main_brt_stables_5`). - **Une clé de CA oubliée** dans une de vos lignes : cette ligne concurrence celle de CA au lieu de s'ajouter. RPFM a aussi un **Unit Editor**, expérimental selon son manuel ; ce guide suit la voie des tables. ### Les tables facultatives de l'unité D'après le guide de Casualfield, selon ce que l'unité doit faire : - `land_units_to_unit_abilites_junctions`, pour ses capacités (la faute d'orthographe est de CA) ; - `unit_attributes_groups` et `unit_attributes_to_groups_junctions` ; - `unit_set_to_unit_junctions` ; - `ui_unit_bullet_point_unit_overrides` ; - `allied_recruitment_unit_permissions` ; - `armed_citizenry_unit_groups` et `building_level_armed_citizenry_junctions`, pour les garnisons ; - `cdir_military_generator_unit_qualities`, pour l'IA ; - `units_to_exclusive_faction_permissions` ; - `faction_rebellion_units_junctions`, pour les armées rebelles : le schéma de CA demande d'y reporter l'unité de `units_to_groupings_military_permissions`, Casualfield la dit facultative. ### Les textes de l'unité - `land_units_onscreen_name_` : le nom (Casualfield donne `unit_description_historical_texts_UNITKEY`, mais le schéma du kit range le nom dans `land_units.onscreen_name`) ; - `unit_description_short_texts_text_` et `unit_description_historical_texts_text_`, si l'unité a ses propres descriptions ; - `land_units_concealed_name_`, facultatif. ### Le minimum viable de l'unité - **En bataille personnalisée** : `main_units`, `land_units`, `unit_variants`, la carte (PNG de 60 × 130 selon le *Unit Card Guide* du wiki ; non entrelacé comme celles de CA, relevé au patch 8.1), `units_custom_battle_permissions` et le nom en `.loc`. - **En campagne**, en plus : `units_to_groupings_military_permissions` et `building_units_allowed`. ### Les pièges de l'unité - **Chaque niveau de bâtiment.** CA liste l'unité à chaque niveau qui la permet, pas seulement à celui qui la débloque : ses Chevaliers errants figurent sur les écuries de niveau 2, 3, 4 et 5. - **La colonne `enabled` de `building_units_allowed`** n'interdit le recrutement qu'à trois conditions réunies : la paire bâtiment-unité existe ailleurs, `faction` est remplie, la case est décochée. - **`units_custom_battle_permissions` agit aussi en campagne** (wiki, page *Units custom battle permissions tables*) : la carte d'un héros dans le panneau des bâtiments en vient, et l'aperçu des unités touchées par un effet en tient compte. - **Un champ obligatoire vide, un fichier nommé `data__`** : voir les diagnostics et les règles des packs. ### Ce que l'unité demande au startpos Rien, sauf pour exister dès le tour 0 (`start_pos_land_units`, `start_pos_settlement_garrisons`, réserves de mercenaires) ; même alors, un script dispense du startpos : `cm:create_force_with_general` pose une armée, `cm:add_unit_to_faction_mercenary_pool` garnit une réserve. ### Vérifier que l'unité marche 1. Diagnostics : ni référence invalide ni texte manquant. 2. Bataille personnalisée avec la faction de bataille choisie : l'unité est dans la liste, avec sa carte et son nom ; en bataille, le modèle est entier. 3. Campagne neuve : l'unité se recrute à chaque niveau de bâtiment listé. ## Procédure 2 : ajouter une faction > **Avant tout : quelle campagne ?** : Chaque campagne n'a qu'un fichier de départ, et un mod ne peut pas le compléter : il le remplace en entier. Deux mods qui touchent au startpos d'une même campagne ne se combinent donc pas (« there can be only one startpos », dit le [wiki du modding](https://tw-modding.com/wiki/Startpos)). **Empires Immortels ou Royaumes du Chaos : n'écrivez pas votre startpos.** La plupart des joueurs utilisent déjà celui de [MIXER – Mixu's Unlocker](https://steamcommunity.com/sharedfiles/filedetails/?id=2859968660), qui rend jouables toutes les factions de ces deux campagnes et n'admet aucun autre mod de startpos ; le wiki conseille de demander l'ajout de votre faction à Mixu, puis de faire le reste par script (par exemple avec [Campaign Custom Starts](https://chadvandy.github.io/tw_modding_resources/WH3/campaign/custom_starts.html)). Une campagne à vous, comme la nôtre : suivez cette procédure, en acceptant l'incompatibilité avec tout autre mod de startpos de cette campagne. Une faction tient en quelques tables, mais elle n'existe sur la carte que par le startpos. ### Avant de commencer : ce qu'il faut réunir Une campagne cible, une culture et une sous-culture existantes, les drapeaux, et le temps de générer un startpos. La figure montre les tables d'une faction, et le chemin des tables de départ jusqu'au startpos. *Schéma : Les tables d'une faction et leurs liens.* Dans le schéma : Une faction · `factions` · clé : key · `subculture → cultures_subcultures` · `name_group → names_groups` · `military_group → groupings_military` · `flags_path = ui\flags\` · `ui/flags//` · `mon_24.png · mon_64.png · mon_256.png…` · les drapeaux : des images à fournir · `faction_agent_permitted_subtypes` · clé : faction + agent + subtype · `subtype → agent_subtypes` · les seigneurs et héros permis · `text/db/.loc` · `factions_screen_name_` · `factions_screen_adjective_` · `factions_screen_name_when_rebels_` · `factions_attack_desc_` · `factions_defend_desc_` · `start_pos_factions` · clé : ID (un entier neuf) · `faction, campaign, playable, is_major` · `cai_personality_group` · obligatoire · `start_pos_regions` · clé : region + campaign · `owning_faction → start_pos_factions.ID` · `start_pos_characters` · clé : ID · `faction → start_pos_factions.ID` · `Type = general` · `ministerial_position = faction_leader` · `start_pos_land_units` · clé : id · `general → start_pos_characters.ID` · `unit_type → main_units` · Puis le startpos · `start_pos_*` · vos tables · le jeu génère · `startpos.esf` · dans le pack · Un seul startpos par campagne ; Empires Immortels et Royaumes du Chaos : Mixer. Une faction : sa ligne de factions, ses drapeaux, ses seigneurs permis, ses textes et ses tables start_pos_*. Le jeu en tire le startpos, un seul par campagne, que votre mod remplace en entier : pour les Empires Immortels et les Royaumes du Chaos, la communauté passe par Mixer. ### Les étapes de la faction 1. **`factions`** : copiez une faction voisine (`wh_main_brt_bordeleaux`) sous une clé neuve ; réglez `subculture`, `name_group`, `military_group`, `flags_path` = `ui\flags\` et les couleurs (ou **Tools → Faction Painter**). 2. **Les drapeaux** : un dossier `ui/flags//` comme ceux de CA : `mon_24.png`, `mon_64.png`, `mon_256.png` (24, 64 et 256 pixels), `mon_64_glow.png`, `mon_icon.png`, `mon_rotated.png`, `mon_banner.dds` (noms de fichiers de CA, « mon » compris, relevés au patch 8.1). Lesquels sont indispensables n'est pas confirmé : fournissez tout le jeu. 3. **`faction_agent_permitted_subtypes`** : les lignes du modèle, qui disent quels seigneurs et héros la faction peut avoir (Bordeleaux en a 12 : general, colonel, minister, champion, wizard). 4. **Les textes**, puis **les tables de départ** du tableau, dans le kit (Dave) ou dans le pack (RPFM), plus `start_pos_character_to_settlements` pour un chef en garnison et `start_pos_diplomacy`. 5. **Le startpos** régénéré (voir « Ce qui exige un nouveau startpos »), rangé dans `campaigns//startpos.esf` du pack ; puis **Diagnostics**, **Install** (sauf pour un pack ouvert depuis le dossier `data`, qu'Install refuse), campagne neuve. | Table | À mettre | Clé | Liens | |---|---|---|---| | `factions` | la faction | `key` | `subculture` → `cultures_subcultures` ; `name_group` → `names_groups` ; `military_group` → `groupings_military` | | `faction_agent_permitted_subtypes` | les seigneurs et héros permis | `faction` + `agent` + `subtype` | → `agent_subtypes` | | `start_pos_factions` | `ID` (un entier neuf), `faction`, `campaign`, `playable`, `is_major`, `cai_personality_group` | `ID` | → `factions`, `campaigns` | | `start_pos_regions` | `owning_faction` = cet `ID`, `faction_capital` | `region` + `campaign` | → `start_pos_factions.ID` | | `start_pos_characters` | le chef : `Type` = general, `subtype`, `ministerial_position` = faction_leader, `portrait_id`, `startx` et `starty`, `Name` et `Surname` | `ID` | `faction` → `start_pos_factions.ID` ; `Name` → `names.id` ; `portrait_id` → `campaign_character_art_sets` | | `start_pos_land_units` | l'armée : `unit_type`, `general`, `soldiers` | `id` | → `main_units` ; → `start_pos_characters.ID` | *Schéma : Les drapeaux d'une faction.* Dans le schéma : Les drapeaux d'une faction · `factions` · `flags_path` · `ui\flags\` · `ui/flags//` · `mon_24.png` · 24 px · `mon_64.png` · 64 px · `mon_256.png` · 256 px · Quatre autres fichiers : `mon_64_glow.png` · 100 × 100 · `mon_icon.png` · 256 × 256 · `mon_rotated.png` · 112 × 90 · `mon_banner.dds` · 256 × 256 (DXT5) · « mon » : le nom de fichier de CA ; noms et tailles relevés sur les fichiers du jeu (patch 8.1) · ? · Lesquels sont indispensables : non confirmé. · Fournissez tout le jeu. Le dossier ui/flags// d'une faction, comme ceux de CA : trois tailles (24, 64 et 256 pixels) et quatre autres fichiers, noms et tailles relevés sur les fichiers du jeu (patch 8.1), « mon » compris. Lesquels sont indispensables n'est pas confirmé : fournissez tout le jeu. ### Les textes de la faction `factions_screen_name_`, `factions_screen_adjective_`, `factions_screen_name_when_rebels_`, `factions_attack_desc_` et `factions_defend_desc_` ; le nom du chef vient de `names_name_`. ### Le minimum viable de la faction `factions`, les drapeaux, `faction_agent_permitted_subtypes`, les textes, `start_pos_factions`, une région ou un chef avec son armée, et le startpos régénéré. ### Les pièges de la faction - **Le groupe d'IA.** Chaque faction doit avoir un groupe d'IA (`cai_personality_group`) qui contient une personnalité, sinon le jeu plante. Chez nous : le groupe qu'a la faction dans les Empires Immortels, à défaut celui des factions mineures de sa culture. - **Les identifiants des tables de départ** : des entiers uniques, sous 2³¹ (la limite d'un entier signé de 32 bits), qu'aucune ligne de CA n'emploie déjà (les siens sont dispersés jusqu'à près de 2³¹, patch 8.1). - **Les clés changent d'un jeu à l'autre** (`wh_dlc05_brt_mini_bastonne` dans Warhammer I, `wh_main_brt_bastonne` dans Warhammer III) : en portant des données, appariez-les sur la culture et la fin de la clé ([le tutoriel du portage](https://bretonia.dev/blog/tutoriel-porter-une-carte-warhammer-1-dans-warhammer-3.html)). ### Ce que la faction demande au startpos Tout ce qui la fait exister : le wiki range parmi ce qui demande un startpos les factions jouables, comme celles qui apparaissent en cours de partie. Une fois la faction dans le startpos, le script prend le relais : `cm:transfer_region_to_faction(region, faction)`, `cm:create_force_with_general(...)`, ou le système [Campaign Custom Starts](https://chadvandy.github.io/tw_modding_resources/WH3/campaign/custom_starts.html) de CA (régions, armées, diplomatie, effets). ### Vérifier que la faction marche 1. Diagnostics propres ; `campaigns//startpos.esf` est bien dans le pack, daté de la génération. 2. Tables de départ passées par un pack de mod : `%APPDATA%\The Creative Assembly\Warhammer3\crash_report\bad_mods_report.txt` nomme l'enregistrement fautif, un à la fois. 3. Campagne neuve : la faction est sur la carte, dans sa région, avec son drapeau et son nom ; son chef mène son armée. 4. Jouable, elle se choisit à l'écran de sélection, une fois la procédure 3 faite pour son chef. ## Procédure 3 : ajouter un seigneur légendaire ou jouable Trois paliers : **A**, le seigneur existe dans la base de données ; **B**, un script le fait apparaître dans une faction existante ; **C**, il se choisit à l'écran « Nouvelle campagne », et ce palier seul demande un startpos. Prérequis : son unité de bataille (procédure 1), son modèle, son portrait. *Schéma : Un seigneur en trois paliers.* Dans le schéma : Un seigneur en trois paliers · Sans startpos · A · La base de données · `agent_subtypes` · `units_custom_battle_permissions` · et l'apparence, les compétences, les textes ; general_unit = 1 : pour la bataille personnalisée · Il se choisit en bataille personnalisée. · B · Un script · ? · `cm:spawn_character_to_pool` · pour une faction qui existe déjà · à tester : non éprouvé dans Warhammer III · Partie neuve : parmi les seigneurs à recruter. · Avec un startpos régénéré · C · L'écran « Nouvelle campagne » · `start_pos_characters` · `start_pos_starting_general_options` · `frontend_faction_leaders` · `startpos.esf` · et playable = 1 dans start_pos_factions · Sa fiche paraît à l'écran de sélection. Trois paliers : A, le seigneur existe dans la base ; B, un script le fait paraître dans une faction qui existe déjà (à tester) ; C, il se choisit à l'écran « Nouvelle campagne ». Seul le palier C demande un startpos régénéré. ### Palier A : le seigneur dans la base de données 1. **`agent_subtypes`** : copiez un seigneur voisin (`wh_dlc07_brt_alberic`) ; `auto_generate` décoché pour un personnage unique, `associated_unit_override` = son unité, `recruitment_category` = `legendary_lords`, `recruitable` = 1 et `cap` = `-1` (comme Alberic). Laissez `magic_lore` vide : rempli, avec `legendary_lords`, il peut masquer les autres seigneurs légendaires de la réserve de recrutement (wiki, page *Agent subtypes tables*). 2. **L'apparence** : `campaign_character_art_sets` → `campaign_character_arts` (un `id` unique) → `agent_uniforms` → `variants`. 3. **Le portrait** : Warhammer III le lit dans `ui/portraits/portholes/portrait_settings*.bin`, rangé par art set (pour Alberic, `portrait_settings__3.bin`, vignette de 300 × 164 : relevés sur les fichiers de CA, patch 8.1). Dans RPFM : **Create… → Create Portrait Settings**, puis son éditeur. Chez CA, `campaign_character_arts.portrait` reste vide. 4. **Les compétences** : `character_skill_node_sets` (colonne `agent_subtype_key`), `character_skill_node_set_items` (`set`, `item`), `character_skill_nodes` (`tier` = colonne de l'arbre, `indent` = ligne), `character_skills` puis `character_skill_level_to_effects_junctions`, `character_skill_node_links` pour les flèches. 5. **`faction_agent_permitted_subtypes`** (la faction, `general`, le sous-type) et **`names`** (de nouveaux `id` pour le prénom et le nom). Pour la bataille personnalisée : `units_custom_battle_permissions` avec `general_unit` = 1, `general_portrait` et `general_uniform`. *Schéma : Palier A : les tables d'un seigneur et leurs liens.* Dans le schéma : Palier A : la base de données · `agent_subtypes` · clé : key · `associated_unit_override → main_units` · `recruitment_category = legendary_lords` · auto_generate décoché : un personnage unique · `campaign_character_art_sets` · clé : art_set_id · `agent_subtype → agent_subtypes` · `campaign_character_arts` · clé : id · `uniform → agent_uniforms` · `agent_uniforms` · clé : uniform_name · `filename, battle_filename → variants` · `ui/portraits/portholes/portrait_settings*.bin` · les réglages des portraits, par art set · `character_skill_node_sets` · clé : key · `agent_subtype_key → agent_subtypes` · `character_skill_node_set_items` · clé : set + item · `item → character_skill_nodes` · `character_skill_nodes` · clé : key · tier : la colonne (sous 48) ; indent : la ligne · `character_skill_key → character_skills` · `character_skills` · ses effets : `character_skill_level_to_effects_junctions` · `faction_agent_permitted_subtypes` · clé : faction + agent + subtype · `agent = general` · la faction peut l'avoir · `names` · clé : id · de nouveaux id pour le prénom et le nom ; leurs textes : `names_name_` Palier A : les tables du seigneur en arbre, de son sous-type à son apparence, son portrait, son arbre de compétences, sa faction et son nom. | Table | À mettre | Clé | Liens | |---|---|---|---| | `agent_subtypes` | le sous-type | `key` | `associated_unit_override` → `main_units` | | `campaign_character_art_sets` | l'art set | `art_set_id` | `agent_subtype` → `agent_subtypes` | | `campaign_character_arts` | l'apparence, par niveau | `id` | `uniform` → `agent_uniforms` | | `agent_uniforms` | les modèles de la carte et de la bataille | `uniform_name` | `filename`, `battle_filename` → `variants` | | `character_skill_node_sets` | l'arbre de compétences | `key` | `agent_subtype_key` → `agent_subtypes` | | `character_skill_node_set_items` | les nœuds de l'arbre | `set` + `item` | → `character_skill_nodes` | | `character_skill_nodes` | la place d'une compétence | `key` | `character_skill_key` → `character_skills` | | `frontend_faction_leaders` | la fiche de l'écran de sélection | `key` (libre) | `agent_subtype_record`, `faction` | | `start_pos_starting_general_options` | le lien du personnage à sa fiche | `id` | `general` → `start_pos_characters.ID` | *Schéma : L'arbre de compétences : une grille.* Dans le schéma : L'arbre de compétences : une grille · `tier` · → la colonne · `0` · `1` · `2` · `3` · `4` · `indent` · la ligne ↓ · `0` · `1` · `2` · Ce nœud : `tier = 2, indent = 1` · les flèches : `character_skill_node_links` · l'arbre du seigneur : `character_skill_node_set_items` · tier : sous 48 (wiki) ; au-delà, le nœud ne marche pas Dans character_skill_nodes, tier donne la colonne d'un nœud et indent sa ligne (schéma de l'Assembly Kit) ; tier reste sous 48 (wiki). Les flèches viennent de character_skill_node_links. ### Les textes du seigneur - `agent_subtypes_onscreen_name_override_` : le libellé du type (« Legendary Lord » pour Alberic) ; le nom propre vient de `names_name_` ; - `agent_subtypes_description_text_override_` ; - `character_skills_localised_name_`, `character_skills_localised_description_` et `character_skill_node_sets_enc_title_` ; - `frontend_faction_leaders_frontend_description_` et `frontend_faction_leaders_localised_description_` ; selon CA, `localised_action_points` et `loading_screen_text` ne servent plus. ### Le minimum viable du seigneur `agent_subtypes`, l'unité de bataille, l'art set, les arts, l'uniforme et la variante, `faction_agent_permitted_subtypes`, `names`, les textes, et un appel de script. ### Palier B : le faire apparaître par script Sans startpos, un script peut ajouter le seigneur à une faction **qui existe déjà**. Ce squelette suit les signatures des scripts de CA, **à tester** : ``` -- squelette à tester : un seigneur dans la réserve d'une faction existante cm:add_first_tick_callback(function() if cm:is_new_game() then cm:spawn_character_to_pool("wh_main_brt_bordeleaux", "names_name_", "names_name_", "", "", 30, true, "general", "", true, "") end end) ``` *Schéma : Un appel, pièce par pièce : cm:spawn_character_to_pool.* Dans le schéma : Un appel, pièce par pièce · `cm:spawn_character_to_pool(` · `"wh_main_brt_bordeleaux",` · La faction (elle existe) · `"names_name_",` · Le prénom (names) · `"names_name_",` · Le nom (names) · `"",` · Le clan : vide · `"",` · L'autre nom : inutilisé, vide · `30,` · L'âge · `true,` · Masculin · `"general",` · Le type d'agent · `"",` · Votre sous-type · `true,` · Immortel · `""` · Son art set · `)` · ? · À tester : squelette non éprouvé dans Warhammer III. · cm:is_new_game() : l'appel n'a lieu qu'au début d'une partie neuve L'appel du palier B, argument par argument, dans l'ordre des scripts de CA : la faction, le prénom et le nom (des clés names_name_), le clan, l'autre nom, l'âge, masculin, le type, le sous-type, immortel, l'art set. À tester. - Ordre des paramètres de `cm:spawn_character_to_pool` : faction, prénom, nom, clan, autre nom, âge, masculin, type, sous-type, immortel, art set. Les noms s'écrivent `names_name_`. - `cm:is_new_game()` : l'appel n'a lieu qu'au début d'une partie neuve, pas à chaque chargement. Selon la documentation de CA, une partie est « neuve » si elle n'a été sauvegardée qu'une fois, pendant la génération du startpos : si un script a échoué pendant cette génération, une partie neuve peut passer pour une sauvegarde. - Avec une armée : `cm:create_force_with_general(faction, unités, région, x, y, "general", sous-type, prénom, clan, nom, autre nom, chef_de_faction, rappel)`, dont les unités sont, selon la documentation de CA, des clés de `land_units` (les mêmes que celles de `main_units` chez CA). - Le script va dans `script/campaign/mod/`, que le jeu charge tout seul (tw-modding, *Lua/First Script*), sous un nom de fichier unique et préfixé : deux fichiers au même chemin dans deux packs ne se chargent pas tous les deux. ### Palier C : le choisir à l'écran « Nouvelle campagne » 1. `start_pos_characters` : le personnage (voir la procédure 2). 2. `start_pos_starting_general_options` : `general` (le personnage) → `frontend_faction_leader` (sa fiche). Sans cette table, aucun seigneur n'est choisissable. 3. Une fiche `frontend_faction_leaders`, à la clé libre : `character_image` (portrait de 85 × 115, relevé sur ceux de CA au patch 8.1), `uniform` (scène `.csc`), `video`, `loading_screen_image`, `agent_subtype_record`, `faction`. 4. `start_pos_factions.playable` = 1, puis le startpos régénéré. *Schéma : Palier C : du personnage du startpos à sa fiche.* Dans le schéma : Palier C : l'écran de sélection · `start_pos_factions` · clé : ID · `playable = 1` · `start_pos_characters` · clé : ID · le personnage : voir la procédure 2 · `start_pos_starting_general_options` · clé : id · sans cette table, aucun seigneur n'est choisissable · `frontend_faction_leaders` · clé : key (libre) · `startpos_map = default` · `agent_subtype_record, faction` · `character_image (85 × 115)` · `loading_screen_image` · `override_force_location_x/y` · une fraction de la carte ; −1 = par défaut · `faction` · sa faction · `general` · le personnage · `frontend_faction_leader` · sa fiche · Puis un startpos régénéré : seul ce palier en exige un. Palier C : start_pos_starting_general_options relie le personnage du startpos à sa fiche frontend_faction_leaders (startpos_map = default), puis le startpos se régénère. ### Les pièges du seigneur - **Les tutoriels de Warhammer II.** « Custom Lords & Heroes », sur tw-modding, vise Warhammer II : vérifiez chaque table dans le schéma de Warhammer III, où le lien entre un nœud et son arbre passe par `character_skill_node_set_items`. - **La colonne `tier`** reste sous 48 (wiki, page des `character_skill_nodes`). - **`startpos_map`** : CA y met le plus souvent `default` ou la clé de la fiche elle-même ; pour une fiche neuve, laissez `default`. Chez nous, une clé neuve dans ce champ a fait planter le chargement. - **Un seigneur en garnison** : sans réglage, son pointeur reste dans le coin de l'onglet Carte de l'écran de sélection ; renseignez `override_force_location_x` et `override_force_location_y` de sa fiche (wiki, page *Startpos*). Ce sont des fractions : la position du personnage en hex, divisée par la largeur de la carte pour x et par sa hauteur pour y, d'après l'exemple du schéma de CA ; `-1` laisse la position par défaut (chez CA, Eltharion : 0,398 et 0,420). *Schéma : Le pointeur de l'écran de sélection.* Dans le schéma : Le pointeur de l'écran de sélection · la carte de campagne, en hex · `0` · ↔ largeur · ↕ hauteur · `x` · `y` · `override_force_location_x = x / largeur` · `override_force_location_y = y / hauteur` · chez CA, Eltharion : 0,398 et 0,420 · −1 : la position par défaut ; un seigneur en garnison, sans réglage, reste dans le coin de l'onglet Carte. override_force_location_x et _y placent le pointeur d'un seigneur sur la carte de l'écran de sélection : sa position en hex, divisée par la largeur de la carte pour x et par sa hauteur pour y ; −1 garde la position par défaut. ### Vérifier que le seigneur marche 1. Diagnostics : ni art set ni variante non déclarés, aucune référence invalide. 2. Palier A : en bataille personnalisée, il se choisit comme général de sa faction, avec son portrait et son uniforme. 3. Palier B : dans une partie neuve de la faction, il figure parmi les seigneurs à recruter, ou à la tête de son armée. Sinon, lisez le journal des scripts : un fichier `script/enable_console_logging` non vide dans un pack chargé fait écrire au jeu des `script_log_*.txt`. 4. Palier C : à l'écran « Nouvelle campagne », sa fiche paraît avec son portrait et sa description, son pointeur est à sa place sur l'onglet Carte, et la partie commence avec lui. ## Ce qui exige un nouveau startpos *Schéma : Startpos ou script ?.* Dans le schéma : Startpos ou script ? · Un seul startpos par campagne ; Empires Immortels et Royaumes du Chaos : Mixer. · Il faut le startpos · Factions jouables, ou qui apparaissent en cours de partie · Types d'agents d'une culture · Emplacements de monuments · Potentiel des factions · Non-agression et accès militaire · Un identifiant (CQI) fixe pour le chef : pour une bataille de quête · Noms proposés au recrutement · Script ou base · Régiments de renom · `cm:add_unit_to_faction_mercenary_pool` · Région, chef, armée, objets : Campaign Custom Starts · `cm:create_force_with_general` · `cm:transfer_region_to_faction` · Pointeur de l'écran de sélection · `override_force_location_x/y` · Arbre de technologies : nœuds à colonne faction, plus un script · Fonctions d'une faction, horde ou non (feature forest) · `cm:add_or_remove_faction_features` · En base seule : unités, sous-types, apparences, compétences, textes, la table factions. Le startpos enregistre le tour 0 : ce qu'il contient ne change que s'il est régénéré, et un mod le remplace en entier. D'après la page Startpos du wiki : à gauche, ce qui l'exige ; à droite, ce qu'un script ou la base font sans lui. Le startpos est la sauvegarde du tour 0 : ce qu'il enregistre ne change que si on le régénère. Le schéma de l'Assembly Kit marque d'un indicateur, `requires_startpos_reprocess`, les colonnes qui y entrent : lisez-le dans `TWaD_
.xml`. Au patch 8.1, 42 tables en portent un : - 25 des 29 tables `start_pos_*` : factions, personnages, traits, objets, unités, régions, colonies, garnisons, diplomatie, options de seigneur, technologies, conditions de victoire… ; - `campaigns`, `campaign_maps`, `campaign_map_playable_areas`, `campaign_map_regions`, `campaign_map_attritions`, `campaign_map_masks_to_excluded_regions`, `regions`, `region_to_province_junctions`, `climates` et `campaign_ground_types` ; - sept tables de mercenaires : `mercenary_pools`, `mercenary_unit_groups`, `mercenary_pool_modifiers`, `mercenary_pool_to_groups_junctions`, `mercenary_pool_type_enums`, `faction_to_mercenary_set_junctions` et `province_to_mercenary_set_junctions`. Unités, sous-types, apparences, compétences, textes et table `factions` se modifient en base de données seule. Trois voies produisent un startpos : *Build Startpos* de RPFM, l'action *Process start pos* de BOB, ou un `user.script.txt` écrit à la main. Chez nous, seule l'écriture à la main a marché : [le guide des outils](https://bretonia.dev/atelier/outils/). ### Build Startpos, dans RPFM Clic droit sur la racine du pack **→ Build Startpos** fait générer le startpos par le jeu lui-même (dans la palette, Ctrl+Shift+P : « Build Startpos »). La 5.0.6 n'a plus de menu *Special Stuff* : les chemins « Special Stuff → … » des anciens tutoriels et du wiki valent pour les versions 4. *Schéma : Build Startpos, pas à pas.* Dans le schéma : Build Startpos · Les tables de départ dans le pack · à créer, ou à importer de l'Assembly Kit par le panneau · Dependencies. · `start_pos_*` · `campaigns` · Le pack ouvert depuis le dossier data du jeu · Save Pack As… dans data, ou PackFile → Open From Data ; sinon RPFM refuse. · `\data\.pack` · Clic droit sur la racine → Build Startpos · choisir la campagne ; Process HLP and SPD data : pour une carte neuve seulement. · Avec cette case, durée très variable : RPFM annonce 10 à 30 minutes, tw-modding bien plus d'une heure pour une grande carte. · Bouton Build Startpos : le jeu se lance, génère, se referme · Steam ouvert ; Play dans le lanceur si besoin. · RPFM a d'abord écrit votre user.script.txt (l'ancien, gardé en .bak) ; la troisième ligne, seulement avec Process HLP and SPD data : `mod .pack;` · `process_campaign_startpos ;` · `process_campaign_ai_map_data;` · `quit_after_campaign_processing;` · Ne fermez pas RPFM ici. · Hit this when the game is closed · RPFM range startpos.esf (et les fichiers hlp et spd) dans le pack et remet votre user.script.txt. · `campaigns//startpos.esf` · Ctrl+S, puis une campagne neuve · le pack est déjà dans data. · Avant de publier : retirez du pack les tables start_pos_*. Build Startpos fait générer le startpos par le jeu lui-même, à partir des tables de départ du pack ouvert depuis data. Ne fermez pas RPFM avant le clic de l'étape 5 : il range startpos.esf dans le pack et remet votre user.script.txt, sans quoi le jeu se refermerait à chaque lancement. 1. Mettez dans le pack les tables `start_pos_*` et `campaigns` : créez-les, ou importez-les de l'Assembly Kit par le panneau Dependencies. La consigne affichée par RPFM réclame aussi `db/victory_objectives.txt`, mais pas pour Warhammer III (code de RPFM ; journal des changements, version 4.3.11). 2. Le pack ouvert doit être enregistré dans le dossier `data` du jeu (*Save Pack As…*, ou **PackFile → Open From Data**) : sinon RPFM refuse. 3. Clic droit sur la racine du pack → **Build Startpos** ; choisissez la campagne (la liste vient de votre table `campaigns`). Ne cochez *Process HLP and SPD data* (les données de carte de l'IA, `hlp_data.esf` et `spd_data.esf`) que pour une carte neuve. Durée très variable : 16 s chez nous (400 × 440 hex) ; le tutoriel de carte de campagne de tw-modding compte moins d'une minute pour `spd`, environ cinq minutes pour `hlp` sur une carte moyenne et bien plus d'une heure sur une grande ; RPFM annonce 10 à 30 minutes. 4. Cliquez **Build Startpos** : le jeu se lance (Steam ouvert ; cliquez *Play* dans le lanceur si besoin), génère, puis se referme tout seul. Ne fermez pas RPFM entre-temps. 5. Une fois le jeu refermé, cliquez **Hit this when the game is closed** : RPFM range `campaigns//startpos.esf` (et, si l'option était cochée, les fichiers hlp et spd) dans le pack, et remet votre `user.script.txt` comme avant. 6. Enregistrez le pack (Ctrl+S), puis lancez une campagne neuve. Une précision : on écrit les tables `start_pos_*` dans le kit (Dave) ou dans RPFM, mais le jeu ne lit pas les XML du kit ; pour la génération, elles doivent donc être dans un pack chargé (pour Build Startpos, le pack même qu'il génère). Une fois le startpos produit, retirez-les du pack publié : elles ne servent plus. Chez nous, le jeu valide à chaque lancement les tables `start_pos_*` d'un pack de mod, et `%APPDATA%\The Creative Assembly\Warhammer3\crash_report\bad_mods_report.txt` nomme alors l'enregistrement fautif. > **Chez nous, le script de génération s'écrit à la main** : RPFM écrit lui-même le `user.script.txt` de la génération, mais n'y met qu'une ligne `mod` : celle du pack ouvert. Notre génération lit deux packs (le mod et celui des tables de départ) : nous écrivons donc le script à la main, avec une ligne `mod` par pack, `process_campaign_startpos ;`, au besoin `process_campaign_ai_map_data;`, puis `quit_after_campaign_processing;`, et nous remettons le fichier comme avant ensuite. Une ligne `add_working_directory`, que nous avions essayée, faisait sortir le jeu en neuf secondes sans rien produire (RPFM 5.0.6 ne l'écrit que pour Attila et Thrones of Britannia). La recette complète, et ce qu'un startpos exige pour ne pas planter : [le guide des outils](https://bretonia.dev/atelier/outils/). ## RPFM pour une IA : le serveur MCP Depuis sa version 5, RPFM a un serveur, `rpfm_server.exe`. Il parle MCP (Model Context Protocol), la prise standard des assistants IA : une IA branchée dessus ouvre les packs, lit et écrit les tables, cherche partout et lance les diagnostics, dans sa propre session, séparée de la fenêtre de RPFM. 1. Si la fenêtre de RPFM est ouverte, son serveur tourne déjà : elle le lance elle-même. Sinon, lancez `rpfm_server.exe` sans argument (il n'a pas d'option `--help` : il démarre aussitôt). Il écoute sur `127.0.0.1:45127` et s'arrête quand plus aucune session n'est ouverte. 2. Branchez votre assistant sur `http://127.0.0.1:45127/mcp` (Streamable HTTP). Avec Claude Code : `claude mcp add --transport http rpfm http://127.0.0.1:45127/mcp`. Tout client MCP compatible Streamable HTTP convient. 3. Demandez-lui de lire d'abord la ressource « Initialization guide » du serveur : elle décrit l'ordre des appels (choisir le jeu, vérifier le schéma, ouvrir le pack). *Schéma : Une IA branchée sur RPFM.* Dans le schéma : Une IA branchée sur RPFM · Une session par connexion · l'IA ne voit pas vos packs ouverts. · La fenêtre de RPFM · vos packs ouverts · `rpfm_server` · `127.0.0.1:45127` · L'assistant · votre IA · `/ws` · `/mcp` · Streamable HTTP · Pour le startpos · Demander à l'humain avant de lancer le jeu. · `build_starpos` · « Success » = jeu lancé · attendre que le jeu se referme · `build_starpos_post` · range startpos.esf, remet user.script.txt · `save_packfile` · pour abandonner : build_starpos_cleanup La fenêtre de RPFM lance elle-même rpfm_server ; l'assistant s'y branche par /mcp et reçoit sa propre session : il ne voit pas les packs ouverts dans la fenêtre. Pour le startpos, build_starpos ne fait que lancer le jeu ; build_starpos_post range le fichier. ``` set_game_selected (warhammer_3, rebuild_dependencies: true) → is_schema_loaded (sinon update_schemas) → open_packfiles (rend le pack_key) → open_pack_info (l'arbre du pack) → decode_packed_file (ex. db/land_units_tables/) → fields_processed (la forme des lignes) → save_packed_file_from_view → diagnostics_check → save_packfile ``` - **Une session = un état** (jeu choisi, packs ouverts) : tout faire dans la même session, `set_game_selected` en tête. Chaque connexion a sa session : l'IA ne voit pas les packs ouverts dans votre fenêtre. Par prudence, n'éditez pas le même pack des deux côtés. - **Les lignes s'écrivent au format « traité »** : appelez `fields_processed` sur la définition avant de construire une ligne. Exemple : les colonnes `r`, `g`, `b` d'une région y deviennent une seule valeur `ColourRGB`, en fin de ligne ; sinon l'enregistrement refuse (« expected a row with 6 fields, but we got a row with 8 »). - Les arguments complexes (`Definition`, `GlobalSearch`, `NewFile`) se passent en **chaîne JSON**. Une table neuve : `new_packed_file` avec `{"DB": ["", "land_units_tables", ]}`. - Retirer une ligne du jeu : `add_keys_to_key_deletes` inscrit ses clés dans une table `twad_key_deletes` du pack (voir « Les règles des packs »). - **`build_starpos`** (c'est l'orthographe de l'outil ; arguments `pack_key`, `campaign_id`, `process_hlp_spd`) répond « Success » en zéro seconde : cela veut dire « jeu lancé », pas « startpos construit ». Attendez que le jeu se referme, puis appelez **`build_starpos_post`** avec les mêmes arguments : il range `campaigns//startpos.esf` (et les fichiers hlp et spd) dans le pack et remet votre `user.script.txt` ; enfin `save_packfile`. Pour abandonner : `build_starpos_cleanup`. Sans l'un des deux, `user.script.txt` garde `quit_after_campaign_processing;` et le jeu se refermera à chaque lancement. - Au 20 septembre 2026, le serveur de RPFM 5.0.6 exposait environ 150 outils, 11 invites et 11 ressources : packs, fichiers, tables, dépendances et schémas, recherche, diagnostics, optimiseur, traductions, startpos. - Si CAIME (Campaign AI Map Editor), l'éditeur du Campaign Map Toolkit, lit sa base par RPFM, il lui faut `rpfm_cli.exe`, celui d'une version 4 de RPFM (chez nous, la 4.2.7) : la version 5 ne le livre plus ([le guide CAIME](https://bretonia.dev/atelier/caime/)). ## Pour une IA qui lit cette page Pour une IA qui aide à modder Total War: Warhammer III avec RPFM, l'essentiel en faits vérifiables, relevés sur RPFM 5.0.6 et le patch 8.1 du jeu (septembre 2026), relus pour la mise à jour 9.0 : à revérifier après une mise à jour (schémas, cache des dépendances ; et, si l'Assembly Kit sert aussi, les lignes ajoutées à `raw_data\db`, que Steam réécrit). - RPFM 5.0.6 : menus PackFile, MyMod, View, Game Selected, Tools, About (plus de *Special Stuff*). PackFile → Settings ; About → Check Updates (bouton des schémas) ; Game Selected → Generate Dependencies Cache ; MyMod → New MyMod (crée `\warhammer_3\.pack`) ; Ctrl+Shift+F recherche globale ; panneau Diagnostics → Check PackFile. **Clic droit sur la racine du pack** : Install, Uninstall, Save Pack For Release…, Optimize PackFile, Build Startpos. Palette : Ctrl+Shift+P (actions), Ctrl+P (fichiers). - Fichier de table : `db/
_tables/_`, jamais `data__`, ni chiffre final ni espace. Ajouter : clé neuve. Modifier une ligne du jeu : même clé, fichier dont le nom trie avant `data__` (`@`, `!`). Retirer une ligne du jeu : `twad_key_deletes` (Warhammer III ≥ 6.3 ; outil MCP `add_keys_to_key_deletes`), jamais une table recopiée ; `mod_disabled` n'existe que dans deux tables. - Clé de texte : `
__` ; les `.loc` d'un mod valent pour toutes les langues ; jamais une clé du jeu. - Unité : même clé dans `main_units.unit` et `land_units.key` ; `building_units_allowed` à chaque niveau de bâtiment, `key` = entier unique (Generate Ids). - Faction : `start_pos_factions.ID` unique sous 2³¹, `cai_personality_group` requis ; un seul startpos par campagne ; Empires Immortels et Royaumes du Chaos : Mixer. - Seigneur choisissable : `start_pos_starting_general_options` + `frontend_faction_leaders` (`startpos_map` = `default`) + `playable` = 1 + startpos ; par script (à tester) : `cm:spawn_character_to_pool`, noms `names_name_`. - Startpos à régénérer : tables dont un champ porte `requires_startpos_reprocess` (lire `TWaD_
.xml`) ; le reste, en base seule. - MCP : `http://127.0.0.1:45127/mcp` (Streamable HTTP), une session par connexion, séparée de la fenêtre ; ressource « Initialization guide » d'abord ; `set_game_selected` (`warhammer_3`, `rebuild_dependencies: true`), `is_schema_loaded` (sinon `update_schemas`) ; lignes selon `fields_processed` ; arguments complexes en chaîne JSON ; `build_starpos` (« Success » = jeu lancé) → fermeture du jeu → `build_starpos_post` → `save_packfile` ; pour abandonner, `build_starpos_cleanup`. - Demandez à l'humain avant de lancer le jeu, de piloter l'écran ou de publier ; ne supprimez rien : rangez, seul l'humain supprime. - Ni rétro-ingénierie ni contournement d'un outil de CA : quand un outil bute, un témoin, puis la communauté (Discord de CAIME, tw-modding). ## Sources et liens - [Manuel de RPFM](https://frodo45127.github.io/rpfm/manual/), en particulier [Datacores](https://frodo45127.github.io/rpfm/manual/tutorials/datacores.html), [Optimising a mod](https://frodo45127.github.io/rpfm/manual/tutorials/optimising-a-mod.html) et [MCP](https://frodo45127.github.io/rpfm/manual/server/mcp.html) ; [code de RPFM à l'étiquette v5.0.6](https://github.com/Frodo45127/rpfm/tree/v5.0.6) (emplacement des menus, Build Startpos, serveur) ; [versions publiées](https://github.com/Frodo45127/rpfm/releases) ; RPFM 5.0.6 lui-même (libellés, journal des changements). - Wiki tw-modding : [RPFM For Dummies](https://tw-modding.com/wiki/Tutorial:RPFM_For_Dummies) (écrit pour RPFM 2.3.2, menus anciens), [RPFM Post-Setup for Beginners](https://tw-modding.com/wiki/Tutorial:RPFM_Post-Setup_for_Beginners), [Localisation](https://tw-modding.com/wiki/Localisation), [Submodding](https://tw-modding.com/wiki/Tutorial:Submodding), [Startpos](https://tw-modding.com/wiki/Startpos), [Lua/First Script](https://tw-modding.com/wiki/Lua/First_Script), [Example Scripts](https://tw-modding.com/wiki/Example_Scripts). - Startpos des Empires Immortels et des Royaumes du Chaos : [MIXER – Mixu's Unlocker](https://steamcommunity.com/sharedfiles/filedetails/?id=2859968660), de Mixu. - Unités : [Creating Custom Units for WH3](https://steamcommunity.com/sharedfiles/filedetails/?id=3335345328), de Casualfield (lien donné par [tw-modding](https://tw-modding.com/wiki/Tutorial:Custom_Units_for_WH3)), [Unit Card Guide](https://tw-modding.com/wiki/Tutorial:Unit_Card_Guide), [Building units allowed tables](https://tw-modding.com/wiki/Building_units_allowed_tables), [Units custom battle permissions tables](https://tw-modding.com/wiki/Units_custom_battle_permissions_tables). - Seigneurs : [Custom Lords & Heroes](https://tw-modding.com/wiki/Tutorial:Custom_Lords_%26_Heroes) (Warhammer II, par Nanu), [Agent subtypes tables](https://tw-modding.com/wiki/Agent_subtypes_tables), [Character skill nodes tables](https://tw-modding.com/wiki/Character_skill_nodes_tables). - Scripts, par Vandy : [Campaign Custom Starts](https://chadvandy.github.io/tw_modding_resources/WH3/campaign/custom_starts.html) et [campaign_manager](https://chadvandy.github.io/tw_modding_resources/WH3/campaign/campaign_manager.html). - Données du jeu relues sur le patch 8.1 : schéma de l'Assembly Kit (`TWaD_*.xml`, `TExc_LocalisableFields.xml`), lignes de CA prises pour modèles (Chevaliers errants, Alberic, Bordeleaux), `lib_campaign_manager.lua`. - Nos autres guides : [les outils du moddeur](https://bretonia.dev/atelier/outils/), [CAIME](https://bretonia.dev/atelier/caime/), [Terry](https://bretonia.dev/atelier/terry/), [BOB](https://bretonia.dev/atelier/bob/), [modder avec une IA](https://bretonia.dev/atelier/ia/) ; et [l'atelier des moddeurs](https://bretonia.dev/atelier/). ## Questions fréquentes ### Quelle version de RPFM utiliser pour Warhammer III ? La 5.0.6, dernière stable au 24 septembre 2026, dont ce guide suit les menus. Le manuel en ligne décrit cette même version, parfois avec d'autres libellés que la fenêtre : la palette (Ctrl+Shift+P) retrouve l'action par son nom. ### Mon mod fait planter le jeu au lancement : que vérifier ? Les diagnostics de RPFM (Check PackFile). Une référence invalide est l'une des premières causes de plantage au lancement, et un champ obligatoire vide peut faire planter le jeu, souvent sans message d'erreur. ### Faut-il un nouveau startpos pour ajouter une unité ? Non. Seules les armées et garnisons de départ et les réserves de mercenaires l'exigent, et un script peut s'en charger (`cm:create_force_with_general`, `cm:add_unit_to_faction_mercenary_pool`). ### Peut-on ajouter une faction sans toucher au startpos ? Non : tout ce qui la fait exister passe par le startpos, dont chaque campagne n'a qu'un exemplaire, qu'un mod remplace en entier. Votre mod sera donc incompatible avec tout autre mod de startpos de cette campagne. Pour les Empires Immortels et les Royaumes du Chaos, demandez plutôt l'ajout de votre faction à Mixer, le mod de startpos de la plupart des joueurs, puis faites le reste par script. ### Pourquoi mon unité n'apparaît-elle pas en bataille personnalisée ? Il lui faut `main_units`, `land_units`, `unit_variants`, sa carte (PNG de 60 × 130), son nom en `.loc` et une ligne `units_custom_battle_permissions` pour la faction de bataille, avec `general_unit` à 0. ### Comment rendre un seigneur choisissable à l'écran de nouvelle campagne ? Le personnage dans `start_pos_characters`, une ligne `start_pos_starting_general_options` qui le relie à une fiche `frontend_faction_leaders` (`startpos_map` à `default`), `start_pos_factions.playable` à 1, puis un startpos régénéré. ### Mes textes remplacent ceux du jeu dans toutes les langues : pourquoi ? Le jeu charge les `.loc` d'un mod quelle que soit la langue du joueur. N'ajoutez que des clés neuves, et faites un pack par langue. ### Comment brancher une IA sur RPFM ? Si la fenêtre de RPFM est ouverte, son serveur tourne déjà ; sinon, lancez `rpfm_server.exe` (RPFM 5). Ajoutez ensuite le serveur MCP `http://127.0.0.1:45127/mcp` à votre assistant ; avec Claude Code : `claude mcp add --transport http rpfm http://127.0.0.1:45127/mcp`. ### Mon mod n'apparaît pas dans le lanceur : pourquoi ? Vérifiez qu'il est installé dans le dossier `data` du jeu et qu'il est de type Mod : clic droit sur la racine du pack, Change PackFile Type, Mod. Dans le même sous-menu, la case Index Includes Timestamp doit être décochée : selon RPFM, un pack qui l'a cochée n'apparaît pas dans le lanceur officiel. ### Ma modification d'une unité du jeu ne change rien : pourquoi ? Votre fichier de table trie après celui du jeu (`data__`) : c'est donc la ligne du jeu qui gagne. Commencez le nom de votre fichier par `@` ou `!`, puis réinstallez le pack. ### Des tables sont signalées Outdated après une mise à jour du jeu : que faire ? Mettez à jour les schémas (About, Check Updates), puis le cache (Game Selected, Generate Dependencies Cache). Ensuite, clic droit sur chaque table signalée, Update Table, et relisez les colonnes neuves : RPFM y met des valeurs par défaut. ### Comment retirer une ligne du jeu ? Avec la table `twad_key_deletes` (Warhammer III, depuis le patch 6.3), jamais en recopiant la table du jeu : créez une fois `twad_key_deletes_tables` dans votre pack, sélectionnez les lignes dans la table du jeu, puis clic droit, Add Selection to Key Deletes. Ne retirez pas une ligne encore citée par une autre table : le jeu planterait. ### Le jeu se ferme dès son lancement : pourquoi ? Une ligne `quit_after_campaign_processing;` est restée dans `user.script.txt` (`%APPDATA%\The Creative Assembly\Warhammer3\scripts`) : une génération de startpos a été interrompue avant sa fin. Retirez la ligne ou remettez le fichier d'avant. Avec Build Startpos, cliquez toujours Hit this when the game is closed, qui le remet.