enefel 1.2.0 → 1.2.2

package/dist/inducement.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_INDUCEMENT = exports.INDUCEMENT = exports.hasInducement = exports.getInducements = exports.getGameInducements = exports.burnInducement = void 0;
+const random_1 = require("./random");
+const MAX_INDUCEMENT = 5;
+exports.MAX_INDUCEMENT = MAX_INDUCEMENT;
+const INDUCEMENT = {
+    APOTHECARY: { key: "apo" },
+    HALFLING_MASTER_CHEF: { key: "hmc" },
+    SPY: { key: "spy" },
+    XXX: { key: "xxx" },
+    BRIBE: { key: "bribe", isMulti: true },
+};
+exports.INDUCEMENT = INDUCEMENT;
+const getInducements = (_team, inducementList) => {
+    let random = Object.values(INDUCEMENT).filter((value) => {
+        return (!inducementList.includes(value.key) || value.isMulti === true);
+    });
+    if (random.length === 0) {
+        return null;
+    }
+    random = (0, random_1.shuffleArray)(random);
+    return random[0].key;
+};
+exports.getInducements = getInducements;
+const getGameInducements = (game) => {
+    if (!game) {
+        return [null, []];
+    }
+    const [teamId, inducements] = game.inducements.split(";");
+    let inducementList = [];
+    if (inducements) {
+        inducementList = inducements.split("-");
+    }
+    return [teamId, inducementList];
+};
+exports.getGameInducements = getGameInducements;
+const hasInducement = (game, currentTeamId, inducement) => {
+    const [teamId, inducementList] = getGameInducements(game);
+    if (currentTeamId === teamId) {
+        return inducementList.includes(inducement.key);
+    }
+    return false;
+};
+exports.hasInducement = hasInducement;
+const burnInducement = (game, inducementKey) => {
+    const [teamId, inducements] = game.inducements.split(";");
+    if (inducements) {
+        let inducementList = inducements.split("-");
+        const index = inducementList.indexOf(inducementKey);
+        if (index === -1) {
+            return;
+        }
+        inducementList[index] = `!${inducementList[index]}`;
+        game.inducements = `${teamId};${inducementList.join("-")}`;
+    }
+    return game;
+};
+exports.burnInducement = burnInducement;

package/dist/item.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RARITY = exports.ITEM_TYPE = exports.ITEM_ID = exports.getQteFromRarity = void 0;
+var RARITY;
+(function (RARITY) {
+    RARITY["COMMUN"] = "c";
+    RARITY["UNCOMMUN"] = "u";
+    RARITY["RARE"] = "r";
+    RARITY["EPIC"] = "e";
+    RARITY["LEGENDARY"] = "l";
+})(RARITY || (exports.RARITY = RARITY = {}));
+var ITEM_ID;
+(function (ITEM_ID) {
+    ITEM_ID["BEER"] = "beer";
+    ITEM_ID["CHAINSAW"] = "chainsaw";
+    ITEM_ID["RUSTED_CHAINSAW"] = "rusted-chainsaw";
+    ITEM_ID["DRUG"] = "drug";
+    ITEM_ID["GREEN_PILL"] = "green-pill";
+    ITEM_ID["NEWSPAPER"] = "newspaper";
+    ITEM_ID["BOOSTER"] = "booster";
+})(ITEM_ID || (exports.ITEM_ID = ITEM_ID = {}));
+var ITEM_TYPE;
+(function (ITEM_TYPE) {
+    ITEM_TYPE["CONSUMABLE"] = "consumable";
+    ITEM_TYPE["WEAPON"] = "weapon";
+    ITEM_TYPE["FILE"] = "file";
+})(ITEM_TYPE || (exports.ITEM_TYPE = ITEM_TYPE = {}));
+const getQteFromRarity = (rarity) => {
+    if (rarity === RARITY.COMMUN) {
+        return 10000;
+    }
+    if (rarity === RARITY.UNCOMMUN) {
+        return 1000;
+    }
+    if (rarity === RARITY.RARE) {
+        return 100;
+    }
+    if (rarity === RARITY.EPIC) {
+        return 10;
+    }
+    if (rarity === RARITY.LEGENDARY) {
+        return 1;
+    }
+};
+exports.getQteFromRarity = getQteFromRarity;

package/dist/jest.config.js

@@ -0,0 +1,11 @@
+"use strict";
+module.exports = {
+    preset: "ts-jest",
+    testEnvironment: "node",
+    roots: ["<rootDir>/__tests__"],
+    testMatch: ["**/*.test.ts"],
+    transform: {
+        "^.+\\.tsx?$": "ts-jest",
+    },
+    moduleFileExtensions: ["ts", "tsx", "js", "jsx", "json", "node"],
+};

package/dist/league.js

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.playoffNextSeason = exports.NUMBER_TEAM_CHANGE = exports.MIN_OPEN_SIZE = exports.HOME_AND_AWAY = exports.HAS_NEXT_SEASON_PLAYOFF = exports.GROUP_SIZE = exports.forcastNextSeason = exports.CAN_CHOOSE_TO_PARTICIPATE = exports.calculateTeamsStandingForPlayoff = exports.calculateTeamsStandingForNextSeason = void 0;
+exports.hasCalendar = hasCalendar;
+exports.round = round;
+exports.sortLeagues = sortLeagues;
+exports.tournament = tournament;
+const game_1 = require("./game");
+const state_1 = require("./state");
+const MIN_OPEN_SIZE = 4;
+exports.MIN_OPEN_SIZE = MIN_OPEN_SIZE;
+const GROUP_SIZE = 0;
+exports.GROUP_SIZE = GROUP_SIZE;
+const HAS_NEXT_SEASON_PLAYOFF = false;
+exports.HAS_NEXT_SEASON_PLAYOFF = HAS_NEXT_SEASON_PLAYOFF;
+const CAN_CHOOSE_TO_PARTICIPATE = false;
+exports.CAN_CHOOSE_TO_PARTICIPATE = CAN_CHOOSE_TO_PARTICIPATE;
+const HOME_AND_AWAY = false;
+exports.HOME_AND_AWAY = HOME_AND_AWAY;
+const NUMBER_TEAM_CHANGE = 2;
+exports.NUMBER_TEAM_CHANGE = NUMBER_TEAM_CHANGE;
+const calculateTeamsStandingForPlayoff = (flatTeams, division) => {
+    const standings = [{ teams: [] }];
+    for (let team of flatTeams) {
+        standings[standings.length - 1].teams.push(team);
+        if (standings[standings.length - 1].teams.length >= GROUP_SIZE &&
+            standings.length < 3) {
+            standings.push({ teams: [] });
+        }
+    }
+    if (division.length <= 2) {
+        // On prends les 8 premiers
+    }
+    else {
+        for (let i = 0; i < standings.length - 1; ++i) {
+            const currentDivision = standings[i];
+            const isLeagueA = i === 0;
+            const isLeagueB = i === 1;
+            // Les derniers des ligues A et B sont relegué dans la league open
+            const nextDivisionIndex = i + (isLeagueA ? 2 : 1);
+            // TODO : Ce truc doit ps etre fait si la saison courante et pas un playoff
+            const nextDivision = standings[nextDivisionIndex];
+            if (!nextDivision) {
+                break;
+            }
+            const currentDivisionLastTeam = currentDivision.teams[currentDivision.teams.length - 1];
+            // Le dernier de la ligue A va remplacer premier de l'open
+            // Le dernier de la ligue B va remplacer le second de l'open
+            const nextDivisionFirstTeam = nextDivision.teams[isLeagueB ? 1 : 0];
+            currentDivision.teams[currentDivision.teams.length - 1] =
+                nextDivisionFirstTeam;
+            nextDivision.teams[isLeagueB ? 1 : 0] = currentDivisionLastTeam;
+        }
+    }
+    // Les ligues A est B sont classé par ELO
+    const flatedTeams = standings.reduce((p, c) => [...p, ...c.teams], []);
+    if (!flatedTeams || flatedTeams.length === 0) {
+        return [];
+    }
+    const size = GROUP_SIZE * 2;
+    for (let i = 0; i < size; i++) {
+        for (let j = i + 1; j < size; j++) {
+            if (!flatedTeams[j] || !flatedTeams[i]) {
+                continue;
+            }
+            if (flatedTeams[j].elo > flatedTeams[i].elo) {
+                let temp = flatedTeams[i];
+                flatedTeams[i] = flatedTeams[j];
+                flatedTeams[j] = temp;
+            }
+        }
+    }
+    // 0 1 2 3 4 5 6 7
+    // 0 2 4 6 1 3 5 7
+    let temp = flatedTeams[1];
+    flatedTeams[1] = flatedTeams[4];
+    flatedTeams[4] = temp;
+    temp = flatedTeams[3];
+    flatedTeams[3] = flatedTeams[6];
+    flatedTeams[6] = temp;
+    return flatedTeams;
+};
+exports.calculateTeamsStandingForPlayoff = calculateTeamsStandingForPlayoff;
+const getIndexNextAvailableTeam = (index, nextDivision, currentSeason, currentDivisionIndex) => {
+    if (nextDivision.name === game_1.GAME_TYPE.OPEN) {
+        // To avoid some teams block the open, we take the first team with canChampionship
+        let alreadyFind = currentDivisionIndex;
+        index = nextDivision.teams.findIndex((t, i) => {
+            if (i < index) {
+                return false;
+            }
+            if (currentSeason.playoff && i < alreadyFind) {
+                // Fix Si CAN_CHOOSE_TO_PARTICIPATE ?
+                return false;
+            }
+            return t.canChampionship || !CAN_CHOOSE_TO_PARTICIPATE;
+        });
+        if (index === -1) {
+            // TODO : Check if this is correct
+            // index = currentSeason.playoff ? i : 0;
+        }
+    }
+    return index;
+};
+const calculateTeamsStandingForLeagues = (newStandings, division, currentSeason) => {
+    const openDivision = newStandings[division.length - 1];
+    for (let i = 0; i < division.length - 1; ++i) {
+        const currentDivision = newStandings[i];
+        const nextDivision = currentSeason.playoff
+            ? openDivision
+            : newStandings[i + 1];
+        const currentDivisionLastTeam = currentDivision.teams[currentDivision.teams.length - 1];
+        const currentDivisionPreLastTeam = currentDivision.teams[currentDivision.teams.length - 2];
+        let indexNextDivisionFirstTeam = getIndexNextAvailableTeam(0, nextDivision, currentSeason, i);
+        const nextDivisionFirstTeam = nextDivision.teams[indexNextDivisionFirstTeam];
+        let indexNextDivisionSecondTeam = getIndexNextAvailableTeam(indexNextDivisionFirstTeam + 1, nextDivision, currentSeason, i);
+        const nextDivisionSecondTeam = nextDivision.teams[indexNextDivisionSecondTeam];
+        if ( /* NUMBER_TEAM_CHANGE === 1 || */!nextDivisionSecondTeam) {
+            currentDivision.teams[currentDivision.teams.length - 1] =
+                nextDivisionFirstTeam;
+            nextDivision.teams[indexNextDivisionFirstTeam] = currentDivisionLastTeam;
+        }
+        else if (NUMBER_TEAM_CHANGE === 2) {
+            currentDivision.teams[currentDivision.teams.length - 2] =
+                nextDivisionFirstTeam;
+            nextDivision.teams[indexNextDivisionSecondTeam] = currentDivisionLastTeam;
+            currentDivision.teams[currentDivision.teams.length - 1] =
+                nextDivisionSecondTeam;
+            nextDivision.teams[indexNextDivisionFirstTeam] =
+                currentDivisionPreLastTeam;
+        }
+    }
+    const flatTeams = newStandings
+        .reduce((p, c) => [...p, ...c.teams], [])
+        .filter((t) => t && (0, state_1.canPlayLeague)(t));
+    return flatTeams;
+};
+const calculateTeamsStandingForNextSeason = (division, currentSeason) => {
+    division = division.filter((d) => d.name !== game_1.GAME_TYPE.FRIENDLY && d.name !== game_1.GAME_TYPE.PLAYOFF);
+    // Standing division should be sorted (playoff, 1, 2, 3, ... , open)
+    const newStandings = JSON.parse(JSON.stringify(division));
+    const flatTeams = newStandings
+        .reduce((p, c) => [...p, ...c.teams], [])
+        .filter((t) => t && (0, state_1.canPlayLeague)(t));
+    if (HAS_NEXT_SEASON_PLAYOFF && GROUP_SIZE * 3 < flatTeams.length) {
+        return calculateTeamsStandingForPlayoff(flatTeams, division);
+    }
+    return calculateTeamsStandingForLeagues(newStandings, division, currentSeason);
+};
+exports.calculateTeamsStandingForNextSeason = calculateTeamsStandingForNextSeason;
+const forcastNextSeason = (flatTeams) => {
+    let groups = [];
+    let open = [];
+    let currentGroup = [];
+    let i = 0;
+    flatTeams.forEach((team) => {
+        if (!team) {
+            return;
+        }
+        // En playoff on n'a que les ligues A et B + open
+        if ((CAN_CHOOSE_TO_PARTICIPATE && !team.canChampionship) ||
+            (i >= 2 && HAS_NEXT_SEASON_PLAYOFF)) {
+            open.push(team);
+            return;
+        }
+        currentGroup.push(team);
+        if (currentGroup.length === GROUP_SIZE) {
+            groups = [...groups, currentGroup];
+            currentGroup = [];
+            ++i;
+        }
+    });
+    open = [...currentGroup, ...open];
+    if (open.length < MIN_OPEN_SIZE) {
+        const lastDivision = groups.pop();
+        if (lastDivision) {
+            open = [...lastDivision, ...open];
+        }
+    }
+    groups = [...groups, open];
+    return { hasPlayoffs: false, groups };
+};
+exports.forcastNextSeason = forcastNextSeason;
+const playoffNextSeason = (flatTeams) => {
+    let groups = [];
+    let open = [];
+    let currentGroup = [];
+    // Creation de groupe de GROUP_SIZE
+    flatTeams.forEach((team) => {
+        if (!team) {
+            return;
+        }
+        // Obligatoire pour les playoffs
+        currentGroup.push(team);
+        if (currentGroup.length === GROUP_SIZE) {
+            groups = [...groups, currentGroup];
+            currentGroup = [];
+        }
+    });
+    // Le reste est mis en open
+    open = [...currentGroup, ...open];
+    if (open.length < MIN_OPEN_SIZE) {
+        const lastDivision = groups.pop();
+        if (lastDivision) {
+            open = [...lastDivision, ...open];
+        }
+    }
+    groups = [...groups, open];
+    if (HAS_NEXT_SEASON_PLAYOFF === false || groups.length < 3) {
+        return forcastNextSeason(flatTeams);
+    }
+    return { hasPlayoffs: true, groups };
+};
+exports.playoffNextSeason = playoffNextSeason;
+function round(r, teams) {
+    const pairs = [];
+    const n = teams.length;
+    for (var i = 1; i <= n / 2; i++) {
+        if (i == 1) {
+            pairs.push([teams[0], teams[((r + n - i - 1) % (n - 1)) + 1]]);
+        }
+        else {
+            pairs.push([
+                teams[((r + i - 2) % (n - 1)) + 1],
+                teams[((r + n - i - 1) % (n - 1)) + 1],
+            ]);
+        }
+    }
+    return pairs;
+}
+function tournament(teams) {
+    const rounds = [];
+    const nbTeams = teams.length;
+    for (var r = 1; r < nbTeams; r++) {
+        rounds.push(round(r, teams));
+    }
+    return rounds;
+}
+function hasCalendar(league) {
+    return league.name !== game_1.GAME_TYPE.OPEN && league.name !== game_1.GAME_TYPE.FRIENDLY;
+}
+function sortLeagues(a, b) {
+    if (a.name < b.name || b.name === game_1.GAME_TYPE.FRIENDLY) {
+        return -1;
+    }
+    if (a.name > b.name || a.name === game_1.GAME_TYPE.FRIENDLY) {
+        return 1;
+    }
+    return 0;
+}

package/dist/meteo.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.meteoTakeBall = exports.meteoRerollRoll = exports.meteoPlayerFall = exports.meteoPickUpBall = exports.meteoPassRebound = exports.meteoPassBonus = exports.meteoMaxPassDistance = exports.meteoMaxMA = exports.meteoKO = exports.meteoHasExpulsion = exports.meteoGfi = exports.meteoAttackerStrengthBlitz = exports.METEO = exports.getSeason = exports.getMeteo = void 0;
+var METEO;
+(function (METEO) {
+    METEO[METEO["AUTUMN_LEAF_STREWN_PITCH"] = 1] = "AUTUMN_LEAF_STREWN_PITCH";
+    METEO[METEO["AUTUMNAL_CHILL"] = 2] = "AUTUMNAL_CHILL";
+    METEO[METEO["POURING_RAIN"] = 3] = "POURING_RAIN";
+    METEO[METEO["STRONG_WINDS"] = 4] = "STRONG_WINDS";
+    METEO[METEO["COLD_WINDS"] = 5] = "COLD_WINDS";
+    METEO[METEO["FREEZING"] = 6] = "FREEZING";
+    METEO[METEO["PERFECT_CONDITION"] = 7] = "PERFECT_CONDITION";
+    METEO[METEO["HEAVY_SNOW"] = 8] = "HEAVY_SNOW";
+    METEO[METEO["BLIZZARD"] = 9] = "BLIZZARD";
+    METEO[METEO["MORNING_DEW"] = 10] = "MORNING_DEW";
+    METEO[METEO["BLOSSOMING_FLOWERS"] = 11] = "BLOSSOMING_FLOWERS";
+    METEO[METEO["MISTY_MORNING"] = 12] = "MISTY_MORNING";
+    METEO[METEO["HIGH_WINDS"] = 13] = "HIGH_WINDS";
+})(METEO || (exports.METEO = METEO = {}));
+var SEASON;
+(function (SEASON) {
+    SEASON[SEASON["WINTER"] = 1] = "WINTER";
+    SEASON[SEASON["SPRING"] = 2] = "SPRING";
+    SEASON[SEASON["SUMMER"] = 3] = "SUMMER";
+    SEASON[SEASON["AUTUMN"] = 4] = "AUTUMN";
+})(SEASON || (SEASON = {}));
+const seasons = [
+    {
+        name: SEASON.SPRING,
+        start: new Date(2000, 2, 21),
+        end: new Date(2000, 5, 20),
+    },
+    {
+        name: SEASON.SUMMER,
+        start: new Date(2000, 5, 21),
+        end: new Date(2000, 8, 20),
+    },
+    {
+        name: SEASON.AUTUMN,
+        start: new Date(2000, 8, 21),
+        end: new Date(2000, 11, 20),
+    },
+    {
+        name: SEASON.WINTER,
+        start: new Date(2000, 11, 21),
+        end: new Date(2001, 2, 20),
+    },
+];
+/** Checks if a date is within a specified season */
+function checkSeason(season, date) {
+    let remappedStart = new Date(2000, season.start.getMonth(), season.start.getDate());
+    let remappedDate = new Date(2000, date.getMonth(), date.getDate());
+    let remappedEnd = new Date(2000, season.end.getMonth(), season.end.getDate());
+    if (season.start.getFullYear() === season.end.getFullYear()) {
+        return remappedStart <= remappedDate && remappedDate <= remappedEnd;
+    }
+    else {
+        return ((remappedStart <= remappedDate &&
+            remappedDate <= new Date(2000, 11, 31)) ||
+            (new Date(2000, 0, 1) <= remappedDate && remappedDate <= remappedEnd));
+    }
+}
+function findSeason(seasons, date) {
+    for (let i = 0; i < seasons.length; i++) {
+        let isInSeason = checkSeason(seasons[i], date);
+        if (isInSeason === true) {
+            return seasons[i];
+        }
+    }
+    return null;
+}
+const getSeason = () => {
+    const season = findSeason(seasons, new Date());
+    if (season) {
+        return season.name;
+    }
+    return null;
+};
+exports.getSeason = getSeason;
+const getMeteo = (value) => {
+    const season = getSeason();
+    if (season === SEASON.SPRING) {
+        switch (value) {
+            case 2:
+                return METEO.MORNING_DEW;
+            case 3:
+                return METEO.BLOSSOMING_FLOWERS;
+            case 11:
+                return METEO.MISTY_MORNING;
+            case 12:
+                return METEO.HIGH_WINDS;
+            default:
+                return METEO.PERFECT_CONDITION;
+        }
+    }
+    if (season === SEASON.WINTER) {
+        switch (value) {
+            case 2:
+                return METEO.COLD_WINDS;
+            case 3:
+                return METEO.FREEZING;
+            case 11:
+                return METEO.HEAVY_SNOW;
+            case 12:
+                return METEO.BLIZZARD;
+            default:
+                return METEO.PERFECT_CONDITION;
+        }
+    }
+    if (season === SEASON.AUTUMN) {
+        switch (value) {
+            case 2:
+                return METEO.AUTUMN_LEAF_STREWN_PITCH;
+            case 3:
+                return METEO.AUTUMNAL_CHILL;
+            case 11:
+                return METEO.POURING_RAIN;
+            case 12:
+                return METEO.STRONG_WINDS;
+            default:
+                return METEO.PERFECT_CONDITION;
+        }
+    }
+    return METEO.PERFECT_CONDITION;
+};
+exports.getMeteo = getMeteo;
+const meteoAttackerStrengthBlitz = (meteoValue) => {
+    let modif = 0;
+    if (meteoValue === METEO.HEAVY_SNOW) {
+        modif = -1;
+    }
+    return modif;
+};
+exports.meteoAttackerStrengthBlitz = meteoAttackerStrengthBlitz;
+const meteoPlayerFall = (meteoValue) => {
+    let modif = 0;
+    if (meteoValue === METEO.AUTUMN_LEAF_STREWN_PITCH) {
+        modif = -1;
+    }
+    if (meteoValue === METEO.FREEZING) {
+        modif = 1;
+    }
+    return modif;
+};
+exports.meteoPlayerFall = meteoPlayerFall;
+const meteoKO = (meteoValue) => {
+    let modif = 0;
+    if (meteoValue === METEO.AUTUMNAL_CHILL) {
+        modif = -1;
+    }
+    if (meteoValue === METEO.COLD_WINDS) {
+        modif = -1;
+    }
+    return modif;
+};
+exports.meteoKO = meteoKO;
+// only pickup ball interaction
+const meteoPickUpBall = (meteoValue) => {
+    let modif = 0;
+    if (meteoValue === METEO.MORNING_DEW) {
+        modif = -1;
+    }
+    return modif;
+};
+exports.meteoPickUpBall = meteoPickUpBall;
+// All ball interaction
+const meteoTakeBall = (meteoValue) => {
+    let modif = 0;
+    if (meteoValue === METEO.POURING_RAIN) {
+        modif = -1;
+    }
+    return modif;
+};
+exports.meteoTakeBall = meteoTakeBall;
+const meteoPassRebound = (meteoValue) => {
+    let modif = 0;
+    if (meteoValue === METEO.STRONG_WINDS) {
+        modif = 3;
+    }
+    return modif;
+};
+exports.meteoPassRebound = meteoPassRebound;
+const meteoPassBonus = (meteoValue) => {
+    let modif = 0;
+    if (meteoValue === METEO.STRONG_WINDS) {
+        modif = -1;
+    }
+    if (meteoValue === METEO.COLD_WINDS) {
+        modif = -1;
+    }
+    return modif;
+};
+exports.meteoPassBonus = meteoPassBonus;
+const meteoGfi = (meteoValue) => {
+    let modif = 0;
+    if (meteoValue === METEO.BLIZZARD) {
+        modif = -1;
+    }
+    if (meteoValue === METEO.MORNING_DEW) {
+        modif = -1;
+    }
+    return modif;
+};
+exports.meteoGfi = meteoGfi;
+const meteoMaxPassDistance = (meteoValue) => {
+    // 3.5, 7, 10.2, 13.1
+    let max = 14;
+    if (meteoValue === METEO.BLIZZARD || meteoValue === METEO.MISTY_MORNING) {
+        max = 7;
+    }
+    return max;
+};
+exports.meteoMaxPassDistance = meteoMaxPassDistance;
+const meteoHasExpulsion = (meteoValue) => {
+    if (meteoValue === METEO.BLOSSOMING_FLOWERS) {
+        return false;
+    }
+    return true;
+};
+exports.meteoHasExpulsion = meteoHasExpulsion;
+const meteoMaxMA = (meteoValue) => {
+    if (meteoValue === METEO.MISTY_MORNING) {
+        return 6;
+    }
+    return Infinity;
+};
+exports.meteoMaxMA = meteoMaxMA;
+const meteoRerollRoll = (meteoValue) => {
+    if (meteoValue === METEO.HIGH_WINDS) {
+        return 2;
+    }
+    return 1;
+};
+exports.meteoRerollRoll = meteoRerollRoll;

package/dist/moral.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getColorFromMoral = getColorFromMoral;
+exports.getMalusFromMoral = getMalusFromMoral;
+function getMalusFromMoral(moral) {
+    if (moral < 20) {
+        return 20;
+    }
+    else if (moral < 40) {
+        return 15;
+    }
+    else if (moral < 60) {
+        return 10;
+    }
+    else if (moral < 80) {
+        return 5;
+    }
+    else {
+        return 0;
+    }
+}
+function getColorFromMoral(moral) {
+    if (moral < 20) {
+        return "#ff0000";
+    }
+    else if (moral < 40) {
+        return "#ff7b00";
+    }
+    else if (moral < 60) {
+        return "#ffcc00";
+    }
+    else if (moral < 80) {
+        return "#ffff00";
+    }
+    else {
+        return "#00FF00";
+    }
+}