@getollie/cli 0.0.1

package/library/game_development-puzzle/tetris-mini-game-text-document.json

@@ -0,0 +1,68 @@
+{
+  "index": 1510,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you provide is executable for demonstration. Help me write a Tetris mini-game, the kind that can be edited using a text document on a computer.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core Tetris gameplay fully implemented?",
+      "description": "Evaluate whether the code implements all essential Tetris mechanics: 1) Seven standard tetromino shapes, 2) Rotation system, 3) Line clearing with scoring, 4) Level progression with increasing speed. Deduct 5 points if rotation near walls/other pieces isn't handled properly (wall kicks), 3 points if line clearing animations are missing, and 5 points if level progression is absent.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are all standard Tetris controls implemented?",
+      "description": "Check for implementation of standard controls: 1) Left/right movement, 2) Rotation (clockwise/counterclockwise), 3) Soft drop, 4) Hard drop, 5) Hold piece functionality, 6) Next piece preview. Deduct 2 points for each missing control feature. Score 0 if movement and rotation aren't implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the game board correctly rendered in text format?",
+      "description": "Assess whether the code can properly render the game state in ASCII/text format with clear representation of: 1) Active tetromino, 2) Placed blocks, 3) Game boundaries, 4) Score/level information. Score 10 for crisp, readable rendering that works in standard console/text environment, 5 for basic but unclear rendering, 0 if board rendering is broken or unreadable.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the game loop implementation properly structured?",
+      "description": "Evaluate the quality of the game loop implementation: 1) Consistent frame rate/timing management, 2) Input handling without blocking, 3) Update-render separation, 4) Proper game state transitions (start, play, pause, game over). Deduct 5 points if timing is inconsistent causing gameplay issues, 3 points if input handling blocks rendering, 5 points if game states aren't properly managed.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid inputs, out-of-bounds conditions, unexpected termination) 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 tetromino will land, 2. Multiple difficulty modes, 3. High score tracking across sessions). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple collision detection methods) 2. Function modules unrelated to Tetris gameplay (e.g., unnecessary mini-games) 3. Fancy features that complicate a text-based implementation (e.g., complex animations that break text rendering). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game logic/rendering/input handling), clear function organization, and code readability. Deduct 5 points if global state is excessively used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no clear separation between game mechanics and rendering. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Is the text-based interface clearly structured and easy to understand?",
+      "description": "Evaluate whether the text interface follows good design principles: 1) Consistent character usage for different elements, 2) Clear boundaries and spacing, 3) Readable game information layout. Deduct 3 points for confusing character choices, 5 points for cramped layouts that make gameplay difficult, and 5 points for important game information being difficult to locate. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the game responsive and performant in a text environment?",
+      "description": "Judge whether the implementation works well within text environment constraints: 1) Acceptable refresh rate without excessive flickering, 2) Responsive controls without noticeable input lag, 3) Efficient clearing and redrawing that works on standard terminals. Deduct 5 points for screen flickering that hinders gameplay, 3 points for delayed input response, and 5 points for rendering approaches that would fail on basic terminals. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "hard"
+}

package/library/game_development-puzzle/tetris-mini-program-design.json

@@ -0,0 +1,68 @@
+{
+  "index": 780,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to make any code you provide executable and ready to run. Please help me design a working Tetris mini-program.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core Tetris game mechanics fully implemented?",
+      "description": "Review whether the code accurately implements tetromino movement (left/right/down), rotation, collision detection, and line clearing. Check if the game handles piece spawning, gravity, and increasing difficulty. Score 0 if core mechanics are missing, 5 if basic movement works but with issues, and 10 if all standard Tetris mechanics are properly implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the game board system properly designed?",
+      "description": "Evaluate the game board implementation, including grid system, block rendering, boundary checking, and state management. The board should handle piece locking, line clearing animations, and game over detection. Deduct 5 points if the grid system is inconsistent, 3 points if boundary checks are incomplete, and 5 points if game over detection is missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the Tetris gameplay features complete?",
+      "description": "Check if the code includes standard Tetris features like piece preview, piece holding, score system, level progression, and increasing speed. Deduct 3 points for each missing feature. The game should follow standard Tetris guidelines for scoring and difficulty progression. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the control system responsive and intuitive?",
+      "description": "Assess the implementation of keyboard/touch controls, including hard drop, soft drop, and wall kicks. Check whether the game supports both keyboard and touch controls with appropriate response times. Deduct 5 points if key controls are missing, 3 points if controls have noticeable input lag, and 3 points if proper control customization is absent. 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 resizing, game pausing/resuming, 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. Multiple game modes like marathon/sprint/ultra 3. Combo system with visual feedback). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple collision detection algorithms) 2. Function modules unrelated to Tetris (e.g., unnecessary animations that don't enhance gameplay) 3. Fancy effects that affect performance (e.g., excessive particle effects during line clears). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game logic/view/input handling layers), maintainability, and performance optimization. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the game loop implementation causes performance issues. 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 (clear contrast between tetrominos and background) 2) Proper layout spacing (game board, next piece preview, score display properly arranged) 3) Professional font system (readable score and level indicators). Deduct 3 points for each visual element that causes confusion, 5 points for poor color choices that make pieces difficult to distinguish, and 5 points for cluttered UI that obscures gameplay. 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 responds within 100ms 2) Line clear animations complete within 300-500ms 3) Game over sequence provides clear feedback. Deduct 5 points for laggy piece movement, 3 points for jerky animations, and 5 points for confusing or missing visual feedback during critical game events like level ups or game over. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "medium"
+}

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

@@ -0,0 +1,68 @@
+{
+  "index": 1130,
+  "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. Please write a mobile game program for Tetris.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Tetris core game mechanics fully implemented?",
+      "description": "Review whether the code accurately implements the 7 standard Tetris pieces (I, O, T, S, Z, J, L) with correct rotation states, proper grid-based movement system, line clearing detection, and gravity mechanics. Score 0 if basic piece spawning/movement is missing, 5 if only basic mechanics work without proper rotation, and 10 if all standard Tetris rules including wall kicks and T-spins are fully implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the mobile touch control system optimized?",
+      "description": "Check whether the touch controls are specifically designed for mobile devices including swipe gestures for movement, tap for rotation, swipe down for soft drop, and long press for hard drop. Evaluate touch responsiveness, gesture recognition accuracy, and haptic feedback. Deduct 5 points if gestures are unresponsive or conflicting, 3 points if no haptic feedback is provided. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the game progression and scoring system properly designed?",
+      "description": "Evaluate whether the scoring system follows standard Tetris mechanics with increasing difficulty levels, proper line clear bonuses (single, double, triple, Tetris), and speed progression. Check for combo scoring, level advancement triggers, and high score persistence. Deduct 5 points if scoring is inconsistent with Tetris standards, 3 points if no difficulty progression exists. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the game state management and persistence implemented?",
+      "description": "Check whether the code includes complete game state management with pause/resume functionality, game over handling, high score storage, and background/foreground state transitions for mobile. Evaluate local storage implementation for game progress. Deduct 5 points if no state persistence exists, 3 points if mobile lifecycle events aren't handled properly. Give 10 points if fully implemented with proper mobile state management.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid touch inputs, device rotation, memory constraints, browser compatibility issues, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should effectively handle edge cases and mobile-specific challenges, giving 10 points. If 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 enhance gameplay?",
+      "description": "Check whether the code includes engaging features that improve the mobile gaming experience (e.g., 1. Ghost piece preview 2. Hold piece functionality 3. Particle effects for line clears 4. Sound effects and music 5. Customizable themes). Add 2 points for each well-implemented feature that enhances gameplay without affecting performance (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 Tetris gameplay (e.g., built-in social media sharing) 3. Performance-heavy effects that cause frame drops on mobile devices. Deduct 3 points for each redundancy found, and directly deduct 10 points if core game performance is impacted by unnecessary features.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (separating game logic, rendering, input handling), code organization, and mobile optimization practices. Deduct 5 points if global state pollution is found or no clear architecture pattern is used; deduct 5 points if code duplication rate exceeds 30%; deduct 5 points if no mobile performance optimizations are implemented (like requestAnimationFrame usage). The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the mobile interface meet professional design standards?",
+      "description": "Evaluate whether the design is optimized for mobile screens: 1) Proper scaling for different screen sizes and orientations 2) Touch-friendly UI elements (minimum 44px touch targets) 3) Clear visual hierarchy with appropriate contrast ratios 4) Responsive layout that works on various mobile devices. Deduct 3 points for each UI element that's difficult to interact with on mobile, 5 points for poor readability, and 5 points for non-responsive design. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Are the animations and visual feedback smooth for mobile?",
+      "description": "Judge whether the visual effects are optimized for mobile performance: 1) Consistent 60fps gameplay without frame drops 2) Smooth piece movement and rotation animations 3) Satisfying visual feedback for line clears and piece placement 4) Proper loading states and transitions. Deduct 5 points for noticeable frame drops during gameplay, 3 points for jarring or missing animations, and 5 points for poor visual feedback that makes gameplay unclear. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "hard"
+}

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

@@ -0,0 +1,68 @@
+{
+  "index": 940,
+  "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. Create a \"Tetris\" program.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core Tetris game logic fully implemented?",
+      "description": "Check if the code correctly implements tetromino generation, rotation, movement, collision detection, and line clearing mechanisms. Verify if all seven standard tetromino shapes (I, J, L, O, S, T, Z) are included. Score 0 if core mechanics are missing, 5 if basic gameplay works but has flaws, and 10 if all standard Tetris rules are properly implemented including wall kicks and piece previews.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Does the game implement proper scoring and level progression?",
+      "description": "Evaluate if the scoring system follows standard Tetris conventions (points for single, double, triple, and tetris line clears with multipliers based on level). Check if game difficulty increases with level progression by accelerating piece descent speed. Deduct 5 points if scoring is simplistic or incorrect, 3 points if level progression is missing. Full score requires complete implementation of both systems with appropriate difficulty curves.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there a complete game state management system?",
+      "description": "Verify the presence of game states including start screen, gameplay, pause, game over, and high score displays. Check if the game properly transitions between these states and maintains appropriate data persistence. Deduct 5 points if state transitions are buggy, 3 points if high score tracking is missing, and 5 points if pause functionality is absent. Give 10 points for flawless implementation.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are the controls responsive and customizable?",
+      "description": "Test keyboard input handling for piece movement (left/right/down), rotation, hard drop, and hold functions. Check for input buffering to handle rapid keystrokes. Evaluate if controls are customizable or at least follow standard conventions. Deduct 5 points if controls feel unresponsive (>100ms delay), 3 points if standard functions are missing, and 5 points if there's no way to restart after game over.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid input, browser resize, focus loss, memory management) 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 landing position 2. Piece hold functionality 3. Background themes or music 4. Multiplayer support 5. Mobile-friendly touch controls). 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 game loop implementations) 2. Function modules unrelated to Tetris (e.g., unrelated mini-games) 3. Fancy effects that affect performance (e.g., excessive animations that slow down gameplay). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game logic/view/input layers), code organization, and maintainability. Deduct 5 points if global state pollution is found; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the code lacks comments or documentation. Check for consistent naming conventions and proper encapsulation of game elements. 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 classic Tetris aesthetics while incorporating modern principles: 1) Clear block visualization with distinct colors for each tetromino 2) Proper layout with game board, next piece preview, score display, and controls information 3) Appropriate text size and contrast for readability. Deduct 3 points for cluttered UI elements, 5 points for indistinguishable tetromino colors, and 5 points for poor information hierarchy. 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 transitions feel natural: 1) Piece movement appears fluid and responsive 2) Line clear animations are satisfying but not disruptive to gameplay 3) Game over and level-up sequences provide clear feedback. Deduct 5 points for choppy piece movement, 3 points for jarring animations, and 5 points for performance issues at higher game speeds. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "hard"
+}

package/library/game_development-puzzle/tetris-program-web-browser.json

@@ -0,0 +1,68 @@
+{
+  "index": 1224,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate, professional replies. Make sure the code you generate is executable and ready to be displayed. Write a Tetris program that runs in a web browser.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core Tetris game mechanics fully implemented?",
+      "description": "Review whether the code correctly implements fundamental Tetris mechanics: tetromino generation, rotation, movement (left/right/down), collision detection, line clearing, and game over condition. Score 0 if core mechanics are missing, 5 if basic movement is implemented but with issues, and 10 if all standard Tetris rules are completely implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the tetromino rotation and wall kick system properly implemented?",
+      "description": "Check if the rotation system handles edge cases correctly, including wall kicks (adjusting position when rotation would cause collision). Evaluate against standard rotation systems like SRS (Super Rotation System). Deduct 3 points for each missing rotation feature (basic rotation, wall kicks, T-spin detection). The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the scoring and level progression systems implemented correctly?",
+      "description": "Evaluate if the game includes proper scoring (points for line clears with bonuses for multiple lines), level progression based on lines cleared, and increasing difficulty (speed) as levels increase. Deduct 3 points if scoring lacks combo/chain detection, 3 points if level progression is missing, and 4 points if speed doesn't increase with levels. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a preview system for upcoming tetromino pieces?",
+      "description": "Check if the game shows the next piece(s) coming up, and whether it implements a 'hold' feature allowing players to save a piece for later use. Deduct 5 points if next piece preview is missing, 3 points if the hold feature is absent, and 2 points if the visual representation is unclear. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid input, browser resize, focus loss, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should handle pause/resume functionality and maintain game state. Give 10 points for comprehensive error handling, 5 points for average robustness, and 0 points if no exceptions are handled.",
+      "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 tetromino will land 2. Special effects for line clears 3. Customizable controls 4. Different game modes like Marathon/Sprint). 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 handle the same input) 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/rendering/input handling), code organization, and maintainability. Deduct 5 points if global state pollution is found; deduct 3 points if magic numbers are used instead of named constants; deduct 2 points if the code lacks comments/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 classic Tetris visual principles: 1) Clear tetromino colors with good contrast 2) Proper grid layout with visible boundaries 3) Well-positioned UI elements (score, level, next piece). Deduct 3 points for poor color choices, 3 points for unclear grid boundaries, and 4 points for cluttered or confusing UI layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and responsive?",
+      "description": "Judge whether the game controls and animations feel responsive and intuitive: 1) Input latency below 100ms 2) Smooth tetromino falling animations 3) Responsive key repeat for continuous movement 4) Satisfying visual/audio feedback for line clears. Deduct 3 points for input lag, 3 points for jerky animations, and 4 points for unresponsive or unintuitive controls. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "hard"
+}

package/library/game_development-puzzle/tetris-web-game-creation.json

@@ -0,0 +1,68 @@
+{
+  "index": 740,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate, professional responses. Make sure that the code you generate can be executed and displayed. Please help me create a Tetris web game.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core Tetris gameplay mechanics fully implemented?",
+      "description": "Review whether the code accurately implements the standard Tetris game mechanics including piece rotation, movement (left, right, down), hard drop, line clearing, and game over detection. Score 0 if the core interaction logic is not implemented, 5 if only basic movement is implemented, and 10 if all standard Tetris rules are fully included with proper collision detection.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the tetromino generation and display system properly implemented?",
+      "description": "Evaluate whether all seven standard tetromino shapes (I, O, T, S, Z, J, L) are correctly implemented with proper colors and rotation points. Check if the next piece preview functionality is available. Deduct 3 points if any shape is missing or incorrectly implemented, 2 points if rotations aren't handled properly, and 2 points if there's no next piece preview. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the scoring and level progression system implemented?",
+      "description": "Check whether the game includes a proper scoring system (points for line clears, with bonuses for multiple lines), level progression (increasing difficulty/speed as the score increases), and if statistics are tracked (lines cleared, score, level). Deduct 3 points for missing scoring, 3 points for no level progression, and 4 points for no game statistics. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the game control system responsive and user-friendly?",
+      "description": "Assess if the game implements both keyboard controls and on-screen buttons (for mobile compatibility), has control customization options, and provides responsive input handling (≤100ms delay). Deduct 3 points if keyboard controls are incomplete, 3 points if mobile controls are missing, and 4 points if there's noticeable input lag. 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 resize events, device orientation changes, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Ghost piece showing where the current piece will land 2. Hold piece functionality 3. Different game modes like Marathon/Sprint/Ultra). 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 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 organization of game components. 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 (tetromino colors should be distinct yet coherent) 2) Proper layout spacing (game board, next piece, score display have clear separation) 3) Professional font system (score/level displays are clearly readable, game over screens are prominent). 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) Piece movement is smooth and responsive 2) Line clear animations are satisfying but not distracting 3) Game over sequence provides clear feedback. Deduct 5 points for jarring or missing animations, 3 points for inconsistent movement speed, and 5 points for confusing visual feedback during critical game events. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "medium"
+}

package/library/game_development-puzzle/tetris-web-mini-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1747,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure the generated code is executable for display. Help me create a Tetris web mini-game.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core Tetris gameplay system fully implemented?",
+      "description": "Review whether the code accurately implements the falling tetromino mechanics, block rotation (with wall kicks), line clearing, and scoring system. Score 0 if the core gameplay logic is missing, 5 if only basic pieces movement is implemented, and 10 if it includes advanced features like hard drop, ghost piece preview, and proper randomization of pieces.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Does the game handle user input correctly?",
+      "description": "Check whether keyboard/touch controls are implemented properly with responsive handling of move left/right, rotate, soft drop and hard drop actions. Deduct 3 points if only keyboard or only touch controls are implemented, 5 points if there's noticeable input lag (>100ms), and 2 points if rotation handling doesn't include wall kick mechanics. Full score requires both keyboard and touch support with configurable controls.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there a complete game state management system?",
+      "description": "Evaluate whether the game includes proper state management (start screen, gameplay, pause, game over states) and transitions between these states. Check if the game allows pausing, resuming, and restarting. Deduct 5 points if there's no pause functionality, 3 points if game state isn't preserved between sessions, and 2 points if state transitions are abrupt or confusing.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the game implement proper collision detection and boundary checks?",
+      "description": "Check whether the code properly detects collisions between tetrominos and walls/floor/other blocks, prevents pieces from moving outside the boundaries, and correctly handles piece locking when it lands. Deduct 5 points if pieces can overlap with existing blocks, 5 points if pieces can escape game boundaries, and 3 points if there are detectable bugs in the locking mechanism.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid repeated inputs, browser resize events, focus loss, memory leaks, etc.) and provide friendly error 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 2. Special pieces or power-ups 3. Multiplayer mode or leaderboards 4. Custom themes or visual 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 game loop implementations) 2. Function modules unrelated to Tetris (e.g., unrelated mini-games) 3. Fancy effects that affect performance (e.g., excessive animations that cause frame drops). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game logic/rendering/input handling), appropriate use of design patterns, and code maintainability. Deduct 5 points if global state pollution is found; deduct 5 points if the code duplication rate is too high (over 30%); deduct 3 points if naming conventions are inconsistent. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface design meet professional standards?",
+      "description": "Evaluate whether the game UI follows modern design principles: 1) Clean, readable game grid with distinct block colors 2) Proper layout with next piece preview and score display 3) Responsive design that works on different screen sizes. Deduct 3 points for cluttered UI elements, 4 points for poor color contrast that makes blocks hard to distinguish, and 5 points for layouts that break on mobile devices. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the game performance smooth and optimized?",
+      "description": "Judge whether the game runs at a consistent frame rate (60 FPS), renders efficiently without visual stuttering, and optimizes browser resources. Deduct 5 points for noticeable frame drops during gameplay, 3 points for inefficient rendering (e.g., redrawing the entire board instead of just changed blocks), and 5 points if the game causes significant battery drain or browser slowdown. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "medium"
+}

package/library/game_development-puzzle/tetris-web-version-mini-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1304,
+  "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 display. Create a Tetris web version mini-game.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core Tetris game logic fully implemented?",
+      "description": "Evaluate whether the code implements all core Tetris mechanics: tetromino random generation, rotation (including wall kicks), movement, collision detection, line clearing, and increasing difficulty levels. Score 0 if the core game logic is incomplete, 5 if basic movement and collision are implemented but lacking certain features, and 10 if all standard Tetris mechanics are correctly implemented according to modern Tetris guidelines.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the game board rendering system properly implemented?",
+      "description": "Check if the game board is correctly rendered using HTML5 Canvas or DOM elements, with proper grid system, piece preview, and next piece display. Review whether the rendering is performant (60+ FPS) even during fast piece drops and line clears. Deduct 3 points if rendering is flickering, 5 points if the game slows down during animations, and 2 points if the grid alignment is inconsistent. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the game controls responsive and user-friendly?",
+      "description": "Examine keyboard controls implementation including left/right movement, rotation, soft drop, hard drop, and hold functionality. Check for touch controls on mobile devices. Deduct 3 points if key repeat rates are not optimized for gameplay, 5 points if any standard control is missing, and 3 points if there's noticeable input lag. Award 2 bonus points for customizable controls. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the scoring system and game progression properly implemented?",
+      "description": "Verify the implementation of standard Tetris scoring mechanics (single/double/triple/tetris line clears), level progression, and speed increase. Check if the game tracks and displays high scores. Deduct 5 points if scoring doesn't follow standard Tetris rules, 3 points if level progression is absent, and 2 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 browser resizing, tab switching, invalid inputs, 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 tetromino will land 2. Hold piece functionality 3. Battle mode or AI opponent 4. Special visual effects for Tetris clears or combos). 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 game loop implementations) 2. Function modules unrelated to Tetris (e.g., unrelated mini-games) 3. Fancy effects that affect performance (e.g., excessive particle effects 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 organization, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 3 points if the codebase lacks comments or documentation. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern game UI principles: 1) Clear visual distinction between game area and information panels 2) Readable score and level displays (even during fast gameplay) 3) Professional color scheme that enhances gameplay visibility 4) Responsive design that works across different screen sizes. Deduct 3 points for each UI element that hinders gameplay, 5 points for poor readability, and 5 points for non-responsive design. 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 Tetris gameplay standards: 1) Piece movement feels responsive (≤ 100ms delay) 2) Line clear animations are satisfying but quick (≤ 500ms) 3) Game over and level up transitions are clear without disrupting flow. Deduct 5 points for laggy piece movement, 3 points for jarring or missing animations, and 5 points for unresponsive controls during animations. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "hard"
+}