add snake pairing

api/proto/ipc/tournament.proto

@@ -81,6 +81,7 @@ enum PairingMethod {
   MANUAL = 8;
   TEAM_ROUND_ROBIN = 9;
   INTERLEAVED_ROUND_ROBIN = 10;
+  SNAKED_ROUND_ROBIN = 11;
 }
 
 enum FirstMethod {
@@ -113,7 +114,7 @@ message RoundControl {
   bool allow_over_max_repeats = 8;
   int32 repeat_relative_weight = 9;
   int32 win_difference_relative_weight = 10;
-  reserved 11;
+  bool play_within_team = 11;
   // Optional is needed to represent:
   // - `nil` for no override at all
   // - `0` overriding the default to disable the spread cap

liwords-ui/src/gen/api/proto/ipc/tournament_pb.ts

@@ -14,7 +14,7 @@ import type { Message } from "@bufbuild/protobuf";
  * Describes the file proto/ipc/tournament.proto.
  */
 export const file_proto_ipc_tournament: GenFile = /*@__PURE__*/
-  fileDesc("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", [file_google_protobuf_timestamp, file_proto_ipc_omgwords]);
+  fileDesc("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", [file_google_protobuf_timestamp, file_proto_ipc_omgwords]);
 
 /**
  * New tournaments will use full tournament
@@ -303,6 +303,11 @@ export type RoundControl = Message<"ipc.RoundControl"> & {
    */
   winDifferenceRelativeWeight: number;
 
+  /**
+   * @generated from field: bool play_within_team = 11;
+   */
+  playWithinTeam: boolean;
+
   /**
    * Optional is needed to represent:
    * - `nil` for no override at all
@@ -1013,6 +1018,11 @@ export enum PairingMethod {
    * @generated from enum value: INTERLEAVED_ROUND_ROBIN = 10;
    */
   INTERLEAVED_ROUND_ROBIN = 10,
+
+  /**
+   * @generated from enum value: SNAKED_ROUND_ROBIN = 11;
+   */
+  SNAKED_ROUND_ROBIN = 11,
 }
 
 /**

liwords-ui/src/tournament/director_tools/ghetto_tools.tsx

@@ -22,7 +22,7 @@ import {
 } from "antd";
 import { Modal } from "../../utils/focus_modal";
 import { Store } from "rc-field-form/lib/interface";
-import React, { useEffect, useMemo, useState } from "react";
+import React, { useCallback, useEffect, useMemo, useState } from "react";
 import {
   SingleRoundControlsRequestSchema,
   TType,
@@ -113,6 +113,7 @@ const FormModal = (props: ModalProps) => {
     "manage-check-ins-and-registrations": (
       <ManageCheckIns tournamentID={props.tournamentID} />
     ),
+    "count-firsts": <CountFirsts tournamentID={props.tournamentID} />,
     // "run-cop": <RunCOP tournamentID={props.tournamentID} />,
   };
 
@@ -182,6 +183,7 @@ export const GhettoTools = (props: Props) => {
     "Unpair entire round", // Unpair a whole round
     // "Run COP", // experimental run COP (new pairing method)
     // 'Clear checked in',
+    "Count firsts",
   ];
 
   const postTournamentTypes = ["Export tournament", "Unfinish tournament"];
@@ -1436,12 +1438,15 @@ const SingleRoundControlFields = (props: SingleRdCtrlFieldsProps) => {
             King of the Hill
           </Select.Option>
           <Select.Option value={PairingMethod.INTERLEAVED_ROUND_ROBIN}>
-            Shirts and Skins
+            Shirts and Skins Round Robin
+          </Select.Option>
+          <Select.Option value={PairingMethod.SNAKED_ROUND_ROBIN}>
+            Snaked (Boustrophedonic) Round Robin
           </Select.Option>
           <Select.Option value={PairingMethod.FACTOR}>Factor</Select.Option>
           <Select.Option value={PairingMethod.MANUAL}>Manual</Select.Option>
           <Select.Option value={PairingMethod.TEAM_ROUND_ROBIN}>
-            Team Round Robin
+            Team (Top vs Bottom) Round Robin
           </Select.Option>
         </Select>
       </Form.Item>
@@ -2071,6 +2076,61 @@ const CreatePrintableScorecards = (props: { tournamentID: string }) => {
   );
 };
 
+const CountFirsts = (props: { tournamentID: string }) => {
+  const [division, setDivision] = useState("");
+  const { tournamentContext } = useTournamentStoreContext();
+  const [firstsDisplay, setFirstsDisplay] = useState<string[]>([]);
+  const countFirsts = useCallback(() => {
+    // go through the tournament and count the number of firsts for every player,
+    // then display these in this widget. we're not using the API, but just doing
+    // a front-end count.
+    const firsts: Record<string, number> = {};
+    if (!division) {
+      message.error("Please select a division first.");
+      return;
+    }
+    const div = tournamentContext.divisions[division];
+    for (let i = 0; i < div.pairings.length; i++) {
+      const m = new Set<string>();
+      for (let j = 0; j < div.pairings[i].roundPairings.length; j++) {
+        const rp = div.pairings[i].roundPairings[j];
+        const playerName = rp.players[0].id.split(":")[1];
+        if (!m.has(playerName)) {
+          m.add(playerName);
+          firsts[playerName] = (firsts[playerName] || 0) + 1;
+        }
+      }
+    }
+    const firstsList = Object.entries(firsts)
+      .sort((a, b) => {
+        if (b[1] !== a[1]) {
+          return b[1] - a[1]; // Sort by count descending
+        }
+        return a[0].localeCompare(b[0]); // If counts are equal, sort by name ascending
+      })
+      .map(([name, count]) => `${name}: ${count} firsts`);
+    setFirstsDisplay(firstsList);
+  }, [division, tournamentContext.divisions]);
+  return (
+    <>
+      <DivisionFormItem onChange={(div: string) => setDivision(div)} />
+
+      <Button onClick={countFirsts}>Count firsts</Button>
+      <div className="readable-text-color" style={{ marginTop: 10 }}>
+        {firstsDisplay.length > 0 ? (
+          <ul>
+            {firstsDisplay.map((f, idx) => (
+              <li key={`first-${idx}`}>{f}</li>
+            ))}
+          </ul>
+        ) : (
+          "No firsts counted yet."
+        )}
+      </div>
+    </>
+  );
+};
+
 const UnstartTournament = (props: { tournamentID: string }) => {
   const tClient = useClient(TournamentService);
   const [form] = Form.useForm();

liwords-ui/src/tournament/director_tools/pairing_methods.ts

@@ -30,12 +30,11 @@ export const fieldsForMethod = (
 ): Array<PairingMethodField> => {
   const fields = new Array<PairingMethodField>();
   switch (m) {
-    case (PairingMethod.RANDOM,
-    PairingMethod.ROUND_ROBIN,
-    PairingMethod.KING_OF_THE_HILL,
-    PairingMethod.MANUAL,
-    PairingMethod.INTERLEAVED_ROUND_ROBIN,
-    PairingMethod.INITIAL_FONTES):
+    case PairingMethod.RANDOM:
+    case PairingMethod.ROUND_ROBIN:
+    case PairingMethod.KING_OF_THE_HILL:
+    case PairingMethod.MANUAL:
+    case PairingMethod.INITIAL_FONTES:
       return [];
     // @ts-expect-error fallthrough is purposeful:
     case PairingMethod.FACTOR:
@@ -77,6 +76,18 @@ export const fieldsForMethod = (
         "The number of games per round. For example, set this to two if you wish each team member to play the other team member twice.",
       ]);
       break;
+
+    case PairingMethod.INTERLEAVED_ROUND_ROBIN:
+    case PairingMethod.SNAKED_ROUND_ROBIN:
+      fields.push([
+        "boolean",
+        "playWithinTeam",
+        "Play Within Team",
+        "This pairing system divides players into two 'teams'. If this option is selected, " +
+          "players will play a round robin within their own team. If false, players will play " +
+          "against players from the other team.",
+      ]);
+      break;
   }
 
   return fields;