@getollie/cli 0.0.5 → 0.2.1

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

@@ -1,68 +0,0 @@
-{
-  "index": 989,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Please ensure that the code you generate is executable. Can you write a Super Mario game with a higher level of complexity?",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core Super Mario gameplay mechanism fully implemented?",
-      "description": "Review whether the code accurately implements the essential Super Mario mechanics including player movement (running, jumping), collisions with platforms and enemies, power-ups (mushroom, fire flower, star), and level transitions. Score 0 if the core gameplay is not implemented, 5 if only basic movement and platforms are implemented, and 10 if all classic mechanics including pipe travel and enemy interactions are fully included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the enemy AI and interaction system complete?",
-      "description": "Check whether diverse enemy types with distinct behaviors are implemented (Goomba, Koopa Troopa, Piranha Plant, etc.), and whether enemy-player interactions follow the proper Super Mario rules (stomping, shell mechanics, fire flower attacks). Deduct 3 points if enemies don't have proper movement patterns, 3 points if enemy-player interactions are inconsistent with classic Super Mario mechanics, and 4 points if less than three enemy types are implemented. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the level design system comprehensive and flexible?",
-      "description": "Evaluate if the game includes a proper level representation system that can handle different types of terrain, obstacles, collectibles, and secrets. Check for multiple levels with increasing difficulty and variety. Deduct 5 points if the level design is hardcoded without a reusable system, 3 points if environmental hazards (pits, lava) are missing, and 2 points if there's no level progression. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are power-ups and scoring mechanisms implemented correctly?",
-      "description": "Assess whether the code properly implements the classic power-up system (size change, abilities), coin collection, score tracking, lives system, and time limits. Deduct 3 points if visual transformations for power-ups are missing, 3 points if the scoring system doesn't follow Super Mario conventions, and 4 points if the life system and game-over conditions are incomplete. 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, edge collisions, simultaneous events, etc.) and provide appropriate 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 code includes surprise features that enhance the experience (e.g., 1. Custom character skins 2. Level editor 3. Speed-running mode with timer 4. Multiplayer capabilities). 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 coexisting) 2. Function modules unrelated to Super Mario (e.g., a built-in calculator) 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 layers), implementation of common game design patterns, and code organization. Deduct 5 points if global state pollution is found or game loop architecture is poor; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no asset loading system. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional game design standards?",
-      "description": "Evaluate whether the visual design follows classic Super Mario aesthetics while maintaining modern standards: 1) Consistent pixel art style or modern visual approach 2) Clear UI elements for score, lives, and power-ups 3) Distinctive character and enemy designs. Deduct 3 points for inconsistent art styles, 4 points for cluttered or unclear UI elements, and 3 points for poor visual feedback for player actions. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the game performance optimized and response time appropriate?",
-      "description": "Judge whether the game maintains proper frame rate (60 FPS target) and has appropriate input response: 1) Input lag ≤ 50ms 2) Consistent animation timing 3) Proper handling of collision detection without performance drops. Deduct 5 points if the game stutters during normal gameplay, 3 points for delayed input response, and 2 points if asset loading causes noticeable pauses. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Action/Rhythm",
-  "difficulty": "hard"
-}

package/library/game_development-action_rhythm/super-mario-game-html-code.json

@@ -1,68 +0,0 @@
-{
-  "index": 1740,
-  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Be sure to ensure the generated code is executable for demonstration. Create a Super Mario game using HTML code.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core Mario character movement system fully implemented?",
-      "description": "Review whether the code accurately implements Mario's movement mechanics including running, jumping, and crouching. Check if the physics system properly handles gravity, acceleration, deceleration, and jump height variability based on button press duration. Score 0 if basic movement is missing, 5 if only simple movements exist, and 10 if all classic Mario movements are implemented with proper physics.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are enemy characters and their behaviors properly implemented?",
-      "description": "Evaluate whether typical enemies (Goombas, Koopas, etc.) are implemented with correct behaviors (patrolling, following Mario, shell mechanics). Check if collision detection with enemies works accurately, including stomping mechanics and proper death animations. Deduct 5 points if enemies are static or lack proper behavior patterns, 3 points if collision detection is inconsistent. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the level design and scrolling mechanism properly implemented?",
-      "description": "Check whether the game implements proper side-scrolling with Mario centered or using edge-triggered scrolling. Verify if the level includes typical Mario elements (blocks, pipes, platforms, coins, power-ups). Examine if the camera follows Mario smoothly without jerking. Deduct 5 points for missing scrolling, 3 points for incomplete level elements, and 5 points for camera issues. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are game mechanics like power-ups, scoring system, and win/lose conditions implemented?",
-      "description": "Assess whether the game includes traditional power-ups (mushroom, fire flower, star), proper scoring mechanism (collecting coins, defeating enemies), and clear win/lose conditions (reaching flagpole, falling into pits, enemy damage). Deduct 5 points if power-ups are missing, 3 points if scoring is incomplete, and 5 points if win/lose conditions aren't clear. 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 key presses, browser resize, focus loss, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Custom level editor 2. Multiplayer mode 3. Mobile touch controls 4. Special effects not in 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 collision detection systems) 2. Function modules unrelated to Mario gameplay (e.g., unnecessary menu systems) 3. Fancy effects that affect performance (e.g., excessive particles or animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/rendering/input handling), proper use of object-oriented or component-based patterns, and code organization. Deduct 5 points if global state pollution is found; deduct 5 points if the code duplication rate is too high; deduct 5 points if there's no clear structure for game assets and resources. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision match the classic Super Mario aesthetic?",
-      "description": "Evaluate whether the visual design faithfully recreates the classic Super Mario look: 1) Accurate sprite representation 2) Proper color palette matching the original 3) Authentic animations for Mario and enemies 4) Faithful recreation of HUD elements (score, coins, time). Deduct 3 points for each visual element that doesn't match the original style, 5 points for inconsistent art direction. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the game performance and responsiveness optimized?",
-      "description": "Judge whether the game runs smoothly: 1) Maintains 60 FPS during gameplay 2) Input response delay ≤ 50ms 3) No visible frame drops during animations or transitions 4) Proper asset loading and management. Deduct 5 points for noticeable frame rate issues, 3 points for input lag, and 5 points for long loading times or browser freezes. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Action/Rhythm",
-  "difficulty": "hard"
-}

package/library/game_development-action_rhythm/super-mario-game-html-single-file.json

@@ -1,68 +0,0 @@
-{
-  "index": 1791,
-  "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. Write a Super Mario game using HTML, with all code contained in a single HTML file that can run directly in a browser.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core Mario character movement system fully implemented?",
-      "description": "Evaluate whether the code correctly implements Mario's movement physics including walking, running, acceleration/deceleration, jumping mechanics with proper gravity, and collision detection. Score 0 if movement is not implemented, 5 if basic movement exists but lacks physics accuracy, and 10 if the movement feels authentic to classic Mario games with proper momentum and jump arcs.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are the essential game mechanics and interactions implemented?",
-      "description": "Check if the game includes core Mario mechanics: coin collection, enemy interaction (stomping Goombas/Koopas), power-ups (mushroom for growth, flower for fireballs), block interactions (question blocks, brick breaking), and level completion conditions. Deduct 2 points for each missing core mechanic. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the game level design and scrolling mechanism properly implemented?",
-      "description": "Assess whether the game implements a proper scrolling mechanism that follows Mario's movement, prevents backtracking beyond the screen's left edge, and includes varied terrain (platforms, pipes, gaps). Check if at least one complete level with a beginning and end point is implemented. Score 0 if no scrolling exists, 5 if basic scrolling is implemented but with visual glitches, and 10 if smooth scrolling with proper level boundaries is present.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the game state management and UI properly handled?",
-      "description": "Evaluate whether the game implements proper state management (start screen, gameplay, game over, victory screens) and essential UI elements (score display, lives counter, time remaining if applicable). Check if the game can be paused/resumed and if player progress is tracked correctly. Deduct 3 points if state transitions are abrupt or buggy, and 3 points if essential UI elements are missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common edge cases (rapid key presses, browser resizing, frame rate variations) and prevent game-breaking bugs. Test for memory leaks during extended play and proper event listener cleanup. Deduct 3 points for each critical bug found, such as character getting stuck in platforms or collision detection failures. The full score is 10 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. Secret warp pipes/areas, 2. Additional power-ups beyond the basics, 3. Custom animations or effects, 4. Mobile-friendly touch controls, 5. Local multiplayer option). Add 2 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple collision detection systems) 2. Function modules unrelated to Mario gameplay (e.g., unnecessary mini-games) 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 code organization (separation of game logic, rendering, input handling), variable/function naming conventions, and performance optimization techniques. Check if the game uses requestAnimationFrame for smooth animation and implements proper time-based movement. Deduct 3 points if global namespace is polluted with variables, 3 points if the code uses inefficient rendering techniques, and 4 points if there's significant code duplication. 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 matches classic Super Mario aesthetics: 1) Proper pixel art style with consistent scale and proportion 2) Authentic color palette matching Nintendo's original designs 3) Clear distinction between interactive and background elements. Deduct 3 points for inconsistent visual style, 3 points for poor sprite quality, and 4 points for unreadable or confusing visual hierarchy. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the game delivers responsive controls and smooth animation: 1) Input lag under 100ms 2) Consistent frame rate (target 60fps) 3) Smooth animations for character movement, enemies, and environmental elements. Deduct 3 points for input delay, 3 points for frame rate drops below 30fps during normal gameplay, and 4 points for jerky or missing animations. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Action/Rhythm",
-  "difficulty": "medium"
-}

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

@@ -1,68 +0,0 @@
-{
-  "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

@@ -1,68 +0,0 @@
-{
-  "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

@@ -1,68 +0,0 @@
-{
-  "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

@@ -1,68 +0,0 @@
-{
-  "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

@@ -1,68 +0,0 @@
-{
-  "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"
-}