Improve tournament ranking

Author: vtm9

apps/codebattle/lib/codebattle/tournament/server.ex

@@ -176,7 +176,7 @@ defmodule Codebattle.Tournament.Server do
       Process.send_after(self(), :start_grade_tournament, max(time_diff_ms, 0))
     end
 
-    {:ok, %{tournament: tournament, frozen: false}}
+    {:ok, %{tournament: tournament, frozen: false, break_timer_expired: false}}
   end
 
   def handle_cast({:fire_event, event_type, params}, state) do
@@ -313,10 +313,7 @@ defmodule Codebattle.Tournament.Server do
       if tournament.current_round_position == round_position and
            in_break?(tournament) and
            not finished?(tournament) do
-        new_tournament = tournament.module.start_round_force(tournament)
-        update_tournament_info_cache(new_tournament)
-
-        {:noreply, %{state | tournament: new_tournament}}
+        process_stop_round_break(state, tournament)
       else
         {:noreply, %{state | tournament: tournament}}
       end
@@ -389,14 +386,7 @@ defmodule Codebattle.Tournament.Server do
       defer_message({:round_finish_completed, op_id, finished_tournament}, "round_finish_completed", state)
     else
       if tournament.round_op_id == op_id and tournament.round_state == "round_finishing" do
-        new_tournament =
-          finished_tournament
-          |> tournament.module.complete_round_finish()
-          |> Map.put(:round_op_status, "done")
-          |> Map.put(:round_op_id, nil)
-
-        update_tournament_info_cache(new_tournament)
-        {:noreply, %{state | tournament: new_tournament}}
+        process_round_finish_completed(state, tournament, finished_tournament)
       else
         {:noreply, state}
       end
@@ -564,6 +554,48 @@ defmodule Codebattle.Tournament.Server do
 
   defp restore_info_cache(_tournament_id, _value), do: :ok
 
+  defp process_stop_round_break(state, tournament) do
+    if tournament.round_op_status == "done" do
+      # Computation already finished — start next round now
+      new_tournament = tournament.module.start_round_force(tournament)
+      update_tournament_info_cache(new_tournament)
+
+      {:noreply, %{state | tournament: new_tournament, break_timer_expired: false}}
+    else
+      # Computation still running — mark break as expired, wait for {:round_finish_completed}
+      {:noreply, %{state | break_timer_expired: true}}
+    end
+  end
+
+  defp process_round_finish_completed(state, tournament, finished_tournament) do
+    if_result =
+      if tournament.module.finish_tournament?(finished_tournament) do
+        tournament.module.maybe_finish_tournament(finished_tournament)
+      else
+        tournament.module.broadcast_round_finished(finished_tournament)
+      end
+
+    new_tournament =
+      if_result
+      |> Map.put(:round_op_status, "done")
+      |> Map.put(:round_op_id, nil)
+
+    if state.break_timer_expired do
+      # Break already expired while we were computing — start next round now
+      new_tournament =
+        if finished?(new_tournament), do: new_tournament, else: tournament.module.start_round_force(new_tournament)
+
+      update_tournament_info_cache(new_tournament)
+      {:noreply, %{state | tournament: new_tournament, break_timer_expired: false}}
+    else
+      # Break still running — wait for {:stop_round_break} to start next round
+      new_tournament = Map.put(new_tournament, :round_state, "break")
+      broadcast_tournament_update(new_tournament)
+      update_tournament_info_cache(new_tournament)
+      {:noreply, %{state | tournament: new_tournament}}
+    end
+  end
+
   defp defer_message(message, reason, state) do
     Logger.info(
       "[handoff] #{inspect(%{phase: "tournament_defer", reason: reason, tournament_id: state.tournament.id}, limit: :infinity, printable_limit: :infinity)}"
@@ -587,11 +619,22 @@ defmodule Codebattle.Tournament.Server do
     op_id = System.unique_integer([:positive, :monotonic])
     server_pid = self()
 
+    # Start break timer immediately alongside computation
+    min_break = Application.get_env(:codebattle, :min_break_duration_seconds, 5)
+    break_seconds = max(tournament.break_duration_seconds || min_break, min_break)
+
+    Process.send_after(
+      self(),
+      {:stop_round_break, tournament.current_round_position},
+      to_timeout(second: break_seconds)
+    )
+
     in_progress_tournament =
       tournament
       |> Map.put(:round_state, "round_finishing")
       |> Map.put(:round_op_status, "running")
       |> Map.put(:round_op_id, op_id)
+      |> Map.put(:break_state, "on")
 
     update_tournament_info_cache(in_progress_tournament)
 
@@ -603,7 +646,7 @@ defmodule Codebattle.Tournament.Server do
         end
       )
 
-    {:noreply, %{state | tournament: in_progress_tournament}}
+    {:noreply, %{state | tournament: in_progress_tournament, break_timer_expired: false}}
   end
 
   defp run_round_finish_job(server_pid, tournament, op_id) do

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

@@ -509,11 +509,16 @@ defmodule Codebattle.Tournament.Base do
       end
 
       def complete_round_finish(tournament) do
-        tournament
-        |> broadcast_round_finished()
-        |> maybe_finish_tournament()
-        |> maybe_start_round_or_break_or_finish()
-        |> then(fn tournament ->
+        if_result =
+          if finish_tournament?(tournament) do
+            maybe_finish_tournament(tournament)
+          else
+            tournament
+            |> broadcast_round_finished()
+            |> maybe_start_round_or_break_or_finish()
+          end
+
+        then(if_result, fn tournament ->
           broadcast_tournament_update(tournament)
           tournament
         end)
@@ -548,27 +553,19 @@ defmodule Codebattle.Tournament.Base do
         update_struct(tournament, %{break_state: "on", round_state: "break"})
       end
 
-      defp maybe_start_round_or_break_or_finish(
-             %{
-               state: "active",
-               break_duration_seconds: break_duration_seconds,
-               current_round_position: current_round_position
-             } = tournament
-           )
-           when break_duration_seconds not in [nil, 0] do
+      defp maybe_start_round_or_break_or_finish(%{state: "active"} = tournament) do
+        min_break = Application.get_env(:codebattle, :min_break_duration_seconds, 5)
+        break_seconds = max(tournament.break_duration_seconds || min_break, min_break)
+
         Process.send_after(
           self(),
           {:stop_round_break, tournament.current_round_position},
-          to_timeout(second: break_duration_seconds)
+          to_timeout(second: break_seconds)
         )
 
         update_struct(tournament, %{break_state: "on", round_state: "break"})
       end
 
-      defp maybe_start_round_or_break_or_finish(tournament) do
-        start_round_force(tournament)
-      end
-
       defp increment_current_round(tournament) do
         update_struct(tournament, %{
           current_round_position: tournament.current_round_position + 1
@@ -770,7 +767,7 @@ defmodule Codebattle.Tournament.Base do
         })
       end
 
-      defp maybe_finish_tournament(tournament) do
+      def maybe_finish_tournament(tournament) do
         if finish_tournament?(tournament) do
           finish_tournament(tournament)
         else
@@ -922,7 +919,7 @@ defmodule Codebattle.Tournament.Base do
         tournament
       end
 
-      defp broadcast_round_finished(tournament) do
+      def broadcast_round_finished(tournament) do
         Codebattle.PubSub.broadcast("tournament:round_finished", %{tournament: tournament})
         tournament
       end

apps/codebattle/lib/codebattle/tournament/tournament_result.ex

@@ -62,7 +62,8 @@ defmodule Codebattle.Tournament.TournamentResult do
   def upsert_results(%{type: type, ranking_type: "by_user", score_strategy: "75_percentile"} = tournament)
       when type in ["swiss", "top200"] do
     round_position = tournament.current_round_position || 0
-    cheated_game_sql = cheated_game_sql("g", tournament)
+    player_cheater_sql = player_cheater_sql(tournament)
+    game_has_cheater_sql = game_has_cheater_sql("g", tournament)
     clean_results(tournament.id, round_position)
 
     Repo.query!("""
@@ -82,7 +83,8 @@ defmodule Codebattle.Tournament.TournamentResult do
       and COALESCE(round_position, 0) = #{round_position}
       and state = 'game_over'
       and bot_won = FALSE
-      and not (#{cheated_game_sql})
+      and not COALESCE(g.was_cheated, FALSE)
+      and not (#{cheater_won_game_sql("g", tournament)})
       GROUP BY
       task_id, level),
       stats as (
@@ -96,16 +98,21 @@ defmodule Codebattle.Tournament.TournamentResult do
       g.tournament_id,
       g.id as game_id,
       COALESCE(g.round_position, 0) as round_position,
-      (#{cheated_game_sql}) AS was_cheated,
+      (COALESCE(g.was_cheated, FALSE) OR (#{player_cheater_sql})) AS was_cheated,
       COALESCE(dt.base_score, 0) AS base_score,
       COALESCE(dt.min_duration, 0) AS min_duration,
       COALESCE(dt.max_duration, 0) AS max_duration,
       CASE
-      WHEN (#{cheated_game_sql}) THEN
+      -- Game-level cheated flag or this player is a cheater
+      WHEN COALESCE(g.was_cheated, FALSE) OR (#{player_cheater_sql}) THEN
         0
-      -- Handle timeout case where both players lost
+      -- Opponent of cheater who lost (cheater won) — give base_score as compensation
+      WHEN (#{game_has_cheater_sql}) AND g.state = 'game_over' AND (p.player_info->>'result_percent')::numeric < 100.0 THEN
+        COALESCE(dt.base_score, 0)
+      -- Handle timeout case where both players lost (including opponent of cheater in timeout)
       WHEN g.state = 'timeout' THEN
         0.5 * COALESCE(dt.base_score, 0) * COALESCE((p.player_info->>'result_percent')::numeric, 0) / 100.0
+      -- Normal scoring (includes opponent of cheater who won — gets normal win score)
       ELSE
         COALESCE(dt.base_score, 0) * (
           2 - ((g.duration_sec - COALESCE(dt.min_duration, 0))::numeric / GREATEST(COALESCE(dt.max_duration - COALESCE(dt.min_duration, 0), 1), 1))
@@ -163,7 +170,8 @@ defmodule Codebattle.Tournament.TournamentResult do
   def upsert_results(%{type: type, ranking_type: "by_user", score_strategy: "win_loss"} = tournament)
       when type in ["swiss"] do
     round_position = tournament.current_round_position || 0
-    cheated_game_sql = cheated_game_sql("g", tournament)
+    player_cheater_sql = player_cheater_sql(tournament)
+    game_has_cheater_sql = game_has_cheater_sql("g", tournament)
     clean_results(tournament.id, round_position)
 
     Repo.query!("""
@@ -180,9 +188,11 @@ defmodule Codebattle.Tournament.TournamentResult do
       g.task_id,
       g.id as game_id,
       COALESCE(g.round_position, 0) as round_position,
-      (#{cheated_game_sql}) AS was_cheated,
+      (COALESCE(g.was_cheated, FALSE) OR (#{player_cheater_sql})) AS was_cheated,
       CASE
-        WHEN (#{cheated_game_sql}) THEN 0
+        WHEN COALESCE(g.was_cheated, FALSE) OR (#{player_cheater_sql}) THEN 0
+        WHEN (#{game_has_cheater_sql}) AND g.state = 'game_over'
+        THEN #{@win_score}
         WHEN (p.player_info->'result_percent')::numeric = 100.0
         THEN #{@win_score}
         ELSE #{@loss_score}
@@ -255,21 +265,41 @@ defmodule Codebattle.Tournament.TournamentResult do
     |> Repo.delete_all()
   end
 
-  defp cheated_game_sql(game_alias, %{cheater_ids: []}), do: "COALESCE(#{game_alias}.was_cheated, FALSE)"
-  defp cheated_game_sql(game_alias, %{cheater_ids: nil}), do: "COALESCE(#{game_alias}.was_cheated, FALSE)"
+  # Checks if the winner of the game is a cheater (for excluding from percentile calculation)
+  defp cheater_won_game_sql(_game_alias, %{cheater_ids: ids}) when ids in [[], nil], do: "FALSE"
+
+  defp cheater_won_game_sql(game_alias, %{cheater_ids: cheater_ids}) do
+    cheater_ids_sql = cheater_ids |> Enum.uniq() |> Enum.join(",")
+
+    """
+    exists (
+      select 1
+      from jsonb_array_elements(#{game_alias}.players) as wp(player_info)
+      where (wp.player_info->>'result_percent')::numeric = 100.0
+      and (wp.player_info->>'id')::integer = any(array[#{cheater_ids_sql}]::integer[])
+    )
+    """
+  end
+
+  # Checks if THIS specific player (from lateral join) is a cheater
+  defp player_cheater_sql(%{cheater_ids: ids}) when ids in [[], nil], do: "FALSE"
+
+  defp player_cheater_sql(%{cheater_ids: cheater_ids}) do
+    cheater_ids_sql = cheater_ids |> Enum.uniq() |> Enum.join(",")
+    "(p.player_info->>'id')::integer = any(array[#{cheater_ids_sql}]::integer[])"
+  end
+
+  # Checks if the game has any identified cheater (by cheater_ids only, not game-level flag)
+  defp game_has_cheater_sql(_game_alias, %{cheater_ids: ids}) when ids in [[], nil], do: "FALSE"
 
-  defp cheated_game_sql(game_alias, %{cheater_ids: cheater_ids}) do
-    cheater_ids_sql =
-      cheater_ids
-      |> Enum.uniq()
-      |> Enum.join(",")
+  defp game_has_cheater_sql(game_alias, %{cheater_ids: cheater_ids}) do
+    cheater_ids_sql = cheater_ids |> Enum.uniq() |> Enum.join(",")
 
     """
-    COALESCE(#{game_alias}.was_cheated, FALSE)
-    or exists (
+    exists (
       select 1
-      from jsonb_array_elements(#{game_alias}.players) as cheater_player(player_info)
-      where (cheater_player.player_info->>'id')::integer = any(array[#{cheater_ids_sql}]::integer[])
+      from jsonb_array_elements(#{game_alias}.players) as cp(player_info)
+      where (cp.player_info->>'id')::integer = any(array[#{cheater_ids_sql}]::integer[])
     )
     """
   end

apps/codebattle/lib/codebattle_web/controllers/auth_bind_controller.ex

@@ -42,13 +42,16 @@ defmodule CodebattleWeb.AuthBindController do
     case_result =
       case params["provider"] do
         "github" ->
-          {:ok, profile} = Github.github_auth(code)
-          GithubUser.bind(current_user, profile)
+          with {:ok, profile} <- Github.github_auth(code) do
+            GithubUser.bind(current_user, profile)
+          end
 
         "discord" ->
           redirect_uri = Routes.auth_bind_url(conn, :callback, "discord")
-          {:ok, profile} = Discord.discord_auth(code, redirect_uri)
-          DiscordUser.bind(current_user, profile)
+
+          with {:ok, profile} <- Discord.discord_auth(code, redirect_uri) do
+            DiscordUser.bind(current_user, profile)
+          end
       end
 
     case case_result do

apps/codebattle/lib/codebattle_web/controllers/auth_controller.ex

@@ -63,13 +63,16 @@ defmodule CodebattleWeb.AuthController do
     case_result =
       case provider_name do
         "github" ->
-          {:ok, profile} = Github.github_auth(code)
-          Codebattle.Auth.User.GithubUser.find_or_create(profile)
+          with {:ok, profile} <- Github.github_auth(code) do
+            Codebattle.Auth.User.GithubUser.find_or_create(profile)
+          end
 
         "discord" ->
           redirect_uri = Routes.auth_url(conn, :callback, provider_name)
-          {:ok, profile} = Discord.discord_auth(code, redirect_uri)
-          Codebattle.Auth.User.DiscordUser.find_or_create(profile)
+
+          with {:ok, profile} <- Discord.discord_auth(code, redirect_uri) do
+            Codebattle.Auth.User.DiscordUser.find_or_create(profile)
+          end
 
         "external" ->
           redirect_uri = Routes.auth_url(conn, :callback, provider_name)

apps/codebattle/lib/codebattle_web/controllers/ext_api/task_controller.ex

@@ -10,6 +10,18 @@ defmodule CodebattleWeb.ExtApi.TaskController do
     origin = Map.get(params, "origin")
     visibility = Map.get(params, "visibility")
 
+    case payload do
+      nil ->
+        conn
+        |> put_status(:not_found)
+        |> json(%{errors: %{payload: "Payload not found"}})
+
+      _ ->
+        process_payload(conn, payload, origin, visibility)
+    end
+  end
+
+  defp process_payload(conn, payload, origin, visibility) do
     with {:ok, gzipped_data} <- decode_base64(payload),
          {:ok, json_data} <- decompress_gzip(gzipped_data),
          {:ok, tasks_list} <- Jason.decode(json_data) do

apps/codebattle/lib/codebattle_web/controllers/ext_api/task_pack_controller.ex

@@ -11,11 +11,22 @@ defmodule CodebattleWeb.ExtApi.TaskPackController do
   plug(CodebattleWeb.Plugs.TokenAuth)
 
   def create(conn, params) do
+    case Map.get(params, "task_pack") do
+      task_pack_params when is_map(task_pack_params) ->
+        process_task_pack(conn, params, task_pack_params)
+
+      _ ->
+        conn
+        |> put_status(:unauthorized)
+        |> json(%{error: "Invalid task_pack payload"})
+    end
+  end
+
+  defp process_task_pack(conn, params, task_pack_params) do
     visibility = Map.get(params, "visibility", "public")
-    tp_params = Map.get(params, "task_pack", %{})
 
     params =
-      tp_params
+      task_pack_params
       |> AtomizedMap.atomize()
       |> Map.put(:visibility, visibility)
       |> Map.put(:state, "active")