<?php

namespace App\Entities\Physics;

use App\Audio\SoundManager;

use Evenement\EventEmitter;
use App\Entities\Entity;
use App\Entities\Player;
use App\Level\Level;

class CollisionSystem extends EventEmitter
{
	private int $tileSize = 32;

	private float $springForce = -1100.0;
	private float $horizontalSpringForce = 600.0;
	private float $bumperBounceForce = 700.0;

	// Original speeds are px/frame at 60Hz. Vertical launches keep the original heights in pixels:
	// original gravity is $38/256 px/frame² (787.5 px/s²) vs 1400 here, so v = v60 * sqrt(1400 / 787.5) = v * 80.
	private const VERTICAL_SCALE = 80.0;
	private const FRAME_SPEED = 60.0;
	/** Engine px/s for 1 px/frame of the original horizontal speeds (500 px/s = the original 3 px/frame). */
	private const ROM_SPEED_TO_ENGINE = 500 / 3;

	private const B_SPIKES = 1;
	private const B_RAMP = 2;
	private const B_SPRING_LEFT = 3;
	private const B_SPRING_UP_RIGHT_HALF = 4;
	private const B_SPRING_RIGHT = 5;
	private const B_CONVEYOR_LEFT = 6;
	private const B_CONVEYOR_RIGHT = 7;
	private const B_SPRING_UP_CENTER = 9;
	private const B_CURRENT_LEFT = 12;
	private const B_SLIDE_RIGHT_5 = 13;
	private const B_SLIDE_RIGHT_6 = 14;
	private const B_SLIDE_LEFT_5 = 15;
	private const B_SLIDE_LEFT_6 = 16;
	private const B_BUMPER_VERTICAL = 17;
	private const B_SPRING_10 = 18;
	private const B_SPRING_12 = 19;
	private const B_SPRING_14 = 20;
	private const B_BUMPER_HORIZONTAL = 21;
	private const B_BUMPER_VERTICAL_2 = 22;
	private const B_ELECTRIC = 23;

	private array $behaviour = [];
	private float $bumperCooldown = 0;
	/** Time (microtime) each sound effect was last emitted, so blocks acting every frame don't spam it. */
	private array $sfxClock = [];
	private int $currentLevel = 0;
	/** Emit 'collisionTile' for the debug view (Scene): off in the game, it costs every physics step of every Sonic. */
	public bool $reportTiles = false;
	/** @var callable|null fn(array $rect, float $vy, string $state): ?array{y: float, dx: float} */
	private $objectGroundProvider = null;

	public function setObjectGroundProvider(?callable $provider): void
	{
		$this->objectGroundProvider = $provider;
	}

	/** @var callable|null fn(): ?float, the Labyrinth water line (object $40) */
	private $waterLineProvider = null;

	public function setWaterLineProvider(?callable $provider): void
	{
		$this->waterLineProvider = $provider;
	}

	private function updateLevelConfig(Level $level): void
	{
		// by object: the levels of the site all have the same number
		$lvl = spl_object_id($level);
		if ($lvl === $this->currentLevel) return;
		$this->currentLevel = $lvl;

		$this->behaviour = $level->getBlockBehaviours();

	}

	public function checkCollisions(Entity|Player $entity, Level $level, float $deltaTime)
	{
		$this->updateLevelConfig($level);
		$oldGrounded = $entity->isGrounded();
		$velocity = $entity->getVelocity();

		$entity->setGrounded(false);

		// --- Ground detection (when falling or standing) ---
		$onObject = false;
		if ($velocity[1] >= 0) {
			$groundResult = $this->detectGround($entity, $level);
			$objectGround = $this->objectGroundProvider !== null
				? ($this->objectGroundProvider)($entity->getCollisionRect(), $velocity[1], $entity->getState())
				: null;
			if ($objectGround !== null && ($groundResult === null || $objectGround['y'] < $groundResult['entityY'] || $objectGround['force'])) {
				$groundResult = ['entityY' => $objectGround['y']];
				$entity->setX($entity->getCollisionRect()['x'] + $objectGround['dx']);
				$onObject = true;
			}
			if ($groundResult !== null) {
				$entity->setY($groundResult['entityY']);
				$entity->setGrounded(true, $groundResult['entityY']);
				$entity->setVelocity($velocity[0], 0);
			}
		}

		// --- Ceiling detection (when moving up) ---
		if ($velocity[1] < 0) {
			$ceilY = $this->detectCeiling($entity, $level);
			if ($ceilY !== null) {
				$entity->setY($ceilY);
				$vel = $entity->getVelocity();
				$entity->setVelocity($vel[0], 0);
			}
		}

		// --- Wall detection ---
		$vel = $entity->getVelocity();
		if ($vel[0] > 0) {
			$wallX = $this->detectWallRight($entity, $level);
			if ($wallX !== null) {
				$entity->setX($wallX);
				$entity->setVelocity(0, $entity->getVelocity()[1]);
			}
		} elseif ($vel[0] < 0) {
			$wallX = $this->detectWallLeft($entity, $level);
			if ($wallX !== null) {
				$entity->setX($wallX);
				$entity->setVelocity(0, $entity->getVelocity()[1]);
			}
		}

		// --- Block behaviours from the ROM table (springs, spikes, ramps, conveyors...) ---
		$this->applyBlockBehaviour($entity, $level, $deltaTime);

		// --- Snap to ground (was grounded, walked off slope/edge) ---
		$currentVel = $entity->getVelocity();
		if (!$entity->isGrounded() && $oldGrounded && $currentVel[1] >= 0) {
			$snapResult = $this->snapToGround($entity, $level, $deltaTime);
			if ($snapResult !== null) {
				$entity->setY($snapResult);
				$entity->setGrounded(true, $snapResult);
				$v = $entity->getVelocity();
				$entity->setVelocity($v[0], 0);
			}
		}

		// --- Slope acceleration (when grounded) ---
		// _32e2: standing on a block adds the value of its solidity type ($3F90 table) to the X speed every frame
		if ($entity->isGrounded() && !$onObject) {
			$slopeAccel = $this->romSlopeAccel($entity, $level);
			// running up the slope (pushing against it, not rolling): only UPHILL_PUSH of its pull. In the
			// original a 45° slope ($1C) pulls more than Sonic accelerates ($10): without a run-up he stalled.
			$ax = $entity->getAcceleration()['x'];
			if ($slopeAccel * $ax < 0 && $entity->getState() !== 'roll') $slopeAccel *= self::UPHILL_PUSH;
			if ($slopeAccel != 0) {
				$v = $entity->getVelocity();
				$entity->setVelocity($v[0] + $slopeAccel * $deltaTime, $v[1]);
			}
		}

		// --- Water detection ---
		$this->detectWater($entity, $level);

		$this->checkLevelBounds($entity, $level);
	}

	/**
	 * $3F90 + solidity type, in 1/256 px/frame²: $1C on the 45° slopes ($01-$04), $12 on the gentle ones
	 * ($05-$0A, $29/$2A), positive = to the right (downhill), nothing on the other shapes.
	 */
	private const SLOPE_ACCEL = [
		0x01 => 0x1C, 0x02 => 0x1C, 0x03 => -0x1C, 0x04 => -0x1C,
		0x05 => 0x12, 0x06 => 0x12, 0x07 => 0x12, 0x08 => -0x12, 0x09 => -0x12, 0x0A => -0x12,
		0x29 => 0x12, 0x2A => -0x12,
	];
	/** Part of a slope's pull left while Sonic runs up it (net push on 45°: $10 - $1C * 0.3 = +$07). */
	private const UPHILL_PUSH = 0.3;
	/** 1/256 px/frame² -> engine px/s², same scale as Sonic's ground acceleration (Player::GROUND_SCALE). */
	private const ROM_ACCEL_TO_ENGINE = Player::GROUND_SCALE;

	/** Slope acceleration of the block under Sonic's feet (centre, like the ROM probe at X + width / 2). */
	private function romSlopeAccel(Entity|Player $entity, Level $level): float
	{
		$rect = $entity->getCollisionRect();
		$x = (int)floor($rect['x'] + $rect['width'] / 2);
		$feet = $rect['y'] + $rect['height'];
		$solidity = $level->getSolidity();
		foreach ([(int)floor($feet) + 1, (int)floor($feet) - 2] as $y) {
			$block = $level->getTile(intdiv($x, $this->tileSize), intdiv(max(0, $y), $this->tileSize));
			if ($block === null || !isset($solidity[$block])) continue;
			$type = ord($solidity[$block]) & 0x3F;
			if ($type === 0) continue;
			return (self::SLOPE_ACCEL[$type] ?? 0) * self::ROM_ACCEL_TO_ENGINE;
		}
		return 0.0;
	}

	private function detectWater(Entity|Player $entity, Level $level): void
	{
		$rect = $entity->getCollisionRect();
		// the original looks at one point only, the centre of Sonic's 24x32 object (X + $0C, Y + $10)
		$centerX = (int)floor($entity->getX() + 0x0C);
		$centerY = (int)floor($rect['y'] + $rect['height'] - 16);
		$tile = $level->getTile((int)floor($centerX / $this->tileSize), (int)floor($centerY / $this->tileSize));

		// Labyrinth: underwater once the top of Sonic is below the water line (_50e8). Elsewhere the block
		// behaviour 8 (_55a8) sets the water flag and only behaviour 0 (_54bc) clears it, the other
		// behaviours leave it as it is.
		$waterLine = $this->waterLineProvider !== null ? ($this->waterLineProvider)() : null;
		if ($waterLine !== null) {
			$inWater = $rect['y'] > $waterLine;
		} else {
			$b = $tile !== null ? ($this->behaviour[$tile] ?? 0) : 0;
			$wasInWater = method_exists($entity, 'isInWater') && $entity->isInWater();
			$inWater = $b === 8 || ($b !== 0 && $wasInWater);
		}

		if (method_exists($entity, 'setInWater')) {
			if ($inWater && !$entity->isInWater()) {
				$this->sfx(SoundManager::SFX_SPLASH);
			}
			$entity->setInWater($inWater);
		}
	}

	public function getBlockBehaviourAt(Level $level, float $x, float $y): int
	{
		$tile = $level->getTile((int)floor($x / $this->tileSize), (int)floor($y / $this->tileSize));
		if ($tile === null) return 0;
		return $this->behaviour[$tile] ?? 0;
	}

	private function applyBlockBehaviour(Entity|Player $entity, Level $level, float $deltaTime): void
	{
		if ($this->bumperCooldown > 0) {
			$this->bumperCooldown -= $deltaTime;
		}
		if (empty($this->behaviour)) return;

		$rect = $entity->getCollisionRect();
		$probeX = $rect['x'] + $rect['width'] / 2;
		$probeY = $rect['y'] + $rect['height'] - 1;
		$b = $this->getBlockBehaviourAt($level, $probeX, $probeY);
		$headBehaviour = $this->getBlockBehaviourAt($level, $probeX, $rect['y'] + 1);
		if ($headBehaviour === self::B_SPIKES || $headBehaviour === self::B_ELECTRIC) {
			$b = $headBehaviour;
		}
		if ($b === 0 || $b >= 0x1C) return;

		$xInBlock = ((int)floor($probeX)) & 31;
		[$vx, $vy] = $entity->getVelocity();
		$grounded = $entity->isGrounded();

		switch ($b) {
			case self::B_SPIKES:
			case self::B_ELECTRIC:
				$this->emit('playerHazard', [$entity]);
				break;

			case self::B_RAMP:
				// _54ce: only a rolling or jumping Sonic ($D414 bit 0 / 2) going right at $0301 or more is thrown,
				// Y speed = -2 x the whole px/frame of his X speed; he stays a ball (no spring pose)
				$romVx = $vx / self::ROM_SPEED_TO_ENGINE;
				$ball = method_exists($entity, 'getState') && in_array($entity->getState(), ['roll', 'jump'], true);
				if ($xInBlock >= 26 && $ball && $romVx >= 0x301 / 256) {
					$this->launch($entity, $vx, -2 * floor($romVx) * self::VERTICAL_SCALE, SoundManager::SFX_LAUNCH, false);
				}
				break;

			case self::B_SPRING_LEFT:
				if ($xInBlock >= 16) {
					$entity->setVelocity(-$this->horizontalSpringForce, $vy);
					$entity->setFacing('left');
					$this->sfx(SoundManager::SFX_SPRING);
				}
				break;

			case self::B_SPRING_RIGHT:
				if ($xInBlock < 16) {
					$entity->setVelocity($this->horizontalSpringForce, $vy);
					$entity->setFacing('right');
					$this->sfx(SoundManager::SFX_SPRING);
				}
				break;

			case self::B_SPRING_UP_RIGHT_HALF:
				if ($xInBlock >= 16 && $grounded) {
					$this->launch($entity, $vx, -12 * self::VERTICAL_SCALE);
				}
				break;

			case self::B_SPRING_UP_CENTER:
				if ($xInBlock >= 8 && $xInBlock < 24 && $grounded) {
					$this->launch($entity, $vx, -12 * self::VERTICAL_SCALE);
				}
				break;

			case self::B_CONVEYOR_LEFT:
				if ($grounded) $entity->setX($entity->getCollisionRect()['x'] - 1.5 * self::FRAME_SPEED * $deltaTime);
				break;

			case self::B_CONVEYOR_RIGHT:
				if ($grounded) $entity->setX($entity->getCollisionRect()['x'] + 2 * self::FRAME_SPEED * $deltaTime);
				break;

			case self::B_CURRENT_LEFT:
				$entity->setVelocity($vx - 8 / 256 * self::FRAME_SPEED * self::FRAME_SPEED * $deltaTime, $vy);
				break;

			case self::B_SLIDE_RIGHT_5:
			case self::B_SLIDE_RIGHT_6:
			case self::B_SLIDE_LEFT_5:
			case self::B_SLIDE_LEFT_6:
				$speed = [self::B_SLIDE_RIGHT_5 => 5, self::B_SLIDE_RIGHT_6 => 6, self::B_SLIDE_LEFT_5 => -5, self::B_SLIDE_LEFT_6 => -6][$b];
				// _567c..: X speed set, Y speed 4 px/frame, no control, neither jumping nor rolling, animation $11
				$entity->setVelocity($speed * self::FRAME_SPEED, 4 * self::VERTICAL_SCALE);
				if ($entity instanceof Player) {
					if ($entity->getState() === 'roll' || $entity->getState() === 'jump') $entity->setState('walk');
					$entity->setSliding($speed < 0);
				}
				break;

			case self::B_SPRING_10:
				$this->launch($entity, $vx, -10 * self::VERTICAL_SCALE);
				break;
			case self::B_SPRING_12:
				$this->launch($entity, $vx, -12 * self::VERTICAL_SCALE);
				break;
			case self::B_SPRING_14:
				$this->launch($entity, $vx, -14 * self::VERTICAL_SCALE);
				break;

			case self::B_BUMPER_VERTICAL:
			case self::B_BUMPER_VERTICAL_2:
				if ($this->bumperCooldown > 0) break;
				$this->bumperCooldown = 8 / self::FRAME_SPEED;
				$towardsCenter = ($xInBlock < 16) === ($vx >= 0);
				$newVx = $towardsCenter ? -$vx * 1.5 : $vx * 1.5;
				$newVy = -$vy;
				if ($newVy < 0) $newVy -= 0.22 * self::VERTICAL_SCALE;
				$entity->setVelocity($newVx, max($newVy, -$this->bumperBounceForce * 1.5));
				$entity->setGrounded(false);
				$this->sfx(SoundManager::SFX_BUMPER);
				// _57cd -> _57be: the big bumpers flash (background colour 14 turns white)
				if ($b === self::B_BUMPER_VERTICAL_2) $this->emit('paletteFlash', []);
				break;

			case self::B_BUMPER_HORIZONTAL:
				if ($this->bumperCooldown > 0) break;
				$this->bumperCooldown = 4 / self::FRAME_SPEED;
				$entity->setVelocity(-$vx + ($vx < 0 ? self::FRAME_SPEED : -self::FRAME_SPEED), $vy);
				$this->sfx(SoundManager::SFX_BUMPER);
				// _5791 -> _57be
				$this->emit('paletteFlash', []);
				break;
		}
	}

	private function launch(Entity|Player $entity, float $vx, float $vy, int $sfx = SoundManager::SFX_SPRING, bool $springPose = true): void
	{
		$this->sfx($sfx);
		$entity->setGrounded(false);
		$entity->setVelocity($vx, $vy);
		if (method_exists($entity, 'setState')) {
			$entity->setState('jump');
		}
		if ($springPose && $vy < 0 && method_exists($entity, 'setSprung')) {
			$entity->setSprung();
		}
	}

	private function sfx(int $index): void
	{
		$now = microtime(true);
		if ($now - ($this->sfxClock[$index] ?? 0) < 0.25) return;
		$this->sfxClock[$index] = $now;
		$this->emit('sfx', [$index]);
	}

	private function detectGround(Entity|Player $entity, Level $level): ?array
	{
		$rect = $entity->getCollisionRect();
		$feetY = $rect['y'] + $rect['height'];

		$sensorXs = [
			(int)floor($rect['x']) + 4,
			(int)floor($rect['x'] + $rect['width'] / 2),
			(int)floor($rect['x'] + $rect['width']) - 4,
		];

		$bestEntityY = null;

		foreach ($sensorXs as $sx) {
			$tileX = (int)floor($sx / $this->tileSize);
			$pixelX = $sx - ($tileX * $this->tileSize);

			$tileYAtFeet = (int)floor($feetY / $this->tileSize);

			for ($ty = max(0, $tileYAtFeet - 1); $ty <= $tileYAtFeet + 1; $ty++) {
				$surfaceY = $this->findSurfaceYForGround($level, $tileX, $ty, $pixelX);
				if ($surfaceY === null) continue;

				$penetration = $feetY - $surfaceY;
				// a surface above the feet only counts when the scenery is solid down to them (slope, step):
				// not a band hanging over Sonic with a gap under it (Scrap Brain teleporter blocks, type $10)
				if ($penetration > 1 && !$level->isSolidAt($sx, (int)floor($feetY) - 1)) continue;

				if ($penetration >= 0 && $penetration <= $this->tileSize) {
					$entityY = $surfaceY - $rect['height'];

					if ($this->reportTiles) {
						$this->emit('collisionTile', [[
							'tileX' => $tileX,
							'tileY' => $ty,
							'tileValue' => $level->getTile($tileX, $ty),
							'collisionData' => $level->getTileColisionAt($tileX, $ty)
						]]);
					}

					if ($bestEntityY === null || $entityY < $bestEntityY) {
						$bestEntityY = $entityY;
					}
				}
			}
		}

		if ($bestEntityY === null) return null;
		return ['entityY' => $bestEntityY];
	}

	private function findSurfaceYForGround(Level $level, int $tileX, int $tileY, int $pixelX): ?float
	{
		if (($level->getTileColisionWayAt($tileX, $tileY)['floor'] ?? true) === false) return null;
		$row = $level->getTileTopAt($tileX, $tileY, $pixelX);
		return $row === null ? null : (float)($tileY * $this->tileSize + $row);
	}

	private function detectCeiling(Entity|Player $entity, Level $level): ?float
	{
		$rect = $entity->getCollisionRect();
		$headY = (int)floor($rect['y']);

		$sensorXs = [
			(int)floor($rect['x']) + 4,
			(int)floor($rect['x'] + $rect['width'] / 2),
			(int)floor($rect['x'] + $rect['width']) - 4,
		];

		$bestEntityY = null;

		foreach ($sensorXs as $sx) {
			$tileX = (int)floor($sx / $this->tileSize);
			$pixelX = $sx - ($tileX * $this->tileSize);

			$tileYAtHead = (int)floor($headY / $this->tileSize);

			for ($ty = max(0, $tileYAtHead - 1); $ty <= $tileYAtHead; $ty++) {
				$colData = $level->getTileColisionAt($tileX, $ty);
				if (!$colData) continue;

				$colWay = $level->getTileColisionWayAt($tileX, $ty);
				if ($colWay !== null && empty($colWay['top'])) continue;

				for ($row = $this->tileSize - 1; $row >= 0; $row--) {
					if (isset($colData[$row][$pixelX]) && $colData[$row][$pixelX] == 1) {
						$ceilingBottomY = (float)($ty * $this->tileSize + $row + 1);

						if ($headY < $ceilingBottomY && $ceilingBottomY - $headY <= $this->tileSize) {
							if ($bestEntityY === null || $ceilingBottomY > $bestEntityY) {
								$bestEntityY = $ceilingBottomY;
							}
						}
						break;
					}
				}
			}
		}

		return $bestEntityY;
	}

	private function detectWallRight(Entity|Player $entity, Level $level): ?float
	{
		$rect = $entity->getCollisionRect();
		$rightEdge = (int)floor($rect['x'] + $rect['width']);

		$sensorYs = [
			(int)floor($rect['y'] + $rect['height'] * 0.25),
			(int)floor($rect['y'] + $rect['height'] * 0.5),
		];

		foreach ($sensorYs as $sy) {
			$tileX = (int)floor($rightEdge / $this->tileSize);
			$pixelX = $rightEdge - ($tileX * $this->tileSize);
			$tileY = (int)floor($sy / $this->tileSize);
			$pixelY = $sy - ($tileY * $this->tileSize);

			$colData = $level->getTileColisionAt($tileX, $tileY);
			if (!$colData) continue;

			$colWay = $level->getTileColisionWayAt($tileX, $tileY);
			if ($colWay !== null && empty($colWay['right'])) continue;

			if (isset($colData[$pixelY][$pixelX]) && $colData[$pixelY][$pixelX] == 1) {
				for ($px = 0; $px < $this->tileSize; $px++) {
					if (isset($colData[$pixelY][$px]) && $colData[$pixelY][$px] == 1) {
						$wallWorldX = (float)($tileX * $this->tileSize + $px);
						return $wallWorldX - $rect['width'];
					}
				}
			}
		}

		return null;
	}

	private function detectWallLeft(Entity|Player $entity, Level $level): ?float
	{
		$rect = $entity->getCollisionRect();
		$leftEdge = (int)floor($rect['x']);

		$sensorYs = [
			(int)floor($rect['y'] + $rect['height'] * 0.25),
			(int)floor($rect['y'] + $rect['height'] * 0.5),
		];

		foreach ($sensorYs as $sy) {
			$tileX = (int)floor($leftEdge / $this->tileSize);
			$pixelX = $leftEdge - ($tileX * $this->tileSize);
			$tileY = (int)floor($sy / $this->tileSize);
			$pixelY = $sy - ($tileY * $this->tileSize);

			if ($pixelX < 0) { $tileX--; $pixelX += $this->tileSize; }

			$colData = $level->getTileColisionAt($tileX, $tileY);
			if (!$colData) continue;

			$colWay = $level->getTileColisionWayAt($tileX, $tileY);
			if ($colWay !== null && empty($colWay['left'])) continue;

			if (isset($colData[$pixelY][$pixelX]) && $colData[$pixelY][$pixelX] == 1) {
				for ($px = $this->tileSize - 1; $px >= 0; $px--) {
					if (isset($colData[$pixelY][$px]) && $colData[$pixelY][$px] == 1) {
						$wallWorldX = (float)($tileX * $this->tileSize + $px + 1);
						return $wallWorldX;
					}
				}
			}
		}

		return null;
	}

	private function snapToGround(Entity|Player $entity, Level $level, float $deltaTime): ?float
	{
		$rect = $entity->getCollisionRect();
		$feetY = $rect['y'] + $rect['height'];
		$speedX = abs($entity->getVelocity()[0]);
		$snapDistance = max($this->tileSize, (int)ceil($speedX * $deltaTime * 2));
		$snapDistance = min($snapDistance, $this->tileSize * 2);

		$sensorXs = [
			(int)floor($rect['x']) + 4,
			(int)floor($rect['x'] + $rect['width'] / 2),
			(int)floor($rect['x'] + $rect['width']) - 4,
		];

		$bestEntityY = null;

		foreach ($sensorXs as $sx) {
			$tileX = (int)floor($sx / $this->tileSize);
			$pixelX = $sx - ($tileX * $this->tileSize);

			for ($dy = 0; $dy <= $snapDistance; $dy++) {
				$checkY = (int)floor($feetY) + $dy;
				$tileY = (int)floor($checkY / $this->tileSize);

				$surfaceY = $this->findSurfaceYForGround($level, $tileX, $tileY, $pixelX);
				if ($surfaceY === null) continue;

				if ($checkY >= $surfaceY) {
					$entityY = $surfaceY - $rect['height'];
					if ($bestEntityY === null || $entityY < $bestEntityY) {
						$bestEntityY = $entityY;
					}
					break;
				}
			}
		}

		return $bestEntityY;
	}

	private function checkLevelBounds(Entity|Player $entity, Level $level)
	{
		$entityRect = $entity->getCollisionRect();
		$velocity = $entity->getVelocity();

		if ($entityRect['x'] < 0) {
			$entity->setX(0);
			$entity->setVelocity(0, $velocity[1]);
		}

		$maxX = $level->getMapWidth() * $this->tileSize - $entityRect['width'];
		if ($entityRect['x'] > $maxX) {
			$entity->setX($maxX);
			$entity->setVelocity(0, $velocity[1]);
		}

		$maxY = $level->getMapHeight() * $this->tileSize;
		if ($entityRect['y'] > $maxY) {
			$this->handleFallOffLevel($entity, $level);
		}
	}

	private function handleFallOffLevel(Entity|Player $entity, Level $level)
	{
		if ($this->listeners('playerFell')) {
			$this->emit('playerFell', [$entity]);
			return;
		}
		$entity->setX($level->getCurrentPositionHeroXinTile() * $this->tileSize);
		$entity->setY($level->getCurrentPositionHeroYinTile() * $this->tileSize);
		$entity->setVelocity(0, 0);
		$entity->setGrounded(false);
	}
}