@getollie/cli 0.0.4 → 0.2.0

package/library/game_development-action_rhythm/godzilla-vs-kong-click-speed-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 999,
-  "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. Write a Godzilla versus Kong game where two players control the characters, and victory is determined by clicking speed.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core game mechanic of clicking speed competition implemented?",
-      "description": "Check if the code implements a click speed counter for each character (Godzilla and Kong), with proper event listeners and score tracking. Scoring should accurately reflect click frequency over time rather than just raw click counts. Score 0 if this core mechanic is missing, 5 points if basic click counting exists but lacks proper timing mechanisms, and 10 points if the system includes click rate calculation with time normalization.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are Godzilla and Kong characters properly implemented with visual feedback?",
-      "description": "Evaluate if both characters have distinct visual representations with appropriate animations/visual changes that respond to player actions. Characters should display different states (idle, attacking, winning, losing). Deduct 5 points if characters are static images without animations, 3 points if only basic state changes exist. Give 10 points if characters have fluid animations tied to game actions with proper hit/impact effects.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the two-player control system properly implemented?",
-      "description": "Review whether the game properly supports two separate input mechanisms (e.g., different keyboard keys or screen areas) that don't interfere with each other. Check if player controls are clearly explained and if the system prevents cross-player inputs. Deduct 5 points if inputs frequently conflict, 3 points if controls are functional but poorly explained. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there a complete game flow with victory conditions?",
-      "description": "Check if the game properly implements start states, battle progression, victory determination, and match conclusion with restart options. Victory should be clearly tied to clicking performance with appropriate thresholds. Deduct 5 points if victory conditions are unclear, 3 points if game restart is missing, and 5 points if there's no proper battle progression visualization. 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 clicking beyond normal counts, browser compatibility issues, simultaneous key presses) and provide friendly error handling or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Special power moves triggered at certain click rates 2. Dynamic background changes based on who's winning 3. Character-specific sound effects for attacks). 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 click counters using different methods) 2. Function modules unrelated to the Godzilla vs. Kong battle theme (e.g., unnecessary settings options) 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 game logic/view/input handling layers), code organization, and maintainability. Deduct 5 points if global state pollution is found or proper encapsulation is missing; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the code lacks comments or is difficult to maintain. 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 appropriate to the monster battle theme 2) Proper layout spacing (character positioning, UI elements, score displays) 3) Professional font system with readable health/score indicators during fast gameplay. 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) Click feedback delay ≤ 100ms 2) Character attack animations properly timed with player clicks 3) Clear visual indicators of which player is currently winning. Deduct 5 points for each operation without feedback, 3 points for stuttering animations during rapid clicking, and 5 points for unclear game state visualization. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Action/Rhythm",
-  "difficulty": "easy"
-}

package/library/game_development-action_rhythm/google-chrome-dinosaur-game-html-javascript.json

@@ -1,68 +0,0 @@
-{
-  "index": 16,
-  "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 can be demonstrated.\n\nPlease implement a Google Chrome dinosaur game using HTML and JavaScript, and include comments in the code so that other developers can understand your implementation process.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the game core mechanics fully implemented?",
-      "description": "Evaluate whether the code accurately implements the dinosaur jumping/ducking mechanics, obstacle generation and movement, collision detection, and score tracking. Score 0 if core game mechanics are missing, 5 if basic jumping is implemented but lacks other features, and 10 if all mechanics from the original Chrome dinosaur game are present.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the game loop and animation system properly implemented?",
-      "description": "Check whether requestAnimationFrame is used for smooth animation, if the game maintains consistent FPS regardless of device performance, and if the animation timing is properly managed. Deduct 5 points if using setTimeout/setInterval instead of requestAnimationFrame, 3 points if frame rate inconsistencies are visible, and 3 points if there's no delta time calculation for movement. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are the game assets and visual elements properly implemented?",
-      "description": "Verify if the game includes proper sprites for the dinosaur (running, jumping, ducking animations), various obstacles (cacti, birds), and environment elements (ground, clouds, day/night cycle). Deduct 3 points for each missing animation, 5 points if there's no visual variety in obstacles, and 2 points if the ground scrolling effect is not implemented. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the game difficulty progression implemented?",
-      "description": "Evaluate if the game properly increases in difficulty over time (speed increases, obstacle frequency changes, different obstacle combinations). Deduct 5 points if the game speed remains constant throughout gameplay, 3 points if obstacle patterns don't vary with score, and 2 points if there's no visual indication of difficulty progression. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as window resize, tab visibility changes, device performance variations, input device differences) and provide appropriate responses. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Power-ups or collectibles 2. Alternative control schemes 3. Visual effects for milestone scores 4. Custom dinosaur skins). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple collision detection systems) 2. Function modules unrelated to the dinosaur game (e.g., unnecessary UI elements) 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), code organization, and comprehensive comments as required in the prompt. Deduct 5 points if global state pollution is found or proper encapsulation is not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if comments are missing or insufficient for understanding the implementation process. 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 faithfully reproduces the Chrome dinosaur game aesthetic: 1) Consistent pixel art style 2) Clean black and white color scheme with proper contrast 3) Proper scaling and proportions on different screen sizes. Deduct 3 points for each visual inconsistency with the original game, 5 points for inappropriate color usage, and 5 points for poor responsive design. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the game controls feel responsive and natural: 1) Input response delay ≤ 50ms 2) Smooth collision and death animations 3) Clear visual feedback for player actions and game events. Deduct 5 points for 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-Action/Rhythm",
-  "difficulty": "hard"
-}

package/library/game_development-action_rhythm/google-chrome-dinosaur-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 985,
-  "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 display. Please help me create HTML code for the Google Chrome dinosaur game.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core game mechanic properly implemented?",
-      "description": "Check if the code implements the essential dinosaur jumping/ducking mechanics, obstacle generation, and collision detection. Score 0 if no game logic is implemented, 5 if basic jumping exists but collision detection is flawed, and 10 if all core mechanics work correctly including proper hit-box calculations.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the game rendering and animation system properly implemented?",
-      "description": "Evaluate the implementation of game rendering using Canvas/CSS animations, including proper frame-rate management (ideally 60fps), smooth sprite animations, and parallax scrolling for background elements. Deduct 5 points if animation is choppy (< 30fps), 3 points if sprite sheets are not utilized efficiently, and 3 points if there's no parallax effect. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the game difficulty progression correctly implemented?",
-      "description": "Check if the game includes progressive difficulty scaling (increasing speed, more obstacles, day-night transitions) based on score/time. Deduct 5 points if speed remains constant throughout gameplay, 3 points if obstacle patterns don't vary with difficulty, and 5 points if there's no difficulty curve. Full score for implementing all original Chrome dinosaur game progression features.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the score tracking and high score system fully functional?",
-      "description": "Evaluate if the code properly implements score tracking (based on distance/time), displays the current score in real-time, and maintains a persistent high score using localStorage. Deduct 3 points if score display isn't properly formatted (e.g., leading zeros), 5 points if high scores aren't persistent across sessions, and 3 points if score milestones aren't celebrated (e.g., score flashing at intervals).",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as window resizing, browser performance issues, focus loss, input lag) and provide graceful degradation or recovery mechanisms. Code with strong robustness should handle these edge cases effectively, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Power-ups like shields or slow-motion 2. Alternative character skins 3. Mobile touch/tilt support). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple collision detection systems) 2. Function modules unrelated to the dinosaur game (e.g., a built-in calculator) 3. Fancy effects that affect performance (e.g., unnecessary 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), code organization, and performance optimization. Deduct 5 points if global state pollution is found or best practices aren't followed; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the game loop implementation is inefficient or causes memory leaks. 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 matches the original Google Chrome dinosaur game's minimalist pixel art style: 1) Proper monochromatic palette 2) Correct sprite proportions and animations 3) Clean, non-pixelated rendering at various zoom levels. Deduct 3 points for unnecessary visual elements, 5 points for inappropriate graphics style, and 5 points for incorrect aspect ratios or sprite dimensions. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the game controls feel responsive and match the original: 1) Input response delay ≤ 50ms 2) Appropriate jump height and timing windows 3) Intuitive keyboard/touch controls with visual feedback. Deduct 5 points for input lag, 3 points for jerky character movement, and 5 points for unintuitive control schemes. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Action/Rhythm",
-  "difficulty": "hard"
-}

package/library/game_development-action_rhythm/gorilla-chase-parkour-running-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 752,
-  "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. Create a web game where a person is being chased by a gorilla from behind - a parkour/running game.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core parkour game mechanics fully implemented?",
-      "description": "Review whether the code implements the basic parkour/running mechanics including player movement, jumping, obstacles generation, collision detection, and scoring system. The character must be able to run forward with the gorilla chasing from behind. Score 0 if the core mechanics are absent, 5 if basic movement and obstacle detection exist but without proper chase dynamics, and 10 if the complete parkour system with difficulty progression is implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the gorilla chase AI behavior properly designed?",
-      "description": "Evaluate the gorilla's AI behavior - it should dynamically pursue the player with appropriate difficulty scaling (increasing speed over time or when player performs well). Check if the gorilla has realistic animations and movement patterns. Deduct 5 points if the gorilla moves in a straight line without any intelligence, 3 points if the chase animation lacks smoothness, and 2 points if there's no difficulty progression. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are the game controls responsive and intuitive?",
-      "description": "Check if the game implements touch/keyboard controls that respond within 50ms, allowing the player to jump, slide, or dodge obstacles. Controls should be clearly explained and consistent. Deduct 5 points if input lag exceeds 100ms, 5 points if controls are not explained in-game, and 3 points if the control scheme is overly complicated. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the game environment properly generated and infinite?",
-      "description": "Assess whether the code implements procedural generation of the game environment for endless running, with appropriate memory management (removing off-screen elements). Check if obstacle patterns are varied and thematically appropriate. Deduct 5 points if the environment is static/finite, 3 points if obstacles are too repetitive, and 5 points if there are performance issues with environment generation. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid input changes, browser resizing, device orientation changes, 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. Power-ups that temporarily slow the gorilla 2. Environmental interaction like swinging vines 3. Different biomes/environments as the game progresses). 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 jump mechanics that serve the same purpose) 2. Function modules unrelated to parkour gameplay (e.g., an unnecessary inventory system) 3. Fancy effects that affect performance (e.g., excessive particle systems causing frame drops). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/view/input handling layers), asset management, and performance optimization. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no asset preloading strategy. 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) Consistent visual theme (jungle/urban environment) 2) Clear UI elements that don't obstruct gameplay (score display, distance meter) 3) Appropriate visual feedback for actions (jump animations, collision effects). Deduct 3 points for each interfering UI element, 5 points for inconsistent visual style, and 5 points for hard-to-read text during gameplay. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the game maintains consistent frame rate (minimum 30 FPS) and whether animations are fluid: 1) Character animation transitions are smooth 2) Obstacle appearance and removal are seamless 3) Game speed changes gradually rather than abruptly. Deduct 5 points for frame rate drops below 30 FPS, 3 points for jerky animations during critical gameplay moments, and 5 points for abrupt visual changes that disrupt gameplay flow. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Action/Rhythm",
-  "difficulty": "medium"
-}

package/library/game_development-action_rhythm/html-game-character-sprints-forward.json

@@ -1,68 +0,0 @@
-{
-  "index": 91,
-  "question": "You are a code expert. Please use your professional knowledge to provide accurate and professional responses. Make sure the generated code is executable. Create a game using HTML where a character sprints forward, ensuring it can run directly in the frontend.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the basic game character and movement system implemented?",
-      "description": "Check whether the code implements a character that moves forward continuously with proper animation frames. Verify if the character maintains consistent forward movement (sprinting) without stopping. Score 0 if there's no character movement, 5 if there's basic movement without animation, and 10 if the character has smooth sprinting animation with proper frame transitions.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the game environment and background properly implemented?",
-      "description": "Evaluate if the game has a scrolling background or environment elements that create the illusion of the character moving forward. Check for parallax scrolling effects (multiple layers moving at different speeds) and if the environment repeats seamlessly. Score 0 if there's no background, 5 if there's a static or basic scrolling background, and 10 if there's a well-implemented parallax scrolling effect with seamless transitions.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are the game controls responsive and intuitive?",
-      "description": "Review if the game includes user input handling (keyboard/touch controls) for actions like jumping, ducking, or changing lanes. Test the responsiveness of controls (input lag <50ms) and verify if there are visual cues for available actions. Score 0 if there are no controls, 5 if basic controls exist but feel sluggish, and 10 if controls are responsive and intuitive with appropriate feedback.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there a game loop with proper frame management?",
-      "description": "Check if the code implements a proper game loop using requestAnimationFrame() or similar methods, maintaining consistent frame rates (ideally 60fps) and including time-based movement calculations instead of frame-based to ensure consistent speed across different devices. Score 0 if there's no game loop, 5 if there's a basic loop without performance optimization, and 10 if there's a well-optimized game loop with frame timing.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as browser resizing, tab switching, device orientation changes, 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 difficulty adjustment 2. Character customization 3. Special power-ups or abilities 4. Weather/time effects that affect gameplay). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple collision detection systems) 2. Function modules unrelated to the sprint game (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive particle effects that cause lag). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/view/input handling layers), asset preloading, and code organization. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if assets are loaded during gameplay causing stutters. 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) Consistent visual style and theme 2) Clear distinction between game elements and UI elements 3) Professional font system (readable text during movement, appropriate size for game context). Deduct 3 points for each inconsistent visual element, 5 points for confusing UI/game element boundaries, and 5 points for poorly implemented text elements. 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) Character responds to input within 100ms 2) Animation transitions are smooth without flickering 3) Clear visual feedback for player actions and collisions. Deduct 5 points for each operation without feedback, 3 points for frame drops during animation transitions, and 5 points for unclear collision feedback. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Action/Rhythm",
-  "difficulty": "easy"
-}

package/library/game_development-action_rhythm/html-javascript-drift-mechanism-implementation.json

@@ -1,68 +0,0 @@
-{
-  "index": 123,
-  "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 and demonstrable.\n\nPlease implement a drift mechanism using HTML and JavaScript.\n\n**Task**: Design a drift mechanism where players can drift to make quick turns or avoid obstacles.\n\n**Hint**: You can set up the drift trigger method and effects, and design tracks or scenarios that require drifting skills.\n\nPlease create a game and include some comments in your code to help other developers understand your implementation process.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core drift mechanism properly implemented?",
-      "description": "Check whether the code accurately implements a realistic drift physics model that includes friction, inertia, and weight transfer. The drift should feel different from normal turning and require skill. Score 0 if no drift mechanic exists, 5 if basic drift is implemented but feels unrealistic, and 10 if the drift mechanism includes proper physics calculations with variables for different surfaces.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the drift trigger and control system intuitive?",
-      "description": "Evaluate the drift activation method (e.g., handbrake button, double-tap direction key) and the control system during drift. Check if there's proper input feedback and if the drift can be controlled mid-execution. Deduct 5 points if drift activation is unintuitive or inconsistent, 3 points if the drift control is too simplified without nuance, and 2 points if there's no visual or audio feedback when drifting. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are meaningful drift scenarios or tracks implemented?",
-      "description": "Check whether the code includes challenging tracks or scenarios where drifting provides a tangible advantage (tight corners, obstacle courses, time trials). Deduct 5 points if there are no specific scenarios that encourage drifting, 3 points if the track design doesn't require skill to navigate with drifts, and 2 points if there's no variety in the course design. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there a meaningful scoring or feedback system for drifting?",
-      "description": "Evaluate if the implementation includes a scoring system, time bonuses, or other rewards for successful drifting. Check if the system provides feedback on drift quality (perfect drift, over-drift, etc.). Deduct 5 points if there's no scoring/reward system tied to drifting, 3 points if feedback is minimal, and 2 points if the scoring system doesn't reflect drift skill accurately. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid input changes, extreme speed conditions, collisions during drift) 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. Drift boost mechanics 2. Variable terrain effects on drift performance 3. Visual drift lines or tire marks 4. Drift combo 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 movement controls (e.g., multiple drift calculation systems coexisting) 2. Function modules unrelated to the drift mechanic (e.g., unnecessary weather effects) 3. Fancy effects that affect performance (e.g., excessive particle systems that cause lag). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating physics engine, input handling, and rendering), code documentation, and optimization. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there are no comments explaining the drift physics calculations. 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 gaming UI principles: 1) Clean HUD that doesn't obstruct gameplay 2) Clear visual indicators for drift status and performance 3) Appropriate use of motion blur or visual effects during drift. Deduct 3 points for cluttered UI elements, 5 points for distracting visual effects that make drifting harder to control, and 5 points for poor contrast that makes track boundaries difficult to see. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the drift mechanics feel responsive and natural: 1) Input response delay ≤ 50ms 2) Smooth transition between normal driving and drift state 3) Consistent frame rate during drift animations. Deduct 5 points for input lag during critical drift moments, 3 points for jittery vehicle movement during drift transitions, and 5 points for inconsistent physics behavior at different speeds. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Action/Rhythm",
-  "difficulty": "easy"
-}

package/library/game_development-action_rhythm/html-javascript-platform-jumping-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 111,
-  "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.\n\nPlease use HTML and JavaScript to implement a platform jumping game where players need to jump and climb to pass through levels while avoiding traps. Set up jumping and climbing controls, and design various platforms and traps. Please include comments in your code so that other developers can understand your implementation process.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core platform jumping mechanic fully implemented?",
-      "description": "Review whether the code accurately implements jumping physics with gravity simulation, variable jump height based on button press duration, and proper collision detection with platforms. Score 0 if basic jumping is missing, 5 if only basic jumping is implemented without physics refinement, and 10 if jumping feels responsive with polished physics (e.g., terminal velocity, jump buffering, coyote time).",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the climbing mechanic properly implemented?",
-      "description": "Check whether the climbing mechanics include proper collision detection with climbable surfaces, smooth transitions between climbing and jumping states, and appropriate control limitations while climbing. Score 0 if climbing is not implemented, 5 if basic climbing exists but feels clunky or has collision issues, and 10 if climbing is smooth with proper animation transitions and intuitive controls.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are various platforms and traps designed and functional?",
-      "description": "Evaluate the diversity and functionality of platforms (static, moving, disappearing, bouncy) and traps (spikes, falling objects, timing-based hazards). Deduct 3 points if fewer than 3 platform types are implemented, 5 points if traps have no visual warning indicators, and 3 points if collision detection with hazards is inconsistent. Score 10 if at least 5 different interactive platform/trap types are implemented with clear visual distinction.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is level design and progression implemented?",
-      "description": "Check whether the game includes multiple levels with increasing difficulty, clear objectives for level completion, and smooth transitions between levels. Score 0 if only a single static level exists, 5 if multiple levels exist but lack progression in difficulty or design variety, and 10 if the game has thoughtful level progression with checkpoint systems and escalating challenges.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid input changes, framerate fluctuations, boundary conditions at level edges, etc.) and provide friendly error handling. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Power-ups with special abilities 2. Environmental interactions like destructible objects 3. Dynamic camera effects that respond to gameplay 4. Particle effects for movement feedback). 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 platform jumping gameplay (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive particle systems that cause lag). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/physics/rendering layers), code readability through comments as requested, and maintainable structure. Deduct 5 points if global state pollution is found; deduct 5 points if the code lacks the requested comments explaining the implementation; deduct 5 points if there's significant code duplication instead of reusable functions. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional game design standards?",
-      "description": "Evaluate whether the game follows professional game design principles: 1) Clear visual hierarchy between background, platforms, hazards and player character 2) Consistent art style throughout elements 3) Proper use of visual feedback for player actions (jumping, landing, taking damage). Deduct 3 points for poor contrast between interactive and non-interactive elements, 5 points for inconsistent visual style, and 5 points for lack of feedback animations. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and responsive?",
-      "description": "Judge whether the game controls feel responsive and smooth: 1) Input response time ≤ 50ms 2) Consistent framerate with no stuttering during animations 3) Appropriate game speed and character movement velocity. Deduct 5 points for input lag, 3 points for jerky animations during transitions, and 5 points for inconsistent game speed affecting gameplay. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Action/Rhythm",
-  "difficulty": "hard"
-}

package/library/game_development-action_rhythm/html-javascript-rhythm-game-custom-music-levels.json

@@ -1,68 +0,0 @@
-{
-  "index": 54,
-  "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 an action game - rhythm game: custom music and level generation.\n**Task**: Design a custom music mode that allows players to import their own music and automatically generate levels based on the audio tracks.\n**Hint**: You can use audio analysis tools to extract rhythm information and generate corresponding key press points.\n\nPlease include comments in your code so that other developers can understand your implementation process.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the music import functionality fully implemented?",
-      "description": "Review whether the code implements file upload capabilities that support common audio formats (MP3, WAV, OGG), and includes proper validation and error handling for file size and format. Score 0 if music import is not implemented, 5 if only basic file upload is available, and 10 if it includes advanced features like progress indicators and drag-and-drop functionality.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the audio analysis system properly implemented?",
-      "description": "Evaluate whether the code uses Web Audio API to analyze the imported audio track, including beat detection, frequency analysis, and amplitude variation. Check if it extracts meaningful rhythm information such as BPM, beat timing, and intensity changes. Deduct 5 points if only basic amplitude analysis is implemented, and 3 points if the analysis doesn't account for different music genres. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the level generation algorithm effective and aligned with the music?",
-      "description": "Check if the algorithm maps audio analysis data to gameplay elements (note placement, timing, patterns) that match the rhythm and intensity of the music. Verify if it creates a balanced difficulty curve and handles transitions between different music sections. Score 0 if level generation is random/unrelated to the music, 5 if it only follows basic beat patterns, and 10 if it creates varied and musically-coherent gameplay experiences.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the gameplay mechanic responsive and synchronized with the music?",
-      "description": "Assess whether the game maintains proper synchronization between visuals, input detection, and audio playback. Check for techniques to minimize audio latency and ensure visual cues appear at the correct time. Deduct 5 points if there's noticeable desynchronization, 3 points if there's no calibration system for different devices. 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 unsupported audio formats, processing large files, unexpected user interactions, 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. Real-time visual effects synchronized with music 2. Customizable note appearance and effects 3. Social sharing of created levels). 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 audio analysis methods performing the same task) 2. Function modules unrelated to rhythm gameplay (e.g., unnecessary social features) 3. Fancy effects that affect performance (e.g., excessive particles that cause frame drops). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating audio analysis/game logic/rendering layers), unit test coverage, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Input response delay ≤ 50ms (crucial for a rhythm game) 2) Visual feedback aligned precisely with audio events 3) Consistent frame rate without drops during intensive sections. Deduct 5 points for perceptible input lag, 3 points for misaligned visual/audio elements, and 5 points for frame rate issues during gameplay. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Action/Rhythm",
-  "difficulty": "hard"
-}