class TitleScreen extends Phaser.Scene { constructor() { super({ key: 'TitleScreen' }); } preload() { this.load.audio('titleMusic', 'https://play.rosebud.ai/assets/UO main.mp3?sOY8'); this.load.image('darkMage', 'https://play.rosebud.ai/assets/darkMage.png?7mJ5'); this.load.image('uoTitle', 'https://play.rosebud.ai/assets/UO title.JPG?G3Xk'); } create() { // Play title music this.titleMusic = this.sound.add('titleMusic', { loop: true, volume: 0.5 }); this.titleMusic.play(); // Add UO title background const background = this.add.image(0, 0, 'uoTitle'); background.setOrigin(0, 0); // Scale the background to fit the screen while maintaining aspect ratio const scaleX = this.cameras.main.width / background.width; const scaleY = this.cameras.main.height / background.height; const scale = Math.max(scaleX, scaleY); background.setScale(scale); // Center the background background.x = (this.cameras.main.width - background.displayWidth) / 2; background.y = (this.cameras.main.height - background.displayHeight) / 2; // Add dark overlay for better text visibility const overlay = this.add.rectangle(0, 0, this.cameras.main.width, this.cameras.main.height, 0x000000, 0.5); overlay.setOrigin(0, 0); // Add decorative top line const lineTop = this.add.rectangle(this.cameras.main.width / 2, 80, 600, 4, 0xc4a484); const lineBottom = this.add.rectangle(this.cameras.main.width / 2, 220, 600, 4, 0xc4a484); // Add title text with medieval style const title = this.add.text(this.cameras.main.width / 2, 150, 'ULTIMA SURVIVOR', { fontSize: '82px', fill: '#ffd700', // More golden color fontStyle: 'bold', padding: { x: 20, y: 10 }, stroke: '#8b0000', // Dark red stroke strokeThickness: 4 }).setOrigin(0.5); // Add shadow/outline effect to title const titleShadow = this.add.text(title.x + 3, title.y + 3, 'ULTIMA SURVIVOR', { fontSize: '82px', fill: '#4a0404', // Darker red fontStyle: 'bold', padding: { x: 20, y: 10 } }).setOrigin(0.5); titleShadow.setDepth(0); title.setDepth(1); // Add dark mage character with more dramatic presentation const mage = this.add.image(this.cameras.main.width / 2, this.cameras.main.height / 2 + 30, 'darkMage'); mage.setScale(0.25); // Add subtle floating animation to mage this.tweens.add({ targets: mage, y: mage.y - 20, duration: 2000, yoyo: true, repeat: -1, ease: 'Sine.easeInOut' }); // Add dramatic lighting effect around mage const light = this.add.sprite(mage.x, mage.y, 'ring'); light.setScale(0.5); light.setAlpha(0.2); light.setTint(0x3c1361); // Dark purple tint // Animate the light this.tweens.add({ targets: light, scale: 0.6, alpha: 0.1, duration: 2000, yoyo: true, repeat: -1, ease: 'Sine.easeInOut' }); // Add medieval-style start text const startText = this.add.text(this.cameras.main.width / 2, this.cameras.main.height - 100, 'Press SPACE to Begin thy Journey', { fontSize: '32px', fill: '#c4a484', padding: { x: 20, y: 10 } }).setOrigin(0.5); // Create blinking effect for start text this.tweens.add({ targets: startText, alpha: 0, duration: 800, yoyo: true, repeat: -1 }); // Add space key handler this.input.keyboard.once('keydown-SPACE', () => { this.titleMusic.stop(); this.scene.start('BulletHell'); }); } } class BulletHell extends Phaser.Scene { constructor() { super({ key: 'BulletHell' }); this.player = null; this.enemies = []; this.isChoosingUpgrade = false; this.isDead = false; this.level = 1; this.experience = 0; this.lastZombieSound = 0; this.playerHealth = 100; this.healthText = null; this.roundTime = 180; // 3 minutes in seconds this.roundTimer = null; this.timerText = null; this.lastAutoAttack = 0; this.autoAttackDelay = 600; // Increased attack frequency this.bullets = null; this.enemyBullets = null; this.expTokens = null; this.starGems = null; this.score = 0; this.scoreText = null; this.nextEnemySpawn = 0; } preload() { // Load all assets this.load.audio('deathSound', 'https://play.rosebud.ai/assets/death sound.mp3?ptm0'); this.load.audio('splat', 'https://play.rosebud.ai/assets/splat.mp3?ySwD'); this.load.audio('zombie2', 'https://play.rosebud.ai/assets/zombie2.mp3?G3Rr'); this.load.audio('zombie4', 'https://play.rosebud.ai/assets/zombie4.mp3?4euL'); this.load.image('blueGem', 'https://play.rosebud.ai/assets/blue gem.png?IMSq'); this.load.image('ring', 'https://play.rosebud.ai/assets/Ring.png?8JWJ'); this.load.image('background', 'https://play.rosebud.ai/assets/background.png?jVcI'); this.load.image('card', 'https://play.rosebud.ai/assets/Card.png?BLnl'); this.load.image('player', 'https://play.rosebud.ai/assets/darkMage.png?7mJ5'); this.load.image('grimReaper', 'https://play.rosebud.ai/assets/Grim reaper.png?SZsc'); this.load.image('ev', 'https://play.rosebud.ai/assets/EV.png?n3w1'); this.load.image('zombie', 'https://play.rosebud.ai/assets/Zombie.png?2nLj'); this.load.image('demon', 'https://play.rosebud.ai/assets/demon.png?ovQi'); this.load.image('darkMage', 'https://play.rosebud.ai/assets/darkMage.png?7mJ5'); this.load.image('playerProjectile', 'https://play.rosebud.ai/assets/playerProjectile.png?Pnih'); this.load.image('fireballProjectile', 'https://play.rosebud.ai/assets/fireballProjectile.png?CXoY'); this.load.image('poisonProjectile', 'https://play.rosebud.ai/assets/poisonProjectile.png?TG3f'); this.load.image('darkProjectile', 'https://play.rosebud.ai/assets/darkProjectile.png?DyQd'); this.load.audio('bgMusic', 'https://play.rosebud.ai/assets/yew.mp3?bk2a'); } create() { // Set world bounds and camera this.physics.world.setBounds(0, 0, 2000, 2000); // Set tiled background for larger area const background = this.add.tileSprite(0, 0, 2000, 2000, 'background'); background.setOrigin(0, 0); // Initialize enemy bullets group this.enemyBullets = this.physics.add.group(); const bgScale = Math.max(2000 / background.width, 2000 / background.height); background.setScale(bgScale); // Setup camera this.cameras.main.setBounds(0, 0, 2000, 2000); // Add background music this.bgMusic = this.sound.add('bgMusic', { loop: true, volume: 1.0 }); this.bgMusic.play(); // Create player this.player = new Player(this, 400, 500); // Make camera follow player this.cameras.main.startFollow(this.player, true, 0.09, 0.09); this.cameras.main.setZoom(1); // Create bullet group for player this.bullets = this.physics.add.group(); // Create experience tokens group this.expTokens = this.physics.add.group(); // Create star gems group this.starGems = this.physics.add.group(); // Add overlap detection for star gems this.physics.add.overlap(this.player, this.starGems, this.collectStarGem, null, this); // Add overlap detection for experience tokens this.physics.add.overlap(this.player, this.expTokens, this.collectExpToken, null, this); // Experience bar this.expBarWidth = 200; this.expBarHeight = 20; this.expBarBg = this.add.rectangle(16 + this.expBarWidth / 2, 26, this.expBarWidth, this.expBarHeight, 0x333333) .setOrigin(0.5) .setScrollFactor(0); this.expBar = this.add.rectangle(16, 26, 0, this.expBarHeight - 4, 0x00ff00) .setOrigin(0, 0.5) .setScrollFactor(0); // Level text this.levelText = this.add.text(16 + this.expBarWidth + 10, 16, `Level ${this.level}`, { fontSize: '24px', fill: '#fff' }).setScrollFactor(0); // Health display this.healthText = this.add.text(16, 56, 'Health: 100', { fontSize: '32px', fill: '#fff' }).setScrollFactor(0); // Timer display this.timerText = this.add.text(16, 96, 'Time: 3:00', { fontSize: '32px', fill: '#fff' }).setScrollFactor(0); // Add suicide button const suicideButton = this.add.rectangle(this.cameras.main.width - 100, 30, 160, 40, 0xff0000, 0.8) .setScrollFactor(0) .setInteractive(); const suicideText = this.add.text(this.cameras.main.width - 100, 30, 'Give Up', { fontSize: '24px', fill: '#fff' }).setOrigin(0.5).setScrollFactor(0); // Add hover effects suicideButton.on('pointerover', () => { suicideButton.setAlpha(1); }); suicideButton.on('pointerout', () => { suicideButton.setAlpha(0.8); }); suicideButton.on('pointerdown', () => { this.playerHealth = 0; this.handlePlayerDeath(); }); // Create round timer this.roundTimer = this.time.addEvent({ delay: 1000, // Update every second callback: this.updateTimer, callbackScope: this, loop: true }); // Input handling this.cursors = this.input.keyboard.createCursorKeys(); this.wasd = this.input.keyboard.addKeys({ up: Phaser.Input.Keyboard.KeyCodes.W, down: Phaser.Input.Keyboard.KeyCodes.S, left: Phaser.Input.Keyboard.KeyCodes.A, right: Phaser.Input.Keyboard.KeyCodes.D }); this.input.keyboard.on('keydown-SPACE', () => this.shootBullet()); // Enemy spawn timer with dynamic delay this.spawnTimer = this.time.addEvent({ delay: 2000, // Start with 2 seconds delay callback: this.spawnEnemyWave, callbackScope: this, loop: true }); // Collision detection with null checks if (this.bullets && this.enemies) { // Create a group for enemies this.enemiesGroup = this.physics.add.group(); this.physics.add.overlap(this.bullets, this.enemiesGroup, this.hitEnemy, null, this); } } update() { // Update player this.player.update(this.cursors, this.wasd); // Auto attack system if (this.player.canAutoAttack()) { const nearestEnemy = this.findNearestEnemy(); if (nearestEnemy && this.isEnemyVisible(nearestEnemy)) { this.shootBullet(nearestEnemy.x, nearestEnemy.y); this.player.setLastAutoAttack(); } } // Update enemies this.enemies.forEach(enemy => { if (enemy.active) { enemy.update(); } }); // Clean up off-screen bullets this.bullets.children.each(bullet => { if (bullet.y < -10) bullet.destroy(); }); } createEnemy(x, y, type) { const enemy = new Enemy(this, x, y, type); this.enemiesGroup.add(enemy); return enemy; } spawnEnemyWave() { // Calculate number of enemies to spawn based on level and time // Base number of enemies based on round const baseEnemies = Math.max(2, Math.min(8, Math.floor(this.level * 1.5))); // Time progression bonus (more enemies as round progresses) const timeBonus = Math.floor((180 - this.roundTime) / 45); // Calculate total enemies const enemiesCount = Math.min( Math.max(2, baseEnemies + timeBonus), 12 // Hard cap on maximum enemies per wave ); // Determine spawn position (top, bottom, left, right) const spawnPositions = [{ x: () => Phaser.Math.Between(100, 1900), y: () => Phaser.Math.Between(50, 100) }, // top { x: () => Phaser.Math.Between(100, 1900), y: () => Phaser.Math.Between(1900, 1950) }, // bottom { x: () => Phaser.Math.Between(50, 100), y: () => Phaser.Math.Between(100, 1900) }, // left { x: () => Phaser.Math.Between(1900, 1950), y: () => Phaser.Math.Between(100, 1900) } // right ]; // Generate group size based on round progression const minGroupSize = Math.max(2, Math.floor(enemiesCount * 0.6)); const maxGroupSize = enemiesCount; const groupSize = Phaser.Math.Between(minGroupSize, maxGroupSize); // Pick a random spawn position for this group const spawnPos = Phaser.Math.RND.pick(spawnPositions); // Spawn group of enemies for (let i = 0; i < groupSize; i++) { let type; // Enemy types with weighted probability based on level let enemyTypes; switch (this.level) { case 1: // Only zombies in round 1 enemyTypes = ['zombie']; break; case 2: // Round 2: Mostly zombies with few EVs enemyTypes = ['zombie', 'zombie', 'zombie', 'ev']; break; case 3: // Round 3: Equal zombies and EVs enemyTypes = ['zombie', 'zombie', 'ev', 'ev']; break; case 4: // Round 4: Introduce demons enemyTypes = ['zombie', 'zombie', 'ev', 'ev', 'demon']; break; case 5: // Round 5: More balanced mix enemyTypes = ['zombie', 'ev', 'ev', 'demon', 'demon']; break; case 6: // Round 6: More demons, fewer zombies enemyTypes = ['zombie', 'demon', 'demon', 'demon']; break; case 7: // Round 7: Introduce EVs back enemyTypes = ['zombie', 'demon', 'demon', 'ev']; break; default: // Round 8+: Mix all types with increasing demon presence const demonCount = Math.min(Math.floor((this.level - 7) / 2), 4); enemyTypes = [ 'zombie', 'ev', ...Array(demonCount).fill('demon') ]; break; } // Randomly select enemy type type = Phaser.Math.RND.pick(enemyTypes); // Select random pattern const pattern = Phaser.Math.Between(0, 2); let x, y; switch (pattern) { case 0: // Circle pattern const angle = (Math.PI * 2 * i) / groupSize; const radius = 150; x = spawnPos.x() + Math.cos(angle) * radius; y = spawnPos.y() + Math.sin(angle) * radius; break; case 1: // Scatter pattern x = spawnPos.x() + Phaser.Math.Between(-200, 200); y = spawnPos.y() + Phaser.Math.Between(-200, 200); break; case 2: // Line pattern x = spawnPos.x() + (i * 50); y = spawnPos.y(); break; } const enemy = this.createEnemy(x, y, type); // Play zombie sound for the first zombie within 20 seconds if (type === 'zombie' && (this.time.now - this.lastZombieSound > 20000 || this.lastZombieSound === 0)) { this.sound.play('zombie2', { volume: 0.5 }); this.lastZombieSound = this.time.now; } enemy.startX = x; enemy.startY = y; enemy.currentX = x; enemy.currentY = y; enemy.moveSpeed = 0.4; enemy.moveDirection = 1; this.enemies.push(enemy); } // Adjust spawn timer based on round progress // Adjust spawn delay based on round number const newDelay = Math.max( 800, // Minimum delay of 0.8 seconds 2500 - (this.level * 200) // Faster spawns in later rounds ); this.spawnTimer.delay = newDelay; } updateEnemy(enemy) { if (!enemy || !enemy.active) return; if (enemy.type === 'ev') { // Smoother, more subtle movement pattern for EV enemy.y += Math.sin(this.time.now / 800) * 0.7; // Reduced vertical bobbing enemy.x += Math.sin(this.time.now / 1200) * 0.3; // Very subtle horizontal drift // Gentler rotation enemy.rotation = Math.sin(this.time.now / 1500) * 0.1; // Reduced rotation } // Add collision between enemy and maze walls if (!enemy.hasWallCollision && this.mazeWalls) { this.physics.add.collider(enemy, this.mazeWalls); enemy.hasWallCollision = true; } // Always calculate angle to player regardless of distance const angle = Phaser.Math.Angle.Between( enemy.x, enemy.y, this.player.x, this.player.y ); // Always move towards player using physics velocity const speed = enemy.speed; enemy.body.setVelocity( Math.cos(angle) * speed, Math.sin(angle) * speed ); // Flip enemy sprite based on movement direction enemy.scaleX = Math.abs(enemy.scaleY) * (Math.cos(angle) > 0 ? 1 : -1); // Calculate distance for attack range only const distanceToPlayer = Phaser.Math.Distance.Between( enemy.x, enemy.y, this.player.x, this.player.y ); // Check if close enough to attack if (distanceToPlayer <= enemy.attackRange) { this.enemyMeleeAttack(enemy); } // Remove enemy if it somehow goes way off screen if (enemy.y > 2050 || enemy.y < -50 || enemy.x < -50 || enemy.x > 2050) { const enemyIndex = this.enemies.indexOf(enemy); if (enemyIndex > -1) { this.enemies.splice(enemyIndex, 1); } enemy.destroy(); } } shootBullet(targetX, targetY) { const playerUpgrades = this.player.getUpgrades(); if (playerUpgrades.fireRing) { this.createFireRing(this.player.x, this.player.y); } // Adjust target position to aim slightly ahead of moving enemies if (targetX && targetY) { const nearestEnemy = this.findNearestEnemy(); if (nearestEnemy && nearestEnemy.body) { // Lead the target based on enemy velocity const leadTime = 0.2; // Adjust this value to change how much we lead targetX = nearestEnemy.x + (nearestEnemy.body.velocity.x * leadTime); targetY = nearestEnemy.y + (nearestEnemy.body.velocity.y * leadTime); } } // Calculate base angle to target const baseAngle = Phaser.Math.Angle.Between( this.player.x, this.player.y, targetX || this.player.x + 1, targetY || this.player.y ); // Calculate spawn position offset from player center const spawnOffset = 20; // Reduced offset for more accurate starting position // Calculate spawn position based on angle and offset const spawnX = this.player.x + Math.cos(baseAngle) * spawnOffset; const spawnY = this.player.y + Math.sin(baseAngle) * spawnOffset; // Create multiple bullets based on multiShot upgrade for (let i = 0; i < playerUpgrades.multiShot; i++) { const bullet = new Bullet(this, this.player.x, this.player.y, playerUpgrades); this.bullets.add(bullet); // Reduce spread and random deviation for better accuracy const spreadAngle = (i - (playerUpgrades.multiShot - 1) / 2) * (Math.PI / 24); // Reduced spread const randomOffset = (Math.random() - 0.5) * (Math.PI / 64); // Reduced random deviation const shotAngle = baseAngle + spreadAngle + randomOffset; // Launch the bullet with increased speed for better accuracy bullet.launch(shotAngle); bullet.speed *= 1.2; // Slightly faster bullets for better accuracy } } shootEnemyBullet(enemy) { let projectileKey; switch (enemy.type) { case 'demon': projectileKey = 'fireballProjectile'; break; default: projectileKey = 'poisonProjectile'; } const bullet = this.add.sprite(enemy.x, enemy.y + 20, projectileKey); bullet.setScale(0.04); this.enemyBullets.add(bullet); const angle = Phaser.Math.Angle.Between(enemy.x, enemy.y, this.player.x, this.player.y); const velocity = this.physics.velocityFromAngle(Phaser.Math.RadToDeg(angle), 200); bullet.body.setVelocity(velocity.x, velocity.y); } hitEnemy(bullet, enemy) { if (!enemy || !enemy.active || !bullet || !bullet.active || !this.isEnemyVisible(enemy) || !(enemy instanceof Enemy)) return; // Get the center points of both objects const bulletCenter = bullet.getCenter(); const enemyCenter = enemy.getCenter(); // Calculate distance between centers const distance = Phaser.Math.Distance.Between( bulletCenter.x, bulletCenter.y, enemyCenter.x, enemyCenter.y ); // Increased hit threshold for better hit registration const hitThreshold = enemy.type === 'zombie' ? 65 : 50; // Much larger hit threshold for zombies // Use a more forgiving hit detection based on movement const enemySpeed = Math.sqrt( Math.pow(enemy.body.velocity.x, 2) + Math.pow(enemy.body.velocity.y, 2) ); // Increase threshold for fast-moving enemies const adjustedThreshold = hitThreshold + (enemySpeed * 0.1); // Only register hit if centers are close enough if (distance > adjustedThreshold) return; const playerUpgrades = this.player.getUpgrades(); // Show damage number at exact hit position const damageText = this.add.text(bullet.x, bullet.y, bullet.damage.toString(), { fontSize: '24px', fill: '#ff0000', stroke: '#ffffff', strokeThickness: 2 }).setOrigin(0.5); // Animate the damage number this.tweens.add({ targets: damageText, y: damageText.y - 50, alpha: 0, duration: 800, ease: 'Power1', onComplete: () => damageText.destroy() }); // Handle ricochet logic if (playerUpgrades.ricochet) { bullet.ricochets = bullet.ricochets || 0; if (bullet.ricochets < playerUpgrades.ricochetCount) { // Find the nearest enemy that's not the current one let nearestEnemy = null; let shortestDistance = Infinity; this.enemies.forEach(otherEnemy => { if (otherEnemy !== enemy && otherEnemy.active) { const distance = Phaser.Math.Distance.Between( enemy.x, enemy.y, otherEnemy.x, otherEnemy.y ); if (distance < shortestDistance) { shortestDistance = distance; nearestEnemy = otherEnemy; } } }); if (nearestEnemy) { // Calculate new angle for ricochet const angle = Phaser.Math.Angle.Between( enemy.x, enemy.y, nearestEnemy.x, nearestEnemy.y ); // Update bullet trajectory with ricochet bullet.ricochet(angle, 0.9); // Add visual effect for ricochet const ricochetEffect = this.add.sprite(enemy.x, enemy.y, 'playerProjectile'); ricochetEffect.setScale(0.04); ricochetEffect.setTint(0xffff00); this.tweens.add({ targets: ricochetEffect, alpha: 0, scale: 0.2, duration: 200, onComplete: () => ricochetEffect.destroy() }); return; // Skip destroying the bullet and enemy } } } // Create a visual effect for the hit at bullet's position const hitEffect = this.add.sprite(bullet.x, bullet.y, 'playerProjectile'); hitEffect.setScale(bullet.scale); hitEffect.setAlpha(0.9); hitEffect.setTint(0xff0000); // Animate the hit effect this.tweens.add({ targets: hitEffect, alpha: 0, scale: 0.2, duration: 200, onComplete: () => hitEffect.destroy() }); // Shake the camera slightly this.cameras.main.shake(100, 0.005); // Destroy the bullet if (bullet.active) { bullet.destroy(); } // Deal damage to the enemy enemy.takeDamage(bullet.damage || 10); // Update score this.score += 10; // Update score text if it exists and is active if (this.scoreText && this.scoreText.active) { try { this.scoreText.setText(`Score: ${this.score} (Level ${this.level})`); } catch (error) { // Recreate score text if it was destroyed this.scoreText = this.add.text(16, 16, `Score: ${this.score} (Level ${this.level})`, { fontSize: '32px', fill: '#fff' }).setScrollFactor(0); } } } enemyMeleeAttack(enemy) { // Check if enemy can attack (add cooldown) if (!enemy.lastAttack || this.time.now - enemy.lastAttack >= 1000) { this.playerHealth -= enemy.damage; enemy.lastAttack = this.time.now; // Update health display if (this.healthText && this.healthText.active) { try { this.healthText.setText(`Health: ${this.playerHealth}`); } catch (error) { // Recreate health text if it was destroyed this.healthText = this.add.text(16, 56, `Health: ${this.playerHealth}`, { fontSize: '32px', fill: '#fff' }).setScrollFactor(0); } } else { // Create health text if it doesn't exist this.healthText = this.add.text(16, 56, `Health: ${this.playerHealth}`, { fontSize: '32px', fill: '#fff' }).setScrollFactor(0); } // Flash the player red when hit this.player.setTint(0xff0000); this.time.delayedCall(100, () => { this.player.clearTint(); }); // Check if player is defeated if (this.playerHealth <= 0) { this.handlePlayerDeath(); } } } handlePlayerDeath() { // Prevent multiple death screens if (this.isDead) return; this.isDead = true; // Stop all sounds this.sound.stopAll(); // Create semi-transparent dark overlay const overlay = this.add.rectangle( this.cameras.main.width / 2, this.cameras.main.height / 2, this.cameras.main.width, this.cameras.main.height, 0x101020, // Dark blue-gray instead of pure black 0.6 // Reduced opacity ).setScrollFactor(0).setDepth(100); // Play death sound this.sound.play('deathSound', { volume: 1.0 }); // Add "I have Failed" text with enhanced visibility const gameOverText = this.add.text( this.cameras.main.width / 2, this.cameras.main.height / 2 - 100, 'I have Failed', { fontSize: '64px', fill: '#ff3333', // Brighter red fontStyle: 'bold', stroke: '#000000', // Black outline strokeThickness: 4 // Outline thickness } ).setOrigin(0.5).setScrollFactor(0).setDepth(102); // Add darkMage as grim reaper const reaper = this.add.image( this.cameras.main.width / 2, this.cameras.main.height / 2 + 50, 'grimReaper' ).setScrollFactor(0).setScale(0.25).setAlpha(1).setDepth(101); // Add score text const finalScore = this.add.text( this.cameras.main.width / 2, this.cameras.main.height / 2 + 200, `Final Score: ${this.score}\nLevel Reached: ${this.level}`, { fontSize: '32px', fill: '#ffffff', align: 'center', stroke: '#000000', // Black outline strokeThickness: 2 // Outline thickness } ).setOrigin(0.5).setScrollFactor(0).setDepth(102); // Add restart text with input handling const restartText = this.add.text( this.cameras.main.width / 2, this.cameras.main.height - 100, 'Press SPACE to Restart', { fontSize: '24px', fill: '#ffffff', stroke: '#000000', // Black outline strokeThickness: 2 // Outline thickness } ).setOrigin(0.5).setScrollFactor(0).setDepth(102); // Pause the game this.physics.pause(); // Add space key handler for restart this.input.keyboard.once('keydown-SPACE', () => { // Stop all sounds before restarting this.sound.stopAll(); // Reset all player stats this.score = 0; this.playerHealth = 100; this.level = 1; this.isDead = false; if (this.player) { this.player.health = 100; } this.scene.restart(); }); } findNearestEnemy() { let nearestEnemy = null; let shortestDistance = Infinity; this.enemies.forEach(enemy => { if (enemy.active) { const distance = Phaser.Math.Distance.Between( this.player.x, this.player.y, enemy.x, enemy.y ); if (distance < shortestDistance) { shortestDistance = distance; nearestEnemy = enemy; } } }); return nearestEnemy; } isEnemyVisible(enemy) { const camera = this.cameras.main; const bounds = camera.worldView; // Check if enemy is within camera bounds return ( enemy.x >= bounds.x && enemy.x <= bounds.x + bounds.width && enemy.y >= bounds.y && enemy.y <= bounds.y + bounds.height ); } updateTimer() { if (this.roundTime > 0) { this.roundTime--; // Only update timer text if it exists and is active if (this.timerText && this.timerText.active) { const minutes = Math.floor(this.roundTime / 60); const seconds = Math.floor(this.roundTime % 60); const timeString = `Time: ${minutes}:${seconds.toString().padStart(2, '0')}`; try { this.timerText.setText(timeString); } catch (error) { // If there's an error updating the text, recreate it this.timerText = this.add.text(16, 96, timeString, { fontSize: '32px', fill: '#fff' }).setScrollFactor(0); } } // Check if round is over if (this.roundTime <= 0) { this.startNewRound(); } } } startNewRound() { // Increase level this.level++; // Reset timer and ensure timer text exists this.roundTime = 180; if (!this.timerText || !this.timerText.active) { this.timerText = this.add.text(16, 96, 'Time: 3:00', { fontSize: '32px', fill: '#fff' }).setScrollFactor(0); } // Clear all enemies this.enemies.forEach(enemy => enemy.destroy()); this.enemies = []; // Create level transition effect const levelText = this.add.text( this.cameras.main.worldView.x + this.cameras.main.width / 2, this.cameras.main.worldView.y + this.cameras.main.height / 2, `Round ${this.level}!`, { fontSize: '64px', fill: '#fff' } ).setOrigin(0.5); // Animate the level text this.tweens.add({ targets: levelText, alpha: { from: 1, to: 0 }, y: levelText.y - 100, duration: 2000, onComplete: () => levelText.destroy() }); // Update score text if (this.scoreText && this.scoreText.active) { try { this.scoreText.setText(`Score: ${this.score} (Level ${this.level})`); } catch (error) { // Recreate score text if it was destroyed this.scoreText = this.add.text(16, 16, `Score: ${this.score} (Level ${this.level})`, { fontSize: '32px', fill: '#fff' }).setScrollFactor(0); } } else { // Create score text if it doesn't exist this.scoreText = this.add.text(16, 16, `Score: ${this.score} (Level ${this.level})`, { fontSize: '32px', fill: '#fff' }).setScrollFactor(0); } } showLevelUpScreen() { this.isChoosingUpgrade = true; // Pause all enemy movement and make them inactive this.enemies.forEach(enemy => { enemy.body.setVelocity(0, 0); enemy.setActive(false); }); // Make player temporarily invulnerable this.player.setImmovable(true); // Reset experience for next level with steeper scaling const currentLevelExp = this.level <= 5 ? Math.floor(100 * Math.pow(2.5, this.level - 1)) : // Steeper early game scaling this.level <= 10 ? Math.floor(100 * Math.pow(2.5, 4) * Math.pow(3, this.level - 5)) : // Mid game scaling Math.floor(100 * Math.pow(2.5, 4) * Math.pow(3, 5) * Math.pow(4, this.level - 10)); // Late game scaling this.experience -= currentLevelExp; // Update experience bar for new level using same formula for next level const nextLevelExp = (this.level + 1) <= 5 ? Math.floor(100 * Math.pow(2.5, this.level)) : (this.level + 1) <= 10 ? Math.floor(100 * Math.pow(2.5, 4) * Math.pow(3, this.level - 4)) : Math.floor(100 * Math.pow(2.5, 4) * Math.pow(3, 5) * Math.pow(4, this.level - 9)); const expProgress = this.experience / nextLevelExp; this.expBar.width = this.expBarWidth * expProgress; // Pause the game this.physics.pause(); // Create semi-transparent background const overlay = this.add.rectangle( this.cameras.main.worldView.x + this.cameras.main.width / 2, this.cameras.main.worldView.y + this.cameras.main.height / 2, this.cameras.main.width, this.cameras.main.height, 0x000000, 0.7 ).setScrollFactor(0); // Create "Choose Your Upgrade" text const titleText = this.add.text( this.cameras.main.width / 2, 100, 'Choose Your Upgrade', { fontSize: '48px', fill: '#fff' } ).setOrigin(0.5).setScrollFactor(0); // Define possible upgrades const upgrades = [{ name: 'Weapon Mastery', description: 'Increase weapon size by 25%', effect: () => { // Initialize player upgrades if not exist if (!this.player.upgrades) { this.player.upgrades = this.player.getUpgrades(); } this.bullets.children.each(bullet => { bullet.setScale(bullet.scale * 1.25); }); // Apply to future bullets this.player.upgrades.bulletScale = (this.player.upgrades.bulletScale || 0.02) * 1.25; } }, { name: 'Health Boost', description: 'Increase max health by 25', effect: () => { this.playerHealth += 25; this.healthText.setText(`Health: ${this.playerHealth}`); } }, { name: 'Damage Up', description: 'Increase damage by 25%', effect: () => { if (!this.player.upgrades) { this.player.upgrades = this.player.getUpgrades(); } this.player.upgrades.damage *= 1.25; } }, { name: 'Attack Speed', description: 'Increase attack speed by 15%', effect: () => { this.player.autoAttackDelay *= 0.85; } }, { name: 'Move Speed', description: 'Increase movement speed by 20%', effect: () => { if (!this.player.upgrades) { this.player.upgrades = this.player.getUpgrades(); } this.player.upgrades.moveSpeed *= 1.2; } }, { name: 'Multi Shot', description: 'Add additional projectile', effect: () => { if (!this.player.upgrades) { this.player.upgrades = this.player.getUpgrades(); } this.player.upgrades.multiShot += 1; } }, { name: 'Bullet Speed', description: 'Increase projectile speed by 20%', effect: () => { if (!this.player.upgrades) { this.player.upgrades = this.player.getUpgrades(); } this.player.upgrades.bulletSpeed *= 1.2; } }, { name: 'Fire Ring', description: 'Spawn damaging rings of fire when attacking', effect: () => { if (!this.player.upgrades) { this.player.upgrades = this.player.getUpgrades(); } this.player.upgrades.fireRing = true; this.player.upgrades.fireRingDamage = 10; } }, { name: 'Ricochet Shot', description: 'Bullets bounce between enemies with reduced damage', effect: () => { if (!this.player.upgrades) { this.player.upgrades = this.player.getUpgrades(); } this.player.upgrades.ricochet = true; this.player.upgrades.ricochetCount = 2; this.player.upgrades.ricochetDamageReduction = 0.5; } }]; // Randomly select 3 unique upgrades const selectedUpgrades = Phaser.Utils.Array.Shuffle(upgrades.slice()).slice(0, 3); // Create cards selectedUpgrades.forEach((upgrade, index) => { const cardX = (this.cameras.main.width / 4) * (index + 1); const cardY = this.cameras.main.height / 2; const card = this.add.image(cardX, cardY, 'card') .setInteractive() .setScrollFactor(0) .setScale(0.45) // Adjust scale to match previous card size .setTint(0xFFFFFF); // Start with normal color const cardTitle = this.add.text(cardX, cardY - 100, upgrade.name, { fontSize: '24px', fill: '#000000', align: 'center', fontStyle: 'bold' }) .setOrigin(0.5) .setScrollFactor(0); const cardDescription = this.add.text(cardX, cardY, upgrade.description, { fontSize: '18px', fill: '#000000', align: 'center', wordWrap: { width: 180 } }) .setOrigin(0.5) .setScrollFactor(0); // Hover effect card.on('pointerover', () => { card.setTint(0xcccccc); // Lighter tint for hover effect }); card.on('pointerout', () => { card.setTint(0xFFFFFF); // Reset to normal color }); // Click handler card.on('pointerdown', () => { // Apply the upgrade upgrade.effect(); // Find and destroy all upgrade cards and their text this.children.list.slice().forEach(child => { // Check if it's a card image if (child.texture && child.texture.key === 'card') { child.destroy(); } // Check if it's upgrade-related text (not score/health/timer) if (child.type === 'Text' && child !== this.scoreText && child !== this.healthText && child !== this.timerText && child.y >= 100 && // Title text and card text are below y=100 child.y <= this.cameras.main.height / 2 + 50) { // Card text doesn't go below middle of screen child.destroy(); } }); // Destroy the overlay and title overlay.destroy(); titleText.destroy(); // Destroy the overlay overlay.destroy(); titleText.destroy(); // Resume the game and restore enemy states this.physics.resume(); this.isChoosingUpgrade = false; // Reactivate enemies and player vulnerability this.enemies.forEach(enemy => { enemy.setActive(true); }); this.player.setImmovable(false); // Show upgrade effect const effectText = this.add.text( this.player.x, this.player.y - 50, upgrade.name + ' Acquired!', { fontSize: '32px', fill: '#fff' } ).setOrigin(0.5); this.tweens.add({ targets: effectText, y: effectText.y - 100, alpha: 0, duration: 1000, onComplete: () => effectText.destroy() }); }); }); } spawnExpToken(x, y) { const token = this.add.sprite(x, y, 'blueGem'); token.setScale(0.04); // Adjusted scale for blue gem token.setAlpha(0.8); // Slight transparency this.expTokens.add(token); // Add floating animation this.tweens.add({ targets: token, y: token.y - 5, // Reduced floating height duration: 1000, yoyo: true, repeat: -1 }); // Add pulsing effect this.tweens.add({ targets: token, scale: 0.02, // Reduced max scale in pulse animation duration: 800, yoyo: true, repeat: -1 }); // Make token move towards player when nearby this.time.addEvent({ delay: 100, callback: () => { if (token.active) { const distToPlayer = Phaser.Math.Distance.Between( token.x, token.y, this.player.x, this.player.y ); if (distToPlayer < 150) { const angle = Phaser.Math.Angle.Between( token.x, token.y, this.player.x, this.player.y ); const speed = 200; token.body.setVelocity( Math.cos(angle) * speed, Math.sin(angle) * speed ); } } }, loop: true }); } collectExpToken(player, token) { if (token.active) { // Create collection effect const collectEffect = this.add.sprite(token.x, token.y, 'blueGem'); collectEffect.setScale(0.04); collectEffect.setAlpha(0.8); this.tweens.add({ targets: collectEffect, alpha: 0, scale: 0.1, duration: 200, onComplete: () => collectEffect.destroy() }); // Increase experience this.experience += 10; // Update experience bar const nextLevelExp = this.level <= 5 ? Math.floor(100 * Math.pow(2.5, this.level - 1)) : this.level <= 10 ? Math.floor(100 * Math.pow(2.5, 4) * Math.pow(3, this.level - 5)) : Math.floor(100 * Math.pow(2.5, 4) * Math.pow(3, 5) * Math.pow(4, this.level - 10)); const expProgress = Math.min(this.experience / nextLevelExp, 1); this.expBar.width = this.expBarWidth * expProgress; // Check for level up if (this.experience >= nextLevelExp) { this.showLevelUpScreen(); } // Update level text if (this.levelText && this.levelText.active) { try { this.levelText.setText(`Level ${this.level}`); } catch (error) { this.levelText = this.add.text(16 + this.expBarWidth + 10, 16, `Level ${this.level}`, { fontSize: '24px', fill: '#fff' }).setScrollFactor(0); } } // Destroy the token token.destroy(); } } spawnStarGem(x, y) { const gem = this.add.sprite(x, y, 'blueGem'); gem.setScale(0.04); this.starGems.add(gem); // Add floating animation this.tweens.add({ targets: gem, y: gem.y - 10, duration: 1500, yoyo: true, repeat: -1 }); // Add sparkle effect this.tweens.add({ targets: gem, alpha: 0.7, duration: 1000, yoyo: true, repeat: -1 }); // Make gem move towards player when nearby this.time.addEvent({ delay: 100, callback: () => { if (gem.active) { const distToPlayer = Phaser.Math.Distance.Between( gem.x, gem.y, this.player.x, this.player.y ); if (distToPlayer < 200) { const angle = Phaser.Math.Angle.Between( gem.x, gem.y, this.player.x, this.player.y ); const speed = 250; gem.body.setVelocity( Math.cos(angle) * speed, Math.sin(angle) * speed ); } } }, loop: true }); } collectStarGem(player, gem) { if (gem.active) { // Create collection effect for the star gem const collectEffect = this.add.sprite(gem.x, gem.y, 'blueGem'); collectEffect.setScale(0.04); this.tweens.add({ targets: collectEffect, alpha: 0, scale: 0.2, duration: 300, onComplete: () => collectEffect.destroy() }); // Add bonus score for star gem and check for level up this.experience += 50; // Update experience bar const nextLevelExp = this.level <= 5 ? Math.floor(100 * Math.pow(2.5, this.level - 1)) : this.level <= 10 ? Math.floor(100 * Math.pow(2.5, 4) * Math.pow(3, this.level - 5)) : Math.floor(100 * Math.pow(2.5, 4) * Math.pow(3, 5) * Math.pow(4, this.level - 10)); const expProgress = Math.min(this.experience / nextLevelExp, 1); this.expBar.width = this.expBarWidth * expProgress; // Check for level up if (this.experience >= nextLevelExp) { this.showLevelUpScreen(); } // Create a wave effect from the star gem const waveEffect = this.add.sprite(gem.x, gem.y, 'ring'); waveEffect.setScale(0.1); waveEffect.setAlpha(0.5); waveEffect.setTint(0xFFFF00); this.tweens.add({ targets: waveEffect, scale: 2, alpha: 0, duration: 500, onComplete: () => waveEffect.destroy() }); // Collect all experience tokens this.expTokens.children.each(token => { if (token.active) { // Create collection effect for each exp token const tokenEffect = this.add.sprite(token.x, token.y, 'blueGem'); tokenEffect.setScale(0.04); tokenEffect.setAlpha(0.8); // Animate token effect moving toward player this.tweens.add({ targets: tokenEffect, x: player.x, y: player.y, alpha: 0, scale: 0.05, duration: 300, onComplete: () => tokenEffect.destroy() }); // Add score for each experience token this.score += 10; // Destroy the token token.destroy(); } }); // Update score text if (this.scoreText && this.scoreText.active) { try { this.scoreText.setText(`Score: ${this.score} (Level ${this.level})`); } catch (error) { this.scoreText = this.add.text(16, 16, `Score: ${this.score} (Level ${this.level})`, { fontSize: '32px', fill: '#fff' }).setScrollFactor(0); } } // Check for level up after collecting all experience // Remove level up check from star gem collection // Destroy the star gem gem.destroy(); } } createFireRing(x, y) { const ring = this.add.sprite(x, y, 'ring'); // Add walking animation for zombie this.anims.create({ key: 'zombie-walk', frames: [{ key: 'zombie', duration: 200 }, { key: 'zombie', scale: { x: 1, y: 0.92 }, duration: 200 }], frameRate: 8, repeat: -1 }); ring.setScale(0.1); ring.setAlpha(0.7); ring.setTint(0xff4400); // Add the ring to physics for enemy collision this.physics.world.enable(ring); ring.body.setImmovable(true); // Get player upgrades const playerUpgrades = this.player.getUpgrades(); // Create expanding ring effect this.tweens.add({ targets: ring, scale: 0.3, alpha: 0, duration: 1000, onUpdate: () => { // Check for enemy overlap during expansion this.physics.overlap(ring, this.enemies, (ring, enemy) => { if (enemy.active && !enemy.hitByRing) { enemy.hitByRing = true; const damage = playerUpgrades.fireRingDamage || 10; // Default to 10 if not set // Visual effect for hit enemy.setTint(0xff0000); this.time.delayedCall(100, () => { if (enemy.active) enemy.clearTint(); }); // Check if enemy should be destroyed const enemyIndex = this.enemies.indexOf(enemy); if (enemyIndex > -1) { this.enemies.splice(enemyIndex, 1); enemy.destroy(); this.spawnExpToken(enemy.x, enemy.y); } } }); }, onComplete: () => { ring.destroy(); } }); } } class Enemy extends Phaser.Physics.Arcade.Sprite { constructor(scene, x, y, type) { super(scene, x, y, type); // Add this sprite to the scene scene.add.existing(this); scene.physics.add.existing(this); this.type = type; this.active = true; this.scene = scene; this.hitByRing = false; this.hasPlayedHitSound = false; // Set scale based on enemy type // Set scale based on enemy type switch (type) { case 'ev': this.setScale(1.0); break; case 'zombie': this.setScale(0.55); // Increased zombie size by 10% break; default: this.setScale(0.04); } // Enable physics and set collision bounds this.body.setCollideWorldBounds(true); // Set specific hitbox for different enemy types if (type === 'zombie') { // Set circular hitbox for zombies const radius = 25; // Radius for the circular hitbox this.body.setCircle(radius); // Center the circular hitbox on the sprite this.body.setOffset( (250 - radius * 2) / 2, // Center horizontally (sprite width - diameter)/2 (250 - radius * 2) / 2 // Center vertically (sprite height - diameter)/2 ); } else if (type === 'ev') { const width = this.width * 0.25; const height = this.height * 0.25; this.body.setSize(width, height, true); this.body.setOffset(this.width * 0.375, this.height * 0.375); } // Set base stats for enemy types without level scaling switch (type) { case 'demon': this.maxHealth = 75; this.damage = 15; this.speed = 70; break; case 'zombie': this.maxHealth = 80; this.damage = 15; this.speed = 60; break; case 'ev': this.maxHealth = 35; this.damage = 15; this.speed = 65; break; default: this.maxHealth = 100; this.damage = 10; this.speed = 100; } this.health = this.maxHealth; this.attackRange = 50; // Fixed attack range this.aggroRange = 400; // Fixed aggro range this.lastAttack = 0; // Add animations for EV type if (type === 'ev') { scene.tweens.add({ targets: this, scaleX: 1.1, scaleY: 0.9, duration: 1000, yoyo: true, repeat: -1 }); scene.tweens.add({ targets: this, alpha: 0.7, duration: 1500, yoyo: true, repeat: -1 }); } } update() { if (!this.active) return; if (this.type === 'ev') { this.y += Math.sin(this.scene.time.now / 800) * 0.7; this.x += Math.sin(this.scene.time.now / 1200) * 0.3; this.rotation = Math.sin(this.scene.time.now / 1500) * 0.1; } else if (this.type === 'zombie') { // Start walking animation if not already playing if (!this.anims.isPlaying) { this.play('zombie-walk'); } } const angle = Phaser.Math.Angle.Between( this.x, this.y, this.scene.player.x, this.scene.player.y ); this.body.setVelocity( Math.cos(angle) * this.speed, Math.sin(angle) * this.speed ); // Handle sprite direction based on enemy type if (this.type === 'zombie') { // For zombie, flip the sprite based on movement direction this.scaleX = Math.abs(this.scaleY) * (Math.cos(angle) > 0 ? -1 : 1); } else { // Default behavior for other enemies this.scaleX = Math.abs(this.scaleY) * (Math.cos(angle) > 0 ? 1 : -1); } const distanceToPlayer = Phaser.Math.Distance.Between( this.x, this.y, this.scene.player.x, this.scene.player.y ); if (distanceToPlayer <= this.attackRange) { this.attackPlayer(); } } takeDamage(amount) { // Calculate actual damage (can be modified by enemy defenses later) const actualDamage = Math.floor(amount); this.health -= actualDamage; // Play zombie hit sound only once per zombie if (this.type === 'zombie' && !this.hasPlayedHitSound) { this.scene.sound.play('zombie4', { volume: 0.3 }); this.hasPlayedHitSound = true; } // Visual feedback this.setTint(0xff0000); this.scene.time.delayedCall(100, () => { if (this.active) { this.clearTint(); } }); // Check if enemy should be destroyed if (this.health <= 0) { const enemyIndex = this.scene.enemies.indexOf(this); if (enemyIndex > -1) { this.scene.enemies.splice(enemyIndex, 1); // Spawn experience token this.scene.spawnExpToken(this.x, this.y); // 3% chance to spawn a star gem if (Math.random() < 0.03) { this.scene.spawnStarGem(this.x, this.y); } // Play death effect this.scene.sound.play('splat', { volume: 0.3 }); // Create death animation this.scene.tweens.add({ targets: this, alpha: 0, scale: this.scale * 1.5, duration: 150, onComplete: () => { if (this.active) { this.destroy(); } } }); } } return this.health; } attackPlayer() { if (this.scene.time.now - this.lastAttack >= 1000) { // Deal damage through the player's damage method const newHealth = this.scene.player.takeDamage(this.damage); this.lastAttack = this.scene.time.now; // Update health text if (this.scene.healthText && this.scene.healthText.active) { this.scene.healthText.setText(`Health: ${newHealth}`); } // Check for player death only if not already dead if (newHealth <= 0 && !this.scene.isDead) { this.scene.handlePlayerDeath(); } } } } class Player extends Phaser.Physics.Arcade.Sprite { constructor(scene, x, y) { super(scene, x, y, 'player'); this.scene = scene; scene.add.existing(this); scene.physics.add.existing(this); this.setScale(0.06); this.body.setCollideWorldBounds(true); this.health = 100; this.upgrades = { damage: 20, attackSpeed: 1, moveSpeed: 150, bulletSpeed: 300, multiShot: 1, bulletScale: 0.02, fireRing: false, fireRingDamage: 10, // Ensure this is initialized ricochet: false, ricochetCount: 2, ricochetDamageReduction: 0.5 }; this.lastAutoAttack = 0; this.autoAttackDelay = 600; // Create movement animation tween this.movementTween = scene.tweens.add({ targets: this, scaleX: 0.058, scaleY: 0.062, duration: 300, yoyo: true, repeat: -1, paused: true }); } update(cursors, wasd) { const speed = this.upgrades.moveSpeed; let velocityX = 0; let velocityY = 0; // Handle horizontal movement if (cursors.left.isDown || wasd.left.isDown) { velocityX = -speed; } else if (cursors.right.isDown || wasd.right.isDown) { velocityX = speed; } // Handle vertical movement if (cursors.up.isDown || wasd.up.isDown) { velocityY = -speed; } else if (cursors.down.isDown || wasd.down.isDown) { velocityY = speed; } // Apply velocity this.body.setVelocity(velocityX, velocityY); // Update animation based on movement if (velocityX !== 0 || velocityY !== 0) { if (this.movementTween.paused) { this.movementTween.resume(); } if (velocityX !== 0) { this.scaleX = Math.abs(this.scaleY) * (velocityX > 0 ? 1 : -1); } if (velocityX !== 0) { this.rotation = velocityX > 0 ? 0.1 : -0.1; } else { this.rotation = 0; } } else { if (!this.movementTween.paused) { this.movementTween.pause(); this.setScale(0.06); this.rotation = 0; } } } takeDamage(amount) { // If player is already dead, don't process more damage if (this.health <= 0) { return this.health; } this.health -= amount; // Visual feedback this.setTint(0xff0000); this.scene.time.delayedCall(100, () => { this.clearTint(); }); return this.health; } canAutoAttack() { return this.scene.time.now - this.lastAutoAttack >= this.autoAttackDelay; } setLastAutoAttack() { this.lastAutoAttack = this.scene.time.now; } getUpgrades() { return this.upgrades; } } class Bullet extends Phaser.Physics.Arcade.Sprite { constructor(scene, x, y, playerUpgrades) { super(scene, x, y, 'playerProjectile'); this.scene = scene; scene.add.existing(this); scene.physics.add.existing(this); this.setScale(playerUpgrades.bulletScale); // Set a larger hitbox for the bullet const width = this.width * 0.8; // Much larger hitbox for better hit detection const height = this.width * 0.8; // Square hitbox for consistency this.body.setSize(width, height); this.body.setOffset((this.width - width) / 2, (this.height - height) / 2); this.ricochets = 0; this.damage = playerUpgrades.damage; this.speed = playerUpgrades.bulletSpeed; } launch(angle) { this.rotation = angle + Math.PI / 2; this.body.setVelocity( Math.cos(angle) * this.speed, Math.sin(angle) * this.speed ); } ricochet(newAngle, speedMultiplier = 1) { this.ricochets++; this.launch(newAngle); this.speed *= speedMultiplier; } } const config = { type: Phaser.AUTO, parent: 'renderDiv', scale: { mode: Phaser.Scale.FIT, autoCenter: Phaser.Scale.CENTER_BOTH, }, width: 800, height: 600, physics: { default: 'arcade', arcade: { debug: false, setBounds: true, width: 2000, height: 2000 } }, scene: [TitleScreen, BulletHell] }; window.phaserGame = new Phaser.Game(config);