Improve tournaments forms

Author: vtm9

apps/codebattle/assets/js/widgets/pages/tournament/EditTournament.jsx

@@ -140,7 +140,7 @@ function EditTournament({ tournamentId, taskPackNames = [], userTimezone = "UTC"
     return (
       <div
         className="w-100 mx-auto cb-bg-panel cb-text shadow-sm cb-rounded py-4 px-3 px-md-4 mb-3"
-        style={{ maxWidth: "1100px" }}
+        style={{ maxWidth: "1400px" }}
       >
         <div
           className="d-flex justify-content-center align-items-center"
@@ -156,7 +156,7 @@ function EditTournament({ tournamentId, taskPackNames = [], userTimezone = "UTC"
     return (
       <div
         className="w-100 mx-auto cb-bg-panel cb-text shadow-sm cb-rounded py-4 px-3 px-md-4 mb-3"
-        style={{ maxWidth: "1100px" }}
+        style={{ maxWidth: "1400px" }}
       >
         <div className="alert alert-danger" role="alert">
           Tournament not found or you don&apos;t have permission to edit it.
@@ -195,6 +195,7 @@ function EditTournament({ tournamentId, taskPackNames = [], userTimezone = "UTC"
     rounds_limit: tournament.roundsLimit || 7,
     timeout_mode: tournament.timeoutMode || "per_task",
     round_timeout_seconds: tournament.roundTimeoutSeconds ?? null,
+    tournament_timeout_seconds: tournament.tournamentTimeoutSeconds ?? null,
     break_duration_seconds: tournament.breakDurationSeconds || 42,
     use_chat: tournament.useChat !== undefined ? tournament.useChat : true,
     use_clan: tournament.useClan !== undefined ? tournament.useClan : false,
@@ -208,15 +209,15 @@ function EditTournament({ tournamentId, taskPackNames = [], userTimezone = "UTC"
   return (
     <div
       className="w-100 mx-auto cb-bg-panel cb-text shadow-sm cb-rounded py-4 px-3 px-md-4 mb-3"
-      style={{ maxWidth: "1100px" }}
+      style={{ maxWidth: "1400px" }}
     >
       <Notification notification={notification} onClose={setNotification} />
       <h1 className="text-center mb-2">Edit Tournament</h1>
       <h3 className="text-center mb-4 text-muted">
         {tournament.creator && <>Creator: {tournament.creator.name}</>}
       </h3>
       <div className="row justify-content-center">
-        <div className="col-12 col-md-10 col-lg-8 col-xl-7">
+        <div className="col-12 col-lg-10 col-xl-10">
           <TournamentForm
             initialValues={initialValues}
             onSubmit={handleSubmit}

apps/codebattle/assets/js/widgets/pages/tournament/TournamentForm.jsx

@@ -38,9 +38,21 @@ const SCORE_STRATEGIES = [
 
 const TIMEOUT_MODES = [
   { value: "per_task", label: "Per task timeout" },
-  { value: "per_round", label: "Per round timeout" },
+  { value: "per_round_fixed", label: "Per round (fixed)" },
+  { value: "per_round_with_rematch", label: "Per round (with rematch)" },
+  { value: "per_tournament", label: "Per tournament timeout" },
 ];
 
+const TIMEOUT_DESCRIPTIONS = {
+  per_task:
+    "Each game uses the task's own time limit. Different tasks may have different timeouts.",
+  per_round_fixed: "All games in a round share a fixed timeout. One task per round.",
+  per_round_with_rematch:
+    "Each round has a fixed timeout. Players play multiple tasks (rematches) within the round until time runs out.",
+  per_tournament:
+    "One global timeout for the entire tournament. Games use the remaining tournament time. Tournament ends automatically when time expires.",
+};
+
 const PLAYERS_LIMITS = [2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384];
 
 function TournamentForm({
@@ -71,6 +83,7 @@ function TournamentForm({
     rounds_limit: initialValues.rounds_limit || 7,
     timeout_mode: initialValues.timeout_mode || "per_task",
     round_timeout_seconds: initialValues.round_timeout_seconds ?? 177,
+    tournament_timeout_seconds: initialValues.tournament_timeout_seconds ?? 3600,
     break_duration_seconds: initialValues.break_duration_seconds || 42,
     use_chat: initialValues.use_chat !== undefined ? initialValues.use_chat : true,
     use_clan: initialValues.use_clan !== undefined ? initialValues.use_clan : false,
@@ -106,8 +119,13 @@ function TournamentForm({
         .split(/[\s,]+/)
         .map((id) => id.trim())
         .filter(Boolean);
-      payload.round_timeout_seconds =
-        formData.timeout_mode === "per_round" ? formData.round_timeout_seconds : null;
+      payload.round_timeout_seconds = ["per_round_fixed", "per_round_with_rematch"].includes(
+        formData.timeout_mode,
+      )
+        ? formData.round_timeout_seconds
+        : null;
+      payload.tournament_timeout_seconds =
+        formData.timeout_mode === "per_tournament" ? formData.tournament_timeout_seconds : null;
 
       onSubmit(payload);
     },
@@ -535,16 +553,44 @@ function TournamentForm({
               {renderError("rounds_limit")}
             </div>
 
+            <div className="col-md-4 mb-3">
+              <label htmlFor="break_duration_seconds" className="form-label text-white">
+                Break Duration (seconds)
+              </label>
+              <input
+                type="number"
+                id="break_duration_seconds"
+                name="break_duration_seconds"
+                className={cn("form-control cb-bg-panel cb-border-color text-white cb-rounded", {
+                  "is-invalid": errors.break_duration_seconds,
+                })}
+                value={formData.break_duration_seconds}
+                onChange={handleChange}
+                min={0}
+                max={100000}
+              />
+              {renderError("break_duration_seconds")}
+            </div>
+          </div>
+        </div>
+      </div>
+
+      {/* Timeout Configuration Section */}
+      <div className="card cb-card mb-4">
+        <div className="card-header">
+          <h5 className="mb-0">Timeout Configuration</h5>
+        </div>
+        <div className="card-body">
+          <p className="text-muted small mb-3">{TIMEOUT_DESCRIPTIONS[formData.timeout_mode]}</p>
+          <div className="row">
             <div className="col-md-4 mb-3">
               <label htmlFor="timeout_mode" className="form-label text-white">
                 Timeout Mode
               </label>
               <select
                 id="timeout_mode"
                 name="timeout_mode"
-                className={cn(
-                  "form-select custom-select cb-bg-panel cb-border-color text-white cb-rounded",
-                )}
+                className="form-select custom-select cb-bg-panel cb-border-color text-white cb-rounded"
                 value={formData.timeout_mode}
                 onChange={handleChange}
               >
@@ -556,46 +602,70 @@ function TournamentForm({
               </select>
             </div>
 
-            {formData.timeout_mode === "per_round" && (
-              <div className="col-md-4 mb-3">
-                <label htmlFor="round_timeout_seconds" className="form-label text-white">
-                  Round Timeout (seconds)
-                </label>
-                <input
-                  type="number"
-                  id="round_timeout_seconds"
-                  name="round_timeout_seconds"
-                  className={cn("form-control cb-bg-panel cb-border-color text-white cb-rounded", {
-                    "is-invalid": errors.round_timeout_seconds,
-                  })}
-                  value={formData.round_timeout_seconds}
-                  onChange={handleChange}
-                  min={10}
-                  max={10000}
-                />
-                {renderError("round_timeout_seconds")}
-              </div>
-            )}
-          </div>
+            <div className="col-md-4 mb-3">
+              <label
+                htmlFor="round_timeout_seconds"
+                className={cn("form-label", {
+                  "text-white": ["per_round_fixed", "per_round_with_rematch"].includes(
+                    formData.timeout_mode,
+                  ),
+                  "text-muted": !["per_round_fixed", "per_round_with_rematch"].includes(
+                    formData.timeout_mode,
+                  ),
+                })}
+              >
+                Round Timeout (seconds)
+              </label>
+              <input
+                type="number"
+                id="round_timeout_seconds"
+                name="round_timeout_seconds"
+                className={cn("form-control cb-bg-panel cb-border-color text-white cb-rounded", {
+                  "is-invalid": errors.round_timeout_seconds,
+                })}
+                value={
+                  ["per_round_fixed", "per_round_with_rematch"].includes(formData.timeout_mode)
+                    ? formData.round_timeout_seconds
+                    : ""
+                }
+                onChange={handleChange}
+                min={10}
+                max={10000}
+                disabled={
+                  !["per_round_fixed", "per_round_with_rematch"].includes(formData.timeout_mode)
+                }
+              />
+              {renderError("round_timeout_seconds")}
+            </div>
 
-          <div className="row">
             <div className="col-md-4 mb-3">
-              <label htmlFor="break_duration_seconds" className="form-label text-white">
-                Break Duration (seconds)
+              <label
+                htmlFor="tournament_timeout_seconds"
+                className={cn("form-label", {
+                  "text-white": formData.timeout_mode === "per_tournament",
+                  "text-muted": formData.timeout_mode !== "per_tournament",
+                })}
+              >
+                Tournament Timeout (seconds)
               </label>
               <input
                 type="number"
-                id="break_duration_seconds"
-                name="break_duration_seconds"
+                id="tournament_timeout_seconds"
+                name="tournament_timeout_seconds"
                 className={cn("form-control cb-bg-panel cb-border-color text-white cb-rounded", {
-                  "is-invalid": errors.break_duration_seconds,
+                  "is-invalid": errors.tournament_timeout_seconds,
                 })}
-                value={formData.break_duration_seconds}
+                value={
+                  formData.timeout_mode === "per_tournament"
+                    ? formData.tournament_timeout_seconds
+                    : ""
+                }
                 onChange={handleChange}
-                min={0}
-                max={100000}
+                min={60}
+                max={36000}
+                disabled={formData.timeout_mode !== "per_tournament"}
               />
-              {renderError("break_duration_seconds")}
+              {renderError("tournament_timeout_seconds")}
             </div>
           </div>
         </div>
@@ -664,8 +734,14 @@ TournamentForm.propTypes = {
     tags: PropTypes.string,
     players_limit: PropTypes.number,
     rounds_limit: PropTypes.number,
-    timeout_mode: PropTypes.oneOf(["per_task", "per_round"]),
+    timeout_mode: PropTypes.oneOf([
+      "per_task",
+      "per_round_fixed",
+      "per_round_with_rematch",
+      "per_tournament",
+    ]),
     round_timeout_seconds: PropTypes.number,
+    tournament_timeout_seconds: PropTypes.number,
     break_duration_seconds: PropTypes.number,
     use_chat: PropTypes.bool,
     use_clan: PropTypes.bool,

apps/codebattle/lib/codebattle/tournament/context.ex

@@ -429,12 +429,28 @@ defmodule Codebattle.Tournament.Context do
 
     timeout_mode =
       params[:timeout_mode] ||
-        if params[:round_timeout_seconds] in [nil, ""], do: "per_task", else: "per_round"
+        cond do
+          params[:tournament_timeout_seconds] not in [nil, ""] -> "per_tournament"
+          params[:round_timeout_seconds] not in [nil, ""] -> "per_round_fixed"
+          true -> "per_task"
+        end
 
     params =
       case timeout_mode do
-        "per_task" -> Map.put(params, :round_timeout_seconds, nil)
-        _ -> params
+        "per_task" ->
+          params
+          |> Map.put(:round_timeout_seconds, nil)
+          |> Map.put(:tournament_timeout_seconds, nil)
+
+        mode when mode in ["per_round_fixed", "per_round_with_rematch"] ->
+          Map.put(params, :tournament_timeout_seconds, nil)
+
+        "per_tournament" ->
+          Map.put(params, :round_timeout_seconds, nil)
+
+        # Pass through unknown modes — changeset validation will reject them
+        _ ->
+          params
       end
 
     cond_result =

apps/codebattle/lib/codebattle/tournament/helpers.ex

@@ -324,7 +324,8 @@ defmodule Codebattle.Tournament.Helpers do
           10
         )
 
-      tournament.timeout_mode == "per_round" and is_integer(tournament.round_timeout_seconds) ->
+      tournament.timeout_mode in ["per_round_fixed", "per_round_with_rematch"] and
+          is_integer(tournament.round_timeout_seconds) ->
         tournament.round_timeout_seconds
 
       true ->

apps/codebattle/lib/codebattle/tournament/strategy/base.ex

@@ -896,13 +896,16 @@ defmodule Codebattle.Tournament.Base do
 
       defp maybe_start_global_timer(tournament), do: tournament
 
-      # We don't want to run a timer for the swiss type, because all games already have a timeout
-      defp maybe_start_round_timer(%{state: "active", type: "swiss"} = tournament), do: tournament
-
+      # per_task: no round timer, games timeout individually
       defp maybe_start_round_timer(%{timeout_mode: "per_task"} = tournament), do: tournament
-
-      defp maybe_start_round_timer(%{state: "active", type: "top200"} = tournament), do: tournament
-
+      # per_tournament: global timer handles it
+      defp maybe_start_round_timer(%{timeout_mode: "per_tournament"} = tournament), do: tournament
+      # per_round_fixed: swiss/top200 don't need round timer (games have individual timeouts,
+      # rounds finish when all games complete)
+      defp maybe_start_round_timer(%{timeout_mode: "per_round_fixed", type: "swiss"} = tournament), do: tournament
+      defp maybe_start_round_timer(%{timeout_mode: "per_round_fixed", type: "top200"} = tournament), do: tournament
+
+      # per_round_with_rematch and per_round_fixed (for show type) need the round timer
       defp maybe_start_round_timer(tournament) do
         Process.send_after(
           self(),
@@ -940,26 +943,31 @@ defmodule Codebattle.Tournament.Base do
       end
 
       defp get_round_game_timeout(tournament, task) do
-        cond do
-          tournament.tournament_timeout_seconds ->
+        case tournament.timeout_mode do
+          "per_tournament" ->
             max(
               tournament.tournament_timeout_seconds -
                 DateTime.diff(DateTime.utc_now(), tournament.started_at),
               10
             )
 
-          tournament.timeout_mode == "per_round" and is_integer(tournament.round_timeout_seconds) ->
+          mode when mode in ["per_round_fixed", "per_round_with_rematch"] ->
             tournament.round_timeout_seconds
 
-          true ->
+          _per_task ->
             (task && task.time_to_solve_sec) || 300
         end
       end
 
+      defp get_rematch_game_timeout(%{timeout_mode: "per_round_with_rematch"} = tournament) do
+        elapsed = NaiveDateTime.diff(NaiveDateTime.utc_now(), tournament.last_round_started_at)
+        max(tournament.round_timeout_seconds - elapsed, 10)
+      end
+
       defp get_rematch_game_timeout(tournament), do: get_round_timeout_seconds(tournament)
 
       defp get_round_timeout_seconds(tournament) do
-        if tournament.timeout_mode == "per_round" do
+        if tournament.timeout_mode in ["per_round_fixed", "per_round_with_rematch"] do
           tournament.round_timeout_seconds
         else
           tournament.match_timeout_seconds