@getollie/cli 0.0.1

package/library/game_development-casual/dinosaur-themed-match-3-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1174,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code for demonstration. Help me create a dinosaur-themed match-3 game as a playable webpage.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the basic match-3 gameplay mechanics fully implemented?",
+      "description": "Review whether the code implements core match-3 mechanics (grid system, matching detection, piece swapping, cascading effects). Score 0 if matching logic is not implemented, 5 if only basic matching works, and 10 if advanced mechanics like cascading matches and special combinations are included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the dinosaur theme effectively integrated into the game?",
+      "description": "Evaluate whether dinosaur elements are meaningfully incorporated in visual assets, gameplay mechanics, and overall aesthetic. Deduct 5 points if dinosaurs appear only as generic icons without thematic integration, 3 points if the dinosaur theme feels disconnected from gameplay. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there a complete game progression system?",
+      "description": "Check for implementation of score tracking, level progression, increasing difficulty, and win/lose conditions. Deduct 5 points if there's no scoring system, 3 points if level progression is missing, and 5 points if win/lose conditions aren't defined. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are there special game elements and power-ups?",
+      "description": "Assess the implementation of special tiles, power-ups, or bonus mechanics that enhance gameplay (e.g., dinosaur-themed special matches, extinction events as power-ups, fossil collection). Deduct 5 points if no special elements exist, 3 points if they're present but not interactive. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid moves, rapid user inputs, browser resizing, etc.) and provide friendly error handling or recovery mechanisms. Code with strong robustness should handle these 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. Dinosaur animations for successful matches 2. Educational dinosaur facts 3. Adaptive difficulty system). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple scoring systems) 2. Function modules unrelated to the match-3 or dinosaur theme 3. Fancy effects that affect performance (e.g., excessive particle effects). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game logic/view/user input layers), code organization, and maintainability. Deduct 5 points if global state pollution is found or appropriate design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no separation of concerns. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern game design principles: 1) Consistent dinosaur-themed visual elements 2) Proper layout spacing (game grid properly sized and centered) 3) Clear visual hierarchy (score display, game board, UI controls). Deduct 3 points for each cluttered visual element, 5 points for inconsistent theming, and 5 points for poor visual guidance. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the game interactions conform to expected match-3 mechanics: 1) Immediate feedback on tile selection (≤100ms) 2) Smooth animations for matches and cascades (300-500ms) 3) Clear visual and audio cues for successful/unsuccessful moves. Deduct 5 points for laggy animations, 3 points for confusing interaction feedback, and 5 points for unresponsive controls. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "hard"
+}

package/library/game_development-casual/elementary-ket-vocabulary-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 342,
+  "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. Create an entertaining and fun KET vocabulary game HTML page for elementary school students that can help children strengthen their memory in word pronunciation and spelling. The requirements are as follows:\n\n1. The page should include learning mode, practice mode, and test mode, incorporating game elements that are highly interactive, entertaining, and challenging.\n2. When the program starts, a popup should prompt the user to load vocabulary words. The user selects a text file containing words saved in TXT format, separated by commas.\n3. After loading the TXT file, the program generates a word card for each word, including a corresponding emoji, phonetic symbol, hidden Chinese explanation (which can be viewed by clicking), and common phrases related to the word.\n4. In learning mode, students study the word cards. Pronunciation should be available in both British and American accents, with adjustable playback speed from 0.5x to 1.5x.\n5. In practice mode, students can practice word spelling, fill-in-the-blank exercises, and dictation to reinforce vocabulary memorization (for spelling practice, the letters of the word can be scrambled, requiring children to click on the letters in the correct order).\n6. In test mode, students take dictation and complete fill-in-the-blank application exercises to check their mastery of vocabulary, avoiding Chinese prompts as much as possible.\n7. Upon successful completion of challenges, encouraging language and fun animations like thumbs-up, fireworks, little stars, rockets, etc. appear. If wrong answers are given, animations like bombs or \"oops\" expressions appear with messages to keep trying.\n7. The layout should be centered, with compatibility considerations to ensure normal use on mobile phones. Words should be displayed in standard print font.\n8. Word information should be configured through a separate JSON file, achieving separation of data and code.\n9. After code generation, review it to ensure all features and buttons are functional without errors.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the vocabulary loading functionality properly implemented?",
+      "description": "Review whether the code correctly implements file loading functionality via a popup dialog, properly handles TXT files with comma-separated words, and successfully converts the input into usable vocabulary data. Score 0 if file loading is completely missing, 5 if basic loading works but lacks error handling, and 10 if the implementation includes proper file type validation, error handling for malformed content, and visual feedback during loading.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are all three required modes (learning, practice, test) implemented with the specified features?",
+      "description": "Evaluate the completeness of each mode: Learning mode must include word cards with emoji, phonetic symbols, hidden Chinese explanations, and common phrases. Practice mode must include spelling exercises with scrambled letters, fill-in-the-blank, and dictation. Test mode must include dictation and application exercises without Chinese prompts. Deduct 3 points for each missing feature in any mode. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the audio pronunciation functionality fully implemented?",
+      "description": "Check if the code implements both British and American accent pronunciations, with adjustable playback speed (0.5x to 1.5x). Verify that the audio control elements are user-friendly and that the implementation handles potential API limitations or errors gracefully. Score 0 if pronunciation features are missing, 5 if only basic functionality without speed control is implemented, and 10 if all requirements are met with proper error handling.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are the interactive game elements and animations properly implemented?",
+      "description": "Assess whether the code includes entertaining animations (thumbs-up, fireworks, stars, rockets for success; bombs, 'oops' expressions for failure), and if these animations trigger appropriately based on student performance. Animations should be visually appealing without being distracting. Deduct 3 points if animations are missing for either success or failure cases, and 5 points if animations are implemented but not contextually triggered. 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 unsupported file formats, malformed vocabulary data, audio loading failures, 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. Spaced repetition algorithm for word review 2. Visual word association aids 3. Progress tracking with achievements/badges 4. Multiplayer competition mode). 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 mechanisms coexisting) 2. Function modules unrelated to vocabulary learning (e.g., a built-in calculator) 3. Fancy effects that affect performance (e.g., excessive animations that slow down the page). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating data/view/controller layers), code reusability, and maintainability. Deduct 5 points if global variable pollution is found; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if JSON data is hardcoded rather than loaded externally as specified. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet child-friendly and professional design standards?",
+      "description": "Evaluate whether the design is appropriate for elementary school students: 1) Age-appropriate color scheme and visuals 2) Clear, readable print font as specified 3) Proper layout spacing and sizing for young users 4) Centered layout with responsive design for mobile compatibility. Deduct 3 points for each instance of text below 16px, 5 points for non-responsive elements, and 5 points for a cluttered or overwhelming interface. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth, intuitive, and educational?",
+      "description": "Judge whether the interactions are suitable for elementary students: 1) Clear instructions and feedback for each action 2) Age-appropriate difficulty progression 3) Intuitive controls suitable for children's motor skills 4) Educational value maintained throughout gameplay elements. Deduct 5 points for confusing navigation, 3 points for inconsistent interaction patterns, and 5 points for interactions that may frustrate young learners. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "hard"
+}

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

@@ -0,0 +1,68 @@
+{
+  "index": 1213,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable for demonstration purposes. Please create a small game for English vocabulary memorization, in the form of a web page HTML version.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the vocabulary memorization system fully implemented?",
+      "description": "Evaluate whether the code implements the core vocabulary learning system with card review, spaced repetition, and word tracking. Score 0 if the core system is missing, 5 if basic flashcard functionality is implemented but lacks systematic review, and 10 if a complete spaced repetition system (like Leitner or SuperMemo algorithm) is implemented with progress tracking.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the vocabulary data management effectively designed?",
+      "description": "Check whether the code includes proper vocabulary data structures, local storage persistence, and vocabulary categorization (by difficulty level, topic, or learning progress). Deduct 5 points if there's no persistent storage implementation, 3 points if vocabulary categorization is missing, and 2 points if the data structure is inefficient for retrieval. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are learning effectiveness features implemented?",
+      "description": "Evaluate whether the system includes effectiveness-enhancing features such as: recall testing, wrong answer tracking, review scheduling, and performance statistics. Give 3 points for each well-implemented feature with a maximum of 10 points. Deduct 5 points if the system only shows words without any recall testing.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is gamification properly integrated into the learning experience?",
+      "description": "Assess whether the code implements game mechanics that enhance vocabulary learning: scoring system, achievements/badges, progress indicators, and learning streaks. Each well-implemented gamification element that enhances motivation counts for 2.5 points. Deduct 5 points if gamification elements are superficial and don't reinforce learning behaviors.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as empty vocabulary lists, browser storage limitations, user input errors, 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. Audio pronunciation of words 2. Visual mnemonics for difficult words 3. Contextual example sentences 4. Etymological information). 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 word checking algorithms) 2. Function modules unrelated to vocabulary learning (e.g., a built-in general calculator) 3. Fancy effects that affect performance (e.g., excessive animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core 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 learning logic/view/data layers), function encapsulation, and code maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no clear separation between presentation and business 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). 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 transitions, 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/geographical-riddle-guessing-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1682,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Ensure that the code you generate is executable for demonstration. Generate 50 geographical riddles (such as \"Double city overlapping clouds, mountains moving within the city\" - answer: Chongqing, a Chinese city); ② Based on this, develop a web-based geographical riddle guessing game (it should prompt success if guessed correctly, and error if guessed incorrectly).",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Quality and diversity of geographical riddles",
+      "description": "Evaluate whether the code generates 50 high-quality geographical riddles that are clever, diverse, and culturally representative. Riddles should include locations from different continents, countries, cities, landmarks, and natural features. Each riddle should be unique, meaningful, and provide sufficient clues for solving while maintaining an appropriate difficulty level.Score 0 if fewer than 30 riddles are provided, 5 if 50 riddles are provided but lack diversity or quality, and 10 if all 50 riddles are high-quality, diverse, and geographically representative.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Implementation of riddle generation mechanism",
+      "description": "Check whether the code properly implements the riddle generation system, including storage (array, database, or JSON structure) and selection mechanisms. The implementation should allow for random selection, tracking of used riddles, and potential difficulty progression.Deduct 5 points if riddles are hardcoded without proper data structure, 3 points if there's no randomization mechanism, and 3 points if there's no tracking of used/unused riddles. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Answer validation functionality",
+      "description": "Review the implementation of the answer validation system. It should properly compare user input with correct answers, handle case sensitivity, partial matches, synonyms, or alternative names for locations. Advanced implementations might include fuzzy matching or handling of common misspellings.Deduct 5 points if only exact case-sensitive matching is implemented, 3 points if there's no feedback mechanism for near-misses, and 2 points if validation doesn't handle common answer variations. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Game flow and user interaction design",
+      "description": "Assess whether the game has a complete flow including introduction, riddle presentation, answer input, feedback, score tracking, and game completion. Check for clear instructions, intuitive navigation, and appropriate transitions between game states.Deduct 3 points for each missing game state (intro, gameplay, feedback, completion), 2 points if there's no restart option, and 5 points if the overall flow is confusing or broken. 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 inputs, special characters in answers, rapid clicking, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases.Give 10 points if exceptions are well-handled with user-friendly messages, 5 points if basic error handling exists but some edge cases are unaddressed, and 0 points if no exception handling is implemented.",
+      "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. Difficulty levels 2. Hints system 3. Map visualization of answers 4. Learning mode with geographical information 5. Multiplayer capability).Add 2 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 validation methods) 2. Function modules unrelated to geographical riddles 3. Fancy effects that affect performance (e.g., excessive animations).Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game logic/view/data layers), code organization, naming conventions, and maintainability. Check for proper commenting and documentation.Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 3 points if comments and documentation are insufficient. 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) 4) Thematic elements that reinforce the geographical nature of the game.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 4) Appropriate feedback for correct and incorrect answers.Deduct 5 points for each operation without feedback, 3 points for visual after-images during transitions, 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/ghibli-red-panda-doodle-jump-game-website.json

@@ -0,0 +1,68 @@
+{
+  "index": 329,
+  "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. Create a jumping game website featuring a red panda character (silly and cute, similar to Totoro style) with Studio Ghibli aesthetic. The background should include fantasy adventure elements. The gameplay should be similar to doodle jump.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core jumping mechanic properly implemented?",
+      "description": "Review whether the code accurately implements the Doodle Jump style physics (gravity, jumping force, continuous upward scrolling). Check for smooth vertical movement, platform collision detection, and character control responsiveness. Score 0 if the core movement mechanics are missing, 5 if basic jumping is implemented but feels unnatural, and 10 if the jumping physics perfectly matches the Doodle Jump experience with proper acceleration curves.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Does the red panda character follow the Totoro-like style specifications?",
+      "description": "Evaluate whether the red panda character has the specified 'silly and cute' aesthetic similar to Totoro style. Character should be properly animated with at least idle, jumping, and falling animations. Check whether the character has expressive features and maintains the Studio Ghibli aesthetic (rounded shapes, soft colors, charming details). Deduct 3 points if the style doesn't match Totoro/Studio Ghibli aesthetic, 3 points if animations are stiff or missing, and 3 points if the character lacks expressiveness.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the Studio Ghibli aesthetic properly implemented in the background and environment?",
+      "description": "Check whether the background includes fantasy adventure elements characteristic of Studio Ghibli works (e.g., floating islands, whimsical clouds, magical plant life, dreamy color palettes). Evaluate if parallax scrolling creates depth, if color palettes use the signature Ghibli soft pastels, and if environment elements maintain consistent artistic style. Deduct 5 points if the background lacks Ghibli aesthetic, 3 points if fantasy adventure elements are missing, and 3 points if background elements appear static without parallax effects.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the platform generation system properly implemented?",
+      "description": "Check whether the code includes a dynamic platform generation system similar to Doodle Jump, with platforms that appear as the character ascends. Evaluate platform variety (regular, moving, breakable, etc.), distribution algorithms (should avoid impossible jumps), and performance optimization (removing off-screen platforms). Score 0 if platform generation is missing, 5 if basic static platforms exist, 10 if there's a sophisticated system with multiple platform types and proper optimization.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as window resizing, touch vs. mouse controls, different device orientations, performance throttling) and provide friendly error handling. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Weather effects that influence gameplay 2. Collectible Ghibli-inspired items with special powers 3. Dynamic soundtrack that intensifies with height). 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 jumping control systems coexisting) 2. Function modules unrelated to the jumping game (e.g., a built-in calculator) 3. Fancy effects that affect performance (e.g., excessive particle systems 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/input handling), asset loading optimization, and rendering performance. 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 performs poorly on standard devices. 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 that complements the Ghibli aesthetic 2) Proper layout spacing for UI elements like score, controls, and menus 3) Professional font system that enhances the fantasy theme (appropriate character spacing, readable yet stylized fonts). Deduct 3 points for each crowded visual element, 5 points for a clashing color combination that breaks the Ghibli mood, 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) Character control response ≤ 100ms 2) Smooth animation transitions for jumping, landing, and collecting items 3) Clear visual feedback for player actions and game events. Deduct 5 points for each operation without feedback, 3 points for jerky animations during fast movements, and 5 points for inconsistent frame rates. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "hard"
+}

package/library/game_development-casual/html-dice-rolling-program.json

@@ -0,0 +1,68 @@
+{
+  "index": 1031,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional replies. Make sure the code you provide is executable for demonstration. Create a dice rolling program using HTML.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the basic dice rolling function implemented correctly?",
+      "description": "Check if the code accurately implements random dice generation using JavaScript Math.random() or similar function. The dice values should be properly generated within the range of 1-6 (or appropriate range for the specified dice). Score 0 if no random functionality exists, 5 if random generation is implemented but with potential bias or incorrect range, 10 if properly implemented with equal probability distribution.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the dice visualization properly implemented with HTML/CSS?",
+      "description": "Review whether the code visually represents dice faces using proper HTML elements (div, svg, canvas, etc.) with CSS styling. Check if the pip patterns correctly match standard dice patterns (e.g., 1 center pip for value 1, diagonal pips for value 3). Deduct 5 points if only textual representation is used, 3 points if visual dice faces exist but with incorrect patterns. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Does the program include a clear user interaction mechanism?",
+      "description": "Evaluate whether there's a clear way for users to trigger dice rolls (button, click event, etc.) with appropriate visual feedback. The interface should make it obvious how to interact with the program. Deduct 5 points if there's no clear roll button/mechanism, 3 points if the interaction is present but confusing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there an animation or visual transition for the dice roll?",
+      "description": "Check if the dice roll includes an appropriate animation effect (such as spinning, shaking, or transitioning between values) to simulate physical dice behavior. The animation should enhance the user experience and provide a sense of randomness. Deduct 5 points if no animation exists, 3 points if the animation is implemented but looks unnatural or distracting. 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 consecutive clicks, browser compatibility issues, or unexpected user interactions) and provide friendly error handling. Code with strong robustness should work consistently across different scenarios, giving 10 points. If the robustness is average, give 5 points, and if no error handling exists, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Sound effects for rolls 2. History of previous rolls 3. Multiple dice options 4. Custom dice faces or themes). 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) 2. Function modules unrelated to dice rolling (e.g., unnecessary animations or features) 3. Fancy effects that affect performance (e.g., excessive particles or 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 code organization (such as separating logic/view layers), code readability, and proper use of HTML/JavaScript/CSS best practices. Deduct 5 points if global namespace pollution is found; deduct 5 points if there's significant code duplication; deduct 5 points if the code lacks comments or uses poor naming 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 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 dice rolls, and 5 points for hard-to-find roll button or controls. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "easy"
+}

package/library/game_development-casual/html-javascript-catch-collect-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 56,
+  "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.\n\nPlease use HTML and JavaScript to implement a Catch and Collect game.\n**Task**: Implement a capture system where players can catch certain objects or creatures in the game and collect them.\n**Hint**: You can capture objects by throwing nets or using specific tools, then add them to the player's collection.\n[CHAT_SEP]Please optimize the above game response, and add comments to your code so other developers can understand your implementation process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core capture system fully implemented?",
+      "description": "Review whether the code implements a complete capture system with mechanics for targeting, throwing/using capture tools, and determining success/failure rates. Check if capturing objects involves skill elements (like timing, aim, or resource management) rather than just simple clicks. Score 0 if no capture mechanics exist, 5 if basic clicking to capture is implemented, and 10 if the system includes varied capture tools with different properties and success calculations.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the collection management system properly designed?",
+      "description": "Evaluate whether the code implements a functional collection system for storing and managing captured objects. Check for features like categorization, sorting options, viewing collection details, and persistent storage of collected items. Deduct 5 points if there's no storage persistence, and 3 points if the collection lacks organization features. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are there varied and interesting objects to collect?",
+      "description": "Assess the diversity and implementation of collectible objects in the game. Check if objects have unique properties, visual representations, and capture difficulty levels. Score 0 if there's only one type of collectible, 5 if there are multiple but with minimal differentiation, and 10 if there's a rich variety of collectibles with different behaviors, appearance, rarity levels, and capture requirements.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the game progression system implemented?",
+      "description": "Check whether the game includes progression mechanics that reward collection and provide increasing challenges. Look for features like unlockable capture tools, achievements for collection milestones, increasing difficulty, or collection-based goals. Deduct 5 points if there's no sense of progression, and 3 points if progression is too linear or predictable. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid clicking, unexpected input sequences, window resizing, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Evolving collectibles based on play patterns 2. Environmental factors affecting capture rates 3. Mini-games for improving capture 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 implementation of similar functions (e.g., multiple overlapping capturing mechanisms) 2. Function modules unrelated to capture/collection gameplay (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive particle effects 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/collection system), code comments quality, 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 comments are missing or unhelpful. 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 feedback for successful/failed captures. Deduct 5 points for each operation without feedback, 3 points for choppy animations during capture attempts, and 5 points for unclear game state indicators. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "medium"
+}

package/library/game_development-casual/html-javascript-friend-system-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 30,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Pay attention to ensure that the generated code is executable.\n\nPlease use HTML and JavaScript to implement a friend system.\n\n**Task**: Implement a friend system where players can add friends and play games or battle with them.\n\n**Hint**: Set up a friend list and invitation functionality, allowing players to add friends through usernames or IDs.\nGame, and include some comments in the code so that other developers can understand your implementation process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the friend list system fully implemented?",
+      "description": "Check whether the code implements a complete friend list system with data structure design (user profiles with unique IDs), CRUD operations (add, remove, update, search friends), and proper state management. Score 0 if the friend list is not implemented, 5 if only basic display is implemented, and 10 if all features including categorization, online status indicators, and search functionality are included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the friend invitation functionality properly implemented?",
+      "description": "Evaluate whether the code includes a complete invitation system with sending invitations, accepting/rejecting mechanisms, notification handling, and validation checks (preventing duplicate invitations, handling expired invitations). Deduct 5 points if there's no confirmation flow, and 3 points if no notification system exists. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the user authentication and identification system implemented?",
+      "description": "Check whether the code implements user authentication (login/registration), unique identification (username/ID system), and proper session management. Assess if there are security measures for friend requests and profile visibility settings. Deduct 5 points if authentication is missing, 3 points if there's no session persistence. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the game/battle invitation system properly implemented?",
+      "description": "Evaluate whether the code handles game/battle invitations between friends, including invitation sending, acceptance/rejection flows, and game session creation. Check if there's proper state handling for ongoing games, matchmaking logic, and multiplayer session management. Deduct 5 points if the invitation flow is incomplete, 3 points if there's no game state management. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid inputs, network failures, friend request spam, 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. Real-time friend activity feed 2. Friend recommendations based on gaming preferences 3. Integrated chat system). 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 friend-finding mechanisms) 2. Function modules unrelated to the friend system (e.g., unnecessary game features) 3. Fancy effects that affect performance (e.g., excessive animations in the friend list). 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), code organization, documentation quality (especially the requested comments for other developers), 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 comments are insufficient or unclear. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern 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 scrolling of friend lists, and 5 points for hard-to-find key function buttons (like add friend or send invitation). The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "medium"
+}