@getollie/cli 0.0.1

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

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

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

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

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

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

package/library/game_development-sports/sports-game-spectator-atmosphere.json

@@ -0,0 +1,68 @@
+{
+  "index": 76,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable when possible.\n\nPlease use HTML and JavaScript to implement a sports game: Spectators and Atmosphere Creation\n\n**Task**: Design a spectator system where audiences react and cheer in different game scenarios to enhance the game atmosphere.\n\n**Hint**: You can use simple animations and sound effects to simulate audience reactions.\n\nPlease create the game and include comments in your code to help other developers understand your implementation process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the spectator system fully implemented?",
+      "description": "Review whether the code implements a dynamic spectator system with varied reactions to different game events. Score 0 if spectators are just static images, 5 if basic crowd animations exist but with limited variety, and 10 if spectators show contextually appropriate reactions to multiple game scenarios (e.g., cheering for goals, disappointed reactions for misses, wave animations during slow moments).",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the audience reaction system event-driven?",
+      "description": "Check if the audience reactions are properly triggered by game events through an event system. The implementation should include event listeners for game scenarios, randomized reaction selection based on event type, and smooth transitions between different crowd states. Deduct 5 points if reactions are hard-coded/timed rather than event-driven, and 3 points if there's no variation in reactions to similar events. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the sound effect system comprehensive?",
+      "description": "Evaluate whether appropriate sound effects are implemented for crowd reactions (cheers, gasps, applause, boos, chants, etc.) with volume control and proper audio layering. Assess if sounds match the visual reactions and game context. Deduct 5 points if sound effects don't vary by event intensity, 3 points if there's no volume control based on event importance, and 5 points if there are no sounds at all. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the atmosphere creation system scalable?",
+      "description": "Analyze whether the code implements a scalable system that can adjust crowd density, reaction intensity, and home/away fan distribution. Check for parameters that control crowd bias, crowd size, enthusiasm levels, and noise levels. Deduct 5 points if the system has fixed crowd settings, 3 points if it lacks home/away fan distinction, and 3 points if crowd enthusiasm doesn't change throughout the game. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid-fire events, audio playback issues, browser compatibility issues, etc.) and provide fallback 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 affecting crowd appearance/behavior 2. Crowd-initiated Mexican waves or chants 3. Fan rivalries visualized in different sections). 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 crowd reactions (e.g., multiple cheer animations triggered by the same event) 2. Function modules unrelated to spectator atmosphere (e.g., unnecessary game mechanics) 3. Fancy effects that affect performance (e.g., too many individual spectator animations running simultaneously). 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 crowd logic/view/audio systems), cohesive organization of related functionality, and performance optimization for animations and sound. 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 considerations are implemented for large crowds. 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) Realistic or stylistically consistent crowd rendering 2) Proper visual hierarchy between game action and spectators 3) Appropriate use of color to distinguish fan sections or reactions. Deduct 3 points for each visual inconsistency in crowd appearance, 5 points for spectator visuals that distract from main gameplay, and 5 points for unrealistic or jarring crowd positioning. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the spectator animations and transitions conform to human perception characteristics: 1) Natural crowd movement patterns (not robotic synchronization) 2) Gradual build-up and fade of crowd reactions 3) Varied timing of individual spectator reactions within a group. Deduct 5 points for unnatural synchronized movements, 3 points for abrupt transitions between crowd states, and 5 points for animations that freeze or stutter during high activity. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Sports",
+  "difficulty": "medium"
+}

package/library/game_development-sports/sports-team-management-season-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 99,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable when possible.\n\nPlease use HTML and JavaScript to implement a Sports: Team Management and Season Mode\n\n**Task**: Implement a team management system where players can manage team rosters, training, and tactics, and participate in a complete season of matches.\n\n**Hint**: You can design a season progression system, and adjust team performance and player rankings based on match results.\n\nGame, and include some comments in the code so that other developers can understand your implementation process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the team management system fully implemented?",
+      "description": "Review whether the code accurately implements team roster management through HTML/JavaScript, including player recruitment, release, position assignment, and attribute management (skills, stamina, morale, etc.). Check if training systems are implemented with proper progression mechanics. Score 0 if core team management is missing, 5 if only basic roster operations exist, and 10 if comprehensive team management with training and player development is fully included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the season mode progression system implemented?",
+      "description": "Check whether the season system includes complete match scheduling, league tables, playoff structures, and season calendar management. Evaluate if match simulation logic considers team tactics, player conditions, and realistic scoring mechanisms. Deduct 5 points if match results are purely random, and 3 points if season progression lacks proper pacing or milestone events. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the tactical system designed with strategic depth?",
+      "description": "Evaluate whether the tactical system allows formation changes, strategy adjustments (offensive/defensive styles), and player role assignments that meaningfully impact match outcomes. Check if tactics interact with player attributes and opponent strategies. Deduct 5 points if tactics are cosmetic only, and 3 points if the system lacks tactical variety or counter-strategies. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the performance tracking and ranking system constructed?",
+      "description": "Check whether the code includes comprehensive statistics tracking for both teams and individual players, dynamic ranking systems that update based on performance, and historical data preservation across seasons. Evaluate if performance metrics influence player values, team reputation, and future opportunities. Deduct 5 points if statistics are not persistent, and 3 points if ranking algorithms are overly simplistic. Give 10 points if fully implemented with detailed analytics.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid player transfers, corrupted save data, simulation errors, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. AI-powered scouting recommendations 2. Dynamic weather effects on matches 3. Social media simulation for team popularity 4. Injury recovery mini-games). 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 save/load systems coexisting) 2. Function modules unrelated to sports management (e.g., built-in social media feed) 3. Fancy effects that affect performance (e.g., complex 3D stadium renders). Deduct 3 points for each redundancy found, and directly deduct 10 points if 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/UI/data management layers), code documentation quality, and maintainable architecture patterns. Deduct 5 points if global state pollution is found or proper encapsulation is missing; deduct 5 points if the code lacks sufficient comments or has poor naming conventions; deduct 3 points if data structures are inefficient. 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 sports management UI principles: 1) Consistent color scheme reflecting team branding 2) Dashboard layout with clear information hierarchy 3) Professional typography with readable statistics tables. Deduct 3 points for each cluttered interface section, 5 points for poor color contrast in data visualization, and 5 points for inconsistent spacing or alignment. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the interactive elements provide appropriate feedback: 1) Drag-and-drop for player transfers with visual confirmation 2) Smooth transitions between different management screens 3) Real-time updates during match simulations with proper pacing. Deduct 5 points for each unresponsive interaction, 3 points for jarring transitions between screens, and 5 points for poorly paced match simulation that feels rushed or tedious. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Sports",
+  "difficulty": "medium"
+}

package/library/game_development-strategy/3d-checkers-game-multiplayer.json

@@ -0,0 +1,68 @@
+{
+  "index": 1000,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Be sure to make the generated code executable for demonstration. Please write me a code for a 3D checkers game that I can play with my desktop friends.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the 3D checkers game board and piece visualization properly implemented?",
+      "description": "Review whether the code implements a true 3D representation of the checkers board and pieces using appropriate technologies (Three.js, WebGL, etc.). Check if the perspective allows clear view of all positions, pieces are distinguishable, and the 3D coordinate system is properly mapped to game logic. Score 0 if only 2D visualization, 5 if basic 3D with limited camera angles, and 10 if full 3D implementation with adjustable camera angles.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the checkers game rules correctly implemented?",
+      "description": "Evaluate whether the code implements all standard checkers rules: piece movement, capturing mechanics (including multiple jumps), king promotion, and win conditions. Check if the game properly validates legal moves and prevents illegal ones. Deduct 5 points if king movement rules are incorrect, 3 points if multiple jumps aren't enforced when available, and 5 points if win conditions are improperly detected.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the local multiplayer functionality properly implemented?",
+      "description": "Check whether the code includes proper turn management between players, clear indication of whose turn it is, and suitable mechanics for local play (such as board rotation between turns or clear player indicators). Deduct 5 points if the turn system is buggy, 3 points if there's no visual indication of current player, and 5 points if the game doesn't properly reset between matches.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the user interaction with the 3D environment intuitive and responsive?",
+      "description": "Assess whether the code implements intuitive selection and movement of pieces in 3D space. Check if there's highlighting of valid moves, clear feedback on selection, and smooth animation of moves. Deduct 5 points if piece selection is unreliable, 3 points if valid moves aren't highlighted, and 5 points if movement animations are jarring or missing.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as out-of-bounds input, user operation errors, 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. Different visual themes for the board and pieces 2. Replay functionality with move history 3. Customizable piece animations or special effects). 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 select pieces) 2. Function modules unrelated to the checkers game (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive particle effects or shader complexity). 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/3D rendering/user input layers), code organization, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no clear separation between rendering and game logic. 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 for the 3D environment and UI elements 2) Proper layout spacing for UI components 3) Clear distinction between game elements and controls. Deduct 3 points for each cluttered UI element, 5 points for poor contrast between board and pieces, and 5 points for inconsistent design language between 3D elements and UI. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the 3D performance optimized for desktop play?",
+      "description": "Judge whether the 3D implementation is optimized for desktop environments: 1) Maintains stable 60fps on mid-range hardware 2) Uses appropriate level of detail for models and textures 3) Implements proper culling and rendering optimizations. Deduct 5 points for noticeable frame drops during normal play, 3 points for excessive memory usage, and 5 points for lack of graphics options to accommodate different hardware capabilities. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "hard"
+}