@getollie/cli 0.0.4 → 0.2.0

package/library/game_development-casual/html-snake-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 1407,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Be sure to provide executable code whenever possible. Design a Snake game using HTML.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core snake game mechanics correctly implemented?",
-      "description": "Review the code for accurate implementation of basic game mechanics: snake movement in four directions, food spawning at random positions, and collision detection (snake-food, snake-wall, snake-self). Score 0 if core mechanics are missing, 5 if only basic movement exists, and 10 if all standard mechanics are properly implemented including speed adjustment as the snake grows.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the game loop and user input handling properly designed?",
-      "description": "Examine the game's main loop structure for proper timing (using requestAnimationFrame or setInterval with appropriate intervals), and check input handling for responsiveness and prevention of illegal moves (like immediate reversal). Deduct 3 points for frame rate issues, 3 points for laggy input response, and 5 points if illegal moves are possible. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the game state management complete?",
-      "description": "Verify if the code includes proper game state management (start, play, pause, game over) with appropriate transitions between states. Check for score tracking, high score persistence (localStorage), and game reset functionality. Deduct 3 points if any state is missing, 3 points without score persistence, 2 points if game reset requires page reload. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the HTML5 Canvas or DOM rendering optimized?",
-      "description": "Evaluate the rendering approach (Canvas or DOM elements) for efficiency. For Canvas, check if drawing operations are minimized and if the context is properly managed. For DOM, check if element creation/destruction is minimized. Deduct 5 points for unnecessary re-renders, 3 points for unoptimized drawing calls, and 3 points for lack of appropriate browser compatibility. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid input sequences, browser tab switching, window resizing, etc.) and provide friendly error handling. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Different types of food with special effects 2. Obstacles or changing map layouts 3. Power-ups or special abilities). 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 input) 2. Function modules unrelated to the Snake game 3. Fancy effects 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 (separation of game logic, rendering, and input handling), code reusability, and maintainability. Deduct 5 points if game logic is tightly coupled with rendering; deduct 5 points if the code has high duplication rate; deduct 3 points if variable/function naming is unclear. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the game design follows modern design principles: 1) Consistent visual style with appropriate color scheme 2) Clear game area boundaries and readable score display 3) Appropriate sizing of game elements for playability. Deduct 3 points for unclear game boundaries, 3 points for poor contrast making elements hard to see, 4 points for inconsistent sizing of snake segments or food. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the game responds well to user input: 1) Immediate visual feedback on key presses 2) Smooth snake movement without jitter 3) Clear visual cues for game events (eating food, game over). Deduct 4 points for delayed movement response, 3 points for choppy animation, 3 points for lack of visual feedback on important game events. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Casual",
-  "difficulty": "easy"
-}

package/library/game_development-casual/html5-sailing-mini-game-character-symbols.json

@@ -1,68 +0,0 @@
-{
-  "index": 1665,
-  "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 whenever possible. Create a sailing mini-game using HTML5, using character symbols to replace graphic resources.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the sailing game core mechanics fully implemented?",
-      "description": "Review whether the code accurately implements sailing physics through HTML5 Canvas/JavaScript, including wind direction effects on boat movement, sail angle adjustments, and realistic boat dynamics (acceleration, deceleration, turning). Check if character symbols effectively represent boat, wind indicators, and environmental elements. Score 0 if core sailing mechanics are missing, 5 if only basic movement is implemented, and 10 if realistic sailing physics with wind interaction are fully included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the game environment and navigation system properly designed?",
-      "description": "Evaluate whether the game includes a proper maritime environment with boundaries, obstacles (islands, rocks), and navigation elements using character symbols. Check for wind visualization, compass/direction indicators, and collision detection with environmental elements. Deduct 5 points if environmental boundaries are not implemented, and 3 points if wind direction indicators are unclear or missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are the game objectives and progression mechanics implemented?",
-      "description": "Check whether the game includes clear objectives (racing checkpoints, cargo delivery, treasure hunting, etc.) and scoring/timing systems. Evaluate if there are multiple difficulty levels or progressive challenges. Deduct 5 points if no clear win/lose conditions exist, and 3 points if scoring mechanism is missing. Assess whether the game provides meaningful progression and replayability. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the character symbol representation system well-designed and intuitive?",
-      "description": "Evaluate whether character symbols are used creatively and intuitively to represent game elements (boat: ⛵ or ^, waves: ~, wind: →, islands: ●, etc.). Check if symbols are consistent, visually distinguishable, and scale appropriately. Review if there's a legend or help system explaining symbol meanings. Deduct 5 points if symbols are confusing or inconsistent, and 3 points if scaling issues affect readability. Give 10 points if symbols create a cohesive and intuitive visual system.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as out-of-bounds movement, invalid input, browser compatibility issues, canvas rendering errors, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should effectively handle edge cases like window resizing, keyboard/mouse input validation, and game state corruption. Give 10 points for comprehensive error handling, 5 points for basic exception handling, and 0 points if no exceptions are handled.",
-      "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 sailing experience (e.g., 1. Weather system affecting gameplay 2. Realistic tide effects 3. Multi-boat AI opponents 4. Sound effects using Web Audio API 5. Procedurally generated maps). Evaluate creativity in using character symbols for advanced visual effects or animations. Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple collision detection systems) 2. Function modules unrelated to sailing gameplay (e.g., built-in calculator) 3. Overly complex character symbol animations that affect performance or readability. Deduct 3 points for each redundancy found, and directly deduct 10 points if core sailing functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (separating game logic/rendering/input handling), code organization, and HTML5 best practices. Check for proper Canvas usage, efficient rendering loops, and memory management. Deduct 5 points if global state pollution is found or no design patterns are used; deduct 5 points if code duplication rate is too high (over 30%); deduct 5 points if no optimization for animation frames or Canvas performance. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface design meet professional standards despite using character symbols?",
-      "description": "Evaluate whether the overall design creates a cohesive visual experience: 1) Harmonious color scheme for background and text 2) Proper spacing and layout organization 3) Readable font system with appropriate sizing for game UI elements 4) Effective use of character symbols to create visual hierarchy. Deduct 3 points for each cluttered visual element, 5 points for poor color contrast affecting readability, and 5 points for chaotic symbol arrangement. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the gameplay interaction smooth and responsive?",
-      "description": "Judge whether the game controls and feedback conform to gaming standards: 1) Input response delay ≤ 100ms 2) Smooth animation transitions for boat movement 3) Clear visual feedback for user actions 4) Intuitive control scheme (keyboard/mouse). Deduct 5 points for each unresponsive control, 3 points for choppy animations or poor frame rates, and 5 points for unclear control instructions or feedback. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Casual",
-  "difficulty": "easy"
-}

package/library/game_development-casual/jump-jump-game-assistant-jumping-distance.json

@@ -1,68 +0,0 @@
-{
-  "index": 970,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Make sure the generated code is executable for demonstration. Write a mobile-runnable code for a \"Jump Jump\" game assistant that obtains the character's coordinates, and then extends a line based on press duration to determine jumping distance.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the character coordinate detection system accurately implemented?",
-      "description": "Review whether the code implements precise character position detection through image recognition or screen capture APIs, including pixel analysis algorithms and coordinate calculation logic. Score 0 if coordinate detection is not implemented, 5 if basic position detection works but accuracy is below 90%, and 10 if character coordinates are detected with high precision (>95% accuracy) and include validation mechanisms.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the press duration measurement and distance calculation mechanism properly functioning?",
-      "description": "Check whether the code accurately measures touch/press duration and converts it to jumping distance using appropriate mathematical models. Evaluate if the timing mechanism handles different touch events correctly and calculates distance with proper scaling. Deduct 5 points if timing accuracy is poor (>50ms deviation), and 3 points if distance calculation lacks calibration options. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the visual trajectory line extension system implemented effectively?",
-      "description": "Evaluate whether the code renders a dynamic trajectory line that extends based on press duration, with real-time visual feedback. Check if the line drawing uses proper graphics APIs (Canvas/SVG) and updates smoothly during interaction. Deduct 5 points if line rendering is choppy or delayed, and 3 points if visual indicators don't match actual calculated distance. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is mobile platform compatibility and touch interaction properly handled?",
-      "description": "Check whether the code is optimized for mobile devices with proper touch event handling, screen size adaptation, and performance optimization. Evaluate if the implementation works across different mobile browsers/platforms and handles device-specific features. Deduct 5 points if touch responsiveness is poor, and 3 points if screen adaptation is inadequate. Give 10 points if fully mobile-optimized.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as screen resolution changes, touch interruptions, coordinate detection failures, 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 gaming experience (e.g., 1. Auto-calibration for different game versions 2. Success rate statistics and learning optimization 3. Trajectory prediction with physics simulation 4. Multi-target detection and selection). 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 coordinate detection methods running simultaneously) 2. Function modules unrelated to the game assistant (e.g., built-in social features) 3. Fancy effects that affect performance (e.g., complex particle systems). Deduct 3 points for each redundancy found, and directly deduct 10 points if 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 detection logic/UI/calculation modules), error handling coverage, and mobile optimization practices. Deduct 5 points if global state pollution is found or proper mobile development patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if mobile performance optimization is not implemented. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet mobile design standards?",
-      "description": "Evaluate whether the mobile interface follows modern mobile design principles: 1) Touch-friendly button sizes (minimum 44px tap targets) 2) Appropriate contrast ratios for outdoor visibility 3) Clear visual hierarchy with proper spacing 4) Responsive design for different screen sizes. Deduct 3 points for each UI element that's hard to interact with on mobile, 5 points for poor readability, and 5 points for non-responsive layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the real-time interaction smooth and responsive?",
-      "description": "Judge whether the real-time feedback meets mobile gaming standards: 1) Touch response delay ≤ 50ms 2) Smooth line extension animation at 60fps 3) Immediate visual feedback for all interactions 4) Stable performance during continuous use. Deduct 5 points for each laggy interaction, 3 points for inconsistent frame rates, and 5 points for delayed coordinate updates. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Casual",
-  "difficulty": "easy"
-}

package/library/game_development-casual/keyboard-practice-master.json

@@ -1,68 +0,0 @@
-{
-  "index": 778,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Keyboard Practice Master\n\nYou are a code expert. Please use your professional knowledge to generate accurate and professional responses. Try to ensure that the generated code is executable. Help me create a webpage for computer keyboard typing practice, focusing on letter typing. Letters appear randomly - you get 1 point for typing correctly, lose 1 point for mistakes. When the score exceeds 26 points, provide positive feedback and reset the score to zero. The page should be double-clickable to run.\n\nRequirements:\n- The webpage background should feature a realistic virtual keyboard\n- Letters should appear at the corresponding positions on the keyboard\n- Include keyboard typing sounds when keys are pressed\n- The page should be simple with a \"Score Board\" at the top to record practice scores\n- Display \"Keyboard Practice Master\" prominently in large text at the top",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the virtual keyboard rendering and letter positioning system fully implemented?",
-      "description": "Review whether the code accurately renders a realistic virtual keyboard layout through HTML/CSS, and whether letters appear at the correct corresponding key positions. Check if the keyboard layout follows standard QWERTY arrangement with proper key sizing and spacing. Score 0 if the keyboard is not visually realistic or letters don't appear at correct positions, 5 if only basic keyboard is shown without proper letter positioning, and 10 if a fully realistic keyboard with accurate letter positioning is implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the typing detection and scoring mechanism accurately implemented?",
-      "description": "Evaluate whether the code correctly detects keyboard input, validates correct/incorrect typing, and implements the scoring system (+1 for correct, -1 for mistakes). Check if the system properly handles the 26-point threshold with positive feedback and score reset. Deduct 5 points if input detection is unreliable, 3 points if scoring logic has bugs, and 5 points if the feedback mechanism doesn't work properly. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the random letter generation and display system properly designed?",
-      "description": "Check whether the random letter generation uses proper randomization algorithms and displays letters clearly at corresponding keyboard positions. Evaluate if the letter appearance timing and visibility are appropriate for typing practice. Deduct 5 points if randomization is not truly random or biased, 3 points if letter display timing is inappropriate, and 5 points if letters are not clearly visible or positioned incorrectly. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the audio feedback system (keyboard sounds) completely integrated?",
-      "description": "Verify whether keyboard typing sounds are properly implemented and triggered on key presses. Check if audio files are optimized for web delivery and don't cause performance issues. Evaluate if sound timing matches visual feedback. Deduct 5 points if sounds don't play consistently, 3 points if audio latency is noticeable, and 5 points if sounds interfere with performance or user experience. Give 10 points if fully implemented with smooth audio feedback.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid key pressing, invalid key inputs, audio loading failures, browser compatibility issues, etc.) and provide friendly error handling or recovery mechanisms. Code with strong robustness should effectively handle edge cases and maintain functionality across different browsers. Give 10 points for excellent robustness, 5 points for average handling, and 0 points if no exception handling is implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that enhance the typing practice experience?",
-      "description": "Check whether the code includes valuable features that improve the learning experience (e.g., 1. WPM (Words Per Minute) calculation 2. Typing accuracy percentage display 3. Visual key press animations 4. Progress tracking over time 5. Difficulty level adjustments). Add 2-3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features that detract from the core functionality?",
-      "description": "Strictly check for three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple scoring systems) 2. Features unrelated to typing practice (e.g., built-in games or social media integration) 3. Excessive animations that distract from typing focus. Deduct 3 points for each redundancy found, and directly deduct 10 points if redundant code interferes with core typing practice functionality.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code demonstrate proper engineering quality and structure?",
-      "description": "Review modular design (separation of game logic, audio handling, UI components), code organization, and maintainability. Check for proper event handling, memory leak prevention, and resource management. Deduct 5 points if global state pollution is found or poor separation of concerns; deduct 5 points if code duplication rate exceeds 30%; deduct 5 points if audio resources are not properly managed or cause memory leaks. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface design meet professional visual standards for educational tools?",
-      "description": "Evaluate whether the design follows modern UI principles: 1) Clear visual hierarchy with prominent title and scoreboard 2) Keyboard design that closely resembles real keyboards 3) Appropriate color contrast for letter visibility 4) Clean, distraction-free layout that focuses attention on typing practice. Deduct 3 points for poor visual hierarchy, 5 points for unrealistic keyboard appearance, 5 points for poor color choices that affect readability, and 3 points for cluttered layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Are the interactive responses smooth and educationally effective?",
-      "description": "Judge whether the interactive feedback supports effective learning: 1) Immediate visual feedback when keys are pressed (≤100ms) 2) Clear indication of correct/incorrect typing 3) Smooth transitions and animations that don't distract from typing 4) Responsive keyboard highlighting that guides user attention. Deduct 5 points for delayed feedback, 3 points for unclear success/error indicators, 5 points for distracting animations, and 3 points for poor visual guidance. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Casual",
-  "difficulty": "easy"
-}

package/library/game_development-casual/livestream-score-tracker.json

@@ -1,68 +0,0 @@
-{
-  "index": 1538,
-  "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. Player Setup: Enter player names, and teams (optional).\nRound Management: Update points and add/subtract scores as the game progresses by using the point toggle zone.\nFont and Appearance: Customize appearance settings for the display.\nOutput: Ensure the display is broadcasted as an overlay or separate window in your livestream. Filtering out green background for a better vision.\nReset Game: Reset the game by clicking \"Reset Game\".",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the player setup system fully implemented?",
-      "description": "Check if the code accurately implements player name input and team assignment functions, including input validation, data storage, and interface display. Evaluate whether it supports multi-player management, team editing, and real-time updates of player information. If core player management functions are not implemented, score 0; if only basic input is implemented, score 5; if all player setup functions are fully implemented, score 10.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the turn management and scoring system precisely implemented?",
-      "description": "Check if the implementation of the score-switching area includes accurate score addition/subtraction logic, real-time score updates, and turn state management. Evaluate whether it has score history, undo functionality, and data persistence. If scoring logic is incorrect, deduct 5 points; if turn management is missing, deduct 3 points; if data persistence is not implemented, deduct 3 points. Full score is 10.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the font and appearance customization system complete?",
-      "description": "Evaluate whether the code provides full font selection, color customization, size adjustment, and layout settings. Check if it supports real-time preview, style saving, and theme switching. If the font system is missing, deduct 5 points; if color customization is absent, deduct 3 points; if style saving is not implemented, deduct 2 points. Full score is 10.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the live broadcast output and green screen filtering professionally implemented?",
-      "description": "Check if professional live broadcast overlay output, independent window mode, and green screen background filtering are implemented. Evaluate the precision of the chroma key algorithm, output resolution adaptation, and streaming compatibility. If green screen filtering is poor, deduct 5 points; if independent window mode is missing, deduct 3 points; if live output is unstable, deduct 2 points. Full score is 10.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "How robust is the code?",
-      "description": "Evaluate whether the code can handle common exceptions (e.g., out-of-bounds input, network interruptions, user operation errors) and provide friendly error prompts or recovery mechanisms. Highly robust code should effectively handle these edge cases, scoring 10. Moderately robust code scores 5, and code that does not handle exceptions scores 0.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Does it have innovative features that stand out?",
-      "description": "Check if the code includes surprising features that enhance the experience (e.g., 1. real-time data visualization charts, 2. automatic match template import, 3. social media sharing, 4. voice broadcast). Each practical innovative feature implemented adds 3 points (maximum 10).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there redundant features?",
-      "description": "Strictly check for three types of redundancy: 1. Duplicate implementations of similar functions (e.g., multiple scoring logics coexisting), 2. Function modules unrelated to the scoring system (e.g., built-in music player), 3. Flashy effects that impact performance (e.g., particle explosion animations). For each redundancy found, deduct 3 points; if redundant code interferes with core functions, deduct 10 points directly.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code meet engineering quality standards?",
-      "description": "Review modular design (e.g., separation of data logic/view/tool layers), unit test coverage, and build process automation. Deduct 5 points for global state pollution or unused design patterns; deduct 5 points for high code duplication (over 30%); deduct 5 points for non-automated build processes. Full score is 10.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface visually meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern principles: 1) Harmonious color scheme (no more than 3 primary colors), 2) Reasonable layout spacing (element spacing follows the 8px multiple rule), 3) Professional font system (main text size ≥14px, line height ≥1.5x). For each instance of crowded visual elements, deduct 3 points; for jarring color schemes, deduct 5 points; for chaotic text-image layouts, deduct 5 points. Full score is 10.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Are dynamic interactions smooth and seamless?",
-      "description": "Judge whether animations align with human perception: 1) Click feedback delay ≤100ms, 2) Transition animation duration between 300-500ms, 3) Clear visual focus guidance. For each instance of unresponsive operations, deduct 5 points; for visual ghosting during rapid scrolling, deduct 3 points; for hard-to-find key function buttons, deduct 5 points. Full score is 10.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Casual",
-  "difficulty": "medium"
-}

package/library/game_development-casual/marble-elimination-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 685,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable. Please develop a marble elimination game where colored marbles are fired from the top of the screen. The player controls the firing angle and color to hit and eliminate marbles of the same color. When three or more marbles of the same color connect, they are eliminated, scoring points and adding time. If the marbles pile up to the bottom of the screen, display \"Game Over!\" Provide \"Start\" and \"Reset\" functions.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core marble elimination gameplay correctly implemented?",
-      "description": "Review whether the code accurately implements the marble shooting mechanics, color matching logic, and elimination detection. Check if the player can control the firing angle and if the color selection mechanism is implemented. Score 0 if core gameplay is missing, 5 if basic shooting works but with flaws in color matching, and 10 if all elimination mechanics work flawlessly including proper physics for marble movement.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the marble collision and connection detection properly implemented?",
-      "description": "Evaluate the accuracy of collision detection between marbles and whether the code correctly identifies when three or more same-colored marbles connect. Check if the algorithm efficiently detects connections in all directions (horizontal, vertical, diagonal). Deduct 5 points if the detection has edge cases where connections are missed, 3 points if there's noticeable lag during collision processing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the scoring system and timer functionality complete?",
-      "description": "Check if the game properly awards points when marbles are eliminated and if extra time is added. Verify if the scoring scales appropriately based on the number of marbles eliminated simultaneously. Assess whether the timer countdown is smoothly implemented and visually clear. Deduct 5 points if the scoring system is basic/static, 3 points if the timer doesn't integrate with gameplay events. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are the game states (Start, Reset, Game Over) correctly managed?",
-      "description": "Verify that the game provides functional Start and Reset buttons, and whether the Game Over detection works when marbles reach the bottom of the screen. Check if state transitions are handled cleanly without bugs or glitches. Deduct 5 points if the Reset function doesn't properly reinitialize all game elements, 3 points if Game Over detection has inconsistencies. 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-fire inputs, unexpected user actions, window resizing, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Special power-up marbles with unique effects 2. Combo system for consecutive eliminations 3. Particle effects for marble explosions). 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 mechanic) 2. Function modules unrelated to the marble 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/physics layers), variable naming conventions, 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's no separation between game mechanics 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 scheme that doesn't interfere with marble colors 2) Clear visual indication of score, time remaining, and game controls 3) Professional typography for UI elements. Deduct 3 points for cluttered UI elements, 5 points for poor color contrast making gameplay difficult, and 5 points for confusing or hard-to-read game information. 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 controls feel responsive: 1) Immediate feedback when shooting marbles 2) Smooth animations for marble movement and eliminations 3) Satisfying visual/audio feedback for successful combinations. Deduct 5 points for input lag when aiming or shooting, 3 points for stuttering animations during elimination sequences, and 5 points for confusing visual feedback. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Casual",
-  "difficulty": "medium"
-}

package/library/game_development-casual/nezha-whack-a-marmot-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 818,
-  "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. Create a whack-a-mole style game where the opening animation shows Nezha saying to a marmot \"Still eating? I'm coming for you!\" Then the game begins with Nezha using his Fire-tipped Spear to hit marmots that try to steal food from a bowl. Players earn points for each marmot they hit. Include different difficulty levels. The animation style should be simple and cute anime-style characters.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the whack-a-mole core game mechanics fully implemented?",
-      "description": "Review whether the code accurately implements the whack-a-mole gameplay through HTML/JavaScript, including marmot spawn/hide timing control, hit detection system, and scoring mechanism. Check if marmots appear randomly from different holes with proper timing intervals. Score 0 if core game loop is missing, 5 if only basic spawn/hide is implemented, and 10 if complete hit detection, scoring, and game state management are included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the Nezha character animation and Fire-tipped Spear interaction properly implemented?",
-      "description": "Evaluate whether Nezha character responds correctly to player clicks/taps with Fire-tipped Spear striking animation. Check if the spear animation aligns with hit detection timing and provides visual feedback for successful/missed hits. Deduct 5 points if spear animation is not synchronized with hit events, 3 points if Nezha character lacks proper attack animations. Full score requires smooth character animation with proper weapon mechanics.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the opening animation sequence with dialogue fully implemented?",
-      "description": "Check whether the opening animation includes Nezha character saying 'Still eating? I'm coming for you!' to a marmot character with proper dialogue display and character animations. Evaluate if the transition from opening sequence to gameplay is smooth. Deduct 5 points if dialogue is missing or poorly timed, 3 points if character animations during dialogue are static. Full score requires animated characters with speech bubbles/text and smooth scene transition.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are multiple difficulty levels properly designed and implemented?",
-      "description": "Evaluate whether the game includes different difficulty settings that meaningfully affect gameplay (spawn rate, marmot visibility duration, point values, etc.). Check if difficulty progression is balanced and provides appropriate challenge scaling. Deduct 5 points if only superficial difficulty changes exist, 3 points if difficulty balance is poor. Full score requires at least 3 distinct difficulty levels with proper game parameter adjustments.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid clicking, game state errors, animation interruptions, etc.) and provide friendly error handling. Code with strong robustness should effectively manage edge cases like simultaneous hits, animation conflicts, and state management issues. Give 10 points for comprehensive error handling, 5 points for basic robustness, and 0 points if no exception handling exists.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that enhance gameplay?",
-      "description": "Check whether the code includes engaging features beyond basic whack-a-mole mechanics (e.g., 1. Special marmot types with different point values 2. Power-up effects for Nezha's spear 3. Combo scoring system 4. Food bowl depletion mechanic). Add 3 points for each well-implemented innovative feature that enhances the core gameplay experience (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant animation systems or duplicate game logic 2. Features unrelated to whack-a-mole gameplay (e.g., unrelated mini-games) 3. Overly complex visual effects that impact performance without adding value. Deduct 3 points for each redundancy found, and directly deduct 10 points if redundant code interferes with core game functionality.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (separating game logic, animation, UI, and audio systems), code organization, and maintainability. Deduct 5 points if global state pollution is found or proper separation of concerns is missing; deduct 5 points if code duplication rate is excessive (over 30%); deduct 3 points if animation frame management is inefficient. Full score requires clean architecture with proper module separation.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the visual design achieve cute anime-style aesthetics?",
-      "description": "Evaluate whether the character designs and visual elements successfully create a simple, cute anime aesthetic: 1) Consistent art style for Nezha and marmot characters 2) Appropriate color palette that conveys playful mood 3) Clean, readable UI elements that complement the anime theme. Deduct 5 points for inconsistent art style, 3 points for poor character design quality, and 5 points if the overall aesthetic doesn't match cute anime requirements. Screenshots must demonstrate cohesive visual theme.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the game interaction smooth and responsive?",
-      "description": "Judge whether the game interactions feel natural and responsive: 1) Click/tap response time ≤ 100ms for hit detection 2) Marmot spawn/hide animations are smooth (60fps preferred) 3) Clear visual feedback for all player actions 4) Consistent frame rate during gameplay. Deduct 5 points for each laggy interaction, 3 points for choppy animations, and 5 points if hit feedback is unclear or delayed. Screenshots should show smooth animation sequences.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Casual",
-  "difficulty": "medium"
-}

package/library/game_development-casual/one-piece-semiconductor-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 1768,
-  "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 am a student at a vocational college. My teacher requires me to introduce intrinsic semiconductors in HTML format, presented as a One Piece anime-themed game (vivid and with various images) that is humorous, funny, simple to understand. However, I don't know how to create this.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the semiconductor educational content accurate and comprehensive?",
-      "description": "Review whether the code accurately explains intrinsic semiconductor concepts (band gap, electron-hole pairs, temperature dependency, etc.). Check if scientific facts are presented correctly without misconceptions. Score 0 if core semiconductor physics is absent, 5 if basic concepts are covered but lack depth, and 10 if concepts are thoroughly explained with proper technical terms and relationships.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the One Piece theme properly integrated with the educational content?",
-      "description": "Evaluate how well One Piece characters, settings, and storylines are integrated with semiconductor concepts. Characters should have relevant roles that relate to semiconductor properties (e.g., Luffy as an electron, Nami as electric field). Deduct 5 points if characters are merely decorative with no conceptual connections, 3 points if the integration is superficial. Full score requires creative parallels between One Piece elements and semiconductor physics.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Does the implementation contain interactive elements that reinforce learning?",
-      "description": "Check for interactive elements like clickable diagrams, drag-and-drop exercises, quizzes, or simulations that demonstrate semiconductor behavior. Score 0 if no interactivity exists, 5 if basic interactions (e.g., simple click revelations) are implemented, and 10 if comprehensive interactive elements that simulate semiconductor physics (e.g., temperature effects on conductivity) are included.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the humor appropriate and effectively used for educational purposes?",
-      "description": "Assess whether humor enhances understanding rather than distracting from it. Humor should relate to semiconductor concepts through One Piece references (puns, situation comedy, character traits). Deduct 5 points if humor is unrelated to the educational content, 3 points if it's too complex for beginners. The full score requires humor that actually aids memory retention and comprehension of semiconductor principles.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as browser compatibility issues, image loading failures, interaction errors) and provide fallback mechanisms. Code with strong robustness should work across modern browsers and offer graceful degradation. Give 10 points for comprehensive error handling, 5 points for basic error management, and 0 points if errors break the experience.",
-      "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 learning experience (e.g., 1. Animated electron flow visualization 2. Interactive band gap demonstration 3. Temperature-controlled semiconductor behavior). 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. Excessive animations that distract from learning 2. Unrelated One Piece content that doesn't connect to semiconductor concepts 3. Unnecessary technical jargon without explanation. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core educational content is overwhelmed by entertainment elements.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (separating content/presentation/behavior), code organization, and maintainability. Deduct 5 points if global variables are overused; deduct 5 points if the code is heavily duplicated; deduct 5 points if resources are inefficiently loaded or managed. The full score is given for clean, well-structured code that follows best practices.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles while maintaining the One Piece aesthetic: 1) Balanced color scheme that enhances readability 2) Proper layout with clear visual hierarchy 3) Appropriate use of One Piece imagery that supports rather than overwhelms content. Deduct 3 points for cluttered screens, 5 points for poor readability, and 5 points for inconsistent theme application. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the animations and transitions help explain semiconductor concepts: 1) Smooth animations of electron movement 2) Clear visual feedback for user interactions 3) Appropriate pacing for educational content absorption. Deduct 5 points for jerky animations, 3 points for delayed response to user input, and 5 points for animations that obscure the educational content. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Casual",
-  "difficulty": "easy"
-}