@getollie/cli 0.0.1

package/library/game_development-puzzle/html5-sudoku-game-development.json

@@ -0,0 +1,68 @@
+{
+  "index": 375,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code when possible. Write a Sudoku game using HTML5 and related technologies.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Sudoku game core logic fully implemented?",
+      "description": "Review whether the code accurately implements the fundamental Sudoku rules (no duplicate numbers in rows, columns, and 3x3 boxes). Check if puzzle generation algorithms produce valid, unique-solution puzzles with appropriate difficulty levels. Score 0 if core validation logic is missing, 5 if only basic validation is implemented, and 10 if puzzle generation and complete validation are properly implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the game interface and user interaction features complete?",
+      "description": "Evaluate if the interface includes essential Sudoku game features: number selection mechanism, highlighting of conflicting cells, notes/pencil marks system, undo/redo functionality, and visual indication of completed rows/columns/boxes. Deduct 2 points for each missing critical feature. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the puzzle generation and difficulty system implemented properly?",
+      "description": "Check if the code includes algorithms for generating puzzles of varying difficulties (easy, medium, hard) with guaranteed unique solutions. Examine whether difficulty is calculated using recognized metrics (e.g., minimum required techniques, number of givens). Deduct 5 points if puzzles are hardcoded rather than generated, 3 points if difficulty levels are absent. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a hint system and solver implementation?",
+      "description": "Assess whether the game provides intelligent hints (beyond random solutions) that teach solving techniques, and whether it includes a step-by-step solver demonstrating solution paths. Deduct 5 points if no hint system exists, 3 points if hints simply reveal answers without explanation, and 5 points if no solver is 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 invalid inputs, browser compatibility issues, performance optimization for large puzzles) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Visual solving technique tutorials 2. Daily puzzles with global leaderboards 3. Custom puzzle creation/sharing 4. Advanced statistics tracking). 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 validation methods that accomplish the same thing) 2. Function modules unrelated to Sudoku (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive animations that slow down gameplay). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game logic/UI/data models), code reusability, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 3 points if the code duplication rate is too high (over 30%); deduct 2 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 with good contrast for numbers 2) Proper layout spacing with clear grid lines and visual hierarchy 3) Professional font system with legible numbers even on small screens. Deduct 3 points for poor number visibility, 4 points for confusing UI elements, and 3 points for inconsistent styling. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Immediate feedback when entering numbers 2) Smooth transitions when highlighting related cells 3) Clear visual indication for valid/invalid entries. Deduct 4 points for laggy number input, 3 points for confusing selection states, and 3 points for disorienting transitions between game states. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "hard"
+}

package/library/game_development-puzzle/icon-matching-game-implementation.json

@@ -0,0 +1,68 @@
+{
+  "index": 966,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure that any code you generate is executable. Based on existing matching games in the market, help me design a similar matching game where players can eliminate identical icons by clicking on them. Please provide the game code that runs as a mouse-operated application rather than a command-line program.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core matching mechanism properly implemented?",
+      "description": "Check whether the code implements a complete matching mechanism that allows players to select and eliminate identical icons. The matching logic should include: detection of identical icons, removal animation, and score calculation. Score 0 if the core matching logic is missing, 5 if only basic matching is implemented without proper validation, and 10 if the solution includes comprehensive matching rules with edge cases handling (such as no more possible matches detection).",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the game board generation and management implemented correctly?",
+      "description": "Evaluate if the game dynamically generates a proper grid of icons with sufficient variety while ensuring the game is solvable. Check if the board is refilled correctly after eliminations and whether the code ensures there are always possible matches available. Deduct 5 points if the board generation doesn't guarantee solvable states, 3 points if refilling mechanism is flawed, and 2 points if icon variety is too limited. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the mouse interaction controls intuitive and responsive?",
+      "description": "Since the game is specifically required to be mouse-operated, examine if click/hover events are properly implemented, with clear visual feedback on selection and matching. Check for smooth highlighting of selected icons and intuitive error feedback for invalid moves. Deduct 5 points if there are click response delays (>100ms), 3 points if visual feedback is unclear, and 5 points if the mouse interaction isn't intuitive. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the game state management comprehensive?",
+      "description": "Check if the code implements proper game state management including start/pause/restart/end game states, score tracking, timer functionality (if applicable), and level progression. Examine if game data persists between sessions using local storage. Deduct 5 points if critical game states are missing, 3 points if score tracking is implemented poorly, and 2 points if there's no session persistence. 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 multiple clicks, browser resize events, or unexpected user interactions) 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 combo elimination mechanics 2. Power-ups or special tiles 3. Adaptive difficulty level based on player performance). 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 restart the game) 2. Function modules unrelated to matching games (e.g., an unnecessary login system) 3. Fancy effects that affect performance (e.g., excessive animations that slow down gameplay). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game logic/view/UI layers), code reusability, 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 game design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (clear grid structure with consistent margins) 3) Professional font system (readable score displays, clear instructions). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic UI layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the animations and transitions enhance gameplay: 1) Icon selection feedback is immediate (≤ 50ms) 2) Matching elimination animations are satisfying but quick (200-400ms) 3) Board refill animations are smooth and logical. Deduct 5 points for static gameplay without animations, 3 points for animations that hinder gameplay speed, and 5 points for confusing visual effects that don't clearly communicate game state. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "medium"
+}

package/library/game_development-puzzle/javascript-canvas-match-3-puzzle-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1193,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the code you generate is executable for demonstration purposes. Use JavaScript and canvas to implement a complete match-3 puzzle game.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the match-3 core game mechanics fully implemented?",
+      "description": "Review whether the code accurately implements the match-3 puzzle logic through JavaScript/Canvas, including gem grid generation, match detection (horizontal/vertical 3+ matches), cascading elimination, and gravity-based gem falling. Score 0 if core matching logic is missing, 5 if only basic 3-match detection exists, and 10 if advanced combos (L-shape, T-shape, 4+ matches) and special gems are fully implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the interactive control system responsive and intuitive?",
+      "description": "Check whether mouse/touch input handling includes accurate gem selection, drag-and-drop swapping, swap validation (only adjacent gems), and illegal move rejection with visual feedback. Deduct 5 points if swap animations are missing, 3 points if touch responsiveness is poor (>150ms delay), and 2 points if visual feedback for invalid moves is absent. Full score requires smooth gesture recognition.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the game progression and scoring system complete?",
+      "description": "Evaluate whether the scoring system includes combo multipliers, cascade bonuses, level progression with increasing difficulty, and objective-based gameplay (score targets, limited moves, or time constraints). Deduct 5 points if no level progression exists, 3 points if scoring lacks combo rewards, and 2 points if no clear win/lose conditions are defined. Full implementation should include multiple game modes.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are visual effects and animations polished and engaging?",
+      "description": "Check whether the code includes smooth gem elimination animations, particle effects for matches, screen shake for large combos, and satisfying visual feedback. Animations should use easing functions and proper timing (200-400ms for swaps, 300-600ms for eliminations). Deduct 5 points if animations are choppy or missing, 3 points if no particle effects exist, and 2 points if visual hierarchy is unclear during gameplay.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid clicking, boundary detection errors, invalid gem states, canvas rendering failures, etc.) and provide friendly error handling or recovery mechanisms. Code with strong robustness should effectively prevent game state corruption and handle edge cases gracefully, giving 10 points. If robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that enhance gameplay?",
+      "description": "Check whether the code includes compelling features that elevate the experience (e.g., 1. Power-up gems with special abilities 2. Daily challenges or puzzle modes 3. Hint system for possible moves 4. Undo functionality 5. Save/load game state). Add 2-3 points for each well-implemented innovative feature (maximum 10 points). Features must be functional, not just cosmetic.",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features or performance issues?",
+      "description": "Strictly check three types of problems: 1. Redundant implementation of similar functions (e.g., multiple animation systems coexisting) 2. Unnecessary features unrelated to match-3 gameplay 3. Performance-heavy effects that cause frame drops (excessive particles, inefficient canvas clearing). Deduct 3 points for each redundancy found, and directly deduct 10 points if core gameplay is affected by performance issues or bloated code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (separating game logic, rendering, input handling), clean code structure, and performance optimization (efficient canvas operations, object pooling for particles). Deduct 5 points if code structure is monolithic or poorly organized; deduct 3 points if canvas operations are inefficient (unnecessary redraws); deduct 2 points if no comments or documentation exist. Full score requires professional code organization.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the visual design meet professional game UI standards?",
+      "description": "Evaluate whether the visual design follows modern game UI principles: 1) Cohesive color palette with proper contrast for gameplay clarity 2) Consistent gem designs that are easily distinguishable 3) Clear UI hierarchy with readable fonts (≥16px for game text) 4) Proper spacing and alignment of game elements. Deduct 3 points for each unclear visual element, 5 points for poor color accessibility, and 5 points for cluttered interface design. Full score requires polished, professional appearance.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the game interaction smooth and responsive?",
+      "description": "Judge whether the interactive experience meets gaming standards: 1) Input response time ≤ 100ms 2) Animation frame rate consistently above 30fps 3) Smooth gem movement with proper easing 4) Clear visual feedback for all user actions 5) Intuitive game flow without confusing states. Deduct 5 points for each laggy interaction, 3 points for inconsistent frame rates, and 5 points for unclear or missing user feedback. Full score requires console-quality smoothness.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "hard"
+}

package/library/game_development-puzzle/lianliankan-puzzle-game-with-optimal-path.json

@@ -0,0 +1,68 @@
+{
+  "index": 1710,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable for demonstration purposes. Referring to https://blog.csdn.net/liuyinghui523/article/details/111638194?ops_request_misc=&request_id=&biz_id=102&utm_term=%E8%BF%9E%E8%BF%9E%E7%9C%8B%E6%B6%88%E6%B6%88%E4%B9%90%E7%9A%84%E7%AE%97%E6%B3%95&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-1-111638194.142^v102^control&spm=1018.2226.3001.4187, develop a Lianliankan (matching pairs) elimination algorithm with optimal path recommendation, and create a small Lianliankan puzzle game using Flutter.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core Lianliankan elimination algorithm correctly implemented?",
+      "description": "Check if the algorithm can accurately determine whether two tiles can be connected with at most two turns. The implementation should include proper validation of matching pairs, path-finding logic, and boundary checks. Score 0 if the core algorithm is missing, 5 if basic matching works but has edge case issues, 10 if the algorithm is complete and handles all scenarios correctly.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the optimal path recommendation feature properly implemented?",
+      "description": "Evaluate whether the code includes an algorithm to find and highlight the shortest connecting path between two matching tiles. Check if it considers all possible paths and selects the optimal one with minimum turns. Score 0 if path recommendation is missing, 5 if basic path finding exists but isn't always optimal, 10 if the recommendation system consistently finds the best path.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the game board generation and shuffling mechanism effectively designed?",
+      "description": "Review the algorithm for generating the game board with guaranteed solvable layouts. Check if the code ensures that all tiles have possible matches and includes a proper shuffling mechanism when no matches are available. Score 0 if board generation is missing or broken, 5 if basic board generation exists but may create unsolvable states, 10 if the system guarantees solvable boards and handles reshuffling appropriately.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the Flutter UI implementation complete for the Lianliankan game?",
+      "description": "Check if the Flutter implementation includes all necessary UI components: game board with tiles, animation for selection and matching, score display, timer, and game control buttons. Score 0 if the Flutter implementation is missing, 5 if basic UI exists but lacks essential game elements, 10 if the UI is complete with all necessary components for a fully functional game.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid selections, edge cases in path finding, premature game termination) and provides 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. Different difficulty levels 2. Custom themes or tile designs 3. Hint system with cooldown 4. Special power-ups or game modes). 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 path-finding algorithms without clear purpose) 2. Function modules unrelated to Lianliankan (e.g., unrelated mini-games) 3. Fancy effects that affect performance (e.g., excessive animations 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/state management layers), widget composition, state management approach, and code organization. Deduct 5 points if global state pollution is found or Flutter best practices aren't followed; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no separation between UI and game logic. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional typography (readable font sizes, appropriate contrast). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for poorly aligned or inconsistent UI elements. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the game interactions conform to human perception characteristics: 1) Responsive tile selection feedback ≤ 100ms 2) Smooth matching animations with appropriate duration (300-500ms) 3) Clear visual indication of successful matches and possible paths. Deduct 5 points for each operation without feedback, 3 points for laggy animations during gameplay, and 5 points for confusing or unclear game state indicators. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "hard"
+}

package/library/game_development-puzzle/magic-forest-game-with-puzzles.json

@@ -0,0 +1,68 @@
+{
+  "index": 117,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and expert responses. Be sure to ensure that the code you generate is executable.\n\nPlease use HTML and JavaScript to implement a Magic Forest game where players need to solve magical puzzles within the forest.\n\nHint: Design a forest environment and magical puzzle system.\n\nPlease include comments in your code so that other developers can understand your implementation process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the forest environment visualization fully implemented?",
+      "description": "Review whether the code creates an immersive forest environment through HTML/CSS/JavaScript, including appropriate background imagery, forest elements (trees, paths, magical items), and ambient effects. Score 0 if the environment is not implemented, 5 if a basic static forest is created, and 10 if the forest is visually rich with dynamic elements and responsive design.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the magical puzzles properly designed and implemented?",
+      "description": "Evaluate the puzzle system implementation: check if there are multiple puzzle types, clear objectives, validation logic, and progression mechanics. Scoring: 0 points if puzzles are missing/non-functional, 5 points for basic puzzles without variety, 10 points for diverse, challenging puzzles with proper solution validation and feedback systems.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there a player interaction and progression system?",
+      "description": "Check for player state management, progression tracking, and reward systems. Review whether the code implements player movement/controls, inventory management if applicable, and a logical puzzle progression sequence. Deduct 5 points if there's no state persistence between puzzles, and 3 points if player progress isn't tracked. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the game's magical element system engaging and interactive?",
+      "description": "Assess whether magical elements (spells, enchanted objects, magical creatures) are interactive and enhance gameplay. Check for special effects when magic is used, appropriate visual feedback, and integration with puzzle mechanics. Deduct 5 points if magical elements are purely decorative, 3 points if interactions are limited. Give 10 points for a fully developed magical system that's central to gameplay.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid inputs, browser compatibility issues, resolution 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. Dynamic weather effects that affect puzzles 2. Procedurally generated forest elements 3. Adaptive difficulty based on player performance). 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 track player progress) 2. Function modules unrelated to the magic forest theme (e.g., unrelated 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/interaction layers), code organization, use of design patterns, and quality of comments. 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 comments are missing or insufficient. 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 that evokes a magical forest atmosphere 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 clashing 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) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance for interactive elements in the forest. Deduct 5 points for each operation without feedback, 3 points for visual after-images during interactions, and 5 points for hard-to-find key interactive elements. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "medium"
+}

package/library/game_development-puzzle/match-3-game-implementation.json

@@ -0,0 +1,68 @@
+{
+  "index": 1520,
+  "question": "You are a coding expert. Please use your professional knowledge to generate accurate, professional responses. Make sure the code you generate is executable where possible. Please help me write code for a match-3 game with the following requirements:\n\nChatGPT: \n\nYou are a coding expert. Please use your professional knowledge to generate accurate, professional responses. Make sure the code you generate is executable where possible. Please help me write code for a match-3 game with the following requirements:",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core match-3 game logic fully implemented?",
+      "description": "Review whether the code accurately implements the match-3 mechanic including grid initialization, piece swapping, match detection, cascade effects, and board refilling. Score 0 if the core interaction logic is missing, 5 if only basic matching is implemented without cascades, and 10 if the complete match-3 mechanic with cascades and special combinations is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is game state management properly implemented?",
+      "description": "Check if the code includes proper game state management (e.g., start, pause, resume, game over conditions), score tracking, level progression, and persistent storage of game progress. Deduct 3 points if there's no pause functionality, 3 points if score tracking is missing, and 4 points if there's no way to save/load game state. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are special pieces and power-ups implemented?",
+      "description": "Evaluate whether the game includes special pieces or power-ups that are created when matching more than 3 pieces, or in special patterns (like L or T shapes). Check for different power-up effects (e.g., row/column clearing, bomb explosions, color matching). Award 3 points for each well-implemented special piece type (up to 10 points maximum).",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the level design system comprehensive?",
+      "description": "Review whether the code supports different level types, varied objectives (like reaching a score target, clearing specific tiles, collecting certain pieces), increasing difficulty progression, and time or move limits. Deduct 3 points if only one level type exists, 3 points if difficulty scaling is absent, and 4 points if there are no varied objectives. 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 swaps, edge cases in matching algorithms, animation interruptions) 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. Dynamic difficulty adjustment 2. Daily challenges 3. Unique theme or narrative elements 4. Meta-progression systems). 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 matching algorithms doing the same thing) 2. Function modules unrelated to match-3 gameplay (e.g., unnecessary 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/input handling), code organization, reusability, 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 separation between rendering and game logic. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the visual design follows modern game UI principles: 1) Harmonious color matching with theme-appropriate palette 2) Proper layout with clear visual hierarchy 3) Readable text with appropriate fonts and sizes 4) Clear visual feedback for matches and interactions. Deduct 3 points for cluttered UI elements, 5 points for clashing colors or poor readability, and 5 points for lack of visual feedback during gameplay. 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) Piece movement animations are smooth (60fps) 2) Match explosions provide satisfying feedback 3) Cascading matches have appropriate timing and visual emphasis 4) Input responsiveness is immediate (≤ 100ms). Deduct 3 points for jerky animations, 3 points for lack of feedback on matches, 5 points for poor touch/click response, and 4 points if cascades are visually confusing. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "hard"
+}

package/library/game_development-puzzle/match-3-game-with-grid-and-score.json

@@ -0,0 +1,68 @@
+{
+  "index": 624,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you produce is executable. Design a match-3 game with an 8x8 grid that randomly generates different colored blocks. Users can swap adjacent blocks to form matches of three or more of the same color. After elimination, blocks from above will fall to fill the gaps. Display the score and remaining moves.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the 8x8 grid properly implemented with random color generation?",
+      "description": "Review whether the code accurately creates an 8x8 grid structure, properly initializes it with random colored blocks, and ensures visual representation of different colors. Each block should have a distinct visual identity (either through CSS colors, images, or SVG). Score 0 if the grid implementation is incorrect/missing, 5 if basic implementation exists but lacks proper randomization, and 10 if fully implemented with visually distinct blocks and proper randomization algorithm that prevents initial matches.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the block swapping mechanism correctly implemented?",
+      "description": "Evaluate the swapping mechanism between adjacent blocks. The code should include: 1) User interaction to select blocks (click/touch/drag), 2) Validation that blocks are adjacent, 3) Visual feedback during swapping, and 4) Rejection of invalid swaps with appropriate feedback. Deduct 3 points if adjacency validation is missing, 2 points if visual feedback is absent, and 5 points if invalid swaps aren't handled properly. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the match detection and elimination system properly implemented?",
+      "description": "Check whether the code can detect horizontal and vertical matches of 3 or more same-colored blocks. The algorithm should handle complex matches (T-shapes, L-shapes) and cascading matches. Deduct 5 points if only basic straight-line matches are detected, 3 points if complex matches are missed, and 3 points if the elimination animation is abrupt or missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the gravity system (falling blocks) properly implemented?",
+      "description": "Assess the gravity mechanism that makes blocks fall to fill empty spaces after matches are eliminated. The code should include: 1) Proper detection of empty spaces, 2) Smooth animation for falling blocks, 3) Correct handling of multiple falling blocks in the same column. Deduct 3 points for jerky animations, 5 points if blocks don't always fill all gaps, and 2 points if the falling timing is too fast/slow for good user experience. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid clicking during animations, browser resizing, touch/mouse input differences, etc.) and provide friendly error handling. Code with strong robustness should prevent game state corruption and handle edge cases like attempting to swap during animations. Give 10 points for comprehensive error handling, 5 points for basic error handling, and 0 points if exceptions could crash the game.",
+      "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 when matching 4+ blocks, 2. Combo score multipliers, 3. Interactive tutorial, 4. Difficulty progression system). 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 handle the same game event), 2. Function modules unrelated to match-3 gameplay (e.g., an unnecessary settings panel with irrelevant options), 3. Fancy effects that affect performance (e.g., excessive particle systems 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), performance optimization for animations, and code maintainability. 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 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 palette that makes matched blocks clearly distinguishable, 2) Proper layout with score and moves prominently displayed, 3) Balanced visual hierarchy with game grid as the focal point. Deduct 3 points for each hard-to-distinguish block color, 5 points for cluttered UI elements, and 5 points for poor readability of score/moves. 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 match-3 genre expectations: 1) Block selection feedback ≤ 100ms, 2) Swap animation duration between 200-400ms, 3) Elimination and falling animations that feel satisfying but don't slow gameplay. Deduct 5 points for missing swap animations, 3 points for jerky block falling, and 5 points for animations that feel too slow or make the game unresponsive. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "easy"
+}

package/library/game_development-puzzle/match-three-game-with-names.json

@@ -0,0 +1,68 @@
+{
+  "index": 1739,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable for demonstration whenever possible. Help me create a match-three game based on the following names:\nXu Mingyang\nDai Ziyang\nZhong Zijia\nLi Junxian\nYang Jiming\nZhang Zirou\nChen Yinlong\nZhong Muxi\nLin Zilin\nLi Hanyu\nHuang Ziqing\nXiong Ganzhen\nXie Ziheng\nZhu Minghan\n\nThe code should be in HTML.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the match-three game core mechanics fully implemented?",
+      "description": "Evaluate whether the code implements the essential match-three mechanics: grid initialization, piece swapping, matching detection (horizontal, vertical, and potentially diagonal matches of 3+ same pieces), clearing matched pieces, and filling empty spaces with new pieces. Score 0 if core gameplay is missing, 5 if basic matching works but has flaws, 10 if all mechanics work seamlessly.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the provided names properly integrated into the gameplay?",
+      "description": "Check if all 14 names (Xu Mingyang, Dai Ziyang, etc.) are effectively incorporated into the game elements, either as characters, piece types, or thematic elements. Deduct 1 point for each name missing from the gameplay. If names are merely displayed but not meaningfully integrated into the mechanics, score no more than 5 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the game state management properly implemented?",
+      "description": "Review the implementation of game state tracking (score, level, remaining moves, etc.), state transitions (game start, pause, win/lose conditions), and persistent state management. Score 0 if state management is absent, 5 if basic state tracking exists but lacks proper transitions, 10 if comprehensive state management is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the game include appropriate feedback and animation systems?",
+      "description": "Evaluate whether the game provides proper visual/audio feedback for actions (swapping, matching, special combos) and smooth animations for piece movement, matching, and board refilling. Deduct 3 points if animations are missing, 2 points if matching feedback is unclear, and 5 points if user actions have no visual response.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common edge cases (invalid moves, rapid clicking, board deadlocks with no possible matches) and provides adequate error handling. Code with strong robustness should prevent game-breaking scenarios and recover gracefully from unexpected states, giving 10 points. If the robustness is average, give 5 points, and if no error handling exists, 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 combo pieces or power-ups 2. Unique match patterns beyond the standard three 3. Character-specific abilities based on the provided names). 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 for three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple scoring systems) 2. Function modules unrelated to match-three gameplay 3. Fancy effects that affect performance (e.g., excessive particle effects that slow down the game). 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 if design patterns are not used appropriately; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the code lacks comments or documentation. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the game UI follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (game grid properly sized and centered) 3) Professional font system (readable text for score/level display, consistent typography). Deduct 3 points for each cluttered UI element, 5 points for jarring color combinations, and 5 points for poor readability. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and responsive?",
+      "description": "Judge whether the game interactions meet user expectations: 1) Piece selection and swapping feels immediate (≤100ms response) 2) Chain reactions and animations complete within a reasonable timeframe 3) Clear visual indication of valid/invalid moves. Deduct 5 points for delayed response to user input, 3 points for choppy animations, and 5 points for confusing interaction patterns. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "medium"
+}