enefel 1.2.8 → 2.0.0

package/dist/index.d.ts

@@ -0,0 +1,246 @@
+import { Game, Player, PlayerWithSkill, Point, Team } from "types/models";
+import { METEO } from "./meteo";
+import version from "./version";
+declare const POSTULATION_HOURS = 24;
+declare const INACTIVE_DAYS = 10;
+declare const MAX_PLAYER_USER = 2;
+declare const MAX_PLAYER_TEAM = 16;
+declare const LAST_SEASON_ALPHA = 2;
+declare const FORMATION_DEFAULT_NAME = "last-76a0754a5a5005e4a1";
+declare const PLAYER_STAT: {
+    BLITZ: string;
+    BLOCK_1D: string;
+    BLOCK_2D: string;
+    BLOCK_3D: string;
+    BLOCK_ARMOR_FAIL: string;
+    BLOCK_ARMOR_SUCCESS: string;
+    BLOCK_ASSISTANCE_ATTACK: string;
+    BLOCK_ASSISTANCE_DEFENSE: string;
+    BLOCK_M2D: string;
+    BLOCK_M3D: string;
+    BLOCK_RESULT_1: string;
+    BLOCK_RESULT_2: string;
+    BLOCK_RESULT_3: string;
+    BLOCK_RESULT_4: string;
+    BLOCK_RESULT_5: string;
+    CASUALTY_BADLY_HURT: string;
+    CASUALTY_DEAD: string;
+    CASUALTY_LASTING_INJURY: string;
+    CASUALTY_RECEIVE_BADLY_HURT: string;
+    CASUALTY_RECEIVE_DEAD_FULL_MOON: string;
+    CASUALTY_RECEIVE_DEAD: string;
+    CASUALTY_RECEIVE_LASTING_INJURY: string;
+    CASUALTY_RECEIVE_SERIOUS_INJURY: string;
+    CASUALTY_RECEIVE_SERIOUSLY_HURT: string;
+    CASUALTY_SERIOUS_INJURY: string;
+    CASUALTY_SERIOUSLY_HURT: string;
+    DODGE_FAIL: string;
+    DODGE_SUCCESS: string;
+    EXPERIENCE_COACH: string;
+    EXPERIENCE: string;
+    FACEUP: string;
+    FOUL_ASSISTANCE_ATTACK: string;
+    FOUL_ASSISTANCE_DEFENSE: string;
+    FOUL_FAIL: string;
+    FOUL_RECEIVE: string;
+    FOUL_SENDOFF: string;
+    FOUL_SUCCESS: string;
+    GAME_DRAW: string;
+    GAME_LOSS: string;
+    GAME_PLAYED: string;
+    GAME_VICTORY: string;
+    GAME: string;
+    GO_FOR_IT_1_FAIL: string;
+    GO_FOR_IT_1_SUCCESS: string;
+    HANDING_OFF_FAIL: string;
+    HANDING_OFF_SUCCESS: string;
+    INJURY_CASUALTY: string;
+    INJURY_KNOCKED_DOWN: string;
+    INJURY_KO: string;
+    INTERCEPTION_FAIL: string;
+    INTERCEPTION_SUCCESS: string;
+    JUMP_FAIL: string;
+    JUMP_SUCCESS: string;
+    MOVE: string;
+    PASS_COMPLETED: string;
+    PASS_FAIL: string;
+    PASS_FUMBLE: string;
+    PASS_INTERCEPTED: string;
+    PASS_NOT_COMPLETED: string;
+    PASS_PERFECT_COMPLETED: string;
+    PASS_PERFECT: string;
+    RECEIVE_ARMOR_FAIL: string;
+    RECEIVE_ARMOR_SUCCESS: string;
+    RECEIVE_BLITZ: string;
+    RECEIVE_BLOCK_1D: string;
+    RECEIVE_BLOCK_2D: string;
+    RECEIVE_BLOCK_3D: string;
+    RECEIVE_BLOCK_ARMOR_FAIL: string;
+    RECEIVE_BLOCK_ARMOR_SUCCESS: string;
+    RECEIVE_BLOCK_M2D: string;
+    RECEIVE_BLOCK_M3D: string;
+    RECEIVE_BLOCK_RESULT_1: string;
+    RECEIVE_BLOCK_RESULT_2: string;
+    RECEIVE_BLOCK_RESULT_3: string;
+    RECEIVE_BLOCK_RESULT_4: string;
+    RECEIVE_BLOCK_RESULT_5: string;
+    RECEIVE_INJURY_CASUALTY: string;
+    RECEIVE_INJURY_KNOCKED_DOWN: string;
+    RECEIVE_INJURY_KO: string;
+    REROLL: string;
+    STANDUP: string;
+    TAKE_BALL_FAIL: string;
+    TAKE_BALL_REBOND_FAIL: string;
+    TAKE_BALL_REBOND_SUCCESS: string;
+    TAKE_BALL_SUCCESS: string;
+    TD: string;
+    TURNOVER: string;
+};
+declare const GAME_HISTORY_TYPE: {
+    BLOCK: string;
+    END_TURN: string;
+    END: string;
+    FACEUP: string;
+    FOUL: string;
+    KICKOFF: string;
+    MOVE: string;
+    PASS: string;
+    SETUP: string;
+    SETUP_POSITION: string;
+    STANDUP: string;
+    START: string;
+    TRANSMISSION: string;
+    VOMIT: string;
+    EVENT: string;
+};
+declare const GAME_HISTORY_INFO: {
+    APO: string;
+    ARMOR: string;
+    BALL: string;
+    BLOCK: string;
+    BRIBE: string;
+    CARAC_CHANGE: string;
+    CASUALTY: string;
+    DODGE: string;
+    END_PO: string;
+    END_POP: string;
+    END_TURN: string;
+    EXP: string;
+    FOUL: string;
+    GO_FOR_IT: string;
+    HANDICAP: string;
+    HANDING_OFF: string;
+    INDUCEMENT_HALFLING_MASTER_CHEF: string;
+    INJURY: string;
+    INTERCEPTION: string;
+    JUMP_UP: string;
+    KICKOFF: string;
+    KO: string;
+    LANDING: string;
+    JUMP: string;
+    LEAP: string;
+    METEO: string;
+    MOVE: string;
+    PASS: string;
+    REJECTION: string;
+    REROLL_COACH: string;
+    REROLL_INITIAL: string;
+    REROLL_METEO: string;
+    REROLL_RACE_MALUS: string;
+    REROLL: string;
+    SCATTER: string;
+    SKILL_GAIN: string;
+    SKILL_LOSS: string;
+    SKILL: string;
+    SPY: string;
+    STANDUP: string;
+    START_FAN: string;
+    STATUS: string;
+    TAKE_BALL: string;
+    TD: string;
+    THREATENING: string;
+    THROW_TEAM_MATE: string;
+    TURNOVER: string;
+};
+declare const PLAYER_HISTORY_TYPE: {
+    AGING: string;
+    APOTHECARY: string;
+    COACH_SKILL: string;
+    CREATE_TEAM: string;
+    CREATED: string;
+    DEAD: string;
+    EXP: string;
+    INACTIVE: string;
+    JOIN_TEAM: string;
+    NEW_COACH: string;
+    NI: string;
+    POP: string;
+    QUIT_COACH: string;
+    QUIT_TEAM: string;
+    RAZ: string;
+    REDUCTION: string;
+    REMOVE_FROM_TEAM: string;
+    RETIRED_END: string;
+    RETIRED: string;
+    SKILL: string;
+};
+declare const PLAYER_HISTORY_INFO: {
+    EXP_ASSIST: string;
+    EXP_BONUS: string;
+    EXP_CAS: string;
+    EXP_COACH: string;
+    EXP_COMP: string;
+    EXP_FALL: string;
+    EXP_INT: string;
+    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 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 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;
+declare const isSamePlayer: (p1: Player, p2: Player) => boolean;
+declare const availableSquaresToPushBack: (p1: Point, p2: Point) => {
+    x: number;
+    y: number;
+    d: number;
+}[] | undefined;
+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 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;
+declare function canEndTurn(player: PlayerWithSkill, game: Game): boolean;
+declare function canThrowTeamMate(player: PlayerWithSkill, target: PlayerWithSkill, playerTeam: Team): boolean;
+declare function canMove(player: PlayerWithSkill, nbTile?: number): boolean;
+declare function canTransmit(player: PlayerWithSkill, target: PlayerWithSkill, playerTeam: Team, playerIdWithBall: string): boolean;
+declare function canStandup(player: Player): boolean;
+declare function canFaceUp(player: Player): boolean;
+declare function isGameRunning(game: Game): boolean;
+declare function isSetUp(game: Game): boolean;
+declare function getTeamColor(game: Game, side: number): string | null;
+declare const isCoach: (player: Player, team?: Team | null) => boolean | null;
+declare const getMoralModifier: (player: Player) => number;
+declare const getTeamXP: (team: Team) => number;
+declare const getTeamMoral: (team: Team) => number;
+declare const getTeamMoralByPlayer: (team: Team) => number;
+declare const getAttackerStrength: (player: PlayerWithSkill, isBlitz?: boolean, meteoValue?: METEO) => number;
+declare const getDefenderStrength: (player: PlayerWithSkill) => number;
+declare const arrayMove: (arr: any[], old_index: number, new_index: number) => any[];
+declare const swapArrayLocs: (arr: any[], index1: number, index2: number) => any[];
+declare const getInactiveDays: (isDev?: boolean) => 10 | 10000;
+declare const getMaxPlayers: (isDev?: boolean) => number;
+export { addSeconds, arrayMove, availableSquaresToPushBack, canBlock, canEndTurn, canFaceUp, canFoul, canMove, canPass, canPlayerIntercepts, canStandup, canThrowTeamMate, canTransmit, FORMATION_DEFAULT_NAME, GAME_HISTORY_INFO, GAME_HISTORY_TYPE, getAttackerStrength, getBestInterceptor, getBlockAssistance, getDefenderStrength, getDicesBlock, getHypnoticGazeMalus, getInactiveDays, getMaxPlayers, getMoralModifier, getPlayerOnCell, getTeamColor, getTeamMoral, getTeamMoralByPlayer, getTeamXP, getThrowingBonus, haveSameTeam, INACTIVE_DAYS, isCoach, isGameRunning, isOnField, isOnLine, isSamePlayer, isSetUp, isSquareValidToPushBack, LAST_SEASON_ALPHA, MAX_PLAYER_TEAM, MAX_PLAYER_USER, p, PLAYER_HISTORY_INFO, PLAYER_HISTORY_TYPE, PLAYER_STAT, POSTULATION_HOURS, swapArrayLocs, TAKE_BALL_TYPE, version, };

package/dist/inducement.d.ts

@@ -0,0 +1,8 @@
+import { Game, Inducement, Team } from "./types/models";
+declare const MAX_INDUCEMENT = 5;
+declare const INDUCEMENT: Record<string, Inducement>;
+declare const getInducements: (_team: Team, inducementList: string[]) => string | null;
+declare const getGameInducements: (game: Game) => [string | null, string[]];
+declare const hasInducement: (game: Game, currentTeamId: string, inducement: Inducement) => boolean;
+declare const burnInducement: (game: Game, inducementKey: string) => Game | undefined;
+export { burnInducement, getGameInducements, getInducements, hasInducement, INDUCEMENT, MAX_INDUCEMENT, };

package/dist/item.d.ts

@@ -0,0 +1,23 @@
+declare enum RARITY {
+    COMMUN = "c",
+    UNCOMMUN = "u",
+    RARE = "r",
+    EPIC = "e",
+    LEGENDARY = "l"
+}
+declare enum ITEM_ID {
+    BEER = "beer",
+    CHAINSAW = "chainsaw",
+    RUSTED_CHAINSAW = "rusted-chainsaw",
+    DRUG = "drug",
+    GREEN_PILL = "green-pill",
+    NEWSPAPER = "newspaper",
+    BOOSTER = "booster"
+}
+declare enum ITEM_TYPE {
+    CONSUMABLE = "consumable",
+    WEAPON = "weapon",
+    FILE = "file"
+}
+declare const getQteFromRarity: (rarity: RARITY) => 1 | 10 | 100 | 1000 | 10000 | undefined;
+export { getQteFromRarity, ITEM_ID, ITEM_TYPE, RARITY };

package/dist/league.d.ts

@@ -0,0 +1,33 @@
+import type { Team } from "./types/models";
+declare const MIN_OPEN_SIZE = 4;
+declare const GROUP_SIZE = 0;
+declare const HAS_NEXT_SEASON_PLAYOFF = false;
+declare const CAN_CHOOSE_TO_PARTICIPATE = false;
+declare const HOME_AND_AWAY = false;
+declare const NUMBER_TEAM_CHANGE = 2;
+interface Division {
+    name: string;
+    teams: Team[];
+}
+interface Season {
+    id: string;
+    truceDate: Date;
+    playoff: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+}
+declare const calculateTeamsStandingForPlayoff: (flatTeams: Team[], division: Division[]) => Team[];
+declare const calculateTeamsStandingForNextSeason: (division: Division[], currentSeason: Season) => Team[];
+declare const forcastNextSeason: (flatTeams: Team[]) => {
+    hasPlayoffs: boolean;
+    groups: Team[][];
+};
+declare const playoffNextSeason: (flatTeams: any[]) => {
+    hasPlayoffs: boolean;
+    groups: any[];
+};
+declare function round(r: number, teams: any[]): any[];
+declare function tournament(teams: any[]): any[];
+declare function hasCalendar(league: Division): boolean;
+declare function sortLeagues(a: Division, b: Division): number;
+export { calculateTeamsStandingForNextSeason, calculateTeamsStandingForPlayoff, CAN_CHOOSE_TO_PARTICIPATE, forcastNextSeason, GROUP_SIZE, HAS_NEXT_SEASON_PLAYOFF, hasCalendar, HOME_AND_AWAY, MIN_OPEN_SIZE, NUMBER_TEAM_CHANGE, playoffNextSeason, round, sortLeagues, tournament, };

package/dist/meteo.d.ts

@@ -0,0 +1,36 @@
+declare enum METEO {
+    AUTUMN_LEAF_STREWN_PITCH = 1,
+    AUTUMNAL_CHILL = 2,
+    POURING_RAIN = 3,
+    STRONG_WINDS = 4,
+    COLD_WINDS = 5,
+    FREEZING = 6,
+    PERFECT_CONDITION = 7,
+    HEAVY_SNOW = 8,
+    BLIZZARD = 9,
+    MORNING_DEW = 10,
+    BLOSSOMING_FLOWERS = 11,
+    MISTY_MORNING = 12,
+    HIGH_WINDS = 13
+}
+declare enum SEASON {
+    WINTER = 1,
+    SPRING = 2,
+    SUMMER = 3,
+    AUTUMN = 4
+}
+declare const getSeason: () => SEASON | null;
+declare const getMeteo: (value: number) => METEO;
+declare const meteoAttackerStrengthBlitz: (meteoValue: number) => number;
+declare const meteoPlayerFall: (meteoValue: number) => number;
+declare const meteoKO: (meteoValue: number) => number;
+declare const meteoPickUpBall: (meteoValue: number) => number;
+declare const meteoTakeBall: (meteoValue: number) => number;
+declare const meteoPassRebound: (meteoValue: number) => number;
+declare const meteoPassBonus: (meteoValue: number) => number;
+declare const meteoGfi: (meteoValue: number) => number;
+declare const meteoMaxPassDistance: (meteoValue: number) => number;
+declare const meteoHasExpulsion: (meteoValue: number) => boolean;
+declare const meteoMaxMA: (meteoValue: number) => number;
+declare const meteoRerollRoll: (meteoValue: number) => 2 | 1;
+export { getMeteo, getSeason, METEO, meteoAttackerStrengthBlitz, meteoGfi, meteoHasExpulsion, meteoKO, meteoMaxMA, meteoMaxPassDistance, meteoPassBonus, meteoPassRebound, meteoPickUpBall, meteoPlayerFall, meteoRerollRoll, meteoTakeBall, };

package/dist/moral.d.ts

@@ -0,0 +1,3 @@
+declare function getMalusFromMoral(moral: number): 0 | 5 | 20 | 15 | 10;
+declare function getColorFromMoral(moral: number): "#ff0000" | "#ff7b00" | "#ffcc00" | "#ffff00" | "#00FF00";
+export { getColorFromMoral, getMalusFromMoral };

package/dist/move.d.ts

@@ -0,0 +1,7 @@
+import { PlayerWithSkill, Point } from "./types/models";
+declare function bonusDodge(player: PlayerWithSkill, adjEnemies: PlayerWithSkill[], adjDestinationEnemies: PlayerWithSkill[]): number;
+declare function modifJumping(player: PlayerWithSkill, destination: Point, playerTeamId: string, players: Record<string, PlayerWithSkill>): {
+    modif: number;
+    enemies: PlayerWithSkill[];
+};
+export { bonusDodge, modifJumping };

package/dist/package.json

@@ -1,7 +1,7 @@
 {
     "name": "enefel",
-    "version": "1.2.8",
-    "description": "Blood Bowl 2 game engine",
+    "version": "2.0.0",
+    "description": "Blood Bowl 3 game engine",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "exports": {
@@ -29,7 +29,6 @@
         "seedrandom": "3.0.5",
         "yup": "^0.29.3"
     },
-    "packageManager": "yarn@3.6.4+sha512.e70835d4d6d62c07be76b3c1529cb640c7443f0fe434ef4b6478a5a399218cbaf1511b396b3c56eb03bc86424cff2320f6167ad2fde273aa0df6e60b7754029f",
     "devDependencies": {
         "@jest/globals": "^29.7.0",
         "@types/jest": "^29.5.14",

package/dist/pitch.d.ts

@@ -0,0 +1,31 @@
+import { Game, Player } from "types/models";
+declare enum TILES {
+    TD1 = "b",
+    CENTRE1 = "c",
+    SCRIMMAGE1 = "j",
+    LATERALA1 = "d",
+    LATERALB1 = "e",
+    TD2 = "f",
+    CENTRE2 = "g",
+    SCRIMMAGE2 = "k",
+    LATERALA2 = "h",
+    LATERALB2 = "i",
+    NEUTRAL = "a"
+}
+declare function coordinatesConvertorY(y: number, isDev?: boolean): string | number;
+declare function coordinatesConvertorX(x: number, isDev?: boolean): number;
+declare function getScrimmageTile(teamNumber: number): TILES.SCRIMMAGE1 | TILES.SCRIMMAGE2;
+declare function getLateralATile(teamNumber: number): TILES.LATERALA1 | TILES.LATERALA2;
+declare function getLateralBTile(teamNumber: number): TILES.LATERALB1 | TILES.LATERALB2;
+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 getNumberPlayerZone(teamNumber: number, players: Player[], game: Game): {
+    playerScrimmage: number;
+    playerLateralA: number;
+    playerLateralB: number;
+    playerCenter: number;
+};
+export { coordinatesConvertorX, coordinatesConvertorY, getCenterTile, getHalfStadium, getIndexFromXY, getLateralATile, getLateralBTile, getNumberPlayerZone, getScrimmageTile, getTdTile, getTile, TILES, };

package/dist/player.d.ts

@@ -0,0 +1,40 @@
+import { Game, Player, PlayerWithSkill, Team } from "./types/models";
+declare enum PLAYER_INJURY {
+    BADLY_HURT = "badly-hurt",
+    SERIOUSLY_HURT = "seriously-hurt",
+    SERIOUS = "serious",
+    LASTING = "lasting",
+    DEAD = "dead"
+}
+declare enum PLAYER_CARAC {
+    AG = "AG",
+    AV = "AV",
+    MA = "MA",
+    ST = "ST"
+}
+declare function hasMove(player: PlayerWithSkill, game: Game): boolean;
+declare function arePlayingSameGame(p1: Player, p2: Player): boolean;
+declare function hasTeam(player: Player): boolean;
+declare function areFromSameTeam(p1: Player, p2: Player): boolean;
+declare function isPlaying(player: Player): boolean;
+declare function isPlayingGame(player: Player, game: Game): boolean;
+declare function isTeamPlaying(team: Team): boolean;
+declare function isTeamPlayingGame(team: Team, game: Game): boolean;
+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): 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 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, };

package/dist/position.d.ts

@@ -0,0 +1,4 @@
+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 };

package/dist/race.d.ts

@@ -0,0 +1,93 @@
+import { AVATAR, CAREER_ID, 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) => {
+    MA: number;
+    ST: number;
+    AG: number;
+    AV: number;
+    normal: string;
+    double: string;
+    normalCoach: string;
+    icons: string[];
+    skills: (import("./skill").SKILL_NAMES | [import("./skill").SKILL_NAMES, number])[];
+    avatars: AVATAR[];
+    badge: RACE;
+    range: number;
+    cost: number;
+    hasSprite?: boolean;
+};
+declare const getCareerKeyFromPlayer: (player: Player) => CAREER_ID;
+declare const getCareerFromPlayer: (player: Player) => {
+    MA: number;
+    ST: number;
+    AG: number;
+    AV: number;
+    normal: string;
+    double: string;
+    normalCoach: string;
+    icons: string[];
+    skills: (import("./skill").SKILL_NAMES | [import("./skill").SKILL_NAMES, number])[];
+    avatars: AVATAR[];
+    badge: RACE;
+    range: number;
+    cost: number;
+    hasSprite?: boolean;
+};
+declare const getCareerFromIcon: (nameIcon: string) => {
+    MA: number;
+    ST: number;
+    AG: number;
+    AV: number;
+    normal: string;
+    double: string;
+    normalCoach: string;
+    icons: string[];
+    skills: (import("./skill").SKILL_NAMES | [import("./skill").SKILL_NAMES, number])[];
+    avatars: AVATAR[];
+    badge: RACE;
+    range: number;
+    cost: number;
+    hasSprite?: boolean;
+} | 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 getCareersByRace: () => any;
+declare const GAIN_CAREER_POINT = 2;
+declare const GAIN_CAREER_POINT_FRIENDLY = 2;
+declare enum GROUP_NAME {
+    AGILE = "group-agile",
+    CHAOTIC = "group-chaotic",
+    EXOTIC = "group-exotic",
+    NEUTRAL = "group-neutral",
+    VICIOUS = "group-vicious"
+}
+type CompatibilityType = {
+    [key in GROUP_NAME]: readonly RACE[];
+};
+declare const COMPATIBILITY: CompatibilityType;
+declare const getPlayerGroup: (player: Player) => GROUP_NAME | undefined;
+declare const getRaceGroup: (race: RACE) => GROUP_NAME | undefined;
+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 getTeamGroups(team: Team): any;
+declare function isPlayerNeutralGroup(player: Player): boolean;
+declare function isNeutralGroup(group: string): boolean;
+declare function getTeamIncompatibleGroups(team: Team): [string, unknown][];
+declare const getPlayersByState: (players: Player[]) => {
+    actives: Player[];
+    inactives: Player[];
+    lastRetired: Player[];
+};
+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, getTeamGroups, getTeamIncompatibleGroups, GROUP_NAME, hasUnlockCareer, hasUnlockRace, isNeutralGroup, isPlayerNeutralGroup, isPrivateRace, };

package/dist/random.d.ts

@@ -0,0 +1,7 @@
+declare function shuffleArray(array: any[]): any[];
+declare function getRandomItem(arr: any[]): any;
+declare function getRandomNumber(min: number, max: number, r?: () => number): number;
+declare function d8(quantity?: number, max?: number): number;
+declare function d6(quantity?: number, max?: number): number;
+declare function d3(quantity?: number, max?: number): number;
+export { d3, d6, d8, getRandomItem, getRandomNumber, shuffleArray };

package/dist/right.d.ts

@@ -0,0 +1,10 @@
+import { Game, Player, PlayerWithSkill, Team } from "types/models";
+declare function canJoinTeam(player: PlayerWithSkill, team: Team): boolean;
+declare function canCreateTeam(player: Player): boolean;
+declare function canQuitTeam(player: Player): boolean | "";
+declare function canRemovePlayer(player: Player, coach: Player): boolean | "";
+declare function canPayPlayer(player: Player, coach: Player, team: Team): boolean | "";
+declare function canChangeCoach(player: Player, coach: Player): boolean;
+declare function canCancelGame(game: Game, player: Player): boolean;
+declare function canRetirement(player: Player): boolean;
+export { canCancelGame, canChangeCoach, canCreateTeam, canJoinTeam, canPayPlayer, canQuitTeam, canRemovePlayer, canRetirement, };