Add standardised scoring for judged contests

app/Console/Commands/ContestCalculateScores.php

@@ -0,0 +1,33 @@
+<?php
+
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the GNU Affero General Public License v3.0.
+// See the LICENCE file in the repository root for full licence text.
+
+namespace App\Console\Commands;
+
+use App\Models\Contest;
+use Illuminate\Console\Command;
+
+class ContestCalculateScores extends Command
+{
+    protected $signature = 'contest:calculate-scores {contestId}';
+
+    protected $description = 'Cleans up expired chat keep alives.';
+
+    public function handle()
+    {
+        $contestId = get_int($this->argument('contestId'));
+        if ($contestId === null) {
+            $this->error('Contest id is required.');
+            return static::INVALID;
+        }
+
+        $contest = Contest::findOrFail($contestId);
+        if (!$contest->isScoreStandardised()) {
+            $this->error('Contest does not use standardised scoring.');
+            return static::FAILURE;
+        }
+
+        $contest->calculateScores();
+    }
+}

app/Http/Controllers/ContestEntriesController.php

@@ -9,6 +9,7 @@
 use App\Models\Contest;
 use App\Models\ContestEntry;
 use App\Models\UserContestEntry;
+use App\Transformers\ContestEntryTransformer;
 use App\Transformers\ContestTransformer;
 use Auth;
 use Ds\Set;
@@ -45,15 +46,16 @@ public function judgeResults($id)
             ],
         );
 
-        $entryJson = json_item($entry, 'ContestEntry', [
+        $entryJson = json_item($entry, new ContestEntryTransformer(), [
             'judge_votes.scores',
             'judge_votes.total_score',
+            'judge_votes.total_score_std',
             'judge_votes.user',
             'results',
             'user',
         ]);
 
-        $entriesJson = json_collection($entry->contest->entries, 'ContestEntry');
+        $entriesJson = json_collection($entry->contest->entries, new ContestEntryTransformer());
 
         return ext_view('contest_entries.judge-results', [
             'contestJson' => $contestJson,
@@ -100,7 +102,7 @@ public function judgeVote($id)
 
         $updatedEntry = $entry->refresh()->load('judgeVotes.scores');
 
-        return json_item($updatedEntry, 'ContestEntry', ['current_user_judge_vote.scores']);
+        return json_item($updatedEntry, new ContestEntryTransformer(), ['current_user_judge_vote.scores']);
     }
 
     public function vote($id)

app/Models/Contest.php

@@ -17,6 +17,7 @@
 use Illuminate\Database\Eloquent\Relations\HasMany;
 
 /**
+ * @property-read Collection<ContestJudge> $contestJudges
  * @property \Carbon\Carbon|null $created_at
  * @property string $description_enter
  * @property string|null $description_voting
@@ -28,7 +29,7 @@
  * @property string $header_url
  * @property int $id
  * @property mixed $link_icon
- * @property-read Collection<ContestJudge> $judges
+ * @property-read Collection<User> $judges
  * @property int $max_entries
  * @property int $max_votes
  * @property string $name
@@ -57,6 +58,11 @@ class Contest extends Model
         'voting_starts_at' => 'datetime',
     ];
 
+    public function contestJudges(): HasMany
+    {
+        return $this->HasMany(ContestJudge::class);
+    }
+
     public function entries()
     {
         return $this->hasMany(ContestEntry::class);
@@ -115,6 +121,14 @@ public function assertVoteRequirement(?User $user): void
         }
     }
 
+    public function calculateScores(): void
+    {
+        $this->contestJudges->each->calculateStdDev();
+
+        $judgeVotes = ContestJudgeVote::whereHas('entry', fn ($q) => $q->whereHas('contest', fn ($qq) => $qq->where('contest_id', $this->getKey())))->get();
+        $judgeVotes->each->calculateScore();
+    }
+
     public function isBestOf(): bool
     {
         return isset($this->getExtraOptions()['best_of']);
@@ -137,6 +151,11 @@ public function isJudgingActive(): bool
         return $this->isJudged() && $this->isVotingStarted() && !$this->show_votes;
     }
 
+    public function isScoreStandardised(): bool
+    {
+        return $this->getExtraOptions()['is_score_standardised'] ?? false;
+    }
+
     public function isSubmittedBeatmaps(): bool
     {
         return $this->isBestOf() || ($this->getExtraOptions()['submitted_beatmaps'] ?? false);
@@ -271,64 +290,28 @@ public function vote(User $user, ContestEntry $entry)
         }
     }
 
-    public function entriesByType($user = null, array $preloads = [])
+    public function entriesByType(?User $user, array $preloads = [])
     {
-        $entries = $this->entries()->with(['contest', ...$preloads]);
+        $query = $this->entries()->with(['contest', ...$preloads]);
 
         if ($this->show_votes) {
-            return Cache::remember("contest_entries_with_votes_{$this->id}", 300, function () use ($entries) {
-                $orderValue = 'votes_count';
-
-                if ($this->isBestOf()) {
-                    $entries = $entries
-                        ->selectRaw('*')
-                        ->selectRaw('(SELECT FLOOR(SUM(`weight`)) FROM `contest_votes` WHERE `contest_entries`.`id` = `contest_votes`.`contest_entry_id`) AS votes_count')
-                        ->limit(50); // best of contests tend to have a _lot_ of entries...
-                } else if ($this->isJudged()) {
-                    $entries = $entries->withSum('scores', 'value');
-                    $orderValue = 'scores_sum_value';
-                } else {
-                    $entries = $entries->withCount('votes');
-                }
-
-                return $entries->orderBy($orderValue, 'desc')->get();
-            });
-        } else {
-            if ($this->isBestOf()) {
-                if ($user === null) {
-                    return [];
-                }
+            $options = $this->getExtraOptions();
 
-                // Only return contest entries that a user has actually played
-                return $entries
-                    ->whereIn('entry_url', function ($query) use ($user) {
-                        $options = $this->getExtraOptions()['best_of'];
-                        $ruleset = $options['mode'] ?? 'osu';
-                        $query->select('beatmapset_id')
-                            ->from('osu_beatmaps')
-                            ->where('osu_beatmaps.playmode', Beatmap::MODES[$ruleset])
-                            ->whereIn('beatmap_id', function ($query) use ($user) {
-                                $query->select('beatmap_id')
-                                    ->from('osu_user_beatmap_playcount')
-                                    ->where('user_id', '=', $user->user_id);
-                            });
-
-                        if ($ruleset === 'mania' && isset($options['variant'])) {
-                            if ($options['variant'] === 'nk') {
-                                $query->whereNotIn('osu_beatmaps.diff_size', [4, 7]);
-                            } else {
-                                $keys = match ($options['variant']) {
-                                    '4k' => 4,
-                                    '7k' => 7,
-                                };
-                                $query->where('osu_beatmaps.diff_size', $keys);
-                            }
-                        }
-                    })->get();
+            return Cache::remember(
+                "contest_entries_with_votes_{$this->id}",
+                300,
+                fn () => $query->with(['contest', ...$preloads])->withScore($options)->get()
+            );
+        } elseif ($this->isBestOf()) {
+            if ($user === null) {
+                return [];
             }
+
+            $options = $this->getExtraOptions()['best_of'];
+            $query->forBestOf($user, $options['mode'] ?? 'osu', $options['variant'] ?? null);
         }
 
-        return $entries->get();
+        return $query->get();
     }
 
     public function defaultJson($user = null)

app/Models/ContestEntry.php

@@ -5,6 +5,8 @@
 
 namespace App\Models;
 
+use Illuminate\Contracts\Database\Query\Builder as QueryBuilder;
+use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Database\Eloquent\Collection;
 use Illuminate\Database\Eloquent\Relations\HasMany;
 use Illuminate\Database\Eloquent\Relations\HasManyThrough;
@@ -52,6 +54,59 @@ public function votes()
         return $this->hasMany(ContestVote::class);
     }
 
+    public function scopeForBestOf(Builder $query, User $user, string $ruleset, ?string $variant = null): Builder
+    {
+        $query->whereIn('entry_url', function (QueryBuilder $beatmapsetQuery) use ($ruleset, $user, $variant) {
+            $beatmapsetQuery->select('beatmapset_id')
+                ->from('osu_beatmaps')
+                ->where('osu_beatmaps.playmode', Beatmap::MODES[$ruleset])
+                ->whereIn('beatmap_id', function (QueryBuilder $beatmapQuery) use ($user) {
+                    $beatmapQuery->select('beatmap_id')
+                        ->from('osu_user_beatmap_playcount')
+                        ->where('user_id', $user->getKey());
+                });
+
+            if ($ruleset === 'mania' && $variant !== null) {
+                if ($variant === 'nk') {
+                    $beatmapsetQuery->whereNotIn('osu_beatmaps.diff_size', [4, 7]);
+                } else {
+                    $keys = match ($variant) {
+                        '4k' => 4,
+                        '7k' => 7,
+                    };
+                    $beatmapsetQuery->where('osu_beatmaps.diff_size', $keys);
+                }
+            }
+        });
+
+        return $query;
+    }
+
+    public function scopeWithScore(Builder $query, array $options): Builder
+    {
+        $orderValue = 'votes_count';
+
+        if (isset($options['best_of'])) {
+            $query
+                ->selectRaw('*')
+                ->selectRaw('(SELECT FLOOR(SUM(`weight`)) FROM `contest_votes` WHERE `contest_entries`.`id` = `contest_votes`.`contest_entry_id`) AS votes_count')
+                ->limit(50); // best of contests tend to have a _lot_ of entries...
+        } else if ($options['judged'] ?? false) {
+            $query->withSum('scores', 'value');
+
+            if ($options['is_score_standardised'] ?? false) {
+                $query->withSum('judgeVotes as total_score_std', 'total_score_std');
+                $orderValue = 'total_score_std';
+            } else {
+                $orderValue = 'scores_sum_value';
+            }
+        } else {
+            $query->withCount('votes');
+        }
+
+        return $query->orderBy($orderValue, 'desc');
+    }
+
     public function thumbnail(): ?string
     {
         if (!$this->contest->hasThumbnails()) {

app/Models/ContestJudge.php

@@ -7,11 +7,14 @@
 
 namespace App\Models;
 
+use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Database\Eloquent\Relations\BelongsTo;
 
 /**
  * @property-read Contest $contest
  * @property int $contest_id
+ * @property ?float $mean
+ * @property ?float $std_dev
  * @property-read User $user
  * @property int $user_id
  */
@@ -27,4 +30,24 @@ public function user(): BelongsTo
     {
         return $this->belongsTo(User::class, 'user_id');
     }
+
+    public function calculateStdDev(): void
+    {
+        [$stdDev, $mean] = $this->stdDev();
+
+        $this->update(['mean' => $mean, 'std_dev' => $stdDev]);
+    }
+
+    public function stdDev(): array
+    {
+        // TODO: treat missing scores as 0?
+        $entryScores = ContestJudgeScore::scoresByEntry()
+            ->whereHas(
+                'vote',
+                fn (Builder $q) => $q->where('user_id', $this->user_id)
+                    ->whereHas('entry', fn (Builder $qq) => $qq->where('contest_id', $this->contest_id))
+            )->pluck('total');
+
+        return std_dev($entryScores->toArray());
+    }
 }

app/Models/ContestJudgeScore.php

@@ -7,6 +7,7 @@
 
 namespace App\Models;
 
+use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Database\Eloquent\Relations\BelongsTo;
 
 /**
@@ -30,4 +31,22 @@ public function vote(): BelongsTo
     {
         return $this->belongsTo(ContestJudgeVote::class, 'contest_judge_vote_id');
     }
+
+    public function scopeScoresFrom(Builder $query, User $user, Contest $contest)
+    {
+        return $query->whereIn(
+            'contest_judge_vote_id',
+            ContestJudgeVote
+                ::where('user_id', $user->getKey())
+                ->whereIn('contest_entry_id', $contest->entries()->select('id'))
+            ->select('id')
+        );
+    }
+
+    public function scopeScoresByEntry(Builder $query)
+    {
+        return $query->groupBy('contest_judge_vote_id')
+            ->select('contest_judge_vote_id')
+            ->addSelect(\DB::raw('SUM(value) as total'));
+    }
 }

app/Models/ContestJudgeVote.php

@@ -18,6 +18,7 @@
  * @property \Carbon\Carbon|null $created_at
  * @property-read ContestEntry $entry
  * @property int $id
+ * @property float $total_score_std
  * @property \Carbon\Carbon|null $updated_at
  * @property-read User $user
  * @property int $user_id
@@ -43,4 +44,13 @@ public function user(): BelongsTo
     {
         return $this->belongsTo(User::class, 'user_id');
     }
+
+    public function calculateScore(): void
+    {
+        $judge = ContestJudge::where(['contest_id' => $this->entry->contest_id, 'user_id' => $this->user_id])->first();
+
+        if ($judge->std_dev !== null) {
+            $this->update(['total_score_std' => $judge->std_dev === 0.0 ? 0 : ($this->totalScore() - $judge->mean) / $judge->std_dev]);
+        }
+    }
 }

app/Transformers/ContestEntryTransformer.php

@@ -60,13 +60,15 @@ public function includeJudgeVotes(ContestEntry $entry): Collection
 
     public function includeResults(ContestEntry $entry)
     {
-        $votes = $entry->contest->isJudged()
+        $judged = $entry->contest->isJudged();
+        $votes = $judged
             ? $entry->scores_sum_value
             : $entry->votes_count;
 
         return $this->primitive([
             'actual_name' => $entry->name,
-            'votes' => (int) $votes,
+            'score_std' => $judged ? $entry->total_score_std : null,
+            'votes' => (int) $votes, // TODO: change to score or something else, or even better stop overloading the results value.
         ]);
     }