Improve

Author: vtm9

apps/codebattle/assets/js/widgets/pages/groupTournament/GroupTournamentPage.jsx

@@ -47,6 +47,7 @@ function GroupTournamentPage({
     useGroupBattleRun(data);
 
   const isAdmin = useSelector(selectors.currentUserIsAdminSelector);
+  const currentUserId = useSelector(selectors.currentUserIdSelector);
 
   const requestInviteUpdates = () => {
     requestInviteUpdate()(dispatch);
@@ -113,6 +114,7 @@ function GroupTournamentPage({
             leaderboard={data?.leaderboard}
             roundsCount={data?.groupTournament?.roundsCount}
             currentRoundPosition={data?.groupTournament?.currentRoundPosition}
+            currentUserId={currentUserId}
           />
         </div>
       </div>

apps/codebattle/assets/js/widgets/pages/groupTournament/Leaderboard.jsx

@@ -12,6 +12,7 @@ function MainPanel({
   roundsCount,
   currentRoundPosition,
   status,
+  currentUserId,
 }) {
   const [openJson, setOpenJson] = useState(null); // "history" | "summary" | null
   const [activeTab, setActiveTab] = useState("run"); // "run" | "leaderboard"
@@ -23,11 +24,12 @@ function MainPanel({
   const summary = run?.result?.summary;
   const hasHistory = history != null;
   const hasSummary = summary != null;
+  // Show the leaderboard tab for every multi-player tournament regardless of
+  // round count or how far along the tournament is — players want to see
+  // current standings even before round 1 is over, and single-round
+  // tournaments still benefit from the slice/seed views.
   const hasLeaderboard =
-    Array.isArray(leaderboard) &&
-    leaderboard.length > 0 &&
-    Number.isInteger(roundsCount) &&
-    roundsCount > 1;
+    Array.isArray(leaderboard) && leaderboard.length > 0 && Number.isInteger(roundsCount);
 
   const tabBtnClass = (active) =>
     `btn btn-sm px-3 mr-2 text-white shadow-none border-0 rounded-0 ${
@@ -84,6 +86,7 @@ function MainPanel({
             roundsCount={roundsCount}
             currentRoundPosition={currentRoundPosition}
             isFinished={status === "finished"}
+            currentUserId={currentUserId}
           />
         </div>
       </>

apps/codebattle/assets/js/widgets/pages/groupTournament/MainPanel.jsx

@@ -73,7 +73,10 @@ const groupTournament = createSlice({
       state.langSlug = payload;
     },
     setData: (state, { payload }) => {
-      state.data = payload;
+      // Merge so a later-arriving REST snapshot can't wipe fields that only
+      // the channel push includes (notably `leaderboard`). Both sources race
+      // on initial page load.
+      state.data = { ...(state.data || {}), ...(payload || {}) };
     },
     setActiveRunIdFromServer: (state, { payload }) => {
       state.activeRunIdFromServer = payload;

apps/codebattle/assets/js/widgets/slices/groupTournament.js

@@ -525,17 +525,23 @@ defmodule Codebattle.GroupTask.Context do
 
     round_position = tournament.current_round_position
 
+    # Dense-rank humans only: when a slice is bot-filled, the runner ranks
+    # bots inline (e.g. a bot may take #1), leaving gaps in the surviving
+    # human places. Strip the bots first, then re-number 1..N by their raw
+    # rank so partial slices score and display contiguously.
     runs
     |> Enum.map(fn run ->
       user_id = run.user_group_tournament && run.user_group_tournament.user_id
-      place = extract_place_for_user(_user_ranking(run), user_id)
-      {user_id, place, run.id}
+      raw_place = extract_place_for_user(_user_ranking(run), user_id)
+      {user_id, raw_place, run.id}
     end)
     |> Enum.filter(fn {user_id, place, _} -> is_integer(user_id) and is_integer(place) end)
-    |> Enum.each(fn {user_id, place, run_id} ->
-      round_points = Scoring.round_points(tournament.scoring_strategy, slice_index, place, opts)
-      bump_player_score(tournament.id, user_id, round_points, place)
-      record_round_score(tournament.id, user_id, run_id, round_position, slice_index, place, round_points)
+    |> Enum.sort_by(fn {_uid, place, _rid} -> place end)
+    |> Enum.with_index(1)
+    |> Enum.each(fn {{user_id, _raw_place, run_id}, dense_place} ->
+      round_points = Scoring.round_points(tournament.scoring_strategy, slice_index, dense_place, opts)
+      bump_player_score(tournament.id, user_id, round_points, dense_place)
+      record_round_score(tournament.id, user_id, run_id, round_position, slice_index, dense_place, round_points)
     end)
   end
 

apps/codebattle/lib/codebattle/group_task/context.ex

@@ -620,49 +620,49 @@ defmodule Codebattle.GroupTournament.Context do
       |> Enum.group_by(& &1.user_id)
 
     players
-    |> Enum.map(fn player ->
-      rounds =
-        round_scores
-        |> Map.get(player.user_id, [])
-        |> Map.new(fn rs ->
-          {rs.round_position,
-           %{
-             slice_index: rs.slice_index,
-             place: rs.place,
-             score: rs.score
-           }}
-        end)
-
-      # Synthesise R1 from the seeding pass so the UI can show the seed score
-      # in the R1 column. Seeding runs solo-against-bots, so there's no
-      # cross-player place; we still surface the score (and the initial slice
-      # the player landed in) without touching total_score.
-      rounds =
-        if is_integer(player.seed_score) and not Map.has_key?(rounds, 1) do
-          Map.put(rounds, 1, %{
-            slice_index: player.slice_index,
-            place: nil,
-            score: player.seed_score
-          })
-        else
-          rounds
-        end
+    |> Enum.map(&build_leaderboard_entry(&1, round_scores))
+    |> Enum.sort_by(fn entry ->
+      {-(entry.total_score || 0), -(entry.seed_score || 0), entry.user_id}
+    end)
+  end
 
-      %{
-        user_id: player.user_id,
-        name: player.user && player.user.name,
-        avatar_url: player.user && Map.get(player.user, :avatar_url),
-        clan: player.user && Map.get(player.user, :clan),
-        clan_id: player.user && Map.get(player.user, :clan_id),
-        state: player.state,
+  defp build_leaderboard_entry(player, round_scores) do
+    rounds =
+      round_scores
+      |> Map.get(player.user_id, [])
+      |> Map.new(fn rs ->
+        {rs.round_position, %{slice_index: rs.slice_index, place: rs.place, score: rs.score}}
+      end)
+      |> maybe_put_seed_round(player)
+
+    %{
+      user_id: player.user_id,
+      name: player.user && player.user.name,
+      avatar_url: player.user && Map.get(player.user, :avatar_url),
+      clan: player.user && Map.get(player.user, :clan),
+      clan_id: player.user && Map.get(player.user, :clan_id),
+      state: player.state,
+      slice_index: player.slice_index,
+      total_score: player.total_score || 0,
+      seed_score: player.seed_score,
+      last_round_place: player.last_round_place,
+      rounds: rounds
+    }
+  end
+
+  # Synthesise R1 from the seeding pass so the UI can show the seed score in
+  # the R1 column. Seeding runs solo-against-bots, so there's no cross-player
+  # place; we surface score and initial slice without touching total_score.
+  defp maybe_put_seed_round(rounds, player) do
+    if is_integer(player.seed_score) and not Map.has_key?(rounds, 1) do
+      Map.put(rounds, 1, %{
         slice_index: player.slice_index,
-        total_score: player.total_score || 0,
-        seed_score: player.seed_score,
-        last_round_place: player.last_round_place,
-        rounds: rounds
-      }
-    end)
-    |> Enum.sort_by(fn entry -> {-(entry.total_score || 0), entry.user_id} end)
+        place: nil,
+        score: player.seed_score
+      })
+    else
+      rounds
+    end
   end
 
   def serialize_run(run) do

apps/codebattle/lib/codebattle/group_tournament/context.ex

@@ -166,6 +166,7 @@ defmodule Codebattle.GroupTournament do
 
   def states, do: @states
   def types, do: @types
+  def slice_strategies, do: @slice_strategies
   def scoring_strategies, do: @scoring_strategies
   def movement_strategies, do: @movement_strategies