// 2D Sidescroller. const ASSETS = { // Do not change the Format of this section - it is designed to be user readable. sprites: [{ key: 'idle_sprites', url: 'https://play.rosebud.ai/assets/IdleSprites.png?CucG' }, { key: 'move_sprites', url: 'https://play.rosebud.ai/assets/MoveSprites.png?sI5q' }, { key: 'idle_crouch_sprites', url: 'https://play.rosebud.ai/assets/IdleCrouchSprites.png?7BFR' }, { key: 'move_crouch_sprites', url: 'https://play.rosebud.ai/assets/MoveCrouchSprites.png?nUOA' }, { key: 'jump_sprites', url: 'https://play.rosebud.ai/assets/JumpSprites.png?C4Ad' }], collisionSprites: [{ key: 'idle_collisions', url: 'https://play.rosebud.ai/assets/IdlesCols.png?SmWE' }, { key: 'move_collisions', url: 'https://play.rosebud.ai/assets/MoveCols.png?2l9H' }, { key: 'idle_crouch_collisions', url: 'https://play.rosebud.ai/assets/IdleCrouchCols.png?agGa' }, { key: 'move_crouch_collisions', url: 'https://play.rosebud.ai/assets/MoveCrouchCols.png?dkjD' }, { key: 'jump_collisions', url: 'https://play.rosebud.ai/assets/JumpCols.png?fBzV' }], images: [{ key: 'orchard_bkgrnd', url: 'https://play.rosebud.ai/assets/night_02.png?YbI7' }], sounds: [{ key: 'walk_sfx', url: 'https://play.rosebud.ai/assets/walk-sfx.wav?e4DT' }, { key: 'sprint_sfx', url: 'https://play.rosebud.ai/assets/sprint-sfx.wav?GJEt' }, { key: 'jump_sfx', url: 'https://play.rosebud.ai/assets/jump-sfx.wav?nqlC' }, { key: 'landing_sfx', url: 'https://play.rosebud.ai/assets/landing-sfx.wav?QwMg' }, { key: 'dash_sfx', url: 'https://play.rosebud.ai/assets/dash-sfx.wav?Sg0J' }, { key: 'turnaround_sfx', url: 'https://play.rosebud.ai/assets/turnaround-sfx.wav?fWyn' }] } class Player { constructor(scene, x, y) { this.scene = scene; this.collisionRects = scene.collisionRects; this.sprite = scene.physics.add.sprite(x, y, 'idle_sprites'); this.sprite.setCollideWorldBounds(true); this.facing = 'right'; // Define states this.states = { IDLE: 'idle', IDLE_BLINK: 'idle_blink', MOVING: 'moving', JUMP: 'jump', JUMPING: 'jumping', FALLING: 'falling', SPRINTING: 'sprinting', SPRINT_JUMP: 'sprint_jump', DOUBLE_JUMP: 'double_jump', CROUCHING: 'crouching', CROUCH_MOVING: 'crouch_moving', // New state for moving while crouched SLIDING: 'sliding' }; // Initialize current state this.currentState = this.states.IDLE; // Add double jump property this.canDoubleJump = false; // Add air control properties this.normalAirControlSpeed = 250; this.sprintAirControlSpeed = 340; // Higher air control speed for sprint jump // Set fall gravity multiplier this.fallGravityMultiplier = 2.2; // Add acceleration properties this.acceleration = 20; this.airAcceleration = 60; this.directionChangeAcceleration = 40; this.deceleration = 40; this.airDeceleration = 10; this.maxSpeed = 240; this.sprintMaxSpeed = 320; this.crouchMaxSpeed = 120; this.slideSpeed = 400; this.slideFriction = 5; // Add terminal velocity this.terminalVelocity = 700; // Add property to track last movement direction this.lastMovementDirection = 0; // 0 for none, -1 for left, 1 for right // Add coyote time properties this.coyoteTime = 150; this.coyoteTimer = null; this.isInCoyoteTime = false; this.lastGroundedTime = 0; // Add path tracing this.path = []; this.pathGraphics = scene.add.graphics(); // Add variable jump properties this.jumpStartTime = 0; this.isJumping = false; this.maxJumpDuration = 300; this.initialJumpVelocity = -400; this.minJumpVelocity = -200; // Add jump buffer properties this.jumpBufferTime = 150; this.jumpBufferTimer = null; this.jumpBuffered = false; // Add crouching property this.isCrouching = false; // Add sliding property this.isSliding = false; this.slideStartTime = 0; this.maxSlideDuration = 600; // Sound properties this.walkSound = null; this.sprintSound = null; this.jumpSound = null; this.landingSound = null; this.dashSound = null; this.turnaroundSound = null; this.lastPlayedStepSound = 0; this.stepSoundInterval = 250; this.currentMovementSound = null; // Add property to track if player is in double jump state this.isDoubleJumping = false; } create() { this.scene.physics.add.collider(this.sprite, this.scene.world.floor); this.scene.physics.add.collider(this.sprite, this.scene.world.platforms); this.scene.physics.add.collider(this.sprite, this.scene.world.movingPlatform); this.sprite.setGravityY(800); this.sprite.setBounce(0); this.sprite.setScale(2); this.onEnterState(this.states.IDLE); // Initialize sounds this.walkSound = this.scene.sound.add('walk_sfx', { loop: true }); this.sprintSound = this.scene.sound.add('sprint_sfx', { loop: true }); this.jumpSound = this.scene.sound.add('jump_sfx'); this.landingSound = this.scene.sound.add('landing_sfx'); this.dashSound = this.scene.sound.add('dash_sfx'); this.turnaroundSound = this.scene.sound.add('turnaround_sfx'); window.logger.log('Player', 'Player successfully created, initialized, scaled, and FSM set up', 'Creation'); } update(cursors) { this.updateCollisionBox(); const onGround = this.sprite.body.touching.down; const moveLeft = cursors.left.isDown; const moveRight = cursors.right.isDown; const jumpJustPressed = Phaser.Input.Keyboard.JustDown(cursors.space); const jumpReleased = Phaser.Input.Keyboard.JustUp(cursors.space); const jumpHeld = cursors.space.isDown; const sprint = cursors.shift.isDown; const crouch = cursors.down.isDown; // Handle coyote time if (onGround) { this.lastGroundedTime = this.scene.time.now; this.isInCoyoteTime = false; if (this.coyoteTimer) { this.coyoteTimer.remove(); this.coyoteTimer = null; } } else if (!this.isInCoyoteTime && this.scene.time.now - this.lastGroundedTime <= this.coyoteTime) { this.isInCoyoteTime = true; this.coyoteTimer = this.scene.time.delayedCall(this.coyoteTime, () => { this.isInCoyoteTime = false; this.coyoteTimer = null; }); } // Reset double jump when on ground or during coyote time if (onGround || this.isInCoyoteTime) { this.canDoubleJump = this.scene.doubleJumpEnabled; this.isDoubleJumping = false; } // Apply fall gravity if (this.sprite.body.velocity.y > 0 && !this.isInCoyoteTime) { this.sprite.setGravityY(600 * this.fallGravityMultiplier); } else { this.sprite.setGravityY(600); } // Apply terminal velocity if (this.sprite.body.velocity.y > this.terminalVelocity) { this.sprite.setVelocityY(this.terminalVelocity); } // Handle jump buffer if (jumpJustPressed) { this.jumpBuffered = true; this.jumpBufferTimer = this.scene.time.delayedCall(this.jumpBufferTime, () => { this.jumpBuffered = false; }); } // Handle variable jump if ((jumpJustPressed || (this.jumpBuffered && onGround)) && (onGround || this.isInCoyoteTime) && !this.isCrouching && !this.isSliding) { this.startJump(); this.jumpBuffered = false; } else if (jumpJustPressed && this.canDoubleJump && this.scene.doubleJumpEnabled && !this.isCrouching && !this.isSliding) { this.startDoubleJump(); } if (this.isJumping) { if (jumpHeld) { this.continueJump(); } else { this.endJump(); } } // Handle crouching and sliding if (crouch) { if (onGround) { if (this.currentState === this.states.SPRINTING && !this.isSliding) { this.startSlide(); } else if (!this.isSliding) { this.isCrouching = true; } } } else { this.isCrouching = false; if (this.isSliding) { this.endSlide(); } } // Update facing direction based on movement if (moveLeft && !moveRight) { this.facing = 'left'; } else if (moveRight && !moveLeft) { this.facing = 'right'; } // Determine new state let newState = this.currentState; if (onGround || this.isInCoyoteTime) { if (this.isSliding) { newState = this.states.SLIDING; } else if (this.isCrouching) { newState = (moveLeft || moveRight) ? this.states.CROUCH_MOVING : this.states.CROUCHING; } else if (this.isJumping) { newState = sprint ? this.states.SPRINT_JUMP : this.states.JUMP; } else if ((moveLeft || moveRight) && sprint) { newState = this.states.SPRINTING; } else if (moveLeft || moveRight) { newState = this.states.MOVING; } else { newState = this.states.IDLE; } } else { if (this.isJumping) { newState = this.states.JUMPING; } else if (this.sprite.body.velocity.y >= 0) { newState = this.states.FALLING; } } // State transition if (newState !== this.currentState) { window.logger.log('Player', `State transition: ${this.currentState} -> ${newState}`, 'States'); this.onExitState(this.currentState); this.onEnterState(newState); this.currentState = newState; } // State actions this.executeStateAction(cursors); // Update path tracing if (this.scene.tracedPathEnabled) { this.updatePath(); } else { this.pathGraphics.clear(); } // Play movement sounds this.playMovementSounds(onGround, moveLeft, moveRight, sprint); } onEnterState(state) { window.logger.log('Player', `Entering state: ${state}`, 'States'); switch (state) { case this.states.IDLE: const idleAnim = `idle_${this.facing}`; this.sprite.play(idleAnim, true); break; case this.states.IDLE_BLINK: const blinkAnim = `idle_${this.facing}_blink`; this.sprite.play(blinkAnim, true); window.logger.log('Player', 'Blinking animation triggered', 'Animation'); break; case this.states.MOVING: this.sprite.play(`move_${this.facing}`, true); break; case this.states.SPRINTING: this.sprite.play(`sprint_${this.facing}`, true); break; case this.states.JUMP: case this.states.SPRINT_JUMP: this.sprite.play(`jump_${this.facing}`, true); this.isInCoyoteTime = false; if (this.coyoteTimer) { this.coyoteTimer.remove(); this.coyoteTimer = null; } this.jumpSound.play(); break; case this.states.DOUBLE_JUMP: this.sprite.play(`jump_${this.facing}`, true); this.canDoubleJump = false; this.isDoubleJumping = true; this.jumpSound.play(); break; case this.states.JUMPING: this.sprite.play(`jumping_${this.facing}`, true); break; case this.states.FALLING: this.sprite.play(`falling_${this.facing}`, true); break; case this.states.CROUCHING: this.sprite.play(`idle_crouch_${this.facing}`, true); break; case this.states.CROUCH_MOVING: this.sprite.play(`move_crouch_${this.facing}`, true); break; case this.states.SLIDING: this.sprite.play(`move_crouch_${this.facing}`, true); break; } } onExitState(state) { // Add any cleanup logic here if needed if (state === this.states.FALLING && !this.isDoubleJumping) { this.landingSound.play(); } } executeStateAction(cursors) { switch (this.currentState) { case this.states.IDLE: this.applyDeceleration(); this.sprite.once('animationcomplete', () => { if (Math.random() < 0.2) { // 20% chance to blink this.currentState = this.states.IDLE_BLINK; this.onEnterState(this.states.IDLE_BLINK); } }); break; case this.states.IDLE_BLINK: this.applyDeceleration(); this.sprite.once('animationcomplete', () => { this.currentState = this.states.IDLE; this.onEnterState(this.states.IDLE); }); break; case this.states.MOVING: this.applyAcceleration(cursors, this.maxSpeed); break; case this.states.SPRINTING: this.applyAcceleration(cursors, this.sprintMaxSpeed); break; case this.states.JUMP: case this.states.SPRINT_JUMP: case this.states.DOUBLE_JUMP: this.sprite.play(`jump_${this.facing}`, true); this.sprite.once('animationcomplete', () => { this.currentState = this.states.JUMPING; this.onEnterState(this.states.JUMPING); }); this.applyAirControl(cursors, this.normalAirControlSpeed); break; case this.states.JUMPING: if (this.sprite.body.velocity.y >= 0) { this.currentState = this.states.FALLING; this.onEnterState(this.states.FALLING); } this.applyAirControl(cursors, this.normalAirControlSpeed); break; case this.states.FALLING: if (this.sprite.body.touching.down) { this.currentState = this.states.IDLE; this.onEnterState(this.states.IDLE); } else { this.applyAirControl(cursors, this.normalAirControlSpeed); } break; case this.states.CROUCHING: this.applyDeceleration(); break; case this.states.CROUCH_MOVING: this.applyAcceleration(cursors, this.crouchMaxSpeed); break; case this.states.SLIDING: this.applySliding(); break; } } applyAirControl(cursors, airControlSpeed) { let currentDirection = 0; if (cursors.left.isDown) { currentDirection = -1; } else if (cursors.right.isDown) { currentDirection = 1; } // Check if direction has changed const isChangingDirection = (this.lastMovementDirection !== 0 && currentDirection !== 0 && this.lastMovementDirection !== currentDirection); const accelerationToUse = isChangingDirection ? this.directionChangeAcceleration : this.airAcceleration; if (currentDirection !== 0) { // If changing direction, immediately set the velocity to a small value in the new direction if (isChangingDirection) { this.sprite.setVelocityX(currentDirection * 50); // Small initial velocity in the new direction this.turnaroundSound.play(); } const newVelocity = this.sprite.body.velocity.x + (currentDirection * accelerationToUse); this.sprite.setVelocityX(Phaser.Math.Clamp(newVelocity, -airControlSpeed, airControlSpeed)); // Update facing direction immediately this.facing = currentDirection === -1 ? 'left' : 'right'; // Update animation immediately const animationKey = `jumping_${this.facing}`; if (this.sprite.anims.currentAnim.key !== animationKey) { this.sprite.play(animationKey, true); } } else { this.applyAirDeceleration(); } // Update last movement direction this.lastMovementDirection = currentDirection; } applyAcceleration(cursors, maxSpeed) { let currentDirection = 0; if (cursors.left.isDown) { currentDirection = -1; } else if (cursors.right.isDown) { currentDirection = 1; } // Check if direction has changed and player is sprinting const isChangingDirection = (this.lastMovementDirection !== 0 && currentDirection !== 0 && this.lastMovementDirection !== currentDirection); const isSprinting = this.currentState === this.states.SPRINTING; const isCrouching = this.currentState === this.states.CROUCHING || this.currentState === this.states.CROUCH_MOVING; const accelerationToUse = isChangingDirection ? this.directionChangeAcceleration : this.acceleration; if (currentDirection !== 0) { // If changing direction, immediately set the velocity to a small value in the new direction if (isChangingDirection) { this.sprite.setVelocityX(currentDirection * 50); // Small initial velocity in the new direction if (isSprinting) { this.turnaroundSound.play(); } } const newVelocity = this.sprite.body.velocity.x + (currentDirection * accelerationToUse); this.sprite.setVelocityX(Phaser.Math.Clamp(newVelocity, -maxSpeed, maxSpeed)); // Update facing direction immediately this.facing = currentDirection === -1 ? 'left' : 'right'; // Update animation immediately let animationKey; if (isCrouching) { animationKey = `move_crouch_${this.facing}`; } else if (isSprinting) { animationKey = `sprint_${this.facing}`; } else { animationKey = `move_${this.facing}`; } if (this.sprite.anims.currentAnim.key !== animationKey) { this.sprite.play(animationKey, true); } } else { this.applyDeceleration(); } // Update last movement direction this.lastMovementDirection = currentDirection; } applyDeceleration() { if (this.sprite.body.velocity.x > 0) { this.sprite.setVelocityX(Math.max(this.sprite.body.velocity.x - this.deceleration, 0)); } else if (this.sprite.body.velocity.x < 0) { this.sprite.setVelocityX(Math.min(this.sprite.body.velocity.x + this.deceleration, 0)); } } applyAirDeceleration() { if (this.sprite.body.velocity.x > 0) { this.sprite.setVelocityX(Math.max(this.sprite.body.velocity.x - this.airDeceleration, 0)); } else if (this.sprite.body.velocity.x < 0) { this.sprite.setVelocityX(Math.min(this.sprite.body.velocity.x + this.airDeceleration, 0)); } } updateCollisionBox() { const currentAnim = this.sprite.anims.currentAnim; if (!currentAnim) return; const animKey = currentAnim.key; const frameIndex = this.sprite.anims.currentFrame.index; // Map animation keys to collision keys const collisionKeyMap = { 'idle_left': 'idle_collisions', 'idle_right': 'idle_collisions', 'move_left': 'move_collisions', 'move_right': 'move_collisions', 'jump_left': 'jump_collisions', 'jump_right': 'jump_collisions', 'falling_left': 'jump_collisions', 'falling_right': 'jump_collisions', 'sprint_left': 'move_collisions', 'sprint_right': 'move_collisions', 'idle_crouch_left': 'idle_crouch_collisions', 'idle_crouch_right': 'idle_crouch_collisions', 'move_crouch_left': 'move_crouch_collisions', 'move_crouch_right': 'move_crouch_collisions' }; const collisionKey = collisionKeyMap[animKey]; // Adjust the frameIndex by subtracting 1, but ensure it's not negative const adjustedFrameIndex = Math.max(0, frameIndex - 1); if (collisionKey && this.collisionRects[collisionKey] && this.collisionRects[collisionKey][adjustedFrameIndex]) { const rect = this.collisionRects[collisionKey][adjustedFrameIndex]; this.sprite.body.setSize(rect.width, rect.height); this.sprite.body.setOffset(rect.x, rect.y); } } updatePath() { // Add current position to the path this.path.push({ x: this.sprite.x, y: this.sprite.y }); // Limit the path length to prevent performance issues if (this.path.length > 200) { this.path.shift(); } // Clear previous path this.pathGraphics.clear(); // Draw new path this.pathGraphics.lineStyle(2, 0xff0000, 1); this.pathGraphics.beginPath(); for (let i = 0; i < this.path.length; i++) { const point = this.path[i]; if (i === 0) { this.pathGraphics.moveTo(point.x, point.y); } else { this.pathGraphics.lineTo(point.x, point.y); } } this.pathGraphics.strokePath(); } startJump() { this.isJumping = true; this.jumpStartTime = this.scene.time.now; this.sprite.setVelocityY(this.initialJumpVelocity); this.jumpSound.play(); } startDoubleJump() { this.isJumping = true; this.jumpStartTime = this.scene.time.now; this.sprite.setVelocityY(this.initialJumpVelocity * 0.8); // Slightly weaker double jump this.canDoubleJump = false; this.isDoubleJumping = true; this.jumpSound.play(); } continueJump() { const jumpDuration = this.scene.time.now - this.jumpStartTime; if (jumpDuration < this.maxJumpDuration) { const jumpForce = Phaser.Math.Linear(this.initialJumpVelocity, this.minJumpVelocity, jumpDuration / this.maxJumpDuration); this.sprite.setVelocityY(jumpForce); } else { this.endJump(); } } endJump() { this.isJumping = false; if (this.sprite.body.velocity.y < this.minJumpVelocity) { this.sprite.setVelocityY(this.minJumpVelocity); } } startSlide() { if (!this.isSliding) { this.isSliding = true; this.slideStartTime = this.scene.time.now; const slideDirection = this.facing === 'right' ? 1 : -1; this.sprite.setVelocityX(this.slideSpeed * slideDirection); this.dashSound.play(); } } applySliding() { const slideDuration = this.scene.time.now - this.slideStartTime; if (slideDuration < this.maxSlideDuration) { // Apply friction to gradually slow down the slide const currentVelocity = this.sprite.body.velocity.x; const newVelocity = currentVelocity > 0 ? Math.max(currentVelocity - this.slideFriction, 0) : Math.min(currentVelocity + this.slideFriction, 0); this.sprite.setVelocityX(newVelocity); // Decelerate into crouch speed const slideProgress = slideDuration / this.maxSlideDuration; const targetSpeed = Phaser.Math.Linear(this.slideSpeed, this.crouchMaxSpeed, slideProgress); const clampedVelocity = Phaser.Math.Clamp(newVelocity, -targetSpeed, targetSpeed); this.sprite.setVelocityX(clampedVelocity); } else { this.endSlide(); } } endSlide() { this.isSliding = false; this.isCrouching = true; this.currentState = this.states.CROUCH_MOVING; this.onEnterState(this.states.CROUCH_MOVING); // Set the velocity to crouch speed in the current direction const direction = this.facing === 'right' ? 1 : -1; this.sprite.setVelocityX(this.crouchMaxSpeed * direction); } playMovementSounds(onGround, moveLeft, moveRight, sprint) { if (onGround && (moveLeft || moveRight) && !this.isSliding && !this.isCrouching) { const soundToPlay = sprint ? this.sprintSound : this.walkSound; // If the player changed direction or speed, stop the current sound and play the new one if (this.currentMovementSound && this.currentMovementSound !== soundToPlay) { this.currentMovementSound.stop(); } if (!soundToPlay.isPlaying) { soundToPlay.play(); this.currentMovementSound = soundToPlay; } } else { // If the player stopped moving, is in the air, sliding, or crouching, stop the movement sound if (this.currentMovementSound) { this.currentMovementSound.stop(); this.currentMovementSound = null; } } } } class GameLoop extends Phaser.Scene { constructor() { super(); this.currentScene = null; this.world = null; this.player = null; this.cursors = null; this.doubleJumpEnabled = true; this.collisionBoxEnabled = true; this.tracedPathEnabled = true; } preload() { this.loadAssets(); } loadAssets() { let assetCount = 0; // Load all sprites as spritesheets ASSETS.sprites.forEach(sprite => { this.load.spritesheet(sprite.key, sprite.url, { frameWidth: 32, frameHeight: 32 }); assetCount++; }); // Load collision sprites as images ASSETS.collisionSprites.forEach(sprite => { this.load.image(sprite.key, sprite.url); assetCount++; }); // Load images ASSETS.images.forEach(image => { this.load.image(image.key, image.url); assetCount++; }); // Load sound effects ASSETS.sounds.forEach(sound => { this.load.audio(sound.key, sound.url); assetCount++; }); this.load.on('complete', () => { window.logger.log('GameLoop', `Finished loading ${assetCount} assets`, 'Loaded'); }); } create() { window.logger.printLogs(); this.createAnimations(); // Create the world this.world = new World(this); this.world.create(); // Create the player this.player = new Player(this, 100, 450); this.player.create(); // Setup input this.setupInput(); // Create UI buttons this.createButtons(); window.logger.log('GameLoop', 'World and Player created in GameLoop', 'Creation'); } update() { if (this.world) { this.world.update(); } if (this.player && this.cursors) { this.player.update(this.cursors); } // Update collision box visibility this.physics.world.debugGraphic.clear(); if (this.collisionBoxEnabled) { this.physics.world.drawDebug = true; } else { this.physics.world.drawDebug = false; } } setupInput() { this.cursors = this.input.keyboard.createCursorKeys(); this.cursors.left = this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.A); this.cursors.down = this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.S); this.cursors.right = this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.D); this.cursors.space = this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.SPACE); this.cursors.shift = this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.SHIFT); } createButtons() { const buttonStyle = { fontSize: '16px', fill: '#fff', backgroundColor: '#333', padding: { x: 10, y: 5 } }; this.doubleJumpButton = this.add.text(10, 10, 'Double Jump: ON', buttonStyle) .setInteractive() .on('pointerdown', () => this.toggleDoubleJump()); this.collisionBoxButton = this.add.text(10, 50, 'Collision Box: ON', buttonStyle) .setInteractive() .on('pointerdown', () => this.toggleCollisionBox()); this.tracedPathButton = this.add.text(10, 90, 'Traced Path: ON', buttonStyle) .setInteractive() .on('pointerdown', () => this.toggleTracedPath()); } toggleDoubleJump() { this.doubleJumpEnabled = !this.doubleJumpEnabled; this.doubleJumpButton.setText(`Double Jump: ${this.doubleJumpEnabled ? 'ON' : 'OFF'}`); } toggleCollisionBox() { this.collisionBoxEnabled = !this.collisionBoxEnabled; this.collisionBoxButton.setText(`Collision Box: ${this.collisionBoxEnabled ? 'ON' : 'OFF'}`); } toggleTracedPath() { this.tracedPathEnabled = !this.tracedPathEnabled; this.tracedPathButton.setText(`Traced Path: ${this.tracedPathEnabled ? 'ON' : 'OFF'}`); if (!this.tracedPathEnabled) { this.player.pathGraphics.clear(); } } createAnimations() { this.collisionRects = this.getCollisions(); this.anims.create({ key: 'idle_right_blink', frames: this.anims.generateFrameNumbers('idle_sprites', { start: 0, end: 3 }), frameRate: 4, repeat: -1 }); this.anims.create({ key: 'idle_left_blink', frames: this.anims.generateFrameNumbers('idle_sprites', { start: 4, end: 7 }), frameRate: 4, repeat: -1 }); this.anims.create({ key: 'idle_right', frames: this.anims.generateFrameNumbers('idle_sprites', { start: 8, end: 11 }), frameRate: 4, repeat: -1 }); this.anims.create({ key: 'idle_left', frames: this.anims.generateFrameNumbers('idle_sprites', { start: 12, end: 15 }), frameRate: 4, repeat: -1 }); // Add move animations this.anims.create({ key: 'move_right', frames: this.anims.generateFrameNumbers('move_sprites', { start: 0, end: 3 }), frameRate: 4, repeat: -1 }); this.anims.create({ key: 'move_left', frames: this.anims.generateFrameNumbers('move_sprites', { start: 4, end: 7 }), frameRate: 4, repeat: -1 }); // Sprint animations this.anims.create({ key: 'sprint_right', frames: this.anims.generateFrameNumbers('move_sprites', { start: 0, end: 3 }), frameRate: 8, repeat: -1 }); this.anims.create({ key: 'sprint_left', frames: this.anims.generateFrameNumbers('move_sprites', { start: 4, end: 7 }), frameRate: 8, repeat: -1 }); // Jump animations this.anims.create({ key: 'jump_right', frames: this.anims.generateFrameNumbers('jump_sprites', { start: 0, end: 3 }), frameRate: 4, repeat: 0 }); this.anims.create({ key: 'jump_left', frames: this.anims.generateFrameNumbers('jump_sprites', { start: 4, end: 7 }), frameRate: 4, repeat: 0 }); this.anims.create({ key: 'jumping_right', frames: [{ key: 'jump_sprites', frame: 8 }], frameRate: 4, repeat: 0 }); this.anims.create({ key: 'jumping_left', frames: [{ key: 'jump_sprites', frame: 12 }], frameRate: 4, repeat: 0 }); this.anims.create({ key: 'falling_right', frames: [{ key: 'jump_sprites', frame: 16 }], frameRate: 4, repeat: 0 }); this.anims.create({ key: 'falling_left', frames: [{ key: 'jump_sprites', frame: 20 }], frameRate: 4, repeat: 0 }); // Idle crouch animations this.anims.create({ key: 'idle_crouch_right', frames: this.anims.generateFrameNumbers('idle_crouch_sprites', { start: 0, end: 3 }), frameRate: 4, repeat: -1 }); this.anims.create({ key: 'idle_crouch_left', frames: this.anims.generateFrameNumbers('idle_crouch_sprites', { start: 4, end: 7 }), frameRate: 4, repeat: -1 }); // Move crouch animations this.anims.create({ key: 'move_crouch_right', frames: this.anims.generateFrameNumbers('move_crouch_sprites', { start: 0, end: 3 }), frameRate: 4, repeat: -1 }); this.anims.create({ key: 'move_crouch_left', frames: this.anims.generateFrameNumbers('move_crouch_sprites', { start: 4, end: 7 }), frameRate: 4, repeat: -1 }); } getCollisions() { const collisionRects = {}; const collisionKeys = ['idle_collisions', 'move_collisions', 'jump_collisions', 'idle_crouch_collisions', 'move_crouch_collisions']; const frameWidth = 32; const frameHeight = 32; collisionKeys.forEach(key => { const texture = this.textures.get(key); const sourceImage = texture.getSourceImage(); const framesHorizontal = sourceImage.width / frameWidth; const framesVertical = sourceImage.height / frameHeight; collisionRects[key] = []; for (let y = 0; y < framesVertical; y++) { for (let x = 0; x < framesHorizontal; x++) { const canvas = document.createElement('canvas'); const ctx = canvas.getContext('2d'); canvas.width = frameWidth; canvas.height = frameHeight; ctx.drawImage(sourceImage, x * frameWidth, y * frameHeight, frameWidth, frameHeight, 0, 0, frameWidth, frameHeight); const imageData = ctx.getImageData(0, 0, frameWidth, frameHeight); const data = imageData.data; let left = frameWidth, right = 0, top = frameHeight, bottom = 0; for (let py = 0; py < frameHeight; py++) { for (let px = 0; px < frameWidth; px++) { const alpha = data[(py * frameWidth + px) * 4 + 3]; if (alpha > 0) { left = Math.min(left, px); right = Math.max(right, px); top = Math.min(top, py); bottom = Math.max(bottom, py); } } } collisionRects[key].push({ x: left, y: top, width: right - left + 1, height: bottom - top + 1 }); } } }); return collisionRects; } } class Logger { constructor(logInterval = 5000, logLimit = 6000) { this.logs = {}; this.logInterval = logInterval; this.lastLogTime = Date.now(); this.colors = { 'Player': '#FF6B6B', 'CurrentScene': '#4ECDC4', 'Enemies': '#45B7D1', 'GameLoop': '#FFA07A', 'UI': '#98D8C8', 'Combat': '#32CD32', }; this.defaultColor = '#808080'; this.logLimit = logLimit; this.logCount = 0; } log(type, message, subcategory = 'General') { if (!this.logs[type]) { this.logs[type] = {}; } if (!this.logs[type][subcategory]) { this.logs[type][subcategory] = []; } this.logs[type][subcategory].push({ timestamp: Date.now(), message: message }); if (Date.now() - this.lastLogTime >= this.logInterval) { this.printLogs(); } } printLogs() { const currentTime = Date.now(); const formatTime = (timestamp) => { const date = new Date(timestamp); return date.toLocaleTimeString('en-US', { hour12: true }); }; if (this.logCount >= this.logLimit) { console.clear(); this.logCount = 0; console.log('%cConsole cleared due to log limit reached', 'color: #FF0000; font-weight: bold;'); } console.group(`%cLogs (${formatTime(this.lastLogTime)} - ${formatTime(currentTime)})`, 'color: #00008B; font-weight: bold;'); for (const [type, subcategories] of Object.entries(this.logs)) { const color = this.colors[type] || this.defaultColor; const totalLogs = Object.values(subcategories).reduce((sum, logs) => sum + logs.length, 0); console.groupCollapsed(`%c${type} (${totalLogs})`, `color: ${color}; font-weight: bold;`); for (const [subcategory, logs] of Object.entries(subcategories)) { if (logs.length > 0) { console.groupCollapsed(`%c${subcategory} (${logs.length})`, `color: ${color}; font-weight: normal;`); logs.forEach(log => { console.log(`%c[${formatTime(log.timestamp)}] ${log.message}`, `color: ${color};`); this.logCount++; }); console.groupEnd(); } } console.groupEnd(); } console.groupEnd(); this.logs = {}; this.lastLogTime = currentTime; } } class World { constructor(scene) { this.scene = scene; this.floor = null; this.platforms = null; this.movingPlatform = null; } create() { // Create a static floor using a rectangle this.floor = this.scene.add.rectangle(400, 580, 800, 40, 0x4CAF50); // Enable physics for the floor this.scene.physics.add.existing(this.floor, true); // true makes it static // Create platforms this.platforms = this.scene.physics.add.staticGroup(); // Add two floating platforms this.platforms.create(200, 400, 'platform').setScale(2).refreshBody(); this.platforms.create(600, 500, 'platform').setScale(2).refreshBody(); // Create the moving platform this.movingPlatform = this.scene.physics.add.image(400, 200, 'platform'); this.movingPlatform.setImmovable(true); this.movingPlatform.body.allowGravity = false; this.movingPlatform.setScale(2); // Set the scale to match the stationary platforms this.movingPlatform.refreshBody(); // Refresh the physics body after scaling this.movingPlatform.setVelocityX(100); // Set initial velocity // Log the creation of the world window.logger.log('World', 'World created with collidable floor, platforms, and moving platform', 'Creation'); } update() { // Move the platform back and forth if (this.movingPlatform.x > 700) { this.movingPlatform.setVelocityX(-100); } else if (this.movingPlatform.x < 100) { this.movingPlatform.setVelocityX(100); } } } const container = document.getElementById('renderDiv'); const config = { type: Phaser.AUTO, parent: 'renderDiv', pixelArt: true, scale: { mode: Phaser.Scale.FIT, autoCenter: Phaser.Scale.CENTER_BOTH, }, width: 800, height: 600, physics: { default: 'arcade', arcade: { gravity: { y: 200 }, debug: true } }, scene: GameLoop }; // Initialize the logger before creating the Phaser game instance window.logger = new Logger(5000); window.phaserGame = new Phaser.Game(config);