@getollie/cli 0.0.1

package/library/game_development-casual/html-javascript-sound-effects-background-music-system.json

@@ -0,0 +1,68 @@
+{
+  "index": 109,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable for demonstration purposes.\n\nPlease implement an environment sound effects and background music system using HTML and JavaScript.\n\n**Task**: Add environmental sound effects and background music to the game to enrich the atmosphere, and dynamically adjust sound effects according to different scenes.\n\n**Hint**: You can use sound effect triggers to control sound playback, and switch background music based on scene changes.\n\nPlease include some comments in your code so other developers can understand your implementation process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the audio loading and playback system fully implemented?",
+      "description": "Evaluate whether the code implements robust audio resource loading with preloading strategy, error handling for failed audio loads, and proper memory management. Check if the implementation includes both HTML5 Audio API and Web Audio API fallback options. Score 0 if core audio playback is missing, 5 if only basic playback is implemented without error handling, and 10 if it includes comprehensive audio resource management with loading indicators and fallback mechanisms.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the environmental sound effects system properly implemented?",
+      "description": "Check whether the code implements a variety of environmental sound effects with proper trigger mechanisms based on user actions or environmental conditions. Evaluate if effects use spatial audio positioning, have appropriate volume levels, and include randomization for natural variation. Deduct 3 points if spatial audio is missing, 3 points if sound variety is limited (less than 3 effect types), and 5 points if trigger mechanisms are simplistic or hardcoded. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the background music system with scene-based transitions implemented?",
+      "description": "Review whether the code implements background music that changes based on game scenes/contexts with smooth crossfading transitions. Check if volume normalization is handled across different tracks, and if looping is properly implemented without audible gaps. Deduct 4 points if transitions are abrupt without crossfading, 3 points if music doesn't adapt to different scenes, and 5 points if looping implementation has gaps or glitches. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the system provide audio controls and user preferences?",
+      "description": "Assess whether the implementation includes user controls for master volume, separate controls for music/effects volumes, mute options, and persistence of audio preferences. Check if the UI for these controls is accessible and intuitive. Score 0 if no audio controls exist, 5 if basic controls exist but lack persistence or separate volume controls, and 10 if comprehensive controls with preference saving are implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as browser audio restrictions, autoplay policy limitations, unsupported audio formats, and mobile device constraints). Code with strong robustness should detect browser capabilities, provide fallbacks, and gracefully handle initialization failures with user prompts. Give 10 points for comprehensive error handling, 5 points for basic error checks, and 0 points if no exception handling exists.",
+      "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 audio experience (e.g., 1. Procedural/dynamic audio generation 2. Audio visualization components 3. Context-aware adaptive mixing 4. Custom audio filters based on environment). 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. Multiple audio implementations doing the same thing 2. Unnecessarily complex audio processing that impacts performance 3. Audio features that don't contribute to the environment/atmosphere. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating audio manager/sound effects/music modules), abstraction level, code reusability, and documentation quality. Assess if the code follows an organized pattern like the audio manager pattern. Deduct 5 points if global audio state is poorly managed; deduct 5 points if the code has high duplication; deduct 5 points if comments are inadequate or misleading. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Is the audio interface intuitive and responsive?",
+      "description": "Evaluate whether audio controls follow modern UI principles: 1) Clear visual feedback when sounds play 2) Intuitive volume sliders with appropriate ranges 3) Consistent positioning of audio controls. Deduct 3 points for missing visual feedback, 5 points for confusing control layout, and 5 points for non-responsive audio interfaces. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the audio processing optimized for performance?",
+      "description": "Judge whether the audio system is optimized: 1) Efficient audio buffer management 2) Proper resource disposal when sounds are no longer needed 3) Audio throttling for multiple simultaneous sounds 4) Mobile-friendly implementation with battery considerations. Deduct 5 points for memory leaks in audio handling, 3 points for performance drops during multiple sound playback, and 5 points for excessive CPU/battery usage. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "easy"
+}

package/library/game_development-casual/html-js-character-animation-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 41,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable for demonstration.\n\nPlease use HTML and JavaScript to implement a game with the following:\n\n### Gameplay\n1. **Direction Control**: Use direction buttons to change the character's walking direction.\n2. **Character Switching**: Switch between different characters to view their respective walking animations.\n\n### Game Features\n- **Animation Technology**: Uses CSS animation techniques to achieve smooth walking effects.\n- **Character Diversity**: Includes various different characters and walking animations.\n- **Interactive Experience**: Users can control the animation interactively, increasing the sense of participation in the game.\n\n### Summary\nThis demonstration is not just a game but also an educational tool to help developers learn and master CSS animation techniques. Include comments in your code to help other developers understand your implementation process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the direction control system fully implemented?",
+      "description": "Evaluate whether the code implements a complete directional control system with at least four directions (up, down, left, right). Check if the directional inputs are properly connected to character movement and if the character's facing direction changes appropriately. Deduct 5 points if diagonal movement is missing when it would enhance gameplay, 3 points if direction change has noticeable delay (>100ms). Award full points only if directional controls are intuitive and responsive.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the character switching mechanism fully functional?",
+      "description": "Review whether the code allows seamless switching between multiple characters (minimum 3 distinct characters required). Check if each character retains their state when switched away from and returns to that state when selected again. Verify that character switching doesn't interrupt ongoing animations. Deduct 5 points if there are fewer than 3 characters, 3 points if switching causes visual glitches, and 2 points if character state isn't properly preserved during switches.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the CSS animation techniques properly implemented?",
+      "description": "Assess the quality of CSS animation implementation. Look for proper use of keyframes, transitions, and transforms. Check for smooth sprite animations with appropriate frame rates (minimum 8 frames per animation cycle). Evaluate whether the animations use best practices like hardware acceleration. Deduct 5 points for jerky animations, 3 points for improper sprite sheet handling, and 2 points if animations don't properly loop or transition between states.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is character diversity adequately represented?",
+      "description": "Evaluate whether each character has unique visual attributes and animation styles. Each character should have distinct walking animations for all implemented directions. Characters should differ in appearance beyond simple color swaps (different sprites, sizes, or animation speeds). Deduct 3 points for each character that shares animations with another, 5 points if all characters are mere palette swaps, and 2 points if animation quality varies significantly between characters.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid direction changes, multiple buttons pressed simultaneously, browser 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. Environmental interactions 2. Dynamic weather/lighting effects 3. Character-specific special animations 4. Sound effects synchronized with animations). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple animation systems coexisting) 2. Function modules unrelated to the walking game (e.g., a built-in calculator) 3. Fancy effects that affect performance (e.g., unnecessary particle systems or filters). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating animation logic/input handling/character data), code organization, and implementation of design patterns. Check for comprehensive code comments as requested in the requirements. Deduct 5 points if global state pollution is found; deduct 3 points if the code duplication rate is too high (over 30%); deduct 3 points if educational comments are inadequate or missing. 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 UI for controls (clearly visible buttons with appropriate sizing). Deduct 3 points for cluttered control elements, 5 points for visually jarring color combinations, and 3 points for poor spatial organization of game elements. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Control input feedback delay ≤ 100ms 2) Animation transitions appear natural without stuttering 3) Clear visual feedback for character selection and direction changes. Deduct 5 points for noticeable input lag, 3 points for animation stuttering during direction changes, and 3 points if the active character or direction isn't clearly indicated. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "easy"
+}

package/library/game_development-casual/html-luck-based-dice-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1684,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code for display whenever possible. Help me create a luck-based dice game in HTML.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core dice game mechanics fully implemented?",
+      "description": "Review whether the code accurately implements random dice generation, score calculation, and turn-based gameplay. Score 0 if the core logic is missing, 5 if only basic dice rolling is implemented without complete game rules, and 10 if the game includes comprehensive rules (scoring system, win conditions, etc.).",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the dice rolling animation and visualization properly executed?",
+      "description": "Check if the dice rolling includes proper visual feedback (animation, transitions, or at minimum state changes) that makes the randomness feel authentic. Deduct 5 points if there's no visual feedback during rolls, 3 points if the animation is jerky or unnatural, and 2 points if the dice representation is too simplistic (e.g., just numbers without dice faces).",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Does the game have complete player interaction and game flow?",
+      "description": "Evaluate whether the game has clear turn management, score tracking, and game progression (start game, player turns, end game conditions). Deduct 4 points if turn management is unclear, 3 points if there's no proper score display, and 3 points if the game lacks clear start/end states.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are the rules of the game clearly presented to the player?",
+      "description": "Check if the game includes clear instructions, scoring explanations, and feedback on player actions. Give 10 points if all rules are clearly explained in the UI, 5 points if basic instructions exist but some rules remain unclear, and 0 points if no instructions or rules are provided.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as repeated clicks during animations, browser compatibility issues, state inconsistencies) and provide friendly error handling. Code with strong robustness should prevent game-breaking behaviors, 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. Sound effects for dice rolls 2. Customizable dice themes/colors 3. Statistics tracking across games 4. Special dice or bonus mechanics). 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 RNG systems) 2. Function modules unrelated to dice gaming (e.g., unnecessary social features) 3. Fancy effects that affect performance (e.g., excessive particles or animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (separating game logic/view/event handling), code reusability, and maintainability. Deduct 5 points if global state pollution is found or if variables/functions are poorly named; deduct 5 points if the code duplication rate is too high; deduct 5 points if there's no separation of concerns between presentation and 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 feedback delay ≤ 100ms 2) Dice rolling animation duration appropriate (not too quick or too slow) 3) Clear visual guidance for player actions. Deduct 5 points for each operation without feedback, 3 points for jarring or inconsistent animations, and 5 points for confusing player action indicators. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "easy"
+}

package/library/game_development-casual/html-scrollbar-idle-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1547,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Pay attention to ensuring that the generated code is executable for demonstration. I want to make a scrollbar idle game using HTML. Could you provide me with an example?",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core scrollbar game mechanic properly implemented?",
+      "description": "Evaluate whether the code implements the fundamental idle game mechanics tied to scrollbar interaction. Check if the scrolling action properly generates resources/points and if the core game loop functions correctly. Score 0 if scrolling doesn't trigger any game mechanics, 5 if basic resource generation exists but lacks progression, and 10 if scrolling mechanics are fully implemented with appropriate resource accumulation rates.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are idle progression mechanics implemented?",
+      "description": "Check if the game properly implements idle mechanics that allow progress even when the player is not actively scrolling. Verify if there's an automated resource generation system, upgrades that enhance idle production, and if the game state persists when not actively played. Deduct 5 points if there's no idle progression at all, and 3 points if idle mechanics exist but are poorly balanced. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there a comprehensive upgrade system?",
+      "description": "Assess whether the code includes a well-designed upgrade system that offers meaningful progression. Check for various upgrade types (e.g., click multipliers, automatic generators, special abilities), proper cost scaling, and visual feedback when purchasing upgrades. Score 0 if no upgrade system exists, 5 if only basic upgrades are available, and 10 if there's a diverse and balanced upgrade tree with multiple paths for progression.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a save/load system for game persistence?",
+      "description": "Evaluate whether the game properly saves and loads progress using localStorage or another persistence method. Check if the game state is preserved between browser sessions, if there's auto-save functionality, and if the save system handles different game versions. Deduct 5 points if saving is manual only, 3 points if there's no export/import save feature, and give 0 points if there's no save system at all. 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 scrolling, browser resizing, invalid user inputs, 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 feedback during scrolling 2. Achievement system 3. Random events triggered by scrolling patterns). 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 track scrolling) 2. Function modules unrelated to the idle game concept 3. Fancy effects that affect performance (e.g., excessive animations that slow down the game). 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/persistence layers), consistent naming conventions, and code organization. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no clear separation between game mechanics and UI. 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 hierarchy for game elements (resources, upgrades, progress indicators). Deduct 3 points for cluttered UI elements, 5 points for poor color contrast or readability issues, and 5 points for inconsistent visual styling. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the scrollbar interaction and game feedback conform to human perception characteristics: 1) Visual feedback appears within 100ms of scrolling 2) Smooth animations for resource accumulation 3) Clear visual cues for affordable upgrades. Deduct 5 points for laggy scrolling responses, 3 points for jarring or missing transition effects, and 5 points for confusing or unclear game state indicators. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "medium"
+}

package/library/game_development-casual/html-small-lucky-draw-program.json

@@ -0,0 +1,68 @@
+{
+  "index": 994,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the code you generate is executable for demonstration. Help me create an HTML file with a small lucky draw program.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core lucky draw functionality fully implemented?",
+      "description": "Evaluate if the code implements a complete lucky draw system including: random selection algorithm, prize pool management, and result display. Score 0 if the core functionality is missing, 5 if basic random selection exists but lacks proper prize management, and 10 if the implementation includes configurable prize weights, animation effects during selection, and clear result presentation.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the prize configuration mechanism well-designed?",
+      "description": "Check if the code allows for flexible prize definition (name, probability, image, etc.) and ensures the total probability adds up correctly (100%). Deduct 5 points if prizes are hardcoded with no configuration option, 3 points if prize weights don't properly balance, and 2 points if there's no visual representation of probability. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there a proper draw animation and result presentation?",
+      "description": "Review whether the lucky draw includes engaging animations (such as spinning wheel, flipping cards, or slot machine effect) and clear result presentation. Deduct 5 points for static transitions with no animation, 3 points for animations that don't match the draw concept, and 2 points if the winning result isn't prominently displayed. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are draw history and statistics tracked?",
+      "description": "Evaluate if the program keeps records of past draws, displays statistics, and potentially allows for result verification. Score 0 if no history is maintained, 5 if basic history exists but lacks persistence between sessions, and 10 if comprehensive statistics are available with localStorage or similar persistence mechanisms.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as missing configurations, unexpected user interactions, or 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. Sound effects during draw/winning 2. Confetti animation for big prizes 3. Customizable themes or backgrounds). 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 number generators) 2. Function modules unrelated to lucky draw (e.g., a built-in calendar) 3. Fancy effects that affect performance (e.g., excessive particle effects 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 UI/logic/data layers), code organization, and reusability. Deduct 5 points if global variable pollution is found; deduct 5 points if the code is not organized in logical functions or components; deduct 5 points if there's significant code duplication. 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 choppy animations during the draw process, and 5 points for confusing or misleading user interactions. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "easy"
+}

package/library/game_development-casual/html-snake-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1407,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Be sure to provide executable code whenever possible. Design a Snake game using HTML.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core snake game mechanics correctly implemented?",
+      "description": "Review the code for accurate implementation of basic game mechanics: snake movement in four directions, food spawning at random positions, and collision detection (snake-food, snake-wall, snake-self). Score 0 if core mechanics are missing, 5 if only basic movement exists, and 10 if all standard mechanics are properly implemented including speed adjustment as the snake grows.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the game loop and user input handling properly designed?",
+      "description": "Examine the game's main loop structure for proper timing (using requestAnimationFrame or setInterval with appropriate intervals), and check input handling for responsiveness and prevention of illegal moves (like immediate reversal). Deduct 3 points for frame rate issues, 3 points for laggy input response, and 5 points if illegal moves are possible. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the game state management complete?",
+      "description": "Verify if the code includes proper game state management (start, play, pause, game over) with appropriate transitions between states. Check for score tracking, high score persistence (localStorage), and game reset functionality. Deduct 3 points if any state is missing, 3 points without score persistence, 2 points if game reset requires page reload. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the HTML5 Canvas or DOM rendering optimized?",
+      "description": "Evaluate the rendering approach (Canvas or DOM elements) for efficiency. For Canvas, check if drawing operations are minimized and if the context is properly managed. For DOM, check if element creation/destruction is minimized. Deduct 5 points for unnecessary re-renders, 3 points for unoptimized drawing calls, and 3 points for lack of appropriate browser compatibility. 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 sequences, browser tab switching, window resizing, etc.) and provide friendly error handling. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Different types of food with special effects 2. Obstacles or changing map layouts 3. Power-ups or special abilities). 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 handle the same input) 2. Function modules unrelated to the Snake game 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 (separation of game logic, rendering, and input handling), code reusability, and maintainability. Deduct 5 points if game logic is tightly coupled with rendering; deduct 5 points if the code has high duplication rate; deduct 3 points if variable/function naming is unclear. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the game design follows modern design principles: 1) Consistent visual style with appropriate color scheme 2) Clear game area boundaries and readable score display 3) Appropriate sizing of game elements for playability. Deduct 3 points for unclear game boundaries, 3 points for poor contrast making elements hard to see, 4 points for inconsistent sizing of snake segments or food. 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 user input: 1) Immediate visual feedback on key presses 2) Smooth snake movement without jitter 3) Clear visual cues for game events (eating food, game over). Deduct 4 points for delayed movement response, 3 points for choppy animation, 3 points for lack of visual feedback on important game events. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "easy"
+}

package/library/game_development-casual/html5-sailing-mini-game-character-symbols.json

@@ -0,0 +1,68 @@
+{
+  "index": 1665,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable whenever possible. Create a sailing mini-game using HTML5, using character symbols to replace graphic resources.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the sailing game core mechanics fully implemented?",
+      "description": "Review whether the code accurately implements sailing physics through HTML5 Canvas/JavaScript, including wind direction effects on boat movement, sail angle adjustments, and realistic boat dynamics (acceleration, deceleration, turning). Check if character symbols effectively represent boat, wind indicators, and environmental elements. Score 0 if core sailing mechanics are missing, 5 if only basic movement is implemented, and 10 if realistic sailing physics with wind interaction are fully included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the game environment and navigation system properly designed?",
+      "description": "Evaluate whether the game includes a proper maritime environment with boundaries, obstacles (islands, rocks), and navigation elements using character symbols. Check for wind visualization, compass/direction indicators, and collision detection with environmental elements. Deduct 5 points if environmental boundaries are not implemented, and 3 points if wind direction indicators are unclear or missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the game objectives and progression mechanics implemented?",
+      "description": "Check whether the game includes clear objectives (racing checkpoints, cargo delivery, treasure hunting, etc.) and scoring/timing systems. Evaluate if there are multiple difficulty levels or progressive challenges. Deduct 5 points if no clear win/lose conditions exist, and 3 points if scoring mechanism is missing. Assess whether the game provides meaningful progression and replayability. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the character symbol representation system well-designed and intuitive?",
+      "description": "Evaluate whether character symbols are used creatively and intuitively to represent game elements (boat: ⛵ or ^, waves: ~, wind: →, islands: ●, etc.). Check if symbols are consistent, visually distinguishable, and scale appropriately. Review if there's a legend or help system explaining symbol meanings. Deduct 5 points if symbols are confusing or inconsistent, and 3 points if scaling issues affect readability. Give 10 points if symbols create a cohesive and intuitive visual system.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as out-of-bounds movement, invalid input, browser compatibility issues, canvas rendering errors, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should effectively handle edge cases like window resizing, keyboard/mouse input validation, and game state corruption. Give 10 points for comprehensive error handling, 5 points for basic exception handling, and 0 points if no exceptions are handled.",
+      "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 sailing experience (e.g., 1. Weather system affecting gameplay 2. Realistic tide effects 3. Multi-boat AI opponents 4. Sound effects using Web Audio API 5. Procedurally generated maps). Evaluate creativity in using character symbols for advanced visual effects or animations. Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple collision detection systems) 2. Function modules unrelated to sailing gameplay (e.g., built-in calculator) 3. Overly complex character symbol animations that affect performance or readability. Deduct 3 points for each redundancy found, and directly deduct 10 points if core sailing functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (separating game logic/rendering/input handling), code organization, and HTML5 best practices. Check for proper Canvas usage, efficient rendering loops, and memory management. Deduct 5 points if global state pollution is found or no design patterns are used; deduct 5 points if code duplication rate is too high (over 30%); deduct 5 points if no optimization for animation frames or Canvas performance. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface design meet professional standards despite using character symbols?",
+      "description": "Evaluate whether the overall design creates a cohesive visual experience: 1) Harmonious color scheme for background and text 2) Proper spacing and layout organization 3) Readable font system with appropriate sizing for game UI elements 4) Effective use of character symbols to create visual hierarchy. Deduct 3 points for each cluttered visual element, 5 points for poor color contrast affecting readability, and 5 points for chaotic symbol arrangement. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the gameplay interaction smooth and responsive?",
+      "description": "Judge whether the game controls and feedback conform to gaming standards: 1) Input response delay ≤ 100ms 2) Smooth animation transitions for boat movement 3) Clear visual feedback for user actions 4) Intuitive control scheme (keyboard/mouse). Deduct 5 points for each unresponsive control, 3 points for choppy animations or poor frame rates, and 5 points for unclear control instructions or feedback. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "easy"
+}

package/library/game_development-casual/jump-jump-game-assistant-jumping-distance.json

@@ -0,0 +1,68 @@
+{
+  "index": 970,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Make sure the generated code is executable for demonstration. Write a mobile-runnable code for a \"Jump Jump\" game assistant that obtains the character's coordinates, and then extends a line based on press duration to determine jumping distance.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the character coordinate detection system accurately implemented?",
+      "description": "Review whether the code implements precise character position detection through image recognition or screen capture APIs, including pixel analysis algorithms and coordinate calculation logic. Score 0 if coordinate detection is not implemented, 5 if basic position detection works but accuracy is below 90%, and 10 if character coordinates are detected with high precision (>95% accuracy) and include validation mechanisms.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the press duration measurement and distance calculation mechanism properly functioning?",
+      "description": "Check whether the code accurately measures touch/press duration and converts it to jumping distance using appropriate mathematical models. Evaluate if the timing mechanism handles different touch events correctly and calculates distance with proper scaling. Deduct 5 points if timing accuracy is poor (>50ms deviation), and 3 points if distance calculation lacks calibration options. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the visual trajectory line extension system implemented effectively?",
+      "description": "Evaluate whether the code renders a dynamic trajectory line that extends based on press duration, with real-time visual feedback. Check if the line drawing uses proper graphics APIs (Canvas/SVG) and updates smoothly during interaction. Deduct 5 points if line rendering is choppy or delayed, and 3 points if visual indicators don't match actual calculated distance. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is mobile platform compatibility and touch interaction properly handled?",
+      "description": "Check whether the code is optimized for mobile devices with proper touch event handling, screen size adaptation, and performance optimization. Evaluate if the implementation works across different mobile browsers/platforms and handles device-specific features. Deduct 5 points if touch responsiveness is poor, and 3 points if screen adaptation is inadequate. Give 10 points if fully mobile-optimized.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as screen resolution changes, touch interruptions, coordinate detection failures, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the gaming experience (e.g., 1. Auto-calibration for different game versions 2. Success rate statistics and learning optimization 3. Trajectory prediction with physics simulation 4. Multi-target detection and selection). 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 coordinate detection methods running simultaneously) 2. Function modules unrelated to the game assistant (e.g., built-in social features) 3. Fancy effects that affect performance (e.g., complex particle systems). Deduct 3 points for each redundancy found, and directly deduct 10 points if 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 detection logic/UI/calculation modules), error handling coverage, and mobile optimization practices. Deduct 5 points if global state pollution is found or proper mobile development patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if mobile performance optimization is not implemented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet mobile design standards?",
+      "description": "Evaluate whether the mobile interface follows modern mobile design principles: 1) Touch-friendly button sizes (minimum 44px tap targets) 2) Appropriate contrast ratios for outdoor visibility 3) Clear visual hierarchy with proper spacing 4) Responsive design for different screen sizes. Deduct 3 points for each UI element that's hard to interact with on mobile, 5 points for poor readability, and 5 points for non-responsive layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the real-time interaction smooth and responsive?",
+      "description": "Judge whether the real-time feedback meets mobile gaming standards: 1) Touch response delay ≤ 50ms 2) Smooth line extension animation at 60fps 3) Immediate visual feedback for all interactions 4) Stable performance during continuous use. Deduct 5 points for each laggy interaction, 3 points for inconsistent frame rates, and 5 points for delayed coordinate updates. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "easy"
+}