@getollie/cli 0.0.1

package/library/game_development-casual/random-number-selector-two-color-ball-lottery.json

@@ -0,0 +1,68 @@
+{
+  "index": 1258,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure that the code you generate is executable and ready to be displayed. Create a random number selector mini-program for the Two-Color Ball lottery.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the random number generation for the Two-Color Ball lottery properly implemented?",
+      "description": "Review whether the code correctly implements the Two-Color Ball lottery rules (6 red balls from numbers 1-33 and 1 blue ball from numbers 1-16). Check if the algorithm ensures no duplicates among red balls and uses a cryptographically strong random function. Score 0 if the core lottery logic is incorrect, 5 if basic random generation is implemented but with possible biases, and 10 if the implementation follows both lottery rules and cryptographic randomness standards.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Does the program validate all user inputs and lottery parameters?",
+      "description": "Check whether the code validates all user inputs (e.g., custom number ranges, manual selections) and enforces the Two-Color Ball lottery constraints. Verify error handling for invalid inputs (e.g., out-of-range values, duplicate selections). Deduct 5 points if basic validation is missing, and 3 points if edge cases aren't handled. Full score requires comprehensive validation with clear user feedback.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the historical drawing feature implemented with statistical analysis?",
+      "description": "Evaluate if the program stores and displays historical lottery drawings, and provides meaningful statistical analysis (e.g., frequency charts, hot/cold numbers, trend analysis). Check if users can review past selections and compare with winning numbers. Deduct 5 points if only basic history is available without analysis, and 8 points if historical tracking is completely absent.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the program offer both quick pick and manual selection options?",
+      "description": "Assess whether users can both generate random selections (quick pick) and manually choose their own numbers. Check if the interface allows for partial selection (some manual + some random). Verify that the program can generate multiple sets of numbers in batch mode. Deduct 4 points if only random selection is available, and 7 points if the implementation severely limits user choice.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid inputs, resource limitations, unexpected user behavior) 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. Number frequency heat map 2. Multiple lottery systems support 3. Winning probability calculator 4. Lucky number suggestions based on birthdate/name). 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 random generators with the same purpose) 2. Function modules unrelated to lottery number selection (e.g., a built-in calculator) 3. Fancy effects that affect performance (e.g., excessive animations when generating numbers). 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 random generation logic/UI/data storage layers), unit test coverage, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance. Deduct 5 points for each operation without feedback, 3 points for visual after-images during fast interaction, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "easy"
+}

package/library/game_development-casual/random-prize-draw-program.json

@@ -0,0 +1,68 @@
+{
+  "index": 1085,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Be sure to provide executable code whenever possible. Write me a small program that can randomly draw prizes.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core prize drawing functionality fully implemented?",
+      "description": "Verify if the code correctly implements a random selection algorithm that fairly selects prizes based on their probability distribution. Score 0 if no random selection is implemented, 5 if basic random selection exists but without proper distribution control, and 10 if the implementation includes configurable probability weights for different prizes.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the prize pool management system properly designed?",
+      "description": "Evaluate whether the code allows for dynamic prize pool configuration, including adding/removing prizes, setting prize quantities, and managing prize availability. Deduct 5 points if the prize pool is hardcoded, 3 points if quantities aren't tracked properly. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there a proper prize distribution validation mechanism?",
+      "description": "Check if the program includes methods to verify the fairness of the distribution (e.g., statistical testing, distribution visualization, or logging). Score 0 if no validation exists, 5 if basic logging is implemented, and 10 if comprehensive statistical validation is included.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the program handle edge cases in prize drawing?",
+      "description": "Assess whether the code properly handles situations like empty prize pools, prizes running out, probability edge cases (0% or 100%), and ensures no unexpected behavior. Deduct 3 points for each unhandled edge case. 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, unexpected data types, out-of-bounds values, 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. Visual prize drawing animation 2. Historical drawing records with statistics 3. Prize inventory management). 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 random selection algorithms) 2. Function modules unrelated to prize drawing (e.g., a built-in calculator) 3. Fancy effects that affect performance. 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 prize definition/drawing logic/user interface), unit test coverage, and appropriate use of language features. 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 best practices for the chosen language are not followed. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the user interface (if applicable) follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects (if applicable) conform to human perception characteristics: 1) Clear visual feedback during and after prize drawing 2) Appropriate animation timing for suspense without excessive delay 3) Clear visual indication of prize results. Deduct 5 points for lack of visual feedback, 3 points for confusing or overly lengthy animations, and 5 points for unclear result presentation. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "easy"
+}

package/library/game_development-casual/simple-jump-game-design.json

@@ -0,0 +1,68 @@
+{
+  "index": 1028,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Try to ensure that the code you generate is executable. I want to develop a small game with the following design: 1. A horizontal line from left to right in the screen, serving as the ground; 2. The main character appears on the left side of the screen, on the ground; 3. The main character's position remains fixed, while enemies continuously appear from the right side of the screen on the ground; 4. When the screen is clicked, the main character can jump up to avoid enemies; 5. If the main character collides with an enemy, the game is over. I plan to develop this small game with Cursor. Please help me organize a plan and generate a complete solution document for Cursor development. You can ask me questions after understanding the above content, one question at a time, until the plan is complete.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the game scene setup properly implemented?",
+      "description": "Check if the code correctly implements a horizontal ground line, a fixed-position main character, and right-to-left enemy movement. All elements should be properly positioned and scaled relative to the canvas/viewport. Score 0 if any core element is missing, 5 if elements exist but with positioning issues, and 10 if all elements are properly implemented with appropriate scaling on different screen sizes.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the jump mechanism functional and responsive?",
+      "description": "Evaluate if the jump action is properly triggered by screen clicks/taps, with appropriate physics (gravity effect, proper arc trajectory). The jump should have natural acceleration and deceleration with proper timing (not too quick or too slow). Deduct 5 points if there's noticeable input lag (>100ms), 3 points if the jump physics feels unnatural, and 2 points if jump height is inconsistent or inappropriate for gameplay. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the enemy generation and movement system well-implemented?",
+      "description": "Review if enemies spawn with appropriate timing (increasing difficulty over time), move at consistent speeds, and display proper animation if applicable. Check if the enemy generation logic includes variety (different speeds, sizes, or types) for gameplay interest. Deduct 5 points if enemies spawn at fixed intervals without progression difficulty, 3 points if movement is jerky/inconsistent, and 5 points if there's no variety in enemy types or behaviors. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the collision detection accurate and reliable?",
+      "description": "Assess the collision detection algorithm between the character and enemies. It should be precise (not triggering on near misses), performance-optimized, and visually matched to the sprites (no invisible collisions). Deduct 5 points if hitboxes don't match visual elements, 5 points if collisions are inconsistently detected, and 3 points if there's noticeable performance impact from collision checks. 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, window resizing, focus loss, browser back/forward navigation, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Power-ups or special abilities 2. Score multiplier system 3. Particle effects for jumps/collisions 4. Dynamic background elements). 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) 2. Function modules unrelated to the core gameplay (e.g., unnecessary mini-games within the main game) 3. Fancy effects that affect performance (e.g., excessive particles that cause lag). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game logic/view/input handling), code organization, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no clear separation between game mechanics, rendering, and input handling. 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 with good contrast between characters, enemies and background 2) Proper visual hierarchy with clear differentiation between interactive and non-interactive elements 3) Professional font system for score display and game messages. Deduct 3 points for each cluttered visual element, 5 points for poor contrast that affects gameplay visibility, and 5 points for inconsistent art style. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the game runs at consistent framerate (ideally 60fps), provides immediate feedback to player actions, and maintains smooth animations throughout gameplay. Deduct 5 points if the game stutters during normal gameplay, 5 points if there's noticeable input delay when jumping, and 3 points if enemy movement isn't smooth and consistent. Also check if the game provides clear visual and audio feedback for key events (jumps, collisions, game over). The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "hard"
+}

package/library/game_development-casual/single-page-fishing-game-html-css-js.json

@@ -0,0 +1,68 @@
+{
+  "index": 1435,
+  "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 when possible. Please write a single-page fishing game using HTML, CSS, and JavaScript.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core fishing mechanic properly implemented?",
+      "description": "Evaluate whether the code implements complete fishing mechanics including casting, waiting, and catching fish. Check if there's a timing or skill-based element that makes fishing engaging. Score 0 if no fishing mechanic exists, 5 if only basic clicking is implemented, and 10 if there's a fully developed fishing system with variable catch rates and player skill involvement.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is there a proper game progression system?",
+      "description": "Check if the game includes elements like scoring, different types of fish with varying rarities/values, upgradeable equipment, or increasing difficulty levels. Deduct 5 points if there's no progression at all, 3 points if progression is minimal. The full score is 10 points for a comprehensive progression system that motivates continued play.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the fishing environment visually represented?",
+      "description": "Evaluate whether the code creates a visual representation of a fishing environment (water, fishing rod animation, fish graphics). Score 0 if there are no visual elements, 5 if only static images are used, and 10 if there are well-designed animations for casting, water effects, and fish movement that enhance the gameplay experience.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a game state management system?",
+      "description": "Check if the code properly manages game states such as starting/pausing the game, tracking inventory, saving progress or high scores, and handling win/lose conditions. Deduct 5 points if there's no state management, 3 points if it's rudimentary. Full score of 10 points requires a comprehensive state management system with persistence between sessions.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid clicking, browser resizing, touch vs. mouse input, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Weather effects affecting catch rates 2. Day/night cycle 3. Special rare fish events 4. Sound effects that enhance immersion). 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 scoring systems) 2. Function modules unrelated to fishing (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive particle systems 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/controller layers), code organization, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no clear separation of concerns between HTML, CSS, and JavaScript. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times) 4) Responsive design for different screen sizes. 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) Transition animation duration controlled between 300-500ms 3) Clear visual feedback for user actions (rod casting, fish biting, successful/failed catches). Deduct 5 points for each operation without feedback, 3 points for visual after-images during animations, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "easy"
+}

package/library/game_development-casual/ski-free-html-javascript-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 6,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Try to ensure the generated code is executable for demonstration.\n\nPlease use HTML and JavaScript to implement 'SkiFree', a skiing simulation game based on JavaScript and canvas. Players need to control the skier on the slope to avoid obstacles such as trees and rocks, while collecting flags to increase their score.\n\n### Gameplay\n- **Control the skier**: Use keyboard arrow keys to move the skier left and right.\n- **Avoid obstacles and collect flags**: Dodge obstacles and collect as many flags as possible to increase your score.\n\n### Game Features\n- **Retro pixel style**: The game adopts a retro pixel art style, recalling the feeling of classic games.\n- **Simple and intuitive**: Easy to operate and get started, suitable for players of all ages.\n\n### Game Tips\n- **Anticipate paths**: Predict and adjust your skiing route in advance to avoid obstacles.\n- **Maintain for long periods**: Keep playing for longer periods to accumulate higher scores.\n\n### Summary\nThis game provides a fast-paced and exciting gaming experience through its simple yet fun gameplay, perfect for players seeking brief entertainment. Please include comments in your code so other developers can understand your implementation process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the skiing game core mechanics fully implemented?",
+      "description": "Review whether the code accurately implements skier movement control through keyboard arrow keys, collision detection with obstacles (trees, rocks), flag collection mechanics, and score calculation system. Score 0 if core skiing mechanics are missing, 5 if only basic movement is implemented, and 10 if all gameplay elements including physics-based skiing simulation are fully functional.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the canvas rendering and game loop properly implemented?",
+      "description": "Check whether the HTML5 Canvas implementation includes proper game loop with requestAnimationFrame, efficient rendering pipeline, and sprite management system. Evaluate scrolling background mechanics and object spawning algorithms. Deduct 5 points if frame rate drops below 30fps, and 3 points if rendering artifacts or flickering occurs. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are obstacle generation and collision systems accurately designed?",
+      "description": "Evaluate whether the obstacle generation uses proper randomization algorithms to create realistic skiing terrain with trees and rocks. Check collision detection accuracy using bounding box or pixel-perfect methods. Deduct 5 points if collision detection has false positives/negatives, and 3 points if obstacle distribution feels unnatural or repetitive. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the retro pixel art style and visual consistency maintained?",
+      "description": "Check whether the code implements authentic retro pixel art aesthetics with proper sprite scaling, pixelated graphics without anti-aliasing, and consistent 8-bit/16-bit color palette. Evaluate whether visual elements match classic SkiFree appearance. Deduct 5 points if modern graphics break retro immersion, and 3 points if inconsistent pixel density is used. Give 10 points if authentic retro style is maintained throughout.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid key presses, canvas resize events, browser tab switching, memory leaks from game objects) and provide graceful error handling. Code with strong robustness should effectively manage edge cases and resource cleanup, giving 10 points. If robustness is average, give 5 points, and if no exception handling exists, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that enhance gameplay?",
+      "description": "Check whether the code includes engaging features that improve the classic SkiFree experience (e.g., 1. Progressive difficulty scaling 2. Power-ups or special items 3. Particle effects for snow trails 4. Sound effects and background music 5. High score persistence). Add 2 points for each well-implemented innovative feature (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Over-engineered systems not suitable for a simple skiing game 2. Duplicate input handling or rendering logic 3. Excessive visual effects that compromise the retro aesthetic or performance. Deduct 3 points for each redundancy found, and directly deduct 10 points if core skiing gameplay is hindered by unnecessary complexity.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (separating game logic, rendering, input handling), code organization with proper commenting for developer understanding, and clean architecture patterns. Deduct 5 points if global state pollution or poor separation of concerns is found; deduct 3 points if insufficient code comments hinder understanding; deduct 2 points if inconsistent naming conventions are used. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface design meet retro gaming standards?",
+      "description": "Evaluate whether the visual design authentically recreates retro gaming aesthetics: 1) Appropriate pixel art scaling without blurring 2) Classic color palette reminiscent of early computer games 3) Proper UI elements for score display and game status 4) Authentic retro typography. Deduct 3 points for each modern design element that breaks immersion, 5 points for inappropriate scaling, and 2 points for inconsistent retro styling. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the gameplay interaction responsive and intuitive?",
+      "description": "Judge whether the skiing controls feel natural and responsive: 1) Keyboard input response delay ≤ 50ms for skiing games 2) Smooth skier movement with appropriate physics 3) Clear visual feedback for collisions and flag collection 4) Intuitive game start/restart mechanisms. Deduct 5 points for each unresponsive control, 3 points for laggy movement, and 2 points for unclear game state feedback. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "easy"
+}

package/library/game_development-casual/small-decompression-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1759,
+  "question": "You are a coding expert. Please use your professional knowledge to generate accurate and expert responses. Be sure to provide executable code demonstrations when possible. Help me create code for a small decompression game.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core decompression mechanic properly implemented?",
+      "description": "Check whether the code accurately implements the fundamental decompression mechanism (such as clicking, dragging, or interacting with stress-relieving objects). The core interaction should respond to user input with appropriate visual feedback and physics. Score 0 if no interaction is implemented, 5 if basic interactions exist but lack polish, and 10 if interactions feel natural and satisfying.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the game objects and physics systems correctly coded?",
+      "description": "Evaluate whether the game includes properly implemented physical objects with realistic behaviors (e.g., bouncing balls, squishable items, destructible objects). Verify that collision detection works correctly and physics parameters create a satisfying feel. Deduct 5 points if physics feels unnatural, 3 points if collisions are buggy, and 2 points if object interactions are limited.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the progression system or gameplay loop well-designed?",
+      "description": "Assess whether the code includes some form of progression (like unlockable items, increasing challenges, or measurable stress reduction metrics). Check if there's a clear gameplay loop that encourages continued engagement. Give 0 points if there's no progression at all, 5 points if basic progression exists, and 10 if the system is thoughtfully designed with appropriate rewards.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are visual and audio feedback systems effectively implemented?",
+      "description": "Review whether the code includes appropriate visual effects (particle systems, animations) and sound effects that enhance the decompression experience. Judge whether they're synchronized with user actions and provide satisfying sensory feedback. Deduct 5 points if visual feedback is missing, 3 points if audio feedback is absent, and 2 points if the effects don't complement the interaction.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid clicking, unusual input combinations, window resizing, 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. Personalized stress tracking 2. Dynamic difficulty adjustment based on user behavior 3. Creative interaction methods beyond standard clicks/taps). 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 mechanics (e.g., multiple ways to achieve the same decompression effect) 2. Function modules unrelated to decompression (e.g., unnecessary 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/view/input handling layers), code organization, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no clear separation of concerns. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Intuitive UI that doesn't distract from the decompression experience. Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for interface elements that create rather than relieve stress. 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) Immediate feedback on interaction (≤ 50ms) 2) Smooth animations with appropriate easing 3) Consistent frame rate without stuttering. Deduct 5 points for each interaction without immediate feedback, 3 points for jerky animations, and 5 points for performance issues during intensive interactions. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "easy"
+}

package/library/game_development-casual/stickman-mini-game-html-web-format.json

@@ -0,0 +1,68 @@
+{
+  "index": 1602,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code for demonstration purposes. Help me create a stickman mini-game in HTML web format.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core stickman character implementation complete?",
+      "description": "Review whether the code properly implements the stickman character using HTML elements (canvas or SVG), with appropriate proportions and connections between body parts. Check if the stickman's anatomy is properly articulated (head, torso, arms, legs) with proper joint connections. Score 0 if no stickman is created, 5 if basic static stickman is implemented, and 10 if a fully articulated stickman with proper proportions is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the animation system for the stickman properly implemented?",
+      "description": "Evaluate if the code includes smooth animations for the stickman character (walking, jumping, etc.) using either CSS animations, JavaScript animation frameworks, or requestAnimationFrame. Check frame rate consistency (should maintain 60fps) and the naturalness of movements. Deduct 5 points if animations are jerky or choppy, 3 points if keyframes are poorly spaced, and 2 points if there are no transitions between animation states. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there a complete game mechanics implementation?",
+      "description": "Check whether the mini-game has clear objectives, challenges, and interaction mechanisms. The game should have scoring systems, win/lose conditions, and at least one core gameplay loop. Deduct 5 points if there are no clear objectives, 5 points if the gameplay is too simplistic (just moving with no purpose), and 3 points if there's no scoring mechanism. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there proper user control implementation?",
+      "description": "Assess whether user input (keyboard, touch, mouse) is properly captured and translated into stickman movements/actions. Check for responsiveness (input lag under 100ms), custom key bindings or touch areas, and proper event handling. Deduct 5 points if controls are sluggish, 3 points if multiple input methods aren't supported, and 5 points if there's no visual feedback for controls. 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 resizing, rapid input changes, browser compatibility issues) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Physics-based ragdoll effects 2. Environmental interactions like climbing or swinging 3. Character customization options). 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 animation systems overlapping) 2. Function modules unrelated to the stickman game (e.g., unnecessary social sharing features) 3. Fancy effects that affect performance (e.g., excessive particle effects or shader usage). 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. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there are no comments explaining complex logic. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click/input feedback delay ≤ 100ms 2) Game loop execution consistency at 60fps 3) Clear visual feedback for interactions with game elements. Deduct 5 points for each operation without feedback, 3 points for frame drops during animations, and 5 points for confusing or misleading visual cues. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "easy"
+}

package/library/game_development-casual/two-player-hand-hitting-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1718,
+  "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. Hand-hitting game - a two-player battle game where whoever presses the button ten times first will cause a rod to drop and hit the opponent's hand. [Include] logic judgments, variables, and displays.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core button-pressing game mechanic fully implemented?",
+      "description": "Review whether the code accurately implements a counter system that tracks button presses for each player, with clear progression toward the 10-press goal. Check if the winning condition (first to 10 presses) triggers the rod animation to hit the opponent's hand. Score 0 if the core interaction logic is not implemented, 5 if basic counting is implemented but without proper winning conditions, and 10 if the full game loop with proper win detection is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the two-player input system properly designed?",
+      "description": "Evaluate whether the code handles simultaneous inputs from two different players, with clear key bindings or UI elements for each player. Check for input validation, prevention of key-spamming exploits, and clear visual feedback when buttons are pressed. Deduct 5 points if inputs aren't clearly separated between players, and 3 points if there's no visual feedback on button presses. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the rod animation and hit detection properly implemented?",
+      "description": "Check whether the rod movement animation is smooth and realistic when triggered, and whether the 'hit' on the opponent's hand is visually clear. Review the timing of the animation to ensure it properly represents the game state. Deduct 5 points if the animation is jerky or unrealistic, and 5 points if the hit detection doesn't visually align with the rod and hand positions. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the game state management and round system implemented?",
+      "description": "Evaluate whether the code includes proper game state management (start, in-progress, game over states) and a round system that allows multiple matches. Check if scores are tracked across rounds and if there's a clear way to reset or start a new game. Deduct 5 points if state transitions are buggy, and 5 points if there's no way to play multiple rounds without refreshing the page. 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 button mashing, browser tab switching, simultaneous key presses, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Power-up mechanics after consecutive presses 2. Sound effects or haptic feedback 3. Dynamic difficulty adjustment based on player performance). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to count presses) 2. Function modules unrelated to the hand-hitting game (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive particle effects that slow down gameplay). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game logic/view/input handling layers), code organization, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if variable naming is inconsistent or unclear. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Clear visual representation of game elements (rod, hands, buttons, counters). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for confusing visual representation of game elements. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and responsive?",
+      "description": "Judge whether the game responds quickly to player inputs and provides clear visual feedback: 1) Button press feedback delay ≤ 50ms 2) Animation smoothness at minimum 30fps 3) Clear visual indication of game progress and current scores. Deduct 5 points for noticeable input lag, 3 points for choppy animations, and 5 points for unclear game state representation. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "easy"
+}