@getollie/cli 0.0.4 → 0.2.0

package/library/game_development-strategy/chinese-networked-card-board-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 926,
-  "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. Create a card/board game code that is authentic and effective, allowing you to have fun with friends, in Chinese language, with networking capabilities.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "卡牌/棋盘游戏基础功能实现",
-      "description": "评估代码是否实现了完整的卡牌/棋盘游戏核心机制，包括游戏规则定义、回合制管理、胜负判定等。检查是否包含清晰的游戏逻辑层和展示层分离。满分需要实现完整的游戏规则和流程，包括特殊规则处理。如果只实现基本游戏流程给5分，完整实现所有游戏规则给10分。",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "中文语言支持和本地化",
-      "description": "检查代码是否完全支持中文界面和交互，包括游戏说明、按钮文本、提示信息等。评估是否有完善的字符编码处理机制避免中文乱码，以及是否考虑了中文排版美观性（如行间距、字间距）。如缺少关键界面中文翻译扣5分，如出现明显乱码问题扣3分，界面中文排版混乱扣2分。",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "网络对战功能实现",
-      "description": "评估网络对战功能的完整性：检查是否实现了房间创建/加入机制、实时数据同步、玩家状态管理等。要求包含WebSocket或类似技术实现实时通信，具备断线重连机制，以及网络延迟补偿策略。如缺少心跳检测扣3分，缺少断线重连扣5分，没有网络延迟处理扣2分。",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "多人游戏交互设计",
-      "description": "评估多人游戏体验的设计质量：检查是否提供了等待队列、玩家准备状态显示、回合提示、玩家在线状态指示等功能。判断游戏是否提供了足够的社交互动元素，如聊天系统、表情/快捷短语功能等。如缺少玩家状态显示扣3分，缺少基本交互反馈扣5分，缺少社交功能扣2分。",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "代码健壮性",
-      "description": "评估代码是否能处理常见异常情况（如网络中断、非法操作、并发冲突等）并提供友好的错误提示或恢复机制。具备强健壮性的代码应该能有效处理这些边缘情况，给予10分。如健壮性一般，给予5分，如完全没有异常处理，给予0分。",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "创新特色功能",
-      "description": "检查代码是否包含提升体验的惊喜功能（如：1. 游戏战绩统计与排行榜 2. 游戏录像回放功能 3. AI辅助对战 4. 自定义游戏规则）。每实现一个实用的创新功能加3分（最高10分）。",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "冗余功能检查",
-      "description": "严格检查三类冗余：1. 类似功能的重复实现（如多个不同的计分逻辑并存）2. 与卡牌/棋盘游戏无关的功能模块（如内置无关小游戏）3. 影响性能的花哨效果（如过度的粒子动画）。发现一处冗余扣3分，核心功能被冗余代码干扰直接扣10分。",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "代码工程质量",
-      "description": "审查模块化设计（如游戏逻辑/视图/网络层分离）、单元测试覆盖率和构建过程自动化。如发现全局状态污染或未使用设计模式扣5分；代码重复率过高（超过30%）扣5分；构建过程未自动化扣5分。",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "界面设计专业性",
-      "description": "评估整体设计是否遵循现代设计原则：1）和谐的配色（不超过3种主色）2）适当的布局间距（元素间距遵循8px倍数原则）3）专业的字体系统（正文字体大小≥14px，行高1.5倍以上）。每出现一处视觉拥挤元素扣3分，刺眼配色组合扣5分，文图布局混乱扣5分。",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "动态交互流畅性",
-      "description": "判断动态效果是否符合人类感知特性：1）点击反馈延迟≤100ms 2）过渡动画时长控制在300-500ms之间 3）明确的视觉焦点引导。每出现一处没有反馈的操作扣5分，快速滑动时出现视觉残影扣3分，关键功能按钮难以找到扣5分。",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "medium"
-}

package/library/game_development-strategy/chinese-poker-game-dou-dizhu.json

@@ -1,68 +0,0 @@
-{
-  "index": 1746,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable for demonstration. Write a Chinese poker game (\"Dou Dizhu\") in HTML, assuming that Xiao Liang, Lao Liang, and Lao Yu are playing. The colors of the poker cards can be random. Include a restart button.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core Chinese poker (Dou Dizhu) game logic fully implemented?",
-      "description": "Review whether the code correctly implements the Dou Dizhu rules, including card distribution (17 cards for farmers, 20 cards for landlord plus 3 face-up cards), card combinations (single, pair, trio, straight, bomb, etc.), and the rule that each play must be larger than the previous one. Score 0 if basic game flow is missing, 5 if only simple card plays are supported, and 10 if all standard combinations and gameplay mechanics are correctly implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the card dealing and turn-based gameplay correctly implemented?",
-      "description": "Check if the code correctly implements the three-player mechanic with proper roles (landlord vs. farmers), role selection process, and turn-based gameplay where Xiao Liang, Lao Liang, and Lao Yu take turns. Verify that the game handles turn transitions properly, shows whose turn it is, and correctly validates if a player can pass or must play. Deduct 5 points if role assignment is missing, 3 points if turn indicators are unclear, and 2 points if passing mechanics are incorrect.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are the winning conditions and game completion properly implemented?",
-      "description": "Evaluate whether the code correctly determines when a player has played all their cards (winning condition), properly awards points to either the landlord or the two farmers as a team, and shows appropriate game-over notifications. Check that the game state is properly updated when someone wins. Deduct 5 points if winning detection is buggy, 3 points if scoring is missing, and 2 points if the game doesn't clearly indicate who won.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the restart functionality properly implemented?",
-      "description": "Test whether the restart button completely resets the game state, redistributes cards randomly, and allows for a fresh game to begin. The reset should clear all previous game data, shuffle the deck properly, and reset the player roles. Deduct 5 points if the restart doesn't properly shuffle cards, 3 points if player states aren't fully reset, and 2 points if the game becomes unstable after multiple restarts.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as clicking cards when it's not your turn, trying to play invalid card combinations, or rapid button clicks). Code with strong robustness should prevent illegal moves and provide user feedback. Give 10 points if the code handles all edge cases gracefully, 5 points if it handles common cases but has minor issues, and 0 points if it breaks easily.",
-      "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. Animation for card dealing 2. Sound effects for card plays 3. Hints for possible moves 4. AI strategy for computer players 5. Game history/statistics). Add 2 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 handle card selection) 2. Function modules unrelated to the poker game (e.g., unrelated mini-games) 3. Fancy effects that affect performance (e.g., excessive animations that slow down gameplay). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/view layers), code organization, and maintainability. Deduct 5 points if global variable abuse is found; deduct 3 points if the code structure is chaotic with no clear separation of concerns; deduct 2 points if there's excessive code duplication. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the card display is clear and visually appealing: 1) Cards are easily distinguishable with clear suits and values 2) Player areas are well-defined with proper spacing 3) Current player and game state indicators are clearly visible. Deduct 3 points for cluttered card layouts, 4 points for poor visibility of critical game information, and 3 points for inconsistent visual styling. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the card interaction smooth and intuitive?",
-      "description": "Judge whether the card selection and play interactions are user-friendly: 1) Cards can be easily selected/deselected 2) Selected cards are visually distinct 3) Playing cards has clear feedback 4) Cards are properly arranged after each play. Deduct 3 points for clunky card selection, 3 points for unclear visual feedback when playing cards, and 4 points if the game becomes visually confusing during gameplay. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "hard"
-}

package/library/game_development-strategy/custom-rules-game-board-generation.json

@@ -1,68 +0,0 @@
-{
-  "index": 29,
-  "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 card/board game: Custom Rules and Game Board Generation\n**Task**: Implement a custom rule-based game board generation system that allows players to customize game rules and initial layouts.\n**Tip**: You can provide a rule editor and generate new game boards based on player settings.\nPlease include comments in your code so other developers can understand your implementation process.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Custom Rules Implementation",
-      "description": "Does the code implement a robust custom rules framework that allows players to define their own game mechanics?Check if the implementation includes a rule definition system with variables, conditions, and actions. Rules should be modifiable through a user interface and properly validated. Score 0 if no rule customization exists, 5 if only basic predefined rules can be toggled, and 10 if players can create complex custom rules with conditionals and effects.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Game Board Generation System",
-      "description": "Is the board generation system flexible and responsive to rule changes?Evaluate whether the board generation algorithm can produce different board layouts based on rule parameters. Check if the system supports variable board sizes, shapes (rectangular, hexagonal, etc.), and cell types. Deduct 5 points if the generator only creates fixed layouts, 3 points if it lacks visual validation of rule conflicts. Full score requires procedural generation with constraint satisfaction.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Rule Editor Design",
-      "description": "Is the rule editor intuitive and comprehensive?Analyze the rule editor's design for usability and completeness. A good editor should allow for visual rule creation (drag-and-drop or guided wizards), provide real-time validation feedback, and include a library of rule templates/examples. Deduct 5 points if the editor uses only raw text input without validation, 3 points if it lacks undo/redo functionality, and 5 points if there's no way to save/load rule sets.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Initial Layout Customization",
-      "description": "Does the system allow for flexible initial board state customization?Check whether players can customize the initial placement of game elements, save layouts as templates, and share configurations with others. The system should validate that initial states comply with the defined rules. Score 0 if no initial layout customization exists, 5 if only predefined layouts are available, and 10 if there's comprehensive placement customization with rule validation.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Code Robustness",
-      "description": "Is the code capable of handling various edge cases and invalid inputs?Evaluate whether the code includes error handling for incorrect rule definitions, incompatible rule combinations, and unexpected user interactions. Check for input validation, graceful failure modes, and descriptive error messages. Deduct 5 points if invalid rules can crash the application, 3 points if user feedback for errors is unclear, and 5 points if there's no protection against infinite loops in rule processing.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Innovative Features",
-      "description": "Are there any eye-catching innovative features that enhance the experience?Look for unique features such as: 1) AI assistance in rule creation 2) Rule simulation/testing tools 3) Community rule-sharing platform 4) Visual rule impact preview. Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Code Redundancy and Efficiency",
-      "description": "Are there any redundant or inefficient implementations?Check for: 1) Duplicate rule processing logic 2) Unnecessary re-rendering of the game board 3) Inefficient data structures for rule evaluation 4) Performance-heavy animations or effects that slow down rule application. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core rule processing is negatively affected by bloated code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Engineering Quality",
-      "description": "Does the code follow good engineering principles?Review the separation of concerns (rule definition, board generation, UI), code modularity, and use of appropriate design patterns. Check for proper documentation (especially for the rule definition API) and test coverage of critical rule processing functions. Deduct 5 points for global state mismanagement, 5 points if the code coupling is high (>70% interdependency), and 5 points if there are no unit tests for rule validation.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Interface Design Quality",
-      "description": "Does the interface meet professional design standards?Evaluate the visual design based on: 1) Clear separation between rule editor and game board areas 2) Consistent visual language for game elements 3) Accessible control schemes with keyboard shortcuts 4) Responsive layout that works on different screen sizes. Deduct 3 points for confusing navigation, 5 points for poor information hierarchy, and 5 points for inconsistent styling between the rule editor and game board.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Interaction Feedback and Usability",
-      "description": "Is the interaction feedback clear and the system easy to use?Judge whether the system provides clear feedback for rule application, board generation, and user interactions. Check for: 1) Visual cues when rules are triggered 2) Smooth transitions when the board changes 3) Progressive disclosure of complex rule options 4) Undo/redo functionality for rule changes. Deduct 5 points for lack of visual feedback during rule processing, 3 points for confusing rule conflict indicators, and 5 points if the system doesn't guide new users through the rule creation process.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "hard"
-}

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

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

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

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

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

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