@getollie/cli 0.0.1

package/library/game_development-strategy/programming-for-a-game-of-fight-the-landlord.json

@@ -0,0 +1,68 @@
+{
+  "index": 1571,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code for demonstration purposes. Create the programming for a game of \"Fight the Landlord\" (Chinese poker).",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core card game logic fully implemented?",
+      "description": "Review whether the code accurately implements the 'Fight the Landlord' card rules, including proper card representation, card combinations validation (singles, pairs, triples, straights, etc.), and winning condition detection. Score 0 if core game mechanics are missing, 5 if basic card play is implemented but with rule gaps, and 10 if all game rules are complete and accurate.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the player roles and bidding phase properly handled?",
+      "description": "Evaluate the implementation of the landlord selection process, including bidding mechanism, role assignment (landlord vs farmers), and the proper handling of the three extra cards for the landlord. Deduct 5 points if bidding is not implemented, 3 points if the role assignment is incomplete, and 2 points if the extra cards mechanism is incorrect. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the turn-based gameplay properly implemented?",
+      "description": "Check whether the code enforces correct turn order, validates if a player's move is legal based on previous plays (card combinations must beat previous plays or start a new combination), and properly handles passing. Deduct 5 points for incorrect turn management, 3 points for faulty play validation logic, and 2 points for improper pass handling. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a complete AI opponent implementation?",
+      "description": "Assess whether computer players can make strategic decisions based on card combinations in their hands, understand the game state, and execute competitive play strategies. Basic AI should at least play valid cards; intermediate AI should recognize optimal plays; advanced AI should employ strategic thinking. Score 3 for basic, 7 for intermediate, and 10 for advanced AI implementation.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid card selections, incorrect turn operations, edge case card combinations) 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 combination suggestion system 2. Game history recording with replay 3. Dynamic difficulty adjustment for AI 4. Multiplayer online capabilities). 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 validation systems) 2. Function modules unrelated to the card game (e.g., unrelated mini-games) 3. Fancy effects that affect performance (e.g., excessive animations that slow 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/player input 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 card visualization (clear suit and rank display, intuitive selection mechanism). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for unclear card representation. 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) Card selection feedback delay ≤ 100ms 2) Card dealing and movement animations controlled between 300-500ms 3) Clear visual indication of whose turn it is and what cards were played last. Deduct 5 points for each operation without feedback, 3 points for choppy card animations, and 5 points for unclear turn indicators. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "hard"
+}

package/library/game_development-strategy/python-chinese-chess-xiangqi-visualization.json

@@ -0,0 +1,68 @@
+{
+  "index": 1573,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure the generated code is executable for demonstration. Create a visualization of Chinese chess (Xiangqi) using Python language.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Chinese chess (Xiangqi) board correctly implemented?",
+      "description": "Verify if the code correctly implements the 9x10 board with river in the middle, palace areas, and proper piece starting positions according to official Xiangqi rules. Check if the coordinate system is properly established. Score 0 if the board is incorrectly structured, 5 if basic structure is present but with minor inaccuracies, and 10 if perfectly implemented with proper board markings and proportions.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are all Chinese chess pieces properly represented with correct movement rules?",
+      "description": "Evaluate if all 7 types of pieces (General, Advisor, Elephant, Horse, Chariot, Cannon, and Soldier) are implemented with their correct movement patterns and restrictions. Each piece should follow Chinese chess rules, including the river crossing rules for soldiers and palace confinement for generals and advisors. Deduct 1.5 points for each piece type with incorrect movement rules. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the game logic fully implemented with proper turn-taking and victory conditions?",
+      "description": "Review if the code includes complete game rules including turn alternation, check detection, checkmate detection, and stalemate scenarios. Check if special rules like the 'flying general' illegal move and perpetual check restrictions are handled. Score 0 if basic game flow is missing, 5 if only simple turn-taking is implemented without check/checkmate detection, and 10 if all official Xiangqi rules are properly enforced.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the visualization clear, culturally appropriate and interactive?",
+      "description": "Assess if the visualization uses traditional Chinese chess piece representations (either Chinese characters or symbolic representations), appropriate colors (traditionally red vs. black), and allows for clear piece differentiation. Check if the user can interact with the board through intuitive mouse or keyboard commands. Deduct 3 points if pieces are difficult to distinguish, 3 points if interaction is unintuitive, and 4 points if the visual style doesn't reflect Chinese chess traditions.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as illegal moves, improper input, out-of-bounds selections, 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. Move suggestions 2. Game recording and replay functionality 3. Different visual themes 4. AI opponent with difficulty levels). 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 select pieces) 2. Function modules unrelated to Chinese chess (e.g., unnecessary animations) 3. Overly complex code that could be simplified. 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 from visualization), code organization, documentation, and maintainability. Assess if proper Python conventions are followed, including naming conventions, docstrings, and type hints. Deduct 5 points if global state pollution is found; deduct 3 points if the code lacks comments/documentation; deduct 3 points if the code has poor organization with no clear separation of concerns. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the visualization follows good design principles: 1) Consistent visual style 2) Proper contrast between pieces and board 3) Clear indication of selected pieces and valid moves 4) Appropriate board proportions. Deduct 3 points for poor color contrast making pieces hard to read, 3 points for inconsistent styling, and 4 points for cluttered or confusing layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and responsive?",
+      "description": "Judge whether the program performs efficiently and responds quickly: 1) Piece movement is smooth with appropriate visual feedback 2) Selection/deselection actions are responsive 3) The game maintains consistent performance throughout gameplay. Deduct 3 points for laggy animations, 3 points for delayed response to user input, and 4 points for performance degradation during prolonged play. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "hard"
+}

package/library/game_development-strategy/random-level-generation-html-javascript.json

@@ -0,0 +1,68 @@
+{
+  "index": 193,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the code you generate is executable.\nPlease use HTML and JavaScript to implement randomly generated levels.\n\n**Task**: Implement a simple random level generation feature that creates different level layouts each time the game starts.\n\n**Hint**: You can use a random number generator and predefined level modules to dynamically create levels.\n\nInclude comments in your code so that other developers can understand your implementation process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the random level generation algorithm correctly implemented?",
+      "description": "Review whether the code implements effective random level generation logic through HTML/JavaScript, including proper random number generation, level layout algorithms (such as procedural generation, template-based generation, or rule-based generation), and ensures each generated level is playable and balanced. Score 0 if no random generation is implemented, 5 if only basic random placement is implemented, and 10 if a sophisticated generation algorithm with validation is fully included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are predefined level modules and templates properly designed?",
+      "description": "Check whether the implementation includes well-structured predefined level components, templates, or building blocks that can be combined randomly. Evaluate if the modular system supports scalability and variation. The system should include different types of level elements (obstacles, paths, collectibles, etc.) and rules for their combination. Deduct 5 points if modules are too simple or limited, and 3 points if combination rules are poorly defined. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is level validation and playability assurance implemented?",
+      "description": "Evaluate whether the random generation includes validation mechanisms to ensure generated levels are completable and balanced. This should include path-finding validation, difficulty balancing, and rejection of impossible or trivial layouts. Check if the system can regenerate levels that fail validation. Deduct 5 points if no validation exists, 3 points if validation is incomplete. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the level generation system flexible and configurable?",
+      "description": "Check whether the code provides configurable parameters for level generation (such as difficulty settings, size parameters, density controls, theme variations). Evaluate if the system supports different generation modes or styles. The implementation should allow easy modification of generation parameters without code changes. Deduct 5 points if the system is hardcoded with no flexibility, and 3 points if configuration options are limited. Give 10 points if fully configurable.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid random seeds, generation failures, memory constraints, infinite loops in generation algorithms, 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. Biome-based generation with smooth transitions 2. Procedural narrative elements 3. Adaptive difficulty based on player performance 4. Level sharing via seed codes 5. Real-time generation preview). 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 generation functions (e.g., multiple random algorithms doing the same thing) 2. Function modules unrelated to level generation (e.g., built-in music player, unnecessary animations) 3. Overly complex generation that affects performance (e.g., generating too much detail that isn't used). Deduct 3 points for each redundancy found, and directly deduct 10 points if core generation 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 generation logic/rendering/data structures), code documentation quality, and proper commenting as specified in requirements. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if comments are insufficient or unclear for other developers to understand. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the level visualization follows modern design principles: 1) Harmonious color matching for different level elements (no more than 3 primary colors per theme) 2) Proper visual hierarchy and spacing (element spacing follows the 8px multiple principle) 3) Clear visual distinction between different level components 4) Professional rendering quality. Deduct 3 points for each visually confusing element, 5 points for poor color combinations that make gameplay difficult, and 5 points for chaotic visual layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the level generation and rendering performance optimized?",
+      "description": "Judge whether the generation and display performance meets user expectations: 1) Level generation time ≤ 2 seconds for complex levels 2) Smooth rendering without frame drops during generation 3) Efficient memory usage without leaks 4) Responsive UI during generation process. Deduct 5 points for each generation that takes too long, 3 points for visible performance issues during rendering, and 5 points for unresponsive interface during generation. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "easy"
+}

package/library/game_development-strategy/recurrent-neural-network-rock-paper-scissors-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 161,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Game Rules\n- **Choose a Gesture**: Select rock, paper, or scissors by clicking the buttons.\n- **Machine Learning Opponent**: The computer uses a recurrent neural network to predict and react to the player's moves.\n\n### Game Features\n- **AI Technology**: Neural network implemented using the `brain.js` library.\n- **Real-time Learning**: The AI learns and adapts in real-time based on the player's choices.\n\n### Game Tips\n- **Vary Your Strategy**: Frequently change your move patterns to increase the difficulty for AI prediction.\n- **Observe AI Patterns**: Pay attention to the AI's move tendencies and adjust your strategy accordingly.\n\n### Summary\n\"Recurrent Neural Network - Rock, Paper, Scissors\" is an interactive experience that uses neural network technology to simulate the rock, paper, scissors game. Players compete against a computer based on machine learning algorithms, predicting and making moves. This game demonstrates the application of artificial intelligence in gaming, providing a novel experience of competing against AI.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the RNN implementation for the AI opponent correctly implemented?",
+      "description": "Check whether the code correctly implements a recurrent neural network using brain.js library. Verify that the network architecture is appropriate for sequence prediction (has memory cells, proper input/output dimensions, and appropriate activation functions). Score 0 if there's no neural network implementation, 5 if a basic neural network exists but lacks recurrent connections, and 10 if a proper RNN is implemented with appropriate parameters.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Does the game implement real-time learning capabilities?",
+      "description": "Evaluate whether the AI can learn from player's moves in real-time. Check for: 1) Move history tracking mechanism 2) Periodic retraining of the network with new data 3) Clear evidence that AI predictions change based on player's patterns. Deduct 5 points if learning only happens at game restart, 3 points if the learning rate is too low to notice adaptation. Full score requires demonstrating that the AI improves predictions after recognizing patterns.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the rock-paper-scissors game logic correctly implemented?",
+      "description": "Review the core game logic implementation, including win determination, score tracking, and game state management. Check that rock beats scissors, scissors beats paper, and paper beats rock. Verify that ties are correctly identified. Deduct 5 points if any rule is implemented incorrectly, 3 points if edge cases (like simultaneous moves) aren't handled properly. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the interface provide meaningful feedback on the AI's learning process?",
+      "description": "Assess whether the interface shows the player how the AI is learning and adapting. Check for: 1) Visualization of AI confidence levels 2) Pattern recognition indicators 3) Prediction probability display. Deduct 3 points for each missing feedback element that would help the player understand the AI's decision-making process. Full score requires clear visualization of how the AI is adapting to the player's strategy.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as unexpected inputs, connection issues with brain.js library, 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 experience (e.g., 1. Visualization of neural network structure 2. Pattern analysis of player's moves 3. Difficulty levels that adjust the AI's learning rate). 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 prediction algorithms running simultaneously) 2. Function modules unrelated to the rock-paper-scissors game (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive animations that slow down AI response). 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/AI logic layers), code organization, and optimization for browser performance. 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 error handling for the brain.js library integration. 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 when making selections. Deduct 5 points for each operation without feedback, 3 points for visual stuttering during animations, and 5 points if the game controls are not intuitive. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "hard"
+}

package/library/game_development-strategy/resource-management-game-with-building-upgrades.json

@@ -0,0 +1,68 @@
+{
+  "index": 179,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate, professional responses. Be sure to ensure that the generated code is executable for demonstration.\n\nPlease use HTML and JavaScript to implement a resource management game where **Task**: Design a resource management system in which players need to collect and manage resources to build and upgrade buildings. **Hint**: Set up resource points where players can gather or trade resources, and use these resources for construction or upgrades.\n\nInclude comments in your code so that other developers can understand your implementation process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the resource collection system fully implemented?",
+      "description": "Review whether the code accurately implements resource gathering mechanics (clicking on resource points, automatic collection over time, etc.) and resource storage/inventory system. Score 0 if resource collection is not implemented, 5 if only basic collection is implemented without variety, and 10 if the system includes multiple resource types with different collection methods and rates.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the building construction and upgrade system functional?",
+      "description": "Evaluate if the code includes a complete building system with construction prerequisites, resource costs, construction time, and meaningful upgrades. Check if buildings have different tiers/levels and if upgrades provide tangible benefits. Deduct 5 points if buildings don't have multiple upgrade levels, and 3 points if upgrades don't affect gameplay. Give 10 points for a comprehensive system with meaningful progression.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the resource trading or economy system implemented?",
+      "description": "Check if there's a mechanism for trading resources (market, exchange rates, NPC traders) or some form of economic gameplay. Evaluate whether the economy is balanced with appropriate resource values and exchange rates. Deduct 5 points if trading is one-dimensional, and 3 points if there's no price fluctuation or strategic depth. Full score for a dynamic economy with meaningful player decisions.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a complete game progression and goal system?",
+      "description": "Assess whether the game has clear objectives, progression milestones, and win conditions (or endless play with increasing challenges). Check for tutorial elements, achievement systems, or quest/mission structure. Deduct 5 points if the game lacks direction, and 3 points if progression is linear with no strategic choices. Give 10 points for well-defined goals with multiple paths to success.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid resource counts, impossible building placements, race conditions in resource gathering, 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 resource visualization 2. Weather/season effects on resource generation 3. Interactive tutorial system). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple resource collection logics coexisting) 2. Function modules unrelated to resource management (e.g., a built-in unrelated mini-game) 3. Fancy effects that affect performance (e.g., excessive particle animations for simple actions). 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/resource management layers), code organization, and proper use of JavaScript patterns. 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 insufficient code commenting as requested in the requirements. 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 that represents different resources distinctly 2) Proper layout spacing between resource counters, buildings, and action buttons 3) Clear visual hierarchy highlighting important game elements. Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic resource/building displays. 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) Resource collection feedback is immediate (≤ 100ms) 2) Building construction/upgrade animations have appropriate duration 3) Resource counters update smoothly rather than jumping. Deduct 5 points for each operation without feedback, 3 points for laggy animations during resource transactions, and 5 points for unintuitive building placement controls. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "easy"
+}

package/library/game_development-strategy/robot-war-game-with-ai-battle.json

@@ -0,0 +1,68 @@
+{
+  "index": 153,
+  "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.\n\nPlease use HTML and JavaScript to implement a Robot War game where players control robots to battle. Requirements: Implement robot AI and battle system.\n\nPlease include comments in your code to help other developers understand your implementation process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core robot battle system fully implemented?",
+      "description": "Check if the code implements a complete battle system including robot movement mechanics, attack capabilities, collision detection, and damage calculation. Score 0 if core battle logic is missing, 5 points if only basic combat mechanics are implemented, and 10 points if the system includes advanced features like different attack types, defensive mechanisms, and battle physics.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the robot AI system properly developed?",
+      "description": "Evaluate the quality of the AI implementation. Check for different AI difficulty levels, decision-making algorithms, pathfinding capabilities, and strategic behaviors. Score 0 if AI is non-existent, 5 points for basic AI that can perform simple actions, and 10 points for sophisticated AI with adaptive behavior, multiple strategies, and different personality types.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the game UI/UX well-designed?",
+      "description": "Assess the interface design of the robot war game. Check for intuitive controls, clear battle indicators (health bars, power levels, etc.), and game status displays. Score 0 if the UI is missing essential elements, 5 points for a functional but basic UI, and 10 points for a polished interface with responsive design and clear visual feedback.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a balanced game progression system?",
+      "description": "Examine if the game includes features like robot upgrades, skill progression, or battle difficulty scaling. Score 0 if progression elements are absent, 5 points if basic progression exists (like simple leveling), and 10 points for a comprehensive system with multiple upgrade paths, unlockable content, and balanced difficulty progression.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid user inputs, browser variations, performance issues on different devices). 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. Custom robot builders 2. Environment interactions that affect battles 3. Multiplayer capabilities 4. Spectator mode with battle replays). 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 different damage calculation systems) 2. Function modules unrelated to the robot war gameplay 3. Fancy effects that affect performance (e.g., excessive particle effects that slow down gameplay). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game logic/rendering/input handling), code organization, maintainability, and use of appropriate design patterns. Check that comments are comprehensive and helpful. Deduct 5 points if global state pollution is found; deduct 5 points if the code duplication rate is high; deduct 5 points if comments are missing or unhelpful. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern game UI principles: 1) Consistent visual theme appropriate for a robot battle game 2) Proper layout with clear battle arena boundaries and UI elements 3) Appropriate use of color for game state indication (health, energy, etc.). Deduct 3 points for each crowded visual element, 5 points for a visually confusing interface, and 5 points for poor readability during gameplay. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the game animations and interactions feel responsive: 1) Robot movements and attacks have appropriate visual feedback 2) Frame rate remains stable during intense battle sequences 3) Game controls are responsive (≤100ms reaction time). Deduct 5 points for laggy animations, 3 points for inconsistent game speed, and 5 points for unresponsive controls. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "medium"
+}

package/library/game_development-strategy/sanguosha-like-card-game-implementation.json

@@ -0,0 +1,68 @@
+{
+  "index": 1127,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code whenever possible. Write a game code where the gameplay is similar to the card game \"Legend of the Three Kingdoms\" (Sanguosha).",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core card game system fully implemented?",
+      "description": "Review whether the code accurately implements the fundamental mechanics of Sanguosha, including proper card definitions (Basic, Strategy, Equipment), character abilities, and the turn-based gameplay flow. Score 0 if core mechanisms are missing, 5 if only basic card interactions are implemented, and 10 if special character abilities and complex card interactions (like chain reactions) are included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the phase-based turn mechanics correctly implemented?",
+      "description": "Check if the code properly implements Sanguosha's distinct turn phases (Draw, Play, Discard), with phase-specific validations and event triggers. Verify that abilities that activate in specific phases function correctly. Deduct 3 points if phase transitions lack proper event handling, 5 points if certain phases are missing or incorrectly implemented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the health and damage system appropriately designed?",
+      "description": "Evaluate if the health system correctly handles damage allocation, armor effects, character-specific health values, and dying/elimination conditions. Check for proper implementation of Wine effects on damage, Peach healing, and special abilities that alter damage (like Zhang Fei's). Deduct 5 points if wine/peach effects are missing, and 3 points if character-specific health modifications aren't handled. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the game handle character abilities and card effects correctly?",
+      "description": "Assess whether the code implements distinct character abilities (passive and active) and handles special card effects with proper timing triggers. Check for implementation of key cards like Duel, Barbarian Invasion, etc. Deduct 5 points if abilities lack proper activation conditions, and 3 points if card resolving order isn't handled correctly. Full score is 10 points for comprehensive implementation.",
+      "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. AI opponents with different difficulty levels 2. Customizable card decks and house rules 3. Animation and sound effects for critical actions). 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 damage calculation systems coexisting) 2. Function modules unrelated to Sanguosha (e.g., a built-in currency system) 3. Fancy effects that affect performance (e.g., excessive particle effects). 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), 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 reflecting the Three Kingdoms theme 2) Proper layout spacing for cards, characters, and action buttons 3) Professional font system with readable card text and clear status indicators. Deduct 3 points for each cluttered game element, 5 points for poor thematic design integration, and 5 points for illegible card information. 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) Card selection and targeting response ≤ 100ms 2) Card animation duration controlled between 300-500ms 3) Clear visual indicators for game state and available actions. Deduct 5 points for each operation without feedback, 3 points for laggy card movements, and 5 points for unclear turn progression indicators. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "hard"
+}

package/library/game_development-strategy/sichuan-mahjong-mini-game-rules.json

@@ -0,0 +1,68 @@
+{
+  "index": 366,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the code you generate is executable for demonstration. Please use HTML code to help me create a Sichuan Mahjong mini-game. The game should include rules for \"chi\" (eating), \"peng\" (claiming), and \"gang\" (kong). Make it visually appealing and provide the complete code.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Core Mahjong Game Mechanics Implementation",
+      "description": "Evaluate whether the code accurately implements the core mechanics of Sichuan Mahjong including tile representation, distribution, and gameplay rules.Score 0 if basic tile representation is missing, 5 points if basic gameplay is implemented but with incomplete rules, 10 points if the code fully implements all Sichuan Mahjong rules including correct tile sets (characters, dots, bamboos, dragons, winds), proper shuffling, wall building, and drawing mechanisms.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "'Chi', 'Peng', and 'Gang' Action Implementation",
+      "description": "Check if the special Mahjong actions are correctly implemented with proper validation logic.Deduct 3 points if any of the three actions (chi, peng, gang) is missing; deduct 2 points if the validation logic for these actions is incorrect; deduct 2 points if the concealed kong (an gang) vs. exposed kong (ming gang) distinction is not implemented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Hand Evaluation and Scoring System",
+      "description": "Assess whether the code implements a proper Sichuan Mahjong scoring system with pattern recognition.Score 0 if there's no winning condition checking, 5 points if basic winning combinations are implemented but without proper point calculation, 10 points if the code fully implements Sichuan Mahjong's unique scoring patterns, fan (doubles) calculation, and accurate point distribution among players.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Game Flow and Turn Management",
+      "description": "Evaluate whether the game properly manages player turns, action priorities, and the overall game flow.Score 0 if turn management is not implemented, 5 points if basic turns exist but without proper action priorities (e.g., peng/gang taking precedence over drawing), 10 points if the code correctly implements the complete Mahjong turn cycle including proper timing windows for claiming discarded tiles and managing interruptions to the normal flow.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid moves, illegal actions, 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. Interactive tutorials for beginners 2. Game history replay 3. AI opponents with different difficulty levels 4. Custom tile themes).Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to calculate the same score) 2. Function modules unrelated to Sichuan Mahjong (e.g., a built-in unrelated mini-game) 3. Fancy effects that affect performance (e.g., excessive animations when revealing tiles).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 between game logic and presentation. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the visual design effectively represents Mahjong tiles with appropriate Chinese styling while maintaining modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (clear differentiation between players' hands, discards, and game information) 3) Professional font system (clear character rendering, especially for Chinese characters).Deduct 3 points for poorly rendered tiles, 5 points for a glaring color combination, and 5 points for chaotic layout that makes it difficult to understand the game state. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the game interactions feel natural and responsive: 1) Clear visual indication of available actions (chi/peng/gang/hu) 2) Smooth animations when tiles are moved or revealed 3) Intuitive UI for selecting tiles and performing actions.Deduct 5 points for operations without feedback, 3 points for sluggish animations, and 5 points for confusing UI that makes it difficult to understand available actions. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "hard"
+}