@getollie/cli 0.0.1

package/library/game_development-shooting/html-tank-battle-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1284,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the generated code is executable for demonstration. Please help me create a perfect Tank Battle game using HTML, carefully check and fix all bugs before generating the final code, with all code saved in a single HTML file.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the tank movement and control system fully implemented?",
+      "description": "Review whether the code accurately implements tank controls using keyboard input (WASD/arrow keys), with smooth movement and rotation that respects physics (acceleration/deceleration). Check for collision detection with game boundaries and obstacles. Score 0 if tank movement isn't implemented, 5 if basic movement exists but lacks physics, and 10 if movement is realistic with proper collision handling.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the combat system properly implemented with projectile mechanics?",
+      "description": "Evaluate if the shooting mechanism includes projectile trajectory calculations, cooldown timers, and hit detection. Check if bullets have proper visual feedback (animation, explosion effects) and whether the damage system is implemented. Score 0 if shooting isn't implemented, 5 if basic shooting exists but lacks collision detection, and 10 if projectiles have realistic physics with proper hit detection and feedback.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the game environment and obstacle system properly designed?",
+      "description": "Check if the game includes a well-designed map with strategic obstacles (walls, barriers, destructible objects). Review if obstacles affect gameplay meaningfully through collision detection and whether some obstacles can be destroyed. Deduct 5 points if obstacles are purely decorative with no collision, and 3 points if obstacle variety is too limited. Full score of 10 if environment is interactive and strategically designed.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the enemy AI system implemented with varying difficulty levels?",
+      "description": "Assess if the game includes AI-controlled enemy tanks with path-finding algorithms, target tracking, and difficulty progression. Check if enemies demonstrate strategic behaviors (flanking, retreating when damaged). Score 0 if no AI exists, 5 if enemies move randomly without targeting, and 10 if AI demonstrates varied tactics and adapts to player actions.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as unexpected user input, animation frame drops, resource loading failures) 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. Power-up system with special abilities 2. Dynamic weather effects that affect gameplay 3. Destructible environment with physics simulation). 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 tank battles (e.g., a built-in mini-game) 3. Fancy effects that affect performance (e.g., excessive particle systems). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game logic/view/input handling), maintainability of code structure, and potential for expansion. 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 components. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional game design standards?",
+      "description": "Evaluate whether the overall design follows modern game UI principles: 1) Clear, readable HUD showing health/ammo/score 2) Proper contrast between game elements and background 3) Intuitive visual feedback for hits/damage/game events. Deduct 3 points for cluttered UI elements, 5 points for poor readability during gameplay, and 5 points for inconsistent visual language. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the game performance optimized and responsive?",
+      "description": "Judge whether the game maintains stable performance: 1) Consistent framerate above 30fps 2) Efficient rendering techniques avoiding unnecessary redraws 3) Proper asset management to prevent memory leaks. Deduct 5 points for noticeable slowdowns during gameplay, 3 points for input lag above 100ms, and 5 points for increasing memory consumption over time. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Shooting",
+  "difficulty": "medium"
+}

package/library/game_development-shooting/mech-shooting-game-with-flight-mode-terrain.json

@@ -0,0 +1,68 @@
+{
+  "index": 610,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable for demonstration. Implement a shooting game where players control a mech that moves around the battlefield and shoots enemies. The mech can transform into flight mode, which increases movement speed but reduces attack power. The battlefield has varying terrain heights that affect player visibility and bullet trajectories.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the mech movement and transformation system fully implemented?",
+      "description": "Review whether the code accurately implements the mech's ground and flight movement mechanics. Check for: 1) smooth transition animations between modes, 2) appropriate speed differences between modes, 3) proper collision detection with terrain, and 4) responsive controls. Score 0 if basic movement is missing, 5 if only basic movement without transformation is implemented, and 10 if both modes with proper physics and transitions are fully included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the combat system with varying attack power implemented correctly?",
+      "description": "Evaluate the implementation of the shooting mechanics, including: 1) different attack power between ground/flight modes, 2) bullet physics and collision detection, 3) visual feedback for hits/misses, and 4) weapon cooldown systems. Deduct 3 points if attack power doesn't vary between modes, 5 points if bullet trajectories don't account for terrain, and 3 points if hit detection is inaccurate. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the terrain system with height variations properly implemented?",
+      "description": "Check whether the code implements terrain with varying heights that properly: 1) affects visibility through occlusion, 2) influences bullet trajectories (arc/gravity effects), 3) impacts player movement (climbing/descending slopes), and 4) provides tactical gameplay elements. Deduct 3 points for each missing feature. Score 0 if terrain is flat or non-functional. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the enemy AI and spawn system sufficiently challenging?",
+      "description": "Assess whether the enemy system includes: 1) varied enemy types with different behaviors, 2) appropriate difficulty scaling, 3) strategic positioning based on terrain, and 4) reasonable spawn patterns that create engaging gameplay. Deduct 3 points if enemies have no varied behaviors, 3 points if they don't interact with terrain, and 4 points if spawn patterns are random or overwhelming. 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 mode switching, boundary collisions, many simultaneous projectiles, rapid fire inputs, etc.) and provide friendly error 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 weather effects affecting gameplay, 2. Destructible environment elements, 3. Special weapons or abilities unlocked during gameplay, 4. Physics-based chain reactions from explosions). 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 shooting mechanics that serve the same purpose) 2. Function modules unrelated to the game premise (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive particle systems that cause frame rate drops). 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), component reusability, and performance optimization. Deduct 5 points if global state is overused or proper design patterns are missing; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if frame rate optimizations for bullet/enemy handling are absent. 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 modern game UI principles: 1) Clear HUD elements (health, ammo, mode indicator) that don't obstruct gameplay, 2) Appropriate visual feedback for hits/damage/mode changes, 3) Consistent art style with clear distinction between terrain, player, and enemies. Deduct 3 points for cluttered UI elements, 5 points for inconsistent visual style, and 5 points for poor readability during intense gameplay. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the game interactions conform to player expectations: 1) Input response delay ≤ 50ms, 2) Consistent frame rate (minimum 30 FPS) even with many objects, 3) Clear visual cues for mode changes and terrain interaction. Deduct 5 points for input lag, 3 points for frame drops during transformation animations, and 5 points for unclear visual feedback when interacting with terrain. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Shooting",
+  "difficulty": "medium"
+}

package/library/game_development-shooting/mobile-shooting-game-source-code.json

@@ -0,0 +1,68 @@
+{
+  "index": 1731,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable when possible. Please create a mobile shooting game for me, with the source code.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core shooting mechanism fully implemented?",
+      "description": "Review whether the code accurately implements the shooting mechanics including weapon system, hit detection, damage calculation, and shooting effects. Score 0 if the core shooting logic is missing, 5 points if basic shooting is implemented without hit feedback, and 10 points if the full shooting system with proper collision detection, damage feedback and varying weapon types is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the mobile touchscreen control system properly designed?",
+      "description": "Evaluate whether the game uses appropriate mobile input methods such as virtual joysticks, touch gestures, gyroscope controls, etc. Check for touch event handling, multi-touch support, and responsive controls that adapt to different screen sizes. Deduct 5 points if the controls are not optimized for mobile (e.g., keyboard controls), and 3 points if touch areas are too small or overlapping. Score 10 points for intuitive mobile-first controls with alternative input methods.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the game loop and performance optimization implemented?",
+      "description": "Check whether the game implements a proper game loop with consistent frame rate handling, physics updates separate from rendering, and efficient resource management. Verify if the code includes mobile-specific optimizations like sprite batching, texture compression, and power management. Deduct 5 points if the game loop doesn't handle variable frame rates, and 5 points if there are no mobile optimization techniques. Give 10 points for a complete implementation with both features.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the game include a complete progression system?",
+      "description": "Assess whether the game includes level progression, scoring/reward systems, character/weapon upgrades, and appropriate difficulty scaling. Evaluate whether game state is properly saved between sessions using local storage or other persistence methods. Deduct 5 points if there's no progression system, and 3 points if progression exists but lacks save functionality. 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 touch events outside game area, device rotation, background/foreground transitions, memory constraints, 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 that affect gameplay 2. Destructible environments 3. AI opponents with adaptive difficulty). 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 a mobile shooting game (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive particle systems that cause frame drops on mobile). 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 handlers), asset management system, and build process for mobile deployment. 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 consideration for mobile packaging and deployment. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional mobile game design standards?",
+      "description": "Evaluate whether the UI follows mobile game design principles: 1) Touch-friendly button sizes (minimum 44x44pt) 2) Clear visual hierarchy with proper contrast 3) Responsive layout that works on different screen sizes and orientations. Deduct 3 points for each element that's too small for touch input, 5 points for poor visibility under different lighting conditions, and 5 points for layouts that don't adapt to device orientation. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the mobile gaming experience optimized?",
+      "description": "Judge whether the game is truly optimized for mobile: 1) Short gameplay sessions suitable for on-the-go play 2) Battery consumption considerations 3) Offline play capability 4) Appropriate use of device vibration and audio for feedback. Deduct 5 points for each missing mobile-specific optimization, 3 points for excessive battery drain without optimization attempts, and 5 points for requiring constant network connection without offline mode. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Shooting",
+  "difficulty": "medium"
+}

package/library/game_development-shooting/multiplayer-online-shooting-game-frontend.json

@@ -0,0 +1,68 @@
+{
+  "index": 599,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure any code you generate is executable and functional.\n\n======== ROLE ========\nYou are an experienced code expert. I am providing you with a software development requirement description, and I need you to generate project code based on these requirements. Strictly follow the rules to help users generate complete project code with simple and easy-to-understand comments, without outputting anything else.\n\n======== OUTPUT RULES ========\n1. Always generate complete, runnable project code, ensuring the project is fully executable\n2. Ensure all code files you output are complete, don't omit any code\n3. Carefully review and check all code before the final output, evaluating its executability. If the code cannot be executed or contains errors, regenerate it\n4. If the requirements involve external API access or require user data (images, videos, audio, etc.), please provide mock data\n\n======== PROJECT REQUIREMENTS DESCRIPTION ========\nDevelop a multiplayer online shooting game frontend where players can battle on the same map. Need to implement real-time synchronization between players, chat functionality, scoreboard, and basic combat mechanisms.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the multiplayer shooting game core combat system fully implemented?",
+      "description": "Review whether the code accurately implements the game map and character positioning system through HTML/JavaScript/Canvas, and whether it includes collision detection for projectiles, hit registration, and damage calculation. Score 0 if the core combat logic is not implemented, 5 if only basic shooting mechanics exist, and 10 if the system includes advanced features like different weapon types, headshots, or damage falloff.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the real-time player synchronization function implemented?",
+      "description": "Check whether WebSocket/Socket.io implementation includes position synchronization, animation states, and player actions. Evaluate if the code handles network latency with techniques like client-side prediction, server reconciliation, and entity interpolation. Deduct 5 points if there's no lag compensation mechanism, and 3 points if the synchronization frequency is inadequate (<10 updates/second). The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the chat functionality properly implemented?",
+      "description": "Evaluate if the chat system supports both team and global messages, has proper UI integration that doesn't interfere with gameplay, and includes basic features like player identification and timestamps. Check if there's message sanitization to prevent XSS attacks. Deduct 5 points if chat messages aren't synchronized in real-time, and 3 points if there's no visual notification for new messages. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the scoreboard system complete and functional?",
+      "description": "Check if the scoreboard tracks and displays relevant statistics (kills, deaths, assists, score), updates in real-time, and has proper sorting functionality. Evaluate if it's accessible during gameplay without disrupting the experience and if it includes end-of-match summary features. Deduct 5 points if the scoreboard doesn't update in real-time, and 3 points if it lacks essential statistics. 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 network interruption, player disconnection, browser compatibility issues, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Destructible environment elements 2. Special abilities or power-ups 3. Dynamic weather/lighting effects that impact gameplay). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple movement control systems coexisting) 2. Function modules unrelated to shooting gameplay (e.g., a built-in music playlist editor) 3. Fancy effects that affect performance (e.g., excessive particle systems when resources are already constrained). 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/network layers), code organization, and performance optimization techniques. Deduct 5 points if global state is excessively used or design patterns are not applied appropriately; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no asset loading optimization or frame rate management. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface design meet professional gaming UI standards?",
+      "description": "Evaluate whether the UI follows game design principles: 1) Non-intrusive HUD elements that provide essential information without blocking gameplay 2) Clear visual feedback for hits, damage taken, and game events 3) Appropriate use of color coding for team identification and game state indicators. Deduct 3 points for cluttered UI elements, 5 points for poor readability during action sequences, and 5 points for inconsistent visual language. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the game performance and responsiveness optimized?",
+      "description": "Judge whether the game maintains smooth performance under various conditions: 1) Input response time ≤ 50ms for critical actions 2) Stable frame rate even with multiple players and effects on screen 3) Efficient resource management to prevent memory leaks. Deduct 5 points for noticeable input lag, 3 points for frame drops during intensive gameplay, and 5 points for progressive performance degradation during longer sessions. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Shooting",
+  "difficulty": "hard"
+}

package/library/game_development-shooting/multiplayer-online-shooting-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 524,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure the code you generate is functional and executable. Implement a multiplayer online shooting game where players connect via WebSocket and can see other players' positions and actions in real-time. Each player controls a character and can shoot bullets to attack other players. Players who are hit temporarily lose their ability to move. The first player to reach a specified number of kills wins the game.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the multiplayer shooting game core mechanics fully implemented?",
+      "description": "Review whether the code accurately implements player movement controls, shooting mechanics with bullet physics, collision detection between bullets and players, hit registration system, and kill/death tracking. Score 0 if core shooting interaction is not implemented, 5 if only basic movement and shooting exist without proper collision detection, and 10 if all shooting game mechanics including hit effects, temporary paralysis, and kill counting are fully functional.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is real-time multiplayer synchronization properly implemented?",
+      "description": "Check whether WebSocket implementation includes real-time position synchronization, action broadcasting, and state consistency across all clients. Evaluate if player movements, shooting actions, and game events are synchronized with minimal latency (<100ms). Deduct 5 points if interpolation/extrapolation for smooth movement is missing, and 3 points if bullet trajectories are not properly synchronized. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the server-side game state management and anti-cheat system designed?",
+      "description": "Evaluate whether server-side authoritative validation is implemented for player actions, hit detection, and game state updates. Check if the system prevents common cheats like speed hacking, teleportation, or invalid shots. Server must validate all client actions and reject invalid ones. Deduct 5 points if client-side validation is trusted without server verification, and 5 points if no rate limiting for actions exists. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is complete game session and lobby management constructed?",
+      "description": "Check whether the code includes game room creation/joining, player matchmaking, game start/end conditions, winner determination, and post-game statistics. Evaluate if disconnection handling allows players to rejoin ongoing games and if spectator mode is available. Deduct 5 points if game session persistence is not implemented, and 3 points if no reconnection mechanism exists. Give 10 points if fully implemented with proper lobby system.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as network interruption, invalid user input, WebSocket connection drops, concurrent player actions, etc.) and provide appropriate error handling or recovery mechanisms. Code with strong robustness should gracefully handle edge cases like simultaneous shots, player disconnections mid-game, and invalid movement commands, giving 10 points. If robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes engaging features that enhance gameplay experience (e.g., 1. Power-ups or special weapons 2. Mini-map showing player positions 3. Kill streak bonuses 4. Spectator mode with replay functionality 5. Real-time leaderboard). Add 3 points for each practical innovative feature implemented that adds genuine value to the gaming experience (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple collision detection systems) 2. Function modules unrelated to shooting gameplay (e.g., built-in chat system when not specified) 3. Excessive visual effects that impact performance (e.g., complex particle systems for every bullet). Deduct 3 points for each redundancy found, and directly deduct 10 points if core shooting mechanics are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (separating game logic/rendering/network layers), proper event handling architecture, and code organization. Deduct 5 points if global state pollution is found or no clear separation of concerns exists; deduct 5 points if code duplication rate is too high (over 30%); deduct 5 points if no proper error logging or debugging capabilities are implemented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional game design standards?",
+      "description": "Evaluate whether the game interface follows modern game UI principles: 1) Clear visual hierarchy with HUD elements (health, ammo, kills) 2) Intuitive control indicators and crosshair design 3) Consistent color scheme that doesn't interfere with gameplay visibility 4) Proper contrast for game elements against background. Deduct 3 points for each cluttered UI element, 5 points for poor color choices that affect gameplay, and 5 points for missing essential HUD components. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and responsive?",
+      "description": "Judge whether game interactions meet real-time gaming standards: 1) Input response delay ≤ 50ms for movement and shooting 2) Smooth character movement without stuttering 3) Clear visual feedback for hits, deaths, and game events 4) Consistent frame rate during intense gameplay. Deduct 5 points for each laggy interaction, 3 points for missing hit feedback effects, and 5 points for poor movement interpolation causing jerky motion. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Shooting",
+  "difficulty": "hard"
+}

package/library/game_development-shooting/pirate-shooting-game-island-scene.json

@@ -0,0 +1,68 @@
+{
+  "index": 574,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Try to ensure the generated code is executable. \n\n## Role\nYou are an experienced code expert. Given a software development requirement description, you need to generate project code according to these requirements. Strictly follow the rules to help users generate complete project code fully commented in simple and easy-to-understand language, without outputting anything else.\n\n## Output Rules\n1. You will always generate complete, runnable project code; please ensure the project is complete and executable\n2. Ensure that all code files you output are complete, don't omit any code\n3. Carefully review and check all code before the final output, evaluating its executability. If the code cannot be executed or contains errors, it needs to be regenerated\n4. If the requirements involve external API access or need to use user data (images, videos, audio, etc.), please provide simulated data\n\n## Project Requirements Description\nCreate a pirate shooting game with an island scene. Pirates will appear from various corners of the island and approach the player's ship. The player controls a ship at the bottom of the screen and fires cannonballs by clicking with the mouse. When a cannonball hits a pirate, the pirate falls into the water and disappears, and the player's score increases by 1. When pirates board the ship, the player loses 1 life point, with an initial life count of 8. When life reaches 0, the game is over.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core pirate shooting game mechanic fully implemented?",
+      "description": "Review whether the code accurately implements the core game mechanics: player ship at the bottom, pirates spawning from different locations, mouse-click firing of cannonballs, collision detection between cannonballs and pirates, and scoring system. Score 0 if the core interaction logic is not implemented, 5 if basic shooting is implemented but with flaws, and 10 if all required game mechanics function correctly with proper hit detection.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the pirate enemy AI behavior properly implemented?",
+      "description": "Evaluate whether pirates appear from various corners of the island as specified, follow reasonable movement patterns toward the player's ship, and properly disappear when hit by cannonballs. Check if the pirate spawning mechanism increases difficulty over time. Deduct 3 points if pirates move unrealistically, 3 points if the spawning logic is too simple/predictable, and 4 points if pirates don't properly approach the player's ship. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the player life/game over system correctly implemented?",
+      "description": "Verify that the game implements the 8 initial life points, correctly detects when pirates board the ship to deduct life points, and properly triggers game over when lives reach 0. Check for a clear game over screen with score display and restart option. Deduct 5 points if life deduction is inconsistent, 3 points if visual feedback is missing when losing lives, and 5 points if the game over condition doesn't work properly. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the island scene and visual presentation properly implemented?",
+      "description": "Assess whether the code creates a visually coherent island scene with appropriate water surroundings, and whether the graphics (ship, pirates, cannonballs, island) are well-implemented and thematically consistent. Deduct 3 points for mismatched visual elements, 5 points for poor scene composition, and 5 points if the island scenery is missing or poorly executed. 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 mouse clicks, browser resizing, performance degradation with many sprites) 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. Power-ups that temporarily enhance firing rate or damage 2. Weather effects that affect gameplay 3. Special pirate types with different behaviors). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple collision detection systems) 2. Function modules unrelated to the pirate game theme (e.g., unrelated mini-games) 3. Fancy effects that affect performance (e.g., excessive particle effects 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/input handling), code organization, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's poor separation of concerns between game components. 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 appropriate for a pirate theme 2) Proper layout of UI elements (score display, life indicators, etc.) 3) Professional font system and readable text. Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Immediate response to mouse clicks for firing 2) Smooth pirate and cannonball movement animations 3) Clear visual feedback for hits and life loss. Deduct 5 points for delayed shooting response, 3 points for choppy animations, and 5 points for unclear visual feedback on important game events. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Shooting",
+  "difficulty": "medium"
+}

package/library/game_development-shooting/roguelike-shooting-game-with-upgrades.json

@@ -0,0 +1,68 @@
+{
+  "index": 695,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable whenever possible. Create a roguelike shooting game where after each room is cleared, the player gets to choose one ability upgrade from three options (such as ricochet, penetration, splitting, etc.). Use seed-based random generation for levels to ensure reproducibility. Implement a combination skill system: when specific ability combinations are activated, they trigger hidden effects (for example, freezing + explosion = expanded ice blast area). Use local storage to save the best completion records.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the roguelike shooting game core mechanics fully implemented?",
+      "description": "Review whether the code accurately implements player movement, shooting mechanics with collision detection, enemy AI behavior, and room-clearing objectives through HTML5 Canvas/JavaScript. Must include projectile physics, hit detection, health systems, and proper game state transitions between rooms. Score 0 if core shooting mechanics are missing, 5 if only basic movement and shooting exist, and 10 if all combat systems including enemy variety and balanced difficulty progression are fully implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the ability upgrade system with three-choice selection properly implemented?",
+      "description": "Check whether the game presents exactly three ability options after each room completion, including visual presentation of upgrade cards/panels with clear descriptions. Verify implementation of various abilities (ricochet, penetration, splitting, etc.) with proper visual and mechanical effects. Must include upgrade application logic and UI feedback. Deduct 5 points if upgrade selection interface is poorly designed, 3 points if ability effects are not visually represented. Full score requires at least 6 different upgrade types with distinct mechanics.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is seed-based random generation implemented with reproducibility guarantee?",
+      "description": "Evaluate whether the level generation uses a proper seed-based random number generator that produces identical room layouts, enemy placements, and upgrade sequences when using the same seed. Check if seed can be manually input for testing and if the generation algorithm creates varied, balanced room layouts. Deduct 5 points if randomization is not seed-based, 3 points if reproducibility is inconsistent. Requires demonstration of identical runs with same seed.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the combination skill system with hidden effects fully designed and functional?",
+      "description": "Check whether the code implements a robust combination detection system that triggers special effects when specific ability pairs/sets are acquired (e.g., freezing + explosion = ice blast). Must include visual indicators for active combinations, enhanced effects animation, and clear feedback when combinations activate. Deduct 5 points if fewer than 3 combinations exist, 3 points if combination effects are not visually distinct from base abilities. Full score requires at least 5 meaningful combinations with balanced gameplay impact.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid clicking, browser tab switching, invalid localStorage data, canvas rendering errors, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should effectively handle edge cases including game state corruption and performance degradation. Give 10 points if fully robust, 5 points if average robustness, and 0 points if no exception handling exists.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the roguelike experience (e.g., 1. Procedural soundtrack that adapts to player progress 2. Screen shake and particle effects synchronized with weapon impacts 3. Mini-map with fog-of-war exploration 4. Weapon trail effects that visualize upgrade combinations). Add 3 points for each practical innovative feature implemented (maximum 10 points). Features must demonstrably improve gameplay experience.",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple collision detection systems coexisting) 2. Function modules unrelated to roguelike gameplay (e.g., built-in social sharing) 3. Excessive visual effects that impact game performance (e.g., overuse of particle systems causing frame drops). Deduct 3 points for each redundancy found, and directly deduct 10 points if core gameplay is interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game engine/entities/upgrade system/rendering layers), proper class inheritance for game objects, and clean separation of concerns. Deduct 5 points if global state pollution is found or object-oriented principles are ignored; deduct 5 points if code duplication rate exceeds 30%; deduct 5 points if no clear architecture pattern is followed. Full score requires clean, maintainable code structure with proper abstraction layers.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional game design standards?",
+      "description": "Evaluate whether the game UI follows modern game design principles: 1) Coherent art style with consistent pixel density and color palette 2) Clear visual hierarchy with readable fonts (minimum 12px for UI text) 3) Intuitive iconography for abilities and game elements 4) Proper contrast ratios for accessibility. Deduct 3 points for each unclear UI element, 5 points for inconsistent visual style, and 5 points for poor readability. Screenshots must demonstrate professional visual polish.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and responsive for gaming?",
+      "description": "Judge whether the game maintains smooth 60fps performance with responsive controls: 1) Input lag ≤ 16ms for movement and shooting 2) Smooth animation transitions for ability effects and UI changes 3) Clear visual feedback for all player actions 4) Consistent frame timing during intense combat scenarios. Deduct 5 points for each noticeable performance hiccup, 3 points for delayed input response, and 5 points for animation stuttering. Must demonstrate smooth gameplay through video or interactive testing.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Shooting",
+  "difficulty": "hard"
+}

package/library/game_development-shooting/sandbox-shooting-game-editor-with-level-design.json

@@ -0,0 +1,68 @@
+{
+  "index": 638,
+  "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 when possible. Please develop a sandbox-style shooting game editor. Players can design their own shooting levels in the editor, place enemies, obstacles, and props, and set level objectives. After completing the editing, they can test and share their game. The editor supports drag-and-drop operations, property adjustments, and level saving functionality.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the shooting game editor's core functionality fully implemented?",
+      "description": "Review whether the code implements a complete canvas-based editor with drag-and-drop functionality for game elements (enemies, obstacles, props). Check if the editor includes a coordinate system, element selection, movement, and resizing capabilities. Score 0 if the core editor functionality is missing, 5 if only basic placement is implemented, and 10 if the editor offers comprehensive design capabilities including layers, grouping, and alignment tools.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the property adjustment features comprehensive and intuitive?",
+      "description": "Evaluate the property panel implementation that allows customization of game elements. Check if properties include basic attributes (position, size, appearance) and behavior parameters (enemy movement patterns, health points, damage values, collision responses). Deduct 3 points if visual feedback is missing when adjusting properties, 3 points if common properties require manual input rather than sliders/dropdowns, and 5 points if behavior scripting/configuration is absent. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the level testing functionality properly implemented?",
+      "description": "Assess whether the editor includes a robust play-test mode that accurately simulates gameplay without requiring export. Check for seamless switching between edit and play modes, real-time debugging tools, and the ability to pause/resume testing. Deduct 5 points if the game physics in test mode differs from final export, 3 points if there's no visual feedback for collisions/interactions during testing, and 5 points if performance diagnostics are missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are level saving and sharing mechanisms well-designed?",
+      "description": "Review the implementation of level persistence and sharing functionality. Check if levels are properly serialized/deserialized, whether the code includes versioning support for backward compatibility, and if export options include shareable formats. Deduct 5 points if there's no auto-save feature, 3 points if sharing requires manual file handling, and 5 points if imported levels lose custom properties. 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 invalid drag operations, corrupt level files, browser crashes, memory leaks with large levels, 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. AI-assisted level balancing 2. Community template library integration 3. Real-time collaborative editing 4. Visual scripting system for complex behaviors). 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 undo systems coexisting) 2. Function modules unrelated to the shooting game editor (e.g., built-in image editor when simple property controls would suffice) 3. Fancy effects that affect performance (e.g., excessive particle effects in the editor interface). 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 editor/game logic/rendering layers), 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 overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Drag-and-drop operations feel natural with appropriate snapping and visual feedback 2) Transition animations controlled between 300-500ms 3) Clear visual hierarchy and focus guidance. Deduct 5 points for each operation without feedback, 3 points for laggy performance during element manipulation, and 5 points for unintuitive UI workflows. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Shooting",
+  "difficulty": "hard"
+}