@getollie/cli 0.0.1

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

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

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

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

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

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

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

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

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

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

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

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