@getollie/cli 0.0.1

package/library/game_development-action_rhythm/real-time-battle-game-html-javascript.json

@@ -0,0 +1,68 @@
+{
+  "index": 95,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Ensure that the code you generate is executable whenever possible.\n\nPlease use HTML and JavaScript to implement a real-time battle game where players can engage in immediate combat with AI or other players.\n\n**Task**: Implement a simple real-time battle system where players can fight instantly against AI or other players.\n\n**Hint**: You can set up basic combat operations and design simple AI opponents for practice or battles.\n\nInclude comments in your code so other developers can understand your implementation process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the real-time battle system core gameplay loop properly implemented?",
+      "description": "Review whether the code implements the fundamental battle mechanics including player input handling, character actions (attack, defend, special moves), and turn management. Score 0 if basic combat is not functional, 5 if only simple attacks are implemented, and 10 if the system includes varied combat actions with proper state management.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the AI opponent system effectively designed?",
+      "description": "Evaluate the quality of AI implementation - check for decision-making logic, difficulty levels, and whether the AI provides an engaging challenge. Deduct 5 points if AI simply performs random actions, 3 points if AI is too predictable, and 2 points if there's no difficulty scaling. Full score requires adaptive AI that responds to player strategies.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there a multiplayer combat capability implemented?",
+      "description": "Check whether the code includes player-vs-player functionality, ideally with some form of networking (WebSockets, Firebase, etc.). Assess for session management, player matching, and synchronization of game states between players. Score 0 if multiplayer is completely absent, 5 if local multiplayer is implemented, 10 if online play with proper synchronization is functional.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a complete battle lifecycle management?",
+      "description": "Verify if the game handles the complete battle flow: initialization, combat phases, victory/defeat conditions, and post-battle results. Check for proper state transitions and battle outcome calculations. Deduct 5 points if end conditions are missing, 3 points if there's no battle summary/results screen. Award full points for a complete, well-managed battle lifecycle.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (like invalid player inputs, connection issues, timing problems) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Dynamic weather effects affecting combat 2. Character progression/leveling system 3. Special combo mechanics or unique abilities). 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 damage calculation systems) 2. Function modules unrelated to battle gameplay (e.g., an unnecessary inventory system) 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 logic/view/controller layers), 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 insufficient commenting despite the requirement. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the battle UI follows modern game design principles: 1) Clear health/status indicators 2) Intuitive control layout 3) Visual feedback for actions 4) Balanced visual hierarchy. Deduct 3 points for cluttered UI elements, 5 points for confusing status indicators, and 5 points for controls that aren't clearly communicated. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and responsive?",
+      "description": "Judge whether the combat interactions feel satisfying: 1) Action response time ≤ 100ms 2) Visual feedback for hits/misses 3) Appropriate animation timing for attacks and effects. Deduct 5 points for actions without feedback, 3 points for sluggish animations that affect gameplay, and 5 points for unclear indication of turn order or current player. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Action/Rhythm",
+  "difficulty": "easy"
+}

package/library/game_development-action_rhythm/rhythm-game-difficulty-curve-changes.json

@@ -0,0 +1,68 @@
+{
+  "index": 125,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable for demonstration.\n\nPlease implement an action game - rhythm game: difficulty curve and rhythm changes\n**Task**: Implement a difficulty curve system where the rhythm speeds up or becomes more complex as the game progresses, challenging the player's reaction ability.\n**Hint**: You can increase game difficulty by gradually adding key combinations and shortening reaction time.\n[CHAT_SEP]Please optimize the game response above and add some comments in the code to help other developers understand your implementation process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core rhythm game mechanic properly implemented?",
+      "description": "Evaluate whether the code implements the fundamental rhythm game mechanics with proper timing systems (measuring in milliseconds), hit detection zones, and scoring mechanics. Check if the timing window for inputs is properly calibrated (perfect/good/miss zones). Score 0 if core mechanics are missing, 5 if basic hit detection exists but lacks precision, and 10 if the timing system is accurately implemented with proper calibration.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the difficulty curve progression system fully implemented?",
+      "description": "Analyze how the difficulty increases throughout gameplay. Look for systematic implementation of: 1) Gradually increasing tempo/BPM, 2) Introducing more complex patterns, 3) Shortening reaction windows, and 4) Adding key combinations as gameplay progresses. Deduct 3 points for each missing progression element. Give full marks only if difficulty changes are smoothly implemented with proper pacing rather than abrupt jumps.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the rhythm synchronization accurate?",
+      "description": "Check whether the game elements (notes, visual cues, audio) are properly synchronized to the beat. Verify if the code implements audio analysis or fixed beat tracking to ensure game events align with music rhythm. Deduct 5 points if there's noticeable audio-visual lag, 3 points if synchronization drifts over time. The full score requires precise frame-level synchronization with compensation for browser performance variations.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a proper visual feedback system for player performance?",
+      "description": "Evaluate visual indicators for hits/misses, combo counters, and scoring feedback. Check for animations that clearly communicate timing accuracy (perfect/good/miss). Deduct 3 points if feedback is delayed (>100ms), 3 points if visual clarity is poor during intense sequences, and 5 points if performance feedback is absent. Full score requires distinct visual feedback for different timing accuracies.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as browser performance issues, audio latency, missed frames, input device variations, etc.) and provide graceful fallbacks. Code with strong robustness should include frame rate compensation, audio sync recovery, and input buffering. Give 10 points for comprehensive error handling, 5 points for basic stability measures, and 0 points if performance issues break gameplay.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Dynamic difficulty adjustment based on player performance 2. Visualizer effects synchronized with music 3. Replays with performance analysis). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple scoring systems) 2. Function modules unrelated to rhythm gameplay (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive particles during critical gameplay). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating rhythm logic/rendering/audio systems), reusable components, and code organization. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no clear separation between game logic and rendering. 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 rhythm game UI principles: 1) Clear note paths with high contrast 2) Non-interfering background elements 3) Prominent scoring and feedback elements 4) Appropriately sized hit targets. Deduct 3 points for each element that reduces gameplay visibility, 5 points for confusing note patterns/colors, and 5 points for unreadable text during gameplay. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the game maintains consistent frame rates (60+ FPS) during complex sequences and provides responsive input handling (≤16ms latency). Check if difficulty transitions feel natural rather than jarring. Deduct 5 points for frame drops during key moments, 3 points for input lag, and 5 points for abrupt difficulty spikes that feel unfair rather than challenging. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Action/Rhythm",
+  "difficulty": "medium"
+}

package/library/game_development-action_rhythm/sekiro-sword-clash-combat-deflection-core-code.json

@@ -0,0 +1,68 @@
+{
+  "index": 701,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Be sure to ensure that any code you generate is executable and displayable. I want to create a game like Sekiro's sword-clashing gameplay. Can you help me generate the core code for sword combat and deflection mechanisms?",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core sword combat mechanics implemented?",
+      "description": "Review whether the code includes a complete sword combat system with attack and defense mechanics similar to Sekiro. Check for proper implementation of player input handling, attack animations, hitbox detection, and damage calculation. Score 0 if core combat is missing, 5 if basic attack/defense exists, and 10 if the system captures Sekiro's nuanced combat feel with different attack types.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the deflection/parry system properly implemented?",
+      "description": "Evaluate if the code includes Sekiro's signature deflection mechanics with precise timing windows. Check for visual feedback effects, sound cues, and the posture/stagger system that increases with failed deflections. Scoring: 0 points if deflection is absent, 5 points for basic parry without posture mechanics, 10 points for a complete implementation with timing-based difficulty and posture buildup effects.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the posture/stagger system implemented?",
+      "description": "Verify that the code includes Sekiro's posture/stagger system where successful attacks and deflections build up an opponent's posture meter leading to critical openings. Check if posture regeneration mechanics and visual indicators are present. Award 0 points if absent, 5 points for basic implementation, and 10 points if it includes varying recovery rates based on health and enemy types.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there AI opponent behavior with varied attack patterns?",
+      "description": "Check if the code implements enemy AI that uses varied attack patterns, combo strings, and adapts to player style similar to Sekiro bosses. Verify that the AI has different states (aggressive, defensive, recovery) and realistic reaction times. Score 0 if AI is missing, 5 if basic attack patterns exist, and 10 if the AI demonstrates complex behavior with pattern recognition of player tactics.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid inputs, animation interruptions, collision edge cases, etc.) and provide graceful handling or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Dynamic difficulty adjustment based on player skill 2. Weapon clashing spark effects with physics 3. Stance-based combat system similar to real swordplay). 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 combat functions (e.g., multiple parry systems with overlapping logic) 2. Function modules unrelated to sword combat (e.g., an excessive inventory system) 3. Fancy effects that affect performance (e.g., too many particle effects during deflection). 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 combat logic/animations/input handling), unit test coverage for combat mechanics, and efficient collision detection. 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 proper optimization techniques aren't applied for performance-critical sections. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the visual feedback meet professional game standards?",
+      "description": "Evaluate whether visual feedback elements follow action game principles: 1) Clear hit/deflection effects with appropriate screen shake 2) Proper animation cancellation/blending for responsive controls 3) Visual clarity during intense combat (readable animations, distinct particle effects). Deduct 3 points for each missing visual feedback element, 5 points for unclear combat readability, and 5 points for animations that hinder gameplay. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the combat interaction smooth, responsive and satisfying?",
+      "description": "Judge whether the combat feels responsive and satisfying: 1) Input response delay ≤ 100ms 2) Animation cancel frames prioritize player control 3) Appropriate hit stop/freeze frames on successful deflections for impact. Deduct 5 points for input lag over 100ms, 3 points for animations that cannot be canceled appropriately, and 5 points if deflections lack satisfying feedback. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Action/Rhythm",
+  "difficulty": "hard"
+}

package/library/game_development-action_rhythm/ski-adventure-game-html-javascript.json

@@ -0,0 +1,68 @@
+{
+  "index": 164,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable.\nPlease implement a Ski Adventure game using HTML and JavaScript.\nTask: Design a skiing game where players slide down a slope and avoid obstacles.\nHint: Implement the physical movement of characters and dynamic changes in scenery.\nPlease include comments in the code so other developers can understand your implementation process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core ski movement physics system implemented correctly?",
+      "description": "Review whether the code accurately implements skiing physics including gravity, momentum, collision detection, and speed control. Check if the character responds to user input with appropriate acceleration/deceleration. Score 0 if the core movement logic is missing, 5 if basic movement exists but physics are unrealistic, and 10 if the skiing mechanics feel natural with proper physics calculations.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the obstacle avoidance system comprehensive?",
+      "description": "Evaluate the obstacle system implementation including variety of obstacles (trees, rocks, etc.), proper collision detection with the player, and consequences of collisions (slowing down, game over, etc.). Deduct 5 points if collision detection is inaccurate, 3 points if obstacle variety is limited, and 2 points if collision consequences are not implemented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the dynamic scenery generation and scroll system effective?",
+      "description": "Check if the game implements infinite or procedural terrain generation with proper scrolling mechanics. Assess whether the scenery changes dynamically (e.g., increasing difficulty, varying landscapes). Deduct 5 points if terrain is static/limited, 3 points if scroll performance is poor (stuttering), and 2 points if there's no variation in scenery. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a complete game progression and scoring system?",
+      "description": "Evaluate whether the game includes proper scoring mechanics (distance traveled, tricks performed, obstacles avoided), difficulty progression, and game states (start, play, pause, game over). Deduct 3 points if scoring is simplistic, 3 points if difficulty doesn't increase, and 4 points if game state management is 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 incorrect user input, browser resizing, performance issues on slower devices, 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. Trick system for jumps and stunts 2. Weather effects that impact gameplay 3. Multiple character options with different abilities). 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 skiing (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive particle effects that slow down gameplay). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game logic/rendering/input handling), code organization, and whether comprehensive comments are included as requested. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 3 points if the code duplication rate is too high (over 30%); deduct 2 points if comments are insufficient or unclear. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern game design principles: 1) Harmonious color matching for the ski environment (contrasting player vs obstacles) 2) Clear HUD elements for score, speed, etc. with proper spacing 3) Professional text display for game states and instructions. Deduct 3 points for each cluttered UI element, 5 points for poor color choices making obstacles hard to distinguish, and 2 points for text that's difficult to read during gameplay. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the game performance and animations conform to player expectations: 1) Consistent frame rate (minimum 30fps) 2) Responsive controls with input lag under 100ms 3) Smooth acceleration/deceleration and turning animations. Deduct 4 points for frame rate drops during normal play, 3 points for input lag issues, and 3 points for jerky animations or movement. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Action/Rhythm",
+  "difficulty": "easy"
+}

package/library/game_development-action_rhythm/snake-game-program-creation.json

@@ -0,0 +1,68 @@
+{
+  "index": 1199,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Take care to ensure that the generated code is executable for display. Create a Snake game program.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Snake game core mechanics fully implemented?",
+      "description": "Review whether the code accurately implements the game grid system, snake movement logic, food generation, collision detection (wall/self), and score calculation. Check if the snake grows correctly after eating food and if the game ends properly on collision. Score 0 if core game loop is missing, 5 if only basic movement is implemented, and 10 if all classic Snake game rules are fully functional.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the control system responsive and intuitive?",
+      "description": "Evaluate whether keyboard controls (arrow keys/WASD) are properly implemented with direction change validation (preventing reverse direction causing instant death). Check for smooth input handling without lag or missed keystrokes during rapid direction changes. Deduct 5 points if input buffering is missing, and 3 points if there's noticeable input delay. Full score requires flawless control responsiveness.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the game timing and difficulty progression well-designed?",
+      "description": "Check if the game uses consistent frame rate or timer-based movement, and whether speed increases appropriately as score grows. Evaluate if the difficulty curve is balanced and engaging. Deduct 5 points if movement is inconsistent or jerky, 3 points if speed progression is too aggressive or absent. Requires smooth 60fps performance and logical difficulty scaling.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are game states and lifecycle properly managed?",
+      "description": "Verify implementation of complete game states: start screen, active gameplay, pause functionality, game over screen, and restart capability. Check for proper state transitions and memory cleanup. Deduct 5 points if pause/resume is missing, 3 points if game over handling is incomplete, and 5 points if memory leaks occur during state transitions.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust and error-resistant?",
+      "description": "Evaluate whether the code can handle edge cases (rapid key presses, browser focus loss, window resize, etc.) and provides appropriate error handling. Code should gracefully handle unexpected situations without crashing or corrupting game state. Give 10 points for comprehensive error handling, 5 points for basic robustness, and 0 points if no exception handling exists.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there innovative features that enhance gameplay?",
+      "description": "Check for creative enhancements beyond basic Snake gameplay (e.g., 1. Power-ups or special food types 2. High score persistence 3. Multiple game modes 4. Sound effects and visual feedback 5. Mobile touch controls). Add 2-3 points for each well-implemented feature that genuinely improves user experience (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant or unnecessary features?",
+      "description": "Identify three types of redundancy: 1. Duplicate game logic or rendering code 2. Unrelated functionality (e.g., built-in calculator) 3. Performance-heavy effects that don't add value (e.g., complex particle systems). Deduct 3 points for each redundancy found, and deduct 10 points if redundant code interferes with core game performance or clarity.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code demonstrate good engineering practices?",
+      "description": "Review code organization, separation of concerns (game logic/rendering/input), consistent naming conventions, and appropriate use of modern JavaScript features. Deduct 5 points for poor code structure or excessive global variables; deduct 5 points for high code duplication (>30%); deduct 3 points for inconsistent coding style. Full score requires clean, maintainable architecture.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the visual design meet modern UI/UX standards?",
+      "description": "Evaluate visual presentation quality: 1) Clean, readable game board with clear contrast 2) Consistent color scheme (snake, food, background) with no more than 4 primary colors 3) Proper proportions and spacing 4) Clear score display and UI elements. Deduct 3 points for poor color choices, 5 points for cluttered layout, and 5 points for hard-to-read text or game elements.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Are animations and visual feedback smooth and polished?",
+      "description": "Judge visual smoothness and user feedback: 1) Snake movement should be fluid without stuttering 2) Visual feedback for food consumption and score changes 3) Smooth game state transitions 4) Consistent frame rate during gameplay. Deduct 5 points for choppy animations, 3 points for missing visual feedback on key actions, and 5 points for inconsistent or jarring visual transitions.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Action/Rhythm",
+  "difficulty": "easy"
+}

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

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

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

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