feat(scoring): Zeit-Bracket scoring strategy for Race Mode (#168) (#178)

* feat(scoring): implement Zeit-Bracket scoring strategy for Race Mode (#168)

Replaces the old ScoringService/ScoringServiceImpl with a sealed
ScoringStrategy hierarchy. RaceScoringStrategy applies time-bracket
points (DIAMOND=60, GOLD=45, SILVER=30, BRONZE=15, FINISH=5) on
map completion, then position bonuses (1st=10, 2nd=6, 3rd=3, 4th+=1)
at end-phase. PracticeScoringStrategy classifies medal tiers only
with no competitive points. Strategy is chosen by ScoringStrategyFactory
based on GameMode and stored as ScoringStrategyComponent on the game entity.

MapDefinition gains referenceDurationMs (default 3 min) used as the
bracket classification anchor. PlayerScore and ScoreComponent gain
completionTimeMs and medalTier fields. Flyway V1 baseline + V2
migration add completion_time_ms to game_results; database module
switches to Flyway for all future schema changes per ADR-0011.

* refactor(scoring): migrate to pure ECS — remove ScoringStrategy hierarchy

Replaces the hybrid ScoringStrategy service pattern with pure ECS:

- NEW: ElapsedTimeComponent (game entity, refreshed per tick by phase)
- NEW: BracketConfigComponent (game entity, set per map by orchestrator)
- NEW: CompletionDetectionSystem — detects when a player passes all rings,
  writes completionTimeMs + medalTier + bracket points (RACE: 60/45/30/15/5)
  directly into ScoreComponent; idempotent, degrades gracefully on missing config
- ScoreComponent.addPositionBonus(int) added for layered bonus application
- MinestomGamePhase: updateElapsedTime() runs before entityManager.update()
  so all systems see a consistent elapsed-time value on every tick;
  recordCompletions() removed (now CompletionDetectionSystem's job)
- MinestomEndPhase.rankAndApplyBonuses() is now pure ECS — reads
  GameModeComponent, applies 10/6/3/1 position bonuses for RACE, no-op for PRACTICE
- GameOrchestrator registers CompletionDetectionSystem in the system chain
  and attaches BracketConfigComponent to the game entity on each map load
- GameSession: ScoringStrategy field removed, constructor simplified to 3 args
- DELETED: ScoringStrategy, BaseScoringStrategy, RaceScoringStrategy,
  PracticeScoringStrategy, ScoringStrategyFactory, ScoringStrategyComponent
- Tests: ScoringServiceTest rewritten as CompletionDetectionSystem @envtest
  covering all bracket tiers, PRACTICE mode, idempotency, and DNF handling

* test(phase): fix MinestomEndPhaseRankingTest — update position bonuses to 10/6/3/1 and use @envtest with real players

* fix(database): V3 migration — convert UUID columns from BINARY(16) to native uuid type

Hibernate ORM 7 maps java.util.UUID to MariaDB's native uuid type, but the
V1 baseline created elytra_players.playerId and game_results.player_id as
BINARY(16). This caused two runtime errors:
- hbm2ddl=update tried to ALTER the columns but MariaDB refused due to FK
- INSERT failed with 'Data too long' because Hibernate sends UUID as a
  36-char string, not 16-byte binary

V3 drops fk_game_results_player, converts both columns to uuid NOT NULL,
and re-adds the FK. Safe on fresh installs too (no-op if already uuid).

* feat(hud): replace speed+points display with speed, ring progress, elapsed time and bracket pace

- Actionbar during race: '{speed} m/s · {passed}/{total} · {mm:ss.t} [BRACKET]'
  where bracket is colored (aqua=DIAMOND, gold=GOLD, gray=SILVER, bronze=BRONZE, red=FINISH)
  and projected from current pace (elapsedMs / passed * total)
- After finish: '{speed} m/s · MEDAL · {finish time}'
- Ring pass feedback: 'Ring X/N!' instead of '+1 pts' — ring points no longer
  meaningful to show per-ring since bracket score is awarded at finish
- ScoreDisplaySystem now injects EntityManager to read ElapsedTimeComponent,
  BracketConfigComponent and ActiveMapComponent from the game entity
- Updated translation keys: hud.actionbar (4 args), hud.actionbar.finished,
  hud.ring_passed (ring count instead of points)

* fix(game): reset rings and score on landing, sync isFlying from player.isGliding()

- ElytraPhysicsSystem now syncs flight.setFlying(player.isGliding()) every tick
  so landing is detected correctly (previously setFlying(false) was never called)
- New LandingResetSystem: on flying→notFlying transition for unfinished players,
  resets RingTrackerComponent + ScoreComponent and clears the actionbar
  (runs after ElytraPhysicsSystem, before ScoreDisplaySystem)
- ScoreDisplaySystem clears its tick/hash cache when not flying so the next
  takeoff renders the HUD immediately without a stale-hash delay
- HudComponent.clearActionbar() sends Component.empty() to dismiss the last message

* feat(scoring): dynamic DB record-based bracket scoring for race mode

Replace static per-map reference durations with a live record sourced from
the database. The first player to finish any (cup, map) combination sets the
record and receives DIAMOND; every subsequent finisher is classified relative
to the current in-session best via MedalBrackets.classify(). A faster finish
breaks the record and also earns DIAMOND.

- Add V4 Flyway migration and MapRecordEntity for the map_records table
- Add MapRecordRepository (getRecordTime / saveOrUpdateRecord UPSERT)
- Expose MapRecordRepository through DatabaseService / DatabaseServiceImpl
- Introduce MapRecordComponent (ECS component on game entity, holds recordTimeMs)
- Remove referenceDurationMs from MapDefinition; update BracketConfigComponent
  to hold only brackets (reference now comes from MapRecordComponent)
- Rewrite CompletionDetectionSystem with optional MapRecordRepository injection:
  sets/updates MapRecordComponent on game entity and fires async DB UPSERT
- GameOrchestrator.loadNextMap() seeds MapRecordComponent from DB async;
  passes MapRecordRepository to CompletionDetectionSystem
- ScoreDisplaySystem.computePace() reads MapRecordComponent for the pace
  projection; returns DIAMOND when no record exists yet
- Update ScoringServiceTest to seed MapRecordComponent instead of using
  the removed BracketConfigComponent reference field

* fix(server): resolve two compile errors blocking CI

- GameOrchestrator: remove duplicate local 'cupName' declaration inside
  loadNextMap() lambda (variable already declared at top of block)
- ElytraPhysicsSystem: replace player.isGliding() (not available in
  Minestom) with player.isOnGround() as the landing detection proxy;
  when the server confirms ground contact, flight.setFlying(false) is set
  so LandingResetSystem can detect the flying→landed transition

Author: TheMeinerLP

server/src/main/java/net/elytrarace/server/cup/MapDefinition.java

@@ -19,18 +19,20 @@
  * @param boostConfig    firework boost settings for this map; defaults to {@link BoostConfig#DEFAULT}
  * @param guidePoints    optional guide points for shaping the ideal racing line between rings
  */
-public record MapDefinition(String name, Path worldDirectory, List<Ring> rings, Pos spawnPos, BoostConfig boostConfig, List<GuidePointDTO> guidePoints) {
+public record MapDefinition(String name, Path worldDirectory, List<Ring> rings, Pos spawnPos,
+                            BoostConfig boostConfig, List<GuidePointDTO> guidePoints) {
+
     public MapDefinition {
         rings = List.copyOf(rings);
         guidePoints = List.copyOf(guidePoints);
     }
 
-    /** Convenience constructor using the default boost configuration. */
+    /** Convenience constructor using the default boost configuration and no guide points. */
     public MapDefinition(String name, Path worldDirectory, List<Ring> rings, Pos spawnPos) {
         this(name, worldDirectory, rings, spawnPos, BoostConfig.DEFAULT, List.of());
     }
 
-    /** Convenience constructor with boost config but no guide points. */
+    /** Convenience constructor with boost config and no guide points. */
     public MapDefinition(String name, Path worldDirectory, List<Ring> rings, Pos spawnPos, BoostConfig boostConfig) {
         this(name, worldDirectory, rings, spawnPos, boostConfig, List.of());
     }

server/src/main/java/net/elytrarace/server/ecs/component/BracketConfigComponent.java

@@ -0,0 +1,15 @@
+package net.elytrarace.server.ecs.component;
+
+import net.elytrarace.common.ecs.Component;
+import net.elytrarace.common.game.scoring.MedalBrackets;
+
+/**
+ * Holds the medal bracket configuration used to classify a player's completion
+ * time into a {@link net.elytrarace.common.game.scoring.MedalTier}.
+ * <p>
+ * The reference time is no longer stored here — it comes from {@link MapRecordComponent}
+ * (populated from DB at map load or set in-session by the first finisher).
+ * Attached to the game entity only.
+ */
+public record BracketConfigComponent(MedalBrackets brackets) implements Component {
+}

server/src/main/java/net/elytrarace/server/ecs/component/ElapsedTimeComponent.java

@@ -0,0 +1,14 @@
+package net.elytrarace.server.ecs.component;
+
+import net.elytrarace.common.ecs.Component;
+
+/**
+ * Tracks how long the current race has been running, in milliseconds.
+ * <p>
+ * Attached to the game entity only. Updated every tick by
+ * {@code MinestomGamePhase} before {@code entityManager.update()} runs, so any
+ * system processing player entities sees a consistent elapsed time for the
+ * current tick.
+ */
+public record ElapsedTimeComponent(long elapsedMs) implements Component {
+}

server/src/main/java/net/elytrarace/server/ecs/component/HudComponent.java

@@ -1,9 +1,12 @@
 package net.elytrarace.server.ecs.component;
 
 import net.elytrarace.common.ecs.Component;
+import net.elytrarace.common.game.scoring.MedalTier;
 import net.kyori.adventure.bossbar.BossBar;
 import net.kyori.adventure.sound.Sound;
+import net.kyori.adventure.text.TextComponent;
 import net.kyori.adventure.text.format.NamedTextColor;
+import net.kyori.adventure.text.format.TextColor;
 import net.kyori.adventure.text.format.TextDecoration;
 import net.kyori.adventure.title.Title;
 import net.minestom.server.entity.Player;
@@ -23,6 +26,8 @@
  */
 public class HudComponent implements Component {
 
+    private static final TextColor BRONZE_COLOR = TextColor.color(0xCD7F32);
+
     private final Player player;
     private BossBar cupProgressBar;
 
@@ -31,22 +36,48 @@ public HudComponent(Player player) {
     }
 
     /**
-     * Sends the speed/score actionbar line.
+     * Sends the live race actionbar: speed, ring progress, elapsed time, and the
+     * bracket tier the player is currently on pace for (projected finish bracket).
      *
-     * @param speedBlocksPerSec current speed in blocks per second
-     * @param currentPoints     accumulated ring points
+     * @param speedBlocksPerSec current speed in blocks/s
+     * @param passed            rings passed so far
+     * @param total             total rings on this map
+     * @param elapsedMs         race time elapsed in milliseconds
+     * @param pace              projected bracket if the player finished right now
      */
-    public void updateActionbar(double speedBlocksPerSec, int currentPoints) {
+    public void updateActionbar(double speedBlocksPerSec, int passed, int total,
+                                long elapsedMs, MedalTier pace) {
+        net.kyori.adventure.text.Component timeAndPace = buildTimeAndPace(elapsedMs, pace);
         player.sendActionBar(net.kyori.adventure.text.Component.translatable(
                 "hud.actionbar",
                 net.kyori.adventure.text.Component.text(String.format("%.1f", speedBlocksPerSec)),
-                net.kyori.adventure.text.Component.text(currentPoints)));
+                net.kyori.adventure.text.Component.text(passed),
+                net.kyori.adventure.text.Component.text(total),
+                timeAndPace));
+    }
+
+    /**
+     * Sends the post-finish actionbar: speed, medal tier earned, and finish time.
+     * Replaces the race actionbar once {@link ScoreComponent#hasFinished()} is true.
+     *
+     * @param speedBlocksPerSec current speed in blocks/s
+     * @param medal             medal tier earned on this map
+     * @param finishMs          map completion time in milliseconds
+     */
+    public void updateActionbarFinished(double speedBlocksPerSec, MedalTier medal, long finishMs) {
+        net.kyori.adventure.text.Component medalComponent = net.kyori.adventure.text.Component
+                .text(medal.name(), tierColor(medal), TextDecoration.BOLD);
+        player.sendActionBar(net.kyori.adventure.text.Component.translatable(
+                "hud.actionbar.finished",
+                net.kyori.adventure.text.Component.text(String.format("%.1f", speedBlocksPerSec)),
+                medalComponent,
+                net.kyori.adventure.text.Component.text(formatTime(finishMs))));
     }
 
     /**
      * Shows or replaces the cup-progress boss bar.
      *
-     * @param cupName   current cup name
+     * @param cupName    current cup name
      * @param currentMap 1-based map index
      * @param totalMaps  total maps in the cup
      */
@@ -109,26 +140,55 @@ public void showCountdown(int seconds) {
     }
 
     /**
-     * Shows ring-pass feedback: green "+N" actionbar and experience-orb sound.
+     * Shows ring-pass feedback: "Ring X/N!" in the actionbar and a pickup sound.
      *
-     * @param points points awarded for the ring
+     * @param passed rings passed so far (including this one)
+     * @param total  total rings on the map
      */
-    public void showRingPassed(int points) {
+    public void showRingPassed(int passed, int total) {
         player.sendActionBar(net.kyori.adventure.text.Component.translatable(
                 "hud.ring_passed",
-                net.kyori.adventure.text.Component.text(points)));
+                net.kyori.adventure.text.Component.text(passed),
+                net.kyori.adventure.text.Component.text(total)));
         player.playSound(Sound.sound(
                 SoundEvent.ENTITY_EXPERIENCE_ORB_PICKUP,
                 Sound.Source.MASTER,
                 1.0f,
                 1.5f));
     }
 
+    /** Clears the actionbar immediately (sends an empty component). */
+    public void clearActionbar() {
+        player.sendActionBar(net.kyori.adventure.text.Component.empty());
+    }
+
     /** Hides the boss bar. Call before removing the entity. */
     public void cleanup() {
         if (cupProgressBar != null) {
             player.hideBossBar(cupProgressBar);
             cupProgressBar = null;
         }
     }
+
+    private static net.kyori.adventure.text.Component buildTimeAndPace(long elapsedMs, MedalTier pace) {
+        TextColor color = tierColor(pace);
+        return net.kyori.adventure.text.Component.text(
+                formatTime(elapsedMs) + " [" + pace.name() + "]", color);
+    }
+
+    static TextColor tierColor(MedalTier tier) {
+        return switch (tier) {
+            case DIAMOND -> NamedTextColor.AQUA;
+            case GOLD    -> NamedTextColor.GOLD;
+            case SILVER  -> NamedTextColor.GRAY;
+            case BRONZE  -> BRONZE_COLOR;
+            case FINISH, DNF -> NamedTextColor.RED;
+        };
+    }
+
+    static String formatTime(long elapsedMs) {
+        long seconds = elapsedMs / 1000;
+        long tenths  = (elapsedMs % 1000) / 100;
+        return String.format("%d:%02d.%d", seconds / 60, seconds % 60, tenths);
+    }
 }

server/src/main/java/net/elytrarace/server/ecs/component/MapRecordComponent.java

@@ -0,0 +1,14 @@
+package net.elytrarace.server.ecs.component;
+
+import net.elytrarace.common.ecs.Component;
+
+/**
+ * Holds the current best finish time for the active map, in milliseconds.
+ * <p>
+ * Set on the game entity by {@code GameOrchestrator.loadNextMap()} from the DB record
+ * (if one exists) and updated in-session by {@code CompletionDetectionSystem} whenever
+ * a player finishes faster than the current value. Absent when no record has ever been
+ * set for this (cup, map) combination.
+ */
+public record MapRecordComponent(long recordTimeMs) implements Component {
+}

server/src/main/java/net/elytrarace/server/ecs/component/ScoreComponent.java

@@ -1,14 +1,33 @@
 package net.elytrarace.server.ecs.component;
 
 import net.elytrarace.common.ecs.Component;
+import net.elytrarace.common.game.scoring.MedalTier;
+import org.jetbrains.annotations.Nullable;
 
 /**
- * Stores a player's score, split into ring points and position bonus.
+ * Stores a player's per-map score state: ring points, position bonus, completion
+ * time, and the resulting medal tier.
+ * <p>
+ * The fields are written by different actors:
+ * <ul>
+ *   <li>{@code ringPoints} — incremented by {@link net.elytrarace.server.ecs.system.RingCollisionSystem}</li>
+ *   <li>{@code positionBonus} — set by {@link net.elytrarace.server.phase.MinestomEndPhase}
+ *       after ranking players by total score (RACE mode only)</li>
+ *   <li>{@code completionTimeMs} — set by {@code CompletionDetectionSystem} when the player
+ *       crosses the last ring</li>
+ *   <li>{@code medalTier} — set by {@code CompletionDetectionSystem} when the run is
+ *       classified against the map's bracket configuration</li>
+ * </ul>
  */
 public class ScoreComponent implements Component {
 
+    /** Sentinel for a player that did not finish the current map. */
+    public static final long NOT_FINISHED = -1L;
+
     private int ringPoints;
     private int positionBonus;
+    private long completionTimeMs = NOT_FINISHED;
+    private @Nullable MedalTier medalTier;
 
     /**
      * Returns the total score (ring points + position bonus).
@@ -33,11 +52,49 @@ public void setPositionBonus(int positionBonus) {
         this.positionBonus = positionBonus;
     }
 
+    public void addPositionBonus(int bonus) {
+        this.positionBonus += bonus;
+    }
+
+    /**
+     * Returns the player's map completion time in milliseconds, or
+     * {@link #NOT_FINISHED} if they have not finished yet.
+     */
+    public long getCompletionTimeMs() {
+        return completionTimeMs;
+    }
+
+    public void setCompletionTimeMs(long completionTimeMs) {
+        this.completionTimeMs = completionTimeMs;
+    }
+
+    /**
+     * Returns whether the player crossed the last ring on the current map.
+     */
+    public boolean hasFinished() {
+        return completionTimeMs >= 0;
+    }
+
+    /**
+     * Returns the medal tier earned on the current map, or {@code null} if the
+     * map has not been classified yet.
+     */
+    public @Nullable MedalTier getMedalTier() {
+        return medalTier;
+    }
+
+    public void setMedalTier(@Nullable MedalTier medalTier) {
+        this.medalTier = medalTier;
+    }
+
     /**
-     * Resets the score to zero.
+     * Resets the score for a new map. Clears ring points, position bonus,
+     * completion time, and medal tier.
      */
     public void reset() {
         this.ringPoints = 0;
         this.positionBonus = 0;
+        this.completionTimeMs = NOT_FINISHED;
+        this.medalTier = null;
     }
 }