Fix

Author: vtm9

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

@@ -365,7 +365,7 @@ defmodule Codebattle.Tournament.Helpers do
   def get_player_ranking_stats(tournament) do
     players = get_players(tournament)
 
-    max_draw_index = get_max_draw_index(players)
+    max_draw_index = get_max_draw_index(tournament)
 
     top_8_ids =
       players
@@ -421,10 +421,19 @@ defmodule Codebattle.Tournament.Helpers do
     }
   end
 
-  def get_max_draw_index(players) do
-    case players do
-      [%{max_draw_index: i} | _] -> i
-      [] -> 0
-    end
+  # «Живой» максимум draw_index — индикатор глубочайшей волны победителей сетки. Имеет
+  # смысл ТОЛЬКО для top200: там draw_index бампается за каждый плей-офф раунд. Для
+  # остальных типов draw_index не используется как маркер сетки, поэтому возвращаем 0
+  # (никто не «в сетке») — это сохраняет прежнее поведение endpoint'а для не-top200.
+  #
+  # Раньше читали хранимое поле player.max_draw_index, но оно нигде не обновляется
+  # (всегда 0). Теперь для top200 считаем максимум по факту — как stream_controller.
+  def get_max_draw_index(%{type: "top200"} = tournament) do
+    tournament
+    |> get_players()
+    |> Enum.map(&(&1.draw_index || 0))
+    |> Enum.max(fn -> 0 end)
   end
+
+  def get_max_draw_index(_tournament), do: 0
 end

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

@@ -879,6 +879,12 @@ defmodule Codebattle.Tournament.Base do
         if get_matches(tournament, "playing") == [] do
           tournament
           |> update_struct(%{state: "finished", finished_at: DateTime.utc_now(:second)})
+          # Гарантируем, что результаты последнего раунда записаны ДО подсчёта финальных
+          # мест. На force-пути (:finish_tournament_force) раунд не проходит через
+          # prepare_round_finish, поэтому без этого upsert строк раунда в TournamentResult
+          # может не быть (top200 определяет победителей финалов по очкам раунда).
+          # Идемпотентно: на штатном пути просто перезапишет уже посчитанные строки.
+          |> Tournament.TournamentResult.upsert_results()
           |> compute_final_standings()
           |> set_stats()
           |> maybe_save_event_results()

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

@@ -221,14 +221,11 @@ defmodule Codebattle.Tournament.Top200 do
   # поэтому их сумма = очки за 5 раундов и они стоят на 9..N. Полный пересчёт результатов
   # (reset+rebuild) не нужен — переставляем ТОЛЬКО топ-8: их места задаёт сетка финалов.
   #
-  # upsert_results обязателен ПЕРВЫМ шагом: при завершении через finish_tournament_force
-  # последний раунд не проходит через prepare_round_finish, и строк раунда в
-  # TournamentResult может не быть. Без них assign_final_bracket_places определял бы
-  # победителей пар по tie-break (id), а не по реальным очкам. upsert_results читает
-  # результаты из таблицы games (они есть на любом пути) и идемпотентен.
+  # Результаты раунда 7 здесь уже в TournamentResult: на любом пути завершения их пишет
+  # finish_tournament (base) через upsert_results перед вызовом compute_final_standings.
+  # Поэтому assign_final_bracket_places определяет победителей пар по реальным очкам.
   def compute_final_standings(tournament) do
     tournament
-    |> TournamentResult.upsert_results()
     |> assign_final_bracket_places()
     |> recalculate_player_wins_count()
   end

apps/codebattle/lib/codebattle_web/channels/game_channel.ex

@@ -72,8 +72,7 @@ defmodule CodebattleWeb.GameChannel do
         %{entries: ranking}
       end)
 
-    in_main_draw =
-      match?(%{draw_index: draw_index, max_draw_index: draw_index}, current_player)
+    in_main_draw = player_in_main_draw?(tournament, current_player)
 
     game_params =
       game
@@ -134,6 +133,15 @@ defmodule CodebattleWeb.GameChannel do
     end
   end
 
+  # Игрок в главной сетке плей-офф = его draw_index равен максимальному среди всех
+  # игроков (самая глубокая «волна» победителей). get_max_draw_index считает максимум
+  # вживую только для top200 (для остальных типов вернёт 0). Зритель (nil) — не в сетке.
+  defp player_in_main_draw?(_tournament, nil), do: false
+
+  defp player_in_main_draw?(tournament, %{draw_index: draw_index}) do
+    (draw_index || 0) == Tournament.Helpers.get_max_draw_index(tournament)
+  end
+
   def terminate(_reason, socket) do
     {:noreply, socket}
   end

apps/codebattle/lib/codebattle_web/channels/tournament_admin_channel.ex

@@ -51,14 +51,14 @@ defmodule CodebattleWeb.TournamentAdminChannel do
     end)
   end
 
-  # Get the auto-select delay (ms) for a tournament. Defaults to 0 (instant).
+  # Get the auto-select delay (ms) for a tournament. Defaults to 5500 (5.5s).
   def get_autoselect_delay(tournament_id) do
     if Process.whereis(__MODULE__.GamesAgent) == nil do
       start_games_agent()
     end
 
     Agent.get(__MODULE__.GamesAgent, fn games_map ->
-      Map.get(games_map, {:autoselect_delay, tournament_id}, 0)
+      Map.get(games_map, {:autoselect_delay, tournament_id}, 5500)
     end)
   end
 

apps/codebattle/lib/codebattle_web/controllers/tournament/stream_controller.ex

@@ -74,7 +74,7 @@ defmodule CodebattleWeb.Tournament.StreamController do
     players = safe_get_players(tournament)
     user_history = safe_get_users_history(tournament, players)
     active_ids = active_player_ids(tournament, players)
-    win_probs = compute_win_probs(user_history)
+    win_probs = compute_win_probs(tournament, user_history, active_ids)
 
     %{
       tournament_id: tournament.id,
@@ -171,29 +171,52 @@ defmodule CodebattleWeb.Tournament.StreamController do
     _ -> %{}
   end
 
-  # Win probability = each top-8 player's share of the top-8 total history score.
-  # Score for each player is summed from their full history. Players outside the
-  # top 8 get no win_prob.
-  defp compute_win_probs(user_history) do
-    totals =
-      Map.new(user_history, fn {user_id, rounds} ->
-        {user_id, Enum.sum(Enum.map(rounds, &(&1.score || 0)))}
-      end)
+  # Win probability for the players still contending for 1st place: each remaining
+  # main-net player's share of that pool's total history score (summed from their
+  # full history).
+  #
+  # The pool is the bracket "active" set (same funnel as the `active` flag), which
+  # narrows by draw_index as the playoff progresses:
+  #   * Swiss done / QF in progress → the top-8 entering the quarterfinals
+  #   * after QF → 4 main-net survivors, after SF → 2 finalists, then the champion
+  #
+  # Only shown in the playoff phase (top200, >=5 completed rounds); blank during the
+  # Swiss stage and for non-bracket tournaments. Players outside the pool get no
+  # win_prob.
+  defp compute_win_probs(tournament, user_history, active_ids) do
+    if win_prob_phase?(tournament) do
+      user_history
+      |> active_history_totals(active_ids)
+      |> normalize_win_probs()
+    else
+      %{}
+    end
+  end
 
-    top_8 =
-      totals
-      |> Enum.sort_by(fn {_id, score} -> -score end)
-      |> Enum.take(8)
+  defp active_history_totals(user_history, active_ids) do
+    user_history
+    |> Enum.filter(fn {user_id, _rounds} -> MapSet.member?(active_ids, user_id) end)
+    |> Map.new(fn {user_id, rounds} ->
+      {user_id, Enum.sum(Enum.map(rounds, &(&1.score || 0)))}
+    end)
+  end
 
-    top_8_total = top_8 |> Enum.map(fn {_id, s} -> s end) |> Enum.sum()
+  defp normalize_win_probs(totals) do
+    total = totals |> Map.values() |> Enum.sum()
 
-    if top_8_total > 0 do
-      Map.new(top_8, fn {id, score} -> {id, round(score * 100.0 / top_8_total)} end)
+    if total > 0 do
+      Map.new(totals, fn {id, score} -> {id, round(score * 100.0 / total)} end)
     else
       %{}
     end
   end
 
+  # Win probabilities are a playoff-bracket concept: only meaningful once the Swiss
+  # stage is over and the top-8 bracket is set (top200, >=5 completed rounds). The
+  # active set is driven by draw_index from the quarterfinals onward.
+  defp win_prob_phase?(%{type: "top200"} = tournament), do: completed_rounds(tournament) >= 5
+  defp win_prob_phase?(_tournament), do: false
+
   defp format_clans(clans) do
     Map.new(clans, fn {id, clan} ->
       {to_string(id), %{name: clan[:name], long_name: clan[:long_name]}}

apps/codebattle/lib/codebattle_web/live/admin/tournament_stream_view.ex

@@ -28,27 +28,34 @@ defmodule CodebattleWeb.Live.Admin.TournamentStreamView do
       Codebattle.PubSub.subscribe("tournament:#{tournament.id}")
       Codebattle.PubSub.subscribe("tournament:#{tournament.id}:common")
       Codebattle.PubSub.subscribe("tournament:#{tournament.id}:stream")
-      # Drive the "round ends in" countdown.
-      Process.send_after(self(), :tick, 1000)
     end
 
-    {:ok,
-     socket
-     |> assign(
-       layout: {CodebattleWeb.LayoutView, :admin},
-       tournament: tournament,
-       current_user: current_user,
-       active_game_id: TournamentAdminChannel.get_active_game(tournament.id),
-       autoselect_delay_ms: TournamentAdminChannel.get_autoselect_delay(tournament.id),
-       widgets: @widgets,
-       filter: "current",
-       now: NaiveDateTime.utc_now(:second),
-       # The simulator panel is always available on the admin stream page, so bots
-       # can be started for any tournament — even one created without meta.simulator.
-       simulator_enabled: true
-     )
-     |> assign_matches_and_players()
-     |> assign_simulator_state()}
+    socket =
+      socket
+      |> assign(
+        layout: {CodebattleWeb.LayoutView, :admin},
+        tournament: tournament,
+        current_user: current_user,
+        active_game_id: TournamentAdminChannel.get_active_game(tournament.id),
+        autoselect_delay_ms: TournamentAdminChannel.get_autoselect_delay(tournament.id),
+        widgets: @widgets,
+        filter: "current",
+        now: NaiveDateTime.utc_now(:second),
+        # Whether the per-second countdown tick loop is currently armed.
+        ticking: false,
+        # The simulator panel is always available on the admin stream page, so bots
+        # can be started for any tournament — even one created without meta.simulator.
+        simulator_enabled: true
+      )
+      |> assign_matches_and_players()
+      |> assign_simulator_state()
+
+    # Only arm the "round ends in" countdown once connected, and only while a
+    # round is actually counting down (see ensure_ticking/1). A finished/waiting
+    # tournament shows a static label, so it must not push a diff every second.
+    socket = if connected?(socket), do: ensure_ticking(socket), else: socket
+
+    {:ok, socket}
   end
 
   defp assign_simulator_state(socket) do
@@ -142,19 +149,52 @@ defmodule CodebattleWeb.Live.Admin.TournamentStreamView do
              "tournament:updated",
              "tournament:finished"
            ] do
-    {:noreply, socket |> assign_matches_and_players() |> assign_simulator_state()}
+    {:noreply,
+     socket
+     |> assign_matches_and_players()
+     |> assign_simulator_state()
+     |> ensure_ticking()}
   end
 
   def handle_info(:tick, socket) do
-    Process.send_after(self(), :tick, 1000)
-    {:noreply, assign(socket, now: NaiveDateTime.utc_now(:second))}
+    socket = assign(socket, now: NaiveDateTime.utc_now(:second))
+
+    # Keep the loop alive only while there is a moving countdown to refresh.
+    # Otherwise stop, so a finished/waiting tournament no longer pushes a diff
+    # to the client every second; a new round re-arms it via ensure_ticking/1.
+    socket =
+      if countdown_active?(socket.assigns.tournament) do
+        Process.send_after(self(), :tick, 1000)
+        socket
+      else
+        assign(socket, ticking: false)
+      end
+
+    {:noreply, socket}
   end
 
   def handle_info(msg, socket) do
     Logger.debug("Stream admin LV unexpected: #{inspect(msg)}")
     {:noreply, socket}
   end
 
+  # Arm the countdown tick loop if it isn't already running and the tournament is
+  # in a state that needs a per-second countdown. Idempotent: safe to call from
+  # mount and from any handler that may have changed the tournament state.
+  defp ensure_ticking(socket) do
+    if not socket.assigns.ticking and countdown_active?(socket.assigns.tournament) do
+      Process.send_after(self(), :tick, 1000)
+      assign(socket, ticking: true)
+    else
+      socket
+    end
+  end
+
+  # Only an active round (including its break) has a moving "ends in / next round
+  # in" countdown. Finished/waiting tournaments show a static label.
+  defp countdown_active?(%{state: "active"}), do: true
+  defp countdown_active?(_), do: false
+
   defp assign_matches_and_players(socket) do
     tournament =
       try do
@@ -519,7 +559,11 @@ defmodule CodebattleWeb.Live.Admin.TournamentStreamView do
         </div>
       <% end %>
 
-      <details class="cb-bg-panel cb-rounded cb-border-color border shadow-sm p-2 mb-3">
+      <details
+        id="obs-stream-urls"
+        phx-update="ignore"
+        class="cb-bg-panel cb-rounded cb-border-color border shadow-sm p-2 mb-3"
+      >
         <summary class="text-white" style="cursor:pointer;font-size:14px;font-weight:600">
           OBS / stream URLs
           <span class="cb-text ml-1" style="font-size:12px;font-weight:400">({length(@widgets)})</span>

apps/codebattle/test/codebattle/tournament/entire/top200_test.exs

@@ -253,7 +253,7 @@ defmodule Codebattle.Tournament.Entire.Top200Test do
   end
 
   describe "compute_final_standings/1 — финальные места" do
-    test "топ-8 расставляются по сетке финалов, места 9+ сохраняются по сумме 5 раундов" do
+    test "топ-8 по результату финалов (очки раунда 7): place + draw_index, ровно 1 «живой»" do
       tournament = insert_top200_tournament()
       players_table = Tournament.Players.create_table(tournament.id)
 
@@ -268,17 +268,30 @@ defmodule Codebattle.Tournament.Entire.Top200Test do
 
       tournament = %{tournament | players_table: players_table, current_round_position: 7, matches: finals}
 
-      # Топ-8: {draw_index, score}. Победитель пары — больший draw_index (его поднял
-      # calculate_round_results). Очки нарочно выше у проигравших — доказываем, что место
-      # топ-8 определяет сетка, а не сумма очков.
+      # Победитель каждой пары — по СУММЕ ОЧКОВ РАУНДА 7. Победители: 2, 4, 5, 8.
+      record_scores(tournament.id, 7, [
+        {1, 10},
+        {2, 100},
+        {3, 10},
+        {4, 100},
+        {5, 100},
+        {6, 10},
+        {7, 10},
+        {8, 100}
+      ])
+
+      # Топ-8: {начальный draw_index, накопленный score}. Оба НАРОЧНО инвертированы — у
+      # проигравших финал выше и draw_index (имитация force-финиша, где бамп не успел
+      # развести финалистов), и накопленная сумма. Доказываем: место и draw_index задаёт
+      # результат финала (очки раунда 7), а не прежний draw_index и не сумма очков.
       top8 = %{
-        1 => {3, 999},
-        2 => {4, 10},
-        3 => {1, 999},
-        4 => {2, 10},
-        5 => {2, 10},
-        6 => {1, 999},
-        7 => {0, 999},
+        1 => {9, 999},
+        2 => {1, 10},
+        3 => {9, 999},
+        4 => {1, 10},
+        5 => {1, 10},
+        6 => {9, 999},
+        7 => {9, 999},
         8 => {1, 10}
       }
 
@@ -301,7 +314,7 @@ defmodule Codebattle.Tournament.Entire.Top200Test do
 
       place_of = fn id -> Tournament.Players.get_player(tournament, id).place end
 
-      # Места топ-8 по сетке финалов (победитель пары — лучшее место).
+      # Места топ-8 по результату финалов (победитель пары — лучшее место).
       assert place_of.(2) == 1
       assert place_of.(1) == 2
       assert place_of.(4) == 3
@@ -311,6 +324,23 @@ defmodule Codebattle.Tournament.Entire.Top200Test do
       assert place_of.(8) == 7
       assert place_of.(7) == 8
 
+      # draw_index = 9 - place: у чемпиона уникальный максимум (8), дальше по убыванию.
+      assert draw_index_by_id(tournament, [1, 2, 3, 4, 5, 6, 7, 8]) == %{
+               2 => 8,
+               1 => 7,
+               4 => 6,
+               3 => 5,
+               5 => 4,
+               6 => 3,
+               8 => 2,
+               7 => 1
+             }
+
+      # Игроки вне сетки (места 9+) — дефолтный draw_index (1), заведомо ниже максимума (8).
+      # Значит «живой» (draw_index == max) ровно один — чемпион (id 2). Это и есть починка
+      # «2 active после финала».
+      assert draw_index_by_id(tournament, [9, 10, 11]) == %{9 => 1, 10 => 1, 11 => 1}
+
       # Места 9+ без изменений.
       assert place_of.(9) == 9
       assert place_of.(10) == 10

apps/codebattle/test/codebattle/tournament/helpers_behavior_test.exs

@@ -186,6 +186,8 @@ defmodule Codebattle.Tournament.HelpersBehaviorTest do
       tournament =
         build_ets_tournament(%{
           id: System.unique_integer([:positive]),
+          # get_max_draw_index/«active»/top-8/win_prob — это статистика сетки top200.
+          type: "top200",
           state: "active",
           current_round_position: 3,
           use_clan: true,