@getollie/cli 0.0.1

package/library/game_development-shooting/shooting-game-teams-ranking-system.json

@@ -0,0 +1,68 @@
+{
+  "index": 1719,
+  "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. Help me write code for a shooting game where each match has 100 players, with teams of 4 people. The last person or team standing wins and receives 100 points. Set up the ranking system however you think is best.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core battle royale gameplay mechanism properly implemented?",
+      "description": "Review whether the code accurately implements the 100-player battle royale system through appropriate data structures, including handling 4-player teams, player elimination tracking, and determining the last player/team standing. Check if the victory condition (last player/team standing gets 100 points) is correctly implemented. Score 0 if core game logic is missing, 5 if only basic elimination is implemented, 10 if the full team-based battle royale system is implemented with proper state management.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the team coordination system fully functional?",
+      "description": "Evaluate the implementation of the 4-player team mechanics, including team formation, in-game communication between team members, shared information (e.g., marking enemies, sharing resources), and team status tracking. Deduct 3 points if team coordination features are limited, 5 points if there's no way for teams to communicate or coordinate. The full score is 10 points if the team system is comprehensive with features like reviving teammates, sharing resources, etc.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the ranking system well-designed and implemented?",
+      "description": "Check whether the ranking system is comprehensive and fair, including MMR (Matchmaking Rating) calculations, tier/division system, seasonal resets, and performance-based adjustments. Point distribution should account for placement, eliminations, and possibly other factors. Deduct 5 points if the ranking is simplistic (only win/loss), 3 points if there's no anti-boosting mechanism. Full score for a sophisticated ELO-based or Glicko system with proper rank distribution.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the matchmaking system balanced and efficient?",
+      "description": "Analyze the matchmaking algorithm that forms 25 teams of 4 players each. It should balance team skill levels, minimize wait times, and handle edge cases (disconnections, partial teams). Deduct 5 points if skill balancing is missing, 3 points if there's no provision for handling disconnects during matchmaking. Full points for a system that optimizes both team balance and queue times with proper fallback mechanisms.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as player disconnections, team imbalance, cheating attempts, edge cases in combat) 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 map elements that change during gameplay 2. Special team-based abilities or synergies 3. Interactive spectator mode for eliminated players). 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 healing systems that overlap) 2. Function modules unrelated to a battle royale shooter (e.g., a built-in social media feed) 3. Fancy effects that affect performance (e.g., excessive particle systems that would cause lag in a 100-player game). 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/network 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 game UI principles: 1) Clear HUD showing team status, player health, map, and elimination feed 2) Proper information hierarchy (critical info like health more prominent) 3) Non-intrusive UI that doesn't block gameplay. Deduct 3 points for cluttered interfaces, 5 points for poorly contrasted or unreadable text during action, and 5 points for necessary information being hard to access quickly. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the game's responsive feedback conforms to expected shooter standards: 1) Hit registration feedback under 50ms 2) Weapon switching/reloading animations with appropriate duration 3) Clear visual and audio cues for critical events (damage taken, teammates down). Deduct 5 points for laggy combat mechanics, 3 points for confusing or missing team status updates, and 5 points for unclear danger indicators. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Shooting",
+  "difficulty": "hard"
+}

package/library/game_development-shooting/simple-fps-game-ak-hk416-dust2-multiplayer.json

@@ -0,0 +1,68 @@
+{
+  "index": 1712,
+  "question": "You are a coding expert. Please use your professional knowledge to generate accurate and professional responses. Ensure that the code you produce is executable when demonstrated. Please develop a simple FPS web game that can be directly opened in a browser when saved as an HTML file. The game should feature two types of guns: AK and HK416. The map should be inspired by \"dust2\" from CS. The game mode should be multiplayer free-for-all.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core FPS game mechanics fully implemented?",
+      "description": "Review whether the code accurately implements essential FPS mechanics: first-person camera controls, player movement (WASD), shooting mechanics, hit detection, and damage calculation. Check if recoil patterns differ between AK and HK416 weapons, with appropriate rate of fire, damage, and reload times for each. Score 0 if movement and shooting don't work, 5 if basic mechanics work but lack weapon differentiation, and 10 if all features are fully implemented with weapon-specific characteristics.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the dust2-inspired map properly implemented?",
+      "description": "Evaluate whether the map captures key recognizable elements of dust2 (such as bombsite A/B, mid, long A, tunnels) using appropriate 3D models or geometry. Check for proper collision detection with map elements, logical spawn points, and optimization techniques (such as occlusion culling). Deduct 5 points if only a basic sandbox exists without dust2 elements, deduct 3 points if collision detection is inconsistent, and deduct 3 points if the map layout isn't intuitive or playable. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the multiplayer free-for-all mode functional?",
+      "description": "Check whether the multiplayer implementation includes client-server communication (WebSockets/WebRTC), player synchronization, score tracking, respawn system, and match progression. Test if player positions, rotations, and actions are properly synchronized. Deduct 5 points if network lag isn't handled, 3 points if player synchronization is inconsistent, and 5 points if only local multiplayer is implemented. Full score requires functional remote multiplayer with at least 4+ concurrent players supported.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are the weapon systems detailed and distinguishable?",
+      "description": "Evaluate whether the AK and HK416 have distinct characteristics (damage, fire rate, recoil patterns, reload speed). Check for appropriate weapon models, animations, and sound effects. Verify ammo management, reloading animations, and weapon switching. Deduct 5 points if weapons are functionally identical, 3 points if visual/audio feedback is missing, and 5 points if fundamental weapon mechanics like reloading are absent. 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 latency, connection drops, resource loading failures, browser compatibility issues) 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. Killstreaks with rewards 2. Destructible environment elements 3. Custom weapon skins 4. Match replay system 5. Voice chat integration). 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 systems coexisting) 2. Function modules unrelated to an FPS game (e.g., a built-in puzzle minigame) 3. Fancy effects that affect performance (e.g., excessive particle effects causing frame 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/networking layers), code organization, and asset management. Check for proper use of WebGL/Three.js/Babylon.js patterns, consistency in coding style, and optimization techniques. Deduct 5 points if global state pollution is found; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if assets aren't properly managed or optimized. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional game UI standards?",
+      "description": "Evaluate whether the UI design follows modern FPS game principles: 1) Non-intrusive HUD elements (health, ammo, minimap) 2) Clear visual feedback for hits/damage 3) Intuitive scoreboard and player status indicators 4) Appropriate crosshair design that changes with movement/weapon. Deduct 3 points for obscured gameplay due to UI elements, 5 points for missing critical information (ammo/health), and 5 points for illegible text or confusing indicators. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the game performance and user experience optimized?",
+      "description": "Judge whether the game runs smoothly at 60+ FPS on mid-tier hardware: 1) Efficient rendering techniques and LOD systems 2) Audio spatialization for gunshots and footsteps 3) Responsive controls with customizable sensitivity 4) Appropriate loading screens and asset management. Deduct 5 points for frame rates below 30 FPS with few players, 3 points for audio issues or missing sound cues, and 5 points for unresponsive controls or input lag above 100ms. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Shooting",
+  "difficulty": "hard"
+}

package/library/game_development-shooting/simple-web-shooting-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1771,
+  "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 when possible. Create a simple web shooting game.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core shooting game mechanics fully implemented?",
+      "description": "Review whether the code accurately implements the player movement control, shooting mechanics, and hit detection through HTML5 Canvas/DOM elements. Score 0 if the core shooting interaction is not implemented, 5 if only basic shooting without collision detection exists, and 10 if it includes proper hit detection, target destruction, and score tracking.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the game physics and movement mechanics properly implemented?",
+      "description": "Evaluate if the game includes appropriate physics for movement (acceleration/deceleration, boundaries), projectile trajectory physics (velocity, gravity if applicable), and collision response. Deduct 3 points if movement feels unnatural, 3 points if projectiles don't follow expected paths, and 4 points if collision responses are unrealistic. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there a complete game structure with proper state management?",
+      "description": "Check whether the code includes a complete game lifecycle (start screen, gameplay, game over states) with proper state transitions. Verify if game parameters (health, score, ammunition) are tracked correctly. Deduct 4 points if there's no clear state management, 3 points if state transitions are buggy, and 3 points if game persistence is missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are the enemy/target behaviors and difficulty progression implemented?",
+      "description": "Assess if the game includes varied enemy types or targets with different behaviors, and whether difficulty increases over time (speed changes, spawn rates, etc.). Deduct 4 points if enemies have no varied behaviors, 3 points if difficulty remains static throughout gameplay, and 3 points if enemy spawning is too predictable. 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, browser resize, focus loss, resource loading failure, 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. Special weapons or power-ups 2. Destructible environment elements 3. Particle effects for impacts 4. Combo scoring system). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple collision detection systems) 2. Function modules unrelated to shooting gameplay (e.g., a built-in chat system) 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/input handling/rendering), use of appropriate design patterns, 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 the code is not properly organized into logical files/modules. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern game UI principles: 1) Clear player feedback and visual cues 2) Proper contrast for game elements vs. background 3) Consistent visual style and theme 4) Readable UI text and indicators. Deduct 3 points for each visually confusing element, 5 points for clashing visual styles, and 5 points for UI elements that obstruct gameplay. 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 and responsiveness meet user expectations: 1) Input response delay ≤ 50ms 2) Consistent frame rate (minimum 30fps) 3) Smooth transitions between game states. Deduct 5 points for input lag, 5 points for frame rate drops during normal gameplay, and 3 points for jarring transitions between screens/states. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Shooting",
+  "difficulty": "easy"
+}

package/library/game_development-shooting/terrain-destruction-shooting-game-with-fluid-simulation.json

@@ -0,0 +1,68 @@
+{
+  "index": 655,
+  "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. Develop a terrain destruction shooting game that uses Perlin noise to generate random terrain. When bullets hit the terrain, they should create realistic depressions and deformations, allowing players to destroy enemies behind cover. Implement fluid simulation: breaking water containers should release water that affects the movement speed of both players and enemies. Use WebGL to render advanced terrain effects.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the terrain generation with Perlin noise properly implemented?",
+      "description": "Evaluate whether the code correctly implements Perlin noise to generate random terrain with natural-looking variations. Check if the implementation includes multiple octaves for detail, proper frequency/amplitude settings, and terrain height normalization. Score 0 if Perlin noise is not implemented, 5 if basic implementation exists but lacks parameter tuning, and 10 if the terrain generation produces diverse, natural-looking landscapes with configurable parameters.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the terrain destruction mechanism realistic and effective?",
+      "description": "Review how bullets interact with the terrain. Check if pixel-perfect or physics-based collision detection is implemented, whether destruction creates proper deformations with debris effects, and if the terrain responds dynamically to different projectile types/sizes. Evaluate if the destruction algorithm preserves terrain stability (no floating islands unless intentional). Deduct 5 points if destruction is binary (all-or-nothing) rather than gradual, 3 points if the collision detection is imprecise, and 2 points if there are no visual effects for impact. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the fluid simulation physics accurately implemented?",
+      "description": "Assess if the fluid simulation follows realistic physical principles including pressure distribution, surface tension, and viscosity. Check if water flows naturally downward, pools in depressions, and interacts properly with terrain boundaries. Evaluate if water affects player/enemy movement speed proportionally to depth. Deduct 5 points if the fluid simulation is purely visual without affecting gameplay, 3 points if water behavior is unrealistic, and 5 points if there are no water containers that can be broken. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is WebGL properly utilized for advanced terrain effects?",
+      "description": "Evaluate whether the code leverages WebGL capabilities for rendering terrain with advanced effects such as dynamic lighting, shadows, normal mapping, or ambient occlusion. Check if shaders are used for terrain deformation instead of CPU-based calculations. Deduct 5 points if WebGL implementation is basic without custom shaders, 5 points if performance optimization techniques (like frustum culling or LOD) are missing, and 3 points if lighting effects don't respond to terrain changes. 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 resource loading failures, WebGL context loss, memory overflows with large terrains, 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 affecting gameplay 2. Procedural destruction sounds based on material types 3. Interactive terrain tools allowing players to build defenses). 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 physics calculations (e.g., multiple gravity systems coexisting) 2. Function modules unrelated to the shooting/destruction gameplay (e.g., unnecessary mini-games) 3. Fancy effects that severely impact 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 physics/rendering/game logic layers), shader code organization, and asset management system. 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 WebGL resources aren't properly managed (shader compilation, texture handling, buffer management). The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern game UI principles: 1) Harmonious color matching that doesn't interfere with gameplay visibility 2) Proper HUD layout that doesn't obstruct important game elements 3) Professional feedback system for player actions (hit markers, damage indicators). Deduct 3 points for cluttered UI elements, 5 points for visual elements that obscure gameplay, and 5 points for missing crucial feedback during destruction events. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the game performance maintains consistent 60 FPS during complex destruction and fluid simulation: 1) Input response delay ≤ 100ms 2) Consistent frame rate during explosions and terrain deformation 3) Smooth transitions between different game states. Deduct 5 points for frame drops below 30 FPS during standard gameplay, 3 points for input lag during intense moments, and 5 points for physics calculation errors causing unnatural behavior. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Shooting",
+  "difficulty": "hard"
+}

package/library/game_development-shooting/web-based-airplane-battle-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 323,
+  "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. Please create a web-based airplane battle game.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core game mechanics fully implemented?",
+      "description": "Review whether the code accurately implements the airplane movement, shooting mechanism, and collision detection. Check if player controls (keyboard/touch) are responsive and intuitive. Score 0 if core game mechanics are missing, 5 if only basic movement and shooting are implemented, and 10 if advanced features like powerups or multiple weapon types are included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the enemy AI system properly designed?",
+      "description": "Evaluate the intelligence and variety of enemy behaviors. Check if enemies have different movement patterns, attack strategies, or difficulty progression. Deduct 5 points if enemies move in fixed patterns only, 3 points if there's no difficulty scaling as the game progresses. Full score requires at least 3 distinct enemy types with unique behaviors.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the scoring and level progression system implemented?",
+      "description": "Check if the game includes a proper scoring system, level progression, and game state management (start, pause, game over). Verify if the difficulty increases with progression. Deduct 5 points if score tracking is missing, 3 points if level progression is absent, and 2 points if there's no game state management. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are the collision detection and physics accurate?",
+      "description": "Verify if collision detection between player, enemies, projectiles, and game boundaries is accurate. Check for physics elements like acceleration, deceleration, and inertia if applicable. Deduct 5 points for imprecise collision detection, 3 points for missing boundary handling, and 5 points if hit detection feels unnatural or laggy.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid input, browser resize, focus loss, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Special screen-clearing bombs 2. Dynamic weather effects 3. Unlockable airplane skins/upgrades). 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 systems that conflict) 2. Function modules unrelated to the airplane battle game (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive particle effects causing lag). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game 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 no 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 game UI principles: 1) Clear visual hierarchy (player, enemies, projectiles, UI elements) 2) Proper contrast between game elements and background 3) Readable UI indicators for health, score, and game state. Deduct 3 points for cluttered visuals, 5 points for poor contrast making gameplay difficult, and 5 points for unreadable or poorly positioned UI elements. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the game provides smooth gameplay experience: 1) Consistent frame rate without drops 2) Responsive controls with immediate feedback 3) Smooth animations for movement, explosions, and transitions. Deduct 5 points for noticeable frame drops, 3 points for input lag, and 5 points for choppy animations or visual glitches. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Shooting",
+  "difficulty": "medium"
+}

package/library/game_development-shooting/web-based-tank-battle-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1802,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code that can be demonstrated. Help me write code for a web-based game similar to Tank Battle.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the tank battle core game system fully implemented?",
+      "description": "Review whether the code accurately implements tank movement mechanics, collision detection with walls/obstacles, bullet firing system with trajectory calculation, and tank destruction logic through HTML5 Canvas/JavaScript. Check if tank controls are responsive (WASD/arrow keys), bullets have proper physics (speed, range, penetration), and hit detection is precise. Score 0 if core combat mechanics are missing, 5 if only basic movement is implemented, and 10 if complete tank battle system with multiple weapon types and power-ups is included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the battlefield environment and obstacle system properly designed?",
+      "description": "Evaluate whether the game includes a well-designed battlefield with destructible/indestructible walls, strategic cover positions, and environmental hazards. Check if collision detection works accurately for all terrain elements, if destructible walls have realistic destruction animations, and if the map layout provides tactical gameplay opportunities. Deduct 3 points if wall collision is imprecise, 5 points if destructible elements don't function properly. Full score requires multiple map layouts with varying strategic elements.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is multi-player functionality or AI opponent system implemented?",
+      "description": "Check whether the game supports either local multiplayer (split controls) or AI-controlled enemy tanks with intelligent behavior patterns. For AI implementation, evaluate pathfinding algorithms, tactical decision-making, and difficulty scaling. For multiplayer, assess control separation and fair gameplay mechanics. Deduct 5 points if AI behavior is too predictable or simplistic, 3 points if multiplayer controls conflict. Full score requires sophisticated AI with multiple difficulty levels or smooth multiplayer experience.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the complete game progression and scoring system constructed?",
+      "description": "Verify whether the code includes comprehensive game state management with level progression, scoring system, lives/health management, and win/lose conditions. Check for features like high score tracking, level advancement mechanics, bonus systems, and game restart functionality. Deduct 5 points if no progression system exists, 3 points if scoring is basic without bonuses. Give 10 points if full campaign mode with multiple levels and achievement system is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid key presses, boundary collisions, simultaneous bullet impacts, frame rate drops, etc.) and provide stable gameplay without crashes or glitches. Code with strong robustness should effectively handle edge cases like multiple collisions, memory leaks from bullet objects, and performance optimization. Give 10 points for excellent error handling, 5 points for 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 engaging features that enhance gameplay experience (e.g., 1. Special weapon types with unique effects 2. Environmental interactions like exploding barrels 3. Tank customization options 4. Replay system with slow-motion highlights 5. Particle effects for explosions). Add 2-3 points for each well-implemented innovative feature that adds genuine value to gameplay (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple collision detection systems coexisting) 2. Function modules unrelated to tank battle gameplay (e.g., built-in social media integration) 3. Excessive visual effects that impact performance (e.g., overly complex particle systems causing frame drops). Deduct 3 points for each redundancy found, and directly deduct 10 points if core gameplay is hindered by unnecessary features.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (separating game engine/rendering/input/physics systems), code organization with proper class structures, and performance optimization. Deduct 5 points if global variable pollution is found or no design patterns are used; deduct 5 points if code duplication rate exceeds 30%; deduct 3 points if no frame rate optimization or object pooling for bullets/effects is implemented. Full score requires clean architecture with separated concerns and optimized performance.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional game design standards?",
+      "description": "Evaluate whether the visual design follows game UI principles: 1) Consistent pixel art or vector graphics style 2) Clear visual hierarchy with readable HUD elements (health, score, ammo) 3) Appropriate color contrast for gameplay visibility 4) Professional sprite design for tanks and environmental elements. Deduct 3 points for each poorly designed visual element, 5 points for inconsistent art style, and 5 points if UI elements obstruct gameplay view. Full score requires polished, cohesive visual design.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether game controls and animations provide smooth gameplay experience: 1) Input response delay ≤ 50ms for tank movement 2) Smooth tank rotation and movement animations at 60fps 3) Satisfying explosion effects and screen shake feedback 4) Audio-visual synchronization for shooting and impacts. Deduct 5 points for each laggy control response, 3 points for choppy animations during intense gameplay, and 5 points for missing or poorly timed feedback effects. Full score requires console-quality smooth gameplay feel.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Shooting",
+  "difficulty": "hard"
+}

package/library/game_development-shooting/web-version-contra-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 265,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure to ensure the code you generate is executable. Create a web version of Contra for me that can be played directly after running.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core Contra gameplay mechanics fully implemented?",
+      "description": "Review whether the code accurately implements the classic Contra mechanics: running, jumping, shooting in 8 directions, and weapon power-ups. Check if the character movement feels responsive (< 50ms delay) and if the hit detection system works correctly for both player and enemy interactions. Score 0 if the core mechanics are missing, 5 if basic movement and shooting are implemented but lack refinement, and 10 if the gameplay feels authentic to the original Contra experience.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the level design and progression system properly implemented?",
+      "description": "Evaluate whether the code includes at least one complete level with proper enemy placement, terrain obstacles (platforms, water, etc.), and a boss fight at the end. Check if the game has a proper level progression system (either through multiple levels or checkpoints). Deduct 5 points if the level design is too simplistic or empty, and 3 points if there's no boss implementation. Give full 10 points only if the level design captures the essence of Contra's challenging but fair gameplay.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the enemy AI and variety properly implemented?",
+      "description": "Check if the game includes multiple enemy types with distinct behaviors (e.g., stationary shooters, runners, jumpers, and turrets). Evaluate whether the enemy AI provides adequate challenge without being unfair. Verify if enemies spawn at appropriate rates and locations. Deduct 5 points if enemy AI is too simplistic (just moving in one direction), and 3 points if there's less than 3 different enemy types. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the weapon system and power-up collection mechanism implemented?",
+      "description": "Assess whether the code implements Contra's iconic weapon system, including at least 3 different weapon types (e.g., spread gun, laser, rapid fire) and the power-up collection mechanism. Check if weapon switching works correctly and if there's appropriate visual and audio feedback when collecting power-ups. Deduct 5 points if only the default weapon is implemented, and 3 points if weapon switching has bugs. 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 user input, browser window resizing, focus loss, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Two-player cooperative mode 2. Custom level editor 3. Secret areas and unlockable content). 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 Contra gameplay (e.g., a built-in chat system) 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 layers), sprite and asset management, and game loop implementation. Deduct 5 points if global state pollution is found or proper 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 proper game state management system. 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 the classic Contra aesthetic while maintaining modern UI principles: 1) Faithful sprite artwork and animations that respect the original style 2) Proper HUD layout showing lives, score, and current weapon 3) Consistent pixel art style throughout the game. Deduct 3 points for inconsistent visual style, 5 points for a hard-to-read HUD, and 5 points for low-quality or mismatched sprite artwork. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the game runs at a consistent frame rate (ideally 60 FPS) and whether the controls are responsive: 1) Input lag < 50ms 2) Smooth animations without stuttering 3) Appropriate sound effects and visual feedback for all actions. Deduct 5 points if the game has noticeable frame drops, 3 points for delayed input response, and 5 points if sound effects are missing or mismatched. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Shooting",
+  "difficulty": "hard"
+}

package/library/game_development-shooting/webpage-2d-shooting-mini-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1562,
+  "question": "You are a coding expert. Please use your professional knowledge to generate accurate and professional responses. Make sure that the code you generate is executable for demonstration. Help me create a webpage with a 2D shooting mini-game similar to Contra.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core shooting game mechanics fully implemented?",
+      "description": "Review whether the code accurately implements player movement (8-directional control), weapon shooting system with different bullet types, enemy AI behavior patterns, and collision detection between bullets/enemies/environment. Score 0 if basic shooting mechanics are missing, 5 if only simple movement and shooting exist, and 10 if includes multiple weapon types, enemy variety, and accurate hit detection with visual feedback.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the game physics and animation system properly constructed?",
+      "description": "Check whether the implementation includes smooth sprite animations (running, shooting, jumping), proper physics for bullet trajectories, gravity effects for jumping mechanics, and frame-rate independent movement. Deduct 5 points if animations are choppy or inconsistent, 3 points if physics calculations cause glitches. Evaluate sprite sheet management and animation timing. Full score requires 60fps performance with smooth character animations.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are game levels and progression mechanics implemented?",
+      "description": "Evaluate whether the code includes multiple game levels with increasing difficulty, enemy spawn patterns, power-up systems (weapon upgrades, health packs), and score tracking. Check for level progression logic, checkpoint systems, and boss battles. Deduct 5 points if only single-screen gameplay exists, 3 points if no progression mechanics. Full score requires multiple levels with distinct challenges and upgrade systems.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the complete game state management system constructed?",
+      "description": "Check whether the code includes comprehensive game state management covering start screen, gameplay, pause/resume, game over, and high score systems. Evaluate local storage implementation for saving progress and settings. Deduct 5 points if state transitions are buggy, 3 points if no save/load functionality. Give 10 points if includes complete menu systems, settings management, and persistent data storage.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid key presses, browser tab switching, memory leaks from game objects, frame rate drops, etc.) and provide graceful degradation. Code with strong robustness should include proper cleanup of game objects, error boundaries, and performance monitoring. Give 10 points for excellent error handling, 5 points if robustness is average, and 0 points if no exception handling exists.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes impressive features that enhance gameplay experience (e.g., 1. Particle effects for explosions and impacts 2. Dynamic background music and sound effects 3. Screen shake and visual juice 4. Procedural level generation 5. Special weapon mechanics). Add 3 points for each well-implemented innovative feature 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 game loop implementations or duplicate collision detection systems 2. Unrelated features like social media integration or complex UI frameworks 3. Performance-heavy effects that don't enhance core gameplay (e.g., excessive particle systems, unnecessarily complex shaders). Deduct 3 points for each redundancy found, and directly deduct 10 points if redundant code interferes with game performance or core mechanics.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular architecture (separating game engine, entities, input handling, rendering layers), proper asset management, and code organization. Deduct 5 points if global variables pollute the namespace or no design patterns are used; deduct 5 points if code has high duplication (over 30%); deduct 5 points if no proper asset loading or memory management. Full score requires clean separation of concerns and maintainable code structure.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional game design standards?",
+      "description": "Evaluate whether the visual design follows game UI principles: 1) Consistent pixel art style or coherent visual theme 2) Readable HUD elements with proper contrast 3) Intuitive visual hierarchy for game elements 4) Appropriate sprite scaling and resolution. Deduct 3 points for each visual inconsistency, 5 points for poor readability of game elements, and 5 points for mismatched art styles. Full score requires polished, cohesive visual presentation.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the game interaction responsive and intuitive?",
+      "description": "Judge whether the game controls and feedback meet gaming standards: 1) Input response time ≤ 16ms (60fps standard) 2) Clear visual and audio feedback for all actions 3) Intuitive control scheme with proper key mapping 4) Consistent interaction patterns throughout gameplay. Deduct 5 points for each unresponsive control, 3 points for missing feedback on important actions, and 5 points for confusing or inconsistent control schemes. Full score requires tight, responsive controls with excellent game feel.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Shooting",
+  "difficulty": "hard"
+}