@getollie/cli 0.0.5 → 0.2.1

package/library/game_development-action_rhythm/classic-brick-breaking-game-code.json

@@ -1,68 +0,0 @@
-{
-  "index": 1517,
-  "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 whenever possible. The classic brick-breaking game code can be run in a browser.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core brick-breaking gameplay mechanics fully implemented?",
-      "description": "Review whether the code accurately implements essential game elements: paddle control, ball physics, brick collision detection, and score tracking. Score 0 if the core mechanics are missing, 5 if only basic collisions work, and 10 if all expected features (varying brick types, ball physics, proper boundary handling) are present.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Does the game have proper collision detection and physics?",
-      "description": "Evaluate ball physics implementation including angle reflection on paddle hits, proper wall bouncing, and brick collision accuracy. Check for edge cases like corner hits and multi-brick collisions. Deduct 3 points for unrealistic physics, 5 points for major collision bugs. Full score requires smooth, realistic physics with proper acceleration handling.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the game's difficulty progression and level design implemented?",
-      "description": "Check if the code includes multiple levels or difficulty progression (increasing speed, complex brick patterns, special bricks). Examine if there's a proper game loop with level transitions. Award 10 points for comprehensive level systems with increasing challenge, 5 points for basic progression, 0 for single-state gameplay.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are power-ups and special game features implemented?",
-      "description": "Assess the implementation of game-enhancing features like paddle size changes, multi-ball, ball speed modifications, or special brick types. Look for proper visual feedback when acquiring power-ups and their effect timing management. Award 10 points for diverse, well-balanced power-up system, 5 for basic power-ups, 0 if none exist.",
-      "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 resize, focus loss, etc.) and provide friendly error handling or recovery mechanisms. Code with strong robustness should effectively manage 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. Particle effects on brick destruction 2. Dynamic soundtrack that changes with gameplay 3. Unique themes or visual 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 implementation of similar functions (e.g., multiple collision detection systems) 2. Function modules unrelated to brick-breaking (e.g., unintegrated mini-games) 3. Fancy effects that affect performance (e.g., excessive particle systems causing lag). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/rendering/input handling), proper use of OOP or functional patterns, and code maintainability. Deduct 5 points if global state is overused or if game loop timing isn't handled properly; deduct 5 points if the code duplication rate is too high; deduct 5 points if there's no separation between game mechanics and rendering. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the game visuals follow modern game design principles: 1) Consistent visual style and color palette 2) Clear visual hierarchy and readable UI elements 3) Appropriate use of animation and transitions that don't interfere with gameplay. Deduct 3 points for inconsistent visual elements, 5 points for poor readability or usability issues, and 5 points for visual elements that hinder gameplay. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the game responsive and provides good user feedback?",
-      "description": "Judge whether the game provides appropriate feedback to user actions: 1) Immediate paddle response to input (≤ 50ms) 2) Clear visual and possibly audio feedback on collisions 3) Readable score display and game state indicators. Deduct 5 points for input lag, 3 points for missing collision feedback, and 5 points for unclear game state information. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Action/Rhythm",
-  "difficulty": "medium"
-}

package/library/game_development-action_rhythm/create-dancing-pixel-ponies.json

@@ -1,68 +0,0 @@
-{
-  "index": 1229,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Be sure to provide executable code for demonstration. I'd like to see you create dancing pixel ponies with code.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the dancing pixel pony animation fully implemented?",
-      "description": "Check if the code creates a complete pixel pony character with proper sprite sheet or pixel-by-pixel rendering. The pony should have a distinct outline and recognizable pony features (head, body, legs, tail). Deduct 5 points if the pony shape is unclear, 3 points if proportions are significantly off. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the dancing animation sequence implemented with smooth transitions?",
-      "description": "Evaluate the animation loop that creates the dancing effect. Look for frame-by-frame animation or procedural movement that creates a natural dancing motion (leg movements, body bobbing, etc.). Animations should run at minimum 12fps for smoothness. Score 10 for fluid, natural movement; 5 for basic animation with some jerkiness; 0 if the pony is static or barely moves.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is there variety in the dance movements or multiple dance patterns?",
-      "description": "Check whether the code implements multiple dance patterns, transitions between dance moves, or randomized movement variations. Award 10 points for 3+ distinct dance patterns with smooth transitions; 5 points for 1-2 patterns; 0 points if only one repetitive movement exists.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there an interactive element allowing user control or influence?",
-      "description": "Assess if the implementation includes user interaction to control the dancing ponies (e.g., mouse/keyboard input to change dance styles, speed, colors, or trigger special moves). Give 10 points for comprehensive interaction; 5 points for basic controls; 0 points for no interaction.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as browser resizing, performance optimization for different devices, error handling for missing resources). 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. Music synchronization with dance moves 2. Customizable pony colors/accessories 3. Particle effects or environmental elements like disco lights). 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 overlapping timers 2. Function modules unrelated to the dancing ponies 3. Excessive visual effects that cause performance issues. 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 animation logic/rendering/user input handling), performance optimization techniques (e.g., requestAnimationFrame usage, canvas vs. DOM manipulation choices), 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 performance considerations are absent. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the visual implementation meet professional design standards?",
-      "description": "Evaluate whether the pony design shows artistic quality: 1) Consistent pixel art style with appropriate resolution 2) Harmonious color palette (no more than 3-4 primary colors unless intentionally colorful) 3) Proper use of animation principles like squash, stretch, anticipation. Deduct 3 points for inconsistent pixel sizing, 5 points for visually jarring color combinations, and 5 points for anatomically impossible animations unless stylistically justified. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the rendering performance optimized and cross-browser compatible?",
-      "description": "Judge whether the implementation is efficient and widely compatible: 1) Maintains 60fps on modern devices 2) Uses appropriate rendering technology (Canvas/WebGL for complex animations, SVG/CSS for simpler ones) 3) Implements fallbacks for different browsers. Deduct 5 points for each noticeable frame drop during animation, 3 points for missing browser compatibility considerations, and 5 points if the animation significantly taxes CPU/GPU on standard devices. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Action/Rhythm",
-  "difficulty": "hard"
-}

package/library/game_development-action_rhythm/crossy-road-game-threejs-implementation.json

@@ -1,68 +0,0 @@
-{
-  "index": 18,
-  "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.\n\nPlease implement a Crossy Road game using HTML and JavaScript.\n\n### Gameplay\n- **Movement Control**: Use keyboard or on-screen buttons to control character movement in four directions.\n- **Avoid Obstacles**: Dodge oncoming vehicles and other obstacles.\n\n### Game Features\n- **3D Graphics**: Use the three.js library to create an engaging 3D environment.\n- **Increasing Difficulty**: As the player progresses, the speed and frequency of obstacles increase.\n\n### Game Tips\n- **Predict Routes**: Observe and predict vehicle travel paths to make movement decisions in advance.\n- **Patient Waiting**: When necessary, wait for safe crossing opportunities.\n\n### Summary\n\"Crossy Road with threejs\" is a 3D road-crossing game based on three.js. Players control a small animal, moving quickly and strategically to avoid vehicles with the goal of crossing roads as much as possible. This game provides an exciting gaming experience suitable for players who enjoy testing their reaction speed and strategic planning abilities. Please include some comments in your code to help other developers understand your implementation process.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core Crossy Road gameplay mechanics fully implemented?",
-      "description": "Review whether the code accurately implements the essential gameplay mechanics: character movement in four directions, obstacle avoidance, and game progression logic. Check if keyboard controls and optional on-screen buttons are functional.Score 0 if core movement and collision detection are not implemented, 5 if basic movement works but collision is unreliable, 10 if movement is smooth with proper collision detection and game progression logic is complete.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the 3D environment properly created using three.js?",
-      "description": "Evaluate the implementation of 3D graphics using three.js. Check for proper scene setup, camera positioning, lighting, and rendering. Assess whether the 3D environment effectively mimics the Crossy Road aesthetic with proper geometry, materials, and textures.Score 0 if three.js is not implemented or severely broken, 5 if basic 3D rendering works but lacks visual polish or proper camera work, 10 if the 3D environment is well-constructed with appropriate lighting, textures, and camera angles.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the difficulty progression implemented?",
-      "description": "Check whether the game implements increasing difficulty as the player progresses. This should include faster vehicles, more frequent obstacles, or decreased spacing between safe zones. Verify that the difficulty curve is balanced and not overly punishing.Score 0 if no difficulty progression exists, 5 if basic difficulty increase is present but poorly balanced, 10 if well-implemented difficulty scaling that creates appropriate challenge over time.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are the obstacle generation and movement systems effectively implemented?",
-      "description": "Assess the code for vehicle/obstacle generation, movement patterns, and variety. Check if obstacles move at different speeds, come from different directions, and create interesting gameplay scenarios. Evaluate the randomness and predictability balance.Score 0 if obstacles are static or non-existent, 5 if basic movement patterns exist but lack variety, 10 if obstacles have diverse, interesting patterns that create genuine strategic challenges.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid input sequences, browser resizing, focus loss, performance degradation) and provide friendly error prompts or recovery mechanisms. Check for proper event handling and cleanup.Code with strong robustness should 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. Character customization 2. Special power-ups 3. Environmental effects like day/night cycles 4. Persistent high scores).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 2. Function modules unrelated to the Crossy Road game 3. Fancy effects that affect performance (e.g., unnecessary particle systems or post-processing).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), code organization, and maintainability. Check for proper use of three.js best practices and game development patterns.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 is difficult to understand or poorly commented despite the requirement. 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 2) Proper UI layout 3) Clean game HUD that doesn't interfere with gameplay visibility. Check if the visual style is consistent with the Crossy Road aesthetic.Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic UI layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the game performance optimized and responsive?",
-      "description": "Judge whether the game runs smoothly: 1) Maintains consistent frame rate (ideally 60fps) 2) Proper memory management 3) Efficient use of three.js features without unnecessary calculations. Check for input responsiveness and game feel.Deduct 5 points for noticeable frame drops during normal gameplay, 3 points for input lag over 100ms, and 5 points for memory leaks or growing performance issues over time. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Action/Rhythm",
-  "difficulty": "medium"
-}

package/library/game_development-action_rhythm/css-html-platform-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 47,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable and can be displayed properly.\n\nPlease use HTML and JavaScript to implement a\n\n### Game Mechanics\n1. **Navigation and Jumping**: Players need to click and interact to navigate and jump over platforms.\n2. **Puzzle Solving**: Solve puzzles by manipulating elements in the environment to open paths or create ways to proceed.\n3. **Multiple Level Design**: The game includes several different levels, each with unique challenges and layouts.\n\n### Game Features\n- **Pure CSS Implementation**: The game interface and animations are entirely built with CSS, without using JavaScript.\n- **Creative Design**: Showcases creative applications of CSS in game design, providing different visual and operational experiences.\n- **Suitable for All Ages**: Simple game rules that are suitable for players of all ages.\n\n### Game Tips\n- **Observation and Planning**: Carefully observe the level layout and plan your movement route and jumps in advance.\n- **Quick Reactions**: The game may require quick reactions to avoid sudden obstacles.\n- **Utilize the Environment**: Take advantage of environmental features in the game, such as movable platforms, to help navigate through complex areas.\n\n### Summary\n\"CSS/HTML Platform Game\" provides an educational yet entertaining gaming experience through its unique pure CSS implementation and creative level design. Please implement the game and include comments in the code to help other developers understand your implementation process.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core platform game navigation and jumping mechanism fully implemented?",
-      "description": "Review whether the code accurately implements the player movement system (navigation and jumping) using CSS/HTML/JavaScript. Check if collision detection with platforms and obstacles is implemented, and if player controls are responsive.Score 0 if the core movement mechanics are not implemented, 5 if only basic movement is implemented without proper collision detection, and 10 if navigation, jumping and collision detection are fully implemented with smooth controls.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are the puzzle-solving elements properly implemented?",
-      "description": "Evaluate whether the game includes interactive puzzle elements that can be manipulated by the player. Check if these elements affect the environment to open paths or create ways to proceed through levels. Verify that puzzle solutions are logical and provide appropriate feedback to the player.Deduct 5 points if puzzles don't affect gameplay progression, 3 points if feedback is unclear or missing, and 3 points if puzzle solutions are too obvious or illogical. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the multi-level design implemented with unique challenges?",
-      "description": "Check if the game includes multiple distinct levels with varying layouts, challenges, and difficulty progression. Each level should offer a unique experience with different platform arrangements, obstacles, or puzzle types.Score 0 points if only one level exists, 5 points if multiple levels exist but are too similar, and 10 points if there are at least 3 distinctly different levels with unique challenges and appropriate difficulty curve.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the CSS-only implementation requirement met?",
-      "description": "Verify that the game interface and animations are built primarily with CSS as specified. Check if CSS is used for character movement, animations, transitions, and visual effects rather than relying heavily on JavaScript for these aspects.Deduct 3 points for each major visual or animation feature implemented in JavaScript that could have been done in CSS. Score 0 if CSS is barely used for game visuals or animations. 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 unexpected user inputs, browser incompatibilities, window resizing, etc.) and provide friendly error handling or recovery mechanisms.Code with strong robustness should be able to effectively handle 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 background changes based on game progress 2. Parallax scrolling effects 3. Unique CSS-based character animations or transformations).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 2. Function modules unrelated to the platform game concept 3. Fancy effects that affect performance negatively (e.g., excessive animations 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 layers), code organization, and maintainability. Check for proper code comments as specified in the requirements.Deduct 5 points if the CSS, HTML, and JavaScript are not properly organized; deduct 5 points if the code lacks comments explaining implementation details; deduct 5 points if the code shows high duplication rate (over 30%). 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 and harmonious color scheme 2) Clear visual hierarchy and proper layout spacing 3) Responsive design that works across different screen sizes 4) Age-appropriate visual elements as specified in the requirements.Deduct 3 points for each inconsistent visual element, 5 points for poor color combinations that affect readability, and 5 points for layouts that break on different screen sizes. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the game suitable for all ages as required?",
-      "description": "Judge whether the game adheres to the 'suitable for all ages' requirement: 1) Simple and intuitive controls 2) Clear instructions or tutorial elements 3) Appropriate difficulty progression 4) Absence of inappropriate content.Deduct 3 points if controls are unnecessarily complex, 3 points if instructions are missing or unclear, 5 points if the difficulty curve is too steep for younger players, and 5 points if any content is not appropriate for all ages. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Action/Rhythm",
-  "difficulty": "medium"
-}

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

@@ -1,68 +0,0 @@
-{
-  "index": 82,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure the generated code is executable for demonstration.\n\nPlease use HTML and JavaScript to implement a Dinosaur Hunter game where players need to track and hunt dinosaurs. Focus on implementing dinosaur behavior patterns and hunting techniques. \n\nPlease include comments in your code to help other developers understand your implementation process.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Are the core game mechanics fully implemented?",
-      "description": "Review whether the code accurately implements the hunting gameplay with proper player controls and dinosaur tracking mechanics. Check if there's hit detection, player movement, aiming/shooting mechanics, and appropriate feedback. Score 0 if core mechanics are missing, 5 if basic movement and shooting exist but lack polish, and 10 if the hunting experience is comprehensive with diverse mechanics.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are dinosaur behavior patterns convincingly implemented?",
-      "description": "Evaluate the AI implementation for dinosaurs: do they exhibit realistic behaviors such as fleeing, attacking, or roaming? Check for path-finding algorithms, state machines controlling behavior, and varying difficulty levels among different dinosaur types. Deduct 5 points if dinosaurs move in predictable patterns without adaptation, and 3 points if there's only one behavior pattern. The full score requires at least 3 distinct, realistic behavior patterns.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are hunting techniques and strategies implemented?",
-      "description": "Check if the game includes tracking mechanics (footprints, sound indicators, vision cones), stealth elements, and different hunting strategies. Assess whether the player has meaningful choices in how to approach dinosaurs. Deduct 5 points if tracking is purely random, 5 points if there's only one viable hunting strategy, and 3 points if feedback on hunting success is unclear. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the game loop and progression system complete?",
-      "description": "Evaluate whether there's a complete game cycle with clear objectives, scoring system, difficulty progression, and win/lose conditions. Check if the game tracks player performance and provides appropriate challenges as the player improves. Deduct 5 points if objectives are unclear, 3 points if difficulty remains static, and 5 points if there's no meaningful 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 rapid clicks, browser resizing, unexpected input sequences, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Weather effects affecting gameplay 2. Dynamic ecosystem where dinosaurs interact with each other 3. Day/night cycle affecting visibility and hunting strategies). 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 dinosaur hunting (e.g., unnecessary mini-games) 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 implementation of design patterns. Evaluate the quality and comprehensiveness of comments. Deduct 5 points if global state pollution is found; deduct 5 points if the code duplication rate is too high (over 30%); deduct 3 points if comments are sparse or unhelpful. 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) Immersive HUD that doesn't obstruct gameplay 2) Clear visual feedback for hits, damage, and tracking 3) Intuitive control scheme with appropriate on-screen indicators. Deduct 3 points for cluttered UI elements, 5 points for confusing visual feedback, and 5 points for unintuitive controls. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and responsive?",
-      "description": "Judge whether the game responds appropriately to player input: 1) Input lag ≤ 100ms 2) Consistent frame rate without stutters during action sequences 3) Appropriate animation timing for dinosaur movements and player actions. Deduct 5 points for noticeable input lag, 3 points for frame drops during critical moments, and 5 points for animations that feel disconnected from actions. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Action/Rhythm",
-  "difficulty": "medium"
-}

package/library/game_development-action_rhythm/fish-at-work-smash-wechat-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 1280,
-  "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. I'd like to develop \"Fish at Work Smash: The Boss-Crushing Plan\" using the WeChat Developer Tools. Please rewrite a complete, executable solution and framework.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the WeChat mini-program game framework fully implemented?",
-      "description": "Review whether the code correctly implements WeChat mini-program game framework using wx.createCanvas() and game loop management. Check if it includes proper scene management, game object lifecycle, collision detection system, and physics engine integration. Score 0 if core game framework is missing, 5 if only basic canvas rendering is implemented, and 10 if complete game framework with optimized performance is included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the 'Boss-Crushing' gameplay mechanics properly designed?",
-      "description": "Evaluate whether the game implements engaging boss battle mechanics including boss AI behavior patterns, progressive difficulty scaling, combo systems, and reward mechanisms. Check for proper game balance, multiple boss types, and satisfying destruction effects. Deduct 5 points if boss AI is too simplistic, 3 points if difficulty progression is poorly balanced. Full score requires sophisticated gameplay mechanics.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are WeChat-specific APIs and social features integrated?",
-      "description": "Check whether the code utilizes WeChat mini-program specific APIs like wx.getUserInfo(), wx.shareAppMessage(), leaderboard integration, and friend ranking systems. Evaluate if social sharing features, achievement systems, and WeChat payment integration (if applicable) are properly implemented. Deduct 5 points if social features are missing, 3 points if sharing functionality is incomplete.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the game data persistence and progression system complete?",
-      "description": "Review whether the code includes comprehensive save/load functionality using wx.setStorageSync(), player progression tracking, achievement unlocking, and cloud save synchronization. Check for proper data validation, backup mechanisms, and cross-device continuity. Deduct 5 points if local storage is not implemented, 3 points if cloud sync is missing, and 2 points if data corruption handling is inadequate.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust and handles WeChat platform constraints?",
-      "description": "Evaluate whether the code can handle WeChat mini-program specific limitations (memory constraints, file size limits, API rate limiting) and provides appropriate error handling for network failures, permission denials, and platform-specific edge cases. Code should gracefully degrade when WeChat services are unavailable. Give 10 points if fully robust, 5 points if average handling, 0 points if no platform-specific error handling.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there innovative features that enhance the 'fish at work' theme?",
-      "description": "Check whether the code includes creative features that cleverly incorporate the 'slacking at work' concept (e.g., boss proximity detection using device sensors, stealth mode with quick alt-tab functionality, work-themed power-ups, office environment integration). Add 3 points for each well-implemented thematic feature (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features or bloated implementations?",
-      "description": "Strictly examine three types of redundancy: 1) Duplicate game logic implementations 2) Features unrelated to the core boss-crushing gameplay 3) Performance-heavy effects that exceed WeChat mini-program optimization guidelines. Deduct 3 points for each redundancy found, and directly deduct 10 points if core gameplay is hindered by unnecessary complexity.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code meet WeChat mini-program engineering standards?",
-      "description": "Review modular architecture following WeChat mini-program best practices, proper use of Component and Page lifecycle methods, optimized subpackage loading, and adherence to WeChat审核 guidelines. Deduct 5 points if global state is poorly managed; deduct 5 points if code structure doesn't follow WeChat conventions; deduct 5 points if performance optimization is inadequate (>2MB package size, >500ms loading time).",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the visual design follow WeChat Design Guidelines and mobile gaming standards?",
-      "description": "Evaluate whether the UI/UX design adheres to WeChat Design Language: 1) Appropriate use of WeChat's recommended color palette and typography 2) Touch-friendly interface elements (minimum 44px touch targets) 3) Proper adaptation for different screen densities and WeChat's navigation bar. Deduct 3 points for each non-compliant interface element, 5 points for poor mobile adaptation, and 5 points for inconsistent visual hierarchy.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Are the game interactions optimized for mobile touch and WeChat environment?",
-      "description": "Judge whether the game controls are optimized for mobile touch interaction within WeChat: 1) Touch response time ≤80ms for game actions 2) Gesture recognition accuracy >95% 3) Proper haptic feedback integration 4) Seamless transition between WeChat UI and game interface. Deduct 5 points for each unresponsive control, 3 points for poor gesture recognition, and 5 points for jarring WeChat integration issues.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Action/Rhythm",
-  "difficulty": "hard"
-}

package/library/game_development-action_rhythm/generate-combat-attack-game-code.json

@@ -1,68 +0,0 @@
-{
-  "index": 828,
-  "question": "You are a code expert, please use your professional knowledge to generate accurate, professional responses. Take care to ensure that the code you generate is executable and ready to demonstrate. Do not provide code for sports games; instead, create code for combat or attack-type game code.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the combat system fully implemented?",
-      "description": "Review whether the code accurately implements core combat mechanics, damage calculation algorithms, and hit detection. Score 0 if core combat logic is missing, 5 if basic attack/defense mechanics exist but lack depth, and 10 if the system includes advanced features like critical hits, combo systems, and varied attack types with appropriate physics.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the character/entity movement and interaction system properly designed?",
-      "description": "Check whether the code includes smooth character movement mechanics, collision detection between entities, and proper interaction between characters and the environment. Deduct 5 points if movement feels rigid or unnatural, 3 points if collision detection is inconsistent, and 5 points if character-environment interaction is absent. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is a balanced game state management system implemented?",
-      "description": "Evaluate whether the code properly manages game states like health points, damage calculation, power-ups, and status effects. Look for appropriate difficulty scaling and enemy AI patterns. Deduct 5 points if enemy behavior is too predictable, 3 points if difficulty balance is poorly implemented, and 5 points if core game state variables aren't properly tracked. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the visual feedback system for combat actions effective?",
-      "description": "Assess whether the code provides clear visual feedback for combat actions through animations, particle effects, or screen effects. Combat should feel impactful with appropriate visual/audio cues. Deduct 5 points for missing hit feedback, 3 points for unclear damage indicators, and 5 points for non-responsive UI elements during combat. 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 invalid inputs, edge cases in combat calculation, 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 environment destruction 2. Adaptive enemy AI that learns from player behavior 3. Weather/time systems affecting combat parameters). 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 damage calculation systems) 2. Function modules unrelated to combat gameplay (e.g., unnecessary complex inventory systems) 3. Fancy effects that affect performance (e.g., excessive particle systems 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 game mechanics/view rendering/input handling), code reusability, 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 architecture separating game components. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern game UI principles: 1) Harmonious color matching that fits the combat theme 2) Clear visual hierarchy for combat information 3) Non-intrusive HUD elements that don't obstruct gameplay. Deduct 3 points for each confusing UI element, 5 points for visually jarring color combinations, and 5 points for UI elements that obstruct critical gameplay visuals. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the combat interactions feel responsive and satisfying: 1) Input response delay ≤ 50ms 2) Combat animations that convey weight and impact 3) Consistent frame rate during intense combat sequences. Deduct 5 points for perceptible input lag, 3 points for choppy animations during critical combat moments, and 5 points for unclear visual communication of hit/miss states. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Action/Rhythm",
-  "difficulty": "easy"
-}

package/library/game_development-action_rhythm/giant-squid-parkour-airplanes-turtle-shells-mini-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 1121,
-  "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 a mini program about parkour that includes elements like airplanes and turtle shells, with the protagonist being a Giant Squid from the deep sea of Inner Mongolia.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the parkour game core gameplay mechanics fully implemented?",
-      "description": "Review whether the code accurately implements the basic parkour mechanics including running, jumping, sliding, and obstacle collision detection. Check if the Giant Squid protagonist has proper movement physics (gravity, acceleration, and inertia). Score 0 if core mechanics are missing, 5 if basic movement exists but feels unnatural, and 10 if the movement system is polished with smooth animation transitions.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are the specified game elements (airplanes and turtle shells) properly integrated?",
-      "description": "Evaluate how the airplane and turtle shell elements are implemented as obstacles or power-ups. Check if airplanes have appropriate flight patterns and if turtle shells have consistent behavior (e.g., can they be dodged, jumped over, or used as weapons?). Deduct 5 points if elements are merely decorative without gameplay function, deduct 3 points if their behavior is inconsistent. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the Giant Squid protagonist properly characterized as being from Inner Mongolia's deep sea?",
-      "description": "Check if the protagonist design combines squid features with Inner Mongolian cultural elements (this creative combination should be visually evident). Evaluate whether the character has unique abilities fitting a squid (e.g., tentacle-based movement, ink defense). Deduct 5 points if the character is generic without unique features, deduct 3 points if animations don't match the character concept. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Does the game have a complete score and progression system?",
-      "description": "Review if the game implements a distance-based scoring system, obstacle avoidance bonuses, and difficulty progression (increasing speed or obstacle frequency over time). Check if there's a game over condition and restart mechanism. Deduct 5 points if the scoring system is too simplistic, deduct 3 points if 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 input changes, focus loss, variable screen sizes, touch vs. keyboard controls) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Weather effects that impact gameplay 2. Day-night cycle affecting visibility 3. Special power-ups with unique visual effects). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple jump mechanics coexisting) 2. Function modules unrelated to parkour gameplay (e.g., an unnecessary inventory system) 3. Fancy effects that affect performance (e.g., excessive particle effects that cause framerate drops). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/view/input handling layers), collision detection efficiency, and frame rate 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 frame rate management for consistent gameplay speed across devices. 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) Clear visual hierarchy differentiating background, obstacles, and player character 3) Professional UI for score display and controls (readable during fast gameplay). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for UI elements that obstruct gameplay. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the game responds well to player input: 1) Input response delay ≤ 50ms for a fluid parkour experience 2) Consistent frame rate above 30fps during gameplay 3) Appropriate collision forgiveness to prevent frustrating deaths. Deduct 5 points for noticeable input lag, 3 points for stuttering animations during gameplay, and 5 points for unfair-feeling collision detection. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Action/Rhythm",
-  "difficulty": "medium"
-}