enefel 1.2.0 → 1.2.2

package/dist/race.js

@@ -0,0 +1,355 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPrivateRace = exports.hasUnlockRace = exports.hasUnlockCareer = exports.GROUP_NAME = exports.getRaceGroup = exports.getRaceFromPlayer = exports.getRaceFromCareer = exports.getRaceCompatibility = exports.getPlayersByState = exports.getPlayerGroup = exports.getPlayerCompatibility = exports.getPlayerAvatarPath = exports.getPlayerAvatarDefault = exports.getPlayerAvatar = exports.getCareersByRace = exports.getCareerKeyFromPlayer = exports.getCareerFromPlayer = exports.getCareerFromKey = exports.getCareerFromIcon = exports.getAvatarTypeFromPlayer = exports.GAIN_CAREER_POINT_FRIENDLY = exports.GAIN_CAREER_POINT = exports.COMPATIBILITY = exports.ANIMOSITY_NUMBER = void 0;
+exports.getCareerRanges = getCareerRanges;
+exports.getPlayersAvailableForPromo = getPlayersAvailableForPromo;
+exports.getPriceCareer = getPriceCareer;
+exports.getPromoCareer = getPromoCareer;
+exports.getTeamGroups = getTeamGroups;
+exports.getTeamIncompatibleGroups = getTeamIncompatibleGroups;
+exports.isNeutralGroup = isNeutralGroup;
+exports.isPlayerNeutralGroup = isPlayerNeutralGroup;
+const seedrandom_1 = __importDefault(require("seedrandom"));
+const avatars_1 = require("./avatars");
+const avatarsDefault_1 = require("./avatarsDefault");
+const badge_1 = require("./badge");
+const career_1 = require("./career");
+const random_1 = require("./random");
+const state_1 = require("./state");
+const ANIMOSITY_NUMBER = 2;
+exports.ANIMOSITY_NUMBER = ANIMOSITY_NUMBER;
+const isPrivateRace = (race) => {
+    return [
+        career_1.RACE.UNDEAD,
+        career_1.RACE.VAMPIRE,
+        career_1.RACE.ELVEN_UNION,
+        career_1.RACE.GOBELIN,
+        career_1.RACE.IMPERIAL,
+        career_1.RACE.KHORNE,
+        career_1.RACE.NECROMANTIC,
+        career_1.RACE.NURGLE,
+        career_1.RACE.SNOTLING,
+        career_1.RACE.SLANN,
+    ].includes(race);
+};
+exports.isPrivateRace = isPrivateRace;
+const hasUnlockRace = (user, race) => {
+    if (!user.badges) {
+        throw Error("no badges for player");
+    }
+    if (!isPrivateRace(race)) {
+        return true;
+    }
+    if (race === career_1.RACE.UNDEAD) {
+        if ((0, badge_1.hasBadge)(badge_1.BADGE_NAMES.DEAD, user)) {
+            return true;
+        }
+    }
+    if (race === career_1.RACE.KHORNE) {
+        if ((0, badge_1.hasBadge)(badge_1.BADGE_NAMES.BLOODTHIRSTY, user)) {
+            return true;
+        }
+    }
+    if (race === career_1.RACE.VAMPIRE) {
+        if ((0, badge_1.hasBadge)(badge_1.BADGE_NAMES.VAMPIRE, user)) {
+            return true;
+        }
+    }
+    if (race === career_1.RACE.ELVEN_UNION) {
+        if ((0, badge_1.hasBadge)(badge_1.BADGE_NAMES.ELVEN_UNION, user)) {
+            return true;
+        }
+    }
+    if (race === career_1.RACE.SNOTLING) {
+        if ((0, badge_1.hasBadge)(badge_1.BADGE_NAMES.SNOTLING, user)) {
+            return true;
+        }
+    }
+    if (race === career_1.RACE.IMPERIAL) {
+        if ((0, badge_1.hasBadge)(badge_1.BADGE_NAMES.IMPERIAL, user)) {
+            return true;
+        }
+    }
+    if (race === career_1.RACE.NECROMANTIC) {
+        if ((0, badge_1.hasBadge)(badge_1.BADGE_NAMES.DEAD_FULL_MOON, user)) {
+            return true;
+        }
+    }
+    if (race === career_1.RACE.GOBELIN) {
+        if ((0, badge_1.hasBadge)(badge_1.BADGE_NAMES.WEAPON, user)) {
+            return true;
+        }
+    }
+    if (race === career_1.RACE.NURGLE) {
+        if ((0, badge_1.hasBadge)(badge_1.BADGE_NAMES.NURGLE, user)) {
+            return true;
+        }
+    }
+    if (race === career_1.RACE.SLANN) {
+        if ((0, badge_1.hasBadge)(badge_1.BADGE_NAMES.SLANN, user)) {
+            return true;
+        }
+    }
+    return false;
+};
+exports.hasUnlockRace = hasUnlockRace;
+const hasUnlockCareer = (user, careerId) => {
+    if (!user.badges) {
+        throw Error("no badges for player");
+    }
+    const race = getRaceFromCareer(careerId);
+    return hasUnlockRace(user, race);
+};
+exports.hasUnlockCareer = hasUnlockCareer;
+const getCareerFromKey = (key) => {
+    const careers = (0, career_1.getCareers)();
+    return careers[key];
+};
+exports.getCareerFromKey = getCareerFromKey;
+const getCareerKeyFromPlayer = (player) => {
+    // Attention la career est le race_id dans la table player
+    return player.race_id;
+};
+exports.getCareerKeyFromPlayer = getCareerKeyFromPlayer;
+const getCareerFromPlayer = (player) => {
+    const careerKey = getCareerKeyFromPlayer(player);
+    return getCareerFromKey(careerKey);
+};
+exports.getCareerFromPlayer = getCareerFromPlayer;
+const getCareerFromIcon = (nameIcon) => {
+    for (const [key, values] of Object.entries((0, career_1.getCareers)())) {
+        if (values.icons.includes(nameIcon)) {
+            return getCareerFromKey(key);
+        }
+    }
+    return null;
+};
+exports.getCareerFromIcon = getCareerFromIcon;
+const getPlayerAvatarDefault = (player) => {
+    const avatars = avatarsDefault_1.AVATAR_DEFAULT_LIST;
+    const career = getCareerFromPlayer(player);
+    const listAvailable = [];
+    for (const avatar of career.avatars) {
+        // Temporary. Before theiy can choose their default avatar
+        if ((career.badge === career_1.RACE.HUMAN ||
+            career.badge === career_1.RACE.IMPERIAL ||
+            career.badge === career_1.RACE.NORSE) &&
+            avatar === career_1.AVATAR.HUMAN_WOMAN) {
+            continue;
+        }
+        if (avatars[avatar]) {
+            avatars[avatar].forEach((item) => {
+                listAvailable.push(item);
+            });
+        }
+    }
+    if (listAvailable.length === 0) {
+        return null;
+    }
+    const random = (0, seedrandom_1.default)(player.id);
+    return listAvailable[(0, random_1.getRandomNumber)(0, listAvailable.length - 1, random)]
+        .file;
+};
+exports.getPlayerAvatarDefault = getPlayerAvatarDefault;
+const getPlayerAvatar = (player) => {
+    const av = player.avatar || player.avatarDefault;
+    if (!av) {
+        return null;
+    }
+    return av.replace(".png", ".jpeg");
+};
+exports.getPlayerAvatar = getPlayerAvatar;
+const getPlayerAvatarPath = (player) => {
+    if (player.avatar) {
+        return "tile/shop/avatar";
+    }
+    else if (player.avatarDefault) {
+        return "tile/shop/avatar-default";
+    }
+    return null;
+};
+exports.getPlayerAvatarPath = getPlayerAvatarPath;
+const getRaceFromCareer = (careerId) => {
+    const career = getCareerFromKey(careerId);
+    return career.badge;
+};
+exports.getRaceFromCareer = getRaceFromCareer;
+const getAvatarTypeFromPlayer = (player, avatarFile) => {
+    const career = getCareerFromPlayer(player);
+    if (avatarFile) {
+        for (const avatarType of career.avatars) {
+            const avatars = avatars_1.AVATAR_LIST[avatarType];
+            if (avatars) {
+                const findAvatar = avatars.find((al) => al.file === avatarFile);
+                if (findAvatar) {
+                    return avatarType;
+                }
+            }
+            const avatarsDefault = avatarsDefault_1.AVATAR_DEFAULT_LIST[avatarType];
+            if (avatarsDefault) {
+                const findAvatarDefault = avatarsDefault.find((al) => al.file === avatarFile);
+                if (findAvatarDefault) {
+                    return avatarType;
+                }
+            }
+        }
+    }
+    return null;
+};
+exports.getAvatarTypeFromPlayer = getAvatarTypeFromPlayer;
+const getRaceFromPlayer = (player) => {
+    return getRaceFromCareer(getCareerKeyFromPlayer(player));
+};
+exports.getRaceFromPlayer = getRaceFromPlayer;
+const getCareersByRace = () => {
+    const carrers = {};
+    for (const [name, values] of Object.entries((0, career_1.getCareers)())) {
+        const badge = values.badge;
+        if (!carrers[badge]) {
+            carrers[badge] = [];
+        }
+        if (!carrers[badge][values.range]) {
+            carrers[badge][values.range] = {};
+        }
+        carrers[badge][values.range][name] = values;
+    }
+    return carrers;
+};
+exports.getCareersByRace = getCareersByRace;
+const GAIN_CAREER_POINT = 2;
+exports.GAIN_CAREER_POINT = GAIN_CAREER_POINT;
+const GAIN_CAREER_POINT_FRIENDLY = 2;
+exports.GAIN_CAREER_POINT_FRIENDLY = GAIN_CAREER_POINT_FRIENDLY;
+var GROUP_NAME;
+(function (GROUP_NAME) {
+    GROUP_NAME["AGILE"] = "group-agile";
+    GROUP_NAME["CHAOTIC"] = "group-chaotic";
+    GROUP_NAME["EXOTIC"] = "group-exotic";
+    GROUP_NAME["NEUTRAL"] = "group-neutral";
+    GROUP_NAME["VICIOUS"] = "group-vicious";
+})(GROUP_NAME || (exports.GROUP_NAME = GROUP_NAME = {}));
+const COMPATIBILITY = {
+    [GROUP_NAME.AGILE]: [career_1.RACE.AMAZON, career_1.RACE.SILVAN, career_1.RACE.ELVEN_UNION, career_1.RACE.SLANN],
+    [GROUP_NAME.CHAOTIC]: [
+        career_1.RACE.ORC,
+        career_1.RACE.CHAOS_DWARF,
+        career_1.RACE.CHAOS,
+        career_1.RACE.GOBELIN,
+        career_1.RACE.KHORNE,
+        career_1.RACE.NURGLE,
+    ],
+    [GROUP_NAME.EXOTIC]: [career_1.RACE.DWARF, career_1.RACE.NORSE, career_1.RACE.LIZARDMEN, career_1.RACE.UNDEAD],
+    [GROUP_NAME.NEUTRAL]: [career_1.RACE.HALFLING, career_1.RACE.HUMAN, career_1.RACE.IMPERIAL],
+    [GROUP_NAME.VICIOUS]: [
+        career_1.RACE.DARK_ELFE,
+        career_1.RACE.RAT,
+        career_1.RACE.SNOTLING,
+        career_1.RACE.NECROMANTIC,
+        career_1.RACE.VAMPIRE,
+    ],
+};
+exports.COMPATIBILITY = COMPATIBILITY;
+const getPlayerGroup = (player) => {
+    return getRaceGroup(getRaceFromPlayer(player));
+};
+exports.getPlayerGroup = getPlayerGroup;
+const getRaceGroup = (race) => {
+    for (const group of Object.keys(COMPATIBILITY)) {
+        if (COMPATIBILITY[group].includes(race)) {
+            return group;
+        }
+    }
+    return undefined;
+};
+exports.getRaceGroup = getRaceGroup;
+const getRaceCompatibility = (race1, race2) => {
+    const group1 = getRaceGroup(race1);
+    const group2 = getRaceGroup(race2);
+    if (group1 === group2 ||
+        group1 === GROUP_NAME.NEUTRAL ||
+        group2 === GROUP_NAME.NEUTRAL) {
+        return true;
+    }
+    return false;
+};
+exports.getRaceCompatibility = getRaceCompatibility;
+const getPlayerCompatibility = (player1, player2) => {
+    const race1 = getRaceFromPlayer(player1);
+    const race2 = getRaceFromPlayer(player2);
+    getRaceCompatibility(race1, race2);
+};
+exports.getPlayerCompatibility = getPlayerCompatibility;
+const ranges = [16, 32, 48, 64, 80, 96];
+function getCareerRanges() {
+    return [0, ...ranges];
+}
+const NB_MAX_PLAYERS = 2;
+function getPlayersAvailableForPromo(players = []) {
+    const playersByState = getPlayersByState(players);
+    return [...playersByState.actives, ...playersByState.lastRetired].slice(0, NB_MAX_PLAYERS);
+}
+function getPromoCareer(careerId, userPlayers) {
+    const race = getRaceFromCareer(careerId);
+    let promo = userPlayers
+        .filter((p, i) => p && i < NB_MAX_PLAYERS && getRaceFromPlayer(p) === race)
+        .reduce((p, c) => c.pc + p, 0);
+    const price = getPriceCareer(careerId);
+    if (promo > price / 2) {
+        promo = price / 2;
+    }
+    return promo;
+}
+function getPriceCareer(careerId) {
+    return getCareerRanges()[getCareerFromKey(careerId).range];
+}
+function getTeamGroups(team) {
+    const groups = {};
+    for (const player of team.players) {
+        const group = getPlayerGroup(player);
+        if (!group) {
+            continue;
+        }
+        if (!groups[group]) {
+            groups[group] = [];
+        }
+        groups[group].push(player);
+    }
+    return groups;
+}
+function isPlayerNeutralGroup(player) {
+    const group = getPlayerGroup(player);
+    const neutrals = [GROUP_NAME.NEUTRAL];
+    return neutrals.includes(group);
+}
+function isNeutralGroup(group) {
+    const neutrals = [GROUP_NAME.NEUTRAL];
+    return neutrals.includes(group);
+}
+function getTeamIncompatibleGroups(team) {
+    const groups = getTeamGroups(team);
+    // return array of [name, players]: [['group-vicious', Array(8)], ...]
+    return Object.entries(groups).filter((group) => !isNeutralGroup(group[0]));
+}
+const getPlayersByState = (players) => {
+    const playerActives = [];
+    const playerInactives = [];
+    for (const p of players) {
+        if ((0, state_1.canBeSelectedByUser)(p.state)) {
+            playerActives.push(p);
+        }
+        else {
+            playerInactives.push(p);
+        }
+    }
+    return {
+        actives: playerActives,
+        inactives: playerInactives,
+        // Check if works (.toString())
+        lastRetired: playerInactives.sort((a, b) => Date.parse(b.connectedAt.toString()) -
+            Date.parse(a.connectedAt.toString())),
+    };
+};
+exports.getPlayersByState = getPlayersByState;

package/dist/random.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.d3 = d3;
+exports.d6 = d6;
+exports.d8 = d8;
+exports.getRandomItem = getRandomItem;
+exports.getRandomNumber = getRandomNumber;
+exports.shuffleArray = shuffleArray;
+const rollDice = (quantity, max) => {
+    let total = 0;
+    for (let i = 0; i < quantity; ++i) {
+        total += getRandomNumber.call(this, 1, max);
+    }
+    return total;
+};
+function shuffleArray(array) {
+    return [...array].sort(() => 0.5 - Math.random());
+}
+function getRandomItem(arr) {
+    const randomIndex = Math.floor(Math.random() * arr.length);
+    const item = arr[randomIndex];
+    return item;
+}
+function getRandomNumber(min, max, r = Math.random) {
+    return Math.floor(r() * (max - min + 1)) + min;
+}
+function d8(quantity = 1, max = 8) {
+    return rollDice(quantity, max);
+}
+function d6(quantity = 1, max = 6) {
+    return rollDice(quantity, max);
+}
+function d3(quantity = 1, max = 3) {
+    return rollDice(quantity, max);
+}

package/dist/right.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canCancelGame = canCancelGame;
+exports.canChangeCoach = canChangeCoach;
+exports.canCreateTeam = canCreateTeam;
+exports.canJoinTeam = canJoinTeam;
+exports.canPayPlayer = canPayPlayer;
+exports.canQuitTeam = canQuitTeam;
+exports.canRemovePlayer = canRemovePlayer;
+exports.canRetirement = canRetirement;
+const game_1 = require("./game");
+const index_1 = require("./index");
+const player_1 = require("./player");
+const skill_1 = require("./skill");
+const state_1 = require("./state");
+function canJoinTeam(player, team) {
+    if ((0, skill_1.getSkillLimitSizeTeam)(player, team.players) !== null) {
+        return false;
+    }
+    return (team &&
+        (0, state_1.isTeamActive)(team.state) &&
+        team.players.length < index_1.MAX_PLAYER_TEAM &&
+        player &&
+        !player.isCoach &&
+        !(0, player_1.isPlaying)(player) &&
+        (!player.teamId || team.id !== player.teamId) &&
+        (0, state_1.canJoinTeamWithState)(player.state));
+}
+function canCreateTeam(player) {
+    return player && !player.teamId && (0, state_1.canJoinTeamWithState)(player.state);
+}
+function canQuitTeam(player) {
+    return player && player.teamId && !(0, player_1.isPlaying)(player);
+}
+function canRemovePlayer(player, coach) {
+    return (coach.isCoach &&
+        player.id !== coach.id &&
+        player.teamId &&
+        player.teamId === coach.teamId &&
+        !(0, player_1.isPlaying)(player));
+}
+function canPayPlayer(player, coach, team) {
+    return (coach.isCoach &&
+        player.teamId &&
+        player.teamId === coach.teamId &&
+        !(0, player_1.isPlaying)(player) &&
+        team.po > 0 &&
+        player.moral < 100);
+}
+function canChangeCoach(player, coach) {
+    return (player && coach && player.id !== coach.id && player.teamId === coach.teamId);
+}
+function canCancelGame(game, player) {
+    return (game &&
+        player &&
+        game.status === game_1.GAME_STATUS.WAITING &&
+        player.isCoach &&
+        game.team1.id === player.teamId);
+}
+function canRetirement(player) {
+    return player && !player.teamId && (0, state_1.isActive)(player.state);
+}