@getollie/cli 0.0.1

package/library/game_development-puzzle/fruit-matching-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 256,
+  "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 for demonstration. Help me design a fruit matching game using HTML code. Please provide me with a complete code.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core fruit matching mechanic fully implemented?",
+      "description": "Review whether the code accurately implements the matching logic, including detection of adjacent fruits, pattern recognition (minimum 3 matching fruits), and handling of cascading matches when new fruits fall. Score 0 if matching logic is missing, 5 if only basic matching is implemented, and 10 if advanced matching patterns and cascading effects are included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the game board generation and fruit distribution implemented properly?",
+      "description": "Check whether the code includes dynamic board generation with appropriately sized grid cells, random but balanced fruit distribution (avoiding pre-matched patterns), and proper visual representation of different fruit types. Deduct 5 points if the board is static/hardcoded, 3 points if fruit distribution lacks variety. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there a scoring system and game progression mechanism?",
+      "description": "Evaluate whether the game includes a proper scoring system (points for matches, bonuses for combos/larger matches), level progression, and increasing difficulty (time limits, target scores, etc.). Give 0 points if scoring is missing, 5 points if basic scoring exists, and 10 points if a complete progression system is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are animations and transitions implemented for game events?",
+      "description": "Check whether the code implements smooth animations for fruit swapping, matching/disappearing, new fruits falling, and special effects for combos/achievements. Deduct 5 points if animations are missing entirely, and 3 points if they look choppy or incomplete. 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, invalid moves, browser 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-up fruits 2. Unique visual/sound effects for combos 3. Personalized themes or customization). 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) 2. Function modules unrelated to fruit matching (e.g., unnecessary mini-games) 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/controller), code readability, 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 code documentation or comments. 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 (fruit colors contrast nicely with background) 2) Proper layout spacing (game board centered, UI elements properly aligned) 3) Professional font system (readable score display, clear instructions). 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 game interactions conform to human perception characteristics: 1) Fruit selection/swapping responds within 100ms 2) Smooth transitions when fruits disappear/fall 3) Clear visual feedback for valid/invalid moves. Deduct 5 points for each operation without feedback, 3 points for jerky animations, and 5 points for confusing/unintuitive controls. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "medium"
+}

package/library/game_development-puzzle/gravity-control-html-javascript-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 142,
+  "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.\nPlease implement a gravity control feature using HTML and JavaScript. \n\n**Task**: Implement a gravity control feature that allows players to temporarily change the direction of gravity in the level to solve puzzles.\n\n**Hint**: You can control the gravity direction through keyboard inputs, and design levels that require specific gravity states to pass through.\n\nPlease include comments in your code to help other developers understand your implementation process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the gravity control mechanism fully implemented?",
+      "description": "Review whether the code accurately implements gravity physics simulation using JavaScript, including proper acceleration, terminal velocity, and collision response. Check if the gravity direction can be changed via keyboard inputs as specified in the requirements. Score 0 if gravity simulation is missing, 5 if only basic gravity is implemented in one direction, and 10 if directional gravity control (up, down, left, right) with proper physics is fully implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are interactive puzzle elements designed that utilize the gravity mechanics?",
+      "description": "Evaluate whether the code includes interactive elements (movable objects, platforms, obstacles) that respond to gravity changes. Score 5 if basic objects that respond to gravity are implemented, and 10 if there are multiple interactive elements designed specifically to create meaningful puzzle scenarios with the gravity control mechanics.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there level design that requires specific gravity states to complete?",
+      "description": "Check if at least one complete level is implemented that requires changing gravity direction to solve. Evaluate whether the level design challenges players to use the gravity mechanism strategically. Score 3 if a basic level exists, 7 if the level has interesting challenges, and 10 if multiple levels with escalating complexity in gravity usage are implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is proper visual feedback provided for gravity changes?",
+      "description": "Assess whether the code provides clear visual indicators when gravity direction changes (such as UI indicators, environment shifts, or particle effects). Score 0 if no visual feedback exists, 5 if basic indicators are implemented, and 10 if comprehensive, intuitive visual feedback is provided that clearly communicates the current gravity state to the player.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid gravity switching, edge cases in physics calculations, object intersections) and provide 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. Time-limited gravity shifts 2. Gravity strength adjustment 3. Special objects that have their own gravity fields). 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 physics functions 2. Function modules unrelated to the gravity puzzle (e.g., unnecessary gameplay elements) 3. Fancy effects that affect performance (e.g., excessive particle systems). 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 physics engine/game logic/rendering), code comments as required in the task, and overall structure. 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 comprehensive comments explaining the implementation process are missing. 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) Clear distinction between game elements and UI elements. Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for confusing game vs UI elements. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the gravity transition animation smooth and intuitive?",
+      "description": "Judge whether the gravity transition effects conform to human perception characteristics: 1) Visual indication begins ≤ 100ms after input 2) Transition animation duration controlled between 200-400ms 3) Objects respond naturally to gravity changes with appropriate acceleration curves. Deduct 5 points for abrupt gravity transitions, 3 points for unrealistic object movement during transitions, and 5 points for lack of directional indicators for current gravity state. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "medium"
+}

package/library/game_development-puzzle/how-to-design-implement-tetris-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1175,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure that the code you generate is executable. How would you design and implement code for a Tetris game?",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core Tetris game mechanics fully implemented?",
+      "description": "Review whether the code accurately implements the standard Tetris mechanics including piece rotation, movement, dropping, line clearing, and scoring. Check if the 7 standard Tetrimino shapes are correctly defined and if their rotation points follow official Tetris guidelines. Score 0 if core game logic is missing, 5 if basic movement is implemented but with flaws, and 10 if all standard Tetris mechanics are correctly implemented including wall kicks and SRS rotation system.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the game board properly implemented?",
+      "description": "Evaluate the implementation of the standard 10x20 game board (or 10x22 with hidden rows), boundary detection, collision detection, and grid system. Check if the board state is properly managed and updated. Deduct 5 points if the board dimensions are incorrect, 3 points if collision detection has bugs, and 2 points if the board state management is inefficient. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the game controls and user input handling implemented correctly?",
+      "description": "Check if the code handles keyboard/touch inputs properly with support for standard controls (left, right, rotate, hard drop, soft drop). Assess if the code implements DAS (Delayed Auto Shift) and ARR (Auto-Repeat Rate) for smooth piece movement. Deduct 3 points if key bindings cannot be customized, 3 points if there's significant input lag, and 5 points if critical controls are missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the game progression system properly implemented?",
+      "description": "Review the implementation of level progression, speed increases, scoring system, and next piece preview. Check if the game follows the standard Tetris scoring system with bonuses for T-spins, combos, and perfect clears. Deduct 3 points if level progression is missing, 3 points if the scoring system is incomplete, and 5 points if there's no next piece preview or hold feature. 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 unexpected inputs, game state inconsistencies, browser compatibility issues) 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. Battle mode features 4. Dynamic difficulty adjustment). 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 mechanisms) 2. Function modules unrelated to Tetris (e.g., unrelated mini-games) 3. Fancy effects that affect performance (e.g., excessive 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/view/controller layers), code readability, proper commenting, and efficient algorithms. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 3 points if the code duplication rate is too high (over 30%); deduct 3 points if the game loop implementation is inefficient. 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 modern design principles: 1) Clear block visibility and distinction 2) Readable score/level display 3) Proper layout with next piece preview and hold piece areas 4) Consistent color scheme following Tetris standards. Deduct 3 points for poor block visibility, 3 points for cluttered UI elements, 5 points for illegible text information. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the game runs at a consistent frame rate (60 FPS recommended), whether piece movements are smooth, and if animations (line clearing, game over) are visually appealing without disrupting gameplay. Deduct 5 points for frame rate drops during gameplay, 3 points for jerky piece movement, and 5 points for animations that interrupt the game flow. Check if the game timing system uses requestAnimationFrame or similar for smooth rendering. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "medium"
+}

package/library/game_development-puzzle/html-6x6-klotski-sliding-block-puzzle.json

@@ -0,0 +1,68 @@
+{
+  "index": 1793,
+  "question": "You are a code expert. Please utilize your professional knowledge to generate accurate and professional responses. Be sure to make the generated code executable for demonstration. Create a 6x6 Klotski (sliding block puzzle) game using HTML.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core Klotski puzzle mechanism implemented correctly?",
+      "description": "Evaluate whether the code accurately implements the 6x6 grid system with movable blocks, proper collision detection, and valid move validation. Check if blocks can only slide horizontally or vertically into empty spaces without jumping over other blocks. Score 0 if core sliding mechanism is missing, 5 if basic movement works but has bugs, and 10 if the sliding mechanism is flawless with smooth transitions.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is there a complete puzzle initialization and win-condition system?",
+      "description": "Check if the code includes proper puzzle initialization with blocks of different sizes positioned correctly on the 6x6 grid, a clear objective (typically moving a specific block to a target position), and win-condition detection. Deduct 3 points if initial state is hardcoded without variety, 3 points if win conditions are unclear, and 5 points if there's no win detection implemented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Does the game include a move counter and history tracking?",
+      "description": "Assess whether the implementation tracks the number of moves made, provides an undo/redo functionality, and maintains a move history that can be reviewed. Deduct 3 points if only basic move counting exists, 5 points if no undo functionality is provided, and 7 points if there's no history tracking at all. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a puzzle reset and level selection system?",
+      "description": "Evaluate if the game allows players to reset the current puzzle to its initial state and provides multiple puzzle configurations or difficulty levels to choose from. Deduct 3 points if only reset functionality exists without level selection, 5 points if neither feature is implemented properly. Give 10 points if both reset and level selection are fully functional with at least 3 different puzzle configurations.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid clicking, invalid moves, browser resize, etc.) and provide friendly error handling 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 when sliding blocks 2. Hint system for next optimal move 3. Timer/leaderboard functionality 4. Puzzle solving visualization). 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 Klotski (e.g., unnecessary 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 proper encapsulation is missing; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there are no 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 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) Clear visual distinction between blocks of different types and the game board. Deduct 3 points for poor block differentiation, 5 points for unclear or inconsistent visual hierarchy, and 5 points for confusing or cluttered UI. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the game interactions conform to human perception characteristics: 1) Immediate visual feedback on block selection and movement 2) Smooth transitions when blocks slide (150-300ms animation) 3) Clear indication of legal vs. illegal moves. Deduct 5 points if blocks move without animation, 3 points for laggy or jerky movements, and 5 points if there's no clear indication when attempting illegal moves. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "hard"
+}

package/library/game_development-puzzle/html-javascript-environmental-interaction-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 11,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable.\n\nPlease use HTML and JavaScript to implement environmental interaction.\n**Task**: Add environmental interaction functionality that allows characters to interact with objects in the scene, such as pushing boxes, pulling levers, etc.\n**Tip**: You can use a simple physics engine to implement object movement and design puzzle elements for levels. Please think through and answer in detail, aiming to implement a solution that is as complete as possible, meets the requirements, has a good game interface, and high playability. Note: Use HTML to implement the above functionality, ensuring it can be directly executed in the frontend.\n\nPlease include comments in your code to help other developers understand your implementation process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the character-object interaction system fully implemented?",
+      "description": "Evaluate whether the code accurately implements core interactions like pushing boxes and pulling levers with proper collision detection and physics calculations. Score 0 if interactions are absent, 5 if only basic interactions work, and 10 if multiple interactions are implemented with physical properties (mass, friction, momentum).",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the physics engine properly implemented?",
+      "description": "Check if the code includes essential physics calculations (collision detection, object momentum, velocity) and handles edge cases like stacking objects or preventing objects from passing through walls. Score 0 for no physics implementation, 5 for basic physics without edge cases, and 10 for robust physics handling all scenarios.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the interactive puzzle elements well-designed?",
+      "description": "Review whether the solution includes actual puzzle scenarios using the environmental interactions (e.g., box-pushing puzzles, lever-activated doors, pressure plates). Deduct 5 points if puzzle logic is inconsistent, 3 points if puzzle difficulty is poorly balanced. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the level design system implemented?",
+      "description": "Evaluate whether the code includes a level structure with progressive challenges, objectives, and states (solved/unsolved). Check for level progression logic and state management. Deduct 5 points if level state persistence is missing, 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 rapid input, out-of-bounds movement, object stacking, wall clipping, etc.) and provide friendly error handling 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. Physics-based chain reactions 2. Interactive tutorial system 3. Multiple solution paths for puzzles). 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 systems) 2. Function modules unrelated to environmental interaction (e.g., unnecessary scoring system) 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 physics/game logic/input handling/rendering layers), code organization, and implementation of design patterns. 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 are insufficient comments explaining complex physics calculations or 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 game UI principles: 1) Clear visual distinction between interactive and non-interactive elements 2) Intuitive feedback when interacting with objects 3) Visual cues for physics interactions (shadows, movement indicators). Deduct 3 points for each confusing interactive element, 5 points for unclear visual feedback, and 5 points for misleading physics representations. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the movement and physics interactions feel natural: 1) Character movement response ≤ 50ms 2) Physics calculations maintain 60fps even with multiple objects 3) Smooth transitions during object interactions. Deduct 5 points for each laggy interaction, 3 points for physics glitches during complex interactions, and 5 points for jerky animation during object movement. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "medium"
+}

package/library/game_development-puzzle/html-javascript-rubiks-cube-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 17,
+  "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 and displayable.\n\nPlease use HTML and JavaScript to implement a:\n\n### Gameplay\n1. **Choose Cube Level**: Players can select 2x2, 3x3, 4x4, or 5x5 Rubik's cubes.\n2. **Manipulate the Cube**: Rotate different layers of the cube using mouse controls.\n3. **Complete Restoration**: The goal is to unify the colors of all faces, with each face having a single color.\n\n### Game Features\n- **Highly Interactive**: Using Three.js technology, the game provides smooth 3D visual effects and a highly interactive user experience.\n- **Multiple Levels**: Offers different difficulty levels suitable for players of varying skill levels.\n- **Educational Value**: Exercises players' spatial imagination and logical thinking abilities.\n\n### Game Tips\n- **Learn Basic Formulas**: Understand and master some basic cube restoration formulas, such as top layer cross, corner block permutation, etc.\n- **Simple to Complex**: Beginners can start with lower-order cubes and gradually transition to higher-order cubes to progressively improve solving techniques.\n- **Practice Observation Skills**: When manipulating the cube, pay attention to color distribution and layer relationships to improve restoration efficiency.\n\n### Summary\n\"The Cube\" is not only a highly entertaining digital game but also an educational tool beneficial for mental development. It's suitable for players of all ages, whether cube enthusiasts or those seeking a challenge.\n\nPlease include comments in your code to help other developers understand your implementation process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Rubik's Cube core structure properly implemented?",
+      "description": "Review whether the code accurately implements the Rubik's Cube data structure through Three.js, correctly representing the cube's internal state with appropriate face/cubelet relationships. Check if the code maintains proper geometry for each cube level (2x2, 3x3, 4x4, 5x5) with accurate mapping of colors to faces.Score 0 if the core structure is missing, 5 if only basic representation exists, 10 if all cube levels are properly implemented with correct internal state management.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the cube rotation mechanism fully functional?",
+      "description": "Evaluate whether the code properly handles layer rotation mechanics, including face turns, middle layer rotations, and whole cube rotation. Check for quaternion-based rotation calculations, proper animation transitions between states, and maintenance of cube integrity during rotations.Score 0 if rotation is not implemented, 5 points for basic single-face rotations, 10 points for complete implementation including complex rotation patterns and animation transitions.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the different cube levels (2x2 to 5x5) properly implemented?",
+      "description": "Check if the code dynamically generates and handles different cube sizes from 2x2 to 5x5, with appropriate scaling, positioning, and rotation mechanics for each level. Verify that the complexity scales appropriately with cube size.Deduct 2.5 points for each missing or incomplete cube level. Give full 10 points only if all four cube levels function correctly with appropriate mechanics for each.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the solved-state detection mechanism implemented?",
+      "description": "Assess whether the code includes a system to detect when the cube is solved (all faces have uniform colors). Check for efficient algorithms that verify the solved state after each move without excessive performance impact.Score 0 if no detection exists, 5 points if basic detection is implemented with flaws, and 10 points for complete, efficient implementation with appropriate user feedback.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid mouse movements, browser resize events, performance limitations on different devices) 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. Cube solving algorithms visualization 2. Move history with undo/redo 3. Pattern generation for practice 4. Timer and move counter statistics).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 rotation handling systems) 2. Function modules unrelated to the Rubik's cube (e.g., unnecessary game elements) 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 cube logic/rendering/interaction layers), code organization, and optimization techniques. Check for proper use of Three.js best practices and efficient rendering approaches.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 techniques are not implemented. 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 (beyond just the cube colors) 2) Proper layout spacing for UI controls 3) Professional font system for instructions and UI elements.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 3D interactions conform to human perception characteristics: 1) Cube rotation responsiveness ≤ 100ms 2) Smooth animation transitions between 300-500ms 3) Intuitive mouse/touch controls for cube manipulation.Deduct 5 points for each operation without feedback, 3 points for jerky animations during rotations, and 5 points for unintuitive or hard-to-discover interaction controls. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "hard"
+}

package/library/game_development-puzzle/html-javascript-sudoku-solver.json

@@ -0,0 +1,68 @@
+{
+  "index": 1762,
+  "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. \n\nRow 1: 0, 0, 6, 0, 8, 0, 2, 4, 0\nRow 2: 5, 0, 2, 0, 0, 6, 0, 0, 0\nRow 3: 4, 0, 0, 0, 0, 0, 0, 3, 6\nRow 4: 0, 4, 0, 8, 0, 1, 0, 0, 0\nRow 5: 7, 0, 0, 0, 0, 0, 0, 0, 2\nRow 6: 0, 0, 0, 4, 0, 5, 0, 8, 0\nRow 7: 6, 1, 0, 0, 0, 0, 0, 0, 4\nRow 8: 0, 0, 0, 1, 0, 0, 5, 0, 8\nRow 9: 0, 5, 7, 0, 6, 0, 9, 0, 0\n\nThe number 0 represents blank spaces.\nPlease generate JavaScript code embedded in HTML to solve this Sudoku puzzle.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Sudoku solver algorithm correctly implemented?",
+      "description": "Evaluate whether the algorithm (backtracking, constraint propagation, etc.) correctly solves the given puzzle. Check if all Sudoku rules are enforced: each row, column, and 3x3 grid contains digits 1-9 without repetition. Award 0 points if the solver doesn't work, 5 points if it works but with inefficient algorithm (e.g., brute force without optimizations), and 10 points if it implements an efficient algorithm with proper constraint checking.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the initial Sudoku grid properly represented and displayed?",
+      "description": "Check if the provided initial Sudoku grid (with the specific numbers in the question) is correctly displayed in the UI. Verify that the grid structure maintains 9x9 format with clearly visible 3x3 subgrids. Award 0 points if the grid is incorrect, 5 points if partially implemented with visual issues, and 10 points for perfect representation with appropriate styling.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Does the solution provide visual feedback during the solving process?",
+      "description": "Assess whether the solution visualizes the solving process (e.g., step-by-step animation, highlighting cells being considered, showing backtracking). Award 0 points for no visualization, 5 points for basic changes only at the end, and 10 points for comprehensive visualization with speed control or step-by-step options.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is user interaction implemented for manual solving assistance?",
+      "description": "Evaluate whether the implementation allows user interaction such as manually entering numbers, requesting hints, or controlling the solving process (start/pause/resume/step). Award 0 points for no interaction, 5 points for basic controls, and 10 points for comprehensive interaction including validation of user inputs against Sudoku rules.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle edge cases (invalid inputs, unsolvable puzzles, multiple solutions). Check for appropriate error handling and user feedback. 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 solving algorithms with comparison 2. Performance statistics of solving time/steps 3. Mobile-responsive design 4. Dark mode toggle). 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 solving algorithms without clear purpose) 2. Function modules unrelated to Sudoku solving (e.g., unnecessary animations) 3. Fancy effects that affect performance (e.g., excessive DOM manipulations). 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 UI logic from solving algorithm), 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 of concerns. 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) Cell highlighting and number updates occur without visual lag 2) Transition animations when displaying solutions are controlled between 300-500ms 3) Clear visual distinction between original numbers and solved numbers. Deduct 5 points for each operation without feedback, 3 points for visual jarring during fast solving, and 5 points for confusing visual states. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "easy"
+}

package/library/game_development-puzzle/html-math-game-quadratic-equations-radicals.json

@@ -0,0 +1,68 @@
+{
+  "index": 1777,
+  "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 and functional. Design an HTML-based math game centered around quadratic radical operations and solving linear quadratic equations. Include a scoring system and a time limit system.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core quadratic radical operation functionality fully implemented?",
+      "description": "Review whether the code accurately implements a system for quadratic radical operations (simplification, addition, multiplication, etc.). Check if the mathematical logic correctly handles operations like √(a²) = |a|, √(a × b) = √a × √b when a,b ≥ 0. Score 0 if the core math operations are incorrect, 5 if basic operations work but edge cases are unhandled, and 10 if all operations are mathematically sound with proper error handling.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the linear quadratic equation solving system properly implemented?",
+      "description": "Evaluate whether the code can generate valid linear and quadratic equations for solving, with proper validation of user input and solution verification. Check if the quadratic formula (-b ± √(b² - 4ac))/2a is correctly implemented with discriminant handling. Deduct 5 points if the system only handles specific coefficient cases, 3 points if imaginary solutions aren't properly addressed, and 2 points if rounding errors affect solution validation. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the scoring system comprehensive and fair?",
+      "description": "Check whether the scoring logic rewards correct answers appropriately with graduated difficulty levels. Verify if the system handles partial credit for multi-step problems, and if score tracking persists across game sessions. Deduct 4 points if scoring doesn't account for problem difficulty, 3 points if there's no visual feedback after scoring events, and 3 points if high scores aren't tracked. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the time limit system properly implemented and user-friendly?",
+      "description": "Assess whether the timer is accurately implemented with appropriate visual cues as time runs low. Check if the system has pause/resume functionality and handles timeout events gracefully. Deduct 4 points if the timer has synchronization issues, 3 points if there's no warning for low time remaining, and 3 points if time penalties/bonuses aren't incorporated for wrong/right answers. 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 inputs, division by zero, incorrect equation formats, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle mathematical edge cases (e.g., irrational results, large numbers), 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. Visual representation of equations/solutions 2. Progressive difficulty adjustment based on user performance 3. Step-by-step solution explanations). 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 mathematical functions (e.g., multiple equation-solving algorithms) 2. Function modules unrelated to math learning (e.g., unnecessary animations) 3. Fancy effects that affect performance or distract from the learning experience. 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 math logic/view/game state management), unit test coverage for mathematical operations, and clean implementation. 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 mathematical functions aren't properly abstracted. 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) Mathematical notation is clear and properly rendered (e.g., using MathJax/KaTeX) 2) Proper layout spacing for equations and input fields 3) Professional font system with appropriate sizing for mathematical expressions. Deduct 3 points for each hard-to-read equation, 5 points for cluttered mathematical notation, and 5 points for inconsistent mathematical formatting. 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 answer submission ≤ 100ms 2) Smooth transitions between problems 3) Clear visual guidance when entering mathematical expressions. Deduct 5 points for each math operation without feedback, 3 points for laggy equation rendering, and 5 points for confusing input methods for mathematical symbols. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "medium"
+}