@getollie/cli 0.0.1

package/library/game_development-puzzle/spider-solitaire-game-implementation.json

@@ -0,0 +1,68 @@
+{
+  "index": 860,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the code you generate is executable for demonstration. Help me write a code for Spider Solitaire that can be directly saved in a document and be ready to run.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Spider Solitaire game mechanics fully implemented?",
+      "description": "Review whether the code accurately implements the standard Spider Solitaire rules with card stacking sequences (King to Ace), moving complete sequences, and the ability to deal new cards when all columns have at least one card. Score 0 if core game mechanics are missing, 5 if basic card movement is implemented but with rule errors, and 10 if all standard rules are correctly implemented including different difficulty levels (1, 2, or 4 suits).",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the card deal and deck management properly implemented?",
+      "description": "Check if the game correctly initializes with 10 columns of cards (with appropriate face-up/face-down distribution), handles the stock pile (5 additional deals of 10 cards each), and maintains proper game state between deals. Verify that cards can only be dealt when all columns have at least one card. Deduct 3 points if the initial deal is incorrect, 4 points if the stock pile management has errors, and 5 points if card dealing conditions aren't properly checked. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the card sequence completion and removal logic correct?",
+      "description": "Evaluate whether the code correctly identifies and handles completed sequences (King to Ace of the same suit) and automatically removes them from the tableau to the foundation. Check for proper validation of sequence completeness before removal and appropriate visual feedback. Deduct 5 points if completed sequences aren't detected properly, 3 points if removal animation is missing, and 5 points if the foundation display is not implemented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the move validation and undo functionality implemented?",
+      "description": "Check if the game validates all card moves according to Spider Solitaire rules (cards can only be placed on cards of next-higher rank regardless of suit, only sequences of same suit can be moved as a unit). Verify that an undo system tracks all moves and allows reversing actions. Deduct 5 points if move validation has errors, 3 points if undo functionality is limited or buggy, and 5 points if the game allows illegal moves. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid user clicks, attempting illegal moves, edge cases in game state) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should 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. Auto-complete functionality when game is solvable 2. Hint system that suggests possible moves 3. Statistics tracking for wins/losses/time 4. Different card themes/backgrounds). 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 card movement logics) 2. Function modules unrelated to Spider Solitaire (e.g., embedded mini-games) 3. Fancy effects that affect performance (e.g., excessive animations that slow down gameplay). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game logic/view/controller layers), code organization, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 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 game's visual design follows modern design principles: 1) Card design clarity and readability 2) Proper layout spacing between columns and cards 3) Professional color scheme with good contrast. Deduct 3 points for cluttered visuals, 5 points for poor card visibility or distinguishability, and 5 points for chaotic tableau layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the card interactions conform to user expectations: 1) Responsive drag-and-drop implementation 2) Clear visual feedback for valid/invalid moves 3) Smooth card dealing and sequence completion animations. Deduct 5 points for laggy card movement, 3 points for missing visual feedback during interactions, and 5 points for confusing or unintuitive controls. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "hard"
+}

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

@@ -0,0 +1,68 @@
+{
+  "index": 1094,
+  "question": "You are a coding expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the code you generate is executable for demonstration. Help me write a Sudoku game.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Sudoku game's core logic fully implemented?",
+      "description": "Review whether the code accurately implements the Sudoku board generation algorithm with unique solutions, validation of user inputs against Sudoku rules (no repeats in rows, columns, and 3x3 sub-grids), and puzzle difficulty levels. Score 0 if the core game logic is missing, 5 if only basic validation is implemented, and 10 if complete with puzzle generation, validation, and difficulty selection.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the Sudoku puzzle generation algorithm effective?",
+      "description": "Evaluate if the code includes a robust algorithm for generating valid Sudoku puzzles with unique solutions. Check for backtracking or other efficient techniques, proper removal of digits to create puzzles of varying difficulties, and verification that puzzles remain solvable. Deduct 5 points if puzzles have multiple solutions, 3 points if generation is inefficient (>500ms), and 5 points if difficulty levels aren't properly calibrated. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the user interaction features comprehensive?",
+      "description": "Check if the implementation includes essential Sudoku gameplay features: number input methods (keyboard/mouse), cell selection highlighting, candidate notation (pencil marks), mistake highlighting, undo/redo functionality, and timer. Deduct 2 points for each missing feature. Award full 10 points only if all these interaction elements are present and functioning correctly.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a hint/solving system implemented?",
+      "description": "Assess whether the game provides player assistance features like hints for the next move, checking current progress, or auto-solving capabilities. Examine if the solver uses efficient algorithms (e.g., constraint propagation, backtracking). Deduct 5 points if hints are random rather than strategic, 3 points if solving is brute-force only, and 2 points if visualization of the solving process 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 invalid inputs, conflicting entries, unsolvable puzzles) 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. Visual solving techniques highlighting 2. Statistics tracking and performance analytics 3. Interactive tutorial mode 4. Multiple visually distinct themes). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple validation methods doing the same thing) 2. Function modules unrelated to Sudoku (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive animations during number entry). 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), unit test coverage, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching with clear distinction between givens and user inputs 2) Proper layout spacing with well-defined grid lines and sub-grid boundaries 3) Professional font system with legible numbers and appropriate size contrast between candidates and confirmed digits. Deduct 3 points for each crowded visual element, 5 points for poor number legibility, and 5 points for insufficient visual distinction between interactive elements. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Immediate feedback on number entry ≤ 100ms 2) Smooth transitions when highlighting rows/columns/boxes 3) Clear visual indication of conflicts and errors. Deduct 5 points for each operation without feedback, 3 points for laggy transitions between game states, and 5 points for confusing selection highlighting. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "medium"
+}

package/library/game_development-puzzle/tangram-puzzle-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 541,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Ensure that the generated code is executable and functional.\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 these requirements. Strictly follow the rules to help users generate complete project code that is fully commented with simple, easy-to-understand language, without outputting anything else.\n\n## Output Rules ##\n1. Always generate complete, runnable project code, ensuring the project is fully executable\n2. Ensure that all code files you output are complete, without omitting any code\n3. Carefully review and check all code before final output, evaluating its executability. If the code cannot be executed or contains errors, it needs to be regenerated\n4. If the requirements involve external API access or user data (images, videos, audio, etc.), please provide simulated data\n\n## Project Requirements Description ##\nPlease develop a 'Tangram' puzzle game. The game interface is divided into two parts: an area displaying the target shape, and an area where players can manipulate the tangram pieces. The tangram consists of 7 geometric shapes (2 large triangles, 1 medium triangle, 2 small triangles, 1 square, and 1 parallelogram). Players can move each shape by dragging, rotate a shape by clicking on it, and flip a shape by double-clicking it. The goal of the game is to use these 7 shapes to create the target shape. The game should provide multiple target shapes of varying difficulty to choose from, a reset button to restore all shapes to their initial positions, and a hint feature (briefly showing the correct position of one shape). When the player successfully completes the target shape, display a congratulatory message and the time taken.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the tangram puzzle game fully implemented with all 7 geometric shapes?",
+      "description": "Check if the code correctly implements all 7 tangram pieces (2 large triangles, 1 medium triangle, 2 small triangles, 1 square, and 1 parallelogram) with appropriate visual representation. Each shape should have distinct characteristics and proper proportional sizes. Verify that the shapes can be properly rendered on the canvas/display area without visual artifacts. Score 0 if pieces are missing or incorrectly implemented, 5 if basic shapes are implemented but with proportion/rendering issues, and 10 if all shapes are perfectly implemented with proper scaling.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are all the required manipulation functionalities implemented correctly?",
+      "description": "Evaluate if the code implements all required piece manipulation: dragging (move), clicking (rotate), and double-clicking (flip). Check if event handlers are properly set up for each interaction type and if the geometric transformations are mathematically correct. Test edge cases like rapid consecutive clicks or interactions with partially off-screen pieces. Deduct 3 points if any manipulation feature is missing, 3 points if transformations have mathematical errors, and 2 points if edge cases cause visual glitches. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the target shape system implemented with multiple difficulty levels?",
+      "description": "Check if the code includes a variety of target shapes with different difficulty levels. Verify that target shapes are properly displayed and that the system can accurately determine when a player's arrangement matches the target (accounting for reasonable tolerance). Deduct 5 points if fewer than 5 different target shapes are available, 3 points if difficulty progression is not clear, and 5 points if the shape matching algorithm is inaccurate. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are the game's supporting features (reset, hints, completion detection) implemented?",
+      "description": "Evaluate if the code includes a reset function to restore pieces to initial positions, a hint feature that temporarily shows the correct position of one piece, and accurate completion detection with a congratulatory message and time tracking. Deduct 3 points if reset doesn't properly restore all pieces, 3 points if the hint system is ineffective, and 4 points if completion detection is unreliable or time tracking is inaccurate. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common edge cases (such as rapid interactions, browser resizing, touch vs. mouse input, etc.) and provide graceful degradation. Code should handle piece overlap conflicts, boundary conditions, and prevent pieces from becoming unusable (e.g., moved off-screen). Deduct 3 points for each unhandled edge case and 5 points if the game becomes unplayable due to common user interactions. The full score is 10 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 completing a shape 2. Custom tangram piece themes/colors 3. Progressive hint system that becomes less revealing with each use 4. Puzzle creation mode for users to design their own challenges). Add 2.5 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to reset the game) 2. Function modules unrelated to the tangram puzzle (e.g., a built-in calculator) 3. Fancy effects that affect performance (e.g., excessive particle animations that slow down gameplay). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game logic/view/input handling), code organization, and maintainability. Check if the game uses appropriate data structures for piece management and transformation operations. Deduct 3 points if global state is overused, 3 points if the code duplication rate is high, 2 points if there's poor separation of concerns, and 2 points if variable/function naming is unclear. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Clear visual distinction between the target area and manipulation area 2) Harmonious color scheme with good contrast between pieces 3) Professional layout with proper spacing between UI elements 4) Responsive design that works on different screen sizes. Deduct 3 points for cluttered interface elements, 3 points for poor color contrast making pieces hard to differentiate, and 4 points for non-responsive layouts that break on different devices. 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) Piece movement feels natural and responsive (≤ 100ms lag) 2) Rotation and flipping animations enhance understanding of the transformation 3) Clear visual feedback when pieces are selected or when a puzzle is completed. Deduct 4 points for laggy piece movement, 3 points for abrupt transitions during rotations/flips, and 3 points for lack of visual feedback during interactions. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "hard"
+}

package/library/game_development-puzzle/tetris-game-html-display.json

@@ -0,0 +1,68 @@
+{
+  "index": 749,
+  "question": "You are a coding expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code for display whenever possible. Help me create a beautiful Tetris game with HTML display.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core Tetris gameplay mechanic fully implemented?",
+      "description": "Review whether the code accurately implements the standard Tetris game mechanics including piece rotation, movement, hard/soft drop, line clearing, scoring system, and level progression. Score 0 if core gameplay is missing, 5 if basic movement is implemented but lacks features like wall kicks or proper collision detection, and 10 if all standard Tetris mechanics are properly implemented according to modern Tetris guidelines.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are all seven standard Tetriminos (I, O, T, S, Z, J, L) properly implemented?",
+      "description": "Check if all seven standard Tetriminos are correctly implemented with proper colors, shapes, and rotation systems. The code should use the SRS (Super Rotation System) or a similar modern rotation system. Deduct 1 point for each incorrectly implemented piece shape, 2 points for incorrect rotation behavior, and 5 points if the randomizer doesn't follow the 7-bag system or another fair distribution method. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there a complete game state management system?",
+      "description": "Evaluate whether the code includes proper game state management with start/pause/resume/game over states, level progression, score tracking, and next piece preview. Deduct 3 points if there's no pause functionality, 3 points if level progression is missing, 2 points if there's no next piece preview, and 2 points if high score persistence is not implemented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a responsive control system with keyboard support?",
+      "description": "Check if the game implements smooth, responsive controls with support for standard keyboard inputs (arrow keys, spacebar, etc.) and possibly touch controls for mobile. Deduct 3 points if keyboard controls are laggy or unresponsive, 3 points if there's no key repeat for horizontal movement, 2 points if hard drop is missing, and 2 points if there's no support for holding a piece. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common edge cases (such as rapid inputs, boundary conditions, browser resize events) and provide appropriate error handling. Code with strong robustness should handle frame rate independence, input buffering, and browser compatibility issues. Give 10 points if the code handles all these scenarios well, 5 points if it's average, and 0 points if critical robustness issues are present.",
+      "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 landing position 2. Hold piece functionality 3. Particle effects for line clears 4. Custom themes/skins 5. Sound effects and music with mute option). Add 2 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple collision detection algorithms) 2. Function modules unrelated to Tetris gameplay (e.g., unnecessary animations) 3. Fancy effects that affect performance (e.g., excessive particle systems 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/input handling), code organization, and performance optimization. Deduct 3 points if global state is overused, 3 points if the code has poor separation of concerns, 2 points if there's significant code duplication, and 2 points if rendering performance is poor (< 30 FPS). 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 follows modern principles: 1) Clean and consistent color scheme that enhances gameplay 2) Well-designed game board with clear grid lines and block visibility 3) Readable UI for score, level, and next piece display 4) Proper responsive layout for different screen sizes. Deduct 2 points for each visual inconsistency, 3 points for poor readability, 3 points for non-responsive design, and 2 points for cluttered interface. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the game's animations and interactions feel satisfying and responsive: 1) Pieces move fluidly with appropriate speed 2) Line clear animations are visually satisfying 3) Game over sequence provides clear feedback 4) Transitions between game states are smooth. Deduct 3 points for jerky animations, 3 points for missing visual feedback on important actions, 2 points for inconsistent game speed, and 2 points for abrupt transitions. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "hard"
+}

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

@@ -0,0 +1,68 @@
+{
+  "index": 942,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Take care to ensure that the code you generate is executable and can be demonstrated. Help me write a Tetris game using HTML.",
+  "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, collision detection, line clearing, and scoring. Score 0 if the core mechanics are missing, 5 if only basic movement is implemented, and 10 if all standard Tetris rules (including wall kicks, hard/soft drops, and piece holding) are fully included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the game board and tetromino rendering correctly implemented?",
+      "description": "Check whether the game renders the 10×20 standard Tetris board correctly, displays all seven tetromino shapes with proper colors, shows upcoming pieces, and maintains visual clarity. Deduct 3 points if the board dimensions are non-standard, 3 points if tetrominoes aren't visually distinguishable, and 5 points if the grid alignment is inconsistent. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the keyboard control system responsive and intuitive?",
+      "description": "Evaluate whether the game handles keyboard inputs appropriately (arrow keys for movement/rotation, space for hard drop, etc.), includes key repeat for continuous movement, and prevents input lag. Deduct 5 points if standard Tetris controls are missing, 3 points if there's noticeable input lag, and 2 points if there's no key repeat for continuous sideways movement. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are game state management and level progression implemented?",
+      "description": "Check whether the code includes proper game state management (start, pause, game over), level progression based on lines cleared or score, and increasing difficulty (speed). Deduct 4 points if state transitions are missing, 3 points if level progression isn't implemented, and 3 points if difficulty doesn't increase with levels. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle edge cases (rapid inputs, browser resize, tab switching, etc.) and prevent game state corruption. Code with strong robustness should have appropriate event listeners cleanup, animation frame management, and handle browser-specific quirks. Give 10 points for comprehensive error handling, 5 points for average robustness, and 0 points if critical bugs occur during normal gameplay.",
+      "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 preview showing where pieces will land 2. Piece holding system 3. Combo scoring system 4. Animated line clears or special effects). 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 collision detection methods) 2. Function modules unrelated to Tetris gameplay (e.g., unnecessary animations) 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 (separating game logic from rendering), code maintainability, and performance optimization. Deduct 5 points if global variables are excessively used, 3 points if game loop isn't optimized (e.g., using setInterval instead of requestAnimationFrame), and 2 points if there's significant code duplication. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the UI follows classic Tetris design principles: 1) Clear block colors with appropriate contrast 2) Proper sizing and spacing of game elements 3) Clean layout with separate areas for score, next piece, and game board. Deduct 3 points for cluttered layouts, 4 points for poor color choices making pieces hard to distinguish, and 3 points for inconsistent visual styling. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the piece movements and animations feel responsive and smooth: 1) Pieces move without stuttering 2) Line clear animations are satisfying but quick 3) Game over and level-up transitions are clear but non-disruptive. Deduct 4 points for stuttering movement, 3 points for jarring animations, and 3 points for delayed response to user input. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "hard"
+}

package/library/game_development-puzzle/tetris-game-javascript-implementation.json

@@ -0,0 +1,68 @@
+{
+  "index": 305,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code whenever possible. Write a Tetris game using JavaScript.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core Tetris game logic fully implemented?",
+      "description": "Review whether the code accurately implements tetromino generation, rotation mechanics, collision detection, line clearing, and scoring system. Score 0 if core mechanics are missing, 5 if basic movement and collision are implemented but with flaws, and 10 if all standard Tetris rules are properly implemented including wall kicks and tetromino randomization using the 7-bag system.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the game loop and rendering mechanism properly implemented?",
+      "description": "Check if the game uses requestAnimationFrame() or similar for smooth rendering, implements proper timing for tetromino descent with increasing difficulty levels, and handles pausing/resuming correctly. Deduct 3 points if the game loop causes performance issues, 3 points if timing is inconsistent, and 3 points if the pause functionality is missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are all standard Tetris controls and interactions implemented?",
+      "description": "Evaluate whether the game includes standard controls: left/right movement, rotation, soft drop, hard drop, and hold piece functionality. Check for responsive keyboard input handling with configurable controls. Deduct 2 points for each missing standard control and 3 points if input handling creates noticeable lag. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a complete game state management system?",
+      "description": "Assess whether the game includes proper state management for game initialization, active gameplay, level progression, game over conditions, and high score tracking. Deduct 3 points if game restart functionality is missing, 3 points if there's no level progression, and 4 points if high score persistence is not implemented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid input sequences, browser tab switching, window resizing, etc.) and provide friendly error handling. 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 tetromino will land 2. Next piece preview showing multiple upcoming pieces 3. Combo system with visual effects 4. Multiplayer capabilities). 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 scoring systems coexisting) 2. Function modules unrelated to Tetris gameplay (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/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 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 visual design follows modern game UI principles: 1) Clear block visualization with distinct colors for each tetromino 2) Proper layout with well-defined game area, score display, and next piece preview 3) Professional font system (readable score and level indicators). Deduct 3 points for cluttered UI elements, 5 points for poor color choices that make pieces hard to distinguish, and 5 points for unreadable or improperly scaled text elements. 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 responsive and natural: 1) Piece movement responds within 100ms of input 2) Line clearing animations are satisfying but not too lengthy (200-400ms) 3) Game over and level up transitions are clear and not jarring. Deduct 5 points for input lag, 3 points for choppy animations, and 5 points for disruptive or missing transition effects. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "hard"
+}

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

@@ -0,0 +1,68 @@
+{
+  "index": 1036,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Pay attention to ensuring the generated code is executable for demonstration. Help me design a Tetris game that I can load and play on my mobile phone.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core Tetris game mechanics fully implemented?",
+      "description": "Review whether the code accurately implements the Tetris game mechanics, including piece rotation, movement, collision detection, line clearing, and scoring. Score 0 if the core game logic is missing, 5 if only basic movement and collision are implemented, and 10 if all standard Tetris mechanics (including wall kicks, ghost pieces, and scoring system) are fully included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the mobile-first responsive design properly implemented?",
+      "description": "Check whether the game is properly optimized for mobile devices with responsive layout, appropriate touch controls (swipe gestures for movement, tap for rotation), and viewport meta tags. Verify if the game adapts to different screen sizes and orientations. Deduct 5 points if touch controls are poorly implemented, and 3 points if the game doesn't properly adapt to different screen orientations or sizes. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the game state management and persistence implemented?",
+      "description": "Evaluate whether the game implements state management for pausing/resuming gameplay and persists game data (high scores, current game) using localStorage or IndexedDB. Check if the game handles browser refresh and app closure gracefully. Deduct 5 points if game state isn't preserved on page reload, and 3 points if high scores aren't persistently stored. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the mobile performance optimization properly addressed?",
+      "description": "Assess whether the implementation considers mobile performance optimizations like requestAnimationFrame for rendering, touch event handling with proper debouncing, battery consumption awareness, and minimal DOM manipulation. Check for offline playability using service workers. Deduct 5 points for frame rate drops below 30fps on mid-range devices, and 5 points for lack of offline support. 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 input, browser compatibility issues, memory management, and touch event anomalies) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Multiple difficulty levels with speed adjustment 2. Special power-ups or challenges 3. Customizable themes or piece styles). 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 control schemes that conflict) 2. Function modules unrelated to Tetris (e.g., unnecessary animations or mini-games) 3. Fancy effects that affect mobile performance (e.g., excessive particle effects or 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 layers), code organization, and build process optimization for mobile delivery (minification, asset optimization). Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the assets aren't properly optimized for mobile delivery. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional mobile design standards?",
+      "description": "Evaluate whether the overall design follows modern mobile design principles: 1) Touch-friendly UI elements (minimum 44x44px tap targets) 2) Proper layout spacing for mobile screens 3) Professional font system with readable sizes on small screens (minimum 16px for primary text). Deduct 3 points for each hard-to-tap element, 5 points for poor contrast that affects visibility in different lighting conditions, and 5 points for elements that get cut off on common mobile screen sizes. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the mobile interaction smooth and intuitive?",
+      "description": "Judge whether the touch interactions conform to mobile user expectations: 1) Touch response delay ≤ 100ms 2) Intuitive swipe/tap controls that match standard Tetris actions 3) Clear visual and haptic feedback for interactions. Deduct 5 points for each touch interaction without feedback, 3 points for control schemes that feel unintuitive or conflict with system gestures, and 5 points for controls that are difficult to use with one hand. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "hard"
+}

package/library/game_development-puzzle/tetris-game-program-code.json

@@ -0,0 +1,68 @@
+{
+  "index": 764,
+  "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 for demonstration purposes. Please provide the program code for a Tetris game.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core Tetris gameplay mechanics fully implemented?",
+      "description": "Review whether the code correctly implements the standard Tetris game mechanics including tetromino generation, rotation, movement (left, right, down), dropping, line clearing, and scoring. The implementation should follow the official Tetris guidelines with proper collision detection. Score 0 if core gameplay is missing, 5 if basic movement is implemented but with flaws, and 10 if all standard Tetris rules are fully implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are all seven standard Tetris pieces (I, O, T, S, Z, J, L) correctly implemented?",
+      "description": "Verify that all seven tetromino shapes are properly defined and rendered with appropriate colors. Each piece should have the correct rotation patterns according to the Super Rotation System (SRS) or another recognized rotation system. Deduct 2 points for each missing piece or incorrect rotation implementation. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Does the game include level progression and increasing difficulty?",
+      "description": "Evaluate whether the game implements increasing difficulty through speed progression as players clear lines or reach higher scores. The game should have a clear level system with appropriate speed increases per level. Deduct 5 points if there's no level progression, 3 points if the difficulty curve is poorly implemented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a preview system for upcoming pieces and score tracking?",
+      "description": "Check if the game includes a next piece preview display and proper score tracking. A modern Tetris implementation should include at least a display of the next piece, scoring for different line clears (especially Tetris/4-line clears), and potentially hold piece functionality. Deduct 3 points for missing preview, 3 points for incomplete scoring system, and 2 points for missing hold function. 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 user inputs, edge-case rotations near walls, timing 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 tetromino will land 2. Hold piece functionality 3. Wall kick system 4. Combo system 5. T-spin recognition). Add 2 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to handle the same key press) 2. Function modules unrelated to Tetris (e.g., a built-in calculator) 3. Fancy effects that affect performance (e.g., excessive animations that slow down gameplay). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game logic/view/control layers), code organization, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if magic numbers are used throughout the code instead of named constants. 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) Clean grid layout with clearly defined play area and information panels 2) Harmonious color scheme for blocks and background 3) Clear, readable fonts for score and level information 4) Appropriate sizing of all elements. Deduct 3 points for cluttered layout, 3 points for poor color choices that make pieces hard to distinguish, and 4 points for illegible text or poorly sized elements. 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 meet performance standards: 1) Input response delay ≤ 100ms 2) Smooth piece movement and rotation 3) Immediate visual feedback for line clears and scoring 4) Consistent frame rate without stuttering. Deduct 3 points for input lag, 3 points for jerky animations, 2 points for missing visual feedback, and 2 points for performance issues during intensive gameplay. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "medium"
+}