class CardManager { constructor(scene) { Object.assign(this, { scene, gameDeck: [], discardPile: [], playerHand: [], aiHands: [ [], [], [], [] ], cardsDrawnThisTurn: 0, cardsPlayedThisTurn: 0, playedCardsCount: 0, firstPlayedCardPosition: null, cards: new Map(), events: new Phaser.Events.EventEmitter(), rebuffCounters: [0, 0, 0, 0], // Track rebuff cards played per player eventTypes: { CARD_DRAWN: 'cardDrawn', CARD_PLAYED: 'cardPlayed', CARD_DISCARDED: 'cardDiscarded', EFFECT_TRIGGERED: 'effectTriggered' }, cardTypes: { LANE_CHANGE: 'lane_change', INTIMIDATION: 'intimidation', REBUFF: 'rebuff' }, effectTypes: { LANE_CHANGE: 'lane_change', INTIMIDATION: 'intimidation', REBUFF: 'rebuff' }, deckPosition: { x: 650, y: 420 }, handPosition: { x: 98, y: 495 } }); this.initialize(); } initialize() { Array.from({ length: 32 }, (_, i) => { let cardType, cardName, cardDescription, effectType, effectValue, conditions; // New distribution: 12 Rebuff, 8 Lane Change, 12 Intimidation if (i < 12) { cardType = this.cardTypes.REBUFF; cardName = `Rebuff ${i+1}`; cardDescription = "Adds +2 to dice roll"; effectType = this.effectTypes.REBUFF; effectValue = 2; conditions = []; } else if (i >= 12 && i < 20) { cardType = this.cardTypes.LANE_CHANGE; cardName = `Lane Change ${i-11}`; cardDescription = "Change to adjacent lane"; effectType = this.effectTypes.LANE_CHANGE; effectValue = i - 11; conditions = ['firstTurnComplete']; } else { cardType = this.cardTypes.INTIMIDATION; cardName = `Intimidation ${i-19}`; cardDescription = "Allows bypassing cars ahead"; effectType = this.effectTypes.INTIMIDATION; effectValue = 0; conditions = ['firstTurnComplete']; } const card = this.createCard(this.deckPosition.x, this.deckPosition.y, { type: cardType, name: cardName, description: cardDescription, id: `CARD_${i+1}`, uniqueId: i + 1, effect: { type: effectType, value: effectValue, target: 'self', duration: 0, conditions: conditions } }); this.cards.set(i + 1, card); this.gameDeck.push(card); }); this.shuffle(); this.setupEventListeners(); } createCard(x, y, cardData) { const cardWidth = 75; const cardHeight = 112.5; const cardColors = this.getCardTypeColors(cardData.type); const graphics = this.scene.add.graphics(); graphics.lineStyle(2, cardColors.border); graphics.strokeRect(0, 0, cardWidth, cardHeight); graphics.fillStyle(cardColors.background); graphics.fillRect(0, 0, cardWidth, cardHeight); graphics.fillStyle(cardColors.accent); graphics.fillRect(5, 5, cardWidth - 10, 15); const title = this.scene.add.text(cardWidth / 2, 12, cardData.name.toUpperCase(), { fontSize: '8px', color: '#FFFFFF', align: 'center', fontStyle: 'bold', wordWrap: { width: cardWidth - 10 } }).setOrigin(0.5); const effectText = this.scene.add.text(cardWidth / 2, 35, `[${cardData.effect.type}]`, { fontSize: '8px', color: cardColors.effectColor, align: 'center', wordWrap: { width: cardWidth - 15 } }).setOrigin(0.5); const description = this.scene.add.text(cardWidth / 2, cardHeight / 2 + 10, cardData.description || this.getDefaultDescription(cardData), { fontSize: '8px', color: '#FFFFFF', align: 'center', wordWrap: { width: cardWidth - 15 }, fixedWidth: cardWidth - 15 }).setOrigin(0.5); const valueText = this.scene.add.text(cardWidth / 2, cardHeight - 15, `Value: ${cardData.effect.value || 0}`, { fontSize: '8px', color: cardColors.valueColor, align: 'center', wordWrap: { width: cardWidth - 15 } }).setOrigin(0.5); const container = this.scene.add.container(x, y, [ graphics, title, effectText, description, valueText ]); container.setVisible(false); container.setScale(0); this.scene.tweens.add({ targets: container, scaleX: 1, scaleY: 1, duration: 200, ease: 'Back.easeOut', onComplete: () => { if (!container.visible) { container.setScale(0); } } }); const containerGlow = this.scene.add.graphics(); this.updateCardGlow(containerGlow, cardColors.glow, cardWidth, cardHeight); container.add(containerGlow); containerGlow.setAlpha(0); this.scene.tweens.add({ targets: containerGlow, alpha: 0.3, yoyo: true, repeat: 2, duration: 300 }); return { container, ...cardData, colors: cardColors }; } getCardTypeColors(type) { const colors = { [this.cardTypes.LANE_CHANGE]: { border: 0x00ff00, // Bright green background: 0x003300, // Dark green accent: 0x006600, // Medium green effectColor: '#00ff00', valueColor: '#00ff00', glow: 0x00ff00 }, [this.cardTypes.INTIMIDATION]: { border: 0xff0000, // Bright red background: 0x330000, // Dark red accent: 0x660000, // Medium red effectColor: '#ff0000', valueColor: '#ff0000', glow: 0xff0000 }, [this.cardTypes.REBUFF]: { border: 0x00ffff, // Cyan background: 0x003333, // Dark cyan accent: 0x006666, // Medium cyan effectColor: '#00ffff', valueColor: '#00ffff', glow: 0x00ffff }, }; return colors[type] || colors[this.cardTypes.LANE_CHANGE]; } updateCardGlow(graphics, color, width, height) { graphics.clear(); graphics.lineStyle(4, color, 0.5); graphics.strokeRect(-2, -2, width + 4, height + 4); } getDefaultDescription(cardData) { const effectDescriptions = { [this.effectTypes.NONE]: 'No effect', [this.effectTypes.MOVE]: 'Modify movement', [this.effectTypes.BLOCK]: 'Block effects', [this.effectTypes.SWAP]: 'Swap positions', [this.effectTypes.LANE_CHANGE]: 'Move to adjacent lane\nSelect up to 2 spots\nUsable after 1st turn', [this.effectTypes.REBUFF]: 'Adds +2 to dice roll\nEffect stacks with other Rebuff cards' }; return effectDescriptions[cardData.effect.type] || 'Basic card'; } shuffle() { for (let i = this.gameDeck.length - 1; i > 0; i--) { const j = Math.floor(Math.random() * (i + 1)); [this.gameDeck[i], this.gameDeck[j]] = [this.gameDeck[j], this.gameDeck[i]]; } } drawCard() { if (this.gameDeck.length === 0) { if (this.discardPile.length > 0) { this.gameDeck = this.discardPile.map(card => { card.container.destroy(); const newCard = this.createCard( this.deckPosition.x, this.deckPosition.y, { type: card.type, name: card.name, description: card.description, id: card.id, uniqueId: card.uniqueId, effect: card.effect } ); newCard.container.setScale(1); newCard.container.setRotation(0); newCard.container.setAlpha(1); newCard.container.setDepth(-1); return newCard; }); this.discardPile = []; this.shuffle(); } else { return null; } } return this.gameDeck.pop(); } discardCard(card) { this.discardPile.push(card); this.events.emit(this.eventTypes.CARD_DISCARDED, { card: card, discardPileSize: this.discardPile.length }); card.container.setScale(1); card.container.setRotation(0); card.container.setPosition(this.deckPosition.x, this.deckPosition.y); card.container.setAlpha(0); } drawCardForPlayer(playerIndex) { if (playerIndex === 0) { if (this.scene.currentPlayer !== playerIndex || this.cardsDrawnThisTurn >= 3) { this.scene.showWarningText('Maximum cards drawn this turn!', '#ff0000'); return null; } if (this.playerHand.length >= 3) { this.scene.showWarningText('Hand is full!', '#ff0000'); return null; } } const card = this.drawCard(); if (!card) return null; this.events.emit(this.eventTypes.CARD_DRAWN, { card: card, playerIndex: playerIndex, deckSize: this.gameDeck.length }); card.container.setVisible(true); card.container.setScale(1); card.container.setRotation(0); card.container.setAlpha(1); if (playerIndex === 0) { this.playerHand.push(card); this.cardsDrawnThisTurn++; this.animateCardToHand(card); this.scene.updateCardIndicators(playerIndex, this.playerHand.length); } else { this.aiHands[playerIndex].push(card); card.container.setPosition(this.deckPosition.x, this.deckPosition.y); card.container.setVisible(false); // Keep AI cards hidden card.container.setAlpha(1); } return card; } animateCardToHand(card) { const cardColors = card.colors || this.getCardTypeColors(card.type); const textElements = card.container.list.filter(item => item instanceof Phaser.GameObjects.Text); textElements.forEach((textObject, index) => { textObject.setAlpha(1); textObject.setOrigin(0.5); if (index === 0) { // Title textObject.setStyle({ fontSize: '10px', color: '#FFFFFF', align: 'center', fontStyle: 'bold' }); } else if (index === 1) { // Effect text textObject.setStyle({ fontSize: '10px', color: cardColors.effectColor, align: 'center' }); } else if (index === 2) { // Description textObject.setStyle({ fontSize: '10px', color: '#FFFFFF', align: 'center', wordWrap: { width: 65 }, fixedWidth: 65 }); } else if (index === 3) { // Value textObject.setStyle({ fontSize: '10px', color: cardColors.valueColor, align: 'center' }); } }); const cardSpacing = 90; const totalWidth = (this.playerHand.length - 1) * cardSpacing; const startX = this.handPosition.x - totalWidth / 2; // Animate all cards to their new positions this.playerHand.forEach((handCard, index) => { const targetX = startX + (index * cardSpacing); this.scene.tweens.add({ targets: handCard.container, x: targetX, y: this.handPosition.y - 165 * 0.33, duration: 150, ease: 'Cubic.easeOut', onComplete: () => { if (handCard === card) { this.setHoverEffects(handCard); } } }); }); } setHoverEffects(card) { // Always set interactive for hover effects card.container.setInteractive({ hitArea: new Phaser.Geom.Rectangle(0, 0, 75, 112.5), hitAreaCallback: Phaser.Geom.Rectangle.Contains, useHandCursor: this.scene.currentPlayer === 0 // Only show hand cursor during player's turn }); card.container .on('pointerover', () => { card.container.setDepth(1); this.scene.tweens.add({ targets: card.container, scaleX: 1.1, scaleY: 1.1, y: this.handPosition.y - 25, duration: 100, ease: 'Cubic.easeOut' }); }) .on('pointerout', () => { card.container.setDepth(0); this.scene.tweens.add({ targets: card.container, scaleX: 1, scaleY: 1, y: this.handPosition.y - 165 * 0.33, duration: 200, ease: 'Power2' }); }) .on('pointerdown', () => { // Only allow playing cards during player's turn if (this.scene.currentPlayer === 0) { this.playCard(card); } }); } createTrailParticle(x, y, color = 0x00a2ff) { const particle = this.scene.add.graphics(); particle.fillStyle(color, 0.3); particle.fillCircle(0, 0, 1.5); particle.x = x; particle.y = y; this.scene.tweens.add({ targets: particle, alpha: 0, scale: 0.3, duration: 400, onComplete: () => particle.destroy() }); } playCard(card, playerIndex = 0) { if (this.scene.currentPlayer !== playerIndex) { this.scene.showWarningText('Not your turn!', '#ff0000'); return false; } if (this.scene.turnCount === 1) { this.scene.showWarningText('Cannot play cards on first turn!', '#ff0000'); return false; } if (this.cardsPlayedThisTurn >= 3) { this.scene.showWarningText('Maximum cards played this turn!', '#ff0000'); return false; } this.applyCardEffect(card, playerIndex); this.events.emit(this.eventTypes.CARD_PLAYED, { card: card, playerIndex: playerIndex, handSize: playerIndex === 0 ? this.playerHand.length : this.aiHands[playerIndex].length }); // Check if it's not the player's turn if (playerIndex === 0 && this.scene.currentPlayer !== 0) { this.scene.showWarningText('Not your turn!', '#ff0000'); return false; } if (this.cardsPlayedThisTurn >= 3) { this.scene.showWarningText('Maximum cards played this turn!', '#ff0000'); return false; } let cardIndex; if (playerIndex === 0) { cardIndex = this.playerHand.indexOf(card); if (cardIndex > -1) { this.playerHand.splice(cardIndex, 1); card.container.removeInteractive(); card.container.setDepth(1000); } } else { cardIndex = this.aiHands[playerIndex].indexOf(card); if (cardIndex > -1) { this.aiHands[playerIndex].splice(cardIndex, 1); const aiAvatarPos = this.scene.players[playerIndex].avatar.container; const offsetX = Math.cos(Math.PI) * 30; const offsetY = Math.sin(Math.PI) * 30; card.container.setPosition(aiAvatarPos.x + offsetX, aiAvatarPos.y + offsetY); card.container.setVisible(true); card.container.setDepth(1000); // More subtle initial scale and rotation card.container.setScale(0.5); card.container.setRotation(Math.random() * 0.2 - 0.1); // Animate the card appearing with a gentler animation this.scene.tweens.add({ targets: card.container, scaleX: 1, scaleY: 1, x: aiAvatarPos.x, y: aiAvatarPos.y, duration: 150, ease: 'Cubic.easeOut' }); } } this.cardsPlayedThisTurn++; // Add to discard pile this.discardPile.push(card); // Update card indicators for player this.scene.updateCardIndicators(playerIndex, playerIndex === 0 ? this.playerHand.length : this.aiHands[playerIndex].length); // Set initial position for first card if (!this.firstPlayedCardPosition && this.playedCardsCount === 0) { this.firstPlayedCardPosition = { x: this.scene.centerX, y: this.scene.centerY * 0.95 * 0.95 * 0.95 }; } const maxCards = 3; const spacing = 8; // Reduced spacing between cards const maxRows = 2; // Maximum number of rows const row = Math.min(Math.floor(this.playedCardsCount / maxCards), maxRows); const col = this.playedCardsCount % maxCards; // Calculate offsets with limits to keep cards centered const maxOffsetX = spacing * maxCards / 2; const maxOffsetY = spacing * maxRows / 2; const offsetX = this.firstPlayedCardPosition.x + Math.min(Math.max((col - 1) * spacing, -maxOffsetX), maxOffsetX); const offsetY = this.firstPlayedCardPosition.y + Math.min(row * spacing, maxOffsetY); this.scene.tweens.add({ targets: card.container, x: offsetX, y: offsetY, rotation: Math.random() * 0.2 - 0.1, scale: 0.7, alpha: 0.9, duration: 300, ease: 'Cubic.easeOut', onUpdate: (tween) => { // Emit particles along the path if (Math.random() < 0.15) { // Reduced emission rate const target = tween.targets[0]; this.createTrailParticle( target.x + (Math.random() * 10 - 5), target.y + (Math.random() * 10 - 5), this.scene.playerColors[playerIndex] ); } }, onComplete: () => { this.playedCardsCount++; card.container.setDepth(100); card.container.removeInteractive(); card.container.input = null; // Add glitch effect and fade out after 5 seconds this.scene.time.delayedCall(5000, () => { this.fadeOutPlayedCard(card); }); } }); // Rearrange remaining cards const remainingCards = this.playerHand; const totalWidth = (remainingCards.length - 1) * 90; const startX = this.handPosition.x - totalWidth / 2; remainingCards.forEach((handCard, index) => { const targetX = startX + (index * 90); this.scene.tweens.add({ targets: handCard.container, x: targetX, duration: 300, ease: 'Power2' }); }); } fadeOutPlayedCard(card) { if (!card || !card.container || !card.container.list) { return; } const glitchEffects = []; for (let i = 0; i < 3; i++) { const glitchGraphics = this.scene.add.graphics(); glitchGraphics.lineStyle(2, 0x00a2ff); glitchGraphics.strokeRect(0, 0, 75, 112.5); glitchGraphics.fillStyle(0x001933); glitchGraphics.fillRect(0, 0, 75, 112.5); const originalText = card.container.list.find(item => item instanceof Phaser.GameObjects.Text); let glitchText; if (originalText && originalText.text !== undefined) { glitchText = this.scene.add.text(0, 0, originalText.text, originalText.style).setOrigin(0.5); } else { // Create default text if original text is not found glitchText = this.scene.add.text(0, 0, card.name || '', { fontSize: '12px', color: '#00a2ff', align: 'center' }).setOrigin(0.5); } const glitchClone = this.scene.add.container(card.container.x, card.container.y, [glitchGraphics, glitchText]); glitchClone.setScale(card.container.scaleX, card.container.scaleY); glitchClone.setRotation(card.container.rotation); glitchClone.setAlpha(0.3); glitchEffects.push(glitchClone); } glitchEffects.forEach((glitch, index) => { this.scene.tweens.add({ targets: glitch, x: glitch.x + Phaser.Math.Between(-20, 20), y: glitch.y + Phaser.Math.Between(-20, 20), alpha: 0, duration: 500, delay: index * 100, onComplete: () => glitch.destroy() }); }); this.scene.tweens.add({ targets: card.container, alpha: 0, scaleX: 0.1, scaleY: 0.1, rotation: card.container.rotation + Phaser.Math.FloatBetween(-0.5, 0.5), duration: 800, ease: 'Power2', onComplete: () => { this.discardCard(card); } }); } resetCardsDrawnCounter() { this.cardsDrawnThisTurn = 0; this.cardsPlayedThisTurn = 0; // Reset all effect counters and hide multipliers this.rebuffCounters = [0, 0, 0, 0]; this.scene.players.forEach((player, index) => { // Clear all effect displays player.avatar.rebuffMultiplier.setVisible(false); // Reset any active effects player.activeEffects = { rebuff: 0 }; }); } getPlayerHandCount(playerIndex) { return playerIndex === 0 ? this.playerHand.length : this.aiHands[playerIndex].length; } getCardById(uniqueId) { return this.cards.get(uniqueId); } applyCardEffect(card, playerIndex) { if (!card || !card.effect) return false; const effect = card.effect; const player = this.scene.players[playerIndex]; // Track rebuff cards if (effect.type === this.effectTypes.REBUFF) { this.rebuffCounters[playerIndex]++; // Update the multiplier display only if rebuff cards were played if (this.rebuffCounters[playerIndex] > 0) { const bonus = this.rebuffCounters[playerIndex] * 2; const bonusText = `+${bonus}`; player.avatar.rebuffMultiplier.setText(bonusText); player.avatar.rebuffMultiplier.setVisible(true); } } if (effect.type === this.effectTypes.INTIMIDATION) { // Check if maximum cards have been played first if (this.cardsPlayedThisTurn >= 3) { this.scene.showWarningText('Maximum cards played this turn!', '#ff0000'); return false; } if (!this.scene.hasPlayedFirstTurn) { this.scene.showWarningText('Intimidation only after first turn!', '#ff0000'); return false; } // Set a flag on the player to allow bypassing cars for this turn only player.canBypassCars = true; player.isIntimidating = true; // Show intimidation effect first player.avatar.intimidationEffect.setVisible(true); // Use the new setEmote method with high priority player.avatar.setEmote('(ಠ_ಠ)', 5000, 3); // Display warning about one-turn limitation this.scene.showWarningText('Intimidation active for this turn only!', '#ffff00'); return true; } if (effect.type === this.effectTypes.LANE_CHANGE) { // Check if maximum cards have been played first if (this.cardsPlayedThisTurn >= 3) { this.scene.showWarningText('Maximum cards played this turn!', '#ff0000'); return false; } if (playerIndex > 0) { return false; } // Check if it's after first turn if (!this.scene.hasPlayedFirstTurn) { this.scene.showWarningText('Lane change only after first turn!', '#ff0000'); return false; } // Store original emote and set lane change emote const player = this.scene.players[playerIndex]; player.originalEmote = player.avatar.emoteDisplay.text; player.avatar.emoteDisplay.setText('〜￣△￣〜'); // Reset emote after 3 seconds this.scene.time.delayedCall(3000, () => { this.scene.tweens.add({ targets: player.avatar.emoteDisplay, alpha: 0, duration: 200, onComplete: () => { player.avatar.emoteDisplay.setText(player.originalEmote); this.scene.tweens.add({ targets: player.avatar.emoteDisplay, alpha: 1, duration: 200 }); } }); }); // Get current lane and calculate possible adjacent lanes const currentLane = player.lane; const possibleLanes = []; if (currentLane > 1) possibleLanes.push(currentLane - 1); if (currentLane < 4) possibleLanes.push(currentLane + 1); if (possibleLanes.length > 0) { // Create container for lane change indicators const indicators = this.scene.add.container(0, 0); const targetSpots = []; possibleLanes.forEach(targetLane => { // Get target lane spaces const targetSpaces = this.scene.racewaySpaces[targetLane]; const totalSpaces = targetSpaces.length; // Calculate equivalent position in target lane const currentProgress = player.space / player.totalSpaces; const currentSpaceIndex = Math.floor(currentProgress * totalSpaces); // Get occupied spaces in target lane const occupiedSpaces = this.scene.players .filter(p => p.lane === targetLane) .map(p => p.space); // Calculate 3 closest spaces around equivalent position const possibleSpaces = []; for (let offset = -1; offset <= 1; offset++) { const spaceIndex = ((currentSpaceIndex + offset + totalSpaces) % totalSpaces); // Only add if space is not occupied if (!occupiedSpaces.includes(spaceIndex)) { possibleSpaces.push(spaceIndex); } } // Use available spaces const validSpaces = possibleSpaces; validSpaces.forEach(spaceIndex => { const targetSpace = targetSpaces[spaceIndex]; const circle = this.scene.add.graphics(); circle.lineStyle(2, 0x00ff00, 0.8); circle.strokeCircle(0, 0, 15); circle.setPosition(targetSpace.x, targetSpace.y); const hitArea = new Phaser.Geom.Circle(0, 0, 15); circle.setInteractive(hitArea, Phaser.Geom.Circle.Contains); // Store target data targetSpots.push({ graphic: circle, lane: targetLane, space: spaceIndex }); indicators.add(circle); // Add hover effect circle.on('pointerover', () => { circle.clear(); circle.lineStyle(3, 0x00ff00, 1); circle.strokeCircle(0, 0, 15); }); circle.on('pointerout', () => { circle.clear(); circle.lineStyle(2, 0x00ff00, 0.8); circle.strokeCircle(0, 0, 15); }); // Handle click circle.on('pointerdown', () => { // Remove all indicators targetSpots.forEach(spot => spot.graphic.destroy()); indicators.destroy(); // Change lane and update space // Store target space data for precise movement const targetSpaceData = targetSpaces[spaceIndex]; if (this.scene.changeLane(player, targetLane, targetSpaceData)) { player.space = spaceIndex; return true; } }); }); }); // Auto-cleanup after 5 seconds if no selection this.scene.time.delayedCall(5000, () => { if (indicators.active) { targetSpots.forEach(spot => spot.graphic.destroy()); indicators.destroy(); } }); return true; } return false; } this.events.emit(this.eventTypes.EFFECT_TRIGGERED, { card: card, effect: effect, playerIndex: playerIndex }); if (!this.canApplyEffect(effect, playerIndex)) { return false; } return true; } canApplyEffect(effect, playerIndex) { if (!effect || !effect.conditions) return true; return effect.conditions.every(condition => { switch (condition) { case 'firstTurnComplete': return this.scene.hasPlayedFirstTurn; default: return true; } }); } getEffectValue(effect, playerIndex) { if (!effect || typeof effect.value !== 'number') return 0; // Calculate final effect value based on any modifiers let finalValue = effect.value; // Will implement modifier logic here return finalValue; } setupEventListeners() { this.events.on(this.eventTypes.CARD_DRAWN, (data) => { // Only update indicators if we haven't reached the maximum cards for the turn if (data.playerIndex === 0 && this.cardsDrawnThisTurn <= 3) { this.scene.updateCardIndicators(data.playerIndex, this.getPlayerHandCount(data.playerIndex)); } }); this.events.on(this.eventTypes.CARD_PLAYED, (data) => { // Only update indicators if we haven't played maximum cards for the turn if (this.cardsPlayedThisTurn <= 3) { this.scene.updateCardIndicators(data.playerIndex, data.handSize - 1); } }); this.events.on(this.eventTypes.CARD_DISCARDED, () => {}); this.events.on(this.eventTypes.EFFECT_TRIGGERED, () => {}); } subscribeToEvent(eventType, callback) { if (this.eventTypes[eventType]) { this.events.on(this.eventTypes[eventType], callback); } } unsubscribeFromEvent(eventType, callback) { if (this.eventTypes[eventType]) { this.events.off(this.eventTypes[eventType], callback); } } getAllCards() { return Array.from(this.cards.values()); } getDeckCount() { return this.gameDeck.length; } getDiscardCount() { return this.discardPile.length; } } class Example extends Phaser.Scene { constructor() { super({ key: 'Example' }); this.raceMusic = null; this.cardManager = null; this.turnCount = 1; this.hasPlayedFirstTurn = false; this.lapText = null; this.centerX = 0; this.centerY = 0; this.playedCardsCount = 0; this.players = []; this.currentPlayer = 0; this.playerColors = [0xffb3b3, 0xb3ffb3, 0xb3ccff, 0xffffb3]; this.racewaySpaces = { 1: [], 2: [], 3: [], 4: [] }; this.cardIndicators = []; this.dice = { die1: 1, die2: 1 }; this.deckPosition = { x: 650, y: 420 }; this.handPosition = { x: 79, y: 450 }; } createPlayerAvatar = (index, x, y) => { // Add emote queue and current emote data this.emoteQueue = []; this.currentEmoteTimeout = null; this.isEmoteAnimating = false; const avatarSize = 60; const container = this.add.container(x, y); let emoteDisplay; let crownGraphic; let lapCounterDots; let rebuffMultiplier; // Create rebuff multiplier text rebuffMultiplier = this.add.text(index === 2 || index === 3 ? -(avatarSize + 15) + (avatarSize * 0.25) : avatarSize + 15, index === 2 || index === 3 ? avatarSize * 0.95 : 0, '', { fontSize: '28px', fontStyle: 'bold', color: '#00ffff', stroke: '#003366', strokeThickness: 4, shadow: { blur: 2, color: '#003366', fill: true }, padding: { x: 8, y: 8 } }).setOrigin(0, 0.5).setVisible(false); // Create intimidation effect (initially invisible) const intimidationEffect = this.add.graphics(); intimidationEffect.lineStyle(3, 0xff0000, 0.8); intimidationEffect.setVisible(false); // Create highlight circle (initially invisible) const highlight = this.add.graphics(); highlight.lineStyle(4, this.playerColors[index]); highlight.strokeCircle(0, 0, avatarSize / 2 + 4); highlight.setAlpha(0); // Create avatar background const bg = this.add.graphics(); bg.fillStyle(this.playerColors[index]); bg.fillCircle(0, 0, avatarSize / 2); // Add emote display emoteDisplay = this.add.text(0, 0, '(◕‿◕)', { fontSize: '20px', color: '#00a2ff', fontWeight: 'bold', strokeThickness: 1, shadow: { blur: 2, color: '#003366', stroke: true, fill: true } }).setOrigin(0.5); // Create lap counter dots horizontally (moved 13% to the right total) lapCounterDots = this.add.container(index === 2 ? -(avatarSize / 2 + 22) - (avatarSize * 0.52) : avatarSize / 2 + 22, -10); for (let i = 0; i < 3; i++) { const dot = this.add.graphics(); dot.fillStyle(0xffffff, 0.5); dot.fillCircle(i * 15, 0, 5); lapCounterDots.add(dot); } container.add(lapCounterDots); // Add emote buttons (initially hidden) const emotes = ['(◕‿◕)', '(╯°□°)╯', '¯\\(ツ)/¯', '(っ´ω`)ﾉ']; const emoteButtons = emotes.map((emote, i) => { const button = this.add.text( (i - 1.5) * (avatarSize + 10), avatarSize / 2 + 25, emote, { fontSize: '16px', color: '#ffffff', fontWeight: 'bold', strokeThickness: 1, shadow: { blur: 2, color: '#003366', stroke: true, fill: true } } ).setOrigin(0.5).setInteractive(); button.on('pointerdown', () => { emoteDisplay.setText(emote); }); // Initially hide the button button.setAlpha(0); return button; }); // Removed crown graphic code container.add([highlight, bg, emoteDisplay, intimidationEffect, rebuffMultiplier, ...emoteButtons]); // Add intimidation animation let angle = 0; this.time.addEvent({ delay: 50, callback: () => { if (intimidationEffect.visible) { intimidationEffect.clear(); intimidationEffect.lineStyle(3, 0xff0000, 0.8); // Draw undulating circle const points = []; for (let i = 0; i <= 32; i++) { const pointAngle = (i / 32) * Math.PI * 2; const wave = Math.sin(pointAngle * 6 + angle) * 3; const radius = avatarSize / 2 + 10 + wave; points.push({ x: Math.cos(pointAngle) * radius, y: Math.sin(pointAngle) * radius }); } // Draw the path intimidationEffect.beginPath(); intimidationEffect.moveTo(points[0].x, points[0].y); for (let i = 1; i <= points.length; i++) { const point = points[i % points.length]; intimidationEffect.lineTo(point.x, point.y); } intimidationEffect.strokePath(); angle += 0.1; } }, loop: true }); // Add click handler to the scene for hiding emote buttons this.input.on('pointerdown', (pointer) => { // Check if buttons are visible (alpha > 0) if (emoteButtons[0].alpha > 0) { // Check if click is outside all emote buttons const clickedButton = emoteButtons.some(button => { const bounds = button.getBounds(); return bounds.contains(pointer.x, pointer.y); }); if (!clickedButton) { emoteButtons.forEach((button, i) => { button.disableInteractive(); this.tweens.add({ targets: button, alpha: 0, y: avatarSize / 2 + 15, duration: 200, delay: i * 50, ease: 'Power2' }); }); } } }); container.setInteractive(new Phaser.Geom.Circle(0, 0, avatarSize / 2), Phaser.Geom.Circle.Contains); container.on('pointerover', () => { // Only show emote buttons for Player 1 (index 0) if (index === 0) { emoteButtons.forEach((button, i) => { button.setInteractive({ useHandCursor: true }); this.tweens.add({ targets: button, alpha: 1, y: avatarSize / 2 + 25, duration: 200, delay: i * 50, ease: 'Power2' }); }); } }); container.on('pointerout', () => { const bounds = container.getBounds(); const pointer = this.input.activePointer; // Only hide if not hovering over buttons if (!bounds.contains(pointer.x, pointer.y)) { emoteButtons.forEach((button, i) => { button.disableInteractive(); this.tweens.add({ targets: button, alpha: 0, y: avatarSize / 2 + 15, duration: 200, delay: i * 50, ease: 'Power2' }); }); } }); const setEmote = (emote, duration = 3000, priority = 1) => { // Clear any existing emote timeout if (this.currentEmoteTimeout) { this.time.removeEvent(this.currentEmoteTimeout); } // Store original emote if not already stored if (!emoteDisplay.originalEmote) { emoteDisplay.originalEmote = emoteDisplay.text; } // Fade out current emote this.tweens.add({ targets: emoteDisplay, alpha: 0, duration: 200, onComplete: () => { // Set new emote emoteDisplay.setText(emote); // Fade in new emote this.tweens.add({ targets: emoteDisplay, alpha: 1, duration: 200 }); // Set timeout to restore original emote this.currentEmoteTimeout = this.time.delayedCall(duration, () => { this.tweens.add({ targets: emoteDisplay, alpha: 0, duration: 200, onComplete: () => { emoteDisplay.setText(emoteDisplay.originalEmote); this.tweens.add({ targets: emoteDisplay, alpha: 1, duration: 200 }); } }); }); } }); }; return { container, emoteDisplay, highlight, intimidationEffect, lapCounterDots, rebuffMultiplier, setEmote }; } updateCarHighlight = (playerIndex, isActive) => { const player = this.players[playerIndex]; // Add defensive checks if (!player || !player.container || !player.container.list || !player.container.list[0]) { return; } const car = player.container.list[0]; // Get the car graphics object if (!car || typeof car.clear !== 'function') { return; } if (isActive) { // Add glow effect car.clear(); car.fillStyle(this.playerColors[playerIndex], 1); car.fillCircle(0, 0, 6.5); // Slightly larger for glow effect car.fillStyle(0xFFFFFF, 0.5); car.fillCircle(0, 0, 4.55); // Original size } else { // Reset to normal car.clear(); car.fillStyle(this.playerColors[playerIndex]); car.fillCircle(0, 0, 4.55); // Original size } } preload() { // Load all race music tracks this.load.audio('raceMusic1', 'https://play.rosebud.ai/assets/Untitled (52).mp3?TGFj'); this.load.audio('raceMusic2', 'https://play.rosebud.ai/assets/Untitled (56).mp3?LS1X'); this.load.audio('raceMusic3', 'https://play.rosebud.ai/assets/Untitled (54).mp3?I46O'); } create = () => { // Initialize music tracks this.musicTracks = [ this.sound.add('raceMusic1', { volume: 0.4 }), this.sound.add('raceMusic2', { volume: 0.4 }), this.sound.add('raceMusic3', { volume: 0.4 }) ]; this.currentTrackIndex = 0; // Add completion listener to each track this.musicTracks.forEach((track, index) => { track.on('complete', () => { this.currentTrackIndex = (index + 1) % this.musicTracks.length; this.musicTracks[this.currentTrackIndex].play(); }); }); // Start playing the first track this.musicTracks[0].play(); // Add back button const backButton = this.add.text(20, 20, 'BACK TO MENU', { fontSize: '24px', color: '#FFFFFF', stroke: '#00a2ff', strokeThickness: 1, shadow: { offsetX: 2, offsetY: 2, color: '#00a2ff', blur: 5, stroke: true, fill: true } }) .setInteractive({ useHandCursor: true }) .on('pointerover', () => { backButton.setStyle({ strokeThickness: 2 }); this.tweens.add({ targets: backButton, scaleX: 1.1, scaleY: 1.1, duration: 100 }); }) .on('pointerout', () => { backButton.setStyle({ strokeThickness: 1 }); this.tweens.add({ targets: backButton, scaleX: 1, scaleY: 1, duration: 100 }); }) .on('pointerdown', () => { // Stop all race music tracks before going back to menu if (this.musicTracks) { this.musicTracks.forEach(track => { if (track.isPlaying) { track.stop(); } }); } this.scene.start('MenuScene'); }); this.cameras.main.setBackgroundColor('#000000'); const track = this.add.graphics(); const scale = 0.65; this.centerX = this.cameras.main.width / 2; this.centerY = this.cameras.main.height / 2; this.trackWidth = Math.floor(600 * scale); this.trackHeight = Math.floor(400 * scale); const laneWidth = Math.floor(40 * scale); this.drawStartFinishLines(this.centerX, this.centerY, this.trackWidth, this.trackHeight); this.drawCartesianPlane(this.centerX, this.centerY); this.addLaneMarkers(track, this.centerX, this.centerY, this.trackWidth, this.trackHeight); this.initializePlayers(this.centerX, this.centerY, this.trackWidth, this.trackHeight); this.createDiceUI(); this.cardManager = new CardManager(this); this.createDeckVisual(); // Set initial player highlights this.players[this.currentPlayer].avatar.highlight.setAlpha(1); this.updateCarHighlight(this.currentPlayer, true); // No longer need lap counter text } drawCartesianPlane = (centerX, centerY) => { const gridGraphics = this.add.graphics(); // Draw grid lines gridGraphics.lineStyle(1, 0xFFFFFF, 0.1); // Vertical grid lines for (let x = -400; x <= 400; x += 50) { gridGraphics.beginPath(); gridGraphics.moveTo(centerX + x, centerY - 300); gridGraphics.lineTo(centerX + x, centerY + 300); gridGraphics.strokePath(); } // Horizontal grid lines for (let y = -300; y <= 300; y += 50) { gridGraphics.beginPath(); gridGraphics.moveTo(centerX - 400, centerY + y); gridGraphics.lineTo(centerX + 400, centerY + y); gridGraphics.strokePath(); } // Grid is complete, no labels needed } drawStartFinishLines = (centerX, centerY, trackWidth, trackHeight) => { const lineGraphics = this.add.graphics(); lineGraphics.lineStyle(4, 0xffffb3); const startAngle = -Math.PI / 2; const outerRadius = (trackWidth / 2) * 0.75 * 1.1; const innerRadius = ((trackWidth - 120) / 2) * 0.75 * 1.1; const startX = centerX + outerRadius * Math.cos(startAngle); const startY = (centerY + outerRadius * Math.sin(startAngle)) * 1.22; const endX = centerX + innerRadius * Math.cos(startAngle); const endY = (centerY + innerRadius * Math.sin(startAngle)) * 1.22; lineGraphics.beginPath(); lineGraphics.moveTo(startX, startY); lineGraphics.lineTo(endX, endY); lineGraphics.strokePath(); } addLaneMarkers = (graphics, centerX, centerY, trackWidth, trackHeight) => { graphics.lineStyle(1, 0x00a2ff, 1); // Bright blue outline graphics.fillStyle(0x00a2ff); // Bright blue fill // Define spaces for each lane with fixed positions const laneSpaces = [25, 30, 35, 40]; const laneOffsets = [0, 40, 80, 120]; // Adjusted offsets for wider lanes // Add markers for each lane and store their coordinates laneSpaces.forEach((spaces, laneIndex) => { const lane = laneIndex + 1; this.racewaySpaces[lane] = []; const [width, height] = [trackWidth - laneOffsets[laneIndex], trackHeight - laneOffsets[laneIndex]]; // Calculate fixed positions for each space [...Array(spaces)].forEach((_, spaceIndex) => { // Calculate angle with a slight offset to create discrete positions const angle = ((spaceIndex / spaces) * Math.PI * 2) - Math.PI / 2; // Add a small random offset to create more natural spacing const radiusVariation = 0; const adjustedWidth = width + radiusVariation; const adjustedHeight = height + radiusVariation; // Calculate position with fixed intervals const [x, y] = [ centerX + (adjustedWidth / 2) * Math.cos(angle), centerY + (adjustedHeight / 2) * Math.sin(angle) ]; // Calculate chess-like position identifier const laneLabel = ['A', 'B', 'C', 'D'][laneIndex]; const spaceNumber = (spaceIndex + 1).toString().padStart(2, '0'); const chessId = `${laneLabel}${spaceNumber}`; // Store space data with fixed positions this.racewaySpaces[lane].push({ id: `L${lane}S${spaceIndex}`, chessId: chessId, x: x, y: y, angle: angle, width: adjustedWidth, height: adjustedHeight, occupied: false }); // Draw smaller markers at fixed positions graphics.beginPath(); graphics.arc(x, y, 3.5, 0, Math.PI * 2); graphics.fillCircle(x, y, 3.5); }); }); } createDeckVisual = () => { const deckGraphics = this.add.graphics(); deckGraphics.lineStyle(2, 0x00a2ff); deckGraphics.strokeRect(0, 0, 100, 150); deckGraphics.fillStyle(0x001933); deckGraphics.fillRect(0, 0, 100, 150); const deckContainer = this.add.container(this.deckPosition.x, this.deckPosition.y, [deckGraphics]); deckContainer.setDepth(2000); // Set deck to always be on top // Make the deck clickable deckContainer.setInteractive({ hitArea: new Phaser.Geom.Rectangle(0, 0, 100, 150), hitAreaCallback: Phaser.Geom.Rectangle.Contains, useHandCursor: true }); // Add hover animations let shuffleTimer; deckContainer.on('pointerover', () => { // Scale and lift animation this.tweens.add({ targets: deckContainer, scaleX: 1.1, scaleY: 1.1, y: this.deckPosition.y - 10, duration: 200, ease: 'Power2' }); // Create shuffling effect shuffleTimer = this.time.addEvent({ delay: 100, callback: () => { // Slightly adjust deck position randomly deckContainer.x = this.deckPosition.x + Phaser.Math.Between(-2, 2); deckContainer.y = (this.deckPosition.y - 10) + Phaser.Math.Between(-2, 2); }, loop: true }); }); deckContainer.on('pointerout', () => { // Stop the shuffle effect if (shuffleTimer) { shuffleTimer.destroy(); } // Reset position and scale this.tweens.add({ targets: deckContainer, scaleX: 1, scaleY: 1, x: this.deckPosition.x, y: this.deckPosition.y, duration: 200, ease: 'Power2' }); }); deckContainer.on('pointerdown', () => { if (this.isDiceRolled || this.isDiceRolling) { this.showWarningText('Cannot draw after rolling dice!', '#ff0000'); return; } if (this.currentPlayer !== 0 || this.cardManager.cardsDrawnThisTurn >= 3) { this.showWarningText('Not your turn!', '#ff0000'); return; } this.cardManager.drawCardForPlayer(0); }); } showWarningText = () => {} initializePlayers = (centerX, centerY, trackWidth, trackHeight) => { const avatarPositions = [{ x: 400, y: 500 }, { x: 400, y: 100 }, { x: 700, y: 300 }, { x: 100, y: 300 }]; this.hasCompletedLap = [false, false, false, false]; // Track lap completion status // Create 4 players, one for each lane for (let i = 0; i < 4; i++) { const laneOffset = i * 40; // Updated to match new laneWidth const width = trackWidth - laneOffset; const height = trackHeight - laneOffset; // Calculate starting position (at starting line) const startAngle = -Math.PI / 2; // Top of the track const x = centerX + (width / 2) * Math.cos(startAngle); const y = centerY + (height / 2) * Math.sin(startAngle); // Create player car visual const car = this.add.graphics(); car.fillStyle(this.playerColors[i]); car.fillCircle(0, 0, 4.55); // Reduced car size by 35% (7 * 0.65 = 4.55) // Create container for car const container = this.add.container(x, y, [car]); // Add player data this.players.push({ container: container, lane: i + 1, originalEmote: null, // Track original emote for intimidation space: 0, width: width, height: height, totalSpaces: [25, 30, 35, 40][i], avatar: this.createPlayerAvatar(i, avatarPositions[i].x, avatarPositions[i].y), cardCount: 0, cardIndicators: [], laps: 0, lastAngle: -Math.PI / 2, // Initialize at start/finish line hasPassedStartLine: false, // Track if player has passed start line lapStartAngle: -Math.PI / 2 // Track starting angle for lap calculation }); // Create card indicator squares for all players const squareSize = 15; const spacing = 20; const startX = i === 2 ? avatarPositions[i].x - 95 : avatarPositions[i].x + 40; // Left side for player 3 (moved 5% right), right for others // Only adjust y position for player 1 (index 0) const yPosition = i === 0 ? (avatarPositions[i].y - squareSize / 2 + (squareSize * 0.07)) * 1.035 // 10% higher for player 1 : (avatarPositions[i].y - squareSize / 2 + (squareSize * 0.07)) * 1.15; // Original position for others for (let j = 0; j < 3; j++) { const square = this.add.graphics(); square.lineStyle(2, this.playerColors[i]); square.strokeRect(0, 0, squareSize, squareSize); square.setPosition(startX + j * spacing, yPosition); square.setAlpha(0.3); // Start with low opacity for empty squares this.players[i].cardIndicators.push(square); } } } updateCardIndicators(playerIndex, cardCount) { if (this.players[playerIndex]) { // For all players const player = this.players[playerIndex]; player.cardIndicators.forEach((square, index) => { if (index < cardCount) { // Fill square when card is drawn this.tweens.add({ targets: square, alpha: 1, duration: 300, ease: 'Power2' }); } else { // Empty square this.tweens.add({ targets: square, alpha: 0.3, duration: 300, ease: 'Power2' }); } }); } } createDiceUI = () => { this.diceContainer = this.add.container(700, 115); this.die1Visual = this.add.graphics(); this.die2Visual = this.add.graphics(); this.die1Visual.setPosition(0, 0); this.die2Visual.setPosition(0, 60); this.die1Visual.setRotation(0.2); this.die2Visual.setRotation(0.2); this.diceContainer.add([this.die1Visual, this.die2Visual]); // Make dice container interactive const hitArea = new Phaser.Geom.Rectangle(-20, -20, 120, 100); this.diceContainer.setInteractive({ hitArea: hitArea, hitAreaCallback: Phaser.Geom.Rectangle.Contains, useHandCursor: true }); // Add hover effect to dice // Add hover effect to dice with random number changes let isHovering = false; this.diceContainer.on('pointerover', () => { if (!isHovering) { isHovering = true; this.tweens.add({ targets: this.diceContainer, scaleX: 1.2, scaleY: 1.2, duration: 150, ease: 'Back.easeOut' }); } }); this.diceContainer.on('pointerout', () => { if (isHovering) { isHovering = false; this.tweens.add({ targets: this.diceContainer, scaleX: 1, scaleY: 1, duration: 150, ease: 'Back.easeOut' }); } }); // Add click handler for rolling this.diceContainer.on('pointerdown', () => this.rollDice()); this.updateDiceVisuals(); } drawDieDots = (dieGraphics, value, offsetX = 0, offsetY = 0) => { // Draw glow effect first dieGraphics.fillStyle(0x00a2ff, 0.3); const dotPositions = { 1: [ [0, 0] ], 2: [ [-10, -10], [10, 10] ], 3: [ [-10, -10], [0, 0], [10, 10] ], 4: [ [-10, -10], [10, -10], [-10, 10], [10, 10] ], 5: [ [-10, -10], [10, -10], [0, 0], [-10, 10], [10, 10] ], 6: [ [-10, -10], [10, -10], [-10, 0], [10, 0], [-10, 10], [10, 10] ] }; const dots = dotPositions[value]; // Draw outer glow dots.forEach(([x, y]) => { dieGraphics.fillCircle(x + offsetX, y + offsetY, 6); }); // Draw bright inner dots dieGraphics.fillStyle(0x00ffff); dots.forEach(([x, y]) => { dieGraphics.fillCircle(x + offsetX, y + offsetY, 3); }); } updateDiceVisuals = () => { // Update first die this.die1Visual.clear(); // Update second die this.die2Visual.clear(); // Draw dots for each die with glowing effect this.drawDieDots(this.die1Visual, this.dice.die1); this.drawDieDots(this.die2Visual, this.dice.die2); } rollDice = () => { if (this.isDiceRolling) { return; } if (this.currentPlayer === 0 && !this.cardManager.getPlayerHandCount(0) && !this.cardManager.cardsDrawnThisTurn) { this.showWarningText('Draw at least one card before rolling!', '#ff0000'); this.diceContainer.setInteractive({ useHandCursor: true }); return; } const player = this.players[this.currentPlayer]; // Disable dice container during animation this.diceContainer.disableInteractive(); // Set dice rolling state this.isDiceRolling = true; this.isDiceRolled = true; // Initial dramatic roll animation let shakeDuration = 1500; let rolls = 15; let currentRoll = 0; // Create dramatic roll animation const rollTimer = this.time.addEvent({ delay: shakeDuration / rolls, callback: () => { // Generate random temporary values during roll this.dice.die1 = Phaser.Math.Between(1, 6); this.dice.die2 = Phaser.Math.Between(1, 6); // Update only the dice visuals without moving the container this.die1Visual.setRotation(0.2); this.die2Visual.setRotation(0.2); this.updateDiceVisuals(); currentRoll++; if (currentRoll >= rolls) { // Final values this.dice.die1 = Phaser.Math.Between(1, 6); this.dice.die2 = Phaser.Math.Between(1, 6); // Keep rotation fixed at 0.2 this.die1Visual.setRotation(0.2); this.die2Visual.setRotation(0.2); // Final dramatic reveal this.tweens.add({ targets: this.diceContainer, scaleX: [1.4, 1], scaleY: [1.4, 1], duration: 400, ease: 'Back.easeOut', onComplete: () => { this.updateDiceVisuals(); // Calculate rebuff bonus only from actual rebuff cards played const rebuffBonus = this.cardManager.rebuffCounters[this.currentPlayer] * 2; let movement = this.dice.die1 + this.dice.die2 + rebuffBonus; // Ensure minimum movement of 1 space movement = Math.max(1, movement); // Get current player reference first const currentPlayerObj = this.players[this.currentPlayer]; // Update avatar expression based on dice roll and clear intimidation let newEmote; // Clear intimidation flag if it exists if (currentPlayerObj.isIntimidating) { currentPlayerObj.isIntimidating = false; } if (movement >= 11) { newEmote = '(≖‿≖)'; // Very happy } else if (movement >= 9) { newEmote = '(っ´ω`)ﾉ'; // Happy } else if (movement >= 5) { newEmote = ':(・―・)'; // Neutral } else { newEmote = '(╯°□°)╯'; // Frustrated } // Show dice result with new setEmote method const diceResult = `[${this.dice.die1}+${this.dice.die2}]`; currentPlayerObj.avatar.setEmote(diceResult, 1000, 2); // After delay, show emotional emote this.time.delayedCall(1200, () => { currentPlayerObj.avatar.setEmote(newEmote, 3000, 1); }); this.time.delayedCall(300, () => { // Ensure movement is applied if (movement > 0) { this.movePlayer(currentPlayerObj, currentPlayerObj.space + movement); } else { // Failsafe: move at least one space if all effects reduced movement to 0 this.movePlayer(currentPlayerObj, currentPlayerObj.space + 1); this.showWarningText('Minimum movement: 1 space', '#ffff00'); } // currentPlayer change and highlight update will happen in movePlayer's onComplete // No need to draw cards here as it's handled at the start of turn if (this.currentPlayer > 0) { // Just enable the dice container this.diceContainer.setInteractive({ useHandCursor: true }); } this.diceContainer.setInteractive({ useHandCursor: true }); }); } }); } }, repeat: rolls - 1 }); } checkLeadingPlayer = () => { // Clear any lingering intimidation effects this.players.forEach((player) => { if (player.isIntimidating) { player.isIntimidating = false; player.canBypassCars = false; player.avatar.intimidationEffect.setVisible(false); if (player.originalEmote) { player.avatar.emoteDisplay.setText(player.originalEmote); player.originalEmote = null; } } }); } movePlayer = (player, newSpace) => { const currentLaneSpaces = this.racewaySpaces[player.lane]; const totalSpacesInLane = currentLaneSpaces.length; const playerIndex = this.players.indexOf(player); const currentPlayerTotalProgress = player.space / player.totalSpaces; // Find all players in the same lane const playersInLane = this.players.filter(p => p.lane === player.lane && p !== player); // Calculate the maximum allowed space based on other players' positions let maxAllowedSpace = newSpace; // Check for players ahead in the same lane if (playersInLane.length > 0) { const playersAhead = playersInLane.map(p => { const progress = p.space / p.totalSpaces; return { player: p, progress: progress, space: p.space }; }).filter(p => p.progress > currentPlayerTotalProgress); if (playersAhead.length > 0) { // Sort by progress to find the closest player ahead playersAhead.sort((a, b) => a.progress - b.progress); const closestAhead = playersAhead[0]; // If not using intimidation, block movement past other cars if (!player.canBypassCars) { // Calculate the space one position behind the closest player ahead maxAllowedSpace = (closestAhead.space - 1 + totalSpacesInLane) % totalSpacesInLane; // Ensure we don't move past the closest player ahead if (newSpace > maxAllowedSpace) { newSpace = maxAllowedSpace; // Show blocking message this.showWarningText('Car ahead is blocking! Use Intimidation to pass.', '#ff0000'); } } else { // When using intimidation, still prevent sharing the same space if (newSpace === closestAhead.space) { newSpace = (closestAhead.space - 1 + totalSpacesInLane) % totalSpacesInLane; } } } } // Calculate target space and movement with wrap-around handling let targetSpace = ((newSpace % totalSpacesInLane) + totalSpacesInLane) % totalSpacesInLane; let spacesToMove = newSpace - player.space; // Check if target space is occupied const isSpaceOccupied = this.players.some(p => p !== player && p.lane === player.lane && p.space === targetSpace ); if (isSpaceOccupied) { // Always find nearest space behind occupied space, even with intimidation targetSpace = this.findNearestUnoccupiedSpace(player, targetSpace, currentLaneSpaces); spacesToMove = (targetSpace - player.space + totalSpacesInLane) % totalSpacesInLane; if (!player.canBypassCars) { this.showWarningText('Space occupied! Cannot share spaces.', '#ff0000'); } } // Intimidation allows bypassing cars during movement but not sharing spaces // Set new target space within bounds targetSpace = Math.min(Math.max(0, targetSpace), currentLaneSpaces.length - 1); // Handle wrap-around movement if (player.space + spacesToMove >= player.totalSpaces) { const totalDistance = spacesToMove; spacesToMove = totalDistance % totalSpacesInLane; newSpace = (player.space + spacesToMove) % totalSpacesInLane; } this.players.forEach((p, idx) => { p.totalProgress = p.space / p.totalSpaces; }); // Calculate angles for forward movement const startAngle = (player.space / totalSpacesInLane) * Math.PI * 2 - Math.PI / 2; const endAngle = (targetSpace / totalSpacesInLane) * Math.PI * 2 - Math.PI / 2; let totalAngleDiff = endAngle - startAngle; // Adjust for forward movement across finish line if (totalAngleDiff < 0) { totalAngleDiff += Math.PI * 2; } const moveData = { t: 0, fromAngle: startAngle, angleDiff: totalAngleDiff }; // Animate movement this.tweens.add({ targets: moveData, t: 1, duration: 1000, ease: 'Power2', onUpdate: () => { const interpolatedAngle = moveData.fromAngle + (moveData.angleDiff * moveData.t); // Check for lap completion // Convert angles to range [0, 2π] const normalizedLastAngle = ((player.lastAngle % (2 * Math.PI)) + 2 * Math.PI) % (2 * Math.PI); const normalizedCurrentAngle = ((interpolatedAngle % (2 * Math.PI)) + 2 * Math.PI) % (2 * Math.PI); const startLineAngle = 3 * Math.PI / 2; // -π/2 normalized to [0, 2π] // Check if we've crossed the start/finish line if (normalizedLastAngle < startLineAngle && normalizedCurrentAngle >= startLineAngle) { // Only count lap if we've made a full circuit if (player.hasPassedStartLine || player.laps === 0) { player.laps = Math.min(player.laps + 1, 3); this.updateLapCounterDots(player, player.laps); // Check for victory condition if (player.laps >= 3) { // Stop all race music tracks if (this.musicTracks) { this.musicTracks.forEach(track => { if (track.isPlaying) { track.stop(); } }); } // Transition to victory scene const playerIndex = this.players.indexOf(player); this.scene.start('VictoryScene', { winner: playerIndex, playerColors: this.playerColors }); return; } // Visual feedback for lap completion const lapCompleteText = this.add.text(player.container.x, player.container.y - 20, `LAP ${player.laps}!`, { fontSize: '16px', fontStyle: 'bold', fill: '#ffffff', stroke: '#000000', strokeThickness: 4 }).setOrigin(0.5); this.tweens.add({ targets: lapCompleteText, y: lapCompleteText.y - 40, alpha: 0, duration: 1000, onComplete: () => lapCompleteText.destroy() }); } player.hasPassedStartLine = true; player.lapStartAngle = interpolatedAngle; } player.lastAngle = interpolatedAngle; // Calculate new position ensuring forward movement const finalX = this.centerX + (player.width / 2) * Math.cos(interpolatedAngle); const finalY = this.centerY + (player.height / 2) * Math.sin(interpolatedAngle); // Update car position player.container.setPosition(finalX, finalY); }, onComplete: () => { // Set the final space position player.space = newSpace; // Check and update leading player this.checkLeadingPlayer(); // Remove highlights from current player this.players[this.currentPlayer].avatar.highlight.setAlpha(0); this.updateCarHighlight(this.currentPlayer, false); this.currentPlayer = (this.currentPlayer + 1) % 4; // Update card interactivity based on current player if (this.cardManager.playerHand.length > 0) { this.cardManager.playerHand.forEach(card => { // Always keep cards interactive for hover effects card.container.setInteractive({ hitArea: new Phaser.Geom.Rectangle(0, 0, 75, 112.5), hitAreaCallback: Phaser.Geom.Rectangle.Contains, useHandCursor: this.currentPlayer === 0 // Only show hand cursor during player's turn }); }); } // Set hasPlayedFirstTurn to true after first player completes their turn if (this.currentPlayer === 0) { this.hasPlayedFirstTurn = true; // Increment turn count when we come back to player 1 this.turnCount++; // Find the current leader before updating display // Check positions directly without lap counting let maxProgress = -1; let leaderIndex = 0; this.players.forEach((player, index) => { const progress = player.space / player.totalSpaces; if (progress > maxProgress) { maxProgress = progress; leaderIndex = index; } }); } // Reset cards drawn counter and all turn-based effects this.cardManager.resetCardsDrawnCounter(); // Reset dice states, lane change tracking, and buff/boost effects this.isDiceRolled = false; this.players.forEach(p => { p.hasChangedLane = false; p.originalLane = null; // Clear buff/boost effects if (p.avatar && p.avatar.rebuffMultiplier) { p.avatar.rebuffMultiplier.setVisible(false); } }); this.isDiceRolling = false; // Reset intimidation effect at end of turn and check leading player if (player.canBypassCars || player.isIntimidating) { player.canBypassCars = false; player.isIntimidating = false; player.avatar.intimidationEffect.setVisible(false); // Reset emote if it was changed by intimidation if (player.originalEmote) { player.avatar.emoteDisplay.setText(player.originalEmote); player.originalEmote = null; } // Force a check of the leading player to ensure crown is updated this.checkLeadingPlayer(); } // Add highlights to new current player with fade effect this.updateCarHighlight(this.currentPlayer, true); this.tweens.add({ targets: this.players[this.currentPlayer].avatar.highlight, alpha: 1, duration: 300, ease: 'Power2', onComplete: () => { // If next player is AI, handle their turn if (this.currentPlayer > 0) { // First draw cards if needed const cardsToDraw = 3 - this.cardManager.getPlayerHandCount(this.currentPlayer); // Function to play AI cards const playAICards = () => { const aiHand = this.cardManager.aiHands[this.currentPlayer]; // Check if AI has any cards to play if (aiHand.length === 0) { // If no cards, just roll the dice this.time.delayedCall(500, () => { this.rollDice(); }); return; } // Don't play cards if it's first turn let cardsToPlay = this.turnCount === 1 ? 0 : Math.min(3, aiHand.length); // Track the original lane for this turn const originalLane = this.players[this.currentPlayer].lane; let hasChangedLane = false; const playNextCard = (index) => { if (index < cardsToPlay && aiHand.length > 0) { const card = aiHand[0]; // Always play first card this.time.delayedCall(500, () => { // Only animate if the card has a proper effect if (card && card.effect && (card.effect.type === this.cardManager.effectTypes.REBUFF || card.effect.type === this.cardManager.effectTypes.INTIMIDATION)) { // Flash the AI's avatar to indicate card play this.tweens.add({ targets: this.players[this.currentPlayer].avatar.container, scale: 1.2, duration: 100, yoyo: true, onComplete: () => { if (card.effect.type === this.cardManager.effectTypes.LANE_CHANGE) { // Handle lane change card for AI this.handleAILaneChange(card, this.currentPlayer); } else if (card) { this.cardManager.playCard(card, this.currentPlayer); } this.updateCardIndicators(this.currentPlayer, this.cardManager.getPlayerHandCount(this.currentPlayer)); playNextCard(index + 1); } }); } else { // If no proper effect, just play the card without animation if (card.effect.type === this.cardManager.effectTypes.LANE_CHANGE) { this.handleAILaneChange(card, this.currentPlayer); } else if (card) { this.cardManager.playCard(card, this.currentPlayer); } this.updateCardIndicators(this.currentPlayer, this.cardManager.getPlayerHandCount(this.currentPlayer)); playNextCard(index + 1); } }); } else { // After playing cards, roll the dice this.time.delayedCall(500, () => { this.rollDice(); }); } }; playNextCard(0); }; // Schedule card drawing const drawPromises = []; for (let i = 0; i < cardsToDraw; i++) { const promise = new Promise(resolve => { this.time.delayedCall(i * 300, () => { // Check if deck is empty const card = this.cardManager.drawCardForPlayer(this.currentPlayer); if (card) { this.updateCardIndicators(this.currentPlayer, this.cardManager.getPlayerHandCount(this.currentPlayer)); } resolve(); }); }); drawPromises.push(promise); } // After all cards are drawn, roll the dice Promise.all(drawPromises).then(() => { // Start playing AI cards after drawing this.time.delayedCall(500, () => { playAICards(); }); }); } } }); } }); } changeLane(player, targetLane, targetSpaceData) { if (targetLane < 1 || targetLane > 4 || targetLane === player.lane) return false; if (!targetSpaceData) return false; // Calculate current angle before lane change const currentAngle = Math.atan2( player.container.y - this.centerY, player.container.x - this.centerX ); // Preserve the angle for lap counting player.lastAngle = currentAngle; // Get target lane spaces and validate const targetLaneSpaces = this.racewaySpaces[targetLane]; const newTotalSpaces = targetLaneSpaces.length; // Calculate relative progress in current lane const currentProgress = player.space / player.totalSpaces; // Update player properties for new lane player.lane = targetLane; // Calculate new space index from target space data const newSpace = targetLaneSpaces.findIndex(space => space.x === targetSpaceData.x && space.y === targetSpaceData.y ); player.space = newSpace; player.totalSpaces = newTotalSpaces; player.width = this.trackWidth - ((targetLane - 1) * 40); player.height = this.trackHeight - ((targetLane - 1) * 40); // Animate the movement to the new position this.tweens.add({ targets: player.container, x: targetSpaceData.x, y: targetSpaceData.y, duration: 500, ease: 'Power2', onStart: () => { // Create trail effect during lane change const trailTimer = this.time.addEvent({ delay: 50, callback: () => { const color = this.playerColors[this.players.indexOf(player)]; this.cardManager.createTrailParticle( player.container.x + (Math.random() * 10 - 5), player.container.y + (Math.random() * 10 - 5), color ); }, repeat: 9 }); }, onComplete: () => { // Update leading player after lane change is complete this.checkLeadingPlayer(); } }); return true; } updateLapCounterDots(player, laps) { const dots = player.avatar.lapCounterDots.list; dots.forEach((dot, index) => { dot.clear(); if (index < laps) { // Completed lap dot dot.fillStyle(0xffffff, 1); dot.fillCircle(index * 15, 0, 5); } else { // Empty dot dot.fillStyle(0xffffff, 0.3); dot.fillCircle(index * 15, 0, 5); } }); } findNearestUnoccupiedSpace(player, targetSpace, laneSpaces) { let backward = targetSpace; const totalSpaces = laneSpaces.length; // Only check spaces backward to ensure player stays behind when space is occupied for (let i = 0; i < totalSpaces; i++) { backward = (backward - 1 + totalSpaces) % totalSpaces; // Check if backward space is occupied const isBackwardOccupied = this.players.some(p => p !== player && p.lane === player.lane && p.space === backward ); // Return first unoccupied space found when moving backward if (!isBackwardOccupied) return backward; } // If no space found, return original target (shouldn't happen with proper checks) return targetSpace; } handleAILaneChange(card, playerIndex) { const player = this.players[playerIndex]; const currentLane = player.lane; const originalLane = player.originalLane || currentLane; // Track original lane let possibleLanes = []; // Check if there's a car blocking in the current lane const currentLaneSpaces = this.racewaySpaces[currentLane]; const currentProgress = player.space / player.totalSpaces; const isBlocked = this.players.some(p => p !== player && p.lane === currentLane && p.space > player.space && p.space < player.space + 3 // Check if car is within 3 spaces ahead ); // Filter out the original lane if AI has already changed lanes this turn if (currentLane > 1 && !isBlocked) { // If not blocked and not in lane 1, try to move towards lane 1 if (player.hasChangedLane && currentLane - 1 === originalLane) { // Skip moving back to original lane } else { possibleLanes.push(currentLane - 1); } } else if (isBlocked) { // If blocked, consider adjacent lanes except the original lane if already changed if (currentLane > 1 && (!player.hasChangedLane || currentLane - 1 !== originalLane)) { possibleLanes.push(currentLane - 1); } if (currentLane < 4 && (!player.hasChangedLane || currentLane + 1 !== originalLane)) { possibleLanes.push(currentLane + 1); } } // If no valid moves or would return to original lane, save the card if (possibleLanes.length === 0 || (player.hasChangedLane && possibleLanes.every(lane => lane === originalLane))) { return false; // Signal that the card should be saved } if (possibleLanes.length > 0) { // Create container for lane change indicators (same as player) const indicators = this.add.container(0, 0); const targetSpots = []; // Show the same visual indicators as player possibleLanes.forEach(targetLane => { const targetSpaces = this.racewaySpaces[targetLane]; const totalSpaces = targetSpaces.length; const currentProgress = player.space / player.totalSpaces; const currentSpaceIndex = Math.floor(currentProgress * totalSpaces); // Get occupied spaces in target lane const occupiedSpaces = this.players .filter(p => p.lane === targetLane) .map(p => p.space); // Calculate possible spaces same as player const possibleSpaces = []; for (let offset = -1; offset <= 1; offset++) { const spaceIndex = ((currentSpaceIndex + offset + totalSpaces) % totalSpaces); if (!occupiedSpaces.includes(spaceIndex)) { possibleSpaces.push(spaceIndex); } } possibleSpaces.forEach(spaceIndex => { const targetSpace = targetSpaces[spaceIndex]; const circle = this.add.graphics(); circle.lineStyle(2, 0x00ff00, 0.8); circle.strokeCircle(0, 0, 15); circle.setPosition(targetSpace.x, targetSpace.y); targetSpots.push({ graphic: circle, lane: targetLane, space: spaceIndex }); indicators.add(circle); }); }); // AI decision making - choose best spot after 1 second this.time.delayedCall(1000, () => { if (targetSpots.length > 0) { // AI prioritizes spots that provide best advancement const bestSpot = targetSpots.reduce((best, current) => { // Check if the target lane is clear ahead const isLaneClear = !this.players.some(p => p !== player && p.lane === current.lane && p.space > current.space && p.space < current.space + 3 ); // Prioritize clear lanes if (isLaneClear && !best.isLaneClear) return current; if (!isLaneClear && best.isLaneClear) return best; // If both lanes are equally clear/blocked if (current.lane < best.lane) return current; if (current.lane > best.lane) return best; // If same lane, choose furthest forward spot return (current.space > best.space) ? current : best; }, { ...targetSpots[0], isLaneClear: !this.players.some(p => p !== player && p.lane === targetSpots[0].lane && p.space > targetSpots[0].space && p.space < targetSpots[0].space + 3 ) }); // Highlight chosen spot const chosenGraphic = bestSpot.graphic; chosenGraphic.clear(); chosenGraphic.lineStyle(3, 0x00ff00, 1); chosenGraphic.strokeCircle(0, 0, 15); // Execute move after showing choice this.time.delayedCall(500, () => { // Clean up indicators targetSpots.forEach(spot => spot.graphic.destroy()); indicators.destroy(); // Execute the lane change const targetSpaceData = this.racewaySpaces[bestSpot.lane][bestSpot.space]; if (this.changeLane(player, bestSpot.lane, targetSpaceData)) { player.space = bestSpot.space; player.hasChangedLane = true; // Mark that the AI has changed lanes this turn player.originalLane = originalLane; // Store the original lane // Play the card after successful lane change this.cardManager.playCard(card, playerIndex); } }); } }); } } } class MenuScene extends Phaser.Scene { constructor() { super({ key: 'MenuScene' }); this.selectedIndex = 0; this.menuMusic = null; this.menuItems = [{ text: 'ARCADE MODE', scene: 'Example' }, { text: 'GRAND TOUR MODE', scene: null }, { text: 'MULTIPLAYER', scene: null }, { text: 'CREDITS', scene: null }]; } preload() { this.load.audio('menuMusic', 'https://play.rosebud.ai/assets/Untitled (55).mp3?ljNX'); } create() { // Create and play menu music this.menuMusic = this.sound.add('menuMusic', { loop: true, volume: 0.5 }); this.menuMusic.play(); // Set background color this.cameras.main.setBackgroundColor('#1A1A1A'); // Add grid effect const gridGraphics = this.add.graphics(); gridGraphics.lineStyle(1, 0xFFFFFF, 0.1); const gridSize = 50; for (let x = 0; x < this.game.config.width; x += gridSize) { gridGraphics.moveTo(x, 0); gridGraphics.lineTo(x, this.game.config.height); } for (let y = 0; y < this.game.config.height; y += gridSize) { gridGraphics.moveTo(0, y); gridGraphics.lineTo(this.game.config.width, y); } gridGraphics.strokePath(); // Create title container const titleContainer = this.add.container(this.game.config.width / 2, 100); // Emotes to cycle through const emotes = ['(◕‿◕)', '(╯°□°)╯', '¯\\(ツ)/¯', '(っ´ω`)ﾉ']; // Create avatars with emotes const avatarSize = 60; const avatarPositions = [{ x: -200 + (this.game.config.width * 0.02), y: 0 }, { x: -100 + (this.game.config.width * 0.02), y: 0 }, { x: 100 + (this.game.config.width * 0.02), y: 0 }, { x: 200 + (this.game.config.width * 0.02), y: 0 }]; const playerColors = [0xffb3b3, 0xb3ffb3, 0xb3ccff, 0xffffb3]; avatarPositions.forEach((pos, index) => { // Create avatar background const avatarBg = this.add.graphics(); avatarBg.fillStyle(playerColors[index]); avatarBg.fillCircle(0, 0, avatarSize / 2); // Create emote text const emoteText = this.add.text(0, 0, emotes[0], { fontSize: '20px', color: '#00a2ff', fontWeight: 'bold', strokeThickness: 1, shadow: { blur: 2, color: '#003366', stroke: true, fill: true } }).setOrigin(0.5); // Create glow effect const glow = this.add.graphics(); glow.lineStyle(4, playerColors[index], 0.5); glow.strokeCircle(0, 0, avatarSize / 2 + 4); glow.setAlpha(0); // Create container for avatar const container = this.add.container(pos.x, pos.y, [glow, avatarBg, emoteText]); titleContainer.add(container); // Add hover effect container.setInteractive(new Phaser.Geom.Circle(0, 0, avatarSize / 2), Phaser.Geom.Circle.Contains); container.on('pointerover', () => { this.tweens.add({ targets: glow, alpha: 1, duration: 200 }); }); container.on('pointerout', () => { this.tweens.add({ targets: glow, alpha: 0, duration: 200 }); }); // Add emote cycling this.time.addEvent({ delay: Phaser.Math.Between(2000, 4000), callback: () => { if (Phaser.Math.Between(0, 100) < 15) { // 15% chance to change const currentEmote = emoteText.text; const newEmote = emotes[Phaser.Math.Between(0, emotes.length - 1)]; // Fade out current emote this.tweens.add({ targets: emoteText, alpha: 0, duration: 100, onComplete: () => { emoteText.setText(newEmote); // Fade in new emote this.tweens.add({ targets: emoteText, alpha: 1, duration: 100 }); } }); } }, loop: true }); // Add floating animation this.tweens.add({ targets: container, y: pos.y + Phaser.Math.Between(-5, 5), duration: Phaser.Math.Between(1500, 2500), yoyo: true, repeat: -1, ease: 'Sine.easeInOut', delay: index * 200 }); }); // Create title text const word = 'RACEWAY'; const letters = []; const spacing = 50; word.split('').forEach((char, index) => { const xPos = (index - word.length / 2) * spacing + (this.game.config.width * 0.05); // Move 5% right const letter = this.add.text(xPos, 0, char, { fontSize: '64px', fontStyle: 'bold', color: '#FFFFFF', stroke: '#00a2ff', strokeThickness: 2, shadow: { offsetX: 2, offsetY: 2, color: '#00a2ff', blur: 10, stroke: true, fill: true } }).setOrigin(0.5); titleContainer.add(letter); letters.push(letter); // Add letter animation this.tweens.add({ targets: letter, y: { getStart: () => 0, getEnd: () => Phaser.Math.Between(-3, 3) }, rotation: { getStart: () => 0, getEnd: () => Phaser.Math.FloatBetween(-0.05, 0.05) }, scaleX: { getStart: () => 1, getEnd: () => Phaser.Math.FloatBetween(0.95, 1.05) }, scaleY: { getStart: () => 1, getEnd: () => Phaser.Math.FloatBetween(0.95, 1.05) }, duration: Phaser.Math.Between(800, 1200), yoyo: true, repeat: -1, ease: 'Sine.easeInOut', delay: index * 100 }); }); // Create menu items this.menuTexts = this.menuItems.map((item, index) => { const y = this.game.config.height / 2 + (index - this.menuItems.length / 2) * 60; const text = this.add.text(this.game.config.width / 2, y, item.text, { fontSize: '32px', color: '#FFFFFF', stroke: '#00a2ff', strokeThickness: 1 }) .setOrigin(0.5) .setInteractive({ useHandCursor: true }) .on('pointerdown', () => this.selectMenuItem(index)) .on('pointerover', () => this.hoverMenuItem(index)); return text; }); // Add keyboard controls this.input.keyboard.on('keydown-UP', () => this.changeSelection(-1)); this.input.keyboard.on('keydown-DOWN', () => this.changeSelection(1)); this.input.keyboard.on('keydown-ENTER', () => this.selectMenuItem(this.selectedIndex)); // Initial update of menu items this.updateMenuItems(); } changeSelection(direction) { this.selectedIndex = (this.selectedIndex + direction + this.menuItems.length) % this.menuItems.length; this.updateMenuItems(); } hoverMenuItem(index) { this.selectedIndex = index; this.updateMenuItems(); } selectMenuItem(index) { const item = this.menuItems[index]; if (item.scene) { // Stop menu music before starting new scene if (this.menuMusic) { this.menuMusic.stop(); } this.scene.start(item.scene); } else { // Show "Coming Soon" message const message = this.add.text(this.game.config.width / 2, this.game.config.height - 100, 'Coming Soon!', { fontSize: '24px', color: '#00a2ff', stroke: '#FFFFFF', strokeThickness: 1 }).setOrigin(0.5); this.tweens.add({ targets: message, alpha: 0, y: this.game.config.height - 150, duration: 2000, ease: 'Power2', onComplete: () => message.destroy() }); } } updateMenuItems() { this.menuTexts.forEach((text, index) => { const distance = Math.abs(index - this.selectedIndex); const alpha = 1 - (distance * 0.3); const scale = index === this.selectedIndex ? 1.2 : 1; const glow = index === this.selectedIndex ? 10 : 0; this.tweens.add({ targets: text, alpha: alpha, scaleX: scale, scaleY: scale, duration: 200, ease: 'Power2' }); text.setStyle({ strokeThickness: index === this.selectedIndex ? 2 : 1, shadow: { offsetX: 2, offsetY: 2, color: '#00a2ff', blur: glow, stroke: true, fill: true } }); }); } } class VictoryScene extends Phaser.Scene { constructor() { super({ key: 'VictoryScene' }); } init(data) { this.winner = data.winner; this.playerColors = data.playerColors; } preload() { this.load.audio('victoryMusic', 'https://play.rosebud.ai/assets/Untitled (54).mp3?I46O'); } create() { // Play victory music const victoryMusic = this.sound.add('victoryMusic', { volume: 0.4 }); victoryMusic.play(); // Set background color this.cameras.main.setBackgroundColor('#1A1A1A'); // Add grid effect const gridGraphics = this.add.graphics(); gridGraphics.lineStyle(1, 0xFFFFFF, 0.1); const gridSize = 50; for (let x = 0; x < this.game.config.width; x += gridSize) { gridGraphics.moveTo(x, 0); gridGraphics.lineTo(x, this.game.config.height); } for (let y = 0; y < this.game.config.height; y += gridSize) { gridGraphics.moveTo(0, y); gridGraphics.lineTo(this.game.config.width, y); } gridGraphics.strokePath(); // Create victory text with animation const victoryText = this.add.text(this.game.config.width / 2, 150, this.winner === 0 ? 'VICTORY!' : 'GAME OVER!', { fontSize: '64px', fontStyle: 'bold', color: '#FFFFFF', stroke: '#00a2ff', strokeThickness: 2, shadow: { offsetX: 2, offsetY: 2, color: '#00a2ff', blur: 10, stroke: true, fill: true } }).setOrigin(0.5); // Add winner information const winnerText = this.add.text(this.game.config.width / 2, 250, `Player ${this.winner + 1} Wins!`, { fontSize: '32px', color: '#FFFFFF', stroke: '#00a2ff', strokeThickness: 1 }).setOrigin(0.5); // Create winner avatar const avatarSize = 80; const avatarContainer = this.add.container(this.game.config.width / 2, 350); // Create avatar background const avatarBg = this.add.graphics(); avatarBg.fillStyle(this.playerColors[this.winner]); avatarBg.fillCircle(0, 0, avatarSize / 2); // Create emote text const emoteText = this.add.text(0, 0, '(っ´ω`)ﾉ', { fontSize: '32px', color: '#00a2ff', fontWeight: 'bold', strokeThickness: 1, shadow: { blur: 2, color: '#003366', stroke: true, fill: true } }).setOrigin(0.5); avatarContainer.add([avatarBg, emoteText]); // Add floating animation to avatar this.tweens.add({ targets: avatarContainer, y: 360, duration: 2000, yoyo: true, repeat: -1, ease: 'Sine.easeInOut' }); // Create return to menu button const menuButton = this.add.text(this.game.config.width / 2, 500, 'RETURN TO MENU', { fontSize: '24px', color: '#FFFFFF', stroke: '#00a2ff', strokeThickness: 1, shadow: { offsetX: 2, offsetY: 2, color: '#00a2ff', blur: 5, stroke: true, fill: true } }) .setOrigin(0.5) .setInteractive({ useHandCursor: true }) .on('pointerover', () => { menuButton.setStyle({ strokeThickness: 2 }); this.tweens.add({ targets: menuButton, scaleX: 1.1, scaleY: 1.1, duration: 100 }); }) .on('pointerout', () => { menuButton.setStyle({ strokeThickness: 1 }); this.tweens.add({ targets: menuButton, scaleX: 1, scaleY: 1, duration: 100 }); }) .on('pointerdown', () => { victoryMusic.stop(); this.scene.start('MenuScene'); }); } } const config = { type: Phaser.AUTO, parent: 'renderDiv', scale: { mode: Phaser.Scale.FIT, autoCenter: Phaser.Scale.CENTER_BOTH }, width: 800, height: 600, scene: [MenuScene, Example, VictoryScene] }; window.phaserGame = new Phaser.Game(config);