@getollie/cli 0.0.1

package/library/game_development-shooting/bubble-shooter-game-implementation.json

@@ -0,0 +1,68 @@
+{
+  "index": 534,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you provide is executable. Please implement a Bubble Shooter style game. The player controls a cannon at the bottom, adjusts the angle by moving the mouse, and clicks to shoot colored bubbles. Above is a matrix of colored bubbles arranged in hexagonal patterns. When a shot bubble connects with 3 or more bubbles of the same color, they are eliminated. Requirements: 1. Bubble physics and adhesion algorithm 2. Matrix structure detection 3. Trajectory prediction line 4. Chain elimination animation.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Bubble physics and adhesion algorithm implementation",
+      "description": "Evaluate whether the code accurately simulates bubble physics (movement, collision) and properly implements the adhesion algorithm that makes bubbles stick to the grid. Check if bubbles correctly snap to the hexagonal grid when they collide with other bubbles or the ceiling.0 points if bubble physics is missing, 5 points if basic movement is implemented but adhesion has issues, 10 points if physics behaves realistically and adhesion is pixel-perfect. Deduct 3 points if there are edge cases where bubbles behave erratically.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Hexagonal matrix structure and detection algorithm",
+      "description": "Review the implementation of the hexagonal grid structure and the algorithm for detecting connected bubbles. Check if the code efficiently identifies clusters of 3+ same-colored bubbles and properly manages the matrix state after eliminations.0 points if the hexagonal structure is not implemented, 5 points if basic structure exists but has detection flaws, 10 points if the hexagonal grid is perfectly implemented with efficient neighbor detection algorithms. Deduct 3 points if the algorithm fails in complex scenarios (e.g., bubbles becoming orphaned).",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Trajectory prediction line accuracy",
+      "description": "Assess the trajectory prediction line's accuracy in showing where bubbles will travel, including proper bounce physics off walls. The prediction should update in real-time as the player moves the mouse.0 points if trajectory prediction is missing, 5 points if basic straight-line prediction exists, 10 points if prediction handles bounces accurately. Deduct 3 points if the prediction doesn't match actual bubble movement or flickers during mouse movement.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Chain elimination animation quality",
+      "description": "Evaluate the visual feedback and animations when bubbles are eliminated. Check for smooth popping animations, proper scoring displays, and visual/audio feedback that enhances player satisfaction.0 points if no elimination animations exist, 5 points for basic disappearing effects, 10 points for professional animations with particle effects and sound synchronization. Deduct 3 points if animations cause performance issues or visual glitches.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Code robustness and error handling",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid-fire clicks, extreme angles, browser resizing, etc.) and provide friendly error prompts or recovery mechanisms.Code with strong robustness should 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. Deduct 3 points for each uncaught exception that breaks gameplay.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Innovative features that enhance gameplay",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Power-ups/special bubbles 2. Difficulty progression 3. Score multipliers 4. Visual/audio feedback systems).Add 3 points for each practical innovative feature implemented (maximum 10 points). Features must be fully functional and meaningfully impact gameplay to receive points.",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Code optimization and performance",
+      "description": "Assess whether the game maintains stable 60 FPS performance even with many bubbles and animations. Check for optimization techniques like object pooling, efficient collision detection, and proper canvas rendering.Deduct 3 points for each performance issue (e.g., frame drops during animations, input lag, memory leaks). Deduct 5 points if the game becomes unplayable on standard hardware when the grid fills up. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Engineering quality and code organization",
+      "description": "Review modular design (separation of game logic/view/physics), use of appropriate design patterns, and code reusability. Check for proper encapsulation and minimal global state.Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if code duplication rate is too high (over 30%); deduct 5 points if there's no clear separation between game logic and rendering. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Visual design and user interface quality",
+      "description": "Evaluate whether the overall design follows game design principles: 1) Consistent bubble color scheme with clear differentiation 2) Proper UI layout with score/level information 3) Readable fonts and intuitive controls.Deduct 3 points for each unclear visual element, 5 points for poor color choices that make matching difficult, and 5 points for unintuitive UI that hinders gameplay. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Game feel and interaction responsiveness",
+      "description": "Judge whether the game controls feel satisfying and responsive: 1) Cannon rotation follows mouse smoothly 2) Shooting has immediate feedback 3) Bubble collisions feel impactful with appropriate sound/visual effects.Deduct 5 points for input lag exceeding 100ms, 3 points for jerky animations, and 5 points for unclear feedback when shooting or eliminating bubbles. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Shooting",
+  "difficulty": "hard"
+}

package/library/game_development-shooting/contra-style-game-development.json

@@ -0,0 +1,68 @@
+{
+  "index": 1514,
+  "question": "You are a coding expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable for demonstration. Write code for a game similar to the NES/Famicom Contra game.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core game character movement and control system fully implemented?",
+      "description": "Review whether the code accurately implements the classic Contra character movement mechanics including running, jumping, crouching, and aiming in 8 directions. Score 0 if core movement is missing, 5 if basic movement is implemented but lacks fluidity, and 10 if the character control feels responsive with proper acceleration/deceleration and matches the original NES Contra feel.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the shooting and weapon system thoroughly developed?",
+      "description": "Check if the code implements the iconic Contra weapon system with different weapon types (regular gun, machine gun, spread gun, laser, flame thrower). Evaluate bullet physics, collision detection, and weapon switching mechanism. Deduct 5 points if fewer than 3 weapon types are implemented, and 3 points if weapon pickup mechanics are missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the enemy AI and spawn system properly implemented?",
+      "description": "Assess whether the code includes varied enemy types with distinct movement patterns and attack behaviors similar to the original Contra. Check if the enemy spawn system follows logical patterns based on level progression. Deduct 5 points if enemies have no AI variation, 3 points if spawn patterns are random rather than designed. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are the level design and stage progression mechanics implemented?",
+      "description": "Evaluate if the code includes at least 2 different stage types (side-scrolling and pseudo-3D perspective stages) with proper checkpoints, boss encounters, and scene transitions. Check for implementation of the iconic level features like destructible environments and vertical scrolling sections. Score 0 if only a single static level exists, 5 for basic scrolling levels, and 10 for complete level progression system.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid input combinations, collision edge cases, game state persistence during browser refresh, 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. Modern visual effects while maintaining retro feel 2. Customizable character skins 3. Level editor functionality 4. Co-op multiplayer support). 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 coexisting) 2. Function modules unrelated to a Contra-style game (e.g., unnecessary RPG elements) 3. Fancy effects that affect performance (e.g., excessive particle effects causing framerate 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/view/input handlers/physics), sprite management efficiency, and performance optimization. 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 rendering optimization techniques are missing (e.g., sprite batching, object pooling). The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the visual design capture the authentic NES/Famicom Contra aesthetic?",
+      "description": "Evaluate whether the visual design faithfully reproduces the iconic Contra pixel art style: 1) Proper use of limited color palette (NES-like constraints) 2) Authentic sprite animations matching the original game's frame counts 3) Appropriate screen resolution and scaling (maintaining proper pixel ratio). Deduct 3 points for inconsistent art style, 5 points for modern visual effects that break the retro aesthetic, and 5 points for improper scaling causing visual artifacts. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the audio and game feel implementation authentic to the original?",
+      "description": "Judge whether the game successfully recreates the iconic Contra audio-visual experience: 1) Implementation of the classic sound effects and music 2) Screen shake and visual feedback on hits/explosions 3) Appropriate game difficulty curve and death mechanics. Deduct 5 points for missing sound effects, 3 points for inconsistent game feel compared to the original, and 5 points if the iconic Contra jingles and music themes are absent. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Shooting",
+  "difficulty": "hard"
+}

package/library/game_development-shooting/first-person-shooter-game-with-obstacles-and-enemies.json

@@ -0,0 +1,68 @@
+{
+  "index": 691,
+  "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. Implement a first-person shooter game where the player controls the view direction with the mouse and fires bullets by clicking. The scene will have both static and dynamic obstacles, with bullets able to penetrate some obstacles. Enemies will appear from random locations and approach the player. The player needs to destroy all enemies to advance to the next level.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the first-person view perspective and mouse control properly implemented?",
+      "description": "Check if the code accurately implements first-person camera mechanics with proper quaternion rotation for smooth view transitions. The mouse should control both horizontal (yaw) and vertical (pitch) camera rotations with configurable sensitivity. Verify that pitch constraints prevent camera flipping (typically -89° to 89° pitch limit). Give 5 points for basic mouse look implementation, 8 points if it includes smooth damping, and 10 points if it also handles edge cases like frame rate independence and has proper constraints.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the shooting mechanism fully functional?",
+      "description": "Evaluate the implementation of bullet firing, including raycasting for hit detection, bullet physics (if applicable), and visual feedback. Check for proper mouse click handling, cooldown/rate of fire implementation, and recoil effects. The shooting should include proper collision detection with different obstacle types. Award 4 points for basic shooting, 7 points if it includes appropriate sound effects and visual feedback, and 10 points if it also handles penetrable vs. non-penetrable obstacles correctly with appropriate physics.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the obstacle types and bullet penetration mechanics well-implemented?",
+      "description": "Review how different obstacle types are defined and handled. The code should distinguish between penetrable and non-penetrable obstacles, with appropriate visual and physical properties for each. Check if bullet penetration mechanics include factors like material types, thickness, bullet velocity degradation, and potential trajectory changes. Award 10 points if all these aspects are properly implemented, 5 points if only basic penetration is handled, and 0 points if obstacles are not differentiated.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the enemy AI and spawning system properly designed?",
+      "description": "Assess the enemy spawning algorithm (should use proper randomization without unfair clustering), pathfinding implementation (A* or NavMesh), and approach behavior. Enemies should navigate around obstacles intelligently while approaching the player. Verify level progression logic after all enemies are destroyed. Award 3 points for basic spawning, 3 points for proper pathfinding, 2 points for enemy behavior variation, and 2 points for level progression implementation.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid multiple inputs, edge collisions, performance spikes, etc.) and provide graceful 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 lighting effects for gunshots 2. Enemy damage visual feedback system 3. Environmental destruction mechanics 4. Player health regeneration system). Add 2.5 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 systems coexisting) 2. Function modules unrelated to FPS gameplay (e.g., unnecessary RPG elements) 3. Fancy effects that affect performance (e.g., excessive particle systems that cause 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/input/rendering layers), component organization, and code reusability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if proper optimization techniques (object pooling, LOD, etc.) are not implemented for performance-critical sections. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the HUD design follows modern FPS design principles: 1) Non-intrusive elements that don't obstruct gameplay visibility 2) Clear ammunition/health indicators positioned in screen corners 3) Subtle hit markers and damage indicators 4) Enemy highlighting that doesn't break immersion. Deduct 3 points for each obstructive UI element, 5 points for visual clutter during intense gameplay, and 5 points for missing critical information (ammo count, health). 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 FPS game standards: 1) Input response delay ≤ 50ms for shooting 2) Consistent frame rate above 30 FPS minimum 3) Appropriate weapon recoil and movement animations 4) Smooth enemy death animations without breaking gameplay flow. Deduct 5 points for input lag exceeding 100ms, 3 points for frame drops during normal gameplay, and 5 points for jarring transitions between animations. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Shooting",
+  "difficulty": "hard"
+}

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

@@ -0,0 +1,68 @@
+{
+  "index": 950,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code when possible. Create an HTML-based airplane battle game.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core game mechanics fully implemented?",
+      "description": "Evaluate whether the code implements the essential airplane battle game mechanics: player movement, enemy spawning, bullet firing, collision detection, and scoring system. Score 0 if the core interaction logic is missing, 5 if only basic movement and shooting are implemented, and 10 if all essential battle mechanics (including enemy AI patterns and power-ups) are fully included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the game loop and rendering system properly designed?",
+      "description": "Check whether the game implements a proper game loop using requestAnimationFrame or similar technique, with separate update and render cycles. Verify that sprite rendering is optimized (using canvas or efficient DOM manipulation). Deduct 5 points if the game has performance issues above 30 FPS, 3 points if animation is jerky, and 3 points if there's no frame rate management. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the game controls responsive and intuitive?",
+      "description": "Assess whether the game provides responsive controls (keyboard/touch/mouse) with proper event handling and input buffering. Test if the player airplane responds within 50ms of input, and if there are alternative control schemes for different devices. Deduct 5 points if controls feel laggy, and 5 points if the game isn't playable across different input methods. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a complete game progression system?",
+      "description": "Review whether the game includes a progression system with increasing difficulty levels, waves of enemies, boss battles, and game states (start screen, gameplay, game over, pause). Check for score persistence and level advancement logic. Deduct 5 points if difficulty never increases, 3 points if there's no pause functionality, and 5 points if game state transitions are abrupt or missing. 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 browser resizing, focus loss, unexpected user input, 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. Dynamic weather effects 3. Procedurally generated enemy patterns 4. Interactive background elements). 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 airplane battle game (e.g., an unnecessary settings menu with too many options) 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 entity classes, rendering engine, input handling), code organization, and maintainability. Deduct 5 points if global state pollution is found or if proper object-oriented/functional patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no clear separation between game logic and presentation. 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 design principles: 1) Consistent visual style and theme 2) Clear visual hierarchy with important elements (player health, score) easily visible 3) Proper contrast between game elements and background 4) Readable text elements even during intense gameplay. Deduct 3 points for each cluttered UI element, 5 points for poor contrast making gameplay difficult, and 5 points for inconsistent visual style. 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 game feel principles: 1) Visual feedback for all player actions (shooting, taking damage, power-ups) 2) Enemy destruction animations and effects 3) Screen shake and other juice elements for impactful moments 4) Smooth transitions between game states. Deduct 5 points for each action without feedback, 3 points for jarring or missing transitions, and 5 points for confusing visual feedback during gameplay. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Shooting",
+  "difficulty": "medium"
+}

package/library/game_development-shooting/html-airplane-shooting-game-with-images.json

@@ -0,0 +1,68 @@
+{
+  "index": 1279,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure that the code you generate is executable for display. Create a computer airplane game shooting monsters code with images (in HTML format).",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core game mechanics of airplane shooting fully implemented?",
+      "description": "Review whether the code accurately implements player movement, shooting mechanics, enemy generation, and collision detection. Score 0 if the core gameplay is not implemented, 5 points if only basic movement and shooting exists, and 10 points if the game includes varying enemy types, different weapons, and proper game difficulty progression.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the game graphics and visual elements properly implemented?",
+      "description": "Check whether the game uses appropriate images for the player airplane, enemies, bullets, explosions, and background. Evaluate image quality, animation smoothness, and visual feedback. Deduct 3 points if images are missing or placeholder graphics are used, 3 points if animations are jerky, and 3 points if visual feedback for events (hits, explosions, power-ups) is inadequate. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the game loop and state management properly implemented?",
+      "description": "Evaluate if the code includes proper game loop implementation (requestAnimationFrame or similar), game states (start screen, playing, game over), score tracking, and level progression. Deduct 5 points if the game loop causes performance issues, 3 points if game states are incomplete, and 3 points if score/level management is missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the game have proper controls and user interaction?",
+      "description": "Check if the game implements responsive keyboard/mouse controls for the airplane, with proper event handling for multiple simultaneous inputs. Evaluate if touch controls are included for mobile devices. Deduct 5 points if controls are laggy or unresponsive, 3 points if only keyboard or only mouse control is implemented, and 5 points if mobile touch support is missing. 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 window resizing, browser tab switching, input device disconnection, 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. Power-up systems with special weapons 2. Boss battles with unique mechanics 3. Dynamic difficulty adjustment 4. Particle effects for visual flair). 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 algorithms) 2. Function modules unrelated to the airplane game (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive particle systems that cause lag). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game logic/rendering/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 the code lacks comments or documentation. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern game design principles: 1) Harmonious color matching with appropriate contrast for game elements 2) Proper UI layout with clear visibility during gameplay 3) Professional text display (score, lives, level information) that doesn't interfere with gameplay. Deduct 3 points for each cluttered UI element, 5 points for poor visual hierarchy, and 5 points for text that is difficult to read during gameplay. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the game's performance and responsiveness meet standards: 1) Consistent frame rate above 30fps 2) Input response time ≤ 100ms 3) Smooth animations for game elements. Deduct 5 points for frame rate drops during normal gameplay, 3 points for delayed response to player input, and 5 points for jerky animations that affect gameplay. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Shooting",
+  "difficulty": "medium"
+}

package/library/game_development-shooting/html-contra-style-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 434,
+  "question": "You are a coding expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the generated code is executable for demonstration. Develop an HTML format Contra-style game that can run directly in the browser.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core game mechanics completely implemented?",
+      "description": "Review whether the code accurately implements the Contra-style game mechanics including character movement (running, jumping, crouching), shooting mechanisms, and enemy AI behavior. Score 0 if the core mechanics are absent, 5 if only basic movement is implemented, and 10 if the implementation closely resembles the Contra gameplay experience with fluid controls and interactions.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the level design and environment interaction properly implemented?",
+      "description": "Evaluate whether the code includes proper level design with platforms, obstacles, terrain collisions, and scrolling backgrounds typical of Contra games. Check if the character can interact with the environment (climbing ladders, hiding behind cover). Deduct 5 points if collision detection is buggy, 3 points if scrolling mechanism is jerky, and 3 points if platform interactions are incomplete. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the weapon system and power-up mechanism fully functional?",
+      "description": "Check whether the game implements multiple weapon types (spread gun, laser, rapid fire, etc.) and power-up collection mechanics similar to the original Contra. Assess if weapon switching is implemented and if visual/audio feedback is provided when firing or collecting power-ups. Score 0 if weapons are not implemented, 5 if only basic shooting exists, and 10 if a complete Contra-like weapon system is available.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the enemy system and boss battles properly designed?",
+      "description": "Review if the code includes various enemy types with different attack patterns and behaviors (soldiers, turrets, flying enemies), and challenging boss encounters with health bars and phase-based mechanics. Deduct 3 points if enemy variety is limited, 5 points if boss battles are missing, and 3 points if enemy spawn logic is poorly implemented. 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, window resizing, browser compatibility issues, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should implement browser detection, handle frame rate drops gracefully, and manage memory efficiently. Give 10 points for comprehensive error handling, 5 points for basic error handling, and 0 points if no exceptions are handled.",
+      "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. Modern visual effects while maintaining retro feel 2. Co-op gameplay via keyboard splitting 3. Custom level editor 4. Persistent high score 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 Contra-style gameplay (e.g., unnecessary social features) 3. Overly complex 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 engine/game logic/rendering layers), game loop implementation, asset loading optimization, and performance considerations. Deduct 5 points if global state pollution is found; deduct 3 points if the game loop implementation is inefficient; deduct 3 points if the code lacks comments or documentation. Check if the code follows game development best practices. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the visual design captures the essence of Contra while maintaining a clean UI: 1) Faithful pixel art style or appropriately modernized graphics 2) Clear HUD displaying lives, score and weapons 3) Proper contrast between characters, enemies and backgrounds. Deduct 3 points for cluttered UI elements, 5 points for visual elements that clash with the Contra aesthetic, and 5 points for poor readability of essential game information. 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 consistent frame rates (ideally 60fps) and responsive controls: 1) Input responsiveness ≤ 50ms 2) Smooth animations for character movement and attacks 3) Proper collision feedback with visual/audio cues. Deduct 5 points for input lag, 3 points for animation stuttering, and 5 points for inconsistent collision detection. Check if the game maintains performance during intense action sequences with multiple enemies and projectiles. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Shooting",
+  "difficulty": "hard"
+}

package/library/game_development-shooting/html-cs-game-minecraft-style.json

@@ -0,0 +1,68 @@
+{
+  "index": 1745,
+  "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. Help me design a \"Counter-Strike\" game in HTML format, with health points, explosion effects after death, bullet trails, and character models that look like Steve from \"Minecraft\".",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core FPS gameplay mechanic implemented?",
+      "description": "Evaluate whether the code effectively implements essential first-person shooter mechanics including movement controls (WASD), targeting/aiming with mouse, shooting mechanics with cooldown, and hit detection. Score 0 if core gameplay is missing, 5 if basic movement and shooting exist but lack precision, and 10 if the implementation feels responsive with appropriate physics and hit registration.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the health point system properly implemented?",
+      "description": "Check if the health system includes visual indicators, damage calculation logic, and appropriate player feedback. The system should handle different damage types, show visual health status, and implement proper death conditions. Deduct 5 points if health regeneration or damage types are missing, 3 points if visual indicators aren't clear. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the explosion effects after death convincing?",
+      "description": "Assess the quality of death animations and explosion effects. Effects should include particle systems, appropriate sound effects, and smooth transition to respawn state. Effects should be visually impressive without impacting performance. Score 10 for full physics-based particle systems with sound, 5 for basic animations, 0 if death effects are missing.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are bullet trails and shooting mechanics realistic?",
+      "description": "Evaluate if bullet trails use appropriate visual effects (line rendering, particle systems) with correct timing and opacity fade. Check if bullet physics include trajectory calculations, penetration logic, and hit markers. Deduct 3 points if trails don't match weapon types, 5 points if bullet physics are unrealistic. 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, memory management issues, input conflicts, 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 lighting effects 2. Weather system affecting gameplay 3. Destructible environment components). 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 mechanisms coexisting) 2. Function modules unrelated to FPS gameplay (e.g., a built-in puzzle minigame) 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 layers), asset loading optimization, and performance considerations. 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 asset loading isn't optimized. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the Minecraft-style character design look authentic?",
+      "description": "Evaluate whether the Steve character models follow the authentic Minecraft aesthetic: 1) Proper blocky proportions with 2:1:2 body ratio 2) Pixelated textures without anti-aliasing 3) Appropriate animation that maintains the blocky feel. Deduct 3 points for incorrect proportions, 5 points for non-pixelated textures, and 5 points for animations that break the blocky aesthetic. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the game performance and responsiveness optimized?",
+      "description": "Judge whether the game maintains responsive performance: 1) Consistent 60 FPS during gameplay 2) Input latency under 50ms 3) Efficient resource management especially during effects. Deduct 5 points for frame drops below 30 FPS, 3 points for noticeable input lag, and 5 points for memory leaks or growing resource consumption. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Shooting",
+  "difficulty": "hard"
+}

package/library/game_development-shooting/html-space-shooter-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1240,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Make sure the code you provide is executable when possible. Write an HTML code for a space shooter game.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core gameplay of the space shooter implemented?",
+      "description": "Review whether the code accurately implements the basic space shooter mechanics including player movement, enemy spawning, shooting mechanics, and collision detection. Score 0 if no core gameplay elements are implemented, 5 if only basic movement and shooting are present, and 10 if it includes enemy variety, player lives/health system, and proper game flow.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the canvas or game rendering system properly implemented?",
+      "description": "Check whether the game uses appropriate rendering techniques (Canvas API, WebGL, or DOM manipulation) with proper frame rate management. Verify that visual elements are drawn correctly with smooth animation (60fps target). Deduct 3 points if frame rate is inconsistent, 5 points if rendering has noticeable artifacts, and 5 points if no animation loop is implemented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are game controls responsive and appropriate?",
+      "description": "Evaluate whether the player controls (keyboard/mouse/touch) are implemented with proper event handling, including preventing default browser behaviors when needed. Controls should be responsive (≤50ms delay) and intuitive. Deduct 5 points if controls are laggy, 3 points if mobile support is missing when claimed, and 5 points if key events aren't properly managed. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the game state management and scoring system implemented?",
+      "description": "Check whether the code includes proper game state management (start screen, gameplay, game over) and scoring mechanics. The game should track player progress, display current score, and maintain high scores if applicable. Deduct 3 points for missing game states, 5 points for no scoring system, and 3 points for not persisting high scores if that feature is mentioned. 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 window resizing, browser compatibility issues, rapid input changes, etc.) and provide friendly error handling. Code with strong robustness should gracefully 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 and special weapons 2. Dynamic difficulty adjustment 3. Particle effects for explosions 4. Boss battles). 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 space shooter game (e.g., unnecessary UI elements) 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 entities/rendering/input handling), code organization, and maintenance considerations. Deduct 5 points if global variables are excessively used or design patterns are not applied; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the code lacks comments or documentation. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern game UI principles: 1) Appropriate color scheme for space theme (dark background with contrasting elements) 2) Proper layout of game elements and HUD 3) Readable text and clear visual hierarchy. Deduct 3 points for cluttered game screens, 5 points for a color scheme that strains the eyes, and 5 points for poorly positioned 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 dynamic effects conform to human perception characteristics: 1) Input response delay ≤ 50ms 2) Smooth movement and transitions 3) Clear visual feedback for player actions and game events. Deduct 5 points for each interaction without feedback, 3 points for jerky or inconsistent animations, and 5 points for confusing visual feedback during gameplay. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Shooting",
+  "difficulty": "easy"
+}