@getollie/cli 0.0.4 → 0.2.0

package/library/game_development-action_rhythm/super-mario-web-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 1461,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you provide is executable for demonstration purposes. Help me write a Super Mario code that I can run on a web page.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core Mario character movement system implemented?",
-      "description": "Review whether the code accurately implements Mario's movement physics including running, jumping, and momentum. Check for collision detection with platforms, enemies, and items. Score 0 if core movement is missing, 5 if basic movement exists but lacks physics accuracy, and 10 if the movement feels authentic to the original game.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are the essential game mechanics fully implemented?",
-      "description": "Evaluate implementation of core Super Mario mechanics: power-ups (mushroom, fire flower), enemy interactions, coin collection, block breaking, and level completion conditions. Deduct 3 points if power-ups are missing, 3 points if enemy interactions are incomplete, and 2 points if coin/scoring system is absent. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is a complete, playable level constructed?",
-      "description": "Check whether the code creates at least one complete, playable level with start and end points, appropriate enemy placement, platforms, and collectibles. Score 0 if there's only a test environment, 5 if there's a basic but incomplete level, and 10 if there's a well-designed, balanced level that captures the Super Mario feel.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the game's visual representation authentic to Super Mario?",
-      "description": "Assess whether the visual elements (sprites, animations, backgrounds) accurately represent the Super Mario aesthetic. Check for sprite animations (walking, jumping, state changes), background parallax effects, and visual feedback. Deduct 3 points for missing animations, 4 points for poor sprite quality, and 3 points for inconsistent visual style. 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, frame rate fluctuations, 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. Level editor 2. Custom character skins 3. Modern visual effects while preserving retro 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 Mario game (e.g., unnecessary social media integrations) 3. Fancy effects that affect performance (e.g., excessive particle effects). 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 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 game logic and rendering. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional game design standards?",
-      "description": "Evaluate whether the UI elements (score display, lives, timer, menus) are well-integrated into the game world without breaking immersion. Check for: 1) Clean HUD design that doesn't obstruct gameplay 2) Intuitive controls with visual feedback 3) Proportional sizing of game elements. Deduct 3 points for obtrusive UI elements, 5 points for confusing control schemes, and 5 points for inconsistent visual scale. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and responsive?",
-      "description": "Judge whether the game controls and animations feel responsive: 1) Input lag under 50ms 2) Consistent frame rate (minimum 30 FPS) 3) Smooth transitions between animations and game states. Deduct 5 points for perceptible input delay, 3 points for frame rate drops during normal gameplay, and 5 points for jerky animations or transitions. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Action/Rhythm",
-  "difficulty": "hard"
-}

package/library/game_development-action_rhythm/tank-battle-game-code.json

@@ -1,68 +0,0 @@
-{
-  "index": 978,
-  "question": "You are a coding expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you produce is executable for demonstration. Help me generate code for a tank battle game.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the tank battle core mechanics fully implemented?",
-      "description": "Review whether the code accurately implements tank movement control (WASD/arrow keys), rotation mechanics, firing system with projectile physics, and collision detection between tanks, bullets, and obstacles. Score 0 if basic tank control is missing, 5 if only movement is implemented without proper physics, and 10 if all mechanics including realistic tank physics (acceleration/deceleration) and accurate hit detection are fully included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the battlefield environment and combat system complete?",
-      "description": "Check whether the implementation includes a proper battlefield map with destructible/indestructible obstacles, spawn points, health system, ammunition management, and scoring mechanism. Evaluate if power-ups, different weapon types, or terrain effects are included. Deduct 5 points if health/damage system is missing, 3 points if no environmental interactions exist. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the multiplayer or AI opponent system properly designed?",
-      "description": "Evaluate whether the game supports multiple players (local or network) or includes AI opponents with reasonable difficulty levels. For multiplayer, check if player identification, turn management, and fair gameplay mechanics are implemented. For AI, assess if the bot behavior includes pathfinding, strategic targeting, and adaptive difficulty. Deduct 5 points if only single-player mode exists without opponents, 3 points if AI behavior is too simplistic. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the complete game state management and progression system constructed?",
-      "description": "Check whether the code includes comprehensive game lifecycle management: game start/pause/restart, win/lose conditions, score tracking, level progression, and game session persistence. Deduct 5 points if game state transitions are not properly handled, 3 points if no victory conditions are defined, and 2 points if restart functionality is missing. Give 10 points if fully implemented with proper state management.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as out-of-bounds movement, rapid key presses, collision edge cases, browser compatibility issues, 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 gaming experience (e.g., 1. Particle effects for explosions 2. Mini-map radar system 3. Weapon upgrade system 4. Environmental destruction 5. 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 collision detection systems coexisting) 2. Function modules unrelated to tank battles (e.g., built-in social media integration) 3. Excessive visual effects that hurt performance (e.g., too many simultaneous particle systems). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core gameplay is interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/rendering/input handling), code organization, and maintainability. Deduct 5 points if global state pollution is found or proper object-oriented design is not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 3 points if performance optimization is not considered (e.g., inefficient rendering loops). The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern game UI principles: 1) Harmonious color scheme appropriate for military theme 2) Clear HUD elements (health bars, ammo counters, mini-map) with proper contrast 3) Consistent visual style and readable fonts (UI text ≥ 12px). Deduct 3 points for each cluttered UI element, 5 points for poor color contrast affecting gameplay, and 5 points for inconsistent visual design. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the game interactions conform to gaming standards: 1) Input response delay ≤ 50ms for competitive gameplay 2) Smooth animation transitions for tank movement and turret rotation 3) Clear visual feedback for hits, damage, and game events 4) Consistent frame rate (ideally 60fps). Deduct 5 points for each laggy interaction, 3 points for stuttering animations, and 5 points for unclear visual feedback. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Action/Rhythm",
-  "difficulty": "medium"
-}

package/library/game_development-action_rhythm/temple-run-style-girl-protagonist-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 852,
-  "question": "You are a coding expert. Please use your professional knowledge to generate accurate and professional responses. Ensure that the code you generate is executable for demonstration. Please help me write a game similar to Temple Run, but make the protagonist in the story a beautiful young girl.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core endless running game mechanics fully implemented?",
-      "description": "Review whether the code accurately implements the endless running system through HTML5 Canvas/WebGL, including continuous terrain generation, character automatic forward movement, left-right lane switching, jumping/sliding mechanics, and collision detection with obstacles. Score 0 if core running mechanics are missing, 5 if only basic movement is implemented, and 10 if all Temple Run-style mechanics (lane switching, jumping, sliding, turning) are fully functional.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the dynamic obstacle generation and collision system properly designed?",
-      "description": "Check whether the obstacle generation system includes procedural generation algorithms, progressive difficulty scaling, and multiple obstacle types (barriers, gaps, moving obstacles). Evaluate collision detection accuracy and response mechanisms. Deduct 5 points if collision boundaries are imprecise, and 3 points if obstacle variety is insufficient. Requires smooth difficulty progression and fair collision feedback. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the 3D environment rendering and camera system optimized?",
-      "description": "Evaluate whether the 3D rendering system uses efficient techniques like frustum culling, level-of-detail (LOD) management, and texture atlasing. Check if the third-person camera smoothly follows the character with appropriate motion blur and depth of field effects. Deduct 5 points if frame rate drops below 30fps on average devices, and 3 points if camera movement causes motion sickness. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the character animation and control system polished?",
-      "description": "Check whether the beautiful girl protagonist has smooth animation transitions between running, jumping, sliding, and turning states. Evaluate character model quality, facial expressions, and clothing physics. Review input responsiveness for touch/keyboard controls with appropriate animation blending. Deduct 5 points if animations are choppy or unnatural, and 3 points if character design lacks visual appeal. Give 10 points if fully polished.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid input sequences, memory overflow from endless generation, device rotation, focus loss/resume, etc.) and provide graceful degradation or recovery mechanisms. Code with strong robustness should maintain stable performance during extended gameplay sessions, giving 10 points. If robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that enhance gameplay experience?",
-      "description": "Check whether the code includes engaging features beyond basic Temple Run mechanics (e.g., 1. Power-up collection system with visual effects 2. Character customization options 3. Environmental theme variations 4. Social sharing of high scores 5. Gesture-based special moves). Add 2-3 points for each well-implemented innovative feature that adds meaningful gameplay value (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features that impact performance?",
-      "description": "Strictly check three types of redundancy: 1. Duplicate rendering pipelines or animation systems 2. Unnecessary high-resolution assets that don't improve visual quality 3. Complex particle effects that cause frame drops without adding significant value. Deduct 3 points for each performance-impacting redundancy found, and directly deduct 10 points if core gameplay is compromised by unnecessary features.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code demonstrate solid engineering architecture?",
-      "description": "Review modular separation of concerns (rendering engine, game logic, input handling, asset management), efficient memory management for endless generation, and proper asset loading strategies. Deduct 5 points if memory leaks are detected or if the architecture doesn't scale well; deduct 5 points if code organization is poor with high coupling; deduct 5 points if no performance monitoring or optimization strategies are evident. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the visual design achieve professional mobile game standards?",
-      "description": "Evaluate whether the overall aesthetic follows modern mobile game design: 1) Cohesive art style with consistent lighting and color palette 2) Clear UI elements with appropriate sizing for touch interaction (minimum 44px touch targets) 3) High-quality character design that fits the Temple Run aesthetic while being distinctive. Deduct 3 points for inconsistent visual style, 5 points for poor character model quality, and 5 points for cluttered or hard-to-read UI elements. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the gameplay interaction fluid and responsive?",
-      "description": "Judge whether the control system provides immediate feedback: 1) Touch/swipe response time ≤ 50ms for mobile-optimized gameplay 2) Smooth animation transitions without stuttering during rapid input sequences 3) Clear visual and audio feedback for all player actions 4) Intuitive gesture recognition for lane switching and jumping/sliding. Deduct 5 points for each unresponsive control interaction, 3 points for delayed visual feedback, and 5 points if gesture recognition fails frequently. Full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Action/Rhythm",
-  "difficulty": "hard"
-}

package/library/game_development-action_rhythm/tiktok-douyin-agar-io-mini-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 1681,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code for demonstration. Help me design a mini-game similar to Agar.io for TikTok/Douyin, and first generate HTML code so I can try running it.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core game mechanic of Agar.io properly implemented?",
-      "description": "Review whether the code implements the fundamental player blob movement, growth mechanics, and collision detection. The player should be able to move using mouse or touch controls, consume smaller elements to grow, and be consumed by larger players. Score 0 if core mechanics are missing, 5 if basic movement and growth are implemented, and 10 if all Agar.io-style mechanics (splitting, ejecting mass, etc.) are fully included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the canvas rendering optimized for mobile performance?",
-      "description": "Check if the game uses efficient canvas rendering techniques suitable for TikTok/Douyin's mobile environment. Verify if the game implements viewport culling (only rendering objects in view), uses requestAnimationFrame properly, and optimizes for mobile GPU. Deduct 3 points for frame drops below 30fps on mid-range devices, 4 points if mobile touch controls are not properly implemented, and 3 points if the game doesn't scale properly across different screen sizes. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Does the game implement social/viral features suitable for TikTok/Douyin?",
-      "description": "Evaluate whether the game includes features that make it shareable and engaging for TikTok/Douyin users, such as quick match sessions (under 2 minutes), score sharing capabilities, personalized avatars, or replay highlights. Deduct 5 points if the game lacks any TikTok/Douyin integration hooks, 3 points if session length is inappropriate for short-form content platforms, and 2 points if there are no viral sharing mechanics. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are the AI opponents' behaviors properly implemented?",
-      "description": "Assess the implementation of AI opponents, which are crucial for an engaging single-player experience. Check for varied AI behavior patterns (aggressive, defensive, etc.), pathfinding algorithms, and difficulty scaling. Deduct 3 points if AI movement is predictable/robotic, 4 points if there's no difficulty progression, and 3 points if AI doesn't adapt to player behavior. 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 screen rotation, browser tab switching, touch event conflicts with the platform, network latency, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Special power-ups unique to this implementation 2. Real-time leaderboard with animation 3. Dynamic background themes based on player size). 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 the Agar.io gameplay (e.g., unnecessary mini-games within) 3. Fancy effects that affect mobile 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/view/input handling layers), code organization, and optimization for TikTok/Douyin's WebView environment. 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 bundled or minified for production. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet short-form video platform standards?",
-      "description": "Evaluate whether the overall design follows mobile-first principles: 1) Bold, vibrant colors that stand out on video feeds 2) Large, touch-friendly UI elements (minimum 44×44px tap targets) 3) Minimal text with large fonts (≥16px). Deduct 3 points for hard-to-see elements on mobile, 5 points for cluttered interfaces, and 5 points for UI that obscures gameplay. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and optimized for short gameplay sessions?",
-      "description": "Judge whether the game is designed for TikTok/Douyin's fast-paced environment: 1) Initial load time ≤ 2 seconds 2) Game start to active play ≤ 3 seconds 3) Responsive controls with ≤ 50ms input lag. Deduct 5 points for each second of loading beyond thresholds, 3 points for each extra step before gameplay begins, and 5 points if touch controls aren't properly calibrated for mobile devices. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Action/Rhythm",
-  "difficulty": "medium"
-}

package/library/game_development-action_rhythm/two-figures-fighting-animation-mobile.json

@@ -1,68 +0,0 @@
-{
-  "index": 212,
-  "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. Create an animation code of two little figures fighting - one red figure and one blue figure. Don't use simple blocks to represent the figures; they should have relatively realistic human body shapes with heads, hands, and feet. Both figures should be holding knives. The code should be directly runnable on mobile phones!",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Are the human figure representations anatomically reasonable?",
-      "description": "Evaluate whether the figures have realistic human body proportions with clearly defined heads, torsos, arms, legs, and feet. The figures should not be simplistic stick figures or blocks. Check whether the body parts are properly connected and move naturally during the animation. Score 0 if only basic shapes are used, 5 if figures have basic body parts but with unrealistic proportions, and 10 if figures appear realistic with proper anatomical structure.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the knife-holding combat animation properly implemented?",
-      "description": "Review the implementation of weapon holding and combat movements. The knives should be visually distinct objects that remain properly positioned in the figures' hands during movement. Combat animations should include attack motions, defensive postures, and appropriate weapon trajectories. Deduct 5 points if weapons float disconnected from hands, 3 points if combat movements are too simplistic (less than 3 distinct fighting moves). Give 10 points if weapons appear naturally held with realistic combat movements.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is color differentiation and character distinction effective?",
-      "description": "Assess whether the red and blue figures are clearly distinguishable not just by color but also potentially by subtle differences in appearance or fighting style. Color contrast should be sufficient for visibility on various backgrounds. Deduct 3 points if the color difference is the only distinguishing feature, 5 points if the figures are identical apart from color. The full score is 10 points for characters with unique identities beyond color.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the animation optimized for mobile devices?",
-      "description": "Check whether the code is specifically optimized for mobile execution, including touch controls if interactive, responsive design that adapts to different screen sizes, and performance optimization techniques. Verify mobile viewport settings and touch event handling if applicable. Deduct 5 points if no mobile-specific optimizations exist, 3 points if performance issues would occur on mid-range 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 browser compatibility issues, screen resizing, device rotation, etc.) and provide graceful fallbacks. 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 lighting effects during combat 2. Environmental interactions like surfaces breaking 3. Combat progression with changing fighting styles). 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 animation loops or duplicate rendering code 2. Unnecessary features unrelated to the fighting animation (e.g., unrelated background animations) 3. Excessive effects that cause performance issues on mobile devices. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core animation is interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating animation logic/rendering/control layers), code reusability, and performance optimization. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if no performance optimizations for animation are implemented. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the visual design meet professional animation standards?",
-      "description": "Evaluate whether the overall design follows animation principles: 1) Anticipation before movements 2) Proper squash and stretch for impact 3) Professional timing and spacing for realistic motion. Deduct 3 points for each jerky movement, 5 points for unrealistic motion physics, and 5 points for inconsistent animation quality between characters. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the animation smooth and performant?",
-      "description": "Judge whether the animation maintains consistent frame rates on mobile devices: 1) At least 30fps performance on mid-range phones 2) No visual stuttering during complex movements 3) Efficient use of resources (memory/CPU/GPU). Deduct 5 points for each noticeable frame drop, 3 points for jittery transitions between animation sequences, and 5 points if the animation causes significant battery drain. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Action/Rhythm",
-  "difficulty": "easy"
-}

package/library/game_development-action_rhythm/two-player-fighting-web-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 1419,
-  "question": "You are a coding expert. Please use your professional knowledge to generate accurate and professional responses. Make sure that the code you generate is executable and displayable. Please create a two-player fighting web game code for me again, ensuring advanced code logic that can run completely.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core combat system fully implemented?",
-      "description": "Review whether the code accurately implements player movement, attacks, and collision detection mechanisms. Check if there are health systems, damage calculation, and hit detection logic. Score 0 if the core interaction logic is not implemented, 5 if only basic movement and attacks exist, and 10 if advanced combat mechanics (combos, special moves, blocking) are fully included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the two-player functionality properly implemented?",
-      "description": "Evaluate whether the code properly handles two players on the same screen or via network. Check for proper input handling for both players (keyboard controls for local play or WebSocket for online). Deduct 5 points if player states are not properly separated and synchronized, and 3 points if there's no mechanism to prevent input conflicts. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the game state management robust and comprehensive?",
-      "description": "Check if the code includes proper state management for the fighting game (character selection, round start/end, win/lose conditions, timing). Evaluate whether game rounds are properly tracked and if there's a clear victory determination system. Deduct 5 points if the game state is inconsistent after multiple rounds, and 3 points if timeout handling is missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the character balance and game mechanics well-designed?",
-      "description": "Assess whether the fighting game has balanced characters with distinct abilities, hitboxes, and movement speeds. Check if the combat mechanics are fair and engaging. Deduct 5 points if one character has clear advantages over others, and 3 points if the combat feels too simplistic or lacks strategy. 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 spamming, out-of-bounds movement, timing issues, 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 environmental effects that impact gameplay 2. Replay system with slow-motion highlights 3. Character progression or unlockable moves). 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 fighting 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 game logic/view/input handling layers), proper class hierarchies for characters/moves, 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 performance optimization for animation rendering. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional fighting game standards?",
-      "description": "Evaluate whether the overall design follows fighting game visual conventions: 1) Clear health bars and round indicators 2) Responsive character animations with proper hit feedback 3) Distinct visual cues for special moves and attacks. Deduct 3 points for unclear UI elements, 5 points for animations that don't properly communicate gameplay, and 5 points for poor visual feedback on hits/blocks. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and responsive?",
-      "description": "Judge whether the game controls and animations conform to fighting game standards: 1) Input response time ≤ 50ms 2) Proper attack startup and recovery frames 3) Smooth animation transitions between moves. Deduct 5 points for input lag, 3 points for jerky or inconsistent animations, and 5 points for poor hit feedback and impact visualization. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Action/Rhythm",
-  "difficulty": "medium"
-}

package/library/game_development-action_rhythm/web-animation-stick-figures-fighting.json

@@ -1,68 +0,0 @@
-{
-  "index": 208,
-  "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 whenever possible. I am a programming beginner, please help me create a web-based animation showing stick figures fighting each other, and guide me on how to use it.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the stick figure fighting animation properly implemented?",
-      "description": "Review whether the code correctly implements stick figure characters with proper joint connections and movement capabilities. Check if the animation includes proper physics for realistic movements (e.g., gravity, momentum). Score 0 if stick figures are not properly rendered, 5 if basic static figures are drawn but animation is limited, and 10 if fully articulated stick figures with smooth movements are implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the fighting interaction between stick figures implemented?",
-      "description": "Evaluate the implementation of combat mechanics between stick figures. Check for collision detection between figures, attack animations, defensive moves, and health/damage systems. Score 0 if no interaction exists, 5 if basic collision is implemented but combat feels unrealistic, and 10 if there's a comprehensive combat system with various attacks, defenses, and believable physics.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is there user control for the stick figures?",
-      "description": "Assess the implementation of keyboard/mouse controls that allow users to manipulate at least one of the stick figures. Check for responsiveness (inputs registered within 100ms), intuitiveness of controls, and whether instructions are provided. Deduct 5 points if controls are limited to basic movements, 3 points if there are no alternative control schemes. Full score requires comprehensive controls for both movement and combat actions.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the animation loop and game state management properly implemented?",
-      "description": "Examine whether the code implements proper requestAnimationFrame usage, maintains consistent frame rates (target 60fps), and handles game states (start, pause, resume, end conditions). Check for memory leaks during long gameplay. Deduct 5 points for frame rate issues, 5 points if there's no proper game state handling, and 3 points if animation timing is inconsistent.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code handles common edge cases (browser compatibility, window resizing, input device variations, performance degradation). Code with strong robustness should gracefully handle these scenarios with fallback mechanisms. Give 10 points for comprehensive error handling and browser compatibility, 5 points for average robustness, and 0 points if the code breaks easily under common variations.",
-      "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 moves or combos 2. Environmental interactions like obstacles 3. Different fighting styles for stick figures 4. Sound effects synchronized with animations). 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 animation loops or rendering processes 2. Unnecessary visual elements unrelated to the fighting animation 3. Complex effects that impact performance without adding value to the core experience. Deduct 3 points for each redundancy found, and directly deduct 10 points if redundant code significantly impacts core animation performance.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (separation of animation logic, rendering, and user input handling), clean code practices, and maintainability. Deduct 5 points if global variable pollution is excessive; deduct 5 points if there's high code duplication (over 30%); deduct 5 points if the code lacks proper commenting for a beginner to understand. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the animation canvas is properly positioned with adequate margins, if controls/UI elements follow consistent design principles, and if the overall visual presentation is clean. Deduct 3 points for poorly positioned elements, 5 points for inconsistent visual style between UI and animation, and 5 points for lack of visual feedback during interactions. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the beginner guidance comprehensive and educational?",
-      "description": "Assess the quality of instructions provided for beginners: 1) Clear setup instructions that work without advanced knowledge 2) Explanation of code concepts used in the animation 3) Guidance on how to modify or extend the animation. Deduct 5 points if setup instructions are incomplete, 5 points if there's no explanation of core animation concepts, and 3 points if there's no guidance for customization. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Action/Rhythm",
-  "difficulty": "easy"
-}

package/library/game_development-action_rhythm/wong-ka-kui-parkour-game-html.json

@@ -1,68 +0,0 @@
-{
-  "index": 765,
-  "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 for demonstration purposes. Help me create a parkour game where the character is Wong Ka Kui (Beyond's lead vocalist), controlled by the A, W, S, D keys, in HTML format.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the basic parkour game mechanics fully implemented?",
-      "description": "Review whether the code implements core parkour mechanics including: character movement, jumping mechanism, obstacle generation and collision detection. Score 0 if the character cannot move, 5 if only basic left-right movement exists, and 10 if complete parkour mechanics (including jumping, dodging, and progressive difficulty) are implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the Wong Ka Kui character properly implemented and designed?",
-      "description": "Check whether the Wong Ka Kui character is visually recognizable (either through sprites or CSS design), has appropriate animations for different actions (running, jumping, falling), and maintains the iconic elements associated with the Beyond vocalist. Deduct 5 points if the character lacks recognizable features, 3 points if animations are missing, and 2 points if proportions are significantly distorted. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the A, W, S, D key control system properly implemented?",
-      "description": "Evaluate whether the WASD key controls are responsive (≤100ms delay), intuitive (W for jump, A/D for left/right movement, S for ducking/sliding), and handle edge cases like multiple key presses. Check for keyboard event listeners and proper key mapping. Deduct 5 points if controls are unresponsive or laggy, and 5 points if key combinations aren't handled properly. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the game environment and obstacle system well-designed?",
-      "description": "Assess whether the game includes varied obstacles that spawn progressively, a scoring system that tracks the player's progress, and background elements that create an engaging parkour environment. Deduct 3 points for monotonous obstacles, 3 points for missing score tracking, and 4 points if the difficulty doesn't increase over time. 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 key presses, browser resizing, performance issues on slower devices, 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. Beyond music integration 2. Special power-ups related to Wong Ka Kui or Beyond 3. Easter eggs from Beyond's music history). 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 parkour game (e.g., unnecessary menus or settings) 3. Fancy effects that affect performance (e.g., excessive particles or 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 game logic/rendering/input handling), code organization, and maintainability. Deduct 5 points if global state pollution is found or if game functions are not encapsulated properly; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the code lacks 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 design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout of game elements (score display, character, obstacles) 3) Professional font system for game text (instructions, score, game over). 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 game's dynamic effects conform to human perception characteristics: 1) Character responds to controls within 100ms 2) Animation transitions are smooth (60fps target) 3) Collision feedback is clear and precise. Deduct 5 points if controls feel unresponsive, 3 points for jerky animations or frame drops, and 5 points for unclear collision boundaries or feedback. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Action/Rhythm",
-  "difficulty": "medium"
-}