enefel 2.9.0 → 2.11.0

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "enefel",
-    "version": "2.9.0",
+    "version": "2.11.0",
     "description": "Blood Bowl 3 game engine",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
@@ -20,12 +20,16 @@
         "watch": "tsc -w",
         "prepare": "yarn build",
         "test": "jest",
-        "test:watch": "jest --watch"
+        "test:watch": "jest --watch",
+        "convert:career": "npx ts-node teams/convert-csv-to-career.ts"
     },
     "keywords": [],
     "author": "Manest",
     "license": "MIT",
     "dependencies": {
+        "csv-parse": "^6.1.0",
+        "csv-stringify": "^6.6.0",
+        "jsdom": "^27.2.0",
         "seedrandom": "3.0.5",
         "yup": "^0.29.3"
     },

package/dist/pitch.d.ts

@@ -28,4 +28,13 @@ declare function getNumberPlayerZone(teamNumber: number, players: Player[], game
     playerLateralB: number;
     playerCenter: number;
 };
-export { coordinatesConvertorX, coordinatesConvertorY, getCenterTile, getHalfStadium, getIndexFromXY, getLateralATile, getLateralBTile, getNumberPlayerZone, getScrimmageTile, getTdTile, getTile, TILES, };
+/**
+ * Checks if a tile at position (x, y) is the enemy team's touchdown zone
+ * @param x - X coordinate
+ * @param y - Y coordinate
+ * @param teamId - The player's team ID
+ * @param game - Game object containing stadium_zone, stadium_width, team1, team2
+ * @returns true if the tile is the enemy TD zone
+ */
+declare function isEnemyTDZone(x: number, y: number, teamId: string, game: Game): boolean;
+export { coordinatesConvertorX, coordinatesConvertorY, getCenterTile, getHalfStadium, getIndexFromXY, getLateralATile, getLateralBTile, getNumberPlayerZone, getScrimmageTile, getTdTile, getTile, isEnemyTDZone, TILES, };

package/dist/pitch.js

@@ -12,6 +12,7 @@ exports.getNumberPlayerZone = getNumberPlayerZone;
 exports.getScrimmageTile = getScrimmageTile;
 exports.getTdTile = getTdTile;
 exports.getTile = getTile;
+exports.isEnemyTDZone = isEnemyTDZone;
 const index_1 = require("./index");
 const status_1 = require("./status");
 var TILES;
@@ -112,3 +113,18 @@ function getNumberPlayerZone(teamNumber, players, game) {
     });
     return { playerScrimmage, playerLateralA, playerLateralB, playerCenter };
 }
+/**
+ * Checks if a tile at position (x, y) is the enemy team's touchdown zone
+ * @param x - X coordinate
+ * @param y - Y coordinate
+ * @param teamId - The player's team ID
+ * @param game - Game object containing stadium_zone, stadium_width, team1, team2
+ * @returns true if the tile is the enemy TD zone
+ */
+function isEnemyTDZone(x, y, teamId, game) {
+    const tile = getTile(game, x, y);
+    // Determine if player is team1 or team2, then get enemy TD zone
+    const enemyTDTeamNumber = teamId === game.team1?.id ? 2 : 1;
+    const enemyTD = getTdTile(enemyTDTeamNumber);
+    return tile === enemyTD;
+}

package/dist/player.d.ts

@@ -1,3 +1,4 @@
+import { CAREER_VERSION } from "./career";
 import { Game, Player, PlayerWithSkill, Team } from "./types/models";
 declare enum PLAYER_INJURY {
     BADLY_HURT = "badly-hurt",
@@ -13,6 +14,8 @@ declare enum PLAYER_CARAC {
     ST = "ST",
     PA = "PA"
 }
+declare const CARAC_MAX: Record<PLAYER_CARAC, number>;
+declare const CARAC_MIN: Record<PLAYER_CARAC, number>;
 declare function hasMove(player: PlayerWithSkill, game: Game): boolean;
 declare function arePlayingSameGame(p1: Player, p2: Player): boolean;
 declare function hasTeam(player: Player): boolean;
@@ -25,17 +28,18 @@ declare function isTeam1(player: Player, game: Game): boolean;
 declare function isRookie(player: Player): boolean;
 declare function getCareerBaseCarac(player: Player, carac: PLAYER_CARAC): number;
 declare function getCareerBaseCaracLimit(player: Player, value: number, carac: PLAYER_CARAC): number;
-declare function getMaxCarac(player: Player, carac: PLAYER_CARAC, game: Game): number;
-declare function getMaxCommun(player: Player, carac: PLAYER_CARAC, _game: Game): any;
+declare function getMaxCarac(player: Player, carac: PLAYER_CARAC, game?: Game): number;
+declare function getMaxCommun(player: Player, carac: PLAYER_CARAC, _game: Game): number;
 declare function getMaxAV(player: Player, game: Game): number;
 declare function getMaxST(player: Player, game: Game): number;
 declare function getMaxAG(player: Player, game: Game): number;
 declare function getMaxMA(player: Player, game: Game): number;
+declare function getMaxPA(player: Player, game?: Game): number;
 declare function getMaxGfi(player: PlayerWithSkill): 2 | 3;
 declare const AGING_SIZE_RANGE = 5;
 declare function gamesforAgingRoll(totalGames: number): number;
 declare const AGING_INITIAL_BONUS = 5;
 declare const AGING_MIN_BONUS = -3;
 declare function getAgingBonus(player: Player, totalGames: number): number | null;
-declare function BB2020Carac(value: number, carac: PLAYER_CARAC): string | number;
-export { AGING_INITIAL_BONUS, AGING_MIN_BONUS, AGING_SIZE_RANGE, areFromSameTeam, arePlayingSameGame, BB2020Carac, gamesforAgingRoll, getAgingBonus, getCareerBaseCarac, getCareerBaseCaracLimit, getMaxAG, getMaxAV, getMaxCarac, getMaxCommun, getMaxGfi, getMaxMA, getMaxST, hasMove, hasTeam, isPlaying, isPlayingGame, isRookie, isTeam1, isTeamPlaying, isTeamPlayingGame, PLAYER_CARAC, PLAYER_INJURY, };
+declare function BB2020Carac(value: number, carac: PLAYER_CARAC, careerVersion?: CAREER_VERSION): string | number;
+export { AGING_INITIAL_BONUS, AGING_MIN_BONUS, AGING_SIZE_RANGE, areFromSameTeam, arePlayingSameGame, BB2020Carac, CARAC_MAX, CARAC_MIN, gamesforAgingRoll, getAgingBonus, getCareerBaseCarac, getCareerBaseCaracLimit, getMaxAG, getMaxAV, getMaxCarac, getMaxCommun, getMaxGfi, getMaxMA, getMaxPA, getMaxST, hasMove, hasTeam, isPlaying, isPlayingGame, isRookie, isTeam1, isTeamPlaying, isTeamPlayingGame, PLAYER_CARAC, PLAYER_INJURY, };

package/dist/player.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PLAYER_INJURY = exports.PLAYER_CARAC = exports.AGING_SIZE_RANGE = exports.AGING_MIN_BONUS = exports.AGING_INITIAL_BONUS = void 0;
+exports.PLAYER_INJURY = exports.PLAYER_CARAC = exports.CARAC_MIN = exports.CARAC_MAX = exports.AGING_SIZE_RANGE = exports.AGING_MIN_BONUS = exports.AGING_INITIAL_BONUS = void 0;
 exports.areFromSameTeam = areFromSameTeam;
 exports.arePlayingSameGame = arePlayingSameGame;
 exports.BB2020Carac = BB2020Carac;
@@ -14,6 +14,7 @@ exports.getMaxCarac = getMaxCarac;
 exports.getMaxCommun = getMaxCommun;
 exports.getMaxGfi = getMaxGfi;
 exports.getMaxMA = getMaxMA;
+exports.getMaxPA = getMaxPA;
 exports.getMaxST = getMaxST;
 exports.hasMove = hasMove;
 exports.hasTeam = hasTeam;
@@ -23,6 +24,7 @@ exports.isRookie = isRookie;
 exports.isTeam1 = isTeam1;
 exports.isTeamPlaying = isTeamPlaying;
 exports.isTeamPlayingGame = isTeamPlayingGame;
+const career_1 = require("./career");
 const improvement_1 = require("./improvement");
 const meteo_1 = require("./meteo");
 const race_1 = require("./race");
@@ -43,6 +45,24 @@ var PLAYER_CARAC;
     PLAYER_CARAC["ST"] = "ST";
     PLAYER_CARAC["PA"] = "PA";
 })(PLAYER_CARAC || (exports.PLAYER_CARAC = PLAYER_CARAC = {}));
+// Valeurs maximales absolues des caractéristiques (Blood Bowl 2020 rulebook)
+const CARAC_MAX = {
+    [PLAYER_CARAC.MA]: 9,
+    [PLAYER_CARAC.ST]: 8,
+    [PLAYER_CARAC.AG]: 5, // interne 5 = affichage 1+
+    [PLAYER_CARAC.PA]: 5, // interne 5 = affichage 1+
+    [PLAYER_CARAC.AV]: 10, // interne 10 = affichage 11+
+};
+exports.CARAC_MAX = CARAC_MAX;
+// Valeurs minimales absolues des caractéristiques
+const CARAC_MIN = {
+    [PLAYER_CARAC.MA]: 1,
+    [PLAYER_CARAC.ST]: 1,
+    [PLAYER_CARAC.AG]: 1, // interne 1 = affichage 6+
+    [PLAYER_CARAC.PA]: 0, // 0 = pas de PA
+    [PLAYER_CARAC.AV]: 2, // interne 2 = affichage 3+
+};
+exports.CARAC_MIN = CARAC_MIN;
 function hasMove(player, game) {
     if (player.current_MA >= getMaxCarac(player, PLAYER_CARAC.MA, game) &&
         player.current_gfi >= getMaxGfi(player) &&
@@ -103,21 +123,27 @@ function getMaxCarac(player, carac, game) {
         return -1;
     }
     if (carac === PLAYER_CARAC.AG) {
-        return getMaxAG(player, game);
+        return getMaxAG(player, game || {});
     }
     else if (carac === PLAYER_CARAC.MA) {
-        return getMaxMA(player, game);
+        return getMaxMA(player, game || {});
     }
     else if (carac === PLAYER_CARAC.AV) {
-        return getMaxAV(player, game);
+        return getMaxAV(player, game || {});
     }
     else if (carac === PLAYER_CARAC.ST) {
-        return getMaxST(player, game);
+        return getMaxST(player, game || {});
+    }
+    else if (carac === PLAYER_CARAC.PA) {
+        return getMaxPA(player, game);
     }
     return -1;
 }
 function getMaxCommun(player, carac, _game) {
     let c = player[carac];
+    if (c == null) {
+        return 0;
+    }
     if (!player.tempCarac) {
         return c;
     }
@@ -140,26 +166,29 @@ function getMaxCommun(player, carac, _game) {
     c = getCareerBaseCaracLimit(player, c, PLAYER_CARAC[carac]);
     return c;
 }
-function getLimitedValue(c) {
-    if (c > 10) {
-        c = 10;
-    }
-    if (c < 0) {
-        c = 0;
-    }
-    return c;
-}
 function getMaxAV(player, game) {
     let c = getMaxCommun(player, PLAYER_CARAC.AV, game);
-    return getLimitedValue(c);
+    if (c > CARAC_MAX[PLAYER_CARAC.AV])
+        c = CARAC_MAX[PLAYER_CARAC.AV];
+    if (c < CARAC_MIN[PLAYER_CARAC.AV])
+        c = CARAC_MIN[PLAYER_CARAC.AV];
+    return c;
 }
 function getMaxST(player, game) {
     let c = getMaxCommun(player, PLAYER_CARAC.ST, game);
-    return getLimitedValue(c);
+    if (c > CARAC_MAX[PLAYER_CARAC.ST])
+        c = CARAC_MAX[PLAYER_CARAC.ST];
+    if (c < CARAC_MIN[PLAYER_CARAC.ST])
+        c = CARAC_MIN[PLAYER_CARAC.ST];
+    return c;
 }
 function getMaxAG(player, game) {
     let c = getMaxCommun(player, PLAYER_CARAC.AG, game);
-    return getLimitedValue(c);
+    if (c > CARAC_MAX[PLAYER_CARAC.AG])
+        c = CARAC_MAX[PLAYER_CARAC.AG];
+    if (c < CARAC_MIN[PLAYER_CARAC.AG])
+        c = CARAC_MIN[PLAYER_CARAC.AG];
+    return c;
 }
 function getMaxMA(player, game) {
     let c = getMaxCommun(player, PLAYER_CARAC.MA, game);
@@ -169,7 +198,57 @@ function getMaxMA(player, game) {
             c = maxMA;
         }
     }
-    return getLimitedValue(c);
+    if (c > CARAC_MAX[PLAYER_CARAC.MA])
+        c = CARAC_MAX[PLAYER_CARAC.MA];
+    if (c < CARAC_MIN[PLAYER_CARAC.MA])
+        c = CARAC_MIN[PLAYER_CARAC.MA];
+    return c;
+}
+function clampPA(c) {
+    if (c <= 0)
+        return CARAC_MIN[PLAYER_CARAC.PA]; // 0 = pas de PA
+    if (c > CARAC_MAX[PLAYER_CARAC.PA])
+        return CARAC_MAX[PLAYER_CARAC.PA];
+    return c;
+}
+function getMaxPA(player, game) {
+    // Si le joueur a déjà une valeur PA en base, l'utiliser
+    if (player.PA != null) {
+        let c = getMaxCommun(player, PLAYER_CARAC.PA, game || {});
+        return clampPA(c);
+    }
+    // Sinon, déterminer la valeur selon la version de la career
+    const career = (0, race_1.getCareerFromPlayer)(player);
+    if (!career) {
+        // Fallback: utiliser AG si pas de career
+        return getMaxAG(player, game || {});
+    }
+    // Si c'est une career 2025, utiliser career.PA
+    if (career.version === career_1.CAREER_VERSION.V2025 && career.PA != null) {
+        let c = career.PA;
+        // Appliquer les modificateurs tempCarac si présents
+        if (player.tempCarac) {
+            let obj;
+            try {
+                obj = JSON.parse(player.tempCarac);
+            }
+            catch (e) {
+                return clampPA(c);
+            }
+            for (const value of Object.values(obj)) {
+                if (value.gainCarac === PLAYER_CARAC.PA) {
+                    c += 1;
+                }
+                if (value.loseCarac === PLAYER_CARAC.PA) {
+                    c -= 1;
+                }
+            }
+            c = getCareerBaseCaracLimit(player, c, PLAYER_CARAC.PA);
+        }
+        return clampPA(c);
+    }
+    // Sinon (career 2020 ou V6), utiliser AG
+    return getMaxAG(player, game || {});
 }
 function getMaxGfi(player) {
     return (0, skill_1.hasSkill)(player, skill_1.SKILL_NAMES.SPRINT) ? 3 : 2;
@@ -211,16 +290,21 @@ function getAgingBonus(player, totalGames) {
     }
     return bonus;
 }
-function BB2020Carac(value, carac) {
+function BB2020Carac(value, carac, careerVersion) {
     //   CHARACTERISTIC TABLE
     // Characteristic MA ST AG PA AV
     // Maximum 9 8 1+ 1+ 11+
     //Minimum 1 1 6+ 6+ 3+
+    // Les valeurs sont maintenant normalisées au format 2020 pour toutes les versions
+    // (les valeurs 2025 sont converties lors de la génération du fichier career2025.ts)
     if (carac === PLAYER_CARAC.AV && value) {
         // TODO: min3+, max11+
         return `${+value + 1}+`;
     }
-    else if (carac === PLAYER_CARAC.AG && value) {
+    else if ((carac === PLAYER_CARAC.AG || carac === PLAYER_CARAC.PA) &&
+        value) {
+        // Conversion pour afficher la notation "+"
+        // PA se comporte exactement comme AG (PA n'existait pas en 2020)
         let newValue = 6;
         if (value <= 1)
             newValue = 6;

package/dist/position.d.ts

@@ -1,3 +1,7 @@
 import { PlayerWithSkill, Point } from "./types/models";
 export declare const isAdjacent: (p1: Point, p2: Point) => boolean;
+/**
+ * Returns all 8 adjacent squares around a given position
+ */
+export declare const getAllAdjacentSquares: (x: number, y: number) => Point[];
 export declare const getEnemyTackleZones: (location: Point, teamId: string, players: Record<string, PlayerWithSkill>) => PlayerWithSkill[];

package/dist/position.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEnemyTackleZones = exports.isAdjacent = void 0;
+exports.getEnemyTackleZones = exports.getAllAdjacentSquares = exports.isAdjacent = void 0;
 const status_1 = require("./status");
 const isAdjacent = (p1, p2) => {
     if (p1 === null ||
@@ -16,6 +16,22 @@ const isAdjacent = (p1, p2) => {
         Math.abs(p1.y - p2.y) <= 1);
 };
 exports.isAdjacent = isAdjacent;
+/**
+ * Returns all 8 adjacent squares around a given position
+ */
+const getAllAdjacentSquares = (x, y) => {
+    return [
+        { x: x - 1, y: y - 1 },
+        { x: x, y: y - 1 },
+        { x: x + 1, y: y - 1 },
+        { x: x - 1, y: y },
+        { x: x + 1, y: y },
+        { x: x - 1, y: y + 1 },
+        { x: x, y: y + 1 },
+        { x: x + 1, y: y + 1 },
+    ];
+};
+exports.getAllAdjacentSquares = getAllAdjacentSquares;
 const getEnemyTackleZones = (location, teamId, players) => {
     // player a un format : { id1: {player1}, id2:{player2} etc...}
     return Object.values(players).filter((player) => {

package/dist/race.d.ts

@@ -1,20 +1,31 @@
-import { AVATAR, CAREER_ID, RACE } from "./career";
+import { AVATAR, CAREER_ID_ALL, RACE } from "./career";
 import { Player, Team, User } from "./types/models";
 declare const ANIMOSITY_NUMBER = 2;
 declare const isPrivateRace: (race: RACE) => boolean;
 declare const hasUnlockRace: (user: User, race: RACE) => boolean;
 declare const hasUnlockCareer: (user: User, careerId: string) => boolean;
-declare const getCareerFromKey: (key: CAREER_ID) => import("./career").Career;
-declare const getCareerKeyFromPlayer: (player: Player) => CAREER_ID;
-declare const getCareerFromPlayer: (player: Player) => import("./career").Career;
-declare const getCareerFromIcon: (nameIcon: string) => import("./career").Career | null;
+declare const getCareerFromKey: (key: CAREER_ID_ALL) => import("./career2025").Career | import("./career").Career;
+declare const getCareerKeyFromPlayer: (player: Player) => CAREER_ID_ALL;
+/**
+ * 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).
+ */
+declare const getCareerId2025: (careerId: string) => string | undefined;
+declare const getCareerFromPlayer: (player: Player) => import("./career2025").Career | import("./career").Career;
+declare const getCareerFromIcon: (nameIcon: string) => import("./career2025").Career | import("./career").Career | null;
 declare const getPlayerAvatarDefault: (player: Player) => string | null;
 declare const getPlayerAvatar: (player: Player) => string | null;
-declare const getPlayerAvatarPath: (player: Player) => "tile/shop/avatar" | "tile/shop/avatar-default" | null;
-declare const getRaceFromCareer: (careerId: CAREER_ID) => RACE;
-declare const getAvatarTypeFromPlayer: (player: Player, avatarFile: string) => AVATAR | null;
-declare const getRaceFromPlayer: (player: Player) => RACE;
+declare const getPlayerAvatarPath: (player: Player) => string | null;
+declare const getRaceFromCareer: (careerId: CAREER_ID_ALL) => RACE | undefined;
+declare const getAvatarTypeFromPlayer: (player: Player, avatarFile: string) => import("./career2025").AVATAR | AVATAR | 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. */
+declare const getAvatarBasePathFromFile: (player: Player, avatarFile: string) => string | null;
+/** Returns the rarity string of a standard avatar file for the given player's career. */
+declare const getAvatarRarityFromFile: (player: Player, avatarFile: string) => string | undefined;
+declare const getRaceFromPlayer: (player: Player) => RACE | undefined;
 declare const getCareersByRace: () => any;
+declare const getAvailableCareersByRace: () => any;
 declare const GAIN_CAREER_POINT = 2;
 declare const GAIN_CAREER_POINT_FRIENDLY = 2;
 declare enum GROUP_NAME {
@@ -34,8 +45,8 @@ declare const getRaceCompatibility: (race1: RACE, race2: RACE) => boolean;
 declare const getPlayerCompatibility: (player1: Player, player2: Player) => void;
 declare function getCareerRanges(): number[];
 declare function getPlayersAvailableForPromo(players?: never[]): Player[];
-declare function getPromoCareer(careerId: CAREER_ID, userPlayers: Player[]): number;
-declare function getPriceCareer(careerId: CAREER_ID): number;
+declare function getPromoCareer(careerId: CAREER_ID_ALL, userPlayers: Player[]): number;
+declare function getPriceCareer(careerId: CAREER_ID_ALL): number;
 declare function getTeamGroups(team: Team): any;
 declare function isPlayerNeutralGroup(player: Player): boolean;
 declare function isNeutralGroup(group: string): boolean;
@@ -46,4 +57,4 @@ declare const getPlayersByState: (players: Player[]) => {
     lastRetired: Player[];
 };
 declare const getRaceSpecialSkills: (race: RACE) => string[];
-export { ANIMOSITY_NUMBER, COMPATIBILITY, GAIN_CAREER_POINT, GAIN_CAREER_POINT_FRIENDLY, getAvatarTypeFromPlayer, getCareerFromIcon, getCareerFromKey, getCareerFromPlayer, getCareerKeyFromPlayer, getCareerRanges, getCareersByRace, getPlayerAvatar, getPlayerAvatarDefault, getPlayerAvatarPath, getPlayerCompatibility, getPlayerGroup, getPlayersAvailableForPromo, getPlayersByState, getPriceCareer, getPromoCareer, getRaceCompatibility, getRaceFromCareer, getRaceFromPlayer, getRaceGroup, getRaceSpecialSkills, getTeamGroups, getTeamIncompatibleGroups, GROUP_NAME, hasUnlockCareer, hasUnlockRace, isNeutralGroup, isPlayerNeutralGroup, isPrivateRace, };
+export { ANIMOSITY_NUMBER, COMPATIBILITY, GAIN_CAREER_POINT, GAIN_CAREER_POINT_FRIENDLY, getAvailableCareersByRace, getAvatarBasePathFromFile, getAvatarRarityFromFile, getAvatarTypeFromPlayer, getCareerId2025, getCareerFromIcon, getCareerFromKey, getCareerFromPlayer, getCareerKeyFromPlayer, getCareerRanges, getCareersByRace, getPlayerAvatar, getPlayerAvatarDefault, getPlayerAvatarPath, getPlayerCompatibility, getPlayerGroup, getPlayersAvailableForPromo, getPlayersByState, getPriceCareer, getPromoCareer, getRaceCompatibility, getRaceFromCareer, getRaceFromPlayer, getRaceGroup, getRaceSpecialSkills, getTeamGroups, getTeamIncompatibleGroups, GROUP_NAME, hasUnlockCareer, hasUnlockRace, isNeutralGroup, isPlayerNeutralGroup, isPrivateRace, };