Bump version to 0.1.6.38

- Entferne Fallback auf hasWon/hasLost States
- isSolved/isFailed werden jetzt direkt aus gameState gelesen
- Boolean() Konvertierung für explizite Typ-Sicherheit
- Behebt Problem, dass Ergebnisanzeige bei zurückkehrenden Rätseln nicht angezeigt wurde

Dockerfile

@@ -24,10 +24,12 @@ COPY --from=deps /app/node_modules ./node_modules
 COPY . .
 
 # Extract version: use build arg if provided, otherwise get from git, fallback to package.json
+# Only use tags that are reachable from the current commit to ensure version matches the code
 RUN if [ -n "$APP_VERSION" ]; then \
     echo "$APP_VERSION" > /tmp/version.txt; \
     else \
-    (git describe --tags --always 2>/dev/null || \
+    (git describe --tags --exact-match 2>/dev/null || \
+     git describe --tags --abbrev=0 2>/dev/null || \
      (grep -o '"version": "[^"]*"' package.json 2>/dev/null | cut -d'"' -f4 | sed 's/^/v/') || \
      echo "dev") > /tmp/version.txt; \
     fi && \

components/AudioPlayer.tsx

@@ -22,8 +22,8 @@ const AudioPlayer = forwardRef<AudioPlayerRef, AudioPlayerProps>(({ src, unlocke
     const [progress, setProgress] = useState(0);
     const [hasPlayedOnce, setHasPlayedOnce] = useState(false);
 
-    const [processedSrc, setProcessedSrc] = useState(src);
+    const [processedSrc, setProcessedSrc] = useState<string | null>(null);
-    const [processedUnlockedSeconds, setProcessedUnlockedSeconds] = useState(unlockedSeconds);
+    const [processedUnlockedSeconds, setProcessedUnlockedSeconds] = useState<number | null>(null);
 
     useEffect(() => {
         console.log('[AudioPlayer] MOUNTED');
@@ -41,7 +41,7 @@ const AudioPlayer = forwardRef<AudioPlayerRef, AudioPlayerProps>(({ src, unlocke
                 let startPos = startTime;
 
                 // If same song but more time unlocked, start from where previous segment ended
-                if (src === processedSrc && unlockedSeconds > processedUnlockedSeconds) {
+                if (processedSrc !== null && src === processedSrc && processedUnlockedSeconds !== null && unlockedSeconds > processedUnlockedSeconds) {
                     startPos = startTime + processedUnlockedSeconds;
                 }
 
@@ -62,8 +62,11 @@ const AudioPlayer = forwardRef<AudioPlayerRef, AudioPlayerProps>(({ src, unlocke
                 const initialPercent = unlockedSeconds > 0 ? (initialElapsed / unlockedSeconds) * 100 : 0;
                 setProgress(Math.min(initialPercent, 100));
 
-                setHasPlayedOnce(false); // Reset for new segment
+                // Only reset hasPlayedOnce if the song changed, not if just more time was unlocked
-                onHasPlayedChange?.(false); // Notify parent
+                if (processedSrc !== null && src !== processedSrc) {
+                    setHasPlayedOnce(false); // Reset for new song
+                    onHasPlayedChange?.(false); // Notify parent
+                }
 
                 // Update processed state
                 setProcessedSrc(src);
@@ -72,22 +75,34 @@ const AudioPlayer = forwardRef<AudioPlayerRef, AudioPlayerProps>(({ src, unlocke
                 if (autoPlay) {
                     // Delay play slightly to ensure currentTime sticks
                     setTimeout(() => {
-                        const playPromise = audioRef.current?.play();
+                        if (audioRef.current) {
-                        if (playPromise !== undefined) {
+                            // Use startPos (which may be startTime + processedUnlockedSeconds if more time was unlocked)
-                            playPromise
+                            // instead of always using startTime
-                                .then(() => {
+                            audioRef.current.currentTime = startPos;
-                                    setIsPlaying(true);
+                            const playPromise = audioRef.current.play();
-                                    onPlay?.();
+                            if (playPromise !== undefined) {
-                                    setHasPlayedOnce(true);
+                                playPromise
-                                    onHasPlayedChange?.(true); // Notify parent
+                                    .then(() => {
-                                })
+                                        setIsPlaying(true);
-                                .catch(error => {
+                                        onPlay?.();
-                                    console.log("Autoplay prevented:", error);
+                                        setHasPlayedOnce(true);
-                                    setIsPlaying(false);
+                                        onHasPlayedChange?.(true); // Notify parent
-                                });
+                                    })
+                                    .catch(error => {
+                                        console.log("Autoplay prevented:", error);
+                                        setIsPlaying(false);
+                                    });
+                            }
                         }
                     }, 150);
                 }
+            } else if (startTime !== undefined && startTime > 0) {
+                // If startTime is set and we haven't processed changes, ensure currentTime is at least at startTime
+                // This handles the case where the audio element was reset or reloaded, or when manually playing for the first time
+                const current = audioRef.current.currentTime;
+                if (current < startTime) {
+                    audioRef.current.currentTime = startTime;
+                }
             }
         }
     }, [src, unlockedSeconds, startTime, autoPlay, processedSrc, processedUnlockedSeconds]);
@@ -97,6 +112,16 @@ const AudioPlayer = forwardRef<AudioPlayerRef, AudioPlayerProps>(({ src, unlocke
         play: () => {
             if (!audioRef.current) return;
 
+            // Check if we need to reset to startTime
+            const current = audioRef.current.currentTime;
+            const elapsed = current - startTime;
+            
+            // Reset if: never played before, current position is before startTime, or we've exceeded the unlocked segment
+            if (!hasPlayedOnce || current < startTime || elapsed >= unlockedSeconds) {
+                // Reset to start of segment
+                audioRef.current.currentTime = startTime;
+            }
+            
             const playPromise = audioRef.current.play();
             if (playPromise !== undefined) {
                 playPromise
@@ -121,8 +146,35 @@ const AudioPlayer = forwardRef<AudioPlayerRef, AudioPlayerProps>(({ src, unlocke
 
         if (isPlaying) {
             audioRef.current.pause();
+            setIsPlaying(false);
         } else {
+            // Ensure we're at the correct position before playing
+            const current = audioRef.current.currentTime;
+            const elapsed = current - startTime;
+            
+            // Determine target position
+            let targetPos = startTime;
+            
+            // If we've played before and we're within the unlocked segment, continue from current position
+            if (hasPlayedOnce && current >= startTime && elapsed < unlockedSeconds) {
+                targetPos = current; // Continue from current position
+            } else {
+                // Reset to start of segment if: never played, before startTime, or exceeded unlocked segment
+                targetPos = startTime;
+            }
+            
+            // Set position before playing
+            audioRef.current.currentTime = targetPos;
+            
+            // Ensure position sticks (browser might reset it)
+            setTimeout(() => {
+                if (audioRef.current && Math.abs(audioRef.current.currentTime - targetPos) > 0.5) {
+                    audioRef.current.currentTime = targetPos;
+                }
+            }, 50);
+            
             audioRef.current.play();
+            setIsPlaying(true);
             onPlay?.();
 
             if (hasPlayedOnce) {
@@ -132,7 +184,6 @@ const AudioPlayer = forwardRef<AudioPlayerRef, AudioPlayerProps>(({ src, unlocke
                 onHasPlayedChange?.(true); // Notify parent
             }
         }
-        setIsPlaying(!isPlaying);
     };
 
     const handleTimeUpdate = () => {

components/Game.tsx

@@ -96,6 +96,10 @@ export default function Game({ dailyPuzzle, genre = null, isSpecial = false, max
             if (gameState.isSolved && !gameState.yearGuessed && dailyPuzzle?.releaseYear) {
                 setShowYearModal(true);
             }
+        } else {
+            // Reset states when gameState is null (e.g., during loading)
+            setHasWon(false);
+            setHasLost(false);
         }
     }, [gameState, dailyPuzzle]);
 
@@ -163,6 +167,12 @@ export default function Game({ dailyPuzzle, genre = null, isSpecial = false, max
         </div>
     );
     if (!gameState) return <div>{t('loadingState')}</div>;
+    
+    // Use gameState directly for isSolved/isFailed to ensure consistency when returning to completed puzzles
+    // Always use gameState values directly - they are the source of truth
+    // This ensures that when returning to a completed puzzle, the result is shown immediately
+    const isSolved = Boolean(gameState.isSolved);
+    const isFailed = Boolean(gameState.isFailed);
 
     const handleGuess = (song: any) => {
         if (isProcessingGuess) return;
@@ -176,6 +186,7 @@ export default function Game({ dailyPuzzle, genre = null, isSpecial = false, max
         if (song.id === dailyPuzzle.songId) {
             addGuess(song.title, true);
             setHasWon(true);
+            // gameState.isSolved will be updated by useGameState
             // Track puzzle solved event
             if (typeof window !== 'undefined' && window.plausible) {
                 window.plausible('puzzle_solved', {
@@ -196,6 +207,7 @@ export default function Game({ dailyPuzzle, genre = null, isSpecial = false, max
             if (gameState.guesses.length + 1 >= maxAttempts) {
                 setHasLost(true);
                 setHasWon(false);
+                // gameState.isFailed will be updated by useGameState
                 // Track puzzle lost event
                 if (typeof window !== 'undefined' && window.plausible) {
                     window.plausible('puzzle_solved', {
@@ -236,6 +248,7 @@ export default function Game({ dailyPuzzle, genre = null, isSpecial = false, max
         if (gameState.guesses.length + 1 >= maxAttempts) {
             setHasLost(true);
             setHasWon(false);
+            // gameState.isFailed will be updated by useGameState
             // Track puzzle lost event
             if (typeof window !== 'undefined' && window.plausible) {
                 window.plausible('puzzle_solved', {
@@ -260,6 +273,7 @@ export default function Game({ dailyPuzzle, genre = null, isSpecial = false, max
         giveUp(); // Ensure game is marked as failed and score reset to 0
         setHasLost(true);
         setHasWon(false);
+        // gameState.isFailed will be updated by useGameState
         // Track puzzle lost event
         if (typeof window !== 'undefined' && window.plausible) {
             window.plausible('puzzle_solved', {
@@ -409,19 +423,19 @@ export default function Game({ dailyPuzzle, genre = null, isSpecial = false, max
             if (i < gameState.guesses.length) {
                 if (gameState.guesses[i] === 'SKIPPED') {
                     emojiGrid += '⬛';
-                } else if (hasWon && i === gameState.guesses.length - 1) {
+                } else if (isSolved && i === gameState.guesses.length - 1) {
                     emojiGrid += '🟩';
                 } else {
                     emojiGrid += '🟥';
                 }
             } else {
                 // If game is lost, fill remaining slots with black squares
-                emojiGrid += hasLost ? '⬛' : '⬜';
+                emojiGrid += isFailed ? '⬛' : '⬜';
             }
         }
 
-        const speaker = hasWon ? '🔉' : '🔇';
+        const speaker = isSolved ? '🔉' : '🔇';
-        const bonusStar = (hasWon && gameState.yearGuessed && dailyPuzzle.releaseYear && gameState.scoreBreakdown.some(item => item.reason === 'Bonus: Correct Year')) ? '⭐' : '';
+        const bonusStar = (isSolved && gameState.yearGuessed && dailyPuzzle.releaseYear && gameState.scoreBreakdown.some(item => item.reason === 'Bonus: Correct Year')) ? '⭐' : '';
         const genreText = genre ? `${isSpecial ? t('special') : t('genre')}: ${genre}\n` : '';
 
         // Use current domain from window.location to support both hoerdle.de and hördle.de
@@ -534,7 +548,7 @@ export default function Game({ dailyPuzzle, genre = null, isSpecial = false, max
                             src={dailyPuzzle.audioUrl}
                             unlockedSeconds={unlockedSeconds}
                             startTime={dailyPuzzle.startTime}
-                            autoPlay={lastAction === 'SKIP' || (lastAction === 'GUESS' && !hasWon && !hasLost)}
+                            autoPlay={lastAction === 'SKIP' || (lastAction === 'GUESS' && !isSolved && !isFailed)}
                             onReplay={addReplay}
                             onHasPlayedChange={setHasPlayedAudio}
                         />
@@ -543,7 +557,7 @@ export default function Game({ dailyPuzzle, genre = null, isSpecial = false, max
 
                 <div className="guess-list">
                     {gameState.guesses.map((guess, i) => {
-                        const isCorrect = hasWon && i === gameState.guesses.length - 1;
+                        const isCorrect = isSolved && i === gameState.guesses.length - 1;
                         return (
                             <div key={i} className="guess-item">
                                 <span className="guess-number">#{i + 1}</span>
@@ -555,7 +569,7 @@ export default function Game({ dailyPuzzle, genre = null, isSpecial = false, max
                     })}
                 </div>
 
-                {!hasWon && !hasLost && (
+                {!isSolved && !isFailed && (
                     <>
                         <div id="tour-input">
                             <GuessInput onGuess={handleGuess} disabled={isProcessingGuess} />
@@ -586,13 +600,13 @@ export default function Game({ dailyPuzzle, genre = null, isSpecial = false, max
                     </>
                 )}
 
-                {(hasWon || hasLost) && (
+                {(isSolved || isFailed) && (
-                    <div className={`message-box ${hasWon ? 'success' : 'failure'}`}>
+                    <div className={`message-box ${isSolved ? 'success' : 'failure'}`}>
                         <h2 style={{ fontSize: '1.5rem', fontWeight: 'bold', marginBottom: '0.5rem' }}>
-                            {hasWon ? t('won') : t('lost')}
+                            {isSolved ? t('won') : t('lost')}
                         </h2>
 
-                        <div style={{ fontSize: '2rem', fontWeight: 'bold', margin: '1rem 0', color: hasWon ? 'var(--success)' : 'var(--danger)' }}>
+                        <div style={{ fontSize: '2rem', fontWeight: 'bold', margin: '1rem 0', color: isSolved ? 'var(--success)' : 'var(--danger)' }}>
                             {t('score')}: {gameState.score}
                         </div>
 
@@ -610,7 +624,7 @@ export default function Game({ dailyPuzzle, genre = null, isSpecial = false, max
                             </ul>
                         </details>
 
-                        <p>{hasWon ? t('comeBackTomorrow') : t('theSongWas')}</p>
+                        <p>{isSolved ? t('comeBackTomorrow') : t('theSongWas')}</p>
 
                         <div style={{ margin: '1.5rem 0', padding: '1rem', background: 'rgba(255,255,255,0.5)', borderRadius: '0.5rem', display: 'flex', flexDirection: 'column', alignItems: 'center' }}>
                             <img

docs/TESTING.md

@@ -0,0 +1,88 @@
+# Integration Testing
+
+Hördle uses [Playwright](https://playwright.dev/) for end-to-end (E2E) integration testing. These tests ensure that critical flows like gameplay, authentication, and admin management function correctly across different browsers.
+
+## Prerequisites
+
+Ensure you have the Playwright browsers installed:
+
+```bash
+npx playwright install
+```
+
+## Running Tests
+
+### Headless Mode (CI/CLI)
+
+To run all tests in headless mode (Chromium, Firefox, WebKit):
+
+```bash
+npm run test:e2e
+```
+
+### UI Mode (Interactive)
+
+To run tests with a UI to inspect traces and watch execution:
+
+```bash
+npm run test:e2e:ui
+```
+
+### Specific Test File
+
+To run a specific test file:
+
+```bash
+npx playwright test tests/gameplay.spec.ts
+```
+
+### Specific Project (Browser)
+
+To run tests only on a specific browser (e.g., Chromium):
+
+```bash
+npx playwright test --project=chromium
+```
+
+## Configuration
+
+The Playwright configuration is located in `playwright.config.ts`. It sets up the base URL (default: `http://localhost:3000`) and the web server command to start the app if it's not running.
+
+### Environment Variables
+
+*   **`ADMIN_PASSWORD`**: The tests assume the admin password is `'admin123'`. 
+    *   In `app/api/admin/login/route.ts`, the login logic has been enhanced to check if `ADMIN_PASSWORD` is a bcrypt hash (starts with `$2b$`) or plain text. 
+    *   For local testing, you can set `ADMIN_PASSWORD="admin123"` in your `.env` or `.env.local` (though the default fallback in the code also handles this).
+*   **Curator Credentials**: The mock Curator login page (`app/[locale]/curator/page.tsx`) mocks validation for testing.
+    *   Username: `elpatron`
+    *   Password: `example_password`
+
+## Test Structure
+
+Tests are located in the `tests/` directory:
+
+*   **`auth.spec.ts`**: Verifies public access and admin login flows.
+*   **`admin.spec.ts`**: Checks the Admin Dashboard, including access protection and visibility of sections (Dashboard, Daily Puzzles, etc.).
+*   **`curator.spec.ts`**: Verifies the Curator login form and authentication flows (valid/invalid credentials).
+*   **`gameplay.spec.ts`**: Tests the core game loop: loading the game, playing audio, interaction with the prompt, and submitting a guess.
+
+## Troubleshooting & Known Issues
+
+### Next.js Development Overlay (`nextjs-portal`)
+
+In development mode (`npm run dev`), Next.js injects an overlay (`<nextjs-portal>`) for hot reloading feedback. This overlay can sometimes intercept clicks intended for UI elements, causing tests to fail with "element is not clickable" or timeout errors.
+
+**Solution:** 
+We inject a CSS style in the `beforeEach` hook of our tests to hide this overlay:
+
+```typescript
+test.beforeEach(async ({ page }) => {
+    await page.addStyleTag({ content: 'nextjs-portal, #nextjs-dev-overlay, [data-nextjs-dev-overlay] { display: none !important; }' });
+});
+```
+
+### WebKit (Safari) Stability
+
+WebKit can be slower or more sensitive to timing in some environments. If tests fail on WebKit but pass on other browsers:
+1.  Try increasing the timeout in `playwright.config.ts`.
+2.  Use `await page.waitForTimeout(500)` or specific assertions like `await expect(page).toHaveURL(...)` to allow for transition times, as implemented in `tests/admin.spec.ts`.

package.json

@@ -1,6 +1,6 @@
 {
   "name": "hoerdle",
-  "version": "0.1.6.33",
+  "version": "0.1.6.38",
   "private": true,
   "scripts": {
     "dev": "next dev",

scripts/deploy.sh

@@ -63,10 +63,44 @@ fi
 ./scripts/backup-restic.sh
 
 # Nur neueste Version holen (shallow fetch), vollständiges Repo ist im Deployment nicht nötig
-echo "📥 Fetching latest commit (shallow clone) from git..."
+# Wichtig: Tags müssen vollständig geholt werden für Version-Anzeige
-git fetch --prune --tags --depth=1 origin master
+echo "📥 Fetching latest commit and all tags from git..."
+git fetch --prune --tags origin master
+git fetch --tags origin
 git reset --hard origin/master
 
+# Determine version: try git tag first, then package.json
+echo "🏷️  Determining version..."
+APP_VERSION=""
+# Try to get exact tag if we're on a tagged commit
+if git describe --tags --exact-match HEAD 2>/dev/null; then
+    APP_VERSION=$(git describe --tags --exact-match HEAD 2>/dev/null)
+    echo "   Found exact tag: $APP_VERSION"
+else
+    # Try to get latest tag
+    LATEST_TAG=$(git describe --tags --abbrev=0 2>/dev/null || echo "")
+    if [ -n "$LATEST_TAG" ]; then
+        APP_VERSION="$LATEST_TAG"
+        echo "   Using latest tag: $APP_VERSION"
+    else
+        # Fallback to package.json
+        if [ -f "package.json" ]; then
+            PACKAGE_VERSION=$(grep -o '"version": "[^"]*"' package.json 2>/dev/null | cut -d'"' -f4)
+            if [ -n "$PACKAGE_VERSION" ]; then
+                APP_VERSION="v${PACKAGE_VERSION}"
+                echo "   Using package.json version: $APP_VERSION"
+            fi
+        fi
+    fi
+fi
+
+if [ -z "$APP_VERSION" ]; then
+    echo "⚠️  Could not determine version, using 'dev'"
+    APP_VERSION="dev"
+fi
+
+echo "📦 Building with version: $APP_VERSION"
+
 # Prüfe und erstelle/repariere Netzwerk falls nötig
 echo "🌐 Prüfe Docker-Netzwerk..."
 if ! docker network ls | grep -q "hoerdle_default"; then
@@ -82,7 +116,7 @@ echo ""
 
 # Build new image in background (doesn't stop running container)
 echo "🔨 Building new Docker image (this runs while app is still online)..."
-docker compose build
+docker compose build --build-arg APP_VERSION="$APP_VERSION"
 
 # Quick restart with pre-built image
 echo "🔄 Restarting with new image (minimal downtime)..."