enefel 2.9.1 → 2.11.0

package/dist/types/models.d.ts

@@ -77,10 +77,12 @@ export interface Player extends Point {
     MA: number;
     ST: number;
     AG: number;
+    PA?: number | null;
     AV: number;
     current_MA: number;
     current_ST: number;
     current_AG: number;
+    current_PA?: number | null;
     current_AV: number;
     current_gfi: number;
     date_next_action: Date | null;
@@ -99,6 +101,7 @@ export interface Player extends Point {
     can_reroll: boolean;
     can_reroll_rebound: boolean;
     can_reroll_no_to: boolean;
+    secure_ball: boolean;
     has_action: boolean;
     pc: number;
     aging: number;
@@ -106,6 +109,7 @@ export interface Player extends Point {
     tempCarac: string;
     userCreatedAt: Date;
     avatar: string;
+    dice_id: string | null;
     quote: string;
     speak: string;
     raz: boolean;

package/index.ts

@@ -8,16 +8,18 @@ import {
   meteoMaxPassDistance,
 } from "./meteo";
 import { getMaxCarac, hasMove, PLAYER_CARAC } from "./player";
-import { getEnemyTackleZones, isAdjacent } from "./position";
+import { getAllAdjacentSquares, getEnemyTackleZones, isAdjacent } from "./position";
 import { getCareerFromPlayer } from "./race";
 import { getDisturbingPresenceMalus, hasSkill, SKILL_NAMES } from "./skill";
 import {
+  hasStatusCanAssist,
   hasStatusCanFaceup,
   hasStatusCanStandup,
   hasStatusFall,
   hasStatusOnField,
   hasStatusStanding,
   hasStatusTacleZone,
+  PLAYER_STATUS,
 } from "./status";
 import version from "./version";
 
@@ -142,6 +144,7 @@ const GAME_HISTORY_INFO = {
   ARMOR: "ar",
   BALL: "ball",
   BLOCK: "b",
+  BREATHE_FIRE: "brf",
   BRIBE: "br",
   CARAC_CHANGE: "cc",
   CASUALTY: "ca",
@@ -166,17 +169,25 @@ const GAME_HISTORY_INFO = {
   METEO: "met",
   MOVE: "m",
   PASS: "p",
+  PUNT_DIRECTION: "puntd",
+  PUNT_DISTANCE: "puntdist",
+  PUNT_TO_CROWD: "puntc",
+  PUNT_ON_PLAYER: "puntp",
+  PUNT_SCATTER: "punts",
+  PRO: "pro",
   REJECTION: "r",
   REROLL_COACH: "rc",
   REROLL_INITIAL: "rei",
   REROLL_METEO: "rm",
   REROLL_RACE_MALUS: "rrm",
   REROLL: "re",
+  SECURE_BALL: "sb",
   SCATTER: "sc",
   SKILL_GAIN: "skg",
   SKILL_LOSS: "skl",
   SKILL: "sk",
   SPY: "spy",
+  STAB: "stab",
   STANDUP: "st",
   START_FAN: "fan",
   STATUS: "s",
@@ -184,6 +195,8 @@ const GAME_HISTORY_INFO = {
   TD: "td",
   THREATENING: "thr",
   THROW_TEAM_MATE: "ttm",
+  BLOODLUST_BITE: "blb",
+  BLOODLUST_NO_TARGET: "blnt",
   TURNOVER: "to",
 };
 
@@ -330,7 +343,8 @@ const getBlockAssistance = (
   attackerPlayer: PlayerWithSkill,
   defenderPlayer: PlayerWithSkill,
   players: PlayerWithSkill[],
-  isAttacker = false
+  isAttacker = false,
+  isFoul = false
 ) => {
   const OtherPlayersThanInvolved = players.filter((player) => {
     return player.id !== attackerPlayer.id && player.id !== defenderPlayer.id;
@@ -346,15 +360,16 @@ const getBlockAssistance = (
 
   // 1. Must be adjacent to the enemy player involved in the block,
   // 3. Must be standing, and …
+  // 5. Must not be Eye Gouged (cannot provide assists)
   const adjacentEnemyPlayers = OtherPlayersThanInvolved.filter((player) => {
-    return isValidAdjacentEnemy(player, defenderPlayer);
+    return isValidAdjacentEnemy(player, defenderPlayer) && hasStatusCanAssist(player);
   });
   // 2. Must not be in the tackle zone of any other player from the
   // opposing team, and ...
   const assistantPlayers = adjacentEnemyPlayers.filter(
     (adjacentEnemyPlayer) => {
       let hasGard = false;
-      if (hasSkill(adjacentEnemyPlayer, SKILL_NAMES.GUARD)) {
+      if (!isFoul && hasSkill(adjacentEnemyPlayer, SKILL_NAMES.GUARD)) {
         hasGard = true;
         if (
           isAttacker && // player is the attacker player.
@@ -368,8 +383,15 @@ const getBlockAssistance = (
           hasGard = false;
         }
       }
+      // Put the Boot In: can provide offensive assist on fouls even when marked
+      const hasPutTheBootIn =
+        isFoul &&
+        isAttacker &&
+        hasSkill(adjacentEnemyPlayer, SKILL_NAMES.PUT_THE_BOOT_IN);
+
       return (
         hasGard ||
+        hasPutTheBootIn ||
         !OtherPlayersThanInvolved.some((player) => {
           return (
             // 4. Must have his tackle zones.
@@ -811,6 +833,7 @@ function canPass(
   playerIdWithBall: string
 ) {
   return (
+    player.status !== PLAYER_STATUS.BLOODLUST &&
     hasStatusTacleZone(player) &&
     player.has_action === true &&
     playerTeam.date_next_pass === null &&
@@ -862,9 +885,20 @@ function canTransmit(
   if (!player || !target || isSamePlayer(player, target)) {
     return false;
   }
+  // Cannot transmit from or to a player in Bloodlust state
+  if (player.status === PLAYER_STATUS.BLOODLUST) {
+    return false;
+  }
+  if (target.status === PLAYER_STATUS.BLOODLUST) {
+    return false;
+  }
   if (player.id !== playerIdWithBall && target.id !== playerIdWithBall) {
     return false;
   }
+  // Cannot transmit if player has already ended turn (e.g., after Bloodlust bite)
+  if (player.hasEndTurn === true) {
+    return false;
+  }
 
   return (
     player.teamId === target.teamId &&
@@ -1016,6 +1050,7 @@ export {
   FORMATION_DEFAULT_NAME,
   GAME_HISTORY_INFO,
   GAME_HISTORY_TYPE,
+  getAllAdjacentSquares,
   getAttackerStrength,
   getBestInterceptor,
   getBlockAssistance,
@@ -1052,3 +1087,21 @@ export {
   TAKE_BALL_TYPE,
   version,
 };
+
+export {
+  SidestepMode,
+  SidestepStrategy,
+  SidestepPreference,
+} from "./skills/sidestep";
+
+export {
+  HitAndRunMode,
+  HitAndRunStrategy,
+  HitAndRunPreference,
+} from "./skills/hitAndRun";
+
+export {
+  SafePairOfHandsMode,
+  SafePairOfHandsStrategy,
+  SafePairOfHandsPreference,
+} from "./skills/safePairOfHands";

package/jest.config.js

@@ -14,3 +14,6 @@ module.exports = {
 
 
 
+
+
+

package/move.ts

@@ -1,6 +1,7 @@
 import { getEnemyTackleZones } from "./position";
 import { hasSkill, SKILL_NAMES } from "./skill";
-import { PlayerWithSkill, Point } from "./types/models";
+import { hasStatusStanding } from "./status";
+import { Game, PlayerWithSkill, Point, Team } from "./types/models";
 
 function bonusDodge(
   player: PlayerWithSkill,
@@ -94,4 +95,51 @@ function modifJumping(
   return { modif, enemies };
 }
 
-export { bonusDodge, modifJumping };
+function hasOpponentStandingAroundBall(
+  players: Record<string, PlayerWithSkill> | PlayerWithSkill[],
+  ball: Point,
+  teamId: string,
+  distance = 2
+) {
+  const list = Array.isArray(players) ? players : Object.values(players);
+  return list.some(
+    (p) =>
+      p.teamId !== teamId &&
+      hasStatusStanding(p) &&
+      p.x !== null &&
+      p.y !== null &&
+      ball.x !== null &&
+      ball.y !== null &&
+      Math.max(Math.abs(p.x - ball.x), Math.abs(p.y - ball.y)) <= distance
+  );
+}
+
+function getGameBall(game: Game | null | undefined): Point | null {
+  if (!game) return null;
+  if (game.ball_player_id !== null) return null;
+  if (game.ball_x == null || game.ball_y == null) return null;
+  return { x: game.ball_x, y: game.ball_y };
+}
+
+function listGamePlayers(game: Game | null | undefined): PlayerWithSkill[] {
+  if (!game) return [];
+  const team1Players = (game.team1 as Team | undefined)?.players || [];
+  const team2Players = (game.team2 as Team | undefined)?.players || [];
+  return [...team1Players, ...team2Players];
+}
+
+function canUseSecureBall(player: PlayerWithSkill): boolean {
+  return (
+    !hasSkill(player, SKILL_NAMES.BIG_GUY) &&
+    !hasSkill(player, SKILL_NAMES.UNSTEADY)
+  );
+}
+
+export {
+  bonusDodge,
+  canUseSecureBall,
+  getGameBall,
+  hasOpponentStandingAroundBall,
+  listGamePlayers,
+  modifJumping,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "enefel",
-  "version": "2.9.1",
+  "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/pitch.ts

@@ -115,6 +115,27 @@ function getNumberPlayerZone(
   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: number,
+  y: number,
+  teamId: string,
+  game: Game
+): boolean {
+  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;
+}
+
 export {
   coordinatesConvertorX,
   coordinatesConvertorY,
@@ -127,5 +148,6 @@ export {
   getScrimmageTile,
   getTdTile,
   getTile,
+  isEnemyTDZone,
   TILES,
 };

package/player.ts

@@ -1,3 +1,4 @@
+import { CAREER_VERSION } from "./career";
 import { getAgingMinExperience } from "./improvement";
 import { meteoMaxMA } from "./meteo";
 import { getCareerFromPlayer } from "./race";
@@ -20,6 +21,24 @@ enum PLAYER_CARAC {
   PA = "PA",
 }
 
+// Valeurs maximales absolues des caractéristiques (Blood Bowl 2020 rulebook)
+const CARAC_MAX: Record<PLAYER_CARAC, number> = {
+  [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+
+};
+
+// Valeurs minimales absolues des caractéristiques
+const CARAC_MIN: Record<PLAYER_CARAC, number> = {
+  [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+
+};
+
 function hasMove(player: PlayerWithSkill, game: Game) {
   if (
     player.current_MA >= getMaxCarac(player, PLAYER_CARAC.MA, game) &&
@@ -95,24 +114,29 @@ function getCareerBaseCaracLimit(
   return value;
 }
 
-function getMaxCarac(player: Player, carac: PLAYER_CARAC, game: Game) {
+function getMaxCarac(player: Player, carac: PLAYER_CARAC, game?: Game) {
   if (!player) {
     return -1;
   }
   if (carac === PLAYER_CARAC.AG) {
-    return getMaxAG(player, game);
+    return getMaxAG(player, game || ({} as Game));
   } else if (carac === PLAYER_CARAC.MA) {
-    return getMaxMA(player, game);
+    return getMaxMA(player, game || ({} as Game));
   } else if (carac === PLAYER_CARAC.AV) {
-    return getMaxAV(player, game);
+    return getMaxAV(player, game || ({} as Game));
   } else if (carac === PLAYER_CARAC.ST) {
-    return getMaxST(player, game);
+    return getMaxST(player, game || ({} as Game));
+  } else if (carac === PLAYER_CARAC.PA) {
+    return getMaxPA(player, game);
   }
   return -1;
 }
 
 function getMaxCommun(player: Player, carac: PLAYER_CARAC, _game: Game) {
-  let c = player[carac];
+  let c: number | null | undefined = player[carac];
+  if (c == null) {
+    return 0;
+  }
   if (!player.tempCarac) {
     return c;
   }
@@ -137,29 +161,25 @@ function getMaxCommun(player: Player, carac: PLAYER_CARAC, _game: Game) {
   return c;
 }
 
-function getLimitedValue(c: number) {
-  if (c > 10) {
-    c = 10;
-  }
-  if (c < 0) {
-    c = 0;
-  }
-  return c;
-}
-
 function getMaxAV(player: Player, game: 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: Player, game: 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: Player, game: 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: Player, game: Game) {
@@ -170,8 +190,57 @@ function getMaxMA(player: Player, game: Game) {
       c = maxMA;
     }
   }
+  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;
+}
 
-  return getLimitedValue(c);
+function clampPA(c: number): number {
+  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: Player, game?: 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 || ({} as Game));
+    return clampPA(c);
+  }
+
+  // Sinon, déterminer la valeur selon la version de la career
+  const career = getCareerFromPlayer(player);
+  if (!career) {
+    // Fallback: utiliser AG si pas de career
+    return getMaxAG(player, game || ({} as Game));
+  }
+
+  // Si c'est une career 2025, utiliser career.PA
+  if (career.version === 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 as any).gainCarac === PLAYER_CARAC.PA) {
+          c += 1;
+        }
+        if ((value as any).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 || ({} as Game));
 }
 
 function getMaxGfi(player: PlayerWithSkill) {
@@ -219,15 +288,26 @@ function getAgingBonus(player: Player, totalGames: number) {
   return bonus;
 }
 
-function BB2020Carac(value: number, carac: PLAYER_CARAC) {
+function BB2020Carac(
+  value: number,
+  carac: PLAYER_CARAC,
+  careerVersion?: CAREER_VERSION
+) {
   //   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;
     if (value === 2) newValue = 5;
@@ -250,6 +330,8 @@ export {
   areFromSameTeam,
   arePlayingSameGame,
   BB2020Carac,
+  CARAC_MAX,
+  CARAC_MIN,
   gamesforAgingRoll,
   getAgingBonus,
   getCareerBaseCarac,
@@ -260,6 +342,7 @@ export {
   getMaxCommun,
   getMaxGfi,
   getMaxMA,
+  getMaxPA,
   getMaxST,
   hasMove,
   hasTeam,

package/position.ts

@@ -19,6 +19,22 @@ export const isAdjacent = (p1: Point, p2: Point): boolean => {
   );
 };
 
+/**
+ * Returns all 8 adjacent squares around a given position
+ */
+export const getAllAdjacentSquares = (x: number, y: number): Point[] => {
+  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 },
+  ];
+};
+
 export const getEnemyTackleZones = (
   location: Point,
   teamId: string,