@getollie/cli 0.0.1

package/library/game_development-puzzle/russian-tetris-game-four-direction-html.json

@@ -0,0 +1,68 @@
+{
+  "index": 1780,
+  "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. Create a Russian Tetris game with four-direction gameplay using HTML.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core Tetris game mechanics correctly implemented?",
+      "description": "Review whether the code accurately implements tetrimino generation, rotation, movement, collision detection, and line clearing. The game should include the 7 standard tetrimino shapes (I, O, T, S, Z, J, L) with proper physics. Score 0 if core game logic is missing, 5 if basic mechanics are implemented but with flaws, and 10 if all standard Tetris mechanics are properly implemented including proper random generation algorithms.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the four-direction gameplay functionality implemented?",
+      "description": "Check whether the game allows tetriminos to fall in all four directions (not just downward) and whether the gameplay adapts accordingly. Each direction should have proper controls, collision detection, and line clearing mechanics. Deduct 5 points if only two directions are implemented, 3 points if the four directions exist but don't function properly with gravity. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the game control system responsive and well-designed?",
+      "description": "Evaluate the keyboard/touch controls implementation, including movement, rotation, hard drop, hold piece functionality, and direction switching. Controls should be responsive (< 100ms delay) and intuitive. Deduct 3 points if key mapping is unconventional without customization options, 5 points if controls feel sluggish or unresponsive. Give 10 points for smooth, professional controls with alternative input methods.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are the game state management and scoring systems properly implemented?",
+      "description": "Verify implementation of game state (start, pause, game over), level progression, scoring system (should increase with combos and level), and persistent high scores. Check if the difficulty increases appropriately with level (increased speed, etc.). Deduct 5 points if scoring doesn't follow standard Tetris rules, 3 points if level progression is missing. 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 input, browser resizing, focus loss, 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. Ghost piece showing where tetrimino will land 2. Next piece preview and hold function 3. Special effects for Tetris clears or combos). 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 game loop systems) 2. Function modules unrelated to Tetris (e.g., unrelated mini-games) 3. Fancy effects that affect performance (e.g., excessive particles or animations that cause lag). 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/rendering/input handling), code organization, naming conventions, and comments. Deduct 5 points if global state pollution is found or proper encapsulation is not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's a lack of comments explaining complex 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 classic Tetris aesthetics while maintaining modern design principles: 1) Clear, high-contrast game grid with distinct tetrimino colors 2) Proper layout with well-positioned UI elements (score, level, next piece) 3) Appropriate font choices and sizes for readability. Deduct 3 points for each cluttered UI element, 5 points for poor color choices making pieces difficult to distinguish, and 5 points for illegible text or awkward layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the game animations and interactions feel satisfying: 1) Tetrimino movement is smooth with no stuttering 2) Line clearing animations are visually appealing 3) Game responds immediately to input (< 100ms delay). Deduct 5 points if tetrimino movement is jerky, 3 points if line clearing lacks visual feedback, and 5 points if there's noticeable input lag. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "hard"
+}

package/library/game_development-puzzle/sheep-a-sheep-like-game-code.json

@@ -0,0 +1,68 @@
+{
+  "index": 769,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Ensure that the code you generate is executable whenever possible. Write programming code for a game similar to \"Yang Le Ge Yang\" (Sheep a Sheep).",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core game mechanic of matching and eliminating similar elements implemented?",
+      "description": "Review whether the code accurately implements the key 'Sheep a Sheep' mechanic where players match and eliminate identical elements (typically in groups of three). Check if the code includes collision detection, element matching logic, and clearing animations. Score 0 if core mechanics are missing, 5 if basic matching is implemented without proper animations or feedback, and 10 if the complete elimination system with visual feedback is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the difficulty progression system properly designed?",
+      "description": "Evaluate whether the code implements the progressively harder levels with increasing complexity of element stacking and overlapping (characteristic of 'Sheep a Sheep'). Check for implementation of the element layering system, proper visibility of partially covered items, and difficulty scaling algorithms. Deduct 5 points if the layering system is flawed, 3 points if difficulty progression is absent, and 5 points if the stacking visualization is confusing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the inventory/holding area for temporary elements implemented?",
+      "description": "Check if the code includes the signature mechanic of a temporary storage area (typically at the bottom of the screen) that can hold a limited number of elements before the player must make matches. Verify that the code properly handles overflow conditions, displays clear visual feedback when the area is nearly full, and implements the game-over condition when this area exceeds capacity. Score 0 if this feature is absent, 5 if implemented with bugs, 10 if fully functional.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the scoring system and victory condition properly implemented?",
+      "description": "Assess whether the code includes a proper scoring mechanism that rewards faster completions, combo matches, or strategic play. Check if victory conditions are clearly defined (clearing all elements from the board) and if end-of-level transitions are handled smoothly. Deduct 5 points if scoring is simplistic or missing, 3 points if victory conditions are buggy, and 3 points if level transitions are abrupt. 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 clicks, rapid-fire user inputs, window resizing, 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-ups or combo systems 2. Unique visual themes or customizable elements 3. Social features like sharing results or leaderboards). 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 restart a level) 2. Function modules unrelated to the core gameplay (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive particle effects 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), code reusability, 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 mechanics 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 game design principles: 1) Harmonious color matching with clear visual hierarchy 2) Proper layout with adequate spacing between clickable elements (preventing mis-clicks) 3) Readable text with appropriate contrast against backgrounds. Deduct 3 points for cluttered UI elements, 5 points for poor color combinations that strain the eyes, and 5 points for elements that are too small to interact with comfortably. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the game animations and interactions feel satisfying: 1) Element selection/matching has immediate visual and possibly audio feedback 2) Animations for matching/clearing last between 200-400ms for satisfaction without delay 3) Clear indication of available moves and game state. Deduct 5 points for laggy animations, 3 points for unclear feedback when selecting elements, and 5 points if the game becomes visually confusing during intense gameplay. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "hard"
+}

package/library/game_development-puzzle/sheep-a-sheep-mini-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 838,
+  "question": "You are a coding expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you provide is executable and demonstrable. Using WeChat development tools, create a mini-game similar to \"Sheep a Sheep,\" implementing complete game logic and adding animation effects. Provide detailed code and gameplay simulation.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core matching logic of the 'Sheep a Sheep' game fully implemented?",
+      "description": "Review whether the code accurately implements the elimination-by-matching mechanics where players need to match identical elements. Check if the implementation includes stack management, visibility detection (elements can only be selected when not blocked), and three-identical elimination rules. Score 0 if the core game logic is missing, 5 if basic matching works but edge cases aren't handled, 10 if the complete mechanics are implemented including special scenarios.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the level generation and difficulty progression system implemented?",
+      "description": "Evaluate whether the code includes a procedural level generation system that creates increasingly difficult puzzles. Check if it manages element distribution to ensure levels are solvable but challenging. The system should track player progress and adjust difficulty accordingly. Score 0 if static levels only, 5 if basic procedural generation exists, 10 if it includes adaptive difficulty scaling based on player performance.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the WeChat Mini-Program specific APIs properly integrated?",
+      "description": "Check whether the implementation correctly uses WeChat Mini-Program APIs (wx.createCanvas, wx.getSystemInfo, etc.) and follows the WeChat mini-game lifecycle. Verify that the game properly handles screen adaptation across different devices, uses wx.setPreferredFramesPerSecond for performance optimization, and implements proper resource loading with wx.loadSubpackage if needed. Deduct 3 points for each critical WeChat API misuse or omission.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the game state management and persistence mechanism implemented?",
+      "description": "Analyze whether the code implements proper game state management including save/resume functionality, level progress tracking, and score persistence using wx.setStorage or cloud capabilities. Check if the game properly handles interruptions (phone calls, app switching) and can restore the exact state. Score 0 if no state persistence exists, 5 if basic save/load exists, 10 if complete state management with error handling is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as erroneous touch events, memory constraints, network fluctuations for leaderboards, 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-ups beyond the original game 2. Daily challenges or time-limited events 3. Social sharing features with customized screenshots). 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 handle the same user interaction) 2. Function modules unrelated to the core gameplay (e.g., unnecessary mini-games within the game) 3. Fancy effects that affect performance (e.g., excessive particle effects causing lag). 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/resource management layers), optimization for WeChat mini-game environment, and proper event handling patterns. Deduct 5 points if global state pollution is found or if proper encapsulation is not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if memory management is poor (causing potential leaks in long gameplay sessions). The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the visual design matches the playful yet clean aesthetic of successful mini-games: 1) Harmonious color matching with consistent theme 2) Clear visual hierarchy with properly sized game elements (considering touch targets should be at least 44x44px) 3) Appropriate use of WeChat's visual language. Deduct 3 points for each inconsistent visual element, 5 points for unclear game state visualization, and 5 points for text that's too small to read on mobile. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the animations and game feedback conform to mobile game best practices: 1) Touch response within 100ms 2) Element matching/elimination animations between 200-500ms 3) Clear visual and audio feedback for successful/unsuccessful interactions. Deduct 5 points for delayed touch response, 3 points for frame rate drops below 30fps during animations, and 5 points for confusing or missing feedback during critical game moments. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "hard"
+}

package/library/game_development-puzzle/shooting-puzzle-game-with-target-interaction.json

@@ -0,0 +1,68 @@
+{
+  "index": 562,
+  "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 demonstration.\n\n======== ROLE ========\nYou are an experienced code expert. You are provided with a software development requirement description and asked to generate project code based on the requirement. Strictly follow the rules to help users generate complete project code with simple and easy-to-understand comments, without outputting anything else.\n\n======== OUTPUT RULES ========\n1. Always generate complete, runnable project code; please ensure the project is complete and executable\n2. Ensure all code files you output are complete, don't omit any code\n3. Carefully review and check all code before final output, evaluating its executability. If the code cannot be executed or contains errors, regenerate it\n4. If the requirements involve external API access or user data (images, videos, audio, etc.), please provide simulated data\n\n======== PROJECT REQUIREMENTS ========\nPlease create a shooting game combined with puzzle elements. As players explore the map, they need to shoot specific targets to unlock doors or trigger mechanisms, thus advancing the game process. The game includes puzzle design, target interaction, and logical level layout. Showcase the combination of puzzle-solving and shooting mechanics.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core shooting mechanism fully implemented?",
+      "description": "Review whether the code accurately implements a shooting system with proper collision detection, hit registration, and visual feedback. Check for weapon handling (aiming, firing), projectile physics, and hit effects. Score 0 if shooting mechanics are missing, 5 if basic shooting is implemented but lacks polish, and 10 if the shooting system is complete with visual and audio feedback.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the puzzle elements properly integrated with the shooting mechanics?",
+      "description": "Evaluate how puzzle elements interact with the shooting mechanics. Check if targets need to be hit in specific sequences, patterns, or timing. Puzzle complexity should increase progressively. Deduct 3 points if puzzles are too simple (just shooting static targets), 5 points if there's no variety between puzzles. Full score requires at least 3 distinct puzzle types that meaningfully combine shooting with problem-solving.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there a complete level progression system with door unlocking and mechanisms?",
+      "description": "Check whether shooting targets correctly triggers mechanisms (doors opening, platforms moving, etc.). Verify that the cause-effect relationship is clear to players through visual/audio cues. Deduct 5 points if mechanism feedback is delayed/unclear, and 3 points if the progression logic has gaps. Full score requires a complete system where progress is clearly tracked and mechanisms respond instantly to correct solutions.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the game map/level design conducive to the gameplay concept?",
+      "description": "Evaluate whether the map layout supports both shooting and puzzle-solving, with appropriate spacing, cover elements, and visibility of interactive targets. Check if the level design guides players naturally without explicit instructions. Deduct 5 points for confusing layouts, 3 points for repetitive environments. Full score requires thoughtful level design that creates interesting shooting challenges while making puzzle elements intuitive.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code handles common edge cases (physics glitches, rapid fire exploits, collision edge cases, etc.) and provides error handling for game-breaking scenarios. Code should gracefully handle player attempts to break puzzle sequences. Deduct 5 points for each unhandled critical path bug, 3 points for minor exploitable mechanics. Full score requires comprehensive edge case handling and prevention of sequence-breaking.",
+      "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 weapons with unique puzzle-solving properties 2. Environmental interactions beyond simple shooting 3. Dynamic difficulty adjustment based on player performance). 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 shooting/puzzle mechanisms 2. Feature bloat unrelated to core gameplay (e.g., complex inventory system in a focused puzzle-shooter) 3. Unnecessarily complex visual effects that detract from gameplay clarity. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are obscured by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (separation of game mechanics, rendering, input handling, etc.), code structure, and potential for extension. Check for proper object-oriented design with clear class responsibilities. Deduct 5 points if global state is overused; deduct 5 points if the code has high coupling between unrelated systems; 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 game UI follows good design principles: 1) Clear distinction between interactive and decorative elements 2) Intuitive indicators for puzzle progress and shooting feedback 3) Consistent visual language throughout the game. Deduct 3 points for cluttered HUD elements, 5 points for unclear puzzle state indicators, and 5 points for illegible text or confusing iconography. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the player feedback system effective and satisfying?",
+      "description": "Judge whether the game provides appropriate feedback for player actions: 1) Immediate visual/audio response to shots 2) Clear indication when puzzle elements are activated 3) Distinctive feedback for correct vs. incorrect solutions. Deduct 5 points for delayed feedback on critical actions, 3 points for ambiguous success/failure indicators, and 5 points for lack of progressive feedback during multi-step puzzles. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "medium"
+}

package/library/game_development-puzzle/simple-tetris-game-in-html.json

@@ -0,0 +1,68 @@
+{
+  "index": 1064,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate, professional responses. Be sure to provide executable code for demonstration purposes. Help me write a simple Tetris game in HTML.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core Tetris game mechanics fully implemented?",
+      "description": "Review whether the code accurately implements Tetris mechanics including: piece rotation, movement (left, right, down), collision detection, line clearing, and scoring. Score 0 if the core mechanics are missing, 5 if basic movement is implemented but with flaws, and 10 if all standard Tetris rules are properly implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are all seven standard Tetromino pieces implemented correctly?",
+      "description": "Check if all seven Tetris pieces (I, O, T, S, Z, J, L) are implemented with correct shapes, colors, and rotation behaviors. Each piece should have 4 blocks and follow standard Tetris rotation patterns. Deduct 2 points for each missing piece type, and 1 point for each incorrectly implemented rotation behavior. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the game loop and timing mechanism properly implemented?",
+      "description": "Evaluate if the game implements proper timing mechanisms for automatic piece descent, with increasing difficulty (speed) as the game progresses. Check if requestAnimationFrame or similar methods are used for smooth animation. Deduct 5 points if the timing is inconsistent, 3 points if difficulty progression is missing, and 2 points if the animation is choppy. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is a complete game interface with controls implemented?",
+      "description": "Check if the game includes a comprehensive UI with: next piece preview, score display, level indicator, game controls (keyboard or on-screen buttons), pause functionality, and game over state handling. Deduct 2 points for each missing essential component. 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 key presses, window resizing, browser compatibility issues, 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. Ghost piece showing where the current piece will land 2. Hold piece functionality 3. Custom themes or skins 4. Multiplayer capability or 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 methods) 2. Function modules unrelated to Tetris gameplay 3. Fancy effects that affect performance (e.g., excessive animations). 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), readability, maintainability, and appropriate commenting. 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; deduct 5 points if there are no comments explaining complex 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 for the game board and pieces 2) Proper layout spacing between UI elements 3) Clear visual distinction between active and upcoming pieces 4) Professional font system for score and level display. 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 responsive?",
+      "description": "Judge whether the game controls are responsive and fluid: 1) Key press response delay ≤ 100ms 2) Smooth piece movement and rotation 3) Clear visual feedback for line clears and scoring 4) Appropriate game over sequence. Deduct 5 points for laggy controls, 3 points for jerky animations, and 5 points for lack of visual feedback on important game events. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "medium"
+}

package/library/game_development-puzzle/sokoban-box-pushing-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1748,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Make sure the code you generate is executable and displayable. Please write a suggested Sokoban (box-pushing) game that I can run in my browser.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Sokoban game core mechanics fully implemented?",
+      "description": "Review whether the code accurately implements the core Sokoban mechanics including player movement, box pushing, collision detection with walls, and win condition verification. Score 0 if the basic push mechanics are missing, 5 if only basic movement is implemented without proper collision detection, and 10 if all game rules are fully included with proper win state detection.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are level design and progression implemented?",
+      "description": "Check whether the code includes a level system with multiple puzzles of increasing difficulty. Evaluate if levels are properly stored/loaded and if there's a progression system that tracks completed levels. Deduct 3 points if only a single level exists, 5 points if level progression is missing, and 2 points if difficulty scaling is poorly implemented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the game state management properly implemented?",
+      "description": "Evaluate whether the game implements proper state management including undo functionality, level restart, game saving/loading, and move counting. Deduct 3 points if undo functionality is missing, 3 points if there's no way to restart a level, and 4 points if game progress cannot be saved/loaded. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the game responsive and browser-compatible?",
+      "description": "Check whether the game renders properly across different screen sizes and browsers. Verify if the game adapts to different viewport dimensions, has touchscreen support for mobile play, and maintains aspect ratio without breaking the layout. Deduct 3 points for each major browser incompatibility, 5 points if the game is unplayable on mobile, and 2 points if the UI breaks on window resize. 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 moves, browser refresh, window resizing, 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. Custom level editor 2. Move optimization suggestions 3. Time-based challenges 4. Animation effects for pushing). 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 restart a level) 2. Function modules unrelated to Sokoban (e.g., unnecessary minigames within the main game) 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/input handling), 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 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) Movement response delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual feedback for valid/invalid moves. Deduct 5 points for each operation without feedback, 3 points for sluggish animations, and 5 points for confusing game state indicators. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "medium"
+}

package/library/game_development-puzzle/sokoban-game-implementation.json

@@ -0,0 +1,68 @@
+{
+  "index": 880,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the generated code is executable for demonstration. Write a perfectly functioning Sokoban game.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Sokoban game core mechanics fully implemented?",
+      "description": "Check whether the code implements all core game mechanics: player movement (up/down/left/right), box pushing, collision detection with walls, valid win condition checking. Score 0 if movement isn't implemented, 5 if only basic movement works without proper collision handling, and 10 if all core mechanics function perfectly including undoing moves.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the level design and loading mechanisms properly implemented?",
+      "description": "Evaluate whether the game includes a level system with multiple puzzles, level loading mechanism, and proper level representation (using arrays or matrices). Check if the game correctly renders different elements (walls, boxes, goals, player). Deduct 3 points if only one hardcoded level exists, 5 points if level design is flawed (e.g., unsolvable puzzles), and 3 points if there's no level completion tracking.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the game state management well-designed?",
+      "description": "Check if the code properly manages game states including player position, box positions, goal positions, move history for undo functionality, and level completion detection. Deduct 5 points if there's no move history tracking, 3 points if the win condition check is faulty, and 5 points if state reset between levels is buggy.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the game include essential quality-of-life features?",
+      "description": "Evaluate if the implementation includes: move counter, undo functionality, level reset, level selection, and game completion tracking. Deduct 2 points for each missing feature. Check if the game saves progress between sessions (local storage); deduct 3 points if missing.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid moves, edge cases in level design, 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. Move optimization suggestions 2. Automatic puzzle solver 3. Custom level editor 4. Score/time tracking 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 movement handling logics coexisting) 2. Function modules unrelated to Sokoban (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive animations 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/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 3 points if variable/function naming is unclear or inconsistent. 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 game design principles: 1) Clear visual distinction between game elements (walls, boxes, goals, player) 2) Proper layout and proportions (grid cells properly sized and aligned) 3) Professional visual feedback for interactions (movement, successful/unsuccessful pushes). Deduct 3 points for unclear visual distinctions, 5 points for inconsistent or cluttered layout, and 5 points for lack of visual feedback. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and responsive?",
+      "description": "Judge whether the game controls and animations conform to human perception characteristics: 1) Input response delay ≤ 100ms 2) Smooth movement animations (if implemented) 3) Clear visual and audio feedback for actions. Deduct 5 points for laggy movement, 3 points for jarring transitions between actions, and 5 points for confusing or missing feedback when attempting invalid moves. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "medium"
+}

package/library/game_development-puzzle/sokoban-nezha-puzzle-game-10-levels.json

@@ -0,0 +1,68 @@
+{
+  "index": 908,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Be sure to provide executable code in your demonstration. I would like to create a computer version of the Sokoban puzzle game with 10 levels, ranging from easy to difficult. The main character should be a pixel art version of Nezha. Please generate the code for me.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Sokoban game core mechanics fully implemented?",
+      "description": "Review whether the code accurately implements the core Sokoban mechanics including character movement, box pushing rules, collision detection with walls, and goal completion logic. Score 0 if the core mechanics are missing, 5 if basic movement and pushing are implemented but with flaws, and 10 if the complete Sokoban ruleset is properly implemented with accurate collision detection.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are all 10 levels implemented with appropriate difficulty progression?",
+      "description": "Verify that exactly 10 levels are implemented with a clear progression from easy to difficult. Each level should be solvable and properly tested. Deduct 2 points if fewer than 10 levels are provided, 5 points if difficulty progression is inconsistent or poorly balanced, and 3 points if any level is unsolvable. Check for level data structure organization and whether levels load correctly.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the Nezha pixel art character properly implemented?",
+      "description": "Evaluate the quality of the Nezha pixel art character implementation. The character should be recognizable as Nezha with distinct features (like the Fire-Tipped Spear, Universe Ring, or Wind Fire Wheels), have proper animations for different movements (up, down, left, right), and maintain pixel art aesthetic quality. Deduct 5 points if the character doesn't resemble Nezha, 3 points if animations are missing or poor, and 2 points if the pixel art style is inconsistent.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are the game state management and undo functionality properly implemented?",
+      "description": "Check whether the code includes proper game state management for tracking box positions, player position, and move history. An undo function should be available to revert previous moves. Deduct 5 points if there's no undo functionality, 3 points if state management is flawed or allows impossible states, and 2 points if the undo function has limitations (like limited steps). The full score requires a robust state management system.",
+      "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, window resizing, 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. Level editor 2. Move counter and optimal solution hints 3. Special animations for level completion 4. Sound effects for movement and completion). 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 movement control systems) 2. Function modules unrelated to Sokoban gameplay 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), code organization, reusability, 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 the code lacks comments or documentation. 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 good pixel art game design principles: 1) Consistent pixel art style throughout (character, boxes, walls, goals) 2) Clear visual distinction between game elements 3) Proper UI for level selection, game controls, and feedback. Deduct 3 points for inconsistent art style, 5 points for unclear visual elements that affect gameplay, and 5 points for poor UI layout or information display. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the game responsive and provides good user experience?",
+      "description": "Judge whether the game provides good usability and interaction design: 1) Responsive controls with minimal input lag 2) Clear visual feedback for valid/invalid moves 3) Proper level restart and navigation options 4) Game progress saving functionality. Deduct 3 points for control lag or unresponsiveness, 3 points for lack of visual feedback, 2 points for missing restart option, and 2 points for no save functionality. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "hard"
+}