@getollie/cli 0.0.5 → 0.2.1

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

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

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

@@ -1,68 +0,0 @@
-{
-  "index": 1105,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Who is the Bull King\n\n\"Who is the Bull King\" is a simple and fun card game suitable for 2-10 players. The game consists of 104 cards, each with numbers from 1 to 104, and each card features a different number of bull heads. This game has won multiple awards, including the 1994 German Players' Award and the 1996 Best Mind Game Award.\n\n## Game Rules\n\n**Dealing**: Each player receives 10 cards, with 4 cards placed face-up on the table as the initial tableau. Excess cards are discarded.\n\n**Playing**: At the beginning of each round, each player selects one card from their hand to play face-down.\n\n**Card Placement Order**: When all players have placed their cards face-down, the system automatically reveals and places the cards, starting with the card closest in value to the last card on the tableau. If cards are equally close, the smaller card is placed first.\n\n**Placement Rules**: Cards are preferentially placed in positions that don't require collecting cards, then in positions closest to the end card on the tableau, and finally in positions where the end card has a smaller value.\n\n**Card Collection**: When a player places a card that is smaller than the last card on the tableau, or when placing a card in the sixth position, they must collect all the previous cards and their played card becomes the new first card on the tableau.\n\n**Game End**: There are two ways to end the game, chosen by players: either when all cards from players' hands have been played, or when a player reaches 66 bull heads.\n\n## Card Quantities\nIf there are fewer than 10 players, reduce the deck size by 20 cards for every 4 fewer players. For 7-10 players, use cards 1-104; for 3-6 players, use cards 1-84; for 2 players, use cards 1-64.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the basic card game structure properly implemented?",
-      "description": "Assess whether the code correctly implements the 'Who is the Bull King' game structure with proper card distribution (104 cards with bull heads) and dynamic deck sizing based on player count. Check if the code properly assigns bull head values to each card and handles the initial tableau setup with 4 face-up cards. Score 0 if the card system is missing, 5 if cards are implemented but have incorrect bull head assignments, and 10 if the full card system with proper scaling for player count is implemented correctly.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the card placement logic implemented according to the rules?",
-      "description": "Evaluate whether the code correctly implements the specific card placement order rules: placing cards closest in value to the last tableau card, handling equal-distance cases by prioritizing smaller cards, and following the described placement hierarchy. Deduct 5 points if the placement logic doesn't handle edge cases (like equal distances), 3 points if the ordering is incorrect, and 5 points if the placement hierarchy is missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the card collection mechanism correctly implemented?",
-      "description": "Check if the code properly enforces the rule where players must collect all cards when placing a card smaller than the last tableau card or when placing a sixth card. Verify that collected cards are properly accounted for in bull head scoring and that the played card correctly becomes the new first card in the tableau. Deduct 5 points if collection rules are partially implemented, and 10 points if completely missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are the game end conditions properly implemented?",
-      "description": "Verify that the code implements both game-ending conditions: either when all cards from players' hands have been played, or when a player reaches 66 bull heads. Check whether the code allows players to choose between these options at game setup. Deduct 5 points if only one ending condition is implemented, and 3 points if the player choice mechanism is missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as out-of-bounds input, network interruption, user operation errors, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Card animation effects during placement 2. Historical statistics tracking for players 3. Interactive tutorials for new players). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple card selection logics coexisting) 2. Function modules unrelated to the Bull King game (e.g., a built-in mini-game) 3. Fancy effects that affect performance (e.g., excessive card animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/view/network layers), unit test coverage, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance for card selection and placement. Deduct 5 points for each operation without feedback, 3 points for visual after-images during card movement, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "hard"
-}

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

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

package/library/game_development-strategy/cartoon-web-chinese-chess-mini-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 1373,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you provide is executable and demonstrable. Help me create a cartoon-style web-based Chinese chess (Xiangqi) mini game.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Chinese chess (Xiangqi) game rule system fully implemented?",
-      "description": "Review whether the code accurately implements the Xiangqi board system (9x10 grid with river), piece movement rules (General, Advisor, Elephant, Horse, Chariot, Cannon, Soldier), position restrictions (palace boundaries, river crossing rules), and win/lose conditions. Score 0 if core movement logic is missing, 5 if only basic piece movement is implemented, and 10 if all traditional Xiangqi rules including checkmate detection are fully implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the cartoon-style visual design professionally executed?",
-      "description": "Evaluate whether the game adopts a consistent cartoon art style: 1) Piece designs should be cute and recognizable with clear Chinese characters 2) Board should have warm, friendly colors with proper contrast 3) Visual effects should maintain cartoon aesthetics (rounded corners, soft shadows, playful animations). Deduct 3 points for inconsistent art style, 5 points for poor readability of Chinese characters on pieces, and 5 points if the overall visual lacks cartoon charm. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the interactive game flow and user experience well-designed?",
-      "description": "Check whether the game includes essential interactive features: 1) Intuitive piece selection and movement with visual highlights 2) Turn-based gameplay with clear player indicators 3) Move validation with helpful error messages 4) Game restart functionality 5) Basic game history or undo feature. Deduct 3 points for each missing core interaction, 5 points if piece movement feels clunky or confusing. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the web-based implementation technically sound and complete?",
-      "description": "Assess whether the code provides a complete web gaming experience: 1) Responsive design that works on different screen sizes 2) Proper HTML structure with semantic elements 3) Efficient JavaScript game state management 4) CSS styling that enhances the cartoon theme 5) Cross-browser compatibility considerations. Deduct 5 points if the game doesn't work on mobile devices, 3 points for poor performance, and 5 points if the code lacks proper web standards. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid moves, rapid clicking, browser refresh, illegal piece placements, 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 gaming experience (e.g., 1. Animated piece movements with cartoon effects 2. Sound effects matching the cartoon theme 3. Victory celebrations with playful animations 4. Tutorial mode for beginners 5. Theme customization options). 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 game state tracking systems) 2. Function modules unrelated to Xiangqi gaming (e.g., unrelated mini-games or social features) 3. Overly complex animations that hinder gameplay flow. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core gaming 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/event handling), code organization, and maintainability. Deduct 5 points if global state pollution is found or proper code structure is missing; deduct 5 points if the code duplication rate is too high (over 30%); deduct 3 points if variable naming is unclear or inconsistent. 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 cartoon UI principles: 1) Harmonious color palette suitable for cartoon style (warm, friendly colors) 2) Proper spacing and layout (elements not crowded, clear visual hierarchy) 3) Readable font system (Chinese characters clear and appropriately sized) 4) Consistent visual elements throughout the game. Deduct 3 points for each crowded visual element, 5 points for clashing color combinations, and 5 points for poor Chinese character legibility. 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 cartoon game standards: 1) Piece selection and movement feedback ≤ 100ms 2) Smooth transition animations between 200-400ms that feel playful 3) Clear visual focus and hover states 4) Satisfying click/tap responses with cartoon-style feedback. Deduct 5 points for each operation without proper feedback, 3 points for jerky animations, and 5 points for unclear interactive elements. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "hard"
-}

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

@@ -1,68 +0,0 @@
-{
-  "index": 34,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure the generated code is executable for demonstration.\nPlease implement a HTML and JavaScript \n### Game Rules\n1. **Choose Mode**: Player can choose to play as black or white against the system.\n2. **Piece Movement**: Following international chess rules, players take turns moving pieces, including pawns, rooks, knights, bishops, queen, and king.\n3. **End Game**: Win the game by checkmate or opponent's surrender.\n\n### Game Features\n- **Single Player**: Players can play a single-player game against the system, which will respond accordingly to the player's moves.\n- **Interactive Teaching**: Players can click on pieces to see possible moves, helping beginners understand piece movements and strategies.\n\n### Game Tips\n- **Opening Layout**: Learn and apply classic opening layouts to establish a good foundation for the middle and end game.\n- **Middle Game Strategy**: Improve overall understanding of the game, especially how to use different piece combinations to create threats.\n- **Endgame Skills**: Master movements with fewer pieces, particularly how to effectively use the king and queen in the final phase.\n\n### Summary\n'Cheap AI Chess' is a chess game suitable for beginners and those looking to improve. Through its simple interface and friendly interactive design, it allows players to easily learn and enjoy the fun of chess.\ngame, and add some comments to the code so that other developers can understand your implementation process.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the chess game implementation complete?",
-      "description": "Review whether the code accurately implements the chessboard with all chess pieces (pawns, rooks, knights, bishops, queen, and king) using HTML/JavaScript, and whether it includes proper validation of legal moves according to international chess rules. Check for special moves like castling, en passant, and pawn promotion. Score 0 if the core game logic is missing, 5 if only basic movement is implemented, and 10 if all standard chess rules are correctly implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the AI opponent properly implemented?",
-      "description": "Evaluate the AI implementation - does it make valid moves and respond to the player's strategies? Check for different difficulty levels if implemented. A basic implementation that makes random legal moves scores 5 points. An AI that shows some strategic thinking scores 8 points. A well-implemented AI with opening book knowledge, tactical awareness, and endgame skills scores 10 points. Score 0 if the AI is not functional.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the mode selection (playing as black or white) implemented?",
-      "description": "Verify that players can choose to play as either black or white pieces, with the AI taking the opposite role. The selection should be clearly presented in the UI, and the game should properly initialize based on the player's choice. Score 0 if the feature is missing, 5 if partially implemented with issues, and 10 if fully functional with proper game state management.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the interactive teaching feature implemented?",
-      "description": "Check whether clicking on pieces shows possible legal moves. The highlighting should be clear and accurate according to chess rules, including consideration of checks, pins, and other restrictions. Score 0 if the feature is missing, 5 if it shows basic moves without considering all rules, and 10 if it accurately displays all possible legal moves with visual cues that are easy to understand.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid moves, attempting to move opponent's pieces, moves that would leave the king in check, 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. Move analysis/suggestions 2. Game history recording and playback 3. Opening book references 4. Visual representation of piece threats/protections). 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 validate moves) 2. Function modules unrelated to the chess game requirements (e.g., unnecessary animations or unrelated features) 3. Fancy effects that affect performance (e.g., excessive graphical effects that slow down gameplay). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/view/controller layers), code commenting as requested, and organization. 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 code comments are insufficient or unclear. 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 representation of the chessboard and pieces (clear distinction between pieces, proper sizing). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, 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 dynamic effects conform to human perception characteristics: 1) Move feedback delay ≤ 100ms 2) Piece movement animations if implemented are smooth and not distracting 3) Clear visual indication of whose turn it is and game state (check, checkmate). Deduct 5 points for each operation without feedback, 3 points for jerky animations, and 5 points for unclear game state indicators. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "medium"
-}

package/library/game_development-strategy/chessboard-wood-texture.json

@@ -1,68 +0,0 @@
-{
-  "index": 1760,
-  "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 display. Change the chessboard color to a standard wood-texture style, and provide me with a complete deployable code.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the chessboard correctly implemented with accurate rendering?",
-      "description": "Evaluate whether the chessboard dimensions are standard (8x8), squares are properly aligned, and piece placement follows chess rules. Check if the wood-texture style is properly implemented using CSS background images or canvas patterns. Score 0 if the board is incorrect, 5 if basic rendering is implemented but with minor issues, and 10 if the chessboard is perfectly rendered with proper wood textures that are not stretching or pixelated.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are all chess pieces correctly displayed with proper styling?",
-      "description": "Review whether all 32 chess pieces are correctly positioned in their initial state and have clear, distinguishable designs. Verify that the pieces contrast well against the wood-texture background. Deduct 3 points if pieces are misaligned, 5 points if some pieces are missing or incorrectly styled, and 5 points if the pieces appear pixelated at standard zoom levels. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the basic chess movement implementation functional?",
-      "description": "Check if the code includes proper event handling for piece selection and movement, with validation for legal chess moves according to each piece type. Verify implementation of special moves (castling, en passant, pawn promotion). Score 0 if movement is not implemented, 5 if only basic movement without special rules is provided, and 10 if all movement rules are correctly implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the wood-texture styling appropriately implemented?",
-      "description": "Assess whether the wood texture appears realistic without being distracting, with proper contrast between light and dark squares. Check if the texture is implemented using optimized images or CSS patterns that don't cause performance issues. Deduct 5 points if the texture appears artificial or cartoonish, 3 points if the grain direction is inconsistent, and 5 points if the texture causes visual readability issues. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid moves, browser resize events, or touch vs. mouse input differences) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Move highlighting 2. Legal move indicators 3. Captured pieces display 4. Check/checkmate notifications with visual effects). 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 methods for piece movement) 2. Function modules unrelated to the chess implementation (e.g., unnecessary animations) 3. Fancy effects that affect performance (e.g., excessive shadows or transitions). 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 chess logic/view layers), code organization, and maintainability. Check for proper commenting and variable naming. 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 is not organized into logical modules. 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 integration of wood texture with UI elements 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system for any chess notations or UI elements (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for clashing color combinations with the wood texture, 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) Piece movement animation is smooth and natural 2) Selection feedback is immediate and clear 3) Transition animations (if any) are controlled between 300-500ms. Deduct 5 points for laggy piece movements, 3 points for missing visual feedback when selecting pieces, and 5 points for jarring or overly slow animations. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "hard"
-}

package/library/game_development-strategy/chinese-chess-game-html.json

@@ -1,68 +0,0 @@
-{
-  "index": 336,
-  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Be careful to ensure that the generated code is executable for demonstration purposes. Please create a complete Chinese chess (Xiangqi) game using HTML.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Chinese chess (Xiangqi) board implementation correct?",
-      "description": "Check if the chessboard adheres to authentic Xiangqi specifications (9×10 grid with river, palace). Verify correct piece placement for both sides (red and black) including proper initial positioning. Deduct 5 points if the board layout is inaccurate, 3 points if piece positions are wrong. Give 0 points if the visual board representation is completely missing.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are all chess pieces properly implemented with correct movement rules?",
-      "description": "Evaluate if all 7 piece types (General/King, Advisor, Elephant, Horse, Chariot, Cannon, Soldier/Pawn) follow correct movement patterns and restrictions (e.g., Elephant cannot cross river, General confined to palace). Check for implementation of special rules like flying General check prevention. Deduct 2 points for each piece type with incorrect movement logic. Score 0 if movement validation is absent.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the game interaction logic fully functional?",
-      "description": "Assess if the game implements proper turn-based mechanics, piece selection, valid move highlighting, and move execution. Check for check/checkmate detection and game-ending conditions. Award 15 points for complete implementation with all features, 10 points if basic functionality works but lacks some refinements, 5 points if interaction is minimal, 0 points if unplayable.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Does the implementation include game state management?",
-      "description": "Verify if the game includes essential state management features: move history tracking, undo/redo functionality, game reset option, and potentially save/load capabilities. Award full points for comprehensive state management with all features, deduct 5 points if only basic state tracking exists, 0 points if no state management is implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid moves, attempted rule violations, etc.) and provide appropriate feedback. Check for event handling cleanup to prevent memory leaks. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Move suggestion system 2. Notation recording in Chinese chess format 3. Sound effects for moves/captures 4. Animation effects). 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 restart the game) 2. Function modules unrelated to Chinese chess (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive animations slowing 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/event handling layers), code organization, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no clear structure or documentation. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the design follows traditional Chinese chess aesthetics while maintaining modern UI principles: 1) Appropriate color scheme for board and pieces with good contrast 2) Clear distinction between red and black pieces 3) Professional typography for any Chinese characters. Deduct 3 points for poor piece visibility, 5 points for inappropriate styling that doesn't match Chinese chess traditions, and 5 points for cluttered layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Immediate visual feedback when selecting pieces 2) Clear indication of possible moves 3) Smooth animation when moving pieces (150-300ms). Deduct 5 points if pieces move without animation, 3 points if selection states are unclear, and 5 points if there's significant lag between user action and visual response. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "hard"
-}

package/library/game_development-strategy/chinese-chess-mini-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 1270,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable and demonstrable. Help me create a Chinese chess mini game that follows the standard Chinese chess board layout and gameplay rules.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Chinese chess board layout implemented correctly?",
-      "description": "Check whether the code accurately implements the standard 9x10 Chinese chess board with properly placed pieces (1 general/marshal, 2 advisors, 2 elephants, 2 horses, 2 chariots, 2 cannons, 5 soldiers/pawns per side). Verify river demarcation and palace areas (3x3 squares). Score 0 if the board layout is incorrect, 5 if basic layout exists but with minor placement errors, and 10 if perfectly implemented with accurate positions and traditional notation.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are the Chinese chess movement rules correctly implemented?",
-      "description": "Review whether the code implements all piece movement rules correctly (general's confinement to palace, advisors' diagonal movement within palace, elephants' can't cross river, horses' leg obstruction, chariots' straight line movement, cannons' jump-capture mechanism, soldiers' forward/lateral movement rules after crossing river). Score 3 for basic movement, 7 for most rules implemented correctly, and 10 if all nuanced rules including illegal moves prevention are implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the game winning condition properly implemented?",
-      "description": "Evaluate the implementation of checkmate detection, general face-to-face rule, and stalemate conditions. Check if the code correctly identifies when a player's general is in check, checkmate, or when generals directly face each other (illegal). Deduct 5 points if check detection is missing, 3 points if the general face-to-face rule is not enforced. Full score requires proper game-ending logic with appropriate win/loss/draw states.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are special gameplay features of Chinese chess implemented?",
-      "description": "Verify if the code includes perpetual check detection, rule of repetitive positions, piece capture visualization, move history notation (traditional Chinese chess notation or modern coordinate system), and possibly time control mechanisms. Award 2 points for each properly implemented feature, with a maximum of 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as out-of-bounds input, invalid moves, multiple clicks on same square, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Move suggestions/hints 2. Move replay functionality 3. Different piece styles/themes 4. Sound effects for moves/captures). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple move validation logics coexisting) 2. Function modules unrelated to Chinese chess (e.g., unnecessary animations) 3. Fancy effects that affect performance (e.g., excessive graphical elements). 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, variable naming, and code reusability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the code lacks comments or documentation. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows traditional Chinese chess aesthetics while maintaining modern usability: 1) Proper piece representation (clear distinction between red and black sides) 2) Appropriate board design with visible grid 3) Clear visual indicators for selected pieces and valid moves. Deduct 3 points for unclear piece designs, 5 points for poor readability of the board, and 5 points for lack of visual feedback during gameplay. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the game interactions conform to user expectations: 1) Piece selection and movement feels natural 2) Move animations (if implemented) are smooth and not distracting 3) Clear visual feedback for illegal moves, checks, and game end conditions. Deduct 5 points for laggy piece movement, 3 points for confusing selection mechanics, and 5 points for missing feedback on important game states. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "hard"
-}