slashvibe-mcp 0.3.20 → 0.3.21

package/games/snake.js

@@ -0,0 +1,406 @@
+/**
+ * Snake Game implementation for /vibe
+ * Classic arcade action! Control the snake, eat food, grow longer, avoid walls and yourself.
+ * Simple controls, endless fun, and high score tracking.
+ */
+
+// Game configuration
+const BOARD_WIDTH = 15;
+const BOARD_HEIGHT = 12;
+const INITIAL_SNAKE_LENGTH = 3;
+
+// Direction constants
+const DIRECTIONS = {
+  'UP': 'UP',
+  'DOWN': 'DOWN',
+  'LEFT': 'LEFT',
+  'RIGHT': 'RIGHT'
+};
+
+// Opposite directions (to prevent instant death by going backwards)
+const OPPOSITE_DIRECTIONS = {
+  'UP': 'DOWN',
+  'DOWN': 'UP',
+  'LEFT': 'RIGHT',
+  'RIGHT': 'LEFT'
+};
+
+// Visual representation
+const SYMBOLS = {
+  empty: '⬜',
+  snake: '🟩',  // Snake body
+  head: '🟢',   // Snake head (brighter green)
+  food: '🍎',   // Food
+  wall: '⬛'    // Walls (if we add them later)
+};
+
+// Create initial snake game state
+function createInitialSnakeState(playerHandle) {
+  // Start snake in the middle of the board
+  const centerX = Math.floor(BOARD_WIDTH / 2);
+  const centerY = Math.floor(BOARD_HEIGHT / 2);
+  
+  const initialSnake = [];
+  for (let i = 0; i < INITIAL_SNAKE_LENGTH; i++) {
+    initialSnake.push({ x: centerX - i, y: centerY });
+  }
+  
+  return {
+    player: playerHandle,
+    snake: initialSnake,
+    direction: 'RIGHT',
+    food: generateRandomFood(initialSnake),
+    score: 0,
+    gameOver: false,
+    moves: 0,
+    speed: 1, // Game speed level (1-5)
+    createdAt: new Date().toISOString(),
+    lastMove: new Date().toISOString(),
+    highScore: 0, // Track personal best
+    reason: null // Game over reason
+  };
+}
+
+// Generate random food position that doesn't overlap with snake
+function generateRandomFood(snake) {
+  let attempts = 0;
+  const maxAttempts = 100;
+  
+  while (attempts < maxAttempts) {
+    const x = Math.floor(Math.random() * BOARD_WIDTH);
+    const y = Math.floor(Math.random() * BOARD_HEIGHT);
+    
+    // Check if this position is occupied by snake
+    const occupied = snake.some(segment => segment.x === x && segment.y === y);
+    
+    if (!occupied) {
+      return { x, y };
+    }
+    
+    attempts++;
+  }
+  
+  // Fallback if we can't find a spot (board is almost full)
+  for (let y = 0; y < BOARD_HEIGHT; y++) {
+    for (let x = 0; x < BOARD_WIDTH; x++) {
+      const occupied = snake.some(segment => segment.x === x && segment.y === y);
+      if (!occupied) {
+        return { x, y };
+      }
+    }
+  }
+  
+  // If board is completely full (shouldn't happen with our board size)
+  return { x: 0, y: 0 };
+}
+
+// Change snake direction
+function changeDirection(gameState, newDirection, playerHandle) {
+  const { player, direction, gameOver } = gameState;
+  
+  if (playerHandle !== player) {
+    return { error: 'Not your game!' };
+  }
+  
+  if (gameOver) {
+    return { error: 'Game is over! Start a new game to play again.' };
+  }
+  
+  // Validate direction
+  if (!DIRECTIONS[newDirection.toUpperCase()]) {
+    return { error: 'Invalid direction. Use: up, down, left, right' };
+  }
+  
+  const normalizedDirection = newDirection.toUpperCase();
+  
+  // Prevent going in opposite direction (instant death)
+  if (OPPOSITE_DIRECTIONS[direction] === normalizedDirection) {
+    return { error: 'Cannot reverse direction!' };
+  }
+  
+  return {
+    success: true,
+    gameState: {
+      ...gameState,
+      direction: normalizedDirection,
+      lastMove: new Date().toISOString()
+    }
+  };
+}
+
+// Move the snake one step
+function moveSnake(gameState) {
+  const { snake, direction, food, score, moves, speed } = gameState;
+  
+  if (gameState.gameOver) {
+    return { success: true, gameState }; // Already over, no change
+  }
+  
+  // Calculate new head position
+  const head = snake[0];
+  let newX = head.x;
+  let newY = head.y;
+  
+  switch (direction) {
+    case 'UP':
+      newY -= 1;
+      break;
+    case 'DOWN':
+      newY += 1;
+      break;
+    case 'LEFT':
+      newX -= 1;
+      break;
+    case 'RIGHT':
+      newX += 1;
+      break;
+  }
+  
+  // Check wall collision
+  if (newX < 0 || newX >= BOARD_WIDTH || newY < 0 || newY >= BOARD_HEIGHT) {
+    return {
+      success: true,
+      gameState: {
+        ...gameState,
+        gameOver: true,
+        reason: 'Hit the wall!',
+        highScore: Math.max(gameState.highScore || 0, score)
+      }
+    };
+  }
+  
+  // Check self collision
+  const selfCollision = snake.some(segment => segment.x === newX && segment.y === newY);
+  if (selfCollision) {
+    return {
+      success: true,
+      gameState: {
+        ...gameState,
+        gameOver: true,
+        reason: 'Bit yourself!',
+        highScore: Math.max(gameState.highScore || 0, score)
+      }
+    };
+  }
+  
+  // Create new head
+  const newHead = { x: newX, y: newY };
+  const newSnake = [newHead, ...snake];
+  
+  // Check if food was eaten
+  const ateFood = newX === food.x && newY === food.y;
+  
+  let finalSnake;
+  let newScore = score;
+  let newFood = food;
+  let newSpeed = speed;
+  
+  if (ateFood) {
+    // Keep tail (snake grows)
+    finalSnake = newSnake;
+    newScore = score + 10;
+    newFood = generateRandomFood(newSnake);
+    
+    // Increase speed every 50 points (max speed 5)
+    newSpeed = Math.min(5, Math.floor(newScore / 50) + 1);
+  } else {
+    // Remove tail (snake moves)
+    finalSnake = newSnake.slice(0, -1);
+  }
+  
+  return {
+    success: true,
+    gameState: {
+      ...gameState,
+      snake: finalSnake,
+      food: newFood,
+      score: newScore,
+      moves: moves + 1,
+      speed: newSpeed,
+      lastMove: new Date().toISOString(),
+      highScore: Math.max(gameState.highScore || 0, newScore)
+    }
+  };
+}
+
+// Auto-move the snake (for continuous play)
+function autoMove(gameState) {
+  if (gameState.gameOver) {
+    return { success: true, gameState };
+  }
+  
+  return moveSnake(gameState);
+}
+
+// Format snake game for display
+function formatSnakeDisplay(gameState) {
+  const { snake, food, score, gameOver, moves, speed, reason, highScore, player } = gameState;
+  
+  let display = `🐍 **Snake Game** - @${player}\n\n`;
+  
+  if (gameOver) {
+    display += `💀 **Game Over!** ${reason}\n`;
+    display += `**Final Score:** ${score} points\n`;
+    if (highScore > score) {
+      display += `**High Score:** ${highScore} points\n`;
+    } else {
+      display += `🎉 **New High Score!** ${score} points\n`;
+    }
+    display += '\n';
+  } else {
+    display += `**Score:** ${score} | **Speed:** ${speed} | **Length:** ${snake.length}\n`;
+    if (highScore > 0) {
+      display += `**High Score:** ${highScore} points\n`;
+    }
+    display += '\n';
+  }
+  
+  // Draw the game board
+  display += '```\n';
+  
+  // Create empty board
+  const board = Array(BOARD_HEIGHT).fill(null).map(() => Array(BOARD_WIDTH).fill(SYMBOLS.empty));
+  
+  // Place snake body
+  for (let i = 1; i < snake.length; i++) {
+    const segment = snake[i];
+    if (segment.x >= 0 && segment.x < BOARD_WIDTH && segment.y >= 0 && segment.y < BOARD_HEIGHT) {
+      board[segment.y][segment.x] = SYMBOLS.snake;
+    }
+  }
+  
+  // Place snake head (on top of body if needed)
+  const head = snake[0];
+  if (head.x >= 0 && head.x < BOARD_WIDTH && head.y >= 0 && head.y < BOARD_HEIGHT) {
+    board[head.y][head.x] = SYMBOLS.head;
+  }
+  
+  // Place food
+  if (food.x >= 0 && food.x < BOARD_WIDTH && food.y >= 0 && food.y < BOARD_HEIGHT) {
+    board[food.y][food.x] = SYMBOLS.food;
+  }
+
+  // Add border for clarity
+  display += '┌' + '─'.repeat(BOARD_WIDTH * 2) + '┐\n';
+
+  // Draw board rows
+  for (let y = 0; y < BOARD_HEIGHT; y++) {
+    display += '│';
+    for (let x = 0; x < BOARD_WIDTH; x++) {
+      display += board[y][x];
+      if (x < BOARD_WIDTH - 1) display += '';
+    }
+    display += '│\n';
+  }
+
+  display += '└' + '─'.repeat(BOARD_WIDTH * 2) + '┘\n';
+  display += '```\n\n';
+
+  if (!gameOver) {
+    display += '**Controls:**\n';
+    display += '• `w` or `up` - Move up\n';
+    display += '• `s` or `down` - Move down\n';
+    display += '• `a` or `left` - Move left\n';
+    display += '• `d` or `right` - Move right\n\n';
+
+    display += '💡 **Tip:** Eat the 🍎 to grow and score points!\n';
+
+    // Show game stats
+    const totalCells = BOARD_WIDTH * BOARD_HEIGHT;
+    const coverage = Math.round((snake.length / totalCells) * 100);
+    display += `**Board Coverage:** ${coverage}%\n`;
+  } else {
+    display += 'Start a new game to play again! 🎮\n';
+  }
+
+  return display;
+}
+
+// Get game statistics
+function getSnakeStats(gameState) {
+  const { snake, score, moves, speed } = gameState;
+
+  const totalCells = BOARD_WIDTH * BOARD_HEIGHT;
+  const coverage = (snake.length / totalCells) * 100;
+
+  return {
+    score,
+    snakeLength: snake.length,
+    moves,
+    speed,
+    boardCoverage: Math.round(coverage * 100) / 100,
+    efficiency: moves > 0 ? Math.round((score / moves) * 100) / 100 : 0
+  };
+}
+
+// Check if game is won (snake fills entire board - nearly impossible!)
+function checkWin(gameState) {
+  const totalCells = BOARD_WIDTH * BOARD_HEIGHT;
+  return gameState.snake.length >= totalCells - 1; // -1 for food
+}
+
+// Get direction from various input formats
+function parseDirection(input) {
+  const normalized = input.toLowerCase().trim();
+
+  const directionMap = {
+    'w': 'UP',
+    'up': 'UP',
+    'u': 'UP',
+    's': 'DOWN',
+    'down': 'DOWN',
+    'd': 'RIGHT',
+    'a': 'LEFT',
+    'left': 'LEFT',
+    'right': 'RIGHT',
+    'l': 'LEFT',
+    'r': 'RIGHT'
+  };
+
+  return directionMap[normalized] || null;
+}
+
+// Generate tips based on game state
+function getGameTips(gameState) {
+  const { snake, score, moves, speed } = gameState;
+
+  const tips = [];
+
+  if (snake.length < 5) {
+    tips.push('🎯 Focus on eating food to grow your snake!');
+  }
+
+  if (score > 0 && moves > score * 2) {
+    tips.push('⚡ Try to be more efficient - plan your path to the food!');
+  }
+
+  if (speed >= 3) {
+    tips.push('🏃 You\'re getting fast! Be careful with turns.');
+  }
+
+  if (snake.length > 10) {
+    tips.push('🐍 Getting long! Watch out for your own tail.');
+  }
+
+  const coverage = (snake.length / (BOARD_WIDTH * BOARD_HEIGHT)) * 100;
+  if (coverage > 30) {
+    tips.push('📈 Great coverage! Space is getting tight.');
+  }
+
+  return tips;
+}
+
+module.exports = {
+  createInitialSnakeState,
+  changeDirection,
+  moveSnake,
+  autoMove,
+  formatSnakeDisplay,
+  getSnakeStats,
+  checkWin,
+  parseDirection,
+  getGameTips,
+  DIRECTIONS,
+  BOARD_WIDTH,
+  BOARD_HEIGHT
+};