@getollie/cli 0.0.1

package/library/game_development-casual/web-vocabulary-memorization-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1763,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code in your demonstration. Design a web-based vocabulary memorization game (HTML+CSS) for third-grade students.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the vocabulary memorization game core functionality fully implemented?",
+      "description": "Review whether the code accurately implements vocabulary display, user input validation, scoring mechanism, and progress tracking through HTML/CSS/JavaScript. Check if it includes word-image matching, spelling exercises, and pronunciation features suitable for third-grade level. Score 0 if core learning interaction is not implemented, 5 if only basic word display is implemented, and 10 if complete vocabulary learning cycle with feedback is included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the age-appropriate game mechanics system properly designed?",
+      "description": "Evaluate whether the game includes appropriate difficulty progression, reward systems (stars/badges), and encouraging feedback mechanisms suitable for 8-9 year olds. Check for implementation of hint systems, mistake tolerance, and positive reinforcement. Deduct 5 points if difficulty curve is too steep, and 3 points if reward feedback is insufficient. Full score requires engaging gamification elements that maintain child attention.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the learning progress tracking and vocabulary management system implemented?",
+      "description": "Check whether the system tracks individual word mastery levels, implements spaced repetition algorithms, and provides progress visualization suitable for children. Evaluate if it includes vocabulary categorization, difficulty adjustment based on performance, and learning analytics. Deduct 5 points if no progress persistence is implemented, and 3 points if vocabulary difficulty adaptation is missing.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are child-friendly accessibility and safety features properly constructed?",
+      "description": "Review whether the code includes appropriate accessibility features for young learners (large buttons, clear fonts, audio support), parental controls, and safe interaction patterns. Check for implementation of session time limits, clear navigation, and error prevention mechanisms. Deduct 5 points if accessibility guidelines for children are not followed, and 3 points if safety considerations are missing.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid input, browser compatibility issues, audio loading failures, etc.) and provide child-friendly error messages or recovery mechanisms. Code with strong robustness should gracefully handle edge cases without breaking the learning experience, giving 10 points. If 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 enhance learning engagement?",
+      "description": "Check whether the code includes creative features that boost educational value (e.g., 1. Interactive word animations 2. Voice recognition for pronunciation practice 3. Collaborative learning modes 4. Adaptive storytelling with vocabulary). Add 3 points for each practical innovative feature implemented that enhances learning outcomes (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant or inappropriate features?",
+      "description": "Strictly check for three types of issues: 1. Redundant implementation of similar learning functions 2. Features inappropriate for third-graders (complex interfaces, advanced concepts) 3. Distracting elements that interfere with learning focus (excessive animations, irrelevant games). Deduct 3 points for each redundancy found, and directly deduct 10 points if core learning functions are compromised by inappropriate content.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (separating game logic/UI/data layers), code organization suitable for educational software, and maintainability. Deduct 5 points if code structure is chaotic or lacks educational software best practices; deduct 5 points if code duplication rate exceeds 30%; deduct 5 points if the codebase is not easily extensible for additional vocabulary sets. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface design meet child-friendly educational standards?",
+      "description": "Evaluate whether the design follows child-centered educational principles: 1) Age-appropriate color schemes (bright, engaging, high contrast) 2) Large, easily clickable interface elements (minimum 44px touch targets) 3) Clear visual hierarchy with educational focus 4) Consistent iconography and navigation patterns. Deduct 3 points for each confusing interface element, 5 points for inappropriate color choices, and 5 points for cluttered educational content layout.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Are the interactions smooth and educationally effective?",
+      "description": "Judge whether the interactive elements support effective learning: 1) Immediate feedback on correct/incorrect answers ≤ 200ms 2) Smooth transitions that don't distract from learning (200-400ms) 3) Clear visual and audio cues for educational progress 4) Intuitive gesture/click patterns for young users. Deduct 5 points for each confusing interaction pattern, 3 points for delayed feedback that breaks learning flow, and 5 points for difficult-to-use educational controls.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "medium"
+}

package/library/game_development-casual/wechat-mini-program-family-social-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1050,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the code you generate is executable. I want to develop a WeChat mini program with the following features: users can create coins to join families, wear family emblems, publish photos and text which can be commented on, and implement a real-time family activity ranking board. The activity level can be increased through online time, number of comments, published content, etc. Please refine and optimize these requirements, and provide the relevant development process and program code. In addition to the above, add a game module where players can earn points for rankings by playing games.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the user family system fully implemented?",
+      "description": "Evaluate whether the code implements a complete family system including: creating families, joining families, family emblem customization, and member management. Check if the system includes permissions hierarchy (admin/member), invitation mechanisms, and family statistics. Score 0 if the core family functions are missing, 5 if only basic family creation and joining is implemented, and 10 if the system includes complete family management with role-based permissions.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the social content publishing and interaction features functional?",
+      "description": "Review if the code properly implements content publishing (photos and text), comment system, and content management. Check for image compression, content filtering mechanisms, and proper database structures. Deduct 3 points if media upload lacks progress indicators, 3 points if there's no content moderation mechanism, and 4 points if comments lack pagination or proper notification systems. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the activity ranking system properly designed and implemented?",
+      "description": "Check whether the activity ranking system calculates and updates scores based on multiple metrics (online time, comments, content publishing) accurately. Evaluate if real-time updates are implemented using cloud functions or WebSocket, and if the system includes anti-cheating mechanisms. Deduct 5 points if the ranking algorithm is simplistic or easily exploitable, and 5 points if there's no real-time update mechanism. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the game module for earning ranking points properly implemented?",
+      "description": "Assess the implementation of the game module, examining if it includes proper game mechanics, score tracking, and integration with the ranking system. Check for multiple game options, difficulty levels, and anti-cheating measures. Deduct 4 points if games are too simple (lacking engagement), 3 points if there's no progression system, and 3 points if score synchronization with the ranking system is unreliable. 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 network interruption, user operation errors, server downtime, 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 family emblem display 2. Voice commentary for content 3. Family-themed interactive stickers 4. Seasonal family event systems). 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 notification systems coexisting) 2. Function modules unrelated to family/social system (e.g., unnecessary utility tools) 3. Heavy animations or effects that affect performance on limited mobile devices. 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 business logic/UI/network layers), appropriate use of WeChat mini program framework patterns, and code maintenance considerations. Deduct 5 points if global state management is chaotic; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no error logging or monitoring implementation. 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 mini program design principles: 1) Harmonious color matching aligned with WeChat's design language 2) Proper layout spacing respecting safe areas on different devices 3) Professional typographic hierarchy with clear readability on small screens. Deduct 3 points for each instance of poor tap target sizing, 5 points for non-standard component usage, 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 WeChat mini program best practices: 1) Response to user input within 100ms 2) Proper loading states for network operations 3) Smooth transitions between pages and tabs 4) Optimized rendering performance for list views. Deduct 3 points for each janky scrolling implementation, 4 points for missing loading indicators during network operations, and 3 points for abrupt page transitions. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "hard"
+}

package/library/game_development-casual/wechat-mini-program-snake-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 956,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the code you generate is executable and can be demonstrated. Create executable code for a WeChat mini-program version of the Snake game.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core Snake game logic fully implemented?",
+      "description": "Check whether the code accurately implements the snake movement mechanics, collision detection (with walls, self, and food), and score tracking. Score 0 if the core game logic is missing, 5 if only basic movement is implemented, and 10 if it includes variable speed levels, different food types, and proper game state management (start, pause, game over).",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the WeChat mini-program framework correctly utilized?",
+      "description": "Evaluate whether the code properly uses the WeChat mini-program lifecycle hooks (onLoad, onReady, onShow, onHide), page routing, and follows the MINA framework architecture (app.js, pages structure, etc.). Deduct 5 points if app.json configuration is incomplete, 3 points if global state management is improperly handled, and 5 points if page routing is missing or incorrect. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the game rendering optimized for the WeChat mini-program environment?",
+      "description": "Check whether the rendering uses canvas for smooth gameplay (required for games) rather than slow WXML DOM manipulation. Assess whether requestAnimationFrame or wx.createAnimation is properly used for animation frames. Deduct 5 points if rendering causes visible performance issues, 3 points if memory leak occurs during long gameplay. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are WeChat mini-program specific features integrated?",
+      "description": "Evaluate whether the game leverages WeChat-specific features like local storage for high scores, share functionality, user avatars, or leaderboards using cloud functions. Score 0 if no WeChat-specific features are used, 5 if only basic storage is implemented, and 10 if multiple platform-specific features are properly integrated and enhance the gaming experience.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as application suspension/resumption, unexpected user inputs, device rotation, 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. Power-ups and special foods 2. Multiplayer mode using WeChat's real-time communication 3. Customizable snake skins). 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 game loop implementations) 2. Function modules unrelated to the snake game (e.g., unnecessary mini-program pages) 3. Fancy effects that affect performance (e.g., excessive particle 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/view/controller layers), proper commenting, and mini-program 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 the project structure doesn't follow WeChat mini-program conventions. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern mobile game design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout for different device sizes (responsive design) 3) Professional UI elements (buttons, score displays, game over screens). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for interfaces that don't respect the safe areas on modern devices. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the touch controls are responsive and intuitive for a mobile snake game: 1) Touch response delay ≤ 100ms 2) Intuitive swipe or button controls for changing direction 3) Proper visual feedback for player actions. Deduct 5 points for input lag exceeding 150ms, 3 points for unnatural snake movement animations, and 5 points for controls that are difficult to use with one hand. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "medium"
+}

package/library/game_development-casual/wechat-mini-program-swipe-data-navigation.json

@@ -0,0 +1,68 @@
+{
+  "index": 883,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure the code you generate is executable for demonstration. Help me write a WeChat Mini Program that implements requesting the next data item when swiping right and the previous data item when swiping left.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the swipe gesture detection properly implemented?",
+      "description": "Verify if the code correctly implements touch event handling (touchStart, touchMove, touchEnd) with proper threshold calculation for horizontal swipes. Check if direction detection differentiates left/right swipes accurately with at least 30px threshold. Score 0 if gesture detection is missing, 5 if basic implementation exists but edge cases aren't handled, 10 if fully implemented with velocity detection and proper cancellation of vertical scrolls.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the data pagination mechanism correctly implemented?",
+      "description": "Evaluate the implementation of data fetching logic for previous/next items. Check if proper state management prevents duplicate requests and handles boundary conditions (first/last item). Verify if caching is implemented to avoid redundant network requests. Deduct 5 points if boundary detection is missing, 3 points if there's no loading state handling. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the UI transition animation smooth and intuitive?",
+      "description": "Assess the animation implementation for transitions between data items. Verify if the code uses proper wxs/animation modules for smooth performance. Check if animations follow the swipe direction (slide left/right) with proper easing functions. Deduct 5 points for jerky animations, 3 points for inconsistent behavior, and 5 points if animations are missing entirely. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there proper error handling and empty state management?",
+      "description": "Check how the code handles errors during data fetching (network issues, API failures) and empty data scenarios. Verify if user-friendly feedback is provided and retry mechanisms exist. Score 0 if no error handling exists, 5 if basic error messages are shown but no recovery options, and 10 if comprehensive error handling with graceful fallbacks and retry options are implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid swiping, network interruption, boundary conditions, 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. Pull-to-refresh with custom animation 2. Haptic feedback on swipe 3. Gesture customization options 4. Smart preloading of adjacent data). 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 gesture detection systems coexisting) 2. Function modules unrelated to the swipe functionality (e.g., unnecessary utility functions) 3. Fancy effects that affect performance (e.g., excessive animations that impact swipe responsiveness). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating UI/logic/data layers), use of WeChat Mini Program best practices, and proper component encapsulation. 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 mini program 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 overall design follows WeChat Mini Program design principles: 1) Consistent with WeChat's visual language 2) Proper layout spacing and component sizing 3) Professional typography system aligned with WeChat standards. Deduct 3 points for each inconsistent visual element, 5 points for a non-native look and feel, 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 swipe interactions conform to human perception characteristics: 1) Swipe response time ≤ 100ms 2) Transition animation duration controlled between 200-400ms 3) Clear visual indicators for swipe direction/progress. Deduct 5 points for each laggy swipe response, 3 points for jittery animations during transitions, and 5 points for lack of visual feedback during swipes. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "medium"
+}

package/library/game_development-casual/wechat-mini-program-t-rex-running-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1003,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Make sure the code you generate is executable for demonstration purposes. Write a WeChat Mini Program similar to Google's T-Rex running game.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core game mechanism fully implemented?",
+      "description": "Review whether the code accurately implements the core T-Rex running game mechanics, including the main character's jump action, obstacle generation and movement, collision detection, score tracking, and game speed progression. Score 0 if the core gameplay is missing, 5 if only basic jumping and obstacles are implemented, and 10 if all features from the original T-Rex game (including ducking, night mode transitions, etc.) are included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the Mini Program structure correctly implemented?",
+      "description": "Check whether the code follows WeChat Mini Program specifications with proper file structure (app.js, app.json, app.wxss, pages structure), correct usage of WXML and WXSS instead of HTML/CSS, and appropriate implementation of the Mini Program lifecycle events. Deduct 5 points if the basic structure is incorrect, 3 points if lifecycle methods are misused, and 2 points if configuration files are incomplete. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the game canvas rendering optimized for Mini Program environment?",
+      "description": "Evaluate whether the game uses wx.createCanvas or wx.createContext appropriately, implements proper frame rate management (using wx.requestAnimationFrame instead of setInterval), and handles device pixel ratio for different screen resolutions. Check if memory usage is optimized through object pooling and proper garbage collection. Deduct 3 points for each performance anti-pattern. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are WeChat Mini Program specific features utilized?",
+      "description": "Check whether the code leverages Mini Program specific capabilities like touch events instead of keyboard inputs, vibration feedback on collision, cloud storage for high scores, and share functionality. Examine if the program handles app suspension and resumption correctly. Deduct 2 points for each missed opportunity to integrate WeChat-specific features. 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 device rotation, Mini Program being switched to background, memory constraints, low battery mode, 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. WeChat friend leaderboards 2. Character customization 3. Alternative game modes 4. Integration with WeChat user profile). 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 jump mechanics coexisting) 2. Function modules unrelated to the game (e.g., unnecessary social features) 3. Fancy effects that affect performance (e.g., complex 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 game logic/view layers), proper component encapsulation, and adherence to Mini Program best practices. 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 the project structure is disorganized or inconsistent. 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 and Mini Program UI guidelines: 1) Harmonious color matching (maintaining the original game's minimalist style while fitting WeChat's aesthetic) 2) Proper layout for both horizontal and vertical orientations 3) Professional font system (readable text at various sizes). Deduct 3 points for each crowded visual element, 5 points for inconsistent styling, and 5 points for poor adaptation to different screen sizes. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and responsive?",
+      "description": "Judge whether the game controls and animations respond appropriately to touch inputs: 1) Jump response delay ≤ 50ms 2) Consistent frame rate without stuttering (ideally 60fps) 3) Clear visual feedback for all interactions. Deduct 5 points for input lag exceeding 100ms, 3 points for inconsistent frame rates, and 5 points for unclear collision feedback. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "medium"
+}

package/library/game_development-casual/whack-a-mole-mini-game-html-frontend.json

@@ -0,0 +1,68 @@
+{
+  "index": 1423,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable for demonstration. Help me write a Whack-a-Mole mini-game using HTML frontend.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core Whack-a-Mole game mechanism fully implemented?",
+      "description": "Check if the code properly implements the core game mechanics: random mole appearance from holes, player clicking/tapping to whack moles, score tracking, and time limit. Score 0 if the basic game loop isn't working, 5 points if only simple functionality exists, and 10 points if the game includes varied mole speeds, proper animation for moles appearing/disappearing, and correct hit detection.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the game board UI properly designed and rendered?",
+      "description": "Evaluate if the game board has appropriate layout with clearly defined holes for moles, consistent spacing, and responsive design that works on different screen sizes. Deduct 3 points if the mole holes aren't visually distinct, 4 points if the layout breaks on mobile devices, and 3 points if the game area doesn't maintain proper proportions. Full score requires professional-looking holes and moles with visual depth.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Does the game implement proper scoring and game state management?",
+      "description": "Review the implementation of score tracking, countdown timer, game states (start, playing, game over), and session persistence. Deduct 5 points if score increments don't validate actual hits, 3 points if the timer doesn't accurately control game duration, and 5 points if game states aren't properly managed. Full score requires persistent high scores and clean state transitions.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the game include difficulty progression or levels?",
+      "description": "Assess if the game implements increasing difficulty (faster moles, shorter appearance times, fake moles, etc.) either through timed progression or explicit level selection. Score 0 if difficulty remains static, 5 points for basic difficulty increase over time, and 10 points for a sophisticated level system with multiple parameters affecting gameplay.",
+      "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, loss of focus, etc.) and provide friendly error handling. Code with strong robustness should prevent cheating through rapid clicking, handle browser tab switching gracefully, and recover from potential errors. Give 10 points for excellent robustness, 5 points for average handling, and 0 points if no exception handling exists.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Special bonus moles 2. Power-ups or combo systems 3. Visual/audio feedback for successful hits 4. Theme customization options). 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 the Whack-a-Mole game (e.g., unrelated mini-games) 3. Fancy effects that affect performance (e.g., excessive animations slowing down gameplay). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game logic/view/input handling), code organization, and maintainability. Deduct 5 points if global variables are excessively used or proper encapsulation is missing; deduct 5 points if the code duplication rate is too high; deduct 5 points if there's no separation between game logic and DOM manipulation. The full score is 10 points for clean, maintainable code.",
+      "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/tap response delay ≤ 100ms 2) Mole animation duration appropriate (200-400ms) 3) Clear visual feedback for hits and misses. Deduct 5 points for laggy animations, 3 points for unclear hit feedback, and 5 points if the game feels unresponsive. The full score is 10 points for a game that feels snappy and satisfying to play.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "medium"
+}

package/library/game_development-casual/whack-a-mole-mini-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1264,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable for demonstration. I'd like to create a whack-a-mole mini-game. I'm a complete beginner, so please explain the detailed steps. Generate comprehensive code with explanatory comments. The code should be directly runnable in the WeChat Mini Program Developer Tools.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core game mechanics fully implemented?",
+      "description": "Review whether the code accurately implements the whack-a-mole game mechanics through JavaScript, including random mole appearance, hit detection, and scoring system. Check if moles appear at random positions and timing, disappear after being hit or after a timeout, and if points are correctly awarded for successful hits. Score 0 if the core game logic is missing, 5 if basic functionality works but with issues, and 10 if the game mechanics are fully implemented with proper randomization and hit detection.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the game UI properly designed for WeChat Mini Program?",
+      "description": "Evaluate whether the implementation uses appropriate WeChat Mini Program components (WXML/WXSS) and follows the platform's design guidelines. Check if the implementation includes game board layout, mole holes, mole animations, hammer cursor/animation, and score display. Deduct 5 points if the UI doesn't follow WeChat Mini Program standards, and 3 points if essential visual elements are missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are game difficulty levels and progression implemented?",
+      "description": "Check whether the code includes different difficulty levels (e.g., increasing speed of moles, decreasing appearance time, or introducing distractors). Evaluate if there's a clear progression system (increasing difficulty over time or levels) and if the game speed/challenge adapts to player performance. Deduct 5 points if there's no difficulty adjustment, 3 points if progression is too simple. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is game state management properly implemented?",
+      "description": "Assess whether the code handles different game states (start screen, gameplay, pause, game over) correctly and smoothly transitions between these states. Check if the implementation includes timer management, score tracking, high score recording, and proper game reset functionality. Deduct 5 points if state transitions are buggy, and 3 points if essential state management features are missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid tapping, extreme screen sizes, unexpected user interactions) and provide friendly error handling or recovery mechanisms. Code with strong robustness should prevent cheating methods and handle edge cases effectively, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Special bonus moles 2. Combo system for consecutive hits 3. Power-ups or special abilities 4. Themed visual/sound effects based on player performance). Add 2.5 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple hit detection mechanisms) 2. Function modules unrelated to the whack-a-mole game (e.g., unnecessary mini-games within) 3. Fancy effects that affect performance (e.g., excessive animations that slow down gameplay). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game logic/view/controller layers), code organization, and proper use of WeChat Mini Program lifecycle functions. 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 the file structure doesn't follow Mini Program best practices. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern mobile game design principles: 1) Appropriate and consistent color scheme 2) Proper layout for touch interactions (tap targets at least 44x44px) 3) Clear visual feedback for hits and misses 4) Adequate contrast between game elements. Deduct 3 points for each cluttered visual element, 5 points for an unappealing or inconsistent color scheme, and 5 points for poor visibility of game elements. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and responsive?",
+      "description": "Judge whether the touch interactions and animations conform to mobile gaming standards: 1) Hit registration delay ≤ 100ms 2) Smooth animations for mole appearance/disappearance 3) Intuitive hammer/tap feedback. Deduct 5 points for noticeable input lag, 3 points for janky animations, and 5 points for confusing or missing visual feedback on hit/miss actions. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "easy"
+}

package/library/game_development-casual/world-of-warcraft-manual-counting-script.json

@@ -0,0 +1,68 @@
+{
+  "index": 1040,
+  "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. Write a small window script for World of Warcraft that can be used for manual counting.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core counting functionality properly implemented?",
+      "description": "Check whether the script accurately implements the basic counting mechanism for manual tracking in WoW. Score 0 if no counting logic exists, 5 if only basic incrementing/decrementing is implemented, and 10 if it includes features like multiple counter types, reset functionality, and persistence between sessions.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the addon properly structured according to WoW addon standards?",
+      "description": "Evaluate whether the code follows proper WoW addon structure (TOC file, directory organization, proper event handling, etc.). Check if it uses the correct API calls for frame creation and management. Deduct 5 points if the TOC file is missing or incomplete, and 3 points if the addon doesn't follow proper naming conventions to avoid conflicts. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Does the script provide user-friendly input methods?",
+      "description": "Verify if the script implements appropriate user input methods like slash commands, keybindings, or clickable buttons. Check if the commands follow WoW addon conventions and are properly registered. Deduct 5 points if slash commands aren't implemented, 3 points if there's no keybinding option, and 2 points if command help/usage information is missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there proper event handling and frame management?",
+      "description": "Assess whether the script correctly uses WoW API for event registration, frame creation, and UI updates. Check if it properly handles events like player login/logout, UI reloads, and avoids taint issues. Deduct 5 points for improper event handling, 5 points for memory leaks due to poor frame management, and 5 points if the script interferes with protected frames. 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 addon conflicts, unexpected inputs, addon memory reset, 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 script includes surprise features that enhance the experience (e.g., 1. Visual animations for count changes 2. Integration with game events for automatic counting 3. Data export/sharing functionality). 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 reset counters) 2. Function modules unrelated to counting (e.g., a built-in damage meter) 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 logic/view/data persistence layers), code organization, and maintainability. Deduct 5 points if global variables pollute the WoW namespace; 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 WoW addon standards?",
+      "description": "Evaluate whether the visual design follows WoW UI principles: 1) Consistent with WoW's visual theme 2) Proper use of WoW UI elements and textures 3) Appropriate scaling for different resolutions. Deduct 3 points for each non-standard UI element, 5 points for clashing with WoW's aesthetic, and 5 points for poor positioning or overlap with important game UI. 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 WoW addon expectations: 1) Responsive to user inputs with minimal delay 2) Proper integration with WoW's frame update cycle 3) Efficiency in update processing to avoid performance impact. Deduct 5 points for each operation without feedback, 5 points for noticeable FPS drops when using the addon, and 3 points for inconsistent behavior across different game scenarios. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "easy"
+}