@getollie/cli 0.0.1

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

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

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

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

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

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

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

@@ -0,0 +1,68 @@
+{
+  "index": 999,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable for demonstration. Write a Godzilla versus Kong game where two players control the characters, and victory is determined by clicking speed.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core game mechanic of clicking speed competition implemented?",
+      "description": "Check if the code implements a click speed counter for each character (Godzilla and Kong), with proper event listeners and score tracking. Scoring should accurately reflect click frequency over time rather than just raw click counts. Score 0 if this core mechanic is missing, 5 points if basic click counting exists but lacks proper timing mechanisms, and 10 points if the system includes click rate calculation with time normalization.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are Godzilla and Kong characters properly implemented with visual feedback?",
+      "description": "Evaluate if both characters have distinct visual representations with appropriate animations/visual changes that respond to player actions. Characters should display different states (idle, attacking, winning, losing). Deduct 5 points if characters are static images without animations, 3 points if only basic state changes exist. Give 10 points if characters have fluid animations tied to game actions with proper hit/impact effects.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the two-player control system properly implemented?",
+      "description": "Review whether the game properly supports two separate input mechanisms (e.g., different keyboard keys or screen areas) that don't interfere with each other. Check if player controls are clearly explained and if the system prevents cross-player inputs. Deduct 5 points if inputs frequently conflict, 3 points if controls are functional but poorly explained. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a complete game flow with victory conditions?",
+      "description": "Check if the game properly implements start states, battle progression, victory determination, and match conclusion with restart options. Victory should be clearly tied to clicking performance with appropriate thresholds. Deduct 5 points if victory conditions are unclear, 3 points if game restart is missing, and 5 points if there's no proper battle progression visualization. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid clicking beyond normal counts, browser compatibility issues, simultaneous key presses) and provide friendly error handling or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Special power moves triggered at certain click rates 2. Dynamic background changes based on who's winning 3. Character-specific sound effects for attacks). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple click counters using different methods) 2. Function modules unrelated to the Godzilla vs. Kong battle theme (e.g., unnecessary settings options) 3. Fancy effects that affect performance (e.g., excessive particle effects that slow down gameplay). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game logic/view/input handling layers), code organization, and maintainability. Deduct 5 points if global state pollution is found or proper encapsulation is missing; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the code lacks comments or is difficult to maintain. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching appropriate to the monster battle theme 2) Proper layout spacing (character positioning, UI elements, score displays) 3) Professional font system with readable health/score indicators during fast gameplay. Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Character attack animations properly timed with player clicks 3) Clear visual indicators of which player is currently winning. Deduct 5 points for each operation without feedback, 3 points for stuttering animations during rapid clicking, and 5 points for unclear game state visualization. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Action/Rhythm",
+  "difficulty": "easy"
+}

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

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

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

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