@getollie/cli 0.0.1

package/library/game_development-adventure/harry-potter-chamber-of-secrets-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1440,
+  "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. Following the method you just provided, please give the complete code, including HTML, JS, and CSS. Also, enrich the game plot based on \"Harry Potter and the Chamber of Secrets\" to create multiple endings.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the game plot based on 'Harry Potter and the Chamber of Secrets' properly implemented?",
+      "description": "Evaluate whether the code successfully integrates storytelling elements from 'Harry Potter and the Chamber of Secrets' with multiple branching narratives leading to different endings. Check if key plot points (Basilisk, Tom Riddle's diary, etc.) are present. Score 0 if the Harry Potter theme is merely cosmetic, 5 if basic plot elements exist but without meaningful choices, and 10 if multiple coherent endings are implemented that reflect player decisions throughout the game.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are multiple endings properly implemented with different gameplay paths?",
+      "description": "Review whether the game provides genuinely different endings based on player choices rather than superficial text changes. Examine the code for branching logic structures, state tracking variables, and distinct story outcomes. Deduct 5 points if fewer than 3 meaningful endings exist, 3 points if the endings don't significantly differ in narrative consequences. The full score is 10 points if the game includes at least 4 distinct endings with appropriate build-up through gameplay.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the game state management system comprehensive?",
+      "description": "Check whether the code implements a robust state management system that tracks player progress, choices, inventory items, and storyline variables. The system should allow for saving/loading game state and persistently track critical narrative decisions. Deduct 5 points if state is tracked using only global variables without proper encapsulation, 3 points if there's no save/load functionality, and 3 points if the game state can easily become inconsistent. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the user interface thematically consistent with Harry Potter?",
+      "description": "Evaluate whether the UI elements (buttons, backgrounds, fonts, etc.) match the aesthetic of the wizarding world. Check for appropriate typography (gothic or serif fonts), color schemes (Hogwarts house colors), and thematic imagery (wands, magical elements). Deduct 5 points for generic UI with no Harry Potter theming, 3 points for inconsistent theming, and 2 points for overuse of copyrighted imagery. Full score is 10 points for an immersive, cohesive Harry Potter experience.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid inputs, browser compatibility issues, unexpected user behaviors) 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. Ambient magical sound effects that change with narrative 2. Wand-casting mechanics using mouse gestures 3. Interactive magical items with physics). 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 text display methods coexisting) 2. Function modules unrelated to the Harry Potter theme or storytelling (e.g., unnecessary mini-games) 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 narrative 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/story content layers), maintainability of narrative branching, and code organization. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the story content is hardcoded throughout the JavaScript rather than stored in structured data. 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 scene transitions, and 5 points for hard-to-find key narrative choices or interaction elements. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Adventure",
+  "difficulty": "easy"
+}

package/library/game_development-adventure/html-javascript-level-switching-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 44,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable whenever possible.\nPlease implement a level switching game using HTML and JavaScript, where the character can enter the next level when reaching a certain position.\nInclude comments in your code to help other developers understand your implementation process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core game movement system fully implemented?",
+      "description": "Review whether the code implements a complete character movement system with keyboard controls (WASD/arrow keys), collision detection, and proper physics (if applicable). Score 0 if movement is not implemented, 5 if only basic movement is present, and 10 if the movement includes acceleration/deceleration, proper collision handling, and feels responsive.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the level switching mechanism properly implemented?",
+      "description": "Check if the code includes a functional level transition system when the character reaches designated positions. Verify that level boundaries or exit points are clearly defined, the transition is triggered correctly, and the game state is properly preserved/reset between levels. Deduct 5 points if transitions are abrupt with no visual feedback, and 3 points if there are issues with game state persistence between levels.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are multiple game levels designed and implemented?",
+      "description": "Evaluate if the code includes at least 2-3 distinct levels with increasing difficulty or complexity. Each level should have unique layouts, obstacles, or objectives. Score 0 if only one level exists, 5 if multiple levels exist but are too similar, and 10 if levels show thoughtful progression in challenge and design.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the code well-commented with clear explanations?",
+      "description": "Assess if the code includes comprehensive comments explaining the implementation process, important functions, and game mechanics. Comments should cover architectural decisions, not just obvious code operations. Deduct 5 points if only basic/sparse comments exist, and give 0 points if crucial parts of the code remain unexplained.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid keypress combinations, rapid key presses, browser resizing, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should 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. Progressive difficulty adjustment 2. Character customization options 3. Interactive environmental elements 4. Scoring/achievement 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 movement control systems) 2. Function modules unrelated to level-based gameplay 3. Fancy effects that affect performance without adding to 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 reusability for level creation, and organization of assets. 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 game architecture makes adding new levels difficult. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the game UI follows modern design principles: 1) Consistent visual theme 2) Clear player character and level exit visibility 3) Proper contrast between gameplay elements and background 4) Appropriate feedback for player actions. Deduct 3 points for poor visual hierarchy, 5 points for confusing game elements, and 5 points for unclear objectives. 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 human perception characteristics: 1) Immediate response to player input (≤ 100ms) 2) Smooth animations for character movement and level transitions 3) Clear visual/audio feedback for significant events. Deduct 5 points for input lag, 3 points for choppy animations, and 5 points for confusing or missing feedback. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Adventure",
+  "difficulty": "easy"
+}

package/library/game_development-adventure/html-javascript-webvr-game-implementation.json

@@ -0,0 +1,68 @@
+{
+  "index": 114,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Please ensure the generated code is executable when possible.\n\nPlease use HTML and JavaScript to implement a Virtual Reality\n\n**Task**: Implement a simple virtual reality game that players can engage with through VR devices, providing an immersive experience.\n\n**Tip**: Use the WebVR API to implement VR support, and design game content suitable for VR.\n\ngame, and include comments in your code to help other developers understand your implementation process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "WebVR/WebXR API Implementation",
+      "description": "Check whether the code correctly implements WebVR/WebXR API to support VR devices, including proper device detection, session establishment, and viewport rendering. The implementation should handle different VR headsets (Oculus, HTC Vive, etc.) and gracefully degrade when VR is not available.0 points if WebVR/WebXR API is not implemented at all, 5 points if basic implementation exists but lacks device compatibility, 10 points for complete implementation with proper device detection, session management, and fallback mechanisms.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "3D Environment and Scene Setup",
+      "description": "Evaluate the quality of the 3D environment setup using WebGL/Three.js/A-Frame. Check if the scene includes proper lighting, textures, skybox, and optimized 3D models with appropriate polygon counts for VR performance. Assess scene composition and spatial design for immersive quality.Deduct 3 points if the scene lacks depth or spatial awareness elements, 3 points if lighting is poorly implemented, 2 points if textures are low quality or missing. Full score for a complete, optimized 3D environment with proper VR spatial considerations.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "VR Interaction and Controls Implementation",
+      "description": "Check for implementation of VR-specific interaction methods: gaze-based selection, controller tracking, hand tracking, or gesture recognition. Verify that interactions feel natural in VR space with proper ray-casting for selection and manipulation of objects.0 points if no VR-specific interactions are implemented, 5 points for basic gaze or controller interactions, 10 points for comprehensive interaction system with multiple input methods and intuitive spatial feedback.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Game Mechanics and VR Experience Design",
+      "description": "Assess the game mechanics' suitability for VR: whether they leverage the unique aspects of VR (spatial awareness, presence, immersion) and avoid common VR pitfalls (motion sickness, disorientation). Check if the game provides clear objectives, feedback loops, and progression suitable for VR interaction.Deduct 5 points if game mechanics cause potential motion sickness, 3 points if spatial presence isn't leveraged, 5 points if core gameplay isn't adapted for VR's unique capabilities. Full score for VR-native gameplay that creates genuine immersion.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Code Robustness",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as VR device disconnection, browser compatibility issues, performance degradation) 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": "Innovative Features",
+      "description": "Check whether the code includes surprise features that enhance the VR experience (e.g., 1. Physics-based interactions 2. Spatial audio implementation 3. Multiplayer VR capability 4. Dynamic environment responses to user presence).Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Redundant Features",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions 2. Function modules unrelated to the core VR experience 3. Fancy effects that affect VR performance and might cause discomfort.Deduct 3 points for each redundancy found, and directly deduct 10 points if the core VR functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Engineering Quality",
+      "description": "Review modular design (separation of VR logic/rendering/game mechanics), performance optimization for VR (maintaining 90fps minimum), 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 no performance optimization techniques for VR are implemented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "User Interface in VR Space",
+      "description": "Evaluate whether UI elements follow VR best practices: 1) Depth-appropriate placement (0.5-3m from user) 2) Proper text size and legibility (minimum 1° visual angle) 3) Intuitive spatial arrangement 4) Non-intrusive HUD elements if present.Deduct 3 points for each UI element positioned too close/far or causing eye strain, 5 points for illegible text in VR, 5 points for UI elements that break immersion unnecessarily. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Performance and Comfort Optimization",
+      "description": "Judge whether the implementation prioritizes VR comfort and performance: 1) Consistent 90fps+ framerate 2) Proper locomotion methods to prevent motion sickness 3) Comfortable visual design (proper contrast, no flickering) 4) Balanced polygon count and texture resolution.Deduct 5 points for each implementation that could cause discomfort (jerky movements, strobing effects), 3 points for frame drops below 90fps, 5 points for lack of comfort options (teleportation, vignetting during movement). The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Adventure",
+  "difficulty": "hard"
+}

package/library/game_development-adventure/knight-77-rescues-prince-cloud-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1595,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable. Create a web mini-game with a story progression where the protagonist Knight 77 rescues Prince Cloud. The journey starts in England, passes through Thailand, and finally reaches Beijing to rescue Prince Cloud, with an iPhone 16 Pro as the final reward.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the story progression system fully implemented?",
+      "description": "Review whether the code accurately implements a three-stage story progression (England → Thailand → Beijing) with clear narrative transitions, character dialogue systems, and quest objectives for Knight 77's rescue mission. Check if each location has unique story elements, environmental descriptions, and progression triggers. Score 0 if no story structure exists, 5 if only basic location transitions are implemented, and 10 if complete narrative flow with dialogue, objectives, and story coherence is fully developed.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the game mechanics and player interactions properly designed?",
+      "description": "Evaluate whether the mini-game includes engaging gameplay mechanics such as puzzle-solving, combat systems, inventory management, or skill challenges appropriate for a rescue adventure. Check for player input handling, character movement controls, and interactive elements within each geographic location. Deduct 5 points if core gameplay mechanics are missing, 3 points if player controls are unresponsive or unclear. Full score requires intuitive and engaging game mechanics that support the rescue narrative.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the multi-location world design and progression system well-structured?",
+      "description": "Assess whether each location (England, Thailand, Beijing) has distinct visual themes, unique challenges, and appropriate cultural elements. Check if the progression system includes unlock mechanisms, save/load functionality, and clear advancement criteria between locations. Deduct 5 points if locations lack distinctiveness, 3 points if progression feels arbitrary or unclear. Require location-specific assets, challenges, and seamless transitions between stages.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the reward system and game completion mechanism properly implemented?",
+      "description": "Review whether the game includes a comprehensive reward system leading to the iPhone 16 Pro finale, with intermediate rewards, achievement tracking, and satisfying completion sequences. Check if Prince Cloud rescue sequence is properly scripted with appropriate celebration/completion animations. Deduct 5 points if reward system is incomplete, 3 points if final sequence lacks polish. Full score requires engaging reward progression and memorable completion experience.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid game states, save/load errors, asset loading failures, user input edge cases, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should effectively handle game state corruption, browser compatibility issues, and graceful degradation. Give 10 points if fully robust, 5 points if average robustness, 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 gaming experience (e.g., 1. Mini-map navigation system 2. Cultural Easter eggs in each location 3. Dynamic weather/time effects 4. Achievement badge system 5. Sound effects and background music). Add 3 points for each practical innovative feature implemented that adds genuine value to the gameplay experience (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 save systems coexisting) 2. Function modules unrelated to the rescue adventure theme (e.g., unrelated mini-games) 3. Excessive animations that impact performance (e.g., overuse of particle effects). Deduct 3 points for each redundancy found, and directly deduct 10 points if core game flow is 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/rendering/audio/state management layers), code organization, and maintainability. Deduct 5 points if global state pollution is found or proper architectural patterns aren't used; deduct 5 points if code duplication rate is too high (over 30%); deduct 5 points if assets aren't properly organized or optimized. Full score requires clean, modular, and maintainable code structure.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the game UI follows modern design principles: 1) Harmonious color palette reflecting each location's theme 2) Consistent UI element spacing and sizing 3) Readable typography with appropriate contrast 4) Cultural authenticity in visual representation of England/Thailand/Beijing. Deduct 3 points for each visually cluttered interface element, 5 points for poor color harmony that strains eyes, and 5 points for inconsistent or unprofessional visual styling. Full score requires polished, themed visual design.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the game interactions conform to user expectations: 1) Button/click feedback delay ≤ 100ms 2) Scene transition animations smooth and appropriately timed (300-500ms) 3) Clear visual feedback for all interactive elements 4) Smooth character movement and animation. Deduct 5 points for each unresponsive interaction, 3 points for jerky animations or transitions, and 5 points for unclear interactive affordances. Full score requires fluid, responsive, and intuitive interaction design.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Adventure",
+  "difficulty": "medium"
+}

package/library/game_development-adventure/narrative-game-song-dynasty-time-travel-cat.json

@@ -0,0 +1,68 @@
+{
+  "index": 723,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure that the code you generate is executable for demonstration. Based on my design content, help me write a simple narrative game framework with a simple story. Since it will be presented through 3D web interaction, the game's interactive content includes the \"Four Elegances of the Song Dynasty\" (tea preparation, incense burning, flower arranging, and hanging paintings). These involve simple interactions. Please help me think about how to incorporate \"time travel\" into the painting. I've also designed an NPC cat.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the narrative game framework properly structured?",
+      "description": "Review whether the code establishes a complete narrative game framework with clear separation of story content, game state management, and player interaction handling. Check if the framework includes scene transitions, dialogue systems, and save/load functionality. Score 0 if the framework is missing, 5 if it's basic but functional, and 10 if it's comprehensive with proper encapsulation and extensibility.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the 'Four Elegances of the Song Dynasty' interactions fully implemented?",
+      "description": "Evaluate the implementation of all four activities (tea preparation, incense burning, flower arranging, and hanging paintings). Each activity should have unique interaction mechanics, clear success/failure states, and visual feedback. Deduct 2.5 points for each elegance that's missing or poorly implemented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the 'time travel' mechanic effectively integrated with the painting interaction?",
+      "description": "Assess whether the code implements a creative and functional time travel mechanic connected to the painting element. Check if it includes proper state management for different time periods, visual transitions between eras, and maintains narrative consistency. Score 0 if time travel is absent, 5 if it's basic, and 10 if it's well-integrated with both gameplay and storytelling.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the NPC cat properly implemented with meaningful interaction?",
+      "description": "Review the implementation of the NPC cat character. The cat should have a defined personality, dialogue system, animation states, and meaningful interactions with the player (e.g., providing hints, advancing the story). Deduct 5 points if the cat is static with minimal interaction, and 3 points if the cat lacks connection to the main narrative. 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 incorrect user inputs, resource loading failures, state inconsistencies) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Dynamic environmental responses to player actions 2. Procedurally generated story variations 3. Accessibility options for different player needs). 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 dialogue systems coexisting) 2. Function modules unrelated to the core narrative experience (e.g., an unnecessary mini-game) 3. Fancy effects that affect performance (e.g., excessive particle systems). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating story logic/view/interaction layers), component reusability, and code organization. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no clear architecture for extending the game. 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 evokes Song Dynasty aesthetics 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system appropriate for a narrative game (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for anachronistic visual styling, 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) Elegance interactions feel natural and responsive (≤ 100ms) 2) Transition animations between scenes/time periods controlled between 300-500ms 3) Clear visual guidance for interactive elements. Deduct 5 points for each interactive element without feedback, 3 points for jarring transitions between story segments, and 5 points for confusing navigation in the 3D environment. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Adventure",
+  "difficulty": "hard"
+}

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

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

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

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

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

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