@getollie/cli 0.0.1

package/library/game_development-simulation_management/web-based-3d-minecraft-like-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1609,
+  "question": "You are a coding expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you provide is executable when possible. I want to develop a game similar to Minecraft, but simpler. Please help me develop it with the following requirements: 1. The game should be a web-based 3D game; 2. In this game, players can freely build things using cubes similar to those in Minecraft; 3. Players should be able to select colors for the cubes.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "3D World Rendering Implementation",
+      "description": "Evaluate whether the code properly implements a 3D environment using WebGL/Three.js or similar technology with proper perspective, lighting, and scene management.Score 0 if there's no 3D environment, 5 if there's basic rendering without proper lighting/shadowing, and 10 if the 3D world is fully implemented with proper depth perception, lighting effects, and optimization for web performance.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Cube Creation & Manipulation System",
+      "description": "Check if the code enables players to add, remove, and manipulate cubes in 3D space with appropriate collision detection.Score 0 if cube placement is not implemented, 5 if basic cube adding/removing is available but lacks precision controls, and 10 if the system provides intuitive placement with snapping, rotation options, and collision prevention.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Color Selection & Customization",
+      "description": "Evaluate the implementation of color selection for cubes, including the UI for color picking and application to cubes.Score 0 if color selection is missing, 5 if only basic predefined colors are available, and 10 if there's a full color picker with RGB/HSL controls, color history, and the ability to save favorite colors.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Player Movement & Camera Controls",
+      "description": "Assess the implementation of player movement in the 3D environment and camera controls for different perspectives.Deduct 3 points if WASD/arrow key navigation is missing, 3 points if camera rotation is not smooth, 5 points if first-person and third-person views aren't toggleable. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Code Robustness",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as browser compatibility issues, WebGL support detection, input validation, 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": "Innovative Features",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Texture system for cubes 2. Save/load functionality 3. Physics interactions between cubes).Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Redundant Features",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions 2. Function modules unrelated to the building game 3. Fancy effects that affect performance.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": "Engineering Quality",
+      "description": "Review modular design (such as separating game logic/rendering/UI layers), code organization, 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 no performance optimizations are implemented for 3D rendering. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Interface Design",
+      "description": "Evaluate whether the UI follows modern design principles: 1) Harmonious color matching 2) Proper layout spacing 3) Unobtrusive controls that don't block the 3D view.Deduct 3 points for each crowded UI element, 5 points for controls that obstruct gameplay, and 5 points for chaotic HUD layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Performance & Optimization",
+      "description": "Judge whether the game runs smoothly with increasing numbers of cubes: 1) Maintains 30+ FPS with 1000+ cubes 2) Implements LOD (Level of Detail) for distant objects 3) Uses efficient data structures for cube storage.Deduct 5 points if FPS drops below 30 with moderate cube count, 3 points if there's no chunk-based rendering for large worlds, and 5 points if memory usage grows linearly with world size without optimization. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Simulation/Management",
+  "difficulty": "medium"
+}

package/library/game_development-simulation_management/web-based-farm-game-html-js-css.json

@@ -0,0 +1,68 @@
+{
+  "index": 1491,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and expert responses. Be careful to ensure that the code you generate is executable and can be displayed. Create a web-based farm game using HTML+JS+CSS.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core farm game system fully implemented?",
+      "description": "Review whether the code accurately implements the farm simulation mechanics through HTML/JavaScript, including crop planting/growing/harvesting cycles, resource management (seeds, water, tools), and economic system (buying/selling). Score 0 if core farming mechanics are missing, 5 if only basic planting is implemented, and 10 if a complete farming ecosystem with growth stages, seasonal effects, and crop varieties is included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the interactive game world properly constructed?",
+      "description": "Check whether the farm environment includes a functional grid-based field system, interactive buildings (barn, shop, house), and inventory management. Evaluate if click/drag interactions for planting and harvesting are smooth and intuitive. Deduct 5 points if the field system lacks proper coordinate mapping, and 3 points if building interactions are non-functional. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the game progression and time management system designed effectively?",
+      "description": "Evaluate whether the game implements a realistic time progression system with day/night cycles, seasonal changes affecting crop growth, and save/load functionality for game state persistence. Check if growth timers work accurately and if the game state can be properly serialized. Deduct 5 points if time progression is unrealistic or inconsistent, and 3 points if save/load functionality is buggy. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the complete game economy and achievement system constructed?",
+      "description": "Check whether the code includes a balanced economic system with currency management, market price fluctuations, and progression rewards. Evaluate if there are achievement milestones, level progression, and unlockable content. Deduct 5 points if the economy is unbalanced or currency system is broken, and 3 points if progression feels unrewarding or unclear. Give 10 points if fully implemented with engaging progression mechanics.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid user inputs, rapid clicking, browser refresh, localStorage errors, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should effectively handle edge cases like negative currency, invalid crop placement, or corrupted save data, giving 10 points. If robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the gaming experience (e.g., 1. Weather system affecting crop growth 2. Animal husbandry with breeding mechanics 3. Seasonal festivals with special events 4. Crop mutation system 5. Market trading with price predictions). 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 inventory systems coexisting) 2. Function modules unrelated to farming (e.g., built-in calculator or unrelated mini-games) 3. Excessive visual effects that impact performance (e.g., constant particle systems or heavy animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if core farming 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/data persistence layers), code organization, and maintainability. Deduct 5 points if global state pollution is found or no clear separation of concerns; deduct 5 points if code duplication rate is too high (over 30%); deduct 3 points if variable naming is unclear or functions are overly complex. 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 palette suitable for farming theme (earth tones, natural colors) 2) Proper spacing and grid alignment for farm elements 3) Readable typography (UI text ≥ 14px, proper contrast) 4) Consistent iconography for tools and crops. Deduct 3 points for each cluttered UI element, 5 points for jarring color combinations, and 5 points for poor visual hierarchy. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the game interactions conform to user expectations: 1) Click feedback delay ≤ 100ms for planting/harvesting 2) Smooth animations for crop growth and UI transitions (200-400ms) 3) Clear visual feedback for all user actions 4) Intuitive drag-and-drop mechanics. Deduct 5 points for each unresponsive interaction, 3 points for jarring or missing animations, and 5 points for confusing user interface elements. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Simulation/Management",
+  "difficulty": "medium"
+}

package/library/game_development-simulation_management/web-based-single-player-cooking-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1354,
+  "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 create a web-based single-player cooking game.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the cooking game mechanics fully implemented?",
+      "description": "Review whether the code accurately implements core cooking mechanics through HTML/JavaScript, including ingredient preparation, cooking processes (chopping, frying, boiling, etc.), timing systems, and recipe completion validation. Score 0 if core cooking interactions are not implemented, 5 if only basic ingredient handling is present, and 10 if comprehensive cooking mechanics with multiple recipes and cooking methods are fully included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the game progression and level system implemented?",
+      "description": "Check whether the game includes a structured progression system with multiple levels, difficulty scaling, recipe unlocking mechanisms, and player skill advancement. Evaluate if scoring/rating systems are present for completed dishes. Deduct 5 points if no progression tracking exists, and 3 points if level transitions are abrupt without proper difficulty curves. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the real-time cooking simulation and timing system designed properly?",
+      "description": "Evaluate whether the cooking simulation includes realistic timing mechanisms for different cooking processes, ingredient state changes (raw to cooked), temperature management, and multi-tasking capabilities. Check if players can manage multiple cooking processes simultaneously. Deduct 5 points if timing is unrealistic or inconsistent, and 3 points if no visual feedback is provided for cooking states. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is complete game state management and save functionality constructed?",
+      "description": "Check whether the code includes comprehensive game state management, including progress saving, recipe collection tracking, high score persistence, and game pause/resume functionality. Deduct 5 points if local storage is not implemented for game progress, and 3 points if the game cannot properly resume after interruption. Give 10 points if fully implemented with robust state persistence.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid user inputs, timer conflicts, resource loading failures, 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 cooking game experience (e.g., 1. Recipe suggestion system based on available ingredients 2. Cooking tutorial with interactive guidance 3. Customizable kitchen layouts 4. Sound effects that match cooking actions). 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 timer systems coexisting) 2. Function modules unrelated to cooking games (e.g., built-in social media features) 3. Overly complex animations that affect gameplay performance (e.g., excessive particle effects during cooking). Deduct 3 points for each redundancy found, and directly deduct 10 points if core cooking 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 proper architecture patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 3 points if functions are not properly documented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional game design standards?",
+      "description": "Evaluate whether the visual design follows modern game UI principles: 1) Cohesive color scheme that fits cooking theme (warm, appetizing colors) 2) Proper visual hierarchy with clear ingredient/tool identification 3) Consistent iconography and typography (readable fonts ≥ 14px). Deduct 3 points for each cluttered interface element, 5 points for poor color choices that hinder gameplay, and 5 points for confusing visual layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the interactive gameplay smooth and engaging?",
+      "description": "Judge whether the game interactions provide satisfying feedback: 1) Immediate response to player actions (≤ 100ms) 2) Smooth drag-and-drop for ingredients with proper visual feedback 3) Clear audio-visual cues for cooking progress and completion 4) Intuitive controls that don't require extensive learning. Deduct 5 points for each unresponsive interaction, 3 points for confusing control schemes, and 5 points for lack of satisfying feedback mechanisms. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Simulation/Management",
+  "difficulty": "hard"
+}

package/library/game_development-simulation_management/web-electronic-pet-raising-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1180,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code where possible. Design a web-based mini-game, an electronic pet raising game.\n\nPlayers can choose pets shaped like kittens, puppies, ponies, etc. Once a pet is selected, players cannot choose another one.\n\nThe pet can run, jump, lie down, and sleep on the screen.\n\nThe pet has a hunger bar with 100 points, which decreases by 1 point every half hour. The bar has different colors for each 30% segment.\n\nWhen the hunger bar is completely depleted, the pet will die and cannot be revived.\n\nProvide three types of food for players to feed their pets, which can increase the hunger bar by 5%, 10%, and 15% respectively.\n\nProvide three types of toys for players to interact with their pets. Each toy can decrease the pet's hunger bar by 5%, 10%, and 15% respectively.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the pet creation and selection system fully implemented?",
+      "description": "Check if the code allows players to select from different pet types (kittens, puppies, ponies) with distinct visual representations. Verify that once a pet is selected, the selection cannot be changed. Evaluate if pet selection is properly persisted in local storage or a database, and if the UI clearly indicates the selection is permanent.10 points maximum. Deduct 5 points if pet selection isn't permanent. Deduct 3 points if fewer than 3 pet types are implemented. Deduct 2 points if pet selection isn't visually intuitive or lacks confirmation dialog. Score 0 if pet selection system is missing entirely.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are all pet animations and behaviors correctly implemented?",
+      "description": "Evaluate whether the required pet behaviors (running, jumping, lying down, sleeping) are implemented with smooth animations and clear visual distinction. Check if animations transition naturally between states and if they respond to player interactions or environmental changes appropriately.15 points maximum. Award 3-4 points for each well-implemented animation (running, jumping, lying down, sleeping). Deduct 3 points if animations are jerky or unnatural. Deduct 5 points if animations don't properly represent the intended behavior. Score 0 if animations are missing entirely.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the hunger system properly implemented with visual indicators?",
+      "description": "Check if the hunger bar starts at 100 points, decreases at the specified rate (1 point every half hour), and changes colors for each 30% segment. Verify that the game correctly detects when hunger reaches zero and implements the death state properly. Validate that hunger persists between sessions.15 points maximum. Deduct 5 points if hunger doesn't decrease at the specified rate. Deduct 3 points if color segments aren't implemented. Deduct 5 points if death state isn't properly handled. Deduct 3 points if hunger doesn't persist between sessions.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are the feeding and toy interaction systems complete?",
+      "description": "Evaluate whether the three types of food and three types of toys are visually distinct and whether they affect the hunger bar by the specified percentages. Check if the feeding/play animations are satisfying and if there are appropriate cooldown mechanisms to prevent spam.10 points maximum. Deduct 2 points for each missing food or toy type. Deduct 3 points if hunger effects don't match specifications. Deduct 2 points if feeding/playing lacks appropriate animations or feedback. Score 0 if systems are completely missing.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as browser refreshes, interruptions, inconsistent timing intervals, etc.) and provide friendly error prompts or recovery mechanisms. Verify that game state is properly saved and restored.10 points maximum. If the robustness is strong with proper error handling and state management, give 10 points. If the robustness is average with some error handling, give 5 points. 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. Weather effects influencing pet behavior 2. Day/night cycle affecting sleep patterns 3. Pet personality traits that evolve over time 4. Social sharing features).10 points maximum. 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 hunger tracking mechanisms) 2. Function modules unrelated to pet raising (e.g., a built-in calculator) 3. Fancy effects that affect performance (e.g., unnecessary 3D renders or particle effects).10 points maximum. 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 layers), unit test coverage, and build process automation. Check for proper use of design patterns, code organization, and maintainability.10 points maximum. 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.",
+      "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) 4) Appropriate pet design that feels cohesive with the UI.10 points maximum. Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. Deduct 3 points if the pet designs clash with the UI style.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance 4) Pet responds naturally to interactions.10 points maximum. Deduct 5 points for each operation without feedback, 3 points for visual after-images during animations, and 5 points for hard-to-find key function buttons. Deduct 3 points if pet interactions feel delayed or unnatural.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Simulation/Management",
+  "difficulty": "medium"
+}

package/library/game_development-sports/3d-first-person-racing-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1495,
+  "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. Create a racing game with a first-person driver's perspective, allowing for left and right turns, acceleration and deceleration based on the track. The track should resemble a realistic three-dimensional racing circuit.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the first-person 3D racing view accurately implemented?",
+      "description": "Review whether the code correctly implements a first-person perspective camera system using WebGL/Three.js or Canvas 3D, including proper field of view (FOV 60-90°), camera positioning inside the cockpit, and realistic depth perception. The view should include dashboard elements and steering wheel. Score 0 if only 2D top-down view is provided, 5 if basic 3D view without cockpit details, and 10 if full immersive first-person racing experience with proper perspective projection.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the vehicle physics and control mechanics realistic?",
+      "description": "Check whether the implementation includes proper physics simulation for acceleration, deceleration, steering dynamics, and momentum conservation. Vehicle should have inertia, drift mechanics, speed-dependent turning radius, and realistic braking distance. Keyboard/gamepad controls should be responsive with proper input mapping (WASD/Arrow keys for steering, acceleration/braking). Deduct 5 points if physics feel arcade-like without momentum, 3 points if steering lacks progressive response. Full score requires realistic vehicle dynamics.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the 3D racing track properly designed and rendered?",
+      "description": "Evaluate whether the track features realistic 3D geometry with proper banking, elevation changes, curves of varying difficulty, and track boundaries. Track should include visual elements like barriers, grass/gravel run-off areas, start/finish line, and lap markers. Texture mapping and lighting should create depth and realism. Deduct 5 points if track is flat without elevation, 3 points if missing proper track boundaries or visual landmarks. Full score requires professional circuit-like design.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the complete racing game loop implemented?",
+      "description": "Check whether the code includes essential racing features: lap counting system, timing/speed display, race start countdown, finish line detection, and basic HUD (speedometer, lap counter, position). Should handle race completion, lap records, and restart functionality. Deduct 5 points if lap detection is inaccurate, 3 points if missing essential HUD elements, 2 points if no timing system. Give 10 points if all core racing mechanics are properly implemented with accurate tracking.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as collision detection edge cases, frame rate drops, browser compatibility issues, memory leaks in 3D rendering, invalid input states) and provide appropriate fallbacks or error handling. Code should gracefully handle WebGL context loss and provide meaningful error messages. Give 10 points for comprehensive error handling, 5 points for basic exception management, and 0 points if no error handling is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that enhance the racing experience?",
+      "description": "Check whether the code includes engaging features that elevate the gameplay (e.g., 1. Realistic engine sound effects with Doppler effect 2. Dynamic weather/lighting conditions 3. Multiple camera angles 4. Ghost car for lap comparison 5. Particle effects for tire smoke/sparks). Add 3 points for each well-implemented innovative feature that adds value to the racing experience (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant rendering pipelines or duplicate 3D model loading 2. Unnecessary non-racing features (e.g., built-in chat system, unrelated mini-games) 3. Performance-heavy visual effects that don't enhance racing (e.g., excessive particle systems, overly complex shaders). Deduct 3 points for each redundancy found, and directly deduct 10 points if core racing performance is significantly impacted by bloated features.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular architecture separating rendering engine, physics simulation, input handling, and game state management. Check for proper asset loading optimization, frame rate management (targeting 60fps), and memory usage patterns. Deduct 5 points if global state pollution or poor separation of concerns; deduct 5 points if code duplication rate exceeds 30% or lacks consistent coding patterns; deduct 5 points if no performance optimization considerations for 3D rendering. Full score requires clean, maintainable architecture.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional racing game standards?",
+      "description": "Evaluate whether the visual design follows modern racing game UI principles: 1) High contrast HUD elements clearly visible against track background 2) Realistic color palette with appropriate track surface textures 3) Professional typography for racing data (lap times, speed) with adequate sizing (≥16px for critical info). Deduct 3 points for each cluttered HUD element, 5 points for poor contrast affecting readability, and 5 points for unrealistic or distracting visual styling that breaks immersion.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the racing performance smooth and responsive?",
+      "description": "Judge whether the game performance meets racing standards: 1) Consistent frame rate ≥30fps (preferably 60fps) during gameplay 2) Input lag ≤50ms for steering responsiveness 3) Smooth camera movement without stuttering during high-speed sections 4) Proper LOD (Level of Detail) management for distant track elements. Deduct 5 points for each noticeable frame drop during normal racing, 3 points for input delay affecting control precision, and 5 points for camera jitter or motion sickness-inducing movement.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Sports",
+  "difficulty": "hard"
+}

package/library/game_development-sports/animation-physical-collision-sports-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 60,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the generated code is executable for display.\nPlease use HTML and JavaScript to implement a sports game: Animation and physical collision\n**Task**: Implement a physics collision system where players will collide during a match and trigger corresponding animation effects.\n**Hint**: You can use a physics engine and animation system to simulate collisions and animation transitions.\nCreate the game, and include some comments in the code so that other developers can understand your implementation process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the physics collision system properly implemented?",
+      "description": "Evaluate whether the code accurately implements a physics-based collision detection system that handles different types of collisions (e.g., player-to-player, player-to-environment). Check for proper collision response including momentum conservation, force application, and rebound effects. Score 0 if collision detection is missing, 5 if only basic collisions are detected without proper physics, and 10 if the implementation includes realistic physical properties (mass, velocity, acceleration) with accurate response calculations.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the animation system fully integrated with the physics system?",
+      "description": "Assess whether animations properly respond to collision events and transition smoothly between states (idle, running, collision, recovery). Check if the animation system includes proper blending, interpolation techniques, and timing synchronization with the physics engine. Deduct 5 points if animations don't match collision intensity, 3 points if transitions are jarring, and full points if animations dynamically adapt to different collision scenarios with proper transition timing.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are different collision types handled with appropriate responses?",
+      "description": "Verify that the code differentiates between collision types (head-on, glancing, side impacts) and responds with different animation sequences and physical outcomes. Check whether collision angle and force affect the response. Score 0 if all collisions are handled identically, 5 if there's basic differentiation, and 10 if the system accounts for collision angle, force, player attributes, and produces varied realistic outcomes.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the game loop and timing system well-designed?",
+      "description": "Review whether the game maintains consistent physics calculations regardless of frame rate (e.g., using delta time), includes proper update scheduling for physics and rendering, and handles performance optimization techniques. Deduct 5 points if physics calculations are frame-dependent, 3 points if there's no separation between physics and rendering loops, and 5 points if there's no handling for performance degradation scenarios.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as extreme collision velocities, edge cases in physical interactions, browser compatibility issues) and provide graceful degradation. Code with strong robustness should effectively prevent physics glitches, giving 10 points. If the robustness is average, give 5 points, and if no error handling exists for physics edge cases, 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. Slow-motion effects during significant collisions 2. Dynamic camera angles that focus on collision points 3. Visual/audio feedback proportional to collision intensity). 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 physics calculations (e.g., multiple collision detection systems running in parallel) 2. Function modules unrelated to the sports game mechanics (e.g., unrelated mini-games) 3. Excessive effects that affect performance without meaningful gameplay impact. 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 engine/animation system/rendering layer), code documentation quality (especially for the physics implementation), and performance optimization techniques. Deduct 5 points if global state pollution is found or appropriate design patterns are not used; deduct 5 points if the code lacks comments explaining key physics concepts; deduct 5 points if no optimization is implemented for collision detection. 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 follows modern gaming principles: 1) Clear visual feedback for collisions 2) Proper contrast between interactive elements and background 3) Consistent visual language for game state representation. Deduct 3 points for cluttered collision effects, 5 points for poor player visibility, and 5 points for inconsistent visual feedback. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and responsive?",
+      "description": "Judge whether the interaction feels natural and immediate: 1) Controls respond within 100ms 2) Physics behave predictably without unexplained jumps 3) Collisions feel impactful with appropriate visual and audio feedback. Deduct 5 points for input lag, 5 points for physics glitches during collisions, and 3 points for weak collision feedback that doesn't match impact intensity. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Sports",
+  "difficulty": "medium"
+}

package/library/game_development-sports/archery-scoring-system-gyroscope-physics-simulation.json

@@ -0,0 +1,68 @@
+{
+  "index": 677,
+  "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. Implement an archery scoring system. Use device gyroscope to control aiming (via DeviceOrientation API), simulate drawing the bow through mouse movement speed, and display bowstring vibration effects. Arrow flight should be affected by wind forces (random vectors). After hitting the target center, show slow-motion replay. The scoring calculation needs to consider arrow compression effects (handling overlap in adjacent scoring zones).",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the gyroscope aiming control system fully implemented?",
+      "description": "Review whether the code accurately implements DeviceOrientation API integration for aiming control, including gyroscope data filtering, calibration mechanism, and smooth aiming cursor movement. Check if proper permission handling and fallback mechanisms are provided for devices without gyroscope support. Score 0 if gyroscope control is not implemented, 5 if only basic orientation detection works, and 10 if full gyroscope aiming with calibration and smooth filtering is included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the bow drawing and bowstring vibration system properly simulated?",
+      "description": "Evaluate whether the mouse movement speed detection accurately simulates bow drawing mechanics, including draw strength calculation, release timing detection, and realistic bowstring vibration effects using canvas/WebGL animations. Check if the bowstring tension visualization responds correctly to drawing speed and provides haptic-like feedback. Deduct 5 points if vibration effects are missing, and 3 points if draw strength calculation is inaccurate. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the arrow flight physics and wind simulation realistic?",
+      "description": "Check whether the arrow trajectory calculation includes proper physics simulation with gravity, air resistance, and random wind vector effects. Evaluate if wind visualization (particles, indicators) is present and if the flight path realistically responds to environmental factors. Deduct 5 points if wind effects are static or unrealistic, and 3 points if trajectory physics don't account for arrow mass and velocity degradation. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the scoring system with compression effects and slow-motion replay implemented?",
+      "description": "Review whether the scoring calculation properly handles arrow compression effects when arrows land in adjacent scoring zones, including overlap detection algorithms and zone boundary calculations. Check if slow-motion replay is triggered on target center hits with smooth animation interpolation. Deduct 5 points if compression effects are not calculated, and 3 points if slow-motion replay is choppy or missing. Give 10 points if fully implemented with accurate scoring logic.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as device orientation permission denial, mouse movement edge cases, canvas rendering failures, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should gracefully handle gyroscope unavailability, extreme mouse speeds, and rendering performance issues, 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 archery experience (e.g., 1. Realistic arrow fletching rotation during flight 2. Dynamic target distance adjustment 3. Weather effects affecting gameplay 4. Achievement system with combo scoring 5. Multiplayer tournament mode). 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 wind calculation systems coexisting) 2. Function modules unrelated to archery (e.g., built-in social media sharing) 3. Fancy effects that affect performance (e.g., excessive particle systems during arrow flight). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core archery mechanics 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 engine/rendering/input handling layers), performance optimization for real-time rendering, and proper event handling architecture. Deduct 5 points if global state pollution is found or physics calculations are not optimized; deduct 5 points if the code lacks proper separation of concerns; deduct 5 points if memory leaks are detected in animation loops. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the archery game design follows modern UI principles: 1) Realistic target and environment textures with proper lighting 2) Clear aiming reticle with appropriate contrast 3) Professional HUD elements (score display, wind indicator, power meter) with readable typography. Deduct 3 points for each poorly designed UI element, 5 points for unrealistic 3D models or textures, and 5 points for cluttered or hard-to-read scoring displays. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the real-time interactions conform to gaming standards: 1) Gyroscope response delay ≤ 50ms for precise aiming 2) Bow drawing animation at consistent 60fps 3) Arrow flight trajectory rendered smoothly without stuttering 4) Slow-motion replay transitions seamlessly. Deduct 5 points for each laggy interaction, 3 points for frame drops during arrow flight, and 5 points for unresponsive gyroscope controls. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Sports",
+  "difficulty": "hard"
+}

package/library/game_development-sports/billiards-aiming-line-tool.json

@@ -0,0 +1,68 @@
+{
+  "index": 745,
+  "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 for demonstration. Now, I would like to play billiards and need you to develop an aiming line tool that will help improve my shooting accuracy.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core physics-based aiming line system implemented correctly?",
+      "description": "Check whether the code accurately implements physics-based prediction for billiard ball trajectories, including proper angle calculation, reflection off cushions, and potential ball collision paths. Score 0 if core trajectory calculation is missing, 5 if only basic straight-line prediction is implemented, and 10 if it handles complex rebounds and ball-to-ball collisions accurately.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is real-time visual feedback of the aiming line implemented?",
+      "description": "Evaluate whether the aiming line updates dynamically as the user moves the cue, with proper visualization techniques (dashed/solid lines, color gradients to indicate force, etc.). The visualization should clearly distinguish between the initial trajectory and subsequent rebounds. Deduct 5 points if the line doesn't update in real-time, and 3 points if visual clarity is poor. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are advanced billiards physics accurately modeled?",
+      "description": "Assess if the code includes friction, spin effects (top/bottom/side spin), momentum transfer between balls, and realistic physics parameters. Score 0 if only basic linear physics are used, 5 if friction is included but spin is absent, and 10 if all professional billiards physics aspects are modeled, including english/spin effects on ball trajectories.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the user interaction for aiming intuitive and responsive?",
+      "description": "Check whether the interface allows natural cue positioning, shot power adjustment, and spin control through intuitive mouse/touch inputs. Test responsiveness on various devices. Deduct 5 points if aiming requires multiple complex steps, and 3 points if there's noticeable lag between input and visual feedback. 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 out-of-bounds inputs, rapid mouse movements, browser resizing, touch vs. mouse inputs, 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. Heat map of successful shots 2. Shot strength meter with audible feedback 3. Replay system for reviewing shots 4. Variable table friction settings). 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 ways to calculate the same physics) 2. Function modules unrelated to billiards aiming (e.g., unnecessary game modes) 3. Fancy effects that affect performance (e.g., excessive particle effects when balls collide). 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 engine/rendering/user input handling), 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 (green billiard table with contrasting but complementary UI elements) 2) Proper layout spacing (controls clearly separated from the play area) 3) Professional font system (readable measurements and settings). 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) Aiming line updates within 50ms of input 2) Ball animations follow natural physics with appropriate easing 3) Clear visual distinction between aiming mode and shot execution. Deduct 5 points for jerky animations, 3 points for inconsistent frame rates during complex calculations, and 5 points for delayed feedback when adjusting shot parameters. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Sports",
+  "difficulty": "medium"
+}