@getollie/cli 0.0.5 → 0.2.1

package/library/game_development-casual/whack-a-mole-mini-game-html-frontend.json

@@ -1,68 +0,0 @@
-{
-  "index": 1423,
-  "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. Help me write a Whack-a-Mole mini-game using HTML frontend.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core Whack-a-Mole game mechanism fully implemented?",
-      "description": "Check if the code properly implements the core game mechanics: random mole appearance from holes, player clicking/tapping to whack moles, score tracking, and time limit. Score 0 if the basic game loop isn't working, 5 points if only simple functionality exists, and 10 points if the game includes varied mole speeds, proper animation for moles appearing/disappearing, and correct hit detection.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the game board UI properly designed and rendered?",
-      "description": "Evaluate if the game board has appropriate layout with clearly defined holes for moles, consistent spacing, and responsive design that works on different screen sizes. Deduct 3 points if the mole holes aren't visually distinct, 4 points if the layout breaks on mobile devices, and 3 points if the game area doesn't maintain proper proportions. Full score requires professional-looking holes and moles with visual depth.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Does the game implement proper scoring and game state management?",
-      "description": "Review the implementation of score tracking, countdown timer, game states (start, playing, game over), and session persistence. Deduct 5 points if score increments don't validate actual hits, 3 points if the timer doesn't accurately control game duration, and 5 points if game states aren't properly managed. Full score requires persistent high scores and clean state transitions.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Does the game include difficulty progression or levels?",
-      "description": "Assess if the game implements increasing difficulty (faster moles, shorter appearance times, fake moles, etc.) either through timed progression or explicit level selection. Score 0 if difficulty remains static, 5 points for basic difficulty increase over time, and 10 points for a sophisticated level system with multiple parameters affecting gameplay.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid clicking, browser resizing, loss of focus, etc.) and provide friendly error handling. Code with strong robustness should prevent cheating through rapid clicking, handle browser tab switching gracefully, and recover from potential errors. Give 10 points for excellent robustness, 5 points for average handling, and 0 points if no exception handling exists.",
-      "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 bonus moles 2. Power-ups or combo systems 3. Visual/audio feedback for successful hits 4. Theme customization options). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple scoring systems coexisting) 2. Function modules unrelated to the Whack-a-Mole game (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/input handling), code organization, and maintainability. Deduct 5 points if global variables are excessively used or proper encapsulation is missing; deduct 5 points if the code duplication rate is too high; deduct 5 points if there's no separation between game logic and DOM manipulation. The full score is 10 points for clean, maintainable code.",
-      "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/tap response delay ≤ 100ms 2) Mole animation duration appropriate (200-400ms) 3) Clear visual feedback for hits and misses. Deduct 5 points for laggy animations, 3 points for unclear hit feedback, and 5 points if the game feels unresponsive. The full score is 10 points for a game that feels snappy and satisfying to play.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Casual",
-  "difficulty": "medium"
-}

package/library/game_development-casual/whack-a-mole-mini-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 1264,
-  "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. I'd like to create a whack-a-mole mini-game. I'm a complete beginner, so please explain the detailed steps. Generate comprehensive code with explanatory comments. The code should be directly runnable in the WeChat Mini Program Developer Tools.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core game mechanics fully implemented?",
-      "description": "Review whether the code accurately implements the whack-a-mole game mechanics through JavaScript, including random mole appearance, hit detection, and scoring system. Check if moles appear at random positions and timing, disappear after being hit or after a timeout, and if points are correctly awarded for successful hits. Score 0 if the core game logic is missing, 5 if basic functionality works but with issues, and 10 if the game mechanics are fully implemented with proper randomization and hit detection.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the game UI properly designed for WeChat Mini Program?",
-      "description": "Evaluate whether the implementation uses appropriate WeChat Mini Program components (WXML/WXSS) and follows the platform's design guidelines. Check if the implementation includes game board layout, mole holes, mole animations, hammer cursor/animation, and score display. Deduct 5 points if the UI doesn't follow WeChat Mini Program standards, and 3 points if essential visual elements are missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are game difficulty levels and progression implemented?",
-      "description": "Check whether the code includes different difficulty levels (e.g., increasing speed of moles, decreasing appearance time, or introducing distractors). Evaluate if there's a clear progression system (increasing difficulty over time or levels) and if the game speed/challenge adapts to player performance. Deduct 5 points if there's no difficulty adjustment, 3 points if progression is too simple. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is game state management properly implemented?",
-      "description": "Assess whether the code handles different game states (start screen, gameplay, pause, game over) correctly and smoothly transitions between these states. Check if the implementation includes timer management, score tracking, high score recording, and proper game reset functionality. Deduct 5 points if state transitions are buggy, and 3 points if essential state management features are missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid tapping, extreme screen sizes, unexpected user interactions) and provide friendly error handling or recovery mechanisms. Code with strong robustness should prevent cheating methods and handle edge cases effectively, 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 bonus moles 2. Combo system for consecutive hits 3. Power-ups or special abilities 4. Themed visual/sound effects based on player performance). 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 hit detection mechanisms) 2. Function modules unrelated to the whack-a-mole game (e.g., unnecessary mini-games within) 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 proper use of WeChat Mini Program lifecycle functions. Deduct 5 points if global state pollution is found; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the file structure doesn't follow Mini Program best practices. 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 mobile game design principles: 1) Appropriate and consistent color scheme 2) Proper layout for touch interactions (tap targets at least 44x44px) 3) Clear visual feedback for hits and misses 4) Adequate contrast between game elements. Deduct 3 points for each cluttered visual element, 5 points for an unappealing or inconsistent color scheme, and 5 points for poor visibility of game elements. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and responsive?",
-      "description": "Judge whether the touch interactions and animations conform to mobile gaming standards: 1) Hit registration delay ≤ 100ms 2) Smooth animations for mole appearance/disappearance 3) Intuitive hammer/tap feedback. Deduct 5 points for noticeable input lag, 3 points for janky animations, and 5 points for confusing or missing visual feedback on hit/miss actions. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Casual",
-  "difficulty": "easy"
-}

package/library/game_development-casual/world-of-warcraft-manual-counting-script.json

@@ -1,68 +0,0 @@
-{
-  "index": 1040,
-  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code whenever possible. Write a small window script for World of Warcraft that can be used for manual counting.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core counting functionality properly implemented?",
-      "description": "Check whether the script accurately implements the basic counting mechanism for manual tracking in WoW. Score 0 if no counting logic exists, 5 if only basic incrementing/decrementing is implemented, and 10 if it includes features like multiple counter types, reset functionality, and persistence between sessions.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the addon properly structured according to WoW addon standards?",
-      "description": "Evaluate whether the code follows proper WoW addon structure (TOC file, directory organization, proper event handling, etc.). Check if it uses the correct API calls for frame creation and management. Deduct 5 points if the TOC file is missing or incomplete, and 3 points if the addon doesn't follow proper naming conventions to avoid conflicts. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Does the script provide user-friendly input methods?",
-      "description": "Verify if the script implements appropriate user input methods like slash commands, keybindings, or clickable buttons. Check if the commands follow WoW addon conventions and are properly registered. Deduct 5 points if slash commands aren't implemented, 3 points if there's no keybinding option, and 2 points if command help/usage information is missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there proper event handling and frame management?",
-      "description": "Assess whether the script correctly uses WoW API for event registration, frame creation, and UI updates. Check if it properly handles events like player login/logout, UI reloads, and avoids taint issues. Deduct 5 points for improper event handling, 5 points for memory leaks due to poor frame management, and 5 points if the script interferes with protected frames. 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 addon conflicts, unexpected inputs, addon memory reset, 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 script includes surprise features that enhance the experience (e.g., 1. Visual animations for count changes 2. Integration with game events for automatic counting 3. Data export/sharing 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 implementation of similar functions (e.g., multiple ways to reset counters) 2. Function modules unrelated to counting (e.g., a built-in damage meter) 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 logic/view/data persistence layers), code organization, and maintainability. Deduct 5 points if global variables pollute the WoW namespace; 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 WoW addon standards?",
-      "description": "Evaluate whether the visual design follows WoW UI principles: 1) Consistent with WoW's visual theme 2) Proper use of WoW UI elements and textures 3) Appropriate scaling for different resolutions. Deduct 3 points for each non-standard UI element, 5 points for clashing with WoW's aesthetic, and 5 points for poor positioning or overlap with important game UI. 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 WoW addon expectations: 1) Responsive to user inputs with minimal delay 2) Proper integration with WoW's frame update cycle 3) Efficiency in update processing to avoid performance impact. Deduct 5 points for each operation without feedback, 5 points for noticeable FPS drops when using the addon, and 3 points for inconsistent behavior across different game scenarios. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Casual",
-  "difficulty": "easy"
-}

package/library/game_development-puzzle/2048-game-implementation-html5.json

@@ -1,68 +0,0 @@
-{
-  "index": 85,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate can be executed and displayed properly.\n\nDo you know the game 2048? It's a grid where there are squares with numbers like 2, 4, 8, etc. Two 2s can merge to form 4, two 4s can merge to form 8. Can you implement a 2048 game using HTML5?",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core game logic of 2048 correctly implemented?",
-      "description": "Review whether the code accurately implements the fundamental 2048 mechanics: grid initialization with random 2s or 4s, directional swipes that move and merge tiles, correct merging of identical values (2+2=4, 4+4=8, etc.), score tracking, and win/lose conditions. Score 0 if the core logic is missing, 5 if basic movement works but merging has bugs, and 10 if all game rules are correctly implemented with proper random tile generation after each move.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the grid rendering and visual representation of the game state properly implemented?",
-      "description": "Check if the 4×4 grid is correctly displayed with proper alignment, if tiles are visually distinct with appropriate colors based on their values, and if the grid updates properly after each move. Examine whether animations for tile movement and merging are included. Deduct 5 points if the grid display is static without animations, 3 points if tile colors don't follow a logical progression based on values, and 2 points if the grid layout breaks on different screen sizes. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are all user input methods properly implemented?",
-      "description": "Evaluate whether the game accepts both keyboard arrow keys and touch/swipe gestures on mobile devices. Check if the input handling prevents multiple inputs during animations and if there's proper event binding/unbinding to prevent memory leaks. Deduct 5 points if only keyboard input is implemented, 3 points if touch events don't properly detect swipe direction, and 5 points if input handling causes performance issues. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the game state management complete with save/load functionality?",
-      "description": "Assess whether the code includes functionality to save game progress (using localStorage or other methods), undo moves, restart the game, and maintain high scores across sessions. Deduct 5 points if there's no save/load functionality, 3 points if the game state isn't properly preserved on page refresh, and 2 points if high scores aren't tracked. 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 inputs, browser refresh, 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. Custom grid sizes beyond 4×4 2. Animated tile merging effects 3. Theme customization 4. Progressive difficulty levels). 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 2048 (e.g., a built-in calculator) 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, naming conventions, and maintainability. Deduct 5 points if global state pollution is found or if the code is not organized into logical functions; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there are no 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 that differentiates tile values clearly 2) Proper layout spacing with consistent margins around tiles 3) Professional typography with readable numbers at all tile values. Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for poor number visibility on tiles with large values. 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 response to swipe/key inputs (≤ 100ms) 2) Smooth tile sliding animations (300-500ms) 3) Clear visual feedback when tiles merge. Deduct 5 points for each operation without feedback, 3 points for jerky animations during tile movement, and 5 points for inconsistent animation speeds. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "medium"
-}

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

@@ -1,68 +0,0 @@
-{
-  "index": 1404,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable for demonstration purposes. Write the code for a 2048 game.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core game mechanism of 2048 correctly implemented?",
-      "description": "Verify if the implementation accurately follows 2048 rules: tiles slide to the edge when a direction is input, identical tiles merge upon contact doubling their value, and a new tile (2 or 4) appears randomly after each move. Score 0 if the core logic is missing, 5 if basic movement works but has merge bugs, and 10 if all rules are correctly implemented including win/lose detection.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the grid system and tile management properly designed?",
-      "description": "Check if the code includes a proper 4x4 grid implementation with correct positioning of tiles, efficient handling of tile creation/deletion/merging, and appropriate data structure for board state representation. Deduct 5 points if the grid system uses inefficient algorithms (O(n²) when unnecessary), 3 points if tile positioning is inconsistent, and 2 points if the board state isn't properly encapsulated. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the user input handling robust and responsive?",
-      "description": "Evaluate if the code handles keyboard inputs (arrow keys) correctly, includes touch/swipe support for mobile users, and offers alternative input methods. The input system must prevent move processing during animations and handle rapid consecutive inputs appropriately. Deduct 5 points if mobile input is missing, 3 points if keyboard handling is buggy, and 5 points if input during animations causes glitches. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is game state management and scoring implemented properly?",
-      "description": "Assess whether the code tracks score correctly (adding merged tile values to score), detects win/lose conditions accurately (2048 tile creation/no valid moves available), and includes game reset functionality. Score management should persist between sessions. Deduct 5 points if high score tracking is missing, 3 points if win/lose detection has edge-case bugs, and 5 points if game reset doesn't properly reinitialize all variables. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code handles edge cases such as rapid inputs, browser refreshes, invalid moves, and unexpected user interactions. Code should validate inputs, prevent game state corruption, and recover gracefully from potential errors. Deduct 5 points if error handling is inadequate, 3 points if the game breaks under rapid inputs, and 3 points if state corruption can occur. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Undo/redo functionality 2. Custom grid sizes beyond 4x4 3. Alternative game modes 4. Animated tutorials or hints). 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. Duplicate code for similar tile operations 2. Unnecessary recalculations of grid state 3. Over-engineered features that add complexity without improving gameplay. Deduct 3 points for each redundancy found, and directly deduct 10 points if core game performance is negatively affected by inefficient implementations.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (separating game logic from UI), code reusability, proper commenting, and adherence to language-specific best practices. Deduct 5 points if there's no separation between game logic and rendering, 3 points if variable names are unclear or inconsistent, and 5 points if there are hardcoded values throughout instead of constants/configuration. 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 principles: 1) Consistent color scheme that enhances tile value recognition 2) Proper spacing between grid cells and tiles 3) Responsive layout that works across device sizes 4) Clear typography with adequate contrast. Deduct 3 points for inconsistent spacing, 5 points for poor color choices that make tile values hard to read, and 5 points for non-responsive layouts. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the animations enhance gameplay: 1) Smooth tile sliding animations (150-250ms duration) 2) Clear visual feedback for tile merging 3) Subtle entrance animations for new tiles 4) Appropriate game over/win screen transitions. Deduct 5 points for jerky animations, 3 points for missing visual feedback on key actions, and 5 points for animations that delay input processing by more than 300ms. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "easy"
-}

package/library/game_development-puzzle/2048-mini-game-browser-implementation.json

@@ -1,68 +0,0 @@
-{
-  "index": 302,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Take care to ensure that the code you produce is executable and functional. Please help me write a 2048 mini-game that can run in a browser.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core 2048 game logic fully implemented?",
-      "description": "Review whether the code accurately implements the 2048 game mechanics including tile merging, movement in all four directions, and scoring system. Check if the algorithm correctly handles the merging of same-value tiles and prevents illegal moves. Score 0 if the core logic is missing, 5 if basic movements work but with edge case bugs, and 10 if all game rules are perfectly implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Does the game initialize and generate new tiles correctly?",
-      "description": "Evaluate whether the game properly initializes with 2 random tiles at the start, and adds a new tile (with value 2 or 4) after each valid move. Check if the random tile generation only occurs in empty spots and follows the correct probability distribution (90% for 2, 10% for 4). Deduct 5 points if random generation is deterministic or biased, and 3 points if new tiles don't appear after valid moves. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the win/lose condition properly implemented?",
-      "description": "Check if the game correctly detects win conditions (reaching the 2048 tile) and lose conditions (no valid moves available when the board is full). Verify that the game provides appropriate feedback upon winning or losing. Deduct 5 points if only one condition is implemented, and 3 points if the detection is delayed or buggy. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are the keyboard and touch/swipe controls implemented effectively?",
-      "description": "Assess whether the game responds to both keyboard inputs (arrow keys) and touch/swipe gestures on mobile devices. Check for gesture recognition accuracy, handling of simultaneous inputs, and prevention of accidental moves. Deduct 5 points if only keyboard controls work, 3 points if touch controls are implemented but unreliable, and 2 points if input handling has noticeable delay. 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 successive inputs, browser refresh, resizing window, etc.) and provide graceful degradation. Code with strong robustness should prevent game state corruption and handle these edge cases. Give 10 points for comprehensive error handling, 5 points for average robustness, and 0 points if the game breaks easily under non-standard use.",
-      "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. Undo/redo functionality 2. Customizable board size 3. Animation speed controls 4. Auto-save game progress 5. Leaderboard integration). Add 2 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant event listeners or game logic calculations 2. Unnecessary UI elements unrelated to the 2048 game 3. Overengineered animations that affect performance. 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 rendering, and input handling), code reusability, and maintainability. Deduct 5 points if global state management is messy; deduct 3 points if magic numbers are used instead of constants; deduct 2 points if the code lacks comments on 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 game follows the classic 2048 aesthetic while maintaining modern design principles: 1) Consistent color scheme for tile values 2) Clear visual distinction between different numbered tiles 3) Proper spacing and grid layout 4) Responsive design that works on different screen sizes. Deduct 3 points for inconsistent tile styling, 3 points for poor readability of numbers, and 4 points for non-responsive layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the animations enhance the game experience: 1) Smooth tile sliding animations (150-250ms duration) 2) Tile merging animations with appropriate visual feedback 3) Subtle but visible new tile appearance effect. Deduct 4 points for jerky or missing movement animations, 3 points for abrupt tile appearances without animation, and 3 points for animations that are too slow and impede gameplay. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "medium"
-}

package/library/game_development-puzzle/5th-grade-science-heart-brain-quiz-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 349,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. 5th Grade Science Semester 2 Knowledge Outline\n\n## Unit 1: Heart and Brain\n### Lesson 1: Our Brain\n1. The brain is the \"command center\" of the human body, directing human actions, generating thoughts and emotions, and performing cognition and decision-making. The brain controls human behavior and emotions.\n2. The brain is divided into three parts: the cerebrum, cerebellum, and brainstem. The cerebrum is divided into left and right hemispheres. Different regions have different functions.\n3. Our brain has sensory centers, auditory centers, motor centers, and visual centers.\n4. We can think, judge, and experience emotions like happiness, anger, sadness, and joy. This is the brain at work.\n\n### Lesson 2: The Nervous System\n1. The nervous system includes the brain, peripheral nerves, and spinal cord.\n2. Nerves are the body's \"telephone lines,\" capable of promptly reporting information obtained from various parts of the body to the brain, and transmitting commands from the brain to various parts of the body.\n3. After the starting gun fires, an athlete's ears receive the sound stimulus, the auditory nerve transmits the signal to the brain, the brain determines it's the starting signal, sends commands through nerves to the muscles, and the athlete begins to run.\n4. If a finger is suddenly pricked by a sharp object, we withdraw our hand first, then feel the pain.\n\n### Lesson 3: Protecting the Brain\n1. The brain is a vital organ of the human body.\n2. How does the human body protect the brain?\n   Answer: ①The skull, similar to a walnut shell, protects the brain. ②There are membranes between the skull and brain tissue that protect and support brain tissue. ③Yawning is a brief self-protective method for the brain to increase blood oxygen levels.\n3. How can we protect our brain?\n   Answer: ①Adequate sleep; ②Alternating between different subjects when studying; ③Appropriate physical exercise; ④No smoking or excessive drinking; ⑤Wearing helmets when cycling.\n\n### Lesson 4: Heart and Blood Vessels\n1. Heart rates differ by age. For children and adolescents under normal circumstances, the heart beats 60 to 100 times per minute.\n2. Heart rate is the number of heartbeats per minute. Pulse rate is the number of arterial pulsations per minute. Under normal circumstances, a person's pulse rate and heart rate are the same.\n3. The heart is located on the left side of the chest cavity, shaped like an inverted pear, larger at the top and smaller at the bottom, approximately the size of one's fist. The heart has four chambers: left atrium, right atrium, left ventricle, and right ventricle.\n4. Blood vessels are divided into arteries, veins, and capillaries.\n5. Each time the heart contracts and relaxes, we feel one heartbeat. Typically, the heart pumps about 70ml of blood with each beat.\n6. How to protect our heart and blood vessels?\n   Answer: ①Daily outdoor exercise; ②Calm emotions and positive outlook; ③Balanced diet and moderate eating habits.\n\n### Lesson 5: Our Health Records\n1. Establishing health records helps us understand our physical health status and prevent and treat diseases in a timely manner.\n2. The WHO has outlined indicators of human health:\n   (1) Mental vitality, able to cope with daily life and work calmly.\n   (2) Positive attitude, optimistic outlook, willingness to take responsibility, non-critical.\n   (3) Ability to rest well, good sleep quality.\n   (4) Strong adaptability, able to adjust to various environmental changes.\n   (5) Certain resistance to common colds and infectious diseases.\n   (6) Appropriate weight, proportionate physique.\n   (7) Bright eyes, quick reactions, no eyelid inflammation.\n   (8) Clean, undamaged teeth, gums that don't bleed.\n   (9) Lustrous hair without dandruff.\n   (10) Radiant and elastic skin, walking with ease and vitality.\n\nPlease generate a game code with 40 challenge questions based on this content. The game code should be able to run offline. The game background should be light blue.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the educational content accurately implemented based on the 5th Grade Science curriculum?",
-      "description": "Review whether the 40 challenge questions accurately cover all five lessons from Unit 1: Heart and Brain. Check if questions properly test knowledge about brain structure (cerebrum, cerebellum, brainstem), nervous system components, brain protection methods, heart anatomy (four chambers), blood vessels (arteries, veins, capillaries), and health indicators. Score 0 if less than 30 questions are implemented, 5 if questions cover only 3-4 lessons comprehensively, and 10 if all curriculum points are accurately represented with appropriate difficulty levels.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the game mechanics and challenge system properly designed?",
-      "description": "Evaluate whether the game includes proper question randomization, scoring system, progress tracking, and multiple question types (multiple choice, true/false, fill-in-the-blank, drag-and-drop). Check for proper game flow with clear instructions, question feedback, and completion rewards. Deduct 5 points if no scoring system exists, 3 points if questions appear in fixed order without randomization, and 5 points if feedback mechanisms are missing. Full score requires engaging educational gameplay mechanics.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the offline functionality completely implemented?",
-      "description": "Verify that the game runs entirely offline without requiring internet connectivity. All assets (images, sounds, data) must be embedded or locally stored. Check that the game loads and functions properly when disconnected from the network. The application should be self-contained with no external API calls or CDN dependencies. Deduct 10 points if any network requests are required, 5 points if assets fail to load offline, and 3 points if performance degrades significantly in offline mode.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the educational progression and learning reinforcement well-structured?",
-      "description": "Assess whether the game provides proper learning scaffolding with questions organized by difficulty and topic progression. Check for hint systems, explanation of correct answers, and knowledge reinforcement through varied question formats. Evaluate if the game tracks learning progress and provides remedial questions for incorrect answers. Deduct 5 points if no difficulty progression exists, 3 points if explanations are missing for wrong answers, and 5 points if no learning analytics or progress tracking is implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid user inputs, missing data, browser compatibility issues, and unexpected user behaviors) 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 educational features that enhance learning?",
-      "description": "Check whether the code includes engaging features that improve educational outcomes (e.g., 1. Interactive anatomical diagrams 2. Gamified achievement badges 3. Adaptive difficulty based on performance 4. Visual learning aids and animations 5. Progress sharing capabilities). Add 3 points for each practical innovative feature implemented (maximum 10 points). Features should specifically enhance the science learning experience.",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple scoring systems coexisting) 2. Function modules unrelated to science education (e.g., built-in social media features) 3. Fancy effects that distract from learning (e.g., excessive animations that interfere with reading). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core educational 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 layers), code organization, and maintainability. Deduct 5 points if global state pollution is found or proper separation of concerns is not implemented; deduct 5 points if the code duplication rate is too high (over 30%); deduct 3 points if variable naming and commenting are poor. The full score requires clean, well-documented, and maintainable code structure.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface design meet educational and aesthetic standards with proper light blue theme?",
-      "description": "Evaluate whether the design follows educational interface principles with the specified light blue background: 1) Proper use of light blue theme without eye strain 2) Clear typography suitable for 5th graders (font size ≥ 16px) 3) Intuitive navigation and age-appropriate UI elements 4) Adequate contrast ratios for readability 5) Consistent visual hierarchy. Deduct 5 points for poor color implementation, 3 points for inadequate text readability, and 5 points for non-intuitive navigation design.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the user interaction smooth and educationally appropriate?",
-      "description": "Judge whether the interactions are suitable for 5th grade students: 1) Response time ≤ 200ms for all interactions 2) Clear visual feedback for all user actions 3) Intuitive button placement and sizing 4) Smooth transitions that don't distract from learning 5) Accessible design considerations. Deduct 5 points for each interaction without proper feedback, 3 points for confusing navigation elements, and 5 points for interactions that hinder the learning process.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "easy"
-}

package/library/game_development-puzzle/angry-birds-game-implementation.json

@@ -1,68 +0,0 @@
-{
-  "index": 1126,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Be sure to provide executable code when possible. Generate code for an Angry Birds game.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core physics engine for Angry Birds properly implemented?",
-      "description": "Review whether the code accurately implements projectile physics, gravity, collision detection, and material properties. Check if trajectory prediction is included for aiming. Score 0 if physics engine is missing, 5 if only basic projectile motion is implemented, and 10 if it includes realistic physics with material deformation and destruction.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are all essential game objects and their interactions implemented?",
-      "description": "Evaluate if the code includes birds with different abilities, various destructible structures, pigs with health properties, and the slingshot mechanism. Check whether object interactions (collisions, destruction) have proper visual and sound feedback. Deduct 3 points if bird special abilities are missing, 3 points if structure destruction physics are simplified, and 2 points if collision feedback is inadequate. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the level design system properly implemented?",
-      "description": "Check if the game includes a level management system with progressive difficulty, score calculation, star rating system, and level persistence. Verify if the code allows for custom level creation or loading predefined level structures. Deduct 5 points if only fixed levels are available without progression, and 3 points if the scoring system is overly simplified. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the game loop fully functional with proper state management?",
-      "description": "Evaluate whether the game includes proper state management (menu, gameplay, level completion, game over), turn management, retry mechanism, and level progression. Check if the player can restart levels, skip to next bird, or exit to menu. Deduct 3 points if state transitions are not smooth, 3 points if save/load functionality is missing, and 3 points if pause functionality is not implemented. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as window resizing, rapid input sequences, performance degradation on complex scenes, 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. Weather effects impacting physics 2. Unique bird abilities beyond the original game 3. Interactive background elements 4. Social sharing of replays). 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 physics engines coexisting) 2. Function modules unrelated to the core gameplay (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive particle effects slowing down gameplay). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/rendering/input systems), use of design patterns appropriate for game development, and asset management. 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 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 game design standards?",
-      "description": "Evaluate whether the visuals follow polished game design principles: 1) Consistent art style across all elements 2) Clear visual hierarchy for gameplay elements 3) Appropriate feedback animations for player actions 4) Intuitive UI with clear icons and readable text (font size ≥ 14px). Deduct 3 points for inconsistent art style, 3 points for cluttered UI elements, and 4 points for confusing visual feedback during gameplay. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and game-appropriate?",
-      "description": "Judge whether the controls and animations meet modern game standards: 1) Responsive controls (<100ms feedback) 2) Smooth transitions between game states 3) Satisfying visual/audio feedback for destruction physics 4) Appropriate camera movements that follow action. Deduct 3 points for input lag, 3 points for jerky animations, 2 points for missing sound effects during key interactions, and 2 points for disorienting camera behavior. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "hard"
-}