enefel 2.9.1 → 2.11.0

package/dist/teams/convert-csv-to-career.js

@@ -0,0 +1,1085 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sync_1 = require("csv-parse/sync");
+const fs_1 = __importDefault(require("fs"));
+const CSV_PATH = "./teams/players_clean.csv";
+const OUTPUT_PATH = "./career2025.ts";
+const SKILL_FILE_PATH = "./skill.ts";
+const CAREER_FILE_PATH = "./career.ts";
+// Icônes déjà présentes côté client (sans l'extension .gif)
+const KNOWN_ICONS = new Set([
+    "amazon-blitzer1",
+    "amazon-catcher1",
+    "amazon-linewomen1",
+    "amazon-thrower1",
+    "chaos-beastman1",
+    "chaos-dwarf-blocker1",
+    "chaos-dwarf-bull-centaur1",
+    "chaos-dwarf-hobgobelin1",
+    "chaos-minotaur1",
+    "chaos-warrior1",
+    "dark-elfe-blitzer1",
+    "dark-elfe-lineman1",
+    "dark-elfe-runner1",
+    "dark-elfe-witch1",
+    "dwarf-blitzer1",
+    "dwarf-deathroller1",
+    "dwarf-runner1",
+    "dwarf-troll-slayer1",
+    "dwarf1",
+    "elven-union-blitzer1",
+    "elven-union-catcher1",
+    "elven-union-lineman1",
+    "elven-union-thrower1",
+    "gobelin-lineman1",
+    "gobelin-looney1",
+    "gobelin-pogoer1",
+    "gobelin-troll1",
+    "halfling-treeman1",
+    "human-blitzer1",
+    "human-catcher1",
+    "human-ogre1",
+    "human-thrower1",
+    "human1",
+    "imperial-blitzer1",
+    "imperial-bodyguard1",
+    "imperial-lineman1",
+    "imperial-ogre1",
+    "imperial-thrower1",
+    "lizardmen-chameleon1",
+    "lizardmen-kroxigor1",
+    "lizardmen-saurus1",
+    "lizardmen-skink1",
+    "norse-berserker1",
+    "norse-catcher1",
+    "norse-lineman1",
+    "norse-thrower1",
+    "norse-ulfwereners1",
+    "norse-yhetee1",
+    "orc-black-orc1",
+    "orc-blitzer1",
+    "orc-thrower1",
+    "orc-troll1",
+    "orc1",
+    "rat-blitzer1",
+    "rat-ogre1",
+    "rat-runner1",
+    "rat-thrower1",
+    "rat1",
+    "silvan-catcher1",
+    "silvan-thrower1",
+    "silvan-wardancer1",
+    "silvan1",
+    "slann-blitzer1",
+    "slann-catcher1",
+    "slann-kroxigor1",
+    "slann-lineman1",
+    "snotling-lineman1",
+    "undead-ghoul1",
+    "undead-mummies1",
+    "undead-skeleton1",
+    "undead-wight1",
+    "undead-zombie1",
+    "vampire-thrall1",
+    "vampire-vampire1",
+]);
+// Adapter icônes générées -> icônes existantes
+const ICON_ADAPTER = {
+    // Amazon
+    "amazon-linewoman1": "amazon-linewomen1",
+    "amazon-blocker1": "amazon-blitzer1",
+    // Chaos Chosen
+    "chaos-chosen-beastman1": "chaos-beastman1",
+    "chaos-chosen-chosen1": "chaos-warrior1",
+    "chaos-chosen-minotaur1": "chaos-minotaur1",
+    // Chaos Dwarf
+    "chaos-dwarf-hobgoblin1": "chaos-dwarf-hobgobelin1",
+    "chaos-dwarf-stabba1": "chaos-dwarf-hobgobelin1",
+    "chaos-dwarf-flamer1": "chaos-dwarf-blocker1",
+    "chaos-dwarf-minotaur1": "chaos-minotaur1",
+    // Dark Elf
+    "dark-elf-lineman1": "dark-elfe-lineman1",
+    "dark-elf-runner1": "dark-elfe-runner1",
+    "dark-elf-assassin1": "dark-elfe-blitzer1",
+    "dark-elf-blitzer1": "dark-elfe-blitzer1",
+    "dark-elf-witch-elf1": "dark-elfe-witch1",
+    // Dwarf
+    "dwarf-lineman1": "dwarf1",
+    // Human
+    "human-lineman1": "human1",
+    // Orc
+    "orc-lineman1": "orc1",
+    "orc-big-un1": "orc-black-orc1",
+    // Goblin
+    "goblin-lineman1": "gobelin-lineman1",
+    "goblin-loony1": "gobelin-looney1",
+    "goblin-pogoer1": "gobelin-pogoer1",
+    "goblin-troll1": "gobelin-troll1",
+    "goblin-ooligan1": "gobelin-lineman1",
+    "goblin-doom-diver1": "gobelin-pogoer1",
+    // Halfling (fallback V6)
+    "halfling-lineman1": "halfling-lineman1",
+    "halfling-hefty1": "halfling-hefty1",
+    "halfling-catcher1": "halfling-catcher1",
+    // Imperial Nobility (fallback V6)
+    "imperial-nobility-blitzer1": "imperial-blitzer1",
+    "imperial-nobility-bodyguard1": "imperial-bodyguard1",
+    "imperial-nobility-ogre1": "imperial-ogre1",
+    "imperial-nobility-retainer1": "imperial-lineman1",
+    "imperial-nobility-thrower1": "imperial-thrower1",
+    // Khorne (fallback V6)
+    "khorne-marauder1": "khorne-lineman1",
+    "khorne-khorngor1": "khorne-khorngor1",
+    "khorne-bloodseeker1": "khorne-bloodseeker1",
+    "khorne-bloodspawn1": "khorne-bloodspawn1",
+    // Necromantic Horror (fallback V6 necromantic)
+    "necromantic-horror-zombie1": "necromantic-zombie1",
+    "necromantic-horror-ghoul1": "necromantic-ghoul1",
+    "necromantic-horror-wraith1": "necromantic-wraith1",
+    "necromantic-horror-werewolf1": "necromantic-werewolf1",
+    "necromantic-horror-flesh-golem1": "necromantic-golem1",
+    // Norse (fallback V6)
+    "norse-raider1": "norse-lineman1",
+    "norse-ulfwerner1": "norse-ulfwereners1",
+    "norse-valkyrie1": "norse-catcher1",
+    // Nurgle (fallback V6)
+    "nurgle-rotter1": "nurgle-rotter1",
+    "nurgle-pestigor1": "nurgle-pestigor1",
+    "nurgle-bloater1": "nurgle-bloater1",
+    "nurgle-rotspawn1": "nurgle-rotspawn1",
+    // Skaven (fallback V6)
+    "skaven-thrower1": "rat-thrower1",
+    "skaven-gutter1": "rat-runner1",
+    "skaven-blitzer1": "rat-blitzer1",
+    "skaven-rat-ogre1": "rat-ogre1",
+    // Snotling (fallback V6 gobelin/snotling)
+    "snotling-hoppa1": "snotling-runner1",
+    "snotling-runna1": "snotling-lineman1",
+    "snotling-pump-wagon1": "snotling-wagon1",
+    "snotling-troll1": "snotling-troll1",
+    // Vampire (fallback V6)
+    "vampire-blitzer1": "vampire-vampire1",
+    "vampire-runner1": "vampire-vampire1",
+    "vampire-thrower1": "vampire-vampire1",
+    "vampire-vargheist1": "vampire-vampire1",
+    // Shambling Undead
+    "shambling-undead-skeleton1": "undead-skeleton1",
+    "shambling-undead-zombie1": "undead-zombie1",
+    "shambling-undead-ghoul1": "undead-ghoul1",
+    "shambling-undead-wight1": "undead-wight1",
+    "shambling-undead-mummy1": "undead-mummies1",
+    // Skaven
+    "skaven-clanrat1": "rat1",
+    // Wood Elf
+    "wood-elf-lineman1": "silvan1",
+    "wood-elf-thrower1": "silvan-thrower1",
+    "wood-elf-catcher1": "silvan-catcher1",
+    "wood-elf-wardancer1": "silvan-wardancer1",
+    "wood-elf-treeman1": "halfling-treeman1",
+    // High Elf (fallback vers Elven Union)
+    "high-elf-lineman1": "elven-union-lineman1",
+    "high-elf-thrower1": "elven-union-thrower1",
+    "high-elf-catcher1": "elven-union-catcher1",
+    "high-elf-blitzer1": "elven-union-blitzer1",
+    // Tomb King (fallback vers Undead)
+    "tomb-king-lineman1": "undead-skeleton1",
+    "tomb-king-thrower1": "undead-ghoul1",
+    "tomb-king-blitzer1": "undead-wight1",
+    "tomb-king-tomb-guardian1": "undead-mummies1",
+};
+const SKILL_NAME_MAP = {
+    "Always Hungry": "always-hungry",
+    "Animal Savagery": "animal-salvagery",
+    Animosity: "animosity",
+    "Big Guy": "big-guy",
+    Block: "block",
+    "Bone Head": "bone-head",
+    Brawler: "brawler",
+    "Break Tackle": "break-tackle",
+    Catch: "catch",
+    Chainsaw: "chainsaw",
+    Claws: "claw",
+    "Cloud Burster": "cloud-burster",
+    Dauntless: "dauntless",
+    Decay: "decay",
+    Defensive: "defensive",
+    "Dirty Player": "dirty-player",
+    "Disturbing Presence": "disturbing-presence",
+    "Diving Catch": "diving-catch",
+    "Diving Tackle": "diving-tackle",
+    Dodge: "dodge",
+    Drunkard: "drunkard",
+    "Dump-Off": "dump-off",
+    Fend: "fend",
+    "Foul Appearance": "foul-appearance",
+    Frenzy: "frenzy",
+    Fumblerooski: "fumblerooskie",
+    "Give and Go": "running-pass", // Mapped to GIVE_AND_GO for DB compatibility
+    Grab: "grab",
+    "Hail Mary Pass": "hail-mary-pass",
+    Horns: "horns",
+    "Hypnotic Gaze": "hypnotic-gaze",
+    "Iron Hard Skin": "iron-hard-skin",
+    Juggernaut: "juggernaut",
+    "Jump Up": "jump-up",
+    Leap: "leap",
+    Loner: "loner",
+    "Mighty Blow": "mighty-blow",
+    "Nerves of Steel": "nerves-of-steel",
+    "No Ball": "no-hand",
+    "No Hands": "no-hand",
+    "On The Ball": "on-the-ball",
+    "On the Ball": "on-the-ball",
+    Pass: "pass",
+    "Pick-me-up": "pick-me-up",
+    "Plague Ridden": "plague-ridden",
+    "Pogo Stick": "pogo-stick",
+    Pogo: "pogo-stick",
+    "Prehensile Tail": "prehensile-tail",
+    "Projectile Vomit": "projectile-vomit",
+    Pro: "pro",
+    Punt: "punt",
+    "Really Stupid": "really-stupid",
+    Regeneration: "regeneration",
+    "Right Stuff": "right-stuff",
+    "Safe Pass": "safe-pass",
+    "Safe Pair of Hands": "safe-pair-of-hands",
+    "Secret Weapon": "secret-weapon",
+    Shadowing: "shadowing",
+    Sidestep: "sidestep",
+    Sprint: "sprint",
+    "Stand Firm": "stand-firm",
+    Star: "star",
+    "Strip Ball": "strip-ball",
+    "Strong Arm": "strong-arm",
+    Stunty: "stunty",
+    "Sure Feet": "sure-feet",
+    "Sure Hands": "sure-hands",
+    Stab: "stab",
+    Tackle: "tackle",
+    "Take Root": "take-root",
+    Taunt: "taunt",
+    Tentacles: "tentacles",
+    "Thick Skull": "thick-skull",
+    "Throw Team-mate": "throw-team-mate",
+    Titchy: "titchy",
+    "Unchannelled Fury": "unchannelled-fury",
+    Unsteady: "unsteady",
+    Wrestle: "wrestle",
+    "Eye Gouge": "eye-gouge",
+    "Hit and Run": "hit-and-run",
+    "Ball & Chain": "ball-and-chain",
+    Bombardier: "bombardier",
+    "Breathe Fire": "breathe-fire",
+    Insignificant: "insignificant",
+    "Kick Team-mate": "kick-team-mate",
+    "Bloodlust (2+)": "bloodlust",
+    "Bloodlust (3+)": "bloodlust",
+    "Hatred (Troll)": "hatred-troll",
+    "Timmm-ber!": "timmm-ber",
+    Swoop: "swoop",
+    "Steady Footing": "steady-footing",
+    "Arm Bar": "arm-bar",
+};
+const TEAM_TO_RACE_MAP = {
+    Amazon: "amazon-career",
+    "Black Orc": "black-orc-career",
+    Bretonnian: "bretonnian-career",
+    "Chaos Chosen": "chaos-career",
+    "Chaos Dwarf": "chaos-dwarf-career",
+    "Chaos Renegate": "chaos-renegate-career",
+    "Dark Elf": "dark-elfe-career",
+    Dwarf: "dwarf-career",
+    "Elven Union": "elven-union-career",
+    Goblin: "gobelin-career",
+    Halfling: "halfling-career",
+    "High Elf": "high-elf-career",
+    Human: "human-career",
+    "Imperial Nobility": "imperial-career",
+    Khorne: "khorne-career",
+    Lizardmen: "lizardmen-career",
+    "Necromantic Horror": "necromantic-career",
+    Norse: "norse-career",
+    Nurgle: "nurgle-career",
+    Ogre: "ogre-career",
+    "Old World Alliance": "old-world-alliance-career",
+    Orc: "orc-career",
+    "Shambling Undead": "undead-career",
+    Skaven: "rat-career",
+    Snotling: "snotling-career",
+    "Tomb King": "tomb-king-career",
+    "Underworld Denizens": "underworld-denizens-career",
+    Vampire: "vampire-career",
+    "Wood Elf": "silvan-career",
+};
+const KEYWORD_TO_AVATAR_MAP = {
+    Human: "human",
+    "Human, Lineman": "human",
+    "Human, Thrower": "human",
+    "Human, Thorwer": "human",
+    "Human, Skeleton": "undead",
+    "Human, Thrall": "human",
+    "Human Woman": "human-woman",
+    "Human, Blocker": "human",
+    "Human, Blitzer": "human",
+    "Human, Catcher": "human",
+    "Human, Runner": "human",
+    "Human, Special": "human",
+    Goblin: "gobelin",
+    "Goblin, Lineman": "gobelin",
+    "Goblin, Special": "gobelin",
+    Orc: "orc",
+    "Lineman, Orc": "orc",
+    "Orc, Thrower": "orc",
+    "Orc, Blitzer": "orc",
+    "Blocker, Orc": "black-orc",
+    Dwarf: "dwarf",
+    "Dwarf, Lineman": "dwarf",
+    "Dwarf, Runner": "dwarf",
+    "Dwarf, Blitzer": "dwarf",
+    "Dwarf, Special": "dwarf",
+    "Blocker, Dwarf": "dwarf",
+    Elf: "elf",
+    "Elf, Lineman": "elf",
+    "Elf, Thrower": "elf",
+    "Elf, Runner": "elf",
+    "Elf, Special": "elf",
+    "Blitzer, Elf": "elf",
+    "Catcher, Elf": "elf",
+    "Dark Elf": "dark_elf",
+    Halfling: "halfing",
+    "Halfling, Lineman": "halfing",
+    "Blocker, Halfling": "halfing",
+    "Catcher, Halfling": "halfing",
+    Skaven: "rat",
+    "Lineman, Skaven": "rat",
+    "Skaven, Thrower": "rat",
+    "Runner, Skaven": "rat",
+    "Blitzer, Skaven": "rat",
+    Lizardman: "lezard",
+    "Lineman, Lizardman": "lezard",
+    "Lizardman, Thrower": "lezard",
+    "Blocker, Lizardman": "lezard",
+    Beastman: "beastman",
+    "Beastman, Lineman": "beastman",
+    "Beastman, Runner": "beastman",
+    Undead: "undead",
+    "Undead, Zombie": "undead",
+    "Undead, Wraith": "undead",
+    "Undead, Werewolf": "werewolf",
+    "Undead, Vampire": "human",
+    Skeleton: "undead",
+    "Human, Lineman, Skeleton, Undead": "undead",
+    "Human, Skeleton, Thrower, Undead": "undead",
+    "Blitzer, Human, Skeleton, Undead": "undead",
+    "Big Guy, Blocker, Human, Undead": "mummie",
+    Zombie: "undead",
+    "Human, Lineman, Undead, Zombie": "undead",
+    Ghoul: "undead",
+    "Ghoul, Runner, Undead": "undead",
+    Wight: "undead",
+    Mummy: "mummie",
+    Troll: "troll",
+    "Big Guy, Troll": "troll",
+    Ogre: "ogre",
+    "Big Guy, Ogre": "ogre",
+    "Big Guy, Blocker, Ogre": "ogre",
+    "Big Guy, Ogre, Thrower": "ogre",
+    Minotaur: "minotaur",
+    "Big Guy, Minotaur": "minotaur",
+    "Rat Ogre": "rat_ogre",
+    "Big Guy, Skaven": "rat_ogre",
+    Treeman: "treeman",
+    "Big Guy, Treeman": "treeman",
+    Spawn: "rotspawn",
+    "Big Guy, Spawn": "rotspawn",
+    Yhetee: "yhetee",
+    "Big Guy, Yhetee": "yhetee",
+    Gnoblar: "gobelin",
+    "Gnoblar, Lineman": "gobelin",
+    Snotling: "gobelin",
+    "Lineman, Snotling": "gobelin",
+    "Snotling, Special": "gobelin",
+    "Runner, Snotling": "gobelin",
+    "Big Guy, Snotling, Special": "wagon",
+    Construct: "golem",
+    "Blocker, Construct, Undead": "golem",
+    Centaur: "centaur",
+    "Blitzer, Dwarf": "centaur",
+    Animal: "gobelin",
+    "Animal, Special": "gobelin",
+};
+function enforceSpecialSkills(skills) {
+    const specials = ["big-guy", "star", "specialist"];
+    const present = new Set();
+    skills.forEach((skill) => {
+        if (typeof skill === "string" && specials.includes(skill)) {
+            present.add(skill);
+        }
+    });
+    const orderedKeep = [];
+    if (present.has("big-guy"))
+        orderedKeep.push("big-guy");
+    else if (present.has("star"))
+        orderedKeep.push("star");
+    else if (present.has("specialist"))
+        orderedKeep.push("specialist");
+    const allowed = new Set(orderedKeep.slice(0, 1));
+    const filtered = [];
+    for (const skill of skills) {
+        if (typeof skill === "string" && specials.includes(skill)) {
+            if (allowed.has(skill)) {
+                filtered.push(skill);
+            }
+        }
+        else {
+            filtered.push(skill);
+        }
+    }
+    return filtered;
+}
+function parseStat(stat) {
+    if (!stat || stat === "")
+        return 0;
+    const match = stat.match(/^(\d+)/);
+    return match ? parseInt(match[1], 10) : 0;
+}
+function convertAGPAFrom2025To2020(value) {
+    if (value <= 0)
+        return 0;
+    return 7 - value;
+}
+function convertAVFrom2025To2020(value) {
+    if (value <= 0)
+        return 0;
+    return value - 1;
+}
+function parseCost(cost) {
+    if (!cost || cost === "")
+        return 0;
+    const match = cost.match(/^(\d+)/);
+    return match ? parseInt(match[1], 10) : 0;
+}
+function parseSkills(skillsStr) {
+    if (!skillsStr || skillsStr.trim() === "")
+        return [];
+    const skills = [];
+    const skillParts = skillsStr.split(",").map((s) => s.trim());
+    for (const skillPart of skillParts) {
+        const lonerMatch = skillPart.match(/^Loner \(([\d+]+)\)$/i);
+        if (lonerMatch) {
+            const value = parseInt(lonerMatch[1].replace("+", ""), 10);
+            skills.push(["loner", value]);
+            continue;
+        }
+        const mightyBlowMatch = skillPart.match(/^Mighty Blow \(\+?(\d+)\)$/i);
+        if (mightyBlowMatch) {
+            const value = parseInt(mightyBlowMatch[1], 10);
+            skills.push(["mighty-blow", value]);
+            continue;
+        }
+        const dirtyPlayerMatch = skillPart.match(/^Dirty Player \((\d+)\)$/i);
+        if (dirtyPlayerMatch) {
+            const value = parseInt(dirtyPlayerMatch[1], 10);
+            skills.push(["dirty-player", value]);
+            continue;
+        }
+        const bloodlustMatch = skillPart.match(/^Bloodlust \(([\d+]+)\)$/i);
+        if (bloodlustMatch) {
+            const value = parseInt(bloodlustMatch[1].replace("+", ""), 10);
+            skills.push(["bloodlust", value]);
+            continue;
+        }
+        const animosityMatch = skillPart.match(/^Animosity \(([^)]+)\)$/i);
+        if (animosityMatch) {
+            skills.push("animosity");
+            continue;
+        }
+        const hatredMatch = skillPart.match(/^Hatred \(([^)]+)\)$/i);
+        if (hatredMatch) {
+            skills.push("hatred-troll");
+            continue;
+        }
+        const normalizedSkill = skillPart
+            .replace(/^\(/, "")
+            .replace(/\)$/, "")
+            .trim();
+        const skillKey = Object.keys(SKILL_NAME_MAP).find((key) => key.toLowerCase() === normalizedSkill.toLowerCase());
+        if (skillKey) {
+            skills.push(SKILL_NAME_MAP[skillKey]);
+        }
+        else {
+            console.warn(`⚠️  Skill non mappé: "${skillPart}"`);
+        }
+    }
+    return skills;
+}
+function toKebabCase(str) {
+    return str
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+function generateCareerId(team, position) {
+    const teamKebab = toKebabCase(team);
+    const positionKebab = toKebabCase(position);
+    return `${teamKebab}-${positionKebab}-2025`;
+}
+function generateRaceEnum(team) {
+    const race = TEAM_TO_RACE_MAP[team] || toKebabCase(team) + "-career";
+    return race.toUpperCase().replace(/-/g, "_");
+}
+function getExistingAvatars() {
+    const careerFileContent = fs_1.default.readFileSync(CAREER_FILE_PATH, "utf-8");
+    const existingAvatars = new Set();
+    const enumMatch = careerFileContent.match(/enum AVATAR \{([^}]+)\}/s);
+    if (enumMatch) {
+        const enumContent = enumMatch[1];
+        const avatarMatches = enumContent.matchAll(/(\w+)\s*=\s*"([^"]+)"/g);
+        for (const match of avatarMatches) {
+            existingAvatars.add(match[2]);
+        }
+    }
+    const avatarMatches = careerFileContent.matchAll(/avatars:\s*\[([^\]]+)\]/g);
+    for (const match of avatarMatches) {
+        const avatarsStr = match[1];
+        const avatarMatches2 = avatarsStr.matchAll(/AVATAR\.(\w+)/g);
+        for (const avatarMatch of avatarMatches2) {
+            const avatarKey = avatarMatch[1];
+            const enumMatch2 = careerFileContent.match(new RegExp(`${avatarKey}\\s*=\\s*"([^"]+)"`));
+            if (enumMatch2) {
+                existingAvatars.add(enumMatch2[1]);
+            }
+        }
+    }
+    return existingAvatars;
+}
+function getAvatarFromKeywords(keywords, position, team) {
+    const keywordParts = keywords.split(",").map((k) => k.trim());
+    let avatar = null;
+    for (const keyword of keywordParts) {
+        const mappedAvatar = KEYWORD_TO_AVATAR_MAP[keyword];
+        if (mappedAvatar) {
+            avatar = mappedAvatar;
+            break;
+        }
+    }
+    if (!avatar) {
+        const posLower = position.toLowerCase();
+        const teamLower = team.toLowerCase();
+        if (posLower.includes("troll")) {
+            avatar = "troll";
+        }
+        else if (posLower.includes("ogre")) {
+            avatar = "ogre";
+        }
+        else if (posLower.includes("treeman")) {
+            avatar = "treeman";
+        }
+        else if (posLower.includes("yhetee")) {
+            avatar = "yhetee";
+        }
+        else if (posLower.includes("minotaur")) {
+            avatar = "minotaur";
+        }
+        else if (posLower.includes("rat ogre") || posLower.includes("ratogre")) {
+            avatar = "rat_ogre";
+        }
+        else if (posLower.includes("werewolf")) {
+            avatar = "werewolf";
+        }
+        else if (posLower.includes("vampire")) {
+            avatar = "vampire";
+        }
+        else if (posLower.includes("golem")) {
+            avatar = "golem";
+        }
+        else if (posLower.includes("centaur")) {
+            avatar = "centaur";
+        }
+        else if (posLower.includes("wagon")) {
+            avatar = "wagon";
+        }
+        else if (teamLower.includes("elf") || teamLower.includes("elven")) {
+            avatar = "elf";
+        }
+        else if (teamLower.includes("dwarf")) {
+            avatar = "dwarf";
+        }
+        else if (teamLower.includes("orc")) {
+            avatar = "orc";
+        }
+        else if (teamLower.includes("goblin") || teamLower.includes("snotling")) {
+            avatar = "gobelin";
+        }
+        else {
+            avatar = "human";
+        }
+    }
+    return avatar;
+}
+function determineRange(quantity) {
+    if (quantity.includes("0-16") || quantity.includes("0-12"))
+        return 0;
+    if (quantity.includes("0-6"))
+        return 5;
+    if (quantity.includes("0-4"))
+        return 4;
+    if (quantity.includes("0-3"))
+        return 3;
+    if (quantity.includes("0-2"))
+        return 2;
+    if (quantity.includes("0-1"))
+        return 6;
+    return 0;
+}
+function getExistingSkills() {
+    const skillFileContent = fs_1.default.readFileSync(SKILL_FILE_PATH, "utf-8");
+    const existingSkills = new Set();
+    const enumMatch = skillFileContent.match(/enum SKILL_NAMES \{([^}]+)\}/s);
+    if (enumMatch) {
+        const enumContent = enumMatch[1];
+        const skillMatches = enumContent.matchAll(/(\w+)\s*=\s*"([^"]+)"/g);
+        for (const match of skillMatches) {
+            existingSkills.add(match[2]);
+        }
+    }
+    // Alias pour la faute d'orthographe historique présente dans skill.ts
+    if (existingSkills.has("distrubing-presence")) {
+        existingSkills.add("disturbing-presence");
+    }
+    return existingSkills;
+}
+function getCommentedSkills() {
+    const skillFileContent = fs_1.default.readFileSync(SKILL_FILE_PATH, "utf-8");
+    const commentedSkills = new Set();
+    // Chercher les compétences commentées dans les tableaux (format: // SKILL_NAMES.XXX)
+    const commentedMatches = skillFileContent.matchAll(/\/\/\s*SKILL_NAMES\.(\w+)/g);
+    // Lire l'enum SKILL_NAMES pour mapper les clés aux valeurs
+    const enumMatch = skillFileContent.match(/enum SKILL_NAMES \{([^}]+)\}/s);
+    const enumToValueMap = {};
+    if (enumMatch) {
+        const enumContent = enumMatch[1];
+        const skillMatches = enumContent.matchAll(/(\w+)\s*=\s*"([^"]+)"/g);
+        for (const match of skillMatches) {
+            enumToValueMap[match[1]] = match[2];
+        }
+    }
+    // Convertir les enum keys commentées en skill values
+    for (const match of commentedMatches) {
+        const enumKey = match[1];
+        if (enumToValueMap[enumKey]) {
+            commentedSkills.add(enumToValueMap[enumKey]);
+        }
+    }
+    return commentedSkills;
+}
+function toEnumKey(skillValue) {
+    return skillValue
+        .split("-")
+        .map((word) => word.toUpperCase())
+        .join("_");
+}
+function skillValueToEnumKey(skillValue) {
+    if (skillValue === "animal-salvagery") {
+        return "SKILL_NAMES.ANIMAL_SAVAGERY";
+    }
+    if (skillValue === "no-hand") {
+        return "SKILL_NAMES.NO_HANDS";
+    }
+    if (skillValue === "disturbing-presence" ||
+        skillValue === "distrubing-presence") {
+        return "SKILL_NAMES.DISTURBING_PRESENCE";
+    }
+    if (skillValue === "running-pass") {
+        return "SKILL_NAMES.GIVE_AND_GO";
+    }
+    const enumKey = toEnumKey(skillValue);
+    const existingSkills = getExistingSkills();
+    if (existingSkills.has(skillValue)) {
+        return `SKILL_NAMES.${enumKey}`;
+    }
+    return `SKILL_NAMES.${enumKey}`;
+}
+function checkAndReportMissingSkills(usedSkills) {
+    const existingSkills = getExistingSkills();
+    const missingSkills = new Set();
+    for (const skill of usedSkills) {
+        if (!existingSkills.has(skill)) {
+            missingSkills.add(skill);
+        }
+    }
+    if (missingSkills.size > 0) {
+        console.log("\n⚠️  Compétences manquantes dans skill.ts:");
+        const sortedMissing = Array.from(missingSkills).sort();
+        for (const skill of sortedMissing) {
+            const enumKey = toEnumKey(skill);
+            console.log(`  // TODO: Ajouter ${enumKey} = "${skill}"`);
+            console.log(`  ${enumKey} = "${skill}",`);
+        }
+        console.log("");
+    }
+    else {
+        console.log("✅ Toutes les compétences existent déjà dans skill.ts");
+    }
+}
+function main() {
+    const csvContent = fs_1.default.readFileSync(CSV_PATH, "utf-8");
+    const rows = (0, sync_1.parse)(csvContent, {
+        columns: true,
+        skip_empty_lines: true,
+    });
+    const races = new Set();
+    const careerIds = [];
+    const careers = [];
+    const usedSkills = new Set();
+    const missingIcons = new Set();
+    for (const row of rows) {
+        if (!row.Team || !row.Position)
+            continue;
+        const careerId = generateCareerId(row.Team, row.Position);
+        const race = TEAM_TO_RACE_MAP[row.Team] || toKebabCase(row.Team) + "-career";
+        races.add(race);
+        const skills = parseSkills(row.Skills || "");
+        const keywordsLower = (row.Keywords || "").toLowerCase();
+        const isBigGuy = keywordsLower.includes("big guy");
+        if (isBigGuy && !skills.includes("big-guy")) {
+            skills.push("big-guy");
+        }
+        if (!row.Quantity.includes("0-16") && !skills.includes("specialist")) {
+            skills.push("specialist");
+        }
+        const avatar = getAvatarFromKeywords(row.Keywords || "", row.Position, row.Team);
+        for (const skill of skills) {
+            if (typeof skill === "string") {
+                usedSkills.add(skill);
+            }
+            else if (Array.isArray(skill) && skill.length > 0) {
+                usedSkills.add(skill[0]);
+            }
+        }
+        const rawIcon = `${toKebabCase(row.Team)}-${toKebabCase(row.Position)}1`;
+        const mappedIcon = ICON_ADAPTER[rawIcon] || rawIcon;
+        if (!KNOWN_ICONS.has(mappedIcon)) {
+            missingIcons.add(mappedIcon);
+        }
+        const rawAG = parseStat(row.AG);
+        const rawPA = parseStat(row.PA);
+        const rawAV = parseStat(row.AR);
+        const careerData = {
+            MA: parseStat(row.MA),
+            ST: parseStat(row.ST),
+            AG: convertAGPAFrom2025To2020(rawAG),
+            PA: convertAGPAFrom2025To2020(rawPA),
+            AV: convertAVFrom2025To2020(rawAV),
+            normal: row.Primary || "G",
+            double: row.Secondary || "",
+            normalCoach: "G",
+            icons: [mappedIcon],
+            skills,
+            avatar,
+            badge: race,
+            range: determineRange(row.Quantity),
+            cost: parseCost(row.Cost),
+            hasSprite: false,
+            version: "V2025",
+            keywords: row.Keywords || "",
+        };
+        careerIds.push(careerId);
+        careers.push({
+            id: careerId,
+            team: row.Team,
+            position: row.Position,
+            data: careerData,
+            isBigGuy,
+        });
+    }
+    // Ajout de la compétence star pour le joueur non-Big Guy le plus cher (>100k) par équipe
+    const mostExpensiveByTeam = new Map();
+    careers.forEach((career, index) => {
+        if (career.isBigGuy)
+            return;
+        if (typeof career.data.cost !== "number" || career.data.cost <= 100)
+            return;
+        const current = mostExpensiveByTeam.get(career.team);
+        if (!current || career.data.cost > current.cost) {
+            mostExpensiveByTeam.set(career.team, {
+                index,
+                cost: career.data.cost,
+            });
+        }
+    });
+    mostExpensiveByTeam.forEach(({ index }) => {
+        const target = careers[index];
+        if (target &&
+            !target.data.skills.includes("star") &&
+            !target.isBigGuy &&
+            typeof target.data.cost === "number" &&
+            target.data.cost > 100) {
+            target.data.skills.push("star");
+            usedSkills.add("star");
+        }
+    });
+    // Répartition des ranges par équipe
+    const teams = new Map();
+    careers.forEach((career, idx) => {
+        const list = teams.get(career.team) ?? [];
+        list.push(idx);
+        teams.set(career.team, list);
+    });
+    teams.forEach((indices) => {
+        const bigGuyIndices = indices.filter((i) => careers[i].isBigGuy);
+        const starIndices = indices.filter((i) => careers[i].data.skills.some((s) => Array.isArray(s) ? s[0] === "star" : s === "star"));
+        const otherIndices = indices
+            .filter((i) => !bigGuyIndices.includes(i) && !starIndices.includes(i))
+            .sort((a, b) => {
+            const costA = careers[a].data.cost ?? 0;
+            const costB = careers[b].data.cost ?? 0;
+            return costA - costB;
+        });
+        // Assign ranges: big guy -> 6, star -> 5, autres 0..5 en boucle en évitant les slots réservés
+        bigGuyIndices.forEach((i) => {
+            careers[i].data.range = 6;
+        });
+        starIndices.forEach((i) => {
+            careers[i].data.range = 5;
+        });
+        const reserved = new Set();
+        if (bigGuyIndices.length)
+            reserved.add(6);
+        if (starIndices.length)
+            reserved.add(5);
+        const baseRanges = [0, 1, 2, 3, 4, 5].filter((r) => !reserved.has(r));
+        if (baseRanges.length === 0) {
+            baseRanges.push(0); // fallback
+        }
+        otherIndices.forEach((i, idx) => {
+            const range = baseRanges[idx % baseRanges.length];
+            careers[i].data.range = range;
+        });
+    });
+    // Appliquer la limite de 2 compétences spéciales (big-guy, star, specialist) par priorité
+    careers.forEach((career) => {
+        career.data.skills = enforceSpecialSkills(career.data.skills);
+    });
+    const raceEnumEntries = Array.from(races)
+        .sort()
+        .map((race) => {
+        const enumName = race.toUpperCase().replace(/-/g, "_");
+        return `  ${enumName} = "${race}",`;
+    });
+    const careerIdEnumEntries = careerIds.sort().map((id) => {
+        const enumName = id.toUpperCase().replace(/-/g, "_");
+        return `  ${enumName} = "${id}",`;
+    });
+    const avatarValueToKey = (value) => {
+        const mapping = {
+            beastman: "BEASTMAN",
+            "black-orc": "BLACK_ORC",
+            bloater: "BLOATER",
+            bloodspawn: "BLOODSPAWN",
+            centaur: "CENTAUR",
+            "chaos-dwarf": "CHAOS_DWARF",
+            "chaos-warrior": "CHAOS_WARRIOR",
+            dark_elf: "DARK_ELF",
+            dwarf: "DWARF",
+            elf: "ELF",
+            gobelin: "GOBELIN",
+            golem: "GOLEM",
+            halfing: "HALFING",
+            "human-woman": "HUMAN_WOMAN",
+            human: "HUMAN",
+            lezard: "LIZARDMEN",
+            minotaur: "MINOTAUR",
+            mummie: "MUMMIE",
+            ogre: "OGRE",
+            orc: "ORC",
+            rat_ogre: "RAT_OGRE",
+            rat: "RAT",
+            rotspawn: "ROTSPAWN",
+            slann: "SLANN",
+            treeman: "TREEMAN",
+            troll: "TROLL",
+            undead: "UNDEAD",
+            vampire: "VAMPIRE",
+            wagon: "WAGON",
+            werewolf: "WEREWOLF",
+            yhetee: "YHETEE",
+        };
+        return mapping[value] || "HUMAN";
+    };
+    const existingSkills = getExistingSkills();
+    const existingAvatars = getExistingAvatars();
+    const commentedSkills = getCommentedSkills();
+    const formatSkill = (skill, existingSkills, commentedSkills) => {
+        let skillValue;
+        let skillValueWithParam = null;
+        if (typeof skill === "string") {
+            skillValue = skill;
+        }
+        else if (Array.isArray(skill) && skill.length === 2) {
+            skillValue = skill[0];
+            skillValueWithParam = `[${skillValueToEnumKey(skill[0])}, ${skill[1]}]`;
+        }
+        else {
+            return JSON.stringify(skill);
+        }
+        const enumKey = skillValueToEnumKey(skillValue);
+        const exists = existingSkills.has(skillValue);
+        const isCommented = commentedSkills.has(skillValue);
+        if (skillValueWithParam) {
+            if (exists && !isCommented) {
+                return skillValueWithParam;
+            }
+            else if (isCommented) {
+                return `// ${skillValueWithParam},`;
+            }
+            else {
+                return `// ${skillValueWithParam}, // TODO: Ajouter ${toEnumKey(skillValue)} = "${skillValue}" dans skill.ts`;
+            }
+        }
+        else {
+            if (exists && !isCommented) {
+                return enumKey;
+            }
+            else if (isCommented) {
+                return `// ${enumKey},`;
+            }
+            else {
+                return `// ${enumKey}, // TODO: Ajouter ${toEnumKey(skillValue)} = "${skillValue}" dans skill.ts`;
+            }
+        }
+    };
+    const formatAvatar = (avatar, existingAvatars) => {
+        const enumKey = avatarValueToKey(avatar);
+        const exists = existingAvatars.has(avatar);
+        if (exists) {
+            return `AVATAR.${enumKey}`;
+        }
+        else {
+            return `// AVATAR.${enumKey}, // TODO: Ajouter ${enumKey} dans career.ts`;
+        }
+    };
+    const careerEntries = careers.map((career) => {
+        const enumName = career.id.toUpperCase().replace(/-/g, "_");
+        const skillsFormatted = career.data.skills.map((skill) => formatSkill(skill, existingSkills, commentedSkills));
+        const skillsStr = skillsFormatted.join(",\n      ");
+        const avatarStr = formatAvatar(career.data.avatar, existingAvatars);
+        return `  [CAREER_ID.${enumName}]: {
+    MA: ${career.data.MA},
+    ST: ${career.data.ST},
+    AG: ${career.data.AG},
+    PA: ${career.data.PA},
+    AV: ${career.data.AV},
+    normal: "${career.data.normal}",
+    double: "${career.data.double}",
+    normalCoach: "${career.data.normalCoach}",
+    icons: ${JSON.stringify(career.data.icons)},
+    skills: [
+      ${skillsStr}
+    ],
+    avatars: [${avatarStr}],
+    badge: RACE.${career.data.badge.toUpperCase().replace(/-/g, "_")},
+    range: ${career.data.range},
+    cost: ${career.data.cost},
+    hasSprite: ${career.data.hasSprite},
+    version: CAREER_VERSION.V2025,
+  },`;
+    });
+    const output = `// MA: Movement Allowance
+// ST : Strength
+// AG: Agility
+// AV: Armour Value
+
+import { SKILL_NAMES } from "./skill";
+
+enum RACE {
+${raceEnumEntries.join("\n")}
+}
+
+enum AVATAR {
+  BEASTMAN = "beastman",
+  BLACK_ORC = "black-orc",
+  BLOATER = "bloater",
+  BLOODSPAWN = "bloodspawn",
+  CENTAUR = "centaur",
+  CHAOS_DWARF = "chaos-dwarf",
+  CHAOS_WARRIOR = "chaos-warrior",
+  DARK_ELF = "dark_elf",
+  DWARF = "dwarf",
+  ELF = "elf",
+  GOBELIN = "gobelin",
+  GOLEM = "golem",
+  HALFING = "halfing",
+  HUMAN_WOMAN = "human-woman",
+  HUMAN = "human",
+  LIZARDMEN = "lezard",
+  MINOTAUR = "minotaur",
+  MUMMIE = "mummie",
+  OGRE = "ogre",
+  ORC = "orc",
+  RAT_OGRE = "rat_ogre",
+  RAT = "rat",
+  ROTSPAWN = "rotspawn",
+  SLANN = "slann",
+  TREEMAN = "treeman",
+  TROLL = "troll",
+  UNDEAD = "undead",
+  VAMPIRE = "vampire",
+  WAGON = "wagon",
+  WEREWOLF = "werewolf",
+  YHETEE = "yhetee",
+}
+
+enum CAREER_ID {
+${careerIdEnumEntries.join("\n")}
+}
+
+enum CAREER_VERSION {
+  V6 = "v6",
+  V2020 = "v2020",
+  V2025 = "v2025",
+}
+
+export type Career = {
+  MA: number;
+  ST: number;
+  AG: number;
+  PA: number;
+  AV: number;
+  normal: string;
+  double: string;
+  normalCoach: string;
+  icons: string[];
+  skills: (SKILL_NAMES | [SKILL_NAMES, number])[];
+  avatars: AVATAR[];
+  badge: RACE;
+  range: number;
+  cost: number;
+  hasSprite?: boolean;
+  version: CAREER_VERSION;
+};
+
+const CAREER: Record<CAREER_ID, Career> = {
+${careerEntries.join("\n\n")}
+};
+
+const getCareers = (): Record<CAREER_ID, Career> => {
+  return CAREER;
+};
+
+export { AVATAR, CAREER_ID, CAREER_VERSION, getCareers, RACE };
+`;
+    fs_1.default.writeFileSync(OUTPUT_PATH, output);
+    console.log(`✅ Fichier généré: ${OUTPUT_PATH}`);
+    console.log(`📊 ${careers.length} carrières générées`);
+    console.log(`🏆 ${races.size} races trouvées`);
+    if (missingIcons.size > 0) {
+        console.warn("ICÔNES MANQUANTES (ajouter dans client/public/tile/player, sans .gif):", Array.from(missingIcons).sort());
+    }
+    checkAndReportMissingSkills(usedSkills);
+}
+main();