@getollie/cli 0.0.1

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

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

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

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

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

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

package/library/game_development-casual/princess-makeup-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 322,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable for demonstration purposes. Help me write a frontend program for a princess makeup game where a princess can get a makeover, including applying eyeshadow, changing contacts, switching hairstyles, changing hair color, and applying lipstick. Include buttons for these operations.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core princess makeup system fully implemented?",
+      "description": "Review whether the code accurately implements the princess makeover functionality through HTML/CSS/JavaScript. Check if all required features (eyeshadow, contacts, hairstyles, hair color, and lipstick) are properly implemented with layering techniques. Score 0 if the core makeup functions are missing, 5 if only basic functions are implemented without visual effects, and 10 if all makeup options include proper visual transformations and blending modes.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the UI control system properly designed?",
+      "description": "Evaluate whether the interface includes all specified buttons (eyeshadow, contacts, hairstyles, hair color, and lipstick) and whether these controls are logically organized. Check if each button triggers the appropriate makeup action and if there are options/variations within each category. Deduct 2 points for each missing makeup category, and 1 point if a category exists but has no style variations. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the makeup application process interactive and realistic?",
+      "description": "Assess whether the makeup application looks realistic with proper blending on the princess model. Check if there are transitions between makeup states rather than abrupt changes. Score 10 if the makeup application includes visual effects like color blending, transparency, and proper layering; 5 if changes are visible but lack realism; 0 if changes are too simplistic (e.g., just swapping entire face images).",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the state management of the princess makeover properly implemented?",
+      "description": "Check if the code maintains the princess's current state across different makeup applications. Verify if multiple makeup elements can be combined (e.g., applying both eyeshadow and lipstick). Deduct 5 points if previous makeup gets erased when applying new makeup, and 3 points if there's no way to reset individual makeup elements. Give 10 points if the state management allows for complete customization.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as missing image assets, unsupported browsers, rapid sequential clicks, 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. Before/after comparison slider 2. Save/share makeover results 3. Animated makeup application effects 4. Personalized recommendations based on selections). 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 apply the same makeup) 2. Function modules unrelated to makeup (e.g., a built-in game unrelated to the makeover) 3. Fancy effects that affect performance (e.g., unnecessary animations that slow down the interface). 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 UI logic/rendering/asset management), code reusability for different makeup types, and asset loading optimization. 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 large image assets aren't properly managed (e.g., no lazy loading). 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 suited for a princess theme (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 makeup application effects conform to user expectations: 1) Makeup application feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual indication of selected makeup items. Deduct 5 points if makeup changes have no visual feedback, 3 points for laggy transitions when changing multiple makeup items quickly, and 5 points for confusing UI that doesn't indicate current selections. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "medium"
+}

package/library/game_development-casual/prize-wheel-game-with-editable-content.json

@@ -0,0 +1,68 @@
+{
+  "index": 1202,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Take care to ensure that the generated code is executable for demonstration purposes. Write a piece of code for a prize wheel game where the wheel contents can be edited and the probability of winning can be modified.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the prize wheel core spinning mechanism properly implemented?",
+      "description": "Check if the code implements a visually accurate rotating wheel with proper physics (deceleration, inertia), smooth animation (60fps minimum), and clear indication of the selected prize. Score 0 if spinning is not implemented, 5 if basic rotation exists but lacks physics, and 10 if the spinning animation is realistic with proper easing functions and stopping mechanics.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the prize configuration and probability modification system complete?",
+      "description": "Evaluate whether the code allows full customization of prizes (names, colors, images) and precise probability settings for each slice. The system should maintain mathematical integrity (probabilities sum to 100%) and include validation. Deduct 5 points if only basic prize editing exists without probability control, and 3 points if validation is missing. Award full 10 points if the system includes weighted randomization implementation.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there a proper prize selection algorithm that respects configured probabilities?",
+      "description": "Review the randomization algorithm to ensure it accurately respects the configured probabilities. Check for proper weighted random selection rather than uniform distribution, and verify through statistical testing functions. Deduct 5 points if the algorithm shows bias, and 3 points if edge cases (like very low probabilities) aren't handled. Full 10 points requires mathematically sound implementation with verifiable outcomes.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a complete user interface for wheel configuration and result display?",
+      "description": "Assess whether the code includes intuitive interfaces for prize editing, probability adjustment, and result display. Check for form validation, real-time preview of wheel changes, and clear winner notification. Deduct 5 points if the configuration UI is incomplete, and 3 points if winner display lacks visual/audio feedback. Full 10 points requires a complete configuration panel with instant visual updates to the wheel.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid probability inputs, extremely fast consecutive spins, browser resize events, 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. Sound effects or haptic feedback, 2. Confetti animation for winners, 3. History of previous spins with statistics, 4. Mobile/touch support). 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 random algorithms) 2. Function modules unrelated to the prize wheel (e.g., unnecessary side games) 3. Fancy effects that affect performance (e.g., excessive particle animations that slow down the wheel). 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 wheel logic/view/configuration), proper event handling, and appropriate use of design patterns. Deduct 5 points if global state pollution is found; deduct 5 points if the code duplication rate is high (over 30%); deduct 5 points if browser compatibility is ignored. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the wheel design follows modern UI principles: 1) Harmonious color matching for prize segments 2) Clear typography for prize labels 3) Proportional layout with proper wheel dimensions relative to the container. Deduct 3 points for each accessibility issue (poor contrast, tiny text), 5 points for clashing colors, and 5 points for prizes becoming illegible when spinning. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the spinning animation and user interactions follow natural expectations: 1) Responsive spin button with clear feedback 2) Smooth acceleration/deceleration curves 3) Clear indication when the wheel is active vs. available to spin again. Deduct 5 points for each interaction without feedback, 3 points for jerky animations, and 5 points for confusing states (e.g., unclear if wheel is currently spinning). The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "easy"
+}

package/library/game_development-casual/pubg-mobile-vocabulary-lottery-system.json

@@ -0,0 +1,68 @@
+{
+  "index": 827,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Ensure that the code you generate is executable for demonstration. Create a lottery system for opening vocabulary boxes in the Peace Elite (PUBG Mobile) subway escape mode, with the requirement that it can replace weapons and vocabulary content.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the lottery system core mechanism fully implemented?",
+      "description": "Review whether the code accurately implements the lottery probability algorithm, including weighted random selection, guarantee mechanism (pity system), and rarity distribution. Check if different vocabulary box types have distinct drop rates and if the probability calculation follows standard gacha mechanics. Score 0 if core lottery logic is missing, 5 if only basic random selection is implemented, and 10 if complete probability system with guarantee mechanism is included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the vocabulary and weapon replacement system properly designed?",
+      "description": "Evaluate whether the system allows dynamic content replacement for both weapons and vocabulary items. Check if the data structure supports easy modification of item pools, rarity levels, and metadata. Verify that the replacement mechanism maintains consistency in item properties and visual representations. Deduct 5 points if hardcoded item lists are used, and 3 points if item metadata is incomplete. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the opening animation and visual feedback system complete?",
+      "description": "Check whether the lottery opening sequence includes proper visual effects such as box opening animations, rarity reveal effects, and item showcase presentations. Evaluate if the animation timing creates appropriate suspense and excitement. Verify that different rarity items have distinct visual treatments. Deduct 5 points if animations are missing or too basic, and 3 points if rarity differentiation is unclear. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the inventory and collection management system implemented?",
+      "description": "Assess whether the system includes comprehensive inventory management with item storage, collection tracking, and usage statistics. Check if duplicate handling is properly managed and if players can view their collection history. Verify that item organization follows logical categorization. Deduct 5 points if inventory persistence is not implemented, and 3 points if duplicate item handling is missing. Give 10 points if fully implemented with statistics.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid probability configurations, missing item data, concurrent lottery requests, 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. Multi-box opening with batch results 2. Item preview with 3D models 3. Achievement system for rare item collection 4. Social sharing of rare drops). 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 random generators coexisting) 2. Function modules unrelated to lottery system (e.g., built-in chat system) 3. Excessive visual effects that impact performance (e.g., complex particle systems for every item). Deduct 3 points for each redundancy found, and directly deduct 10 points if core lottery 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 lottery logic/UI/data layers), configuration management, and code maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if item configuration is not externalized. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern game UI principles: 1) Gaming-appropriate color scheme with proper rarity color coding (Common/Rare/Epic/Legendary) 2) Proper layout spacing with clear visual hierarchy 3) Professional typography with readable font sizes (≥14px for body text). Deduct 3 points for each crowded visual element, 5 points for poor rarity color distinction, and 5 points for chaotic item layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the lottery interactions conform to gaming standards: 1) Box opening trigger response ≤100ms 2) Opening animation duration 2-4 seconds for proper suspense 3) Clear visual feedback for item rarity reveals 4) Smooth transitions between lottery states. Deduct 5 points for each interaction without proper feedback, 3 points for jarring animation transitions, and 5 points for unclear rarity reveal sequences. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "hard"
+}