enefel 2.0.7 → 2.1.0

package/calcul.ts

@@ -1,13 +1,20 @@
 import { Point } from "types/models";
 
 export const distance = (p1: Point, p2: Point): number => {
+  if (p1.x === null || p1.y === null || p2.x === null || p2.y === null) {
+    return Infinity;
+  }
   return Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2));
 };
 
+// Est ce que distance est inférieure ou égale à distance
 export const distanceSquares = (
   p1: Point,
   p2: Point,
   distance: number
 ): boolean => {
+  if (p1.x === null || p1.y === null || p2.x === null || p2.y === null) {
+    return false;
+  }
   return Math.abs(p1.x - p2.x) <= distance && Math.abs(p1.y - p2.y) <= distance;
 };

package/canUseSkills.ts

@@ -3,11 +3,11 @@ import { SKILL_NAMES, hasSkill } from "./skill";
 import { hasStatusFall, hasStatusTacleZone } from "./status";
 import { PlayerWithSkill } from "./types/models";
 
-function canUseFend(
+export const canUseFend = (
   playerFrom: PlayerWithSkill,
   playerTo: PlayerWithSkill,
   isBlitz: boolean
-) {
+) => {
   if (!hasSkill(playerTo, SKILL_NAMES.FEND)) {
     return false;
   }
@@ -15,13 +15,13 @@ function canUseFend(
     return false;
   }
   return true;
-}
+};
 
-function canUseStandFirm(
-  playerFrom: PlayerWithSkill,
-  playerTo: PlayerWithSkill,
-  isBlitz: boolean
-) {
+export const canUseStandFirm = (
+  playerFrom: PlayerWithSkill | null,
+  playerTo: PlayerWithSkill | null,
+  isBlitz?: boolean
+) => {
   if (playerTo && !hasSkill(playerTo, SKILL_NAMES.STAND_FIRM)) {
     return false;
   }
@@ -29,13 +29,13 @@ function canUseStandFirm(
     return false;
   }
   return true;
-}
+};
 
-function canUseStandWrestle(
+export const canUseStandWrestle = (
   playerFrom: PlayerWithSkill,
   playerTo: PlayerWithSkill,
   isBlitz: boolean
-) {
+) => {
   if (hasSkill(playerFrom, SKILL_NAMES.JUGGERNAUT) && isBlitz) {
     return false;
   }
@@ -46,12 +46,12 @@ function canUseStandWrestle(
     return true;
   }
   return false;
-}
+};
 
-function canUsePileDriver(
+export const canUsePileDriver = (
   playerFrom: PlayerWithSkill,
   playerTo: PlayerWithSkill
-) {
+) => {
   if (
     hasSkill(playerFrom, SKILL_NAMES.PILE_DRIVER) &&
     hasStatusTacleZone(playerFrom) &&
@@ -61,6 +61,4 @@ function canUsePileDriver(
     return true;
   }
   return false;
-}
-
-export { canUseFend, canUsePileDriver, canUseStandFirm, canUseStandWrestle };
+};

package/dist/calcul.js

@@ -2,10 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.distanceSquares = exports.distance = void 0;
 const distance = (p1, p2) => {
+    if (p1.x === null || p1.y === null || p2.x === null || p2.y === null) {
+        return Infinity;
+    }
     return Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2));
 };
 exports.distance = distance;
+// Est ce que distance est inférieure ou égale à distance
 const distanceSquares = (p1, p2, distance) => {
+    if (p1.x === null || p1.y === null || p2.x === null || p2.y === null) {
+        return false;
+    }
     return Math.abs(p1.x - p2.x) <= distance && Math.abs(p1.y - p2.y) <= distance;
 };
 exports.distanceSquares = distanceSquares;

package/dist/canUseSkills.d.ts

@@ -1,6 +1,5 @@
 import { PlayerWithSkill } from "./types/models";
-declare function canUseFend(playerFrom: PlayerWithSkill, playerTo: PlayerWithSkill, isBlitz: boolean): boolean;
-declare function canUseStandFirm(playerFrom: PlayerWithSkill, playerTo: PlayerWithSkill, isBlitz: boolean): boolean;
-declare function canUseStandWrestle(playerFrom: PlayerWithSkill, playerTo: PlayerWithSkill, isBlitz: boolean): boolean;
-declare function canUsePileDriver(playerFrom: PlayerWithSkill, playerTo: PlayerWithSkill): boolean;
-export { canUseFend, canUsePileDriver, canUseStandFirm, canUseStandWrestle };
+export declare const canUseFend: (playerFrom: PlayerWithSkill, playerTo: PlayerWithSkill, isBlitz: boolean) => boolean;
+export declare const canUseStandFirm: (playerFrom: PlayerWithSkill | null, playerTo: PlayerWithSkill | null, isBlitz?: boolean) => boolean;
+export declare const canUseStandWrestle: (playerFrom: PlayerWithSkill, playerTo: PlayerWithSkill, isBlitz: boolean) => boolean;
+export declare const canUsePileDriver: (playerFrom: PlayerWithSkill, playerTo: PlayerWithSkill) => boolean;

package/dist/canUseSkills.js

@@ -1,13 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.canUseFend = canUseFend;
-exports.canUsePileDriver = canUsePileDriver;
-exports.canUseStandFirm = canUseStandFirm;
-exports.canUseStandWrestle = canUseStandWrestle;
+exports.canUsePileDriver = exports.canUseStandWrestle = exports.canUseStandFirm = exports.canUseFend = void 0;
 const position_1 = require("./position");
 const skill_1 = require("./skill");
 const status_1 = require("./status");
-function canUseFend(playerFrom, playerTo, isBlitz) {
+const canUseFend = (playerFrom, playerTo, isBlitz) => {
     if (!(0, skill_1.hasSkill)(playerTo, skill_1.SKILL_NAMES.FEND)) {
         return false;
     }
@@ -15,8 +12,9 @@ function canUseFend(playerFrom, playerTo, isBlitz) {
         return false;
     }
     return true;
-}
-function canUseStandFirm(playerFrom, playerTo, isBlitz) {
+};
+exports.canUseFend = canUseFend;
+const canUseStandFirm = (playerFrom, playerTo, isBlitz) => {
     if (playerTo && !(0, skill_1.hasSkill)(playerTo, skill_1.SKILL_NAMES.STAND_FIRM)) {
         return false;
     }
@@ -24,8 +22,9 @@ function canUseStandFirm(playerFrom, playerTo, isBlitz) {
         return false;
     }
     return true;
-}
-function canUseStandWrestle(playerFrom, playerTo, isBlitz) {
+};
+exports.canUseStandFirm = canUseStandFirm;
+const canUseStandWrestle = (playerFrom, playerTo, isBlitz) => {
     if ((0, skill_1.hasSkill)(playerFrom, skill_1.SKILL_NAMES.JUGGERNAUT) && isBlitz) {
         return false;
     }
@@ -34,8 +33,9 @@ function canUseStandWrestle(playerFrom, playerTo, isBlitz) {
         return true;
     }
     return false;
-}
-function canUsePileDriver(playerFrom, playerTo) {
+};
+exports.canUseStandWrestle = canUseStandWrestle;
+const canUsePileDriver = (playerFrom, playerTo) => {
     if ((0, skill_1.hasSkill)(playerFrom, skill_1.SKILL_NAMES.PILE_DRIVER) &&
         (0, status_1.hasStatusTacleZone)(playerFrom) &&
         (0, status_1.hasStatusFall)(playerTo) &&
@@ -43,4 +43,5 @@ function canUsePileDriver(playerFrom, playerTo) {
         return true;
     }
     return false;
-}
+};
+exports.canUsePileDriver = canUsePileDriver;

package/dist/index.d.ts

@@ -195,17 +195,17 @@ declare const PLAYER_HISTORY_INFO: {
     EXP_KO: string;
     EXP_TD: string;
 };
-declare const TAKE_BALL_TYPE: {
-    CATCH_PASS: string;
-    CATCH_HANDOFF: string;
-    PICKUP: string;
-    CATCH_BOUNCE: string;
-};
-declare const p: (x: number, y: number) => Point;
+declare enum TAKE_BALL_TYPE {
+    CATCH_PASS = "pass",// Reception passe
+    CATCH_HANDOFF = "hand-off",// Reception d'une Transmission
+    PICKUP = "pick-up",// Ramasse la balle au sol
+    CATCH_BOUNCE = "bounce"
+}
+declare const p: (x: number | string, y: number | string) => Point;
 declare function addSeconds(date: Date, days: number): Date;
-declare const isSquareValidToPushBack: (availableSquares: Point[], targetIndex: number, players: Player[], w: number, h: number, busy?: Point[]) => boolean;
-declare const getPlayerOnCell: (x: number, y: number, players: Player[]) => Player | undefined;
-declare const getHypnoticGazeMalus: (player: Player, target: Player, players: Player[]) => number;
+declare const isSquareValidToPushBack: (availableSquares: Point[], targetIndex: number, players: Record<string, PlayerWithSkill>, w: number, h: number, busy?: Point[]) => boolean;
+declare const getPlayerOnCell: (x: number | null, y: number | null, players: Record<string, PlayerWithSkill>) => false | PlayerWithSkill | undefined;
+declare const getHypnoticGazeMalus: (player: Player, target: Player, players: Record<string, Player>) => number;
 declare const getBlockAssistance: (attackerPlayer: PlayerWithSkill, defenderPlayer: PlayerWithSkill, players: PlayerWithSkill[], isAttacker?: boolean) => PlayerWithSkill[];
 declare const getDicesBlock: (attackerStrength: number, defenderStrength: number) => 2 | 1 | 3;
 declare const haveSameTeam: (p1: Player, p2: Player) => boolean;
@@ -219,7 +219,7 @@ declare const isOnLine: (A: Point, B: Point, C: Point) => boolean;
 declare const getThrowingBonus: (p1: Point, p2: Point, game: Game) => 0 | 1 | -1 | -2 | null;
 declare const isOnField: (x: number, y: number, w: number, h: number) => boolean;
 declare const canPlayerIntercepts: (playerFrom: PlayerWithSkill, player: PlayerWithSkill, pointTo: Point) => boolean;
-declare const getBestInterceptor: (playerFrom: PlayerWithSkill, pointTo: Point, players: PlayerWithSkill[]) => null;
+declare const getBestInterceptor: (playerFrom: PlayerWithSkill, pointTo: Point, players: PlayerWithSkill[]) => PlayerWithSkill | null;
 declare function canBlock(attacker: PlayerWithSkill, defender: PlayerWithSkill, attackerTeam: Team, game: Game, withModif?: boolean, checkBlitz?: boolean): boolean;
 declare function canFoul(attacker: PlayerWithSkill, defender: PlayerWithSkill, attackerTeam: Team): boolean;
 declare function canPass(player: PlayerWithSkill, playerTeam: Team, playerIdWithBall: string): boolean;

package/dist/index.js

@@ -233,13 +233,13 @@ const PLAYER_HISTORY_INFO = {
     EXP_TD: "etd",
 };
 exports.PLAYER_HISTORY_INFO = PLAYER_HISTORY_INFO;
-const TAKE_BALL_TYPE = {
-    CATCH_PASS: "pass", // Reception passe
-    CATCH_HANDOFF: "hand-off", // Reception d'une Transmission
-    PICKUP: "pick-up", // Ramasse la balle au sol
-    CATCH_BOUNCE: "bounce", // Reception d'un rebond
-};
-exports.TAKE_BALL_TYPE = TAKE_BALL_TYPE;
+var TAKE_BALL_TYPE;
+(function (TAKE_BALL_TYPE) {
+    TAKE_BALL_TYPE["CATCH_PASS"] = "pass";
+    TAKE_BALL_TYPE["CATCH_HANDOFF"] = "hand-off";
+    TAKE_BALL_TYPE["PICKUP"] = "pick-up";
+    TAKE_BALL_TYPE["CATCH_BOUNCE"] = "bounce";
+})(TAKE_BALL_TYPE || (exports.TAKE_BALL_TYPE = TAKE_BALL_TYPE = {}));
 const p = (x, y) => {
     return { x: +x, y: +y };
 };
@@ -250,7 +250,9 @@ function addSeconds(date, days) {
     return result;
 }
 const isSquareValidToPushBack = (availableSquares, targetIndex, players, w, h, busy = []) => {
-    if (!availableSquares[targetIndex]) {
+    if (!availableSquares[targetIndex] ||
+        availableSquares[targetIndex].x === null ||
+        availableSquares[targetIndex].y === null) {
         return false;
     }
     const player = getPlayerOnCell(availableSquares[targetIndex].x, availableSquares[targetIndex].y, players);
@@ -263,6 +265,9 @@ const isSquareValidToPushBack = (availableSquares, targetIndex, players, w, h, b
     }
     // All the spaces are full, we can't push back
     const noEmptySquares = availableSquares.every((point) => {
+        if (point.x === null || point.y === null) {
+            return false;
+        }
         return (getPlayerOnCell(point.x, point.y, players) ||
             busy.some((b) => b.x === point.x && b.y === point.y) ||
             !isOnField(point.x, point.y, w, h));
@@ -271,6 +276,9 @@ const isSquareValidToPushBack = (availableSquares, targetIndex, players, w, h, b
 };
 exports.isSquareValidToPushBack = isSquareValidToPushBack;
 const getPlayerOnCell = (x, y, players) => {
+    if (x === null || y === null) {
+        return false;
+    }
     return Object.values(players).find((player) => player.x === x && player.y === y && (0, status_1.hasStatusOnField)(player));
 };
 exports.getPlayerOnCell = getPlayerOnCell;
@@ -364,7 +372,11 @@ const isSamePlayer = (p1, p2) => {
 };
 exports.isSamePlayer = isSamePlayer;
 const availableSquaresToPushBack = (p1, p2) => {
-    if (!(0, position_1.isAdjacent)(p1, p2)) {
+    if (!(0, position_1.isAdjacent)(p1, p2) ||
+        p1.x === null ||
+        p1.y === null ||
+        p2.x === null ||
+        p2.y === null) {
         return [];
     }
     const xFrom = p1.x;
@@ -543,14 +555,20 @@ const isOnLine = (A, B, C) => {
 };
 exports.isOnLine = isOnLine;
 const getThrowingBonus = (p1, p2, game) => {
-    if (!(Number.isInteger(p1.x) &&
-        Number.isInteger(p1.y) &&
-        Number.isInteger(p2.x) &&
-        Number.isInteger(p2.y) &&
-        p1.x >= 0 &&
-        p1.y >= 0 &&
-        p2.x >= 0 &&
-        p2.y >= 0)) {
+    if (!p1 ||
+        !p2 ||
+        p1.x === null ||
+        p1.y === null ||
+        p2.x === null ||
+        p2.y === null ||
+        !(Number.isInteger(p1.x) &&
+            Number.isInteger(p1.y) &&
+            Number.isInteger(p2.x) &&
+            Number.isInteger(p2.y) &&
+            p1.x >= 0 &&
+            p1.y >= 0 &&
+            p2.x >= 0 &&
+            p2.y >= 0)) {
         return null;
     }
     var dist = (0, calcul_1.distance)(p1, p2);

package/dist/package-lock.json

@@ -1,12 +1,12 @@
 {
     "name": "enefel",
-    "version": "2.0.7",
+    "version": "2.1.0",
     "lockfileVersion": 2,
     "requires": true,
     "packages": {
         "": {
             "name": "enefel",
-            "version": "2.0.7",
+            "version": "2.1.0",
             "license": "MIT",
             "dependencies": {
                 "seedrandom": "3.0.5",

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "enefel",
-    "version": "2.0.7",
+    "version": "2.1.0",
     "description": "Blood Bowl 3 game engine",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",

package/dist/pitch.d.ts

@@ -21,7 +21,7 @@ declare function getTdTile(teamNumber: number): TILES.TD1 | TILES.TD2;
 declare function getCenterTile(teamNumber: number): TILES.CENTRE1 | TILES.CENTRE2;
 declare function getTile(game: Game, x: number, y: number): string;
 declare function getIndexFromXY(x: number, y: number, width: number): number;
-declare function getHalfStadium(side: number, width: number): import("types/models").Point;
+declare function getHalfStadium(side: 1 | 2, width: number): import("types/models").Point;
 declare function getNumberPlayerZone(teamNumber: number, players: Player[], game: Game): {
     playerScrimmage: number;
     playerLateralA: number;

package/dist/position.d.ts

@@ -1,4 +1,3 @@
 import { PlayerWithSkill, Point } from "./types/models";
-declare const isAdjacent: (p1: Point, p2: Point) => boolean;
-declare function getEnemyTackleZones(location: Point, teamId: string, players: Record<string, PlayerWithSkill>): PlayerWithSkill[];
-export { getEnemyTackleZones, isAdjacent };
+export declare const isAdjacent: (p1: Point, p2: Point) => boolean;
+export declare const getEnemyTackleZones: (location: Point, teamId: string, players: Record<string, PlayerWithSkill>) => PlayerWithSkill[];

package/dist/position.js

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isAdjacent = void 0;
-exports.getEnemyTackleZones = getEnemyTackleZones;
+exports.getEnemyTackleZones = exports.isAdjacent = void 0;
 const status_1 = require("./status");
 const isAdjacent = (p1, p2) => {
-    if (!p1 || !p2) {
+    if (!p1 || !p2 || !p1.x || !p1.y || !p2.x || !p2.y) {
         return false;
     }
     return ((p1.x !== p2.x || p1.y !== p2.y) &&
@@ -12,12 +11,13 @@ const isAdjacent = (p1, p2) => {
         Math.abs(p1.y - p2.y) <= 1);
 };
 exports.isAdjacent = isAdjacent;
-function getEnemyTackleZones(location, teamId, players) {
+const getEnemyTackleZones = (location, teamId, players) => {
     // player a un format : { id1: {player1}, id2:{player2} etc...}
     return Object.values(players).filter((player) => {
         const res = (0, status_1.hasStatusTacleZone)(player) &&
             player.teamId !== teamId &&
-            isAdjacent(player, location);
+            (0, exports.isAdjacent)(player, location);
         return res;
     });
-}
+};
+exports.getEnemyTackleZones = getEnemyTackleZones;

package/dist/stadium.d.ts

@@ -55,44 +55,13 @@ declare const getTeamStadium: (team: Team, size: STADIUM_SIZE) => {
     height: number | undefined;
     width: number | undefined;
 };
-declare const TILES_STADIUM: {
-    a: {
-        y: number;
-        price: number;
-        wear: number;
-        icons: number[];
-    };
-    b: {
-        y: number;
-        price: number;
-        wear: number;
-        icons: number[];
-    };
-    c: {
-        y: number;
-        price: number;
-        wear: number;
-        icons: number[];
-    };
-    d: {
-        y: number;
-        price: number;
-        wear: number;
-        icons: number[];
-    };
-    e: {
-        y: number;
-        price: number;
-        wear: number;
-        icons: number[];
-    };
-    f: {
-        y: number;
-        price: number;
-        wear: number;
-        icons: number[];
-    };
+export type TileStadium = {
+    y: number;
+    price: number;
+    wear: number;
+    icons: number[];
 };
+declare const TILES_STADIUM: Record<string, TileStadium>;
 declare const minWidth = 20;
 declare const maxWidth = 26;
 declare const minHeight = 11;

package/dist/status.d.ts

@@ -1,20 +1,19 @@
 import { Player } from "types/models";
-declare const PLAYER_STATUS: {
-    STANDING: number;
-    KNOCKED_DOWN: number;
-    STUNNED: number;
-    RESERVE: number;
-    KO: number;
-    CASUALTY: number;
-    SENDOFF: number;
-    BONE_HEAD: number;
-};
-declare const hasStatusCanFaceup: (player: Player) => boolean;
-declare const hasStatusCanStandup: (player: Player) => boolean;
-declare const hasStatusTacleZone: (player: Player) => boolean;
-declare const hasStatusStanding: (player: Player) => boolean;
-declare const hasStatusInjury: (player: Player) => boolean;
-declare const hasStatusFall: (player: Player) => boolean;
-declare const hasStatusOnField: (player: Player) => boolean;
-declare const hasStatusCantPlay: (player: Player) => boolean;
-export { hasStatusCanFaceup, hasStatusCanStandup, hasStatusCantPlay, hasStatusFall, hasStatusInjury, hasStatusOnField, hasStatusStanding, hasStatusTacleZone, PLAYER_STATUS, };
+export declare enum PLAYER_STATUS {
+    STANDING = 0,
+    KNOCKED_DOWN = 1,// Sur le dos
+    STUNNED = 2,// Sur le ventre
+    RESERVE = 3,// Dans la réserve
+    KO = 4,
+    CASUALTY = 5,// Blessé
+    SENDOFF = 6,// Expulsé
+    BONE_HEAD = 7
+}
+export declare const hasStatusCanFaceup: (player: Player) => boolean;
+export declare const hasStatusCanStandup: (player: Player) => boolean;
+export declare const hasStatusTacleZone: (player: Player) => boolean;
+export declare const hasStatusStanding: (player: Player) => boolean;
+export declare const hasStatusInjury: (player: Player) => boolean;
+export declare const hasStatusFall: (player: Player) => boolean;
+export declare const hasStatusOnField: (player: Player) => boolean;
+export declare const hasStatusCantPlay: (player: Player) => boolean;

package/dist/status.js

@@ -1,18 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PLAYER_STATUS = exports.hasStatusTacleZone = exports.hasStatusStanding = exports.hasStatusOnField = exports.hasStatusInjury = exports.hasStatusFall = exports.hasStatusCantPlay = exports.hasStatusCanStandup = exports.hasStatusCanFaceup = void 0;
-const PLAYER_STATUS = {
-    STANDING: 0,
-    KNOCKED_DOWN: 1, // Sur le dos
-    STUNNED: 2, // Sur le ventre
-    RESERVE: 3, // Dans la réserve
-    KO: 4,
-    CASUALTY: 5, // Blessé
+exports.hasStatusCantPlay = exports.hasStatusOnField = exports.hasStatusFall = exports.hasStatusInjury = exports.hasStatusStanding = exports.hasStatusTacleZone = exports.hasStatusCanStandup = exports.hasStatusCanFaceup = exports.PLAYER_STATUS = void 0;
+var PLAYER_STATUS;
+(function (PLAYER_STATUS) {
+    PLAYER_STATUS[PLAYER_STATUS["STANDING"] = 0] = "STANDING";
+    PLAYER_STATUS[PLAYER_STATUS["KNOCKED_DOWN"] = 1] = "KNOCKED_DOWN";
+    PLAYER_STATUS[PLAYER_STATUS["STUNNED"] = 2] = "STUNNED";
+    PLAYER_STATUS[PLAYER_STATUS["RESERVE"] = 3] = "RESERVE";
+    PLAYER_STATUS[PLAYER_STATUS["KO"] = 4] = "KO";
+    PLAYER_STATUS[PLAYER_STATUS["CASUALTY"] = 5] = "CASUALTY";
     // For other casuality (death), update all playerTo.status === PLAYER_STATUS.CASUALTY
-    SENDOFF: 6, // Expulsé
-    BONE_HEAD: 7, // Plus de zdt
-};
-exports.PLAYER_STATUS = PLAYER_STATUS;
+    PLAYER_STATUS[PLAYER_STATUS["SENDOFF"] = 6] = "SENDOFF";
+    PLAYER_STATUS[PLAYER_STATUS["BONE_HEAD"] = 7] = "BONE_HEAD";
+})(PLAYER_STATUS || (exports.PLAYER_STATUS = PLAYER_STATUS = {}));
 const hasStatusCanFaceup = (player) => {
     return player.status === PLAYER_STATUS.STUNNED;
 };
@@ -42,7 +42,7 @@ const hasStatusFall = (player) => {
 };
 exports.hasStatusFall = hasStatusFall;
 const hasStatusOnField = (player) => {
-    return hasStatusStanding(player) || hasStatusFall(player);
+    return (0, exports.hasStatusStanding)(player) || (0, exports.hasStatusFall)(player);
 };
 exports.hasStatusOnField = hasStatusOnField;
 const hasStatusCantPlay = (player) => {

package/dist/types/models.d.ts

@@ -1,6 +1,6 @@
 export interface Point {
-    x: number;
-    y: number;
+    x: number | null;
+    y: number | null;
 }
 export interface Inducement {
     key: string;
@@ -30,11 +30,11 @@ export interface Team {
     coach_id: string;
     league_id: string;
     game_id: string;
-    date_next_transmission: Date;
-    date_next_pass: Date;
-    date_next_foul: Date;
-    date_next_blitz: Date;
-    date_next_reroll: Date;
+    date_next_transmission: Date | null;
+    date_next_pass: Date | null;
+    date_next_foul: Date | null;
+    date_next_blitz: Date | null;
+    date_next_reroll: Date | null;
     color1: string;
     color2: string;
     isOpen: boolean;
@@ -57,7 +57,7 @@ export interface Team {
     stadium_state_l: string;
     players: PlayerWithSkill[];
 }
-export interface Player {
+export interface Player extends Point {
     id: string;
     order: number;
     name: string;
@@ -72,8 +72,6 @@ export interface Player {
     active: string;
     experience: number;
     experienceCoach: number;
-    x: number;
-    y: number;
     MA: number;
     ST: number;
     AG: number;
@@ -83,8 +81,8 @@ export interface Player {
     current_AG: number;
     current_AV: number;
     current_gfi: number;
-    date_next_action: Date;
-    date_next_block: Date;
+    date_next_action: Date | null;
+    date_next_block: Date | null;
     date_last_gfi: Date;
     date_last_move: Date;
     teamId: string;
@@ -93,7 +91,7 @@ export interface Player {
     icon_id: string;
     state: number;
     ni: number;
-    date_next_standup: Date;
+    date_next_standup: Date | null;
     can_auto_standup: boolean;
     reroll_counter: number;
     can_reroll: boolean;
@@ -109,10 +107,18 @@ export interface Player {
     quote: string;
     speak: string;
     raz: boolean;
-    last_injury: string;
+    last_injury: string | null;
     can_jump: boolean;
     isCoach: boolean;
     avatarDefault: string;
+    improvements: number[];
+    changed: any;
+    previous: any;
+    hadRegen: boolean;
+    checkByReferee: boolean;
+    prevX: number | null;
+    prevY: number | null;
+    hasEndTurn: boolean;
 }
 export interface PlayerWithSkill extends Player {
     skills: PlayerSkill[];
@@ -128,9 +134,9 @@ export interface Game {
     fan2: number;
     reroll1: number;
     reroll2: number;
-    ball_x: number;
-    ball_y: number;
-    ball_player_id: string;
+    ball_x: number | null;
+    ball_y: number | null;
+    ball_player_id: string | null;
     status: number;
     date_start: Date;
     date_kickoff: Date;

package/index.ts

@@ -222,14 +222,14 @@ const PLAYER_HISTORY_INFO = {
   EXP_TD: "etd",
 };
 
-const TAKE_BALL_TYPE = {
-  CATCH_PASS: "pass", // Reception passe
-  CATCH_HANDOFF: "hand-off", // Reception d'une Transmission
-  PICKUP: "pick-up", // Ramasse la balle au sol
-  CATCH_BOUNCE: "bounce", // Reception d'un rebond
-};
+enum TAKE_BALL_TYPE {
+  CATCH_PASS = "pass", // Reception passe
+  CATCH_HANDOFF = "hand-off", // Reception d'une Transmission
+  PICKUP = "pick-up", // Ramasse la balle au sol
+  CATCH_BOUNCE = "bounce", // Reception d'un rebond
+}
 
-const p = (x: number, y: number): Point => {
+const p = (x: number | string, y: number | string): Point => {
   return { x: +x, y: +y };
 };
 
@@ -242,12 +242,16 @@ function addSeconds(date: Date, days: number) {
 const isSquareValidToPushBack = (
   availableSquares: Point[],
   targetIndex: number,
-  players: Player[],
+  players: Record<string, PlayerWithSkill>,
   w: number,
   h: number,
   busy: Point[] = []
 ) => {
-  if (!availableSquares[targetIndex]) {
+  if (
+    !availableSquares[targetIndex] ||
+    availableSquares[targetIndex].x === null ||
+    availableSquares[targetIndex].y === null
+  ) {
     return false;
   }
   const player = getPlayerOnCell(
@@ -272,6 +276,9 @@ const isSquareValidToPushBack = (
   }
   // All the spaces are full, we can't push back
   const noEmptySquares = availableSquares.every((point) => {
+    if (point.x === null || point.y === null) {
+      return false;
+    }
     return (
       getPlayerOnCell(point.x, point.y, players) ||
       busy.some((b: Point) => b.x === point.x && b.y === point.y) ||
@@ -281,7 +288,14 @@ const isSquareValidToPushBack = (
   return noEmptySquares;
 };
 
-const getPlayerOnCell = (x: number, y: number, players: Player[]) => {
+const getPlayerOnCell = (
+  x: number | null,
+  y: number | null,
+  players: Record<string, PlayerWithSkill>
+) => {
+  if (x === null || y === null) {
+    return false;
+  }
   return Object.values(players).find(
     (player) => player.x === x && player.y === y && hasStatusOnField(player)
   );
@@ -290,7 +304,7 @@ const getPlayerOnCell = (x: number, y: number, players: Player[]) => {
 const getHypnoticGazeMalus = (
   player: Player,
   target: Player,
-  players: Player[]
+  players: Record<string, Player>
 ) => {
   const adjacentEnemyPlayers = Object.values(players).filter((p) => {
     return (
@@ -401,7 +415,13 @@ const isSamePlayer = (p1: Player, p2: Player) => {
 };
 
 const availableSquaresToPushBack = (p1: Point, p2: Point) => {
-  if (!isAdjacent(p1, p2)) {
+  if (
+    !isAdjacent(p1, p2) ||
+    p1.x === null ||
+    p1.y === null ||
+    p2.x === null ||
+    p2.y === null
+  ) {
     return [];
   }
   const xFrom = p1.x;
@@ -584,6 +604,12 @@ const isOnLine = (A: Point, B: Point, C: Point) => {
 
 const getThrowingBonus = (p1: Point, p2: Point, game: Game) => {
   if (
+    !p1 ||
+    !p2 ||
+    p1.x === null ||
+    p1.y === null ||
+    p2.x === null ||
+    p2.y === null ||
     !(
       Number.isInteger(p1.x) &&
       Number.isInteger(p1.y) &&
@@ -662,7 +688,7 @@ const getBestInterceptor = (
   playerFrom: PlayerWithSkill,
   pointTo: Point,
   players: PlayerWithSkill[]
-) => {
+): PlayerWithSkill | null => {
   const possiblePlayers = players.filter((foe) => {
     return canPlayerIntercepts(playerFrom, foe, pointTo);
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "enefel",
-  "version": "2.0.7",
+  "version": "2.1.0",
   "description": "Blood Bowl 3 game engine",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/pitch.ts

@@ -58,7 +58,7 @@ function getIndexFromXY(x: number, y: number, width: number) {
   return width * y + x;
 }
 
-function getHalfStadium(side: number, width: number) {
+function getHalfStadium(side: 1 | 2, width: number) {
   let offset = 0;
   if (width === 20) {
     offset = 3;

package/position.ts

@@ -1,8 +1,8 @@
 import { hasStatusTacleZone } from "./status";
 import { PlayerWithSkill, Point } from "./types/models";
 
-const isAdjacent = (p1: Point, p2: Point) => {
-  if (!p1 || !p2) {
+export const isAdjacent = (p1: Point, p2: Point): boolean => {
+  if (!p1 || !p2 || !p1.x || !p1.y || !p2.x || !p2.y) {
     return false;
   }
   return (
@@ -12,11 +12,11 @@ const isAdjacent = (p1: Point, p2: Point) => {
   );
 };
 
-function getEnemyTackleZones(
+export const getEnemyTackleZones = (
   location: Point,
   teamId: string,
   players: Record<string, PlayerWithSkill>
-) {
+): PlayerWithSkill[] => {
   // player a un format : { id1: {player1}, id2:{player2} etc...}
   return Object.values(players).filter((player) => {
     const res =
@@ -25,6 +25,4 @@ function getEnemyTackleZones(
       isAdjacent(player, location);
     return res;
   });
-}
-
-export { getEnemyTackleZones, isAdjacent };
+};

package/stadium.ts

@@ -130,7 +130,14 @@ const getTeamStadium = (team: Team, size: STADIUM_SIZE) => {
   }
 };
 
-const TILES_STADIUM = {
+export type TileStadium = {
+  y: number;
+  price: number;
+  wear: number;
+  icons: number[];
+};
+
+const TILES_STADIUM: Record<string, TileStadium> = {
   a: {
     y: 5,
     price: 0,

package/status.ts

@@ -1,70 +1,58 @@
 import { Player } from "types/models";
 
-const PLAYER_STATUS = {
-  STANDING: 0,
-  KNOCKED_DOWN: 1, // Sur le dos
-  STUNNED: 2, // Sur le ventre
-  RESERVE: 3, // Dans la réserve
-  KO: 4,
-  CASUALTY: 5, // Blessé
+export enum PLAYER_STATUS {
+  STANDING = 0,
+  KNOCKED_DOWN = 1, // Sur le dos
+  STUNNED = 2, // Sur le ventre
+  RESERVE = 3, // Dans la réserve
+  KO = 4,
+  CASUALTY = 5, // Blessé
   // For other casuality (death), update all playerTo.status === PLAYER_STATUS.CASUALTY
-  SENDOFF: 6, // Expulsé
-  BONE_HEAD: 7, // Plus de zdt
-};
+  SENDOFF = 6, // Expulsé
+  BONE_HEAD = 7, // Plus de zdt
+}
 
-const hasStatusCanFaceup = (player: Player) => {
+export const hasStatusCanFaceup = (player: Player) => {
   return player.status === PLAYER_STATUS.STUNNED;
 };
 
-const hasStatusCanStandup = (player: Player) => {
+export const hasStatusCanStandup = (player: Player) => {
   return player.status === PLAYER_STATUS.KNOCKED_DOWN;
 };
 
-const hasStatusTacleZone = (player: Player) => {
+export const hasStatusTacleZone = (player: Player) => {
   // BONE_HEAD doesn't have table zone
   return player.status === PLAYER_STATUS.STANDING;
 };
 
-const hasStatusStanding = (player: Player) => {
+export const hasStatusStanding = (player: Player) => {
   return (
     player.status === PLAYER_STATUS.STANDING ||
     player.status === PLAYER_STATUS.BONE_HEAD
   );
 };
 
-const hasStatusInjury = (player: Player) => {
+export const hasStatusInjury = (player: Player) => {
   return (
     player.status === PLAYER_STATUS.KO ||
     player.status === PLAYER_STATUS.CASUALTY
   );
 };
 
-const hasStatusFall = (player: Player) => {
+export const hasStatusFall = (player: Player) => {
   return (
     player.status === PLAYER_STATUS.KNOCKED_DOWN ||
     player.status === PLAYER_STATUS.STUNNED
   );
 };
 
-const hasStatusOnField = (player: Player) => {
+export const hasStatusOnField = (player: Player) => {
   return hasStatusStanding(player) || hasStatusFall(player);
 };
 
-const hasStatusCantPlay = (player: Player) => {
+export const hasStatusCantPlay = (player: Player) => {
   return (
     player.status === PLAYER_STATUS.SENDOFF ||
     player.status === PLAYER_STATUS.CASUALTY
   );
 };
-
-export {
-  hasStatusCanFaceup,
-  hasStatusCanStandup,
-  hasStatusCantPlay,
-  hasStatusFall,
-  hasStatusInjury,
-  hasStatusOnField,
-  hasStatusStanding,
-  hasStatusTacleZone,
-  PLAYER_STATUS,
-};

package/types/models.ts

@@ -1,6 +1,6 @@
 export interface Point {
-  x: number;
-  y: number;
+  x: number | null;
+  y: number | null;
 }
 
 export interface Inducement {
@@ -33,11 +33,11 @@ export interface Team {
   coach_id: string;
   league_id: string;
   game_id: string;
-  date_next_transmission: Date;
-  date_next_pass: Date;
-  date_next_foul: Date;
-  date_next_blitz: Date;
-  date_next_reroll: Date;
+  date_next_transmission: Date | null;
+  date_next_pass: Date | null;
+  date_next_foul: Date | null;
+  date_next_blitz: Date | null;
+  date_next_reroll: Date | null;
   color1: string;
   color2: string;
   isOpen: boolean;
@@ -61,7 +61,7 @@ export interface Team {
   players: PlayerWithSkill[];
 }
 
-export interface Player {
+export interface Player extends Point {
   id: string;
   order: number;
   name: string;
@@ -76,8 +76,6 @@ export interface Player {
   active: string;
   experience: number;
   experienceCoach: number;
-  x: number;
-  y: number;
   MA: number;
   ST: number;
   AG: number;
@@ -87,8 +85,8 @@ export interface Player {
   current_AG: number;
   current_AV: number;
   current_gfi: number;
-  date_next_action: Date;
-  date_next_block: Date;
+  date_next_action: Date | null;
+  date_next_block: Date | null;
   date_last_gfi: Date;
   date_last_move: Date;
   teamId: string;
@@ -97,7 +95,7 @@ export interface Player {
   icon_id: string;
   state: number;
   ni: number;
-  date_next_standup: Date;
+  date_next_standup: Date | null;
   can_auto_standup: boolean;
   reroll_counter: number;
   can_reroll: boolean;
@@ -113,10 +111,18 @@ export interface Player {
   quote: string;
   speak: string;
   raz: boolean;
-  last_injury: string;
+  last_injury: string | null;
   can_jump: boolean;
   isCoach: boolean; // add by resolver
   avatarDefault: string; // add by resolver
+  improvements: number[];
+  changed: any; // Game sequelize model
+  previous: any; // Game sequelize model
+  hadRegen: boolean; // add by Game
+  checkByReferee: boolean; // add by Game
+  prevX: number | null; // add by Game
+  prevY: number | null; // add by Game
+  hasEndTurn: boolean; // add by Game
 }
 
 export interface PlayerWithSkill extends Player {
@@ -134,9 +140,9 @@ export interface Game {
   fan2: number;
   reroll1: number;
   reroll2: number;
-  ball_x: number;
-  ball_y: number;
-  ball_player_id: string;
+  ball_x: number | null;
+  ball_y: number | null;
+  ball_player_id: string | null;
   status: number;
   date_start: Date;
   date_kickoff: Date;