@getollie/cli 0.0.5 → 0.2.0

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

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

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

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

package/library/game_development-sports/equestrian-show-jumping-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 637,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable and displayable. \n\n## Role\nYou are an experienced code expert. You are provided with a software development requirement description, and you are required to generate project code based on this requirement. Strictly follow the rules to help users generate complete project code that is fully commented in simple and easy-to-understand language. Don't output anything else.\n\n## Output Rules\n1. You always generate complete, runnable project code. Please ensure the project is complete and executable.\n2. Ensure all code files you output are complete, don't omit any code.\n3. Carefully review and check all code before final output, evaluate its executability. If the code cannot be executed or contains errors, it needs to be regenerated.\n4. If the requirement involves external API access or needs to use user data (images, videos, audio, etc.), please provide simulated data.\n\n## Project Requirement Description\nImplement an equestrian show jumping game. The screen shows an equestrian arena with multiple obstacles (such as rails, water pits, etc.) and a rider with a horse. The player controls the direction of the horse through keyboard arrow keys and makes the horse jump by pressing the space bar. When the horse hits an obstacle, points are deducted based on the collision (e.g., knocking down a rail). When the horse successfully passes all obstacles and reaches the finish line, the game ends and displays the final score. The game needs to display the equestrian arena, obstacles, rider and horse, as well as the horse's movement and jumping animations.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core equestrian game mechanic fully implemented?",
-      "description": "Review whether the code accurately implements horse movement controls using keyboard arrow keys and jumping with space bar. Check if the movement physics are realistic (acceleration, deceleration, turning radius) and if the jumping mechanism includes proper timing elements (approach speed affects jump height/distance). Score 0 if basic controls are missing, 5 if only rudimentary movement is implemented, and 10 if movement feels natural with appropriate physics.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the obstacle system properly designed and implemented?",
-      "description": "Evaluate if the game includes diverse obstacles (rails, water pits, walls, etc.) with proper collision detection. Check if obstacles have different properties (height, width, penalty values) and if collision detection is precise (distinguishing between clean jumps, rail knocks, or complete failures). Obstacles should be properly positioned in the arena to create a challenging course. Deduct 5 points if collision detection is unreliable, 3 points if obstacles lack variety, and 3 points if obstacle properties don't affect gameplay.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the scoring system complete and appropriate?",
-      "description": "Verify that the game implements a proper scoring system that deducts points based on specific collision types (e.g., -4 for knocking down a rail, -10 for refusing a jump). Check if the game tracks completion time and incorporates it into the final score. The scoring should follow equestrian show jumping rules. Deduct 5 points if the scoring system doesn't reflect different obstacle interactions, 3 points if time isn't factored into scoring, and 5 points if penalties aren't displayed during gameplay.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are the horse and rider animations properly implemented?",
-      "description": "Assess whether the code includes smooth animations for walking, trotting, cantering, jumping, turning, and collision responses. The horse's movement should transition naturally between states, and the rider should maintain proper posture during jumps. Examine if sprites or 3D models are properly synchronized. Score 0 if animations are missing, 5 if only basic animations exist, and 10 if animations are fluid and contextually appropriate for all actions.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid key presses, boundary conditions, collisions from unexpected angles, 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. Weather effects that impact gameplay 2. Customizable horse and rider appearances 3. Replay system with multiple camera angles). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple collision detection systems coexisting) 2. Function modules unrelated to equestrian show jumping (e.g., a built-in music mixer) 3. Fancy effects that affect performance (e.g., excessive particle systems). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/rendering/input handling 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 design principles: 1) Harmonious color matching representing an authentic equestrian arena 2) Proper layout spacing for UI elements (score display, timer, instruction prompts) 3) Professional font system with clearly visible text during gameplay. Deduct 3 points for each crowded visual element, 5 points for unrealistic or jarring visual representations of the arena/obstacles, and 5 points for poorly positioned UI elements that obstruct gameplay. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Input response delay ≤ 100ms 2) Smooth frame rate (minimum 30 FPS) 3) Clear visual feedback for jumps, collisions, and scoring events. Deduct 5 points for each action without proper feedback, 3 points for stuttering animations during complex movements, and 5 points for confusing visual cues that don't clearly indicate jump timing or obstacle positions. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Sports",
-  "difficulty": "hard"
-}

package/library/game_development-sports/html-javascript-racing-game-design.json

@@ -1,68 +0,0 @@
-{
-  "index": 42,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable whenever possible.\nPlease use HTML and JavaScript to implement a racing game.\nTask: Design a racing game where players drive cars to compete on a racetrack.\nHint: Implement the physical movement of the racing cars and the track design.\nPlease include comments in your code so that other developers can understand your implementation process.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the racing game core physics system fully implemented?",
-      "description": "Evaluate whether the code properly implements vehicle physics including acceleration, deceleration, friction, steering, and collision detection. Check if there's proper implementation of forces (gravity, friction), momentum, and car handling characteristics. Score 0 if physics is not implemented, 5 if only basic movement exists, and 10 if realistic racing physics are implemented with vehicle-specific characteristics.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the racetrack design and rendering system complete?",
-      "description": "Review the track implementation, including proper path definition, boundaries, checkpoints, and visual representation. Check if the track has appropriate difficulty elements (curves, obstacles). Assess rendering performance and visual clarity. Award 10 points for a complete system with multiple track elements, 5 points for basic implementation, 0 points if the track system is absent.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the game loop and timing system properly implemented?",
-      "description": "Evaluate the implementation of a consistent game loop using requestAnimationFrame or similar techniques. Check for proper timing mechanisms for lap counting, race timing, and game state updates. Score 10 if the timing system handles variable frame rates and maintains consistent gameplay, 5 if basic timing exists but with potential issues, 0 if timing is severely flawed.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there a complete racing competition system?",
-      "description": "Check if the code implements essential racing game elements: starting countdown, lap counting, position tracking, finish line detection, and race results. Award 10 points for a fully-featured racing system with position display and lap timing, 5 points for basic implementation, 0 points if competition elements are missing.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as window resizing, performance bottlenecks, unexpected user input, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Dynamic weather effects 2. Car customization 3. AI opponents with different driving styles 4. Minimap/tracking 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 racing (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive particle effects causing framerate drops). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game physics/rendering/input layers), code organization, and implementation of design patterns. Check for proper comments as specified in the requirements. 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 clear, explanatory comments are missing. 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) Non-intrusive HUD elements (speedometer, position indicator, lap counter) 2) Proper contrast between the game world and UI elements 3) Readable text even during high-speed gameplay. Deduct 3 points for each poorly positioned UI element, 5 points for unreadable or unclear game status information, and 5 points for excessive UI elements that obstruct gameplay. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and responsive?",
-      "description": "Judge whether the control dynamics conform to racing game expectations: 1) Input response delay ≤ 50ms 2) Minimum 30fps performance under normal conditions 3) Smooth camera movements that follow the car appropriately. Deduct 5 points for significant input lag, 3 points for jerky animations or camera movements, and 5 points for controls that feel unnatural or unresponsive. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Sports",
-  "difficulty": "medium"
-}

package/library/game_development-sports/html-racing-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 1013,
-  "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 purposes. Write a racing game using HTML.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the racing game core mechanics fully implemented?",
-      "description": "Review whether the code accurately implements the basic racing mechanics through HTML/JavaScript, including car movement controls, collision detection, and proper track boundaries. Score 0 if core mechanics are missing, 5 if only basic movement is implemented, and 10 if advanced features like acceleration/braking physics and proper collision handling are included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the game rendering engine properly built?",
-      "description": "Evaluate whether the game uses appropriate rendering techniques (Canvas, CSS transformations, or WebGL) with smooth animation (minimum 30 FPS). Check if rendering optimization techniques are applied (like sprite batching, object pooling, or off-screen rendering). Deduct 5 points if frame rate drops below 30 FPS during normal gameplay, 3 points if visual artifacts occur. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are the race track and environment well-designed?",
-      "description": "Check if the racing track has a proper design with clear boundaries, checkpoints, and visual indicators. Evaluate whether the environment includes scenery elements, obstacles, or varying terrain that affects gameplay. Deduct 5 points if the track is too simplistic (just straight lines), 3 points if there's no visual differentiation between track and off-track areas. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the game progression system implemented?",
-      "description": "Assess whether the game includes features like lap counting, timing system, position tracking (if multiple racers), and result display. Check for game states like countdown, race in progress, and finish. Deduct 5 points if there's no proper race beginning/end, 3 points if lap tracking or timing is missing. Give 10 points if fully implemented with additional features like personal best times or achievements.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as window resizing, rapid input sequences, 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. Dynamic weather effects 2. Customizable vehicles 3. Multiplayer support via local play or simple AI opponents). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple movement control systems) 2. Function modules unrelated to racing (e.g., unrelated 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 layers), code organization, and documentation. 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 are no comments or documentation. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern game UI principles: 1) Clear heads-up display (HUD) with speed, position, and lap information 2) Proper contrast between game elements and background 3) Readable text even during fast gameplay (font size ≥ 14px). Deduct 3 points for each poorly positioned UI element, 5 points for unclear visual hierarchy, and 5 points for unreadable text during movement. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and responsive?",
-      "description": "Judge whether the controls and feedback conform to player expectations: 1) Input response delay ≤ 50ms 2) Appropriate physics feel with weight and momentum 3) Clear visual/audio feedback for collisions, acceleration, and braking. Deduct 5 points for sluggish controls, 3 points for unrealistic physics that harm gameplay, and 5 points for lack of feedback during important game events. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Sports",
-  "difficulty": "medium"
-}

package/library/game_development-sports/player-control-sports-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 33,
-  "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 for demonstration.\nPlease use HTML and JavaScript to implement a sports game: Player Control and Game Rules\n**Task**: Implement a player control system where players can control athletes to perform actions like passing, shooting, etc. in a match while following game rules.\n**Hint**: You can use keyboard or gamepad input to control the players, and design basic game rule logic.\nPlease include comments in your code so other developers can understand your implementation process.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the player control system fully implemented?",
-      "description": "Evaluate whether the code implements comprehensive player controls with keyboard/gamepad input handling. Check for implementation of movement controls (up/down/left/right), action keys (pass/shoot/tackle), and modifier keys (sprint/special moves). Score 0 if basic movement controls are missing, 5 if only simple movement and basic actions are implemented, and 10 if the control system includes advanced mechanics like player stamina effects, contextual actions, and responsive inputs.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are the core game rules and mechanics properly implemented?",
-      "description": "Review whether the code accurately implements essential sports game rules such as boundaries detection, scoring system, foul detection, and game flow (periods/timing). Check for proper implementation of physics for ball movement, player collisions, and interaction between players and ball. Deduct 5 points if core rules like scoring or boundaries are missing, and 3 points if physics implementation is unrealistic. Award full points if all expected sports mechanics are present and function correctly.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the game loop and state management properly designed?",
-      "description": "Assess whether the game implements a proper game loop with consistent frame rate and time-based animation. Check if the game state management includes handling of different game phases (pre-match, active play, paused, scoring events, game over). Deduct 5 points if the game loop implementation causes performance issues or visual stuttering, 3 points if state transitions are poorly implemented. The full score requires clean separation between rendering and game logic updates.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the AI opponent or team implementation effective?",
-      "description": "Evaluate the implementation of AI for non-player-controlled athletes. Check for path-finding algorithms, decision-making logic based on game context, and realistic team formations/positioning. Deduct 5 points if AI athletes stand still or move randomly without purpose, 3 points if AI is too predictable or lacks variability in behavior. Full points require AI that adapts to player actions and demonstrates strategic behavior appropriate for the sport being simulated.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid input changes, edge-case user actions, browser inconsistencies, 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 camera angles during key moments 2. Realistic player fatigue system 3. Weather effects that impact gameplay 4. Instant replay 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 movement control systems coexisting) 2. Function modules unrelated to sports gameplay (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive particle effects that slow down gameplay). 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 input handling/game logic/rendering layers), code readability through comments as requested, and organization of assets and resources. 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 comments are missing or inadequate for understanding the implementation. 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) Clear game UI elements (score, time, player indicators) 2) Proper layout for gameplay area vs. UI elements (non-intrusive HUD) 3) Consistent visual style throughout the game. Deduct 3 points for each obscured gameplay element, 5 points for inconsistent or clashing visual elements, and 5 points for UI that interferes with 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 dynamic effects conform to human perception characteristics: 1) Player input response time ≤ 100ms 2) Smooth animations for player movements and actions 3) Clear visual feedback for successful/failed actions. Deduct 5 points for noticeable input lag, 3 points for choppy animations during gameplay, and 5 points for lack of visual/audio feedback on important game events. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Sports",
-  "difficulty": "medium"
-}

package/library/game_development-sports/soccer-team-formation-program.json

@@ -1,68 +0,0 @@
-{
-  "index": 1445,
-  "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 and can be displayed.\n\nI need you to create a soccer team formation program based on the following list of names:\nChen Junchao, Huang Dun'an, Yang Nian, Wang Zhijian, Tu, Xu Ben, Fan Kai, Chen Zhen, Zhu Jun, Wu Rui, Xin Lei, Wen Quan, Zhang Jin, Wu Di, Xiao Long, Jie, Chen Gang, He Shaomin, Jiang Rui, Y.p🍀👣, gx, Wu Zhenxing, Deng Wei, Yu Fan, Liu Lei\n\nThe program should have a green soccer field background and allow selection between 5-a-side, 7-a-side, 8-a-side, 9-a-side, and 11-a-side formats. The formation should vary based on the number of players, with some basic preset formations. The program should include a player database where you can add, remove, and modify player names. Don't include the numbers before the names. Please create this in HTML format. I want to use AI to generate this program code, so please help me optimize this prompt.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the soccer field visualization properly implemented?",
-      "description": "Check if the code creates a visually accurate green soccer field with appropriate dimensions, markings (penalty areas, center circle, etc.), and proper orientation. The field should scale responsively based on screen size. Deduct 5 points if field dimensions aren't proportional, 3 points if key markings are missing, and 2 points if the green color isn't consistent with standard soccer fields. Full implementation scores 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are all the required formation options implemented correctly?",
-      "description": "Verify that the code includes all required formation options (5-a-side, 7-a-side, 8-a-side, 9-a-side, and 11-a-side) and that each formation displays players in tactically logical positions. Each formation should have at least 2 preset variations (e.g., 4-4-2 vs 4-3-3 for 11-a-side). Deduct 2 points for each missing format, and 1 point for each formation without tactical coherence. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the player database functionality complete?",
-      "description": "Evaluate if the player database allows adding, removing, and modifying player names as specified. Test if the initial 25 players are preloaded correctly (without numbers before names) and if the database persists changes (using localStorage). Verify that the UI for player management is intuitive. Deduct 4 points if CRUD operations are incomplete, 3 points if data persistence is missing, and 3 points if the initial player list is incorrect. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there a random team generation feature with balanced team selection?",
-      "description": "Check if the code implements a random team generation algorithm that creates balanced teams from the available player pool. The algorithm should distribute players evenly while maintaining the selected formation. Verify that the randomization doesn't create duplicate player assignments and handles cases when there are insufficient players. Deduct 5 points if randomization is unbalanced, 3 points if duplicates are possible, and 2 points if edge cases aren't handled. 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 insufficient players for a formation, duplicate player names, special characters in names, 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. Drag-and-drop player positioning 2. Player statistics tracking 3. Formation effectiveness visualization 4. Player position compatibility indicators). 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 generate teams) 2. Function modules unrelated to soccer team formation (e.g., weather forecasts) 3. Fancy effects that affect performance (e.g., unnecessary animations). 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 UI/data/formation logic), code reusability, and efficiency of algorithms. 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 isn't organized into logical functions/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 design principles: 1) Harmonious color matching (soccer-appropriate green field with contrasting, readable UI elements) 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) Formation switching transitions smoothly within 300ms 2) Clear visual feedback when selecting players 3) Intuitive UI for adding/removing players. Deduct 5 points for each operation without feedback, 3 points for jarring transitions between formations, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Sports",
-  "difficulty": "medium"
-}