@getollie/cli 0.0.4 → 0.2.0

package/library/game_development-casual/html-dice-rolling-program.json

@@ -1,68 +0,0 @@
-{
-  "index": 1031,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional replies. Make sure the code you provide is executable for demonstration. Create a dice rolling program using HTML.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the basic dice rolling function implemented correctly?",
-      "description": "Check if the code accurately implements random dice generation using JavaScript Math.random() or similar function. The dice values should be properly generated within the range of 1-6 (or appropriate range for the specified dice). Score 0 if no random functionality exists, 5 if random generation is implemented but with potential bias or incorrect range, 10 if properly implemented with equal probability distribution.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the dice visualization properly implemented with HTML/CSS?",
-      "description": "Review whether the code visually represents dice faces using proper HTML elements (div, svg, canvas, etc.) with CSS styling. Check if the pip patterns correctly match standard dice patterns (e.g., 1 center pip for value 1, diagonal pips for value 3). Deduct 5 points if only textual representation is used, 3 points if visual dice faces exist but with incorrect patterns. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Does the program include a clear user interaction mechanism?",
-      "description": "Evaluate whether there's a clear way for users to trigger dice rolls (button, click event, etc.) with appropriate visual feedback. The interface should make it obvious how to interact with the program. Deduct 5 points if there's no clear roll button/mechanism, 3 points if the interaction is present but confusing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there an animation or visual transition for the dice roll?",
-      "description": "Check if the dice roll includes an appropriate animation effect (such as spinning, shaking, or transitioning between values) to simulate physical dice behavior. The animation should enhance the user experience and provide a sense of randomness. Deduct 5 points if no animation exists, 3 points if the animation is implemented but looks unnatural or distracting. 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 consecutive clicks, browser compatibility issues, or unexpected user interactions) and provide friendly error handling. Code with strong robustness should work consistently across different scenarios, giving 10 points. If the robustness is average, give 5 points, and if no error handling exists, 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 rolls 2. History of previous rolls 3. Multiple dice options 4. Custom dice faces or themes). 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) 2. Function modules unrelated to dice rolling (e.g., unnecessary animations or 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 code organization (such as separating logic/view layers), code readability, and proper use of HTML/JavaScript/CSS best practices. Deduct 5 points if global namespace pollution is found; deduct 5 points if there's significant code duplication; deduct 5 points if the code lacks comments or uses poor naming conventions. 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 dice rolls, and 5 points for hard-to-find roll button or controls. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Casual",
-  "difficulty": "easy"
-}

package/library/game_development-casual/html-javascript-catch-collect-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 56,
-  "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.\n\nPlease use HTML and JavaScript to implement a Catch and Collect game.\n**Task**: Implement a capture system where players can catch certain objects or creatures in the game and collect them.\n**Hint**: You can capture objects by throwing nets or using specific tools, then add them to the player's collection.\n[CHAT_SEP]Please optimize the above game response, and add comments to your code so other developers can understand your implementation process.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core capture system fully implemented?",
-      "description": "Review whether the code implements a complete capture system with mechanics for targeting, throwing/using capture tools, and determining success/failure rates. Check if capturing objects involves skill elements (like timing, aim, or resource management) rather than just simple clicks. Score 0 if no capture mechanics exist, 5 if basic clicking to capture is implemented, and 10 if the system includes varied capture tools with different properties and success calculations.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the collection management system properly designed?",
-      "description": "Evaluate whether the code implements a functional collection system for storing and managing captured objects. Check for features like categorization, sorting options, viewing collection details, and persistent storage of collected items. Deduct 5 points if there's no storage persistence, and 3 points if the collection lacks organization features. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are there varied and interesting objects to collect?",
-      "description": "Assess the diversity and implementation of collectible objects in the game. Check if objects have unique properties, visual representations, and capture difficulty levels. Score 0 if there's only one type of collectible, 5 if there are multiple but with minimal differentiation, and 10 if there's a rich variety of collectibles with different behaviors, appearance, rarity levels, and capture requirements.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the game progression system implemented?",
-      "description": "Check whether the game includes progression mechanics that reward collection and provide increasing challenges. Look for features like unlockable capture tools, achievements for collection milestones, increasing difficulty, or collection-based goals. Deduct 5 points if there's no sense of progression, and 3 points if progression is too linear or predictable. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid clicking, unexpected input sequences, 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. Evolving collectibles based on play patterns 2. Environmental factors affecting capture rates 3. Mini-games for improving capture chances). 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 overlapping capturing mechanisms) 2. Function modules unrelated to capture/collection gameplay (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive particle effects that slow down gameplay). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/view/collection system), code comments quality, 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 comments are missing or unhelpful. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern 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 feedback for successful/failed captures. Deduct 5 points for each operation without feedback, 3 points for choppy animations during capture attempts, and 5 points for unclear game state indicators. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Casual",
-  "difficulty": "medium"
-}

package/library/game_development-casual/html-javascript-friend-system-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 30,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Pay attention to ensure that the generated code is executable.\n\nPlease use HTML and JavaScript to implement a friend system.\n\n**Task**: Implement a friend system where players can add friends and play games or battle with them.\n\n**Hint**: Set up a friend list and invitation functionality, allowing players to add friends through usernames or IDs.\nGame, and include some comments in the code so that other developers can understand your implementation process.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the friend list system fully implemented?",
-      "description": "Check whether the code implements a complete friend list system with data structure design (user profiles with unique IDs), CRUD operations (add, remove, update, search friends), and proper state management. Score 0 if the friend list is not implemented, 5 if only basic display is implemented, and 10 if all features including categorization, online status indicators, and search functionality are included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the friend invitation functionality properly implemented?",
-      "description": "Evaluate whether the code includes a complete invitation system with sending invitations, accepting/rejecting mechanisms, notification handling, and validation checks (preventing duplicate invitations, handling expired invitations). Deduct 5 points if there's no confirmation flow, and 3 points if no notification system exists. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the user authentication and identification system implemented?",
-      "description": "Check whether the code implements user authentication (login/registration), unique identification (username/ID system), and proper session management. Assess if there are security measures for friend requests and profile visibility settings. Deduct 5 points if authentication is missing, 3 points if there's no session persistence. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the game/battle invitation system properly implemented?",
-      "description": "Evaluate whether the code handles game/battle invitations between friends, including invitation sending, acceptance/rejection flows, and game session creation. Check if there's proper state handling for ongoing games, matchmaking logic, and multiplayer session management. Deduct 5 points if the invitation flow is incomplete, 3 points if there's no game state management. 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, network failures, friend request spam, 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. Real-time friend activity feed 2. Friend recommendations based on gaming preferences 3. Integrated chat system). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple friend-finding mechanisms) 2. Function modules unrelated to the friend system (e.g., unnecessary game features) 3. Fancy effects that affect performance (e.g., excessive animations in the friend list). 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, documentation quality (especially the requested comments for other developers), 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 comments are insufficient 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) 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 scrolling of friend lists, and 5 points for hard-to-find key function buttons (like add friend or send invitation). The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Casual",
-  "difficulty": "medium"
-}

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

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

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

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

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

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