enefel 1.0.96 → 1.0.100

package/calcul.js

@@ -0,0 +1,8 @@
+const distance = (p1, p2) => {
+  return Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2));
+};
+
+const distanceSquares = (p1, p2, distance) => {
+  return Math.abs(p1.x - p2.x) <= distance && Math.abs(p1.y - p2.y) <= distance;
+};
+module.exports = { distance, distanceSquares };

package/index.js

@@ -1,4 +1,8 @@
-const { hasSkill, SKILL_NAMES } = require("./skill");
+const {
+  hasSkill,
+  SKILL_NAMES,
+  getDisturbingPresenceMalus,
+} = require("./skill");
 const { ranges } = require("./improvement");
 const races = require("./race");
 const {
@@ -14,6 +18,7 @@ const {
   meteoMaxPassDistance,
   METEO,
 } = require("./meteo");
+const { distance } = require("./calcul");
 const INITIAL_REROLL = 2;
 const POSTULATION_HOURS = 24;
 const INACTIVE_DAYS = 10;
@@ -207,6 +212,7 @@ const GAME_TYPE = {
   DIVISION: "division",
   FRIENDLY: "friendly",
   OPEN: "open",
+  PLAYOFF: "playoff",
 };
 
 const TAKE_BALL_TYPE = {
@@ -580,10 +586,6 @@ const availableSquaresToPushBack = (p1, p2) => {
   }
 };
 
-const distance = (p1, p2) => {
-  return Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2));
-};
-
 // playerFrom, pointTo, foe
 const isOnLine = (A, B, C) => {
   //http://www.luccini.it/bloodbowl/downloads/Tabella_Intercetti.pdf
@@ -673,7 +675,8 @@ const getBestInterceptor = (playerFrom, pointTo, players) => {
   let bestAGPlayers = [];
   possiblePlayers.forEach((player) => {
     const zdt = getEnemyTackleZones(player, player.teamId, players).length;
-    if (player.current_AG - zdt > bestAG) {
+    const disturbingPresence = getDisturbingPresenceMalus(player, players);
+    if (player.current_AG - zdt - disturbingPresence > bestAG) {
       bestAG = player.current_AG - zdt;
       bestAGPlayers = [];
       bestAGPlayers.push(player);
@@ -875,8 +878,27 @@ const getDefenderStrength = (player) => {
   return player.current_ST;
 };
 
+const arrayMove = (arr, old_index, new_index) => {
+  if (new_index >= arr.length) {
+    var k = new_index - arr.length + 1;
+    while (k--) {
+      arr.push(undefined);
+    }
+  }
+  arr.splice(new_index, 0, arr.splice(old_index, 1)[0]);
+  return arr; // for testing
+};
+
+const swapArrayLocs = (arr, index1, index2) => {
+  var temp = arr[index1];
+
+  arr[index1] = arr[index2];
+  arr[index2] = temp;
+
+  return arr;
+};
+
 module.exports = {
-  getDefenderStrength,
   addSeconds,
   availableSquaresToPushBack,
   canBlock,
@@ -889,7 +911,6 @@ module.exports = {
   canStandup,
   canThrowTeamMate,
   canTransmit,
-  distance,
   FORMATION_DEFAULT_NAME,
   GAME_HISTORY_INFO,
   GAME_HISTORY_TYPE,
@@ -899,6 +920,7 @@ module.exports = {
   getBestInterceptor,
   getBlockAssistance,
   getCareers,
+  getDefenderStrength,
   getDicesBlock,
   getEnemyTackleZones,
   getMaxGfi,
@@ -920,11 +942,13 @@ module.exports = {
   LAST_SEASON_ALPHA,
   MAX_PLAYER_TEAM,
   MAX_PLAYER_USER,
+  swapArrayLocs,
   p,
   PLAYER_HISTORY_INFO,
   PLAYER_HISTORY_TYPE,
   PLAYER_STAT,
   POSTULATION_HOURS,
   shuffleArray,
+  arrayMove,
   TAKE_BALL_TYPE,
 };

package/league.js

@@ -1,15 +1,72 @@
-const { isTeamActive } = require("./state");
+const { GAME_TYPE } = require(".");
+const { canPlayLeague } = require("./state");
 
 const GROUP_SIZE = 4;
+const HAS_NEXT_SEASON_PLAYOFF = true;
+
+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];
+      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;
+    }
+  }
 
-const LEAGUE_NAME = {
-  OPEN: "open",
-  FRIENDLY: "friendly",
+  // 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 (i = 0; i < size; i++) {
+    for (j = i + 1; j < size; j++) {
+      if (flatedTeams[j].elo > flatedTeams[i].elo) {
+        let temp = flatedTeams[i];
+        flatedTeams[i] = flatedTeams[j];
+        flatedTeams[j] = temp;
+      }
+    }
+  }
+  // On met ensemble le 1, 3, 5, 7  et 2, 4, 6, 8 (B)
+  for (i = 1; i < GROUP_SIZE; i += 2) {
+    let temp = flatedTeams[i];
+    flatedTeams[i] = flatedTeams[i + GROUP_SIZE - 1];
+    flatedTeams[i + GROUP_SIZE - 1] = temp;
+  }
+  return flatedTeams;
 };
 
-const calculateTeamsStandingForNextSeason = (division) => {
-  // Standing division should be sorted (1, 2, 3, ... , open)
-  const newStandings = JSON.parse(JSON.stringify(division));
+const calculateTeamsStandingForLeagues = (newStandings, division) => {
   for (let i = 0; i < division.length - 1; ++i) {
     const currentDivision = newStandings[i];
     const nextDivision = newStandings[i + 1];
@@ -18,10 +75,8 @@ const calculateTeamsStandingForNextSeason = (division) => {
       currentDivision.teams[currentDivision.teams.length - 1];
 
     let indexNextDivisionFirstTeam = 0;
-    if (nextDivision.name === LEAGUE_NAME.FRIENDLY) {
-      continue;
-    }
-    if (nextDivision.name === LEAGUE_NAME.OPEN) {
+
+    if (nextDivision.name === GAME_TYPE.OPEN) {
       // To avoid some teams block the open, we take the first team with canChampionship
       indexNextDivisionFirstTeam = nextDivision.teams.findIndex(
         (t) => t.canChampionship
@@ -33,38 +88,89 @@ const calculateTeamsStandingForNextSeason = (division) => {
     const nextDivisionFirstTeam =
       nextDivision.teams[indexNextDivisionFirstTeam];
 
-    currentDivision.teams[
-      currentDivision.teams.length - 1
-    ] = nextDivisionFirstTeam;
+    currentDivision.teams[currentDivision.teams.length - 1] =
+      nextDivisionFirstTeam;
 
     nextDivision.teams[indexNextDivisionFirstTeam] = currentDivisionLastTeam;
   }
   const flatTeams = newStandings
     .reduce((p, c) => [...p, ...c.teams], [])
-    .filter((t) => t && isTeamActive(t.state));
+    .filter((t) => t && canPlayLeague(t));
 
   return flatTeams;
 };
 
+const calculateTeamsStandingForNextSeason = (division) => {
+  division = division.filter(
+    (d) => d.name !== GAME_TYPE.FRIENDLY && d.name !== 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 && canPlayLeague(t));
+
+  if (HAS_NEXT_SEASON_PLAYOFF && GROUP_SIZE * 3 >= flatTeams.length) {
+    return calculateTeamsStandingForPlayoff(flatTeams, division);
+  }
+  return calculateTeamsStandingForLeagues(newStandings, division);
+};
+
 const forcastNextSeason = (flatTeams) => {
+  // debugger;
   let groups = [];
   let open = [];
   let currentGroup = [];
+  let i = 0;
   flatTeams.forEach((team) => {
     if (!team) {
       return;
     }
-    if (!team.canChampionship) {
+    // En playoff on n'a que les ligues A et B + open
+    if (!team.canChampionship || i >= 2) {
       open.push(team);
       return;
     }
     currentGroup.push(team);
 
+    if (currentGroup.length === GROUP_SIZE) {
+      groups = [...groups, currentGroup];
+      currentGroup = [];
+      ++i;
+    }
+  });
+  open = [...currentGroup, ...open];
+
+  if (open.length < GROUP_SIZE) {
+    const lastDivision = groups.pop();
+    if (lastDivision) {
+      open = [...lastDivision, ...open];
+    }
+  }
+  groups = [...groups, open];
+  return { hasPlayoffs: false, groups };
+};
+
+const playoffNextSeason = (flatTeams) => {
+  let groups = [];
+  let open = [];
+  let currentGroup = [];
+
+  // Creation de groupe de 4
+  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 < GROUP_SIZE) {
@@ -74,7 +180,12 @@ const forcastNextSeason = (flatTeams) => {
     }
   }
   groups = [...groups, open];
-  return groups;
+
+  if (HAS_NEXT_SEASON_PLAYOFF === false || groups.length < 3) {
+    return forcastNextSeason(flatTeams);
+  }
+
+  return { hasPlayoffs: true, groups };
 };
 
 function round(r, teams) {
@@ -105,26 +216,32 @@ function tournament(teams) {
 }
 
 function hasCalendar(league) {
-  return (
-    league.name !== LEAGUE_NAME.OPEN && league.name !== LEAGUE_NAME.FRIENDLY
-  );
+  return league.name !== GAME_TYPE.OPEN && league.name !== GAME_TYPE.FRIENDLY;
 }
 
 function sortLeagues(a, b) {
-  if (a.name < b.name || b.name === LEAGUE_NAME.FRIENDLY) {
+  if (a.name < b.name || b.name === GAME_TYPE.FRIENDLY) {
     return -1;
   }
-  if (a.name > b.name || a.name === LEAGUE_NAME.FRIENDLY) {
+  if (a.name > b.name || a.name === GAME_TYPE.FRIENDLY) {
     return 1;
   }
   return 0;
 }
 
+function getWinner(game) {
+  // TODO
+  if (game.score1 > game.score2) {
+    return game.team1_id;
+  } else {
+    return game.team2_id;
+  }
+}
 module.exports = {
-  LEAGUE_NAME,
+  getWinner,
   calculateTeamsStandingForNextSeason,
-  forcastNextSeason,
   hasCalendar,
-  tournament,
+  playoffNextSeason,
   sortLeagues,
+  tournament,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "enefel",
-  "version": "1.0.96",
+  "version": "1.0.100",
   "main": "index.js",
   "author": "Manest",
   "license": "MIT",

package/race.js

@@ -33,29 +33,29 @@ module.exports = {
     range: 0,
     cost: 60,
   },
-  // "lizardmen-chameleon": {
-  //   MA: 7,
-  //   ST: 2,
-  //   AG: 3,
-  //   AV: 7,
-  //   normal: "A",
-  //   double: "GPS",
-  //   normalCoach: "G",
-  //   icons: ["lizardmen-chameleon1"],
-  //   skills: [
-  //     SKILL_NAMES.DODGE,
-  //     // SKILL_NAMES.ON_THE_BALL,
-  //     // SKILL_NAMES.SHADOWING,
-  //     SKILL_NAMES.STUNTY,
-  //   ],
-  //   badge: "lizardmen-career",
-  //   range: 1,
-  //   cost: 70,
-  // },
+  "lizardmen-chameleon": {
+    MA: 7,
+    ST: 2,
+    AG: 3,
+    AV: 7,
+    normal: "A",
+    double: "GPS",
+    normalCoach: "G",
+    icons: ["lizardmen-chameleon1"],
+    skills: [
+      SKILL_NAMES.DODGE,
+      SKILL_NAMES.ON_THE_BALL,
+      SKILL_NAMES.SHADOWING,
+      SKILL_NAMES.STUNTY,
+    ],
+    badge: "lizardmen-career",
+    range: 1,
+    cost: 70,
+  },
   "lizardmen-saurus": {
     MA: 6,
     ST: 4,
-    AG: 2,
+    AG: 1,
     AV: 9,
     normal: "GS",
     double: "A",
@@ -69,7 +69,7 @@ module.exports = {
   "lizardmen-kroxigor": {
     MA: 6,
     ST: 5,
-    AG: 2,
+    AG: 1,
     AV: 9,
     normal: "S",
     double: "AG",
@@ -175,7 +175,7 @@ module.exports = {
     icons: ["norse-yhetee1"],
     skills: [
       SKILL_NAMES.CLAW,
-      // SKILL_NAMES.DISTURBING_PRESENCE,
+      SKILL_NAMES.DISTURBING_PRESENCE,
       SKILL_NAMES.FRENZY,
       [SKILL_NAMES.LONER, 4],
       SKILL_NAMES.UNCHANNELLED_FURY,
@@ -199,7 +199,7 @@ module.exports = {
     skills: [SKILL_NAMES.DODGE],
     badge: "amazon-career",
     range: 0,
-    cost: 75,
+    cost: 50,
   },
   "amazon-thrower": {
     MA: 6,

package/skill.js

@@ -1,3 +1,5 @@
+const { distanceSquares } = require("./calcul");
+const { hasStatusOnField } = require("./status");
 const { getTime, TYPE_TIMER } = require("./time");
 
 const BIG_GUY_LIMIT = 1;
@@ -7,6 +9,7 @@ const SPECIALIST_LIMIT = 6;
 const SKILL_INFO_ACTIVE = "active";
 const SKILL_INFO_INACTIVE = "inactive";
 
+// Missing for races
 const SKILL_NAMES = {
   ACCURATE: "accurate",
   ALWAYS_HUNGRY: "always-hungry",
@@ -24,6 +27,7 @@ const SKILL_NAMES = {
   DAUNTLESS: "dauntless",
   DEFENSIVE: "defensive",
   DIRTY_PLAYER: "dirty-player",
+  DISTURBING_PRESENCE: "distrubing-presence",
   DODGE: "dodge",
   DUMP_OFF: "dump-off",
   FEND: "fend",
@@ -38,6 +42,7 @@ const SKILL_NAMES = {
   LONER: "loner",
   MIGHTY_BLOW: "mighty-blow",
   NERVES_OF_STEEL: "nerves-of-steel",
+  ON_THE_BALL: "on-the-ball",
   PASS: "pass",
   PILE_DRIVER: "pile-driver",
   PREHENSILE_TAIL: "prehensile-tail",
@@ -47,6 +52,7 @@ const SKILL_NAMES = {
   RIGHT_STUFF: "right-stuff",
   RUNNING_PASS: "running-pass",
   SAFE_PASS: "safe-pass",
+  SHADOWING: "shadowing",
   SNEAKY_GIT: "sneaky-git",
   SPECIALIST: "specialist",
   SPRINT: "sprint",
@@ -98,6 +104,7 @@ const SKILLS = {
   [SKILL_NAMES.DAUNTLESS]: SKILL_TYPE.GENERAL,
   [SKILL_NAMES.DEFENSIVE]: SKILL_TYPE.AGILITY,
   [SKILL_NAMES.DIRTY_PLAYER]: SKILL_TYPE.GENERAL,
+  [SKILL_NAMES.DISTURBING_PRESENCE]: SKILL_TYPE.MUTATION,
   [SKILL_NAMES.DODGE]: SKILL_TYPE.AGILITY,
   [SKILL_NAMES.DUMP_OFF]: SKILL_TYPE.PASSING,
   [SKILL_NAMES.FEND]: SKILL_TYPE.GENERAL,
@@ -112,6 +119,7 @@ const SKILLS = {
   [SKILL_NAMES.LONER]: SKILL_TYPE.EXTRAORDINARY,
   [SKILL_NAMES.MIGHTY_BLOW]: SKILL_TYPE.STRENGTH,
   [SKILL_NAMES.NERVES_OF_STEEL]: SKILL_TYPE.PASSING,
+  [SKILL_NAMES.ON_THE_BALL]: SKILL_TYPE.PASSING,
   [SKILL_NAMES.PASS]: SKILL_TYPE.PASSING,
   [SKILL_NAMES.PILE_DRIVER]: SKILL_TYPE.STRENGTH,
   [SKILL_NAMES.PREHENSILE_TAIL]: SKILL_TYPE.MUTATION,
@@ -121,6 +129,7 @@ const SKILLS = {
   [SKILL_NAMES.RIGHT_STUFF]: SKILL_TYPE.EXTRAORDINARY,
   [SKILL_NAMES.RUNNING_PASS]: SKILL_TYPE.PASSING,
   [SKILL_NAMES.SAFE_PASS]: SKILL_TYPE.PASSING,
+  [SKILL_NAMES.SHADOWING]: SKILL_TYPE.GENERAL,
   [SKILL_NAMES.SNEAKY_GIT]: SKILL_TYPE.AGILITY,
   [SKILL_NAMES.SPECIALIST]: SKILL_TYPE.EXTRAORDINARY,
   [SKILL_NAMES.SPRINT]: SKILL_TYPE.AGILITY,
@@ -211,6 +220,7 @@ const isActivableSkills = (skill) => {
     SKILL_NAMES.PILE_DRIVER,
     SKILL_NAMES.TENTACLES,
     SKILL_NAMES.WRESTLE,
+    SKILL_NAMES.SHADOWING,
   ];
   return activables.includes(skill);
 };
@@ -254,6 +264,30 @@ function getSkillLimitSizeTeam(player, teamPlayers) {
   return null;
 }
 
+/* 
+DISTURBING PRESENCE
+ When an opposition player performs either a 
+ Pass action,
+ a Throw Team- mate action 
+ or a Throw Bomb Special action,
+ or attempts to either interfere with a pass 
+ or to catch the ball, 
+ they must apply a -1 modifier to the test for each player on your team with this Skill 
+ that is within three squares of them, 
+ even if the player with this Skill is Prone, 
+ Stunned or has lost their Tackle Zone. */
+function getDisturbingPresenceMalus(player, players) {
+  const malus = players.filter((p) => {
+    return (
+      p.teamId !== player.teamId &&
+      hasStatusOnField(p) &&
+      hasSkill(p, SKILL_NAMES.DISTURBING_PRESENCE) &&
+      distanceSquares(player, p, 3)
+    );
+  }).length;
+  return malus;
+}
+
 module.exports = {
   BIG_GUY_LIMIT,
   getPlayersWithSkill,
@@ -268,4 +302,5 @@ module.exports = {
   SKILL_NAMES,
   SKILLS,
   useSkill,
+  getDisturbingPresenceMalus,
 };

package/skillCoach.js

@@ -13,7 +13,7 @@ const SKILL_COACH_TYPE = {
 // TODO: add text translation when add a skill
 const COACH_SKILLS = {
   [SKILL_COACH_NAMES.SPONSOR]: SKILL_COACH_TYPE.GENERAL,
-  [SKILL_COACH_NAMES.SPY]: SKILL_COACH_TYPE.GENERAL,
+  // [SKILL_COACH_NAMES.SPY]: SKILL_COACH_TYPE.GENERAL, // If reactivate, check getCoachSkill hotfix
   [SKILL_COACH_NAMES.THREATENING]: SKILL_COACH_TYPE.GENERAL,
 };
 
@@ -23,6 +23,10 @@ function shouldDisplayInfoInName(skillId) {
 }
 
 function getCoachSkill(player, skillId) {
+  if (skillId === SKILL_COACH_NAMES.SPY) {
+    // Hotfix
+    return false;
+  }
   if (!COACH_SKILLS.hasOwnProperty(skillId)) {
     throw `Skill '${skillId}' does not exist`;
   }