@getollie/cli 0.0.1

package/library/game_development-strategy/deepseek-chinese-sentence-game-creation.json

@@ -0,0 +1,68 @@
+{
+  "index": 1726,
+  "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. You are a teacher of Chinese as a foreign language, and you are using Deepseek to create a sentence-building game page. By providing magic instructions, Deepseek gives you the corresponding code. Please narrate this complete process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the sentence-building game core mechanism fully implemented?",
+      "description": "Review whether the code accurately implements the sentence-building mechanics, including word selection, sentence formation validation, and grammar checking. Score 0 if the core game logic is missing, 5 if only basic word selection is implemented, and 10 if it includes comprehensive grammar validation with feedback for learners of Chinese as a foreign language.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the Chinese language learning pedagogical elements incorporated?",
+      "description": "Evaluate whether the implementation includes essential pedagogical elements for teaching Chinese: character/pinyin display options, difficulty levels based on HSK standards, and contextual learning hints. Deduct 5 points if there's no progression system, 3 points if linguistic explanations are missing, and 3 points if there's no visual reinforcement of character learning. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the user input and feedback system properly designed?",
+      "description": "Check whether the code implements appropriate input methods for Chinese characters (pinyin input, character selection), error correction mechanisms, and positive reinforcement feedback. Deduct 5 points for lack of immediate feedback, 3 points for missing visual/audio reinforcement, and 5 points if there's no progress tracking for learners. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are gamification elements implemented to enhance language learning?",
+      "description": "Assess whether the code incorporates gamification elements such as scoring systems, achievement badges, timed challenges, or multiplayer competition options that specifically reinforce Chinese language learning objectives. Score 0 for no gamification, 5 for basic points/levels, and 10 for comprehensive, pedagogically-sound gamification elements.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid character inputs, incorrect sentence structures, network interruption, 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 language learning experience (e.g., 1. Animated character stroke order demonstrations 2. Cultural context explanations with visuals 3. Voice recognition for pronunciation practice). 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 input the same character type) 2. Function modules unrelated to language learning (e.g., a built-in calculator) 3. Fancy effects that affect performance (e.g., excessive animations when displaying characters). 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), 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) 4) Clear visual hierarchy for Chinese characters vs. explanatory text. 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 4) Smooth character rendering and transitions. Deduct 5 points for each operation without feedback, 3 points for visual after-images during fast sliding, 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/dou-dizhu-card-game-html.json

@@ -0,0 +1,68 @@
+{
+  "index": 1554,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and expert responses. Make sure the generated code is executable whenever possible. Help me create a Dou Dizhu (Fighting the Landlord) card game using HTML, with all code saved in a single HTML file.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core Dou Dizhu game logic fully implemented?",
+      "description": "Review whether the code accurately implements the card distribution system, the landlord bidding process, and all valid card combination rules (singles, pairs, three-of-a-kind, straights, etc.). Score 0 if the core game logic is missing, 5 if only basic card play is implemented without complete rule validation, and 10 if all official Dou Dizhu rules are fully implemented with proper validation of moves.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the card dealing and turn-based gameplay well implemented?",
+      "description": "Evaluate whether the code includes proper card shuffling algorithm (Fisher-Yates or equivalent), correct 17-17-17 card distribution with 3 landlord cards, and proper turn-based gameplay that follows clockwise rotation. Check if pass/play mechanics work correctly. Deduct 3 points if card dealing is not random, 3 points if turn rotation is flawed, and 4 points if the landlord bidding process is missing or incorrect. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are all card combinations and game rules properly implemented?",
+      "description": "Check if the code implements all valid card combinations (singles, pairs, three-of-a-kind with/without attachments, straights, bomb, rocket) and their relative strengths. Verify that the system correctly prevents invalid plays and enforces the 'must beat previous play' rule. Deduct 2 points for each missing combination type, 3 points if strength comparison is flawed, and 5 points if play validation is inconsistent. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the winning condition and score calculation properly implemented?",
+      "description": "Assess whether the game correctly identifies the winner when a player uses all their cards, calculates the base points and multipliers (rockets, bombs, spring, etc.), and handles game-ending scenarios. Check for proper display of results and option to start a new game. Deduct 3 points if winner detection is flawed, 4 points if score calculation is incomplete, and 3 points if the game restart 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 edge cases (e.g., improper card selections, out-of-turn plays, UI edge cases) and provides friendly error messages. Check for input validation, state management during transitions, and prevention of race conditions. Deduct 2 points for each unhandled edge case, 3 points for missing error handling, and 5 points if the game can easily break. The full score is 10 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 suggestion helper 2. Game history tracking 3. Animation effects for special card combinations 4. Sound effects for card plays). Add 2.5 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 methods that could be combined) 2. Function modules unrelated to Dou Dizhu (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 the code structure (separating game logic/UI/event handling), variable naming conventions, and overall organization. Check if the single HTML file is well-structured with clear separation of HTML, CSS, and JavaScript. Deduct 3 points for global variable abuse, 3 points for poor function organization, 2 points for inconsistent naming conventions, and 2 points for excessive code duplication. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the card game interface meet professional design standards?",
+      "description": "Evaluate whether the card design and layout follows good principles: 1) Clear card representation with easy-to-recognize suits and values 2) Proper hand display with overlapping cards at appropriate spacing 3) Distinct visual cues for active player, landlord, and played cards. Deduct 3 points for unclear card visualization, 3 points for cluttered layout, 2 points for poor color choices, and 2 points for insufficient player status indicators. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the game interaction smooth and intuitive?",
+      "description": "Judge whether the interaction design is player-friendly: 1) Card selection with clear visual feedback 2) Obvious buttons for actions (play, pass, etc.) 3) Clear indications of valid/invalid card combinations. Deduct 3 points for confusing card selection mechanics, 3 points for unclear turn indicators, 2 points for slow response time, and 2 points if common actions require excessive clicks. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "hard"
+}

package/library/game_development-strategy/economic-dev-tech-tree-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 77,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable when possible.\n\nPlease implement a strategy game: Economic Development and Technology Tree using HTML and JavaScript.\n\n**Task**: Design an economic development system where players can develop their economy and research technologies to unlock higher-level units and buildings.\n\n**Hint**: You can use a tech tree to manage the research order of technologies and allow players to freely choose their development direction.\n\nPlease include comments in your code to help other developers understand your implementation process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the economic development system fully implemented?",
+      "description": "Review whether the code accurately implements resource management (collection, storage, consumption), population management, and building construction mechanics through HTML/JavaScript. Check if there are clear economic progression paths with appropriate resource generation rates and balancing mechanisms. Score 0 if the core economic system is missing, 5 if only basic resource collection is implemented, and 10 if there's a complete economic simulation with multiple interdependent resources and feedback loops.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the technology tree research system properly implemented?",
+      "description": "Evaluate whether the technology tree has clear progression paths, prerequisite relationships, and meaningful choices for players. Check if the implementation includes proper visualization of the tech tree, tooltips showing requirements and benefits, and proper unlocking mechanics. Score 0 if there's no tech tree, 5 if there's a basic linear progression system, and 10 if there's a complex branching tech tree with multiple viable research strategies and clear visual representation.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the higher-level units and buildings properly integrated with the tech tree?",
+      "description": "Check if unlocked technologies meaningfully affect gameplay by enabling new units, buildings, or capabilities. Verify that unlocks are properly tied to research completion events and that the player receives clear feedback when new options become available. Deduct 5 points if unlocks don't change gameplay substantially, and 3 points if the connection between research and unlocks isn't clearly communicated to the player. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the player choice and strategic direction-setting implemented?",
+      "description": "Assess whether players can meaningfully choose different development paths with distinct advantages and tradeoffs. Check for branching decisions in both economic and technological progression that lead to different gameplay experiences or victory conditions. Deduct 5 points if choices are mostly cosmetic without gameplay impact, and 3 points if there's only one optimal strategy. Give 10 points for multiple viable strategies with distinct strengths and weaknesses.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid inputs, resource shortages, attempting to research unavailable technologies, 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 market system with fluctuating prices 2. Random events affecting economy 3. Diplomatic interactions with AI factions). 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) 2. Function modules unrelated to economic/tech development (e.g., a built-in weather simulator) 3. Fancy effects that affect performance (e.g., excessive particle animations for basic 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 state/view/controller layers), code organization, and appropriate design patterns. Check if the code includes comprehensive comments as requested in the requirements. Deduct 5 points if global state pollution is found; deduct 5 points if the code duplication rate is too high (over 30%); deduct 3 points if comments are missing or insufficient. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Clear visual hierarchy between resources, buildings, and tech tree elements. Deduct 3 points for cluttered UI elements, 5 points for poor color combinations that hinder readability, and 5 points for confusing information architecture. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and appropriate for a strategy game?",
+      "description": "Judge whether the interaction design is appropriate for a strategy game: 1) Clear visual feedback for resource transactions and tech research 2) Tooltips or information panels for complex game elements 3) Appropriate pacing for economic development (neither too slow nor unrealistically fast). Deduct 5 points for unclear action feedback, 3 points for hidden critical information, and 5 points for confusing navigation between different game views. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "easy"
+}

package/library/game_development-strategy/enemy-ai-track-attack-pathfinding.json

@@ -0,0 +1,68 @@
+{
+  "index": 19,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the generated code is executable for demonstration.\nPlease use HTML and JavaScript to implement an Enemy AI\n**Task**: Write simple AI logic for enemies in a game, enabling them to automatically track and attack players.\n**Hint**: You can use simple pathfinding algorithms to implement enemy movement and attack behaviors.\ngame, and add some comments in the code so other developers can understand your implementation process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the enemy AI movement and pathfinding system properly implemented?",
+      "description": "Review whether the code implements effective pathfinding algorithms (A*, Dijkstra's, etc.) or simpler movement patterns (direct pursuit, flocking). Check if enemies can navigate around obstacles and avoid getting stuck in corners. Score 0 if movement is non-functional, 5 if basic direct pursuit is implemented, and 10 if sophisticated pathfinding with obstacle avoidance is included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the enemy detection and player tracking mechanism implemented?",
+      "description": "Evaluate whether enemies can detect the player through vision cones, proximity detection, or other sensory systems. Check if the detection includes different states (unaware, suspicious, alerted). Verify if line-of-sight checks are implemented to prevent enemies from seeing through walls. Deduct 3 points if detection is binary (only sees/doesn't see), and 5 points if there's no line-of-sight verification. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the attack behavior and combat system implemented?",
+      "description": "Check if enemies have different attack patterns based on distance, cooldowns for attacks, and damage calculation. Ensure the attack system includes proper player feedback (visual/audio cues when being attacked). Deduct 5 points if attacks have no cooldown management, and 3 points if there's no feedback for incoming attacks. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are different AI states and transitions properly managed?",
+      "description": "Verify if the code implements a state machine or behavior tree for enemy AI (patrol, chase, attack, retreat). Check if state transitions are smooth and logical based on game conditions. Deduct 5 points if only basic states exist with no transition logic, and 3 points if transitions are abrupt with no blending. Give 10 points for a complete state management system.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as missing player reference, edge cases in pathfinding, performance spikes, etc.) and provide graceful fallbacks. 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 difficulty adjustment 2. Enemy cooperation and flanking behaviors 3. Learning from player patterns). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple pathfinding algorithms running in parallel) 2. Function modules unrelated to enemy AI (e.g., weather effects) 3. Fancy effects that affect performance (e.g., excessive particle effects for each enemy). 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 AI logic/movement/combat systems), code commenting quality and comprehensiveness, and performance optimization. Deduct 5 points if global state pollution is found; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there are insufficient comments for understanding the implementation. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the visual representation meet professional game design standards?",
+      "description": "Evaluate whether the enemy visualization follows game design principles: 1) Clear visual indication of enemy states (patrol, alert, attacking) 2) Proper animation transitions between states 3) Visual differentiation between enemy types if multiple exist. Deduct 3 points for unclear state visualization, 5 points for missing animations or transitions, and 5 points for confusing enemy representation. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the interaction between enemies and the game environment seamless?",
+      "description": "Judge whether enemies interact properly with the game environment: 1) Proper collision detection with environment objects 2) Appropriate reaction to environmental changes or events 3) Performance optimization for multiple enemies. Deduct 5 points for collision detection issues, 3 points for ignoring environmental factors, and 5 points for significant performance drops with multiple enemies. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "medium"
+}

package/library/game_development-strategy/fight-the-landlord-card-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1080,
+  "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 write a program for the card game \"Fight the Landlord\" (Dou Dizhu).",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the card game core mechanics fully implemented?",
+      "description": "Review whether the code accurately implements the 'Fight the Landlord' game rules including card ranking (3/4/5/.../Q/K/A/2/Jokers), valid combinations (singles, pairs, triplets, straights, etc.), and special hands (rockets, bombs). Score 0 if the core game logic is missing, 5 if only basic card play mechanics are implemented, and 10 if all official rules including landlord identification and bonus points are fully included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the player turn system properly implemented?",
+      "description": "Check if the code correctly handles the turn-based gameplay with 3 players (1 landlord vs 2 farmers), proper turn rotation, pass/play options, and combination validation against the previous play. Evaluate if the code prevents out-of-turn plays and handles the winning condition (first player to play all cards). Deduct 5 points if turn validation is missing, 3 points if combination comparison is flawed. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the card dealing and landlord selection process implemented?",
+      "description": "Evaluate whether the code includes random card shuffling and distribution (17 cards to each player with 3 landlord cards), bidding process for determining the landlord, and proper handling of the landlord receiving the extra cards. Check if the distribution is truly random and if the landlord selection follows standard rules. Deduct 5 points if the bidding system is missing, 3 points if the card distribution is not random. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the scoring mechanism and game state management implemented?",
+      "description": "Check whether the code tracks game points based on the standard multiplier system (base points × factors like bombs, rockets, spring, etc.), maintains game history, and handles multiple rounds. Evaluate if the code properly determines winners and calculates point transfers between players. Deduct 5 points if multipliers are not handled, 3 points if multi-round functionality 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 invalid card plays, disconnection during gameplay, repeated card 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. AI players with different difficulty levels 2. Card play suggestion feature 3. Card combination auto-sorting 4. Game replay functionality). 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 logics) 2. Function modules unrelated to the card game (e.g., a built-in chat system unrelated to gameplay) 3. Fancy effects that affect performance (e.g., excessive card 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/card management 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 suits, ranks, and special effects for landlord cards). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic card 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) Card selection feedback delay ≤ 100ms 2) Card play animations controlled between 300-500ms 3) Clear visual indication of current player turn and valid play options. Deduct 5 points for each operation without feedback, 3 points for laggy card animations during fast plays, and 5 points for unclear turn indicators. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Casual",
+  "difficulty": "hard"
+}

package/library/game_development-strategy/fight-the-landlord-chinese-poker-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1616,
+  "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. Use HTML, JS, and CSS to create 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' game rules, including card values/suits representation, deck initialization, card distribution logic, player turn management, valid play checking (singles, pairs, triples, straights, etc.), and win condition detection. Score 0 if the core game mechanics are missing, 5 if basic card playing is implemented but with rule inaccuracies, and 10 if all official rules are correctly implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the player role system (Landlord vs Farmers) properly implemented?",
+      "description": "Evaluate whether the code correctly handles the bidding phase for determining the landlord, allocates the extra cards to the landlord, implements the proper scoring system (with different points for landlord and farmers), and manages the alliance mechanics between farmers. Deduct 3 points if the bidding process is incomplete, 5 points if the landlord bonus cards aren't handled correctly, and 3 points if scoring doesn't account for bombs and rocket multipliers. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the game interface and card representation visually effective?",
+      "description": "Check whether cards are clearly represented with proper suits and values, whether the player hands are organized and easily readable, and if the played cards are distinctly displayed. Assess if player roles (landlord/farmer) are visually indicated. Deduct 3 points for unclear card representation, 3 points for disorganized hand display, and 4 points if game status information is not prominently visible. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are the AI opponents implemented with reasonable playing strategies?",
+      "description": "Evaluate whether AI players demonstrate intelligent card play decisions, including hand optimization, tactical plays against the landlord/farmers, and strategic responses to previous plays. Review if AI difficulty levels are implemented or if the AI can adapt to various game situations. Score 0 for random play AI, 5 for basic strategic play, and 10 for comprehensive opponent AI with advanced tactics and situational awareness.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid card selections, interruptions, game state inconsistencies, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle 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. Hand strength calculator 2. Game replay functionality 3. Card animation effects 4. Historical statistics tracking 5. Custom rule variations). 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 logics coexisting) 2. Function modules unrelated to the card game (e.g., unrelated mini-games) 3. Fancy effects that affect performance (e.g., excessive animations that hinder gameplay). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game logic/view/controller layers), code organization, naming conventions, 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 structure separating UI from game logic. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times) 4) Appropriate card table theme and styling. Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic card 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) Card selection/play feedback delay ≤ 100ms 2) Card dealing/moving animations controlled between 300-500ms 3) Clear visual indication of whose turn it is and valid card combinations. Deduct 5 points for each operation without feedback, 3 points for laggy card animations, and 5 points if it's unclear which card combinations are playable. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "hard"
+}

package/library/game_development-strategy/fighting-landlord-guandan-shengji-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1449,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure that the code you generate is executable for demonstration purposes. I want to create a four-player Fighting Landlord (Dou Dizhu) game that incorporates elements of Guandan and Shengji card games.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Card game rules implementation completeness",
+      "description": "Review whether the code accurately implements the core rules of Fighting Landlord with elements from Guandan and Shengji. Check for correct card distribution (17 cards for farmers, 20 for landlord), proper card ranking, valid card combinations (singles, pairs, triplets, etc.), and special rule integrations from Guandan and Shengji (like upgrading cards or bomb mechanisms). Score 0 if basic card game mechanics are missing, 5 if only Fighting Landlord rules are implemented, and 10 if all three game elements are successfully integrated.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Four-player adaptation and turn management",
+      "description": "Evaluate the adaptation of traditionally three-player Fighting Landlord to four players. Check for proper team formation (2v2 or 1v3), balanced gameplay adjustments, and smooth turn transitions. Review the bidding mechanism for landlord selection and whether the code handles proper turn order with visual indicators. Deduct 5 points if the four-player adaptation creates gameplay imbalance, and 3 points if turn management lacks clarity. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Card play validation and combination detection",
+      "description": "Assess whether the code correctly validates all possible card plays and detects valid card combinations across all three game types. Check if the system properly identifies straights, full houses, airplane combinations, bombs, and special combinations from Guandan/Shengji. Test edge cases such as joker combinations and multi-deck scenarios. Deduct 5 points if validation fails for complex combinations and 3 points if special rule validations are missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Game state management and scoring system",
+      "description": "Review the implementation of game state tracking (dealing, bidding, playing, ending phases), multi-round persistence, and the scoring system that incorporates elements from all three games. Check if the code maintains player statistics and handles game progression logically. Verify if the scoring system accounts for bombs, spring scenarios, and special combinations. Deduct 5 points if state transitions are buggy and 3 points if the scoring system doesn't reflect all game elements. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Code robustness",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as disconnections during play, invalid card selections, timeout scenarios, etc.) and provide friendly error prompts or recovery mechanisms. Test edge cases like simultaneous actions or rapid-fire inputs. 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": "Innovative features",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Dynamic difficulty AI opponents 2. Replay system with annotation 3. Custom rule configuration to balance the three game types 4. Voice commands for card play). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Feature redundancy and optimization",
+      "description": "Strictly check three types of redundancy: 1. Overlapping card validation logics that could be consolidated 2. Unnecessary features unrelated to the card games (e.g., excessive mini-games) 3. Performance-heavy animations that affect gameplay responsiveness. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core card game functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Code engineering quality",
+      "description": "Review modular design (such as separating card game logic/UI/networking layers), reusable components for cards, and clear class hierarchies for game rules. Check for unit tests covering edge cases in card combinations. Deduct 5 points if global state management is messy; deduct 5 points if similar card validation logic is duplicated; deduct 5 points if the code lacks documentation for the complex rule integrations. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Card game interface design",
+      "description": "Evaluate whether the card game UI follows professional design principles: 1) Clear visual distinction between the three integrated game types 2) Properly sized and easily recognizable cards (even when many are displayed) 3) Distinct player areas with status indicators. Deduct 3 points for cluttered card arrangements, 5 points for unclear card hierarchies, and 5 points for confusing game phase transitions. Check if animations for card dealing and playing feel natural. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Player interaction and feedback",
+      "description": "Judge whether the player interactions are intuitive and responsive: 1) Card selection feedback ≤ 100ms 2) Clear validation indicators for legal/illegal card plays 3) Visible countdown timers for turns. Check if multiplayer actions are clearly communicated to all players. Deduct 5 points for delayed feedback on card selections, 3 points for unclear indicators of whose turn it is, and 5 points if valid card combinations aren't visually suggested to help players. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "hard"
+}

package/library/game_development-strategy/gomoku-five-in-a-row-mini-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 767,
+  "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 and can be demonstrated. Help me write code for a Gomoku (Five in a Row) mini-game.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Gomoku game core logic fully implemented?",
+      "description": "Review whether the code accurately implements the 15x15 or 19x19 board coordinate system through HTML/JavaScript, and whether it includes win condition detection (five consecutive stones in horizontal, vertical, or diagonal directions), forbidden move validation for black pieces (double-three, double-four, overline rules), and turn-based gameplay mechanics. Score 0 if the core game logic is not implemented, 5 if only basic stone placement and simple win detection are implemented, and 10 if all standard Gomoku rules including forbidden moves are fully included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the interactive board interface properly designed?",
+      "description": "Check whether the game board provides clear visual feedback for stone placement, including hover effects on intersection points, clear distinction between black and white stones, and proper board grid rendering. Evaluate if the board supports both mouse click and touch interactions. Deduct 5 points if stone placement feedback is unclear, and 3 points if the board intersection detection is imprecise (stones not aligning properly with grid points). The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is comprehensive game state management implemented?",
+      "description": "Evaluate whether the code includes complete game state tracking such as move history, undo/redo functionality, game reset capability, and current player indication. Check if the game can detect and handle game-ending conditions (win, draw, resignation). Deduct 5 points if move history is not maintained, and 3 points if game state transitions are not properly managed. Give 10 points if all state management features are fully implemented including save/load game functionality.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are AI opponent capabilities or multiplayer features provided?",
+      "description": "Check whether the code includes either a functional AI opponent with reasonable difficulty levels (using algorithms like minimax, alpha-beta pruning, or pattern recognition) or local multiplayer functionality. For AI implementation, evaluate move quality and response time. For multiplayer, check turn management and game synchronization. Deduct 5 points if AI makes obviously poor moves or if multiplayer turn switching is buggy. Give 10 points for well-implemented AI or smooth multiplayer experience.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as clicking outside the board, rapid consecutive clicks, invalid moves, browser refresh during gameplay, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should prevent illegal moves and maintain game integrity under various user interactions, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the gaming experience (e.g., 1. Move suggestion system with strength indicators 2. Game replay with animated move sequence 3. Multiple board themes or stone styles 4. Sound effects for stone placement 5. Statistical analysis of winning patterns). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple win detection algorithms coexisting) 2. Function modules unrelated to Gomoku (e.g., built-in calculator or weather widget) 3. Overly complex animations that affect game responsiveness (e.g., elaborate stone-dropping physics). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core gameplay is 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 rendering/event handling), code organization and readability, and proper use of design patterns. Deduct 5 points if global state pollution is found or if code is poorly structured; deduct 5 points if the code duplication rate is too high (over 30%); deduct 3 points if variable naming is inconsistent or functions are overly complex. 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) Harmonious color scheme with clear contrast between board and stones 2) Proper proportions with board taking appropriate screen space 3) Clean typography for game information display 4) Consistent visual hierarchy for buttons and controls. Deduct 3 points for each cluttered visual element, 5 points for poor color contrast making gameplay difficult, and 5 points for inconsistent or unprofessional styling. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the gameplay interaction smooth and intuitive?",
+      "description": "Judge whether the game interactions conform to user expectations: 1) Stone placement response time ≤ 100ms 2) Smooth hover effects and visual feedback 3) Clear indication of whose turn it is 4) Intuitive button placement and game controls 5) Responsive design that works on different screen sizes. Deduct 5 points for each unresponsive interaction, 3 points for confusing UI elements, and 5 points for poor mobile compatibility. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "easy"
+}