slashvibe-mcp 0.3.20 → 0.3.21

package/games/drawing.js

@@ -0,0 +1,347 @@
+/**
+ * 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

@@ -0,0 +1,300 @@
+/**
+ * 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
+};