@getollie/cli 0.0.5 → 0.2.0

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

@@ -1,68 +0,0 @@
-{
-  "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

@@ -1,68 +0,0 @@
-{
-  "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

@@ -1,68 +0,0 @@
-{
-  "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"
-}

package/library/game_development-puzzle/tile-matching-game-eliminate-blocks.json

@@ -1,68 +0,0 @@
-{
-  "index": 1505,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the generated code is executable for demonstration. Help me write runnable code for a tile-matching game app that can eliminate matching blocks of the same color.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the tile-matching core gameplay fully implemented?",
-      "description": "Review whether the code accurately implements a grid system for the tiles with proper color assignment, detection of adjacent matches (vertical and horizontal), and elimination mechanics. Score 0 if the core matching logic is missing, 5 if only basic matching detection is implemented, and 10 if the code includes cascading matches, special combinations, and proper score calculation.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Does the game include proper initialization and state management?",
-      "description": "Check if the game properly initializes the game board with random or preset patterns, ensures there are valid moves at the start, and maintains game state (running, paused, game over). The code should handle the generation of new tiles after elimination. Deduct 5 points if the initialization doesn't guarantee playable states, and 3 points if there's no proper state management system. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the player interaction system well-designed?",
-      "description": "Evaluate the implementation of player controls (mouse/touch interactions) for selecting and swapping tiles. Check if the code validates move legality, provides visual feedback during interactions, and handles multi-input scenarios gracefully. Deduct 5 points if swapping mechanics aren't smooth, and 5 points if there's no visual feedback for selection/swapping. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Does the game include proper scoring and progression systems?",
-      "description": "Review whether the code implements a clear scoring mechanism based on matches (considering chain reactions, combo multipliers), level progression with increasing difficulty, and game objectives/win conditions. Deduct 5 points if scoring is simplistic (fixed points per match), and 5 points if there's no difficulty progression. 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 successive clicks, browser resize events, memory management for long gameplay sessions) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Special power-up tiles after specific patterns 2. Time-based challenges 3. Unique visual/sound effects for combos). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to check for matches) 2. Function modules unrelated to tile-matching (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive particle effects). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/view/input handling layers), maintainability of the codebase, and optimization techniques. 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 performance optimization for rendering loops. 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) Harmonious color matching with visual clarity of different tile types 2) Proper layout with clear game boundaries and UI elements 3) Professional typography for score display and game messages. Deduct 3 points for cluttered game board, 5 points for poor color contrast between tiles, and 5 points for hard-to-read game text. 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) Responsive tile selection (≤ 100ms feedback) 2) Smooth animations for tile swapping and elimination (300-500ms) 3) Clear visual/audio feedback for matches and combos. Deduct 5 points for laggy animations, 3 points for abrupt transitions between game states, and 5 points for unclear visual feedback during matching. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "hard"
-}

package/library/game_development-puzzle/time-reversal-space-time-puzzles.json

@@ -1,68 +0,0 @@
-{
-  "index": 165,
-  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable if possible.\n\nPlease use HTML and JavaScript to implement a puzzle game: Time Reversal and Space-Time Puzzles\n\n**Task**: Design a time reversal system where players can rewind time to solve space-time puzzles and restore previous states.\n\n**Hint**: You can record scene states and restore these states when time is reversed.\n\nPlease create the game and include comments in the code so other developers can understand your implementation process.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Core Time Reversal Mechanism Implementation",
-      "description": "Review how effectively the code implements the fundamental time reversal system through state recording and restoration.Score 0 if no time reversal functionality exists, 5 if only basic state tracking is implemented, and 10 if the system can seamlessly record and restore complex game states including player position, object states, and interactions. Check if the implementation uses an efficient data structure for state storage that balances memory consumption with rewind fidelity.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Space-Time Puzzle Design and Logic",
-      "description": "Evaluate the quality and complexity of the puzzles that utilize the time reversal mechanic.Check whether puzzles are specifically designed to leverage the time reversal mechanic in creative ways. Score 0 if there are no actual puzzles implemented, 5 if puzzles are basic and don't fully utilize the time reversal concept, and 10 if puzzles demonstrate complex cause-and-effect relationships across time that require creative thinking to solve. Puzzle progression should increase in difficulty and introduce new mechanics gradually.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "State Tracking and Restoration System",
-      "description": "Assess the implementation of the game state recording and playback systems.Evaluate how comprehensively game states are tracked and restored. Score 0 if state tracking is missing, 5 if only basic elements (like position) are tracked, and 10 if the system handles complex states including physics interactions, animations, and conditional triggers. Check for optimizations like delta compression or keyframing to reduce memory usage while maintaining accurate state reproduction.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Time Visualization and Player Feedback",
-      "description": "Examine how time manipulation is visually communicated to the player.Review whether the interface clearly indicates the current time state, rewind capacity, and provides clear visual/audio feedback during time manipulation. Score 0 if no visual feedback exists, 5 if basic indicators are present but unclear, and 10 if time manipulation includes intuitive UI elements, smooth visual effects (like color shifts, motion blur, or particle effects), and clear audio cues that enhance player understanding of the time mechanics.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Code Robustness",
-      "description": "Evaluate whether the code can handle common abnormal situations and edge cases.Examine error handling for scenarios like rapid time reversal commands, boundary conditions (beginning/end of time), user operation errors, and memory management during extensive time manipulation. 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": "Innovative Features",
-      "description": "Check for unique mechanics that enhance the time manipulation concept.Look for surprise features that enhance the experience (e.g., 1. Partial time reversal affecting only certain objects 2. Time dilation/slow-motion effects 3. Parallel timeline exploration). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Feature Efficiency and Relevance",
-      "description": "Check for unnecessary or redundant features that detract from the core experience.Strictly check three types of redundancy: 1. Multiple implementations of similar time manipulation functions 2. Function modules unrelated to the puzzle-solving or time mechanics 3. Visually impressive but performance-heavy effects that don't contribute to 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": "Code Engineering Quality",
-      "description": "Review the overall code structure, organization, and implementation quality.Review modular design (separation of time mechanics, puzzle logic, rendering, and input handling), code comments as requested, and pattern usage. Deduct 5 points if global state is poorly managed; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if comments are missing or insufficient for understanding the time reversal implementation. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Interface Design and Visual Clarity",
-      "description": "Evaluate whether the game interface follows professional design principles.Evaluate whether the overall design follows modern design principles: 1) Clear visual distinction between past/present/future states 2) Proper layout spacing with intuitive controls for time manipulation 3) Visual consistency in representing time-affected elements. Deduct 3 points for confusing time state representations, 5 points for unclear puzzle objectives, and 5 points for poor readability of critical game elements. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Interaction Smoothness and Responsiveness",
-      "description": "Judge the fluidity and responsiveness of time manipulation controls.Judge whether time manipulation feels intuitive and responsive: 1) Immediate feedback when initiating time reversal (≤100ms) 2) Smooth transitions between time states (no visual jarring) 3) Appropriate speed control for time reversal. Deduct 5 points for laggy time manipulation, 3 points for confusing visual transitions during time changes, and 5 points for unintuitive time control mechanisms. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "easy"
-}

package/library/game_development-puzzle/waste-sorting-game-webpage.json

@@ -1,68 +0,0 @@
-{
-  "index": 1794,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable for demonstration. Help me create a waste sorting game webpage.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core waste sorting mechanism fully implemented?",
-      "description": "Review whether the code accurately implements a waste categorization system (e.g., recyclable, hazardous, organic, landfill) with proper validation logic. Check if drag-and-drop or click-to-select interactions are implemented for sorting items into appropriate bins. Score 0 if core sorting logic is missing, 5 if basic sorting is implemented but lacks validation feedback, and 10 if the system includes comprehensive item recognition with immediate feedback.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the game progression and scoring system implemented?",
-      "description": "Evaluate whether the code includes a complete scoring mechanism that rewards correct sorting decisions and penalizes mistakes. Check if there are difficulty levels or time constraints that increase challenge as players progress. Deduct 5 points if scoring logic is inconsistent or missing, and 3 points if progression mechanics are absent. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the waste item database diverse and educational?",
-      "description": "Assess whether the game includes a varied database of waste items with accurate categorization information. Check if items have visual representations and educational descriptions about proper disposal. Deduct 5 points if fewer than 15 unique items exist, 3 points if categorizations are inaccurate, and 5 points if educational content is missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are the game mechanics and educational components balanced?",
-      "description": "Review whether the code balances entertainment value with educational content. Check if the game provides information about why items belong in certain categories and environmental impact. Deduct 5 points if the game is technically sound but lacks educational value, or vice versa. Give 10 points if both aspects are well integrated.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid clicks, incomplete drag operations, browser resize, mobile touch events) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Real-time environmental impact calculator 2. Localized waste sorting rules based on user location 3. Customizable waste items with image upload). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to reset game state) 2. Function modules unrelated to waste sorting (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive animations that slow loading time). 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 reusability, and optimization for performance. 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 no performance optimization considerations exist (e.g., excessive DOM manipulations). 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 (using appropriate colors for waste categories) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic bin-to-item visual relationships. 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) Drag-and-drop feedback delay ≤ 100ms 2) Animation duration controlled between 300-500ms for sorting feedback 3) Clear visual cues for correct/incorrect sorting decisions. Deduct 5 points for each operation without feedback, 3 points for stuttering animations during item movement, and 5 points for confusing interaction patterns. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "medium"
-}

package/library/game_development-puzzle/web-based-candy-crush-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 1159,
-  "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 help me create an HTML program for a web-based version of Candy Crush (Happy Elimination game).",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core game mechanics fully implemented?",
-      "description": "Review whether the code accurately implements the match-3 mechanics through HTML/JavaScript, including board generation, candy matching algorithms, and cascading effects when candies are eliminated. Score 0 if the core game logic is missing, 5 if only basic matching is implemented, and 10 if advanced features like special candies and combos are included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the board generation and candy management properly handled?",
-      "description": "Evaluate whether the game board dynamically generates candies with appropriate randomization, handles candy falling animations, and properly refills the board after matches. Check if the code prevents impossible game states and ensures at least one valid match is always available. Deduct 5 points if the board generation is static, and 3 points if refilling logic is flawed. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are special candies and power-ups implemented?",
-      "description": "Check if the game includes special candies (striped, wrapped, color bomb) that are created when matching more than 3 candies, and if these special candies have appropriate effects when activated. Evaluate if combinations between special candies create enhanced effects. Score 0 if no special candies exist, 5 if basic special candies are implemented, and 10 if all combinations work correctly.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the level progression and scoring system implemented?",
-      "description": "Assess whether the game has a complete level system with objectives (score targets, collecting specific candy types, etc.), move limits, and progression tracking. Check if the scoring system appropriately rewards larger matches and combo chains. Deduct 5 points if level objectives are missing, and 3 points if the scoring system is too simplistic. 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 swipes, rapid player inputs, browser resizing, etc.) and provide friendly error handling or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Unique candy types beyond standard match-3 games 2. Physics-based interactions or gravity effects 3. Customizable themes or board layouts). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to check for matches) 2. Function modules unrelated to Candy Crush gameplay (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive particle effects that slow down gameplay). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/view/controller layers), code reusability for similar candy types, and browser compatibility. Deduct 5 points if global variable 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 doesn't work across major browsers. 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) Vibrant but harmonious color palette suitable for a candy-themed game 2) Proper layout with clear visual hierarchy and adequate spacing between elements 3) Professional font system with readable text sizes (body font size ≥ 14px). Deduct 3 points for each crowded visual element, 5 points for a jarring color combination, and 5 points for disorganized UI components. 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 visual/audio feedback on candy selection (≤ 100ms) 2) Smooth candy swapping and elimination animations (300-500ms) 3) Satisfying cascading effects that pause appropriately between sequences. Deduct 5 points for each interaction without feedback, 3 points for choppy animations during combo chains, and 5 points for unintuitive swipe controls or candy selection. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "hard"
-}

package/library/game_development-puzzle/web-based-candy-crush-match-3-puzzle-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 1657,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code for display when possible. Help me create a web-based version of the Candy Crush-style match-3 puzzle game.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core match-3 game mechanic fully implemented?",
-      "description": "Check if the code properly implements the fundamental match-3 mechanics including: grid generation, piece swapping logic, match detection (horizontal/vertical/L-shapes/T-shapes), cascade effects after matches, and board refilling. Score 0 if core matching isn't implemented, 5 if only basic 3-in-a-row detection works, and 10 if all professional match variations are supported with proper animations.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are special candy/power-up mechanics implemented?",
-      "description": "Verify implementation of special candies created from matches of 4+ pieces (striped candies, wrapped candies, color bombs) with their specific effects. Check if the interactions between special candies are correctly handled (e.g., striped+wrapped combination). Deduct 3 points if only basic special candies exist, 5 points if combinations aren't implemented, and 7 points if animations for special effects are missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the level progression and scoring system properly designed?",
-      "description": "Evaluate if the game includes level objectives (score targets, specific piece collection, obstacle clearing), move limits, progression tracking, and star ratings. Check if scoring calculations account for combo multipliers and special candy creations. Deduct 5 points if objectives are missing, 3 points if scoring lacks depth, and 5 points if level progression isn't persistent. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Does the game include proper game state management and UI controls?",
-      "description": "Assess if the game handles different states (menu, playing, paused, game over) correctly with appropriate transitions. Check for UI elements including score display, move counter, level selector, restart button, and game over screen. Deduct 3 points for each missing critical UI element, and 5 points if state transitions are broken or 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 moves, rapid clicking, browser resizing, etc.) and provide friendly error handling. Check if the game prevents illegal moves and handles edge cases in the match detection algorithm. Deduct 3 points for each unhandled edge case, and 5 points if the game breaks under normal usage scenarios. 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. Daily challenges 2. Social sharing of scores 3. Custom themes or skins 4. Unique power-ups beyond standard match-3 games). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple scoring systems) 2. Function modules unrelated to match-3 gameplay (e.g., unintegrated mini-games) 3. Fancy effects that affect performance (e.g., excessive particle systems causing lag). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/view/controller layers), code organization, and maintainability. Check for proper use of design patterns, consistent naming conventions, and code reusability. 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 the code lacks comments and 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 follows match-3 visual design principles: 1) Vibrant yet harmonious color palette for game pieces 2) Clear grid layout with appropriate spacing 3) Readable UI elements with proper contrast 4) Visually distinct special candies. Deduct 3 points for visually confusing game pieces, 5 points for unclear grid boundaries, and 5 points for poorly contrasting UI elements that affect readability. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the game animations and interactions feel satisfying: 1) Responsive drag-and-swap operations (≤ 100ms) 2) Smooth matching and disappearing animations (300-500ms) 3) Pleasing cascading effects with appropriate timing 4) Satisfying visual/audio feedback for matches and special candy activations. Deduct 5 points for laggy animations, 3 points for missing feedback on matches, and 5 points for unpolished or abrupt transitions. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "hard"
-}