[V0_FILE]typescript:file="lib/workout-data.ts" isEdit="true" isMerged="true" import { type Workout, calculateWorkoutXP } from "./game-mechanics" export const presetWorkouts: Workout[] = [ { id: "beginner-strength-1", name: "Beginner Strength Training", difficulty: "beginner", focusArea: "strength", estimatedDuration: 30, xpReward: calculateWorkoutXP("beginner", 30), exercises: [ { name: "Push-ups", sets: 3, reps: 10, restTime: 60, variations: ["Bench Press", "Dumbbell Press", "Chest Fly", "Incline Push-ups"], }, { name: "Squats", sets: 3, reps: 15, restTime: 60, variations: ["Barbell Squats", "Goblet Squats", "Leg Press", "Bulgarian Split Squats"], }, { name: "Plank", duration: 30, sets: 3, restTime: 60, variations: ["Side Plank", "Plank to Push-up", "Ab Wheel", "Dead Bug"], }, { name: "Dumbbell Rows", sets: 3, reps: 12, restTime: 60, variations: ["Barbell Rows", "Cable Rows", "T-Bar Rows", "Inverted Rows"], }, ], }, { id: "beginner-cardio-1", name: "Beginner Cardio Blast", difficulty: "beginner", focusArea: "stamina", estimatedDuration: 20, xpReward: calculateWorkoutXP("beginner", 20), exercises: [ { name: "Jumping Jacks", duration: 60, sets: 3, restTime: 30, variations: ["Star Jumps", "Seal Jacks", "Plyo Jacks"], }, { name: "High Knees", duration: 30, sets: 3, restTime: 30, variations: ["Running in Place", "Butt Kicks", "A-Skips"], }, { name: "Mountain Climbers", duration: 30, sets: 3, restTime: 30, variations: ["Cross-body Mountain Climbers", "Slow Mountain Climbers", "Spider Climbers"], }, { name: "Burpees", sets: 2, reps: 10, restTime: 60, variations: ["Box Burpees", "Burpee Pull-ups", "Half Burpees", "Tuck Jump Burpees"], }, ], }, { id: "intermediate-agility-1", name: "Agility & Speed Training", difficulty: "intermediate", focusArea: "agility", estimatedDuration: 40, xpReward: calculateWorkoutXP("intermediate", 40), exercises: [ { name: "Lateral Shuffles", duration: 45, sets: 4, restTime: 45, variations: ["Lateral Bounds", "Ladder Drills", "Carioca"], }, { name: "Box Jumps", sets: 3, reps: 12, restTime: 60, variations: ["Depth Jumps", "Broad Jumps", "Single-leg Box Jumps"], }, { name: "Cone Drills", duration: 60, sets: 3, restTime: 60, variations: ["T-Drill", "5-10-5 Shuttle", "Zig-zag Sprints"], }, { name: "Sprint Intervals", duration: 30, sets: 6, restTime: 90, variations: ["Hill Sprints", "Sled Pushes", "Resistance Band Sprints"], }, ], }, { id: "intermediate-strength-1", name: "Intermediate Strength Builder", difficulty: "intermediate", focusArea: "strength", estimatedDuration: 45, xpReward: calculateWorkoutXP("intermediate", 45), exercises: [ { name: "Barbell Squats", sets: 4, reps: 10, restTime: 90, variations: ["Front Squats", "Safety Bar Squats", "Pause Squats", "Box Squats"], }, { name: "Bench Press", sets: 4, reps: 8, restTime: 90, variations: ["Incline Bench Press", "Close-grip Bench", "Dumbbell Bench Press", "Floor Press"], }, { name: "Deadlifts", sets: 3, reps: 8, restTime: 120, variations: ["Romanian Deadlifts", "Trap Bar Deadlifts", "Sumo Deadlifts", "Deficit Deadlifts"], }, { name: "Pull-ups", sets: 3, reps: 8, restTime: 90, variations: ["Chin-ups", "Weighted Pull-ups", "Wide-grip Pull-ups", "Lat Pulldowns"], }, ], }, { id: "advanced-stamina-1", name: "Advanced Endurance Challenge", difficulty: "advanced", focusArea: "stamina", estimatedDuration: 60, xpReward: calculateWorkoutXP("advanced", 60), exercises: [ { name: "Long Distance Run", duration: 1800, sets: 1, variations: ["Treadmill Run", "Trail Running", "Fartlek Training"], }, { name: "Rowing Machine", duration: 600, sets: 2, restTime: 120, variations: ["Concept2 Rowing", "Water Rowing", "Rowing Intervals"], }, { name: "Cycling", duration: 900, sets: 1, variations: ["Spin Bike", "Road Cycling", "Mountain Biking", "Assault Bike"], }, ], }, { id: "beginner-flexibility-1", name: "Flexibility & Mobility", difficulty: "beginner", focusArea: "flexibility", estimatedDuration: 25, xpReward: calculateWorkoutXP("beginner", 25), exercises: [ { name: "Hamstring Stretch", duration: 60, sets: 2, variations: ["Standing Hamstring Stretch", "Seated Hamstring Stretch", "PNF Stretching"], }, { name: "Hip Flexor Stretch", duration: 60, sets: 2, variations: ["Kneeling Hip Flexor Stretch", "Standing Hip Flexor Stretch", "Pigeon Pose"], }, { name: "Shoulder Circles", reps: 20, sets: 2, variations: ["Arm Swings", "Wall Slides", "Band Pull-aparts"], }, { name: "Yoga Flow", duration: 600, sets: 1, variations: ["Vinyasa Flow", "Yin Yoga", "Power Yoga", "Restorative Yoga"], }, ], }, ] [V0_FILE]typescript:file="hooks/use-player-profile.ts" isMerged="true" "use client" import { useState, useEffect } from "react" import { type PlayerProfile, createInitialProfile, processWorkoutCompletion, type Workout, type WorkoutSession, } from "@/lib/game-mechanics" const STORAGE_KEY = "workout-planner-profile" const SESSIONS_KEY = "workout-planner-sessions" export function usePlayerProfile() { const [profile, setProfile] = useState(createInitialProfile()) const [sessions, setSessions] = useState([]) const [isLoading, setIsLoading] = useState(true) // Load profile from localStorage useEffect(() => { try { const stored = localStorage.getItem(STORAGE_KEY) const storedSessions = localStorage.getItem(SESSIONS_KEY) if (stored) { setProfile(JSON.parse(stored)) } if (storedSessions) { setSessions(JSON.parse(storedSessions)) } } catch (error) { console.error("Failed to load profile:", error) } finally { setIsLoading(false) } }, []) // Save profile to localStorage whenever it changes useEffect(() => { if (!isLoading) { localStorage.setItem(STORAGE_KEY, JSON.stringify(profile)) } }, [profile, isLoading]) // Save sessions to localStorage useEffect(() => { if (!isLoading) { localStorage.setItem(SESSIONS_KEY, JSON.stringify(sessions)) } }, [sessions, isLoading]) const completeWorkout = (workout: Workout) => { const result = processWorkoutCompletion(profile, workout) const newSession: WorkoutSession = { id: `session-${Date.now()}`, workoutId: workout.id, workoutName: workout.name, completedAt: new Date(), xpEarned: workout.xpReward, focusArea: workout.focusArea, } setProfile(result.profile) setSessions([newSession, ...sessions]) return result } const resetProfile = () => { setProfile(createInitialProfile()) setSessions([]) localStorage.removeItem(STORAGE_KEY) localStorage.removeItem(SESSIONS_KEY) } return { profile, sessions, isLoading, completeWorkout, resetProfile, } } [V0_FILE]json:file="package.json" isMerged="true" { "name": "my-v0-project", "version": "0.1.0", "private": true, "scripts": { "dev": "next dev", "build": "next build", "start": "next start", "lint": "eslint ." }, "dependencies": { "@hookform/resolvers": "^3.10.0", "@radix-ui/react-accordion": "1.2.2", "@radix-ui/react-alert-dialog": "1.1.4", "@radix-ui/react-aspect-ratio": "1.1.1", "@radix-ui/react-avatar": "1.1.2", "@radix-ui/react-checkbox": "1.1.3", "@radix-ui/react-collapsible": "1.1.2", "@radix-ui/react-context-menu": "2.2.4", "@radix-ui/react-dialog": "1.1.4", "@radix-ui/react-dropdown-menu": "2.1.4", "@radix-ui/react-hover-card": "1.1.4", "@radix-ui/react-label": "2.1.1", "@radix-ui/react-menubar": "1.1.4", "@radix-ui/react-navigation-menu": "1.2.3", "@radix-ui/react-popover": "1.1.4", "@radix-ui/react-progress": "1.1.1", "@radix-ui/react-radio-group": "1.2.2", "@radix-ui/react-scroll-area": "1.2.2", "@radix-ui/react-select": "2.1.4", "@radix-ui/react-separator": "1.1.1", "@radix-ui/react-slider": "1.2.2", "@radix-ui/react-slot": "1.1.1", "@radix-ui/react-switch": "1.1.2", "@radix-ui/react-tabs": "1.1.2", "@radix-ui/react-toast": "1.2.4", "@radix-ui/react-toggle": "1.1.1", "@radix-ui/react-toggle-group": "1.1.1", "@radix-ui/react-tooltip": "1.1.6", "@vercel/analytics": "1.3.1", "autoprefixer": "^10.4.20", "class-variance-authority": "^0.7.1", "clsx": "^2.1.1", "cmdk": "1.0.4", "date-fns": "4.1.0", "embla-carousel-react": "8.5.1", "input-otp": "1.4.1", "lucide-react": "^0.454.0", "next": "16.0.10", "next-themes": "^0.4.6", "react": "19.2.0", "react-day-picker": "9.8.0", "react-dom": "19.2.0", "react-hook-form": "^7.60.0", "react-resizable-panels": "^2.1.7", "recharts": "2.15.4", "sonner": "^1.7.4", "tailwind-merge": "^3.3.1", "tailwindcss-animate": "^1.0.7", "vaul": "^1.1.2", "zod": "3.25.76" }, "devDependencies": { "@tailwindcss/postcss": "^4.1.9", "@types/node": "^22", "@types/react": "^19", "@types/react-dom": "^19", "postcss": "^8.5", "tailwindcss": "^4.1.9", "tw-animate-css": "1.3.3", "typescript": "^5" } } [V0_FILE]typescriptreact:file="components/level-display.tsx" isMerged="true" "use client" import { type PlayerProfile, getXPRequiredForLevel } from "@/lib/game-mechanics" import { Progress } from "@/components/ui/progress" interface LevelDisplayProps { profile: PlayerProfile } export function LevelDisplay({ profile }: LevelDisplayProps) { const xpRequired = getXPRequiredForLevel(profile.level) const xpProgress = (profile.currentXP / xpRequired) * 100 return (

Level {profile.level}

Total XP

{profile.totalXP.toLocaleString()}

Progress to Level {profile.level + 1} {profile.currentXP} / {xpRequired} XP

) } [V0_FILE]typescriptreact:file="components/stats-overview.tsx" isMerged="true" "use client" import type { PlayerStats } from "@/lib/game-mechanics" import { Progress } from "@/components/ui/progress" interface StatsOverviewProps { stats: PlayerStats } const statConfig = { strength: { label: "Strength", icon: "💪", color: "bg-chart-1" }, agility: { label: "Agility", icon: "⚡", color: "bg-chart-2" }, stamina: { label: "Stamina", icon: "❤️", color: "bg-chart-3" }, flexibility: { label: "Flexibility", icon: "🧘", color: "bg-chart-4" }, } export function StatsOverview({ stats }: StatsOverviewProps) { const maxStatValue = Math.max(...Object.values(stats), 50) return (

{Object.entries(stats).map(([key, value]) => { const config = statConfig[key as keyof PlayerStats] const percentage = (value / maxStatValue) * 100 return (

{config.icon} {config.label}

{value}

) })}

) } [V0_FILE]typescriptreact:file="components/recent-workouts.tsx" isMerged="true" "use client" import type { WorkoutSession } from "@/lib/game-mechanics" import { Card } from "@/components/ui/card" interface RecentWorkoutsProps { sessions: WorkoutSession[] limit?: number } const focusAreaIcons = { strength: "💪", agility: "⚡", stamina: "❤️", flexibility: "🧘", } export function RecentWorkouts({ sessions, limit = 5 }: RecentWorkoutsProps) { const recentSessions = sessions.slice(0, limit) if (recentSessions.length === 0) { return (

No workouts completed yet. Start your first workout to earn XP!

) } return (

{recentSessions.map((session) => { const date = new Date(session.completedAt) const isToday = date.toDateString() === new Date().toDateString() return (

{focusAreaIcons[session.focusArea]}

{session.workoutName}

{isToday ? "Today" : date.toLocaleDateString(undefined, { month: "short", day: "numeric", })}{" "} at {date.toLocaleTimeString(undefined, { hour: "2-digit", minute: "2-digit" })}

+{session.xpEarned} XP

) })}

) } [V0_FILE]typescriptreact:file="app/page.tsx" isMerged="true" "use client" import { usePlayerProfile } from "@/hooks/use-player-profile" import { LevelDisplay } from "@/components/level-display" import { StatsOverview } from "@/components/stats-overview" import { RecentWorkouts } from "@/components/recent-workouts" import { Card, CardHeader, CardTitle, CardContent } from "@/components/ui/card" import { Button } from "@/components/ui/button" import Link from "next/link" import { Dumbbell, User, Trophy } from "lucide-react" export default function HomePage() { const { profile, sessions, isLoading } = usePlayerProfile() if (isLoading) { return (

Loading your profile...

) } return (

Fitness Quest

Welcome Back, Champion

Complete workouts to gain XP and level up your fitness stats

Your Progress

{profile.workoutsCompleted}

Workouts Completed

Your Stats

Recent Activity

) } [V0_FILE]typescript:file="app/layout.tsx" isEdit="true" isQuickEdit="true" isMerged="true" import type React from "react" import type { Metadata } from "next" import { Geist, Geist_Mono } from "next/font/google" import { Analytics } from "@vercel/analytics/next" import "./globals.css" const _geist = Geist({ subsets: ["latin"] }) const _geistMono = Geist_Mono({ subsets: ["latin"] }) export const metadata: Metadata = { title: "Fitness Quest - Gamified Workout Planner", description: "Level up your fitness with XP and stat progression", generator: "v0.app", icons: { icon: [ { url: "/icon-light-32x32.png", media: "(prefers-color-scheme: light)", }, { url: "/icon-dark-32x32.png", media: "(prefers-color-scheme: dark)", }, { url: "/icon.svg", type: "image/svg+xml", }, ], apple: "/apple-icon.png", }, } export default function RootLayout({ children, }: Readonly<{ children: React.ReactNode }>) { return ( {children} ) } [V0_FILE]typescriptreact:file="components/workout-card.tsx" isMerged="true" "use client" import type { Workout } from "@/lib/game-mechanics" import { Card, CardHeader, CardTitle, CardContent, CardFooter } from "@/components/ui/card" import { Badge } from "@/components/ui/badge" import { Button } from "@/components/ui/button" import { Clock, Zap } from "lucide-react" interface WorkoutCardProps { workout: Workout onSelect: (workout: Workout) => void } const difficultyColors = { beginner: "bg-green-500/10 text-green-500 border-green-500/20", intermediate: "bg-yellow-500/10 text-yellow-500 border-yellow-500/20", advanced: "bg-red-500/10 text-red-500 border-red-500/20", } const focusIcons = { strength: "💪", agility: "⚡", stamina: "❤️", flexibility: "🧘", } export function WorkoutCard({ workout, onSelect }: WorkoutCardProps) { return (

{focusIcons[workout.focusArea]} {workout.name}

{workout.difficulty} {workout.focusArea}

{workout.estimatedDuration} minutes

+{workout.xpReward} XP

Exercises:

• {exercise.name}
• +{workout.exercises.length - 3} more...

) } [V0_FILE]typescriptreact:file="components/level-up-modal.tsx" isMerged="true" "use client" import { useEffect, useState } from "react" import { Card, CardContent } from "@/components/ui/card" import { Button } from "@/components/ui/button" interface LevelUpModalProps { newLevel: number onClose: () => void } export function LevelUpModal({ newLevel, onClose }: LevelUpModalProps) { const [show, setShow] = useState(false) useEffect(() => { setShow(true) }, []) return (

🎉

Level Up!

{newLevel}

You've reached level {newLevel}!

Level Up Bonus:

All stats increased by +1

) } [V0_FILE]typescriptreact:file="app/workouts/page.tsx" isMerged="true" "use client" import { useState } from "react" import { usePlayerProfile } from "@/hooks/use-player-profile" import { presetWorkouts } from "@/lib/workout-data" import { WorkoutCard } from "@/components/workout-card" import { WorkoutSession } from "@/components/workout-session" import { LevelUpModal } from "@/components/level-up-modal" import type { Workout } from "@/lib/game-mechanics" import { Button } from "@/components/ui/button" import { ArrowLeft } from "lucide-react" import Link from "next/link" export default function WorkoutsPage() { const { profile, completeWorkout } = usePlayerProfile() const [activeWorkout, setActiveWorkout] = useState(null) const [levelUpData, setLevelUpData] = useState<{ newLevel: number } | null>(null) const handleStartWorkout = (workout: Workout) => { setActiveWorkout(workout) } const handleCompleteWorkout = () => { if (activeWorkout) { const result = completeWorkout(activeWorkout) if (result.leveledUp && result.newLevel) { setLevelUpData({ newLevel: result.newLevel }) } setActiveWorkout(null) } } const handleCancelWorkout = () => { setActiveWorkout(null) } return (

{!activeWorkout ? ( <>

Choose Your Workout

Complete workouts to earn XP and improve your stats. Currently Level {profile.level}

{presetWorkouts.map((workout) => ( ))}

) : ( )}

{levelUpData && setLevelUpData(null)} />}

) } [V0_FILE]typescriptreact:file="components/stat-detail-card.tsx" isMerged="true" "use client" import type { WorkoutSession } from "@/lib/game-mechanics" import { Card, CardHeader, CardTitle, CardContent } from "@/components/ui/card" import { Progress } from "@/components/ui/progress" interface StatDetailCardProps { statName: string statValue: number icon: string sessions: WorkoutSession[] focusArea: string } export function StatDetailCard({ statName, statValue, icon, sessions, focusArea }: StatDetailCardProps) { const relatedSessions = sessions.filter((s) => s.focusArea === focusArea) const totalXPEarned = relatedSessions.reduce((sum, s) => sum + s.xpEarned, 0) // Calculate rank based on stat value const getRank = (value: number) => { if (value < 20) return { name: "Beginner", progress: (value / 20) * 100 } if (value < 40) return { name: "Novice", progress: ((value - 20) / 20) * 100 } if (value < 60) return { name: "Intermediate", progress: ((value - 40) / 20) * 100 } if (value < 80) return { name: "Advanced", progress: ((value - 60) / 20) * 100 } if (value < 100) return { name: "Expert", progress: ((value - 80) / 20) * 100 } return { name: "Master", progress: 100 } } const rank = getRank(statValue) return (

{icon}

{statName}

{rank.name} Rank

{statValue}

Progress to next rank {Math.round(rank.progress)}%

{relatedSessions.length}

Workouts

{totalXPEarned.toLocaleString()}

XP Earned

) } [V0_FILE]typescriptreact:file="components/achievements-section.tsx" isMerged="true" "use client" import type React from "react" import type { PlayerProfile, WorkoutSession } from "@/lib/game-mechanics" import { Card, CardHeader, CardTitle, CardContent } from "@/components/ui/card" import { Badge } from "@/components/ui/badge" import { Trophy, Zap, Target, Award } from "lucide-react" interface AchievementsSectionProps { profile: PlayerProfile sessions: WorkoutSession[] } interface Achievement { id: string name: string description: string icon: React.ReactNode unlocked: boolean progress?: number requirement?: number } export function AchievementsSection({ profile, sessions }: AchievementsSectionProps) { const achievements: Achievement[] = [ { id: "first-workout", name: "First Steps", description: "Complete your first workout", icon: , unlocked: profile.workoutsCompleted >= 1, }, { id: "level-5", name: "Rising Star", description: "Reach level 5", icon: , unlocked: profile.level >= 5, progress: profile.level, requirement: 5, }, { id: "level-10", name: "Champion", description: "Reach level 10", icon: , unlocked: profile.level >= 10, progress: profile.level, requirement: 10, }, { id: "10-workouts", name: "Dedicated", description: "Complete 10 workouts", icon: , unlocked: profile.workoutsCompleted >= 10, progress: profile.workoutsCompleted, requirement: 10, }, { id: "25-workouts", name: "Committed", description: "Complete 25 workouts", icon: , unlocked: profile.workoutsCompleted >= 25, progress: profile.workoutsCompleted, requirement: 25, }, { id: "50-workouts", name: "Fitness Warrior", description: "Complete 50 workouts", icon: , unlocked: profile.workoutsCompleted >= 50, progress: profile.workoutsCompleted, requirement: 50, }, ] const unlockedCount = achievements.filter((a) => a.unlocked).length return (

Achievements {unlockedCount} / {achievements.length}

{achievements.map((achievement) => (

{achievement.icon}

{achievement.name}

{achievement.unlocked && ( Unlocked )}

{achievement.description}

{!achievement.unlocked && achievement.progress !== undefined && achievement.requirement && (

Progress: {achievement.progress} / {achievement.requirement}

)}

))}

) } [V0_FILE]typescriptreact:file="app/profile/page.tsx" isMerged="true" "use client" import { usePlayerProfile } from "@/hooks/use-player-profile" import { LevelDisplay } from "@/components/level-display" import { StatDetailCard } from "@/components/stat-detail-card" import { AchievementsSection } from "@/components/achievements-section" import { RecentWorkouts } from "@/components/recent-workouts" import { Card, CardHeader, CardTitle, CardContent } from "@/components/ui/card" import { Button } from "@/components/ui/button" import { ArrowLeft, RotateCcw } from "lucide-react" import Link from "next/link" import { useState } from "react" export default function ProfilePage() { const { profile, sessions, resetProfile } = usePlayerProfile() const [showConfirm, setShowConfirm] = useState(false) const handleReset = () => { if (showConfirm) { resetProfile() setShowConfirm(false) } else { setShowConfirm(true) setTimeout(() => setShowConfirm(false), 3000) } } return (

Your Profile

Track your progress and unlock achievements

Level & Experience Overall Stats

{profile.workoutsCompleted}

Total Workouts

{profile.totalXP.toLocaleString()}

Total XP

{sessions.length}

Sessions Logged

{Object.values(profile.stats).reduce((a, b) => a + b, 0)}

Combined Stats

Detailed Stats

Workout History

) } [V0_FILE]typescriptreact:file="components/rest-timer.tsx" isMerged="true" "use client" import { useState, useEffect, useCallback } from "react" import { Card, CardContent } from "@/components/ui/card" import { Button } from "@/components/ui/button" import { Progress } from "@/components/ui/progress" import { Play, Pause, RotateCcw } from "lucide-react" interface RestTimerProps { duration: number onComplete?: () => void } export function RestTimer({ duration, onComplete }: RestTimerProps) { const [timeRemaining, setTimeRemaining] = useState(duration) const [isActive, setIsActive] = useState(false) const [isPaused, setIsPaused] = useState(false) const progress = ((duration - timeRemaining) / duration) * 100 useEffect(() => { let interval: NodeJS.Timeout | null = null if (isActive && !isPaused && timeRemaining > 0) { interval = setInterval(() => { setTimeRemaining((time) => { if (time <= 1) { setIsActive(false) onComplete?.() return 0 } return time - 1 }) }, 1000) } return () => { if (interval) clearInterval(interval) } }, [isActive, isPaused, timeRemaining, onComplete]) const handleStart = useCallback(() => { setIsActive(true) setIsPaused(false) }, []) const handlePause = useCallback(() => { setIsPaused(true) }, []) const handleReset = useCallback(() => { setIsActive(false) setIsPaused(false) setTimeRemaining(duration) }, [duration]) const formatTime = (seconds: number) => { const mins = Math.floor(seconds / 60) const secs = seconds % 60 return `${mins}:${secs.toString().padStart(2, "0")}` } return (

Rest Timer {duration}s total

{formatTime(timeRemaining)}

{!isActive || isPaused ? ( ) : ( )}

) } [V0_FILE]typescript:file="lib/game-mechanics.ts" isEdit="true" isQuickEdit="true" // Core game mechanics and progression system export interface PlayerStats { strength: number agility: number stamina: number flexibility: number } export interface PlayerProfile { level: number currentXP: number totalXP: number stats: PlayerStats workoutsCompleted: number } export interface Workout { id: string name: string exercises: Exercise[] difficulty: "beginner" | "intermediate" | "advanced" focusArea: keyof PlayerStats estimatedDuration: number xpReward: number } export interface Exercise { name: string sets?: number reps?: number duration?: number restTime?: number variations?: string[] } export interface WorkoutSession { id: string workoutId: string workoutName: string completedAt: Date xpEarned: number focusArea: keyof PlayerStats } // XP required for each level (exponential growth) export function getXPRequiredForLevel(level: number): number { return Math.floor(100 * Math.pow(1.5, level - 1)) } // Calculate total XP needed to reach a level export function getTotalXPForLevel(level: number): number { let total = 0 for (let i = 1; i < level; i++) { total += getXPRequiredForLevel(i) } return total } // Calculate level from total XP export function calculateLevel(totalXP: number): number { let level = 1 let xpNeeded = 0 while (xpNeeded <= totalXP) { xpNeeded += getXPRequiredForLevel(level) if (xpNeeded <= totalXP) { level++ } } return level } // Calculate current XP progress within current level export function getCurrentLevelXP(totalXP: number): number { const level = calculateLevel(totalXP) const xpAtLevelStart = getTotalXPForLevel(level) return totalXP - xpAtLevelStart } // Stat increases based on workout focus area export function calculateStatIncrease( currentStats: PlayerStats, focusArea: keyof PlayerStats, level: number, ): PlayerStats { const baseIncrease = 2 const levelBonus = Math.floor(level / 5) const increase = baseIncrease + levelBonus return { ...currentStats, [focusArea]: currentStats[focusArea] + increase, } } // Award XP based on workout difficulty export function calculateWorkoutXP(difficulty: "beginner" | "intermediate" | "advanced", duration: number): number { const baseXP = { beginner: 50, intermediate: 100, advanced: 150, } const durationMultiplier = Math.max(1, duration / 30) return Math.floor(baseXP[difficulty] * durationMultiplier) } // Initial player profile export function createInitialProfile(): PlayerProfile { return { level: 1, currentXP: 0, totalXP: 0, stats: { strength: 10, agility: 10, stamina: 10, flexibility: 10, }, workoutsCompleted: 0, } } // Process workout completion export function processWorkoutCompletion( profile: PlayerProfile, workout: Workout, ): { profile: PlayerProfile; leveledUp: boolean; newLevel?: number } { const xpEarned = workout.xpReward const newTotalXP = profile.totalXP + xpEarned const oldLevel = profile.level const newLevel = calculateLevel(newTotalXP) const leveledUp = newLevel > oldLevel let updatedStats = profile.stats // Increase stat based on workout focus area updatedStats = calculateStatIncrease(updatedStats, workout.focusArea, newLevel) // Additional stat boost on level up if (leveledUp) { Object.keys(updatedStats).forEach((key) => { updatedStats[key as keyof PlayerStats] += 1 }) } const newProfile: PlayerProfile = { level: newLevel, currentXP: getCurrentLevelXP(newTotalXP), totalXP: newTotalXP, stats: updatedStats, workoutsCompleted: profile.workoutsCompleted + 1, } return { profile: newProfile, leveledUp, newLevel: leveledUp ? newLevel : undefined, } } [V0_FILE]typescriptreact:file="components/workout-session.tsx" isEdit="true" "use client" import { useState } from "react" import type { Workout } from "@/lib/game-mechanics" import { Card, CardHeader, CardTitle, CardContent } from "@/components/ui/card" import { Button } from "@/components/ui/button" import { Progress } from "@/components/ui/progress" import { CheckCircle2, Circle, ChevronDown, ChevronUp } from "lucide-react" import { RestTimer } from "@/components/rest-timer" interface WorkoutSessionProps { workout: Workout onComplete: () => void onCancel: () => void } export function WorkoutSession({ workout, onComplete, onCancel }: WorkoutSessionProps) { const [currentExerciseIndex, setCurrentExerciseIndex] = useState(0) const [completedExercises, setCompletedExercises] = useState>(new Set()) const [showRestTimer, setShowRestTimer] = useState(false) const [showVariations, setShowVariations] = useState(false) const currentExercise = workout.exercises[currentExerciseIndex] const progress = (completedExercises.size / workout.exercises.length) * 100 const handleCompleteExercise = () => { const newCompleted = new Set(completedExercises) newCompleted.add(currentExerciseIndex) setCompletedExercises(newCompleted) if (currentExercise.restTime && currentExerciseIndex < workout.exercises.length - 1) { setShowRestTimer(true) } else if (currentExerciseIndex < workout.exercises.length - 1) { setCurrentExerciseIndex(currentExerciseIndex + 1) } } const handleRestComplete = () => { setShowRestTimer(false) setShowVariations(false) if (currentExerciseIndex < workout.exercises.length - 1) { setCurrentExerciseIndex(currentExerciseIndex + 1) } } const handlePrevious = () => { if (currentExerciseIndex > 0) { setShowRestTimer(false) setShowVariations(false) setCurrentExerciseIndex(currentExerciseIndex - 1) } } const handleNext = () => { if (currentExerciseIndex < workout.exercises.length - 1) { setShowRestTimer(false) setShowVariations(false) setCurrentExerciseIndex(currentExerciseIndex + 1) } } const allCompleted = completedExercises.size === workout.exercises.length if (showRestTimer && currentExercise.restTime) { return (

{workout.name}

{completedExercises.size} / {workout.exercises.length} exercises completed {Math.round(progress)}%

Just completed

{currentExercise.name}

Up next

{currentExerciseIndex < workout.exercises.length - 1 ? workout.exercises[currentExerciseIndex + 1].name : "Workout Complete!"}

) } return (

{workout.name}

{completedExercises.size} / {workout.exercises.length} exercises completed {Math.round(progress)}%

Exercise {currentExerciseIndex + 1} of {workout.exercises.length} {completedExercises.has(currentExerciseIndex) ? ( ) : ( )}

{currentExercise.name}

{currentExercise.sets && (

Sets {currentExercise.sets}

)} {currentExercise.reps && (

Reps {currentExercise.reps}

)} {currentExercise.duration && (

Duration {currentExercise.duration >= 60 ? `${Math.floor(currentExercise.duration / 60)}m ${currentExercise.duration % 60}s` : `${currentExercise.duration}s`}

)} {currentExercise.restTime && (

Rest Time {currentExercise.restTime}s

)}

{currentExercise.variations && currentExercise.variations.length > 0 && (

{showVariations && (

{currentExercise.variations.map((variation, idx) => (

{variation}

))}

)}

{!completedExercises.has(currentExerciseIndex) ? ( ) : currentExerciseIndex < workout.exercises.length - 1 ? ( ) : null}

{workout.exercises.map((exercise, idx) => ( ))}

{allCompleted && (

Workout Complete!

You earned +{workout.xpReward} XP

)}

) }

About

Tags

Share

About

Tags

Share

More from jeffmpan

More Templates Like This

About

Tags

Share

About

Tags

Share

More from jeffmpan

More Templates Like This