gamercomp/backend/scripts/create-classic-games.js

require('dotenv').config();
const { pool } = require('../src/models/db');
const { generateGame } = require('../src/utils/claude');

const ADMIN_USER_ID = 2; // arcade_master

const classicGames = [
  {
    title: "Snake",
    prompt: `Create a classic Snake game where the player controls a snake that grows longer each time it eats food.

GAMEPLAY MECHANICS:
- The snake moves continuously in the current direction
- Arrow keys (desktop) or swipe gestures (mobile) change direction
- A food item (apple or dot) appears randomly on the screen
- When the snake eats food, it grows by one segment and score increases by 10
- The game ends if the snake hits the wall or its own body
- Snake should start with 3 segments moving to the right
- Speed should gradually increase every 50 points

VISUAL DESIGN:
- Use a grid-based playing field with a subtle grid pattern
- Snake head should be slightly different color than body (dark green head, lighter green body)
- Food should be red and visually distinct (like an apple)
- Display score prominently in the top-left corner
- Show a "Game Over" screen with final score and "Play Again" button

CONTROLS:
- Desktop: Arrow keys for direction
- Mobile: Swipe in any direction to change snake direction
- Prevent 180-degree turns (can't go directly backward)`
  },
  {
    title: "Tetris",
    prompt: `Create a Tetris-style falling block puzzle game.

GAMEPLAY MECHANICS:
- Seven different tetromino shapes (I, O, T, S, Z, J, L) fall from the top
- Player can move pieces left/right and rotate them
- Pieces fall automatically at a steady pace
- When a horizontal line is completely filled, it clears and awards points
- Clearing multiple lines at once awards bonus points (1 line=100, 2=300, 3=500, 4=800)
- Game ends when pieces stack to the top
- Show the next piece that will appear

VISUAL DESIGN:
- 10 columns wide, 20 rows tall playing field
- Each tetromino type has a distinct bright color
- Ghost piece shows where current piece will land
- Clear lines with a satisfying flash animation
- Display score, level, and lines cleared
- Level increases every 10 lines, increasing fall speed

CONTROLS:
- Left/Right arrows or A/D: Move piece horizontally
- Up arrow or W: Rotate piece clockwise
- Down arrow or S: Soft drop (faster fall)
- Space: Hard drop (instant drop)
- Mobile: On-screen buttons for all actions`
  },
  {
    title: "Pong",
    prompt: `Create a classic Pong game - the original video game tennis.

GAMEPLAY MECHANICS:
- Two paddles on opposite sides of the screen (left and right)
- A ball bounces between them
- Players score when the ball passes the opponent's paddle
- Ball speed increases slightly after each paddle hit
- Ball angle changes based on where it hits the paddle (edges = sharper angles)
- First player to 11 points wins
- Ball resets to center after each point, launching toward the player who was scored on

VISUAL DESIGN:
- Black background with white elements (classic arcade look)
- Dotted line down the center of the screen
- Paddles are simple white rectangles
- Ball is a small white square
- Large score display at top for both players
- "Player 1 Wins!" or "Player 2 Wins!" message at game end

CONTROLS:
- Player 1 (left): W/S keys to move up/down
- Player 2 (right): Up/Down arrow keys
- Mobile: Touch left side to control left paddle, right side for right paddle
- Alternatively, make Player 2 a simple AI opponent`
  },
  {
    title: "Breakout",
    prompt: `Create a Breakout/Brick Breaker arcade game.

GAMEPLAY MECHANICS:
- Rows of colored bricks at the top of the screen
- Player controls a paddle at the bottom
- Ball bounces around, breaking bricks on contact
- Different colored bricks may take multiple hits (green=1, yellow=2, orange=3, red=4)
- Some bricks drop power-ups: wider paddle, multi-ball, slow ball
- Player has 3 lives, loses one if ball falls below paddle
- Level complete when all bricks are destroyed
- Ball angle changes based on where it hits the paddle

VISUAL DESIGN:
- Colorful brick arrangement (rainbow pattern from top to bottom)
- Bricks should visibly crack or change color when damaged
- Particle effects when bricks break
- Paddle has a metallic/shiny appearance
- Display score at top, lives as small ball icons
- Power-ups are falling capsules with distinct colors

CONTROLS:
- Mouse movement or Left/Right arrows move the paddle
- Click or Space to launch the ball from paddle at game start
- Mobile: Touch and drag to move paddle`
  },
  {
    title: "Space Invaders",
    prompt: `Create the classic Space Invaders alien shooting game.

GAMEPLAY MECHANICS:
- Grid of alien invaders (5 rows of 11) march left and right, dropping down each time they hit an edge
- Player ship at bottom can move left/right and shoot upward
- Aliens occasionally drop bombs downward
- Player has 3 lives, loses one if hit by bomb
- Killing aliens awards points (bottom row=10, increasing by 10 per row up)
- Mystery UFO occasionally flies across the top (bonus 50-300 points)
- Aliens speed up as fewer remain
- Game over if aliens reach the bottom

VISUAL DESIGN:
- Classic pixel-art style aliens (3 different designs for variety)
- Aliens animate between 2 frames as they move
- Green player ship with white bullets
- Four destructible shields/bunkers that erode when hit
- Black space background with stars
- Score and high score at top, lives shown as ship icons

CONTROLS:
- Left/Right arrows or A/D to move ship
- Space bar to shoot (limit: one bullet on screen at a time for authenticity, or allow 3)
- Mobile: Touch left/right sides to move, tap center to shoot`
  },
  {
    title: "Pac-Man",
    prompt: `Create a Pac-Man style maze chase game.

GAMEPLAY MECHANICS:
- Player controls Pac-Man through a maze eating dots
- Four ghosts chase Pac-Man with different behaviors
- Small dots = 10 points, large power pellets = 50 points
- Power pellets make ghosts vulnerable (blue) for 8 seconds - eating them = 200, 400, 800, 1600 points
- Player has 3 lives, loses one if touched by a non-vulnerable ghost
- Level complete when all dots are eaten
- Tunnels on sides wrap around to opposite side
- Ghosts get faster with each level

VISUAL DESIGN:
- Classic maze layout with blue walls
- Pac-Man is yellow circle with animated chomping mouth
- Four colorful ghosts: red (Blinky), pink (Pinky), cyan (Inky), orange (Clyde)
- Ghosts have cute eyes that look in their direction of travel
- Dots are small, power pellets are large and flashing
- Display score, high score, and lives

CONTROLS:
- Arrow keys for direction (Pac-Man turns at next intersection)
- Mobile: Swipe in direction to turn
- Pac-Man continues moving in current direction until wall`
  },
  {
    title: "Flappy Bird",
    prompt: `Create a Flappy Bird-style endless flying game.

GAMEPLAY MECHANICS:
- Bird automatically falls due to gravity
- Tapping/clicking makes the bird flap and rise
- Pipes (or obstacles) scroll from right to left with gaps to fly through
- Each pipe passed = 1 point
- Game over if bird hits pipe or ground/ceiling
- Pipe gap size stays constant, but spacing between pipes can vary
- Bird rotates based on velocity (nose up when rising, nose down when falling)
- High score is saved and displayed

VISUAL DESIGN:
- Cute, simple bird with flapping wing animation
- Colorful green pipes coming from top and bottom
- Scrolling background with clouds and simple scenery
- Ground at bottom with scrolling texture
- Large score display in center-top during play
- Game over screen shows score vs best score with "Tap to Retry"

CONTROLS:
- Spacebar, click, or tap anywhere to flap
- That's it - one-button gameplay!
- Bird should feel floaty with satisfying physics`
  },
  {
    title: "2048",
    prompt: `Create the 2048 sliding number puzzle game.

GAMEPLAY MECHANICS:
- 4x4 grid of tiles
- Tiles contain powers of 2 (2, 4, 8, 16... up to 2048+)
- Swiping/arrow key slides ALL tiles in that direction
- When two tiles with same number collide, they merge into their sum
- After each move, a new tile (2 or 4) appears in a random empty spot
- Goal: Create a 2048 tile (though game continues after)
- Game over when no more moves are possible
- Score increases by the value of each merged tile

VISUAL DESIGN:
- Clean, modern design with rounded tile corners
- Each number has a distinct background color (2=light, higher=darker/warmer)
- Smooth sliding and merging animations
- Tiles should pop/scale when they appear and merge
- Display current score and best score
- Large, clear numbers on tiles
- "You Win!" celebration when reaching 2048, with option to continue

CONTROLS:
- Arrow keys to slide all tiles in a direction
- Mobile: Swipe gestures in any direction
- Consider adding "Undo" button for last move`
  },
  {
    title: "Minesweeper",
    prompt: `Create the classic Minesweeper puzzle game.

GAMEPLAY MECHANICS:
- Grid of covered cells (start with 10x10 with 15 mines for beginner)
- Left-click reveals a cell
- Numbers show how many adjacent cells (including diagonals) contain mines
- Empty cells auto-reveal adjacent empty cells (flood fill)
- Right-click places a flag to mark suspected mines
- First click is always safe (never a mine)
- Win by revealing all non-mine cells
- Lose by clicking a mine (reveal all mines, show X on wrong flags)
- Timer starts on first click

VISUAL DESIGN:
- Clean grid with beveled 3D-style unrevealed cells
- Revealed cells are flat with clear numbers
- Numbers colored by value (1=blue, 2=green, 3=red, etc.)
- Mines shown as black circles/bombs when revealed
- Flags are red
- Smiley face button to restart (changes expression: smile, surprised on click, dead on loss, cool on win)
- Display mine count remaining and timer

CONTROLS:
- Left-click to reveal cell
- Right-click to toggle flag
- Mobile: Tap to reveal, long-press to flag
- Include toggle button for flag mode on mobile`
  },
  {
    title: "Asteroids",
    prompt: `Create the classic Asteroids space shooter game.

GAMEPLAY MECHANICS:
- Player ship in center of screen can rotate and thrust
- Ship wraps around screen edges (appears on opposite side)
- Shoot bullets to destroy asteroids
- Large asteroids split into 2 medium, medium split into 2 small
- Points: Large=20, Medium=50, Small=100
- Player has 3 lives, loses one if hit by asteroid
- Ship has brief invincibility after respawning
- UFOs occasionally appear and shoot at player (Small=1000pts, Large=200pts)
- Hyperspace: random teleport as escape (risky - might teleport into asteroid)

VISUAL DESIGN:
- Vector graphics style (white lines on black background)
- Ship is a simple triangle that rotates smoothly
- Asteroids are irregular polygons that rotate as they drift
- Bullets are small dots/lines
- Thrust shows small particles behind ship
- Ship explosion is satisfying particle burst
- Display score and lives (ship icons)

CONTROLS:
- Left/Right arrows or A/D to rotate ship
- Up arrow or W to thrust forward
- Space to shoot
- Shift or X for hyperspace
- Mobile: On-screen joystick for rotation/thrust, fire button`
  },
  {
    title: "Frogger",
    prompt: `Create a Frogger-style road and river crossing game.

GAMEPLAY MECHANICS:
- Frog starts at bottom, must reach one of 5 home bases at top
- Bottom half: Cross road with cars/trucks moving at different speeds
- Top half: Cross river by jumping on logs and turtles
- Falling in water or getting hit by vehicle = lose a life
- Turtles occasionally submerge (warning animation first)
- Bonus items appear on logs (flies for points, female frog for bonus)
- Time limit per frog (30 seconds) - bonus points for time remaining
- Fill all 5 home bases to complete level
- Each level, traffic and logs move faster

VISUAL DESIGN:
- Colorful top-down view
- Cute pixel-art frog that faces direction of last move
- Road section: gray with lane markings, colorful vehicles
- River section: blue water, brown logs, green turtles
- Safe zones: green grass/lily pads
- Home bases at top with flowers when empty, frog when filled
- Display score, time bar, and lives

CONTROLS:
- Arrow keys for hopping in four directions
- Each press = one hop (grid-based movement)
- Mobile: Swipe in direction to hop, or on-screen d-pad`
  },
  {
    title: "Simon Says",
    prompt: `Create a Simon Says memory pattern game.

GAMEPLAY MECHANICS:
- Four colored buttons arranged in quadrants (red, blue, green, yellow)
- Computer plays a sequence by lighting up buttons with sounds
- Player must repeat the sequence by clicking buttons in same order
- Sequence grows by one each successful round
- Wrong button = game over, show final score (rounds completed)
- Speed increases gradually as sequence gets longer
- Each color has a distinct tone/sound
- High score is saved and displayed

VISUAL DESIGN:
- Large circular or rounded square device
- Four bright colored quadrants that light up when active (glow effect)
- Center shows current round number
- Buttons dim when inactive, bright when pressed/shown
- "Simon Says" title at top
- Satisfying button press animations (press down effect)
- Game over screen with score and "Play Again"
- Consider a "strict mode" toggle (one mistake = restart from beginning vs. one mistake = retry same sequence)

CONTROLS:
- Click/tap on colored buttons to repeat sequence
- Each button should have hover effect on desktop
- Consider keyboard shortcuts (1,2,3,4 or Q,W,A,S for the four colors)
- "Start" button to begin new game`
  }
];

async function createGame(gameData, index) {
  console.log(`\n[${index + 1}/12] Generating: ${gameData.title}...`);

  try {
    const result = await generateGame(gameData.prompt);

    if (!result.success) {
      console.error(`  Failed to generate ${gameData.title}: ${result.error}`);
      return null;
    }

    // Insert into database with prompt
    const dbResult = await pool.query(
      `INSERT INTO games (creator_id, title, description, game_code, prompt, status, published_at)
       VALUES ($1, $2, $3, $4, $5, 'published', NOW())
       RETURNING id`,
      [
        ADMIN_USER_ID,
        gameData.title,
        gameData.prompt.split('\n\n')[0], // Use first paragraph as description
        result.code,
        gameData.prompt
      ]
    );

    console.log(`  Created: ${gameData.title} (ID: ${dbResult.rows[0].id})`);
    return dbResult.rows[0].id;
  } catch (error) {
    console.error(`  Error creating ${gameData.title}:`, error.message);
    return null;
  }
}

async function main() {
  console.log('Creating 12 classic games with detailed prompts...\n');
  console.log('Using Claude Sonnet 4 for high-quality game generation.');
  console.log('This will take several minutes...\n');

  const createdGames = [];

  for (let i = 0; i < classicGames.length; i++) {
    const gameId = await createGame(classicGames[i], i);
    if (gameId) {
      createdGames.push({ title: classicGames[i].title, id: gameId });
    }

    // Small delay between API calls
    if (i < classicGames.length - 1) {
      await new Promise(resolve => setTimeout(resolve, 2000));
    }
  }

  console.log('\n========================================');
  console.log('SUMMARY');
  console.log('========================================');
  console.log(`Successfully created: ${createdGames.length}/12 games\n`);

  createdGames.forEach(g => {
    console.log(`  - ${g.title} (ID: ${g.id})`);
  });

  await pool.end();
  process.exit(0);
}

main().catch(err => {
  console.error('Fatal error:', err);
  process.exit(1);
});