@getollie/cli 0.0.4 → 0.2.0

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

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

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

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

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

@@ -1,68 +0,0 @@
-{
-  "index": 1035,
-  "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. Write a program for a match-three puzzle game.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core match-three game logic fully implemented?",
-      "description": "Review whether the code accurately implements the match detection algorithm, board generation with guaranteed matches, piece swapping mechanics, and cascading effects when matches are cleared. Score 0 if the core game logic is missing, 5 if only basic matching is implemented without cascades, and 10 if the game includes proper matching, cascading, and board refilling mechanics.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the game board rendering and user interaction properly implemented?",
-      "description": "Evaluate whether the game board is correctly rendered with a grid system, pieces have distinct visual appearances, and user interactions (selection, swapping) are intuitive and responsive. Check for proper highlighting of selected pieces and visual feedback for valid/invalid moves. Deduct 3 points if selection feedback is missing, 3 points if swap animations are absent, and 4 points if the board rendering has alignment issues.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are game mechanics like scoring system and level progression implemented?",
-      "description": "Check if the game includes a scoring system that rewards larger matches and cascades, tracks player progress, implements level difficulty progression (increasing targets, decreasing moves/time), and provides clear win/lose conditions. Score 0 if scoring is absent, 5 if basic scoring exists without progression, and 10 if full scoring with level progression is implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are special game elements and power-ups included?",
-      "description": "Assess whether the game includes special pieces created from larger matches (4+ pieces), power-ups with unique effects (row/column clearers, bombs, etc.), and obstacle tiles that add strategic depth. Score 3 points for basic special pieces, 3 points for power-up implementation, and 4 points for strategic obstacle integration.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle edge cases such as no possible matches, invalid moves, rapid user inputs, and browser resizing. Code with strong robustness should gracefully recover from these scenarios, providing board reshuffling when no matches are possible and blocking input during animations. Give 10 points for comprehensive edge case handling, 5 points for basic error prevention, and 0 points if critical edge cases are unhandled.",
-      "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 match patterns beyond straight lines 2. Physics-based falling animations 3. Theme customization options 4. Accessibility features like colorblind mode). 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 detect matches) 2. Function modules unrelated to match-three 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/input handling), proper object-oriented or component-based architecture, and performance optimization techniques. Deduct 5 points if global state pollution is found; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if no performance considerations exist for large board sizes. 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 palette that enhances gem visibility 2) Clear visual hierarchy with emphasized game elements 3) Consistent style for UI components (buttons, panels, score displays). Deduct 3 points for poor color contrast between pieces, 5 points for cluttered UI, and 3 points for inconsistent button styling or poorly readable text. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the game animations follow satisfying principles: 1) Piece swapping completes within 200-300ms 2) Match clearing and cascading have sequential timing with proper pacing 3) Smooth transitions between game states (level start/end, special effects). Deduct 4 points for jerky animations, 3 points for overlapping animations that cause visual confusion, and 3 points for missing transition effects between game states. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "medium"
-}

package/library/game_development-puzzle/matching-game-lianliankan-html-small-animals.json

@@ -1,68 +0,0 @@
-{
-  "index": 1825,
-  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Be sure to make the generated code executable for demonstration. Write a matching game (Lianliankan) using HTML language, displaying small animals.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core matching game (Lianliankan) logic fully implemented?",
-      "description": "Review whether the code accurately implements the matching logic where players connect identical animal tiles that can be linked by a line with at most two turns. Check if the code includes validation for matching pairs, path-finding algorithm, and scoring mechanism. Score 0 if the core matching logic is not implemented, 5 if only basic pair validation exists without path-finding, and 10 if complete matching rules with proper path visualization are implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are animal graphics properly implemented and displayed?",
-      "description": "Evaluate whether the game uses proper animal graphics (at least 6 different animal types), with consistent style and clear visibility. Check if images are preloaded to prevent flickering during gameplay. Deduct 3 points if fewer than 6 animal types are used, 4 points if images have inconsistent sizes or styles, and 5 points if images fail to load properly. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the game board generation and layout properly implemented?",
-      "description": "Check if the code generates a balanced game board with proper randomization that ensures all pairs can be matched. Verify that the board layout is responsive and properly aligned. Deduct 5 points if the board generation doesn't ensure solvability, 3 points if the layout is fixed and not responsive, and 2 points if the tile arrangement is visually confusing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there proper game state management and progression?",
-      "description": "Evaluate if the game includes proper state management (start, play, win/lose conditions), timer functionality, scoring system, and level progression. Deduct 3 points if win/lose conditions aren't properly detected, 3 points if there's no timer or scoring system, and 4 points if the game lacks level progression or difficulty adjustment. 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, clicking already matched tiles, invalid connections) and provide friendly error handling or recovery mechanisms. Code with strong robustness should prevent game-breaking behaviors and handle edge cases effectively, giving 10 points. If the robustness is average, give 5 points, and if no exception 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. Hint system that helps players find matches 2. Special effects for successful matches 3. Combo system for consecutive quick matches 4. Different difficulty 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 ways to reset the game) 2. Function modules unrelated to the matching game (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/view/controller layers), code organization, and readability. Deduct 5 points if global variables are excessively used or if there's no separation of concerns; deduct 5 points if the code duplication rate is too high (over 30%); deduct 3 points if the code lacks proper 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 (no more than 3 primary colors) 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 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 for matching animations 3) Clear visual indication of selected tiles and valid/invalid matches. Deduct 5 points for each operation without feedback, 3 points for animations that are too slow or jerky, and 5 points for unclear selection indicators. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "easy"
-}

package/library/game_development-puzzle/minesweeper-game-html.json

@@ -1,68 +0,0 @@
-{
-  "index": 1821,
-  "question": "You are a coding expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code for demonstration purposes. Write a Minesweeper game using HTML code.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core Minesweeper game mechanics fully implemented?",
-      "description": "Check if the code correctly implements mine placement, cell revealing logic, and win/loss detection. The game should generate random mine positions, calculate adjacent mine counts, handle recursive revealing of empty cells, and detect game completion conditions. Score 0 if core game mechanics are missing, 5 if basic functionality works but with flaws, 10 if completely implemented according to traditional Minesweeper rules.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the game board dynamically generated with configurable difficulty levels?",
-      "description": "Evaluate if the code allows for different board sizes (beginner: 9x9 with 10 mines, intermediate: 16x16 with 40 mines, expert: 30x16 with 99 mines) and proper mine density. The board should be generated programmatically, not hardcoded. Deduct 5 points if only one difficulty level is implemented, 3 points if the mine distribution algorithm has clustering issues, and 2 points if board size isn't responsive to window size.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are all user interactions properly handled?",
-      "description": "Check if the game properly handles left-click (reveal cell), right-click (flag/mark mine), and potentially middle-click (chord) operations. Timer functionality should start on first click, and the first click should never be a mine. Award 10 points if all standard Minesweeper interactions are implemented, 5 points if basic interactions work but with limitations, 0 points if interactions are broken or inconsistent.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there a functional game state management system?",
-      "description": "Evaluate if the game tracks and manages states properly (new game, in-progress, won, lost) with appropriate UI indicators. Check if the game includes a counter for remaining mines/flags, a timer, and a way to restart the game. Deduct 3 points if state transitions are buggy, 3 points if game statistics aren't displayed, and 4 points if there's no game reset functionality.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle edge cases (such as rapid clicking, right-clicking already revealed cells, resizing the window, etc.) and prevent common bugs like accidental page navigation on right-click. 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. Save/load game state 2. Custom themes or color schemes 3. Animation effects for explosions or victories 4. Hint system or undo functionality). 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 event handlers that could cause memory leaks 2. Unnecessary DOM manipulation that could be handled more efficiently 3. Fancy effects that affect performance without enhancing 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 (separation of game logic, UI rendering, and event handling), code organization, and maintainability. Check for proper use of constants, meaningful variable names, and appropriate comments. Deduct 5 points if global scope is polluted with variables, 3 points if there's significant code duplication, and 2 points if the HTML structure is not semantic. 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 classic Minesweeper aesthetics while maintaining modern design principles: 1) Clear visual distinction between revealed/unrevealed cells 2) Proper color coding for numbers 3) Proportional grid sizing and readable font. Deduct 3 points for poor cell spacing, 4 points for unclear number colors, 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 game provides immediate visual feedback for user actions: 1) Cell reveal animations under 100ms 2) Clear visual indication of flagged cells and revealed numbers 3) Distinct game over state visualization. Deduct 3 points for laggy cell reveals, 3 points for unclear flagging indicators, and 4 points for abrupt or jarring game over presentation. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "medium"
-}

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

@@ -1,68 +0,0 @@
-{
-  "index": 1006,
-  "question": "You are a coding expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you provide is executable for demonstration. Help me write the code to create a Minesweeper game.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core Minesweeper game mechanics fully implemented?",
-      "description": "Check if the code implements all essential Minesweeper game mechanics: random mine placement, number calculation for adjacent cells, revealing cells with cascading effect for empty cells, and flagging suspected mines. Score 0 if core mechanics are missing, 5 if basic mine detection works but cascading reveals are absent, and 10 if all standard Minesweeper mechanics are properly implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the game board generation and initialization complete?",
-      "description": "Evaluate whether the code correctly generates a customizable game board with appropriate difficulty levels (at least Beginner 9x9 with 10 mines, Intermediate 16x16 with 40 mines, Expert 16x30 with 99 mines). Check if mines are randomly distributed and numbers correctly calculated. Deduct 5 points if only one difficulty level is implemented, 3 points if board sizes aren't customizable, and 3 points if mine distribution isn't truly random. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are win and loss conditions properly implemented?",
-      "description": "Verify if the game correctly detects win conditions (all non-mine cells revealed) and loss conditions (mine clicked). Check if the game reveals all mines upon loss and prevents further interaction. Ensure proper game state management for restart functionality. Deduct 5 points if win detection is faulty, 5 points if loss handling is incomplete, and 3 points if restart functionality is missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there a functional timer and mine counter?",
-      "description": "Assess whether the game includes a working timer that starts on first click and stops on game end, and a mine counter that tracks remaining unflagged mines. The timer should count seconds accurately, and the counter should update with each flag placement/removal. Deduct 5 points if the timer is missing/non-functional, 3 points if the mine counter doesn't update correctly, and 2 points if visual display is unclear. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid clicking, right-click on revealed cells, 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. First-click safety guarantee 2. Custom themes or skins 3. Save/load game state 4. Intelligent hint 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 restart the game) 2. Function modules unrelated to Minesweeper (e.g., a built-in calculator) 3. Fancy effects that affect performance (e.g., excessive animations when revealing cells). 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/event 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 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 classic Minesweeper aesthetics while maintaining modern UI principles: 1) Clear visual distinction between revealed/unrevealed cells 2) Proper color coding for numbers (1=blue, 2=green, 3=red, etc.) 3) Professional font system and clean grid layout. Deduct 3 points for unclear cell states, 5 points for non-standard number coloring, and 5 points for misaligned or inconsistent grid cells. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the game interactions feel responsive and intuitive: 1) Left-click reveals cells instantly 2) Right-click cycles between unmarked, flagged, and question mark states 3) Double-click reveals surrounding cells when requirements are met. Deduct 5 points for delayed click responses, 3 points for unintuitive controls without instructions, and 5 points if the chording feature (clicking both mouse buttons) is missing. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "easy"
-}

package/library/game_development-puzzle/minesweeper-game-with-home-demo-tabs.json

@@ -1,68 +0,0 @@
-{
-  "index": 1754,
-  "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 display. Create a complete Minesweeper game and save it in two navigation tabs, namely \"Home\" and \"Demo\", to facilitate future maintenance.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Minesweeper core gameplay fully implemented?",
-      "description": "Review whether the code accurately implements the Minesweeper game mechanics including mine placement, cell revealing logic, adjacent mine counting, and win/loss detection. Score 0 if the core interaction logic is not implemented, 5 if only basic cell revealing is implemented without proper win/loss conditions, and 10 if all standard Minesweeper rules are fully included with proper flagging functionality.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the game board generation algorithm properly implemented?",
-      "description": "Evaluate whether the mine placement algorithm ensures fair distribution (not clustering excessively) and guarantees the first click is always safe. Check if the algorithm initializes the board only after the first click to prevent unfair game starts. Deduct 5 points if mines can appear on first click, 3 points if distribution is too clustered, and 3 points if board size options are missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are the game difficulty levels and customization options implemented?",
-      "description": "Check whether the code includes at least three standard difficulty levels (Beginner: 9×9 with 10 mines, Intermediate: 16×16 with 40 mines, Expert: 30×16 with 99 mines) and an option for custom board size and mine count. Deduct 4 points for each missing difficulty level, and 5 points if custom options aren't available. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the navigation system between Home and Demo tabs properly implemented?",
-      "description": "Verify that the code implements proper navigation between the Home and Demo tabs without page reloads (using client-side rendering), maintaining game state when switching tabs, and providing clear visual indicators for the active tab. Deduct 5 points if navigation causes game reset, 3 points if tab indicators are unclear, and 5 points if navigation doesn't work correctly. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid user inputs, rapid clicking, right-click menu prevention, 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. Timer and high score system 2. Themes or visual customization 3. Game state saving/loading 4. Animated reveals). 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 the game) 2. Function modules unrelated to Minesweeper (e.g., a built-in calculator) 3. Fancy effects that affect performance (e.g., excessive animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/view/state management layers), function encapsulation, and code organization. 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 are no comments for complex 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 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 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) Cell revealing animations are quick but visible 3) Clear visual feedback for flagging and game outcome. Deduct 5 points for each operation without feedback, 3 points for laggy animations during rapid cell reveals, and 5 points for confusing state indicators (unclear if a cell is flagged or revealed). The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "easy"
-}