-
-
+ {/* Center area for ScoreBoard and GameBoard */}
+ moveChef('up')}
+ onMoveDown={() => moveChef('down')}
+ onServePizza={servePizza}
+ onUseOven={useOven}
+ onCleanOven={cleanOven}
+ currentLane={gameState.chefLane}
+ availableSlices={gameState.availableSlices}
+ ovens={gameState.ovens}
+ ovenSpeedUpgrades={gameState.ovenSpeedUpgrades}
+ isLandscape={true}
+ />
+ )}
{gameState.gameOver && showGameOver && (
- = ({ plate }) => {
- // Safe helpers (SSR-friendly)
- const getIsLandscape = () =>
- typeof window !== 'undefined' ? window.innerWidth > window.innerHeight : true;
-
- const getIsMobile = () =>
- typeof navigator !== 'undefined'
- ? /Mobi|Android|iPhone|iPad|iPod/i.test(navigator.userAgent) ||
- (navigator as any).maxTouchPoints > 1
- : false;
-
- const [isLandscape, setIsLandscape] = React.useState(getIsLandscape);
- const [isMobile, setIsMobile] = React.useState(getIsMobile);
-
- React.useEffect(() => {
- const handleResize = () => {
- setIsLandscape(getIsLandscape());
- setIsMobile(getIsMobile());
- };
- window.addEventListener('resize', handleResize);
- window.addEventListener('orientationchange', handleResize);
- return () => {
- window.removeEventListener('resize', handleResize);
- window.removeEventListener('orientationchange', handleResize);
- };
- }, []);
-
- // Match PizzaSlice logic exactly
- const topPercent =
- isMobile && isLandscape
- ? LANDSCAPE_LANE_POSITIONS[plate.lane]
- : plate.lane * 25 + 6;
+ // Calculate visual lane for angled throws
+ let visualLane = plate.lane;
+
+ if (plate.targetLane !== undefined && plate.startLane !== undefined && plate.startPosition !== undefined) {
+ // Interpolate lane based on horizontal progress
+ const totalDistance = plate.startPosition - OVEN_POSITION;
+ const traveled = plate.startPosition - plate.position;
+ const progress = Math.min(1, Math.max(0, traveled / totalDistance));
+
+ visualLane = plate.startLane + (plate.targetLane - plate.startLane) * progress;
+ }
+
+ const topPercent = visualLane * 25 + 6;
return (
+ {/* ScoreBoard at top - compact mode for landscape */}
+
+
+ {/* Mobile controls on sides */}
+ {!gameState.gameOver && !showHighScores && !gameState.showStore && (
+
+
- {gameState.powerUpAlert && (
-
+ setShowInstructions(true)} />
- moveChef('up')}
- onMoveDown={() => moveChef('down')}
- onServePizza={servePizza}
- onUseOven={useOven}
- onCleanOven={cleanOven}
- currentLane={gameState.chefLane}
- availableSlices={gameState.availableSlices}
- ovens={gameState.ovens}
- ovenSpeedUpgrades={gameState.ovenSpeedUpgrades}
- />
+ {showControlsOverlay &&
+
+
+ )}
- {!gameState.gameOver && !gameState.paused && !gameState.showStore &&
+
+
+ ✨ Clean Kitchen Bonus! ✨
+
+
+
+ )}
+
+
)}
- {showControlsOverlay && setShowInstructions(false)}
- onReset={() => {
- resetGame();
- setShowHighScores(false);
- setShowGameOver(false);
- }}
- onShowHighScores={() => {
- setShowHighScores(true);
- setShowInstructions(false);
- }}
- onResume={() => {
- if (gameState.paused && !gameState.gameOver) {
- togglePause();
- }
- }}
- />
- )}
-
{showHighScores && !gameState.gameOver && (
setShowInstructions(false)}
- onReset={() => {
- resetGame();
- setShowHighScores(false);
- setShowGameOver(false);
- }}
- onShowHighScores={() => {
- setShowHighScores(true);
- setShowInstructions(false);
- }}
- onResume={() => {
- if (gameState.paused && !gameState.gameOver) {
- togglePause();
- }
- }}
- />
- )}
-
{showHighScores && !gameState.gameOver && (
);
diff --git a/src/components/Boss.tsx b/src/components/Boss.tsx
index 4261e52..6adc7e4 100644
--- a/src/components/Boss.tsx
+++ b/src/components/Boss.tsx
@@ -1,8 +1,31 @@
import React from 'react';
import { BossBattle } from '../types/game';
import { sprite } from '../lib/assets';
+import { PAPA_JOHN_CONFIG, DOMINOS_CONFIG } from '../lib/constants';
-const bossImg = sprite("dominos-boss.png");
+const dominosBossImg = sprite("dominos-boss.png");
+const papaJohnSprites = [
+ sprite("papa-john.png"), // Encounter 1 (level 10)
+ sprite("papa-john-2.png"), // Encounter 2 (level 20)
+ sprite("papa-john-3.png"), // Encounter 3 (level 40)
+ sprite("papa-john-4.png"), // Encounter 4 (level 50)
+ sprite("papa-john-5.png"), // Encounter 5 (level 60)
+ sprite("papa-john-6.png"), // Encounter 6 (level 70)
+];
+
+const getBossSprite = (bossBattle: BossBattle): string => {
+ if (bossBattle.bossType === 'dominos') {
+ return dominosBossImg;
+ }
+ // Papa John - select based on hits received (changes every 8 hits)
+ const hits = bossBattle.hitsReceived || 0;
+ const spriteIndex = Math.min(Math.floor(hits / 8), papaJohnSprites.length - 1);
+ return papaJohnSprites[spriteIndex];
+};
+
+const getBossConfig = (bossBattle: BossBattle) => {
+ return bossBattle.bossType === 'papaJohn' ? PAPA_JOHN_CONFIG : DOMINOS_CONFIG;
+};
interface BossProps {
bossBattle: BossBattle;
@@ -11,21 +34,24 @@ interface BossProps {
const Boss: React.FC = ({ bossBattle }) => {
if (!bossBattle.active && !bossBattle.bossDefeated) return null;
+ const bossSprite = getBossSprite(bossBattle);
+ const config = getBossConfig(bossBattle);
+
return (
<>
{!bossBattle.bossDefeated && (
= ({ bossBattle }) => {
)}
{bossBattle.minions.map(minion => {
- if (minion.defeated) return null;
- return (
- = ({ onClose }) => {
const controls = ui("controls.png");
+ // Close on Escape key or Enter key
+ useEffect(() => {
+ const handleKeyDown = (e: KeyboardEvent) => {
+ if (e.key === 'Escape' || e.key === 'Enter') {
+ e.preventDefault();
+ onClose();
+ }
+ };
+
+ window.addEventListener('keydown', handleKeyDown);
+ return () => window.removeEventListener('keydown', handleKeyDown);
+ }, [onClose]);
+
const handleImageClick = (event: React.MouseEvent) => {
const rect = event.currentTarget.getBoundingClientRect();
const x = event.clientX - rect.left;
@@ -23,8 +36,8 @@ const ControlsOverlay: React.FC = ({ onClose }) => {
return (
= ({ customer, boardWidth, boardHeight }
const textYPx = ((customer.lane * 25 + textYOffset) / 100) * boardHeight;
const getDisplay = () => {
- // 🌈 Rainbow Brian (nyan hit) — override everything else
+ const variant = getCustomerVariant(customer);
+ const isSpecialCustomer = variant === 'badLuckBrian' || variant === 'scumbagSteve' || variant === 'pizzaMafia';
+
+ // 🌈 Rainbow Brian (nyan hit) — special behavior override
if (customer.brianNyaned) {
return { type: 'image', value: rainbowBrian, alt: 'rainbow-brian' };
}
+ // Brian puke — special behavior override
+ if (customer.vomit && variant === 'badLuckBrian') {
+ return { type: 'image', value: badLuckBrianPukeImg, alt: 'brian-puke' };
+ }
+
+ // Special customers keep their base image (no powerup/status effects)
+ if (isSpecialCustomer) {
+ if (variant === 'badLuckBrian') return { type: 'image', value: badLuckBrianImg, alt: 'badluckbrian' };
+ if (variant === 'scumbagSteve') return { type: 'image', value: scumbagSteveImg, alt: 'scumbagsteve' };
+ if (variant === 'pizzaMafia') return { type: 'image', value: pizzaMafiaImg, alt: 'pizzamafia' };
+ }
+
+ // Status effects for normal customers and critics
if (customer.frozen) return { type: 'image', value: frozenfaceImg, alt: 'frozen' };
- if (customer.vomit && customer.badLuckBrian) return { type: 'image', value: badLuckBrianPukeImg, alt: 'brian-puke' };
if (customer.vomit) return { type: 'emoji', value: '🤮' };
if (customer.woozy) {
if (customer.woozyState === 'drooling') return { type: 'image', value: droolfaceImg, alt: 'drooling' };
@@ -55,8 +72,9 @@ const Customer: React.FC = ({ customer, boardWidth, boardHeight }
if (customer.served) return { type: 'image', value: yumfaceImg, alt: 'yum' };
if (customer.disappointed) return { type: 'emoji', value: customer.disappointedEmoji || '😢' };
if (customer.hotHoneyAffected) return { type: 'image', value: spicyfaceImg, alt: 'spicy' };
- if (customer.badLuckBrian) return { type: 'image', value: badLuckBrianImg, alt: 'badluckbrian' };
- if (customer.critic) return { type: 'image', value: criticImg, alt: 'critic' };
+
+ // Base appearance by variant
+ if (variant === 'critic') return { type: 'image', value: criticImg, alt: 'critic' };
return { type: 'image', value: droolfaceImg, alt: 'drool' };
};
diff --git a/src/components/DroppedPlate.tsx b/src/components/DroppedPlate.tsx
index 4066fda..ae39bce 100644
--- a/src/components/DroppedPlate.tsx
+++ b/src/components/DroppedPlate.tsx
@@ -1,6 +1,8 @@
import React, { useEffect, useState } from 'react';
import { DroppedPlate as DroppedPlateType } from '../types/game';
-const slice1PlateImg = "https://i.imgur.com/XFdXriH.png";
+import { sprite } from '../lib/assets';
+
+const slicePlateImg = sprite("slice-plate.png");
interface DroppedPlateProps {
droppedPlate: DroppedPlateType;
@@ -41,7 +43,7 @@ const DroppedPlate: React.FC = ({ droppedPlate }) => {
opacity: visible ? 1 : 0,
}}
>
- 
+ 
);
};
diff --git a/src/components/EmptyPlate.tsx b/src/components/EmptyPlate.tsx
index 32cc639..84d165e 100644
--- a/src/components/EmptyPlate.tsx
+++ b/src/components/EmptyPlate.tsx
@@ -1,44 +1,29 @@
import React from 'react';
import { EmptyPlate as EmptyPlateType } from '../types/game';
+import { sprite } from '../lib/assets';
+
+const paperPlateImg = sprite("paperplate.png");
interface EmptyPlateProps {
plate: EmptyPlateType;
}
-const LANDSCAPE_LANE_POSITIONS = [20, 40, 60, 80]; // match LandscapeCustomer & PizzaSlice
+const OVEN_POSITION = 10; // Target X position (near the ovens)
const EmptyPlate: React.FC
-
- )}
-
- {gameState.showStore && (
-
-
- Paused
-Tap to continue
- -
-
- )}
-
- {showInstructions && (
-
- setShowInstructions(true)} />
+
+
+ )}
+
{!gameState.gameOver && !gameState.paused && !gameState.showStore &&
+
+
+ ✨ Clean Kitchen Bonus! ✨
+
+
-
+ {!gameState.gameOver && !showControlsOverlay && (
+
-
- Paused
-Press Space or tap to continue
- -
+ 
+
- HP: {bossBattle.bossHealth}/8
+ HP: {bossBattle.bossHealth}/{config.HEALTH}
)}
{!bossBattle.bossVulnerable && (
- Wave {bossBattle.currentWave}/3
+ Wave {bossBattle.currentWave}/{config.WAVES}
)}
-
-
- );
-})}
+ if (minion.defeated) return null;
+ return (
+
+ 
+
+ );
+ })}
);
};
diff --git a/src/components/ControlsOverlay.tsx b/src/components/ControlsOverlay.tsx
index 610f221..5889525 100644
--- a/src/components/ControlsOverlay.tsx
+++ b/src/components/ControlsOverlay.tsx
@@ -1,4 +1,4 @@
-import React from 'react';
+import React, { useEffect } from 'react';
import { ui } from '../lib/assets';
interface ControlsOverlayProps {
@@ -8,6 +8,19 @@ interface ControlsOverlayProps {
const ControlsOverlay: React.FC
-
![]()
= ({ onClose }) => {
alt="Game Controls"
className="w-full h-auto rounded-lg shadow-2xl"
/>
- {/* Visual indicator for close area (optional, can be removed) */}
- {/*
-
- */}
);
diff --git a/src/components/Customer.tsx b/src/components/Customer.tsx
index fb29a0a..222c837 100644
--- a/src/components/Customer.tsx
+++ b/src/components/Customer.tsx
@@ -1,6 +1,6 @@
// src/components/Customer.tsx
import React from 'react';
-import { Customer as CustomerType } from '../types/game';
+import { Customer as CustomerType, getCustomerVariant } from '../types/game';
import { sprite } from '../lib/assets';
// Sprites (all hosted on Cloudflare)
@@ -13,6 +13,8 @@ const criticImg = sprite("critic.png");
const badLuckBrianImg = sprite("bad-luck-brian.png");
const badLuckBrianPukeImg = sprite("bad-luck-brian-puke.png");
const rainbowBrian = sprite("rainbow-brian.png");
+const scumbagSteveImg = sprite("scumbag-steve.png");
+const pizzaMafiaImg = sprite("pizza-mafia.png");
interface CustomerProps {
customer: CustomerType;
@@ -40,13 +42,28 @@ const Customer: React.FC = ({ plate }) => {
>
{/* Empty plate image */}
void;
+}
+
+export default function FloatingStar({ id, isGain, count = 1, lane, position, onComplete }: FloatingStarProps) {
+ const [yOffset, setYOffset] = useState(0);
+ const [opacity, setOpacity] = useState(1);
+
+ useEffect(() => {
+ const startTime = Date.now();
+ const duration = 2000;
+
+ const animate = () => {
+ const elapsed = Date.now() - startTime;
+ const progress = Math.min(elapsed / duration, 1);
+
+ setYOffset(progress * -30);
+ setOpacity(1 - progress);
+
+ if (progress < 1) {
+ requestAnimationFrame(animate);
+ } else {
+ onComplete(id);
+ }
+ };
+
+ requestAnimationFrame(animate);
+ }, [id, onComplete]);
+
+ const lanePosition = 15 + (lane * 22);
+
+ return (
+ = ({ gameState }) => {
const lanes = [0, 1, 2, 3];
- const [, forceUpdate] = React.useReducer(x => x + 1, 0);
const [completedScores, setCompletedScores] = useState>(new Set());
+ const [completedStars, setCompletedStars] = useState>(new Set());
// ✅ Measure board size (for px-based translate3d positioning)
const boardRef = useRef(null);
@@ -47,53 +54,31 @@ const GameBoard: React.FC = ({ gameState }) => {
setCompletedScores(prev => new Set(prev).add(id));
}, []);
- React.useEffect(() => {
- const interval = setInterval(forceUpdate, 100);
- return () => clearInterval(interval);
+ const handleStarComplete = useCallback((id: string) => {
+ setCompletedStars(prev => new Set(prev).add(id));
}, []);
const getOvenStatus = (lane: number) => {
const oven = gameState.ovens[lane];
-
- if (oven.burned) {
- if (oven.cleaningStartTime > 0) {
- const cleaningElapsed = Date.now() - oven.cleaningStartTime;
- const halfCleaning = 1500; // 1.5 seconds (half of 3 second cleaning time)
- if (cleaningElapsed < halfCleaning) {
- return 'extinguishing';
- }
- return 'sweeping';
- }
- return 'burned';
- }
-
- if (!oven.cooking) return 'empty';
-
- // Use pausedElapsed if game is paused, otherwise calculate from startTime
- const elapsed = oven.pausedElapsed !== undefined ? oven.pausedElapsed : Date.now() - oven.startTime;
-
- // Calculate cook time based on speed upgrades
const speedUpgrade = gameState.ovenSpeedUpgrades[lane] || 0;
- const cookingTime =
- speedUpgrade === 0 ? 3000 :
- speedUpgrade === 1 ? 2500 :
- speedUpgrade === 2 ? 2000 : 1500;
-
- const warningTime = 7000; // 7 seconds (start blinking)
- const burnTime = 8000; // 8 seconds total
- const blinkInterval = 250; // 0.25 seconds
+ const baseStatus = getOvenDisplayStatus(oven, speedUpgrade);
- if (elapsed >= burnTime) return 'burning';
+ // Add visual enhancements for GameBoard display
+ if (baseStatus === 'cleaning') {
+ const cleaningElapsed = Date.now() - oven.cleaningStartTime;
+ const halfCleaning = OVEN_CONFIG.CLEANING_TIME / 2;
+ return cleaningElapsed < halfCleaning ? 'extinguishing' : 'sweeping';
+ }
- // Blinking phase (between 7-8 seconds)
- if (elapsed >= warningTime) {
- const warningElapsed = elapsed - warningTime;
- const blinkCycle = Math.floor(warningElapsed / blinkInterval);
+ if (baseStatus === 'warning') {
+ // Blinking effect for warning state
+ const elapsed = oven.pausedElapsed !== undefined ? oven.pausedElapsed : Date.now() - oven.startTime;
+ const warningElapsed = elapsed - OVEN_CONFIG.WARNING_TIME;
+ const blinkCycle = Math.floor(warningElapsed / TIMINGS.WARNING_BLINK_INTERVAL);
return blinkCycle % 2 === 0 ? 'warning-fire' : 'warning-pizza';
}
- if (elapsed >= cookingTime) return 'ready';
- return 'cooking';
+ return baseStatus;
};
return (
@@ -154,7 +139,8 @@ const GameBoard: React.FC = ({ gameState }) => {
})}
{/* ✅ Chef (no scale(15), positioned directly on board) */}
- {!gameState.nyanSweep?.active && (
+ {/* Hide chef when paused (but show game over chef) */}
+ {!gameState.nyanSweep?.active && (!gameState.paused || gameState.gameOver) && (
void;
+}
+
+export default function FloatingStar({ id, isGain, count = 1, lane, position, onComplete }: FloatingStarProps) {
+ const [yOffset, setYOffset] = useState(0);
+ const [opacity, setOpacity] = useState(1);
+
+ useEffect(() => {
+ const startTime = Date.now();
+ const duration = 2000;
+
+ const animate = () => {
+ const elapsed = Date.now() - startTime;
+ const progress = Math.min(elapsed / duration, 1);
+
+ setYOffset(progress * -30);
+ setOpacity(1 - progress);
+
+ if (progress < 1) {
+ requestAnimationFrame(animate);
+ } else {
+ onComplete(id);
+ }
+ };
+
+ requestAnimationFrame(animate);
+ }, [id, onComplete]);
+
+ const lanePosition = 15 + (lane * 22);
+
+ return (
+
+
+ {isGain ? '+' : '-'}
+
+ {Array.from({ length: count }, (_, i) => (
+
+ );
+}
diff --git a/src/components/GameBoard.tsx b/src/components/GameBoard.tsx
index 8172ed7..7ee582e 100644
--- a/src/components/GameBoard.tsx
+++ b/src/components/GameBoard.tsx
@@ -1,17 +1,24 @@
import React, { useState, useCallback, useEffect, useRef } from 'react';
import Customer from './Customer';
import PizzaSlice from './PizzaSlice';
+import MafiaSlice from './MafiaSlice';
import EmptyPlate from './EmptyPlate';
import DroppedPlate from './DroppedPlate';
import PowerUp from './PowerUp';
import PizzaSliceStack from './PizzaSliceStack';
import FloatingScore from './FloatingScore';
+import FloatingStar from './FloatingStar';
import Boss from './Boss';
+import PepeHelpers from './PepeHelpers';
import { GameState } from '../types/game';
import pizzaShopBg from '/pizza shop background v2.png';
import { sprite } from '../lib/assets';
+import { getOvenDisplayStatus } from '../logic/ovenSystem';
+import { OVEN_CONFIG, TIMINGS } from '../lib/constants';
const chefImg = sprite("chef.png");
+const sadChefImg = sprite("sad-chef.png");
+const nyanChefImg = sprite("nyan-chef.png");
interface GameBoardProps {
gameState: GameState;
@@ -19,8 +26,8 @@ interface GameBoardProps {
const GameBoard: React.FC = ({ gameState }) => {
}}
>
= ({ gameState }) => {
)}
+ {/* Pepe Helpers - Franco-Pepe and Frank-Pepe */}
+ = ({ gameState }) => {
}}
>
= ({ gameState }) => {
= ({ gameState }) => {
/>
))}
+ {/* Floating star indicators */}
+ {gameState.floatingStars.filter(fs => !completedStars.has(fs.id)).map((floatingStar) => (
+
= ({ gameState }) => {
(null);
const imagesRef = useRef({
splashLogo: null,
@@ -117,6 +122,53 @@ export default function GameOverScreen({ stats, score, level, lastStarLostReason
const skillRating = calculateSkillRating(stats, score, level);
const gameId = useMemo(() => crypto.randomUUID(), []);
const timestamp = new Date();
+
+ // Keyboard navigation for main scorecard view
+ // 0: Submit Score, 1: Leaderboard, 2: Play Again
+ const mainMenuActions = useMemo(() => [
+ () => { /* form submit handled by form */ },
+ () => setShowLeaderboard(true),
+ onPlayAgain,
+ ], [onPlayAgain]);
+
+ const handleMainMenuSelect = useCallback((index: number) => {
+ if (index === 0) {
+ // Trigger form submit programmatically
+ const form = document.querySelector('form');
+ if (form) form.requestSubmit();
+ } else {
+ mainMenuActions[index]?.();
+ }
+ }, [mainMenuActions]);
+
+ const { selectedIndex: mainSelectedIndex, getItemProps: getMainItemProps } = useMenuKeyboardNav({
+ itemCount: 3,
+ columns: 2,
+ onSelect: handleMainMenuSelect,
+ isActive: !showLeaderboard && !scoreSubmitted,
+ initialIndex: 0,
+ });
+
+ // Keyboard navigation for leaderboard view (after submission)
+ // 0: Back, 1: Play Again
+ const leaderboardMenuActions = useMemo(() => [
+ () => setShowLeaderboard(false),
+ onPlayAgain,
+ ], [onPlayAgain]);
+
+ const handleLeaderboardMenuSelect = useCallback((index: number) => {
+ leaderboardMenuActions[index]?.();
+ }, [leaderboardMenuActions]);
+
+ const { selectedIndex: leaderboardSelectedIndex, getItemProps: getLeaderboardItemProps } = useMenuKeyboardNav({
+ itemCount: 2,
+ columns: 2,
+ onSelect: handleLeaderboardMenuSelect,
+ isActive: showLeaderboard && scoreSubmitted,
+ initialIndex: 1, // Start on Play Again
+ });
+
+ const selectedRing = "ring-2 ring-white ring-opacity-80";
const formattedDate = timestamp.toLocaleDateString('en-US', { month: 'short', day: 'numeric', year: 'numeric' });
const formattedTime = timestamp.toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit' });
@@ -469,6 +521,16 @@ export default function GameOverScreen({ stats, score, level, lastStarLostReason
setScoreSubmitted(true);
setShowLeaderboard(true);
setSubmitting(false);
+
+ // Check if score made it to top 10 and show confetti
+ const isTopScore = await checkIfTopScore(score);
+ if (isTopScore) {
+ const isNumOne = await checkIfNumberOneScore(score);
+ setIsNumberOne(isNumOne);
+ setShowConfetti(true);
+ setLeaderboardRefreshKey(prev => prev + 1);
+ }
+
onSubmitted(session, nameToSubmit);
} else if (scoreSuccess) {
const fallbackSession: GameSession = {
@@ -489,6 +551,16 @@ export default function GameOverScreen({ stats, score, level, lastStarLostReason
setScoreSubmitted(true);
setShowLeaderboard(true);
setSubmitting(false);
+
+ // Check if score made it to top 10 and show confetti
+ const isTopScore = await checkIfTopScore(score);
+ if (isTopScore) {
+ const isNumOne = await checkIfNumberOneScore(score);
+ setIsNumberOne(isNumOne);
+ setShowConfetti(true);
+ setLeaderboardRefreshKey(prev => prev + 1);
+ }
+
onSubmitted(fallbackSession, nameToSubmit);
} else {
setError('Failed to submit score. Please try again.');
@@ -585,24 +657,27 @@ export default function GameOverScreen({ stats, score, level, lastStarLostReason
return (
- = ({
= ({
= ({
- gameOver,
- paused,
- nyanSweepActive,
- onMoveUp,
- onMoveDown,
- onServePizza,
- onUseOven,
- onCleanOven,
- currentLane,
- availableSlices,
- ovens,
- ovenSpeedUpgrades,
-}) => {
- const safeLane = Math.round(currentLane);
- const isDisabled = gameOver || paused || nyanSweepActive;
-
- const getOvenStatus = () => {
- const oven = ovens[safeLane];
- if (!oven) return 'empty';
- if (oven.burned) return 'burned';
- if (!oven.cooking) return 'empty';
-
- const elapsed = oven.pausedElapsed !== undefined ? oven.pausedElapsed : Date.now() - oven.startTime;
-
- const speedUpgrade = ovenSpeedUpgrades[safeLane] || 0;
- const cookingTime = speedUpgrade === 0 ? 3000 :
- speedUpgrade === 1 ? 2000 :
- speedUpgrade === 2 ? 1000 : 500;
-
- const warningTime = 7000;
- const burnTime = 8000;
-
- if (elapsed >= burnTime) return 'burning';
- if (elapsed >= warningTime) return 'warning';
- if (elapsed >= cookingTime) return 'ready';
- return 'cooking';
- };
-
- const handleOvenAction = () => {
- const oven = ovens[safeLane];
- if (!oven) return;
- if (oven.burned) {
- onCleanOven();
- } else {
- onUseOven();
- }
- };
-
- const ovenStatus = getOvenStatus();
- const currentOven = ovens[safeLane];
-
- return (
- <>
- {/* Left side - Chef Movement Controls */}
- = ({ customer }) => {
- const leftPosition = customer.position;
-
- const getDisplay = () => {
- if (customer.frozen) return { type: 'image', value: frozenfaceImg, alt: 'frozen' };
- if (customer.vomit && customer.badLuckBrian) return { type: 'image', value: badLuckBrianPukeImg, alt: 'brian-puke' };
- if (customer.vomit) return { type: 'emoji', value: '🤮' };
- if (customer.woozy) {
- if (customer.woozyState === 'drooling') return { type: 'image', value: droolfaceImg, alt: 'drooling' };
- return { type: 'image', value: woozyfaceImg, alt: 'woozy' };
- }
- if (customer.served) return { type: 'image', value: yumfaceImg, alt: 'yum' };
- if (customer.disappointed) return { type: 'emoji', value: customer.disappointedEmoji || '😢' };
- if (customer.hotHoneyAffected) return { type: 'image', value: spicyfaceImg, alt: 'spicy' };
- if (customer.badLuckBrian) return { type: 'image', value: badLuckBrianImg, alt: 'badluckbrian' };
- if (customer.critic) return { type: 'image', value: criticImg, alt: 'critic' };
- return { type: 'image', value: droolfaceImg, alt: 'drool' };
- };
-
- const display = getDisplay();
-
- return (
- <>
- = ({ droppedPlate }) => {
- const [visible, setVisible] = useState(true);
- const elapsed = Date.now() - droppedPlate.startTime;
-
- useEffect(() => {
- if (elapsed >= TOTAL_DURATION) {
- setVisible(false);
- return;
- }
-
- const blinkInterval = setInterval(() => {
- const currentElapsed = Date.now() - droppedPlate.startTime;
- const blinkCycle = Math.floor(currentElapsed / BLINK_DURATION);
- setVisible(blinkCycle % 2 === 0);
- }, BLINK_DURATION);
-
- return () => clearInterval(blinkInterval);
- }, [droppedPlate.startTime, elapsed]);
-
- if (!visible || elapsed >= TOTAL_DURATION) {
- return null;
- }
-
- return (
- = ({ gameState }) => {
- const lanes = [0, 1, 2, 3];
- const [, forceUpdate] = React.useReducer(x => x + 1, 0);
- const [completedScores, setCompletedScores] = useState>(new Set());
-
- const handleScoreComplete = useCallback((id: string) => {
- setCompletedScores(prev => new Set(prev).add(id));
- }, []);
-
- React.useEffect(() => {
- const interval = setInterval(forceUpdate, 100);
- return () => clearInterval(interval);
- }, []);
-
- const getOvenStatus = (lane: number) => {
- const oven = gameState.ovens[lane];
-
- if (oven.burned) {
- if (oven.cleaningStartTime > 0) {
- const cleaningElapsed = Date.now() - oven.cleaningStartTime;
- const halfCleaning = 1500;
- if (cleaningElapsed < halfCleaning) {
- return 'extinguishing';
- }
- return 'sweeping';
- }
- return 'burned';
- }
-
- if (!oven.cooking) return 'empty';
-
- const elapsed = oven.pausedElapsed !== undefined ? oven.pausedElapsed : Date.now() - oven.startTime;
-
- // Calculate cook time based on speed upgrades
- const speedUpgrade = gameState.ovenSpeedUpgrades[lane] || 0;
- const cookingTime = speedUpgrade === 0 ? 3000 :
- speedUpgrade === 1 ? 2000 :
- speedUpgrade === 2 ? 1000 : 500;
-
- const warningTime = 7000;
- const burnTime = 8000;
- const blinkInterval = 250;
-
- if (elapsed >= burnTime) return 'burning';
-
- if (elapsed >= warningTime) {
- const warningElapsed = elapsed - warningTime;
- const blinkCycle = Math.floor(warningElapsed / blinkInterval);
- return blinkCycle % 2 === 0 ? 'warning-fire' : 'warning-pizza';
- }
-
- if (elapsed >= cookingTime) return 'ready';
- return 'cooking';
- };
-
- return (
- = ({ gameState, onShowInstructions }) => {
- return (
- = ({ slice }) => {
+ // Calculate rotation based on velocity direction
+ const rotation = Math.atan2(slice.speedY, slice.speedX) * (180 / Math.PI);
+
+ // Position based on lane (fractional) and position (percentage)
+ const xPct = slice.position;
+ const yPct = slice.lane * 25 + 6;
+
+ return (
+ = ({
@@ -40,6 +42,7 @@ const MobileGameControls: React.FC = ({
availableSlices,
ovens,
ovenSpeedUpgrades,
+ isLandscape = false,
}) => {
const safeLane = Math.round(currentLane);
const isDisabled = gameOver || paused || nyanSweepActive;
@@ -47,23 +50,8 @@ const MobileGameControls: React.FC = ({
const getOvenStatus = () => {
const oven = ovens[safeLane];
if (!oven) return 'empty';
- if (oven.burned) return 'burned';
- if (!oven.cooking) return 'empty';
-
- const elapsed = oven.pausedElapsed !== undefined ? oven.pausedElapsed : Date.now() - oven.startTime;
-
const speedUpgrade = ovenSpeedUpgrades[safeLane] || 0;
- const cookingTime = speedUpgrade === 0 ? 3000 :
- speedUpgrade === 1 ? 2000 :
- speedUpgrade === 2 ? 1000 : 500;
-
- const warningTime = 7000;
- const burnTime = 8000;
-
- if (elapsed >= burnTime) return 'burning';
- if (elapsed >= warningTime) return 'warning';
- if (elapsed >= cookingTime) return 'ready';
- return 'cooking';
+ return getOvenDisplayStatus(oven, speedUpgrade);
};
const handleOvenAction = () => {
@@ -79,6 +67,85 @@ const MobileGameControls: React.FC = ({
const ovenStatus = getOvenStatus();
const currentOven = ovens[safeLane];
+ // Landscape layout - controls on left and right edges
+ if (isLandscape) {
+ return (
+ <>
+ {/* Left side - Movement Controls */}
+
-
-
+
@@ -164,13 +422,13 @@ const ItemStore: React.FC
+
) : (
+
+
+
@@ -724,8 +799,9 @@ export default function GameOverScreen({ stats, score, level, lastStarLostReason
diff --git a/src/components/HighScores.tsx b/src/components/HighScores.tsx
index 5365ba3..e1dcd9d 100644
--- a/src/components/HighScores.tsx
+++ b/src/components/HighScores.tsx
@@ -5,9 +5,10 @@ import ScorecardImageView from './ScorecardImageView';
interface HighScoresProps {
userScore?: { name: string; score: number };
+ refreshKey?: number; // Increment to trigger refresh
}
-const HighScores: React.FC = ({ userScore }) => {
+const HighScores: React.FC = ({ userScore, refreshKey = 0 }) => {
const [scores, setScores] = useState([]);
const [loading, setLoading] = useState(true);
const [selectedImageUrl, setSelectedImageUrl] = useState(null);
@@ -16,7 +17,7 @@ const HighScores: React.FC = ({ userScore }) => {
useEffect(() => {
loadScores();
- }, []);
+ }, [refreshKey]);
const loadScores = async () => {
setLoading(true);
diff --git a/src/components/ItemStore.tsx b/src/components/ItemStore.tsx
index cadb454..0fa7ff5 100644
--- a/src/components/ItemStore.tsx
+++ b/src/components/ItemStore.tsx
@@ -1,8 +1,9 @@
-import React from 'react';
+import React, { useCallback, useMemo, useState, useEffect, useRef } from 'react';
import { GameState } from '../types/game';
import { Store, DollarSign, X } from 'lucide-react';
import PizzaSliceStack from './PizzaSliceStack';
import { sprite } from '../lib/assets';
+import { getUpgradeCost, getSpeedUpgradeCost } from '../logic/storeSystem';
// Power-up images (served from Cloudflare)
const beerImg = sprite("beer.png");
@@ -26,8 +27,6 @@ const ItemStore: React.FC = ({
onBuyPowerUp,
onClose,
}) => {
- const upgradeCost = 10;
- const speedUpgradeCost = 10;
const maxUpgradeLevel = 7;
const maxSpeedUpgradeLevel = 3;
const bribeCost = 25;
@@ -35,8 +34,10 @@ const ItemStore: React.FC = ({
const getOvenUpgradeLevel = (lane: number) => gameState.ovenUpgrades[lane] || 0;
const getOvenSpeedUpgradeLevel = (lane: number) => gameState.ovenSpeedUpgrades[lane] || 0;
- const canAffordUpgrade = gameState.bank >= upgradeCost;
- const canAffordSpeedUpgrade = gameState.bank >= speedUpgradeCost;
+ const getLaneUpgradeCost = (lane: number) => getUpgradeCost(getOvenUpgradeLevel(lane));
+ const getLaneSpeedUpgradeCost = (lane: number) => getSpeedUpgradeCost(getOvenSpeedUpgradeLevel(lane));
+ const canAffordUpgrade = (lane: number) => gameState.bank >= getLaneUpgradeCost(lane);
+ const canAffordSpeedUpgrade = (lane: number) => gameState.bank >= getLaneSpeedUpgradeCost(lane);
const getSpeedUpgradeText = (level: number) => {
if (level === 0) return 'Base: 3s';
@@ -45,6 +46,263 @@ const ItemStore: React.FC = ({
return '1.5s';
};
+ // Custom keyboard navigation for complex grid layout:
+ // Left side (ovens): 4 rows x 2 cols = indices 0-7
+ // Row 0: [Speed0=0] [Level0=1]
+ // Row 1: [Speed1=2] [Level1=3]
+ // Row 2: [Speed2=4] [Level2=5]
+ // Row 3: [Speed3=6] [Level3=7]
+ // Right side:
+ // Bribe = 8 (accessible from oven rows 0-1)
+ // Power-ups = 9, 10, 11 (accessible from oven rows 2-3)
+ // Bottom: Continue = 12
+
+ const [selectedIndex, setSelectedIndex] = useState(12); // Start on Continue
+ const itemRefs = useRef<(HTMLButtonElement | null)[]>([]);
+
+ const menuActions = useMemo(() => [
+ () => onUpgradeOvenSpeed(0),
+ () => onUpgradeOven(0),
+ () => onUpgradeOvenSpeed(1),
+ () => onUpgradeOven(1),
+ () => onUpgradeOvenSpeed(2),
+ () => onUpgradeOven(2),
+ () => onUpgradeOvenSpeed(3),
+ () => onUpgradeOven(3),
+ onBribeReviewer,
+ () => onBuyPowerUp('beer'),
+ () => onBuyPowerUp('ice-cream'),
+ () => onBuyPowerUp('honey'),
+ onClose,
+ ], [onUpgradeOvenSpeed, onUpgradeOven, onBribeReviewer, onBuyPowerUp, onClose]);
+
+ // Focus selected element
+ useEffect(() => {
+ itemRefs.current[selectedIndex]?.focus();
+ }, [selectedIndex]);
+
+ // Store refs for stable access in event handler
+ const selectedIndexRef = useRef(selectedIndex);
+ const menuActionsRef = useRef(menuActions);
+ const onCloseRef = useRef(onClose);
+ const gameStateRef = useRef(gameState);
+
+ useEffect(() => {
+ selectedIndexRef.current = selectedIndex;
+ }, [selectedIndex]);
+
+ useEffect(() => {
+ menuActionsRef.current = menuActions;
+ }, [menuActions]);
+
+ useEffect(() => {
+ onCloseRef.current = onClose;
+ }, [onClose]);
+
+ useEffect(() => {
+ gameStateRef.current = gameState;
+ }, [gameState]);
+
+ // Helper to check if a button at given index is disabled (defined before ref)
+ const isDisabledAt = (index: number, gs: GameState): boolean => {
+ // Oven speed buttons (0, 2, 4, 6)
+ if (index % 2 === 0 && index <= 6) {
+ const lane = index / 2;
+ const speedLevel = gs.ovenSpeedUpgrades[lane] || 0;
+ const isMaxSpeed = speedLevel >= maxSpeedUpgradeLevel;
+ const cost = getSpeedUpgradeCost(speedLevel);
+ return isMaxSpeed || gs.bank < cost;
+ }
+ // Oven level buttons (1, 3, 5, 7)
+ if (index % 2 === 1 && index <= 7) {
+ const lane = (index - 1) / 2;
+ const level = gs.ovenUpgrades[lane] || 0;
+ const isMaxLevel = level >= maxUpgradeLevel;
+ const cost = getUpgradeCost(level);
+ return isMaxLevel || gs.bank < cost;
+ }
+ // Bribe (8)
+ if (index === 8) {
+ return gs.bank < bribeCost || gs.lives >= 5;
+ }
+ // Power-ups (9, 10, 11)
+ if (index >= 9 && index <= 11) {
+ return gs.bank < powerUpCost;
+ }
+ // Continue (12) - never disabled
+ return false;
+ };
+
+ // Custom navigation logic - stable handler
+ useEffect(() => {
+ const handleKeyDown = (e: KeyboardEvent) => {
+ const key = e.key;
+ if (!['ArrowUp', 'ArrowDown', 'ArrowLeft', 'ArrowRight', 'Enter', ' ', 'Escape'].includes(key)) return;
+
+ e.preventDefault();
+ e.stopPropagation();
+
+ if (key === 'Escape') {
+ onCloseRef.current();
+ return;
+ }
+
+ if (key === 'Enter') {
+ menuActionsRef.current[selectedIndexRef.current]?.();
+ return;
+ }
+
+ setSelectedIndex(current => {
+ const gs = gameStateRef.current;
+ const disabled = (idx: number) => isDisabledAt(idx, gs);
+
+ // Helper to find first non-disabled in a list, or return fallback
+ const firstEnabled = (indices: number[], fallback: number) => {
+ for (const idx of indices) {
+ if (!disabled(idx)) return idx;
+ }
+ return fallback;
+ };
+
+ // In oven grid (0-7)
+ if (current >= 0 && current <= 7) {
+ const row = Math.floor(current / 2);
+ const col = current % 2;
+
+ if (key === 'ArrowUp') {
+ // Try rows above, find first enabled in same column first
+ for (let r = row - 1; r >= 0; r--) {
+ const target = r * 2 + col;
+ if (!disabled(target)) return target;
+ }
+ // If none in same column, try the other column in rows above
+ const otherCol = col === 0 ? 1 : 0;
+ for (let r = row - 1; r >= 0; r--) {
+ const target = r * 2 + otherCol;
+ if (!disabled(target)) return target;
+ }
+ return current; // Stay if none found
+ }
+ if (key === 'ArrowDown') {
+ // Try rows below, find first enabled in same column first
+ for (let r = row + 1; r <= 3; r++) {
+ const target = r * 2 + col;
+ if (!disabled(target)) return target;
+ }
+ // If none in same column, try the other column in rows below
+ const otherCol = col === 0 ? 1 : 0;
+ for (let r = row + 1; r <= 3; r++) {
+ const target = r * 2 + otherCol;
+ if (!disabled(target)) return target;
+ }
+ return 12; // Go to Continue
+ }
+ if (key === 'ArrowLeft') {
+ if (col > 0) {
+ const target = current - 1;
+ if (!disabled(target)) return target;
+ }
+ return current; // Stay at left edge or if disabled
+ }
+ if (key === 'ArrowRight') {
+ if (col === 0) {
+ const target = current + 1;
+ if (!disabled(target)) return target;
+ // If level button disabled, try going to right side
+ }
+ // From level column (or if level disabled), go to right side
+ if (row <= 1) {
+ // Try Bribe first, then power-ups
+ if (!disabled(8)) return 8;
+ return firstEnabled([9, 10, 11], current);
+ }
+ // From bottom rows, go to power-ups
+ return firstEnabled([9, 10, 11], current);
+ }
+ }
+
+ // At Bribe (8)
+ if (current === 8) {
+ if (key === 'ArrowLeft') {
+ // Go to first enabled in oven rows 0-1
+ return firstEnabled([1, 0, 3, 2], current);
+ }
+ if (key === 'ArrowDown') {
+ // Go to first enabled power-up
+ return firstEnabled([9, 10, 11, 12], current);
+ }
+ if (key === 'ArrowUp') {
+ // Go to first enabled in oven row 0-1
+ return firstEnabled([1, 0, 3, 2], current);
+ }
+ if (key === 'ArrowRight') return current;
+ }
+
+ // At Power-ups (9-11)
+ if (current >= 9 && current <= 11) {
+ const powerUpCol = current - 9;
+ if (key === 'ArrowLeft') {
+ // Try power-ups to the left first
+ for (let i = powerUpCol - 1; i >= 0; i--) {
+ if (!disabled(9 + i)) return 9 + i;
+ }
+ // Then try oven section
+ return firstEnabled([5, 4, 7, 6], current);
+ }
+ if (key === 'ArrowRight') {
+ // Try power-ups to the right
+ for (let i = powerUpCol + 1; i <= 2; i++) {
+ if (!disabled(9 + i)) return 9 + i;
+ }
+ return current; // Stay at right edge
+ }
+ if (key === 'ArrowUp') {
+ // Try Bribe if enabled
+ if (!disabled(8)) return 8;
+ return current;
+ }
+ if (key === 'ArrowDown') return 12; // Go to Continue
+ }
+
+ // At Continue (12)
+ if (current === 12) {
+ if (key === 'ArrowUp') {
+ // Try bottommost rightmost oven upgrade first (oven 4 level, then oven 4 speed)
+ if (!disabled(7)) return 7; // Oven 4 level (rightmost)
+ if (!disabled(6)) return 6; // Oven 4 speed
+ // No oven 4 upgrades - try power-ups if enabled
+ const powerUpEnabled = firstEnabled([9, 10, 11], -1);
+ if (powerUpEnabled !== -1) return powerUpEnabled;
+ // Fall back to other ovens (bottommost rightmost first)
+ return firstEnabled([5, 4, 3, 2, 1, 0], current);
+ }
+ if (key === 'ArrowLeft') return current;
+ if (key === 'ArrowRight') return current;
+ if (key === 'ArrowDown') return current;
+ }
+
+ return current;
+ });
+ };
+
+ // Use capture phase to ensure we get events before other handlers
+ window.addEventListener('keydown', handleKeyDown, { capture: true });
+ return () => window.removeEventListener('keydown', handleKeyDown, { capture: true });
+ }, []); // Empty deps - handler is stable via refs
+
+ const registerRef = useCallback((index: number) => (el: HTMLButtonElement | null) => {
+ itemRefs.current[index] = el;
+ }, []);
+
+ const getItemProps = useCallback((index: number) => ({
+ ref: registerRef(index),
+ tabIndex: selectedIndex === index ? 0 : -1,
+ onMouseEnter: () => setSelectedIndex(index),
+ onClick: () => menuActions[index]?.(),
+ }), [selectedIndex, registerRef, menuActions]);
+
+ const selectedRing = "ring-2 ring-white ring-opacity-80";
+
return (
// ADDED z-[100] here to ensure the Store Card sits above text prompts (which are z-50)
= ({
) : (
)}
@@ -117,16 +375,16 @@ const ItemStore: React.FC = ({
) : (
)}
@@ -137,16 +395,16 @@ const ItemStore: React.FC⭐ Bribe Reviewer
Gain an extra star
@@ -182,19 +440,19 @@ const ItemStore: React.FCPower-Ups
{[
- { type: 'beer', img: beerImg, color: 'amber' },
- { type: 'ice-cream', img: sundaeImg, color: 'blue' },
- { type: 'honey', img: honeyImg, color: 'orange' },
- ].map(({ type, img, color }) => (
+ { type: 'beer', img: beerImg, color: 'amber', index: 9 },
+ { type: 'ice-cream', img: sundaeImg, color: 'blue', index: 10 },
+ { type: 'honey', img: honeyImg, color: 'orange', index: 11 },
+ ].map(({ type, img, color, index }) => (
diff --git a/src/components/LandscapeControls.tsx b/src/components/LandscapeControls.tsx
deleted file mode 100644
index 68b1294..0000000
--- a/src/components/LandscapeControls.tsx
+++ /dev/null
@@ -1,203 +0,0 @@
-import React from 'react';
-import { sprite } from '../lib/assets';
-
-const pizzaPanImg = sprite("pizzapan.png");
-
-interface LandscapeControlsProps {
- gameOver: boolean;
- paused: boolean;
- nyanSweepActive: boolean;
- onMoveUp: () => void;
- onMoveDown: () => void;
- onServePizza: () => void;
- onUseOven: () => void;
- onCleanOven: () => void;
- currentLane: number;
- availableSlices: number;
- ovens: {
- [key: number]: {
- cooking: boolean;
- startTime: number;
- burned: boolean;
- cleaningStartTime: number;
- pausedElapsed?: number;
- sliceCount: number;
- };
- };
- ovenSpeedUpgrades: { [key: number]: number };
-}
-
-const LandscapeControls: React.FC
-
-
-
-
- {/* Right side - Oven and Serve Controls */}
-
- ![chef]({"https://i.imgur.com/EPCSa79.png"})
- {availableSlices > 0 && (
-
-
-
-
-
- {availableSlices > 0 && (
-
- {availableSlices}
-
- )}
-
- Lane {safeLane + 1}
-
-
- {/* Serve Pizza Button */}
-
-
- );
-};
-
-export default LandscapeControls;
\ No newline at end of file
diff --git a/src/components/LandscapeCustomer.tsx b/src/components/LandscapeCustomer.tsx
deleted file mode 100644
index f7e33c5..0000000
--- a/src/components/LandscapeCustomer.tsx
+++ /dev/null
@@ -1,79 +0,0 @@
-import React from 'react';
-import { Customer as CustomerType } from '../types/game';
-import droolfaceImg from '/sprites/droolface.png';
-import yumfaceImg from '/sprites/yumface.png';
-import frozenfaceImg from '/sprites/frozenface.png';
-const spicyfaceImg = "https://i.imgur.com/MDS5EVg.png";
-import woozyfaceImg from '/sprites/woozyface.png';
-const criticImg = "https://i.imgur.com/ZygBTOI.png";
-const badLuckBrianImg = "https://i.imgur.com/cs0LDgJ.png";
-const badLuckBrianPukeImg = "https://i.imgur.com/yRXQDIT.png";
-
-interface LandscapeCustomerProps {
- customer: CustomerType;
-}
-
-const LANDSCAPE_LANE_POSITIONS = [20, 40, 60, 80];
-
-const LandscapeCustomer: React.FC
-
-
-
- {/* Oven Control */}
-
- Serve
-
-
-
-
-
- {ovenStatus === 'burned' ? 'Clean!' :
- ovenStatus === 'burning' ? 'Burning!' :
- ovenStatus === 'warning' ? 'Warning!' :
- ovenStatus === 'ready' ? 'Take Out!' :
- ovenStatus === 'cooking' ? 'Cooking...' :
- 'Put Pizza'}
-
-
- {display.type === 'image' ? (
- 
- ) : (
-
- {customer.textMessage && (
-
- {display.value}
-
- )}
-
- {customer.textMessage}
-
- )}
-
- );
-};
-
-export default LandscapeCustomer;
diff --git a/src/components/LandscapeDroppedPlate.tsx b/src/components/LandscapeDroppedPlate.tsx
deleted file mode 100644
index e1254c2..0000000
--- a/src/components/LandscapeDroppedPlate.tsx
+++ /dev/null
@@ -1,50 +0,0 @@
-import React, { useEffect, useState } from 'react';
-import { DroppedPlate as DroppedPlateType } from '../types/game';
-import slice1PlateImg from '/sprites/1slicepizzapan.png';
-
-interface LandscapeDroppedPlateProps {
- droppedPlate: DroppedPlateType;
-}
-
-const LANDSCAPE_LANE_POSITIONS = [20, 40, 60, 80];
-const BLINK_DURATION = 250;
-const TOTAL_DURATION = 1000;
-
-const LandscapeDroppedPlate: React.FC
-
-
- );
-};
-
-export default LandscapeDroppedPlate;
diff --git a/src/components/LandscapeGameBoard.tsx b/src/components/LandscapeGameBoard.tsx
deleted file mode 100644
index 0bdb6ec..0000000
--- a/src/components/LandscapeGameBoard.tsx
+++ /dev/null
@@ -1,229 +0,0 @@
-import React, { useState, useCallback } from 'react';
-import LandscapeCustomer from './LandscapeCustomer';
-import PizzaSlice from './PizzaSlice';
-import EmptyPlate from './EmptyPlate';
-import LandscapeDroppedPlate from './LandscapeDroppedPlate';
-import PowerUp from './PowerUp';
-import PizzaSliceStack from './PizzaSliceStack';
-import FloatingScore from './FloatingScore';
-import Boss from './Boss';
-import { GameState } from '../types/game';
-import landscapeBg from '../assets/landscape version pizza chef.png';
-import { sprite } from '../lib/assets';
-
-const chefImg = sprite("chef.png");
-
-interface LandscapeGameBoardProps {
- gameState: GameState;
-}
-
-const LandscapeGameBoard: React.FC
- {/* Pizza Ovens - positioned on the left side */}
- {lanes.map((lane) => {
- const ovenStatus = getOvenStatus(lane);
- const oven = gameState.ovens[lane];
- const showSlices = oven.cooking && !oven.burned;
-
- return (
-
- );
-};
-
-export default LandscapeGameBoard;
diff --git a/src/components/LandscapeScoreBoard.tsx b/src/components/LandscapeScoreBoard.tsx
deleted file mode 100644
index 86fcf7d..0000000
--- a/src/components/LandscapeScoreBoard.tsx
+++ /dev/null
@@ -1,61 +0,0 @@
-import React from 'react';
-import { GameState } from '../types/game';
-import { Star, Trophy, DollarSign, Pause, HelpCircle, Layers } from 'lucide-react';
-
-interface LandscapeScoreBoardProps {
- gameState: GameState;
- onShowInstructions: () => void;
-}
-
-const LandscapeScoreBoard: React.FC
- {showSlices && (
-
- );
- })}
-
- {/* Chef positioned at current lane - only shown when NOT in nyan sweep */}
- {!gameState.nyanSweep?.active && (
-
-
- )}
-
- {ovenStatus === 'burned' ? '💀' :
- ovenStatus === 'extinguishing' ? '🧯' :
- ovenStatus === 'sweeping' ? '🧹' :
- ovenStatus === 'burning' ? '💀' :
- ovenStatus === 'warning-fire' ? '🔥' :
- ovenStatus === 'warning-pizza' ? '⚠️' :
- ovenStatus === 'ready' ? '♨️' :
- ovenStatus === 'cooking' ? '🌡️' :
- ''}
-
-
- {gameState.gameOver ? (
- 
- ) : (
-
- )}
-
- )}
-
- {/* Nyan Cat Chef - positioned directly on game board during sweep */}
- {gameState.nyanSweep?.active && (
-
- ) : (
-
- )}
-
-
-
-
-
- )}
-
- {/* Game Elements */}
- {gameState.customers.map((customer) => (
-
-
- 🍕
-
- )}
-
-
- );
-};
-
-export default LandscapeScoreBoard;
diff --git a/src/components/MafiaSlice.tsx b/src/components/MafiaSlice.tsx
new file mode 100644
index 0000000..ebee6b1
--- /dev/null
+++ b/src/components/MafiaSlice.tsx
@@ -0,0 +1,34 @@
+// src/components/MafiaSlice.tsx
+import React from 'react';
+import { MafiaSlice as MafiaSliceType } from '../types/game';
+
+interface MafiaSliceProps {
+ slice: MafiaSliceType;
+}
+
+const MafiaSlice: React.FC
-
-
-
-
-
-
-
-
- {Array.from({ length: 5 }, (_, i) => (
-
-
-
-
-
-
-
-
-
+ 🍕
+
+ );
+};
+
+export default MafiaSlice;
diff --git a/src/components/MobileGameControls.tsx b/src/components/MobileGameControls.tsx
index 16a4911..9d4f9a1 100644
--- a/src/components/MobileGameControls.tsx
+++ b/src/components/MobileGameControls.tsx
@@ -1,5 +1,6 @@
import React from 'react';
import { sprite } from '../lib/assets';
+import { getOvenDisplayStatus } from '../logic/ovenSystem';
const pizzaPanImg = sprite("pizzapan.png");
@@ -25,6 +26,7 @@ interface MobileGameControlsProps {
};
};
ovenSpeedUpgrades: { [key: number]: number };
+ isLandscape?: boolean;
}
const MobileGameControls: React.FC
+
+
+
+
+ {/* Right side - Oven and Serve Controls */}
+
+ {/* Serve Pizza Control */}
+
+
+ {/* Oven Control */}
+
+
+
+ );
+ }
+
+ // Portrait layout - controls at bottom
return (
diff --git a/src/components/PauseMenu.tsx b/src/components/PauseMenu.tsx
new file mode 100644
index 0000000..b890e59
--- /dev/null
+++ b/src/components/PauseMenu.tsx
@@ -0,0 +1,108 @@
+import React, { useEffect, useCallback } from 'react';
+import { Play, RotateCcw, Volume2, VolumeX, Trophy, HelpCircle } from 'lucide-react';
+import { useMenuKeyboardNav } from '../hooks/useMenuKeyboardNav';
+import { sprite } from '../lib/assets';
+
+const smokingChefImg = sprite('chef-smoking.png');
+
+interface PauseMenuProps {
+ isVisible: boolean;
+ isMuted: boolean;
+ onResume: () => void;
+ onReset: () => void;
+ onToggleMute: () => void;
+ onShowScores: () => void;
+ onShowHelp: () => void;
+}
+
+const PauseMenu: React.FC = ({
+ isVisible,
+ isMuted,
+ onResume,
+ onReset,
+ onToggleMute,
+ onShowScores,
+ onShowHelp,
+}) => {
+ const menuActions = [onResume, onReset, onToggleMute, onShowScores, onShowHelp];
+
+ const handleSelect = useCallback((index: number) => {
+ menuActions[index]?.();
+ }, [menuActions]);
+
+ const { selectedIndex, getItemProps } = useMenuKeyboardNav({
+ itemCount: 5, // 4 main buttons + help
+ columns: 2,
+ onSelect: handleSelect,
+ onEscape: onResume,
+ isActive: isVisible,
+ initialIndex: 0,
+ });
+
+ if (!isVisible) return null;
+
+ const buttonBaseClass = "flex items-center justify-center gap-2 px-4 py-3 rounded-lg transition-colors font-bold shadow-lg";
+ const selectedRing = "ring-4 ring-white ring-opacity-80";
+
+ return (
+ = ({ helpers }) => {
+ if (!helpers?.active) return null;
+
+ return (
+ <>
+ {/* Franco-Pepe */}
+ = ({ active, duration = 5000, isNumberOne = false }) => {
+ const [pieces, setPieces] = useState([]);
+ const [visible, setVisible] = useState(false);
+
+ useEffect(() => {
+ if (active) {
+ // Generate confetti pieces
+ const newPieces: ConfettiPiece[] = [];
+ for (let i = 0; i < 30; i++) {
+ newPieces.push({
+ id: i,
+ left: Math.random() * 100,
+ delay: Math.random() * 2,
+ duration: 2 + Math.random() * 2,
+ rotation: Math.random() * 720 - 360,
+ size: 24 + Math.random() * 24,
+ });
+ }
+ setPieces(newPieces);
+ setVisible(true);
+
+ // Hide after duration
+ const timer = setTimeout(() => {
+ setVisible(false);
+ }, duration);
+
+ return () => clearTimeout(timer);
+ }
+ }, [active, duration]);
+
+ if (!visible || pieces.length === 0) return null;
+
+ return (
+ = ({ slice }) => {
- const getIsLandscape = () =>
- typeof window !== 'undefined' ? window.innerWidth > window.innerHeight : true;
-
- const getIsMobile = () =>
- typeof navigator !== 'undefined'
- ? /Mobi|Android|iPhone|iPad|iPod/i.test(navigator.userAgent) ||
- (navigator as any).maxTouchPoints > 1
- : false;
-
- const [isLandscape, setIsLandscape] = React.useState(getIsLandscape);
- const [isMobile, setIsMobile] = React.useState(getIsMobile);
-
- React.useEffect(() => {
- const handleResize = () => {
- setIsLandscape(getIsLandscape());
- setIsMobile(getIsMobile());
- };
- window.addEventListener('resize', handleResize);
- window.addEventListener('orientationchange', handleResize);
- return () => {
- window.removeEventListener('resize', handleResize);
- window.removeEventListener('orientationchange', handleResize);
- };
- }, []);
-
- const topPercent =
- isMobile && isLandscape
- ? LANDSCAPE_LANE_POSITIONS[slice.lane]
- : slice.lane * 25 + 6;
+ const topPercent = slice.lane * 25 + 6;
return (
+
+ );
+};
+
+export default PauseMenu;
diff --git a/src/components/PepeHelpers.tsx b/src/components/PepeHelpers.tsx
new file mode 100644
index 0000000..3ebb4ab
--- /dev/null
+++ b/src/components/PepeHelpers.tsx
@@ -0,0 +1,93 @@
+import React from 'react';
+import { sprite } from '../lib/assets';
+import { PepeHelpers as PepeHelpersType } from '../types/game';
+import PizzaSliceStack from './PizzaSliceStack';
+
+const francoPepeImg = sprite("franco-pepe.png");
+const frankPepeImg = sprite("frank-pepe.png");
+
+interface PepeHelpersProps {
+ helpers: PepeHelpersType | undefined;
+}
+
+const PepeHelpers: React.FC
+ {/* Help button */}
+
+
+ 
+
+ {/* Button grid */}
+
+
+
+
+
+
+
+
+ 
+ {/* Franco's slice stack */}
+ {helpers.franco.availableSlices > 0 && (
+
+
+ {/* Frank-Pepe */}
+
+
+ )}
+
+ 
+ {/* Frank's slice stack */}
+ {helpers.frank.availableSlices > 0 && (
+
+
+ );
+};
+
+export default PepeHelpers;
diff --git a/src/components/PizzaConfetti.tsx b/src/components/PizzaConfetti.tsx
new file mode 100644
index 0000000..f974f02
--- /dev/null
+++ b/src/components/PizzaConfetti.tsx
@@ -0,0 +1,99 @@
+import React, { useEffect, useState } from 'react';
+import { sprite } from '../lib/assets';
+
+interface ConfettiPiece {
+ id: number;
+ left: number;
+ delay: number;
+ duration: number;
+ rotation: number;
+ size: number;
+}
+
+interface PizzaConfettiProps {
+ active: boolean;
+ duration?: number; // How long to show confetti in ms
+ isNumberOne?: boolean; // Use Molto Benny instead of pizza
+}
+
+const PizzaConfetti: React.FC
+
+ )}
+
+ {pieces.map((piece) => (
+
+ );
+};
+
+export default PizzaConfetti;
diff --git a/src/components/PizzaSlice.tsx b/src/components/PizzaSlice.tsx
index 8fc23d0..d47303c 100644
--- a/src/components/PizzaSlice.tsx
+++ b/src/components/PizzaSlice.tsx
@@ -1,42 +1,15 @@
import React from 'react';
import { PizzaSlice as PizzaSliceType } from '../types/game';
+import { sprite } from '../lib/assets';
+
+const slicePlateImg = sprite("slice-plate.png");
interface PizzaSliceProps {
slice: PizzaSliceType;
}
-const LANDSCAPE_LANE_POSITIONS = [20, 40, 60, 80]; // match LandscapeCustomer
-
const PizzaSlice: React.FC
+ {isNumberOne ? (
+ ![Molto Benny]({sprite("molto-benny.png")})
+ ) : (
+ '🍕'
+ )}
+
+ ))}
+
+
+
+ ) : (
+ '🍕'
+ )}
+ = ({ slice }) => {
top: `${topPercent}%`,
}}
>
- {/* White plate image underneath */}
+ {/* Pizza slice on plate */}
diff --git a/src/components/PowerUp.tsx b/src/components/PowerUp.tsx
index b297e5e..db6d6dc 100644
--- a/src/components/PowerUp.tsx
+++ b/src/components/PowerUp.tsx
@@ -6,6 +6,11 @@ import { sprite } from '../lib/assets';
const beerImg = sprite("beer.png");
const honeyImg = sprite("hot-honey.png");
const sundaeImg = sprite("sundae.png");
+const dogeImg = sprite("doge.png");
+const nyanImg = sprite("nyan-cat.png");
+const moltobennyImg = sprite("molto-benny.png");
+const starImg = sprite("star.png");
+const pepeImg = sprite("pepe.png");
interface PowerUpProps {
powerUp: PowerUpType;
@@ -31,13 +36,15 @@ const PowerUp: React.FC = ({ powerUp, boardWidth, boardHeight }) =
case 'beer':
return beerImg;
case 'doge':
- return 'https://i.imgur.com/TqnVUzO.png';
+ return dogeImg;
case 'nyan':
- return 'https://i.imgur.com/OLD9UC8.png';
+ return nyanImg;
case 'moltobenny':
- return 'https://i.imgur.com/5goVcAS.png';
+ return moltobennyImg;
case 'star':
- return 'https://i.imgur.com/hw0jkrq.png';
+ return starImg;
+ case 'pepe':
+ return pepeImg;
default:
return null;
}
diff --git a/src/components/PowerUpAlert.tsx b/src/components/PowerUpAlert.tsx
index 84f16a3..39e758b 100644
--- a/src/components/PowerUpAlert.tsx
+++ b/src/components/PowerUpAlert.tsx
@@ -1,5 +1,8 @@
-import React from 'react';
+import React, { useState, useEffect } from 'react';
import { PowerUpType } from '../types/game';
+import { sprite } from '../lib/assets';
+
+const dogeAlertImg = sprite("doge-power-up-alert.png");
interface PowerUpAlertProps {
powerUpType: PowerUpType;
@@ -7,12 +10,22 @@ interface PowerUpAlertProps {
}
const PowerUpAlert: React.FC = ({ powerUpType }) => {
+ const [isMobile, setIsMobile] = useState(false);
+
+ useEffect(() => {
+ const checkMobile = () => setIsMobile(window.innerWidth < 1000);
+ checkMobile();
+ window.addEventListener('resize', checkMobile);
+ return () => window.removeEventListener('resize', checkMobile);
+ }, []);
+
const getAlertContent = () => {
switch (powerUpType) {
case 'doge':
return {
- image: 'https://i.imgur.com/n0FtlUg.png',
+ image: dogeAlertImg,
scale: 6,
+ mobileScale: 2, // 1/3 size on mobile
};
default:
return null;
@@ -22,7 +35,7 @@ const PowerUpAlert: React.FC = ({ powerUpType }) => {
const content = getAlertContent();
if (!content) return null;
- const scale = content.scale || 1;
+ const scale = isMobile ? (content.mobileScale || content.scale / 3) : (content.scale || 1);
return (
diff --git a/src/components/PowerUp.tsx b/src/components/PowerUp.tsx
index b297e5e..db6d6dc 100644
--- a/src/components/PowerUp.tsx
+++ b/src/components/PowerUp.tsx
@@ -6,6 +6,11 @@ import { sprite } from '../lib/assets';
const beerImg = sprite("beer.png");
const honeyImg = sprite("hot-honey.png");
const sundaeImg = sprite("sundae.png");
+const dogeImg = sprite("doge.png");
+const nyanImg = sprite("nyan-cat.png");
+const moltobennyImg = sprite("molto-benny.png");
+const starImg = sprite("star.png");
+const pepeImg = sprite("pepe.png");
interface PowerUpProps {
powerUp: PowerUpType;
@@ -31,13 +36,15 @@ const PowerUp: React.FC void;
+ onPauseClick: () => void;
+ compact?: boolean;
}
-const ScoreBoard: React.FC = ({ gameState, onShowInstructions }) => {
+const ScoreBoard: React.FC = ({ gameState, onPauseClick, compact = false }) => {
return (
-
+
diff --git a/src/components/SplashScreen.tsx b/src/components/SplashScreen.tsx
index a2ae015..6a5ad63 100644
--- a/src/components/SplashScreen.tsx
+++ b/src/components/SplashScreen.tsx
@@ -1,19 +1,37 @@
-import React from 'react';
+import React, { useEffect } from 'react';
import { sprite } from '../lib/assets';
const chefImg = sprite("chef.png");
interface SplashScreenProps {
onStart: () => void;
+ isLoading?: boolean;
+ loadingProgress?: number;
}
-const SplashScreen: React.FC = ({ onStart }) => {
+const SplashScreen: React.FC = ({
+ onStart,
+ isLoading = false,
+ loadingProgress = 100
+}) => {
+ // Allow Enter key to start the game (only when not loading)
+ useEffect(() => {
+ const handleKeyDown = (e: KeyboardEvent) => {
+ if (e.key === 'Enter' && !isLoading) {
+ e.preventDefault();
+ onStart();
+ }
+ };
+ window.addEventListener('keydown', handleKeyDown);
+ return () => window.removeEventListener('keydown', handleKeyDown);
+ }, [onStart, isLoading]);
+
return (
@@ -27,11 +45,31 @@ const SplashScreen: React.FC = ({ onStart }) => {
className="w-48 h-auto mx-auto"
/>
+ {/* Loading progress bar */}
+ {isLoading && (
+
diff --git a/src/hooks/useAssetPreloader.ts b/src/hooks/useAssetPreloader.ts
new file mode 100644
index 0000000..e515a5b
--- /dev/null
+++ b/src/hooks/useAssetPreloader.ts
@@ -0,0 +1,66 @@
+import { useState, useEffect } from 'react';
+import { sprite, ui } from '../lib/assets';
+import { PRELOAD_SPRITES, PRELOAD_UI } from '../lib/spriteManifest';
+
+interface PreloadResult {
+ progress: number; // 0-100
+ isComplete: boolean;
+ failedAssets: string[];
+}
+
+function preloadImage(src: string): Promise {
+ return new Promise((resolve, reject) => {
+ const img = new Image();
+ img.onload = () => resolve();
+ img.onerror = () => reject(new Error(`Failed to load: ${src}`));
+ img.src = src;
+ });
+}
+
+export function useAssetPreloader(): PreloadResult {
+ const [loaded, setLoaded] = useState(0);
+ const [failedAssets, setFailedAssets] = useState([]);
+
+ // Build full URL list
+ const allUrls = [
+ ...PRELOAD_SPRITES.map(name => sprite(name)),
+ ...PRELOAD_UI.map(name => ui(name)),
+ ];
+
+ const total = allUrls.length;
+
+ useEffect(() => {
+ let isMounted = true;
+
+ const loadAssets = async () => {
+ // Load images in parallel with individual tracking
+ const promises = allUrls.map(async (url) => {
+ try {
+ await preloadImage(url);
+ if (isMounted) {
+ setLoaded(prev => prev + 1);
+ }
+ } catch {
+ console.warn(`Asset preload failed: ${url}`);
+ if (isMounted) {
+ setLoaded(prev => prev + 1); // Still count as "processed"
+ setFailedAssets(prev => [...prev, url]);
+ }
+ }
+ });
+
+ await Promise.all(promises);
+ };
+
+ loadAssets();
+
+ return () => {
+ isMounted = false;
+ };
+ }, []); // Run once on mount
+
+ const progress = total > 0 ? Math.round((loaded / total) * 100) : 0;
+ const isComplete = loaded >= total;
+
+ return { progress, isComplete, failedAssets };
+}
diff --git a/src/hooks/useGameLogic.ts b/src/hooks/useGameLogic.ts
index fd5a281..8819e5e 100644
--- a/src/hooks/useGameLogic.ts
+++ b/src/hooks/useGameLogic.ts
@@ -2,15 +2,14 @@
import { useState, useEffect, useCallback, useRef } from 'react';
import {
GameState,
- Customer,
PizzaSlice,
- EmptyPlate,
- PowerUp,
+ MafiaSlice,
+ GameStats,
PowerUpType,
- FloatingScore,
- DroppedPlate,
StarLostReason,
- BossMinion
+ EmptyPlate,
+ isCustomerLeaving,
+ getCustomerVariant
} from '../types/game';
import { soundManager } from '../utils/sounds';
import { getStreakMultiplier } from '../components/StreakDisplay';
@@ -20,13 +19,10 @@ import {
SPAWN_RATES,
PROBABILITIES,
SCORING,
- COSTS,
- BOSS_CONFIG,
- POWERUPS,
- TIMINGS,
POSITIONS,
INITIAL_GAME_STATE,
- OVEN_CONFIG
+ POWERUPS,
+ TIMINGS
} from '../lib/constants';
// --- Logic Imports ---
@@ -44,24 +40,55 @@ import {
import {
calculateCustomerScore,
- calculatePlateScore,
calculateMinionScore,
- calculatePowerUpScore,
checkLifeGain,
- updateStatsForStreak
+ updateStatsForStreak,
+ applyCustomerScoring
} from '../logic/scoringSystem';
import {
- checkSliceCustomerCollision,
checkSlicePowerUpCollision,
- checkChefPowerUpCollision,
- checkChefPlateCollision,
- checkNyanSweepCollision,
- checkStarPowerRange,
- checkMinionReachedChef,
- checkSliceMinionCollision
+ checkSliceCustomerCollision
} from '../logic/collisionSystem';
+import {
+ processChefPowerUpCollisions,
+ processPowerUpCollection,
+ processPowerUpExpirations
+} from '../logic/powerUpSystem';
+
+import {
+ processNyanSweepMovement,
+ checkNyanSweepCollisions
+} from '../logic/nyanSystem';
+
+import {
+ checkBossTrigger,
+ initializeBossBattle,
+ processBossTick
+} from '../logic/bossSystem';
+
+import { initializeBossMasks } from '../logic/bossCollisionMasks';
+
+import {
+ processSpawning
+} from '../logic/spawnSystem';
+
+import {
+ processPlates
+} from '../logic/plateSystem';
+
+import {
+ processPepeHelperTick,
+ checkPepeHelpersExpired
+} from '../logic/pepeHelperSystem';
+
+import {
+ spawnMafiaSlices,
+ updateMafiaSlices,
+ checkMafiaSliceCollision
+} from '../logic/mafiaSliceSystem';
+
// --- Store System (actions only) ---
import {
upgradeOven as upgradeOvenStore,
@@ -94,6 +121,11 @@ export const useGameLogic = (gameStarted: boolean = true) => {
const prevShowStoreRef = useRef(false);
+ // Initialize boss collision masks (fire and forget)
+ useEffect(() => {
+ initializeBossMasks();
+ }, []);
+
// --- 1. THE STABLE TICK REF ---
const latestTickRef = useRef<() => void>(() => { });
@@ -104,12 +136,23 @@ export const useGameLogic = (gameStarted: boolean = true) => {
return {
...state,
floatingScores: [...state.floatingScores, {
- id: `score-${now}-${Math.random()}`,
+ id: `score - ${now} -${Math.random()} `,
points, lane, position, startTime: now,
}],
};
}, []);
+ const addFloatingStar = useCallback((isGain: boolean, lane: number, position: number, state: GameState, count: number = 1): GameState => {
+ const now = Date.now();
+ return {
+ ...state,
+ floatingStars: [...state.floatingStars, {
+ id: `star-${now}-${Math.random()}`,
+ isGain, count, lane, position, startTime: now,
+ }],
+ };
+ }, []);
+
/**
* Consolidated "game over" cleanup:
* - triggers game over sound once
@@ -126,6 +169,8 @@ export const useGameLogic = (gameStarted: boolean = true) => {
// Stop oven loop + freeze oven timers
const pausedOvens = calculateOvenPauseState(state.ovens, true, now);
+ // Stop Nyan cat song
+ soundManager.stopNyan();
soundManager.gameOver();
const shouldDropPizza = state.availableSlices > 0;
@@ -148,7 +193,7 @@ export const useGameLogic = (gameStarted: boolean = true) => {
setGameState(prev => ({
...prev,
pizzaSlices: [...prev.pizzaSlices, {
- id: `pizza-${Date.now()}-${gameState.chefLane}`,
+ id: `pizza - ${Date.now()} -${gameState.chefLane} `,
lane: gameState.chefLane,
position: GAME_CONFIG.CHEF_X_POSITION,
speed: ENTITY_SPEEDS.PIZZA,
@@ -171,7 +216,8 @@ export const useGameLogic = (gameStarted: boolean = true) => {
if (gameState.gameOver || gameState.paused) return;
setGameState(prev => {
- const result = tryInteractWithOven(prev, prev.chefLane, Date.now());
+ const starPowerActive = prev.activePowerUps.some(p => p.type === 'star');
+ const result = tryInteractWithOven(prev, prev.chefLane, Date.now(), starPowerActive);
if (result.action === 'STARTED') {
soundManager.ovenStart();
@@ -227,6 +273,11 @@ export const useGameLogic = (gameStarted: boolean = true) => {
const hasStar = newState.activePowerUps.some(p => p.type === 'star');
const dogeMultiplier = hasDoge ? 2 : 1;
+ // Initialize clean kitchen timer if not set
+ if (newState.cleanKitchenStartTime === undefined) {
+ newState.cleanKitchenStartTime = now;
+ }
+
// 1. PROCESS OVENS (Logic from ovenSystem)
const ovenTickResult = processOvenTick(
newState.ovens,
@@ -250,6 +301,10 @@ export const useGameLogic = (gameStarted: boolean = true) => {
soundManager.lifeLost();
newState.lives = Math.max(0, newState.lives - 1);
newState.lastStarLostReason = 'burned_pizza';
+ // Use the oven's lane for the floating star
+ newState = addFloatingStar(false, event.lane, 5, newState);
+ // Reset clean kitchen timer
+ newState.cleanKitchenStartTime = now;
if (newState.lives === 0) {
newState = triggerGameOver(newState, now);
}
@@ -266,19 +321,22 @@ export const useGameLogic = (gameStarted: boolean = true) => {
}
customerUpdate.events.forEach(event => {
- if (event === 'LIFE_LOST') {
+ if (event.type === 'LIFE_LOST') {
soundManager.customerDisappointed();
soundManager.lifeLost();
}
- if (event === 'STAR_LOST_CRITIC') {
+ if (event.type === 'STAR_LOST_CRITIC') {
newState.lives = Math.max(0, newState.lives - 2);
newState.lastStarLostReason = 'disappointed_critic';
+ // Critic loses 2 stars - show one indicator with 2 stars
+ newState = addFloatingStar(false, event.lane, event.position, newState, 2);
}
- if (event === 'STAR_LOST_NORMAL') {
+ if (event.type === 'STAR_LOST_NORMAL') {
newState.lives = Math.max(0, newState.lives - 1);
newState.lastStarLostReason = 'disappointed_customer';
+ newState = addFloatingStar(false, event.lane, event.position, newState);
}
- if (event === 'GAME_OVER' && newState.lives === 0) {
+ if (event.type === 'GAME_OVER' && newState.lives === 0) {
newState = triggerGameOver(newState, now);
}
});
@@ -290,20 +348,21 @@ export const useGameLogic = (gameStarted: boolean = true) => {
const destroyedPowerUpIds = new Set();
const platesFromSlices = new Set();
const customerScores: Array<{ points: number; lane: number; position: number }> = [];
+ const starGainsToAdd: Array<{ lane: number; position: number }> = [];
let sliceWentOffScreen = false;
newState.pizzaSlices.forEach(slice => {
let consumed = false;
newState.customers = newState.customers.map(customer => {
- if (consumed || customer.served || customer.disappointed || customer.vomit || customer.leaving) return customer;
+ if (consumed || isCustomerLeaving(customer)) return customer;
const isHit = checkSliceCustomerCollision(slice, customer);
if (isHit) {
consumed = true;
- const hitResult = processCustomerHit(customer, now);
+ const hitResult = processCustomerHit(customer, now, hasDoge);
if (hitResult.newEntities.droppedPlate) newState.droppedPlates = [...newState.droppedPlates, hitResult.newEntities.droppedPlate];
if (hitResult.newEntities.emptyPlate) newState.emptyPlates = [...newState.emptyPlates, hitResult.newEntities.emptyPlate];
@@ -313,71 +372,116 @@ export const useGameLogic = (gameStarted: boolean = true) => {
soundManager.plateDropped();
newState.stats.currentCustomerStreak = 0;
newState.stats.currentPlateStreak = 0;
+ // Reset clean kitchen timer
+ newState.cleanKitchenStartTime = now;
+ // Brian still pays $1 even when he drops the slice
+ newState.bank += SCORING.BASE_BANK_REWARD;
+ newState.stats.totalEarned += SCORING.BASE_BANK_REWARD;
} else if (event === 'UNFROZEN_AND_SERVED') {
soundManager.customerUnfreeze();
- const { points: pointsEarned, bank: bankEarned } = calculateCustomerScore(
- customer,
- dogeMultiplier,
- getStreakMultiplier(newState.stats.currentCustomerStreak)
- );
+ const result = applyCustomerScoring(customer, newState, dogeMultiplier,
+ getStreakMultiplier(newState.stats.currentCustomerStreak),
+ { includeBank: true, countsAsServed: true, isFirstSlice: false, checkLifeGain: true });
+
+ newState.score += result.scoreToAdd;
+ newState.bank += result.bankToAdd;
+ newState.stats.totalEarned += result.bankToAdd;
+ newState.happyCustomers = result.newHappyCustomers;
+ newState.stats = result.newStats;
+ customerScores.push(result.floatingScore);
+
+ if (result.livesToAdd > 0) {
+ newState.lives += result.livesToAdd;
+ if (result.shouldPlayLifeSound) soundManager.lifeGained();
+ if (result.starGain) starGainsToAdd.push(result.starGain);
+ }
- newState.score += pointsEarned;
- newState.bank += bankEarned;
- customerScores.push({ points: pointsEarned, lane: customer.lane, position: customer.position });
+ } else if (event === 'WOOZY_STEP_1') {
+ soundManager.woozyServed();
- newState.happyCustomers += 1;
- newState.stats.customersServed += 1;
- newState.stats = updateStatsForStreak(newState.stats, 'customer');
+ const result = applyCustomerScoring(customer, newState, dogeMultiplier,
+ getStreakMultiplier(newState.stats.currentCustomerStreak),
+ { includeBank: true, countsAsServed: false, isFirstSlice: true, checkLifeGain: false });
- const lifeResult = checkLifeGain(newState.lives, newState.happyCustomers, dogeMultiplier);
- if (lifeResult.livesToAdd > 0) {
- newState.lives += lifeResult.livesToAdd;
- if (lifeResult.shouldPlaySound) soundManager.lifeGained();
- }
+ newState.score += result.scoreToAdd;
+ newState.bank += result.bankToAdd;
+ newState.stats.totalEarned += result.bankToAdd;
+ customerScores.push(result.floatingScore);
- } else if (event === 'WOOZY_STEP_1') {
+ } else if (event === 'STEVE_FIRST_SLICE') {
+ // Steve got his first slice but wants more - NO PAYMENT
soundManager.woozyServed();
- const { points: pointsEarned, bank: bankEarned } = calculateCustomerScore(
- customer,
- dogeMultiplier,
+ const result = applyCustomerScoring(customer, newState, dogeMultiplier,
getStreakMultiplier(newState.stats.currentCustomerStreak),
- true // isFirstSlice
- );
+ { includeBank: false, countsAsServed: false, isFirstSlice: true, checkLifeGain: false });
- newState.score += pointsEarned;
- newState.bank += bankEarned;
- customerScores.push({ points: pointsEarned, lane: customer.lane, position: customer.position });
+ newState.score += result.scoreToAdd;
+ customerScores.push(result.floatingScore);
- } else if (event === 'WOOZY_STEP_2' || event === 'SERVED_NORMAL' || event === 'SERVED_CRITIC') {
+ } else if (event === 'STEVE_SERVED') {
+ // Steve is satisfied - NO PAYMENT but counts as served
soundManager.customerServed();
- const { points: pointsEarned, bank: bankEarned } = calculateCustomerScore(
- customer,
- dogeMultiplier,
- getStreakMultiplier(newState.stats.currentCustomerStreak)
- );
-
- newState.score += pointsEarned;
- newState.bank += bankEarned;
- customerScores.push({ points: pointsEarned, lane: customer.lane, position: customer.position });
-
- newState.happyCustomers += 1;
- newState.stats.customersServed += 1;
- newState.stats = updateStatsForStreak(newState.stats, 'customer');
-
- const lifeResult = checkLifeGain(
- newState.lives,
- newState.happyCustomers,
- dogeMultiplier,
- customer.critic,
- customer.position
- );
-
- if (lifeResult.livesToAdd > 0) {
- newState.lives += lifeResult.livesToAdd;
- if (lifeResult.shouldPlaySound) soundManager.lifeGained();
+ const result = applyCustomerScoring(customer, newState, dogeMultiplier,
+ getStreakMultiplier(newState.stats.currentCustomerStreak),
+ { includeBank: false, countsAsServed: true, isFirstSlice: false, checkLifeGain: true });
+
+ newState.score += result.scoreToAdd;
+ newState.happyCustomers = result.newHappyCustomers;
+ newState.stats = result.newStats;
+ customerScores.push(result.floatingScore);
+
+ if (result.livesToAdd > 0) {
+ newState.lives += result.livesToAdd;
+ if (result.shouldPlayLifeSound) soundManager.lifeGained();
+ if (result.starGain) starGainsToAdd.push(result.starGain);
+ }
+
+ } else if (event === 'MAFIA_SERVED') {
+ // Pizza Mafia served - spawn 8 slices flying in all directions
+ soundManager.customerServed();
+
+ const result = applyCustomerScoring(customer, newState, dogeMultiplier,
+ getStreakMultiplier(newState.stats.currentCustomerStreak),
+ { includeBank: true, countsAsServed: true, isFirstSlice: false, checkLifeGain: true });
+
+ newState.score += result.scoreToAdd;
+ newState.bank += result.bankToAdd;
+ newState.stats.totalEarned += result.bankToAdd;
+ newState.happyCustomers = result.newHappyCustomers;
+ newState.stats = result.newStats;
+ customerScores.push(result.floatingScore);
+
+ if (result.livesToAdd > 0) {
+ newState.lives += result.livesToAdd;
+ if (result.shouldPlayLifeSound) soundManager.lifeGained();
+ if (result.starGain) starGainsToAdd.push(result.starGain);
+ }
+
+ // Spawn 8 mafia slices radiating outward
+ const mafiaSlices = spawnMafiaSlices(customer.lane, customer.position, now);
+ newState.mafiaSlices = [...newState.mafiaSlices, ...mafiaSlices];
+
+ } else if (event === 'WOOZY_STEP_2' || event === 'SERVED_NORMAL' || event === 'SERVED_CRITIC' || event === 'SERVED_BRIAN_DOGE') {
+ soundManager.customerServed();
+
+ const result = applyCustomerScoring(customer, newState, dogeMultiplier,
+ getStreakMultiplier(newState.stats.currentCustomerStreak),
+ { includeBank: true, countsAsServed: true, isFirstSlice: false, checkLifeGain: true });
+
+ newState.score += result.scoreToAdd;
+ newState.bank += result.bankToAdd;
+ newState.stats.totalEarned += result.bankToAdd;
+ newState.happyCustomers = result.newHappyCustomers;
+ newState.stats = result.newStats;
+ customerScores.push(result.floatingScore);
+
+ if (result.livesToAdd > 0) {
+ newState.lives += result.livesToAdd;
+ if (result.shouldPlayLifeSound) soundManager.lifeGained();
+ if (result.starGain) starGainsToAdd.push(result.starGain);
}
}
});
@@ -414,11 +518,16 @@ export const useGameLogic = (gameStarted: boolean = true) => {
newState.pizzaSlices = finalSlices;
newState.powerUps = newState.powerUps.filter(p => !destroyedPowerUpIds.has(p.id));
- if (sliceWentOffScreen) newState.stats.currentPlateStreak = 0;
+ if (sliceWentOffScreen) {
+ newState.stats.currentPlateStreak = 0;
+ newState.cleanKitchenStartTime = now;
+ }
customerScores.forEach(({ points, lane, position }) => { newState = addFloatingScore(points, lane, position, newState); });
+ starGainsToAdd.forEach(({ lane, position }) => { newState = addFloatingStar(true, lane, position, newState); });
// --- 4. CLEANUP EXPIRATIONS ---
newState.floatingScores = newState.floatingScores.filter(fs => now - fs.startTime < TIMINGS.FLOATING_SCORE_LIFETIME);
+ newState.floatingStars = newState.floatingStars.filter(fs => now - fs.startTime < TIMINGS.FLOATING_SCORE_LIFETIME);
newState.droppedPlates = newState.droppedPlates.filter(dp => now - dp.startTime < TIMINGS.DROPPED_PLATE_LIFETIME);
newState.customers = newState.customers.map(customer => {
if (customer.textMessage && customer.textMessageTime && now - customer.textMessageTime >= TIMINGS.TEXT_MESSAGE_LIFETIME) {
@@ -427,280 +536,275 @@ export const useGameLogic = (gameStarted: boolean = true) => {
return customer;
});
- const expiredStarPower = newState.activePowerUps.some(p => p.type === 'star' && now >= p.endTime);
- const expiredHoney = newState.activePowerUps.some(p => p.type === 'honey' && now >= p.endTime);
- newState.activePowerUps = newState.activePowerUps.filter(powerUp => now < powerUp.endTime);
- if (expiredStarPower) newState.starPowerActive = false;
- if (expiredHoney) newState.customers = newState.customers.map(c => ({ ...c, hotHoneyAffected: false }));
- if (newState.powerUpAlert && now >= newState.powerUpAlert.endTime) {
- if (newState.powerUpAlert.type !== 'doge' || !hasDoge) newState.powerUpAlert = undefined;
- }
+ // --- 4a. MAFIA SLICES PROCESSING ---
+ if (newState.mafiaSlices.length > 0) {
+ // Update positions
+ newState.mafiaSlices = updateMafiaSlices(newState.mafiaSlices, now);
- // --- 5. STAR POWER AUTO-FEED ---
- const starPowerScores: Array<{ points: number; lane: number; position: number }> = [];
- if (hasStar && newState.availableSlices > 0) {
- newState.customers = newState.customers.map(customer => {
- if (checkStarPowerRange(newState.chefLane, GAME_CONFIG.CHEF_X_POSITION, customer)) {
- newState.availableSlices = Math.max(0, newState.availableSlices - 1);
- if (customer.badLuckBrian) {
- soundManager.plateDropped();
- newState.stats.currentCustomerStreak = 0;
- newState.stats.currentPlateStreak = 0;
- const droppedPlate = { id: `dropped-${Date.now()}-${customer.id}`, lane: customer.lane, position: customer.position, startTime: Date.now(), hasSlice: true };
- newState.droppedPlates = [...newState.droppedPlates, droppedPlate];
- return { ...customer, flipped: false, leaving: true, movingRight: true, textMessage: "Ugh! I dropped my slice!", textMessageTime: Date.now() };
- }
- soundManager.customerServed();
+ // Check collisions with customers
+ const mafiaSlicesToRemove = new Set();
+ const mafiaScores: Array<{ points: number; lane: number; position: number }> = [];
+ const mafiaStarGains: Array<{ lane: number; position: number }> = [];
- const { points: pointsEarned, bank: bankEarned } = calculateCustomerScore(
- customer,
- dogeMultiplier,
- getStreakMultiplier(newState.stats.currentCustomerStreak)
- );
-
- newState.score += pointsEarned;
- newState.bank += bankEarned;
- newState.happyCustomers += 1;
- starPowerScores.push({ points: pointsEarned, lane: customer.lane, position: customer.position });
-
- newState.stats.customersServed += 1;
- newState.stats = updateStatsForStreak(newState.stats, 'customer');
-
- if (!customer.critic) {
- const lifeResult = checkLifeGain(newState.lives, newState.happyCustomers, dogeMultiplier);
- if (lifeResult.livesToAdd > 0) {
- newState.lives += lifeResult.livesToAdd;
- if (lifeResult.shouldPlaySound) soundManager.lifeGained();
+ newState.mafiaSlices.forEach(slice => {
+ if (mafiaSlicesToRemove.has(slice.id)) return;
+
+ newState.customers = newState.customers.map(customer => {
+ if (mafiaSlicesToRemove.has(slice.id) || isCustomerLeaving(customer)) return customer;
+
+ if (checkMafiaSliceCollision(slice, customer)) {
+ mafiaSlicesToRemove.add(slice.id);
+ soundManager.customerServed();
+
+ const result = applyCustomerScoring(customer, newState, dogeMultiplier,
+ getStreakMultiplier(newState.stats.currentCustomerStreak),
+ { includeBank: true, countsAsServed: true, isFirstSlice: false, checkLifeGain: true });
+
+ newState.score += result.scoreToAdd;
+ newState.bank += result.bankToAdd;
+ newState.stats.totalEarned += result.bankToAdd;
+ newState.happyCustomers = result.newHappyCustomers;
+ newState.stats = result.newStats;
+ mafiaScores.push(result.floatingScore);
+
+ if (result.livesToAdd > 0) {
+ newState.lives += result.livesToAdd;
+ if (result.shouldPlayLifeSound) soundManager.lifeGained();
+ if (result.starGain) mafiaStarGains.push(result.starGain);
}
+
+ // Return empty plate and mark as served
+ newState.emptyPlates = [...newState.emptyPlates, {
+ id: `plate-${now}-${customer.id}-mafia`,
+ lane: customer.lane,
+ position: customer.position,
+ speed: ENTITY_SPEEDS.PLATE
+ }];
+
+ return { ...customer, served: true, hasPlate: false };
}
+ return customer;
+ });
+ });
- const newPlate: EmptyPlate = { id: `plate-star-${Date.now()}-${customer.id}`, lane: customer.lane, position: customer.position, speed: ENTITY_SPEEDS.PLATE };
- newState.emptyPlates = [...newState.emptyPlates, newPlate];
- return { ...customer, served: true, hasPlate: false };
- }
- return customer;
+ // Remove consumed slices
+ newState.mafiaSlices = newState.mafiaSlices.filter(s => !mafiaSlicesToRemove.has(s.id));
+
+ // Add floating scores and stars
+ mafiaScores.forEach(({ points, lane, position }) => {
+ newState = addFloatingScore(points, lane, position, newState);
+ });
+ mafiaStarGains.forEach(({ lane, position }) => {
+ newState = addFloatingStar(true, lane, position, newState);
});
}
- starPowerScores.forEach(({ points, lane, position }) => { newState = addFloatingScore(points, lane, position, newState); });
- // --- 6. CHEF POWERUP COLLISIONS ---
- const caughtPowerUpIds = new Set();
- const powerUpScores: Array<{ points: number; lane: number; position: number }> = [];
- newState.powerUps.forEach(powerUp => {
- if (checkChefPowerUpCollision(newState.chefLane, GAME_CONFIG.CHEF_X_POSITION, powerUp) && !newState.nyanSweep?.active) {
- soundManager.powerUpCollected(powerUp.type);
-
- if (powerUp.type !== 'moltobenny') {
- const pointsEarned = calculatePowerUpScore(dogeMultiplier);
- newState.score += pointsEarned;
- powerUpScores.push({ points: pointsEarned, lane: powerUp.lane, position: powerUp.position });
- }
+ // --- 4. POWER-UP EXPIRATIONS ---
+ const expResult = processPowerUpExpirations(newState.activePowerUps, now);
+ newState.activePowerUps = expResult.activePowerUps;
+ newState.starPowerActive = expResult.starPowerActive;
- caughtPowerUpIds.add(powerUp.id);
- newState.stats.powerUpsUsed[powerUp.type] += 1;
-
- if (powerUp.type === 'beer') {
- let livesLost = 0;
- let lastReason: StarLostReason | undefined;
- newState.customers = newState.customers.map(customer => {
- if (customer.critic) {
- if (customer.woozy) return { ...customer, woozy: false, woozyState: undefined, frozen: false, hotHoneyAffected: false, textMessage: "I prefer wine", textMessageTime: Date.now() };
- if (!customer.served && !customer.vomit && !customer.disappointed && !customer.leaving) return { ...customer, textMessage: "I prefer wine", textMessageTime: Date.now() };
- return customer;
- }
- if (customer.woozy) {
- livesLost += 1;
- lastReason = 'beer_vomit';
- return { ...customer, woozy: false, vomit: true, disappointed: true, movingRight: true };
- }
- if (!customer.served && !customer.vomit && !customer.disappointed && !customer.leaving) {
- if (customer.badLuckBrian) {
- livesLost += 1;
- lastReason = 'brian_hurled';
- return { ...customer, vomit: true, disappointed: true, movingRight: true, flipped: false, textMessage: "Oh man I hurled", textMessageTime: Date.now(), hotHoneyAffected: false, frozen: false };
- }
- return { ...customer, woozy: true, woozyState: 'normal', movingRight: true, hotHoneyAffected: false, frozen: false };
- }
- return customer;
- });
- newState.lives = Math.max(0, newState.lives - livesLost);
- if (livesLost > 0) {
- soundManager.lifeLost();
- newState.stats.currentCustomerStreak = 0;
- if (lastReason) newState.lastStarLostReason = lastReason;
- }
- if (newState.lives === 0) {
- newState = triggerGameOver(newState, now);
- }
- } else if (powerUp.type === 'star') {
- newState.availableSlices = GAME_CONFIG.MAX_SLICES;
- newState.starPowerActive = true;
- newState.activePowerUps = [...newState.activePowerUps.filter(p => p.type !== 'star'), { type: 'star', endTime: now + POWERUPS.DURATION }];
- } else if (powerUp.type === 'doge') {
- newState.activePowerUps = [...newState.activePowerUps.filter(p => p.type !== 'doge'), { type: 'doge', endTime: now + POWERUPS.DURATION }];
- newState.powerUpAlert = { type: 'doge', endTime: now + POWERUPS.ALERT_DURATION_DOGE, chefLane: newState.chefLane };
- } else if (powerUp.type === 'nyan') {
- if (!newState.nyanSweep?.active) {
- newState.nyanSweep = { active: true, xPosition: GAME_CONFIG.CHEF_X_POSITION, laneDirection: 1, startTime: now, lastUpdateTime: now, startingLane: newState.chefLane };
- soundManager.nyanCatPowerUp();
- if (!hasDoge || newState.powerUpAlert?.type !== 'doge') {
- newState.powerUpAlert = { type: 'nyan', endTime: now + POWERUPS.ALERT_DURATION_NYAN, chefLane: newState.chefLane };
- }
- }
- } else if (powerUp.type === 'moltobenny') {
- const moltoScore = SCORING.MOLTOBENNY_POINTS * dogeMultiplier;
- const moltoMoney = SCORING.MOLTOBENNY_CASH * dogeMultiplier;
- newState.score += moltoScore;
- newState.bank += moltoMoney;
- powerUpScores.push({ points: moltoScore, lane: newState.chefLane, position: GAME_CONFIG.CHEF_X_POSITION });
- } else {
- newState.activePowerUps = [...newState.activePowerUps.filter(p => p.type !== powerUp.type), { type: powerUp.type, endTime: now + POWERUPS.DURATION }];
- if (powerUp.type === 'honey') {
- newState.customers = newState.customers.map(c => {
- if (c.served || c.disappointed || c.vomit || c.leaving) return c;
- if (c.badLuckBrian) return { ...c, shouldBeHotHoneyAffected: false, hotHoneyAffected: false, frozen: false, woozy: false, woozyState: undefined, textMessage: "I can't do spicy.", textMessageTime: Date.now() };
- return { ...c, shouldBeHotHoneyAffected: true, hotHoneyAffected: true, frozen: false, woozy: false, woozyState: undefined };
- });
- }
- if (powerUp.type === 'ice-cream') {
- newState.customers = newState.customers.map(c => {
- if (!c.served && !c.disappointed && !c.vomit) {
- if (c.badLuckBrian) return { ...c, textMessage: "I'm lactose intolerant", textMessageTime: Date.now() };
- return { ...c, shouldBeFrozenByIceCream: true, frozen: true, hotHoneyAffected: false, woozy: false, woozyState: undefined };
- }
- return c;
- });
+ // Handle specific expiration effects
+ if (expResult.expiredTypes.includes('honey')) {
+ newState.customers = newState.customers.map(c => ({ ...c, hotHoneyAffected: false }));
+ }
+
+ if (newState.powerUpAlert && now >= newState.powerUpAlert.endTime) {
+ if (newState.powerUpAlert.type !== 'doge' || !hasDoge) newState.powerUpAlert = undefined;
+ }
+
+ // --- 4b. PEPE HELPERS PROCESSING ---
+ if (newState.pepeHelpers?.active) {
+ // Check expiration first
+ if (checkPepeHelpersExpired(newState.pepeHelpers, now)) {
+ newState.pepeHelpers = undefined;
+ } else {
+ // Process helper actions
+ const pepeResult = processPepeHelperTick(newState, now);
+
+ // Apply state updates
+ if (pepeResult.updatedState.ovens) newState.ovens = pepeResult.updatedState.ovens;
+ if (pepeResult.updatedState.pizzaSlices) newState.pizzaSlices = pepeResult.updatedState.pizzaSlices;
+ if (pepeResult.updatedState.emptyPlates) newState.emptyPlates = pepeResult.updatedState.emptyPlates;
+ if (pepeResult.updatedState.pepeHelpers) newState.pepeHelpers = pepeResult.updatedState.pepeHelpers;
+ if (pepeResult.updatedState.stats) newState.stats = pepeResult.updatedState.stats;
+ if (pepeResult.updatedState.score !== undefined) newState.score = pepeResult.updatedState.score;
+
+ // Handle events (sounds)
+ pepeResult.events.forEach(event => {
+ if (event.type === 'OVEN_STARTED') soundManager.ovenStart();
+ if (event.type === 'PIZZA_PULLED') soundManager.servePizza();
+ if (event.type === 'CUSTOMER_SERVED') soundManager.servePizza();
+ if (event.type === 'PLATE_CAUGHT') soundManager.plateCaught();
+ });
+
+ // Add floating scores for plates caught by helpers
+ pepeResult.events.forEach(event => {
+ if (event.type === 'PLATE_CAUGHT') {
+ newState = addFloatingScore(50, event.lane, GAME_CONFIG.CHEF_X_POSITION, newState);
}
- }
+ });
}
+ }
+
+ // --- 5. STAR POWER AUTO-REFILL SLICES ---
+ if (hasStar) {
+ // Keep chef's pizza slices maxed out
+ newState.availableSlices = GAME_CONFIG.MAX_SLICES;
+ }
+
+ // --- 6. CHEF POWERUP COLLISIONS ---
+ const powerUpResult = processChefPowerUpCollisions(
+ newState,
+ newState.chefLane,
+ GAME_CONFIG.CHEF_X_POSITION,
+ dogeMultiplier,
+ now
+ );
+ newState = powerUpResult.newState;
+
+ // Play sounds for caught power-ups
+ powerUpResult.caughtPowerUpIds.forEach(id => {
+ const powerUp = newState.powerUps.find(p => p.id === id);
+ if (powerUp) soundManager.powerUpCollected(powerUp.type);
});
+
+ // Handle life loss sounds
+ if (powerUpResult.livesLost > 0) {
+ soundManager.lifeLost();
+ if (powerUpResult.shouldTriggerGameOver) {
+ newState = triggerGameOver(newState, now);
+ }
+ }
+
+ // Handle Nyan sweep sound
+ if (powerUpResult.nyanSweepStarted) {
+ soundManager.nyanCatPowerUp();
+ }
+
+ // Update power-ups: remove caught, move remaining, remove off-screen
newState.powerUps = newState.powerUps
- .filter(powerUp => !caughtPowerUpIds.has(powerUp.id))
+ .filter(powerUp => !powerUpResult.caughtPowerUpIds.has(powerUp.id))
.map(powerUp => ({ ...powerUp, position: powerUp.position - powerUp.speed }))
.filter(powerUp => powerUp.position > 0);
- powerUpScores.forEach(({ points, lane, position }) => { newState = addFloatingScore(points, lane, position, newState); });
+
+ // Add floating scores
+ powerUpResult.scores.forEach(({ points, lane, position }) => {
+ newState = addFloatingScore(points, lane, position, newState);
+ });
// --- 7. PLATE CATCHING LOGIC ---
- const platesToAddScores: Array<{ points: number; lane: number; position: number }> = [];
- newState.emptyPlates = newState.emptyPlates
- .map(plate => ({ ...plate, position: plate.position - plate.speed }))
- .filter(plate => {
- if (checkChefPlateCollision(newState.chefLane, plate) && !newState.nyanSweep?.active) {
- soundManager.plateCaught();
-
- const pointsEarned = calculatePlateScore(
- dogeMultiplier,
- getStreakMultiplier(newState.stats.currentPlateStreak)
- );
-
- newState.score += pointsEarned;
- platesToAddScores.push({ points: pointsEarned, lane: plate.lane, position: plate.position });
-
- newState.stats.platesCaught += 1;
- newState.stats = updateStatsForStreak(newState.stats, 'plate');
- return false;
- } else if (plate.position <= 0) {
- soundManager.plateDropped();
- newState.stats.currentPlateStreak = 0;
- return false;
- }
- return true;
- });
- platesToAddScores.forEach(({ points, lane, position }) => { newState = addFloatingScore(points, lane, position, newState); });
+ const plateResult = processPlates(
+ newState.emptyPlates,
+ newState.chefLane,
+ newState.stats,
+ dogeMultiplier,
+ getStreakMultiplier(newState.stats.currentPlateStreak),
+ newState.nyanSweep?.active ?? false
+ );
+
+ newState.emptyPlates = plateResult.remainingPlates;
+ newState.stats = plateResult.updatedStats;
+ newState.score += plateResult.totalScore;
+
+ plateResult.events.forEach(event => {
+ if (event === 'CAUGHT') soundManager.plateCaught();
+ else if (event === 'DROPPED') {
+ soundManager.plateDropped();
+ newState.cleanKitchenStartTime = now;
+ }
+ });
+
+ plateResult.scores.forEach(({ points, lane, position }) => {
+ newState = addFloatingScore(points, lane, position, newState);
+ });
// --- 8. NYAN CAT SWEEP LOGIC ---
if (newState.nyanSweep?.active) {
- const MAX_X = 90;
- const dt = Math.min(now - newState.nyanSweep.lastUpdateTime, 100);
- const INITIAL_X = GAME_CONFIG.CHEF_X_POSITION;
- const totalDistance = MAX_X - INITIAL_X;
- const duration = 2600;
- const moveIncrement = (totalDistance / duration) * dt;
- const oldX = newState.nyanSweep.xPosition;
- const newXPosition = oldX + moveIncrement;
- const laneChangeSpeed = 0.01;
- let newLane = newState.chefLane + (newState.nyanSweep.laneDirection * laneChangeSpeed * dt);
- let newLaneDirection = newState.nyanSweep.laneDirection;
-
- if (newLane > GAME_CONFIG.LANE_BOTTOM) {
- newLane = GAME_CONFIG.LANE_BOTTOM;
- newLaneDirection = -1;
- } else if (newLane < GAME_CONFIG.LANE_TOP) {
- newLane = GAME_CONFIG.LANE_TOP;
- newLaneDirection = 1;
- }
+ // 1. Move Sweep
+ const sweepResult = processNyanSweepMovement(newState.nyanSweep, newState.chefLane, now);
+
+ const newLane = sweepResult.nextChefLane;
+ // 2. Check Collisions
const nyanScores: Array<{ points: number; lane: number; position: number }> = [];
- newState.customers = newState.customers.map(customer => {
- if (customer.served || customer.disappointed || customer.vomit) return customer;
- if (checkNyanSweepCollision(newLane, oldX, newXPosition, customer)) {
- if (customer.badLuckBrian) {
+
+ const collisionResult = checkNyanSweepCollisions(
+ newState.nyanSweep,
+ sweepResult.newXPosition,
+ newLane,
+ newState.customers,
+ newState.bossBattle?.active && !newState.bossBattle.bossDefeated ? newState.bossBattle.minions : undefined
+ );
+
+ // 3. Process Customer Hits
+ const hitCustomerSet = new Set(collisionResult.hitCustomerIds);
+
+ if (hitCustomerSet.size > 0) {
+ newState.customers = newState.customers.map(customer => {
+ if (hitCustomerSet.has(customer.id)) {
+ if (getCustomerVariant(customer) === 'badLuckBrian') {
+ soundManager.customerServed();
+ return { ...customer, brianNyaned: true, leaving: true, hasPlate: false, flipped: false, movingRight: true, woozy: false, frozen: false, unfrozenThisPeriod: undefined };
+ }
+
soundManager.customerServed();
- return { ...customer, brianNyaned: true, leaving: true, hasPlate: false, flipped: false, movingRight: true, woozy: false, frozen: false, unfrozenThisPeriod: undefined };
- }
- soundManager.customerServed();
- const { points: pointsEarned, bank: bankEarned } = calculateCustomerScore(
- customer,
- dogeMultiplier,
- getStreakMultiplier(newState.stats.currentCustomerStreak)
- );
-
- newState.score += pointsEarned;
- newState.bank += bankEarned;
- nyanScores.push({ points: pointsEarned, lane: customer.lane, position: customer.position });
-
- newState.happyCustomers += 1;
- newState.stats.customersServed += 1;
- newState.stats = updateStatsForStreak(newState.stats, 'customer');
-
- const lifeResult = checkLifeGain(
- newState.lives,
- newState.happyCustomers,
- dogeMultiplier,
- customer.critic,
- customer.position
- );
- if (lifeResult.livesToAdd > 0) {
- newState.lives += lifeResult.livesToAdd;
- if (lifeResult.shouldPlaySound) soundManager.lifeGained();
+ const result = applyCustomerScoring(customer, newState, dogeMultiplier,
+ getStreakMultiplier(newState.stats.currentCustomerStreak),
+ { includeBank: true, countsAsServed: true, isFirstSlice: false, checkLifeGain: true });
+
+ newState.score += result.scoreToAdd;
+ newState.bank += result.bankToAdd;
+ newState.stats.totalEarned += result.bankToAdd;
+ newState.happyCustomers = result.newHappyCustomers;
+ newState.stats = result.newStats;
+ nyanScores.push(result.floatingScore);
+
+ if (result.livesToAdd > 0) {
+ newState.lives += result.livesToAdd;
+ if (result.shouldPlayLifeSound) soundManager.lifeGained();
+ newState = addFloatingStar(true, customer.lane, customer.position, newState);
+ }
+
+ return { ...customer, served: true, hasPlate: false, woozy: false, frozen: false, unfrozenThisPeriod: undefined };
}
- return { ...customer, served: true, hasPlate: false, woozy: false, frozen: false, unfrozenThisPeriod: undefined };
- }
- return customer;
- });
+ return customer;
+ });
+ }
- if (newState.bossBattle?.active && !newState.bossBattle.bossDefeated) {
+ // 4. Process Minion Hits
+ const hitMinionSet = new Set(collisionResult.hitMinionIds);
+ if (hitMinionSet.size > 0 && newState.bossBattle) {
newState.bossBattle.minions = newState.bossBattle.minions.map(minion => {
- if (minion.defeated) return minion;
- const isLaneHit = Math.abs(minion.lane - newLane) < 0.8;
- const sweepStart = oldX - 10;
- const sweepEnd = newXPosition + 10;
- const isPositionHit = minion.position >= sweepStart && minion.position <= sweepEnd;
-
- if (isLaneHit && isPositionHit) {
+ if (hitMinionSet.has(minion.id)) {
soundManager.customerServed();
- const pointsEarned = calculateMinionScore();
+ const pointsEarned = calculateMinionScore(); // Assumes this is available in scope
newState.score += pointsEarned;
- newState = addFloatingScore(pointsEarned, minion.lane, minion.position, newState);
+ // addFloatingScore helper handles the state update for score list, but we can't call it easily inside map.
+ // We'll add to nyanScores list and process it after.
+ nyanScores.push({ points: pointsEarned, lane: minion.lane, position: minion.position });
return { ...minion, defeated: true };
}
return minion;
});
}
+
+ // Add floaters
nyanScores.forEach(({ points, lane, position }) => { newState = addFloatingScore(points, lane, position, newState); });
+ // 5. Update State
newState.chefLane = newLane;
- newState.nyanSweep = { ...newState.nyanSweep, xPosition: newXPosition, laneDirection: newLaneDirection, lastUpdateTime: now };
- if (newState.nyanSweep.xPosition >= MAX_X) {
- newState.chefLane = Math.round(newState.chefLane);
- newState.chefLane = Math.max(GAME_CONFIG.LANE_TOP, Math.min(GAME_CONFIG.LANE_BOTTOM, newState.chefLane));
+ if (sweepResult.sweepComplete) {
+ // Snap lane done in helper but helper returned finalLane as nextChefLane
newState.nyanSweep = undefined;
if (newState.pendingStoreShow) {
newState.showStore = true;
newState.pendingStoreShow = false;
}
+ } else if (sweepResult.nextSweep) {
+ newState.nyanSweep = sweepResult.nextSweep;
}
}
@@ -718,133 +822,85 @@ export const useGameLogic = (gameStarted: boolean = true) => {
else newState.showStore = true;
}
- const crossedBossLevel = BOSS_CONFIG.TRIGGER_LEVELS.find(triggerLvl =>
- oldLevel < triggerLvl && targetLevel >= triggerLvl
+ // Check if boss battle should trigger
+ const bossTrigger = checkBossTrigger(
+ oldLevel,
+ targetLevel,
+ newState.defeatedBossLevels,
+ newState.bossBattle
);
-
- if (crossedBossLevel !== undefined &&
- !newState.defeatedBossLevels.includes(crossedBossLevel) &&
- !newState.bossBattle?.active) {
-
- const initialMinions: BossMinion[] = [];
- for (let i = 0; i < BOSS_CONFIG.MINIONS_PER_WAVE; i++) {
- initialMinions.push({
- id: `minion-${now}-1-${i}`,
- lane: i % 4,
- position: POSITIONS.SPAWN_X + (Math.floor(i / 4) * 15),
- speed: ENTITY_SPEEDS.MINION,
- defeated: false,
- });
- }
-
- newState.bossBattle = {
- active: true,
- bossHealth: BOSS_CONFIG.HEALTH,
- currentWave: 1,
- minions: initialMinions,
- bossVulnerable: true,
- bossDefeated: false,
- bossPosition: BOSS_CONFIG.BOSS_POSITION,
- };
+ if (bossTrigger !== null) {
+ newState.bossBattle = initializeBossBattle(now, bossTrigger.type);
}
}
+ // --- BOSS BATTLE PROCESSING ---
if (newState.bossBattle?.active && !newState.bossBattle.bossDefeated) {
- const bossScores: Array<{ points: number; lane: number; position: number }> = [];
- newState.bossBattle.minions = newState.bossBattle.minions.map(minion => {
- if (minion.defeated) return minion;
- return { ...minion, position: minion.position - minion.speed };
- });
+ const bossResult = processBossTick(
+ newState.bossBattle,
+ newState.pizzaSlices,
+ newState.level,
+ newState.defeatedBossLevels,
+ now
+ );
- newState.bossBattle.minions = newState.bossBattle.minions.map(minion => {
- if (minion.defeated) return minion;
- if (checkMinionReachedChef(minion)) {
+ newState.bossBattle = bossResult.nextBossBattle;
+ newState.pizzaSlices = newState.pizzaSlices.filter(s => !bossResult.consumedSliceIds.has(s.id));
+ newState.score += bossResult.scoreGained;
+
+ // Handle lives lost
+ if (bossResult.livesLost > 0) {
+ for (let i = 0; i < bossResult.livesLost; i++) {
soundManager.lifeLost();
- newState.lives = Math.max(0, newState.lives - 1);
- if (newState.lives === 0) {
- newState = triggerGameOver(newState, now);
- }
- return { ...minion, defeated: true };
+ newState = addFloatingStar(false, i % 4, GAME_CONFIG.CHEF_X_POSITION, newState);
}
- return minion;
- });
-
- const consumedSliceIds = new Set();
- newState.pizzaSlices.forEach(slice => {
- if (consumedSliceIds.has(slice.id)) return;
- newState.bossBattle!.minions = newState.bossBattle!.minions.map(minion => {
- if (minion.defeated || consumedSliceIds.has(slice.id)) return minion;
- if (checkSliceMinionCollision(slice, minion, 8)) {
- consumedSliceIds.add(slice.id);
- soundManager.customerServed();
- const pointsEarned = SCORING.MINION_DEFEAT;
- newState.score += pointsEarned;
- bossScores.push({ points: pointsEarned, lane: minion.lane, position: minion.position });
- return { ...minion, defeated: true };
- }
- return minion;
- });
- });
+ newState.lives = Math.max(0, newState.lives - bossResult.livesLost);
+ if (newState.lives === 0) {
+ newState = triggerGameOver(newState, now);
+ }
+ }
- if (newState.bossBattle.bossVulnerable) {
- newState.pizzaSlices.forEach(slice => {
- if (consumedSliceIds.has(slice.id)) return;
- if (Math.abs(newState.bossBattle!.bossPosition - slice.position) < 10) {
- consumedSliceIds.add(slice.id);
- soundManager.customerServed();
- newState.bossBattle!.bossHealth -= 1;
- const pointsEarned = SCORING.BOSS_HIT;
- newState.score += pointsEarned;
- bossScores.push({ points: pointsEarned, lane: slice.lane, position: slice.position });
-
- if (newState.bossBattle!.bossHealth <= 0) {
- newState.bossBattle!.bossDefeated = true;
- newState.bossBattle!.active = false;
- newState.bossBattle!.minions = [];
- newState.score += SCORING.BOSS_DEFEAT;
- bossScores.push({ points: SCORING.BOSS_DEFEAT, lane: 1, position: newState.bossBattle!.bossPosition });
-
- const currentBossLevel = BOSS_CONFIG.TRIGGER_LEVELS
- .slice()
- .reverse()
- .find(lvl => newState.level >= lvl);
-
- if (currentBossLevel && !newState.defeatedBossLevels.includes(currentBossLevel)) {
- newState.defeatedBossLevels = [...newState.defeatedBossLevels, currentBossLevel];
- }
- }
- }
- });
+ // Handle defeated boss level
+ if (bossResult.defeatedBossLevel !== undefined) {
+ newState.defeatedBossLevels = [...newState.defeatedBossLevels, bossResult.defeatedBossLevel];
}
- newState.pizzaSlices = newState.pizzaSlices.filter(slice => !consumedSliceIds.has(slice.id));
- bossScores.forEach(({ points, lane, position }) => { newState = addFloatingScore(points, lane, position, newState); });
-
- const activeMinions = newState.bossBattle.minions.filter(m => !m.defeated);
- if (activeMinions.length === 0) {
- if (newState.bossBattle.currentWave < BOSS_CONFIG.WAVES) {
- const nextWave = newState.bossBattle.currentWave + 1;
- const newMinions: BossMinion[] = [];
- for (let i = 0; i < BOSS_CONFIG.MINIONS_PER_WAVE; i++) {
- newMinions.push({
- id: `minion-${now}-${nextWave}-${i}`,
- lane: i % 4,
- position: POSITIONS.SPAWN_X + (Math.floor(i / 4) * 15),
- speed: ENTITY_SPEEDS.MINION,
- defeated: false,
- });
- }
- newState.bossBattle.currentWave = nextWave;
- newState.bossBattle.minions = newMinions;
- } else if (!newState.bossBattle.bossVulnerable) {
- newState.bossBattle.bossVulnerable = true;
- newState.bossBattle.minions = [];
+
+ // Play sounds and add floating scores for events
+ bossResult.events.forEach(event => {
+ if (event.type === 'MINION_DEFEATED' || event.type === 'BOSS_HIT' || event.type === 'BOSS_DEFEATED') {
+ soundManager.customerServed();
+ newState = addFloatingScore(event.points, event.lane, event.position, newState);
}
+ });
+ }
+
+ // --- CLEAN KITCHEN BONUS CHECK ---
+ if (newState.cleanKitchenStartTime !== undefined) {
+ const cleanDuration = now - newState.cleanKitchenStartTime;
+ const timeSinceLastBonus = newState.lastCleanKitchenBonusTime
+ ? now - newState.lastCleanKitchenBonusTime
+ : Infinity;
+
+ // Award bonus if 30 seconds of clean kitchen and at least 30 seconds since last bonus
+ if (cleanDuration >= SCORING.CLEAN_KITCHEN_TIME && timeSinceLastBonus >= SCORING.CLEAN_KITCHEN_TIME) {
+ const bonusPoints = SCORING.CLEAN_KITCHEN_BONUS * dogeMultiplier;
+ newState.score += bonusPoints;
+ newState = addFloatingScore(bonusPoints, newState.chefLane, GAME_CONFIG.CHEF_X_POSITION, newState);
+ newState.cleanKitchenStartTime = now; // Reset timer for next bonus
+ newState.lastCleanKitchenBonusTime = now;
+ newState.cleanKitchenBonusAlert = { endTime: now + 3000 }; // Show for 3 seconds
+ soundManager.lifeGained(); // Use a celebratory sound
}
}
+ // Clear expired clean kitchen bonus alert
+ if (newState.cleanKitchenBonusAlert && now >= newState.cleanKitchenBonusAlert.endTime) {
+ newState.cleanKitchenBonusAlert = undefined;
+ }
+
return newState;
});
- }, [addFloatingScore, triggerGameOver]); // ✅ removed gameState.* and ovenSoundStates deps
+ }, [addFloatingScore, addFloatingStar, triggerGameOver]); // ✅ removed gameState.* and ovenSoundStates deps
// --- Store / Upgrades / Debug (now via storeSystem.ts) ---
@@ -878,87 +934,39 @@ export const useGameLogic = (gameStarted: boolean = true) => {
setGameState(prev => {
if (prev.gameOver) return prev;
const now = Date.now();
- let newState = {
- ...prev,
- stats: {
- ...prev.stats,
- powerUpsUsed: { ...prev.stats.powerUpsUsed, [type]: prev.stats.powerUpsUsed[type] + 1 }
- }
+
+ // Create synthetic power-up for the collection system
+ const syntheticPowerUp = {
+ id: `debug-${now}`,
+ lane: prev.chefLane,
+ position: GAME_CONFIG.CHEF_X_POSITION,
+ speed: 0,
+ type
};
- const dogeMultiplier = prev.activePowerUps.some(p => p.type === 'doge') ? 2 : 1;
+ // Use the unified power-up collection system
+ const result = processPowerUpCollection(prev, syntheticPowerUp, 1, now);
+ let newState = result.newState;
- if (type === 'beer') {
- let livesLost = 0;
- let lastReason: StarLostReason | undefined;
- newState.customers = newState.customers.map(customer => {
- if (customer.critic) {
- if (customer.woozy) return { ...customer, woozy: false, woozyState: undefined, frozen: false, hotHoneyAffected: false, textMessage: "I prefer wine", textMessageTime: Date.now() };
- if (!customer.served && !customer.vomit && !customer.disappointed && !customer.leaving) return { ...customer, textMessage: "I prefer wine", textMessageTime: Date.now() };
- return customer;
- }
- if (customer.woozy) {
- livesLost += 1;
- lastReason = 'beer_vomit';
- return { ...customer, woozy: false, vomit: true, disappointed: true, movingRight: true };
- }
- if (!customer.served && !customer.vomit && !customer.leaving) {
- if (customer.badLuckBrian) {
- livesLost += 1;
- lastReason = 'brian_hurled';
- return { ...customer, vomit: true, disappointed: true, movingRight: true, flipped: false, textMessage: "Oh man I hurled", textMessageTime: Date.now(), hotHoneyAffected: false, frozen: false };
- }
- return { ...customer, woozy: true, woozyState: 'normal', movingRight: true, hotHoneyAffected: false, frozen: false };
- }
- return customer;
- });
- newState.lives = Math.max(0, newState.lives - livesLost);
- if (livesLost > 0) {
- newState.stats.currentCustomerStreak = 0;
- if (lastReason) newState.lastStarLostReason = lastReason;
- }
- if (newState.lives === 0) {
- newState = triggerGameOver(newState as GameState, now);
- }
- } else if (type === 'star') {
- newState.availableSlices = GAME_CONFIG.MAX_SLICES;
- newState.starPowerActive = true;
- newState.activePowerUps = [...newState.activePowerUps.filter(p => p.type !== 'star'), { type: 'star', endTime: now + POWERUPS.DURATION }];
- } else if (type === 'doge') {
- newState.activePowerUps = [...newState.activePowerUps.filter(p => p.type !== 'doge'), { type: 'doge', endTime: now + POWERUPS.DURATION }];
- newState.powerUpAlert = { type: 'doge', endTime: now + POWERUPS.ALERT_DURATION_DOGE, chefLane: newState.chefLane };
- } else if (type === 'nyan') {
- if (!newState.nyanSweep?.active) {
- newState.nyanSweep = { active: true, xPosition: GAME_CONFIG.CHEF_X_POSITION, laneDirection: 1, startTime: now, lastUpdateTime: now, startingLane: newState.chefLane };
- soundManager.nyanCatPowerUp();
- if (!newState.activePowerUps.some(p => p.type === 'doge') || newState.powerUpAlert?.type !== 'doge') {
- newState.powerUpAlert = { type: 'nyan', endTime: now + POWERUPS.ALERT_DURATION_NYAN, chefLane: newState.chefLane };
- }
- }
- } else {
- newState.activePowerUps = [...newState.activePowerUps.filter(p => p.type !== type), { type: type, endTime: now + POWERUPS.DURATION }];
- if (type === 'honey') {
- newState.customers = newState.customers.map(c => {
- if (c.served || c.disappointed || c.vomit || c.leaving) return c;
- if (c.badLuckBrian) return { ...c, shouldBeHotHoneyAffected: false, hotHoneyAffected: false, frozen: false, woozy: false, woozyState: undefined, textMessage: "I can't do spicy.", textMessageTime: Date.now() };
- return { ...c, shouldBeHotHoneyAffected: true, hotHoneyAffected: true, frozen: false, woozy: false, woozyState: undefined };
- });
- }
- if (type === 'ice-cream') {
- newState.customers = newState.customers.map(c => {
- if (!c.served && !c.disappointed && !c.vomit) {
- if (c.badLuckBrian) return { ...c, textMessage: "I'm lactose intolerant", textMessageTime: Date.now() };
- return { ...c, shouldBeFrozenByIceCream: true, frozen: true, hotHoneyAffected: false, woozy: false, woozyState: undefined };
- }
- return c;
- });
+ // Handle side effects
+ if (result.livesLost > 0) {
+ soundManager.lifeLost();
+ if (result.shouldTriggerGameOver) {
+ newState = triggerGameOver(newState, now);
}
}
- return newState as GameState;
+
+ // Play Nyan sweep sound if started
+ if (result.nyanSweepStarted) {
+ soundManager.nyanCatPowerUp();
+ }
+
+ return newState;
});
}, [triggerGameOver]);
const resetGame = useCallback(() => {
+ soundManager.stopNyan();
setGameState({ ...INITIAL_GAME_STATE });
lastCustomerSpawnRef.current = 0;
lastPowerUpSpawnRef.current = 0;
@@ -968,9 +976,32 @@ export const useGameLogic = (gameStarted: boolean = true) => {
const togglePause = useCallback(() => {
setGameState(prev => {
+ const now = Date.now();
const newPaused = !prev.paused;
- const updatedOvens = calculateOvenPauseState(prev.ovens, newPaused, Date.now());
- return { ...prev, paused: newPaused, ovens: updatedOvens };
+ const updatedOvens = calculateOvenPauseState(prev.ovens, newPaused, now);
+
+ // Pause/resume Nyan cat song
+ if (newPaused) {
+ soundManager.pauseNyan();
+ } else {
+ soundManager.resumeNyan();
+ }
+
+ // Handle clean kitchen timer pause/resume
+ let cleanKitchenStartTime = prev.cleanKitchenStartTime;
+ let lastPauseTime = prev.lastPauseTime;
+
+ if (newPaused) {
+ // Starting pause - record when we paused
+ lastPauseTime = now;
+ } else if (prev.lastPauseTime && cleanKitchenStartTime) {
+ // Resuming - adjust clean kitchen start time to exclude pause duration
+ const pauseDuration = now - prev.lastPauseTime;
+ cleanKitchenStartTime = cleanKitchenStartTime + pauseDuration;
+ lastPauseTime = undefined;
+ }
+
+ return { ...prev, paused: newPaused, ovens: updatedOvens, cleanKitchenStartTime, lastPauseTime };
});
}, []);
@@ -982,18 +1013,31 @@ export const useGameLogic = (gameStarted: boolean = true) => {
const now = Date.now();
if (!prevShowStore && currentShowStore) {
+ // Store opening - pause game
setGameState(prev => ({
...prev,
paused: true,
- ovens: calculateOvenPauseState(prev.ovens, true, now)
+ ovens: calculateOvenPauseState(prev.ovens, true, now),
+ lastPauseTime: now, // Track pause time for clean kitchen timer
}));
}
if (prevShowStore && !currentShowStore) {
- setGameState(prev => ({
- ...prev,
- paused: false,
- ovens: calculateOvenPauseState(prev.ovens, false, now)
- }));
+ // Store closing - unpause game
+ setGameState(prev => {
+ // Adjust clean kitchen start time to exclude pause duration
+ let cleanKitchenStartTime = prev.cleanKitchenStartTime;
+ if (prev.lastPauseTime && cleanKitchenStartTime) {
+ const pauseDuration = now - prev.lastPauseTime;
+ cleanKitchenStartTime = cleanKitchenStartTime + pauseDuration;
+ }
+ return {
+ ...prev,
+ paused: false,
+ ovens: calculateOvenPauseState(prev.ovens, false, now),
+ cleanKitchenStartTime,
+ lastPauseTime: undefined,
+ };
+ });
}
prevShowStoreRef.current = currentShowStore;
}, [gameState.showStore]);
@@ -1009,76 +1053,25 @@ export const useGameLogic = (gameStarted: boolean = true) => {
const now = Date.now();
- // Customer spawn (gate by min interval)
- const spawnDelay =
- SPAWN_RATES.CUSTOMER_MIN_INTERVAL_BASE -
- (current.level * SPAWN_RATES.CUSTOMER_MIN_INTERVAL_DECREMENT);
-
- const levelSpawnRate =
- SPAWN_RATES.CUSTOMER_BASE_RATE +
- (current.level - 1) * SPAWN_RATES.CUSTOMER_LEVEL_INCREMENT;
-
- const effectiveSpawnRate = current.bossBattle?.active
- ? levelSpawnRate * 0.5
- : levelSpawnRate;
+ // Use spawn system for customer and power-up spawning
+ const spawnResult = processSpawning(
+ lastCustomerSpawnRef.current,
+ lastPowerUpSpawnRef.current,
+ now,
+ current.level,
+ current.bossBattle?.active ?? false
+ );
let next = current;
- if (now - lastCustomerSpawnRef.current >= spawnDelay && Math.random() < effectiveSpawnRate * 0.01) {
- const lane = Math.floor(Math.random() * GAME_CONFIG.LANE_COUNT);
- const disappointedEmojis = ['😢', '😭', '😠', '🤬'];
- const isCritic = Math.random() < PROBABILITIES.CRITIC_CHANCE;
- const isBadLuckBrian = !isCritic && Math.random() < PROBABILITIES.BAD_LUCK_BRIAN_CHANCE;
-
+ if (spawnResult.newCustomer) {
lastCustomerSpawnRef.current = now;
-
- next = {
- ...next,
- customers: [
- ...next.customers,
- {
- id: `customer-${now}-${lane}`,
- lane,
- position: POSITIONS.SPAWN_X,
- speed: ENTITY_SPEEDS.CUSTOMER_BASE,
- served: false,
- hasPlate: false,
- leaving: false,
- disappointed: false,
- disappointedEmoji: disappointedEmojis[Math.floor(Math.random() * disappointedEmojis.length)],
- movingRight: false,
- critic: isCritic,
- badLuckBrian: isBadLuckBrian,
- flipped: isBadLuckBrian,
- }
- ]
- };
+ next = { ...next, customers: [...next.customers, spawnResult.newCustomer] };
}
- // PowerUp spawn (gate by min interval)
- if (now - lastPowerUpSpawnRef.current >= SPAWN_RATES.POWERUP_MIN_INTERVAL && Math.random() < SPAWN_RATES.POWERUP_CHANCE) {
- const lane = Math.floor(Math.random() * GAME_CONFIG.LANE_COUNT);
- const rand = Math.random();
- const randomType =
- rand < PROBABILITIES.POWERUP_STAR_CHANCE
- ? 'star'
- : POWERUPS.TYPES[Math.floor(Math.random() * POWERUPS.TYPES.length)];
-
+ if (spawnResult.newPowerUp) {
lastPowerUpSpawnRef.current = now;
-
- next = {
- ...next,
- powerUps: [
- ...next.powerUps,
- {
- id: `powerup-${now}-${lane}`,
- lane,
- position: POSITIONS.POWERUP_SPAWN_X,
- speed: ENTITY_SPEEDS.POWERUP,
- type: randomType,
- }
- ]
- };
+ next = { ...next, powerUps: [...next.powerUps, spawnResult.newPowerUp] };
}
return next;
diff --git a/src/hooks/useMenuKeyboardNav.ts b/src/hooks/useMenuKeyboardNav.ts
new file mode 100644
index 0000000..daa3372
--- /dev/null
+++ b/src/hooks/useMenuKeyboardNav.ts
@@ -0,0 +1,161 @@
+import { useState, useEffect, useCallback, useRef } from 'react';
+
+interface UseMenuKeyboardNavOptions {
+ itemCount: number;
+ columns?: number; // For grid layouts (default 1 = vertical list)
+ onSelect: (index: number) => void;
+ onEscape?: () => void;
+ isActive?: boolean; // Whether this menu is currently active/visible
+ initialIndex?: number;
+ loop?: boolean; // Whether to wrap around at edges (default true)
+}
+
+/**
+ * Hook for keyboard navigation in menus
+ * Supports arrow keys, Enter to select, Escape to close
+ */
+export const useMenuKeyboardNav = ({
+ itemCount,
+ columns = 1,
+ onSelect,
+ onEscape,
+ isActive = true,
+ initialIndex = 0,
+ loop = true,
+}: UseMenuKeyboardNavOptions) => {
+ const [selectedIndex, setSelectedIndex] = useState(initialIndex);
+ const itemRefs = useRef<(HTMLButtonElement | HTMLElement | null)[]>([]);
+
+ // Reset selection when menu becomes active
+ useEffect(() => {
+ if (isActive) {
+ setSelectedIndex(initialIndex);
+ }
+ }, [isActive, initialIndex]);
+
+ // Focus the selected element when it changes
+ useEffect(() => {
+ if (isActive && itemRefs.current[selectedIndex]) {
+ itemRefs.current[selectedIndex]?.focus();
+ }
+ }, [selectedIndex, isActive]);
+
+ const navigate = useCallback((direction: 'up' | 'down' | 'left' | 'right') => {
+ if (itemCount === 0) return;
+
+ setSelectedIndex(current => {
+ let next = current;
+ const rows = Math.ceil(itemCount / columns);
+
+ switch (direction) {
+ case 'up':
+ next = current - columns;
+ if (next < 0) {
+ next = loop ? itemCount - 1 : current;
+ }
+ break;
+ case 'down':
+ next = current + columns;
+ if (next >= itemCount) {
+ next = loop ? 0 : current;
+ }
+ break;
+ case 'left':
+ if (columns > 1) {
+ // In grid, move left within row
+ if (current % columns === 0) {
+ next = loop ? current + columns - 1 : current;
+ if (next >= itemCount) next = itemCount - 1;
+ } else {
+ next = current - 1;
+ }
+ } else {
+ // In single column, treat as up
+ next = current - 1;
+ if (next < 0) next = loop ? itemCount - 1 : 0;
+ }
+ break;
+ case 'right':
+ if (columns > 1) {
+ // In grid, move right within row
+ if ((current + 1) % columns === 0 || current === itemCount - 1) {
+ next = loop ? current - (current % columns) : current;
+ } else {
+ next = current + 1;
+ }
+ } else {
+ // In single column, treat as down
+ next = current + 1;
+ if (next >= itemCount) next = loop ? 0 : itemCount - 1;
+ }
+ break;
+ }
+
+ // Ensure next is within bounds
+ return Math.max(0, Math.min(itemCount - 1, next));
+ });
+ }, [itemCount, columns, loop]);
+
+ useEffect(() => {
+ if (!isActive) return;
+
+ const handleKeyDown = (e: KeyboardEvent) => {
+ switch (e.key) {
+ case 'ArrowUp':
+ e.preventDefault();
+ navigate('up');
+ break;
+ case 'ArrowDown':
+ e.preventDefault();
+ navigate('down');
+ break;
+ case 'ArrowLeft':
+ e.preventDefault();
+ navigate('left');
+ break;
+ case 'ArrowRight':
+ e.preventDefault();
+ navigate('right');
+ break;
+ case 'Enter':
+ e.preventDefault();
+ onSelect(selectedIndex);
+ break;
+ case 'Escape':
+ e.preventDefault();
+ onEscape?.();
+ break;
+ }
+ };
+
+ window.addEventListener('keydown', handleKeyDown);
+ return () => window.removeEventListener('keydown', handleKeyDown);
+ }, [isActive, navigate, onSelect, onEscape, selectedIndex]);
+
+ // Helper to register refs for focusable items
+ const registerItem = useCallback((index: number) => (el: HTMLButtonElement | HTMLElement | null) => {
+ itemRefs.current[index] = el;
+ }, []);
+
+ // Helper to get props for each menu item
+ const getItemProps = useCallback((index: number) => ({
+ ref: registerItem(index),
+ tabIndex: selectedIndex === index ? 0 : -1,
+ 'data-selected': selectedIndex === index,
+ onMouseEnter: () => setSelectedIndex(index),
+ onClick: () => onSelect(index),
+ // Prevent space bar from triggering button click (browser default)
+ onKeyDown: (e: React.KeyboardEvent) => {
+ if (e.key === ' ') {
+ e.preventDefault();
+ }
+ },
+ }), [selectedIndex, registerItem, onSelect]);
+
+ return {
+ selectedIndex,
+ setSelectedIndex,
+ getItemProps,
+ registerItem,
+ };
+};
diff --git a/src/lib/constants.ts b/src/lib/constants.ts
index 38e5d2f..6ae40e0 100644
--- a/src/lib/constants.ts
+++ b/src/lib/constants.ts
@@ -4,14 +4,14 @@ export const GAME_CONFIG = {
STARTING_LIVES: 3,
LEVEL_THRESHOLD: 500, // Score needed to level up
GAME_LOOP_INTERVAL: 50, // ms
-
+
// Store Settings
STORE_LEVEL_INTERVAL: 10,
-
+
// Chef & Player
MAX_SLICES: 8,
CHEF_X_POSITION: 15, // The "catch/serve" zone (approx 15%)
-
+
// Lanes
LANE_COUNT: 4,
LANE_TOP: 0,
@@ -23,7 +23,7 @@ export const OVEN_CONFIG = {
WARNING_TIME: 7000, // Pizza starts warning
BURN_TIME: 8000, // Pizza burns (total time)
CLEANING_TIME: 3000,
-
+
// Upgrade Timings (based on speedUpgrade level 0-3)
COOK_TIMES: [3000, 2500, 2000, 1500],
MAX_UPGRADE_LEVEL: 7,
@@ -51,30 +51,50 @@ export const SPAWN_RATES = {
export const PROBABILITIES = {
CRITIC_CHANCE: 0.15,
BAD_LUCK_BRIAN_CHANCE: 0.1, // If not critic
+ SCUMBAG_STEVE_CHANCE: 0.08, // If not critic or brian
+ PIZZA_MAFIA_CHANCE: 0.05, // If not critic, brian, or steve
POWERUP_STAR_CHANCE: 0.1,
};
+export const SCUMBAG_STEVE = {
+ SPEED_MULTIPLIER: 1.4, // 40% faster than normal
+ SLICES_REQUIRED: 2,
+ LANE_CHANGE_INTERVAL: 1500, // ms between possible lane changes
+ LANE_CHANGE_CHANCE: 0.3, // 30% chance to change lane each interval
+};
+
+export const MAFIA_SLICE_CONFIG = {
+ SLICE_COUNT: 8,
+ SPEED: 2.5,
+ LIFETIME: 2000, // ms
+ LANE_SPEED: 0.02, // Vertical movement speed
+};
+
export const SCORING = {
// Customer Service
CUSTOMER_NORMAL: 150,
CUSTOMER_CRITIC: 300,
CUSTOMER_FIRST_SLICE: 50, // "Drooling" state
-
+
// Actions
PLATE_CAUGHT: 50,
POWERUP_COLLECTED: 100,
-
+
// Boss
MINION_DEFEAT: 100,
BOSS_HIT: 100,
BOSS_DEFEAT: 5000,
-
+
// Special
MOLTOBENNY_POINTS: 10000,
MOLTOBENNY_CASH: 69,
-
+
// Bank
BASE_BANK_REWARD: 1,
+
+ // Clean Kitchen Bonus
+ CLEAN_KITCHEN_BONUS: 1000,
+ CLEAN_KITCHEN_TIME: 30000, // 30 seconds
};
export const COSTS = {
@@ -85,24 +105,50 @@ export const COSTS = {
};
export const BOSS_CONFIG = {
- TRIGGER_LEVELS: [30],
+ DOMINOS_LEVEL: 30,
+ PAPA_JOHN_LEVEL: 10, // Single appearance at level 10
+ BOSS_POSITION: 85,
+};
+
+export const PAPA_JOHN_CONFIG = {
+ HEALTH: 40, // 40 slices to defeat, changes image every 8 hits
+ WAVES: 3,
+ MINIONS_PER_WAVE: 4,
+ HITS_PER_IMAGE: 8, // Change sprite every 8 hits
+};
+
+export const DOMINOS_CONFIG = {
HEALTH: 24,
WAVES: 3,
MINIONS_PER_WAVE: 4,
- BOSS_POSITION: 85,
};
export const POWERUPS = {
DURATION: 5000, // ms
- ALERT_DURATION_DOGE: 5000,
+ DOGE_DURATION: 8750, // 75% longer than base duration
+ PEPE_DURATION: 8000, // 8 seconds
+ ALERT_DURATION_DOGE: 8750,
ALERT_DURATION_NYAN: 3000,
- TYPES: ['honey', 'ice-cream', 'beer', 'doge', 'nyan', 'moltobenny'] as const,
+ TYPES: ['honey', 'ice-cream', 'beer', 'doge', 'nyan', 'moltobenny', 'pepe'] as const,
+};
+
+export const NYAN_CONFIG = {
+ MAX_X: 90, // End position of sweep
+ DURATION: 2600, // Total sweep duration in ms
+ LANE_CHANGE_SPEED: 0.01, // Vertical movement speed
+ DT_MAX: 100, // Max delta time per frame
+};
+
+export const PEPE_CONFIG = {
+ ACTION_INTERVAL: 100, // ms between helper actions (famous chefs are fast!)
+ STARTING_SLICES: 4, // Famous chefs come prepared
};
export const TIMINGS = {
FLOATING_SCORE_LIFETIME: 1000,
DROPPED_PLATE_LIFETIME: 1000,
TEXT_MESSAGE_LIFETIME: 3000,
+ WARNING_BLINK_INTERVAL: 250, // ms between warning blinks
};
export const POSITIONS = {
@@ -113,13 +159,21 @@ export const POSITIONS = {
TURN_AROUND_POINT: 90, // For woozy customers
};
+// Lane positioning (percentage-based layout)
+export const LAYOUT = {
+ LANE_HEIGHT_PERCENT: 25, // Each lane is 25% of board height
+ LANE_Y_OFFSET: 6, // Vertical offset within lane (%)
+};
+
export const INITIAL_GAME_STATE = {
customers: [],
pizzaSlices: [],
+ mafiaSlices: [],
emptyPlates: [],
powerUps: [],
activePowerUps: [],
floatingScores: [],
+ floatingStars: [],
droppedPlates: [],
chefLane: 0,
score: 0,
@@ -162,9 +216,17 @@ export const INITIAL_GAME_STATE = {
doge: 0,
nyan: 0,
moltobenny: 0,
+ pepe: 0,
+ speed: 0,
+ slow: 0,
},
ovenUpgradesMade: 0,
+ totalEarned: 0,
+ totalSpent: 0,
},
bossBattle: undefined,
- defeatedBossLevels:[],
+ defeatedBossLevels: [],
+ cleanKitchenStartTime: undefined,
+ lastCleanKitchenBonusTime: undefined,
+ cleanKitchenBonusAlert: undefined,
};
\ No newline at end of file
diff --git a/src/lib/spriteManifest.ts b/src/lib/spriteManifest.ts
new file mode 100644
index 0000000..141a022
--- /dev/null
+++ b/src/lib/spriteManifest.ts
@@ -0,0 +1,57 @@
+// All sprites to preload before game starts
+export const PRELOAD_SPRITES = [
+ // Characters
+ 'chef.png',
+ 'sad-chef.png',
+ 'nyan-chef.png',
+
+ // Customer faces
+ 'drool-face.png',
+ 'yum-face.png',
+ 'frozen-face.png',
+ 'woozy-face.png',
+ 'spicy-face.png',
+ 'critic.png',
+ 'bad-luck-brian.png',
+ 'bad-luck-brian-puke.png',
+ 'scumbag-steve.png',
+ 'rainbow-brian.png',
+
+ // Food
+ 'slice-plate.png',
+ 'paperplate.png',
+ '1slicepizzapan.png',
+ '2slicepizzapan.png',
+ '3slicepizzapan.png',
+ '4slicepizzapan.png',
+ '5slicepizzapan.png',
+ '6slicepizzapan.png',
+ '7slicepizzapan.png',
+ '8slicepizzapan.png',
+
+ // Power-ups
+ 'beer.png',
+ 'hot-honey.png',
+ 'sundae.png',
+ 'doge.png',
+ 'nyan-cat.png',
+ 'pepe.png',
+ 'molto-benny.png',
+ 'star.png',
+
+ // Boss/special
+ 'dominos-boss.png',
+ 'papa-john.png',
+ 'papa-john-2.png',
+ 'papa-john-3.png',
+ 'papa-john-4.png',
+ 'papa-john-5.png',
+ 'papa-john-6.png',
+ 'franco-pepe.png',
+ 'frank-pepe.png',
+] as const;
+
+// UI assets to preload (separate array for different CDN path)
+export const PRELOAD_UI = [
+ 'controls.png',
+] as const;
diff --git a/src/lib/supabase.ts b/src/lib/supabase.ts
index cb15a97..67c897d 100644
--- a/src/lib/supabase.ts
+++ b/src/lib/supabase.ts
@@ -1,10 +1,9 @@
-import { createClient } from '@supabase/supabase-js';
+import { createClient, SupabaseClient } from '@supabase/supabase-js';
const supabaseUrl = import.meta.env.VITE_SUPABASE_URL;
const supabaseAnonKey = import.meta.env.VITE_SUPABASE_ANON_KEY;
-if (!supabaseUrl || !supabaseAnonKey) {
- throw new Error('Missing Supabase environment variables');
-}
-
-export const supabase = createClient(supabaseUrl, supabaseAnonKey);
+export const supabase: SupabaseClient | null =
+ supabaseUrl && supabaseAnonKey
+ ? createClient(supabaseUrl, supabaseAnonKey)
+ : null;
diff --git a/src/logic/bossCollisionMasks.ts b/src/logic/bossCollisionMasks.ts
new file mode 100644
index 0000000..3533265
--- /dev/null
+++ b/src/logic/bossCollisionMasks.ts
@@ -0,0 +1,93 @@
+/**
+ * Boss Collision Masks
+ *
+ * Loads pre-generated collision masks for pixel-perfect collision detection.
+ * Masks are 32x32 boolean grids where true = solid pixel, false = transparent.
+ */
+
+import { BOSS_CONFIG } from '../lib/constants';
+
+const ASSET_BASE = "https://pizza-chef-assets.pages.dev";
+
+export interface CollisionMask {
+ width: number;
+ height: number;
+ data: boolean[][];
+}
+
+// Cached masks for Papa John sprites (6 variants)
+const papaJohnMasks: (CollisionMask | null)[] = [null, null, null, null, null, null];
+let masksInitialized = false;
+
+const PAPA_JOHN_MASK_FILES = [
+ 'papa-john.json',
+ 'papa-john-2.json',
+ 'papa-john-3.json',
+ 'papa-john-4.json',
+ 'papa-john-5.json',
+ 'papa-john-6.json',
+];
+
+/**
+ * Fetch and cache all Papa John collision masks.
+ * Call once at game start. Fire-and-forget - game works without masks.
+ */
+export const initializeBossMasks = async (): Promise => {
+ if (masksInitialized) return;
+
+ const loadPromises = PAPA_JOHN_MASK_FILES.map(async (filename, index) => {
+ try {
+ const url = `${ASSET_BASE}/sprites/masks/${filename}`;
+ const response = await fetch(url);
+ if (response.ok) {
+ const mask = await response.json() as CollisionMask;
+ papaJohnMasks[index] = mask;
+ }
+ } catch {
+ // Silently fail - game works without pixel-perfect collision
+ }
+ });
+
+ await Promise.all(loadPromises);
+ masksInitialized = true;
+};
+
+/**
+ * Get the collision mask for the current Papa John sprite.
+ * Returns null if masks haven't loaded yet.
+ *
+ * @param hitsReceived - Number of hits Papa John has taken
+ */
+export const getPapaJohnMask = (hitsReceived: number): CollisionMask | null => {
+ const spriteIndex = Math.min(
+ Math.floor(hitsReceived / BOSS_CONFIG.HITS_PER_IMAGE),
+ papaJohnMasks.length - 1
+ );
+ return papaJohnMasks[spriteIndex];
+};
+
+/**
+ * Check if a point collides with a solid pixel in the mask.
+ *
+ * @param mask - The collision mask
+ * @param normalizedX - X position within sprite bounds (0-1)
+ * @param normalizedY - Y position within sprite bounds (0-1)
+ * @returns true if the point hits a solid pixel
+ */
+export const checkMaskCollision = (
+ mask: CollisionMask,
+ normalizedX: number,
+ normalizedY: number
+): boolean => {
+ // Clamp to valid range
+ if (normalizedX < 0 || normalizedX >= 1 || normalizedY < 0 || normalizedY >= 1) {
+ return false;
+ }
+
+ // Map to mask grid coordinates
+ const gridX = Math.floor(normalizedX * mask.width);
+ const gridY = Math.floor(normalizedY * mask.height);
+
+ // Return whether this cell is solid
+ return mask.data[gridY]?.[gridX] ?? false;
+};
diff --git a/src/logic/bossSystem.ts b/src/logic/bossSystem.ts
new file mode 100644
index 0000000..9f6c82f
--- /dev/null
+++ b/src/logic/bossSystem.ts
@@ -0,0 +1,445 @@
+import { GameState, BossBattle, BossMinion, PizzaSlice, BossType } from '../types/game';
+import { BOSS_CONFIG, PAPA_JOHN_CONFIG, DOMINOS_CONFIG, POSITIONS, ENTITY_SPEEDS, SCORING } from '../lib/constants';
+import { checkSliceMinionCollision, checkMinionReachedChef } from './collisionSystem';
+import { getPapaJohnMask, checkMaskCollision } from './bossCollisionMasks';
+
+export type BossEvent =
+ | { type: 'MINION_DEFEATED'; lane: number; position: number; points: number }
+ | { type: 'BOSS_HIT'; lane: number; position: number; points: number }
+ | { type: 'BOSS_DEFEATED'; lane: number; position: number; points: number }
+ | { type: 'MINION_REACHED_CHEF' }
+ | { type: 'WAVE_COMPLETE'; nextWave: number }
+ | { type: 'BOSS_VULNERABLE' };
+
+export interface BossTickResult {
+ nextBossBattle: BossBattle;
+ consumedSliceIds: Set;
+ livesLost: number;
+ scoreGained: number;
+ events: BossEvent[];
+ defeatedBossLevel?: number;
+}
+
+export interface BossTriggerResult {
+ type: BossType;
+ level: number;
+}
+
+/**
+ * Check if a boss battle should trigger based on level progression
+ */
+export const checkBossTrigger = (
+ oldLevel: number,
+ newLevel: number,
+ defeatedBossLevels: number[],
+ currentBossBattle?: BossBattle
+): BossTriggerResult | null => {
+ if (currentBossBattle?.active) return null;
+
+ // Check Papa John (level 10)
+ if (oldLevel < BOSS_CONFIG.PAPA_JOHN_LEVEL && newLevel >= BOSS_CONFIG.PAPA_JOHN_LEVEL &&
+ !defeatedBossLevels.includes(BOSS_CONFIG.PAPA_JOHN_LEVEL)) {
+ return { type: 'papaJohn', level: BOSS_CONFIG.PAPA_JOHN_LEVEL };
+ }
+
+ // Check Dominos (level 30)
+ if (oldLevel < BOSS_CONFIG.DOMINOS_LEVEL && newLevel >= BOSS_CONFIG.DOMINOS_LEVEL &&
+ !defeatedBossLevels.includes(BOSS_CONFIG.DOMINOS_LEVEL)) {
+ return { type: 'dominos', level: BOSS_CONFIG.DOMINOS_LEVEL };
+ }
+
+ return null;
+};
+
+/**
+ * Create initial minions for a wave
+ */
+export const createWaveMinions = (waveNumber: number, now: number, minionsPerWave: number): BossMinion[] => {
+ const minions: BossMinion[] = [];
+ for (let i = 0; i < minionsPerWave; i++) {
+ minions.push({
+ id: `minion-${now}-${waveNumber}-${i}`,
+ lane: i % 4,
+ position: POSITIONS.SPAWN_X + (Math.floor(i / 4) * 15),
+ speed: ENTITY_SPEEDS.MINION,
+ defeated: false,
+ });
+ }
+ return minions;
+};
+
+/**
+ * Get boss config based on boss type
+ */
+const getBossConfig = (bossType: BossType) => {
+ return bossType === 'papaJohn' ? PAPA_JOHN_CONFIG : DOMINOS_CONFIG;
+};
+
+/**
+ * Initialize a new boss battle
+ */
+export const initializeBossBattle = (
+ now: number,
+ bossType: BossType
+): BossBattle => {
+ const config = getBossConfig(bossType);
+ // Papa John has no minions - immediately vulnerable
+ const isPapaJohn = bossType === 'papaJohn';
+ return {
+ active: true,
+ bossType,
+ bossHealth: config.HEALTH,
+ currentWave: isPapaJohn ? config.WAVES : 1, // Skip waves for Papa John
+ minions: isPapaJohn ? [] : createWaveMinions(1, now, config.MINIONS_PER_WAVE),
+ bossVulnerable: isPapaJohn, // Papa John is immediately vulnerable
+ bossDefeated: false,
+ bossPosition: isPapaJohn ? 50 : BOSS_CONFIG.BOSS_POSITION, // Papa John starts in the middle
+ bossLane: 1.5, // Start in the middle (between lanes 1 and 2)
+ bossLaneDirection: 1, // Start moving down
+ bossXDirection: -1, // Start moving left
+ hitsReceived: 0, // Track hits for Papa John sprite changes
+ };
+};
+
+/**
+ * Update boss position (moves around the board)
+ * Papa John runs all over, Dominos stays on the right
+ */
+export const updateBossLane = (bossBattle: BossBattle): BossBattle => {
+ if (!bossBattle.active || bossBattle.bossDefeated) return bossBattle;
+
+ const isPapaJohn = bossBattle.bossType === 'papaJohn';
+
+ // Vertical movement (both bosses)
+ const BOSS_LANE_SPEED = isPapaJohn ? 0.04 : 0.02; // Papa John moves faster
+ const MIN_LANE = 0.5;
+ const MAX_LANE = 2.5;
+
+ let newLane = bossBattle.bossLane + (BOSS_LANE_SPEED * bossBattle.bossLaneDirection);
+ let newLaneDirection = bossBattle.bossLaneDirection;
+
+ // Bounce off top and bottom
+ if (newLane >= MAX_LANE) {
+ newLane = MAX_LANE;
+ newLaneDirection = -1;
+ } else if (newLane <= MIN_LANE) {
+ newLane = MIN_LANE;
+ newLaneDirection = 1;
+ }
+
+ // Horizontal movement (Papa John only - runs all over!)
+ let newPosition = bossBattle.bossPosition;
+ let newXDirection = bossBattle.bossXDirection;
+
+ if (isPapaJohn) {
+ const BOSS_X_SPEED = 0.3; // How fast Papa John runs horizontally
+ const MIN_X = 20; // Don't go too close to chef
+ const MAX_X = 85; // Right edge
+
+ newPosition = bossBattle.bossPosition + (BOSS_X_SPEED * bossBattle.bossXDirection);
+
+ // Bounce off left and right
+ if (newPosition >= MAX_X) {
+ newPosition = MAX_X;
+ newXDirection = -1;
+ } else if (newPosition <= MIN_X) {
+ newPosition = MIN_X;
+ newXDirection = 1;
+ }
+ }
+
+ return {
+ ...bossBattle,
+ bossLane: newLane,
+ bossLaneDirection: newLaneDirection,
+ bossPosition: newPosition,
+ bossXDirection: newXDirection,
+ };
+};
+
+/**
+ * Update minion positions (move left)
+ */
+export const updateMinionPositions = (minions: BossMinion[]): BossMinion[] => {
+ return minions.map(minion => {
+ if (minion.defeated) return minion;
+ return { ...minion, position: minion.position - minion.speed };
+ });
+};
+
+/**
+ * Check for minions reaching the chef (causes life loss)
+ */
+export const checkMinionsReachedChef = (
+ minions: BossMinion[]
+): { updatedMinions: BossMinion[]; livesLost: number } => {
+ let livesLost = 0;
+ const updatedMinions = minions.map(minion => {
+ if (minion.defeated) return minion;
+ if (checkMinionReachedChef(minion)) {
+ livesLost++;
+ return { ...minion, defeated: true };
+ }
+ return minion;
+ });
+ return { updatedMinions, livesLost };
+};
+
+/**
+ * Process slice-minion collisions
+ */
+export const processSliceMinionCollisions = (
+ slices: PizzaSlice[],
+ minions: BossMinion[]
+): {
+ updatedMinions: BossMinion[];
+ consumedSliceIds: Set;
+ events: BossEvent[];
+ scoreGained: number;
+} => {
+ const consumedSliceIds = new Set();
+ const events: BossEvent[] = [];
+ let scoreGained = 0;
+
+ let updatedMinions = [...minions];
+
+ slices.forEach(slice => {
+ if (consumedSliceIds.has(slice.id)) return;
+
+ updatedMinions = updatedMinions.map(minion => {
+ if (minion.defeated || consumedSliceIds.has(slice.id)) return minion;
+
+ if (checkSliceMinionCollision(slice, minion, 8)) {
+ consumedSliceIds.add(slice.id);
+ const points = SCORING.MINION_DEFEAT;
+ scoreGained += points;
+ events.push({
+ type: 'MINION_DEFEATED',
+ lane: minion.lane,
+ position: minion.position,
+ points,
+ });
+ return { ...minion, defeated: true };
+ }
+ return minion;
+ });
+ });
+
+ return { updatedMinions, consumedSliceIds, events, scoreGained };
+};
+
+/**
+ * Process slice-boss collisions (when boss is vulnerable)
+ */
+export const processSliceBossCollisions = (
+ slices: PizzaSlice[],
+ bossBattle: BossBattle,
+ alreadyConsumedIds: Set,
+ currentLevel: number,
+ defeatedBossLevels: number[]
+): {
+ updatedBossBattle: BossBattle;
+ consumedSliceIds: Set;
+ events: BossEvent[];
+ scoreGained: number;
+ defeatedBossLevel?: number;
+} => {
+ if (!bossBattle.bossVulnerable) {
+ return {
+ updatedBossBattle: bossBattle,
+ consumedSliceIds: new Set(),
+ events: [],
+ scoreGained: 0,
+ };
+ }
+
+ const consumedSliceIds = new Set();
+ const events: BossEvent[] = [];
+ let scoreGained = 0;
+ let updatedBossBattle = { ...bossBattle };
+ let defeatedBossLevel: number | undefined;
+
+ slices.forEach(slice => {
+ if (alreadyConsumedIds.has(slice.id) || consumedSliceIds.has(slice.id)) return;
+
+ // Check both horizontal position AND vertical lane proximity
+ // bossPosition is left edge, boss is 24% wide, so center is at bossPosition + 12
+ const bossCenterX = updatedBossBattle.bossPosition + 12;
+ const horizontalHit = Math.abs(bossCenterX - slice.position) < 14; // 14 = half width (12) + some margin
+ const verticalHit = Math.abs(updatedBossBattle.bossLane - slice.lane) < 1.2; // Boss is roughly 1 lane tall
+
+ if (horizontalHit && verticalHit) {
+ // For Papa John, do pixel-perfect collision check
+ if (updatedBossBattle.bossType === 'papaJohn') {
+ const mask = getPapaJohnMask(updatedBossBattle.hitsReceived || 0);
+ if (mask) {
+ // Map game coords to sprite coords (0-1 range)
+ // Boss left edge is at bossPosition, width is 24%
+ const normalizedX = (slice.position - updatedBossBattle.bossPosition) / 24;
+ // Boss top edge is at bossLane (in lane units), height is 1 lane
+ // Slice is at center of its lane, so add 0.5 to align
+ const normalizedY = (slice.lane - updatedBossBattle.bossLane) + 0.5;
+
+ if (!checkMaskCollision(mask, normalizedX, normalizedY)) {
+ return; // Hit transparent area - skip this slice
+ }
+ }
+ }
+
+ consumedSliceIds.add(slice.id);
+ updatedBossBattle.bossHealth -= 1;
+ updatedBossBattle.hitsReceived = (updatedBossBattle.hitsReceived || 0) + 1;
+
+ const points = SCORING.BOSS_HIT;
+ scoreGained += points;
+ events.push({
+ type: 'BOSS_HIT',
+ lane: slice.lane,
+ position: slice.position,
+ points,
+ });
+
+ if (updatedBossBattle.bossHealth <= 0) {
+ updatedBossBattle.bossDefeated = true;
+ updatedBossBattle.active = false;
+ updatedBossBattle.minions = [];
+
+ scoreGained += SCORING.BOSS_DEFEAT;
+ events.push({
+ type: 'BOSS_DEFEATED',
+ lane: 1,
+ position: updatedBossBattle.bossPosition,
+ points: SCORING.BOSS_DEFEAT,
+ });
+
+ // Find current boss level to mark as defeated
+ let currentBossLevel: number | undefined;
+ if (updatedBossBattle.bossType === 'papaJohn') {
+ currentBossLevel = currentLevel >= BOSS_CONFIG.PAPA_JOHN_LEVEL ? BOSS_CONFIG.PAPA_JOHN_LEVEL : undefined;
+ } else {
+ currentBossLevel = currentLevel >= BOSS_CONFIG.DOMINOS_LEVEL ? BOSS_CONFIG.DOMINOS_LEVEL : undefined;
+ }
+
+ if (currentBossLevel && !defeatedBossLevels.includes(currentBossLevel)) {
+ defeatedBossLevel = currentBossLevel;
+ }
+ }
+ }
+ });
+
+ return { updatedBossBattle, consumedSliceIds, events, scoreGained, defeatedBossLevel };
+};
+
+/**
+ * Check wave completion and spawn next wave or make boss vulnerable
+ */
+export const checkWaveCompletion = (
+ bossBattle: BossBattle,
+ now: number
+): { updatedBossBattle: BossBattle; events: BossEvent[] } => {
+ const activeMinions = bossBattle.minions.filter(m => !m.defeated);
+ const events: BossEvent[] = [];
+
+ if (activeMinions.length > 0) {
+ return { updatedBossBattle: bossBattle, events };
+ }
+
+ let updatedBossBattle = { ...bossBattle };
+ const config = getBossConfig(bossBattle.bossType);
+
+ if (bossBattle.currentWave < config.WAVES) {
+ const nextWave = bossBattle.currentWave + 1;
+ updatedBossBattle.currentWave = nextWave;
+ updatedBossBattle.minions = createWaveMinions(nextWave, now, config.MINIONS_PER_WAVE);
+ events.push({ type: 'WAVE_COMPLETE', nextWave });
+ } else if (!bossBattle.bossVulnerable) {
+ updatedBossBattle.bossVulnerable = true;
+ updatedBossBattle.minions = [];
+ events.push({ type: 'BOSS_VULNERABLE' });
+ }
+
+ return { updatedBossBattle, events };
+};
+
+/**
+ * Process a full boss battle tick
+ */
+export const processBossTick = (
+ bossBattle: BossBattle,
+ slices: PizzaSlice[],
+ currentLevel: number,
+ defeatedBossLevels: number[],
+ now: number
+): BossTickResult => {
+ if (!bossBattle.active || bossBattle.bossDefeated) {
+ return {
+ nextBossBattle: bossBattle,
+ consumedSliceIds: new Set(),
+ livesLost: 0,
+ scoreGained: 0,
+ events: [],
+ };
+ }
+
+ const allEvents: BossEvent[] = [];
+ let totalScore = 0;
+ let totalLivesLost = 0;
+ const allConsumedSliceIds = new Set();
+
+ // 1. Move minions
+ let currentMinions = updateMinionPositions(bossBattle.minions);
+
+ // 2. Check minions reaching chef
+ const reachResult = checkMinionsReachedChef(currentMinions);
+ currentMinions = reachResult.updatedMinions;
+ totalLivesLost = reachResult.livesLost;
+ if (reachResult.livesLost > 0) {
+ for (let i = 0; i < reachResult.livesLost; i++) {
+ allEvents.push({ type: 'MINION_REACHED_CHEF' });
+ }
+ }
+
+ // 3. Process slice-minion collisions
+ const minionCollisionResult = processSliceMinionCollisions(slices, currentMinions);
+ currentMinions = minionCollisionResult.updatedMinions;
+ minionCollisionResult.consumedSliceIds.forEach(id => allConsumedSliceIds.add(id));
+ totalScore += minionCollisionResult.scoreGained;
+ allEvents.push(...minionCollisionResult.events);
+
+ let currentBossBattle: BossBattle = {
+ ...bossBattle,
+ minions: currentMinions,
+ };
+
+ // 3.5. Update boss vertical movement
+ currentBossBattle = updateBossLane(currentBossBattle);
+
+ // 4. Process slice-boss collisions (if vulnerable)
+ const bossCollisionResult = processSliceBossCollisions(
+ slices,
+ currentBossBattle,
+ allConsumedSliceIds,
+ currentLevel,
+ defeatedBossLevels
+ );
+ currentBossBattle = bossCollisionResult.updatedBossBattle;
+ bossCollisionResult.consumedSliceIds.forEach(id => allConsumedSliceIds.add(id));
+ totalScore += bossCollisionResult.scoreGained;
+ allEvents.push(...bossCollisionResult.events);
+
+ // 5. Check wave completion
+ if (!currentBossBattle.bossDefeated) {
+ const waveResult = checkWaveCompletion(currentBossBattle, now);
+ currentBossBattle = waveResult.updatedBossBattle;
+ allEvents.push(...waveResult.events);
+ }
+
+ return {
+ nextBossBattle: currentBossBattle,
+ consumedSliceIds: allConsumedSliceIds,
+ livesLost: totalLivesLost,
+ scoreGained: totalScore,
+ events: allEvents,
+ defeatedBossLevel: bossCollisionResult.defeatedBossLevel,
+ };
+};
diff --git a/src/logic/collisionSystem.ts b/src/logic/collisionSystem.ts
index c510a1b..a591e64 100644
--- a/src/logic/collisionSystem.ts
+++ b/src/logic/collisionSystem.ts
@@ -48,6 +48,20 @@ export const checkChefPowerUpCollision = (
return powerUp.lane === chefLane && powerUp.position <= chefX;
};
+/**
+ * Calculates the visual lane for a plate (handles angled throws)
+ */
+const getPlateVisualLane = (plate: EmptyPlate): number => {
+ if (plate.targetLane !== undefined && plate.startLane !== undefined && plate.startPosition !== undefined) {
+ const OVEN_POSITION = 10;
+ const totalDistance = plate.startPosition - OVEN_POSITION;
+ const traveled = plate.startPosition - plate.position;
+ const progress = Math.min(1, Math.max(0, traveled / totalDistance));
+ return plate.startLane + (plate.targetLane - plate.startLane) * progress;
+ }
+ return plate.lane;
+};
+
/**
* Checks if the chef has caught an empty plate.
*/
@@ -56,7 +70,10 @@ export const checkChefPlateCollision = (
plate: EmptyPlate,
threshold: number = 10
): boolean => {
- return plate.lane === chefLane && plate.position <= threshold;
+ const visualLane = getPlateVisualLane(plate);
+ // For angled plates, check if within 0.5 lane distance for more forgiving collision
+ const laneTolerance = plate.targetLane !== undefined ? 0.5 : 0;
+ return Math.abs(visualLane - chefLane) <= laneTolerance && plate.position <= threshold;
};
/**
diff --git a/src/logic/customerSystem.test.ts b/src/logic/customerSystem.test.ts
new file mode 100644
index 0000000..978a124
--- /dev/null
+++ b/src/logic/customerSystem.test.ts
@@ -0,0 +1,296 @@
+import { describe, it, expect } from 'vitest';
+import { updateCustomerPositions, processCustomerHit, CustomerUpdateResult, CustomerHitResult } from './customerSystem';
+import { Customer, ActivePowerUp } from '../types/game';
+
+// Helper to create a basic customer
+const createCustomer = (overrides: Partial = {}): Customer => ({
+ id: 'test-customer-1',
+ lane: 0,
+ position: 80,
+ speed: 0.5,
+ served: false,
+ hasPlate: false,
+ leaving: false,
+ disappointed: false,
+ disappointedEmoji: '😢',
+ movingRight: false,
+ critic: false,
+ badLuckBrian: false,
+ flipped: false,
+ ...overrides,
+});
+
+describe('Customer System - Integrated Tests', () => {
+ const now = Date.now();
+
+ describe('Customer Movement (updateCustomerPositions)', () => {
+ it('should move customer left when approaching', () => {
+ const customer = createCustomer({ position: 80, speed: 0.5 });
+ const result = updateCustomerPositions([customer], [], now);
+
+ expect(result.nextCustomers[0].position).toBeLessThan(80);
+ });
+
+ it('should move customer right when served', () => {
+ const customer = createCustomer({ position: 50, served: true });
+ const result = updateCustomerPositions([customer], [], now);
+
+ expect(result.nextCustomers[0].position).toBeGreaterThan(50);
+ });
+
+ it('should remove customer when off screen left (position <= -10)', () => {
+ const customer = createCustomer({ position: -10 });
+ const result = updateCustomerPositions([customer], [], now);
+
+ // Customer should not be in nextCustomers (removed)
+ expect(result.nextCustomers.length).toBe(0);
+ });
+
+ it('should remove customer when off screen right', () => {
+ const customer = createCustomer({ position: 101, served: true });
+ const result = updateCustomerPositions([customer], [], now);
+
+ expect(result.nextCustomers.length).toBe(0);
+ });
+ });
+
+ describe('Customer Disappointment', () => {
+ it('should mark customer disappointed when reaching chef (position <= 15)', () => {
+ const customer = createCustomer({ position: 16, speed: 2 }); // Will move to 14
+ const result = updateCustomerPositions([customer], [], now);
+
+ expect(result.nextCustomers[0].disappointed).toBe(true);
+ expect(result.nextCustomers[0].movingRight).toBe(true);
+ expect(result.events.some(e => e.type === 'LIFE_LOST')).toBe(true);
+ });
+
+ it('should not mark served customer as disappointed', () => {
+ const customer = createCustomer({ position: 14, served: true });
+ const result = updateCustomerPositions([customer], [], now);
+
+ expect(result.nextCustomers[0].disappointed).toBe(false);
+ });
+ });
+
+ describe('Frozen Effect (Ice Cream)', () => {
+ it('should freeze normal customer when ice cream active and shouldBeFrozenByIceCream', () => {
+ const customer = createCustomer({ shouldBeFrozenByIceCream: true });
+ const iceCreamPowerUp: ActivePowerUp = { type: 'ice-cream', endTime: now + 5000 };
+
+ const result = updateCustomerPositions([customer], [iceCreamPowerUp], now);
+
+ expect(result.nextCustomers[0].frozen).toBe(true);
+ });
+
+ it('should not freeze Bad Luck Brian', () => {
+ const customer = createCustomer({
+ badLuckBrian: true,
+ shouldBeFrozenByIceCream: true
+ });
+ const iceCreamPowerUp: ActivePowerUp = { type: 'ice-cream', endTime: now + 5000 };
+
+ const result = updateCustomerPositions([customer], [iceCreamPowerUp], now);
+
+ // Brian is immune - shouldBeFrozenByIceCream check is bypassed for badLuckBrian
+ expect(result.nextCustomers[0].frozen).toBeFalsy();
+ });
+
+ it('should not move frozen customer', () => {
+ const customer = createCustomer({
+ position: 50,
+ frozen: true,
+ shouldBeFrozenByIceCream: true
+ });
+ const iceCreamPowerUp: ActivePowerUp = { type: 'ice-cream', endTime: now + 5000 };
+
+ const result = updateCustomerPositions([customer], [iceCreamPowerUp], now);
+
+ // Position should remain the same (frozen)
+ expect(result.nextCustomers[0].position).toBe(50);
+ });
+ });
+
+ describe('Hot Honey Effect', () => {
+ it('should slow down normal customer when honey active (half speed)', () => {
+ const customer = createCustomer({
+ position: 80,
+ speed: 1,
+ shouldBeHotHoneyAffected: true
+ });
+ const honeyPowerUp: ActivePowerUp = { type: 'honey', endTime: now + 5000 };
+
+ const result = updateCustomerPositions([customer], [honeyPowerUp], now);
+
+ // Hot honey slows customers (speed * 0.5), so movement should be 0.5
+ const actualMovement = 80 - result.nextCustomers[0].position;
+ expect(actualMovement).toBeCloseTo(0.5, 1);
+ expect(result.nextCustomers[0].hotHoneyAffected).toBe(true);
+ });
+
+ it('should not affect critic with hot honey', () => {
+ const customer = createCustomer({
+ critic: true,
+ shouldBeHotHoneyAffected: true
+ });
+ const honeyPowerUp: ActivePowerUp = { type: 'honey', endTime: now + 5000 };
+
+ const result = updateCustomerPositions([customer], [honeyPowerUp], now);
+
+ expect(result.nextCustomers[0].hotHoneyAffected).toBe(false);
+ expect(result.nextCustomers[0].textMessage).toBe('Just plain, thanks.');
+ });
+
+ it('should not affect Bad Luck Brian with hot honey', () => {
+ const customer = createCustomer({
+ badLuckBrian: true,
+ shouldBeHotHoneyAffected: true
+ });
+ const honeyPowerUp: ActivePowerUp = { type: 'honey', endTime: now + 5000 };
+
+ const result = updateCustomerPositions([customer], [honeyPowerUp], now);
+
+ expect(result.nextCustomers[0].hotHoneyAffected).toBe(false);
+ expect(result.nextCustomers[0].textMessage).toBe("I can't do spicy.");
+ });
+ });
+
+ describe('Woozy Movement', () => {
+ it('should move woozy customer right when movingRight is true', () => {
+ const customer = createCustomer({
+ position: 50,
+ woozy: true,
+ woozyState: 'normal',
+ movingRight: true
+ });
+
+ const result = updateCustomerPositions([customer], [], now);
+
+ expect(result.nextCustomers[0].position).toBeGreaterThan(50);
+ });
+
+ it('should move woozy customer left when movingRight is false', () => {
+ const customer = createCustomer({
+ position: 50,
+ woozy: true,
+ woozyState: 'normal',
+ movingRight: false
+ });
+
+ const result = updateCustomerPositions([customer], [], now);
+
+ expect(result.nextCustomers[0].position).toBeLessThan(50);
+ });
+ });
+
+ describe('processCustomerHit', () => {
+ it('should serve normal customer and create empty plate', () => {
+ const customer = createCustomer();
+ const result = processCustomerHit(customer, now);
+
+ expect(result.updatedCustomer.served).toBe(true);
+ expect(result.events).toContain('SERVED_NORMAL');
+ expect(result.newEntities.emptyPlate).toBeDefined();
+ });
+
+ it('should serve critic and emit SERVED_CRITIC event', () => {
+ const customer = createCustomer({ critic: true });
+ const result = processCustomerHit(customer, now);
+
+ expect(result.updatedCustomer.served).toBe(true);
+ expect(result.events).toContain('SERVED_CRITIC');
+ });
+
+ it('should handle Bad Luck Brian drop and create dropped plate', () => {
+ const customer = createCustomer({ badLuckBrian: true });
+ const result = processCustomerHit(customer, now);
+
+ expect(result.updatedCustomer.leaving).toBe(true);
+ expect(result.events).toContain('BRIAN_DROPPED_PLATE');
+ expect(result.newEntities.droppedPlate).toBeDefined();
+ expect(result.updatedCustomer.textMessage).toBe("Ugh! I dropped my slice!");
+ });
+
+ it('should serve Bad Luck Brian when doge power-up is active', () => {
+ const customer = createCustomer({ badLuckBrian: true });
+ const result = processCustomerHit(customer, now, true); // dogeActive = true
+
+ expect(result.updatedCustomer.served).toBe(true);
+ expect(result.updatedCustomer.leaving).toBeFalsy();
+ expect(result.events).toContain('SERVED_BRIAN_DOGE');
+ expect(result.newEntities.emptyPlate).toBeDefined();
+ expect(result.updatedCustomer.textMessage).toBe("Such yum!");
+ });
+
+ it('should unfreeze and serve frozen customer', () => {
+ const customer = createCustomer({ frozen: true });
+ const result = processCustomerHit(customer, now);
+
+ expect(result.updatedCustomer.frozen).toBe(false);
+ expect(result.updatedCustomer.unfrozenThisPeriod).toBe(true);
+ expect(result.updatedCustomer.served).toBe(true);
+ expect(result.events).toContain('UNFROZEN_AND_SERVED');
+ });
+
+ it('should handle woozy customer first hit (step 1)', () => {
+ const customer = createCustomer({ woozy: true, woozyState: 'normal' });
+ const result = processCustomerHit(customer, now);
+
+ expect(result.updatedCustomer.woozyState).toBe('drooling');
+ expect(result.updatedCustomer.woozy).toBe(false);
+ expect(result.events).toContain('WOOZY_STEP_1');
+ });
+
+ it('should handle woozy customer second hit (step 2)', () => {
+ const customer = createCustomer({ woozy: true, woozyState: 'drooling' });
+ const result = processCustomerHit(customer, now);
+
+ expect(result.updatedCustomer.woozyState).toBe('satisfied');
+ expect(result.updatedCustomer.served).toBe(true);
+ expect(result.events).toContain('WOOZY_STEP_2');
+ });
+ });
+
+ describe('Bad Luck Brian Behavior', () => {
+ it('should move Brian right when movingRight is true', () => {
+ const customer = createCustomer({
+ badLuckBrian: true,
+ movingRight: true,
+ position: 50
+ });
+
+ const result = updateCustomerPositions([customer], [], now);
+
+ expect(result.nextCustomers[0].position).toBeGreaterThan(50);
+ });
+
+ it('should make Brian leave with complaint when reaching chef', () => {
+ const customer = createCustomer({
+ badLuckBrian: true,
+ position: 16,
+ speed: 2
+ });
+
+ const result = updateCustomerPositions([customer], [], now);
+
+ expect(result.nextCustomers[0].leaving).toBe(true);
+ expect(result.nextCustomers[0].textMessage).toBe("You don't have gluten free?");
+ // Brian doesn't cause LIFE_LOST
+ expect(result.events.some(e => e.type === 'LIFE_LOST')).toBe(false);
+ });
+ });
+
+ describe('Nyan Cat Effect', () => {
+ it('should push brianNyaned customer right and up', () => {
+ const customer = createCustomer({
+ brianNyaned: true,
+ position: 50,
+ lane: 2
+ });
+
+ const result = updateCustomerPositions([customer], [], now);
+
+ expect(result.nextCustomers[0].position).toBeGreaterThan(50);
+ expect(result.nextCustomers[0].lane).toBeLessThan(2);
+ });
+ });
+});
diff --git a/src/logic/customerSystem.ts b/src/logic/customerSystem.ts
index 16d8e4f..5488d90 100644
--- a/src/logic/customerSystem.ts
+++ b/src/logic/customerSystem.ts
@@ -1,12 +1,19 @@
-import { Customer, DroppedPlate, EmptyPlate, GameState } from '../types/game';
-import { ENTITY_SPEEDS, GAME_CONFIG, POSITIONS } from '../lib/constants';
+import {
+ Customer,
+ DroppedPlate,
+ EmptyPlate,
+ isCustomerLeaving,
+ isCustomerAffectedByPowerUps,
+ getCustomerVariant
+} from '../types/game';
+import { ENTITY_SPEEDS, GAME_CONFIG, POSITIONS, SCUMBAG_STEVE } from '../lib/constants';
// --- Types for the Update Result ---
-export type CustomerUpdateEvent =
- | 'GAME_OVER'
- | 'LIFE_LOST'
- | 'STAR_LOST_CRITIC'
- | 'STAR_LOST_NORMAL';
+export type CustomerUpdateEvent =
+ | { type: 'GAME_OVER' }
+ | { type: 'LIFE_LOST'; lane: number; position: number }
+ | { type: 'STAR_LOST_CRITIC'; lane: number; position: number }
+ | { type: 'STAR_LOST_NORMAL'; lane: number; position: number };
export interface CustomerUpdateResult {
nextCustomers: Customer[];
@@ -17,13 +24,17 @@ export interface CustomerUpdateResult {
}
// --- Types for the Hit Result ---
-export type CustomerHitEvent =
+export type CustomerHitEvent =
| 'SERVED_NORMAL'
| 'SERVED_CRITIC'
+ | 'SERVED_BRIAN_DOGE'
| 'WOOZY_STEP_1'
| 'WOOZY_STEP_2'
| 'UNFROZEN_AND_SERVED'
- | 'BRIAN_DROPPED_PLATE';
+ | 'BRIAN_DROPPED_PLATE'
+ | 'STEVE_FIRST_SLICE'
+ | 'STEVE_SERVED'
+ | 'MAFIA_SERVED';
export interface CustomerHitResult {
updatedCustomer: Customer;
@@ -71,7 +82,15 @@ export const updateCustomerPositions = (
processedCustomer.textMessage = "I can't do spicy.";
processedCustomer.textMessageTime = now;
}
- } else if (!processedCustomer.woozy && !processedCustomer.served && !processedCustomer.leaving && !processedCustomer.disappointed) {
+ // Critics are immune to hot honey
+ } else if (processedCustomer.critic) {
+ if (processedCustomer.hotHoneyAffected || processedCustomer.shouldBeHotHoneyAffected) {
+ processedCustomer.hotHoneyAffected = false;
+ processedCustomer.shouldBeHotHoneyAffected = false;
+ processedCustomer.textMessage = "Just plain, thanks.";
+ processedCustomer.textMessageTime = now;
+ }
+ } else if (isCustomerAffectedByPowerUps(processedCustomer)) {
// Normal customers get effects
if (hasHoney && hasIceCream) {
if (honeyEnd > iceCreamEnd) {
@@ -98,15 +117,25 @@ export const updateCustomerPositions = (
// Clear effects if powerups are gone
if (!hasIceCream && (processedCustomer.frozen || processedCustomer.shouldBeFrozenByIceCream)) {
+ // If woozy customer was frozen, cure them when ice cream ends
+ if (processedCustomer.woozy && processedCustomer.frozen) {
+ processedCustomer.woozy = false;
+ processedCustomer.woozyState = 'drooling';
+ }
processedCustomer.frozen = false;
processedCustomer.shouldBeFrozenByIceCream = false;
}
if (!hasHoney && processedCustomer.hotHoneyAffected) {
+ // If woozy customer had hot honey, cure them when honey ends
+ if (processedCustomer.woozy) {
+ processedCustomer.woozy = false;
+ processedCustomer.woozyState = 'drooling';
+ }
processedCustomer.hotHoneyAffected = false;
}
// C. Movement Calculations
- const isDeparting = processedCustomer.served || processedCustomer.disappointed || processedCustomer.vomit || processedCustomer.leaving;
+ const isDeparting = isCustomerLeaving(processedCustomer);
// 1. Nyan Cat pushed (Zoom!)
if (processedCustomer.brianNyaned) {
@@ -146,10 +175,12 @@ export const updateCustomerPositions = (
const newPos = processedCustomer.position - (processedCustomer.speed * 0.75);
if (newPos <= GAME_CONFIG.CHEF_X_POSITION) {
// Game Over Condition for Woozy
- events.push('LIFE_LOST');
- events.push(processedCustomer.critic ? 'STAR_LOST_CRITIC' : 'STAR_LOST_NORMAL');
- events.push('GAME_OVER'); // Technically game over logic checks lives later, but this signals a fail state
-
+ events.push({ type: 'LIFE_LOST', lane: processedCustomer.lane, position: newPos });
+ events.push(getCustomerVariant(processedCustomer) === 'critic'
+ ? { type: 'STAR_LOST_CRITIC', lane: processedCustomer.lane, position: newPos }
+ : { type: 'STAR_LOST_NORMAL', lane: processedCustomer.lane, position: newPos });
+ events.push({ type: 'GAME_OVER' }); // Technically game over logic checks lives later, but this signals a fail state
+
processedCustomer.disappointed = true;
processedCustomer.movingRight = true;
processedCustomer.woozy = false;
@@ -180,7 +211,7 @@ export const updateCustomerPositions = (
// Moving Left (Approaching)
const speedMod = processedCustomer.hotHoneyAffected ? 0.5 : 1;
const newPos = processedCustomer.position - (processedCustomer.speed * speedMod);
-
+
if (newPos <= GAME_CONFIG.CHEF_X_POSITION) {
// Brian Reaches Chef -> Complains and Leaves (No Game Over)
processedCustomer.position = newPos;
@@ -197,16 +228,66 @@ export const updateCustomerPositions = (
return;
}
+ // 6.5. Scumbag Steve Special Movement (Lane Changing)
+ if (processedCustomer.scumbagSteve && !isDeparting) {
+ // Check for lane change
+ const lastChange = processedCustomer.lastLaneChangeTime || 0;
+ if (now - lastChange >= SCUMBAG_STEVE.LANE_CHANGE_INTERVAL) {
+ if (Math.random() < SCUMBAG_STEVE.LANE_CHANGE_CHANCE) {
+ // Change to a random adjacent lane
+ const currentLane = processedCustomer.lane;
+ let newLane: number;
+ if (currentLane === 0) {
+ newLane = 1;
+ } else if (currentLane === GAME_CONFIG.LANE_COUNT - 1) {
+ newLane = GAME_CONFIG.LANE_COUNT - 2;
+ } else {
+ newLane = Math.random() < 0.5 ? currentLane - 1 : currentLane + 1;
+ }
+ processedCustomer.lane = newLane;
+ }
+ processedCustomer.lastLaneChangeTime = now;
+ }
+
+ // Steve moves (faster than normal, set in spawn)
+ if (processedCustomer.movingRight) {
+ processedCustomer.position += processedCustomer.speed;
+ nextCustomers.push(processedCustomer);
+ return;
+ }
+
+ const newPos = processedCustomer.position - processedCustomer.speed;
+ if (newPos <= GAME_CONFIG.CHEF_X_POSITION) {
+ // Steve reaches chef without enough pizza -> Disappointed
+ events.push({ type: 'LIFE_LOST', lane: processedCustomer.lane, position: newPos });
+ events.push({ type: 'STAR_LOST_NORMAL', lane: processedCustomer.lane, position: newPos });
+ events.push({ type: 'GAME_OVER' });
+
+ processedCustomer.disappointed = true;
+ processedCustomer.movingRight = true;
+ processedCustomer.position = newPos;
+ processedCustomer.textMessage = "I wanted more!";
+ processedCustomer.textMessageTime = now;
+ customerStreakReset = true;
+ } else {
+ processedCustomer.position = newPos;
+ }
+ nextCustomers.push(processedCustomer);
+ return;
+ }
+
// 7. Standard Customer Movement (Approaching)
const speedMod = processedCustomer.hotHoneyAffected ? 0.5 : 1;
const newPos = processedCustomer.position - (processedCustomer.speed * speedMod);
if (newPos <= GAME_CONFIG.CHEF_X_POSITION) {
// Reached Chef -> Angry -> Life Lost
- events.push('LIFE_LOST');
- events.push(processedCustomer.critic ? 'STAR_LOST_CRITIC' : 'STAR_LOST_NORMAL');
- events.push('GAME_OVER');
-
+ events.push({ type: 'LIFE_LOST', lane: processedCustomer.lane, position: newPos });
+ events.push(getCustomerVariant(processedCustomer) === 'critic'
+ ? { type: 'STAR_LOST_CRITIC', lane: processedCustomer.lane, position: newPos }
+ : { type: 'STAR_LOST_NORMAL', lane: processedCustomer.lane, position: newPos });
+ events.push({ type: 'GAME_OVER' });
+
processedCustomer.disappointed = true;
processedCustomer.movingRight = true;
processedCustomer.hotHoneyAffected = false;
@@ -215,7 +296,7 @@ export const updateCustomerPositions = (
} else {
processedCustomer.position = newPos;
}
-
+
nextCustomers.push(processedCustomer);
});
@@ -229,13 +310,40 @@ export const updateCustomerPositions = (
*/
export const processCustomerHit = (
customer: Customer,
- now: number
+ now: number,
+ dogeActive: boolean = false
): CustomerHitResult => {
const events: CustomerHitEvent[] = [];
const newEntities: { droppedPlate?: DroppedPlate; emptyPlate?: EmptyPlate } = {};
-
- // 1. Bad Luck Brian (Fail State)
+
+ // 1. Bad Luck Brian
if (customer.badLuckBrian) {
+ // Doge power-up lets Brian be served successfully!
+ if (dogeActive) {
+ events.push('SERVED_BRIAN_DOGE');
+ newEntities.emptyPlate = {
+ id: `plate-${now}-${customer.id}`,
+ lane: customer.lane,
+ position: customer.position,
+ speed: ENTITY_SPEEDS.PLATE
+ };
+ return {
+ updatedCustomer: {
+ ...customer,
+ served: true,
+ hasPlate: false,
+ flipped: false,
+ textMessage: "Such yum!",
+ textMessageTime: now,
+ frozen: false,
+ woozy: false
+ },
+ events,
+ newEntities
+ };
+ }
+
+ // Normal Brian behavior - drops the plate
events.push('BRIAN_DROPPED_PLATE');
const droppedPlate: DroppedPlate = {
id: `dropped-${now}-${customer.id}`,
@@ -260,6 +368,30 @@ export const processCustomerHit = (
};
}
+ // 1.5. Pizza Mafia - spawns 8 slices flying in all directions
+ if (customer.pizzaMafia) {
+ events.push('MAFIA_SERVED');
+ newEntities.emptyPlate = {
+ id: `plate-${now}-${customer.id}`,
+ lane: customer.lane,
+ position: customer.position,
+ speed: ENTITY_SPEEDS.PLATE
+ };
+ return {
+ updatedCustomer: {
+ ...customer,
+ served: true,
+ hasPlate: false,
+ textMessage: "Bada bing!",
+ textMessageTime: now,
+ frozen: false,
+ woozy: false
+ },
+ events,
+ newEntities
+ };
+ }
+
// 2. Frozen Customers (Instant Serve + Unfreeze)
if (customer.frozen) {
events.push('UNFROZEN_AND_SERVED');
@@ -315,8 +447,75 @@ export const processCustomerHit = (
}
}
- // 4. Normal / Hot Honey Customers (Standard Serve)
- events.push(customer.critic ? 'SERVED_CRITIC' : 'SERVED_NORMAL');
+ // 4. Scumbag Steve (Two-Slice Requirement, Angled Plate, No Payment)
+ if (customer.scumbagSteve) {
+ const slicesReceived = (customer.slicesReceived || 0) + 1;
+
+ // Calculate target lane for angled throw (toward adjacent oven)
+ let targetLane: number;
+ if (customer.lane === 0) {
+ targetLane = 1; // Top lane throws to lane below
+ } else if (customer.lane === GAME_CONFIG.LANE_COUNT - 1) {
+ targetLane = GAME_CONFIG.LANE_COUNT - 2; // Bottom lane throws to lane above
+ } else {
+ // Middle lanes randomly throw up or down
+ targetLane = Math.random() < 0.5 ? customer.lane - 1 : customer.lane + 1;
+ }
+
+ if (slicesReceived < SCUMBAG_STEVE.SLICES_REQUIRED) {
+ // First slice - not satisfied yet
+ events.push('STEVE_FIRST_SLICE');
+ newEntities.emptyPlate = {
+ id: `plate-${now}-${customer.id}-first`,
+ lane: customer.lane, // Start at Steve's lane
+ position: customer.position,
+ speed: ENTITY_SPEEDS.PLATE,
+ // Angled throw properties
+ startLane: customer.lane,
+ startPosition: customer.position,
+ targetLane: targetLane
+ };
+ return {
+ updatedCustomer: {
+ ...customer,
+ slicesReceived,
+ textMessage: "I'm still hungry!",
+ textMessageTime: now
+ },
+ events,
+ newEntities
+ };
+ } else {
+ // Second slice - Steve is satisfied but doesn't pay
+ events.push('STEVE_SERVED');
+ newEntities.emptyPlate = {
+ id: `plate-${now}-${customer.id}`,
+ lane: customer.lane, // Start at Steve's lane
+ position: customer.position,
+ speed: ENTITY_SPEEDS.PLATE,
+ // Angled throw properties
+ startLane: customer.lane,
+ startPosition: customer.position,
+ targetLane: targetLane
+ };
+ return {
+ updatedCustomer: {
+ ...customer,
+ served: true,
+ hasPlate: false,
+ slicesReceived,
+ flipped: true, // Flip when leaving
+ textMessage: "Thanks sucker!",
+ textMessageTime: now
+ },
+ events,
+ newEntities
+ };
+ }
+ }
+
+ // 5. Normal / Hot Honey Customers (Standard Serve)
+ events.push(getCustomerVariant(customer) === 'critic' ? 'SERVED_CRITIC' : 'SERVED_NORMAL');
newEntities.emptyPlate = {
id: `plate-${now}-${customer.id}`,
lane: customer.lane,
diff --git a/src/logic/mafiaSliceSystem.ts b/src/logic/mafiaSliceSystem.ts
new file mode 100644
index 0000000..8bd7c41
--- /dev/null
+++ b/src/logic/mafiaSliceSystem.ts
@@ -0,0 +1,78 @@
+// src/logic/mafiaSliceSystem.ts
+import { MafiaSlice, Customer, isCustomerLeaving } from '../types/game';
+import { MAFIA_SLICE_CONFIG, GAME_CONFIG } from '../lib/constants';
+
+/**
+ * Spawn 8 mafia slices radiating outward from the served customer's position
+ */
+export const spawnMafiaSlices = (
+ lane: number,
+ position: number,
+ now: number
+): MafiaSlice[] => {
+ const slices: MafiaSlice[] = [];
+ const { SLICE_COUNT, SPEED } = MAFIA_SLICE_CONFIG;
+
+ for (let i = 0; i < SLICE_COUNT; i++) {
+ // Distribute slices evenly in a circle (360 / 8 = 45 degrees apart)
+ const angle = (i / SLICE_COUNT) * 2 * Math.PI;
+
+ slices.push({
+ id: `mafia-slice-${now}-${i}`,
+ lane,
+ position,
+ speedX: Math.cos(angle) * SPEED,
+ speedY: Math.sin(angle) * MAFIA_SLICE_CONFIG.LANE_SPEED * 100, // Scale for lane units
+ startTime: now,
+ });
+ }
+
+ return slices;
+};
+
+/**
+ * Update mafia slice positions and remove expired ones
+ */
+export const updateMafiaSlices = (
+ slices: MafiaSlice[],
+ now: number
+): MafiaSlice[] => {
+ return slices
+ .filter(slice => {
+ // Remove expired slices
+ const elapsed = now - slice.startTime;
+ if (elapsed > MAFIA_SLICE_CONFIG.LIFETIME) return false;
+
+ // Remove slices that went off screen
+ if (slice.position < -10 || slice.position > 110) return false;
+ if (slice.lane < -1 || slice.lane > GAME_CONFIG.LANE_COUNT) return false;
+
+ return true;
+ })
+ .map(slice => ({
+ ...slice,
+ position: slice.position + slice.speedX,
+ lane: slice.lane + slice.speedY,
+ }));
+};
+
+/**
+ * Check if a mafia slice collides with a customer
+ */
+export const checkMafiaSliceCollision = (
+ slice: MafiaSlice,
+ customer: Customer
+): boolean => {
+ // Don't hit customers that are already leaving
+ if (isCustomerLeaving(customer)) return false;
+
+ // Check if in same lane (with tolerance for fractional lanes)
+ const laneDiff = Math.abs(slice.lane - customer.lane);
+ if (laneDiff > 0.5) return false;
+
+ // Check horizontal collision
+ const posDiff = Math.abs(slice.position - customer.position);
+ if (posDiff > 5) return false;
+
+ return true;
+};
diff --git a/src/logic/nyanSystem.test.ts b/src/logic/nyanSystem.test.ts
new file mode 100644
index 0000000..203cad6
--- /dev/null
+++ b/src/logic/nyanSystem.test.ts
@@ -0,0 +1,88 @@
+import { describe, it, expect } from 'vitest';
+import { processNyanSweepMovement, checkNyanSweepCollisions } from './nyanSystem';
+import { Customer, BossMinion, NyanSweep } from '../types/game';
+import { GAME_CONFIG } from '../lib/constants';
+
+describe('nyanSystem', () => {
+ describe('processNyanSweepMovement', () => {
+ it('moves the nyan cat forward', () => {
+ const initialSweep: NyanSweep = {
+ active: true,
+ xPosition: 10,
+ laneDirection: 1,
+ startTime: 1000,
+ lastUpdateTime: 1000,
+ startingLane: 1
+ };
+
+ // Advance time by 100ms
+ const result = processNyanSweepMovement(initialSweep, 1, 1100);
+
+ expect(result.nextSweep?.xPosition).toBeGreaterThan(10);
+ expect(result.newXPosition).toBeGreaterThan(10);
+ expect(result.sweepComplete).toBe(false);
+ });
+
+ it('completes the sweep when reaching MAX_X', () => {
+ const initialSweep: NyanSweep = {
+ active: true,
+ xPosition: 89, // Near end (90)
+ laneDirection: 1,
+ startTime: 1000,
+ lastUpdateTime: 1000,
+ startingLane: 1
+ };
+
+ // Advance time significantly to ensure completion
+ const result = processNyanSweepMovement(initialSweep, 1, 5000);
+
+ expect(result.sweepComplete).toBe(true);
+ expect(result.nextSweep).toBeUndefined();
+ });
+ });
+
+ describe('checkNyanSweepCollisions', () => {
+ it('detects collisions with customers', () => {
+ const sweep: NyanSweep = {
+ active: true,
+ xPosition: 50,
+ laneDirection: 1,
+ startTime: 1000,
+ lastUpdateTime: 1000,
+ startingLane: 0
+ };
+
+ const customers: Customer[] = [
+ // Hit
+ { id: 'c1', lane: 0, position: 50, speed: 0, served: false, hasPlate: false, leaving: false, disappointed: false, woozy: false, vomit: false, movingRight: false, critic: false, badLuckBrian: false, flipped: false },
+ // Miss (wrong position)
+ { id: 'c2', lane: 0, position: 20, speed: 0, served: false, hasPlate: false, leaving: false, disappointed: false, woozy: false, vomit: false, movingRight: false, critic: false, badLuckBrian: false, flipped: false }
+ ];
+
+ // Assuming newLane calculation placed it on lane 0
+ const result = checkNyanSweepCollisions(sweep, 52, 0, customers);
+
+ expect(result.hitCustomerIds).toContain('c1');
+ expect(result.hitCustomerIds).not.toContain('c2');
+ });
+
+ it('detects collisions with minions', () => {
+ const sweep: NyanSweep = {
+ active: true,
+ xPosition: 50,
+ laneDirection: 1,
+ startTime: 1000,
+ lastUpdateTime: 1000,
+ startingLane: 0
+ };
+
+ const minions: BossMinion[] = [
+ { id: 'm1', lane: 0, position: 50, speed: 0, defeated: false }
+ ];
+
+ const result = checkNyanSweepCollisions(sweep, 52, 0, [], minions);
+
+ expect(result.hitMinionIds).toContain('m1');
+ });
+ });
+});
diff --git a/src/logic/nyanSystem.ts b/src/logic/nyanSystem.ts
new file mode 100644
index 0000000..119f680
--- /dev/null
+++ b/src/logic/nyanSystem.ts
@@ -0,0 +1,113 @@
+import { GameState, Customer, BossMinion, NyanSweep } from '../types/game';
+import { GAME_CONFIG, NYAN_CONFIG } from '../lib/constants';
+import { checkNyanSweepCollision } from './collisionSystem';
+
+export interface NyanSweepResult {
+ nextSweep?: NyanSweep;
+ nextChefLane: number;
+ sweepComplete: boolean;
+ newXPosition: number;
+}
+
+export interface NyanCollisionResult {
+ hitCustomerIds: string[];
+ hitMinionIds: string[];
+}
+
+/**
+ * Processes the movement of the Nyan Cat sweep
+ */
+export const processNyanSweepMovement = (
+ currentSweep: NyanSweep,
+ currentChefLane: number,
+ now: number
+): NyanSweepResult => {
+ const dt = Math.min(now - currentSweep.lastUpdateTime, NYAN_CONFIG.DT_MAX);
+ const INITIAL_X = GAME_CONFIG.CHEF_X_POSITION;
+ const totalDistance = NYAN_CONFIG.MAX_X - INITIAL_X;
+
+ const moveIncrement = (totalDistance / NYAN_CONFIG.DURATION) * dt;
+ const newXPosition = currentSweep.xPosition + moveIncrement;
+
+ let newLane = currentChefLane + (currentSweep.laneDirection * NYAN_CONFIG.LANE_CHANGE_SPEED * dt);
+ let newLaneDirection = currentSweep.laneDirection;
+
+ // Bounce logic
+ if (newLane > GAME_CONFIG.LANE_BOTTOM) {
+ newLane = GAME_CONFIG.LANE_BOTTOM;
+ newLaneDirection = -1;
+ } else if (newLane < GAME_CONFIG.LANE_TOP) {
+ newLane = GAME_CONFIG.LANE_TOP;
+ newLaneDirection = 1;
+ }
+
+ const sweepComplete = newXPosition >= NYAN_CONFIG.MAX_X;
+
+ if (sweepComplete) {
+ // Snap to nearest lane when done
+ const finalLane = Math.max(
+ GAME_CONFIG.LANE_TOP,
+ Math.min(GAME_CONFIG.LANE_BOTTOM, Math.round(newLane))
+ );
+ return {
+ nextSweep: undefined,
+ nextChefLane: finalLane,
+ sweepComplete: true,
+ newXPosition
+ };
+ }
+
+ return {
+ nextSweep: {
+ ...currentSweep,
+ xPosition: newXPosition,
+ laneDirection: newLaneDirection,
+ lastUpdateTime: now
+ },
+ nextChefLane: newLane,
+ sweepComplete: false,
+ newXPosition
+ };
+};
+
+/**
+ * Checks for collisions during Nyan Sweep
+ */
+export const checkNyanSweepCollisions = (
+ sweep: NyanSweep,
+ newXPosition: number,
+ newLane: number,
+ customers: Customer[],
+ minions?: BossMinion[]
+): NyanCollisionResult => {
+ const hitCustomerIds: string[] = [];
+ const hitMinionIds: string[] = [];
+
+ const oldX = sweep.xPosition;
+
+ // Check Customers
+ customers.forEach(customer => {
+ if (customer.served || customer.disappointed || customer.vomit) return;
+
+ // Using the extracted collision logic
+ if (checkNyanSweepCollision(newLane, oldX, newXPosition, customer)) {
+ hitCustomerIds.push(customer.id);
+ }
+ });
+
+ // Check Boss Minions
+ if (minions) {
+ minions.forEach(minion => {
+ if (minion.defeated) return;
+
+ // Inline check or reuse logic. Since checkNyanSweepCollision takes {lane, position}, it works for minions too.
+ // Replicating the specific tolerance used in the original code for minions if different
+ // Original code used 0.8 tolerance for minions, same as default in checkNyanSweepCollision
+ if (checkNyanSweepCollision(newLane, oldX, newXPosition, minion)) {
+ hitMinionIds.push(minion.id);
+ }
+ });
+ }
+
+ return { hitCustomerIds, hitMinionIds };
+};
diff --git a/src/logic/ovenSystem.ts b/src/logic/ovenSystem.ts
index 8d1b739..be4652a 100644
--- a/src/logic/ovenSystem.ts
+++ b/src/logic/ovenSystem.ts
@@ -25,6 +25,37 @@ export interface OvenInteractionResult {
newState?: Partial; // Only the parts that changed
}
+export type OvenDisplayStatus = 'empty' | 'cooking' | 'ready' | 'warning' | 'burning' | 'burned' | 'cleaning';
+
+/**
+ * Get the display status of an oven for UI rendering
+ * Single source of truth for oven status calculation
+ */
+export const getOvenDisplayStatus = (
+ oven: OvenState,
+ speedUpgrade: number,
+ now: number = Date.now()
+): OvenDisplayStatus => {
+ if (oven.burned) {
+ if (oven.cleaningStartTime > 0) {
+ return 'cleaning';
+ }
+ return 'burned';
+ }
+
+ if (!oven.cooking) {
+ return 'empty';
+ }
+
+ const elapsed = oven.pausedElapsed !== undefined ? oven.pausedElapsed : now - oven.startTime;
+ const cookTime = OVEN_CONFIG.COOK_TIMES[speedUpgrade] || OVEN_CONFIG.COOK_TIMES[0];
+
+ if (elapsed >= OVEN_CONFIG.BURN_TIME) return 'burning';
+ if (elapsed >= OVEN_CONFIG.WARNING_TIME) return 'warning';
+ if (elapsed >= cookTime) return 'ready';
+ return 'cooking';
+};
+
/**
* Calculates the status of all ovens for a single game tick
*/
@@ -110,10 +141,11 @@ export const processOvenTick = (
export const tryInteractWithOven = (
gameState: GameState,
lane: number,
- now: number
+ now: number,
+ starPowerActive: boolean = false
): OvenInteractionResult => {
const currentOven = gameState.ovens[lane];
-
+
if (currentOven.burned) return { action: 'NONE' };
// A. Start Cooking
@@ -124,40 +156,62 @@ export const tryInteractWithOven = (
newState: {
ovens: {
...gameState.ovens,
- [lane]: {
- cooking: true,
- startTime: now,
- burned: false,
- cleaningStartTime: 0,
- sliceCount: slicesProduced
+ [lane]: {
+ cooking: true,
+ startTime: now,
+ burned: false,
+ cleaningStartTime: 0,
+ sliceCount: slicesProduced
}
}
}
};
- }
-
+ }
+
// B. Serve Pizza
const speedUpgrade = gameState.ovenSpeedUpgrades[lane] || 0;
const cookTime = OVEN_CONFIG.COOK_TIMES[speedUpgrade];
-
+
// Check if cooked enough but not burned
if (now - currentOven.startTime >= cookTime && now - currentOven.startTime < OVEN_CONFIG.BURN_TIME) {
const slicesProduced = currentOven.sliceCount;
const newTotal = gameState.availableSlices + slicesProduced;
if (newTotal <= GAME_CONFIG.MAX_SLICES) {
+ // Has room - serve normally
return {
action: 'SERVED',
newState: {
availableSlices: newTotal,
ovens: {
...gameState.ovens,
- [lane]: {
- cooking: false,
- startTime: 0,
- burned: false,
- cleaningStartTime: 0,
- sliceCount: 0
+ [lane]: {
+ cooking: false,
+ startTime: 0,
+ burned: false,
+ cleaningStartTime: 0,
+ sliceCount: 0
+ }
+ },
+ stats: {
+ ...gameState.stats,
+ slicesBaked: gameState.stats.slicesBaked + slicesProduced,
+ }
+ }
+ };
+ } else if (starPowerActive) {
+ // No room but star power active - just empty the oven (don't add slices)
+ return {
+ action: 'SERVED',
+ newState: {
+ ovens: {
+ ...gameState.ovens,
+ [lane]: {
+ cooking: false,
+ startTime: 0,
+ burned: false,
+ cleaningStartTime: 0,
+ sliceCount: 0
}
},
stats: {
@@ -167,6 +221,7 @@ export const tryInteractWithOven = (
}
};
}
+ // No room and no star power - do nothing
}
return { action: 'NONE' };
diff --git a/src/logic/pepeHelperSystem.ts b/src/logic/pepeHelperSystem.ts
new file mode 100644
index 0000000..6ab4c48
--- /dev/null
+++ b/src/logic/pepeHelperSystem.ts
@@ -0,0 +1,292 @@
+import { GameState, PepeHelpers, PepeHelper, PizzaSlice, Customer } from '../types/game';
+import { POWERUPS, PEPE_CONFIG, GAME_CONFIG, ENTITY_SPEEDS, OVEN_CONFIG } from '../lib/constants';
+import { getOvenDisplayStatus } from './ovenSystem';
+
+/**
+ * Initialize pepe helpers when power-up is collected
+ * Famous chefs come prepared with pizza and spread out to cover all lanes
+ */
+export const initializePepeHelpers = (now: number, chefLane: number): PepeHelpers => ({
+ active: true,
+ startTime: now,
+ endTime: now + POWERUPS.PEPE_DURATION,
+ franco: {
+ id: 'franco',
+ lane: chefLane <= 1 ? 2 : 0, // Spread out from chef
+ availableSlices: PEPE_CONFIG.STARTING_SLICES, // Famous chefs come prepared!
+ lastActionTime: 0,
+ },
+ frank: {
+ id: 'frank',
+ lane: chefLane >= 2 ? 1 : 3, // Spread out from chef
+ availableSlices: PEPE_CONFIG.STARTING_SLICES, // Famous chefs come prepared!
+ lastActionTime: 0,
+ },
+});
+
+/**
+ * Check if pepe helpers have expired
+ */
+export const checkPepeHelpersExpired = (helpers: PepeHelpers, now: number): boolean => {
+ return now >= helpers.endTime;
+};
+
+export interface PepeHelperTickResult {
+ updatedState: Partial;
+ events: PepeHelperEvent[];
+}
+
+export type PepeHelperEvent =
+ | { type: 'OVEN_STARTED'; lane: number; helper: 'franco' | 'frank' }
+ | { type: 'PIZZA_PULLED'; lane: number; slices: number; helper: 'franco' | 'frank' }
+ | { type: 'CUSTOMER_SERVED'; lane: number; helper: 'franco' | 'frank' }
+ | { type: 'PLATE_CAUGHT'; lane: number; helper: 'franco' | 'frank' }
+ | { type: 'HELPER_MOVED'; lane: number; helper: 'franco' | 'frank' };
+
+/**
+ * Evaluate what action a helper should take
+ */
+const evaluateLanePriority = (
+ lane: number,
+ gameState: GameState,
+ helper: PepeHelper,
+ otherHelperLane: number,
+ chefLane: number
+): number => {
+ let priority = 0;
+ const oven = gameState.ovens[lane];
+ const speedUpgrade = gameState.ovenSpeedUpgrades[lane] || 0;
+ const status = getOvenDisplayStatus(oven, speedUpgrade);
+
+ // High priority: Ready oven that needs pulling (and helper can carry more)
+ if (status === 'ready' && helper.availableSlices < GAME_CONFIG.MAX_SLICES) {
+ priority += 100;
+ }
+
+ // Medium priority: Idle oven that can be started
+ if (status === 'idle') {
+ priority += 50;
+ }
+
+ // High priority: Approaching customers in this lane (if we have slices)
+ const approachingInLane = gameState.customers.filter(
+ c => c.lane === lane && !c.served && !c.disappointed && !c.vomit && !c.leaving && c.position < 80
+ );
+ if (approachingInLane.length > 0 && helper.availableSlices > 0) {
+ // Closer customers = higher priority
+ const closestCustomer = approachingInLane.reduce((a, b) => a.position < b.position ? a : b);
+ priority += 80 + (100 - closestCustomer.position);
+ }
+
+ // Medium priority: Plates returning in this lane
+ const platesInLane = gameState.emptyPlates.filter(p => p.lane === lane && p.position < 30);
+ if (platesInLane.length > 0) {
+ priority += 60;
+ }
+
+ // Avoid clustering - reduce priority if chef or other helper is here
+ if (lane === chefLane) priority -= 20;
+ if (lane === otherHelperLane) priority -= 30;
+
+ return priority;
+};
+
+/**
+ * Process a single helper's actions
+ */
+const processHelperAction = (
+ helper: PepeHelper,
+ gameState: GameState,
+ otherHelperLane: number,
+ chefLane: number,
+ now: number
+): {
+ updatedHelper: PepeHelper;
+ updatedOvens: typeof gameState.ovens;
+ newSlices: PizzaSlice[];
+ caughtPlateIds: string[];
+ events: PepeHelperEvent[];
+ statsUpdates: Partial;
+ scoreGained: number;
+} => {
+ const events: PepeHelperEvent[] = [];
+ let updatedHelper = { ...helper };
+ let updatedOvens = { ...gameState.ovens };
+ const newSlices: PizzaSlice[] = [];
+ const caughtPlateIds: string[] = [];
+ let statsUpdates: Partial = {};
+ let scoreGained = 0;
+
+ // Rate limit actions
+ if (now - helper.lastActionTime < PEPE_CONFIG.ACTION_INTERVAL) {
+ return { updatedHelper, updatedOvens, newSlices, caughtPlateIds, events, statsUpdates, scoreGained };
+ }
+
+ // Evaluate best lane
+ const lanePriorities = [0, 1, 2, 3].map(lane => ({
+ lane,
+ priority: evaluateLanePriority(lane, gameState, helper, otherHelperLane, chefLane),
+ }));
+ lanePriorities.sort((a, b) => b.priority - a.priority);
+
+ const bestLane = lanePriorities[0].lane;
+
+ // Move one lane at a time toward the best lane
+ if (helper.lane !== bestLane) {
+ const direction = bestLane > helper.lane ? 1 : -1;
+ updatedHelper.lane = helper.lane + direction;
+ events.push({ type: 'HELPER_MOVED', lane: updatedHelper.lane, helper: helper.id });
+ // Famous chefs can move AND act in the same tick!
+ }
+
+ // We're in the best lane - take action (use updatedHelper.lane since we might have moved)
+ const currentLane = updatedHelper.lane;
+ const oven = updatedOvens[currentLane];
+ const speedUpgrade = gameState.ovenSpeedUpgrades[currentLane] || 0;
+ const status = getOvenDisplayStatus(oven, speedUpgrade);
+
+ // Priority 1: Catch plates
+ const platesInLane = gameState.emptyPlates.filter(
+ p => p.lane === currentLane && p.position < 20
+ );
+ if (platesInLane.length > 0) {
+ const plate = platesInLane[0];
+ caughtPlateIds.push(plate.id);
+ scoreGained += 50;
+ statsUpdates = {
+ platesCaught: (gameState.stats.platesCaught || 0) + 1,
+ currentPlateStreak: (gameState.stats.currentPlateStreak || 0) + 1,
+ largestPlateStreak: Math.max(
+ gameState.stats.largestPlateStreak || 0,
+ (gameState.stats.currentPlateStreak || 0) + 1
+ ),
+ };
+ updatedHelper.lastActionTime = now;
+ events.push({ type: 'PLATE_CAUGHT', lane: currentLane, helper: helper.id });
+ return { updatedHelper, updatedOvens, newSlices, caughtPlateIds, events, statsUpdates, scoreGained };
+ }
+
+ // Priority 2: Pull ready pizza
+ if (status === 'ready' && updatedHelper.availableSlices < GAME_CONFIG.MAX_SLICES) {
+ const slicesToAdd = Math.min(oven.sliceCount, GAME_CONFIG.MAX_SLICES - updatedHelper.availableSlices);
+ updatedHelper.availableSlices += slicesToAdd;
+ updatedOvens[currentLane] = {
+ ...oven,
+ cooking: false,
+ startTime: 0,
+ sliceCount: 0,
+ };
+ statsUpdates = {
+ slicesBaked: (gameState.stats.slicesBaked || 0) + slicesToAdd,
+ };
+ updatedHelper.lastActionTime = now;
+ events.push({ type: 'PIZZA_PULLED', lane: currentLane, slices: slicesToAdd, helper: helper.id });
+ return { updatedHelper, updatedOvens, newSlices, caughtPlateIds, events, statsUpdates, scoreGained };
+ }
+
+ // Priority 3: Serve customers (only if needed)
+ const approachingCustomers = gameState.customers.filter(
+ c => c.lane === currentLane && !c.served && !c.disappointed && !c.vomit && !c.leaving && c.position < 85
+ );
+ // Count slices already heading to this lane
+ const slicesInLane = gameState.pizzaSlices.filter(s => s.lane === currentLane).length + newSlices.filter(s => s.lane === currentLane).length;
+ // Only throw if there are more customers than slices already in flight
+ if (approachingCustomers.length > slicesInLane && updatedHelper.availableSlices > 0) {
+ const newSlice: PizzaSlice = {
+ id: `${helper.id}-pizza-${now}-${currentLane}`,
+ lane: currentLane,
+ position: GAME_CONFIG.CHEF_X_POSITION,
+ speed: ENTITY_SPEEDS.PIZZA,
+ };
+ newSlices.push(newSlice);
+ updatedHelper.availableSlices -= 1;
+ updatedHelper.lastActionTime = now;
+ events.push({ type: 'CUSTOMER_SERVED', lane: currentLane, helper: helper.id });
+ return { updatedHelper, updatedOvens, newSlices, caughtPlateIds, events, statsUpdates, scoreGained };
+ }
+
+ // Priority 4: Start cooking
+ if (status === 'idle') {
+ const upgradeLevel = gameState.ovenUpgrades[currentLane] || 0;
+ const sliceCount = upgradeLevel + 1;
+ updatedOvens[currentLane] = {
+ ...oven,
+ cooking: true,
+ startTime: now,
+ burned: false,
+ sliceCount,
+ };
+ updatedHelper.lastActionTime = now;
+ events.push({ type: 'OVEN_STARTED', lane: currentLane, helper: helper.id });
+ return { updatedHelper, updatedOvens, newSlices, caughtPlateIds, events, statsUpdates, scoreGained };
+ }
+
+ return { updatedHelper, updatedOvens, newSlices, caughtPlateIds, events, statsUpdates, scoreGained };
+};
+
+/**
+ * Process pepe helper actions each tick
+ * Helpers operate independently like additional chefs
+ */
+export const processPepeHelperTick = (
+ gameState: GameState,
+ now: number
+): PepeHelperTickResult => {
+ const helpers = gameState.pepeHelpers;
+ if (!helpers || !helpers.active) {
+ return { updatedState: {}, events: [] };
+ }
+
+ const allEvents: PepeHelperEvent[] = [];
+ let currentOvens = { ...gameState.ovens };
+ let currentPlates = [...gameState.emptyPlates];
+ let allNewSlices: PizzaSlice[] = [];
+ let totalScore = 0;
+ let statsUpdates: Partial = {};
+
+ // Process Franco
+ const francoResult = processHelperAction(
+ helpers.franco,
+ { ...gameState, ovens: currentOvens, emptyPlates: currentPlates },
+ helpers.frank.lane,
+ gameState.chefLane,
+ now
+ );
+ currentOvens = francoResult.updatedOvens;
+ currentPlates = currentPlates.filter(p => !francoResult.caughtPlateIds.includes(p.id));
+ allNewSlices = [...allNewSlices, ...francoResult.newSlices];
+ allEvents.push(...francoResult.events);
+ totalScore += francoResult.scoreGained;
+ statsUpdates = { ...statsUpdates, ...francoResult.statsUpdates };
+
+ // Process Frank
+ const frankResult = processHelperAction(
+ helpers.frank,
+ { ...gameState, ovens: currentOvens, emptyPlates: currentPlates },
+ francoResult.updatedHelper.lane,
+ gameState.chefLane,
+ now
+ );
+ currentOvens = frankResult.updatedOvens;
+ currentPlates = currentPlates.filter(p => !frankResult.caughtPlateIds.includes(p.id));
+ allNewSlices = [...allNewSlices, ...frankResult.newSlices];
+ allEvents.push(...frankResult.events);
+ totalScore += frankResult.scoreGained;
+ statsUpdates = { ...statsUpdates, ...frankResult.statsUpdates };
+
+ return {
+ updatedState: {
+ ovens: currentOvens,
+ pizzaSlices: [...gameState.pizzaSlices, ...allNewSlices],
+ emptyPlates: currentPlates,
+ pepeHelpers: {
+ ...helpers,
+ franco: francoResult.updatedHelper,
+ frank: frankResult.updatedHelper,
+ },
+ stats: { ...gameState.stats, ...statsUpdates },
+ score: gameState.score + totalScore,
+ },
+ events: allEvents,
+ };
+};
diff --git a/src/logic/plateSystem.ts b/src/logic/plateSystem.ts
new file mode 100644
index 0000000..9357b91
--- /dev/null
+++ b/src/logic/plateSystem.ts
@@ -0,0 +1,80 @@
+import { EmptyPlate, GameStats } from '../types/game';
+import { checkChefPlateCollision } from './collisionSystem';
+import { calculatePlateScore, updateStatsForStreak } from './scoringSystem';
+
+export type PlateEvent = 'CAUGHT' | 'DROPPED';
+
+export interface PlateTickResult {
+ remainingPlates: EmptyPlate[];
+ scores: Array<{ points: number; lane: number; position: number }>;
+ events: PlateEvent[];
+ updatedStats: GameStats;
+ totalScore: number;
+}
+
+/**
+ * Update plate positions (move left)
+ */
+export const updatePlatePositions = (plates: EmptyPlate[]): EmptyPlate[] => {
+ return plates.map(plate => ({
+ ...plate,
+ position: plate.position - plate.speed
+ }));
+};
+
+/**
+ * Process plate catching and cleanup
+ */
+export const processPlates = (
+ plates: EmptyPlate[],
+ chefLane: number,
+ stats: GameStats,
+ dogeMultiplier: number,
+ streakMultiplier: number,
+ nyanSweepActive: boolean
+): PlateTickResult => {
+ const remainingPlates: EmptyPlate[] = [];
+ const scores: Array<{ points: number; lane: number; position: number }> = [];
+ const events: PlateEvent[] = [];
+ let totalScore = 0;
+ let updatedStats = { ...stats };
+
+ // First update positions
+ const movedPlates = updatePlatePositions(plates);
+
+ movedPlates.forEach(plate => {
+ // Check chef collision (only if not in nyan sweep)
+ if (checkChefPlateCollision(chefLane, plate) && !nyanSweepActive) {
+ const pointsEarned = calculatePlateScore(dogeMultiplier, streakMultiplier);
+
+ totalScore += pointsEarned;
+ scores.push({ points: pointsEarned, lane: plate.lane, position: plate.position });
+
+ updatedStats.platesCaught += 1;
+ updatedStats = updateStatsForStreak(updatedStats, 'plate');
+ events.push('CAUGHT');
+
+ // Don't add to remaining plates (caught)
+ return;
+ }
+
+ // Check if plate went off screen
+ if (plate.position <= 0) {
+ updatedStats.currentPlateStreak = 0;
+ events.push('DROPPED');
+ // Don't add to remaining plates (dropped)
+ return;
+ }
+
+ // Keep the plate
+ remainingPlates.push(plate);
+ });
+
+ return {
+ remainingPlates,
+ scores,
+ events,
+ updatedStats,
+ totalScore
+ };
+};
diff --git a/src/logic/powerUpSystem.test.ts b/src/logic/powerUpSystem.test.ts
new file mode 100644
index 0000000..4b873d4
--- /dev/null
+++ b/src/logic/powerUpSystem.test.ts
@@ -0,0 +1,253 @@
+import { describe, it, expect } from 'vitest';
+import { processPowerUpCollection, processPowerUpExpirations, processChefPowerUpCollisions } from './powerUpSystem';
+import { GameState, Customer, PowerUp } from '../types/game';
+import { INITIAL_GAME_STATE, GAME_CONFIG } from '../lib/constants';
+
+const createMockGameState = (overrides: Partial = {}): GameState => ({
+ ...INITIAL_GAME_STATE,
+ ...overrides
+} as GameState);
+
+describe('powerUpSystem', () => {
+ describe('processPowerUpExpirations', () => {
+ it('removes expired power-ups', () => {
+ const now = 1000;
+ const result = processPowerUpExpirations([
+ { type: 'speed', endTime: 500 }, // Expired
+ { type: 'slow', endTime: 1500 } // Active
+ ], now);
+
+ expect(result.activePowerUps).toHaveLength(1);
+ expect(result.activePowerUps[0].type).toBe('slow');
+ expect(result.expiredTypes).toContain('speed');
+ });
+
+ it('detects active star power', () => {
+ const now = 1000;
+ const result = processPowerUpExpirations([
+ { type: 'star', endTime: 1500 }
+ ], now);
+
+ expect(result.starPowerActive).toBe(true);
+ });
+ });
+
+ describe('processPowerUpCollection', () => {
+ it('activates timed power-ups', () => {
+ const state = createMockGameState({ chefLane: 0 });
+ const now = 1000;
+ const result = processPowerUpCollection(
+ state,
+ { id: '1', type: 'speed', lane: 0, position: 0, speed: 0 },
+ 1,
+ now
+ );
+
+ expect(result.newState.activePowerUps).toHaveLength(1);
+ expect(result.newState.activePowerUps[0].type).toBe('speed');
+ });
+
+ it('triggers star power effects', () => {
+ const state = createMockGameState({ availableSlices: 0 });
+ const now = 1000;
+ const result = processPowerUpCollection(
+ state,
+ { id: '1', type: 'star', lane: 0, position: 0, speed: 0 },
+ 1,
+ now
+ );
+
+ expect(result.newState.starPowerActive).toBe(true);
+ expect(result.newState.availableSlices).toBe(8); // MAX_SLICES
+ expect(result.newState.activePowerUps).toHaveLength(1);
+ });
+
+ it('handles beer power-up lives lost', () => {
+ const woozyCustomer: Customer = {
+ id: 'c1', lane: 0, position: 50, speed: 0, served: false,
+ hasPlate: false, leaving: false, disappointed: false,
+ woozy: true, vomit: false, movingRight: false, critic: false, badLuckBrian: false, flipped: false
+ };
+
+ const state = createMockGameState({
+ lives: 3,
+ customers: [woozyCustomer]
+ });
+
+ const result = processPowerUpCollection(
+ state,
+ { id: '1', type: 'beer', lane: 0, position: 0, speed: 0 },
+ 1,
+ 1000
+ );
+
+ // Woozy + Beer = Vomit and Life Lost
+ expect(result.livesLost).toBe(1);
+ expect(result.newState.lives).toBe(2);
+ expect(result.newState.customers[0].vomit).toBe(true);
+ });
+
+ it('initializes nyan sweep and returns nyanSweepStarted flag', () => {
+ const state = createMockGameState({ chefLane: 1 });
+ const now = 1000;
+ const result = processPowerUpCollection(
+ state,
+ { id: '1', type: 'nyan', lane: 0, position: 0, speed: 0 },
+ 1,
+ now
+ );
+
+ expect(result.nyanSweepStarted).toBe(true);
+ expect(result.newState.nyanSweep).toBeDefined();
+ expect(result.newState.nyanSweep?.active).toBe(true);
+ expect(result.newState.nyanSweep?.startingLane).toBe(1);
+ });
+
+ it('does not start nyan sweep if already active', () => {
+ const state = createMockGameState({
+ chefLane: 1,
+ nyanSweep: {
+ active: true,
+ xPosition: 50,
+ laneDirection: 1,
+ startTime: 500,
+ lastUpdateTime: 500,
+ startingLane: 0
+ }
+ });
+ const now = 1000;
+ const result = processPowerUpCollection(
+ state,
+ { id: '1', type: 'nyan', lane: 0, position: 0, speed: 0 },
+ 1,
+ now
+ );
+
+ expect(result.nyanSweepStarted).toBe(false);
+ // Original sweep should remain unchanged
+ expect(result.newState.nyanSweep?.startingLane).toBe(0);
+ });
+ });
+
+ describe('processChefPowerUpCollisions', () => {
+ const createPowerUp = (id: string, type: PowerUp['type'], lane: number, position: number): PowerUp => ({
+ id, type, lane, position, speed: 1
+ });
+
+ it('detects collision when chef is on same lane and position', () => {
+ const powerUp = createPowerUp('p1', 'honey', 0, GAME_CONFIG.CHEF_X_POSITION);
+ const state = createMockGameState({ powerUps: [powerUp] });
+
+ const result = processChefPowerUpCollisions(
+ state,
+ 0, // chefLane
+ GAME_CONFIG.CHEF_X_POSITION,
+ 1, // dogeMultiplier
+ 1000
+ );
+
+ expect(result.caughtPowerUpIds.has('p1')).toBe(true);
+ expect(result.scores.length).toBeGreaterThan(0);
+ });
+
+ it('does not detect collision when chef is on different lane', () => {
+ const powerUp = createPowerUp('p1', 'honey', 2, GAME_CONFIG.CHEF_X_POSITION);
+ const state = createMockGameState({ powerUps: [powerUp] });
+
+ const result = processChefPowerUpCollisions(
+ state,
+ 0, // chefLane - different from powerUp lane
+ GAME_CONFIG.CHEF_X_POSITION,
+ 1,
+ 1000
+ );
+
+ expect(result.caughtPowerUpIds.size).toBe(0);
+ });
+
+ it('skips collision detection during active nyan sweep', () => {
+ const powerUp = createPowerUp('p1', 'honey', 0, GAME_CONFIG.CHEF_X_POSITION);
+ const state = createMockGameState({
+ powerUps: [powerUp],
+ nyanSweep: {
+ active: true,
+ xPosition: 50,
+ laneDirection: 1,
+ startTime: 500,
+ lastUpdateTime: 500,
+ startingLane: 0
+ }
+ });
+
+ const result = processChefPowerUpCollisions(
+ state,
+ 0,
+ GAME_CONFIG.CHEF_X_POSITION,
+ 1,
+ 1000
+ );
+
+ expect(result.caughtPowerUpIds.size).toBe(0);
+ });
+
+ it('collects multiple power-ups in single pass', () => {
+ const powerUps = [
+ createPowerUp('p1', 'honey', 0, GAME_CONFIG.CHEF_X_POSITION),
+ createPowerUp('p2', 'star', 0, GAME_CONFIG.CHEF_X_POSITION) // Same position
+ ];
+ const state = createMockGameState({ powerUps });
+
+ const result = processChefPowerUpCollisions(
+ state,
+ 0,
+ GAME_CONFIG.CHEF_X_POSITION,
+ 1,
+ 1000
+ );
+
+ expect(result.caughtPowerUpIds.size).toBe(2);
+ });
+
+ it('returns nyanSweepStarted when nyan power-up collected', () => {
+ const powerUp = createPowerUp('p1', 'nyan', 0, GAME_CONFIG.CHEF_X_POSITION);
+ const state = createMockGameState({ powerUps: [powerUp] });
+
+ const result = processChefPowerUpCollisions(
+ state,
+ 0,
+ GAME_CONFIG.CHEF_X_POSITION,
+ 1,
+ 1000
+ );
+
+ expect(result.nyanSweepStarted).toBe(true);
+ expect(result.newState.nyanSweep?.active).toBe(true);
+ });
+
+ it('aggregates lives lost from beer power-up', () => {
+ const woozyCustomer: Customer = {
+ id: 'c1', lane: 0, position: 50, speed: 0, served: false,
+ hasPlate: false, leaving: false, disappointed: false,
+ woozy: true, vomit: false, movingRight: false, critic: false, badLuckBrian: false, flipped: false
+ };
+ const powerUp = createPowerUp('p1', 'beer', 0, GAME_CONFIG.CHEF_X_POSITION);
+ const state = createMockGameState({
+ powerUps: [powerUp],
+ customers: [woozyCustomer],
+ lives: 3
+ });
+
+ const result = processChefPowerUpCollisions(
+ state,
+ 0,
+ GAME_CONFIG.CHEF_X_POSITION,
+ 1,
+ 1000
+ );
+
+ expect(result.livesLost).toBe(1);
+ expect(result.newState.lives).toBe(2);
+ });
+ });
+
+});
diff --git a/src/logic/powerUpSystem.ts b/src/logic/powerUpSystem.ts
new file mode 100644
index 0000000..ec75998
--- /dev/null
+++ b/src/logic/powerUpSystem.ts
@@ -0,0 +1,232 @@
+import { GameState, PowerUp, StarLostReason, PowerUpType, ActivePowerUp, NyanSweep } from '../types/game';
+import { GAME_CONFIG, POWERUPS, SCORING } from '../lib/constants';
+import { checkChefPowerUpCollision } from './collisionSystem';
+import { calculatePowerUpScore } from './scoringSystem';
+import { initializePepeHelpers } from './pepeHelperSystem';
+
+// Result of collecting a power-up
+export interface PowerUpCollectionResult {
+ newState: GameState; // Modified state
+ scoresToAdd: Array<{ points: number; lane: number; position: number }>; // Floating scores to spawn
+ livesLost: number; // For sound effects
+ shouldTriggerGameOver: boolean;
+ powerUpAlert?: { type: PowerUpType; endTime: number; chefLane: number };
+ nyanSweepStarted: boolean; // Whether a new Nyan sweep was started
+}
+
+// Result of processing all chef power-up collisions
+export interface ChefPowerUpCollisionResult {
+ newState: GameState;
+ caughtPowerUpIds: Set;
+ scores: Array<{ points: number; lane: number; position: number }>;
+ livesLost: number;
+ shouldTriggerGameOver: boolean;
+ nyanSweepStarted: boolean;
+}
+
+// Result of processing expirations
+export interface PowerUpExpirationResult {
+ activePowerUps: ActivePowerUp[];
+ expiredTypes: PowerUpType[];
+ starPowerActive: boolean;
+}
+
+/**
+ * Processes the collection of a power-up by the chef
+ */
+export const processPowerUpCollection = (
+ currentState: GameState,
+ powerUp: PowerUp,
+ dogeMultiplier: number,
+ now: number
+): PowerUpCollectionResult => {
+ let newState = { ...currentState };
+ const scoresToAdd: Array<{ points: number; lane: number; position: number }> = [];
+ let livesLost = 0;
+ let shouldTriggerGameOver = false;
+
+ // Track power-up usage
+ newState.stats = {
+ ...newState.stats,
+ powerUpsUsed: {
+ ...newState.stats.powerUpsUsed,
+ [powerUp.type]: (newState.stats.powerUpsUsed[powerUp.type] || 0) + 1
+ }
+ };
+
+ if (powerUp.type === 'beer') {
+ let lastReason: StarLostReason | undefined;
+
+ newState.customers = newState.customers.map(customer => {
+ // Impact on Critic
+ if (customer.critic) {
+ if (customer.woozy) return { ...customer, woozy: false, woozyState: undefined, frozen: false, hotHoneyAffected: false, textMessage: "I prefer wine", textMessageTime: now };
+ if (!customer.served && !customer.vomit && !customer.disappointed && !customer.leaving) return { ...customer, textMessage: "I prefer wine", textMessageTime: now };
+ return customer;
+ }
+
+ // Impact on Woozy customers (Double Beer = Vomit)
+ if (customer.woozy) {
+ livesLost += 1;
+ lastReason = 'beer_vomit';
+ return { ...customer, woozy: false, vomit: true, disappointed: true, movingRight: true };
+ }
+
+ // Impact on Normal customers
+ if (!customer.served && !customer.vomit && !customer.disappointed && !customer.leaving) {
+ if (customer.badLuckBrian) {
+ livesLost += 1;
+ lastReason = 'brian_hurled';
+ return { ...customer, vomit: true, disappointed: true, movingRight: true, flipped: false, textMessage: "Oh man I hurled", textMessageTime: now, hotHoneyAffected: false, frozen: false };
+ }
+ return { ...customer, woozy: true, woozyState: 'normal', movingRight: true, hotHoneyAffected: false, frozen: false };
+ }
+ return customer;
+ });
+
+ if (livesLost > 0) {
+ newState.lives = Math.max(0, newState.lives - livesLost);
+ newState.stats = { ...newState.stats, currentCustomerStreak: 0 };
+ if (lastReason) newState.lastStarLostReason = lastReason;
+ }
+
+ if (newState.lives === 0) {
+ shouldTriggerGameOver = true;
+ }
+
+ } else if (powerUp.type === 'star') {
+ newState.availableSlices = GAME_CONFIG.MAX_SLICES;
+ newState.starPowerActive = true;
+ newState.activePowerUps = [...newState.activePowerUps.filter(p => p.type !== 'star'), { type: 'star', endTime: now + POWERUPS.DURATION }];
+ } else if (powerUp.type === 'doge') {
+ newState.activePowerUps = [...newState.activePowerUps.filter(p => p.type !== 'doge'), { type: 'doge', endTime: now + POWERUPS.DOGE_DURATION }];
+ newState.powerUpAlert = { type: 'doge', endTime: now + POWERUPS.ALERT_DURATION_DOGE, chefLane: newState.chefLane };
+ } else if (powerUp.type === 'nyan') {
+ newState.powerUpAlert = { type: 'nyan', endTime: now + POWERUPS.ALERT_DURATION_NYAN, chefLane: newState.chefLane };
+ // Initialize Nyan sweep if not already active
+ if (!newState.nyanSweep?.active) {
+ newState.nyanSweep = {
+ active: true,
+ xPosition: GAME_CONFIG.CHEF_X_POSITION,
+ laneDirection: 1,
+ startTime: now,
+ lastUpdateTime: now,
+ startingLane: newState.chefLane
+ };
+ return { newState, scoresToAdd, livesLost, shouldTriggerGameOver, powerUpAlert: newState.powerUpAlert, nyanSweepStarted: true };
+ }
+ } else if (powerUp.type === 'moltobenny') {
+ const moltoScore = SCORING.MOLTOBENNY_POINTS * dogeMultiplier;
+ const moltoMoney = SCORING.MOLTOBENNY_CASH * dogeMultiplier;
+ newState.score += moltoScore;
+ newState.bank += moltoMoney;
+ scoresToAdd.push({ points: moltoScore, lane: newState.chefLane, position: GAME_CONFIG.CHEF_X_POSITION });
+ } else if (powerUp.type === 'pepe') {
+ // Initialize Pepe helpers - Franco-Pepe and Frank-Pepe assist the chef
+ newState.pepeHelpers = initializePepeHelpers(now, newState.chefLane);
+ newState.activePowerUps = [...newState.activePowerUps.filter(p => p.type !== 'pepe'), { type: 'pepe', endTime: now + POWERUPS.PEPE_DURATION }];
+ } else {
+ // Generic timed power-up addition
+ newState.activePowerUps = [...newState.activePowerUps.filter(p => p.type !== powerUp.type), { type: powerUp.type, endTime: now + POWERUPS.DURATION }];
+
+ // Immediate effects for Honey
+ if (powerUp.type === 'honey') {
+ newState.customers = newState.customers.map(c => {
+ if (c.served || c.disappointed || c.vomit || c.leaving) return c;
+ if (c.critic) return { ...c, shouldBeHotHoneyAffected: false, hotHoneyAffected: false, textMessage: "Just plain, thanks.", textMessageTime: now };
+ if (c.badLuckBrian) return { ...c, shouldBeHotHoneyAffected: false, hotHoneyAffected: false, frozen: false, woozy: false, woozyState: undefined, textMessage: "I can't do spicy.", textMessageTime: now };
+ return { ...c, shouldBeHotHoneyAffected: true, hotHoneyAffected: true, frozen: false, woozy: false, woozyState: undefined };
+ });
+ }
+
+ // Immediate effects for Ice Cream
+ if (powerUp.type === 'ice-cream') {
+ newState.customers = newState.customers.map(c => {
+ if (!c.served && !c.disappointed && !c.vomit) {
+ if (c.badLuckBrian) return { ...c, textMessage: "I'm lactose intolerant", textMessageTime: now };
+ return { ...c, shouldBeFrozenByIceCream: true, frozen: true, hotHoneyAffected: false, woozy: false, woozyState: undefined };
+ }
+ return c;
+ });
+ }
+ }
+
+ return { newState, scoresToAdd, livesLost, shouldTriggerGameOver, powerUpAlert: newState.powerUpAlert, nyanSweepStarted: false };
+};
+
+/**
+ * Handles expiration of active power-ups
+ */
+export const processPowerUpExpirations = (
+ activePowerUps: ActivePowerUp[],
+ now: number
+): PowerUpExpirationResult => {
+ const nextPowerUps = activePowerUps.filter(p => p.endTime > now);
+ const expiredTypes = activePowerUps
+ .filter(p => p.endTime <= now)
+ .map(p => p.type);
+
+ const starPowerActive = nextPowerUps.some(p => p.type === 'star');
+
+ return {
+ activePowerUps: nextPowerUps,
+ expiredTypes,
+ starPowerActive
+ };
+};
+
+/**
+ * Processes all chef power-up collisions in a single pass
+ * Returns updated state, caught IDs, scores, and events for sound handling
+ */
+export const processChefPowerUpCollisions = (
+ state: GameState,
+ chefLane: number,
+ chefXPosition: number,
+ dogeMultiplier: number,
+ now: number
+): ChefPowerUpCollisionResult => {
+ const caughtPowerUpIds = new Set();
+ const scores: Array<{ points: number; lane: number; position: number }> = [];
+ let newState = state;
+ let totalLivesLost = 0;
+ let shouldTriggerGameOver = false;
+ let nyanSweepStarted = false;
+
+ // Skip collision detection during active Nyan sweep
+ if (state.nyanSweep?.active) {
+ return { newState, caughtPowerUpIds, scores, livesLost: 0, shouldTriggerGameOver: false, nyanSweepStarted: false };
+ }
+
+ state.powerUps.forEach(powerUp => {
+ if (checkChefPowerUpCollision(chefLane, chefXPosition, powerUp)) {
+ caughtPowerUpIds.add(powerUp.id);
+
+ // Add base score for non-moltobenny power-ups
+ if (powerUp.type !== 'moltobenny') {
+ const pointsEarned = calculatePowerUpScore(dogeMultiplier);
+ newState = { ...newState, score: newState.score + pointsEarned };
+ scores.push({ points: pointsEarned, lane: powerUp.lane, position: powerUp.position });
+ }
+
+ // Process the collection effects
+ const collectionResult = processPowerUpCollection(newState, powerUp, dogeMultiplier, now);
+ newState = collectionResult.newState;
+
+ // Aggregate results
+ totalLivesLost += collectionResult.livesLost;
+ if (collectionResult.shouldTriggerGameOver) {
+ shouldTriggerGameOver = true;
+ }
+ if (collectionResult.nyanSweepStarted) {
+ nyanSweepStarted = true;
+ }
+ if (collectionResult.scoresToAdd.length > 0) {
+ scores.push(...collectionResult.scoresToAdd);
+ }
+ }
+ });
+
+ return { newState, caughtPowerUpIds, scores, livesLost: totalLivesLost, shouldTriggerGameOver, nyanSweepStarted };
+};
+
diff --git a/src/logic/scoringSystem.test.ts b/src/logic/scoringSystem.test.ts
new file mode 100644
index 0000000..f3e0a92
--- /dev/null
+++ b/src/logic/scoringSystem.test.ts
@@ -0,0 +1,184 @@
+import { describe, it, expect } from 'vitest';
+import { applyCustomerScoring, calculateCustomerScore, checkLifeGain } from './scoringSystem';
+import { GameState, Customer } from '../types/game';
+import { INITIAL_GAME_STATE, SCORING, GAME_CONFIG } from '../lib/constants';
+
+const createMockGameState = (overrides: Partial = {}): GameState => ({
+ ...INITIAL_GAME_STATE,
+ ...overrides
+} as GameState);
+
+const createMockCustomer = (overrides: Partial = {}): Customer => ({
+ id: 'c1',
+ lane: 0,
+ position: 50,
+ speed: 1,
+ served: false,
+ hasPlate: true,
+ leaving: false,
+ disappointed: false,
+ woozy: false,
+ vomit: false,
+ movingRight: false,
+ critic: false,
+ badLuckBrian: false,
+ flipped: false,
+ ...overrides
+});
+
+describe('scoringSystem', () => {
+ describe('calculateCustomerScore', () => {
+ it('calculates normal customer score', () => {
+ const customer = createMockCustomer();
+ const result = calculateCustomerScore(customer, 1, 1);
+
+ expect(result.points).toBe(SCORING.CUSTOMER_NORMAL);
+ expect(result.bank).toBe(SCORING.BASE_BANK_REWARD);
+ });
+
+ it('calculates critic score (double points)', () => {
+ const customer = createMockCustomer({ critic: true });
+ const result = calculateCustomerScore(customer, 1, 1);
+
+ expect(result.points).toBe(SCORING.CUSTOMER_CRITIC);
+ });
+
+ it('calculates first slice score', () => {
+ const customer = createMockCustomer();
+ const result = calculateCustomerScore(customer, 1, 1, true);
+
+ expect(result.points).toBe(SCORING.CUSTOMER_FIRST_SLICE);
+ });
+
+ it('applies doge multiplier to points and bank', () => {
+ const customer = createMockCustomer();
+ const dogeMultiplier = 2;
+ const result = calculateCustomerScore(customer, dogeMultiplier, 1);
+
+ expect(result.points).toBe(SCORING.CUSTOMER_NORMAL * dogeMultiplier);
+ expect(result.bank).toBe(SCORING.BASE_BANK_REWARD * dogeMultiplier);
+ });
+
+ it('applies streak multiplier to points', () => {
+ const customer = createMockCustomer();
+ const streakMultiplier = 1.5;
+ const result = calculateCustomerScore(customer, 1, streakMultiplier);
+
+ expect(result.points).toBe(Math.floor(SCORING.CUSTOMER_NORMAL * streakMultiplier));
+ });
+ });
+
+ describe('checkLifeGain', () => {
+ it('grants life at every 8 happy customers', () => {
+ const result = checkLifeGain(3, 8, 1); // 8th customer
+
+ expect(result.livesToAdd).toBe(1);
+ expect(result.shouldPlaySound).toBe(true);
+ });
+
+ it('does not grant life at non-multiples of 8', () => {
+ const result = checkLifeGain(3, 7, 1);
+
+ expect(result.livesToAdd).toBe(0);
+ });
+
+ it('does not exceed max lives', () => {
+ const result = checkLifeGain(GAME_CONFIG.MAX_LIVES, 8, 1);
+
+ expect(result.livesToAdd).toBe(0);
+ });
+
+ it('grants bonus life for critic served efficiently', () => {
+ const result = checkLifeGain(3, 5, 1, true, 60); // critic at position 60+
+
+ expect(result.livesToAdd).toBe(1);
+ });
+
+ it('does not grant critic bonus if served too late', () => {
+ const result = checkLifeGain(3, 5, 1, true, 40); // position < 50
+
+ expect(result.livesToAdd).toBe(0);
+ });
+ });
+
+ describe('applyCustomerScoring', () => {
+ it('applies full scoring with bank and stats for served customer', () => {
+ const customer = createMockCustomer({ lane: 1, position: 60 });
+ const state = createMockGameState({ happyCustomers: 0, lives: 3 });
+
+ const result = applyCustomerScoring(customer, state, 1, 1, {
+ includeBank: true,
+ countsAsServed: true,
+ isFirstSlice: false,
+ checkLifeGain: true
+ });
+
+ expect(result.scoreToAdd).toBe(SCORING.CUSTOMER_NORMAL);
+ expect(result.bankToAdd).toBe(SCORING.BASE_BANK_REWARD);
+ expect(result.newHappyCustomers).toBe(1);
+ expect(result.newStats.customersServed).toBe(1);
+ expect(result.floatingScore.points).toBe(SCORING.CUSTOMER_NORMAL);
+ });
+
+ it('excludes bank when includeBank is false (Scumbag Steve)', () => {
+ const customer = createMockCustomer();
+ const state = createMockGameState();
+
+ const result = applyCustomerScoring(customer, state, 1, 1, {
+ includeBank: false,
+ countsAsServed: true,
+ isFirstSlice: false,
+ checkLifeGain: true
+ });
+
+ expect(result.bankToAdd).toBe(0);
+ expect(result.scoreToAdd).toBe(SCORING.CUSTOMER_NORMAL);
+ });
+
+ it('does not increment happy customers when countsAsServed is false', () => {
+ const customer = createMockCustomer();
+ const state = createMockGameState({ happyCustomers: 5 });
+
+ const result = applyCustomerScoring(customer, state, 1, 1, {
+ includeBank: true,
+ countsAsServed: false,
+ isFirstSlice: true,
+ checkLifeGain: false
+ });
+
+ expect(result.newHappyCustomers).toBe(5); // unchanged
+ expect(result.scoreToAdd).toBe(SCORING.CUSTOMER_FIRST_SLICE);
+ });
+
+ it('checks life gain when checkLifeGain is true', () => {
+ const customer = createMockCustomer({ lane: 2, position: 55 });
+ const state = createMockGameState({ happyCustomers: 7, lives: 3 }); // Will become 8
+
+ const result = applyCustomerScoring(customer, state, 1, 1, {
+ includeBank: true,
+ countsAsServed: true,
+ isFirstSlice: false,
+ checkLifeGain: true
+ });
+
+ expect(result.livesToAdd).toBe(1);
+ expect(result.shouldPlayLifeSound).toBe(true);
+ expect(result.starGain).toBeDefined();
+ });
+
+ it('returns correct floatingScore position', () => {
+ const customer = createMockCustomer({ lane: 2, position: 75 });
+ const state = createMockGameState();
+
+ const result = applyCustomerScoring(customer, state, 1, 1, {
+ includeBank: true,
+ countsAsServed: true,
+ isFirstSlice: false,
+ checkLifeGain: false
+ });
+
+ expect(result.floatingScore.lane).toBe(2);
+ expect(result.floatingScore.position).toBe(75);
+ });
+ });
+});
diff --git a/src/logic/scoringSystem.ts b/src/logic/scoringSystem.ts
index eacff03..106f98c 100644
--- a/src/logic/scoringSystem.ts
+++ b/src/logic/scoringSystem.ts
@@ -1,8 +1,94 @@
import {
Customer,
- GameStats
+ GameStats,
+ GameState
} from '../types/game';
import { SCORING, GAME_CONFIG } from '../lib/constants';
+import { getCustomerVariant } from '../types/game';
+
+/**
+ * Options for applying customer scoring to game state
+ */
+export interface CustomerScoringOptions {
+ includeBank: boolean; // Whether to add bank reward
+ countsAsServed: boolean; // Whether to increment happyCustomers and stats
+ isFirstSlice: boolean; // Whether this is a first slice (drooling/partial)
+ checkLifeGain: boolean; // Whether to check for life gain bonus
+}
+
+/**
+ * Result of applying customer scoring
+ */
+export interface CustomerScoringResult {
+ scoreToAdd: number;
+ bankToAdd: number;
+ newHappyCustomers: number;
+ newStats: GameStats;
+ livesToAdd: number;
+ shouldPlayLifeSound: boolean;
+ floatingScore: { points: number; lane: number; position: number };
+ starGain?: { lane: number; position: number };
+}
+
+/**
+ * Applies customer scoring to game state - consolidates repeated scoring logic
+ */
+export const applyCustomerScoring = (
+ customer: Customer,
+ state: GameState,
+ dogeMultiplier: number,
+ streakMultiplier: number,
+ options: CustomerScoringOptions
+): CustomerScoringResult => {
+ const { points, bank } = calculateCustomerScore(
+ customer,
+ dogeMultiplier,
+ streakMultiplier,
+ options.isFirstSlice
+ );
+
+ let newHappyCustomers = state.happyCustomers;
+ let newStats = state.stats;
+ let livesToAdd = 0;
+ let shouldPlayLifeSound = false;
+ let starGain: { lane: number; position: number } | undefined;
+
+ if (options.countsAsServed) {
+ newHappyCustomers += 1;
+ newStats = {
+ ...newStats,
+ customersServed: newStats.customersServed + 1,
+ };
+ newStats = updateStatsForStreak(newStats, 'customer');
+
+ if (options.checkLifeGain) {
+ const lifeResult = checkLifeGain(
+ state.lives,
+ newHappyCustomers,
+ dogeMultiplier,
+ getCustomerVariant(customer) === 'critic',
+ customer.position
+ );
+
+ if (lifeResult.livesToAdd > 0) {
+ livesToAdd = lifeResult.livesToAdd;
+ shouldPlayLifeSound = lifeResult.shouldPlaySound;
+ starGain = { lane: customer.lane, position: customer.position };
+ }
+ }
+ }
+
+ return {
+ scoreToAdd: points,
+ bankToAdd: options.includeBank ? bank : 0,
+ newHappyCustomers,
+ newStats,
+ livesToAdd,
+ shouldPlayLifeSound,
+ floatingScore: { points, lane: customer.lane, position: customer.position },
+ starGain,
+ };
+};
/**
* Calculates the score and bank reward for serving a customer.
@@ -82,7 +168,7 @@ export const checkLifeGain = (
// HOWEVER, looking at legacy code:
// "if (newState.happyCustomers % 8 === 0 ...)"
// This implies we check the *accumulated* value.
- if (!isCritic && happyCustomers > 0 && happyCustomers % 8 === 0) {
+ if (happyCustomers > 0 && happyCustomers % 8 === 0) {
const stars = Math.min(dogeMultiplier, GAME_CONFIG.MAX_LIVES - currentLives);
livesToAdd += stars;
}
diff --git a/src/logic/spawnSystem.ts b/src/logic/spawnSystem.ts
new file mode 100644
index 0000000..e97279a
--- /dev/null
+++ b/src/logic/spawnSystem.ts
@@ -0,0 +1,160 @@
+import { Customer, PowerUp, CustomerVariant } from '../types/game';
+import {
+ SPAWN_RATES,
+ GAME_CONFIG,
+ PROBABILITIES,
+ POSITIONS,
+ ENTITY_SPEEDS,
+ POWERUPS,
+ SCUMBAG_STEVE
+} from '../lib/constants';
+
+export interface SpawnResult {
+ shouldSpawn: boolean;
+ entity?: T;
+}
+
+/**
+ * Calculate the spawn delay based on level
+ */
+export const getCustomerSpawnDelay = (level: number): number => {
+ return SPAWN_RATES.CUSTOMER_MIN_INTERVAL_BASE -
+ (level * SPAWN_RATES.CUSTOMER_MIN_INTERVAL_DECREMENT);
+};
+
+/**
+ * Calculate effective spawn rate based on level and boss status
+ */
+export const getEffectiveSpawnRate = (level: number, bossActive: boolean): number => {
+ const levelSpawnRate =
+ SPAWN_RATES.CUSTOMER_BASE_RATE +
+ (level - 1) * SPAWN_RATES.CUSTOMER_LEVEL_INCREMENT;
+
+ return bossActive ? levelSpawnRate * 0.5 : levelSpawnRate;
+};
+
+/**
+ * Check if a customer should spawn and create one if so
+ */
+export const trySpawnCustomer = (
+ lastSpawnTime: number,
+ now: number,
+ level: number,
+ bossActive: boolean
+): SpawnResult => {
+ const spawnDelay = getCustomerSpawnDelay(level);
+ const effectiveSpawnRate = getEffectiveSpawnRate(level, bossActive);
+
+ // Check time gate and random chance
+ if (now - lastSpawnTime < spawnDelay) {
+ return { shouldSpawn: false };
+ }
+
+ if (Math.random() >= effectiveSpawnRate * 0.01) {
+ return { shouldSpawn: false };
+ }
+
+ // Create the customer
+ const lane = Math.floor(Math.random() * GAME_CONFIG.LANE_COUNT);
+ const disappointedEmojis = ['😢', '😭', '😠', '🤬'];
+
+ // Determine customer variant (mutually exclusive)
+ const variant: CustomerVariant =
+ Math.random() < PROBABILITIES.CRITIC_CHANCE ? 'critic' :
+ Math.random() < PROBABILITIES.BAD_LUCK_BRIAN_CHANCE ? 'badLuckBrian' :
+ Math.random() < PROBABILITIES.SCUMBAG_STEVE_CHANCE ? 'scumbagSteve' :
+ Math.random() < PROBABILITIES.PIZZA_MAFIA_CHANCE ? 'pizzaMafia' :
+ 'normal';
+
+ // Calculate speed (Steve is faster)
+ const speed = variant === 'scumbagSteve'
+ ? ENTITY_SPEEDS.CUSTOMER_BASE * SCUMBAG_STEVE.SPEED_MULTIPLIER
+ : ENTITY_SPEEDS.CUSTOMER_BASE;
+
+ // Create customer in 'approaching' state
+ const customer: Customer = {
+ id: `customer-${now}-${lane}`,
+ lane,
+ position: POSITIONS.SPAWN_X,
+ speed,
+ // Initial state: approaching (not served, leaving, or disappointed)
+ served: false,
+ hasPlate: false,
+ leaving: false,
+ disappointed: false,
+ disappointedEmoji: disappointedEmojis[Math.floor(Math.random() * disappointedEmojis.length)],
+ movingRight: false,
+ // Customer variant
+ critic: variant === 'critic',
+ badLuckBrian: variant === 'badLuckBrian',
+ scumbagSteve: variant === 'scumbagSteve',
+ pizzaMafia: variant === 'pizzaMafia',
+ slicesReceived: variant === 'scumbagSteve' ? 0 : undefined,
+ lastLaneChangeTime: variant === 'scumbagSteve' ? now : undefined,
+ flipped: variant === 'badLuckBrian', // Brian spawns flipped, Steve spawns normal
+ };
+
+ return { shouldSpawn: true, entity: customer };
+};
+
+/**
+ * Check if a power-up should spawn and create one if so
+ */
+export const trySpawnPowerUp = (
+ lastSpawnTime: number,
+ now: number
+): SpawnResult => {
+ // Check time gate
+ if (now - lastSpawnTime < SPAWN_RATES.POWERUP_MIN_INTERVAL) {
+ return { shouldSpawn: false };
+ }
+
+ // Check random chance
+ if (Math.random() >= SPAWN_RATES.POWERUP_CHANCE) {
+ return { shouldSpawn: false };
+ }
+
+ // Create the power-up
+ const lane = Math.floor(Math.random() * GAME_CONFIG.LANE_COUNT);
+ const rand = Math.random();
+ const randomType = rand < PROBABILITIES.POWERUP_STAR_CHANCE
+ ? 'star'
+ : POWERUPS.TYPES[Math.floor(Math.random() * POWERUPS.TYPES.length)];
+
+ const powerUp: PowerUp = {
+ id: `powerup-${now}-${lane}`,
+ lane,
+ position: POSITIONS.POWERUP_SPAWN_X,
+ speed: ENTITY_SPEEDS.POWERUP,
+ type: randomType,
+ };
+
+ return { shouldSpawn: true, entity: powerUp };
+};
+
+/**
+ * Process all spawning for a tick
+ * Returns new entities to add and whether spawn timers should be updated
+ */
+export const processSpawning = (
+ lastCustomerSpawn: number,
+ lastPowerUpSpawn: number,
+ now: number,
+ level: number,
+ bossActive: boolean
+): {
+ newCustomer?: Customer;
+ newPowerUp?: PowerUp;
+ updateCustomerSpawnTime: boolean;
+ updatePowerUpSpawnTime: boolean;
+} => {
+ const customerResult = trySpawnCustomer(lastCustomerSpawn, now, level, bossActive);
+ const powerUpResult = trySpawnPowerUp(lastPowerUpSpawn, now);
+
+ return {
+ newCustomer: customerResult.entity,
+ newPowerUp: powerUpResult.entity,
+ updateCustomerSpawnTime: customerResult.shouldSpawn,
+ updatePowerUpSpawnTime: powerUpResult.shouldSpawn,
+ };
+};
diff --git a/src/logic/storeSystem.ts b/src/logic/storeSystem.ts
index 50c6e92..2522deb 100644
--- a/src/logic/storeSystem.ts
+++ b/src/logic/storeSystem.ts
@@ -9,9 +9,18 @@ export type StoreResult = {
events: StoreEvent[];
};
+// Calculate cumulative upgrade cost: $10 for 1st, $20 for 2nd, $30 for 3rd, etc.
+export const getUpgradeCost = (currentLevel: number): number => {
+ return COSTS.OVEN_UPGRADE * (currentLevel + 1);
+};
+
+export const getSpeedUpgradeCost = (currentLevel: number): number => {
+ return COSTS.OVEN_SPEED_UPGRADE * (currentLevel + 1);
+};
+
export const upgradeOven = (prev: GameState, lane: number): GameState => {
- const upgradeCost = COSTS.OVEN_UPGRADE;
const currentUpgrade = prev.ovenUpgrades[lane] || 0;
+ const upgradeCost = getUpgradeCost(currentUpgrade);
if (prev.bank >= upgradeCost && currentUpgrade < OVEN_CONFIG.MAX_UPGRADE_LEVEL) {
return {
@@ -25,8 +34,8 @@ export const upgradeOven = (prev: GameState, lane: number): GameState => {
};
export const upgradeOvenSpeed = (prev: GameState, lane: number): GameState => {
- const speedUpgradeCost = COSTS.OVEN_SPEED_UPGRADE;
const currentSpeedUpgrade = prev.ovenSpeedUpgrades[lane] || 0;
+ const speedUpgradeCost = getSpeedUpgradeCost(currentSpeedUpgrade);
if (prev.bank >= speedUpgradeCost && currentSpeedUpgrade < OVEN_CONFIG.MAX_SPEED_LEVEL) {
return {
diff --git a/src/services/highScores.ts b/src/services/highScores.ts
index 6bb96e2..c8a47fd 100644
--- a/src/services/highScores.ts
+++ b/src/services/highScores.ts
@@ -1,6 +1,9 @@
import { supabase } from '../lib/supabase';
import { GameStats } from '../types/game';
+const LOCAL_SCORES_KEY = 'pizza_chef_high_scores';
+const LOCAL_SESSIONS_KEY = 'pizza_chef_game_sessions';
+
export interface HighScore {
id: string;
player_name: string;
@@ -9,6 +12,41 @@ export interface HighScore {
game_session_id?: string;
}
+// Local storage helpers
+function getLocalScores(): HighScore[] {
+ try {
+ const data = localStorage.getItem(LOCAL_SCORES_KEY);
+ return data ? JSON.parse(data) : [];
+ } catch {
+ return [];
+ }
+}
+
+function saveLocalScores(scores: HighScore[]): void {
+ try {
+ localStorage.setItem(LOCAL_SCORES_KEY, JSON.stringify(scores));
+ } catch {
+ console.warn('Failed to save scores to local storage');
+ }
+}
+
+function getLocalSessions(): GameSession[] {
+ try {
+ const data = localStorage.getItem(LOCAL_SESSIONS_KEY);
+ return data ? JSON.parse(data) : [];
+ } catch {
+ return [];
+ }
+}
+
+function saveLocalSessions(sessions: GameSession[]): void {
+ try {
+ localStorage.setItem(LOCAL_SESSIONS_KEY, JSON.stringify(sessions));
+ } catch {
+ console.warn('Failed to save sessions to local storage');
+ }
+}
+
export interface GameSession {
id: string;
player_name: string;
@@ -26,31 +64,73 @@ export interface GameSession {
}
export async function getTopScores(limit: number = 10): Promise {
- const { data, error } = await supabase
- .from('high_scores')
- .select('*')
- .order('score', { ascending: false })
- .order('created_at', { ascending: true })
- .limit(limit);
+ // Try Supabase first
+ if (supabase) {
+ const { data, error } = await supabase
+ .from('high_scores')
+ .select('*')
+ .order('score', { ascending: false })
+ .order('created_at', { ascending: true })
+ .limit(limit);
+
+ if (!error && data) {
+ return data;
+ }
+ console.warn('Supabase fetch failed, falling back to local storage:', error);
+ }
- if (error) {
- console.error('Error fetching high scores:', error);
- return [];
+ // Fall back to local storage
+ const localScores = getLocalScores();
+ return localScores
+ .sort((a, b) => b.score - a.score || new Date(a.created_at).getTime() - new Date(b.created_at).getTime())
+ .slice(0, limit);
+}
+
+export async function checkIfTopScore(score: number, limit: number = 10): Promise {
+ const topScores = await getTopScores(limit);
+
+ if (topScores.length < limit) {
+ return true; // Less than 10 scores, any score qualifies
}
- return data || [];
+ const lowestTopScore = topScores[topScores.length - 1]?.score ?? 0;
+ return score > lowestTopScore;
}
-export async function submitScore(playerName: string, score: number, gameSessionId?: string): Promise {
- const { error } = await supabase
- .from('high_scores')
- .insert([{ player_name: playerName.toLowerCase(), score, game_session_id: gameSessionId }]);
+export async function checkIfNumberOneScore(score: number): Promise {
+ const topScores = await getTopScores(1);
- if (error) {
- console.error('Error submitting score:', error);
- return false;
+ if (topScores.length === 0) {
+ return true; // No scores yet, this is #1
}
+ return score >= topScores[0].score;
+}
+
+export async function submitScore(playerName: string, score: number, gameSessionId?: string): Promise {
+ // Try Supabase first
+ if (supabase) {
+ const { error } = await supabase
+ .from('high_scores')
+ .insert([{ player_name: playerName.toLowerCase(), score, game_session_id: gameSessionId }]);
+
+ if (!error) {
+ return true;
+ }
+ console.warn('Supabase submit failed, falling back to local storage:', error);
+ }
+
+ // Fall back to local storage
+ const localScores = getLocalScores();
+ const newScore: HighScore = {
+ id: crypto.randomUUID(),
+ player_name: playerName.toLowerCase(),
+ score,
+ created_at: new Date().toISOString(),
+ game_session_id: gameSessionId
+ };
+ localScores.push(newScore);
+ saveLocalScores(localScores);
return true;
}
@@ -60,47 +140,78 @@ export async function createGameSession(
level: number,
stats: GameStats
): Promise {
- const { data, error } = await supabase
- .from('game_sessions')
- .insert([{
- player_name: playerName.toLowerCase(),
- score,
- level,
- slices_baked: stats.slicesBaked,
- customers_served: stats.customersServed,
- longest_streak: stats.longestCustomerStreak,
- plates_caught: stats.platesCaught,
- largest_plate_streak: stats.largestPlateStreak,
- oven_upgrades: stats.ovenUpgradesMade,
- power_ups_used: stats.powerUpsUsed,
- }])
- .select()
- .single();
-
- if (error) {
- console.error('Error creating game session:', error);
- return null;
+ // Try Supabase first
+ if (supabase) {
+ const { data, error } = await supabase
+ .from('game_sessions')
+ .insert([{
+ player_name: playerName.toLowerCase(),
+ score,
+ level,
+ slices_baked: stats.slicesBaked,
+ customers_served: stats.customersServed,
+ longest_streak: stats.longestCustomerStreak,
+ plates_caught: stats.platesCaught,
+ largest_plate_streak: stats.largestPlateStreak,
+ oven_upgrades: stats.ovenUpgradesMade,
+ power_ups_used: stats.powerUpsUsed,
+ }])
+ .select()
+ .single();
+
+ if (!error && data) {
+ return data;
+ }
+ console.warn('Supabase session create failed, falling back to local storage:', error);
}
- return data;
+ // Fall back to local storage
+ const localSessions = getLocalSessions();
+ const newSession: GameSession = {
+ id: crypto.randomUUID(),
+ player_name: playerName.toLowerCase(),
+ score,
+ level,
+ slices_baked: stats.slicesBaked,
+ customers_served: stats.customersServed,
+ longest_streak: stats.longestCustomerStreak,
+ plates_caught: stats.platesCaught,
+ largest_plate_streak: stats.largestPlateStreak,
+ oven_upgrades: stats.ovenUpgradesMade,
+ power_ups_used: stats.powerUpsUsed,
+ created_at: new Date().toISOString()
+ };
+ localSessions.push(newSession);
+ saveLocalSessions(localSessions);
+ return newSession;
}
export async function getGameSession(id: string): Promise {
- const { data, error } = await supabase
- .from('game_sessions')
- .select('*')
- .eq('id', id)
- .maybeSingle();
-
- if (error) {
- console.error('Error fetching game session:', error);
- return null;
+ // Try Supabase first
+ if (supabase) {
+ const { data, error } = await supabase
+ .from('game_sessions')
+ .select('*')
+ .eq('id', id)
+ .maybeSingle();
+
+ if (!error && data) {
+ return data;
+ }
+ console.warn('Supabase session fetch failed, falling back to local storage:', error);
}
- return data;
+ // Fall back to local storage
+ const localSessions = getLocalSessions();
+ return localSessions.find(s => s.id === id) || null;
}
export async function uploadScorecardImage(gameSessionId: string, blob: Blob): Promise {
+ if (!supabase) {
+ console.warn('Supabase not configured - cannot upload scorecard');
+ return null;
+ }
+
const fileName = `${gameSessionId}.png`;
const { error } = await supabase.storage
.from('scorecards')
@@ -122,6 +233,11 @@ export async function uploadScorecardImage(gameSessionId: string, blob: Blob): P
}
export async function updateGameSessionImage(gameSessionId: string, imageUrl: string): Promise {
+ if (!supabase) {
+ console.warn('Supabase not configured - cannot update game session');
+ return false;
+ }
+
const { error } = await supabase
.from('game_sessions')
.update({ scorecard_image_url: imageUrl })
diff --git a/src/types/game.ts b/src/types/game.ts
index de2bb66..0b431b0 100644
--- a/src/types/game.ts
+++ b/src/types/game.ts
@@ -1,3 +1,33 @@
+// Customer state machine types
+export type CustomerState =
+ | 'approaching' // Moving toward chef
+ | 'served' // Got pizza, leaving happy
+ | 'disappointed' // Reached chef without pizza, leaving sad
+ | 'leaving' // Generic leaving (Brian complaining, etc.)
+ | 'vomit'; // Beer+woozy = sick
+
+export type CustomerVariant = 'normal' | 'critic' | 'badLuckBrian' | 'scumbagSteve' | 'pizzaMafia';
+
+export type WoozyState = 'normal' | 'drooling' | 'satisfied';
+
+// Helper functions for state checks
+export const isCustomerLeaving = (c: Customer): boolean =>
+ c.served || c.disappointed || c.leaving || c.vomit || false;
+
+export const isCustomerApproaching = (c: Customer): boolean =>
+ !isCustomerLeaving(c);
+
+export const getCustomerVariant = (c: Customer): CustomerVariant => {
+ if (c.pizzaMafia) return 'pizzaMafia';
+ if (c.scumbagSteve) return 'scumbagSteve';
+ if (c.badLuckBrian) return 'badLuckBrian';
+ if (c.critic) return 'critic';
+ return 'normal';
+};
+
+export const isCustomerAffectedByPowerUps = (c: Customer): boolean =>
+ !c.badLuckBrian && !c.critic && !c.scumbagSteve && !c.pizzaMafia && !c.served && !c.leaving && !c.disappointed;
+
export interface Customer {
id: string;
lane: number;
@@ -8,7 +38,7 @@ export interface Customer {
disappointed?: boolean;
disappointedEmoji?: string;
woozy?: boolean;
- woozyState?: 'normal' | 'drooling' | 'satisfied';
+ woozyState?: WoozyState;
movingRight?: boolean;
vomit?: boolean;
frozen?: boolean;
@@ -18,7 +48,11 @@ export interface Customer {
shouldBeHotHoneyAffected?: boolean;
critic?: boolean;
badLuckBrian?: boolean;
+ scumbagSteve?: boolean;
+ slicesReceived?: number; // For Steve who needs 2 slices
+ lastLaneChangeTime?: number; // For Steve's random lane changes
leaving?: boolean;
+ pizzaMafia?: boolean;
brianNyaned?: boolean; // Brian got hit by Nyan + is flying away
flipped?: boolean;
textMessage?: string;
@@ -34,14 +68,51 @@ export interface PizzaSlice {
fallY?: number;
}
+export interface MafiaSlice {
+ id: string;
+ lane: number;
+ position: number;
+ speedX: number;
+ speedY: number;
+ startTime: number;
+}
+
export interface EmptyPlate {
id: string;
lane: number;
position: number;
speed: number;
+ // For angled throws (Steve)
+ startLane?: number;
+ startPosition?: number;
+ targetLane?: number;
+}
+
+export interface NyanSweep {
+ active: boolean;
+ xPosition: number;
+ laneDirection: number;
+ startTime: number;
+ lastUpdateTime: number;
+ startingLane: number;
+}
+
+export interface PepeHelper {
+ id: 'franco' | 'frank';
+ lane: number;
+ availableSlices: number;
+ lastActionTime: number;
}
-export type PowerUpType = 'honey' | 'ice-cream' | 'beer' | 'star' | 'doge' | 'nyan' | 'moltobenny';
+export interface PepeHelpers {
+ active: boolean;
+ startTime: number;
+ endTime: number;
+ franco: PepeHelper;
+ frank: PepeHelper;
+}
+
+export type PowerUpType = 'honey' | 'ice-cream' | 'beer' | 'star' | 'doge' | 'nyan' | 'moltobenny' | 'pepe' | 'speed' | 'slow';
export interface PowerUp {
id: string;
@@ -64,6 +135,15 @@ export interface FloatingScore {
startTime: number;
}
+export interface FloatingStar {
+ id: string;
+ isGain: boolean; // true = gained star (green +), false = lost star (red -)
+ count: number; // number of stars (e.g., 2 for critic)
+ lane: number;
+ position: number;
+ startTime: number;
+}
+
export interface DroppedPlate {
id: string;
lane: number;
@@ -72,6 +152,15 @@ export interface DroppedPlate {
hasSlice?: boolean;
}
+export interface OvenState {
+ cooking: boolean;
+ startTime: number;
+ burned: boolean;
+ cleaningStartTime: number;
+ pausedElapsed?: number;
+ sliceCount: number;
+}
+
export interface BossMinion {
id: string;
lane: number;
@@ -80,14 +169,21 @@ export interface BossMinion {
defeated: boolean;
}
+export type BossType = 'dominos' | 'papaJohn';
+
export interface BossBattle {
active: boolean;
+ bossType: BossType;
bossHealth: number;
currentWave: number;
minions: BossMinion[];
bossVulnerable: boolean;
bossDefeated: boolean;
bossPosition: number;
+ bossLane: number;
+ bossLaneDirection: number; // 1 = moving down, -1 = moving up
+ bossXDirection: number; // 1 = moving right, -1 = moving left
+ hitsReceived?: number; // Track hits for Papa John sprite changes
}
export interface GameStats {
@@ -106,8 +202,13 @@ export interface GameStats {
doge: number;
nyan: number;
moltobenny: number;
+ pepe: number;
+ speed: number;
+ slow: number;
};
ovenUpgradesMade: number;
+ totalEarned: number;
+ totalSpent: number;
}
export type StarLostReason =
@@ -123,10 +224,12 @@ export type StarLostReason =
export interface GameState {
customers: Customer[];
pizzaSlices: PizzaSlice[];
+ mafiaSlices: MafiaSlice[];
emptyPlates: EmptyPlate[];
powerUps: PowerUp[];
activePowerUps: ActivePowerUp[];
floatingScores: FloatingScore[];
+ floatingStars: FloatingStar[];
droppedPlates: DroppedPlate[];
chefLane: number;
score: number;
@@ -136,7 +239,7 @@ export interface GameState {
lastStarLostReason?: StarLostReason;
paused: boolean;
availableSlices: number;
- ovens: { [key: number]: { cooking: boolean; startTime: number; burned: boolean; cleaningStartTime: number; pausedElapsed?: number; sliceCount: number } };
+ ovens: { [key: number]: OvenState };
ovenUpgrades: { [key: number]: number };
ovenSpeedUpgrades: { [key: number]: number };
happyCustomers: number;
@@ -147,8 +250,13 @@ export interface GameState {
fallingPizza?: { lane: number; y: number };
starPowerActive?: boolean;
powerUpAlert?: { type: PowerUpType; endTime: number; chefLane: number };
- nyanSweep?: { active: boolean; xPosition: number; laneDirection: 1 | -1; startTime: number; lastUpdateTime: number; startingLane: number };
+ nyanSweep?: NyanSweep;
+ pepeHelpers?: PepeHelpers;
stats: GameStats;
bossBattle?: BossBattle;
defeatedBossLevels: number[];
+ cleanKitchenStartTime?: number;
+ lastCleanKitchenBonusTime?: number;
+ cleanKitchenBonusAlert?: { endTime: number };
+ lastPauseTime?: number; // Track when game was paused for timer adjustments
}
\ No newline at end of file
diff --git a/src/utils/sounds.ts b/src/utils/sounds.ts
index d73e89b..03041e8 100644
--- a/src/utils/sounds.ts
+++ b/src/utils/sounds.ts
@@ -1,6 +1,10 @@
class SoundManager {
private audioContext: AudioContext | null = null;
private isMuted: boolean = false;
+ private nyanTimeouts: number[] = [];
+ private nyanPausedAt: number = 0;
+ private nyanRemainingNotes: Array<{ frequency: number; delay: number; duration: number; type?: OscillatorType; volume?: number }> = [];
+ private nyanStartTime: number = 0;
private getAudioContext(): AudioContext {
if (!this.audioContext) {
@@ -196,35 +200,80 @@ ovenReady() {
]);
}
+ private nyanNotes: Array<{ frequency: number; delay: number; duration: number; type: OscillatorType; volume: number }> = [
+ { frequency: 1046.5, delay: 0, duration: 0.188, type: 'square', volume: 0.22 },
+ { frequency: 1174.7, delay: 188, duration: 0.095, type: 'square', volume: 0.22 },
+ { frequency: 784.0, delay: 377, duration: 0.095, type: 'square', volume: 0.22 },
+ { frequency: 880.0, delay: 472, duration: 0.188, type: 'square', volume: 0.22 },
+ { frequency: 698.5, delay: 660, duration: 0.047, type: 'square', volume: 0.22 },
+ { frequency: 830.6, delay: 755, duration: 0.095, type: 'square', volume: 0.22 },
+ { frequency: 784.0, delay: 848, duration: 0.095, type: 'square', volume: 0.22 },
+ { frequency: 698.5, delay: 943, duration: 0.095, type: 'square', volume: 0.22 },
+ { frequency: 698.5, delay: 1132, duration: 0.095, type: 'square', volume: 0.22 },
+ { frequency: 784.0, delay: 1320, duration: 0.188, type: 'square', volume: 0.22 },
+ { frequency: 830.6, delay: 1508, duration: 0.095, type: 'square', volume: 0.22 },
+ { frequency: 830.6, delay: 1697, duration: 0.047, type: 'square', volume: 0.22 },
+ { frequency: 784.0, delay: 1792, duration: 0.047, type: 'square', volume: 0.22 },
+ { frequency: 698.5, delay: 1885, duration: 0.095, type: 'square', volume: 0.22 },
+ { frequency: 784.0, delay: 1980, duration: 0.095, type: 'square', volume: 0.22 },
+ { frequency: 880.0, delay: 2075, duration: 0.095, type: 'square', volume: 0.22 },
+ { frequency: 1046.5, delay: 2168, duration: 0.095, type: 'square', volume: 0.22 },
+ { frequency: 1174.7, delay: 2263, duration: 0.095, type: 'square', volume: 0.22 },
+ { frequency: 880.0, delay: 2357, duration: 0.095, type: 'square', volume: 0.22 },
+ { frequency: 1046.5, delay: 2452, duration: 0.095, type: 'square', volume: 0.22 },
+ { frequency: 784.0, delay: 2545, duration: 0.095, type: 'square', volume: 0.22 },
+ { frequency: 830.6, delay: 2640, duration: 0.095, type: 'square', volume: 0.22 },
+ { frequency: 698.5, delay: 2735, duration: 0.095, type: 'square', volume: 0.22 },
+ ];
+
nyanCatPowerUp() {
- this.playMultiTone([
- { frequency: 1046.5, delay: 0, duration: 0.188, type: 'square', volume: 0.22 },
- { frequency: 1174.7, delay: 188, duration: 0.095, type: 'square', volume: 0.22 },
- { frequency: 784.0, delay: 377, duration: 0.095, type: 'square', volume: 0.22 },
- { frequency: 880.0, delay: 472, duration: 0.188, type: 'square', volume: 0.22 },
- { frequency: 698.5, delay: 660, duration: 0.047, type: 'square', volume: 0.22 },
-
- { frequency: 830.6, delay: 755, duration: 0.095, type: 'square', volume: 0.22 },
- { frequency: 784.0, delay: 848, duration: 0.095, type: 'square', volume: 0.22 },
- { frequency: 698.5, delay: 943, duration: 0.095, type: 'square', volume: 0.22 },
- { frequency: 698.5, delay: 1132, duration: 0.095, type: 'square', volume: 0.22 },
-
- { frequency: 784.0, delay: 1320, duration: 0.188, type: 'square', volume: 0.22 },
- { frequency: 830.6, delay: 1508, duration: 0.095, type: 'square', volume: 0.22 },
- { frequency: 830.6, delay: 1697, duration: 0.047, type: 'square', volume: 0.22 },
- { frequency: 784.0, delay: 1792, duration: 0.047, type: 'square', volume: 0.22 },
-
- { frequency: 698.5, delay: 1885, duration: 0.095, type: 'square', volume: 0.22 },
- { frequency: 784.0, delay: 1980, duration: 0.095, type: 'square', volume: 0.22 },
- { frequency: 880.0, delay: 2075, duration: 0.095, type: 'square', volume: 0.22 },
- { frequency: 1046.5, delay: 2168, duration: 0.095, type: 'square', volume: 0.22 },
- { frequency: 1174.7, delay: 2263, duration: 0.095, type: 'square', volume: 0.22 },
- { frequency: 880.0, delay: 2357, duration: 0.095, type: 'square', volume: 0.22 },
- { frequency: 1046.5, delay: 2452, duration: 0.095, type: 'square', volume: 0.22 },
- { frequency: 784.0, delay: 2545, duration: 0.095, type: 'square', volume: 0.22 },
- { frequency: 830.6, delay: 2640, duration: 0.095, type: 'square', volume: 0.22 },
- { frequency: 698.5, delay: 2735, duration: 0.095, type: 'square', volume: 0.22 },
-]);
+ this.stopNyan(); // Clear any existing nyan playback
+ this.nyanStartTime = Date.now();
+ this.nyanRemainingNotes = [...this.nyanNotes];
+ this.playNyanNotes(this.nyanNotes);
+ }
+
+ private playNyanNotes(notes: Array<{ frequency: number; delay: number; duration: number; type?: OscillatorType; volume?: number }>) {
+ notes.forEach(note => {
+ const timeoutId = window.setTimeout(() => {
+ this.playTone(note.frequency, note.duration, note.type || 'sine', note.volume || 0.3);
+ }, note.delay);
+ this.nyanTimeouts.push(timeoutId);
+ });
+ }
+
+ pauseNyan() {
+ if (this.nyanTimeouts.length === 0) return;
+
+ // Clear all pending timeouts
+ this.nyanTimeouts.forEach(id => window.clearTimeout(id));
+ this.nyanTimeouts = [];
+
+ // Calculate how much time has elapsed
+ this.nyanPausedAt = Date.now() - this.nyanStartTime;
+
+ // Store remaining notes (notes that haven't played yet)
+ this.nyanRemainingNotes = this.nyanNotes.filter(note => note.delay > this.nyanPausedAt);
+ }
+
+ resumeNyan() {
+ if (this.nyanRemainingNotes.length === 0) return;
+
+ // Adjust delays based on elapsed time
+ const adjustedNotes = this.nyanRemainingNotes.map(note => ({
+ ...note,
+ delay: note.delay - this.nyanPausedAt
+ }));
+
+ this.nyanStartTime = Date.now() - this.nyanPausedAt;
+ this.playNyanNotes(adjustedNotes);
+ }
+
+ stopNyan() {
+ this.nyanTimeouts.forEach(id => window.clearTimeout(id));
+ this.nyanTimeouts = [];
+ this.nyanRemainingNotes = [];
+ this.nyanPausedAt = 0;
}
setMuted(muted: boolean) {
@@ -235,8 +284,9 @@ ovenReady() {
return this.isMuted;
}
- toggleMute(): void {
+ toggleMute(): boolean {
this.isMuted = !this.isMuted;
+ return this.isMuted;
}
checkMuted(): boolean {
diff --git a/vitest.config.ts b/vitest.config.ts
new file mode 100644
index 0000000..8e730d5
--- /dev/null
+++ b/vitest.config.ts
@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+ test: {
+ globals: true,
+ environment: 'node',
+ },
+});
@@ -45,13 +46,12 @@ const ScoreBoard: React.FC = ({ gameState, onShowInstructions }
@@ -27,11 +45,31 @@ const SplashScreen: React.FC
+
+ )}
+
+
+
+ + Loading... {loadingProgress}% +
+