@getollie/cli 0.0.5 → 0.2.1

package/library/game_development-action_rhythm/pacman-web-game-html-css-javascript.json

@@ -1,68 +0,0 @@
-{
-  "index": 299,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure the code you provide is executable and ready to demonstrate. Write a complete Pacman web game using HTML, CSS, and JavaScript.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core Pacman gameplay mechanics fully implemented?",
-      "description": "Review whether the code correctly implements the classic Pacman mechanics: pac-dots collection, ghost AI behaviors (chase, scatter, frightened modes), power pellets that make ghosts vulnerable, player movement in four directions, and collision detection. Score 0 if core mechanics are absent, 5 if basic movement and pac-dot collection work but ghost AI is simplistic, 10 if all classic mechanics are faithfully implemented including proper ghost personalities and mode switching.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the game board and level design properly implemented?",
-      "description": "Check whether the game has a well-structured maze with walls, paths, pac-dots, power pellets, and ghost home areas. Evaluate if the collision detection with walls works accurately, if the level design is playable, and if the game includes multiple levels or difficulty progression. Deduct 5 points if the maze doesn't match classic Pacman layouts, 3 points if collision detection is buggy, and 2 points if there's no level progression. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the game state management and scoring system complete?",
-      "description": "Evaluate if the game properly manages states (start screen, active game, pause, game over, level completion) and includes accurate scoring (points for eating pac-dots, power pellets, vulnerable ghosts with increasing values for consecutive ghosts). Check if it tracks lives, high scores, and bonus fruit appearances. Deduct 5 points for incomplete state management, 3 points for inaccurate scoring system, and 2 points if high score persistence is missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are the animations and visual effects authentic to the Pacman experience?",
-      "description": "Assess whether the game includes classic Pacman animations: Pacman's mouth opening/closing while moving, ghost animations (including eyes that indicate direction), ghost vulnerability state with flashing before recovery, death animation, level introduction sequences, and fruit appearances. Deduct 3 points for each missing key animation and 5 points if animations significantly impact gameplay performance. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid input changes, browser resizing, timing issues, frame rate drops) and provide friendly error recovery. Code with strong robustness should maintain consistent gameplay experience across different devices and browsers. Give 10 points for excellent error handling and performance optimization, 5 points for average robustness with minor issues, and 0 points if game frequently breaks under normal usage conditions.",
-      "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. Modern visual effects while maintaining classic gameplay 3. Adjustable difficulty settings 4. Mobile-friendly controls). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple movement control systems) 2. Function modules unrelated to Pacman gameplay (e.g., unnecessary mini-games) 3. Visual effects that affect performance without enhancing the core experience. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/view/input handling), code organization, reuse of common functions, and performance optimization. Deduct 5 points if global variable pollution is excessive; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there are no comments or documentation. 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 balances authenticity to classic Pacman with modern web standards: 1) Appropriate color scheme maintaining the classic look 2) Clean, readable UI elements for score, lives, and messages 3) Responsive layout that works across different screen sizes. Deduct 3 points for each usability issue, 5 points for significant departure from recognizable Pacman aesthetics without justification, and 5 points for non-responsive design. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the player control experience smooth and responsive?",
-      "description": "Judge whether the control system provides a satisfying experience: 1) Input response time ≤ 50ms 2) Support for both keyboard and touch controls on appropriate devices 3) Predictable and consistent movement behavior. Deduct 5 points for perceivable input lag, 3 points for missing alternative control schemes, and 5 points if the movement feels erratic or unpredictable. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Action/Rhythm",
-  "difficulty": "hard"
-}

package/library/game_development-action_rhythm/pixel-dance-rhythm-music-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 8,
-  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable for demonstration purposes.\n\nPlease use HTML and JavaScript to implement \"Pixel Dance!\", an interactive rhythm and music-based game. The game provides a stage where characters dance to music. Players need to follow arrow prompts displayed at the bottom of the screen to control and complete correct dance moves. The game's objective is to accurately complete a series of actions according to the rhythm to achieve the highest score.\n\n### Gameplay\n- **Follow Instructions**: Follow the arrow directions shown on screen, input all direction keys and press the space bar at the right moment.\n- **Rhythm Matching**: Synchronize with the background music's rhythm to complete dance moves.\n\n### Game Features\n- **Visual Effects**: Dynamic pixel art style and visual effects.\n- **Music Interaction**: Gameplay closely integrated with musical rhythm.\n\n### Game Tips\n- **Pay Attention to Rhythm**: Closely follow the music rhythm and screen instructions to ensure accuracy of movements.\n- **Reaction Speed**: Quickly respond to screen instructions to improve scoring rate.\n\n### Summary\nThis game combines music, dance, and pixel art to provide players with a challenging and entertaining gaming experience. Please implement the game and include comments in the code to help other developers understand your implementation process.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core rhythm-based input system fully implemented?",
-      "description": "Evaluate whether the code implements a rhythm-based input system that accurately detects key presses (arrow keys and space bar) synchronized with music beats. Check for timing windows that categorize inputs as 'Perfect', 'Good', or 'Miss'. Score 0 if input detection is missing, 5 if basic key detection exists without timing precision, and 10 if the system includes accurate beat synchronization with visual feedback.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the music synchronization mechanism properly implemented?",
-      "description": "Check whether arrow prompts are correctly synchronized with the music beats, including proper preloading of audio assets and precise timing calculations. Verify that the game has a calibration system or offset adjustment to account for audio latency. Deduct 3 points if synchronization drifts over time, 5 points if there's no preloading mechanism for audio, and 3 points if there's no way to handle audio latency. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the dance animation system responsive and visually satisfying?",
-      "description": "Assess whether character animations transition smoothly in response to player inputs, with different animations for successful vs. failed moves. Evaluate the pixel art quality and whether animations match the rhythm. Deduct 5 points if animations are jerky or delayed, 3 points if there's no visual difference between successful/failed moves, and 2 points if animations don't match the music's rhythm. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the scoring and feedback system comprehensive?",
-      "description": "Evaluate whether the game provides clear scoring feedback (Perfect/Good/Miss indicators), maintains combo counters, and calculates final scores based on accuracy and combo chains. Check if there's appropriate visual and audio feedback for different quality inputs. Deduct 3 points if visual feedback is delayed, 3 points if the combo system is missing, and 4 points if there's no end-game score summary. 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 audio loading failures, unsupported browsers, unexpected key presses, 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 difficulty settings 2. Ability to import custom songs/charts 3. Multiplayer functionality 4. Performance replay features). 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 input detection systems) 2. Function modules unrelated to rhythm gaming (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 modular design (such as separating game logic/view/audio handling/input detection), unit test coverage, and build process automation. 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 build process is not automated. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the pixel art style is consistent and polished: 1) Proper color palette suitable for pixel art (limited colors per element) 2) Consistent pixel sizing (no mixed resolutions) 3) Clear UI elements that don't obstruct gameplay. Deduct 3 points for inconsistent pixel art style, 3 points for poor contrast between UI and game elements, and 4 points for cluttered or confusing interface layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the game's performance meets rhythm game requirements: 1) Input lag under 50ms 2) Stable frame rate (minimum 60fps) 3) Smooth transitions between dance moves. Deduct 5 points for noticeable input delay, 3 points for frame rate drops during complex animations, and 2 points for jarring transitions between animations. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Action/Rhythm",
-  "difficulty": "hard"
-}

package/library/game_development-action_rhythm/pixel-racing-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 1070,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to make the generated code executable for demonstration. Create a running pixel racing game.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core racing game engine fully implemented?",
-      "description": "Review whether the code accurately implements the fundamental racing mechanics including player movement, collision detection, and race track boundaries. Assess the physics implementation for vehicle handling (acceleration, deceleration, steering). Score 0 if the core movement mechanics are missing, 5 if basic movement is implemented without proper physics, and 10 if the game includes realistic pixel-style racing physics with proper friction and momentum handling.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the pixel art style properly executed?",
-      "description": "Evaluate whether the game consistently maintains an authentic pixel art aesthetic throughout all visual elements (vehicles, tracks, UI, effects). Check for appropriate pixel density, limited color palette usage, and proper pixel-perfect scaling. Deduct 5 points if the pixel art is inconsistent or mixed with non-pixel art elements, 3 points if anti-aliasing is incorrectly applied breaking the pixel aesthetic. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the game loop and racing progression system implemented?",
-      "description": "Check whether the code implements a complete game loop including starting sequence, lap counting, finish line detection, and race completion states. Verify if there's a timing/scoring system that tracks player performance. Deduct 5 points if lap tracking is missing, 3 points if there's no race completion state, and 5 points if there's no timing system. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there an opponent AI or multiplayer system?",
-      "description": "Assess whether the game includes AI opponents with reasonable pathfinding and difficulty scaling, or a multiplayer system allowing for competitive racing. Evaluate the AI's ability to navigate the track and provide challenge without cheating. Score 0 if no opponents exist, 5 if basic AI opponents are present but lack sophisticated behavior, and 10 if either well-implemented AI with different difficulty levels or functional multiplayer racing is available.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid input changes, browser resize, frame rate drops, 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. Dynamic weather effects 2. Vehicle customization options 3. Procedurally generated tracks 4. Power-ups or special 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 control schemes without purpose) 2. Function modules unrelated to racing (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive particle systems 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/rendering/input handling), use of appropriate design patterns for game development, and code maintainability. Deduct 5 points if global state management is chaotic; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the game loop implementation causes performance issues. 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 pixel game design principles: 1) Consistent pixel art style throughout UI elements 2) Readable pixel fonts at intended resolution 3) Clear visual hierarchy in game screens and HUD elements. Deduct 3 points for each inconsistent UI element, 5 points for unreadable text, and 5 points for cluttered or confusing HUD layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the gameplay smooth and responsive?",
-      "description": "Judge whether the game meets performance standards: 1) Consistent frame rate (minimum 30 FPS) 2) Input latency under 100ms 3) Smooth animations without stuttering. Deduct 5 points for noticeable frame drops during normal gameplay, 3 points for input lag affecting player control, and 5 points if collision detection feels inconsistent or unfair. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Action/Rhythm",
-  "difficulty": "medium"
-}

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

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

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

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

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

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