import React, { useState, useEffect, useCallback } from 'react'; import Track from 'Track'; import Controls from 'Controls'; import Resources from 'Resources'; import { generateTrackRow, generateObstacleRow } from 'gameUtils'; import RogueShop from 'RogueShop'; import AudioManager from 'AudioManager'; import LevelBonus from 'LevelBonus'; import BossLevelManager from 'BossLevelManager'; import BonusLevelManager from 'BonusLevelManager'; import AudioInitializer from 'AudioInitializer'; import ConfettiEffect from 'ConfettiEffect'; import VictoryScreen from 'VictoryScreen'; import GameLoader from 'GameLoader'; const Game = ({ onTurnsChange, highScore }) => { const [bossState, setBossState] = useState({ active: false, remainingRows: 0, level: 0 }); // Ajout d'une variable d'état pour suivre le nombre total de rangées boss générées pour chaque niveau const [bossRowsGenerated, setBossRowsGenerated] = useState({}); const [collectedItem, setCollectedItem] = useState(null); const [showBonusNotification, setShowBonusNotification] = useState(false); // New function to handle boss level activation const activateBossLevel = useCallback((currentTurn) => { if (BossLevelManager.isBossLevel(currentTurn)) { const newBossState = BossLevelManager.activateBossLevel(currentTurn); setBossState(newBossState); // Play the boss level notification sound BossLevelManager.playBossNotification(AudioManager); return true; } return false; }, []); const [gameOverReason, setGameOverReason] = useState("Out of fuel!"); const [currentCellItem, setCurrentCellItem] = useState(null); const [showRogueShop, setShowRogueShop] = useState(false); const [gameOverState, setGameOverState] = useState(false); const [showResetConfirm, setShowResetConfirm] = useState(false); // Roguelike upgrades configuration const [rogueUpgrades, setRogueUpgrades] = useState(() => { // Load upgrades using GameLoader with error handling return GameLoader.loadRogueUpgrades(); }); // Tracker for completed bonus levels const [completedBonusLevels, setCompletedBonusLevels] = useState(() => { // Load completed bonus levels using GameLoader with error handling return GameLoader.loadCompletedBonusLevels(); }); // Save completed bonus levels whenever they change useEffect(() => { localStorage.setItem('rogueRaceCompletedBonusLevels', JSON.stringify(completedBonusLevels)); }, [completedBonusLevels]); const [gameState, setGameState] = useState(() => { // Use GameLoader to load saved game progress with error handling const loadedState = GameLoader.loadGameProgress(); // Apply track generation to the loaded state and enable dev mode return { ...loadedState, track: [ ['⬛', '⬛', '⬛'], // First row always empty for a clean start generateTrackRow(), generateTrackRow() ], devMode: true // Activer le mode développeur dès le démarrage }; }); // Check if an object is present on the player's current square useEffect(() => { if (!gameState.gameOver) { // Handle both normal track rows and boss level rows consistently let currentItem; const trackRow = gameState.track[2]; // Check if the track row is an array (normal case) or an object with cells (boss row) if (Array.isArray(trackRow)) { currentItem = trackRow[gameState.position]; } else if (trackRow && trackRow.cells) { // Boss row case - use the cells property currentItem = trackRow.cells[gameState.position]; } else { currentItem = '⬛'; // Default to empty if structure is unexpected } setCurrentCellItem(currentItem !== '⬛' ? currentItem : null); } }, [gameState.track, gameState.position, gameState.gameOver]); // Apply fuel efficiency effect const getFuelEfficiencyChance = () => { const fuelEfficiency = rogueUpgrades.find(u => u.id === 'fuelEfficiency'); // Use the effect property directly as a reference instead of calling it as a function return fuelEfficiency && fuelEfficiency.level > 0 ? fuelEfficiency.level * 10 : 0; }; const moveForward = (direction) => { if (gameState.gameOver || gameState.fuel <= 0) return; // Always check for level bonus first if (collectedItem && collectedItem.type === 'levelBonus') { if (direction === 'levelBonus') { LevelBonus.handleCollectLevelBonus(collectedItem, buyItem); // Check if it's a permanent bonus if (collectedItem.isPermanentBonus) { // Don't add immediate coins for permanent bonuses // Instead, we'll show a notification about future games AudioManager.playBonusSound(); // Update the collected item to show it's been processed setCollectedItem(prevItem => ({ ...prevItem, collected: true, message: "Permanent bonus unlocked for future games!" })); } else if (collectedItem.bonus && !collectedItem.collected) { // For non-permanent bonuses, add coins as before setGameState(prevState => ({ ...prevState, coins: prevState.coins + collectedItem.bonus })); AudioManager.playBonusSound(); } // Clear the notification after a short delay setTimeout(() => { setCollectedItem(null); }, 1500); } return; // Prevent any movement if there's an uncollected level bonus } // First collect item at current position before moving // First collect item at current position before moving let currentPosition = gameState.position; // Determine current item consistently for both normal and boss level rows let currentItem; const trackRow = gameState.track[2]; if (Array.isArray(trackRow)) { currentItem = trackRow[currentPosition]; } else if (trackRow && trackRow.cells) { // Boss level case currentItem = trackRow.cells[currentPosition]; } else { currentItem = '⬛'; // Default to empty if structure is unexpected } // Create a deep copy of the track to modify const currentTrack = JSON.parse(JSON.stringify(gameState.track)); // Variables to track state changes from current position item let newFuel = gameState.fuel; let newAmmo = gameState.ammo; let newCoins = gameState.coins; let newScore = gameState.score || 0; // Ensure score is initialized let newLightning = gameState.lightning || 0; // Ensure lightning is initialized let collectedItemType = null; let collectedItemIcon = null; // Process current position item FIRST if (currentItem !== '⬛') { // Handle item at current position if (currentItem === '💥') { collectedItemType = 'obstacle'; collectedItemIcon = currentItem; if (gameState.ammo > 0) { newAmmo--; // Use ammo to destroy obstacle AudioManager.playObstacleSound(); } else { // Game over when hitting an obstacle without ammo setGameOverReason("You hit an obstacle without any ammo! Game Over."); setGameOverState(true); AudioManager.playGameOverSound(); // Update game state and trigger auto-save on death const newGameState = { ...gameState, gameOver: true, deaths: (gameState.deaths || 0) + 1 }; setGameState(newGameState); // Explicitly save progress on death const gameProgress = { lightning: gameState.lightning, coins: gameState.coins, turns: gameState.turns, deaths: (gameState.deaths || 0) + 1, highScore: highScore }; localStorage.setItem('rogueRaceProgress', JSON.stringify(gameProgress)); return; // Exit the function early to prevent further processing } } else if (currentItem === '🚧') { collectedItemType = 'barrier'; collectedItemIcon = currentItem; if (gameState.ammo >= 2) { newAmmo -= 2; // Use 2 ammo to destroy barrier AudioManager.playObstacleSound(); // Add sound effect for barriers } else { // Game over when hitting a barrier without enough ammo setGameOverReason("You hit a barrier but needed 2 ammo to break through! Game Over."); setGameOverState(true); AudioManager.playGameOverSound(); // Update game state and trigger auto-save on death const newGameState = { ...gameState, gameOver: true, deaths: (gameState.deaths || 0) + 1 }; setGameState(newGameState); // Explicitly save progress on death const gameProgress = { lightning: gameState.lightning, coins: gameState.coins, turns: gameState.turns, deaths: (gameState.deaths || 0) + 1, highScore: highScore }; localStorage.setItem('rogueRaceProgress', JSON.stringify(gameProgress)); return; // Exit the function early to prevent further processing } } else if (currentItem === '📌' && gameState.turns > 100) { // Pin - NEW Endless Mode obstacle (requires 3 ammo) collectedItemType = 'pinObstacle'; collectedItemIcon = currentItem; if (gameState.ammo >= 3) { newAmmo -= 3; // Use 3 ammo to destroy pin AudioManager.playObstacleSound(); } else { // Game over when hitting a pin without enough ammo setGameOverReason("You encountered a pin obstacle but needed 3 ammo to break through! Game Over."); setGameOverState(true); AudioManager.playGameOverSound(); // Update game state and trigger auto-save on death const newGameState = { ...gameState, gameOver: true, deaths: (gameState.deaths || 0) + 1 }; setGameState(newGameState); // Explicitly save progress on death const gameProgress = { lightning: gameState.lightning, coins: gameState.coins, turns: gameState.turns, deaths: (gameState.deaths || 0) + 1, highScore: highScore }; localStorage.setItem('rogueRaceProgress', JSON.stringify(gameProgress)); return; // Exit the function early to prevent further processing } } else if (currentItem === '🔪' && gameState.turns > 100) { // Knife - Endless Mode obstacle (removes 2 fuel) collectedItemType = 'knifeObstacle'; collectedItemIcon = currentItem; newFuel = Math.max(0, newFuel - 2); // Remove 2 fuel, but not below 0 AudioManager.playObstacleSound(); // Check if the fuel loss would cause game over if (newFuel <= 0) { setGameOverReason("The knife obstacle depleted your fuel! Game Over."); setGameOverState(true); AudioManager.playGameOverSound(); // Update game state and trigger auto-save on death const newGameState = { ...gameState, gameOver: true, deaths: (gameState.deaths || 0) + 1 }; setGameState(newGameState); // Explicitly save progress on death const gameProgress = { lightning: gameState.lightning, coins: gameState.coins, turns: gameState.turns, deaths: (gameState.deaths || 0) + 1, highScore: highScore }; localStorage.setItem('rogueRaceProgress', JSON.stringify(gameProgress)); return; // Exit the function early to prevent further processing } } else if (currentItem === '⛽') { collectedItemType = 'fuel'; collectedItemIcon = currentItem; newFuel = Math.min(newFuel + 2, gameState.maxFuel); // Add fuel, respect maxFuel AudioManager.playFuelSound(); } else if (currentItem === '💣') { collectedItemType = 'ammo'; collectedItemIcon = currentItem; newAmmo = Math.min(newAmmo + 1, gameState.maxAmmo); // Add ammo, respect maxAmmo AudioManager.playAmmoSound(); } else if (currentItem === '💰') { collectedItemType = 'coin'; collectedItemIcon = currentItem; newCoins += 50; // Add coins AudioManager.playCollectSound(); } else if (currentItem === '⚡') { collectedItemType = 'boost'; collectedItemIcon = currentItem; newScore += 30; // Speed boost bonus newLightning += 1; // Add lightning to the counter debugLightning('COLLECTED', gameState.lightning, newLightning); AudioManager.playCollectSound(); } else if (currentItem === '🧲' && gameState.turns > 100) { // Magnet - NEW Endless Mode power-up collectedItemType = 'magnetPowerUp'; collectedItemIcon = currentItem; AudioManager.playCollectSound(); // Collect all power-ups in current row let powerUpsCollected = 0; // Create a deep copy of the track to modify const modifiedTrack = JSON.parse(JSON.stringify(gameState.track)); // Check if the current row is a regular array or a boss row if (Array.isArray(modifiedTrack[2])) { // Process regular array row for (let i = 0; i < modifiedTrack[2].length; i++) { const cell = modifiedTrack[2][i]; if (i !== gameState.position && cell !== '⬛') { // Check if it's a collectible item (not an obstacle) if (cell === '⛽') { newFuel = Math.min(newFuel + 2, gameState.maxFuel); powerUpsCollected++; } else if (cell === '💣') { newAmmo = Math.min(newAmmo + 1, gameState.maxAmmo); powerUpsCollected++; } else if (cell === '💰') { newCoins += 50; powerUpsCollected++; } else if (cell === '⚡') { newLightning += 1; powerUpsCollected++; } // Clear the cell after collecting modifiedTrack[2][i] = '⬛'; } } } else if (modifiedTrack[2] && modifiedTrack[2].cells) { // Process boss row for (let i = 0; i < modifiedTrack[2].cells.length; i++) { const cell = modifiedTrack[2].cells[i]; if (i !== gameState.position && cell !== '⬛') { // Check if it's a collectible item (not an obstacle) if (cell === '⛽') { newFuel = Math.min(newFuel + 2, gameState.maxFuel); powerUpsCollected++; } else if (cell === '💣') { newAmmo = Math.min(newAmmo + 1, gameState.maxAmmo); powerUpsCollected++; } else if (cell === '💰') { newCoins += 50; powerUpsCollected++; } else if (cell === '⚡') { newLightning += 1; powerUpsCollected++; } // Clear the cell after collecting modifiedTrack[2].cells[i] = '⬛'; } } } // Add a bonus based on how many power-ups were collected if (powerUpsCollected > 0) { newScore += powerUpsCollected * 20; // Set a variable in game state to track that magnet is active for next row setGameState(prevState => ({ ...prevState, magnetActive: true // Will be used when generating the next row })); } // Update the track with collected items setGameState(prevState => ({ ...prevState, track: modifiedTrack })); } else if (currentItem === '🃏' && gameState.turns > 100) { // Joker - NEW Endless Mode power-up (random effect) collectedItemType = 'jokerPowerUp'; collectedItemIcon = currentItem; AudioManager.playCollectSound(); // Generate a random effect const effects = [ // Good effects () => { newFuel = Math.min(newFuel + 5, gameState.maxFuel); }, // Fuel boost () => { newAmmo = Math.min(newAmmo + 3, gameState.maxAmmo); }, // Ammo boost () => { newCoins += 100; }, // Coin boost () => { newScore += 100; }, // Score boost // Bad effects () => { newFuel = Math.max(1, newFuel - 1); }, // Fuel loss (but never below 1) () => { newAmmo = Math.max(0, newAmmo - 1); }, // Ammo loss // Neutral or situational effects () => { setGameState(prevState => ({ ...prevState, blitzActive: 5 })); } // Activate Blitz ]; // Choose and apply a random effect const randomEffect = effects[Math.floor(Math.random() * effects.length)]; randomEffect(); // Show what the joker did const jokerNotification = { type: 'jokerEffect', icon: '🃏', message: `The Joker has cast its spell!`, requireDismissal: true }; setCollectedItem(jokerNotification); } else if (currentItem === '🔄' && gameState.turns > 100) { // Blitz - NEW Endless Mode power-up (reverse controls) collectedItemType = 'blitzPowerUp'; collectedItemIcon = currentItem; AudioManager.playCollectSound(); // Set blitz effect for 5 turns setGameState(prevState => ({ ...prevState, blitzActive: 5 // Will count down each turn })); // Show notification about reversed controls const blitzNotification = { type: 'blitzEffect', icon: '🔄', message: `Controls reversed for 5 turns!`, requireDismissal: true }; setCollectedItem(blitzNotification); } else if (currentItem === '🧨' && gameState.turns > 100) { // Chain Explosion - NEW Endless Mode power-up collectedItemType = 'explosionPowerUp'; collectedItemIcon = currentItem; AudioManager.playObstacleSound(); // Use obstacle sound for explosion // Set flag to destroy all obstacles in next row setGameState(prevState => ({ ...prevState, explosionActive: true // Will be checked when processing next row })); // Show notification about the chain explosion const explosionNotification = { type: 'explosionEffect', icon: '🧨', message: `Chain explosion ready for next row!`, requireDismissal: true }; setCollectedItem(explosionNotification); } // Clear the current cell immediately // Handle both normal track rows and boss rows if (Array.isArray(currentTrack[2])) { currentTrack[2][currentPosition] = '⬛'; } else if (currentTrack[2] && currentTrack[2].cells) { // Boss level case currentTrack[2].cells[currentPosition] = '⬛'; } // Show collected item animation if (collectedItemType) { setCollectedItem({ type: collectedItemType, icon: collectedItemIcon, position: currentPosition }); // Clear the animation after it completes, EXCEPT for level bonus which requires explicit dismissal if (collectedItemType !== 'levelBonus') { setTimeout(() => { setCollectedItem(null); }, 1000); } } // Update game state immediately with current position effects setGameState({ ...gameState, track: currentTrack, fuel: newFuel, ammo: newAmmo, coins: newCoins, score: newScore, lightning: newLightning // Ensure lightning updates are saved }); // Exit early to let the animation complete before moving return; } // ONLY after processing current cell, apply movement for the next step let newPosition = currentPosition; // Apply direction change for next movement - movement limited to one space at a time // Check if Blitz effect is active (reversed controls) if (gameState.blitzActive && gameState.blitzActive > 0) { // Reversed controls if (direction === 'right' && newPosition > 0) { newPosition--; // Move left when right is pressed } else if (direction === 'left' && newPosition < 2) { newPosition++; // Move right when left is pressed } } else { // Normal controls if (direction === 'left' && newPosition > 0) { newPosition--; // Move one space to the left } else if (direction === 'right' && newPosition < 2) { newPosition++; // Move one space to the right } } // After collecting current cell items, consume fuel and add score for movement // Chance to not consume fuel (roguelike upgrade) const fuelEfficiencyChance = getFuelEfficiencyChance(); const shouldConsumeFuel = Math.random() * 100 > fuelEfficiencyChance; if (shouldConsumeFuel) { newFuel = Math.max(0, newFuel - 1); // Consume fuel for movement } // Score multiplier (roguelike upgrade) const scoreMultiplier = rogueUpgrades.find(u => u.id === 'scoreMultiplier'); // Calculate multiplier directly instead of calling effect as a function const multiplier = scoreMultiplier && scoreMultiplier.level > 0 ? 1 + (scoreMultiplier.level * 0.25) : 1; newScore += Math.floor(10 * multiplier); // Add score for movement with multiplier // Check for boss encounter, bonus levels, and game end let newBossState = { ...bossState }; const currentTurn = gameState.turns + 1; console.log("Current turn:", currentTurn); // Debug log if (currentTurn === 100) { // End the game at level 100 with victory celebration setGameOverReason("Congratulations! You've completed all 100 levels! You are the CHAMPION!"); setGameOverState(true); // Important: Set both gameOver and isVictory flags together setGameState(prevState => ({ ...prevState, gameOver: true, isVictory: true // Propriété pour identifier une fin victorieuse })); // Play celebratory sound AudioManager.playBonusSound(); // Launch confetti celebration ConfettiEffect.createConfetti(); return; // Exit the function to prevent further processing } else if (BossLevelManager.isBossLevel(currentTurn)) { // Boss level check console.log("Boss level reached at turn:", currentTurn); // Activate special level with no empty cells using BossLevelManager newBossState = BossLevelManager.activateBossLevel(currentTurn); // Utiliser la fonction de débogage pour afficher l'état initial du niveau boss const debugResult = BossLevelManager.debugBossLevel( currentTurn, newBossState, 0, bossRowsGenerated ); // Force le nombre correct de rangées en utilisant forceCorrectRowCount newBossState = BossLevelManager.forceCorrectRowCount( currentTurn, newBossState, 0, bossRowsGenerated ); console.log(`Boss level ${currentTurn} initialized with ${newBossState.remainingRows} obstacle rows`); // Play boss level sound AudioManager.playBonusLevelSound(); } else if (BonusLevelManager.isBonusLevel(currentTurn)) { // Bonus level check console.log("Bonus level reached at turn:", currentTurn); // Process the level bonus const bonusProcessed = LevelBonus.processLevelBonus( currentTurn, completedBonusLevels, setCollectedItem, setCompletedBonusLevels ); if (bonusProcessed) { console.log("Bonus level processed successfully"); AudioManager.playBonusSound(); } else { console.log("Bonus level not processed (possibly already collected)"); } } // Generate new track row and shift existing rows let newTrack; // Initialiser le compteur des rangées générées pour le niveau boss actuel let generatedBossRows = 0; // Récupérer le compteur total des rangées générées pour ce niveau boss (si existant) const totalBossRowsGenerated = bossRowsGenerated[currentTurn] || 0; if (newBossState.active && newBossState.remainingRows > 0) { // For boss levels, generate obstacle rows with increasing difficulty - 100% obstacles const bossRow = generateObstacleRow(newBossState.level); // No more random power-ups in boss levels - they are 100% obstacles const bossRowWithIndicator = bossRow; console.log(`Boss level ${newBossState.level}, remaining rows: ${newBossState.remainingRows}`); // Mark this as a boss row with a special property // Create a standard array format for boss rows to ensure compatibility with item collection const bossRowArray = [...bossRowWithIndicator]; // Ensure we're using a plain array // Create the new track with proper formatting for boss rows newTrack = [ bossRowArray, // Use a simple array format for consistency ...currentTrack.slice(0, 2) ]; // Incrémenter le compteur de rangées générées // Incrémentation du compteur local generatedBossRows++; // Mise à jour du compteur total pour ce niveau boss const updatedTotalRows = totalBossRowsGenerated + 1; // Add a special message for debug if (newBossState.remainingRows === 1) { console.log(`Last boss row generated for level ${newBossState.level}`); } // Update boss state after row generation newBossState = BossLevelManager.updateBossState(newBossState); // Utiliser la fonction de débogage pour vérifier l'état après génération const debugAfterGeneration = BossLevelManager.debugBossLevel( currentTurn, newBossState, generatedBossRows, bossRowsGenerated ); // Forcer la correction si nécessaire newBossState = BossLevelManager.forceCorrectRowCount( currentTurn, newBossState, generatedBossRows, bossRowsGenerated ); // Play a special sound to indicate boss level progression if (newBossState.remainingRows === 1) { // This is the last boss row, play a success sound AudioManager.playBonusSound(); } // Validation finale if (newBossState.remainingRows === 0) { const validationResult = BossLevelManager.validateObstacleRowsCount( currentTurn, generatedBossRows ); if (!validationResult) { console.warn(`Correction finale du niveau boss ${currentTurn}: ${generatedBossRows} rangées générées sur ${BossLevelManager.getObstacleRows(currentTurn)} attendues`); newBossState.active = false; } else { console.log(`Niveau boss ${currentTurn} correctement terminé avec ${generatedBossRows} rangées`); } } } else { // Check if the previous boss level has just been completed if (bossState.active === false && BossLevelManager.isBossLevel(currentTurn - 1) && bossRowsGenerated[currentTurn - 1]) { // Validate boss level completion to determine if we should add power-up row const validationResult = BossLevelManager.validateBossLevelCompletion( currentTurn - 1, bossState, bossRowsGenerated ); if (validationResult.valid || validationResult.shouldAddPowerUpRow) { console.log(`Adding power-up reward row after completing boss level ${currentTurn - 1}`); // Generate a special power-up reward row const powerUpRow = BossLevelManager.generatePowerUpRow(); newTrack = [ powerUpRow, ...currentTrack.slice(0, 2) ]; } else { // Regular row generation newTrack = [ generateTrackRow(), ...currentTrack.slice(0, 2) ]; } } else { // Regular row generation let newRow = generateTrackRow(); // If explosionActive is true, clear all obstacles in the first row if (gameState.explosionActive) { newRow = newRow.map(cell => { // If the cell is an obstacle, clear it if (cell === '💥' || cell === '🚧' || cell === '📌' || cell === '🔪') { return '⬛'; // Clear the obstacle } return cell; }); // Play explosion sound effect AudioManager.playObstacleSound(); // Reset the explosion flag newBossState.explosionActive = false; } // If magnetActive is true, collect all power-ups in the new row if (gameState.magnetActive) { let powerUpCollected = false; // Process each cell in the new row newRow = newRow.map(cell => { // If it's a collectible (not an obstacle) if (cell === '⛽') { newFuel = Math.min(newFuel + 2, gameState.maxFuel); powerUpCollected = true; return '⬛'; // Clear after collecting } else if (cell === '💣') { newAmmo = Math.min(newAmmo + 1, gameState.maxAmmo); powerUpCollected = true; return '⬛'; // Clear after collecting } else if (cell === '💰') { newCoins += 50; powerUpCollected = true; return '⬛'; // Clear after collecting } else if (cell === '⚡') { newLightning += 1; powerUpCollected = true; return '⬛'; // Clear after collecting } return cell; // Keep other items as they are }); // Reset the magnet flag newBossState.magnetActive = false; // Play collect sound if any power-up was collected if (powerUpCollected) { AudioManager.playCollectSound(); newScore += 25; // Bonus for magnet collection } } newTrack = [ newRow, ...currentTrack.slice(0, 2) ]; } } // Update game state with movement and track generation setGameState({ ...gameState, track: newTrack, position: newPosition, fuel: newFuel, ammo: newAmmo, coins: newCoins, score: newScore, turns: gameState.turns + 1, gameOver: newFuel <= 0, lightning: newLightning, // Make sure lightning changes are saved in state // Reset or decrement special effect counters blitzActive: gameState.blitzActive > 0 ? gameState.blitzActive - 1 : 0, magnetActive: false, explosionActive: false }); // Make sure the boss state is properly persisted before next turn console.log(`Setting boss state to: active=${newBossState.active}, remainingRows=${newBossState.remainingRows}, level=${newBossState.level}`); // Mettre à jour la variable d'état qui suit le nombre total de rangées générées if (BossLevelManager.isBossLevel(currentTurn)) { setBossRowsGenerated(prev => ({ ...prev, [currentTurn]: (prev[currentTurn] || 0) + generatedBossRows })); } // Vérification finale avant de persister l'état boss if (BossLevelManager.isBossLevel(currentTurn)) { // Dernière vérification pour s'assurer que le nombre de rangées est correct const expectedRows = BossLevelManager.getObstacleRows(currentTurn); const totalGeneratedForLevel = (bossRowsGenerated[currentTurn] || 0) + generatedBossRows; if (newBossState.remainingRows === 0 && totalGeneratedForLevel < expectedRows) { console.warn(`Correction finale avant persistence: Niveau boss ${currentTurn} n'a pas généré assez de rangées (${totalGeneratedForLevel}/${expectedRows})`); newBossState = { ...newBossState, active: true, remainingRows: expectedRows - totalGeneratedForLevel }; } else if (totalGeneratedForLevel >= expectedRows && newBossState.remainingRows > 0) { console.warn(`Correction finale avant persistence: Niveau boss ${currentTurn} a généré trop de rangées (${totalGeneratedForLevel}/${expectedRows}), désactivation du niveau boss`); newBossState = { ...newBossState, active: false, remainingRows: 0 }; } } setBossState(newBossState); // Check for milestone levels before setting game over if (BossLevelManager.isBossLevel(currentTurn) && newFuel <= 0 && !gameState.gameOver) { // Process permanent bonus before game over LevelBonus.processPermanentBonus( currentTurn, completedBonusLevels, setCollectedItem, setCompletedBonusLevels ); // Don't set game over yet - let player collect the bonus first AudioManager.playBonusLevelSound(); // Only deduct fuel for future calculations newFuel = 0; } // Check if we've just reached a bonus level and are out of fuel else if (BonusLevelManager.isBonusLevel(currentTurn) && newFuel <= 0 && !gameState.gameOver) { // Process bonus level before game over const bonusProcessed = LevelBonus.processLevelBonus( currentTurn, completedBonusLevels, setCollectedItem, setCompletedBonusLevels ); if (bonusProcessed) { console.log("Prioritizing bonus collection over game over"); // Set a flag in the collectedItem to indicate game over should happen after collection setCollectedItem(prev => ({ ...prev, delayGameOver: true, message: "Collect your bonus before the game ends!", requireDismissal: true })); // Play bonus sound to alert the player AudioManager.playBonusSound(); // Keep fuel at 0 but don't trigger game over yet newFuel = 0; } else { // No new bonus to process, proceed with game over setGameOverReason("Out of fuel! Your car stopped in the middle of the track."); setGameOverState(true); AudioManager.playGameOverSound(); // Increment death counter when running out of fuel setGameState(prevState => ({ ...prevState, deaths: (prevState.deaths || 0) + 1 })); } } // Standard game over check with bonus collection priority else if (newFuel <= 0 && !gameState.gameOver) { // Check if there's an uncollected level bonus before setting game over if (collectedItem && collectedItem.type === 'levelBonus' && !collectedItem.collected) { // Prioritize bonus collection - don't trigger game over yet console.log("Delaying game over to allow bonus collection"); // Show a notification to prompt user to collect the bonus setCollectedItem(prev => ({ ...prev, message: "Collect your bonus before continuing!", flashHighlight: true, requireDismissal: true, delayGameOver: true })); // Play a special alert sound AudioManager.playBonusSound(); } else { // No pending bonus to collect, proceed with game over setGameOverReason("Out of fuel! Your car stopped in the middle of the track."); setGameOverState(true); AudioManager.playGameOverSound(); // Increment death counter setGameState(prevState => ({ ...prevState, deaths: (prevState.deaths || 0) + 1 })); } } }; const buyItem = (item, quantity = 1) => { if (gameState.gameOver) return; let newCoins = gameState.coins; let newFuel = gameState.fuel; let newAmmo = gameState.ammo; // Handle level bonus collection if (item === 'levelBonus' && collectedItem && collectedItem.type === 'levelBonus') { if (collectedItem.bonus && !collectedItem.collected) { newCoins += collectedItem.bonus; AudioManager.playBonusSound(); // Check if this was a delayed game over situation const wasDelayingGameOver = collectedItem.delayGameOver; setCollectedItem(prevItem => ({ ...prevItem, collected: true, message: wasDelayingGameOver ? "Bonus collected! Game will continue..." : "Bonus collected!" })); setGameState(prevState => ({ ...prevState, coins: newCoins })); // For regular bonuses (not delaying game over), clear after a delay if (!wasDelayingGameOver) { setTimeout(() => { setCollectedItem(null); }, 1000); } // For bonuses delaying game over, we'll handle them in handleCloseBonusNotification } return; } // Gérer la collecte du power-up quand il y a à la fois un bonus de niveau et un power-up if (item === 'powerUp' && collectedItem && collectedItem.type === 'levelBonus' && collectedItem.powerUp) { // Traiter le power-up en fonction de son type switch(collectedItem.powerUp) { case '⛽': newFuel = Math.min(newFuel + 2, gameState.maxFuel); break; case '💣': newAmmo = Math.min(newAmmo + 1, gameState.maxAmmo); break; case '💰': newCoins += 50; break; case '⚡': gameState.lightning += 1; break; } // Mettre à jour l'état du collectedItem pour enlever le power-up mais garder le bonus setCollectedItem({ ...collectedItem, powerUp: null, requireDismissal: true // Ensure it requires explicit dismissal }); return; } switch(item) { case 'fuel': if (newCoins >= 50 && gameState.fuel < gameState.maxFuel) { newCoins -= 50; newFuel = Math.min(newFuel + 2, gameState.maxFuel); AudioManager.playFuelSound(); } break; case 'ammo': if (newCoins >= 50 && gameState.ammo < gameState.maxAmmo) { newCoins -= 50; // Always add 2 ammo (removed ammo boost dependency) const ammoAmount = 2 * quantity; newAmmo = Math.min(newAmmo + ammoAmount, gameState.maxAmmo); AudioManager.playAmmoSound(); } break; default: return; } setGameState(prevState => ({ ...prevState, coins: newCoins, fuel: newFuel, ammo: newAmmo })); }; // Helper function to ensure audio is enabled const enableAudio = useCallback(() => { try { // Set a flag to prevent recursive calls and track initialization status if (window.audioBeingEnabled) return false; window.audioBeingEnabled = true; // Check if audio has already been initialized if (!AudioManager.audio.isInitialized) { // Initialize the AudioManager first AudioManager.initAudio(); // Start playing background music AudioManager.playBackgroundMusic(); console.log('Game audio initialized and started successfully'); } else { // Just make sure music is playing if already initialized if (AudioManager.audio.bgMusic && AudioManager.audio.bgMusic.paused) { AudioManager.playBackgroundMusic(); console.log('Resumed background music'); } } // Set a flag to try again later if needed window.lastAudioEnableAttempt = Date.now(); window.audioBeingEnabled = false; return true; } catch (e) { console.warn('Error enabling audio:', e); window.audioBeingEnabled = false; return false; } }, []); // Debug function to log lightning state changes const debugLightning = useCallback((action, oldValue, newValue) => { console.log(`⚡ LIGHTNING ${action}: ${oldValue} → ${newValue}`); }, []); // Listen for restart game event from Track component useEffect(() => { // Enable audio only once when the component mounts if (!window.audioEnabledOnMount) { window.audioEnabledOnMount = true; enableAudio(); } // Create a safe event handler that won't trigger recursion const handleForceEnableAudio = (event) => { console.log('Received forceEnableAudio event:', event.detail); // Only enable audio if it's not already being enabled and hasn't been checked recently const lastAttempt = window.lastAudioEnableAttempt || 0; const timeSinceLastAttempt = Date.now() - lastAttempt; if (!window.audioBeingEnabled && timeSinceLastAttempt > 5000) { enableAudio(); } else { console.log('Skipping redundant audio enable request'); } }; // A more efficient interval that respects the enableAudio flags const audioCheckInterval = setInterval(() => { // Only check if we're not already in the process of enabling audio if (!window.audioBeingEnabled) { // Check audio state by looking at the actual audio element const isAudioPlaying = AudioManager.audio.bgMusic && !AudioManager.audio.bgMusic.paused; if (!isAudioPlaying) { console.log('Audio appears to be stopped, attempting to restart'); enableAudio(); } } }, 10000); // Less frequent checks to reduce overhead // Add event listener with proper cleanup document.addEventListener('forceEnableAudio', handleForceEnableAudio); const handleRestartGame = () => { restartGame(); }; const handleOpenRogueShopEvent = () => { handleOpenRogueShop(); }; const handleClearCollectedItem = () => { // Only clear if it's not a level bonus that requires explicit dismissal if (!collectedItem || (!collectedItem.permanent && collectedItem.type !== 'levelBonus')) { setCollectedItem(null); } }; const handleCollectLevelBonus = () => { if (collectedItem && collectedItem.type === 'levelBonus') { moveForward('levelBonus'); // Don't clear the collected item notification immediately // It will be cleared after the bonus is processed in moveForward } }; const handlePreserveNotification = (event) => { if (event.detail && event.detail.type === 'levelBonus') { setCollectedItem(prevItem => ({ ...prevItem, forceVisible: event.detail.forceVisible })); } }; document.addEventListener('restartGame', handleRestartGame); document.addEventListener('openRogueShop', handleOpenRogueShopEvent); document.addEventListener('clearCollectedItem', handleClearCollectedItem); document.addEventListener('collectLevelBonus', handleCollectLevelBonus); document.addEventListener('preserveNotification', handlePreserveNotification); // Check for milestone levels and show permanent bonus notification if (BossLevelManager.isBossLevel(gameState.turns)) { // Set boss state to generate special milestone level with no empty cells setBossState(BossLevelManager.activateBossLevel(gameState.turns)); console.log("Milestone level reached: level", gameState.turns); // Process permanent bonus for milestone levels const bonusProcessed = LevelBonus.processPermanentBonus( gameState.turns, completedBonusLevels, setCollectedItem, setCompletedBonusLevels ); if (bonusProcessed) { console.log("Bonus notification displayed for level", gameState.turns); } } // Keep level bonus notifications visible until explicitly dismissed if (collectedItem && collectedItem.type === 'levelBonus') { console.log("Keeping level bonus notification visible"); } else if (collectedItem && !collectedItem.permanent && collectedItem.type !== 'levelBonus') { setCollectedItem(null); } return () => { document.removeEventListener('restartGame', handleRestartGame); document.removeEventListener('openRogueShop', handleOpenRogueShopEvent); document.removeEventListener('clearCollectedItem', handleClearCollectedItem); document.removeEventListener('collectLevelBonus', handleCollectLevelBonus); document.removeEventListener('preserveNotification', handlePreserveNotification); document.removeEventListener('forceEnableAudio', handleForceEnableAudio); clearInterval(audioCheckInterval); }; }, [gameState.turns]); const restartGame = () => { // Get all upgrade definitions from the roguelike system const upgrades = { startFuel: rogueUpgrades.find(u => u.id === 'startFuel'), startAmmo: rogueUpgrades.find(u => u.id === 'startAmmo'), maxFuel: rogueUpgrades.find(u => u.id === 'maxFuel'), maxAmmo: rogueUpgrades.find(u => u.id === 'maxAmmo'), fuelEfficiency: rogueUpgrades.find(u => u.id === 'fuelEfficiency'), startCoins: rogueUpgrades.find(u => u.id === 'startCoins') }; // Make lightning more rare by exposing a global variable window.lightningRarity = 0.5; // Increase from 0.3 to 0.5 (50% of original spawn rate) // Calculate max capacity values based on upgrades const newMaxFuel = 5 + (upgrades.maxFuel ? upgrades.maxFuel.level : 0); const newMaxAmmo = 3 + (upgrades.maxAmmo ? upgrades.maxAmmo.level : 0); // Calculate starting resource values based on upgrades // For fuel: base 3 + level, but must not exceed max capacity and level cannot exceed max upgrade level let newStartFuel = 3; if (upgrades.startFuel) { // If startFuel level is higher than maxFuel level, cap it to maxFuel level const effectiveStartFuelLevel = upgrades.maxFuel ? Math.min(upgrades.startFuel.level, upgrades.maxFuel.level) : 0; newStartFuel = Math.min(3 + effectiveStartFuelLevel, newMaxFuel); } // For ammo: base 2 + level, but must not exceed max capacity and level cannot exceed max upgrade level let newStartAmmo = 2; if (upgrades.startAmmo) { // Get the actual level of the startAmmo upgrade const startAmmoLevel = upgrades.startAmmo.level; // Calculate the effective start ammo value directly // Base value (2) + upgrade level, capped at max capacity newStartAmmo = Math.min(2 + startAmmoLevel, newMaxAmmo); console.log("Start Ammo Calculation:", { startAmmoLevel, newMaxAmmo, calculatedStartAmmo: newStartAmmo }); } // For coins: base 100 + level*50 // Calculate permanent coin bonus based on high score const permanentCoinBonus = LevelBonus.calculatePermanentBonus(highScore); // For coins: base 50 + permanent bonus (no level bonus at restart) const newStartCoins = 50 + permanentCoinBonus; console.log("Starting with coins:", newStartCoins, "permanent bonus:", permanentCoinBonus); // Update the UI to show a notification about the permanent bonus if applicable if (permanentCoinBonus > 0) { // We don't need to set this as collectedItem since we're just restarting console.log(`Applied permanent bonus of ${permanentCoinBonus} coins to starting money`); } // Réinitialiser le compteur de rangées boss générées si on recommence complètement setBossRowsGenerated({}); // Reset boss state setBossState({ active: false, remainingRows: 0, level: 0 }); // Create new game state with all applicable upgrades const newGameState = { track: [ ['⬛', '⬛', '⬛'], // First row always empty on restart generateTrackRow(), generateTrackRow() ], position: 1, fuel: newStartFuel, maxFuel: newMaxFuel, ammo: newStartAmmo, maxAmmo: newMaxAmmo, score: 0, coins: newStartCoins, turns: 0, gameOver: false, lightning: gameState.lightning || 0, // Ensure lightning is properly initialized and preserved deaths: gameState.deaths || 0, // Preserve death count between games // Reset special effect counters blitzActive: 0, magnetActive: false, explosionActive: false }; // Reset game over state setGameOverState(false); setGameOverReason("Out of fuel!"); // Apply the new game state setGameState(newGameState); // Clear any collected item animation setCollectedItem(null); setCurrentCellItem(null); // Keep track of bonus levels across restarts (don't reset them) const savedCompletedLevels = localStorage.getItem('rogueRaceCompletedBonusLevels'); if (savedCompletedLevels) { setCompletedBonusLevels(JSON.parse(savedCompletedLevels)); } }; // Update high score when turns change useEffect(() => { if (onTurnsChange) { onTurnsChange(gameState.turns); } }, [gameState.turns, onTurnsChange]); // Auto-save game progress useEffect(() => { // Save progress whenever important game state changes const saveGameProgress = () => { // Create the progress object to save const gameProgress = { lightning: gameState.lightning, coins: gameState.coins, turns: gameState.turns, deaths: gameState.deaths || 0, highScore: highScore }; // Save to localStorage localStorage.setItem('rogueRaceProgress', JSON.stringify(gameProgress)); console.log('Game progress auto-saved'); console.log('⚡ LIGHTNING IN SAVED PROGRESS:', gameProgress.lightning); }; // Save immediately when this effect runs saveGameProgress(); // Set up interval for regular auto-saving (every 30 seconds) const autoSaveInterval = setInterval(saveGameProgress, 30000); // Clean up interval on unmount return () => clearInterval(autoSaveInterval); }, [gameState.lightning, gameState.coins, gameState.turns, gameState.deaths, highScore]); // Function to purchase a roguelike upgrade const handleRoguePurchase = (upgradeId, cost, newValue) => { // Deduct lightning from player // Debug the lightning value before purchase debugLightning('BEFORE PURCHASE', gameState.lightning, gameState.lightning); setGameState(prevState => { const newLightningValue = prevState.lightning - cost; debugLightning('PURCHASE', prevState.lightning, newLightningValue); const newState = { ...prevState, lightning: newLightningValue }; // Update localStorage with new lightning value immediately const savedProgress = localStorage.getItem('rogueRaceProgress'); const progressData = savedProgress ? JSON.parse(savedProgress) : {}; progressData.lightning = newLightningValue; localStorage.setItem('rogueRaceProgress', JSON.stringify(progressData)); // Debug after saving to localStorage console.log('⚡ LIGHTNING SAVED TO STORAGE:', progressData.lightning); // Apply direct changes based on upgrade type switch (upgradeId) { case 'maxFuel': newState.maxFuel = newValue; // If max capacity increased, add the difference to current fuel if (newValue > prevState.maxFuel) { const fuelIncrease = newValue - prevState.maxFuel; newState.fuel = Math.min(prevState.fuel + fuelIncrease, newValue); } // Also check if we need to adjust startFuel upgrade effects const startFuelUpgrade = rogueUpgrades.find(u => u.id === 'startFuel'); if (startFuelUpgrade && startFuelUpgrade.level > 0) { // If player has startFuel upgrades, they will now be effective up to the new maxFuel level // This doesn't change game state immediately, but will apply on restart } break; case 'maxAmmo': newState.maxAmmo = newValue; // If max capacity increased, add the difference to current ammo if (newValue > prevState.maxAmmo) { const ammoIncrease = newValue - prevState.maxAmmo; newState.ammo = Math.min(prevState.ammo + ammoIncrease, newValue); } // Also check if we need to adjust startAmmo upgrade effects const startAmmoUpgrade = rogueUpgrades.find(u => u.id === 'startAmmo'); if (startAmmoUpgrade && startAmmoUpgrade.level > 0) { // If player has startAmmo upgrades, they will now be effective up to the new maxAmmo level // This doesn't change game state immediately, but will apply on restart } break; case 'startFuel': // Ensure this upgrade doesn't exceed maxFuel's current level const maxFuelUpgrade = rogueUpgrades.find(u => u.id === 'maxFuel'); const maxFuelLevel = maxFuelUpgrade ? maxFuelUpgrade.level : 0; if (maxFuelLevel > 0) { // This will be applied on next restart, no immediate effect needed } break; case 'startAmmo': // Ensure this upgrade doesn't exceed maxAmmo's current level const maxAmmoUpgrade = rogueUpgrades.find(u => u.id === 'maxAmmo'); const maxAmmoLevel = maxAmmoUpgrade ? maxAmmoUpgrade.level : 0; if (maxAmmoLevel > 0) { // This will be applied on next restart, no immediate effect needed } break; case 'fuelEfficiency': // Effect is applied dynamically in the moveForward function break; } return newState; }); // Find the specific upgrade in the local state const updatedUpgrades = [...rogueUpgrades]; const upgradeIndex = updatedUpgrades.findIndex(u => u.id === upgradeId); // Calculate the level value correctly based on the upgrade type let levelValue; if (upgradeId === 'maxFuel' || upgradeId === 'maxAmmo') { // These upgrades store the actual value directly levelValue = newValue - (upgradeId === 'maxFuel' ? 5 : 3); // Base values (5 for fuel, 3 for ammo) } else if (upgradeId === 'startCoins') { levelValue = newValue / 50; } else if (upgradeId === 'fuelEfficiency') { levelValue = newValue / 10; // 10% increments } else { levelValue = newValue - (upgradeId === 'startFuel' ? 3 : 2); // Base values } if (upgradeIndex >= 0) { // Update only the specific existing upgrade updatedUpgrades[upgradeIndex] = { ...updatedUpgrades[upgradeIndex], level: levelValue }; } else { // Add the new upgrade updatedUpgrades.push({ id: upgradeId, level: levelValue }); } // Update the rogueUpgrades state and localStorage setRogueUpgrades(updatedUpgrades); localStorage.setItem('emojiRacingUpgrades', JSON.stringify(updatedUpgrades)); // Show visual feedback for the purchase with a temporary notification const purchaseEventDetail = { id: upgradeId, level: levelValue + 1, // Show the new level (1-indexed for display) value: newValue }; // Create a custom event with the purchase details const purchaseEvent = new CustomEvent('upgradePurchased', { detail: purchaseEventDetail }); document.dispatchEvent(purchaseEvent); }; // Function to close the roguelike shop const handleRogueShopClose = () => { setShowRogueShop(false); }; // Function to open the roguelike shop const handleOpenRogueShop = () => { setShowRogueShop(true); }; // Apply score multiplier effect useEffect(() => { const scoreMultiplier = rogueUpgrades.find(u => u.id === 'scoreMultiplier'); if (scoreMultiplier && scoreMultiplier.level > 0) { // We directly modify moveForward to apply the multiplier // This logic is already included in moveForward } }, [rogueUpgrades]); // Debugging hook to log the current state of rogueUpgrades useEffect(() => { console.log("Current rogueUpgrades:", rogueUpgrades); localStorage.setItem('emojiRacingUpgrades', JSON.stringify(rogueUpgrades)); }, [rogueUpgrades]); // Save game progress whenever important values change useEffect(() => { // Save current progress to localStorage const gameProgress = { lightning: gameState.lightning, coins: gameState.coins, turns: gameState.turns, deaths: gameState.deaths || 0, highScore: highScore }; localStorage.setItem('rogueRaceProgress', JSON.stringify(gameProgress)); }, [gameState.lightning, gameState.coins, gameState.turns, gameState.deaths, highScore]); const handleCloseBonusNotification = () => { setShowBonusNotification(false); // Check if we need to trigger game over after collecting bonus if (collectedItem && collectedItem.delayGameOver) { // Now that the bonus is collected/dismissed, proceed with game over setGameOverReason("Out of fuel! Your car stopped in the middle of the track."); setGameOverState(true); AudioManager.playGameOverSound(); // Increment death counter for delayed game over setGameState(prevState => ({ ...prevState, deaths: (prevState.deaths || 0) + 1 })); } setCollectedItem(null); }; // Handle reset game data button click const handleResetGameData = () => { setShowResetConfirm(true); }; // Handle confirm reset action const confirmResetGameData = () => { const resetSuccessful = GameLoader.resetAllGameData(); if (resetSuccessful) { // Reset local state setRogueUpgrades([]); setCompletedBonusLevels([]); // Reset game state to default values setGameState({ ...GameLoader.defaultGameState, track: [ ['⬛', '⬛', '⬛'], generateTrackRow(), generateTrackRow() ], devMode: true // Activer le mode développeur }); // Reset UI states setGameOverState(false); setGameOverReason("Out of fuel!"); setCollectedItem(null); setCurrentCellItem(null); // Play sound to confirm reset AudioManager.playBonusSound(); // Show a temporary notification about the reset alert("Game data has been reset successfully. Starting a new game with default values."); } else { // Show error message alert("There was a problem resetting game data. Please try again."); } // Close the confirmation dialog setShowResetConfirm(false); }; // Cancel reset action const cancelResetGameData = () => { setShowResetConfirm(false); }; return (

{/* Afficher l'écran de victoire spécial si le joueur a gagné */} {gameState.isVictory && ( )} {/* Reset game data confirmation dialog */} {showResetConfirm && (

⚠️ Reset Game Data?

This will permanently delete all your progress, upgrades, lightning bolts, coins, and bonus levels.

This action cannot be undone!

)} {/* Additional styling for the danger button */} {/* Game over controls - only displayed in case of defeat */} {gameState.gameOver && !gameState.isVictory && (

)} {/* Normal game controls - only shown when game is not over */} {!gameState.gameOver && !gameState.isVictory && ( )} {/* Roguelike Shop */} {showRogueShop && ( )} {/* Le bouton développeur a été temporairement supprimé */}

); }; export default Game;