@getollie/cli 0.0.1

package/library/game_development-strategy/agar-io-web-game-html-javascript.json

@@ -0,0 +1,68 @@
+{
+  "index": 1642,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Be careful to ensure that the generated code is executable for demonstration. Help me create a web game similar to Agar.io, requiring it to be identical to the original. I have no programming knowledge whatsoever. It should be made in a format that can be saved as a notepad file, then directly run in a web browser.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core gameplay of Agar.io accurately implemented?",
+      "description": "Review whether the code correctly implements the fundamental mechanics of Agar.io: 1) Player-controlled cell that grows by consuming smaller cells 2) Shrinking mechanism when splitting 3) Cell splitting functionality 4) Proper mass/size relationship. Score 0 if these core mechanics are missing, 5 if only basic movement and consumption are implemented, and 10 if all features including splitting, ejecting mass, and proper growth/shrinkage dynamics are included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the multiplayer simulation properly implemented?",
+      "description": "Check whether the code includes AI opponents that mimic player behavior when real multiplayer is unavailable (since true multiplayer would require server infrastructure). Evaluate if these AI cells follow convincing movement patterns, demonstrate varied strategies (aggressive/passive), and properly interact with the player's cell. Deduct 5 points if AI behavior is too predictable, 3 points if they don't react to player actions. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the physics and collision detection accurately implemented?",
+      "description": "Assess whether the physics system correctly handles: 1) Size-based consumption rules 2) Momentum and mass effects on movement speed 3) Collision detection between cells of different sizes 4) Proper handling of cell merging after splitting. Deduct 3 points for each physics inconsistency with the original game, and 5 points if cells pass through each other incorrectly. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the game environment and food generation system properly implemented?",
+      "description": "Evaluate the implementation of: 1) Randomly generated food pellets 2) Properly scaled game map 3) Zoom functionality that adjusts based on player cell size 4) Virus cells that can split larger players. Deduct 3 points if food generation is not continuous, 5 points if the map lacks boundaries, and 5 points if viruses don't function correctly. 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 mouse movements, browser resize, performance issues on slower devices) 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 beyond the original Agar.io (e.g., 1. Custom skins selection 2. Local high score tracking 3. Different game modes like timed challenges). 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 implementations of similar functions (e.g., multiple ways to handle the same game event) 2. Function modules unrelated to the Agar.io concept (e.g., unnecessary menu systems) 3. Fancy effects that affect performance (e.g., excessive particle effects 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 (such as separating game logic/rendering/input handling), code organization, and whether the single HTML file structure is well-organized for a beginner to understand. Deduct 5 points if global variable pollution is excessive; deduct 5 points if the code is not commented or explained for beginners; deduct 5 points if the game loop implementation is inefficient. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision match the original Agar.io design?",
+      "description": "Evaluate whether the visual implementation matches Agar.io's clean aesthetic: 1) Simple colored circles with proper gradients 2) Clear size differentiation 3) Minimal UI elements for score and leaderboard 4) Clean playing field with subtle grid pattern. Deduct 3 points for each visual element that differs significantly from the original, 5 points for an overcomplicated interface, and 5 points for missing essential UI components like the leaderboard. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and responsive?",
+      "description": "Judge whether the game's interactions match the original Agar.io experience: 1) Smooth mouse-following movement 2) Responsive splitting with Space key 3) Proper mass ejection with W key 4) Seamless camera zoom as player grows. Deduct 5 points for input lag exceeding 100ms, 3 points for choppy animations during rapid growth/movement, and 5 points for incorrect handling of key commands. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "hard"
+}

package/library/game_development-strategy/ai-chess-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1122,
+  "question": "You are a coding expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the generated code is executable when possible. Create code for an AI chess game.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the chess game core mechanics fully implemented?",
+      "description": "Review whether the code accurately implements the chessboard representation, piece movement rules, and game state management. Check if all chess pieces (pawns, knights, bishops, rooks, queens, kings) follow standard chess rules. Score 0 if the core game logic is missing, 5 if basic movement is implemented but with rule gaps, and 10 if all standard chess rules are correctly implemented including special moves (castling, en passant, promotion).",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the AI opponent functionality properly implemented?",
+      "description": "Evaluate the AI algorithm's implementation and complexity. Check if it uses appropriate techniques like minimax with alpha-beta pruning, evaluation functions, or more advanced approaches like neural networks. Score 3 for basic random move selection, 7 for a medium-difficulty AI that can anticipate a few moves ahead, and 10 for a sophisticated AI that implements multiple difficulty levels and demonstrates strategic play.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there a complete game state management system?",
+      "description": "Check whether the code includes game initialization, turn tracking, win/loss/draw detection, and game history recording. Verify if checkmate, stalemate, and draw conditions (50-move rule, threefold repetition, insufficient material) are properly detected. Deduct 3 points if any critical chess rules are missing, 2 points if game history is not maintained, and 2 points if draw conditions are not fully implemented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the UI representation of the chess game properly implemented?",
+      "description": "Assess whether the chess board is correctly rendered with alternating colors, pieces are visually distinguishable, and the current game state is clearly displayed. Check if legal moves are visually indicated and if there's visual feedback for check, checkmate, and game end conditions. Deduct 5 points for missing visual cues, 3 points for poor piece differentiation, and 3 points for lack of game state indicators. 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 moves, interrupted games, etc.) and provide friendly error handling or recovery mechanisms. Code with strong robustness should effectively handle edge cases, giving 10 points. If the 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 are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Move suggestions for beginners 2. Game analysis after completion 3. Different AI personalities/playing styles 4. Interactive tutorials). 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 move validation logics) 2. Function modules unrelated to chess (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive animations that slow down gameplay). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game logic/UI/AI components), 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 the code lacks appropriate comments or documentation. 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 piece selection, move execution, and game events. 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-Strategy",
+  "difficulty": "easy"
+}

package/library/game_development-strategy/ancient-civilization-city-building-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 39,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Make sure the generated code is executable for demonstration.\n\nPlease implement an Ancient Civilization game using HTML and JavaScript where players need to rebuild an ancient city. \nHint: Implement city planning and civilization development.\n\nInclude some comments in your code so other developers can understand your implementation process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the city planning system fully implemented?",
+      "description": "Review whether the code accurately implements a grid-based city planning system through HTML/JavaScript, including building placement mechanics, terrain constraints, and zoning functionality (residential, commercial, industrial areas). Score 0 if core city building mechanics are missing, 5 if only basic building placement is implemented, and 10 if comprehensive city planning with zoning restrictions and adjacency bonuses is fully included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the civilization development progression system implemented?",
+      "description": "Check whether the game includes a complete civilization advancement system with technology trees, resource management (food, materials, population), and era progression. Evaluate if research mechanics, resource production chains, and population growth are properly simulated. Deduct 5 points if resource balancing is missing, and 3 points if technology prerequisites are not enforced. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the ancient city rebuilding mechanic designed with historical authenticity?",
+      "description": "Evaluate whether the rebuilding system reflects authentic ancient civilization elements including appropriate building types (temples, markets, granaries, walls), historical resource constraints, and period-accurate visual design. Check if the game includes realistic construction timelines and resource requirements. Deduct 5 points if buildings lack historical context, and 3 points if the rebuilding progression feels anachronistic. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the complete game state management and save system constructed?",
+      "description": "Check whether the code includes comprehensive game state persistence, including city layout serialization, civilization progress tracking, and local storage integration. Evaluate if the game can resume from saved states and handle multiple save slots. Deduct 5 points if game state serialization is not implemented, and 3 points if the save/load mechanism is unreliable. Give 10 points if fully implemented with robust state management.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid building placements, resource shortage scenarios, browser compatibility issues, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the ancient civilization experience (e.g., 1. Dynamic weather affecting city development 2. Historical events and random challenges 3. Archaeological discovery mini-games 4. Trade route establishment with other civilizations). 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 resource calculation systems coexisting) 2. Function modules unrelated to ancient civilization building (e.g., modern technology elements) 3. Overly complex animations that affect gameplay performance (e.g., excessive particle effects for construction). Deduct 3 points for each redundancy found, and directly deduct 10 points if core city-building functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game logic/rendering/UI management layers), code organization with proper commenting as requested, and maintainable architecture. Deduct 5 points if global state pollution is found or object-oriented principles are not followed; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if insufficient commenting makes the code hard to understand for other developers. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards with ancient civilization theming?",
+      "description": "Evaluate whether the overall design follows ancient civilization aesthetics: 1) Appropriate color palette evoking ancient times (earth tones, stone textures) 2) Proper layout spacing with clear building grid visualization 3) Thematic UI elements that match the ancient setting. Deduct 3 points for each anachronistic visual element, 5 points for color schemes that break immersion, and 5 points for UI elements that don't match the ancient theme. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless for city building?",
+      "description": "Judge whether the city building interactions conform to user expectations: 1) Building placement feedback with hover previews 2) Smooth camera/viewport controls for city navigation 3) Clear visual indicators for buildable areas and resource flows 4) Responsive building construction animations. Deduct 5 points for each building action without proper feedback, 3 points for laggy city navigation, and 5 points for unclear building placement indicators. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "hard"
+}

package/library/game_development-strategy/aura-rune-build-calculator-aoki-legend.json

@@ -0,0 +1,68 @@
+{
+  "index": 1400,
+  "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. Can you help me create a specific calculator for the Aura Rune builds in the Aoki Legend mobile game, which calculates optimal rune set combinations?",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Aura Rune calculation algorithm correctly implemented?",
+      "description": "Review whether the code accurately implements the Aura Rune stat calculation formulas, including base stats, percentage bonuses, set effects, and multiplicative stacking rules. Check if all rune types (ATK, HP, DEF, SPD, CRIT, etc.) are properly defined with correct coefficient calculations. Score 0 if core calculation logic is missing, 5 if only basic stat additions are implemented, and 10 if all complex multiplier interactions and diminishing returns are accurately calculated.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the optimal combination recommendation engine fully functional?",
+      "description": "Evaluate whether the optimization algorithm can effectively compare different rune set combinations and recommend the best builds based on user-defined priorities (damage output, survivability, speed tuning). Check if the system implements proper weight scoring, considers set bonuses, and handles constraint optimization (e.g., minimum speed requirements). Deduct 5 points if the algorithm uses simple brute force without optimization, and 3 points if set synergy effects are not considered. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the rune database and filtering system comprehensive?",
+      "description": "Check whether the system includes a complete rune database with all available rune sets from Aoki Legend, proper categorization by main stats and substats, and advanced filtering options. Evaluate if users can input their current rune inventory and filter by quality grades, enhancement levels, and specific stat ranges. Deduct 5 points if rune data is incomplete or outdated, and 3 points if filtering functionality is limited. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are build comparison and export features properly implemented?",
+      "description": "Assess whether the calculator provides side-by-side build comparisons with detailed stat breakdowns, damage calculations against different enemy types, and export functionality for sharing builds. Check if the system includes build saving/loading, team synergy analysis, and integration with popular gaming platforms or forums. Deduct 5 points if comparison features are superficial, and 3 points if export formats are limited. Give 10 points if fully implemented with multiple export options.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid rune inputs, calculation overflow, missing data, network timeouts when fetching game data, 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 calculator experience (e.g., 1. Real-time damage simulation against boss mechanics 2. AI-powered build suggestions based on current meta 3. Integration with game APIs for automatic rune import 4. Advanced statistical analysis with build performance tracking). 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 calculation methods (e.g., multiple stat computation engines coexisting) 2. Function modules unrelated to rune optimization (e.g., built-in character tier lists or gacha simulators) 3. Overly complex animations that slow down calculations (e.g., elaborate 3D rune visualizations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core calculation 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 calculation engine/UI components/data layers), unit test coverage for critical calculation functions, 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 calculation accuracy is not validated through comprehensive testing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the calculator interface follows modern design principles: 1) Gaming-appropriate color scheme that matches Aoki Legend's aesthetic (no more than 4 primary colors) 2) Proper layout spacing with clear sections for input/results/comparison (element spacing follows the 8px multiple principle) 3) Professional typography with readable fonts (body font size ≥ 14px, line height over 1.5 times) 4) Intuitive iconography for different rune types. Deduct 3 points for each crowded visual element, 5 points for color combinations that strain the eyes during long calculation sessions, and 5 points for chaotic data presentation layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the calculator interactions conform to user expectations: 1) Calculation updates with input delay ≤ 200ms for real-time feedback 2) Smooth transitions between different build configurations (300-500ms) 3) Clear visual indicators for loading states during complex optimizations 4) Intuitive drag-and-drop or click interactions for rune selection. Deduct 5 points for each operation without proper feedback, 3 points for laggy performance during intensive calculations, and 5 points for confusing navigation between calculator sections. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "hard"
+}

package/library/game_development-strategy/beautiful-interactive-web-page-garbage-sorting-mini-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1060,
+  "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. Help me create a beautiful, interactive web page for a garbage sorting mini-game.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core garbage sorting game mechanism fully implemented?",
+      "description": "Check if the code implements the complete game logic including: item classification into correct categories (recyclable, hazardous, kitchen waste, other waste), scoring system, and validation of correct/incorrect sorting. Score 0 if core sorting mechanics are missing, 5 if basic sorting is implemented but lacks comprehensive validation, 10 if the system handles all waste types with proper feedback and scoring.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the drag-and-drop interaction properly implemented?",
+      "description": "Evaluate the implementation of the drag-and-drop functionality: verify if items can be smoothly dragged, if the hitbox detection works accurately when dropping items into bins, and if there's appropriate visual feedback during the dragging process. Deduct 5 points if mobile touch events aren't supported, 3 points if accessibility features are missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there a complete game progression structure?",
+      "description": "Assess if the game has a proper structure with levels of increasing difficulty, clear goals, progress tracking, and performance metrics (time, accuracy, score). Check if there's a tutorial/onboarding experience for new players. Deduct 5 points if the difficulty curve is missing, 3 points if there's no feedback on player progress. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the educational content about garbage sorting accurate and complete?",
+      "description": "Review whether the game provides accurate information about different waste categories, sorting guidelines, and environmental impact. Check if it includes tooltips, explanations for incorrect sorting, or educational facts. Deduct 5 points if information is inaccurate, 3 points if explanations for sorting decisions are missing. 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 incorrect user inputs, browser compatibility issues, performance on different devices) 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 environmental impact calculation 2. Leaderboard with social sharing 3. Animated educational sequences about waste processing). 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 garbage sorting (e.g., unrelated mini-games) 3. Fancy effects that affect performance (e.g., excessive animations that slow down gameplay). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game logic/view/data 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 separation between game assets 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 (environmental theme with consistent palette) 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) Immediate visual feedback when items are sorted correctly/incorrectly 2) Smooth animations for dragging/dropping waste items 3) Clear visual cues for interactive elements. Deduct 5 points for each operation without feedback, 3 points for jerky animations, and 5 points for confusing interaction design. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "medium"
+}

package/library/game_development-strategy/browser-pixel-art-survival-game-html.json

@@ -0,0 +1,68 @@
+{
+  "index": 450,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate can be executed and displayed. Help me create a survival-style game with pixel art aesthetics that can run in a computer browser, implemented in a single HTML file. Please carefully check the code to ensure the program runs properly. I may add modification requests later.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core game loop and survival mechanics well-implemented?",
+      "description": "Evaluate whether the game properly implements essential survival mechanics (health, hunger, energy systems) and if the game loop handles game state updates correctly. Check for day-night cycle implementation, resource depletion, and progressive difficulty. Score 0 if core mechanics are missing, 5 if basic systems exist but lack depth, 10 if there's a comprehensive survival system with balanced mechanics.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "How well is the pixel art aesthetic implemented?",
+      "description": "Assess the quality and consistency of pixel art visuals. Look for proper scaling (no blur), consistent pixel size ratio, appropriate color palette (limited colors for authentic retro feel), and pixelated animations. Deduct 5 points if graphics are inconsistent in style, 3 points if using non-pixel art elements, and 5 points for improper scaling. Score 10 for authentic, cohesive pixel art that enhances gameplay.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the player movement and interaction system properly implemented?",
+      "description": "Examine the player control system including keyboard/mouse controls, collision detection, interaction with game objects, and inventory management. Check for smooth movement animations and responsive controls (≤100ms delay). Deduct 5 points for clunky controls, 5 points for collision detection issues, and 3 points if interactions lack visual feedback. Full score requires fluid movement and intuitive interactions.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "How well does the game handle resource management and crafting?",
+      "description": "Evaluate the implementation of gathering resources, inventory system, and crafting mechanics. Look for balanced resource distribution, intuitive crafting interface, and progression system through crafted items. Score 0 if these systems are absent, 5 if basic implementation exists, and 10 if there's a comprehensive system with meaningful choices and progression.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid inputs, browser compatibility issues, performance degradation on low-end devices) 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. Procedural world generation 2. Dynamic weather system 3. Ecosystem with AI creatures interacting). 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 player stats) 2. Function modules unrelated to survival gameplay (e.g., an unnecessary minigame) 3. Fancy effects that affect performance (e.g., excessive particles 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/rendering/input handling), code organization, and optimization for browser performance. Deduct 5 points if global variables are overused; deduct 5 points if the code structure is monolithic without clear separation of concerns; deduct 5 points if there are noticeable frame rate issues or memory leaks. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the UI design maintains pixel art consistency while being functional: 1) Appropriate scaling of UI elements 2) Clear visual hierarchy with important information easily readable 3) UI elements that match the game's aesthetic. Deduct 3 points for inconsistent UI style, 5 points for cluttered/unreadable UI, and 5 points for UI elements that break the pixel art immersion. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the game provides appropriate feedback and satisfying interactions: 1) Visual/audio feedback for player actions within 100ms 2) Smooth transitions between game states 3) Clear indication of damage, healing, or status effects. Deduct 5 points for actions without feedback, 3 points for choppy animations, and 5 points for confusing status indicators. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "medium"
+}

package/library/game_development-strategy/bull-king-card-game-rules.json

@@ -0,0 +1,68 @@
+{
+  "index": 1105,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Who is the Bull King\n\n\"Who is the Bull King\" is a simple and fun card game suitable for 2-10 players. The game consists of 104 cards, each with numbers from 1 to 104, and each card features a different number of bull heads. This game has won multiple awards, including the 1994 German Players' Award and the 1996 Best Mind Game Award.\n\n## Game Rules\n\n**Dealing**: Each player receives 10 cards, with 4 cards placed face-up on the table as the initial tableau. Excess cards are discarded.\n\n**Playing**: At the beginning of each round, each player selects one card from their hand to play face-down.\n\n**Card Placement Order**: When all players have placed their cards face-down, the system automatically reveals and places the cards, starting with the card closest in value to the last card on the tableau. If cards are equally close, the smaller card is placed first.\n\n**Placement Rules**: Cards are preferentially placed in positions that don't require collecting cards, then in positions closest to the end card on the tableau, and finally in positions where the end card has a smaller value.\n\n**Card Collection**: When a player places a card that is smaller than the last card on the tableau, or when placing a card in the sixth position, they must collect all the previous cards and their played card becomes the new first card on the tableau.\n\n**Game End**: There are two ways to end the game, chosen by players: either when all cards from players' hands have been played, or when a player reaches 66 bull heads.\n\n## Card Quantities\nIf there are fewer than 10 players, reduce the deck size by 20 cards for every 4 fewer players. For 7-10 players, use cards 1-104; for 3-6 players, use cards 1-84; for 2 players, use cards 1-64.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the basic card game structure properly implemented?",
+      "description": "Assess whether the code correctly implements the 'Who is the Bull King' game structure with proper card distribution (104 cards with bull heads) and dynamic deck sizing based on player count. Check if the code properly assigns bull head values to each card and handles the initial tableau setup with 4 face-up cards. Score 0 if the card system is missing, 5 if cards are implemented but have incorrect bull head assignments, and 10 if the full card system with proper scaling for player count is implemented correctly.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the card placement logic implemented according to the rules?",
+      "description": "Evaluate whether the code correctly implements the specific card placement order rules: placing cards closest in value to the last tableau card, handling equal-distance cases by prioritizing smaller cards, and following the described placement hierarchy. Deduct 5 points if the placement logic doesn't handle edge cases (like equal distances), 3 points if the ordering is incorrect, and 5 points if the placement hierarchy is missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the card collection mechanism correctly implemented?",
+      "description": "Check if the code properly enforces the rule where players must collect all cards when placing a card smaller than the last tableau card or when placing a sixth card. Verify that collected cards are properly accounted for in bull head scoring and that the played card correctly becomes the new first card in the tableau. Deduct 5 points if collection rules are partially implemented, and 10 points if completely missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are the game end conditions properly implemented?",
+      "description": "Verify that the code implements both game-ending conditions: either when all cards from players' hands have been played, or when a player reaches 66 bull heads. Check whether the code allows players to choose between these options at game setup. Deduct 5 points if only one ending condition is implemented, and 3 points if the player choice mechanism is missing. 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 out-of-bounds input, network interruption, user operation errors, 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. Card animation effects during placement 2. Historical statistics tracking for players 3. Interactive tutorials for new players). 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 card selection logics coexisting) 2. Function modules unrelated to the Bull King game (e.g., a built-in mini-game) 3. Fancy effects that affect performance (e.g., excessive card 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 (such as separating game logic/view/network 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 for card selection and placement. Deduct 5 points for each operation without feedback, 3 points for visual after-images during card movement, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "hard"
+}

package/library/game_development-strategy/card-battle-game-hearthstone-like.json

@@ -0,0 +1,68 @@
+{
+  "index": 874,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Make sure the generated code is executable for demonstration. Create a card battle game similar to Hearthstone with the following requirements: players can interact, AI acts automatically, both sides start with non-duplicate card decks, and card deck generation is random. Write a complete code that can be run directly.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core card battle system fully implemented?",
+      "description": "Review whether the code implements the essential card game mechanics including card drawing, mana management, play/attack phases, turn system, and win/loss conditions. Score 0 if core mechanics are missing, 5 points if basic card play is implemented but lacking depth, 10 points if the system resembles Hearthstone's comprehensive battle mechanics including effects like taunt, charge, etc.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the deck generation and card variety implemented properly?",
+      "description": "Check whether the code correctly creates non-duplicate randomized card decks for players as specified. Examine if there's sufficient card variety (at least 15 different card types with varied attributes/effects). Deduct 5 points if randomization is weak or predictable, 3 points if card variety is limited, and 5 points if deck constraints are not properly enforced. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the player interaction system properly implemented?",
+      "description": "Evaluate the quality of player interaction mechanisms. Check if players can select cards, target opponents, use hero powers, and make strategic decisions. Verify that the UI clearly shows valid targets and actions. Deduct 5 points if interaction fails in edge cases (e.g., when no valid targets exist), 3 points if feedback is unclear, and 5 points if core interaction features are missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the AI opponent implementation robust?",
+      "description": "Assess the AI's decision-making process. Verify that the AI can make reasonable moves, target selection, and adapt to the game state. Test if the AI avoids obvious mistakes and presents a challenge. Deduct 5 points if the AI makes consistently poor decisions, 3 points if it's too predictable, and 5 points if it freezes or errors in unusual game states. 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 card plays, out-of-mana attempts, targeting errors, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Dynamic card effects or animations 2. Deck builder/editor functionality 3. Game history recording 4. Card rarity system with visual indicators). 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 calculate damage) 2. Function modules unrelated to card battles (e.g., an unnecessary avatar customization system) 3. Fancy effects that affect performance (e.g., excessive particle effects during card play). 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/controllers), proper class inheritance for cards with similar effects, and maintainable architecture. 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 code lacks comments or documentation. 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) Clear representation of game state (health, mana, cards in hand/deck) 2) Proper layout with cards clearly visible and organized 3) Visual distinction between playable and non-playable cards. Deduct 3 points for cluttered UI elements, 5 points for poor visibility of critical game information, and 5 points for confusing card state indicators. 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 card game expectations: 1) Card animations when drawing/playing cards 2) Visual feedback for attacks and damage 3) Clear indications of turn phases and available actions. Deduct 5 points for each interaction without feedback, 3 points for jarring or disruptive animations, and 5 points for unclear turn or phase transitions. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "medium"
+}