@getollie/cli 0.0.1

package/library/game_development-action_rhythm/super-mario-game-javascript.json

@@ -0,0 +1,68 @@
+{
+  "index": 401,
+  "question": "You are a coding expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable when possible. Write a Super Mario game using JavaScript.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core Mario character movement system properly implemented?",
+      "description": "Review whether the code correctly implements Mario's movement mechanics including running, jumping, crouching, and acceleration/deceleration physics. Check if the jump height varies based on button press duration and if momentum is preserved during movement. Score 0 if basic movement is missing, 5 if only simple movement exists without physics, and 10 if the movement feels authentic to the original game with proper physics implementation.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the game world and level design functionality complete?",
+      "description": "Evaluate if the code includes a proper level design system with blocks, pipes, coins, and other classic Mario elements. Check if the camera follows Mario correctly with appropriate scrolling mechanics. The implementation should include collision detection for all objects and proper level boundaries. Deduct 5 points if the world is static without scrolling, 3 points if collision detection is inconsistent, and 2 points if essential Mario world elements are missing.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the enemy system with proper AI implemented?",
+      "description": "Check if the game includes classic enemies (Goombas, Koopas, etc.) with appropriate AI behaviors. Enemies should move according to their patterns, respond to player actions, and have proper collision mechanics (e.g., stomping on Goombas, kicking Koopa shells). Deduct 5 points if enemies have no AI logic, 3 points if collision with enemies is buggy, and 2 points if fewer than three enemy types are implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are the power-up and progression systems implemented?",
+      "description": "Review if the code includes classic power-ups (Mushrooms, Fire Flowers, Stars) with appropriate transformation effects and abilities. Check if Mario can change states (small, big, fire) and if the scoring system tracks coins, points, and lives correctly. Score 0 if no power-ups exist, 5 if only size changes are implemented, and 10 if multiple power-ups with appropriate abilities are fully functional.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid input changes, boundary conditions, game state transitions) and provide friendly error handling or recovery mechanisms. Code with strong robustness should prevent game-breaking bugs and handle edge cases such as falling through platforms or getting stuck in walls. Give 10 points if fully robust, 5 points if average, and 0 points if no exception handling exists.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Level editor functionality 2. Modern visual effects while maintaining retro feel 3. Additional power-ups beyond the original game). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple jump mechanics competing) 2. Function modules unrelated to Mario gameplay (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive particle effects causing lag). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game engine/rendering/input handling), organization of sprite sheets, and performance optimization. Deduct 5 points if global state is overused; deduct 5 points if the rendering approach causes performance issues on standard hardware; deduct 5 points if the code lacks comments or has poor variable naming. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the visual design properly captures the classic Mario aesthetic while providing modern UI conveniences: 1) Faithful reproduction of the original pixel art style 2) Proper HUD layout showing lives, coins, score, and time 3) Responsive design that works across different screen sizes. Deduct 3 points for inconsistent pixel art, 5 points for an obtrusive or poorly positioned HUD, and 5 points for screen scaling issues. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the game runs at a consistent frame rate (target 60 FPS) with smooth animations: 1) Responsive controls with minimal input lag (≤50ms) 2) Consistent collision detection without visual glitches 3) Smooth animations for all game elements including Mario, enemies, and effects. Deduct 5 points for noticeable frame drops during normal gameplay, 3 points for inconsistent animation speeds, and 5 points for input lag that affects gameplay. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Action/Rhythm",
+  "difficulty": "hard"
+}

package/library/game_development-action_rhythm/super-mario-like-game-javascript.json

@@ -0,0 +1,68 @@
+{
+  "index": 1795,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you provide is executable and ready for demonstration. Write a Super Mario-like game using JavaScript.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core game mechanics fully implemented?",
+      "description": "Review whether the code accurately implements Mario's movement system (left/right movement, jumping with gravity physics), collision detection with platforms and enemies, power-up collection mechanics, and level progression. Score 0 if basic movement is not implemented, 5 if only simple movement without collision detection, and 10 if all core mechanics including enemy interactions, power-ups, and level completion are fully functional.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the game physics engine properly implemented?",
+      "description": "Check whether the physics system includes realistic gravity simulation, momentum conservation during jumps, proper collision response, and smooth character acceleration/deceleration. Evaluate if the jump mechanics feel responsive and natural. Deduct 5 points if gravity calculations are incorrect, 3 points if collision detection has noticeable lag or glitches. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the game entities and level design comprehensively constructed?",
+      "description": "Evaluate whether the game includes multiple enemy types with distinct behaviors, interactive objects (coins, power-ups, blocks), scrolling background system, and at least one complete playable level. Check if enemies have proper AI patterns and if level elements are positioned logically. Deduct 5 points if enemies lack behavioral patterns, 3 points if level scrolling is jerky or incomplete. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the complete game state management system implemented?",
+      "description": "Check whether the code includes comprehensive game state management covering start screen, gameplay, pause/resume functionality, game over conditions, score tracking, and lives system. Evaluate if transitions between states are smooth and logical. Deduct 5 points if pause/resume is not implemented, 3 points if score system is missing or non-functional. Give 10 points if fully implemented with proper state transitions.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as boundary collisions, rapid key presses, browser compatibility issues, performance drops on slower devices) and provide appropriate fallbacks or error handling. Code with strong robustness should gracefully handle edge cases and maintain stable frame rates. Give 10 points for excellent robustness, 5 points if average, 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 enhanced features that elevate the gaming experience (e.g., 1. Particle effects for power-ups 2. Dynamic background music and sound effects 3. Multiple playable characters 4. Level editor functionality 5. Local high score system). Add 3 points for each well-implemented innovative feature (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple collision detection systems) 2. Function modules unrelated to platformer gameplay (e.g., built-in chat system) 3. Excessive visual effects that impact performance (e.g., complex shader effects inappropriate for pixel art style). Deduct 3 points for each redundancy found, and directly deduct 10 points if core gameplay is hindered by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (separating game engine, entities, input handling, and rendering layers), code organization with clear separation of concerns, and maintainable architecture. Deduct 5 points if global variables are overused or if there's no clear architectural pattern; deduct 5 points if code duplication rate exceeds 30%; deduct 5 points if the codebase lacks proper documentation or comments. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the visual design follows classic platformer aesthetics: 1) Consistent pixel art style or coherent art direction 2) Readable UI elements with appropriate contrast 3) Smooth sprite animations with proper frame timing 4) Clear visual hierarchy for game elements. Deduct 3 points for inconsistent art styles, 5 points for poor readability of UI text, and 5 points for choppy or missing character animations. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the game controls and animations provide excellent user experience: 1) Input response time ≤ 50ms for platform games 2) Consistent 60fps performance during gameplay 3) Smooth character animations with proper easing 4) Clear visual feedback for all player actions. Deduct 5 points for noticeable input lag, 3 points for frame drops during normal gameplay, and 5 points for unclear or missing animation transitions. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Action/Rhythm",
+  "difficulty": "medium"
+}

package/library/game_development-action_rhythm/super-mario-like-mobile-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1604,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and expert responses. Make sure the generated code is executable for demonstration purposes. Write code for a Super Mario-like game that I can run on my mobile device.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the game's physics system fully implemented?",
+      "description": "Review whether the code accurately implements Super Mario-style physics including gravity effects, character movement, jump mechanics, and collision detection. Score 0 if the core physics logic is not implemented, 5 if basic movement and jumping are implemented but lack polish, and 10 if the game features accurate momentum, variable jump heights based on button press duration, and proper collision handling including platform interactions.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the core gameplay mechanics present and functional?",
+      "description": "Check whether essential Super Mario mechanics are implemented, including enemy interactions (stomping, side collisions), power-ups (mushroom for growth, etc.), collectibles (coins), and level completion conditions. Deduct 3 points if enemy interaction is missing, 3 points if power-ups are not implemented, 2 points if collectibles don't work properly, and 2 points if level completion logic is absent. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is mobile-specific optimization and responsive design implemented?",
+      "description": "Evaluate whether the game properly adapts to different mobile screen sizes, implements touch controls effectively (virtual d-pad, gesture controls, etc.), and handles device orientation changes. Additionally, check for mobile performance optimizations like asset loading strategies and battery consumption considerations. Deduct 4 points for non-responsive design, 3 points for poor touch controls, and 3 points for missing mobile-specific optimizations. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the level design system flexible and functional?",
+      "description": "Assess whether the code includes a tile-based or similar level system that allows for creating Super Mario-style environments with platforms, pipes, blocks, and obstacles. Check if the level rendering is optimized (only rendering visible elements) and if the camera system follows the player appropriately. Deduct 4 points if the level system is hard-coded without flexibility, 3 points if camera movement is jerky or problematic, and 3 points if performance issues occur with larger levels. 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 touch inputs, device rotation, background/foreground app transitions, memory constraints, and varying network conditions) 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. Custom character skins 2. Level editor functionality 3. Special power-ups beyond the original game 4. Social sharing of gameplay achievements). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple physics engines running simultaneously) 2. Function modules unrelated to the core Mario gameplay (e.g., a built-in chat system) 3. Fancy effects that affect mobile 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 management approach, and code reusability. 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 assets aren't properly managed for mobile optimization. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional game design standards?",
+      "description": "Evaluate whether the overall design follows modern mobile game design principles: 1) Visually distinct game elements with clear silhouettes 2) Appropriate visual hierarchy highlighting interactive elements 3) Unobtrusive UI that doesn't block gameplay 4) Proper touch target sizes (minimum 44×44 points). Deduct 3 points for each cluttered visual area, 5 points for poor contrast/readability, and 5 points for UI elements that obstruct crucial gameplay areas. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and responsive?",
+      "description": "Judge whether the game responds appropriately to player input: 1) Input response delay ≤ 50ms 2) Consistent frame rate (minimum 30 FPS) 3) Appropriate feedback for all player actions (visual/audio cues). Deduct 5 points if input lag exceeds 100ms, 3 points if frame drops occur during normal gameplay, and 5 points if essential feedback is missing for critical actions (jumping, taking damage, etc.). The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Action/Rhythm",
+  "difficulty": "hard"
+}

package/library/game_development-action_rhythm/super-mario-mini-game-web-browser.json

@@ -0,0 +1,68 @@
+{
+  "index": 1606,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you provide is executable for demonstration. Help me create a Super Mario mini-game that can be played in a web browser.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core Mario gameplay mechanics fully implemented?",
+      "description": "Review whether the code accurately implements essential Mario mechanics: character movement (left/right), jumping physics with gravity, collision detection (platforms, obstacles, enemies), and power-up systems (mushrooms, fire flowers). Score 0 if core mechanics are missing, 5 if only basic movement and jumping are implemented, and 10 if all classic Mario mechanics are present.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the enemy AI and interaction system implemented?",
+      "description": "Check if enemies (Goombas, Koopas, etc.) have proper movement patterns, collision detection with Mario, and appropriate behaviors when stomped or hit. Evaluate whether enemies respond differently based on Mario's state (small, big, fire). Deduct 3 points if enemies move but don't interact, 5 points if enemy variety is limited to one type, and 5 points if death/respawn mechanics are missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is level design and progression properly implemented?",
+      "description": "Evaluate whether the game includes scrollable levels with varied terrain, obstacles, and collectibles. Check if the implementation includes pipes, blocks (breakable and question), coins, and end-level flags/castles. Score 10 if the level design is comprehensive with multiple stages or progressive difficulty, 5 if there's only a single basic level, and 0 if there's just a flat surface with minimal objects.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the scoring and game state management complete?",
+      "description": "Review the implementation of score tracking, lives system, time countdown, and game state transitions (start screen, gameplay, game over, level complete). Check if player progress is maintained between levels and if there's a proper restart mechanism. Deduct 3 points for each missing component (score, lives, timer, game states). 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 input sequences, browser resizing, performance degradation on slower devices) and provide graceful fallbacks. Code with strong robustness should prevent game-breaking bugs like falling through platforms or getting stuck in walls. Give 10 points for comprehensive error handling, 5 points for average robustness, and 0 points if the game breaks easily.",
+      "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. Level editor functionality 2. Custom character skins 3. Mobile-friendly touch controls 4. Local multiplayer option). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple jump mechanics coexisting) 2. Function modules unrelated to Mario gameplay (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/rendering/input handling), asset management efficiency, and optimization techniques. 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 optimization for sprite rendering or collision detection. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the visual design maintains faithfulness to the classic Mario aesthetic while implementing modern UI principles: 1) Pixel-perfect sprite rendering 2) Proper aspect ratio and scaling for different screen sizes 3) Clean, unobtrusive HUD design displaying score, lives and time. Deduct 3 points for blurry sprites, 5 points for inconsistent art style, and 5 points for poorly positioned UI elements that obscure gameplay. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the game animations and controls feel responsive and accurate: 1) Input response delay ≤ 50ms 2) Consistent frame rate (minimum 30 FPS) 3) Smooth transitions between animations (walking, jumping, power-ups). Deduct 5 points for input lag, 3 points for jerky scrolling or character movement, and 5 points for frame rate drops during normal gameplay. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Action/Rhythm",
+  "difficulty": "hard"
+}

package/library/game_development-action_rhythm/super-mario-style-game-introduction.json

@@ -0,0 +1,68 @@
+{
+  "index": 22,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Make sure any code you provide is executable.\n\nPlease use HTML and JavaScript to implement a **\"Super Mario Style Game\" game introduction**\n\n**Game Introduction:**\nThis game is a classic side-scrolling platform action game inspired by the \"Super Mario\" series, known for its simple controls and adventure-filled game world. Players will take on the role of a brave adventurer, exploring colorful levels by jumping, stomping on enemies, and collecting items, while facing various challenges and enemies.\n\n**Game Features:**\n1. **Classic Platform Action**: Based on side-scrolling mechanics, players can control their character to progress through various levels using simple jump and attack operations.\n\n2. **Diverse Level Design**: The game features multiple levels with different themes and difficulties. Each level is filled with unique obstacles, enemies, and puzzles that require players to skillfully use their abilities and strategies to complete.\n\n**Gameplay:**\nPlayers need to control their character to jump over obstacles, defeat enemies with attacks, and collect treasures and secret items during exploration. Each level has different objectives and challenges.\n\n**Game Tips:**\n- **Precise Jumping and Attacking**: Learn to control the character's jumping height to avoid traps and defeat enemies.\n\n- **Observation and Planning**: Before starting each level, observe the map layout and enemy distribution to develop adaptive strategies and plan your path.\n\nThis game not only preserves the classic elements and challenges of the \"Super Mario\" series but also brings players new adventure experiences and fun. Whether you're looking to revisit the classics or seeking a fresh experience, you'll find satisfaction in this game. Include some comments in your code to help other developers understand your implementation process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Super Mario game introduction interface fully implemented?",
+      "description": "Review whether the HTML/JavaScript code creates a visually appealing and informative game introduction page that effectively showcases the Super Mario style game. Check for sections that present game features, gameplay mechanics, and tips as specified in the requirements. Score 0 if the introduction is missing key elements, 5 if basic information is presented in a plain format, and 10 if the introduction is comprehensive with proper styling and organization.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the classic Super Mario visual elements incorporated?",
+      "description": "Evaluate whether the introduction includes iconic Super Mario style visual elements (e.g., character sprites, blocks, coins, pipes, enemies). Check if these elements are properly rendered and positioned. Deduct 3 points if key visual elements are missing, 2 points if they lack animation or interactivity, and 2 points if the style doesn't match the classic Super Mario aesthetic. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there a dynamic demonstration of gameplay mechanics?",
+      "description": "Assess whether the introduction includes interactive demonstrations or animations showing core gameplay elements (jumping, attacking enemies, collecting items). Review if the demonstrations accurately represent the described mechanics. Deduct 5 points if no gameplay demonstrations are provided, and 3 points if the demonstrations are static or don't clearly explain the mechanics. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is level diversity and game progression illustrated?",
+      "description": "Check if the introduction showcases different level themes and progression mechanics as specified in the requirements. Evaluate whether the visual representation gives players a clear idea of the game's scope and variety. Deduct 5 points if level diversity isn't shown, 3 points if progression mechanics aren't explained, and 2 points if the visual representation is too abstract or unclear. 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 image loading failures, browser compatibility issues, window resizing, etc.) and provide fallbacks 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 introduction includes surprise features that enhance the experience (e.g., 1. Interactive character demonstrations 2. Sound effects when hovering over game elements 3. Mini-playable demo section). 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 animation systems) 2. Function modules unrelated to the game introduction (e.g., full game implementation instead of just the introduction) 3. Fancy effects that affect performance (e.g., excessive particle effects or animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core information presentation is interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating content/presentation/interaction layers), code organization, and maintainability. Deduct 5 points if global variable pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the code lacks comments as specified in the requirements. 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 (using the classic Mario color palette appropriately) 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 interaction without feedback, 3 points for visual after-images during animations, and 5 points for hard-to-find key information. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Action/Rhythm",
+  "difficulty": "medium"
+}

package/library/game_development-action_rhythm/super-mario-web-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1461,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you provide is executable for demonstration purposes. Help me write a Super Mario code that I can run on a web page.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core Mario character movement system implemented?",
+      "description": "Review whether the code accurately implements Mario's movement physics including running, jumping, and momentum. Check for collision detection with platforms, enemies, and items. Score 0 if core movement is missing, 5 if basic movement exists but lacks physics accuracy, and 10 if the movement feels authentic to the original game.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the essential game mechanics fully implemented?",
+      "description": "Evaluate implementation of core Super Mario mechanics: power-ups (mushroom, fire flower), enemy interactions, coin collection, block breaking, and level completion conditions. Deduct 3 points if power-ups are missing, 3 points if enemy interactions are incomplete, and 2 points if coin/scoring system is absent. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is a complete, playable level constructed?",
+      "description": "Check whether the code creates at least one complete, playable level with start and end points, appropriate enemy placement, platforms, and collectibles. Score 0 if there's only a test environment, 5 if there's a basic but incomplete level, and 10 if there's a well-designed, balanced level that captures the Super Mario feel.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the game's visual representation authentic to Super Mario?",
+      "description": "Assess whether the visual elements (sprites, animations, backgrounds) accurately represent the Super Mario aesthetic. Check for sprite animations (walking, jumping, state changes), background parallax effects, and visual feedback. Deduct 3 points for missing animations, 4 points for poor sprite quality, and 3 points for inconsistent visual style. 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 input changes, browser resizing, frame rate fluctuations, etc.) 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. Level editor 2. Custom character skins 3. Modern visual effects while preserving retro gameplay). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple collision detection systems) 2. Function modules unrelated to the Mario game (e.g., unnecessary social media integrations) 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/rendering/input handling), code organization, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no clear separation between game logic and rendering. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional game design standards?",
+      "description": "Evaluate whether the UI elements (score display, lives, timer, menus) are well-integrated into the game world without breaking immersion. Check for: 1) Clean HUD design that doesn't obstruct gameplay 2) Intuitive controls with visual feedback 3) Proportional sizing of game elements. Deduct 3 points for obtrusive UI elements, 5 points for confusing control schemes, and 5 points for inconsistent visual scale. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and responsive?",
+      "description": "Judge whether the game controls and animations feel responsive: 1) Input lag under 50ms 2) Consistent frame rate (minimum 30 FPS) 3) Smooth transitions between animations and game states. Deduct 5 points for perceptible input delay, 3 points for frame rate drops during normal gameplay, and 5 points for jerky animations or transitions. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Action/Rhythm",
+  "difficulty": "hard"
+}

package/library/game_development-action_rhythm/tank-battle-game-code.json

@@ -0,0 +1,68 @@
+{
+  "index": 978,
+  "question": "You are a coding expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you produce is executable for demonstration. Help me generate code for a tank battle game.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the tank battle core mechanics fully implemented?",
+      "description": "Review whether the code accurately implements tank movement control (WASD/arrow keys), rotation mechanics, firing system with projectile physics, and collision detection between tanks, bullets, and obstacles. Score 0 if basic tank control is missing, 5 if only movement is implemented without proper physics, and 10 if all mechanics including realistic tank physics (acceleration/deceleration) and accurate hit detection are fully included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the battlefield environment and combat system complete?",
+      "description": "Check whether the implementation includes a proper battlefield map with destructible/indestructible obstacles, spawn points, health system, ammunition management, and scoring mechanism. Evaluate if power-ups, different weapon types, or terrain effects are included. Deduct 5 points if health/damage system is missing, 3 points if no environmental interactions exist. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the multiplayer or AI opponent system properly designed?",
+      "description": "Evaluate whether the game supports multiple players (local or network) or includes AI opponents with reasonable difficulty levels. For multiplayer, check if player identification, turn management, and fair gameplay mechanics are implemented. For AI, assess if the bot behavior includes pathfinding, strategic targeting, and adaptive difficulty. Deduct 5 points if only single-player mode exists without opponents, 3 points if AI behavior is too simplistic. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the complete game state management and progression system constructed?",
+      "description": "Check whether the code includes comprehensive game lifecycle management: game start/pause/restart, win/lose conditions, score tracking, level progression, and game session persistence. Deduct 5 points if game state transitions are not properly handled, 3 points if no victory conditions are defined, and 2 points if restart functionality is missing. Give 10 points if fully implemented with proper state management.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as out-of-bounds movement, rapid key presses, collision edge cases, browser compatibility issues, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the gaming experience (e.g., 1. Particle effects for explosions 2. Mini-map radar system 3. Weapon upgrade system 4. Environmental destruction 5. Replay 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 collision detection systems coexisting) 2. Function modules unrelated to tank battles (e.g., built-in social media integration) 3. Excessive visual effects that hurt performance (e.g., too many simultaneous particle systems). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core gameplay 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/input handling), code organization, and maintainability. Deduct 5 points if global state pollution is found or proper object-oriented design is not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 3 points if performance optimization is not considered (e.g., inefficient rendering loops). 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 UI principles: 1) Harmonious color scheme appropriate for military theme 2) Clear HUD elements (health bars, ammo counters, mini-map) with proper contrast 3) Consistent visual style and readable fonts (UI text ≥ 12px). Deduct 3 points for each cluttered UI element, 5 points for poor color contrast affecting gameplay, and 5 points for inconsistent visual design. 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 gaming standards: 1) Input response delay ≤ 50ms for competitive gameplay 2) Smooth animation transitions for tank movement and turret rotation 3) Clear visual feedback for hits, damage, and game events 4) Consistent frame rate (ideally 60fps). Deduct 5 points for each laggy interaction, 3 points for stuttering animations, and 5 points for unclear visual feedback. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Action/Rhythm",
+  "difficulty": "medium"
+}

package/library/game_development-action_rhythm/temple-run-style-girl-protagonist-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 852,
+  "question": "You are a coding expert. Please use your professional knowledge to generate accurate and professional responses. Ensure that the code you generate is executable for demonstration. Please help me write a game similar to Temple Run, but make the protagonist in the story a beautiful young girl.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core endless running game mechanics fully implemented?",
+      "description": "Review whether the code accurately implements the endless running system through HTML5 Canvas/WebGL, including continuous terrain generation, character automatic forward movement, left-right lane switching, jumping/sliding mechanics, and collision detection with obstacles. Score 0 if core running mechanics are missing, 5 if only basic movement is implemented, and 10 if all Temple Run-style mechanics (lane switching, jumping, sliding, turning) are fully functional.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the dynamic obstacle generation and collision system properly designed?",
+      "description": "Check whether the obstacle generation system includes procedural generation algorithms, progressive difficulty scaling, and multiple obstacle types (barriers, gaps, moving obstacles). Evaluate collision detection accuracy and response mechanisms. Deduct 5 points if collision boundaries are imprecise, and 3 points if obstacle variety is insufficient. Requires smooth difficulty progression and fair collision feedback. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the 3D environment rendering and camera system optimized?",
+      "description": "Evaluate whether the 3D rendering system uses efficient techniques like frustum culling, level-of-detail (LOD) management, and texture atlasing. Check if the third-person camera smoothly follows the character with appropriate motion blur and depth of field effects. Deduct 5 points if frame rate drops below 30fps on average devices, and 3 points if camera movement causes motion sickness. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the character animation and control system polished?",
+      "description": "Check whether the beautiful girl protagonist has smooth animation transitions between running, jumping, sliding, and turning states. Evaluate character model quality, facial expressions, and clothing physics. Review input responsiveness for touch/keyboard controls with appropriate animation blending. Deduct 5 points if animations are choppy or unnatural, and 3 points if character design lacks visual appeal. Give 10 points if fully polished.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid input sequences, memory overflow from endless generation, device rotation, focus loss/resume, etc.) and provide graceful degradation or recovery mechanisms. Code with strong robustness should maintain stable performance during extended gameplay sessions, giving 10 points. If robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that enhance gameplay experience?",
+      "description": "Check whether the code includes engaging features beyond basic Temple Run mechanics (e.g., 1. Power-up collection system with visual effects 2. Character customization options 3. Environmental theme variations 4. Social sharing of high scores 5. Gesture-based special moves). Add 2-3 points for each well-implemented innovative feature that adds meaningful gameplay value (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features that impact performance?",
+      "description": "Strictly check three types of redundancy: 1. Duplicate rendering pipelines or animation systems 2. Unnecessary high-resolution assets that don't improve visual quality 3. Complex particle effects that cause frame drops without adding significant value. Deduct 3 points for each performance-impacting redundancy found, and directly deduct 10 points if core gameplay is compromised by unnecessary features.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code demonstrate solid engineering architecture?",
+      "description": "Review modular separation of concerns (rendering engine, game logic, input handling, asset management), efficient memory management for endless generation, and proper asset loading strategies. Deduct 5 points if memory leaks are detected or if the architecture doesn't scale well; deduct 5 points if code organization is poor with high coupling; deduct 5 points if no performance monitoring or optimization strategies are evident. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the visual design achieve professional mobile game standards?",
+      "description": "Evaluate whether the overall aesthetic follows modern mobile game design: 1) Cohesive art style with consistent lighting and color palette 2) Clear UI elements with appropriate sizing for touch interaction (minimum 44px touch targets) 3) High-quality character design that fits the Temple Run aesthetic while being distinctive. Deduct 3 points for inconsistent visual style, 5 points for poor character model quality, and 5 points for cluttered or hard-to-read UI elements. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the gameplay interaction fluid and responsive?",
+      "description": "Judge whether the control system provides immediate feedback: 1) Touch/swipe response time ≤ 50ms for mobile-optimized gameplay 2) Smooth animation transitions without stuttering during rapid input sequences 3) Clear visual and audio feedback for all player actions 4) Intuitive gesture recognition for lane switching and jumping/sliding. Deduct 5 points for each unresponsive control interaction, 3 points for delayed visual feedback, and 5 points if gesture recognition fails frequently. Full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Action/Rhythm",
+  "difficulty": "hard"
+}