@getollie/cli 0.0.4 → 0.2.0

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

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

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

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

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

@@ -1,68 +0,0 @@
-{
-  "index": 1201,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to make the generated code executable for demonstration. Write me a mobile game code for Gomoku (Five in a Row), a single-player version with 10 levels. Each win earns one champion medal. Winning 2 consecutive games earns 2 champion medals, winning 3 consecutive games earns 3 champion medals, and so on. The wins must be consecutive - losing a game or drawing in between breaks the streak and resets the count.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Gomoku core game logic fully implemented?",
-      "description": "Review whether the code accurately implements the 15×15 board, correctly handles stone placement, and properly identifies winning conditions (5 stones in a row horizontally, vertically, or diagonally). Score 0 if the core logic is missing, 5 if basic win detection is implemented but has edge cases, and 10 if the implementation is complete and bug-free.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are all 10 difficulty levels properly implemented and distinct?",
-      "description": "Evaluate whether the AI opponents across 10 levels show meaningful progression in difficulty. Check if higher levels employ more sophisticated strategies (such as threat detection, forced moves recognition, opening strategies). Deduct 2 points for each level that is indistinguishable from adjacent levels. Full score requires visible differences in AI behavior between levels shown in screenshots.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the consecutive win medal system correctly implemented?",
-      "description": "Test whether the medal reward system accurately tracks consecutive wins (1 medal for first win, 2 for second consecutive win, etc.), and properly resets the counter upon loss or draw. Score 0 if not implemented, 5 if the system works but has edge cases (e.g., incorrect counting after app restart), and 10 if fully functional with persistent storage.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there a single-player progression system with proper game state management?",
-      "description": "Check if the code includes player progression tracking, statistics (wins/losses/draws), level unlocking mechanism, and proper game state management (new game, pause, resume, forfeit). Score 0 if missing, 5 if basic implementation, and 10 if the system includes animations and visual feedback when unlocking new levels.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code handles edge cases (invalid moves, race conditions during animations, rapid input) and provides friendly error messages or recovery mechanisms. Code should prevent illegal moves and handle potential state inconsistencies. Give 10 points for comprehensive error handling, 5 points for basic validation, 0 points if critical errors can crash the game.",
-      "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. Replay system with move annotations 2. Customizable board themes 3. Interactive tutorials for strategies). 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 board rendering methods) 2. Function modules unrelated to Gomoku (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive particle animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/view/AI/medal system), code organization, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there are no comments for complex algorithms. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional mobile game design standards?",
-      "description": "Evaluate whether the UI follows mobile game design principles: 1) Finger-friendly touch targets (minimum 44×44 pixels) 2) Clear visual hierarchy with appropriate contrast 3) Consistent design language across screens. Deduct 3 points for each hard-to-tap element, 5 points for cluttered layouts, and 5 points for inconsistent visual styles between screens. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and responsive?",
-      "description": "Judge whether the game interactions feel native and responsive: 1) Move feedback delay ≤ 100ms 2) Stone placement animations between 200-300ms 3) Clear visual and audio feedback for important events (wins, medals earned). Deduct 5 points for laggy animations, 3 points for missing visual feedback on stone placement, and 5 points for unresponsive UI during AI's turn. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "medium"
-}

package/library/game_development-strategy/hearts-card-game-notepad-implementation.json

@@ -1,68 +0,0 @@
-{
-  "index": 1383,
-  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Please ensure that the code you generate is executable for demonstration. I only have Notepad on my computer, so please help me write a Hearts card game using Notepad.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Hearts card game core logic fully implemented?",
-      "description": "Review whether the code accurately implements Hearts game rules through HTML/JavaScript, including proper card dealing (13 cards per player), card passing mechanism (left/right/across/no pass rotation), trick-taking logic, and scoring system (hearts = 1 point, Queen of Spades = 13 points, shooting the moon = 26 points to others). Score 0 if core game mechanics are missing, 5 if only basic trick-taking is implemented, and 10 if all official Hearts rules are correctly included with proper score calculation.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the AI opponent intelligence system properly designed?",
-      "description": "Check whether the AI players demonstrate realistic card play strategies including: basic card counting, avoiding dangerous leads, strategic passing decisions, and appropriate risk assessment for shooting the moon attempts. The AI should exhibit different difficulty levels and playing styles. Deduct 5 points if AI makes obviously poor decisions, and 3 points if AI behavior is too predictable or mechanical. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the game state management and turn-based system implemented correctly?",
-      "description": "Evaluate whether the game properly manages turn sequences, validates legal plays (must follow suit if possible, no hearts/Queen of Spades on first trick unless hearts broken), tracks game progress across multiple hands, and maintains accurate score tracking until a player reaches 100 points. Deduct 5 points if turn validation is missing, and 3 points if game state becomes inconsistent during play. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the complete game flow and user interaction system constructed?",
-      "description": "Check whether the code includes complete game lifecycle management: game initialization, card passing phase UI, trick-playing interface, score display after each hand, and game-over conditions with final rankings. Must include intuitive card selection, play confirmation, and game restart functionality. Deduct 5 points if any major game phase is missing UI, and 3 points if user cannot easily understand current game state. Give 10 points if fully implemented with clear game progression.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid card selections, clicking during AI turns, rapid clicking, browser refresh, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Card play history with move analysis 2. Customizable AI difficulty and personality 3. Statistics tracking across multiple games 4. Hint system for beginners 5. Animated card movements). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple scoring calculation methods coexisting) 2. Function modules unrelated to Hearts gameplay (e.g., built-in calculator or timer) 3. Fancy effects that affect performance (e.g., excessive particle animations or heavy graphics). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core game functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/UI rendering/AI strategy), code organization in a single HTML file, and clean function structure. Deduct 5 points if global state pollution is found or functions are poorly organized; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if code is not properly commented for Notepad editing. 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 with proper card suit colors (no more than 4 primary colors) 2) Proper layout spacing with clear card arrangement (element spacing follows consistent principles) 3) Professional typography (readable font sizes ≥ 14px, clear score display). Deduct 3 points for each crowded visual element, 5 points for poor color contrast making cards hard to distinguish, and 5 points for chaotic layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the card game interactions conform to user expectations: 1) Card selection feedback ≤ 100ms with clear visual indication 2) Smooth card play animations between 300-500ms 3) Clear visual focus on playable cards and current player turn 4) Intuitive hover effects and click states. Deduct 5 points for each operation without visual feedback, 3 points for confusing game state indicators, and 5 points for hard-to-identify selectable cards. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "hard"
-}

package/library/game_development-strategy/hex-game-11x11-pie-rule.json

@@ -1,68 +0,0 @@
-{
-  "index": 1325,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Pay attention to ensure that the generated code is executable for display.\n\nThe chess board is typically n×n in size. In this problem, we specify the board size as 11×11.\n• Both sides take turns placing pieces continuously. Once placed on the board, chess pieces cannot be moved or removed.\n• The red side (the letter side in the coordinate system mentioned later) goes first.\n• Since Hex has a significant first-mover advantage, we introduce the pie rule: after the first piece is placed, the opponent can choose to swap this piece for their own and place it at a position symmetrical to the original position along the diagonal of the board. First and second players are randomly determined.\n• The side that connects the opposite sides of the board with pieces of the same color wins. Please regenerate the .js code according to these rules.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Hex game board system fully implemented?",
-      "description": "Review whether the code accurately implements the 11×11 hexagonal board coordinate system through HTML/JavaScript, including proper hexagonal cell rendering, coordinate mapping, and visual representation of the hex grid. Check if the hexagonal geometry is mathematically correct with proper spacing and alignment. Score 0 if the hexagonal board is not implemented, 5 if only basic grid is shown without proper hex geometry, and 10 if the complete hexagonal board with accurate coordinates is fully implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are the Hex game rules correctly implemented?",
-      "description": "Evaluate whether the core Hex rules are properly coded: alternating turns (red goes first), permanent piece placement (no movement/removal), and win condition detection (connecting opposite sides). Verify the algorithm can detect valid connections across the board boundaries. Score 0 if basic rules are missing, 5 if only placement and turns work, and 10 if all rules including win detection are fully functional.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the pie rule mechanism correctly designed and implemented?",
-      "description": "Check whether the pie rule is properly implemented: after the first move, the second player can swap the piece and place it at the diagonally symmetric position. Verify the diagonal symmetry calculation is mathematically accurate for the 11×11 hex board and that the swap option is presented at the correct timing. Score 0 if pie rule is missing, 5 if only basic swap is implemented without proper symmetry, and 10 if complete pie rule with accurate diagonal symmetry is implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the win condition detection algorithm efficient and accurate?",
-      "description": "Evaluate the path-finding algorithm used to detect winning connections. Check if it uses efficient algorithms (like BFS/DFS or Union-Find) to detect connections between opposite sides. Verify it correctly identifies all possible winning paths and handles edge cases. Score 0 if win detection is missing or incorrect, 5 if basic detection works but is inefficient, and 10 if optimal algorithm with complete accuracy is implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as clicking occupied cells, invalid coordinates, rapid clicking, browser compatibility issues, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the Hex gaming experience (e.g., 1. Move history with undo functionality 2. AI opponent with difficulty levels 3. Game analysis showing potential winning paths 4. Save/load game 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 win detection algorithms coexisting) 2. Function modules unrelated to Hex game (e.g., built-in calculators) 3. Fancy effects that affect performance (e.g., excessive animations on every click). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core Hex 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/interaction layers), code organization, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the code structure is chaotic without proper separation of concerns. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the Hex board design follows modern design principles: 1) Harmonious color scheme for red/blue pieces and board 2) Proper hexagonal cell sizing and spacing 3) Clear visual distinction between empty and occupied cells 4) Professional typography for game status. Deduct 3 points for each crowded visual element, 5 points for poor color contrast making pieces hard to distinguish, and 5 points for unclear board layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the game interactions conform to user expectations: 1) Immediate visual feedback on cell hover 2) Smooth piece placement animation ≤ 300ms 3) Clear indication of current player's turn 4) Responsive highlighting of potential winning connections. Deduct 5 points for each operation without feedback, 3 points for laggy animations, and 5 points for unclear game state indicators. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "hard"
-}

package/library/game_development-strategy/horror-game-monster-ai-escape-routes.json

@@ -1,68 +0,0 @@
-{
-  "index": 130,
-  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Try to ensure the generated code is executable for demonstration.\nPlease use HTML and JavaScript to implement a horror game: Monster AI and Escape Routes\n**Task**: Implement a monster AI system where monsters patrol randomly and track players, and players need to find safe routes to avoid capture.\n**Hint**: You can set different perception ranges and tracking algorithms for monsters, and design multiple escape routes in the scene.\n[CHAT_SEP]Please optimize the game answer above and add some comments to the code so other developers can understand your implementation process.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the monster AI patrolling and tracking system fully implemented?",
-      "description": "Review whether the code implements different AI states (idle, patrolling, alert, tracking) with smooth transitions. Check if the monsters have proper path finding algorithms, random patrol routes, and player detection mechanisms. Score 0 if there's no AI implementation, 5 if only basic movement is present, and 10 if the AI includes perception ranges, memory of player's last position, and state machine transitions.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are the escape routes and navigation systems properly designed?",
-      "description": "Evaluate whether multiple escape routes are implemented with varying difficulty levels and strategic options (hiding spots, distractions, etc.). Check if the map design includes bottlenecks, alternative paths, and safe zones. Deduct 3 points if there's only one escape route, 5 points if the routes are too simplistic with no tactical choices, and 5 points if there's no visual indication of route options. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the monster perception system implemented with different ranges and mechanics?",
-      "description": "Verify that monsters have multiple perception systems (sight, hearing, proximity) with appropriate ranges and detection logic. Check if environmental factors affect perception (darkness reducing sight range, noise masking player sounds). Score 0 if perception is binary (detect/not detect), 5 if only basic distance checks are implemented, and 10 if the system includes cone of vision, sound propagation, and environmental interactions.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the game loop and tension-building mechanism properly implemented?",
-      "description": "Assess whether the game implements proper tension-building mechanisms like proximity indicators, audio cues, and visual effects that intensify as danger approaches. Check for chase dynamics (monster speed adjustments, cornering behaviors) and escape mechanics (hiding, breaking line of sight). Deduct 5 points if tension indicators are absent and 5 points if the chase dynamics are too simple or unfair. 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 off-map movement, collision edge cases, rapid state transitions, etc.) and provide appropriate fallbacks. Check error handling for game events, animation states, and player 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": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the horror experience (e.g., 1. Dynamic lighting and shadows, 2. Procedurally generated maps, 3. Adaptive AI difficulty based on player skill, 4. Environmental interaction like creating distractions). 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 collision detection systems) 2. Function modules unrelated to the horror game (e.g., unnecessary mini-games) 3. Overly complex effects that affect performance (e.g., excessive particle systems). 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/player controls/rendering layers), code organization, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there are no meaningful comments explaining complex algorithms. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional horror game standards?",
-      "description": "Evaluate whether the visual design creates appropriate atmosphere: 1) Effective use of darkness and limited visibility 2) Unnerving color schemes and visual distortions 3) Minimal but impactful UI that maintains immersion. Deduct 3 points for inappropriately bright environments, 5 points for visually cluttered interfaces that break immersion, and 5 points for missing visual feedback on critical game states. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and responsive?",
-      "description": "Judge whether the player controls and monster interactions feel responsive and fair: 1) Movement controls respond within 100ms 2) Visual and audio feedback on detection and danger levels 3) Consistent framerate during intense chase sequences. Deduct 5 points for input lag exceeding 200ms, 5 points for missing feedback on critical game events (monster detection, near misses), and 3 points for frame rate drops during key gameplay moments. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "medium"
-}

package/library/game_development-strategy/html-canvas-faction-war-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 458,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Be sure to provide executable code when possible. Help me write a game using HTML with the following requirements:\n\n1. Use Canvas to draw the game screen\n2. Two factions (green/blue vs orange/pink)\n3. Different classes (warrior/archer) with different attributes\n4. Automatic pathfinding and attack logic\n5. Simple collision detection\n6. Skill cooldown system\n7. Basic sound effect support\n8. Add character animation system\n9. Add more game balancing mechanisms\n10. Add equipment system\n11. Add more visual effects (particle effects, lighting, etc.)",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the game implementation with Canvas complete and optimized?",
-      "description": "Review the Canvas initialization, game loop implementation, and rendering optimizations. Check whether the code efficiently uses requestAnimationFrame, implements proper canvas clearing/redrawing strategies, and handles canvas resize events. Score 0 if Canvas is not used at all, 5 if basic rendering is implemented with poor performance, and 10 if the implementation includes advanced techniques like layer management, off-screen canvas for complex elements, and maintains 60 FPS.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are the two factions properly implemented with distinct visual and behavioral differences?",
-      "description": "Evaluate whether the green/blue and orange/pink factions have clearly differentiated visual designs, team-based logic, and balanced capabilities. Check for team identification systems (colors, emblems), team-specific bonuses/abilities, and proper team-based collision detection. Deduct 5 points if factions are only visually different without gameplay distinctions, and 3 points if team balance issues are obvious. Full score of 10 if factions are well-designed with unique characteristics and strategic depth.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "How well are the different character classes implemented?",
-      "description": "Assess the implementation of warrior/archer classes and their attributes. Check for proper class inheritance structure, unique attributes per class (health, damage, range, speed), and class-specific behaviors. Verify that warriors have appropriate melee combat mechanics while archers have proper range attack systems. Score 0 if classes don't exist or are purely cosmetic, 5 if basic class differences exist but lack depth, and 10 if classes have meaningful gameplay differences, proper balancing, and unique abilities.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "How sophisticated is the pathfinding and attack logic?",
-      "description": "Evaluate the implementation of pathfinding algorithms (A*, Dijkstra's, etc.) and combat logic. Check for obstacle avoidance, dynamic path recalculation, target selection intelligence, and attack range considerations. Verify that units properly navigate complex environments and engage enemies according to their class capabilities. Deduct 5 points if pathfinding frequently fails on basic obstacles, 3 points if attack logic doesn't consider proper range/angle. Full score requires efficient pathfinding implementation with minimal computational overhead.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as out-of-bounds input, animation errors, resource loading failures, 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 weather effects 2. Advanced AI behaviors like flanking or unit cooperation 3. Interactive environment elements). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple collision detection systems) 2. Function modules unrelated to the core game requirements (e.g., unnecessary social features) 3. Visual effects that severely impact performance. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/rendering/input layers), code organization, and maintainability. Deduct 5 points if global state pollution is found or proper design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if game assets and code are not properly separated. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern game UI principles: 1) Consistent faction color schemes and visual language 2) Non-intrusive HUD elements with proper information hierarchy 3) Clear visual feedback for player actions and game events. Deduct 3 points for cluttered UI elements, 5 points for poorly contrasting text or indicators, and 5 points for inconsistent visual style between game elements and UI. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the game experience polished with proper feedback systems?",
-      "description": "Judge whether the game provides appropriate feedback through animations, sound effects, and visual indicators: 1) Character animations that clearly indicate their state 2) Sound effects that match actions and provide gameplay information 3) Visual effects for skills, damage, and game events that enhance understanding. Deduct 5 points for missing animation states, 3 points for poorly implemented sound systems, and 5 points for visual effects that obscure gameplay. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "hard"
-}