@getollie/cli 0.0.5 → 0.2.0

package/library/game_development-puzzle/minesweeper-mini-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 1071,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Be sure to ensure that the generated code is executable for demonstration purposes. Create a minesweeper-like mini-game for me.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core game mechanic fully implemented?",
-      "description": "Evaluate whether the code accurately implements the fundamental minesweeper game mechanics: grid generation, mine placement, cell revealing, flag placement, and win/loss conditions. Score 0 if these core mechanics are missing, 5 if basic functionality is implemented but with issues, and 10 if all features work correctly with proper game state management.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the mine generation algorithm well-designed?",
-      "description": "Check if the algorithm randomly distributes mines across the board while ensuring the first click is never a mine (industry standard). Evaluate if the density distribution is appropriate and configurable. Deduct 5 points if the first click can be a mine, 3 points if the mine distribution is noticeably uneven or predictable, and 2 points if mine density isn't configurable.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the adjacent mine counting system correctly implemented?",
-      "description": "Review the implementation of the neighbor counting algorithm that displays numbers in revealed cells. Test edge cases like corners and borders. The algorithm should efficiently calculate adjacent mines without redundant calculations. Score 10 points for an optimized implementation that works in all cases, 5 points for functional but inefficient code, and 0 points for incorrect calculations.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Does the flood fill reveal system work properly?",
-      "description": "Evaluate the implementation of the flood fill algorithm that automatically reveals adjacent empty cells when an empty cell is clicked. Check for proper recursion limits, handling of grid boundaries, and performance with large open areas. Deduct 5 points for stack overflow risks, 3 points for inefficient implementation (O(n²) or worse), and 2 points for improper boundary handling.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid inputs, rapid consecutive clicks, browser resize events) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Custom difficulty settings 2. Timer and high score system 3. Animated reveals 4. Hint system 5. Undo functionality). Add 2 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple board generation algorithms) 2. Function modules unrelated to minesweeper (e.g., unrelated mini-games) 3. Fancy effects that affect performance (e.g., excessive animations that slow down gameplay). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/view/controller layers), code organization, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 3 points if naming conventions are inconsistent or unclear. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Clean and consistent grid visualization 2) Clear distinction between revealed/unrevealed cells and flagged mines 3) Proper spacing and sizing for easy interaction on different devices. Deduct 3 points for inconsistent cell styling, 5 points for poor visual hierarchy making game state unclear, and 5 points for elements that are too small for comfortable interaction. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Immediate feedback on cell clicks 2) Clear distinction between left-click (reveal) and right-click (flag) actions 3) Visual indication of game state (playing/won/lost). Deduct 5 points for delayed click responses, 3 points for confusing interactions, and 5 points for lack of visual feedback when the game ends. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "easy"
-}

package/library/game_development-puzzle/mobile-tetris-game-development.json

@@ -1,68 +0,0 @@
-{
-  "index": 1142,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Make sure the code you produce is executable for demonstration. Create a Tetris game that can run locally on a mobile device.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core Tetris game logic fully implemented?",
-      "description": "Evaluate whether the code includes all essential Tetris mechanics: piece rotation, movement, collision detection, line clearing, and scoring. Check if the game implements standard Tetris rules (7 tetromino types, proper rotation behavior including wall kicks, ghost pieces). Score 0 if fundamental game mechanics are missing, 5 if basic movement and collision are implemented but with flaws, 10 if all standard Tetris mechanics are properly implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the mobile-specific implementation adequate?",
-      "description": "Assess if the game is properly optimized for mobile devices: responsive design that adapts to different screen sizes, touch controls (swipe gestures for movement/rotation, tap for hard drop), appropriate button sizing (≥44px), and proper viewport settings. Deduct 5 points if touch controls are missing or poorly implemented, 3 points if the UI doesn't adapt well to different mobile screen sizes. Full score requires implementation of device orientation changes and proper handling of touch events.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is local data persistence implemented?",
-      "description": "Check if the game can save high scores, game state (for resuming interrupted games), and user preferences locally on the device using appropriate technologies (localStorage, IndexedDB, etc.). Verify that the game handles application lifecycle events (page visibility changes, browser closing) to properly save state. Deduct 5 points if game state isn't saved during interruptions, 3 points if high scores aren't persistent. Full score requires complete offline functionality with local data persistence.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the mobile performance optimized?",
-      "description": "Evaluate if the game runs smoothly on mobile devices: maintains 60fps, optimizes rendering (canvas vs DOM), minimizes layout thrashing, implements efficient collision detection, and handles touch events without lag. Check for battery usage optimization techniques like requestAnimationFrame. Deduct 5 points if frame rate drops are noticeable, 5 points if the game consumes excessive battery power. Full score requires stable performance across multiple device types.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as incorrect user input, device orientation changes, browser compatibility issues, memory constraints) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Multiple game modes like marathon/sprint/ultra 2. Custom themes or skins 3. Haptic feedback on mobile 4. Social media score sharing). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple collision detection algorithms) 2. Function modules unrelated to Tetris gameplay (e.g., unnecessary social features) 3. Fancy effects that affect performance (e.g., excessive animations that slow down gameplay). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/view/input handling layers), code organization, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no clear separation between game logic and rendering. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern mobile design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Touch-friendly controls (minimum tap target of 44px) 4) Clear game area with appropriate contrast. Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for inaccessible controls. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and responsive?",
-      "description": "Judge whether the game controls respond appropriately to touch input: 1) Touch response delay ≤ 100ms 2) Smooth piece movement and rotation without visual lag 3) Clear visual and possibly haptic feedback for actions. Deduct 5 points for input lag over 100ms, 3 points for jerky animations, and 5 points for unclear or missing visual feedback. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "hard"
-}

package/library/game_development-puzzle/mobile-tetris-game-with-instructions.json

@@ -1,68 +0,0 @@
-{
-  "index": 1252,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable when possible. Help me create a Tetris game code that can be played on mobile devices, along with detailed usage instructions.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core Tetris game mechanics fully implemented?",
-      "description": "Review whether the code accurately implements standard Tetris mechanics including: tetromino generation (all 7 shapes), rotation system (preferably SRS), collision detection, line clearing, and scoring system. Score 0 if the core game logic is missing, 5 if basic mechanics are implemented but with flaws, 10 if all standard mechanics are properly implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is mobile responsiveness properly implemented?",
-      "description": "Evaluate if the game adapts to different screen sizes and orientations on mobile devices. Check for viewport meta tags, responsive CSS (using media queries, relative units, or flexible layouts), and touch-friendly UI elements. Deduct 5 points if the game doesn't resize properly on different devices, 3 points if touch targets are smaller than 44px×44px. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are mobile-specific touch controls implemented?",
-      "description": "Assess the implementation of touch controls for mobile gameplay: swipe gestures (left/right for movement, down for soft drop, up for hard drop), tap controls for rotation, and possibly shake for hold/swap function. Check if controls are customizable and have visual indicators. Deduct 5 points if basic touch controls are missing, 3 points if there's no visual feedback for touch interactions. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are the usage instructions comprehensive and clear?",
-      "description": "Review whether detailed usage instructions are provided, including: game controls explanation, scoring system details, special features description, and mobile-specific instructions (e.g., device orientation recommendations, touch gesture guides). Instructions should be accessible from within the game. Deduct 3 points for each major omission. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as browser back navigation, screen rotation, incoming calls/notifications, device sleep/wake cycles) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Customizable tetromino themes 2. Progressive difficulty levels 3. Challenge modes beyond classic Tetris 4. Haptic feedback for mobile 5. Local high score system). Add 2 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to handle the same input) 2. Function modules unrelated to Tetris gameplay (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive particle effects that cause lag on mobile). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/view/input handling layers), code readability, performance optimization for mobile, and offline capability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code is not optimized for mobile performance; deduct 5 points if the game can't be played without an internet connection. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern mobile design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (game board clearly visible without scrolling) 3) Touch-friendly UI with elements sized appropriately for fingers 4) Clear game status indicators (score, level, next piece). Deduct 3 points for each poorly designed element, 5 points for cluttered interface, and 5 points for poor visibility of game elements. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to mobile interaction standards: 1) Touch response delay ≤ 100ms 2) Smooth tetromino movement at minimum 30fps 3) Clear visual feedback for all interactions 4) Game state persistence when app is minimized. Deduct 5 points for laggy animations, 3 points for missed touch inputs, 5 points for game reset on browser refresh or app minimization. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "hard"
-}

package/library/game_development-puzzle/mobile-tetris-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 1730,
-  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Make sure the code you produce is executable for demonstration purposes. Write code for a Tetris game that can be directly used on mobile phones.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core Tetris game logic fully implemented?",
-      "description": "Review whether the code accurately implements standard Tetris mechanics including piece rotation, movement, collision detection, line clearing, and scoring. Score 0 if the core game logic is missing, 5 if basic movement and collision are implemented but with flaws, and 10 if all standard Tetris rules (including piece previews, holding pieces, and proper randomization) are correctly implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the mobile-specific touch interaction properly implemented?",
-      "description": "Evaluate whether the game handles touch events appropriately for mobile devices with features like swipe to move, tap to rotate, swipe down to drop pieces, and proper touch area sizing. Deduct 5 points if touch areas are too small for fingers, 3 points if there's noticeable input lag, and 5 points if any essential mobile interaction is missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the responsive design properly implemented for different mobile screen sizes?",
-      "description": "Check whether the game interface adapts properly to different screen sizes (portrait/landscape) and aspect ratios. The game should use relative units, media queries, or dynamic sizing. Deduct 5 points if the game is unplayable on some common device dimensions, 3 points for UI elements that overflow or get cut off, and 3 points if orientation changes aren't handled. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are mobile-specific performance optimizations implemented?",
-      "description": "Assess whether the code includes optimizations for mobile devices such as requestAnimationFrame usage, event throttling/debouncing, efficient rendering techniques, and battery-saving measures. Deduct 4 points for frame rate drops below 30fps during gameplay, 3 points for excessive battery drain, and 3 points for lack of memory management. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as out-of-bounds inputs, device rotation, app going to background/foreground, touch events during animations, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Haptic feedback on line clears 2. Advanced scoring system with combos 3. AR/VR mode or 3D effects 4. Custom themes or skins). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple movement control methods without clear purpose) 2. Function modules unrelated to Tetris gameplay (e.g., unnecessary animations) 3. Fancy effects that affect performance on lower-end devices. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/view/input handling layers), use of appropriate design patterns, and mobile-specific optimizations. Deduct 5 points if global state pollution is found; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no offline capability or state persistence. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional mobile design standards?",
-      "description": "Evaluate whether the overall design follows mobile design principles: 1) Finger-friendly touch targets (minimum 44×44 pixels) 2) Proper layout spacing accounting for thumbs' natural reach 3) Appropriate text size (minimum 16px) and contrast for mobile viewing. Deduct 3 points for each difficult-to-tap element, 5 points for poor contrast in outdoor viewing conditions, and 5 points for UI elements hidden by fingers during play. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to mobile interaction standards: 1) Touch response delay ≤ 100ms 2) Smooth piece movement and rotation animations 3) Clear visual and haptic feedback for actions. Deduct 5 points for each operation without feedback, 3 points for choppy animations during fast movements, and 5 points for inconsistent touch response times. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "hard"
-}

package/library/game_development-puzzle/multi-player-pixel-block-elimination-game-analysis.json

@@ -1,68 +0,0 @@
-{
-  "index": 894,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Multi-Player Online Multi-Colored Pixel Block Elimination Game Analysis\n\n## I. Core Gameplay and Differentiation Design\n\n1. Elimination Mechanism Optimization\n   • Visual and Operational Experience: Drawing from NetEase's similar elimination games with \"high-recognition color block design\" strategy, utilize multi-colored pixel blocks with high saturation and brightness, combined with a rounded cartoon style (similar to \"Egg Party\" style), to enhance block recognition and reduce the difficulty for players to find elimination targets.\n   • Enhanced Satisfaction: Maintain a fast pace through a \"eliminate and generate\" dynamic mechanism (immediately filling new color blocks after elimination), allowing players to continue operating before elimination animations complete, improving control and continuity.\n   • Dynamic Difficulty Adjustment: Increase block generation speed every 100 points; can adopt the \"level step count delicate control\" approach to ensure players feel the urge to \"use items to pass the level\" at critical failure points, creating payment impulses. Complete code output required.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the multi-colored pixel block elimination mechanism fully implemented?",
-      "description": "Check if the code properly implements the core elimination logic with high-recognition color blocks and accurate detection of matching patterns. Verify that blocks can be eliminated when matching conditions are met (e.g., same colors adjacent, minimum cluster size). Score 0 if the elimination logic is missing, 5 if basic elimination works but has bugs, and 10 if the system handles all elimination patterns correctly with proper visual feedback.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the 'eliminate and generate' dynamic mechanism implemented correctly?",
-      "description": "Evaluate whether the code implements immediate block regeneration after elimination, allowing continuous gameplay. Check if players can continue operating before elimination animations complete. Score 0 if blocks don't regenerate, 5 if regeneration works but with timing issues or visual glitches, and 10 if the system provides seamless regeneration with smooth transitions that maintain gameplay flow.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the dynamic difficulty adjustment system properly implemented?",
-      "description": "Review if the code increases block generation speed every 100 points as specified. Check whether the 'level step count delicate control' approach is implemented to create strategic difficulty spikes. Evaluate if the system tracks player progress and adjusts accordingly. Score 0 if difficulty remains static, 5 if basic scaling exists but lacks finesse, and 10 if the difficulty curve is sophisticated with proper metrics tracking.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the multi-player online functionality robustly implemented?",
-      "description": "Assess the implementation of real-time multiplayer features including player synchronization, match-making, and competitive elements. Check for latency compensation, conflict resolution, and session management. Score 0 if multiplayer is absent, 5 if basic functionality exists but with synchronization issues, and 10 if the system provides seamless multiplayer with proper error handling for disconnections and rejoins.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as out-of-bounds input, network interruption, user operation errors, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Special power-up blocks with unique effects 2. Social features like sending challenges 3. Personalized block themes). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple scoring systems overlapping) 2. Function modules unrelated to the elimination game (e.g., an unnecessary minigame) 3. Fancy effects that affect performance (e.g., excessive particle systems slowing gameplay). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/view/network layers), unit test coverage, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows the specified rounded cartoon style (similar to 'Egg Party'). Check for: 1) High saturation and brightness in color blocks 2) Clear visual distinction between different block colors 3) Proper UI layout with focus on gameplay area. Deduct 3 points for each element that breaks visual cohesion, 5 points if color blocks lack the required high-recognition qualities, and 5 points for cluttered or confusing UI. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Block selection/elimination response ≤ 100ms 2) Elimination and regeneration animations between 300-500ms 3) Clear visual guidance for possible moves. Deduct 5 points for each elimination operation without proper feedback, 3 points for choppy animations during continuous eliminations, and 5 points for unclear visual indicators of potential matches. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "hard"
-}

package/library/game_development-puzzle/nine-grid-klotski-puzzle-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 795,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure that the code you provide is executable when possible. Create a nine-grid Klotski puzzle game.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the nine-grid Klotski puzzle base functionality fully implemented?",
-      "description": "Review whether the code correctly implements the 3x3 grid system with 8 number tiles and one empty space. Check if the basic sliding mechanics work (tiles adjacent to the empty space can move into it). Score 0 if the core grid system is missing, 5 if basic movement is implemented but with bugs, and 10 if the complete puzzle mechanics function properly including movement validation.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the puzzle shuffling and solvability verification implemented?",
-      "description": "Evaluate whether the code includes a proper randomization algorithm that ensures the puzzle is solvable. Check for implementation of parity check or other methods that guarantee solvability. Deduct 5 points if the shuffling doesn't ensure solvable states, and 3 points if the shuffling isn't truly random. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are the game state management and winning condition properly implemented?",
-      "description": "Check if the code properly tracks the current state of the board, validates moves, and correctly identifies when the puzzle is solved (tiles arranged in numerical order). Verify that the game provides appropriate feedback when the player wins. Deduct 5 points if win detection is faulty, and 3 points if the state management has inconsistencies. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there a move counter and/or timer functionality?",
-      "description": "Assess whether the game includes features to track the number of moves made and/or time elapsed. Check if these metrics are displayed to the player and updated in real-time. Deduct 3 points if only one metric is implemented, 5 points if the metrics aren't updated properly, and 10 points if neither is implemented. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid clicking, browser resize, unexpected input) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Animation effects for tile movements 2. Multiple difficulty levels 3. Custom images instead of numbers 4. Solution hint system). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to reset the game) 2. Function modules unrelated to the puzzle (e.g., a built-in calculator) 3. Fancy effects that affect performance (e.g., excessive animations that slow down gameplay). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/view layers), appropriate use of data structures, and clean organization. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no separation between UI and game logic. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Tile sliding animations are smooth and consistent (150-300ms) 3) Clear visual distinction between movable and unmovable tiles. Deduct 5 points for each operation without feedback, 3 points for jerky animations, and 5 points for confusing or inconsistent interaction patterns. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "hard"
-}

package/library/game_development-puzzle/number-connection-animal-game-1-to-1000.json

@@ -1,68 +0,0 @@
-{
-  "index": 1678,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable for display. Help me create a fun number connection game from 1 to 1000, where all points are marked, and when connected in numerical order, they form an animal image. The game should include 100 different animal shapes to choose from, with all code integrated into a single webpage.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core numerical connection game mechanics fully implemented?",
-      "description": "Review whether the code accurately implements the connection of points from 1 to 1000 in numerical order. Check if the points are properly marked with numbers, if the game validates correct connections, and if there's visual feedback when points are connected. Score 0 if the core connection logic is not implemented, 5 if only basic connections work, and 10 if fully implemented with validation and visual feedback.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are 100 different animal shapes properly implemented and selectable?",
-      "description": "Evaluate whether the code genuinely includes 100 different animal shapes with distinct point distributions. Check if each animal is uniquely identifiable and if the selection mechanism works properly. Deduct 1 point for every 10 animals missing from the required 100. Deduct 5 points if the animals are too similar or indistinguishable. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the coordinate system and point distribution implementation effective?",
-      "description": "Check if the points are distributed in a way that clearly forms the animal shape when connected. Points should be positioned strategically to make the animal recognizable during gameplay. Evaluate if the 1000 points are distributed with appropriate density (not too sparse in important details, not too dense in simple areas). Deduct 5 points if animal shapes are unrecognizable, and 3 points if point density is poorly managed. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the game progression and user interface properly designed?",
-      "description": "Assess whether the game provides clear guidance on which number to connect next, progress tracking, completion indication, and reset functionality. Check if the interface allows for easy navigation between different animal options. Deduct 3 points if the next number to connect isn't clearly indicated, 3 points if progress isn't tracked, and 4 points if there's no completion feedback or reset option. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as incorrect connections, rapid clicking, resizing the browser window, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Progressive difficulty levels 2. Timed challenges 3. Partial image reveals as hints 4. Animation when completing an animal). Add 2.5 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to select animals) 2. Function modules unrelated to the number connection game (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive animations that slow down point connections). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/view/data layers), code organization, and performance optimization for handling 1000 points. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if rendering optimization is poor (slow performance with 1000 points). The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Point connection feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual guidance for the next number. Deduct 5 points if connecting points lacks feedback, 3 points for laggy animations when many points are connected, and 5 points for unclear number identification. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "hard"
-}

package/library/game_development-puzzle/offline-vocabulary-english-tetris-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 1203,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable when presented. Please help me create an offline web page for a vocabulary-based English word pairing Tetris game, with a creamy white background for the webpage.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core Tetris gameplay mechanism fully implemented?",
-      "description": "Evaluate whether the game implements the fundamental Tetris mechanics: block generation, movement (left, right, down), rotation, line clearing, and increasing difficulty over time. The English word pairing aspect should be integrated into the gameplay (e.g., matching words with definitions or synonyms). Score 0 if core mechanics are missing, 5 if basic mechanics work but word pairing is poorly integrated, 10 if both Tetris mechanics and word pairing work seamlessly together.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the vocabulary system properly designed and implemented?",
-      "description": "Check whether the code includes a robust vocabulary system with a varied word database, proper word-pairing logic (matching words with synonyms, antonyms, or definitions), and appropriate difficulty progression. Deduct 5 points if the vocabulary is too limited (<50 words), 3 points if the pairing logic is overly simplistic, and 2 points if there's no difficulty adjustment based on player performance. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the game state management properly implemented?",
-      "description": "Assess whether the game includes proper state management for game initialization, gameplay, pausing, game over, score tracking, and high score storage (using localStorage). Check for clean state transitions and appropriate UI updates. Deduct 3 points for each missing state feature, and 5 points if the state management causes gameplay bugs. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the offline functionality properly implemented?",
-      "description": "Evaluate whether the game truly works offline using appropriate techniques (e.g., localStorage for saving game data, static asset bundling). Check if the application includes proper offline detection and user notification. Deduct 5 points if offline storage isn't implemented, 3 points if the game doesn't handle reconnection gracefully, and 2 points if there's no offline indicator. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid user input, browser compatibility issues, varying screen sizes, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Spaced repetition system for vocabulary learning 2. Voice pronunciation for English words 3. Visual hints for word associations). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple scoring systems overlapping) 2. Function modules unrelated to the Tetris vocabulary game (e.g., unnecessary animations) 3. Fancy effects that affect performance (e.g., excessive particle effects). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/view/data management layers), code organization, and performance optimization. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no consideration for performance optimization for smooth gameplay. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Creamy white background as specified, with harmonious complementary colors 2) Clear visual distinction between Tetris blocks and word elements 3) Professional typography with readable text (game text ≥ 14px, sufficient contrast with background). Deduct 3 points for each cluttered UI element, 5 points for poor color combinations that strain the eyes, and 5 points for text that's difficult to read during gameplay. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the game interactions feel responsive and intuitive: 1) Block movement responds within 100ms 2) Keyboard controls are intuitive with alternative touch controls for mobile 3) Clear visual and audio feedback for successful word pairing. Deduct 5 points for laggy block movement, 3 points for confusing control scheme, and 5 points for unclear feedback when words are paired correctly/incorrectly. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "hard"
-}