Source: classes/Match.js

  1. /**
  2.  * @class Match
  3.  * @param {string} team1 Team number of the first team (red)
  4.  * @param {string} team2 Team number of the second team (red)
  5.  * @param {string} team3 Team number of the third team (red)
  6.  * @param {string} team4 Team number of the fourth team (blue)
  7.  * @param {string} team5 Team number of the fifth team (blue)
  8.  * @param {string} team6 Team number of the sixth team (blue)
  9.  */
  10. class Match {
  11.   /**
  12.    * @constructor
  13.    * @param {string} team1 Team number of the first team (red)
  14.    * @param {string} team2 Team number of the second team (red)
  15.    * @param {string} team3 Team number of the third team (red)
  16.    * @param {string} team4 Team number of the fourth team (blue)
  17.    * @param {string} team5 Team number of the fifth team (blue)
  18.    * @param {string} team6 Team number of the sixth team (blue)
  19.    */
  20.   constructor(team1, team2, team3, team4, team5, team6) {
  21.     this.archive = false;
  22.     this.redAlliance = new Alliance(this, RED, team1, team2, team3);
  23.     this.blueAlliance = new Alliance(this, BLUE, team4, team5, team6);
  25.     this.events = [];
  27.     this.mode = {
  28.       auto: true,
  29.       teleop: false,
  31.       isAuto() {
  32.         return this.auto;
  33.       },
  35.       isTeleop() {
  36.         return !this.auto;
  37.       },
  38.     };
  40.     /**
  41.      * @object Timer
  42.      * @property {Match} match - The match that the timer is in
  43.      * @property {number} time - The current time of the timer
  44.      * @property {boolean} running - Whether the timer is running or not
  45.      * @property {number} autoLength - The length of the auto period in seconds
  46.      * @property {number} matchLength - The length of the match in seconds
  47.      * @memberof Match
  48.      */
  49.     this.timer = {
  50.       match: this,
  51.       time: 0,
  52.       // Whether the timer is running or not
  53.       running: false,
  54.       autoLength: 15, // seconds
  55.       matchLength: 135, // 2:15 in seconds
  56.       // whether we are in auto or teleop
  57.       lastUpdate: Date.now(),
  58.       deltaTime: 0,
  60.       /**
  61.        * @method reset
  62.        * @description Reset the timer to 0
  63.        * @memberof Timer
  64.        */
  65.       reset() {
  66.         this.time = 0;
  67.         this.running = false;
  68.       },
  70.       /**
  71.        * @method play
  72.        * @description Start the timer
  73.        * @memberof Timer
  74.        */
  75.       play() {
  76.         if (this.time < this.matchLength) this.running = true;
  77.       },
  79.       /**
  80.        * @method pause
  81.        * @description Pause the timer
  82.        * @memberof Timer
  83.        */
  84.       pause() {
  85.         this.running = false;
  86.       },
  88.       /**
  89.        * @method toggle
  90.        * @description Toggle the timer
  91.        * @memberof Timer
  92.        */
  93.       toggle() {
  94.         if (this.time < this.matchLength) this.running = !this.running;
  95.       },
  97.       /**
  98.        * @method setTime
  99.        * @description Set the time of the timer
  100.        * @param {number} time The time to set the timer to
  101.        * @memberof Timer
  102.        */
  103.       setTime(time) {
  104.         this.time = time;
  105.       },
  107.       /**
  108.        * @method delta
  109.        * @description Calculate the delta time
  110.        * @memberof Timer
  111.        * @returns {number} The delta time
  112.        */
  113.       delta() {
  114.         const now = Date.now();
  115.         this.deltaTime = (now - this.lastUpdate) / 1000;
  116.         this.lastUpdate = now;
  117.         return this.deltaTime;
  118.       },
  120.       /**
  121.        * @method update
  122.        * @description Update the timer
  123.        * @memberof Timer
  124.        */
  125.       update() {
  126.         // update the timer
  127.         this.delta(); // calculate the delta time
  129.         if (this.running) {
  130.           // increment the timer
  131.           this.time += this.deltaTime;
  132.         }
  133.         if (this.time > this.matchLength) {
  134.           // set the timer to the max time
  135.           this.time = this.matchLength;
  136.           this.running = false;
  137.         }
  139.         // update the game state
  140.         if (this.time > this.autoLength) {
  141.           // change the game state to teleop
  142.           this.match.mode.auto = false;
  143.         } else {
  144.           // change the game state to auto
  145.           this.match.mode.auto = true;
  146.         }
  148.         // update the timer on the user interface
  149.         UserInterface.updateTimer(this.toString());
  151.         // update the play/pause button
  152.         UserInterface.playing(this.running);
  154.         // update "Mobility Bonus" button's status
  155.         UserInterface.updateMobilityBonus(this.match.mode.isAuto());
  157.         // update UI for inventories
  158.         UserInterface.updateRobotInventories();
  159.       },
  161.       /**
  162.        * @method toString
  163.        * @description Convert the timer to a string
  164.        * @memberof Timer
  165.        * @returns {string} The timer as a string
  166.        */
  167.       toString() {
  168.         // Calculate minutes from time
  169.         const minutes = Math.floor(this.time / 60);
  170.         // Calculate seconds from time
  171.         const seconds = Math.floor(this.time % 60);
  172.         // Calculate milliseconds from time
  173.         const milliseconds = Math.floor((this.time % 1) * 100);
  174.         // Return a formatted string
  175.         return `${minutes.toString()}:${seconds
  176.           .toString()
  177.           .padStart(2, "0")}.${milliseconds.toString().padStart(2, "0")}`;
  178.       },
  179.     };
  181.     /**
  182.      * @object Scoring
  183.      * @typedef {Object} Scoring
  184.      * @memberof Match
  185.      */
  186.     this.scoring = {
  187.       /**
  188.        * @method fieldState
  189.        * @description Get the current state of the field
  190.        * @memberof Scoring
  191.        * @returns {Object} The current state of the field, which includes the scoring grid and the score
  192.        */
  193.       getFieldState(events) {
  194.         // Create an object that represents the scoring grid
  195.         const scoringGrid = {
  196.           red: new Array(27).fill([]), // 9x3 grid
  197.           blue: new Array(27).fill([]), // 9x3 grid
  198.         };
  200.         // Create an object to keep track of the score for each alliance
  201.         const score = {
  202.           red: 0,
  203.           blue: 0,
  204.         };
  206.         // Loop through each event
  207.         for (const event of events) {
  208.           // If the event is a placeGamePiece event
  209.           if (event.type === "placeGamePiece") {
  210.             const { alliance, location, auto } = event;
  211.             // Location is the index of the array
  212.             scoringGrid[alliance][location].push(event.matchPiece);
  213.             // Row is the top, middle, or bottom
  214.             const row = this.getPieceRow(location);
  215.             // autoOrTeleop is "AUTO" or "TELEOP" depending on the time
  216.             const autoOrTeleop = auto ? "AUTO" : "TELEOP";
  217.             // Add the points to the score
  218.             score[alliance] += POINT_VALUES[autoOrTeleop].match_PIECES[row];
  219.           }
  221.           // If the event is a mobilityBonus event
  222.           if (event.type === "mobilityBonus") {
  223.             const { alliance, auto } = event;
  224.             if (auto) {
  225.               score[alliance] += POINT_VALUES.AUTO.MOBILITY;
  226.             } else {
  227.               throw new Error("Mobility bonus can only be awarded in auto");
  228.             }
  229.           }
  230.         }
  232.         // Calculate the link bonus for each alliance
  233.         score.red += this.calculateLinkBonus(scoringGrid.red);
  234.         score.blue += this.calculateLinkBonus(scoringGrid.blue);
  236.         return {
  237.           scoringGrid,
  238.           score,
  239.         };
  240.       },
  242.       /**
  243.        * @method calculateLinkBonus
  244.        * @description Calculate the link bonus for an alliance
  245.        * @memberof Scoring
  246.        * @param {Array} scoringGrid The scoring grid for an alliance
  247.        * @returns {number} The link bonus for the alliance
  248.        */
  249.       calculateLinkBonus(scoringGrid) {
  250.         let score = 0;
  252.         let count = 0;
  253.         let iteration = 0;
  255.         for (const gamePiece of scoringGrid) {
  256.           // Reset on new row
  257.           if (iteration % 9 === 0) {
  258.             count = 0;
  259.           }
  261.           // If the game piece is not empty
  262.           if (gamePiece !== EMPTY) {
  263.             count++;
  264.           } else {
  265.             count = 0;
  266.           }
  268.           // If we have 3 in a row
  269.           if (count === 3) {
  270.             // Add the link bonus
  271.             score += POINT_VALUES.TELEOP.LINK;
  272.             // Reset the count
  273.             count = 0;
  274.           }
  276.           iteration++;
  277.         }
  279.         return score;
  280.       },
  282.       /**
  283.        * @method getPieceRow
  284.        * @description Get the row of a piece
  285.        * @memberof Scoring
  286.        * @param {number} piece The piece to get the row of
  287.        * @returns {string} The row of the piece
  288.        */
  289.       getPieceRow(piece) {
  290.         if (piece < 9 * (TOP + 1)) {
  291.           return "TOP";
  292.         } else if (piece < 9 * (MIDDLE + 1)) {
  293.           return "MIDDLE";
  294.         }
  295.         return "BOTTOM";
  296.       },
  297.     };
  298.   }
  300.   /**
  301.    * @method start
  302.    * @description Start the match
  303.    * @memberof Match
  304.    */
  305.   start() {
  306.     this.timer.start();
  307.   }
  309.   /**
  310.    * @method reset
  311.    * @description Reset the match
  312.    * @memberof Match
  313.    */
  314.   reset() {
  315.     this.timer.reset();
  316.     if (!this.archive) {
  317.       this.events = [];
  318.       this.redAlliance.reset();
  319.       this.blueAlliance.reset();
  320.     }
  321.   }
  323.   /**
  324.    * @method update
  325.    * @description Update the match
  326.    * @memberof Match
  327.    */
  328.   update() {
  329.     // update the timer element
  330.     this.timer.update();
  332.     UserInterface.updateGameState(this.mode.isTeleop() ? "TELEOP" : "AUTO");
  333.   }
  335.   /**
  336.    * @method setupTeamButtons
  337.    * @description Set up the team buttons
  338.    * @memberof Match
  339.    */
  340.   setupTeamButtons() {
  341.     for (let color of ["red", "blue"]) {
  342.       for (let i = 1; i <= 3; i++) {
  343.         let btn = document.querySelector(
  344.           `button[data-alliance=${color}][data-team-index="${i}"]`
  345.         );
  346.         let alliance = color === "red" ? this.redAlliance : this.blueAlliance;
  347.         let team = alliance.robots[i - 1].team;
  348.         btn.innerHTML = team;
  349.         btn.setAttribute("team-number", team);
  350.       }
  351.     }
  352.   }
  354.   /**
  355.    * @method getRobot
  356.    * @description Gets a robot
  357.    * @memberof Match
  358.    * @param {object} robot robot data
  359.    * @returns {Robot | null}
  360.    */
  361.   getRobot(robot) {
  362.     if (!robot) return null;
  363.     let alliance = robot.color === RED ? this.redAlliance : this.blueAlliance;
  364.     let team = alliance.robots.find((x) => x.team === robot.teamNumber);
  365.     return team;
  366.   }
  368.   /**
  369.    * @method serialize
  370.    * @description Converts the match to JSON
  371.    * @memberof Match
  372.    * @returns {string}
  373.    */
  374.   serialize() {
  375.     let obj = {
  376.       archive: this.archive,
  377.     };
  378.     obj.events = this.events.map((x) => ({
  379.       robot: x.robot.team,
  380.       eventType: x.eventType,
  381.     }));
  382.     obj.redAlliance = {
  383.       color: this.redAlliance.color,
  384.       robots: this.redAlliance.robots.map((x) => ({
  385.         team: x.team,
  386.         startingPosition: x.startingPosition,
  387.       })),
  388.     };
  389.     obj.blueAlliance = {
  390.       color: this.blueAlliance.color,
  391.       robots: this.blueAlliance.robots.map((x) => ({
  392.         team: x.team,
  393.         startingPosition: x.startingPosition,
  394.       })),
  395.     };
  396.     return JSON.stringify(obj);
  397.   }
  399.   /**
  400.    * @function deserialize
  401.    * @description Converts a JSON representation of a match to the match itself
  402.    * @memberof Match
  403.    * @static
  404.    * @param {string} jsonRepresentation the JSON representation
  405.    * @returns {Match}
  406.    */
  407.   static deserialize(jsonRepresentation) {
  408.     let obj = JSON.parse(jsonRepresentation);
  409.     let teamNumbers = obj.redAlliance.robots
  410.       .concat(obj.blueAlliance.robots)
  411.       .map((x) => x.team);
  412.     let match = new Match(...teamNumbers);
  413.     for (let event of obj.events) {
  414.       let color = obj.redAlliance.robots
  415.         .map((x) => x.team)
  416.         .includes(event.robot)
  417.         ? RED
  418.         : BLUE;
  419.       match.events.push(
  420.         new Event(
  421.           match,
  422.           match.getRobot({ color: color, teamNumber: event.robot }),
  423.           event.eventType
  424.         )
  425.       );
  426.     }
  427.     return match;
  428.   }
  429. }