@getollie/cli 0.0.5 → 0.2.0

package/library/game_development-casual/princess-makeup-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 322,
-  "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 purposes. Help me write a frontend program for a princess makeup game where a princess can get a makeover, including applying eyeshadow, changing contacts, switching hairstyles, changing hair color, and applying lipstick. Include buttons for these operations.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core princess makeup system fully implemented?",
-      "description": "Review whether the code accurately implements the princess makeover functionality through HTML/CSS/JavaScript. Check if all required features (eyeshadow, contacts, hairstyles, hair color, and lipstick) are properly implemented with layering techniques. Score 0 if the core makeup functions are missing, 5 if only basic functions are implemented without visual effects, and 10 if all makeup options include proper visual transformations and blending modes.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the UI control system properly designed?",
-      "description": "Evaluate whether the interface includes all specified buttons (eyeshadow, contacts, hairstyles, hair color, and lipstick) and whether these controls are logically organized. Check if each button triggers the appropriate makeup action and if there are options/variations within each category. Deduct 2 points for each missing makeup category, and 1 point if a category exists but has no style variations. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the makeup application process interactive and realistic?",
-      "description": "Assess whether the makeup application looks realistic with proper blending on the princess model. Check if there are transitions between makeup states rather than abrupt changes. Score 10 if the makeup application includes visual effects like color blending, transparency, and proper layering; 5 if changes are visible but lack realism; 0 if changes are too simplistic (e.g., just swapping entire face images).",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the state management of the princess makeover properly implemented?",
-      "description": "Check if the code maintains the princess's current state across different makeup applications. Verify if multiple makeup elements can be combined (e.g., applying both eyeshadow and lipstick). Deduct 5 points if previous makeup gets erased when applying new makeup, and 3 points if there's no way to reset individual makeup elements. Give 10 points if the state management allows for complete customization.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as missing image assets, unsupported browsers, rapid sequential clicks, 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. Before/after comparison slider 2. Save/share makeover results 3. Animated makeup application effects 4. Personalized recommendations based on selections). 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 apply the same makeup) 2. Function modules unrelated to makeup (e.g., a built-in game unrelated to the makeover) 3. Fancy effects that affect performance (e.g., unnecessary animations that slow down the interface). 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/rendering/asset management), code reusability for different makeup types, and asset loading optimization. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if large image assets aren't properly managed (e.g., no lazy loading). 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 suited for a princess theme (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 makeup application effects conform to user expectations: 1) Makeup application feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual indication of selected makeup items. Deduct 5 points if makeup changes have no visual feedback, 3 points for laggy transitions when changing multiple makeup items quickly, and 5 points for confusing UI that doesn't indicate current selections. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Casual",
-  "difficulty": "medium"
-}

package/library/game_development-casual/prize-wheel-game-with-editable-content.json

@@ -1,68 +0,0 @@
-{
-  "index": 1202,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Take care to ensure that the generated code is executable for demonstration purposes. Write a piece of code for a prize wheel game where the wheel contents can be edited and the probability of winning can be modified.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the prize wheel core spinning mechanism properly implemented?",
-      "description": "Check if the code implements a visually accurate rotating wheel with proper physics (deceleration, inertia), smooth animation (60fps minimum), and clear indication of the selected prize. Score 0 if spinning is not implemented, 5 if basic rotation exists but lacks physics, and 10 if the spinning animation is realistic with proper easing functions and stopping mechanics.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the prize configuration and probability modification system complete?",
-      "description": "Evaluate whether the code allows full customization of prizes (names, colors, images) and precise probability settings for each slice. The system should maintain mathematical integrity (probabilities sum to 100%) and include validation. Deduct 5 points if only basic prize editing exists without probability control, and 3 points if validation is missing. Award full 10 points if the system includes weighted randomization implementation.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is there a proper prize selection algorithm that respects configured probabilities?",
-      "description": "Review the randomization algorithm to ensure it accurately respects the configured probabilities. Check for proper weighted random selection rather than uniform distribution, and verify through statistical testing functions. Deduct 5 points if the algorithm shows bias, and 3 points if edge cases (like very low probabilities) aren't handled. Full 10 points requires mathematically sound implementation with verifiable outcomes.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there a complete user interface for wheel configuration and result display?",
-      "description": "Assess whether the code includes intuitive interfaces for prize editing, probability adjustment, and result display. Check for form validation, real-time preview of wheel changes, and clear winner notification. Deduct 5 points if the configuration UI is incomplete, and 3 points if winner display lacks visual/audio feedback. Full 10 points requires a complete configuration panel with instant visual updates to the wheel.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid probability inputs, extremely fast consecutive spins, browser resize events, 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. Sound effects or haptic feedback, 2. Confetti animation for winners, 3. History of previous spins with statistics, 4. Mobile/touch support). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple random algorithms) 2. Function modules unrelated to the prize wheel (e.g., unnecessary side games) 3. Fancy effects that affect performance (e.g., excessive particle animations that slow down the wheel). 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 wheel logic/view/configuration), proper event handling, and appropriate use of design patterns. Deduct 5 points if global state pollution is found; deduct 5 points if the code duplication rate is high (over 30%); deduct 5 points if browser compatibility is ignored. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the wheel design follows modern UI principles: 1) Harmonious color matching for prize segments 2) Clear typography for prize labels 3) Proportional layout with proper wheel dimensions relative to the container. Deduct 3 points for each accessibility issue (poor contrast, tiny text), 5 points for clashing colors, and 5 points for prizes becoming illegible when spinning. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the spinning animation and user interactions follow natural expectations: 1) Responsive spin button with clear feedback 2) Smooth acceleration/deceleration curves 3) Clear indication when the wheel is active vs. available to spin again. Deduct 5 points for each interaction without feedback, 3 points for jerky animations, and 5 points for confusing states (e.g., unclear if wheel is currently spinning). The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Casual",
-  "difficulty": "easy"
-}

package/library/game_development-casual/pubg-mobile-vocabulary-lottery-system.json

@@ -1,68 +0,0 @@
-{
-  "index": 827,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Ensure that the code you generate is executable for demonstration. Create a lottery system for opening vocabulary boxes in the Peace Elite (PUBG Mobile) subway escape mode, with the requirement that it can replace weapons and vocabulary content.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the lottery system core mechanism fully implemented?",
-      "description": "Review whether the code accurately implements the lottery probability algorithm, including weighted random selection, guarantee mechanism (pity system), and rarity distribution. Check if different vocabulary box types have distinct drop rates and if the probability calculation follows standard gacha mechanics. Score 0 if core lottery logic is missing, 5 if only basic random selection is implemented, and 10 if complete probability system with guarantee mechanism is included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the vocabulary and weapon replacement system properly designed?",
-      "description": "Evaluate whether the system allows dynamic content replacement for both weapons and vocabulary items. Check if the data structure supports easy modification of item pools, rarity levels, and metadata. Verify that the replacement mechanism maintains consistency in item properties and visual representations. Deduct 5 points if hardcoded item lists are used, and 3 points if item metadata is incomplete. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the opening animation and visual feedback system complete?",
-      "description": "Check whether the lottery opening sequence includes proper visual effects such as box opening animations, rarity reveal effects, and item showcase presentations. Evaluate if the animation timing creates appropriate suspense and excitement. Verify that different rarity items have distinct visual treatments. Deduct 5 points if animations are missing or too basic, and 3 points if rarity differentiation is unclear. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the inventory and collection management system implemented?",
-      "description": "Assess whether the system includes comprehensive inventory management with item storage, collection tracking, and usage statistics. Check if duplicate handling is properly managed and if players can view their collection history. Verify that item organization follows logical categorization. Deduct 5 points if inventory persistence is not implemented, and 3 points if duplicate item handling is missing. Give 10 points if fully implemented with statistics.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid probability configurations, missing item data, concurrent lottery requests, 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. Multi-box opening with batch results 2. Item preview with 3D models 3. Achievement system for rare item collection 4. Social sharing of rare drops). 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 coexisting) 2. Function modules unrelated to lottery system (e.g., built-in chat system) 3. Excessive visual effects that impact performance (e.g., complex particle systems for every item). Deduct 3 points for each redundancy found, and directly deduct 10 points if core lottery 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 lottery logic/UI/data layers), configuration management, and code 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 item configuration is not externalized. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern game UI principles: 1) Gaming-appropriate color scheme with proper rarity color coding (Common/Rare/Epic/Legendary) 2) Proper layout spacing with clear visual hierarchy 3) Professional typography with readable font sizes (≥14px for body text). Deduct 3 points for each crowded visual element, 5 points for poor rarity color distinction, and 5 points for chaotic item layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the lottery interactions conform to gaming standards: 1) Box opening trigger response ≤100ms 2) Opening animation duration 2-4 seconds for proper suspense 3) Clear visual feedback for item rarity reveals 4) Smooth transitions between lottery states. Deduct 5 points for each interaction without proper feedback, 3 points for jarring animation transitions, and 5 points for unclear rarity reveal sequences. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Casual",
-  "difficulty": "hard"
-}

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

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

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

@@ -1,68 +0,0 @@
-{
-  "index": 1085,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Be sure to provide executable code whenever possible. Write me a small program that can randomly draw prizes.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core prize drawing functionality fully implemented?",
-      "description": "Verify if the code correctly implements a random selection algorithm that fairly selects prizes based on their probability distribution. Score 0 if no random selection is implemented, 5 if basic random selection exists but without proper distribution control, and 10 if the implementation includes configurable probability weights for different prizes.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the prize pool management system properly designed?",
-      "description": "Evaluate whether the code allows for dynamic prize pool configuration, including adding/removing prizes, setting prize quantities, and managing prize availability. Deduct 5 points if the prize pool is hardcoded, 3 points if quantities aren't tracked properly. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is there a proper prize distribution validation mechanism?",
-      "description": "Check if the program includes methods to verify the fairness of the distribution (e.g., statistical testing, distribution visualization, or logging). Score 0 if no validation exists, 5 if basic logging is implemented, and 10 if comprehensive statistical validation is included.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Does the program handle edge cases in prize drawing?",
-      "description": "Assess whether the code properly handles situations like empty prize pools, prizes running out, probability edge cases (0% or 100%), and ensures no unexpected behavior. Deduct 3 points for each unhandled edge case. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid inputs, unexpected data types, out-of-bounds values, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Visual prize drawing animation 2. Historical drawing records with statistics 3. Prize inventory management). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple random selection algorithms) 2. Function modules unrelated to prize drawing (e.g., a built-in calculator) 3. Fancy effects that affect performance. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating prize definition/drawing logic/user interface), unit test coverage, and appropriate use of language features. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if best practices for the chosen language are not followed. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the user interface (if applicable) follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects (if applicable) conform to human perception characteristics: 1) Clear visual feedback during and after prize drawing 2) Appropriate animation timing for suspense without excessive delay 3) Clear visual indication of prize results. Deduct 5 points for lack of visual feedback, 3 points for confusing or overly lengthy animations, and 5 points for unclear result presentation. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Casual",
-  "difficulty": "easy"
-}

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

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

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

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

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

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