enefel 2.9.1 → 2.11.0

package/teams/convert-csv-to-career.ts

@@ -0,0 +1,1209 @@
+import { parse } from "csv-parse/sync";
+import fs from "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<string>([
+  "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: Record<string, string> = {
+  // 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",
+};
+interface CSVRow {
+  Team: string;
+  Quantity: string;
+  Position: string;
+  Keywords: string;
+  Cost: string;
+  Skills: string;
+  Primary: string;
+  Secondary: string;
+  MA: string;
+  ST: string;
+  AG: string;
+  PA: string;
+  AR: string;
+}
+
+const SKILL_NAME_MAP: Record<string, string> = {
+  "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: Record<string, string> = {
+  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: Record<string, string> = {
+  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: (string | [string, number])[]
+): (string | [string, number])[] {
+  const specials = ["big-guy", "star", "specialist"];
+  const present = new Set<string>();
+  skills.forEach((skill) => {
+    if (typeof skill === "string" && specials.includes(skill)) {
+      present.add(skill);
+    }
+  });
+
+  const orderedKeep: string[] = [];
+  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: (string | [string, number])[] = [];
+  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: string): number {
+  if (!stat || stat === "") return 0;
+  const match = stat.match(/^(\d+)/);
+  return match ? parseInt(match[1], 10) : 0;
+}
+
+function convertAGPAFrom2025To2020(value: number): number {
+  if (value <= 0) return 0;
+  return 7 - value;
+}
+
+function convertAVFrom2025To2020(value: number): number {
+  if (value <= 0) return 0;
+  return value - 1;
+}
+
+function parseCost(cost: string): number {
+  if (!cost || cost === "") return 0;
+  const match = cost.match(/^(\d+)/);
+  return match ? parseInt(match[1], 10) : 0;
+}
+
+function parseSkills(skillsStr: string): (string | [string, number])[] {
+  if (!skillsStr || skillsStr.trim() === "") return [];
+
+  const skills: (string | [string, number])[] = [];
+  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: string): string {
+  return str
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+}
+
+function generateCareerId(team: string, position: string): string {
+  const teamKebab = toKebabCase(team);
+  const positionKebab = toKebabCase(position);
+  return `${teamKebab}-${positionKebab}-2025`;
+}
+
+function generateRaceEnum(team: string): string {
+  const race = TEAM_TO_RACE_MAP[team] || toKebabCase(team) + "-career";
+  return race.toUpperCase().replace(/-/g, "_");
+}
+
+function getExistingAvatars(): Set<string> {
+  const careerFileContent = fs.readFileSync(CAREER_FILE_PATH, "utf-8");
+  const existingAvatars = new Set<string>();
+
+  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: string,
+  position: string,
+  team: string
+): string {
+  const keywordParts = keywords.split(",").map((k) => k.trim());
+  let avatar: string | null = 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: string): number {
+  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(): Set<string> {
+  const skillFileContent = fs.readFileSync(SKILL_FILE_PATH, "utf-8");
+  const existingSkills = new Set<string>();
+
+  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(): Set<string> {
+  const skillFileContent = fs.readFileSync(SKILL_FILE_PATH, "utf-8");
+  const commentedSkills = new Set<string>();
+
+  // 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: Record<string, string> = {};
+  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: string): string {
+  return skillValue
+    .split("-")
+    .map((word) => word.toUpperCase())
+    .join("_");
+}
+
+function skillValueToEnumKey(skillValue: string): string {
+  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: Set<string>): void {
+  const existingSkills = getExistingSkills();
+  const missingSkills = new Set<string>();
+
+  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.readFileSync(CSV_PATH, "utf-8");
+  const rows = parse(csvContent, {
+    columns: true,
+    skip_empty_lines: true,
+  }) as CSVRow[];
+
+  const races = new Set<string>();
+  const careerIds: string[] = [];
+  const careers: Array<{
+    id: string;
+    team: string;
+    position: string;
+    data: any;
+    isBigGuy: boolean;
+  }> = [];
+  const usedSkills = new Set<string>();
+  const missingIcons = new Set<string>();
+
+  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" as const,
+      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<
+    string,
+    { index: number; cost: number }
+  >();
+  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<string, number[]>();
+  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: any) =>
+        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<number>();
+    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: string): string => {
+    const mapping: Record<string, string> = {
+      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: string | [string, number],
+    existingSkills: Set<string>,
+    commentedSkills: Set<string>
+  ): string => {
+    let skillValue: string;
+    let skillValueWithParam: string | null = 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: string,
+    existingAvatars: Set<string>
+  ): string => {
+    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: string | [string, number]) =>
+        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.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();