@getollie/cli 0.0.4 → 0.2.0

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

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

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

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

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

@@ -1,68 +0,0 @@
-{
-  "index": 638,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Ensure that the code you generate is executable when possible. Please develop a sandbox-style shooting game editor. Players can design their own shooting levels in the editor, place enemies, obstacles, and props, and set level objectives. After completing the editing, they can test and share their game. The editor supports drag-and-drop operations, property adjustments, and level saving functionality.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the shooting game editor's core functionality fully implemented?",
-      "description": "Review whether the code implements a complete canvas-based editor with drag-and-drop functionality for game elements (enemies, obstacles, props). Check if the editor includes a coordinate system, element selection, movement, and resizing capabilities. Score 0 if the core editor functionality is missing, 5 if only basic placement is implemented, and 10 if the editor offers comprehensive design capabilities including layers, grouping, and alignment tools.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are the property adjustment features comprehensive and intuitive?",
-      "description": "Evaluate the property panel implementation that allows customization of game elements. Check if properties include basic attributes (position, size, appearance) and behavior parameters (enemy movement patterns, health points, damage values, collision responses). Deduct 3 points if visual feedback is missing when adjusting properties, 3 points if common properties require manual input rather than sliders/dropdowns, and 5 points if behavior scripting/configuration is absent. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the level testing functionality properly implemented?",
-      "description": "Assess whether the editor includes a robust play-test mode that accurately simulates gameplay without requiring export. Check for seamless switching between edit and play modes, real-time debugging tools, and the ability to pause/resume testing. Deduct 5 points if the game physics in test mode differs from final export, 3 points if there's no visual feedback for collisions/interactions during testing, and 5 points if performance diagnostics are missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are level saving and sharing mechanisms well-designed?",
-      "description": "Review the implementation of level persistence and sharing functionality. Check if levels are properly serialized/deserialized, whether the code includes versioning support for backward compatibility, and if export options include shareable formats. Deduct 5 points if there's no auto-save feature, 3 points if sharing requires manual file handling, and 5 points if imported levels lose custom properties. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid drag operations, corrupt level files, browser crashes, memory leaks with large levels, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. AI-assisted level balancing 2. Community template library integration 3. Real-time collaborative editing 4. Visual scripting system for complex behaviors). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple undo systems coexisting) 2. Function modules unrelated to the shooting game editor (e.g., built-in image editor when simple property controls would suffice) 3. Fancy effects that affect performance (e.g., excessive particle effects in the editor interface). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating editor/game logic/rendering layers), unit test coverage, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Drag-and-drop operations feel natural with appropriate snapping and visual feedback 2) Transition animations controlled between 300-500ms 3) Clear visual hierarchy and focus guidance. Deduct 5 points for each operation without feedback, 3 points for laggy performance during element manipulation, and 5 points for unintuitive UI workflows. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Shooting",
-  "difficulty": "hard"
-}

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

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

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

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

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

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