@getollie/cli 0.0.4 → 0.2.0

package/library/game_development-casual/10-years-from-now-randomizer-webpage.json

@@ -1,68 +0,0 @@
-{
-  "index": 1674,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable for display. Create a \"What will you be like 10 years from now\" randomizer with options including: becoming a millionaire, successful entrepreneur, unemployed, career on the rise, passed away, just an ordinary person, still paying car and house loans, or living happily. Use a dynamic dropdown frame with HTML, CSS, and JavaScript.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core randomizer functionality properly implemented?",
-      "description": "Evaluate whether the code correctly implements a random selection mechanism from the predefined options (millionaire, entrepreneur, unemployed, etc.). Check if the randomization is truly random and not biased. The function should select from all available options with equal probability. Deduct 5 points if the randomization is predictable or biased, 3 points if some options are missing, and 2 points if the randomization doesn't work properly on repeated use. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the dropdown frame dynamically implemented?",
-      "description": "Review the implementation of the dropdown frame. It should appear/disappear dynamically on user interaction, have smooth animation effects, and maintain its state appropriately. Deduct 3 points if the dropdown doesn't toggle properly, 5 points if it lacks animation effects, and 7 points if it's not implemented as a dropdown at all. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are all required outcome options included?",
-      "description": "Check if all the required outcome options are included: becoming a millionaire, successful entrepreneur, unemployed, career on the rise, passed away, just an ordinary person, still paying car and house loans, and living happily. Deduct 1 point for each missing option. Additionally, assess if the outcomes are displayed clearly to the user. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the user interaction intuitive and engaging?",
-      "description": "Evaluate the user flow – how users trigger the randomizer, how results are presented, and whether there's a clear call-to-action for retrying. Check if there's an engaging visual presentation when showing results (such as a spinning animation or transitional effect). Deduct 5 points if the interaction flow is confusing, 3 points if there's no visual feedback during randomization, and 2 points if the retry mechanism is not obvious. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid clicking, browser compatibility issues, or script errors) 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. Personalized results based on user input 2. Sharing results to social media 3. Saving history of previous predictions). 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 trigger the randomizer) 2. Function modules unrelated to the prediction feature 3. Fancy effects that affect performance (e.g., excessive animations that slow down the page). 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 from randomization logic), code readability, and efficient use of HTML/CSS/JavaScript. Deduct 5 points if global variables are overused or if poor practices are employed; deduct 5 points if the code is overly complex for the task at hand; deduct 5 points if there's no separation of concerns between HTML structure, CSS styling, and JavaScript behavior. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance. Deduct 5 points for each operation without feedback, 3 points for visual after-images during animations, and 5 points if the randomization result is not clearly highlighted. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Casual",
-  "difficulty": "easy"
-}

package/library/game_development-casual/2d-mobile-racing-game-with-clear-graphics.json

@@ -1,68 +0,0 @@
-{
-  "index": 1518,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to make the generated code executable and ready for demonstration. Help me write a 2D casual, easy-to-learn racing game for mobile phones with clear graphics and appealing colors.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core racing game mechanics fully implemented?",
-      "description": "Review whether the code accurately implements the basic racing mechanics including player movement controls, collision detection, track boundaries, and speed management. Score 0 if core racing mechanics are missing, 5 if only basic movement is implemented, and 10 if all expected racing features (acceleration, braking, steering, obstacles) are properly implemented with physics considerations.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the mobile touch control system properly designed?",
-      "description": "Check whether the implementation includes touch-friendly controls appropriate for mobile devices (such as tilt controls, touch steering, on-screen buttons). Evaluate responsiveness across different screen sizes and device orientations. Deduct 5 points if controls are not optimized for touch interfaces, 3 points if there's noticeable input lag. Full score requires multi-touch support and alternative control schemes.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the game properly optimized for mobile performance?",
-      "description": "Evaluate whether the code implements mobile optimization techniques such as asset compression, minimal DOM manipulation, efficient rendering loops, and battery consumption considerations. Check if the game maintains a stable framerate (minimum 30 FPS). Deduct 5 points for each significant performance issue that would cause lag or battery drain on mid-range devices.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the 2D casual visual style appropriately implemented?",
-      "description": "Assess if the graphics match the 'casual, easy-to-learn' requirement with clear, appealing visuals. Check for consistent art style, appropriate animations, and visual feedback. Deduct 5 points if graphics are inconsistent, 5 points if visual feedback for player actions is inadequate, and 3 points if animations are choppy or missing. The full score requires polished, cohesive visuals.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as screen rotation, browser tab switching, touch event interruptions, memory constraints on low-end devices) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Dynamic weather effects 2. Customizable vehicles 3. Unique power-ups or boost mechanisms 4. Social features like ghost racing). 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 movement control systems coexisting) 2. Function modules unrelated to the racing game (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive particle systems). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/view/input handling layers), asset loading management, 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 efficient asset loading strategy for mobile. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern mobile game design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (accommodating for touch targets at least 44x44 pixels) 3) Clear information hierarchy with appropriate font sizes (readable on small screens). Deduct 3 points for each cluttered UI element, 5 points for a visually conflicting color scheme, and 5 points for text that's too small to read on mobile. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Touch response delay ≤ 50ms 2) Transition animation duration controlled between 200-400ms for mobile 3) Clear visual and audio feedback for all interactions. Deduct 5 points for each interaction without feedback, 3 points for jerky animations during gameplay, and 5 points for UI elements that obscure important game action. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Casual",
-  "difficulty": "hard"
-}

package/library/game_development-casual/browser-snake-game-creation.json

@@ -1,68 +0,0 @@
-{
-  "index": 1493,
-  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable for demonstration. Please help me create a snake game that can run in a browser.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core snake game mechanics properly implemented?",
-      "description": "Review whether the code accurately implements the snake's movement system, growth mechanism when eating food, and collision detection (with walls, itself). Score 0 if the core mechanics are missing, 5 if only basic movement is implemented, and 10 if all traditional snake game mechanics (including speed progression) are fully included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the game canvas/rendering properly set up?",
-      "description": "Evaluate whether the game uses appropriate HTML5 Canvas or DOM elements for rendering. Check if the grid system is clearly defined with proper dimensions and if the game elements (snake, food) are clearly rendered with appropriate colors/sprites. Deduct 5 points if rendering is inconsistent or flickering, and 3 points if the canvas size doesn't adapt to different screen sizes.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is keyboard/touch input handling implemented correctly?",
-      "description": "Check whether the code includes robust input handling for keyboard arrows (or WASD) with appropriate event listeners and directional logic that prevents immediate 180-degree turns. For mobile compatibility, assess whether touch/swipe gestures are implemented. Deduct 5 points if input lag exceeds 100ms, and 5 points if mobile touch controls are missing.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there a complete game lifecycle implementation?",
-      "description": "Evaluate whether the game includes proper start/pause/game over states, score tracking, and restart functionality. Check for clear visual indicators of the current game state and smooth transitions between states. Deduct 3 points if game pausing is not implemented, 3 points if there's no clear scoring system, and 4 points if the restart mechanism requires page refresh.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid input changes, browser resizing, focus loss) and provide appropriate 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. Power-ups or special food types 2. Multiple difficulty levels 3. Visual/sound effects for events 4. Obstacles or maze generation). Add 2.5 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple movement calculation methods) 2. Function modules unrelated to snake gameplay (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive particle effects). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/view/input handling layers), code organization, and maintainability. Deduct 5 points if global state pollution is found or if functions have multiple responsibilities; deduct 5 points if the code duplication rate is too high (over 30%). Check if the game loop uses requestAnimationFrame instead of setTimeout/setInterval. 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) Consistent visual theme 2) Proper contrast between game elements and background 3) Clear visual hierarchy for score, controls, and game area. Deduct 3 points for each hard-to-distinguish game element, 5 points for poor contrast making gameplay difficult, and 5 points for chaotic UI layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the game performance optimized and responsive?",
-      "description": "Judge whether the game maintains consistent framerate (60fps) without stuttering, even as the snake grows longer. Check if the game adapts to different screen sizes and orientations. Deduct 5 points for noticeable frame drops during normal gameplay, 3 points for inefficient collision detection algorithms, and 5 points for unresponsive controls during intense moments. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Casual",
-  "difficulty": "easy"
-}

package/library/game_development-casual/capital-letters-typing-practice-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 991,
-  "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. Design a small game for practicing capital letters, based on HTML, that allows students to practice typing.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the capital letter typing practice core functionality fully implemented?",
-      "description": "Review whether the code accurately implements letter display through HTML/JavaScript, including random letter generation, keyboard input capture, and correct/incorrect input validation. Score 0 if the core typing interaction logic is not implemented, 5 if only basic letter display and input are implemented, and 10 if comprehensive typing practice with real-time feedback is fully included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the scoring and progress tracking system implemented?",
-      "description": "Check whether the implementation includes accuracy calculation, typing speed measurement (WPM/CPM), progress tracking, and performance statistics. Real-time score updates and session history are required. Deduct 5 points if the scoring algorithm is missing, and 3 points if progress persistence is not handled. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are multiple difficulty levels and practice modes designed?",
-      "description": "Evaluate whether the game provides different difficulty levels (beginner/intermediate/advanced) with varying speeds and complexity, and multiple practice modes (timed mode, accuracy mode, endless mode). Check if adaptive difficulty adjustment is implemented based on user performance. Deduct 5 points if only single mode exists. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is comprehensive educational feedback and guidance constructed?",
-      "description": "Check whether the code includes educational elements such as visual feedback for correct/incorrect typing, helpful hints, mistake analysis, and progress encouragement. Deduct 5 points if no educational guidance is provided, and 3 points if feedback is not immediate or clear. Give 10 points if comprehensive learning support is fully implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as multiple key presses, invalid input, browser compatibility issues, 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 learning experience (e.g., 1. Gamification elements like achievements/badges 2. Sound effects and audio feedback 3. Personalized avatars or themes 4. Social sharing of scores). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple scoring systems coexisting) 2. Function modules unrelated to typing practice (e.g., built-in calculator) 3. Fancy effects that affect performance (e.g., excessive animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/UI/data layers), code organization, and maintainability. Deduct 5 points if global state pollution is found or proper code structure is not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 3 points if variable naming is inconsistent or unclear. 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 educational game design principles: 1) Child-friendly color palette (high contrast, readable colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Educational typography (font size ≥ 16px for readability, clear hierarchy). Deduct 3 points for each crowded visual element, 5 points for poor color contrast affecting readability, and 5 points for chaotic layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to educational interaction standards: 1) Keystroke feedback delay ≤ 50ms 2) Smooth transitions between letters (200-300ms) 3) Clear visual indicators for current target and progress 4) Immediate visual/audio feedback for correct/incorrect input. Deduct 5 points for each delayed response, 3 points for confusing visual states, and 5 points if key interactive elements lack clear indication. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Casual",
-  "difficulty": "easy"
-}

package/library/game_development-casual/cat-character-collects-bamboo-every-15-min.json

@@ -1,68 +0,0 @@
-{
-  "index": 1779,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code whenever possible. Could you help me design a small cat character, similar to the scenario in the \"Moon Rabbit Adventure\" game, that comes online once every 15 minutes to collect bamboo? I need this programming work right now.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the cat character design visually appealing and well-implemented?",
-      "description": "Evaluate whether the cat character has a distinct visual style with proper proportions, colors, and details. Check if the design is implemented using appropriate HTML5 Canvas or SVG techniques with clean path definitions or sprite sheets. Award 10 points for a professional-looking character with smooth outlines and thoughtful design; 5 points for a basic but functional design; 0 points if the character is poorly defined or visually unappealing.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the 15-minute timing mechanism correctly implemented?",
-      "description": "Examine the code that handles the periodic appearance of the cat character. Verify if it uses proper JavaScript timing functions (setTimeout, setInterval) or more modern approaches like requestAnimationFrame with timestamp tracking. Check for proper clearance of timers to prevent memory leaks. The timing should be accurate within 1-2 seconds. Deduct 5 points if the timing is inconsistent, 3 points if it doesn't handle browser tab inactivity correctly, and give 0 points if the timing mechanism is missing or fundamentally flawed.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the bamboo collection animation and logic properly implemented?",
-      "description": "Review the animation sequence and interaction logic for the bamboo collection process. Check if there are smooth transitions between states (approaching, collecting, leaving) with appropriate easing functions. Verify that the collection logic tracks bamboo counts correctly and provides visual feedback. Award 10 points for polished animations with proper state management; 5 points for functional but basic implementation; 0 points if the collection process is broken or missing.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the game state persistence properly handled?",
-      "description": "Assess how the code manages game state persistence between sessions. Check if localStorage/sessionStorage is used appropriately to save bamboo counts, cat appearance times, and other relevant data. Verify that the state restoration works correctly when the page is reloaded. Deduct 5 points if the state is only partially saved, 3 points if there's no validation of stored data, and give 0 points if persistence is completely missing.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as browser compatibility issues, unexpected user interactions, or resource loading failures). Code with strong robustness should include error handling, fallback mechanisms, and graceful degradation. Give 10 points for comprehensive error handling and defensive coding; 5 points for basic error checks; 0 points if critical errors aren't 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 experience (e.g., 1. Dynamic cat behaviors based on time of day 2. Weather effects influencing the cat's appearance 3. Sound effects for interaction feedback). 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 animation loops or timing mechanisms 2. Unnecessary visual elements unrelated to the cat's bamboo collection 3. Overly complex code that could be simplified. 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 animation logic/rendering/state management), code organization, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the code lacks comments or documentation. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching for the cat and bamboo elements 2) Proper layout spacing for game elements 3) Appropriate use of visual hierarchy. Deduct 3 points for each visually jarring element, 5 points for poor color choices that affect readability, and 5 points for cluttered or confusing visual layouts. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the animations and interactions conform to human perception characteristics: 1) Responsive cat movements 2) Smooth transitions between animation states 3) Clear visual feedback for user interactions. Deduct 5 points for jerky animations, 3 points for inconsistent movement speeds, and 5 points for abrupt transitions between states. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Casual",
-  "difficulty": "hard"
-}

package/library/game_development-casual/chinese-character-pinyin-matching-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 1521,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure the code you provide is executable. Create a Chinese character and pinyin matching game for me that can be run directly.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Chinese character and pinyin matching core functionality implemented?",
-      "description": "Review whether the code accurately implements the matching mechanism between Chinese characters and their corresponding pinyin, including validation of correct matches and handling of incorrect matches. Score 0 if the core matching logic is not implemented, 5 if only basic matching is implemented without feedback, and 10 if full matching with proper feedback and score tracking is included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is there a diverse and educational character set included?",
-      "description": "Evaluate the variety and educational value of the Chinese characters included in the game. Check if characters are grouped by difficulty levels or thematic categories. Deduct 5 points if fewer than 20 characters are included, 3 points if characters lack proper pinyin annotations, and 2 points if there's no progression in character complexity. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Does the game include proper learning feedback and progression?",
-      "description": "Assess whether the game provides educational feedback when matches are made, such as character meanings, usage examples, or cultural context. Check if there's a learning progression system that tracks user performance. Deduct 5 points if no educational content is provided beyond the matching, and 3 points if there's no progress tracking. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there a complete game lifecycle with proper state management?",
-      "description": "Check whether the code includes complete game lifecycle management, including start/pause/resume/end states, score tracking, and session persistence. Deduct 5 points if there's no way to restart or reset the game, 3 points if the game state isn't preserved between sessions, and 2 points if there's no clear game completion state. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid inputs, browser compatibility issues, touch vs. mouse interactions, 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. Audio pronunciation of characters 2. Character stroke order animations 3. Spaced repetition learning algorithm 4. Customizable character sets). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple scoring systems) 2. Function modules unrelated to Chinese character learning (e.g., a built-in calculator) 3. Fancy effects that affect performance (e.g., excessive animations that slow loading times). 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/data layers), code reusability, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 3 points if there are no comments or documentation. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching suitable for an educational context 2) Proper layout with clear distinction between Chinese characters and pinyin 3) Professional font system with appropriate sizing for Chinese characters (large enough to see strokes clearly). Deduct 3 points for cluttered layouts, 5 points for poor character readability, and 5 points for inappropriate color schemes for educational content. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and intuitive for language learning?",
-      "description": "Judge whether the game interactions support effective language learning: 1) Clear visual indication of selection state 2) Intuitive matching mechanism 3) Appropriate feedback timing for learning retention. Deduct 5 points for confusing interaction patterns, 3 points for delayed feedback that interrupts the learning flow, and 5 points for accessibility issues that would prevent certain users from engaging with the content. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Casual",
-  "difficulty": "easy"
-}

package/library/game_development-casual/chinese-character-pronunciation-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 326,
-  "question": "You are a code expert. Please utilize your professional knowledge to generate accurate and professional responses. Be sure to make the generated code executable for demonstration. Create a web game where Chinese characters appear on the webpage, and children read these characters aloud. The game should determine if the recording is successful, showing a checkmark when successful, and then verify if the child's pronunciation matches the Chinese character. If correct, the child earns points.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Chinese character display and pronunciation verification system fully implemented?",
-      "description": "Review whether the code accurately implements Chinese character display logic, including character selection algorithms, pronunciation standard comparison, and scoring mechanisms. Check if it supports multiple pronunciation standards (Mandarin/Pinyin) and handles polyphonic characters correctly. Score 0 if core pronunciation verification is not implemented, 5 if only basic character display is available, and 10 if complete pronunciation matching with accuracy scoring is included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the audio recording and processing functionality properly implemented?",
-      "description": "Check whether the Web Audio API implementation includes proper microphone permission handling, real-time audio capture, noise reduction, and audio format conversion. Evaluate if the recording quality meets speech recognition requirements (sample rate ≥16kHz, bit depth ≥16bit). Deduct 5 points if recording permission errors are not handled, and 3 points if audio preprocessing is missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the speech recognition and pronunciation accuracy assessment system designed?",
-      "description": "Evaluate whether the speech recognition uses reliable APIs (such as Web Speech API or third-party services) and implements pronunciation accuracy scoring algorithms. Check if it can distinguish similar pronunciations and provide detailed feedback on tone accuracy. Deduct 5 points if pronunciation accuracy is below 80% for standard pronunciation, and 3 points if tone recognition is not implemented. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the complete game progression and scoring system constructed?",
-      "description": "Check whether the code includes complete game flow management: character progression logic, point accumulation system, difficulty level adjustment, and progress saving. Evaluate if it provides learning analytics and performance tracking for children. Deduct 5 points if progress persistence is not implemented, and 3 points if difficulty adaptation mechanism is missing. Give 10 points if fully implemented with comprehensive learning metrics.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as microphone access denial, network interruption, browser compatibility issues, audio processing failures, etc.) and provide child-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 learning experience (e.g., 1. Real-time pronunciation waveform visualization 2. Gamified character collection system 3. Adaptive difficulty based on child's performance 4. Parent dashboard with learning progress). 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 audio processing pipelines coexisting) 2. Function modules unrelated to language learning (e.g., built-in games unrelated to pronunciation) 3. Overly complex animations that may distract children from learning. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core learning 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 audio processing/character management/UI layers), error handling coverage, and performance optimization. Deduct 5 points if memory leaks are found in audio processing or inefficient DOM manipulation; deduct 5 points if the code structure lacks clear separation of concerns; deduct 5 points if no performance monitoring for real-time audio processing is implemented. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface design meet child-friendly and accessibility standards?",
-      "description": "Evaluate whether the design is suitable for children: 1) High contrast colors and large, clear Chinese characters (font size ≥ 24px) 2) Intuitive visual feedback with engaging animations 3) Simple navigation suitable for young users 4) Proper color psychology for learning environments. Deduct 3 points for each hard-to-read text element, 5 points for overwhelming visual complexity, and 5 points for poor accessibility compliance. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the interactive feedback immediate and encouraging?",
-      "description": "Judge whether the interactive responses are optimized for children's learning: 1) Visual feedback appears within 100ms of recording completion 2) Encouraging animations and sounds for correct answers 3) Gentle correction guidance for mistakes 4) Clear recording status indicators. Deduct 5 points for each delayed feedback response, 3 points for discouraging error messages, and 5 points for unclear recording state visualization. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Casual",
-  "difficulty": "medium"
-}

package/library/game_development-casual/claw-machine-game-with-cute-characters.json

@@ -1,68 +0,0 @@
-{
-  "index": 393,
-  "question": "You are a code expert, please use your professional knowledge to generate accurate, professional responses. Be sure to ensure that the generated code is executable for display. Help me create a claw machine (crane game) frontend game, which should be a directly runnable HTML version. The page should have a cute and rounded appearance, and include baby dragons, QQ figurines, and Mickey Mouse.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core claw machine gameplay mechanic fully implemented?",
-      "description": "Check whether the code implements the three main phases of claw machine gameplay: positioning, dropping, and grabbing. The claw should move horizontally in both X and Y axes, drop vertically when triggered, close to grab items, and retract. Verify that the claw movement has appropriate physics (acceleration/deceleration). Score 0 if core interaction logic is missing, 5 if only basic movement exists without proper physics, and 10 if all mechanics are properly implemented with realistic physics.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are the specified prize items (baby dragons, QQ figurines, Mickey Mouse) properly implemented?",
-      "description": "Evaluate whether the code includes all three required prize types with distinct visual appearances. Each prize type should have proper collision detection with the claw and realistic physics when being grabbed or dropped. The prizes should be randomly distributed in the machine at the start. Deduct 3 points if any prize type is missing, 3 points if the prize physics are unrealistic, and 2 points if there's no variety in each prize type (e.g., different colors or sizes).",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the game container (claw machine cabinet) visually implemented with proper perspective?",
-      "description": "Check if the claw machine cabinet is properly rendered with a 3D-like perspective or isometric view that allows players to clearly see the prizes and claw positions. The machine should have transparent walls and a visible prize collection chute. Deduct 5 points if the perspective makes gameplay difficult, 3 points if the machine lacks depth perception, and 3 points if the collection mechanism isn't visually represented.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Does the game include proper controls and feedback mechanisms?",
-      "description": "Evaluate if the game provides intuitive controls (keyboard arrows or buttons) for claw movement and a clear button for dropping the claw. Check for visual and audio feedback during gameplay (button highlights, claw movement sounds, prize capture sounds). Deduct 3 points for unintuitive controls, 3 points for missing visual feedback, and 4 points for lack of audio feedback indicating success or failure.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid clicking, browser resizing, touch vs. mouse input differences) 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. Prize rarity system with special effects for rare items 2. Skill-based claw strength adjustment 3. Combo system for grabbing multiple items). 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 control systems overlapping) 2. Function modules unrelated to the claw machine (e.g., a built-in unrelated mini-game) 3. Fancy effects that affect performance (e.g., excessive particle effects causing lag). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/view/physics layers), organized asset management, and code readability. 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 assets are not properly organized or optimized. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet the 'cute and rounded' aesthetic requirement?",
-      "description": "Evaluate whether the design follows the requested cute aesthetic: 1) Rounded corners on UI elements (≥8px radius) 2) Pastel or bright, cheerful color palette 3) Cartoonish, child-friendly visual elements with proper proportions. Deduct 3 points for each angular/harsh visual element, 5 points for dull or inappropriate color schemes, and 5 points for realistic/non-cute styling that contradicts requirements. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Claw movement responds within 100ms of input 2) Grabbing animations feel weighted and natural 3) Transition effects between game states are smooth. Deduct 5 points for laggy claw movement, 3 points for jerky prize physics, and 5 points for abrupt state transitions without proper animation. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Casual",
-  "difficulty": "medium"
-}