add optscore logic to order team

Author: as6325400

webapp/src/Service/ScoreboardService.php

@@ -139,24 +139,44 @@ public function calculateTeamRank(
             $totalTime  = $contest->getRuntimeAsScoreTiebreaker() ? $rankCache->getTotalruntimeRestricted() : $rankCache->getTotaltimeRestricted();
         }
         $timeType   = $contest->getRuntimeAsScoreTiebreaker() ? 'runtime' : 'time';
+        $useOpt     = $contest->getOptScoreAsScoreTiebreaker();
+        $optMode    = $contest->getOptScoreOrder() === 'asc' ? 'min' : 'max';
         $sortOrder  = $team->getCategory()->getSortorder();
 
+        if ($useOpt) {
+            $tieField = "r.totaloptscore_{$optMode}_{$variant}";
+            $tieOp    = $optMode === 'min' ? '<' : '>';
+            $tieValue = $rankCache
+                ? $rankCache->getTotalOptscore($restricted)
+                : 0;
+            $tieValue = $tieValue ?? 0;
+        } else {
+            $type     = $contest->getRuntimeAsScoreTiebreaker() ? 'runtime' : 'time';
+            $tieField = "r.total{$type}_{$variant}";
+            $tieOp    = '<';
+            $tieValue = $totalTime;
+        }
+
         // Number of teams that definitely ranked higher.
-        $better = $this->em->createQueryBuilder()
+        $better = (int) $this->em->createQueryBuilder()
+            ->select('COUNT(t.teamid)')
             ->from(RankCache::class, 'r')
             ->join('r.team', 't')
             ->join('t.category', 'tc')
-            ->select('COUNT(t.teamid)')
-            ->andWhere('r.contest = :contest')
+            ->andWhere('r.contest   = :contest')
             ->andWhere('tc.sortorder = :sortorder')
-            ->andWhere('t.enabled = 1')
-            ->andWhere(sprintf('r.points_%s > :points OR '.
-                               '(r.points_%s = :points AND r.total%s_%s < :totaltime)',
-                               $variant, $variant, $timeType, $variant))
-            ->setParameter('contest', $contest)
-            ->setParameter('sortorder', $sortOrder)
-            ->setParameter('points', $points)
-            ->setParameter('totaltime', $totalTime)
+            ->andWhere('t.enabled   = 1')
+            ->andWhere(sprintf(
+                'r.points_%1$s >  :points
+                OR (r.points_%1$s = :points AND %2$s %3$s :tiebreaker)',
+                $variant,
+                $tieField,
+                $tieOp
+            ))
+            ->setParameter('contest',    $contest)
+            ->setParameter('sortorder',  $sortOrder)
+            ->setParameter('points',     $points)
+            ->setParameter('tiebreaker', $tieValue)
             ->getQuery()
             ->getSingleScalarResult();
 
@@ -175,12 +195,15 @@ public function calculateTeamRank(
                 ->andWhere('r.contest = :contest')
                 ->andWhere('tc.sortorder = :sortorder')
                 ->andWhere('t.enabled = 1')
-                ->andWhere(sprintf('r.points_%s = :points AND r.total%s_%s = :totaltime',
-                                   $variant, $timeType, $variant))
+                ->andWhere(sprintf(
+                    'r.points_%1$s = :points AND %2$s = :tiebreaker',
+                    $variant,
+                    $tieField
+                ))
                 ->setParameter('contest', $contest)
                 ->setParameter('sortorder', $sortOrder)
                 ->setParameter('points', $points)
-                ->setParameter('totaltime', $totalTime)
+                ->setParameter('tiebreaker', $tieValue)
                 ->getQuery()
                 ->getResult();
 
@@ -576,10 +599,14 @@ public function updateRankCache(Contest $contest, Team $team): void
         $numPoints = [];
         $totalTime = [];
         $totalRuntime = [];
+        $totalMaxOpt = [];
+        $totalMinOpt = [];
         foreach ($variants as $variant => $isRestricted) {
             $numPoints[$variant] = 0;
             $totalTime[$variant] = $team->getPenalty();
             $totalRuntime[$variant] = 0;
+            $totalMaxOpt[$variant] = 0;
+            $totalMinOpt[$variant] = 0;
         }
 
         $penaltyTime      = (int) $this->config->get('penalty_time');
@@ -612,6 +639,8 @@ public function updateRankCache(Contest $contest, Team $team): void
                         $scoreIsInSeconds
                     ) + $penalty;
                     $totalRuntime[$variant] += $scoreCache->getRuntime($isRestricted);
+                    $totalMaxOpt[$variant] += $scoreCache->getMaxOptscore($isRestricted);
+                    $totalMinOpt[$variant] += $scoreCache->getMinOptscore($isRestricted);
                 }
             }
         }
@@ -623,14 +652,30 @@ public function updateRankCache(Contest $contest, Team $team): void
             'pointsRestricted' => $numPoints['restricted'],
             'totalTimeRestricted' => $totalTime['restricted'],
             'totalRuntimeRestricted' => $totalRuntime['restricted'],
+            'totalMaxOptRestricted' => $totalMaxOpt['restricted'],
+            'totalMinOptRestricted' => $totalMinOpt['restricted'],
             'pointsPublic' => $numPoints['public'],
             'totalTimePublic' => $totalTime['public'],
             'totalRuntimePublic' => $totalRuntime['public'],
+            'totalMaxOptPublic' => $totalMaxOpt['public'],
+            'totalMinOptPublic' => $totalMinOpt['public']
         ];
-        $this->em->getConnection()->executeQuery('REPLACE INTO rankcache (cid, teamid,
-            points_restricted, totaltime_restricted, totalruntime_restricted,
-            points_public, totaltime_public, totalruntime_public)
-            VALUES (:cid, :teamid, :pointsRestricted, :totalTimeRestricted, :totalRuntimeRestricted, :pointsPublic, :totalTimePublic, :totalRuntimePublic)', $params);
+        $this->em->getConnection()->executeQuery(
+            'REPLACE INTO rankcache (
+                cid, teamid,
+                points_restricted, totaltime_restricted, totalruntime_restricted,
+                totaloptscore_max_restricted, totaloptscore_min_restricted,
+                totaloptscore_max_public, totaloptscore_min_public,
+                points_public, totaltime_public, totalruntime_public
+            ) VALUES (
+                :cid, :teamid,
+                :pointsRestricted, :totalTimeRestricted, :totalRuntimeRestricted,
+                :totalMaxOptRestricted, :totalMinOptRestricted,
+                :totalMaxOptPublic, :totalMinOptPublic,
+                :pointsPublic, :totalTimePublic, :totalRuntimePublic
+            )',
+            $params
+        );
 
         if ($this->em->getConnection()->fetchOne('SELECT RELEASE_LOCK(:lock)',
                                                     ['lock' => $lockString]) != 1) {

webapp/src/Utils/Scoreboard/Scoreboard.php

@@ -158,7 +158,8 @@ protected function calculateScoreboard(): void
                 $scoreRow->getPending($this->restricted),
                 $scoreRow->getSolveTime($this->restricted),
                 $penalty,
-                $scoreRow->getRuntime($this->restricted)
+                $scoreRow->getRuntime($this->restricted),
+                $scoreRow->getOptscore($this->restricted)
             );
 
             if ($scoreRow->getIsCorrect($this->restricted)) {
@@ -169,6 +170,7 @@ protected function calculateScoreboard(): void
                 $this->scores[$teamId]->solveTimes[] = $solveTime;
                 $this->scores[$teamId]->totalTime += $solveTime + $penalty;
                 $this->scores[$teamId]->totalRuntime += $scoreRow->getRuntime($this->restricted);
+                $this->scores[$teamId]->totalOptscore += $scoreRow->getOptscore($this->restricted);
             }
         }
 
@@ -216,7 +218,7 @@ protected function calculateScoreboard(): void
                 $problemId = $contestProblem->getProbid();
                 // Provide default scores when nothing submitted for this team + problem yet
                 if (!isset($this->matrix[$teamId][$problemId])) {
-                    $this->matrix[$teamId][$problemId] = new ScoreboardMatrixItem(false, false, 0, 0, 0, 0, 0);
+                    $this->matrix[$teamId][$problemId] = new ScoreboardMatrixItem(false, false, 0, 0, 0, 0, 0, 0);
                 }
 
                 $problemMatrixItem = $this->matrix[$teamId][$problemId];
@@ -458,4 +460,13 @@ public function getRuntimeAsScoreTiebreaker(): bool
     {
         return $this->contest->getRuntimeAsScoreTiebreaker();
     }
+
+    /**
+     * Determine whether to order by optscore instead of solvetime
+     * @return bool
+     */
+    public function getOptScoreAsScoreTiebreaker(): bool
+    {
+        return $this->contest->getOptScoreAsScoreTiebreaker();
+    }
 }

webapp/src/Utils/Scoreboard/ScoreboardMatrixItem.php

@@ -11,6 +11,7 @@ public function __construct(
         public int $numSubmissionsPending,
         public float|string $time,
         public int $penaltyTime,
-        public int $runtime
+        public int $runtime,
+        public float|null $optscore
     ) {}
 }

webapp/src/Utils/Scoreboard/SingleTeamScoreboard.php

@@ -46,6 +46,7 @@ protected function calculateScoreboard(): void
             $teamScore->numPoints += $this->rankCache->getPointsRestricted();
             $teamScore->totalTime += $this->rankCache->getTotaltimeRestricted();
             $teamScore->totalRuntime += $this->rankCache->getTotalruntimeRestricted();
+            $teamScore->totalOptscore +=  $this->rankCache->getTotalOptscoreRestricted();
         }
         $teamScore->rank = $this->teamRank;
 
@@ -69,7 +70,8 @@ protected function calculateScoreboard(): void
                 $scoreRow->getPending($this->restricted),
                 $scoreRow->getSolveTime($this->restricted),
                 $penalty,
-                $scoreRow->getRuntime($this->restricted)
+                $scoreRow->getRuntime($this->restricted),
+                $scoreRow->getOptscore($this->restricted)
             );
         }
 
@@ -79,7 +81,7 @@ protected function calculateScoreboard(): void
             $teamId    = $this->team->getTeamid();
             $problemId = $contestProblem->getProbid();
             if (!isset($this->matrix[$teamId][$problemId])) {
-                $this->matrix[$teamId][$problemId] = new ScoreboardMatrixItem(false, false, 0, 0, 0, 0, 0);
+                $this->matrix[$teamId][$problemId] = new ScoreboardMatrixItem(false, false, 0, 0, 0, 0, 0, 0);
             }
         }
     }

webapp/src/Utils/Scoreboard/TeamScore.php

@@ -13,6 +13,7 @@ class TeamScore
     public int $rank = 0;
     public int $totalTime;
     public int $totalRuntime = 0;
+    public ?float $totalOptscore = null;
 
     public function __construct(public Team $team)
     {

webapp/templates/partials/scoreboard_table.html.twig

@@ -235,6 +235,8 @@
                 <td class="scorenc">{{ totalPoints }}</td>
                 {% if scoreboard.getRuntimeAsScoreTiebreaker() %}
                     <td class="scorett">{{ "%0.3f s" | format(score.totalRuntime/1000.0) }}</td>
+                {% elseif contest.getOptScoreAsScoreTiebreaker() %}
+                    <td class="scorett">{{ score.totalOptscore | formatOptScore }}</td>
                 {% else %}
                     <td class="scorett">{{ totalTime }}</td>
                 {% endif %}
@@ -270,7 +272,9 @@
                     {% set time = '' %}
                     {% if matrixItem.isCorrect %}
                         {% set time = matrixItem.time %}
-                        {% if scoreboard.getRuntimeAsScoreTiebreaker() %}
+                        {% if scoreboard.getOptScoreAsScoreTiebreaker() %}
+                            {% set time = matrixItem.optscore %}
+                        {% elseif scoreboard.getRuntimeAsScoreTiebreaker() %}
                             {% set time = "%0.3f s" | format(matrixItem.runtime / 1000.0) %}
                         {% elseif scoreInSeconds %}
                             {% set time = time | scoreTime | printTimeRelative %}