@getollie/cli 0.0.1

package/library/game_development-casual/typing-game-implementation.json

@@ -0,0 +1,68 @@
+{
+  "index": 75,
+  "question": "You are a code expert. Please utilize your professional knowledge to generate accurate and professional responses. Pay attention to ensure the code you produce is executable for demonstration.\nPlease write a typing game.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core typing mechanism implemented correctly?",
+      "description": "Examine if the code properly captures keyboard input, matches it with displayed text, and updates the game state accordingly. Check for event listeners that handle keypress/keydown events, input validation against the target text, and appropriate visual feedback for correct/incorrect typing. Award 10 points for complete implementation with accurate character matching, 5 points if only basic functionality works but has edge cases, and 0 if core typing detection is missing.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the game mechanics and scoring system properly designed?",
+      "description": "Verify if the game includes essential metrics like typing speed (WPM), accuracy percentage, and a time-based or completion-based scoring system. Check for features like countdown timers, progression levels, or difficulty settings. Award 10 points for a comprehensive system that tracks multiple metrics and provides meaningful feedback, 5 points for basic scoring only, and deduct points if calculations contain errors.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there appropriate content generation for typing challenges?",
+      "description": "Assess how text content is generated for typing practice. Look for variety in content (random words, sentences, paragraphs), difficulty progression, and possibly themed content categories. Ideal implementation should avoid repetition and have sufficient content volume. Award 10 points for dynamic content generation with multiple difficulty levels, 5 points for static but sufficient content, and deduct points if content is too limited or contains errors.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the game provide real-time feedback and visual cues?",
+      "description": "Examine if the game visually indicates typing progress (highlighting current character, showing completed text differently), displays errors clearly, and provides real-time stats. Check for features like cursor position tracking and visual distinction between correct and incorrect inputs. Award 10 points for comprehensive feedback system with clear visual indicators, 5 points for basic feedback, and deduct points for confusing or missing visual cues.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid typing, special character inputs, browser focus 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 experience (e.g., 1. Multiplayer racing mode 2. Typing rhythm with audio feedback 3. Heat maps showing problematic keys 4. Adaptive difficulty based on user performance). 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 track typing speed) 2. Function modules unrelated to typing practice (e.g., unrelated mini-games) 3. Fancy effects that affect performance (e.g., excessive animations that slow down typing response). 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 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 clear separation between UI and game 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) 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, monospace font for typing text). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for poor text readability that hinders typing. 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) Instant typing feedback with no perceptible delay 2) Smooth text scrolling or transition when completing lines/paragraphs 3) Appropriate animation for game state changes (starting, finishing). Deduct 5 points for input lag that affects typing experience, 3 points for jerky animations during gameplay, and 5 points for distracting visual effects that make text hard to read. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "easy"
+}

package/library/game_development-casual/uniapp-blind-box-lottery-system.json

@@ -0,0 +1,68 @@
+{
+  "index": 907,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure that the code you generate is executable for demonstration purposes. Please provide front-end code for a blind box lottery system using uniapp.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the blind box lottery core mechanism fully implemented?",
+      "description": "Review whether the code accurately implements the blind box lottery mechanism, including random selection algorithms, prize pool configuration, probability calculation, and display of lottery results. Score 0 if the core lottery logic is not implemented, 5 if only basic random selection is present, and 10 if a complete weighted probability system with proper prize distribution is fully included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the uniapp cross-platform compatibility addressed?",
+      "description": "Evaluate whether the code properly utilizes uniapp's cross-platform features to ensure the lottery system works across different platforms (WeChat Mini Program, H5, App, etc.). Check for platform-specific API conditional compilation (#ifdef), responsive UI design, and proper use of uniapp components. Deduct 3 points if only one platform is supported, 5 points if platform-specific issues are not handled. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are animation effects for the blind box opening experience implemented?",
+      "description": "Check whether appropriate animations are implemented for the blind box opening process (e.g., shaking, unwrapping, revealing). The animations should enhance user experience and create excitement. Deduct 5 points if animations are missing entirely, 3 points if animations are basic/rudimentary with no transitions, and 2 points if animations lack performance optimization. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a complete state management system for user inventory and prizes?",
+      "description": "Evaluate whether the code includes proper state management for tracking user's obtained items, remaining chances, purchase history, and prize inventory. Check for vuex/pinia integration, local storage persistence, and prize history display. Deduct 3 points if state is not persisted between sessions, 5 points if there's no inventory management, and 5 points if user history tracking is absent. 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 network failures during lottery draws, invalid configurations, edge cases in probability calculations, 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. AR visualization of prizes 2. Social sharing with custom cards 3. Prize combination collection systems 4. Seasonal/themed blind box designs). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple random generators coexisting) 2. Function modules unrelated to lottery (e.g., a built-in news feed) 3. Fancy effects that affect performance (e.g., excessive particle animations that cause 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 lottery logic/UI components/state management), 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 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 for the lottery process. Deduct 5 points for each operation without feedback, 3 points for visual stuttering during animations, and 5 points for confusing user flow in the lottery process. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "easy"
+}

package/library/game_development-casual/uniapp-lucky-draw-lottery-marquee-animation.json

@@ -0,0 +1,68 @@
+{
+  "index": 1196,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you provide is executable when possible. UniApp lucky draw lottery with marquee animation",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the lucky draw system fully implemented?",
+      "description": "Review whether the code accurately implements a complete lucky draw system including prize pool configuration, drawing logic, probability calculation, and result display. Score 0 if the core functionality is missing, 5 if only basic drawing without probability weighting is implemented, and 10 if it includes configurable probability, anti-cheating validation, and prize inventory management.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the marquee animation properly implemented?",
+      "description": "Check if the marquee animation is smooth, performant and visually appealing. The animation should use requestAnimationFrame or CSS animations rather than setTimeout/setInterval for better performance. Verify that the animation has proper easing (acceleration and deceleration), and the stopping mechanism feels natural rather than abrupt. Deduct 5 points if the animation is jerky, 3 points if it lacks proper easing, and 2 points if the stopping doesn't align perfectly with prize slots.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the UniApp cross-platform compatibility ensured?",
+      "description": "Evaluate whether the code uses UniApp's cross-platform APIs correctly and avoids platform-specific implementations where possible. Check for conditional compilation (`#ifdef`) where needed for platform differences. Deduct 3 points if only tested on one platform, 5 points if platform-specific bugs exist, and 7 points if critical features don't work across platforms (WeChat Mini Program, H5, App).",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the draw result handling and user feedback mechanism complete?",
+      "description": "Check if the code includes proper result handling with winning/losing notifications, prize claiming flows, and history records. Verify that animations and sound effects enhance the excitement of the draw. Award full 10 points only if the system includes prize claim verification, result persistence, and engaging feedback. Deduct 5 points if missing history tracking, 3 points if feedback is minimal.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as network interruption, permission denial, multiple rapid clicks) and provide friendly error prompts or recovery mechanisms. Check for validation of user inputs and draw conditions (e.g., remaining chances). Deduct 3 points for each unhandled edge case, with a minimum score of 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. Particle effects for winners 2. Social sharing of results with custom images 3. Mini-games to earn extra draw chances). 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 implementations of similar animations 2. Feature modules unrelated to lucky draw (e.g., a built-in calculator) 3. Fancy effects that affect performance (e.g., excessive particle systems on mobile). 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/business logic/API calls), proper use of UniApp component system, and adherence to best practices. Check if the code follows a consistent style guide. Deduct 5 points if global state pollution is found; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no error handling or logging mechanism. 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 festive/game context 2) Proper layout spacing that follows UniApp's responsive design guidelines 3) Professional typography with appropriate emphasis on prize items. Deduct 3 points for each UI element with poor contrast, 5 points for inconsistent design language, and 5 points for layouts that break on different screen sizes. 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 touch feedback ≤ 100ms 2) Marquee animation speed variation that builds excitement 3) Clear visual indication of when users can/cannot draw. Deduct 5 points for laggy animations on mid-range devices, 3 points for inconsistent animation timing, and 5 points for confusing interaction states. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "medium"
+}

package/library/game_development-casual/viral-cat-confession-code.json

@@ -0,0 +1,68 @@
+{
+  "index": 1084,
+  "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 when possible. Create a viral \"cat confession\" code that's especially popular on the internet.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core 'cat confession' functionality fully implemented?",
+      "description": "Check if the code creates an interactive interface where users can input 'confessions' alongside cat images/animations. The implementation should include text input, cat image selection/display, and confession posting mechanism. Score 0 if there's no interactive confession input, 5 if basic functionality exists but lacks visual cat elements, and 10 if the complete cat confession experience is implemented with proper text-image integration.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the viral sharing mechanism properly implemented?",
+      "description": "Evaluate the social sharing capabilities: 1) One-click sharing to major platforms (Twitter, Facebook, Instagram, TikTok) 2) Ability to generate shareable links/images 3) Copy-to-clipboard functionality. Deduct 3 points for each missing platform integration, 5 points if there's no image export functionality, and 5 points if the shared content lacks proper attribution/watermarking. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the cat visualization element compelling and customizable?",
+      "description": "Review the quality and variety of cat visualizations: 1) Multiple cat images/animations to choose from 2) Cat emotion/reaction tied to confession content 3) Customization options (cat colors, accessories, backgrounds). Deduct 3 points if fewer than 5 cat options exist, 5 points if cats don't react to content, and 5 points if no customization is available. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the 'viral' component engineered with effective growth mechanics?",
+      "description": "Assess implementation of viral growth features: 1) Call-to-action for sharing 2) Gamification elements like confession streaks or achievements 3) Subtle prompts to engage friends. Deduct 3 points for missing social proof indicators (view/share counters), 5 points for lack of friend invitation system, and 5 points if there's no reward for viral spreading. 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 confessions, oversized images, network interruption during sharing, 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. AI-generated cat responses to confessions 2. Voice-to-text confession with matching cat reactions 3. Seasonal themes or trending meme integration). 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 sharing methods that do the same thing) 2. Function modules unrelated to cat confessions (e.g., a built-in weather forecast) 3. Fancy effects that affect performance (e.g., excessive animations that slow page loading). 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 components/state management/API calls), code reusability, and performance optimization. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if basic performance optimizations are missing (such as image lazy loading). The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (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 interactions, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "hard"
+}

package/library/game_development-casual/web-chinese-english-matching-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1581,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable and demonstrable. Create a web-based Chinese-English matching game that comes with 10 English words along with their Chinese translations. Words should be displayed on the left side and Chinese translations on the right side (for example, apple-苹果). Include a voice system that pronounces the English word when the Chinese translation is clicked and pronounces the Chinese when the English word is clicked.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core Chinese-English matching game functionality properly implemented?",
+      "description": "Evaluate whether the code accurately implements the matching game with 10 English words and their Chinese translations. Check if the matching logic handles correct and incorrect matches appropriately with visual feedback. Score 0 if matching functionality is not implemented, 5 if basic matching exists but has issues, and 10 if the matching system is fully functional with proper validation and scoring.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the word pronunciation system implemented correctly?",
+      "description": "Verify if the voice system pronounces English words when Chinese translations are clicked and Chinese translations when English words are clicked. Check if the Web Speech API or a similar technology is properly integrated, with appropriate error handling for unsupported browsers. Deduct 5 points if only one language works, 3 points if pronunciation has significant delays (>500ms), and 2 points if there's no visual feedback during pronunciation. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the required 10 English-Chinese word pairs properly included?",
+      "description": "Check if exactly 10 English-Chinese word pairs are included in the implementation. Verify that translations are accurate and culturally appropriate. Deduct 1 point for each missing pair, 0.5 points for each inaccurate translation, and 2 points if words are hardcoded rather than stored in a maintainable data structure. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the layout properly implemented with left-side English words and right-side Chinese translations?",
+      "description": "Assess if the layout follows the specification with English words on the left and Chinese translations on the right. Check if the layout is responsive and maintains proper alignment across different screen sizes. Deduct 5 points if the layout is reversed, 3 points if alignment issues exist, and 5 points if the layout breaks on mobile devices. 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 browsers without speech synthesis support, network issues loading audio resources, user rapid-clicking, 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. Spaced repetition learning system 2. Pronunciation accuracy scoring 3. Visual mnemonics for vocabulary). 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 playback methods) 2. Function modules unrelated to language learning (e.g., unrelated games or tools) 3. Fancy effects that affect performance (e.g., excessive animations that slow down matching). 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/audio layers), 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 there's no clear separation between data and presentation. 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 interactions, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "easy"
+}

package/library/game_development-casual/web-english-vocabulary-matching-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1371,
+  "question": "You are a coding expert. Please use your professional knowledge to generate accurate and professional responses. Take care to ensure that the code you provide is executable and properly displayed. I want to create a word-matching elimination game (like a memory game) for English vocabulary, as a web application. How should I provide instructions to you?",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the word-matching game core mechanism fully implemented?",
+      "description": "Review whether the code accurately implements the card flip system through HTML/JavaScript, including card randomization, matching logic validation, and scoring system. Check if the game includes proper card state management (hidden/revealed/matched) and win condition detection. Score 0 if the core matching logic is not implemented, 5 if only basic card flipping is implemented, and 10 if complete matching rules with scoring system are included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the English vocabulary learning system effectively integrated?",
+      "description": "Evaluate whether the implementation includes a comprehensive vocabulary management system with word-definition pairing, pronunciation support (audio playback), and difficulty level categorization. Check for vocabulary progress tracking and adaptive learning features. Deduct 5 points if pronunciation is missing, 3 points if no difficulty progression exists. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the game progression and level system properly designed?",
+      "description": "Assess whether the code implements multiple difficulty levels, progressive vocabulary sets, and achievement/scoring systems. Verify the presence of timer functionality, streak counting, and performance analytics. Deduct 5 points if no level progression exists, 3 points if scoring system is incomplete. Check for save/load game progress functionality. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the complete game state management and data persistence constructed?",
+      "description": "Check whether the code includes comprehensive game state management with local storage for vocabulary progress, user preferences, and game statistics. Evaluate the implementation of game pause/resume, vocabulary set customization, and performance tracking over time. Deduct 5 points if data persistence is not implemented, 3 points if user progress tracking is missing. Give 10 points if fully implemented with robust data management.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid vocabulary data, audio loading failures, localStorage limitations, rapid clicking, 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. Voice recognition for pronunciation practice 2. Adaptive difficulty based on performance 3. Social sharing of achievements 4. Custom vocabulary import 5. Multi-language support). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple scoring systems coexisting) 2. Function modules unrelated to vocabulary learning (e.g., built-in social media integration) 3. Fancy effects that affect learning focus (e.g., distracting particle animations during gameplay). 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 game logic/vocabulary management/UI rendering layers), component reusability, and code organization. Deduct 5 points if global state pollution is found or MVC/MVP patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if no configuration management exists for vocabulary sets. 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 app design principles: 1) Harmonious color matching suitable for learning (no more than 3 primary colors, high contrast for readability) 2) Proper card layout spacing (element spacing follows the 8px multiple principle) 3) Professional typography system (body font size ≥ 16px for accessibility, line height over 1.4 times). Deduct 3 points for each cluttered visual element, 5 points for color combinations that strain the eyes, and 5 points for poor card arrangement that affects gameplay. 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 game standards: 1) Card flip animation duration controlled between 250-400ms 2) Click feedback delay ≤ 80ms for responsive feel 3) Clear visual feedback for correct/incorrect matches 4) Smooth transitions between game states. Deduct 5 points for each interaction without proper feedback, 3 points for jarring animation transitions, and 5 points if card flip animations interfere with gameplay rhythm. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "hard"
+}

package/library/game_development-casual/web-fast-paced-ball-dot-eater-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1783,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you provide is executable. Create web code for a fully automatic fast-paced game where a ball eats numerous dots.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core game mechanic implemented correctly?",
+      "description": "Review whether the code accurately implements the ball movement system through HTML5 Canvas/JavaScript, and whether it includes proper collision detection between the ball and dots. Score 0 if the core interaction logic is not implemented, 5 if only basic movement is implemented without proper physics, and 10 if smooth movement with proper momentum and collision is fully implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the automatic gameplay system functioning properly?",
+      "description": "Evaluate whether the ball moves automatically with intelligent pathfinding towards dots, implements proper decision-making algorithms for selecting which dots to target, and handles movement smoothly without player intervention. Deduct 5 points if the automation is rudimentary (straight-line movement only), and 3 points if the decision-making isn't optimized. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the dot generation and management system well-designed?",
+      "description": "Check whether the code implements proper dot spawning mechanisms with appropriate distribution algorithms, performance optimization for handling numerous dots simultaneously, and proper cleanup when dots are consumed. Deduct 5 points if dots appear in predictable patterns, and 3 points if performance degrades with many dots. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the game progression and scoring system implemented?",
+      "description": "Assess whether the code includes game state management such as score tracking, difficulty progression (increasing speed or complexity), and win/lose conditions. Deduct 5 points if scoring is absent or simplistic, and 3 points if difficulty doesn't increase as the player progresses. Give 10 points if fully implemented with visual feedback.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as browser compatibility issues, window resizing, performance bottlenecks with many elements, etc.) and provide graceful degradation 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 difficulty adjustment based on performance 2. Visual effects when consuming dots 3. Variable dot sizes with different point values). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple collision detection systems) 2. Function modules unrelated to the core gameplay (e.g., unnecessary settings) 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/physics layers), reusable component patterns, and performance optimization. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the game loop implementation is inefficient. 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 gaming design principles: 1) Contrasting colors between ball, dots, and background for clear visibility 2) Proper layout with score/status information not interfering with gameplay 3) Consistent visual style throughout. Deduct 3 points for each visual element that hinders gameplay, 5 points for poor color choices that make objects hard to distinguish, and 5 points for cluttered UI. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the game performance smooth and responsive?",
+      "description": "Judge whether the game maintains a consistent frame rate (60fps target): 1) No visible stuttering when many dots are present 2) Animation remains fluid throughout gameplay 3) No input lag when the game state changes. Deduct 5 points if the frame rate drops below 30fps with normal dot counts, 3 points for visible rendering artifacts, and 5 points for significant performance degradation over time. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "easy"
+}

package/library/game_development-casual/web-mini-game-trending-hit-songs.json

@@ -0,0 +1,68 @@
+{
+  "index": 913,
+  "question": "You are a coding expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable and can be demonstrated. Help me create a web mini-game that randomly generates currently trending hit songs.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the song generation algorithm properly implemented?",
+      "description": "Evaluate if the code implements a robust random song generation algorithm that can produce varied yet recognizable trending song structures. Check if it incorporates parameters for tempo, key, chord progressions, and melodic patterns found in current hit songs. Score 0 if no generation logic exists, 5 if basic random selection is implemented, and 10 if it includes sophisticated music theory principles with genre variations.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the trending song data source integration functional?",
+      "description": "Examine whether the application connects to an external API (like Spotify, Billboard, or LastFM) to retrieve current trending song data, or includes a manually curated database with recent hits. Check if the data is properly refreshed and if song characteristics are extracted correctly. Deduct 5 points if the trending data is outdated or static, and 3 points if the integration is unreliable. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the audio synthesis and playback system well-implemented?",
+      "description": "Assess whether the code utilizes Web Audio API effectively to synthesize and play the generated music. Look for implementation of proper sound generation, effects processing, and mixing. Test if the playback controls (play, pause, stop) work smoothly without audio glitches. Deduct 5 points for poor sound quality, 3 points for playback inconsistencies, and 5 points if volume control is missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the game include engaging interactive elements?",
+      "description": "Verify if the mini-game incorporates interactive elements that make it engaging as a game rather than just a music generator. This could include features like guessing the original song, rating/scoring system, customization options, or challenges. Deduct 5 points if user interaction is minimal, and 3 points if the gamification elements don't enhance the experience. Give 10 points if the game is genuinely fun and engaging.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as API failures, audio playback issues, browser compatibility problems, 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. Visualizing the music with animated elements 2. Social sharing of generated songs with custom album art 3. Voice or instrument recognition to influence generation). 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 playback systems) 2. Function modules unrelated to music generation or game mechanics (e.g., unnecessary animations) 3. Fancy effects that affect performance (e.g., excessive particle effects or 3D rendering). 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 music generation logic, audio engine, UI components, and game mechanics), 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 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 fast sliding, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "medium"
+}