<?phpnamespace App\Stage;use Evenement\EventEmitter;use App\Entities\GameObjectManager;use App\Entities\Objects\Flower;use App\Entities\Player;use App\Level\Level;use App\Level\LevelManager;use App\Gfx\Gfx;use App\Audio\SoundManager;class Stage extends EventEmitter{ private int $debugMode = 0; private ?Level $currentLevel = null ; private array $collisionTiles = []; private ?GameObjectManager $objectManager = null; private ?HUD $hud = null; public function __construct(private Camera $camera, private Gfx $sdl,private Player $player) { $this->camera->setScene($this); $this->camera->stickTo($this->player); $this->hud = new HUD($sdl); } public function setObjectManager(GameObjectManager $objectManager): void { $this->objectManager = $objectManager; } public function getPlayer() { return $this->player; } public function getCurrentLevel() { return $this->currentLevel; } /** * Écoute l'événement collisionTile du CollisionSystem */ public function listenToCollisionEvents($collisionSystem) { $collisionSystem->on('collisionTile', function($data) { $this->handleCollisionTile($data); }); } /** * Gère l'événement collisionTile */ private function handleCollisionTile($data) { $tileKey = $data['tileX'] . ',' . $data['tileY']; // Stocke les informations de collision pour debug $this->collisionTiles[$tileKey] = [ 'tileX' => $data['tileX'], 'tileY' => $data['tileY'], 'tileValue' => $data['tileValue'], 'timestamp' => microtime(true) ]; // Debug: affiche les informations de collision // echo "Scene: Collision tile détectée à ({$data['tileX']}, {$data['tileY']}) - Tile value: {$data['tileValue']}\n"; // Émet un événement pour informer d'autres composants // $this->emit('collisionTileRendered', $data); } /** * Récupère les tiles de collision pour debug */ public function getCollisionTiles(): array { return $this->collisionTiles; } /** * Nettoie les anciennes tiles de collision (plus de 1 seconde) */ public function cleanupOldCollisionTiles() { $currentTime = microtime(true); $this->collisionTiles = array_filter($this->collisionTiles, function($tile) use ($currentTime) { return ($currentTime - $tile['timestamp']) < 1.0; // Garde seulement 1 seconde }); } public function drawScene($font, Level $level) { if ($this->currentLevel === null) { // init level $this->currentLevel = &$level ; // init player // the act starts again from the checkpoint after a death [$startX, $startY] = $this->objectManager?->getCheckpoint() ?? [$level->getCurrentPositionHeroXinTile() * 32, $level->getCurrentPositionHeroYinTile() * 32]; $this->getPlayer()->setXY($startX, $startY); // init camera $this->camera->startLevel($level); $this->camera->noSmooth = true; $this->camera->stickTo($this->player); $this->camera->update(); } $this->drawWorld($font, $level, $this->player); // Labyrinth: below the water line everything uses the underwater palette $waterLine = $this->objectManager?->getWaterLine(); if ($waterLine !== null && $this->debugMode != 1) { $screenLine = (int)round($waterLine - $this->camera->getY()); if ($screenLine < $this->sdl->getWindow()->getHeight()) { $this->drawUnderwater($font, $level, max(0, $screenLine)); } } if ($this->debugMode == 0) { $this->maskOutsideLevel(); } // Afficher le HUD en dernier (par-dessus tout) if ($this->hud && $this->objectManager) { $this->hud->draw($this->objectManager, $level); $this->drawAirCountdown(); } } private function drawWorld($font, Level $level, Player $player): void { // Ne pas afficher les tiles normales en mode debug 1 if ($this->debugMode != 1) { $this->drawTiles($level); } // Afficher le debug en premier (en arrière-plan) if ($this->debugMode) { $this->drawDebug($font); } // Afficher les game objects (enemies, monitors, etc.) $this->drawGameObjects(); // ghost of the best run (title menu > options), behind Sonic $this->drawGhost(); // multiplayer: the other Sonics and the flag (Versus::drawWorld) if ($this->worldOverlay !== null) { ($this->worldOverlay)($this->camera->getX(), $this->camera->getY()); } // Afficher le joueur par-dessus $this->drawPlayer($player); // Blocs prioritaires (arbres, piliers...) devant les sprites, comme le VDP de la SMS if ($this->debugMode != 1) { $this->drawForeground($level); } } /** Black outside of the area the original screen could show (Camera::getVisibleArea). */ private function maskOutsideLevel(): void { [$left, $right, $top, $bottom] = $this->camera->getVisibleArea(); $w = $this->sdl->getWindow()->getWidth(); $h = $this->sdl->getWindow()->getHeight(); $x0 = (int)round($left - $this->camera->getX()); $x1 = (int)round($right - $this->camera->getX()); $y0 = (int)round($top - $this->camera->getY()); $y1 = (int)round($bottom - $this->camera->getY()); $renderer = $this->sdl->getRenderer()->getRenderer(); \SDL_SetRenderDrawColor($renderer, 0, 0, 0, 255); foreach ([[0, 0, $x0, $h], [$x1, 0, $w - $x1, $h], [0, 0, $w, $y0], [0, $y1, $w, $h - $y1]] as [$x, $y, $rw, $rh]) { if ($rw <= 0 || $rh <= 0) continue; $rect = new \SDL_Rect; $rect->x = $x; $rect->y = $y; $rect->w = $rw; $rect->h = $rh; \SDL_RenderFillRect($renderer, $rect); } } /** @var resource|null render target of the underwater pass */ private $waterTexture = null; private bool $underwaterPass = false; private int $lastLightningPhase = 0; private array $waterSize = [0, 0]; private const WATER_WAVE = [152, 56, 16, 7]; // _8e16: X of the surface sprites, 4 of them per frame private const WATER_WAVE_X = [0x00, 0x40, 0x80, 0xC0, 0x10, 0x50, 0x90, 0xD0, 0x20, 0x60, 0xA0, 0xE0, 0x30, 0x70, 0xB0, 0xF0]; /** * The original reloads the palette with S1_UnderwaterPalette on a line interrupt at the water line: * the world is drawn a second time with the "-water" textures (tools/waterpalette.py) into another * target and only the part below the line is copied over. The surface sprites follow (object $40). */ private function drawUnderwater($font, Level $level, int $screenLine): void { $renderer = $this->sdl->getRenderer()->getRenderer(); $winW = $this->sdl->getWindow()->getWidth(); $winH = $this->sdl->getWindow()->getHeight(); if ($this->waterTexture !== null && $this->waterSize !== [$winW, $winH]) { \SDL_DestroyTexture($this->waterTexture); // the view size changed (zoom) $this->waterTexture = null; } $this->waterTexture ??= \SDL_CreateTexture($renderer, \SDL_PIXELFORMAT_RGBA8888, \SDL_TEXTUREACCESS_TARGET, $winW, $winH); $this->waterSize = [$winW, $winH]; \SDL_SetRenderTarget($renderer, $this->waterTexture); $this->sdl->getRenderer()->clear(); $this->sdl->setTextureVariant('-water'); $this->underwaterPass = true; $this->drawWorld($font, $level, $this->player); $this->underwaterPass = false; $this->sdl->setTextureVariant(''); \SDL_SetRenderTarget($renderer, $this->sdl->getRenderer()->getRenderTexture()); $rect = new \SDL_Rect; $rect->x = 0; $rect->y = $screenLine; $rect->w = $winW; $rect->h = $winH - $screenLine; \SDL_RenderCopy($renderer, $this->waterTexture, $rect, $rect); // surface sprites, scrolling 1px per frame over a 16px period $frames = $this->objectManager->getWaterFrames(); $y = (int)round($this->objectManager->getWaterLine() - $this->camera->getY()) - 3; if ($y < -8) return; $texture = $this->sdl->getTextures('objects')[0]['texture']; $src = new \SDL_Rect; [$src->x, $src->y, $src->w, $src->h] = self::WATER_WAVE; for ($base = 0; $base < $winW; $base += 256) { foreach (self::WATER_WAVE_X as $x) { $dst = new \SDL_Rect; $dst->x = $base + $x + ($frames & 0x0F); $dst->y = $y; $dst->w = $src->w; $dst->h = $src->h; \SDL_RenderCopy($renderer, $texture, $src, $dst); } } } /** Drowning countdown over Sonic (_5009: Sonic X + 8, Y - 20, shown every other frame). */ private function drawAirCountdown(): void { $digit = $this->objectManager->getAirCountdown(); if ($digit === null || ((int)(fmod(microtime(true), 86400.0) * 30) & 1)) return; $src = new \SDL_Rect; [$src->x, $src->y, $src->w, $src->h] = [544 + 8 * $digit, 107, 8, 13]; $dst = new \SDL_Rect; $dst->x = (int)round($this->player->getX() - $this->camera->getX() + 8); $dst->y = (int)round($this->player->getY() - $this->camera->getY() - 20); $dst->w = 8; $dst->h = 13; \SDL_RenderCopy($this->sdl->getRenderer()->getRenderer(), $this->sdl->getTextures('objects')[0]['texture'], $src, $dst); } /** Drawn between the objects and Sonic: fn(float $cameraX, float $cameraY) (multiplayer). */ public ?\Closure $worldOverlay = null; /** Sonic blinks (multiplayer: hit or put back by the match). */ public bool $playerBlink = false; public function drawPlayer(Player $player) { if ($this->objectManager && $this->objectManager->isPlayerHidden()) return; if (($this->objectManager && $this->objectManager->isPlayerHurt()) || $this->playerBlink) { $blink = (int)(fmod(microtime(true), 86400.0) * 10) % 2; if ($blink === 0) return; } $destRect = new \SDL_Rect; // the frames of the sheet are 32px wide with Sonic's 24px sprite 4px in: the sprite is drawn over the // 24px box of the original (the collision rect), so that he touches the walls without entering them $destRect->x = $player->getX() - 4 - $this->camera->getX(); $destRect->y = $player->getY() - $this->camera->getY() ; // + 16; $destRect->w = 32; $destRect->h = 32; // thrown up by a spring / a balance (animation $13): frame $26 of the ROM art; water slide (animation $11) $spring = $player->getSpringFrame(); $slide = $player->getSlideFrame(); if ($slide !== null && !($this->objectManager && $this->objectManager->hasShield() && (int)floor(fmod(microtime(true), 86400.0) * 60) % 2 === 0)) { $src = new \SDL_Rect; [$src->x, $src->y, $src->w, $src->h] = \App\Entities\Objects\RomSprites::HERO_SLIDE[$slide]; $dst = new \SDL_Rect; [$dst->x, $dst->y, $dst->w, $dst->h] = [$destRect->x + 4, $destRect->y, 24, 32]; \SDL_RenderCopyEx($this->sdl->getRenderer()->getRenderer(), $this->sdl->getTextures($player->getRomSheet())[0]['texture'], $src, $dst, 0, null, $player->getFacing() === 'left' ? \SDL_FLIP_HORIZONTAL : \SDL_FLIP_NONE); if ($this->objectManager && $this->objectManager->hasInvincibility()) { self::drawInvincibilityStars($this->sdl, $destRect->x + 16, $destRect->y + 16); } return; } if ($spring !== null && !($this->objectManager && $this->objectManager->hasShield() && (int)floor(fmod(microtime(true), 86400.0) * 60) % 2 === 0)) { $src = new \SDL_Rect; [$src->x, $src->y, $src->w, $src->h] = \App\Entities\Objects\RomSprites::HERO_SPRING; $dst = new \SDL_Rect; [$dst->x, $dst->y, $dst->w, $dst->h] = [$destRect->x + 4, $destRect->y, 24, 32]; \SDL_RenderCopyEx($this->sdl->getRenderer()->getRenderer(), $this->sdl->getTextures($player->getRomSheet())[0]['texture'], $src, $dst, 0, null, $player->getFacing() === 'left' ? \SDL_FLIP_HORIZONTAL : \SDL_FLIP_NONE); if ($this->objectManager && $this->objectManager->hasInvincibility()) { self::drawInvincibilityStars($this->sdl, $destRect->x + 16, $destRect->y + 16); } return; } // waiting (animation $0D): frames of the ROM art $wait = $player->getWaitFrame(); if ($wait !== null && !($this->objectManager && $this->objectManager->hasShield() && (int)floor(fmod(microtime(true), 86400.0) * 60) % 2 === 0)) { $src = new \SDL_Rect; [$src->x, $src->y, $src->w, $src->h] = \App\Entities\Objects\RomSprites::HERO_WAIT[$wait]; $dst = new \SDL_Rect; [$dst->x, $dst->y, $dst->w, $dst->h] = [$destRect->x + 4, $destRect->y, 24, 32]; \SDL_RenderCopyEx($this->sdl->getRenderer()->getRenderer(), $this->sdl->getTextures($player->getRomSheet())[0]['texture'], $src, $dst, 0, null, $player->getFacing() === 'left' ? \SDL_FLIP_HORIZONTAL : \SDL_FLIP_NONE); return; } // shield (_5206): every other frame Sonic's sprite is replaced by the ring of frame $18 if ($this->objectManager && $this->objectManager->hasShield() && (int)floor(fmod(microtime(true), 86400.0) * 60) % 2 === 0) { $src = new \SDL_Rect; [$src->x, $src->y, $src->w, $src->h] = \App\Entities\Objects\RomSprites::SHIELD; $dst = new \SDL_Rect; [$dst->x, $dst->y, $dst->w, $dst->h] = [$destRect->x + 4, $destRect->y, 24, 32]; \SDL_RenderCopy($this->sdl->getRenderer()->getRenderer(), $this->sdl->getTextures(\App\Entities\Objects\RomSprites::SHEET)[0]['texture'], $src, $dst); } else { $player->draw($destRect); } if ($this->objectManager && $this->objectManager->hasInvincibility()) { self::drawInvincibilityStars($this->sdl, $destRect->x + 16, $destRect->y + 16); } } /** Four stars turning around ($centerX, $centerY) (view pixels); also the other Sonics of a match (Versus). */ public static function drawInvincibilityStars(Gfx $sdl, int $centerX, int $centerY): void { $t = microtime(true); $src = new \SDL_Rect; $src->x = ((int)($t * 12) % 2) ? 560 : 608; $src->y = 72; $src->w = 16; $src->h = 16; for ($i = 0; $i < 4; $i++) { $angle = $t * 5 + $i * M_PI / 2; $dst = new \SDL_Rect; $dst->x = (int)round($centerX + cos($angle) * 18 - 8); $dst->y = (int)round($centerY + sin($angle) * 18 - 8); $dst->w = 16; $dst->h = 16; \SDL_RenderCopy($sdl->getRenderer()->getRenderer(), $sdl->getTextures('objects')[0]['texture'], $src, $dst); } } public function getCamera() { return $this->camera; } /** Blocks kept around the view in each cache (on every side). */ private const TILE_CACHE_MARGIN = 3; private const TILE_CACHES = 8; /** * Render targets holding the blocks around the view, one per tileset texture (palette cycling step, * underwater...): [texture, w, h, level, version, col, row, cols, rows, rings, foreground, animated]. Drawing ~400 * blocks costs ~5 ms of PHP per frame in the browser: they are drawn again only when the view leaves the * cached area or a block changes, the frame copies one texture. */ private array $tileCaches = []; public function drawTiles(Level $level) { $tileSize = 32; $cameraX = $this->camera->getX(); $cameraY = $this->camera->getY(); $winW = $this->sdl->getWindow()->getWidth(); $winH = $this->sdl->getWindow()->getHeight(); $name = $this->currentTilesetTextureName($level); $key = $name . ($this->underwaterPass ? '-water' : ''); // blocks of the view (one more for the part of a block on each edge) $col0 = (int)floor($cameraX / $tileSize); $row0 = (int)floor($cameraY / $tileSize); $viewCols = intdiv($winW, $tileSize) + 2; $viewRows = intdiv($winH, $tileSize) + 2; $cols = $viewCols + 2 * self::TILE_CACHE_MARGIN; $rows = $viewRows + 2 * self::TILE_CACHE_MARGIN; $cache = $this->tileCaches[$key] ?? null; if ($cache === null || $cache[1] !== $cols * $tileSize || $cache[2] !== $rows * $tileSize || $cache[3] !== $level || $cache[4] !== $level->getVersion() || $col0 < $cache[5] || $col0 + $viewCols > $cache[5] + $cols || $row0 < $cache[6] || $row0 + $viewRows > $cache[6] + $rows) { $cache = $this->renderTileCache($level, $name, $key, $col0 - self::TILE_CACHE_MARGIN, $row0 - self::TILE_CACHE_MARGIN, $cols, $rows, $cache); } else { // most recently used last (the oldest one is dropped first) unset($this->tileCaches[$key]); $this->tileCaches[$key] = $cache; } $renderer = $this->sdl->getRenderer()->getRenderer(); $originX = $cache[5] * $tileSize - $cameraX; $originY = $cache[6] * $tileSize - $cameraY; $dst = new \SDL_Rect; $dst->x = (int)floor($originX); $dst->y = (int)floor($originY); $dst->w = $cache[1]; $dst->h = $cache[2]; \SDL_RenderCopy($renderer, $cache[0], null, $dst); // rings (their blocks may have changed since) and priority blocks of the view $ringOverlays = []; foreach ($cache[9] as [$x, $y]) { if ($x < $col0 || $x >= $col0 + $viewCols || $y < $row0 || $y >= $row0 + $viewRows) continue; $block = $level->getTile($x, $y); if ($block !== null && GameObjectManager::isRingBlock($block)) { $ringOverlays[] = [$x * $tileSize - $cameraX, $y * $tileSize - $cameraY, $block]; } } $this->foregroundBlocks = []; foreach ($cache[10] as [$x, $y, $block]) { if ($x < $col0 || $x >= $col0 + $viewCols || $y < $row0 || $y >= $row0 + $viewRows) continue; $this->foregroundBlocks[] = [$x * $tileSize - $cameraX, $y * $tileSize - $cameraY, $block]; } $this->drawRingOverlays($ringOverlays); // animated blocks (levels of the site): left out of the cache, the block of the moment drawn each frame if ($cache[11]) { $tileSet = $level->getTileSet(); $textures = $this->sdl->getTextures($name); $frame = self::frame(); foreach ($cache[11] as [$x, $y, $block]) { if ($x < $col0 || $x >= $col0 + $viewCols || $y < $row0 || $y >= $row0 + $viewRows) continue; $shown = $level->animatedBlock($block, $frame); $src = $tileSet->getTile($shown); $texture = $textures[$tileSet->getTextureIndex($shown)]['texture'] ?? null; if (!$src || !$texture) continue; $dst = new \SDL_Rect; $dst->x = (int)floor($x * $tileSize - $cameraX); $dst->y = (int)floor($y * $tileSize - $cameraY); $dst->w = $tileSize; $dst->h = $tileSize; \SDL_RenderCopy($renderer, $texture, $src, $dst); } } } /** The frame of the moment (60Hz), the same for every player. */ private static function frame(): int { return (int)floor(fmod(microtime(true), 86400.0) * 60); } /** Draws the blocks from ($col, $row) into the cache $key (made, or remade at a new size). */ private function renderTileCache(Level $level, string $name, string $key, int $col, int $row, int $cols, int $rows, ?array $old): array { $tileSize = 32; $renderer = $this->sdl->getRenderer()->getRenderer(); $w = $cols * $tileSize; $h = $rows * $tileSize; $texture = $old[0] ?? null; if ($texture !== null && ($old[1] !== $w || $old[2] !== $h)) { \SDL_DestroyTexture($texture); // the view size changed (zoom) $texture = null; } unset($this->tileCaches[$key]); if ($texture === null && count($this->tileCaches) >= self::TILE_CACHES) { $oldest = array_key_first($this->tileCaches); \SDL_DestroyTexture($this->tileCaches[$oldest][0]); unset($this->tileCaches[$oldest]); } $texture ??= \SDL_CreateTexture($renderer, \SDL_PIXELFORMAT_RGBA8888, \SDL_TEXTUREACCESS_TARGET, $w, $h); \SDL_SetRenderTarget($renderer, $texture); \SDL_SetRenderDrawColor($renderer, 0, 0, 0, 0); \SDL_RenderClear($renderer); \SDL_SetRenderDrawColor($renderer, 0, 0, 0, 255); $tileSet = $level->getTileSet(); $textures = $this->sdl->getTextures($name); $rings = []; $foreground = []; $animated = []; $dst = new \SDL_Rect; $dst->w = $tileSize; $dst->h = $tileSize; for ($y = max(0, $row); $y < min($level->getMapHeight(), $row + $rows); $y++) { for ($x = max(0, $col); $x < min($level->getMapWidth(), $col + $cols); $x++) { $tileValue = $level->getTile($x, $y); if ($tileValue === null) continue; $drawn = Level::drawnBlock($tileValue); // ring blocks (and empty ones, rings can come back): the rings are drawn over them each frame if ($drawn === GameObjectManager::RING_BLOCK_EMPTY) { $rings[] = [$x, $y]; } elseif ($level->isForegroundBlock($tileValue)) { $foreground[] = [$x, $y, $tileValue]; } if ($level->isAnimatedBlock($drawn)) { $animated[] = [$x, $y, $drawn]; continue; } $tileRect = $tileSet->getTile($drawn); if (!$tileRect) continue; $dst->x = ($x - $col) * $tileSize; $dst->y = ($y - $row) * $tileSize; \SDL_RenderCopy($renderer, $textures[$tileSet->getTextureIndex($drawn)]['texture'], $tileRect, $dst); } } // back to the target being drawn (the frame, or the underwater pass) \SDL_SetRenderTarget($renderer, $this->underwaterPass ? $this->waterTexture : $this->sdl->getRenderer()->getRenderTexture()); return $this->tileCaches[$key] = [$texture, $w, $h, $level, $level->getVersion(), $col, $row, $cols, $rows, $rings, $foreground, $animated]; } // Ring rotation frames (tileset-objects.png), 16x16 cells centred on each frame; the original shows each for 10 frames at 60Hz. private const RING_FRAMES = [[536, 72], [520, 72], [504, 72], [488, 72], [472, 72], [456, 72]]; private function drawRingOverlays(array $overlays): void { if (empty($overlays)) return; $texture = $this->sdl->getTextures('objects')[0]['texture']; $frame = self::RING_FRAMES[(int)floor(fmod(microtime(true), 86400.0) * 6) % 6]; $src = new \SDL_Rect; $src->x = $frame[0]; $src->y = $frame[1]; $src->w = 16; $src->h = 16; $renderer = $this->sdl->getRenderer()->getRenderer(); foreach ($overlays as [$sx, $sy, $block]) { foreach ([1 => 0, 2 => 16] as $bit => $offsetX) { if (!($block & $bit)) continue; $dst = new \SDL_Rect; $dst->x = $sx + $offsetX; $dst->y = $sy + 8; $dst->w = 16; $dst->h = 16; \SDL_RenderCopy($renderer, $texture, $src, $dst); } } } /** Blocks collected by drawTiles() whose solidity has the priority bit: redrawn over the sprites. */ private array $foregroundBlocks = []; private function drawForeground(Level $level): void { if (empty($this->foregroundBlocks)) return; $name = $this->currentTilesetTextureName($level) . '-fg'; if (!$this->sdl->hasTexture($name)) { $name = 'tileset' . $level->getLevel() . '-fg'; if (!$this->sdl->hasTexture($name)) return; } $textures = $this->sdl->getTextures($name); $tileSet = $level->getTileSet(); $renderer = $this->sdl->getRenderer()->getRenderer(); $frame = self::frame(); foreach ($this->foregroundBlocks as [$sx, $sy, $block]) { $block = $level->animatedBlock($block, $frame); $src = $tileSet->getTile($block); $texture = $textures[$tileSet->getTextureIndex($block)]['texture'] ?? null; if (!$src || !$texture) continue; $dst = new \SDL_Rect; $dst->x = $sx; $dst->y = $sy; $dst->w = 32; $dst->h = 32; \SDL_RenderCopy($renderer, $texture, $src, $dst); } } /** Colour cycling like the original: step every CS frames (60Hz) through CC palettes. */ private function currentTilesetTextureName(Level $level): string { $base = 'tileset' . $level->getLevel(); // no palette cycling under water, the underwater palette is fixed if ($this->underwaterPass && $this->sdl->hasTexture($base . '-water')) { return $base; } if ($this->objectManager && $this->objectManager->isPaletteFlashWhite() && $this->sdl->hasTexture($base . '-flash')) { return $base . '-flash'; } $count = $level->getMeta('CC'); $speed = max(1, $level->getMeta('CS')); // TL bit 1, Sky Base 1 lightning (_1f49): 171-frame loop, flash palettes from frame 100 and 130 // (thunder at 130), every palette cycling 4 steps at speed 2 if (($level->getMeta('TL') & 0x02) && $this->sdl->hasTexture($base . '-light1-cycle0')) { $frame = (int)floor(fmod(microtime(true), 86400.0) * 60); $phase = $frame % 171; $light = $phase >= 130 ? 2 : ($phase >= 100 ? 1 : 0); if ($light === 2 && $this->lastLightningPhase < 130) { $this->emit('sfx', [SoundManager::SFX_ELECTRIC]); } $this->lastLightningPhase = $phase; $step = intdiv($frame, 2) % 4; return $light ? $base . '-light' . $light . '-cycle' . $step : $base . '-cycle' . $step; } if ($count <= 1 || !$this->sdl->hasTexture($base . '-cycle0')) { return $base; } $step = (int)floor(fmod(microtime(true), 86400.0) * 60 / $speed) % $count; return $base . '-cycle' . $step; } /** Ghost frame to draw this frame: [x, y, sx, sy, sw, sh, flip] (GhostRecorder), or null. */ private ?array $ghostFrame = null; public function setGhostFrame(?array $frame): void { $this->ghostFrame = $frame; } private function drawGhost(): void { if ($this->ghostFrame === null) return; [$x, $y, $sx, $sy, $sw, $sh, $flip] = $this->ghostFrame; $src = new \SDL_Rect; [$src->x, $src->y, $src->w, $src->h] = [$sx, $sy, $sw, $sh]; $dst = new \SDL_Rect; // same place as Sonic's sprite (drawPlayer): 4px left of his 24px box, 32x32 [$dst->x, $dst->y, $dst->w, $dst->h] = [(int)round($x - 4 - $this->camera->getX()), (int)round($y - $this->camera->getY()), 32, 32]; \SDL_RenderCopyEx($this->sdl->getRenderer()->getRenderer(), $this->sdl->getTextures('hero-ghost')[0]['texture'], $src, $dst, 0, null, $flip ? \SDL_FLIP_HORIZONTAL : \SDL_FLIP_NONE); } public function setDebugMode(int $debugMode) { $this->debugMode = $debugMode; } private function drawDebug($fontTab) { $this->drawDebugTiles($fontTab, $this->debugMode); } private function drawDebugTiles($fontTab, $debugType = 1) { if (!$this->currentLevel) { return; } $level = $this->currentLevel; $cameraX = $this->camera->getX(); $cameraY = $this->camera->getY(); $tileSize = 32; $winW = $this->sdl->getWindow()->getWidth(); $winH = $this->sdl->getWindow()->getHeight(); $startCol = (int)floor($cameraX / $tileSize); $endCol = (int)ceil(($winW/$tileSize) + ($cameraX/$tileSize)); $offsetX = -(int)($cameraX % $tileSize); $startRow = (int)floor($cameraY / $tileSize); $endRow = (int)ceil(($winH/$tileSize) + ($cameraY/$tileSize)); $offsetY = -(int)($cameraY % $tileSize); $startRow = max(0, $startRow); $endRow = min($level->getMapHeight(), $endRow); $startCol = max(0, $startCol); $endCol = min($level->getMapWidth(), $endCol); $previewMore = 2; // Définir la couleur jaune pour les borders \SDL_SetRenderDrawColor($this->sdl->getRenderer()->getRenderer(), 255, 255, 0, 255); // Afficher les valeurs des tiles for ($y = $startRow; $y < $endRow + $previewMore; $y++) { for ($x = $startCol; $x < $endCol + $previewMore; $x++) { $tileValue = $level->getTile($x, $y); if ($tileValue === null) { continue; } // Calculer l'index de la tile $tileIndex = $x + $y * $level->getMapWidth(); // Choisir la valeur à afficher selon le type de debug if ($debugType == 1) { // Mode 1 : Valeurs des tiles $char = strtoupper(dechex($tileValue)); if (strlen($char) == 1) { $char = '0' . $char; } } elseif ($debugType == 4) { // Mode 4 : Coordonnées logiques des tiles (X/Y) // Afficher X et Y séparément, en limitant à un chiffre chacun pour la lisibilité $charX = substr((string)$x, -1); // Dernier chiffre de X $charY = substr((string)$y, -1); // Dernier chiffre de Y $char = $charX . $charY; } else { // Mode 2 : Valeurs de collision $solidity = $level->getSolidity(); if (isset($solidity[$tileValue])) { $colisionIndexTile = ord($solidity[$tileValue]); $char = strtoupper(dechex($colisionIndexTile)); if (strlen($char) == 1) { $char = '0' . $char; } } else { $char = '00'; // Pas de collision } } $dstRect = new \SDL_Rect; $dstRect->x = ($x - $startCol) * $tileSize + $offsetX; $dstRect->y = ($y - $startRow) * $tileSize + $offsetY; $dstRect->w = $tileSize; $dstRect->h = $tileSize; // Dessiner le border jaune autour de la tile (seulement le contour) $x1 = $dstRect->x; $y1 = $dstRect->y; $x2 = $dstRect->x + $dstRect->w - 1; $y2 = $dstRect->y + $dstRect->h - 1; // Rectangle jaune plein (border) $borderRect = new \SDL_Rect; $borderRect->x = $x1; $borderRect->y = $y1; $borderRect->w = $dstRect->w; $borderRect->h = $dstRect->h; \SDL_SetRenderDrawColor($this->sdl->getRenderer()->getRenderer(), 255, 255, 0, 255); // Jaune \SDL_RenderFillRect($this->sdl->getRenderer()->getRenderer(), $borderRect); // Rectangle noir plus petit à l'intérieur $innerRect = new \SDL_Rect; $innerRect->x = $x1 + 2; $innerRect->y = $y1 + 2; $innerRect->w = $dstRect->w - 4; $innerRect->h = $dstRect->h - 4; \SDL_SetRenderDrawColor($this->sdl->getRenderer()->getRenderer(), 0, 0, 0, 255); // Noir \SDL_RenderFillRect($this->sdl->getRenderer()->getRenderer(), $innerRect); // Remettre la couleur jaune pour le texte \SDL_SetRenderDrawColor($this->sdl->getRenderer()->getRenderer(), 255, 255, 0, 255); // Afficher les 2 caractères hexadécimaux séparément if (isset($fontTab[substr($char, 0, 1)]) && isset($fontTab[substr($char, 1, 1)])) { // Premier caractère (gauche) $dstRectFont = new \SDL_Rect; $dstRectFont->x = $dstRect->x + 4; $dstRectFont->y = $dstRect->y + 4; $dstRectFont->w = 12; $dstRectFont->h = 24; \SDL_RenderCopyEx( $this->sdl->getRenderer()->getRenderer(), $fontTab[substr($char, 0, 1)], new \SDL_Rect(0, 0, 32, 32), $dstRectFont, 0, null, \SDL_FLIP_NONE ); // Deuxième caractère (droite) $dstRectFont2 = new \SDL_Rect; $dstRectFont2->x = $dstRect->x + 16; $dstRectFont2->y = $dstRect->y + 4; $dstRectFont2->w = 12; $dstRectFont2->h = 24; \SDL_RenderCopyEx( $this->sdl->getRenderer()->getRenderer(), $fontTab[substr($char, 1, 1)], new \SDL_Rect(0, 0, 32, 32), $dstRectFont2, 0, null, \SDL_FLIP_NONE ); } // En mode debug 2, afficher les zones de collision if ($debugType == 3) { if ($colision = $level->getTileColisionAt($x, $y)) { \SDL_SetRenderDrawColor($this->sdl->getRenderer()->getRenderer(), 0, 255, 255, 128); // Semi-transparent // Calculer les zones de collision et les remplir $this->fillCollisionZones($level->getTileColisionAt($x, $y) , $dstRect->x, $dstRect->y); // $this->drawCollisionPixelRand($colision, $dstRect->x, $dstRect->y); // Remettre la couleur jaune pour les borders \SDL_SetRenderDrawColor($this->sdl->getRenderer()->getRenderer(), 255, 255, 0, 255); } } } } // En mode debug 2, dessiner les rectangles multicolors autour des tiles en collision if ($debugType == 2) { $this->drawCollisionTilesMulticolor(); } } /** * Dessine des rectangles multicolors autour des tiles en collision */ private function drawCollisionTilesMulticolor() { $cameraX = $this->camera->getX(); $cameraY = $this->camera->getY(); $tileSize = 32; foreach ($this->collisionTiles as $tileKey => $tileData) { $tileX = $tileData['tileX']; $tileY = $tileData['tileY']; // Calculer la position à l'écran $screenX = $tileX * $tileSize - $cameraX; $screenY = $tileY * $tileSize - $cameraY; // Vérifier si la tile est visible à l'écran if ($screenX >= -$tileSize && $screenX <= $this->sdl->getWindow()->getWidth() && $screenY >= -$tileSize && $screenY <= $this->sdl->getWindow()->getHeight()) { // Créer un rectangle multicolor (arc-en-ciel) $this->drawRainbowBorder($screenX, $screenY, $tileSize); } } } /** * Dessine une bordure arc-en-ciel autour d'une tile */ private function drawRainbowBorder($x, $y, $size) { $colors = [ [255, 0, 0], // Rouge [255, 127, 0], // Orange [255, 255, 0], // Jaune [0, 255, 0], // Vert [0, 0, 255], // Bleu [75, 0, 130], // Indigo [148, 0, 211] // Violet ]; shuffle($colors); $colorIndex = 0; $borderWidth = 2; // Dessiner les 4 côtés avec des couleurs différentes for ($i = 0; $i < 4; $i++) { $color = $colors[$colorIndex % count($colors)]; \SDL_SetRenderDrawColor($this->sdl->getRenderer()->getRenderer(), $color[0], $color[1], $color[2], 255); $rect = new \SDL_Rect; switch ($i) { case 0: // Haut $rect->x = $x; $rect->y = $y; $rect->w = $size; $rect->h = $borderWidth; break; case 1: // Droite $rect->x = $x + $size - $borderWidth; $rect->y = $y; $rect->w = $borderWidth; $rect->h = $size; break; case 2: // Bas $rect->x = $x; $rect->y = $y + $size - $borderWidth; $rect->w = $size; $rect->h = $borderWidth; break; case 3: // Gauche $rect->x = $x; $rect->y = $y; $rect->w = $borderWidth; $rect->h = $size; break; } \SDL_RenderFillRect($this->sdl->getRenderer()->getRenderer(), $rect); $colorIndex++; } } private function drawCollisionPixelRand($tileColisionData, $tileX, $tileY) { // Parcourir les 32x32 pixels de la tile for ($y = 0; $y < 32; $y++) { for ($x = 0; $x < 32; $x++) { // Vérifier si rand(1,10) == 5 (10% de chance) if (rand(1, 20) == 5) { // Vérifier si le pixel est dans une zone de collision if (isset($tileColisionData[$y][$x]) && $tileColisionData[$y][$x] == 1) { // Dessiner un pixel à cette position $pixelX = $tileX + $x; $pixelY = $tileY + $y; // Utiliser SDL_RenderDrawPoint pour dessiner un pixel \SDL_RenderDrawPoint( $this->sdl->getRenderer()->getRenderer(), $pixelX, $pixelY ); } } } } } private function fillCollisionZones($tileColisionData, $tileX, $tileY) { // Algorithme simple : détecter les lignes horizontales de collision for ($y = 0; $y < 32; $y++) { $startX = -1; $endX = -1; // Trouver le début et la fin de chaque ligne de collision for ($x = 0; $x < 32; $x++) { if (isset($tileColisionData[$y][$x]) && $tileColisionData[$y][$x] == 1) { if ($startX == -1) { $startX = $x; } $endX = $x; } else { // Si on trouve un pixel sans collision, dessiner le rectangle précédent if ($startX != -1 && $endX != -1) { $rect = new \SDL_Rect; $rect->x = $tileX + $startX; $rect->y = $tileY + $y; $rect->w = $endX - $startX + 1; $rect->h = 1; \SDL_RenderFillRect($this->sdl->getRenderer()->getRenderer(), $rect); $startX = -1; $endX = -1; } } } // Dessiner le dernier rectangle de la ligne si nécessaire if ($startX != -1 && $endX != -1) { $rect = new \SDL_Rect; $rect->x = $tileX + $startX; $rect->y = $tileY + $y; $rect->w = $endX - $startX + 1; $rect->h = 1; \SDL_RenderFillRect($this->sdl->getRenderer()->getRenderer(), $rect); } } } private function drawGameObjects(): void { if (!$this->objectManager || !$this->currentLevel) return; $cameraX = $this->camera->getX(); $cameraY = $this->camera->getY(); $winW = $this->sdl->getWindow()->getWidth(); $winH = $this->sdl->getWindow()->getHeight(); $visibleObjects = $this->objectManager->getVisibleObjects($cameraX, $cameraY, $winW, $winH); // flowers are background tiles in the original: behind every sprite usort($visibleObjects, fn($a, $b) => ($b instanceof Flower) <=> ($a instanceof Flower)); foreach ($visibleObjects as $obj) { $obj->render($cameraX, $cameraY); } } public function setPlayer(Player $player) { $this->player = $player; } public function resetLevel() { $this->currentLevel = null; }}