slashvibe-mcp 0.3.21 → 0.3.22

package/games/drawing.js

@@ -1,347 +0,0 @@
-/**
- * Collaborative Drawing game implementation for /vibe
- * A shared canvas where multiple users can draw together in real-time
- * Create art, doodles, or play drawing games like Pictionary!
- */
-
-// Drawing canvas dimensions (character-based art)
-const CANVAS_WIDTH = 20;
-const CANVAS_HEIGHT = 12;
-
-// Drawing tools and colors (using Unicode characters)
-const DRAWING_CHARS = {
-  empty: '⬜', // Empty space
-  dot: '⚫', // Small dot
-  circle: '⚪', // Circle 
-  square: '⬛', // Filled square
-  star: '⭐', // Star
-  heart: '❤️', // Heart
-  tree: '🌲', // Tree
-  house: '🏠', // House
-  sun: '☀️', // Sun
-  moon: '🌙', // Moon
-  water: '🌊', // Wave
-  mountain: '⛰️', // Mountain
-  person: '🧍', // Person
-  cat: '🐱', // Cat
-  dog: '🐕', // Dog
-  car: '🚗', // Car
-  plane: '✈️', // Plane
-  flower: '🌸', // Flower
-  umbrella: '☂️', // Umbrella
-  rainbow: '🌈' // Rainbow
-};
-
-// Create initial drawing game state
-function createInitialDrawingState() {
-  // Initialize empty canvas
-  const canvas = Array(CANVAS_HEIGHT).fill(null).map(() => 
-    Array(CANVAS_WIDTH).fill(DRAWING_CHARS.empty)
-  );
-
-  return {
-    canvas: canvas,
-    players: [],
-    moves: [],
-    maxPlayers: 8,
-    gameOver: false,
-    createdAt: new Date().toISOString(),
-    lastActivity: new Date().toISOString(),
-    theme: null, // Optional drawing theme/prompt
-    mode: 'freeform' // 'freeform', 'pictionary', 'collaborative'
-  };
-}
-
-// Add player to drawing session
-function addPlayer(gameState, playerHandle) {
-  if (gameState.players.includes(playerHandle)) {
-    return { error: 'Player already in the drawing session' };
-  }
-
-  if (gameState.players.length >= gameState.maxPlayers) {
-    return { error: `Drawing session is full (max ${gameState.maxPlayers} players)` };
-  }
-
-  const newPlayers = [...gameState.players, playerHandle];
-  
-  return {
-    success: true,
-    gameState: {
-      ...gameState,
-      players: newPlayers,
-      lastActivity: new Date().toISOString()
-    }
-  };
-}
-
-// Make a drawing move (place character at position)
-function makeMove(gameState, x, y, char, playerHandle) {
-  const { canvas, players, moves } = gameState;
-  
-  // Validate player
-  if (!players.includes(playerHandle)) {
-    return { error: 'You need to join the drawing session first!' };
-  }
-  
-  // Validate position
-  if (x < 0 || x >= CANVAS_WIDTH || y < 0 || y >= CANVAS_HEIGHT) {
-    return { error: `Position out of bounds. Canvas is ${CANVAS_WIDTH}x${CANVAS_HEIGHT}` };
-  }
-  
-  // Validate character
-  const validChars = Object.values(DRAWING_CHARS);
-  if (!validChars.includes(char)) {
-    return { error: `Invalid character. Use one of: ${Object.keys(DRAWING_CHARS).join(', ')}` };
-  }
-  
-  // Update canvas
-  const newCanvas = canvas.map(row => [...row]);
-  newCanvas[y][x] = char;
-  
-  // Record the move
-  const move = {
-    x, y, char, 
-    player: playerHandle,
-    timestamp: new Date().toISOString(),
-    moveNumber: moves.length + 1
-  };
-  
-  const newMoves = [...moves, move];
-  
-  const newGameState = {
-    ...gameState,
-    canvas: newCanvas,
-    moves: newMoves,
-    lastActivity: new Date().toISOString()
-  };
-  
-  return { success: true, gameState: newGameState };
-}
-
-// Draw a line between two points (simple Bresenham-like algorithm)
-function drawLine(gameState, x0, y0, x1, y1, char, playerHandle) {
-  const moves = [];
-  
-  // Simple line drawing - just plot points between start and end
-  const dx = Math.abs(x1 - x0);
-  const dy = Math.abs(y1 - y0);
-  const steps = Math.max(dx, dy);
-  
-  if (steps === 0) {
-    // Single point
-    const result = makeMove(gameState, x0, y0, char, playerHandle);
-    return result;
-  }
-  
-  const xInc = (x1 - x0) / steps;
-  const yInc = (y1 - y0) / steps;
-  
-  let currentGameState = gameState;
-  
-  for (let i = 0; i <= steps; i++) {
-    const x = Math.round(x0 + i * xInc);
-    const y = Math.round(y0 + i * yInc);
-    
-    const result = makeMove(currentGameState, x, y, char, playerHandle);
-    if (result.error) {
-      // Stop on first error but return what we accomplished
-      break;
-    }
-    currentGameState = result.gameState;
-  }
-  
-  return { success: true, gameState: currentGameState };
-}
-
-// Clear a region of the canvas
-function clearRegion(gameState, x0, y0, x1, y1, playerHandle) {
-  const { players } = gameState;
-  
-  if (!players.includes(playerHandle)) {
-    return { error: 'You need to join the drawing session first!' };
-  }
-  
-  // Ensure coordinates are in bounds and properly ordered
-  const minX = Math.max(0, Math.min(x0, x1));
-  const maxX = Math.min(CANVAS_WIDTH - 1, Math.max(x0, x1));
-  const minY = Math.max(0, Math.min(y0, y1));
-  const maxY = Math.min(CANVAS_HEIGHT - 1, Math.max(y0, y1));
-  
-  const newCanvas = gameState.canvas.map(row => [...row]);
-  
-  for (let y = minY; y <= maxY; y++) {
-    for (let x = minX; x <= maxX; x++) {
-      newCanvas[y][x] = DRAWING_CHARS.empty;
-    }
-  }
-  
-  const clearMove = {
-    action: 'clear',
-    x0: minX, y0: minY, x1: maxX, y1: maxY,
-    player: playerHandle,
-    timestamp: new Date().toISOString(),
-    moveNumber: gameState.moves.length + 1
-  };
-  
-  return {
-    success: true,
-    gameState: {
-      ...gameState,
-      canvas: newCanvas,
-      moves: [...gameState.moves, clearMove],
-      lastActivity: new Date().toISOString()
-    }
-  };
-}
-
-// Format drawing canvas for display
-function formatDrawingDisplay(gameState) {
-  const { canvas, players, moves, theme, mode } = gameState;
-  
-  let display = `🎨 **Collaborative Drawing** (${players.length} artist${players.length !== 1 ? 's' : ''})\n\n`;
-  
-  // Show theme if set
-  if (theme) {
-    display += `🎯 **Theme:** ${theme}\n\n`;
-  }
-  
-  // Show canvas with coordinate labels
-  display += '```\n';
-  
-  // Top coordinate labels
-  let topLabels = '   ';
-  for (let x = 0; x < CANVAS_WIDTH; x++) {
-    if (x < 10) {
-      topLabels += x + ' ';
-    } else {
-      topLabels += String.fromCharCode(55 + x); // A, B, C... for 10+
-    }
-  }
-  display += topLabels + '\n';
-  
-  // Canvas rows with left coordinate labels
-  for (let y = 0; y < CANVAS_HEIGHT; y++) {
-    let row = (y < 10 ? ' ' + y : String.fromCharCode(55 + y)) + ' ';
-    row += canvas[y].join('');
-    display += row + '\n';
-  }
-  
-  display += '```\n\n';
-  
-  // Show players
-  if (players.length > 0) {
-    display += `**Artists:** ${players.map(p => `@${p}`).join(', ')}\n\n`;
-  }
-  
-  // Show recent activity
-  if (moves.length > 0) {
-    const recentMoves = moves.slice(-3); // Last 3 moves
-    display += '**Recent activity:**\n';
-    for (const move of recentMoves) {
-      if (move.action === 'clear') {
-        display += `• @${move.player} cleared region (${move.x0},${move.y0}) to (${move.x1},${move.y1})\n`;
-      } else {
-        display += `• @${move.player} drew ${move.char} at (${move.x},${move.y})\n`;
-      }
-    }
-    display += '\n';
-  }
-  
-  // Show available characters
-  display += '**Available characters:**\n';
-  const charEntries = Object.entries(DRAWING_CHARS);
-  const charGroups = [];
-  for (let i = 0; i < charEntries.length; i += 5) {
-    const group = charEntries.slice(i, i + 5);
-    charGroups.push(group.map(([name, char]) => `${char} (${name})`).join(' '));
-  }
-  display += charGroups.join('\n') + '\n\n';
-  
-  return display;
-}
-
-// Set drawing theme/prompt
-function setTheme(gameState, theme, playerHandle) {
-  const { players } = gameState;
-  
-  if (!players.includes(playerHandle)) {
-    return { error: 'You need to join the drawing session first!' };
-  }
-  
-  return {
-    success: true,
-    gameState: {
-      ...gameState,
-      theme: theme,
-      lastActivity: new Date().toISOString()
-    }
-  };
-}
-
-// Generate drawing tips based on theme
-function getDrawingTips(theme) {
-  const tips = {
-    'house': ['Start with a ⬛ base', 'Add a roof with ⛰️', 'Use 🏠 for details'],
-    'landscape': ['Use 🌲 for trees', '☀️ for sun', '🌊 for water', '⛰️ for mountains'],
-    'portrait': ['Use 🧍 for people', '⚪⚫ for eyes', '❤️ for heart'],
-    'animals': ['Try 🐱🐕 for pets', '🌲 for habitat', '⭐ for magical touches'],
-    'vehicle': ['🚗 for cars', '✈️ for planes', '⬛ for roads'],
-    'nature': ['🌸 for flowers', '🌲 for trees', '☀️🌙 for sky', '🌈 for color']
-  };
-  
-  const defaultTips = ['Use ⬛⬜ for shapes', 'Add ⭐❤️ for details', 'Try 🌸🌲 for nature'];
-  
-  return tips[theme?.toLowerCase()] || defaultTips;
-}
-
-// Get canvas statistics
-function getCanvasStats(gameState) {
-  const { canvas, moves, players } = gameState;
-  
-  // Count characters used
-  const charCount = {};
-  for (const row of canvas) {
-    for (const char of row) {
-      if (char !== DRAWING_CHARS.empty) {
-        charCount[char] = (charCount[char] || 0) + 1;
-      }
-    }
-  }
-  
-  // Count moves per player
-  const playerMoves = {};
-  for (const move of moves) {
-    if (move.player) {
-      playerMoves[move.player] = (playerMoves[move.player] || 0) + 1;
-    }
-  }
-  
-  const totalDrawnCells = Object.values(charCount).reduce((a, b) => a + b, 0);
-  const totalCells = CANVAS_WIDTH * CANVAS_HEIGHT;
-  const fillPercentage = Math.round((totalDrawnCells / totalCells) * 100);
-  
-  return {
-    totalMoves: moves.length,
-    totalDrawnCells,
-    fillPercentage,
-    uniqueCharsUsed: Object.keys(charCount).length,
-    charCount,
-    playerMoves,
-    mostUsedChar: Object.entries(charCount).sort(([,a], [,b]) => b - a)[0]
-  };
-}
-
-module.exports = {
-  createInitialDrawingState,
-  addPlayer,
-  makeMove,
-  drawLine,
-  clearRegion,
-  formatDrawingDisplay,
-  setTheme,
-  getDrawingTips,
-  getCanvasStats,
-  DRAWING_CHARS,
-  CANVAS_WIDTH,
-  CANVAS_HEIGHT
-};

package/games/gameroulette.js

@@ -1,300 +0,0 @@
-/**
- * Game Roulette - Discover random games from the /vibe workshop
- * Perfect for when you want to play something but don't know what!
- */
-
-const arcade = require('./arcade');
-
-// Game difficulty weights for smart recommendations
-const DIFFICULTY_WEIGHTS = {
-  'Easy': 0.4,
-  'Medium': 0.4, 
-  'Hard': 0.2
-};
-
-// Player count weights for recommendations
-const PLAYER_WEIGHTS = {
-  'Solo': 0.3,
-  '1v1': 0.4,
-  '1v2': 0.1,
-  'Multiplayer': 0.2
-};
-
-// Create initial game roulette state
-function createInitialGameRouletteState() {
-  return {
-    lastRecommendation: null,
-    userPreferences: {},
-    playHistory: [],
-    sessionStarted: new Date().toISOString(),
-    totalRecommendations: 0
-  };
-}
-
-// Get a random game recommendation
-function getRandomGame(gameState, userHandle = null, preferences = {}) {
-  const { GAMES } = arcade;
-  const gameIds = Object.keys(GAMES);
-  
-  // Apply preferences if provided
-  let filteredGames = gameIds;
-  
-  if (preferences.difficulty) {
-    filteredGames = filteredGames.filter(id => 
-      GAMES[id].difficulty.toLowerCase() === preferences.difficulty.toLowerCase()
-    );
-  }
-  
-  if (preferences.category) {
-    filteredGames = filteredGames.filter(id => 
-      GAMES[id].category === preferences.category
-    );
-  }
-  
-  if (preferences.players) {
-    filteredGames = filteredGames.filter(id => 
-      GAMES[id].players === preferences.players
-    );
-  }
-  
-  // Avoid recommending the same game twice in a row
-  if (gameState.lastRecommendation && filteredGames.length > 1) {
-    filteredGames = filteredGames.filter(id => id !== gameState.lastRecommendation.id);
-  }
-  
-  if (filteredGames.length === 0) {
-    return { error: 'No games match your preferences!' };
-  }
-  
-  // Pick random game
-  const randomId = filteredGames[Math.floor(Math.random() * filteredGames.length)];
-  const game = { id: randomId, ...GAMES[randomId] };
-  
-  // Update game state
-  const newGameState = {
-    ...gameState,
-    lastRecommendation: game,
-    totalRecommendations: gameState.totalRecommendations + 1,
-    playHistory: [...gameState.playHistory.slice(-9), game] // Keep last 10
-  };
-  
-  if (userHandle) {
-    // Track user preferences
-    newGameState.userPreferences[userHandle] = {
-      ...gameState.userPreferences[userHandle],
-      lastSeen: new Date().toISOString(),
-      totalRequests: (gameState.userPreferences[userHandle]?.totalRequests || 0) + 1
-    };
-  }
-  
-  return { success: true, gameState: newGameState, recommendation: game };
-}
-
-// Get smart recommendation based on user history
-function getSmartRecommendation(gameState, userHandle, mood = null) {
-  const { GAMES, CATEGORIES } = arcade;
-  
-  // Mood-based filtering
-  const moodCategories = {
-    'chill': ['word', 'puzzle'],
-    'competitive': ['classic', 'action'], 
-    'social': ['social', 'creative'],
-    'quick': ['classic', 'action'],
-    'thoughtful': ['puzzle', 'word'],
-    'creative': ['creative', 'social']
-  };
-  
-  const preferences = {};
-  if (mood && moodCategories[mood]) {
-    preferences.categoryList = moodCategories[mood];
-  }
-  
-  return getRecommendationWithFilters(gameState, userHandle, preferences);
-}
-
-// Get recommendation with advanced filters
-function getRecommendationWithFilters(gameState, userHandle, filters = {}) {
-  const { GAMES } = arcade;
-  let candidateGames = Object.keys(GAMES);
-  
-  // Apply category list filter
-  if (filters.categoryList) {
-    candidateGames = candidateGames.filter(id => 
-      filters.categoryList.includes(GAMES[id].category)
-    );
-  }
-  
-  // Apply other filters
-  if (filters.difficulty) {
-    candidateGames = candidateGames.filter(id => 
-      GAMES[id].difficulty.toLowerCase() === filters.difficulty.toLowerCase()
-    );
-  }
-  
-  if (filters.maxPlayers && filters.maxPlayers < 4) {
-    candidateGames = candidateGames.filter(id => 
-      GAMES[id].players === 'Solo' || GAMES[id].players === '1v1'
-    );
-  }
-  
-  // Weighted random selection
-  if (candidateGames.length > 1) {
-    const weights = candidateGames.map(id => {
-      const game = GAMES[id];
-      let weight = 1.0;
-      
-      // Prefer easier games slightly
-      if (game.difficulty === 'Easy') weight *= 1.2;
-      else if (game.difficulty === 'Hard') weight *= 0.8;
-      
-      // Prefer variety - reduce weight if recently recommended
-      const recentHistory = gameState.playHistory.slice(-3);
-      if (recentHistory.some(h => h.id === id)) {
-        weight *= 0.3;
-      }
-      
-      return weight;
-    });
-    
-    // Weighted random selection
-    const totalWeight = weights.reduce((a, b) => a + b, 0);
-    let random = Math.random() * totalWeight;
-    
-    for (let i = 0; i < candidateGames.length; i++) {
-      random -= weights[i];
-      if (random <= 0) {
-        const gameId = candidateGames[i];
-        const game = { id: gameId, ...GAMES[gameId] };
-        
-        const newGameState = {
-          ...gameState,
-          lastRecommendation: game,
-          totalRecommendations: gameState.totalRecommendations + 1,
-          playHistory: [...gameState.playHistory.slice(-9), game]
-        };
-        
-        return { success: true, gameState: newGameState, recommendation: game };
-      }
-    }
-  }
-  
-  // Fallback to simple random
-  return getRandomGame(gameState, userHandle, filters);
-}
-
-// Get games by current "vibe"
-function getGamesByVibe(vibe) {
-  const { GAMES } = arcade;
-  const vibes = {
-    'competitive': ['chess', 'tictactoe', 'multiplayer-tictactoe', 'quickduel', 'rockpaperscissors'],
-    'social': ['storybuilder', 'drawing', 'twotruths', 'werewolf', 'wordassociation'],
-    'solo': ['snake', 'memory', 'hangman', 'riddle', 'guessnumber', 'colorguess'],
-    'quick': ['rockpaperscissors', 'guessnumber', 'colorguess', 'quickduel'],
-    'creative': ['drawing', 'storybuilder'],
-    'thinking': ['chess', 'riddle', 'twentyquestions', 'hangman'],
-    'party': ['werewolf', 'twotruths', 'wordassociation', 'drawing']
-  };
-  
-  const gameIds = vibes[vibe.toLowerCase()] || [];
-  return gameIds.map(id => ({ id, ...GAMES[id] })).filter(g => g.name);
-}
-
-// Format roulette display
-function formatRouletteDisplay(gameState, recommendation, userHandle = null) {
-  if (!recommendation) {
-    return 'Game Roulette ready! Spin the wheel to discover your next game!';
-  }
-  
-  const { icon, name, description, category, players, difficulty } = recommendation;
-  
-  let display = `🎲 **GAME ROULETTE** 🎲\n\n`;
-  display += `${icon} **${name}**\n\n`;
-  display += `**Description:** ${description}\n`;
-  display += `**Category:** ${category.charAt(0).toUpperCase() + category.slice(1)}\n`;
-  display += `**Players:** ${players}\n`;
-  display += `**Difficulty:** ${difficulty}\n\n`;
-  
-  // Add contextual launch instructions
-  if (['tictactoe', 'chess'].includes(recommendation.id)) {
-    display += `**How to play:** \`vibe game @username\` to challenge someone!\n`;
-  } else if (recommendation.id === 'drawing') {
-    display += `**How to play:** Join the collaborative canvas and start drawing!\n`;
-  } else if (recommendation.id === 'arcade') {
-    display += `**How to play:** Browse all games in the Workshop Arcade!\n`;
-  } else {
-    display += `**How to play:** Launch ${name} and dive in!\n`;
-  }
-  
-  display += `\n🎯 **Feeling lucky?** Spin again for another recommendation!`;
-  
-  if (gameState.totalRecommendations > 1) {
-    display += `\n\n*This is recommendation #${gameState.totalRecommendations} in your session*`;
-  }
-  
-  return display;
-}
-
-// Get roulette statistics
-function getRouletteStats(gameState) {
-  const { playHistory, totalRecommendations } = gameState;
-  
-  if (playHistory.length === 0) {
-    return null;
-  }
-  
-  // Category distribution
-  const categoryCount = {};
-  const difficultyCount = {};
-  const playerCount = {};
-  
-  for (const game of playHistory) {
-    categoryCount[game.category] = (categoryCount[game.category] || 0) + 1;
-    difficultyCount[game.difficulty] = (difficultyCount[game.difficulty] || 0) + 1;
-    playerCount[game.players] = (playerCount[game.players] || 0) + 1;
-  }
-  
-  const mostRecommendedCategory = Object.entries(categoryCount)
-    .sort(([,a], [,b]) => b - a)[0];
-    
-  const mostRecommendedDifficulty = Object.entries(difficultyCount)
-    .sort(([,a], [,b]) => b - a)[0];
-  
-  return {
-    totalRecommendations,
-    sessionGames: playHistory.length,
-    favoriteCategory: mostRecommendedCategory ? mostRecommendedCategory[0] : null,
-    favoriteDifficulty: mostRecommendedDifficulty ? mostRecommendedDifficulty[0] : null,
-    categoryDistribution: categoryCount,
-    difficultyDistribution: difficultyCount,
-    playerDistribution: playerCount
-  };
-}
-
-// Generate fun recommendation messages
-function getRandomRouletteMessage() {
-  const messages = [
-    "🎲 The roulette wheel is spinning...",
-    "🎯 Searching for your perfect game match...",
-    "🎰 Rolling the dice of destiny...",
-    "🔮 Consulting the gaming crystal ball...", 
-    "🎪 Welcome to the game carnival!",
-    "🚀 Launching game discovery sequence...",
-    "🎨 Painting your gaming adventure...",
-    "⚡ Generating gaming lightning in a bottle...",
-    "🧩 Assembling your perfect game puzzle...",
-    "🌟 Aligning the gaming stars for you..."
-  ];
-  
-  return messages[Math.floor(Math.random() * messages.length)];
-}
-
-module.exports = {
-  createInitialGameRouletteState,
-  getRandomGame,
-  getSmartRecommendation,
-  getRecommendationWithFilters,
-  getGamesByVibe,
-  formatRouletteDisplay,
-  getRouletteStats,
-  getRandomRouletteMessage
-};