@getollie/cli 0.0.1

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

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

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

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

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

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

package/library/game_development-puzzle/web-based-fruit-tetris-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 986,
+  "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. Hello, could you please help create a web-based Tetris game where the blocks are cartoon fruit shapes instead of traditional shapes?",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core Tetris game mechanics fully implemented?",
+      "description": "Review whether the code implements all standard Tetris mechanics including block rotation, movement, line clearing, scoring system, and increasing difficulty. Check if the game loop runs smoothly at 60fps. Score 0 if core mechanics are missing, 5 if basic movement works but some mechanics are incomplete, 10 if all standard Tetris mechanics are properly implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the cartoon fruit shapes properly designed and implemented?",
+      "description": "Evaluate whether the code replaces traditional Tetris blocks with distinct fruit shapes that maintain gameplay balance. Check if the fruits have clear visual designs with proper hitboxes that match their appearance. Examine if the rotation of fruit shapes feels natural and consistent. Score 0 if still using traditional shapes, 5 if fruits are implemented but have visual or functional issues, 10 if fruits are well-designed, visually appealing, and function correctly.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the collision detection and grid system properly implemented?",
+      "description": "Check if the collision detection works correctly with the irregular fruit shapes. Verify that fruits stack properly on the game grid without visual glitches or logical errors. Test edge cases like wall kicks and floor kicks. Deduct 5 points for collision bugs, 3 points for grid alignment issues, and 2 points if rotation near walls causes problems. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are game controls and user interactions well-implemented?",
+      "description": "Verify keyboard controls for movement (left/right/down), rotation, and hard drop. Check if mobile touch controls are implemented with swipe gestures and tap actions. Test responsiveness of controls (should be under 100ms). Evaluate if there's a pause function and game reset option. Deduct 3 points if mobile support is missing, 5 points if controls feel unresponsive, and 2 points if pause/reset functions are missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid input, browser resize, focus loss, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Fruit juice splatter effects when lines clear 2. Combo animations with fruit themes 3. Fruit-matching bonus mechanics 4. Dynamic backgrounds based on fruit types). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple collision detection systems) 2. Function modules unrelated to fruit-themed Tetris (e.g., unnecessary social media features) 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/rendering/input handling), code organization, and performance optimization. Deduct 5 points if global state management is messy; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if no performance optimizations are implemented for rendering multiple fruit shapes. 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 palette appropriate for a fruit theme 2) Proper layout with clear game board and next-piece preview 3) Consistent art style for all fruit pieces and UI elements. Deduct 3 points for inconsistent fruit designs, 5 points for a cluttered game UI, and 5 points for poor contrast between fruits and background. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the fruit blocks move and rotate smoothly: 1) No frame drops during piece movement 2) Satisfying animations for line clearing (200-400ms) 3) Visual/audio feedback when pieces lock into place. Deduct 5 points for jerky animations, 3 points for missing feedback when lines clear, and 5 points for laggy rotation or movement. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "medium"
+}

package/library/game_development-puzzle/web-based-match-three-puzzle-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1544,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and expert responses. Take care to ensure that any code you generate is executable and ready to be displayed. Create a simple web-based match-three puzzle game.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core match-three game mechanics fully implemented?",
+      "description": "Review whether the code accurately implements the match detection algorithm, piece swapping mechanism, and board state management. Check if it handles special patterns like L-shapes and T-shapes. Score 0 if the core matching logic is missing, 5 if only basic three-in-a-row matching is implemented, and 10 if advanced patterns and cascading matches are fully supported.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the game board initialization and management properly implemented?",
+      "description": "Evaluate the board generation algorithm to ensure it creates valid starting positions without pre-existing matches. Verify that the board repopulates correctly after matches are cleared. Deduct 5 points if the initial board can contain pre-existing matches, 3 points if edge cases (like board deadlocks) aren't handled. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the scoring system and game progression logic implemented?",
+      "description": "Check whether the game includes a proper scoring mechanism, level progression, difficulty scaling, and win/lose conditions. Deduct 5 points if scoring is overly simplistic, 3 points if difficulty doesn't increase over time, and 5 points if there are no clear win/lose conditions. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the user interaction for selecting and swapping pieces intuitive?",
+      "description": "Assess if the drag-and-drop or click-based selection system works smoothly across devices. Check if invalid moves are properly rejected with feedback. Deduct 5 points if the selection mechanism is unintuitive, 3 points if there's no visual feedback for selections, and 5 points if touch/mobile support is missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid moves, rapid clicking, browser resizing, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Special power-ups or boosters 2. Unique game modes 3. Combo multipliers or special effects for impressive matches). 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 matches) 2. Function modules unrelated to the match-three gameplay (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive particle effects slowing down gameplay). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game logic/view/input handling), code organization, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no clear separation between game logic and rendering. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern game design principles: 1) Harmonious color matching for game pieces and background 2) Clear visual distinction between different piece types 3) Proper layout with well-defined game boundaries and UI elements. Deduct 3 points for poor piece distinction, 5 points for cluttered UI elements, and 5 points for inconsistent visual styling. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the game animations conform to human perception characteristics: 1) Immediate response to player input (≤ 100ms) 2) Smooth matching/clearing animations (300-500ms) 3) Fluid piece-falling animations. Deduct 5 points for laggy animations, 3 points for jerky piece movements, and 5 points for missing visual/audio feedback for matches. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "hard"
+}

package/library/game_development-puzzle/web-based-single-player-tetris-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1541,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be careful to ensure that the generated code is executable for demonstration. Create a web-based single-player Tetris game.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core Tetris game mechanics fully implemented?",
+      "description": "Review whether the code accurately implements the standard Tetris mechanics including piece rotation, movement, collision detection, line clearing, and scoring. Score 0 if the basic game loop is not implemented, 5 if only basic movement is implemented without proper collision or line clearing, and 10 if all standard Tetris mechanics are fully included with proper game physics.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are all standard Tetris pieces (tetrominoes) correctly implemented?",
+      "description": "Check whether all seven standard Tetris pieces (I, O, T, S, Z, J, L) are correctly implemented with their proper shapes, colors, and rotation behaviors. Each piece should follow the official rotation system (preferably SRS - Super Rotation System). Deduct 2 points if a piece is missing, 3 points if rotation system is inconsistent, and 5 points if collision detection during rotation fails. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the game progression and difficulty system implemented?",
+      "description": "Evaluate whether the game includes proper level progression, increasing speed as the player advances, and appropriate scoring mechanisms (points for line clears, with bonuses for multiple lines). Check for implementation of special scoring for techniques like T-spins or back-to-back Tetrises. Deduct 5 points if speed progression is missing, 3 points if the scoring system is overly simplified. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the next piece preview and piece holding functionality implemented?",
+      "description": "Check whether the game includes standard modern Tetris features like displaying the next piece(s) in queue and the ability to hold a piece for later use. Evaluate the implementation of the piece swapping mechanism and whether it follows standard rules (can't swap twice in a row). Deduct 5 points if next piece preview is missing, and 5 points if hold functionality is not implemented or has incorrect rules. 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 events, focus/blur events when switching tabs, 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. Ghost piece showing where the tetromino will land 2. Game statistics tracking and visualization 3. Special visual/audio effects for combos or Tetris clears). 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 implementations) 2. Function modules unrelated to Tetris (e.g., unnecessary social sharing features) 3. Fancy effects that affect performance (e.g., excessive particle animations that slow down gameplay). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game logic/view/input handling layers), code organization, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the code lacks comments or documentation. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching for the game board and pieces 2) Proper layout spacing with clear separation between game area and UI elements 3) Professional font system for score display and game information. 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 control scheme and game responsiveness optimized?",
+      "description": "Judge whether the game controls are intuitive and responsive: 1) Input response delay ≤ 50ms 2) Support for both keyboard and touch controls (for mobile devices) 3) Customizable controls or standard Tetris controls (arrow keys, spacebar for hard drop). Deduct 5 points for sluggish controls, 3 points for missing standard Tetris control options (like hard/soft drop), and 5 points for lack of mobile device support. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "hard"
+}