enefel 2.9.1 → 2.11.0

package/race.ts

@@ -1,8 +1,15 @@
 import alea from "seedrandom";
 import { AVATAR_LIST } from "./avatars";
 import { AVATAR_DEFAULT_LIST } from "./avatarsDefault";
+import { findSeasonAvatar, getSeasonAvatarPath } from "./avatarsSeason";
 import { BADGE_NAMES, hasBadge } from "./badge";
-import { AVATAR, CAREER_ID, getCareers, RACE } from "./career";
+import {
+  AVATAR,
+  CAREER_ID_ALL,
+  getAvailableCareers,
+  getCareers,
+  RACE,
+} from "./career";
 import { getRandomNumber } from "./random";
 import { isSpecialSkill, SKILL_NAMES } from "./skill";
 import { canBeSelectedByUser } from "./state";
@@ -91,19 +98,152 @@ const hasUnlockCareer = (user: User, careerId: string) => {
   if (!user.badges) {
     throw Error("no badges for player");
   }
-  const race = getRaceFromCareer(careerId as CAREER_ID);
+  const race = getRaceFromCareer(careerId as CAREER_ID_ALL);
 
-  return hasUnlockRace(user, race);
+  return hasUnlockRace(user, race as RACE);
 };
 
-const getCareerFromKey = (key: CAREER_ID) => {
+const getCareerFromKey = (key: CAREER_ID_ALL) => {
   const careers = getCareers();
   return careers[key];
 };
 
 const getCareerKeyFromPlayer = (player: Player) => {
   // Attention la career est le race_id dans la table player
-  return player.race_id as CAREER_ID;
+  return player.race_id as CAREER_ID_ALL;
+};
+
+/**
+ * Maps legacy (pre-2025) career IDs to their 2025 equivalents.
+ * Derived by inverting the ICON_ADAPTER from convert-csv-to-career.ts:
+ *   old icon name (strip "1") → new 2025 career ID
+ */
+const LEGACY_TO_2025_CAREER_ID: Record<string, string> = {
+  // Amazon
+  "amazon-linewomen": "amazon-linewoman-2025",
+  "amazon-blocker": "amazon-blocker-2025",
+  "amazon-blitzer": "amazon-blitzer-2025",
+  "amazon-catcher": "amazon-catcher-2025",
+  "amazon-thrower": "amazon-thrower-2025",
+  // Chaos Chosen
+  "chaos-beastman": "chaos-chosen-beastman-2025",
+  "chaos-warrior": "chaos-chosen-chosen-2025",
+  "chaos-minotaur": "chaos-chosen-minotaur-2025",
+  // Chaos Dwarf
+  "chaos-dwarf-blocker": "chaos-dwarf-blocker-2025",
+  "chaos-dwarf-bull-centaur": "chaos-dwarf-bull-centaur-2025",
+  "chaos-dwarf-hobgobelin": "chaos-dwarf-hobgoblin-2025",
+  // Dark Elf
+  "dark-elfe-blitzer": "dark-elf-blitzer-2025",
+  "dark-elfe-lineman": "dark-elf-lineman-2025",
+  "dark-elfe-runner": "dark-elf-runner-2025",
+  "dark-elfe-witch": "dark-elf-witch-elf-2025",
+  // Dwarf
+  "dwarf": "dwarf-lineman-2025",
+  "dwarf-blocker": "dwarf-lineman-2025",
+  "dwarf-blitzer": "dwarf-blitzer-2025",
+  "dwarf-deathroller": "dwarf-deathroller-2025",
+  "dwarf-runner": "dwarf-runner-2025",
+  "dwarf-troll-slayer": "dwarf-troll-slayer-2025",
+  // Elven Union
+  "elven-union-blitzer": "elven-union-blitzer-2025",
+  "elven-union-catcher": "elven-union-catcher-2025",
+  "elven-union-lineman": "elven-union-lineman-2025",
+  "elven-union-thrower": "elven-union-thrower-2025",
+  // Goblin
+  "gobelin-lineman": "goblin-lineman-2025",
+  "gobelin-looney": "goblin-loony-2025",
+  "gobelin-pogoer": "goblin-pogoer-2025",
+  "gobelin-troll": "goblin-troll-2025",
+  // Halfling
+  "halfling-lineman": "halfling-lineman-2025",
+  "halfling-hefty": "halfling-hefty-2025",
+  "halfling-catcher": "halfling-catcher-2025",
+  "halfling-treeman": "halfling-treeman-2025",
+  // Human
+  "human": "human-lineman-2025",
+  "human-lineman": "human-lineman-2025",
+  "human-blitzer": "human-blitzer-2025",
+  "human-catcher": "human-catcher-2025",
+  "human-ogre": "human-ogre-2025",
+  "human-thrower": "human-thrower-2025",
+  // Imperial Nobility
+  "imperial-lineman": "imperial-nobility-retainer-2025",
+  "imperial-blitzer": "imperial-nobility-blitzer-2025",
+  "imperial-bodyguard": "imperial-nobility-bodyguard-2025",
+  "imperial-ogre": "imperial-nobility-ogre-2025",
+  "imperial-thrower": "imperial-nobility-thrower-2025",
+  // Khorne
+  "khorne-lineman": "khorne-marauder-2025",
+  "khorne-khorngor": "khorne-khorngor-2025",
+  "khorne-bloodseeker": "khorne-bloodseeker-2025",
+  "khorne-bloodspawn": "khorne-bloodspawn-2025",
+  // Lizardmen
+  "lizardmen-chameleon": "lizardmen-chameleon-2025",
+  "lizardmen-kroxigor": "lizardmen-kroxigor-2025",
+  "lizardmen-saurus": "lizardmen-saurus-2025",
+  "lizardmen-skink": "lizardmen-skink-2025",
+  // Necromantic
+  "necromantic-zombie": "necromantic-horror-zombie-2025",
+  "necromantic-ghoul": "necromantic-horror-ghoul-2025",
+  "necromantic-wraith": "necromantic-horror-wraith-2025",
+  "necromantic-werewolf": "necromantic-horror-werewolf-2025",
+  "necromantic-golem": "necromantic-horror-flesh-golem-2025",
+  // Norse
+  "norse-lineman": "norse-raider-2025",
+  "norse-berserker": "norse-berserker-2025",
+  "norse-catcher": "norse-catcher-2025",
+  "norse-thrower": "norse-thrower-2025",
+  "norse-ulfwereners": "norse-ulfwerner-2025",
+  "norse-yhetee": "norse-yhetee-2025",
+  // Nurgle
+  "nurgle-rotter": "nurgle-rotter-2025",
+  "nurgle-pestigor": "nurgle-pestigor-2025",
+  "nurgle-bloater": "nurgle-bloater-2025",
+  "nurgle-rotspawn": "nurgle-rotspawn-2025",
+  // Orc
+  "orc": "orc-lineman-2025",
+  "orc-lineman": "orc-lineman-2025",
+  "orc-black-orc": "orc-big-un-2025",
+  "orc-blitzer": "orc-blitzer-2025",
+  "orc-thrower": "orc-thrower-2025",
+  "orc-troll": "orc-troll-2025",
+  // Skaven (anciens "rat")
+  "rat": "skaven-clanrat-2025",
+  "rat-lineman": "skaven-clanrat-2025",
+  "rat-runner": "skaven-gutter-2025",
+  "rat-blitzer": "skaven-blitzer-2025",
+  "rat-thrower": "skaven-thrower-2025",
+  "rat-ogre": "skaven-rat-ogre-2025",
+  // Shambling Undead (anciens "undead")
+  "undead-skeleton": "shambling-undead-skeleton-2025",
+  "undead-zombie": "shambling-undead-zombie-2025",
+  "undead-ghoul": "shambling-undead-ghoul-2025",
+  "undead-wight": "shambling-undead-wight-2025",
+  "undead-mummies": "shambling-undead-mummy-2025",
+  // Snotling
+  "snotling-lineman": "snotling-lineman-2025",
+  "snotling-runner": "snotling-runna-2025",
+  "snotling-wagon": "snotling-pump-wagon-2025",
+  "snotling-troll": "snotling-troll-2025",
+  // Vampire
+  "vampire-thrall": "vampire-thrall-2025",
+  "vampire-vampire": "vampire-blitzer-2025",
+  // Wood Elf (anciens "silvan")
+  "silvan": "wood-elf-lineman-2025",
+  "silvan-lineman": "wood-elf-lineman-2025",
+  "silvan-thrower": "wood-elf-thrower-2025",
+  "silvan-catcher": "wood-elf-catcher-2025",
+  "silvan-wardancer": "wood-elf-wardancer-2025",
+};
+
+/**
+ * Returns the 2025 career ID for a given career ID (legacy or already 2025).
+ * Returns undefined for careers without a 2025 equivalent (e.g. Slann).
+ */
+const getCareerId2025 = (careerId: string): string | undefined => {
+  if (careerId.endsWith("-2025")) return careerId;
+  return LEGACY_TO_2025_CAREER_ID[careerId];
 };
 
 const getCareerFromPlayer = (player: Player) => {
@@ -114,7 +254,7 @@ const getCareerFromPlayer = (player: Player) => {
 const getCareerFromIcon = (nameIcon: string) => {
   for (const [key, values] of Object.entries(getCareers())) {
     if (values.icons.includes(nameIcon)) {
-      return getCareerFromKey(key as CAREER_ID);
+      return getCareerFromKey(key as CAREER_ID_ALL);
     }
   }
   return null;
@@ -155,11 +295,26 @@ const getPlayerAvatar = (player: Player) => {
   if (!av) {
     return null;
   }
+  // Les avatars saisonniers (format "s17/1.png" ou trouvés dans la liste) gardent leur extension
+  // Normalise .jpeg → .png car les fichiers sont PNG (anciens enregistrements DB peuvent avoir .jpeg)
+  if (av.includes("/") || findSeasonAvatar(av)) {
+    return av.replace(".jpeg", ".png");
+  }
   return av.replace(".png", ".jpeg");
 };
 
 const getPlayerAvatarPath = (player: Player) => {
   if (player.avatar) {
+    // Nouveau format "s17/1.png"
+    if (player.avatar.includes("/")) {
+      const slashIdx = player.avatar.indexOf("/");
+      const season = parseInt(player.avatar.slice(1, slashIdx), 10);
+      return getSeasonAvatarPath(season);
+    }
+    const seasonAvatar = findSeasonAvatar(player.avatar);
+    if (seasonAvatar) {
+      return getSeasonAvatarPath(seasonAvatar.season);
+    }
     return "tile/shop/avatar";
   } else if (player.avatarDefault) {
     return "tile/shop/avatar-default";
@@ -167,9 +322,9 @@ const getPlayerAvatarPath = (player: Player) => {
   return null;
 };
 
-const getRaceFromCareer = (careerId: CAREER_ID) => {
+const getRaceFromCareer = (careerId: CAREER_ID_ALL): RACE | undefined => {
   const career = getCareerFromKey(careerId);
-  return career?.badge;
+  return career?.badge as RACE | undefined;
 };
 
 const getAvatarTypeFromPlayer = (player: Player, avatarFile: string) => {
@@ -199,6 +354,39 @@ const getAvatarTypeFromPlayer = (player: Player, avatarFile: string) => {
   return null;
 };
 
+/** Returns the correct base path for an avatar file based on which list it belongs to,
+ *  independent of the player's currently active avatar. */
+const getAvatarBasePathFromFile = (player: Player, avatarFile: string): string | null => {
+  const career = getCareerFromPlayer(player);
+  if (!avatarFile) return null;
+  for (const avatarType of career.avatars) {
+    const avatars = AVATAR_LIST[avatarType as keyof typeof AVATAR_LIST];
+    if (avatars?.find((al) => al.file === avatarFile)) {
+      return "tile/shop/avatar";
+    }
+    const avatarsDefault = AVATAR_DEFAULT_LIST[avatarType as keyof typeof AVATAR_DEFAULT_LIST];
+    if (avatarsDefault?.find((al) => al.file === avatarFile)) {
+      return "tile/shop/avatar-default";
+    }
+  }
+  return null;
+};
+
+/** Returns the rarity string of a standard avatar file for the given player's career. */
+const getAvatarRarityFromFile = (player: Player, avatarFile: string): string | undefined => {
+  const career = getCareerFromPlayer(player);
+  if (!avatarFile) return undefined;
+  for (const avatarType of career.avatars) {
+    const avatars = AVATAR_LIST[avatarType as keyof typeof AVATAR_LIST];
+    const found = avatars?.find((al) => al.file === avatarFile);
+    if (found) return found.rarity;
+    const avatarsDefault = AVATAR_DEFAULT_LIST[avatarType as keyof typeof AVATAR_DEFAULT_LIST];
+    const foundDefault = avatarsDefault?.find((al) => al.file === avatarFile);
+    if (foundDefault) return foundDefault.rarity;
+  }
+  return undefined;
+};
+
 const getRaceFromPlayer = (player: Player) => {
   return getRaceFromCareer(getCareerKeyFromPlayer(player));
 };
@@ -218,6 +406,21 @@ const getCareersByRace = () => {
   return carrers;
 };
 
+const getAvailableCareersByRace = () => {
+  const carrers: any = {};
+  for (const [name, values] of Object.entries(getAvailableCareers())) {
+    const badge = values.badge;
+    if (!carrers[badge]) {
+      carrers[badge] = [];
+    }
+    if (!carrers[badge][values.range]) {
+      carrers[badge][values.range] = {};
+    }
+    carrers[badge][values.range][name] = values;
+  }
+  return carrers;
+};
+
 const GAIN_CAREER_POINT = 2;
 const GAIN_CAREER_POINT_FRIENDLY = 2;
 
@@ -255,7 +458,11 @@ const COMPATIBILITY: CompatibilityType = {
 } as const;
 
 const getPlayerGroup = (player: Player) => {
-  return getRaceGroup(getRaceFromPlayer(player));
+  const race = getRaceFromPlayer(player);
+  if (!race) {
+    return undefined;
+  }
+  return getRaceGroup(race);
 };
 
 const getRaceGroup = (race: RACE): GROUP_NAME | undefined => {
@@ -283,6 +490,9 @@ const getRaceCompatibility = (race1: RACE, race2: RACE) => {
 const getPlayerCompatibility = (player1: Player, player2: Player) => {
   const race1 = getRaceFromPlayer(player1);
   const race2 = getRaceFromPlayer(player2);
+  if (!race1 || !race2) {
+    return;
+  }
   getRaceCompatibility(race1, race2);
 };
 
@@ -303,7 +513,7 @@ function getPlayersAvailableForPromo(players = []) {
   );
 }
 
-function getPromoCareer(careerId: CAREER_ID, userPlayers: Player[]) {
+function getPromoCareer(careerId: CAREER_ID_ALL, userPlayers: Player[]) {
   const race = getRaceFromCareer(careerId);
   let promo = userPlayers
     .filter((p, i) => p && i < NB_MAX_PLAYERS && getRaceFromPlayer(p) === race)
@@ -315,7 +525,7 @@ function getPromoCareer(careerId: CAREER_ID, userPlayers: Player[]) {
   return promo;
 }
 
-function getPriceCareer(careerId: CAREER_ID) {
+function getPriceCareer(careerId: CAREER_ID_ALL) {
   return getCareerRanges()[getCareerFromKey(careerId).range];
 }
 
@@ -377,7 +587,7 @@ const getPlayersByState = (players: Player[]) => {
 const getRaceSpecialSkills = (race: RACE) => {
   const careers = getCareers();
   const raceCareerIds = Object.keys(careers).filter(
-    (careerId) => careers[careerId as CAREER_ID].badge === race
+    (careerId) => careers[careerId as CAREER_ID_ALL].badge === race
   );
 
   if (raceCareerIds.length === 0) {
@@ -388,7 +598,7 @@ const getRaceSpecialSkills = (race: RACE) => {
   const skillCount: Record<string, number> = {};
 
   raceCareerIds.forEach((careerId) => {
-    const careerSkills = careers[careerId as CAREER_ID].skills;
+    const careerSkills = careers[careerId as CAREER_ID_ALL].skills;
     careerSkills.forEach((skill) => {
       const skillName = Array.isArray(skill) ? skill[0] : skill;
       // Ne compter que les compétences spéciales
@@ -418,7 +628,11 @@ export {
   COMPATIBILITY,
   GAIN_CAREER_POINT,
   GAIN_CAREER_POINT_FRIENDLY,
+  getAvailableCareersByRace,
+  getAvatarBasePathFromFile,
+  getAvatarRarityFromFile,
   getAvatarTypeFromPlayer,
+  getCareerId2025,
   getCareerFromIcon,
   getCareerFromKey,
   getCareerFromPlayer,