Houtini-lm

Instructions

Implementation Reference

• src/prompts/fun/arcade-game.ts:30-34 (registration)

  Plugin class registration with name 'arcade_game', category, and description.

  export class ArcadeGameGenerator extends BasePlugin implements IPromptPlugin {
    name = 'arcade_game';
    category = 'generate' as const;
    description = 'Generate complete playable 2D arcade games using HTML5 Canvas with player controls, enemies, and game mechanics';

• src/prompts/fun/arcade-game.ts:36-126 (schema)

  Input schema defining parameters for single/multi-game generation, game types, difficulty, features, theme, controls, etc.

  parameters = {
    // Single-game parameters
    code: {
      type: 'string' as const,
      description: 'Existing game code to enhance (for single-game analysis)',
      required: false
    },
    filePath: {
      type: 'string' as const,
      description: 'Path to existing game file to enhance',
      required: false
    },
    
    // Multi-game parameters  
    projectPath: {
      type: 'string' as const,
      description: 'Path to project root (for multi-game generation)',
      required: false
    },
    files: {
      type: 'array' as const,
      description: 'Array of specific game files (for multi-game analysis)',
      required: false,
      items: { type: 'string' as const }
    },
    maxDepth: {
      type: 'number' as const,
      description: 'Maximum directory depth for game file discovery (1-3)',
      required: false,
      default: 2
    },
    
    // Arcade game specific parameters
    gameType: {
      type: 'string' as const,
      description: 'Type of arcade game to generate',
      enum: ['shooter', 'platformer', 'puzzle', 'snake', 'breakout', 'asteroids', 'custom'],
      default: 'shooter',
      required: false
    },
    difficulty: {
      type: 'string' as const,
      description: 'Game difficulty level',
      enum: ['easy', 'medium', 'hard', 'adaptive'],
      default: 'medium',
      required: false
    },
    features: {
      type: 'array' as const,
      description: 'Game features to include',
      items: { type: 'string' as const },
      default: ['score', 'lives', 'powerups', 'sound'],
      required: false
    },
    theme: {
      type: 'string' as const,
      description: 'Visual theme for the game',
      enum: ['retro', 'neon', 'pixel', 'minimal', 'space', 'nature', 'custom'],
      default: 'retro',
      required: false
    },
    controls: {
      type: 'string' as const,
      description: 'Control scheme',
      enum: ['wasd', 'arrows', 'mouse', 'touch', 'hybrid'],
      default: 'hybrid',
      required: false
    },
    
    // Universal parameters
    language: {
      type: 'string' as const,
      description: 'Programming language',
      required: false,
      default: 'javascript'
    },
    analysisDepth: {
      type: 'string' as const,
      description: 'Level of game complexity',
      enum: ['basic', 'detailed', 'comprehensive'],
      default: 'detailed',
      required: false
    },
    analysisType: {
      type: 'string' as const,
      description: 'Type of game generation to perform',
      enum: ['prototype', 'polished', 'comprehensive'],
      default: 'comprehensive',
      required: false
    }
  };

• src/prompts/fun/arcade-game.ts:136-159 (handler)

  Main handler method that detects single/multi mode, validates params, sets up LLM model, and routes to game generation logic.

  async execute(params: any, llmClient: any) {
    return await withSecurity(this, params, llmClient, async (secureParams) => {
      try {
        // 1. Auto-detect analysis mode based on parameters
        const analysisMode = this.detectAnalysisMode(secureParams);
        
        // 2. Validate parameters based on detected mode
        this.validateParameters(secureParams, analysisMode);
        
        // 3. Setup model
        const { model, contextLength } = await ModelSetup.getReadyModel(llmClient);
        
        // 4. Route to appropriate generation method
        if (analysisMode === 'single-file') {
          return await this.executeSingleGameGeneration(secureParams, model, contextLength);
        } else {
          return await this.executeMultiGameGeneration(secureParams, model, contextLength);
        }
        
      } catch (error: any) {
        return ErrorHandler.createExecutionError('arcade_game', error);
      }
    });
  }

• src/prompts/fun/arcade-game.ts:167-180 (helper)

  Helper to auto-detect single-file or multi-file analysis mode based on input parameters.

  private detectAnalysisMode(params: any): 'single-file' | 'multi-file' {
    // Single-file indicators take priority (avoids default parameter issues)
    if (params.code || params.filePath) {
      return 'single-file';
    }
    
    // Multi-file indicators (game collections, project enhancement)
    if (params.projectPath || params.files) {
      return 'multi-file';
    }
    
    // Default to single-file for arcade game generation (game-focused)
    return 'single-file';
  }

• src/prompts/fun/arcade-game.ts:296-499 (helper)

  Core helper generating the prompt stages (system, data, output) for single-game arcade generation, containing the actual game generation instructions.

    private getSingleGamePromptStages(params: any): PromptStages {
      const { gameType, difficulty, features, theme, controls, analysisDepth, analysisType, code } = params;
      
      const systemAndContext = `You are a legendary game developer and creative genius specializing in ${analysisDepth} ${analysisType} arcade game creation.
  
  **Your Mission**: Create a complete, playable, and FUN ${gameType} arcade game that will immediately delight and engage players.
  
  **Game Development Context:**
  - Game Type: ${gameType}
  - Difficulty: ${difficulty}
  - Theme: ${theme}
  - Controls: ${controls}
  - Features: ${JSON.stringify(features)}
  - Complexity: ${analysisDepth}
  - Polish Level: ${analysisType}
  
  **Your World-Class Expertise:**
  - 20+ years creating addictive arcade games that players can't put down
  - Master of HTML5 Canvas, game physics, and smooth 60fps gameplay
  - Expert in player psychology - you know what makes games instantly fun
  - Specialized in clean, readable code that's easy to understand and modify
  - Pioneer of elegant game architectures with proper separation of concerns
  
  **Game Development Philosophy:**
  1. **Instant Fun** - Game should be enjoyable within 5 seconds of loading
  2. **Progressive Challenge** - Start easy, gradually increase difficulty
  3. **Juicy Feedback** - Visual and audio feedback for every player action
  4. **Clean Architecture** - Organized code with clear game loop, entities, and systems
  5. **Responsive Design** - Works perfectly on any screen size
  6. **Educational Value** - Code should teach good game development practices
  
  **Technical Requirements:**
  - Pure HTML5 Canvas and JavaScript (no external dependencies)
  - Smooth 60fps gameplay with proper game loop timing
  - Responsive canvas that adapts to screen size
  - Clean object-oriented design with Player, Enemy, and Game classes
  - Collision detection system optimized for performance
  - Particle effects for visual polish (explosions, trails, etc.)
  - Score system with local storage persistence
  - Professional code comments explaining game development concepts
  
  **Creative Requirements:**
  - Engaging visual style that matches the ${theme} theme
  - Intuitive ${controls} controls that feel responsive
  - Satisfying game mechanics that create flow state
  - Progressive difficulty that keeps players engaged
  - Polish details that make the game feel professional
  
  Your task is to create a masterpiece arcade game that showcases both technical excellence and creative brilliance.`;
  
      const dataPayload = code ? `**Existing Game Code to Enhance:**
  
  \`\`\`javascript
  ${code}
  \`\`\`
  
  **Enhancement Request:**
  Please analyze the existing game and enhance it with the requested features while maintaining the core gameplay.` : 
  
  `**New Game Generation Request:**
  Create a brand new ${gameType} game from scratch with the specified parameters.
  
  **Inspiration for ${gameType} games:**
  ${this.getGameTypeInspiration(gameType)}
  
  **Theme Guidelines for ${theme}:**
  ${this.getThemeGuidelines(theme)}`;
  
      const outputInstructions = `**Generate a complete, playable arcade game as a single HTML file:**
  
  \`\`\`html
  <!DOCTYPE html>
  <html lang="en">
  <head>
      <meta charset="UTF-8">
      <meta name="viewport" content="width=device-width, initial-scale=1.0">
      <title>${gameType.charAt(0).toUpperCase() + gameType.slice(1)} Game</title>
      <style>
          /* Beautiful ${theme}-themed CSS styling */
          /* Responsive design that works on all screen sizes */
          /* Professional visual polish */
      </style>
  </head>
  <body>
      <canvas id="gameCanvas"></canvas>
      <script>
          // Complete, production-ready game code including:
          
          // 1. GAME CONFIGURATION
          const GAME_CONFIG = {
              // All game constants and settings
          };
          
          // 2. UTILITY FUNCTIONS
          class Vector2 {
              // 2D vector math for positions and movement
          }
          
          class Utils {
              // Collision detection, random generators, etc.
          }
          
          // 3. GAME ENTITIES
          class Player {
              // Player character with movement, animation, abilities
          }
          
          class Enemy {
              // Enemy AI, spawning, different types
          }
          
          class Projectile {
              // Bullets, missiles, etc. with physics
          }
          
          class Powerup {
              // Power-ups, collectibles, bonuses
          }
          
          class Particle {
              // Visual effects system for polish
          }
          
          // 4. GAME SYSTEMS
          class InputManager {
              // ${controls} input handling with smooth controls
          }
          
          class AudioManager {
              // Sound effects using Web Audio API (optional)
          }
          
          class ScoreManager {
              // Scoring, high scores, local storage
          }
          
          // 5. MAIN GAME CLASS
          class Game {
              constructor() {
                  // Initialize game systems
              }
              
              init() {
                  // Setup canvas, event listeners, initial state
              }
              
              gameLoop() {
                  // Main 60fps game loop
                  this.update();
                  this.render();
                  requestAnimationFrame(() => this.gameLoop());
              }
              
              update() {
                  // Update all game entities and systems
              }
              
              render() {
                  // Draw everything to canvas
              }
              
              // Additional game state methods (start, pause, gameOver, etc.)
          }
          
          // 6. GAME INITIALIZATION
          const game = new Game();
          game.init();
          game.gameLoop();
      </script>
  </body>
  </html>
  \`\`\`
  
  **Critical Requirements:**
  ✅ Complete, runnable HTML file - no external dependencies
  ✅ Smooth 60fps gameplay with proper timing
  ✅ Responsive design that works on any screen size  
  ✅ Professional code organization with clear separation of concerns
  ✅ Engaging ${gameType} gameplay that's immediately fun
  ✅ Beautiful ${theme} visual style with polished UI
  ✅ Intuitive ${controls} controls that feel responsive
  ✅ All requested features: ${JSON.stringify(features)}
  ✅ Educational code comments explaining game development concepts
  ✅ Ready to copy-paste and play immediately
  
  **Visual Polish Standards:**
  - Smooth animations and transitions
  - Particle effects for explosions, collection, etc.
  - Screen shake for impact feedback
  - Color-coded UI elements for clarity
  - Professional typography and layout
  - Visual feedback for all player actions
  
  **Code Quality Standards:**
  - Clean, readable, well-documented code
  - Proper object-oriented design patterns
  - Performance optimizations for smooth gameplay
  - Error handling and edge case management
  - Easy to understand and modify for learning
  
  Create an arcade game that players will love and developers will learn from!`;
  
      return { systemAndContext, dataPayload, outputInstructions };
    }