class Example extends Phaser.Scene { constructor() { super(); this.player = null; this.backgroundMusic = null; this.pMeter = null; this.pMeterBars = []; this.levelBlocks = null; this.bothKeysTimer = 0; // Timer for both keys pressed this.inputDisplay = null; // Add this line to store the input display text this.fpsText = null; // Add this line to store the FPS text this.showHitboxes = false; // Track hitbox visibility this.hitboxToggleText = null; // Store the hitbox toggle text display this.hitboxToggleKey = null; // Store the 'S' key for toggling hitboxes this.runStartTime = 0; // Track when the player started running this.isSprintRunning = false; // Track if the player is in sprint mode this.timerActive = true; // Track if the timer is active this.pizzaFaceSpawnKey = null; // Store the 'P' key for spawning Pizza Face } init() { this.player = null; this.levelBlocks = null; if (this.backgroundMusic) { this.backgroundMusic.stop(); } this.backgroundMusic = null; this.bothKeysTimer = 0; this.inputDisplay = null; this.fpsText = null; this.showHitboxes = false; this.hitboxToggleText = null; this.hitboxToggleKey = null; this.runStartTime = 0; this.isSprintRunning = false; this.timerActive = true; this.pizzaFaceSpawnKey = null; this.pizzaFace = null; this.redPizzaFace = null; this.timeLeft = 60; this.countdownEvent = null; this.fadeTimer = null; // Reset P Meter if (this.pMeter) { this.pMeter.clear(true, true); } this.pMeter = null; this.pMeterBars = []; } preload() { // Load the specific cloud texture this.load.image('cloud', 'https://play.rosebud.ai/assets/000.png?pcjZ'); // Load the new ground texture this.load.image('ground', 'https://play.rosebud.ai/assets/doubel.png?309F'); this.load.image('red', `https://play.rosebud.ai/assets/red.png?CiSK`); // Load the bread sprite for Pizza Face this.load.image('pizzaface', 'https://play.rosebud.ai/assets/bread.png?t8gg'); this.load.image('block', 'https://play.rosebud.ai/assets/001.png?FrjK'); this.load.image('player', 'https://play.rosebud.ai/assets/idleg.png?rOxx'); this.load.image('dead', 'https://play.rosebud.ai/assets/dieg.png?sdmc'); this.load.image('walk1', 'https://play.rosebud.ai/assets/walkg1.png?loWc'); this.load.image('walk2', 'https://play.rosebud.ai/assets/walkg2.png?wu9q'); this.load.image('walk3', 'https://play.rosebud.ai/assets/walkg3.png?Lug5'); this.load.image('jump', 'https://play.rosebud.ai/assets/jumpg.png?be7Q'); this.load.image('slide', 'https://play.rosebud.ai/assets/slideg.png?DZdi'); this.load.audio('backgroundMusic', 'https://play.rosebud.ai/assets/platformer_template_music.mp3?GpvC'); // Load new block assets this.load.image('block000', 'https://play.rosebud.ai/assets/000.png?hQw2'); this.load.image('block001', 'https://play.rosebud.ai/assets/001.png?FrjK'); this.load.image('block002', 'https://play.rosebud.ai/assets/002.png?3uyT'); this.load.image('block003', 'https://play.rosebud.ai/assets/003.png?0KlF'); this.load.image('block004', 'https://play.rosebud.ai/assets/004.png?zvDC'); this.load.image('pong', 'https://play.rosebud.ai/assets/pong.png?HMoX'); } create() { // Create cloud group this.clouds = this.add.group(); // Create initial clouds this.createClouds(); // Define the level layout (only floor) const levelLayout = [ [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], // This row represents the ground ]; // Build the level this.buildLevel(levelLayout); // Create player this.createPlayer(); // Add keyboard input this.cursors = this.input.keyboard.createCursorKeys(); this.jumpKey = this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.Z); this.runKey = this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.X); this.hitboxToggleKey = this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.S); this.pizzaFaceSpawnKey = this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.P); this.knockbackKey = this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.C); // Remove only specific key listeners to prevent duplicates this.input.keyboard.removeKey(Phaser.Input.Keyboard.KeyCodes.S); this.input.keyboard.removeKey(Phaser.Input.Keyboard.KeyCodes.P); // Add listeners for the specific keys this.input.keyboard.on('keydown-S', this.toggleHitboxes, this); this.input.keyboard.on('keydown-P', this.spawnPizzaFace, this); // Add colliders // Add collider between player and floor this.physics.add.collider(this.player, this.levelBlocks); // Add collision between player and Pizza Face this.physics.add.overlap(this.player, this.pizzaFace, this.playerDeath, null, this); // Add collision between player and invisible walls // Add collision between player and invisible walls this.physics.add.collider(this.player, this.physics.world.staticBodies); // Add background music if (this.backgroundMusic) { this.backgroundMusic.stop(); } this.backgroundMusic = this.sound.add('backgroundMusic', { loop: true, volume: 0.1 }); this.backgroundMusic.play(); // Create walk animation this.anims.create({ key: 'walk', frames: [{ key: 'walk1' }, { key: 'walk2' }, { key: 'walk3' }, { key: 'walk2' }], frameRate: 8, repeat: -1 }); this.anims.create({ key: 'run', frames: [{ key: 'walk1' }, { key: 'walk2' }, { key: 'walk3' }, { key: 'walk2' }], frameRate: 14, repeat: -1 }); // Remove this entire block // Create slide animation this.anims.create({ key: 'slide', frames: [{ key: 'slide' }], frameRate: 1, repeat: 0 }); // Create a single large black border for all text elements const borderColor = 0x000000; const borderHeight = 60; // Adjust this value to cover all your text elements const uiBorder = this.add.rectangle(0, 0, this.sys.game.config.width, borderHeight, borderColor) .setOrigin(0, 0) .setScrollFactor(0) .setDepth(999); // Create input display this.inputDisplay = this.add.text(16, 10, '', { fontSize: '18px', fill: '#ffffff' }); this.inputDisplay.setScrollFactor(0).setDepth(1000); // Create FPS counter this.fpsText = this.add.text(this.sys.game.config.width - 20, 10, '', { fontSize: '16px', fill: '#ffffff' }); this.fpsText.setOrigin(1, 0).setScrollFactor(0).setDepth(1000); // Create hitbox toggle button this.hitboxToggleText = this.add.text(this.sys.game.config.width - 20, 35, 'Show Hitboxes: OFF', { fontSize: '16px', fill: '#ffffff' }).setOrigin(1, 0).setScrollFactor(0).setDepth(1000); // Add countdown timer this.timeLeft = 60; // 60 seconds = 1 minute this.timerText = this.add.text(this.sys.game.config.width / 2, 30, '1:00', { fontSize: '32px', fill: '#ffffff' }).setOrigin(0.5, 0.5).setScrollFactor(0).setDepth(1000); // Start the countdown this.countdownEvent = this.time.addEvent({ delay: 1000, callback: this.updateTimer, callbackScope: this, loop: true }); // Set up camera to follow player const worldWidth = this.sys.game.config.width * 10; // Match the ground width const leftWallWidth = 10; // Width of the invisible wall this.cameras.main.setBounds(leftWallWidth, 0, worldWidth - leftWallWidth, this.sys.game.config.height); // Remove smooth following this.cameras.main.startFollow(this.player, false, 1, 1); // Make the world bounds match the ground width, but include the left wall this.physics.world.setBounds(0, 0, worldWidth, this.sys.game.config.height); // Wall creation code removed // Add invisible walls at the corners of the map this.addInvisibleWalls(); // Add tall walls on both sides of the level this.addTallSideWalls(); // Create the P Meter this.createPMeter(); } createPMeter() { this.pMeter = this.add.group(); const x = 20; const y = this.sys.game.config.height - 40; // Create background const bg = this.add.rectangle(x, y, 100, 20, 0x000000); bg.setOrigin(0, 0.5); bg.setScrollFactor(0); this.pMeter.add(bg); // Create bars const barColors = [0x00ff00, 0x00ff00, 0xffff00, 0xffa500, 0xff0000]; for (let i = 0; i < 5; i++) { const bar = this.add.rectangle(x + i * 20, y, 18, 18, barColors[i]); bar.setOrigin(0, 0.5); bar.setScrollFactor(0); bar.setVisible(false); this.pMeterBars.push(bar); this.pMeter.add(bar); } } addTallSideWalls() { const worldWidth = this.physics.world.bounds.width; const worldHeight = this.physics.world.bounds.height; const wallWidth = 10; // Reduced width of the side walls // Create a static group for the walls const walls = this.physics.add.staticGroup(); // Left wall (moved slightly more to the left) walls.create(-wallWidth / 2, worldHeight / 2, 'red') .setScale(wallWidth / 32, worldHeight / 32) .setOrigin(0.5, 0.5) .refreshBody(); // Right wall walls.create(worldWidth, worldHeight / 2, 'red') .setScale(wallWidth / 32, worldHeight / 32) .setOrigin(1, 0.5) .refreshBody(); // Add collision between player and walls this.physics.add.collider(this.player, walls); } addInvisibleWalls() { const worldWidth = this.physics.world.bounds.width; const worldHeight = this.physics.world.bounds.height; const wallThickness = 50; // Create a static group for the walls const walls = this.physics.add.staticGroup(); // Function to add a wall to the group const addWall = (x, y, width, height) => { walls.create(x + width / 2, y + height / 2, 'red') .setSize(width, height) .setImmovable(true) .setVisible(false); }; // Left wall addWall(0, 0, wallThickness, worldHeight); // Right wall addWall(worldWidth - wallThickness, 0, wallThickness, worldHeight); // Bottom wall addWall(0, worldHeight - wallThickness, worldWidth, wallThickness); // Add collision between player and walls this.physics.add.collider(this.player, walls); } // Remove these methods update(time, delta) { if (this.snakeGameActive) { return; // Snake game is updated by its own timer } if (!this.player || !this.player.body || this.player.isDead) return; // Updated check this.updatePizzaFace(); this.updatePMeter(); // Update the P Meter this.updateClouds(); // Update cloud positions const baseSpeed = 180; const runningSpeed = 400; // Initial running speed const sprintSpeed = 600; // Sprint speed after running for 1 second const slideSpeed = 300; // Reduced initial slide speed const slideDuration = 200; // Reduced slide duration for a shorter slide const jumpDuration = 250; // Duration of jump effect in milliseconds const slideDeceleration = 3000; // Increased rate at which slide speed decreases const acceleration = 1500; // Acceleration rate const deceleration = 2000; // Deceleration rate if (this.player.isSliding) { const elapsedTime = this.time.now - this.player.slideTimer; if (elapsedTime < slideDuration) { // Calculate new velocity based on deceleration const newVelocity = this.player.slideInitialVelocity * (1 - (elapsedTime / slideDuration)); this.player.setVelocityX(newVelocity); } else { // End of slide this.player.isSliding = false; this.player.setVelocityX(0); this.player.body.setDragX(500); } } else if (this.cursors.left.isDown || this.cursors.right.isDown) { const isRunning = this.runKey.isDown; // Check if both left and right keys are pressed if (this.cursors.left.isDown && this.cursors.right.isDown) { this.runStartTime = 0; this.isSprintRunning = false; if (this.bothKeysTimer === 0) { this.bothKeysTimer = this.time.now; } else if (this.time.now - this.bothKeysTimer > 2) { // If both keys are pressed for more than 2ms, stop the player this.player.setVelocityX(0); this.player.anims.stop(); this.player.setTexture('player'); } } else { this.bothKeysTimer = 0; // Reset the timer when only one key is pressed if (isRunning) { if (this.runStartTime === 0) { this.runStartTime = time; } if (time - this.runStartTime > 5000) { this.isSprintRunning = true; } else { this.isSprintRunning = false; } } else { this.runStartTime = 0; this.isSprintRunning = false; } const targetSpeed = isRunning ? (this.isSprintRunning ? sprintSpeed : runningSpeed) : baseSpeed; const currentSpeed = Math.abs(this.player.body.velocity.x); let animKey = isRunning ? 'run' : 'walk'; // Always play the animation, even if it's the same key if (this.player.body.onFloor() && !this.player.isSliding) { if (this.player.anims.currentAnim?.key !== animKey || !this.player.anims.isPlaying) { this.player.play(animKey, true); } } // Ensure the animation is playing and not stuck if (this.player.anims.currentAnim && !this.player.anims.isPlaying) { this.player.anims.resume(); } const finalTargetSpeed = this.cursors.left.isDown ? -targetSpeed : targetSpeed; // Accelerate towards the target speed if (this.cursors.left.isDown) { this.player.setVelocityX(Math.max(this.player.body.velocity.x - acceleration * (delta / 1000), -targetSpeed)); } else if (this.cursors.right.isDown) { this.player.setVelocityX(Math.min(this.player.body.velocity.x + acceleration * (delta / 1000), targetSpeed)); } // Only change direction if on the ground if (this.player.body.onFloor()) { this.player.flipX = this.cursors.left.isDown; this.player.jumpDirection = null; // Reset jump direction when on ground } else if (this.player.jumpDirection) { // Keep the direction from when the jump started this.player.flipX = this.player.jumpDirection === 'left'; } // Remove this redundant block as we've already set the animation above // const animKey = isRunning ? 'run' : 'walk'; // if (this.player.anims.currentAnim && this.player.anims.currentAnim.key !== animKey) { // this.player.anims.stop(); // this.player.setTexture('walk1'); // this.player.anims.play(animKey); // } else if (!this.player.anims.currentAnim) { // this.player.setTexture('walk1'); // this.player.anims.play(animKey); // } } // Sliding logic if (this.bothKeysTimer === 0 || this.time.now - this.bothKeysTimer <= 2) { if (isRunning && ((this.player.body.velocity.x > 0 && this.cursors.left.isDown) || (this.player.body.velocity.x < 0 && this.cursors.right.isDown))) { // Start sliding only when there's a clear direction change this.player.isSliding = true; this.player.slideTimer = this.time.now; // Reduce the initial slide velocity this.player.slideInitialVelocity = this.player.body.velocity.x > 0 ? Math.min(this.player.body.velocity.x, slideSpeed) : Math.max(this.player.body.velocity.x, -slideSpeed); this.player.setVelocityX(this.player.slideInitialVelocity); this.player.anims.play('slide', true); this.player.body.setDragX(100); // Add a small amount of drag during slide } } } else { // Decelerate to a stop if (this.player.body.velocity.x > 0) { this.player.setVelocityX(Math.max(0, this.player.body.velocity.x - deceleration * (delta / 1000))); } else if (this.player.body.velocity.x < 0) { this.player.setVelocityX(Math.min(0, this.player.body.velocity.x + deceleration * (delta / 1000))); } if (Math.abs(this.player.body.velocity.x) < 10) { this.player.setVelocityX(0); if (this.player.body.onFloor() && !this.player.isSliding) { this.player.anims.stop(); this.player.setTexture('player'); } } } // Ensure slide animation plays even if jumping if (this.player.isSliding && this.player.body.onFloor()) { this.player.anims.play('slide', true); } const canJump = this.player.body.onFloor(); if (Phaser.Input.Keyboard.JustDown(this.jumpKey) && canJump) { const baseJumpVelocity = -650; const runningJumpBoost = 70; const isRunning = Math.abs(this.player.body.velocity.x) > baseSpeed; let jumpVelocity = isRunning ? baseJumpVelocity - runningJumpBoost : baseJumpVelocity; this.player.setVelocityY(jumpVelocity); this.player.jumpTimer = this.time.now; this.player.jumpDirection = this.player.flipX ? 'left' : 'right'; if (this.player.isSliding) { this.player.anims.play('slide', true); } else { this.player.setTexture('jump'); } } // Limit jump duration const maxJumpDuration = 100; // Kept the reduced maximum time for ascent if (this.jumpKey.isDown && !this.player.body.onFloor()) { if (this.time.now - this.player.jumpTimer <= maxJumpDuration) { const baseJumpVelocity = -650; // Increased base jump velocity for higher jumps const runningJumpBoost = 70; // Increased boost for running jumps const isRunning = Math.abs(this.player.body.velocity.x) > baseSpeed; const jumpVelocity = isRunning ? baseJumpVelocity - runningJumpBoost : baseJumpVelocity; this.player.setVelocityY(jumpVelocity); } } // Check if player is in the air or just landed if (!this.isNearGround()) { if (this.player.texture.key !== 'jump') { this.player.setTexture('jump'); } this.player.wasInAir = true; } else if (this.player.wasInAir) { // Player just landed this.player.wasInAir = false; this.player.jumpDirection = null; // Reset jump direction this.player.setVelocityY(0); // Stop vertical movement immediately if (this.player.isSliding) { this.player.anims.play('slide', true); } else if (Math.abs(this.player.body.velocity.x) < 10) { this.player.setTexture('player'); } else { const animKey = this.runKey.isDown ? 'run' : 'walk'; this.player.setTexture('walk1'); this.player.anims.play(animKey); } } else if (this.player.body.onFloor()) { // Player is on the ground if (this.player.isSliding) { this.player.anims.play('slide', true); } else if (Math.abs(this.player.body.velocity.x) < 10) { this.player.setTexture('player'); } else { const animKey = this.runKey.isDown ? 'run' : 'walk'; this.player.anims.play(animKey, true); } // Update player direction based on current input when landing if (this.cursors.left.isDown) { this.player.flipX = true; } else if (this.cursors.right.isDown) { this.player.flipX = false; } } // Cancel jump momentum when Z key is released if (Phaser.Input.Keyboard.JustUp(this.jumpKey) && this.player.body.velocity.y < 0) { this.player.setVelocityY(this.player.body.velocity.y * 0.5); // Less aggressive jump cancellation } // Update input display let inputText = ''; inputText += this.cursors.left.isDown ? 'Left ' : ''; inputText += this.cursors.right.isDown ? 'Right ' : ''; inputText += this.jumpKey.isDown ? 'Jump ' : ''; inputText += this.runKey.isDown ? 'Run ' : ''; inputText += this.player.isSliding ? 'Slide ' : ''; this.inputDisplay.setText('Inputs: ' + (inputText || 'None')); // Update FPS counter const currentFps = Math.round(this.game.loop.actualFps); this.fpsText.setText(`FPS: ${currentFps}`); this.fpsText.setColor(currentFps <= 30 ? '#ff0000' : '#ffffff'); // Check for hitbox toggle key press if (Phaser.Input.Keyboard.JustDown(this.hitboxToggleKey)) { this.toggleHitboxes(); } // Check for Pizza Face spawn key press if (Phaser.Input.Keyboard.JustDown(this.pizzaFaceSpawnKey)) { this.spawnPizzaFace(); } // Check for knockback key press if (Phaser.Input.Keyboard.JustDown(this.knockbackKey)) { this.attemptParry(); } // Check for pong game activation if (Phaser.Input.Keyboard.JustDown(this.cursors.up)) { const distance = Phaser.Math.Distance.Between(this.player.x, this.player.y, this.pongSprite.x, this.pongSprite.y); if (distance < 150) { // Increased interaction distance this.startSnakeGame(); } } // Update camera position this.updateCamera(); // Update parry timer if (this.player.parryTimer > 0) { this.player.parryTimer -= delta; if (this.player.parryTimer <= 0) { this.player.canParry = true; this.player.clearTint(); } } } buildLevel(layout) { const tileSize = 32; const scaleFactor = 2; const scaledTileSize = tileSize * scaleFactor; this.levelBlocks = this.physics.add.staticGroup(); // Create the floor const gameHeight = this.sys.game.config.height; const groundHeight = 64; // Height of the ground sprite const raisedGroundY = gameHeight * 0.90; // Move the ground down to 90% of the game height const groundWidth = Math.max(layout[0].length * scaledTileSize, 20000); // Create the visual ground sprite const ground = this.add.tileSprite(groundWidth / 2, gameHeight - groundHeight / 2, groundWidth, groundHeight, 'ground'); ground.setScale(2); // Calculate pit dimensions const stairStartX = 300; // Starting X position of the staircase const stairStartY = raisedGroundY - groundHeight; // Starting Y position of the staircase const stairSteps = 6; // Number of steps in the staircase const stairWidth = 3; // Width of each step in blocks const pitStartX = stairStartX + (stairSteps * stairWidth * scaledTileSize); const pitWidth = 4 * scaledTileSize; // Width of the pit (4 blocks wide) // Create the collision floor with a gap for the pit const leftFloor = this.add.rectangle(0, raisedGroundY, pitStartX, groundHeight); this.physics.add.existing(leftFloor, true); this.levelBlocks.add(leftFloor); const rightFloor = this.add.rectangle(pitStartX + pitWidth, raisedGroundY, groundWidth - (pitStartX + pitWidth), groundHeight); this.physics.add.existing(rightFloor, true); this.levelBlocks.add(rightFloor); // Store the collision floor Y position for player spawning this.collisionFloorY = raisedGroundY - groundHeight / 2; // Create a more structured staircase for (let i = 0; i < stairSteps; i++) { for (let j = 0; j < stairWidth; j++) { const block = this.levelBlocks.create( stairStartX + ((i * stairWidth + j) * scaledTileSize), stairStartY - (i * scaledTileSize), 'block' ); block.setOrigin(0, 1); block.setScale(scaleFactor); block.refreshBody(); } // Add support blocks underneath each step for (let k = 0; k < i; k++) { const supportBlock = this.levelBlocks.create( stairStartX + (i * stairWidth * scaledTileSize), stairStartY - (k * scaledTileSize), 'block' ); supportBlock.setOrigin(0, 1); supportBlock.setScale(scaleFactor); supportBlock.refreshBody(); } } // Create a pit between the staircase and the bridge const pitDepth = 5 * scaledTileSize; // Depth of the pit (5 blocks deep) // Create pit walls const leftPitWall = this.levelBlocks.create( stairStartX + (stairSteps * stairWidth * scaledTileSize), stairStartY, 'block' ); leftPitWall.setOrigin(0, 1); leftPitWall.setScale(scaleFactor, scaleFactor * 5); // Make the wall 5 blocks tall leftPitWall.refreshBody(); const rightPitWall = this.levelBlocks.create( stairStartX + (stairSteps * stairWidth * scaledTileSize) + pitWidth + scaledTileSize, stairStartY, 'block' ); rightPitWall.setOrigin(0, 1); rightPitWall.setScale(scaleFactor, scaleFactor * 5); // Make the wall 5 blocks tall rightPitWall.refreshBody(); // Pit bottom removed // Create a bridge after the pit const bridgeStartX = stairStartX + (stairSteps * stairWidth * scaledTileSize) + pitWidth + scaledTileSize * 2; const bridgeY = stairStartY - (stairSteps * scaledTileSize) + scaledTileSize; const bridgeLength = 10; // Length of the bridge in blocks for (let i = 0; i < bridgeLength; i++) { const bridgeBlock = this.levelBlocks.create( bridgeStartX + (i * scaledTileSize), bridgeY, 'block' ); bridgeBlock.setOrigin(0, 0); bridgeBlock.setScale(scaleFactor); bridgeBlock.refreshBody(); } // Add support pillars for the bridge const pillarSpacing = 3; // Space between pillars in blocks for (let i = 0; i < bridgeLength; i += pillarSpacing) { for (let j = 1; j < (raisedGroundY - bridgeY) / scaledTileSize; j++) { const pillar = this.levelBlocks.create( bridgeStartX + (i * scaledTileSize), bridgeY + (j * scaledTileSize), 'block' ); pillar.setOrigin(0, 0); pillar.setScale(scaleFactor); pillar.refreshBody(); } } // Add pong at the end of the level const pongX = bridgeStartX + (bridgeLength * scaledTileSize) + 300; // Moved 200 pixels further to the right const pongY = raisedGroundY - 24; // Placed 24 pixels above the ground (moved up by 8 pixels) this.pongSprite = this.physics.add.staticImage(pongX, pongY, 'pong'); this.pongSprite.setOrigin(0.5, 1); // Set origin to bottom center this.pongSprite.setScale(0.25); // Adjust scale as needed this.pongSprite.setInteractive(); // Set world bounds const worldWidth = Math.max(groundWidth, pongX + 200); const worldHeight = gameHeight; this.physics.world.setBounds(0, 0, worldWidth, worldHeight); this.cameras.main.setBounds(0, 0, worldWidth, worldHeight); } createPlayer() { const playerSpawnX = 100; const gameHeight = this.sys.game.config.height; const playerSpawnY = this.collisionFloorY - 200; // Spawn player 200 pixels above the collision floor this.player = this.physics.add.sprite(playerSpawnX, playerSpawnY, 'player'); // Revert to the original scale this.player.setScale(2.5); // Set a custom rectangular hitbox for the player const hitboxWidth = this.player.width * 0.6; // 60% of the sprite width const hitboxHeight = this.player.height * 0.8; // 80% of the sprite height this.player.body.setSize(hitboxWidth, hitboxHeight); this.player.body.setOffset((this.player.width - hitboxWidth) / 2, (this.player.height - hitboxHeight) / 2 + 4); // Offset 4 pixels down (3 pixels down from previous) this.player.setBounce(0); this.player.setCollideWorldBounds(false); // Set player physics properties this.player.body.setGravityY(1800); this.player.body.setDragX(500); this.player.isSliding = false; this.player.slideTimer = 0; this.player.isJumping = false; this.player.wasInAir = false; this.player.jumpDirection = null; this.player.isDead = false; this.player.canParry = true; this.player.parryTimer = 0; this.player.parryWindow = 500; // 500ms parry window } isNearGround() { const rayStart = this.player.body.bottom; const rayEnd = rayStart + 5; // Check 5 pixels below the player const bodies = this.physics.overlapRect(this.player.body.left, rayStart, this.player.body.width, rayEnd - rayStart, false, true); return bodies.length > 0; } toggleHitboxes() { this.showHitboxes = !this.showHitboxes; this.hitboxToggleText.setText(`Show Hitboxes: ${this.showHitboxes ? 'ON' : 'OFF'}`); this.physics.world.drawDebug = this.showHitboxes; if (this.showHitboxes) { if (!this.physics.world.debugGraphic) { this.physics.world.createDebugGraphic(); } } else if (this.physics.world.debugGraphic) { this.physics.world.debugGraphic.clear(); } } updateCamera() { const camera = this.cameras.main; const halfWidth = camera.width * 0.5; const halfHeight = camera.height * 0.5; // Calculate the target position const targetX = Math.floor(this.player.x - halfWidth); const targetY = Math.floor(this.player.y - halfHeight - 100); // Offset to show more above the player // Use lerp for smoother camera movement camera.scrollX = Phaser.Math.Linear(camera.scrollX, targetX, 0.1); camera.scrollY = Phaser.Math.Linear(camera.scrollY, targetY, 0.1); } // checkWallCollision method removed createPizzaFace() { // Calculate the spawn position for Pizza Face const spawnX = this.player.x; const spawnY = this.player.y - this.cameras.main.height * 0.3; // Spawn closer to the player // Create the red duplicate sprite this.redPizzaFace = this.add.sprite(spawnX, spawnY, 'pizzaface'); this.redPizzaFace.setScale(0.25); // Adjust scale for the new bread image this.redPizzaFace.setAlpha(0); this.redPizzaFace.setDepth(999); this.redPizzaFace.setTint(0xff0000); // Create the main Pizza Face sprite at the calculated position this.pizzaFace = this.physics.add.sprite(spawnX, spawnY, 'pizzaface'); this.pizzaFace.setScale(0.25); // Adjust scale for the new bread image this.pizzaFace.setAlpha(0); this.pizzaFace.setDepth(1000); // Adjust the Pizza Face hitbox this.pizzaFace.body.setSize(this.pizzaFace.width * 0.7, this.pizzaFace.height * 0.7); this.pizzaFace.body.setOffset(this.pizzaFace.width * 0.15, this.pizzaFace.height * 0.15); // Disable physics on the bread initially this.pizzaFace.body.enable = false; // Initialize position history for the red duplicate this.pizzaFacePositions = []; // Start the fade-in effect this.startFadeInEffect(); // Add a delay before enabling collision this.time.delayedCall(2000, () => { this.pizzaFace.body.enable = true; }); } startFadeInEffect() { this.tweens.add({ targets: [this.pizzaFace, this.redPizzaFace], alpha: { from: 0, to: 1 }, duration: 2000, ease: 'Linear', onComplete: () => { this.redPizzaFace.setAlpha(0.7); this.startContinuousShake(); } }); } startContinuousShake() { this.time.addEvent({ delay: 50, callback: () => { this.cameras.main.shake(50, 0.002); }, loop: true }); } updatePizzaFace() { // Only update bread if it exists, its physics are enabled, and the player is not dead if (!this.pizzaFace || !this.pizzaFace.body || !this.pizzaFace.body.enable || !this.player || !this.player.body || this.player.isDead) return; // Check for collision between bread and the player const distance = Phaser.Math.Distance.Between(this.pizzaFace.x, this.pizzaFace.y, this.player.x, this.player.y); if (distance < 20) { // Use a fixed distance for collision this.playerDeath(); return; // Exit the method early if collision occurs } // Only move bread if it's not stunned if (!this.pizzaFace.stunned) { const speed = 350; // Reduced speed for the larger bread const targetX = this.player.x; const targetY = this.player.y; const angle = Phaser.Math.Angle.Between(this.pizzaFace.x, this.pizzaFace.y, targetX, targetY); const velocityX = Math.cos(angle) * speed; const velocityY = Math.sin(angle) * speed; this.pizzaFace.setVelocity(velocityX, velocityY); } // Store the current position with timestamp this.pizzaFacePositions.push({ x: this.pizzaFace.x, y: this.pizzaFace.y, time: this.time.now }); // Remove positions older than 100 milliseconds while (this.pizzaFacePositions.length > 0 && this.time.now - this.pizzaFacePositions[0].time > 100) { this.pizzaFacePositions.shift(); } // Update the red duplicate's position (100 milliseconds behind) only if the player is not dead if (this.pizzaFacePositions.length > 0 && !this.player.isDead) { const oldPosition = this.pizzaFacePositions[0]; this.redPizzaFace.setPosition(oldPosition.x, oldPosition.y); } // Implement fade out and reappear effect only if the player is not dead if (!this.fadeTimer && !this.player.isDead) { this.fadeTimer = this.time.addEvent({ delay: 1000, // Start a new fade cycle every second callback: this.startFadeEffect, callbackScope: this, loop: true }); } } startFadeEffect() { this.tweens.add({ targets: this.redPizzaFace, alpha: { from: 0.7, // Start from 70% opacity to: 0.3 // Fade to 30% opacity }, duration: 250, // Kept at 250 for faster fade-out ease: 'Linear', yoyo: true, // This will make it fade back to 0.7 repeat: 0, // This will make it only fade out and back in once onComplete: () => { this.redPizzaFace.setAlpha(0.7); // Reset to 70% opacity after the tween } }); } playerDeath() { if (!this.player || this.player.isDead) return; // Prevent multiple death triggers and check if player exists this.player.isDead = true; if (this.player.body) { this.player.setVelocity(0, 0); this.player.body.enable = false; } this.player.setTexture('dead'); if (this.player.anims) { this.player.anims.stop(); // Stop any running animations } // Stop the countdown timer if (this.countdownEvent) { this.countdownEvent.remove(); } // Freeze Pizza Face if (this.pizzaFace && this.pizzaFace.body) { this.pizzaFace.setVelocity(0, 0); this.pizzaFace.body.enable = false; } // Disable player input if (this.cursors) { this.cursors.left.reset(); this.cursors.right.reset(); } if (this.jumpKey) this.jumpKey.reset(); if (this.runKey) this.runKey.reset(); // Reset P Meter if (this.pMeterBars) { this.pMeterBars.forEach(bar => bar.setVisible(false)); } // Stop the fade effect timer if (this.fadeTimer) { this.fadeTimer.remove(); this.fadeTimer = null; } // Fade out Pizza Face sprites if (this.pizzaFace && this.redPizzaFace) { this.tweens.add({ targets: [this.pizzaFace, this.redPizzaFace], alpha: 0, duration: 1000, ease: 'Linear', onComplete: () => { this.pizzaFace.setVisible(false); this.redPizzaFace.setVisible(false); } }); } // Immediate death animation this.tweens.add({ targets: this.player, y: this.player.y - 100, duration: 500, ease: 'Cubic.easeOut', onComplete: () => { // Freeze for 1 second this.time.delayedCall(1000, () => { // Bounce down off the screen this.tweens.add({ targets: this.player, y: this.cameras.main.height + 100, duration: 1000, ease: 'Cubic.easeIn' }); }); } }); // Restart the scene after 5 seconds this.time.delayedCall(5000, () => { this.scene.restart(); }); } updateTimer() { if (!this.timerActive || !this.timerText) return; this.timeLeft--; const minutes = Math.floor(this.timeLeft / 60); const seconds = this.timeLeft % 60; this.timerText.setText(`${minutes}:${seconds < 10 ? '0' : ''}${seconds}`); if (this.timeLeft <= 0) { if (this.countdownEvent) { this.countdownEvent.remove(); } this.spawnPizzaFace(); } } spawnPizzaFace() { if (this.pizzaFace) return; // Don't spawn if Pizza Face already exists this.timerActive = false; if (this.timerText) { this.timerText.setText('Times up!'); } this.createPizzaFace(); } updatePMeter() { if (!this.player || !this.player.body || !this.pMeterBars || this.player.isDead) return; const speed = Math.abs(this.player.body.velocity.x); const baseSpeed = 180; const runningSpeed = 400; const maxSpeed = 600; let filledBars = 0; if (speed >= baseSpeed) { filledBars = 1; if (speed >= runningSpeed) { filledBars = 2; const sprintProgress = (speed - runningSpeed) / (maxSpeed - runningSpeed); filledBars += Math.min(Math.floor(sprintProgress * 3), 3); } } this.pMeterBars.forEach((bar, index) => { bar.setVisible(index < filledBars); }); } triggerPizzaFaceEvents() { this.spawnPizzaFace(); } knockbackPizzaFace() { if (this.pizzaFace && this.pizzaFace.body && this.pizzaFace.body.enable) { // Calculate knockback direction (away from the player) const angle = Phaser.Math.Angle.Between(this.player.x, this.player.y, this.pizzaFace.x, this.pizzaFace.y); const knockbackDistance = 150; // Distance to knock back const knockbackDuration = 300; // Duration of the knockback movement const freezeDuration = 2500; // 2.5 seconds freeze duration // Calculate the target position for the knockback const targetX = this.pizzaFace.x + Math.cos(angle) * knockbackDistance; const targetY = this.pizzaFace.y + Math.sin(angle) * knockbackDistance; // Use a tween for smooth knockback movement this.tweens.add({ targets: this.pizzaFace, x: targetX, y: targetY, duration: knockbackDuration, ease: 'Cubic.out', onComplete: () => { this.pizzaFace.stunned = true; this.pizzaFace.setVelocity(0, 0); // Ensure Pizza Face stops moving // Add a visual indicator for the freeze duration const freezeIndicator = this.add.graphics(); freezeIndicator.lineStyle(4, 0x00ffff, 1); freezeIndicator.strokeCircle(this.pizzaFace.x, this.pizzaFace.y, 40); // Tween for the freeze indicator this.tweens.add({ targets: freezeIndicator, alpha: { from: 1, to: 0 }, duration: freezeDuration, onComplete: () => freezeIndicator.destroy() }); // Clear stun effect and allow movement after freeze duration this.time.delayedCall(freezeDuration, () => { if (this.pizzaFace) { this.pizzaFace.clearTint(); this.pizzaFace.stunned = false; } }); } }); // Add a flash effect this.pizzaFace.setTint(0xFFFFFF); this.tweens.add({ targets: this.pizzaFace, alpha: 0.6, yoyo: true, duration: 100, repeat: 2, onComplete: () => { this.pizzaFace.setTint(0xFF0000); // Set to red tint after flash this.pizzaFace.setAlpha(1); } }); // Add a camera shake effect this.cameras.main.shake(200, 0.005); } } attemptParry() { // Always show a visual indication when parry key is pressed this.player.setTint(0xFFFFFF); // Create a white flash effect around the player const flash = this.add.rectangle(this.player.x, this.player.y, this.player.width * 2, this.player.height * 2, 0xFFFFFF); flash.setAlpha(0.5); this.tweens.add({ targets: flash, alpha: 0, duration: 200, onComplete: () => flash.destroy() }); // Parry logic if (this.player.canParry) { this.player.canParry = false; this.player.parryTimer = this.player.parryWindow; // Check if Pizza Face is close enough to be parried if (this.pizzaFace && this.pizzaFace.body && this.pizzaFace.body.enable) { const distance = Phaser.Math.Distance.Between(this.player.x, this.player.y, this.pizzaFace.x, this.pizzaFace.y); if (distance < 150) { // Lenient parry range this.knockbackPizzaFace(); this.player.setTint(0x00FF00); // Green tint for successful parry // Enhanced camera zoom effect const originalZoom = this.cameras.main.zoom; const maxZoom = 1.3; const maxRotation = 0.1; const zoomInDuration = 100; const zoomOutDuration = 400; this.tweens.add({ targets: this.cameras.main, zoom: maxZoom, rotation: maxRotation, duration: zoomInDuration, ease: 'Cubic.easeIn', onComplete: () => { // Slow zoom out this.tweens.add({ targets: this.cameras.main, zoom: originalZoom, rotation: 0, duration: zoomOutDuration, ease: 'Sine.easeOut' }); } }); // Add a flash effect const flash = this.add.rectangle(0, 0, this.cameras.main.width, this.cameras.main.height, 0xffffff); flash.setScrollFactor(0); flash.setDepth(999); flash.alpha = 0.5; this.tweens.add({ targets: flash, alpha: 0, duration: 200, ease: 'Power2', onComplete: () => { flash.destroy(); } }); } } } // Reset player tint after a short delay this.time.delayedCall(200, () => { this.player.clearTint(); }); } startSnakeGame() { if (this.snakeGameActive) return; this.snakeGameActive = true; // Disable Pizza Face and hide all existing game elements this.hideGameElements(); // Create a black background this.snakeBackground = this.add.rectangle(0, 0, this.cameras.main.width, this.cameras.main.height, 0x000000); this.snakeBackground.setOrigin(0, 0); this.snakeBackground.setScrollFactor(0); this.snakeBackground.setDepth(1000); // Reset camera this.cameras.main.stopFollow(); this.cameras.main.setScroll(0, 0); this.cameras.main.setZoom(1); // Create snake game elements this.cellSize = 20; // Increased cell size for better visibility this.gridWidth = Math.floor(this.cameras.main.width / this.cellSize); this.gridHeight = Math.floor(this.cameras.main.height / this.cellSize); // Initialize snake this.snake = [{ x: 5, y: 5 }, { x: 4, y: 5 }, { x: 3, y: 5 }]; this.direction = 'right'; // Create food this.food = this.spawnFood(); // Add score text this.score = 0; this.scoreText = this.add.text(10, 10, 'Score: 0', { fontSize: '24px', fill: '#fff' }); this.scoreText.setDepth(1001); // Add timer text this.snakeTimeLeft = 30; // 30 seconds timer this.snakeTimerText = this.add.text(this.cameras.main.width - 10, 10, 'Time: 30', { fontSize: '24px', fill: '#fff' }); this.snakeTimerText.setOrigin(1, 0); this.snakeTimerText.setDepth(1001); // Add "quick get the apple!" text this.appleText = this.add.text(this.cameras.main.width / 2, 50, 'Quick, get the apple!', { fontSize: '28px', fill: '#fff' }); this.appleText.setOrigin(0.5); this.appleText.setDepth(1001); // Set up keyboard input this.cursors = this.input.keyboard.createCursorKeys(); // Create graphics object for rendering this.snakeGraphics = this.add.graphics(); this.snakeGraphics.setDepth(1001); // Start game loop this.snakeTimer = this.time.addEvent({ delay: 150, callback: this.updateSnake, callbackScope: this, loop: true }); // Start countdown timer this.snakeCountdownTimer = this.time.addEvent({ delay: 1000, callback: this.updateSnakeTimer, callbackScope: this, loop: true }); // Initial render this.renderSnake(); this.renderFood(); } hideGameElements() { // Hide all existing game elements this.player.setVisible(false); this.player.body.enable = false; this.pMeter.setVisible(false); this.levelBlocks.setVisible(false); if (this.pizzaFace) { this.pizzaFace.setVisible(false); this.pizzaFace.body.enable = false; } if (this.redPizzaFace) { this.redPizzaFace.setVisible(false); } // Hide UI elements this.inputDisplay.setVisible(false); this.fpsText.setVisible(false); this.hitboxToggleText.setVisible(false); this.timerText.setVisible(false); } updateSnake() { if (!this.snakeGameActive) return; // Update direction based on input if (this.cursors.left.isDown && this.direction !== 'right') { this.direction = 'left'; } else if (this.cursors.right.isDown && this.direction !== 'left') { this.direction = 'right'; } else if (this.cursors.up.isDown && this.direction !== 'down') { this.direction = 'up'; } else if (this.cursors.down.isDown && this.direction !== 'up') { this.direction = 'down'; } // Move snake let newHead = { ...this.snake[0] }; switch (this.direction) { case 'left': newHead.x--; break; case 'right': newHead.x++; break; case 'up': newHead.y--; break; case 'down': newHead.y++; break; } // Check for collisions if (this.checkCollision(newHead)) { this.endSnakeGame(false); return; } // Check if snake eats food let foodEaten = false; for (let i = 0; i < this.foods.length; i++) { if (newHead.x === this.foods[i].x && newHead.y === this.foods[i].y) { this.score++; this.scoreText.setText(`Score: ${this.score}`); this.foods.splice(i, 1); // Remove eaten food foodEaten = true; this.showWinMessage(); return; } } // Add new head this.snake.unshift(newHead); // Only remove tail if no food was eaten if (!foodEaten) { this.snake.pop(); } // Spawn new food if (this.foods.length < 5 || Math.random() < 0.1) { // Ensure there's always food, with a chance for more this.spawnFood(); } // Clear previous render and re-render this.snakeGraphics.clear(); this.renderSnake(); this.renderFood(); } spawnFood() { if (!this.foods) { this.foods = []; } let newFood; do { newFood = { x: Math.floor(Math.random() * this.gridWidth), y: Math.floor(Math.random() * this.gridHeight) }; } while ( this.snake.some(segment => segment.x === newFood.x && segment.y === newFood.y) || this.foods.some(food => food.x === newFood.x && food.y === newFood.y) ); this.foods.push(newFood); // Limit the number of foods on screen if (this.foods.length > 5) { this.foods.shift(); } } checkCollision(head) { // Check wall collision if (head.x < 0 || head.x >= this.gridWidth || head.y < 0 || head.y >= this.gridHeight) { return true; } // Check self collision return this.snake.some(segment => segment.x === head.x && segment.y === head.y); } clearSnakeRender() { if (this.snakeGraphics) { this.snakeGraphics.clear(); } else { this.snakeGraphics = this.add.graphics(); } } renderSnake() { this.snakeGraphics.fillStyle(0x00ff00); this.snake.forEach(segment => { this.snakeGraphics.fillRect( segment.x * this.cellSize, segment.y * this.cellSize, this.cellSize - 1, this.cellSize - 1 ); }); } renderFood() { this.snakeGraphics.fillStyle(0xff0000); this.foods.forEach(food => { this.snakeGraphics.fillRect( food.x * this.cellSize, food.y * this.cellSize, this.cellSize - 1, this.cellSize - 1 ); }); } endSnakeGame(win = false) { this.snakeGameActive = false; if (this.snakeTimer) { this.snakeTimer.remove(); } if (this.snakeCountdownTimer) { this.snakeCountdownTimer.remove(); } // Show game over text only if the player didn't win if (!win) { const gameOverText = this.add.text(this.cameras.main.width / 2, this.cameras.main.height / 2, 'Game Over', { fontSize: '48px', fill: '#fff' }); gameOverText.setOrigin(0.5); gameOverText.setDepth(1002); // Return to main game after 3 seconds this.time.delayedCall(3000, () => { gameOverText.destroy(); this.transitionToMainGame(); }); } else { // If the player won, transition immediately this.transitionToMainGame(); } } transitionToMainGame() { if (this.snakeBackground) this.snakeBackground.destroy(); if (this.snakeGraphics) this.snakeGraphics.destroy(); if (this.scoreText) this.scoreText.destroy(); if (this.snakeTimerText) this.snakeTimerText.destroy(); if (this.appleText) this.appleText.destroy(); // Show all game elements again this.player.setVisible(true); this.player.body.enable = true; this.pMeter.setVisible(true); this.levelBlocks.setVisible(true); if (this.pizzaFace) { this.pizzaFace.setVisible(true); this.pizzaFace.body.enable = true; } if (this.redPizzaFace) { this.redPizzaFace.setVisible(true); } // Show UI elements this.inputDisplay.setVisible(true); this.fpsText.setVisible(true); this.hitboxToggleText.setVisible(true); this.timerText.setVisible(true); // Reset camera this.cameras.main.startFollow(this.player); } updateSnakeTimer() { this.snakeTimeLeft--; this.snakeTimerText.setText(`Time: ${this.snakeTimeLeft}`); if (this.snakeTimeLeft <= 0) { this.endSnakeGame(); } } showWinMessage() { this.snakeGameActive = false; if (this.snakeTimer) { this.snakeTimer.remove(); } if (this.snakeCountdownTimer) { this.snakeCountdownTimer.remove(); } const winText = this.add.text(this.cameras.main.width / 2, this.cameras.main.height / 2, 'You Win!', { fontSize: '64px', fill: '#ffffff' }); winText.setOrigin(0.5); winText.setDepth(1002); // Add a scale animation this.tweens.add({ targets: winText, scale: { from: 0, to: 1 }, duration: 1000, ease: 'Bounce' }); // Transition back to the main game after 3 seconds this.time.delayedCall(3000, () => { this.endSnakeGame(true); }); } createClouds() { const numClouds = 25; // Significantly increased initial number of clouds for (let i = 0; i < numClouds; i++) { this.createCloud(); } } createCloud() { const worldWidth = this.physics.world.bounds.width; const worldHeight = this.physics.world.bounds.height; const x = Phaser.Math.Between(0, worldWidth); const y = Phaser.Math.Between(0, worldHeight * 0.7); // Limit clouds to the upper 70% of the level const cloud = this.add.image(x, y, 'cloud'); // Adjust cloud appearance cloud.setAlpha(Phaser.Math.FloatBetween(0.4, 0.7)); const scale = Phaser.Math.FloatBetween(0.8, 1.5); cloud.setScale(scale); // Set cloud movement cloud.speedX = Phaser.Math.FloatBetween(0.05, 0.2) * (Math.random() < 0.5 ? 1 : -1); this.clouds.add(cloud); } updateClouds() { const worldWidth = this.physics.world.bounds.width; const worldHeight = this.physics.world.bounds.height; this.clouds.children.entries.forEach(cloud => { cloud.x += cloud.speedX; // Wrap clouds around the level const buffer = cloud.width * cloud.scaleX; if (cloud.x > worldWidth + buffer) { cloud.x = -buffer; cloud.y = Phaser.Math.Between(0, worldHeight * 0.7); } else if (cloud.x < -buffer) { cloud.x = worldWidth + buffer; cloud.y = Phaser.Math.Between(0, worldHeight * 0.7); } }); // Create new clouds as needed if (this.clouds.children.entries.length < 40 && Math.random() < 0.01) { this.createCloud(); } } } const container = document.getElementById('renderDiv'); const config = { type: Phaser.AUTO, parent: 'renderDiv', scale: { mode: Phaser.Scale.FIT, autoCenter: Phaser.Scale.CENTER_BOTH, }, width: 600, height: 600, pixelArt: true, crisp: true, backgroundColor: '#87CEEB', // Sky blue color physics: { default: 'arcade', arcade: { gravity: { y: 300 }, debug: false, debugShowBody: true, debugShowStaticBody: true } }, scene: [Example] }; window.phaserGame = new Phaser.Game(config);