v1.26.1 - Fix protest matters calculation (#275)

- Fix protest matters calculation (#266)
- Fix issue with debugging unit tests
- Bump version to 1.26.1

Author: alopezlago

.vscode/launch.json

@@ -19,12 +19,13 @@
                 "-r",
                 "tsconfig-paths/register"
             ],
-            "internalConsoleOptions": "openOnSessionStart",
+            "internalConsoleOptions": "neverOpen",
             "name": "Mocha Tests",
             "program": "${workspaceFolder}/node_modules/mocha/bin/_mocha",
             "request": "launch",
             "skipFiles": ["<node_internals>/**"],
-            "type": "pwa-node"
+            "type": "node",
+            "console": "integratedTerminal"
         },
         {
             "type": "chrome",

.vscode/settings.json

@@ -1,7 +1,7 @@
 {
     "editor.formatOnSave": true,
     "editor.codeActionsOnSave": {
-        "source.fixAll.eslint": true
+        "source.fixAll.eslint": "explicit"
     },
     "editor.defaultFormatter": "esbenp.prettier-vscode",
     "[javascript]": {

package.json

@@ -1,6 +1,6 @@
 {
     "name": "modaq",
-    "version": "1.26.0",
+    "version": "1.26.1",
     "description": "Quiz Bowl Reader using TypeScript, React, and MobX",
     "repository": {
         "type": "git",

src/state/GameState.ts

@@ -206,11 +206,48 @@ export class GameState {
                     const tossup: Tossup | undefined = this.packet.tossups[tossupProtest.questionIndex];
 
                     if (tossup != undefined) {
-                        const tossupTeamIndex: number = tossupProtest.teamName === this.teamNames[0] ? 0 : 1;
+                        let tossupTeamIndex: number = tossupProtest.teamName === this.teamNames[0] ? 0 : 1;
+                        if (cycle.correctBuzz) {
+                            // If the correct buzz is for the protesting team, then this should be for "against"
+                            if (
+                                cycle.correctBuzz.tossupIndex === tossupProtest.questionIndex &&
+                                cycle.correctBuzz.marker.player.teamName === tossupProtest.teamName
+                            ) {
+                                tossupTeamIndex = 1 - tossupTeamIndex;
+                            }
+
+                            // We have a correct buzz... we need to discount this buzz for the other team, plus any
+                            // bonus they got
+                            const correctTossupPoints = tossup.getPointsAtPosition(
+                                this.gameFormat,
+                                tossupProtest.position,
+                                /* isCorrect */ true
+                            );
+
+                            // Need to include correct parts and bouncebacks (the -1 * current.points part)
+                            const bonusPoints =
+                                cycle.bonusAnswer?.parts.reduce(
+                                    (previous, current) =>
+                                        (cycle.correctBuzz?.marker.player.teamName === current.teamName
+                                            ? current.points
+                                            : -1 * current.points) + previous,
+                                    0
+                                ) ?? 0;
+
+                            swings[1 - tossupTeamIndex].against += correctTossupPoints + bonusPoints;
+                        }
+
+                        const bonusIndex: number = this.getBonusIndex(i);
+                        const potentialBonusPoints = this.packet.bonuses[bonusIndex].parts.reduce(
+                            (previous, current) => current.value + previous,
+                            0
+                        );
+
                         // Need to remove the neg (subtract) and add what the correct value would be
                         swings[tossupTeamIndex].for +=
                             tossup.getPointsAtPosition(this.gameFormat, tossupProtest.position, /* isCorrect */ true) -
-                            tossup.getPointsAtPosition(this.gameFormat, tossupProtest.position, /* isCorrect */ false);
+                            tossup.getPointsAtPosition(this.gameFormat, tossupProtest.position, /* isCorrect */ false) +
+                            potentialBonusPoints;
                     }
                 }
             }
@@ -230,11 +267,11 @@ export class GameState {
                             swings[bonusTeamIndex].against += value;
                         }
                     }
-                    bonusProtest.partIndex;
                 }
             }
         }
 
+        // [Best outcome for team 1, best outcome for team 2]
         return [
             [this.finalScore[0] + swings[0].for, this.finalScore[1] - swings[1].against],
             [this.finalScore[0] - swings[0].against, this.finalScore[1] + swings[1].for],

tests/ProtestsMatterTests.ts

@@ -3,6 +3,7 @@ import { expect } from "chai";
 import { Player } from "src/state/TeamState";
 import { GameState } from "src/state/GameState";
 import { PacketState, Tossup, Bonus } from "src/state/PacketState";
+import { Cycle } from "src/state/Cycle";
 
 const firstTeamPlayer: Player = new Player("Alice", "A", /* isStarter */ true);
 const secondTeamPlayer: Player = new Player("Bob", "B", /* isStarter */ true);
@@ -62,6 +63,7 @@ describe("GameStateTests", () => {
         });
         it("Uneven game, protests don't matter", () => {
             const game: GameState = createDefaultGame();
+            // 20-0
             game.cycles[0].addCorrectBuzz(
                 { player: firstTeamPlayer, points: 10, position: 2, isLastWord: false },
                 0,
@@ -71,6 +73,7 @@ describe("GameStateTests", () => {
             );
             game.cycles[0].setBonusPartAnswer(0, firstTeamPlayer.teamName, 10);
 
+            // 60-0
             game.cycles[1].addCorrectBuzz(
                 { player: firstTeamPlayer, points: 10, position: 1, isLastWord: false },
                 0,
@@ -79,8 +82,10 @@ describe("GameStateTests", () => {
                 1
             );
             game.cycles[1].setBonusPartAnswer(0, firstTeamPlayer.teamName, 10);
+            game.cycles[1].setBonusPartAnswer(1, firstTeamPlayer.teamName, 10);
+            game.cycles[1].setBonusPartAnswer(2, firstTeamPlayer.teamName, 10);
 
-            // 40-0, so 15 points here and 10 points shouldn't make up for 40-10
+            // 60-0, so 10 + 30 points here and 10 points shouldn't make up for 60-0
             game.cycles[2].addWrongBuzz(
                 { player: secondTeamPlayer, points: -5, position: 1, isLastWord: false },
                 2,
@@ -180,6 +185,8 @@ describe("GameStateTests", () => {
         });
         it("Uneven game, bonus protest matters (against)", () => {
             const game: GameState = createDefaultGame();
+
+            // 20-0, one protest
             game.cycles[0].addCorrectBuzz(
                 { player: firstTeamPlayer, points: 10, position: 2, isLastWord: false },
                 0,
@@ -190,6 +197,7 @@ describe("GameStateTests", () => {
             game.cycles[0].setBonusPartAnswer(0, firstTeamPlayer.teamName, 10);
             game.cycles[0].addBonusProtest(0, 0, "My answer", "My reason", secondTeamPlayer.teamName);
 
+            // 20-10, one bonus protest (should tie since protest against correctness)
             game.cycles[1].addCorrectBuzz(
                 { player: secondTeamPlayer, points: 10, position: 1, isLastWord: false },
                 0,
@@ -220,6 +228,79 @@ describe("GameStateTests", () => {
             game.cycles[3].addTossupProtest(secondTeamPlayer.teamName, 2, 1, "My answer", "My reason");
             expect(game.protestsMatter).to.be.true;
         });
+        it("Uneven game, tossup with bonus for other team would swing it", () => {
+            const packet: PacketState = new PacketState();
+            packet.setTossups([
+                new Tossup("first q", "first a"),
+                new Tossup("second q", "second a"),
+                new Tossup("third q", "third a"),
+                new Tossup("fourth q", "fourth a"),
+            ]);
+            packet.setBonuses([
+                new Bonus("first leadin", [
+                    { question: "first q", answer: "first a", value: 10 },
+                    { question: "first q2", answer: "first a2", value: 10 },
+                    { question: "first q3", answer: "first a3", value: 10 },
+                ]),
+                new Bonus("second leadin", [
+                    { question: "second q", answer: "second a", value: 10 },
+                    { question: "second q2", answer: "second a2", value: 10 },
+                    { question: "second q3", answer: "second a3", value: 10 },
+                ]),
+                new Bonus("third leadin", [
+                    { question: "third q", answer: "third a", value: 10 },
+                    { question: "third q2", answer: "third a2", value: 10 },
+                    { question: "third q3", answer: "third a3", value: 10 },
+                ]),
+            ]);
+
+            const game: GameState = new GameState();
+            game.addNewPlayers(players);
+            game.loadPacket(defaultPacket);
+
+            // 30-0
+            const firstCycle: Cycle = game.cycles[0];
+            firstCycle.addCorrectBuzz(
+                { player: firstTeamPlayer, points: 10, position: 2, isLastWord: false },
+                0,
+                game.gameFormat,
+                0,
+                3
+            );
+            firstCycle.setBonusPartAnswer(0, firstTeamPlayer.teamName, 10);
+            firstCycle.setBonusPartAnswer(1, firstTeamPlayer.teamName, 10);
+            expect(game.protestsMatter).to.be.false;
+
+            // 25-40, but protest neg
+            const secondCycle: Cycle = game.cycles[1];
+            secondCycle.addWrongBuzz(
+                { player: firstTeamPlayer, points: -5, position: 1, isLastWord: false },
+                1,
+                game.gameFormat
+            );
+            secondCycle.addTossupProtest(firstTeamPlayer.teamName, 2, 1, "My answer", "My reason");
+            secondCycle.addCorrectBuzz(
+                { player: secondTeamPlayer, points: 10, position: 2, isLastWord: false },
+                1,
+                game.gameFormat,
+                1,
+                3
+            );
+            secondCycle.setBonusPartAnswer(0, secondTeamPlayer.teamName, 10);
+            secondCycle.setBonusPartAnswer(1, secondTeamPlayer.teamName, 10);
+            expect(game.protestsMatter).to.be.true;
+
+            // 25-50... protestMatter should still be true, since the protest in the second question should flip it
+            const thirdCycle: Cycle = game.cycles[2];
+            thirdCycle.addCorrectBuzz(
+                { player: secondTeamPlayer, points: 10, position: 2, isLastWord: false },
+                2,
+                game.gameFormat,
+                2,
+                3
+            );
+            expect(game.protestsMatter).to.be.true;
+        });
     });
 });