Fix tournament

Author: vtm9

services/app/apps/codebattle/lib/codebattle/game/context.ex

@@ -231,7 +231,7 @@ defmodule Codebattle.Game.Context do
     end
   end
 
-  @spec trigger_timeout(game_id) :: :ok
+  @spec trigger_timeout(game_id) :: {:ok, Game.t()}
   def trigger_timeout(game_id) do
     game_id |> get_game!() |> Engine.trigger_timeout()
   end

services/app/apps/codebattle/lib/codebattle/game/engine.ex

@@ -356,10 +356,12 @@ defmodule Codebattle.Game.Engine do
     |> Repo.update!()
   end
 
+  @spec update_game!(Game.t()) :: Game.t()
+  @spec update_game!(Game.t(), map()) :: Game.t()
   def update_game!(%Game{} = game) do
     case Repo.get(Game, game.id) do
       nil ->
-        :ok
+        game
 
       game ->
         game
@@ -371,7 +373,7 @@ defmodule Codebattle.Game.Engine do
   def update_game!(%Game{} = game, params) do
     case Repo.get(Game, game.id) do
       nil ->
-        :ok
+        game
 
       game ->
         game
@@ -386,37 +388,40 @@ defmodule Codebattle.Game.Engine do
 
   def trigger_timeout(%Game{state: "game_over"} = game) do
     terminate_game_after(game, 1)
+    {:ok, game}
   end
 
   def trigger_timeout(%Game{} = game) do
     Logger.debug("Trigger timeout for game: #{game.id}")
     {:ok, {old_game_state, new_game}} = fire_transition(game.id, :timeout, %{})
 
-    case {old_game_state, new_game.state} do
-      {old_state, "timeout"}
-      when old_state in ["waiting_opponent", "playing"] ->
-        Codebattle.PubSub.broadcast("game:finished", %{game: new_game})
-
-        update_game!(new_game, %{
-          state: get_state(new_game),
-          players: get_game_players(new_game),
-          duration_sec: new_game.duration_sec,
-          finishes_at: new_game.finishes_at
-        })
+    new_game =
+      case {old_game_state, new_game.state} do
+        {old_state, "timeout"}
+        when old_state in ["waiting_opponent", "playing"] ->
+          Codebattle.PubSub.broadcast("game:finished", %{game: new_game})
+
+          update_game!(new_game, %{
+            state: get_state(new_game),
+            players: get_game_players(new_game),
+            duration_sec: new_game.duration_sec,
+            finishes_at: new_game.finishes_at
+          })
 
-        if game.tournament_id do
-          terminate_game_after(game, 1)
-        else
-          terminate_game_after(game, 15)
-        end
+          if game.tournament_id do
+            terminate_game_after(game, 1)
+          else
+            terminate_game_after(game, 15)
+          end
 
-        store_playbook_async(game)
+          store_playbook_async(game)
+          new_game
 
-      _ ->
-        :noop
-    end
+        _ ->
+          new_game
+      end
 
-    :ok
+    {:ok, new_game}
   end
 
   defp maybe_fire_playing_game_side_effects(%{state: "playing"} = game) do

services/app/apps/codebattle/lib/codebattle/tournament/global_supervisor.ex

@@ -6,12 +6,18 @@ defmodule Codebattle.Tournament.GlobalSupervisor do
 
   require Logger
 
+  @tournament_info_table :tournament_info_cache
+
   def start_link(_) do
     Supervisor.start_link(__MODULE__, [], name: __MODULE__)
   end
 
   @impl true
   def init(_) do
+    if :ets.whereis(@tournament_info_table) == :undefined do
+      :ets.new(@tournament_info_table, [:named_table, :set, :public, read_concurrency: true])
+    end
+
     Supervisor.init([], strategy: :one_for_one)
   end
 

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

@@ -102,9 +102,6 @@ defmodule Codebattle.Tournament.Server do
   # SERVER
   def init(tournament_id) do
     # Create tournament_info_cache table if it doesn't exist
-    if :ets.whereis(@tournament_info_table) == :undefined do
-      :ets.new(@tournament_info_table, [:named_table, :set, :public, read_concurrency: true])
-    end
 
     players_table = Tournament.Players.create_table(tournament_id)
     matches_table = Tournament.Matches.create_table(tournament_id)

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

@@ -391,21 +391,6 @@ defmodule Codebattle.Tournament.Base do
         match = get_match(tournament, params.ref)
         winner_id = pick_game_winner_id(match.player_ids, params.player_results)
 
-        player_results =
-          Map.new(params.player_results, fn {player_id, result} ->
-            {player_id,
-             Map.put(
-               result,
-               :score,
-               get_score(
-                 tournament.score_strategy,
-                 match.level,
-                 result.result_percent,
-                 params.duration_sec
-               )
-             )}
-          end)
-
         params.player_results
         |> Map.keys()
         |> Enum.each(fn player_id ->
@@ -414,20 +399,13 @@ defmodule Codebattle.Tournament.Base do
           if player do
             player = %{
               player
-              | score: player.score + player_results[player_id].score,
-                lang: params.player_results[player_id].lang,
+              | lang: params.player_results[player_id].lang,
                 wins_count:
                   player.wins_count +
-                    if(player_results[player_id].result == "won", do: 1, else: 0)
+                    if(params.player_results[player_id].result == "won", do: 1, else: 0)
             }
 
             Tournament.Players.put_player(tournament, player)
-
-            Tournament.Ranking.update_player_result(
-              tournament,
-              player,
-              player_results[player_id].score
-            )
           end
         end)
 
@@ -436,7 +414,7 @@ defmodule Codebattle.Tournament.Base do
           | state: params.game_state,
             winner_id: winner_id,
             duration_sec: params.duration_sec,
-            player_results: player_results,
+            player_results: params.player_results,
             finished_at: DateTime.utc_now(:second)
         }
 
@@ -861,7 +839,6 @@ defmodule Codebattle.Tournament.Base do
           |> maybe_finish_waiting_room()
           |> set_stats()
           |> set_winner_ids()
-          # |> db_save!()
           |> maybe_save_event_results()
           |> db_save!(:with_ets)
           |> broadcast_tournament_finished()
@@ -1056,99 +1033,40 @@ defmodule Codebattle.Tournament.Base do
           tournament
         else
           # Process matches in parallel with Task.async_stream
-          match_results =
-            matches_to_finish
-            |> Task.async_stream(
-              fn match ->
-                duration_sec = NaiveDateTime.diff(finished_at, match.started_at)
-
-                # Get player results and trigger timeout
-                player_results = improve_player_results(tournament, match, duration_sec)
-                Game.Context.trigger_timeout(match.game_id)
-
-                # Create new match with timeout state
-                new_match = %{
-                  match
-                  | state: "timeout",
-                    player_results: player_results,
-                    duration_sec: duration_sec,
-                    finished_at: finished_at
-                }
-
-                # Return match and player data for batch processing
-                {new_match, player_results}
-              end,
-              max_concurrency: System.schedulers_online() * 2,
-              timeout: 10_000
-            )
-            |> Enum.to_list()
+          matches_to_finish
+          |> Task.async_stream(
+            fn match ->
+              # trigger game timeout and set player results
+              {:ok, game} = Game.Context.trigger_timeout(match.game_id)
+
+              # Create new match with timeout state
+              new_match = %{
+                match
+                | state: "timeout",
+                  player_results: Game.Helpers.get_player_results(game),
+                  duration_sec: game.duration_sec,
+                  finished_at: finished_at
+              }
 
-          # Batch update matches and collect player updates
-          player_updates =
-            Enum.reduce(match_results, %{}, fn {:ok, {new_match, player_results}}, acc ->
-              # Update match in tournament
+              # Return match and player data for batch processing
               Tournament.Matches.put_match(tournament, new_match)
 
               # Broadcast match update
               Codebattle.PubSub.broadcast("tournament:match:upserted", %{
                 tournament: tournament,
                 match: new_match
               })
-
-              # Collect player updates
-              Enum.reduce(player_results, acc, fn {player_id, result}, player_acc ->
-                player_score = result.score
-                player_lang = result.lang
-
-                # credo:disable-for-next-line Credo.Check.Refactor.Nesting
-                Map.update(player_acc, player_id, %{score: player_score, lang: player_lang}, fn existing ->
-                  %{score: existing.score + player_score, lang: player_lang}
-                end)
-              end)
-            end)
-
-          # Batch update player scores
-          Enum.each(player_updates, fn {player_id, updates} ->
-            player = Tournament.Players.get_player(tournament, player_id)
-
-            if player do
-              Tournament.Players.put_player(tournament, %{
-                player
-                | score: player.score + updates.score,
-                  lang: updates.lang
-              })
-            end
-          end)
+            end,
+            max_concurrency: System.schedulers_online() * 2,
+            timeout: 10_000
+          )
+          |> Stream.run()
 
           tournament
         end
       end
 
-      defp improve_player_results(tournament, match, duration_sec) do
-        case Game.Context.fetch_game(match.game_id) do
-          {:ok, %{is_live: true} = game} ->
-            game
-            |> Game.Helpers.get_player_results()
-            |> Map.new(fn {player_id, result} ->
-              {player_id,
-               Map.put(
-                 result,
-                 :score,
-                 get_score(
-                   tournament.score_strategy,
-                   match.level,
-                   result.result_percent,
-                   duration_sec
-                 )
-               )}
-            end)
-
-          {:error, _reason} ->
-            %{}
-        end
-      end
-
-      defp maybe_add_award(game_params, tournament) do
+      defp maybe_add_award(game_params, %{type: "show"} = tournament) do
         tournament.meta
         |> Map.get(:rounds_config)
         |> case do
@@ -1168,6 +1086,8 @@ defmodule Codebattle.Tournament.Base do
         end
       end
 
+      defp maybe_add_award(game_params, _tournament), do: game_params
+
       defp maybe_set_free_task(game_params, %Tournament{type: "show", task_strategy: "sequential"} = tournament, player) do
         task_id = Enum.at(tournament.round_task_ids, Enum.count(player.task_ids))
 

services/app/apps/codebattle/lib/codebattle/tournament/strategy/swiss.ex

@@ -20,10 +20,14 @@ defmodule Codebattle.Tournament.Swiss do
   def reset_meta(meta), do: meta
 
   @impl Tournament.Base
-  def finish_round_after_match?(%{current_round_position: current_round_position} = tournament) do
-    matches = get_round_matches(tournament, current_round_position)
+  def finish_round_after_match?(tournament) do
+    if tournament.players_count < 128 do
+      matches = get_round_matches(tournament, tournament.current_round_position)
 
-    Enum.all?(matches, &(&1.state != "playing"))
+      Enum.all?(matches, &(&1.state != "playing"))
+    else
+      false
+    end
   end
 
   @impl Tournament.Base

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

@@ -64,10 +64,10 @@ defmodule Codebattle.Tournament.TournamentResult do
       task_id,
       count(*),
       case
-        when level = 'elementary' THEN 30.0
+        when level = 'elementary' THEN 50.0
         when level = 'easy' THEN 100.0
-        when level = 'medium' THEN 300.0
-        when level = 'hard' THEN 1000.0
+        when level = 'medium' THEN 150.0
+        when level = 'hard' THEN 200.0
       end AS base_score,
       array_agg(duration_sec),
       max(duration_sec) as max_duration,
@@ -226,8 +226,8 @@ defmodule Codebattle.Tournament.TournamentResult do
         },
         where: r.tournament_id == ^tournament.id,
         group_by: [r.user_id, r.user_name, c.id],
-        order_by: [asc_nulls_first: sum(r.score)],
-        windows: [overall_partition: [order_by: [asc_nulls_first: sum(r.score), asc: sum(r.duration_sec)]]]
+        order_by: [desc: sum(r.score)],
+        windows: [overall_partition: [order_by: [desc_nulls_last: sum(r.score), asc: sum(r.duration_sec)]]]
       )
 
     Repo.all(query)

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

@@ -25,6 +25,7 @@ defmodule CodebattleWeb.GameChannel do
 
           active_game_id = Tournament.Helpers.get_active_game_id(tournament, user_id)
 
+          # TODO: think about active_game_id
           {user_id, active_game_id}
         else
           {nil, nil}

services/app/apps/codebattle/lib/codebattle_web/live/components/tournament/create_form.ex

@@ -264,9 +264,7 @@ defmodule CodebattleWeb.Live.Tournament.CreateFormComponent do
           <div class="d-flex flex-column flex-md-row flex-lg-row flex-xl-row justify-content-between mt-3">
             <div class="d-flex flex-column justify-content-between w-auto">
               <%= label(f, :rounds_limit) %>
-              <%= select(f, :rounds_limit, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 137, 200],
-                class: "custom-select"
-              ) %>
+              <%= select(f, :rounds_limit, Enum.to_list(1..42), class: "custom-select") %>
               <%= error_tag(f, :rounds_limit) %>
             </div>
           </div>

services/app/apps/codebattle/test/codebattle/game/context_test.exs

@@ -27,7 +27,7 @@ defmodule Codebattle.Game.ContextTest do
       game_topic = "game:#{game_id}"
       Codebattle.PubSub.subscribe(game_topic)
 
-      :ok = Game.Context.trigger_timeout(game_id)
+      {:ok, _new_game} = Game.Context.trigger_timeout(game_id)
 
       assert_received %Message{
         event: "game:finished",