@getollie/cli 0.0.1

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

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

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

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

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

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

package/library/game_development-casual/cocos-creator-vertical-scrollview-customers-projects.json

@@ -0,0 +1,68 @@
+{
+  "index": 267,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Take care to ensure the generated code is executable. Using Cocos 3.8.2, create a vertical ScrollView to display items, with customerName using customerItemPrefab and project using projectItemPrefab, with all items supporting click functionality. Please refer to the following JSON:\n\n```\n{\n    \"code\": 0,\n    \"msg\": null,\n    \"data\": [\n        {\n            \"customerId\": \"2\",\n            \"customerName\": \"Shanghai Nuclear Engineering Research and Design Institute Co., Ltd.\",\n            \"projects\": [\n                {\n                    \"projectId\": \"914468469536329728\",\n                    \"projectName\": \"Integrated Small Reactor Control Rod Drive Line Performance Test\"\n                }\n            ]\n        },\n        {\n            \"customerId\": \"3\",\n            \"customerName\": \"CGN Engineering Co., Ltd.\",\n            \"projects\": [\n                {\n                    \"projectId\": \"873153510613585920\",\n                    \"projectName\": \"Lianjiang Nuclear Power Project Phase I Unit 4 Reactor Internals 5\"\n                },\n                {\n                    \"projectId\": \"884559337463353344\",\n                    \"projectName\": \"Lufeng Nuclear Power Plant Unit 5 Reactor Internals\"\n                },\n                {\n                    \"projectId\": \"873153510592614400\",\n                    \"projectName\": \"Lianjiang Nuclear Power Project Phase I Unit 4 Reactor Internals 4\"\n                },\n                {\n                    \"projectId\": \"917907373564235776\",\n                    \"projectName\": \"Fangchenggang Unit 5 Reactor Internals\"\n                },\n                {\n                    \"projectId\": \"884560018756734976\",\n                    \"projectName\": \"Lufeng Nuclear Power Plant Unit 6 Reactor Internals\"\n                },\n                {\n                    \"projectId\": \"876391299413053440\",\n                    \"projectName\": \"Taipingling Unit 3 CRDM\"\n                },\n                {\n                    \"projectId\": \"954752623586709504\",\n                    \"projectName\": \"Ningde Unit 5 Reactor Internals\"\n                }\n            ]\n        },\n        {\n            \"customerId\": \"898905938222780416\",\n            \"customerName\": \"C5 Test Customer\",\n            \"projects\": [\n                {\n                    \"projectId\": \"898906689154191360\",\n                    \"projectName\": \"C5 Project Name test\"\n                }\n            ]\n        }\n    ],\n    \"ok\": true\n}\n```\n\nPlease provide specific TypeScript implementation code.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the ScrollView component implementation complete?",
+      "description": "Check if the ScrollView component is properly implemented with vertical scrolling enabled. The component should handle content larger than the viewport, implement proper scrolling physics (momentum, elasticity), and manage scroll events correctly. Score 0 if ScrollView is not implemented at all, 5 if basic scrolling works but with issues, and 10 if it's fully implemented with proper physics and event handling.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the prefab instances correctly instantiated and configured?",
+      "description": "Verify if customerItemPrefab and projectItemPrefab are correctly loaded, instantiated, and configured based on the JSON data. Check if the prefabs are dynamically created for each item in the data structure. Deduct 5 points if only one type of prefab is implemented correctly, and 3 points if the prefab instantiation has performance issues (e.g., no pooling for large lists). The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the hierarchical data display structure implemented correctly?",
+      "description": "Evaluate if the nested structure of customers and their projects is properly displayed in the ScrollView, maintaining the hierarchical relationship. Check if projects are visually grouped under their respective customers. Deduct 5 points if the hierarchy is not visually clear, and 7 points if projects are not properly associated with their customers. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the click functionality fully implemented for all items?",
+      "description": "Check if both customer and project items have functioning click handlers that correctly identify which item was clicked. Events should include appropriate data (customerId, projectId) and follow Cocos event system best practices. Deduct 5 points if only one type of item is clickable, and 7 points if click detection areas are imprecise or if event propagation is incorrectly handled. 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 empty data arrays, missing properties, incorrect data types, dynamic content changes, etc.) and provide appropriate error handling. Code with strong robustness should be able to effectively handle 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. Animated expand/collapse for projects 2. Search/filter functionality 3. Custom scrollbar with preview hints). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple scroll management systems) 2. Function modules unrelated to the ScrollView (e.g., unnecessary analytics) 3. Fancy effects that affect performance (e.g., excessive particle effects on scroll). 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 data/view/controller layers), typing quality (proper TypeScript interfaces/types), component reusability, and adherence to Cocos best practices. 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 Cocos component lifecycle methods are misused. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the visual implementation follows modern UI design principles: 1) Consistent styling between customer and project items 2) Proper padding and margins (element spacing follows the 8px multiple principle) 3) Clear visual hierarchy between customers and their projects. Deduct 3 points for each visual inconsistency, 5 points for poor contrast that affects readability, and 5 points for improper text truncation on long names. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the ScrollView performance optimized?",
+      "description": "Judge whether the implementation follows performance best practices: 1) Item recycling/virtualization for long lists 2) Proper handling of item visibility 3) Efficient update mechanisms when data changes. Deduct 5 points for visible performance degradation with many items, 3 points for unnecessary redraws during scrolling, and 5 points for memory leaks from improper node management. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "easy"
+}

package/library/game_development-casual/cocos-java-3d-pinball-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1104,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable when possible. I want to recreate a 3D Pinball Space Cadet game using Cocos engine version 3.85 with Java language. Please write a complete code including all functional modules. Since I'm a beginner, please provide step-by-step instructions in a very detailed manner on how to set up and add the code. I have already installed COCOS and VISUAL STUDIO CODE software.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Pinball game physics system properly implemented?",
+      "description": "Review whether the code accurately implements the pinball physics including collision detection, realistic ball movement, flipper mechanics, and spring launcher physics. Check if the physical properties like gravity, elasticity, friction, and momentum are correctly configured. Score 0 if core physics is missing, 5 if basic collisions work but lack realism, and 10 if physics closely resembles the original Space Cadet game.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are all the essential game elements of Space Cadet Pinball recreated?",
+      "description": "Evaluate if all key components are implemented: flippers (2 main ones), bumpers, targets, ramps, drop targets, multiball mechanism, plunger, and the specific Space Cadet themed elements like launch ramp and wormholes. Each missing major element deducts 2 points. The game should visually resemble the original Space Cadet design. Score 10 if all elements are present with correct functionality.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the scoring system and mission progression implemented?",
+      "description": "Check if the code includes the Space Cadet mission system (cadet, commander, captain ranks), bonus multipliers, multiball triggers, and accurate point allocation. Review if mission states are properly tracked and if visual/audio feedback is provided when missions are activated or completed. Score 0 if scoring is basic, 5 if some missions exist but lack progression, 10 if the full mission hierarchy is implemented similar to the original game.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the Cocos 3D environment properly configured and optimized?",
+      "description": "Assess whether the code properly utilizes Cocos 3.85 features for 3D rendering, including proper camera setup, lighting, materials, and optimization techniques. Check if the implementation follows Cocos best practices for scene management and 3D object manipulation. Deduct 3 points for inefficient rendering approaches, 4 points if camera angles are poorly implemented, and 3 points if lighting doesn't match the original game's atmosphere.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as frame rate drops, physics edge cases, unexpected input sequences, etc.) and provide friendly error handling. Code with strong robustness should be able to effectively handle these edge cases, scoring 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Custom table editor 2. Online leaderboards 3. Alternative camera views 4. Physics parameter customization). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple physics systems coexisting) 2. Function modules unrelated to pinball (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 physics/game logic/view layers), class inheritance structure, unit test coverage, and build process automation. 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 build process is not automated. 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 faithfully recreates the Space Cadet aesthetic while following modern principles: 1) Accurate visual representation of the original table 2) Proper UI layout for scores and game status 3) Professional font system matching the Space Cadet style. Deduct 3 points for each visual element that doesn't match the original game, 5 points for poor quality textures, and 5 points for inaccurate table layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and responsive?",
+      "description": "Judge whether the game mechanics meet player expectations: 1) Flipper response time ≤ 50ms from button press 2) Consistent 60 FPS performance 3) Accurate ball physics without clipping or stuttering. Deduct 5 points for each 100ms of input lag, 3 points for frame drops below 30 FPS, and 5 points if ball physics behaves unrealistically during fast movement. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "hard"
+}

package/library/game_development-casual/company-annual-meeting-lucky-draw.json

@@ -0,0 +1,68 @@
+{
+  "index": 1801,
+  "question": "You are a code expert. Please utilize your professional knowledge to generate accurate and professional responses. Pay attention to ensuring that the code you generate is executable for display. Help me create an HTML code for a small web program for a company annual meeting lucky draw game.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the lucky draw core functionality fully implemented?",
+      "description": "Review whether the code implements the essential lucky draw mechanics including participant data management, random selection algorithm, and winner display. Score 0 if the core drawing functionality is missing, 5 if basic random selection is implemented but lacks animation or proper winner handling, and 10 if the system includes comprehensive drawing mechanics with proper randomization entropy and winner management.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Does the participant management system work properly?",
+      "description": "Examine how participant data is handled - whether it supports data import (e.g., CSV/Excel upload, manual entry), participant filtering (by department, position, etc.), and prevention of duplicate winners for multi-round draws. Deduct 5 points if data import is manual-only with no validation, 3 points if filtering capabilities are missing, and 2 points if there's no mechanism to prevent repeated winners. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the prize tier system properly implemented?",
+      "description": "Check whether the code supports multiple prize categories with different probabilities, prize images/descriptions, and proper tracking of remaining prizes. Evaluate if the system prevents over-drawing (more winners than available prizes). Deduct 5 points if only a single prize type is supported, 3 points if there's no visual distinction between prize tiers, and 5 points if prize inventory management is missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the drawing animation enhance the suspense and excitement?",
+      "description": "Evaluate the drawing animation quality - whether it includes proper build-up (name flashing/scrolling), tempo changes (slowing down before revealing the winner), and satisfying reveal effects. Verify if the animation timing is appropriate for building anticipation (5-10 seconds). Deduct 5 points for static draws with no animation, 3 points for animations that are too brief or too lengthy, and 2 points for choppy/unoptimized animations. 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 large participant lists, browser compatibility issues, network delays when loading assets, 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. Confetti/fireworks for winners 2. Sound effects synchronized with animations 3. Special effects for high-tier prizes 4. History tracking of all winners). 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 selection algorithms) 2. Function modules unrelated to lucky draw (e.g., unnecessary user profiles) 3. Fancy effects that affect performance (e.g., excessive animations that slow down the system). 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 data/UI/animation logic), reusability of components, and code maintainability. Deduct 5 points if global variables are overused or if there's no separation of concerns; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there are no comments for complex logic. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Festive and appropriate color scheme for an annual meeting 2) Proper layout with focus on the drawing area and winners 3) Professional typography with readable text even on projection screens. Deduct 3 points for each instance of poor visual hierarchy, 5 points for inappropriate color schemes, and 5 points for layouts that don't emphasize the core drawing functionality. 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) Responsive controls for the host/operator 2) Appropriate animation timing for building suspense 3) Clear visual and auditory feedback when winners are selected. Deduct 5 points for lack of visual feedback during drawing operations, 3 points for jarring transitions between states, and 5 points for confusing user flow that might disrupt the live event. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "easy"
+}