slashvibe-mcp 0.3.20 → 0.3.21

package/games/guessnumber.js

@@ -0,0 +1,209 @@
+/**
+ * Guess the Number game implementation for /vibe
+ * Classic number guessing game with hints and difficulty levels
+ */
+
+// Create initial guess the number state
+function createInitialGuessNumberState(difficulty = 'medium') {
+  const ranges = {
+    easy: { min: 1, max: 10 },
+    medium: { min: 1, max: 50 },
+    hard: { min: 1, max: 100 },
+    extreme: { min: 1, max: 1000 }
+  };
+  
+  const range = ranges[difficulty] || ranges.medium;
+  const targetNumber = Math.floor(Math.random() * (range.max - range.min + 1)) + range.min;
+  
+  return {
+    targetNumber: targetNumber,
+    guesses: [],
+    moves: 0,
+    gameOver: false,
+    won: false,
+    difficulty: difficulty,
+    range: range,
+    hints: []
+  };
+}
+
+// Make a guess
+function makeGuess(gameState, guess) {
+  const { targetNumber, guesses, moves, gameOver, range } = gameState;
+  
+  // Parse guess as number
+  const guessNumber = parseInt(guess);
+  
+  // Validate guess
+  if (isNaN(guessNumber)) {
+    return { error: 'Please enter a valid number!' };
+  }
+  
+  if (guessNumber < range.min || guessNumber > range.max) {
+    return { error: `Please guess a number between ${range.min} and ${range.max}!` };
+  }
+  
+  // Check if already guessed
+  if (guesses.includes(guessNumber)) {
+    return { error: `You already guessed ${guessNumber}! Try a different number.` };
+  }
+  
+  // Check if game is already over
+  if (gameOver) {
+    return { error: 'Game is over! Start a new game to play again.' };
+  }
+  
+  // Process the guess
+  const newGuesses = [...guesses, guessNumber];
+  const newMoves = moves + 1;
+  let hint = '';
+  let won = false;
+  
+  if (guessNumber === targetNumber) {
+    // Correct guess!
+    won = true;
+    hint = '🎯 Perfect! You got it!';
+  } else if (guessNumber < targetNumber) {
+    // Too low
+    const diff = targetNumber - guessNumber;
+    if (diff <= 2) {
+      hint = '📈 Very close! Go a bit higher!';
+    } else if (diff <= 5) {
+      hint = '📈 Close! Too low, but getting warmer!';
+    } else if (diff <= 10) {
+      hint = '📈 Too low! Go higher!';
+    } else {
+      hint = '📈 Way too low! Much higher!';
+    }
+  } else {
+    // Too high
+    const diff = guessNumber - targetNumber;
+    if (diff <= 2) {
+      hint = '📉 Very close! Go a bit lower!';
+    } else if (diff <= 5) {
+      hint = '📉 Close! Too high, but getting warmer!';
+    } else if (diff <= 10) {
+      hint = '📉 Too high! Go lower!';
+    } else {
+      hint = '📉 Way too high! Much lower!';
+    }
+  }
+  
+  const newHints = [...gameState.hints, hint];
+  const newGameOver = won;
+  
+  const newGameState = {
+    ...gameState,
+    guesses: newGuesses,
+    moves: newMoves,
+    gameOver: newGameOver,
+    won: won,
+    hints: newHints,
+    lastGuess: guessNumber,
+    lastHint: hint
+  };
+  
+  return { success: true, gameState: newGameState };
+}
+
+// Format display for guess the number game
+function formatGuessNumberDisplay(gameState) {
+  const { guesses, moves, gameOver, won, difficulty, range, lastGuess, lastHint, targetNumber } = gameState;
+  
+  let display = `🔢 **Guess the Number** (${difficulty}) - Move ${moves}\n\n`;
+  
+  // Show range
+  display += `**Range:** ${range.min} - ${range.max}\n\n`;
+  
+  // Show latest guess and hint
+  if (lastGuess) {
+    display += `**Last guess:** ${lastGuess}\n`;
+    if (lastHint) {
+      display += `**Hint:** ${lastHint}\n\n`;
+    }
+  }
+  
+  // Show all guesses in order
+  if (guesses.length > 0) {
+    display += `**Your guesses:** ${guesses.join(', ')}\n\n`;
+  }
+  
+  // Show game status
+  if (gameOver) {
+    if (won) {
+      display += `🎉 **Congratulations!** You guessed ${targetNumber} in ${moves} tries!\n\n`;
+      
+      // Add performance feedback
+      const maxOptimal = Math.ceil(Math.log2(range.max - range.min + 1));
+      if (moves <= maxOptimal) {
+        display += '⭐ **Excellent strategy!** You used optimal guessing!';
+      } else if (moves <= maxOptimal + 2) {
+        display += '👍 **Great job!** Very efficient guessing!';
+      } else if (moves <= maxOptimal + 5) {
+        display += '👌 **Not bad!** Room for improvement with binary search!';
+      } else {
+        display += '🎯 **You got there!** Try narrowing down with middle numbers next time!';
+      }
+    }
+  } else {
+    display += '**Keep guessing! You can do it! 🎯**';
+    
+    // Give strategic hint after several guesses
+    if (moves >= 3 && moves % 3 === 0) {
+      display += '\n\n💡 **Tip:** Try guessing numbers in the middle of your remaining range!';
+    }
+  }
+  
+  return display;
+}
+
+// Get optimal strategy hint
+function getStrategyHint(gameState) {
+  const { guesses, range } = gameState;
+  
+  if (guesses.length === 0) {
+    const middle = Math.floor((range.min + range.max) / 2);
+    return `Try starting with ${middle} (middle of the range) for optimal strategy!`;
+  }
+  
+  // Find remaining range based on guesses
+  let min = range.min;
+  let max = range.max;
+  
+  guesses.forEach(guess => {
+    const hints = gameState.hints;
+    const hintIndex = guesses.indexOf(guess);
+    if (hints[hintIndex]) {
+      if (hints[hintIndex].includes('higher') || hints[hintIndex].includes('low')) {
+        min = Math.max(min, guess + 1);
+      } else if (hints[hintIndex].includes('lower') || hints[hintIndex].includes('high')) {
+        max = Math.min(max, guess - 1);
+      }
+    }
+  });
+  
+  if (min >= max) {
+    return 'Keep going! You\'re very close!';
+  }
+  
+  const middle = Math.floor((min + max) / 2);
+  return `Try ${middle} (middle of ${min}-${max} range)`;
+}
+
+// Get difficulty info
+function getDifficultyInfo() {
+  return {
+    easy: { range: '1-10', description: 'Perfect for beginners' },
+    medium: { range: '1-50', description: 'Good balance of challenge and fun' },
+    hard: { range: '1-100', description: 'Classic number guessing challenge' },
+    extreme: { range: '1-1000', description: 'For the truly brave!' }
+  };
+}
+
+module.exports = {
+  createInitialGuessNumberState,
+  makeGuess,
+  formatGuessNumberDisplay,
+  getStrategyHint,
+  getDifficultyInfo
+};

package/games/hangman.js

@@ -0,0 +1,279 @@
+/**
+ * Hangman game implementation for /vibe
+ * Classic word guessing game with ASCII art
+ */
+
+// Word lists organized by difficulty
+const WORD_LISTS = {
+  easy: [
+    'cat', 'dog', 'sun', 'car', 'run', 'big', 'fun', 'red', 'yes', 'top',
+    'old', 'new', 'hot', 'cold', 'good', 'fast', 'slow', 'book', 'tree', 'blue'
+  ],
+  medium: [
+    'apple', 'house', 'water', 'happy', 'music', 'phone', 'sleep', 'magic',
+    'friend', 'school', 'garden', 'yellow', 'rainbow', 'castle', 'dragon',
+    'planet', 'forest', 'ocean', 'mountain', 'butterfly'
+  ],
+  hard: [
+    'javascript', 'computer', 'elephant', 'adventure', 'chocolate', 'umbrella',
+    'fantastic', 'mysterious', 'programming', 'butterfly', 'technology',
+    'dinosaur', 'encyclopedia', 'extraordinary', 'magnificent', 'revolutionary',
+    'philosopher', 'kaleidoscope', 'whimsical', 'serendipity'
+  ]
+};
+
+// Hangman ASCII art stages
+const HANGMAN_STAGES = [
+  // 0 wrong guesses
+  `
+   +---+
+   |   |
+       |
+       |
+       |
+       |
+=========`,
+  
+  // 1 wrong guess
+  `
+   +---+
+   |   |
+   O   |
+       |
+       |
+       |
+=========`,
+  
+  // 2 wrong guesses
+  `
+   +---+
+   |   |
+   O   |
+   |   |
+       |
+       |
+=========`,
+  
+  // 3 wrong guesses
+  `
+   +---+
+   |   |
+   O   |
+  /|   |
+       |
+       |
+=========`,
+  
+  // 4 wrong guesses
+  `
+   +---+
+   |   |
+   O   |
+  /|\\  |
+       |
+       |
+=========`,
+  
+  // 5 wrong guesses
+  `
+   +---+
+   |   |
+   O   |
+  /|\\  |
+  /    |
+       |
+=========`,
+  
+  // 6 wrong guesses (game over)
+  `
+   +---+
+   |   |
+   O   |
+  /|\\  |
+  / \\  |
+       |
+=========`
+];
+
+// Get random word from difficulty level
+function getRandomWord(difficulty = 'medium') {
+  const words = WORD_LISTS[difficulty] || WORD_LISTS.medium;
+  return words[Math.floor(Math.random() * words.length)].toLowerCase();
+}
+
+// Create initial hangman state
+function createInitialHangmanState(difficulty = 'medium') {
+  const word = getRandomWord(difficulty);
+  
+  return {
+    word: word,
+    guessedLetters: [],
+    wrongGuesses: [],
+    correctGuesses: [],
+    wrongCount: 0,
+    maxWrongs: 6,
+    gameOver: false,
+    won: false,
+    difficulty: difficulty,
+    moves: 0
+  };
+}
+
+// Check if letter has been guessed before
+function hasBeenGuessed(gameState, letter) {
+  return gameState.guessedLetters.includes(letter.toLowerCase());
+}
+
+// Check if letter is in the word
+function isLetterInWord(word, letter) {
+  return word.includes(letter.toLowerCase());
+}
+
+// Get current word display (with underscores for unguessed letters)
+function getWordDisplay(word, correctGuesses) {
+  return word
+    .split('')
+    .map(letter => correctGuesses.includes(letter) ? letter.toUpperCase() : '_')
+    .join(' ');
+}
+
+// Make a guess
+function makeGuess(gameState, guess) {
+  const { word, guessedLetters, wrongGuesses, correctGuesses, wrongCount, maxWrongs } = gameState;
+  
+  // Normalize guess
+  const letter = guess.toLowerCase().trim();
+  
+  // Validate guess
+  if (!/^[a-z]$/.test(letter)) {
+    return { error: 'Please guess a single letter (a-z)' };
+  }
+  
+  // Check if already guessed
+  if (hasBeenGuessed(gameState, letter)) {
+    return { error: `You already guessed "${letter.toUpperCase()}". Try a different letter!` };
+  }
+  
+  // Check if game is already over
+  if (gameState.gameOver) {
+    return { error: 'Game is over! Start a new game to play again.' };
+  }
+  
+  // Process the guess
+  const newGuessedLetters = [...guessedLetters, letter];
+  const newWrongGuesses = [...wrongGuesses];
+  const newCorrectGuesses = [...correctGuesses];
+  let newWrongCount = wrongCount;
+  
+  if (isLetterInWord(word, letter)) {
+    // Correct guess
+    newCorrectGuesses.push(letter);
+  } else {
+    // Wrong guess
+    newWrongGuesses.push(letter);
+    newWrongCount++;
+  }
+  
+  // Check win condition (all letters guessed)
+  const uniqueLetters = [...new Set(word.split(''))];
+  const won = uniqueLetters.every(letter => newCorrectGuesses.includes(letter));
+  
+  // Check lose condition
+  const gameOver = won || newWrongCount >= maxWrongs;
+  
+  const newGameState = {
+    ...gameState,
+    guessedLetters: newGuessedLetters,
+    wrongGuesses: newWrongGuesses,
+    correctGuesses: newCorrectGuesses,
+    wrongCount: newWrongCount,
+    gameOver: gameOver,
+    won: won,
+    moves: gameState.moves + 1,
+    lastGuess: letter
+  };
+  
+  return { success: true, gameState: newGameState };
+}
+
+// Format hangman display
+function formatHangmanDisplay(gameState) {
+  const { word, wrongGuesses, correctGuesses, wrongCount, gameOver, won, difficulty, moves, lastGuess } = gameState;
+  
+  let display = `🎯 **Hangman** (${difficulty}) - Move ${moves}\n\n`;
+  
+  // Show hangman drawing
+  display += '```\n' + HANGMAN_STAGES[wrongCount] + '\n```\n\n';
+  
+  // Show current word progress
+  const wordDisplay = getWordDisplay(word, correctGuesses);
+  display += `**Word:** ${wordDisplay}\n\n`;
+  
+  // Show wrong guesses
+  if (wrongGuesses.length > 0) {
+    display += `**Wrong guesses:** ${wrongGuesses.map(l => l.toUpperCase()).join(', ')}\n`;
+  }
+  
+  // Show remaining guesses
+  const remaining = 6 - wrongCount;
+  display += `**Remaining guesses:** ${remaining}\n\n`;
+  
+  // Show game status
+  if (gameOver) {
+    if (won) {
+      display += `🎉 **You won!** The word was "${word.toUpperCase()}"\n`;
+      display += `Solved in ${moves} guesses!`;
+    } else {
+      display += `💀 **Game Over!** The word was "${word.toUpperCase()}"\n`;
+      display += 'Better luck next time!';
+    }
+  } else {
+    if (lastGuess) {
+      if (correctGuesses.includes(lastGuess)) {
+        display += `✅ Good guess! "${lastGuess.toUpperCase()}" is in the word.\n\n`;
+      } else {
+        display += `❌ Sorry, "${lastGuess.toUpperCase()}" is not in the word.\n\n`;
+      }
+    }
+    display += '**Guess a letter to continue!**';
+  }
+  
+  return display;
+}
+
+// Get hint for the current word
+function getHint(word, difficulty) {
+  const hints = {
+    // Easy words
+    'cat': 'A furry pet that says meow',
+    'dog': 'Man\'s best friend that barks',
+    'sun': 'Bright star in our sky',
+    'car': 'Vehicle with four wheels',
+    'run': 'Move quickly on foot',
+    
+    // Medium words
+    'apple': 'Red or green fruit that grows on trees',
+    'house': 'Building where people live',
+    'water': 'Clear liquid we drink',
+    'music': 'Sounds arranged in harmony',
+    'phone': 'Device for making calls',
+    
+    // Hard words
+    'javascript': 'Popular programming language',
+    'computer': 'Electronic device for processing data',
+    'elephant': 'Large gray animal with a trunk',
+    'adventure': 'Exciting or unusual experience',
+    'programming': 'Writing code for computers'
+  };
+  
+  return hints[word] || `A ${difficulty} word with ${word.length} letters`;
+}
+
+module.exports = {
+  createInitialHangmanState,
+  makeGuess,
+  formatHangmanDisplay,
+  getRandomWord,
+  getHint,
+  WORD_LISTS
+};