@getollie/cli 0.0.5 → 0.2.1

package/library/game_development-strategy/html-classical-chess-board.json

@@ -1,68 +0,0 @@
-{
-  "index": 1543,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the code you generate is executable for demonstration. Create a classical chess board in HTML format that can be run directly.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the chess board structure correctly implemented?",
-      "description": "Review whether the code accurately creates an 8x8 chessboard using HTML structure with proper coordinate system (a1-h8). Check if the board uses semantic HTML elements and maintains correct alternating colors for squares. Score 0 if board structure is incorrect or non-standard, 5 if basic 8x8 grid is present but lacks proper labeling, and 10 if complete board with coordinates and proper square identification is implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are all chess pieces properly positioned and visually represented?",
-      "description": "Evaluate whether all 32 chess pieces (16 white, 16 black) are correctly placed in their starting positions according to international chess standards. Check if pieces are clearly distinguishable and use appropriate symbols, images, or Unicode characters. Deduct 3 points for each incorrectly positioned piece type, 5 points if pieces are not visually distinct, and 2 points for poor piece representation quality. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the chessboard styling professionally designed with proper proportions?",
-      "description": "Check whether the chessboard maintains proper square proportions (1:1 aspect ratio), uses traditional light/dark square colors (typically #F0D9B5/#B58863 or similar), and scales appropriately across different screen sizes. Board should be centered and have clear borders. Deduct 5 points if squares are not proportional, 3 points for non-standard colors, and 2 points for poor responsive design. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Does the implementation include proper board labeling and notation system?",
-      "description": "Verify whether the chessboard includes file labels (a-h) and rank labels (1-8) positioned correctly around the board perimeter. Labels should be clearly visible and follow standard chess notation conventions. Score 0 if no labeling system exists, 5 if partial labeling is present but incomplete or incorrectly positioned, and 10 if complete and properly positioned algebraic notation system is implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common edge cases such as different screen sizes, missing assets, and browser compatibility issues. The code should include proper error handling and fallback mechanisms. Code with strong robustness should gracefully handle these scenarios, giving 10 points. If robustness is average, give 5 points, and if no error handling exists, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that enhance the chess board experience?",
-      "description": "Check whether the code includes additional features that improve usability (e.g., 1. Hover effects on squares 2. Click highlighting 3. Piece shadows or 3D effects 4. Board rotation capability 5. Theme switching). Add 2-3 points for each well-implemented enhancement (maximum 10 points). Features must be functional and add genuine value to the chess board experience.",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features or unnecessary complexity?",
-      "description": "Strictly check for three types of redundancy: 1. Overly complex styling that doesn't improve functionality 2. Unnecessary JavaScript for a static board display 3. Excessive animations or effects that distract from the chess board. Deduct 3 points for each redundancy found, and directly deduct 10 points if core board functionality is compromised by unnecessary features.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code demonstrate good engineering practices?",
-      "description": "Review code organization, CSS structure, and HTML semantics. Check for proper separation of concerns (HTML structure, CSS styling), clean and readable code formatting, appropriate use of CSS classes and IDs, and semantic HTML elements. Deduct 5 points for inline styles or poor organization; deduct 3 points for non-semantic HTML; deduct 2 points for inconsistent naming conventions. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the visual design meet professional chess board standards?",
-      "description": "Evaluate whether the design follows traditional chess board aesthetics: 1) Appropriate contrast between light and dark squares 2) Professional color scheme that doesn't strain eyes 3) Clear piece visibility against square backgrounds 4) Proper spacing and margins. Deduct 3 points for poor color contrast, 5 points for unprofessional color choices, and 2 points for cramped or poorly spaced layout. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the chess board immediately usable and visually appealing?",
-      "description": "Judge the overall user experience and visual impact: 1) Board loads quickly and displays correctly 2) All elements are properly aligned and proportioned 3) Professional appearance suitable for actual chess play 4) Clear visual hierarchy and focus. Deduct 5 points for slow loading or display issues, 3 points for misaligned elements, and 2 points for unprofessional appearance. Full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "easy"
-}

package/library/game_development-strategy/html-earth-gomoku-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 971,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be careful to ensure the generated code is executable for demonstration. Now for the question: write me a small HTML Gomoku (Five-in-a-Row) game with the chessboard designed in the shape of the Earth.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Gomoku game core logic fully implemented?",
-      "description": "Review whether the code accurately implements the Gomoku game rules including win detection (5 consecutive pieces), turn switching between players, and preventing moves on occupied positions. Score 0 if the core game logic is missing, 5 if basic functionality works but has edge cases, and 10 if the implementation is complete and bug-free.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the Earth-shaped chessboard properly implemented?",
-      "description": "Evaluate whether the chessboard genuinely resembles Earth (either using CSS border-radius for a spherical appearance, SVG with Earth continents, or Canvas with a spherical projection). Check if the game pieces are properly positioned on the curved surface with appropriate perspective adjustments. Give 0 points if it's just a regular board, 5 points if it's round but lacks Earth features, and 10 points for a realistic Earth representation with continents, oceans, and proper spherical distortion handling.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Does the board implement proper coordinate mapping?",
-      "description": "Verify whether the coordinate system handles the spherical nature of the Earth-shaped board correctly, including accurate click detection on the curved surface and proper piece placement. Check if the coordinate calculation accounts for distortion at the poles or edges. Deduct 5 points if there's noticeable misalignment when placing pieces, and 3 points if edge cases (like poles) aren't handled properly. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there appropriate visual feedback for game state?",
-      "description": "Check if the interface provides clear visual indicators for whose turn it is, valid moves, win conditions, and game completion. Evaluate whether the visuals incorporate Earth-themed elements (e.g., different continents lighting up, atmospheric effects). Deduct 5 points if win detection has no clear visual celebration, 3 points if turn indication is unclear. Full score is 10 points if feedback is both clear and thematically appropriate.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle abnormal situations (incorrect inputs, rapid clicking, browser resizing, etc.) and provides friendly error handling. Code with strong robustness should prevent board state corruption and handle edge cases like simultaneous clicks or invalid placements. Give 10 points for comprehensive error handling, 5 points for average implementation, and 0 points if no error handling exists.",
-      "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. Day/night cycle on the Earth board 2. Animated piece placement with geographical effects 3. Sound effects based on continent placement 4. Gravity or rotation effects for the Earth). 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. Multiple implementations of similar functions (e.g., duplicate win-checking algorithms) 2. Function modules unrelated to Gomoku or Earth theme (e.g., unrelated animations) 3. Excessive effects that affect performance (e.g., constant rotating Earth that hurts gameplay). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are impaired by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (separation of game logic/view/event handling), code reusability, and maintainability. Deduct 5 points if global variables are overused or if the code structure is monolithic; deduct 5 points if there's significant code duplication; deduct 5 points if the code lacks comments or is poorly organized. The full score is 10 points for clean, well-structured code.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the design follows modern principles: 1) Earth colors are realistic and harmonious 2) Game elements have proper contrast against the Earth background 3) Text is legible (instructions, status messages, etc.) with appropriate size and contrast. Deduct 3 points for poor piece visibility, 5 points for unrealistic Earth coloration, and 5 points for cluttered UI elements. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and intuitive?",
-      "description": "Judge whether the interaction feels natural: 1) Pieces place immediately on click (≤100ms) 2) Visual cues show valid placement positions 3) Earth visualization doesn't interfere with gameplay. Deduct 5 points if piece placement feels delayed, 3 points if the Earth representation makes it difficult to see the game state, and 5 points if players might be confused about where to click. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "easy"
-}

package/library/game_development-strategy/html-gomoku-go-board-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 1742,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the generated code is executable for demonstration. Help me create an HTML code file for a Go board (Gomoku) with a white board and black and white stones.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Go board (Gomoku) visual representation fully implemented?",
-      "description": "Check if the code accurately creates a standard Go board with the correct dimensions (typically 19x19 or 15x15 for Gomoku), proper grid lines, and star points (hoshi). Evaluate whether the board has the traditional wooden appearance with appropriate coloring. Score 0 if the board is missing, 5 if only a basic grid is implemented, and 10 if the board has authentic visual details.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are the black and white stones properly implemented?",
-      "description": "Verify that both black and white stones are correctly rendered with appropriate sizing (stones should cover intersection points without obscuring adjacent lines), realistic appearance (including 3D effects or shadows), and proper contrast against the board. Deduct 3 points if stones lack visual depth, 5 points if they're poorly positioned on intersections, and 3 points if they don't match traditional Go stone aesthetics.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the stone placement interaction implemented?",
-      "description": "Evaluate whether the code allows users to place stones on the board through mouse clicks on intersections. Check if the code correctly handles turn-based play (alternating between black and white stones) and prevents placing stones on occupied intersections. Score 0 if no interaction exists, 5 if basic placement works but has issues, and 10 if interaction is smooth and follows Go rules.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are the basic Gomoku game rules implemented?",
-      "description": "Check if the code implements the win condition for Gomoku (5 stones in a row horizontally, vertically, or diagonally). The game should detect winning patterns automatically and notify players. Evaluate whether the game prevents further moves after a win. Score 0 if no win detection exists, 5 if only partial detection is implemented, and 10 if all win conditions are properly handled.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as out-of-bounds clicks, rapid successive clicks, browser resizing, etc.) and provide friendly error handling. 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. Stone placement sound effects 2. Last move indicator 3. Move history/replay functionality). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to place stones) 2. Function modules unrelated to the Go board (e.g., unrelated decorations) 3. Fancy effects that affect performance (e.g., excessive 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 board rendering/game logic/user interaction), code reusability, and efficient DOM manipulation. Deduct 5 points if global variables are overused; deduct 5 points if the code lacks structure or comments; deduct 5 points if performance bottlenecks are evident (e.g., inefficient redrawing of the entire board). 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 Go aesthetics and modern design principles: 1) Authentic board appearance with warm wood tones 2) Proper sizing and proportions of board and stones 3) Clear visual contrast between board and stones. Deduct 3 points for inaccurate board-to-stone proportions, 5 points for non-traditional color schemes, and 5 points for poor spacing or alignment. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and responsive?",
-      "description": "Judge whether the stone placement and other interactions feel natural: 1) Immediate visual feedback when placing stones 2) Smooth transitions or subtle animations if included 3) No noticeable lag between click and stone appearance. Deduct 5 points for delayed feedback, 3 points for jerky animations, and 5 points for unresponsive or confusing interaction patterns. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "medium"
-}

package/library/game_development-strategy/html-javascript-castle-defense-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 156,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate, expert responses. Make sure the generated code is executable.\n# Please implement a Castle Defense game using HTML and JavaScript.\n# Task: Design a castle defense game where players need to defend against enemy attacks and protect the castle.\n# Hint: Implement enemy AI and defense strategies.\n# Include comments in your code to help other developers understand your implementation process.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core castle defense gameplay implemented?",
-      "description": "Review whether the code implements the fundamental elements of a castle defense game: castle structure, enemy spawning system, defensive mechanisms, and win/loss conditions. Score 0 if the core gameplay is missing, 5 if basic elements are present but incomplete, and 10 if the game includes varied enemy types, multiple defense options, and proper game flow with difficulty progression.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the enemy AI system properly implemented?",
-      "description": "Evaluate the sophistication of the enemy AI. Check for path-finding algorithms, target selection logic, attack patterns, and difficulty scaling. Deduct 5 points if enemies move in predefined patterns only, 3 points if there's no variety in enemy types or behaviors. Give full score if AI includes strategic decision-making, adapts to player actions, and features different enemy types with unique behaviors.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are the defense strategies and player interaction mechanisms implemented?",
-      "description": "Check whether the code implements varied defensive options (towers, traps, special abilities) and intuitive player controls. Assess if the placement system works correctly, if upgrade paths exist, and if resource management is implemented. Deduct 4 points if only a single defense type exists, 3 points if placement validation is missing, and 3 points if there's no upgrade system.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Does the game have proper wave management and difficulty progression?",
-      "description": "Evaluate the wave system implementation, including timing mechanisms, enemy variety per wave, increasing difficulty, and wave notification system. Check for a balanced difficulty curve. Deduct 5 points if waves are static with no progression, 3 points if there's no visual indication of incoming waves, and 2 points if difficulty scaling is poorly balanced.",
-      "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, resource miscalculations, rapid user clicks, game speed variations) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Dynamic weather effects that impact gameplay 2. Special events or boss battles 3. Interactive environment elements). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple enemy spawning systems) 2. Function modules unrelated to castle defense (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive particle effects that cause lag). 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/input handling layers), code organization, and maintainability. Assess whether the code follows proper object-oriented principles for game entities. Deduct 5 points if global state pollution is found; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there are no comments despite the requirement. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the game UI follows game design principles: 1) Clear visual hierarchy for game elements 2) Intuitive controls and feedback 3) Readable game information display (health, resources, wave information). Deduct 3 points for cluttered UI elements, 5 points for unclear visual distinction between enemies and defenses, and 5 points for information overload or poorly organized HUD. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the game's dynamic effects enhance gameplay: 1) Responsive controls with immediate feedback 2) Smooth animations for tower placement, attacks and enemy movement 3) Clear visual and audio cues for important events (wave start, castle damage). Deduct 5 points for laggy animations, 3 points for missing feedback on player actions, and 5 points for confusing visual effects during intense gameplay. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "medium"
-}

package/library/game_development-strategy/html-javascript-treasure-hunt-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 84,
-  "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.\nPlease use HTML and JavaScript to implement a Treasure Hunt game.\n**Task**: Design a treasure hunt game where players need to explore and fight to find hidden treasures.\n**Hint**: Set up randomly generated treasure locations and enemies. Players need to defeat enemies and solve puzzles to obtain treasures.\nPlease include comments in your code so that other developers can understand your implementation process.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core game exploration system fully implemented?",
-      "description": "Review whether the code accurately implements map generation with randomized treasure locations. Check if the player movement system works correctly with proper collision detection. Score 0 if the exploration mechanic is missing, 5 if basic movement is implemented but without proper treasure randomization, and 10 if the exploration system is complete with diverse areas and discovery mechanics.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the combat system properly implemented?",
-      "description": "Evaluate whether the game includes a functioning combat system where players can engage with enemies. Check if there are different enemy types, health/damage mechanics, and combat animations. Score 0 if combat is absent, 5 if only basic combat is implemented (single enemy type, simple hit mechanics), and 10 if the combat system is comprehensive (multiple enemy types, varied attacks, strategic elements).",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are puzzles integrated into the treasure hunting gameplay?",
-      "description": "Check if the code includes puzzle mechanics that players must solve to access treasures. Puzzles should have clear objectives, interactive elements, and validation logic. Score 0 if puzzles are missing, 5 if only basic puzzles exist (e.g., simple key collection), and 10 if multiple diverse puzzle types are implemented with increasing complexity.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the treasure reward system properly implemented?",
-      "description": "Evaluate whether treasures have varied types/rarities and provide meaningful rewards to the player. Check if there's a proper inventory system to track found treasures. Score 0 if treasures are merely decorative or missing, 5 if basic treasure collection exists without variety, and 10 if treasures have diverse properties, rarities, and gameplay effects.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid user inputs, game state errors, or browser inconsistencies) 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 difficulty adjustment based on player performance 2. Procedurally generated maps with seed sharing 3. Environmental interaction beyond basic movement). 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 movement systems coexisting) 2. Function modules unrelated to treasure hunting gameplay (e.g., an unnecessary mini-game) 3. Fancy effects that affect performance (e.g., excessive particle systems). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game states, entity management, rendering, and input handling), code reusability, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there are no comments or documentation as requested in the requirements. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern game UI principles: 1) Consistent visual theme matching the treasure hunt concept 2) Clear HUD elements (health, inventory, map) with proper spacing 3) Readable text with appropriate contrast against backgrounds. Deduct 3 points for each misaligned UI element, 5 points for inconsistent visual style, and 5 points for poor readability or cluttered information display. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the game's dynamic effects enhance playability: 1) Responsive controls with < 100ms feedback 2) Smooth animations for movement, combat and treasure discovery 3) Clear visual/audio feedback for important events (enemy encounters, puzzle solving, treasure found). Deduct 5 points for input lag or unresponsive controls, 3 points for jerky animations, and 5 points for lack of feedback when interacting with game elements. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "medium"
-}

package/library/game_development-strategy/html-mobile-tower-defense-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 1770,
-  "question": "You are a coding expert. Please use your professional knowledge to generate accurate and professional responses. Make sure that the code you generate is executable for demonstration. Design a tower defense game that can be played on mobile phones using HTML language.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core tower defense game mechanics fully implemented?",
-      "description": "Evaluate whether the code implements the basic tower defense mechanics (tower placement, enemy pathing, wave system, currency/resources). Check for collision detection between projectiles and enemies, and proper damage calculation. Score 0 if core gameplay is missing, 5 if only basic functionality exists, 10 if there's a complete, balanced gameplay system with variety of towers and enemies.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the mobile-first design approach properly implemented?",
-      "description": "Verify if the implementation includes touch controls, responsive design (using viewport meta tags, media queries, flexible grid layouts), and appropriate UI scaling for mobile screens. Check for touch event handling (touchstart, touchmove, touchend) instead of only mouse events. Deduct 5 points if there's no touch support, 3 points if the layout breaks on common mobile resolutions (320px-428px width). Full score requires fully functional touch controls with proper hit areas (≥44px).",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the game loop and performance optimization suitable for mobile devices?",
-      "description": "Assess if the game loop uses requestAnimationFrame properly, implements throttling for intensive operations, and optimizes rendering for mobile GPUs. Check for battery-efficient code (avoiding constant redraws, using object pooling). Deduct 5 points if the frame rate drops below 30fps on mid-range devices, 3 points if there's no performance monitoring. Give 10 points if the game maintains 60fps with proper resource management.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the game state management and progression system properly designed?",
-      "description": "Evaluate if the code includes save/load functionality (using localStorage), level progression, difficulty scaling, and persistent upgrades. Check for proper pause/resume functionality when the browser tab loses focus or during incoming calls. Deduct 5 points if there's no state persistence between sessions, 3 points if the game doesn't handle interruptions gracefully. Give 10 points for a complete progression system with multiple levels and challenges.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as touch input errors, orientation changes, memory limitations on low-end devices, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Dynamic weather effects that affect gameplay 2. Social sharing of gameplay results 3. Unique tower combination mechanics). 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 wave generation systems) 2. Function modules unrelated to tower defense gameplay (e.g., unnecessary mini-games) 3. Heavy visual effects that affect mobile performance (e.g., excessive particle systems). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game entities/rendering/input handling), code organization, and potential for maintenance/extension. 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 asset preloading or optimized resource management. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet mobile gaming design standards?",
-      "description": "Evaluate whether the UI follows mobile game design best practices: 1) Touch targets of at least 44px × 44px 2) Clear visual hierarchy and contrast for outdoor visibility 3) Properly sized text (minimum 16px) 4) Minimal UI that doesn't obstruct gameplay. Deduct 3 points for each UI element that's too small for touch, 5 points for poor contrast that hampers outdoor visibility, and 5 points for cluttered interfaces that obscure the game field. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and optimized for mobile?",
-      "description": "Judge whether the touch interactions feel natural and responsive: 1) Touch response time ≤ 100ms 2) Smooth dragging for tower placement 3) Intuitive pinch-to-zoom and swipe gestures 4) Haptic feedback for important actions. Deduct 5 points for touch latency > 200ms, 3 points for janky animations during gameplay, and 5 points for imprecise hitboxes that cause user frustration. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "medium"
-}

package/library/game_development-strategy/html-offline-dou-dizhu-card-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 1106,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Ensure that the code you generate can be executed properly. Please create an HTML-based Dou Dizhu (Fighting the Landlord) card game that can be played offline without requiring an internet connection.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core card game rule system fully implemented?",
-      "description": "Review whether the code correctly implements all Dou Dizhu rules including card ranking, valid combinations (singles, pairs, straights, bombs, etc.), and the special role of jokers. Score 0 if the core rules are missing, 5 if only basic play patterns are implemented, and 10 if all official rules including rocket bombs, sequence of 3 pairs, etc. are fully included with proper validation logic.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the single-player offline gameplay complete?",
-      "description": "Check whether the implementation includes all game phases: card dealing, bidding for landlord role, playing rounds, determining winners, and scoring. The AI opponents should make reasonable decisions. Deduct 5 points if the bidding phase is missing, 5 points if the AI makes completely random moves without strategy, and 3 points if the scoring system isn't implemented. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the card dealing and AI logic properly implemented?",
-      "description": "Evaluate whether the card shuffling algorithm is truly random, if the 3 additional landlord cards are correctly allocated, and if the AI opponents have basic strategic thinking (e.g., saving bombs, recognizing card combinations). Deduct 5 points if the card distribution is predictable/biased, and 5 points if the AI cannot recognize basic strategic patterns like holding onto higher cards. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the game state management robust?",
-      "description": "Check if the code maintains proper game state including current player's turn, played cards history, remaining cards for each player, and win conditions. There should be no way to get into an invalid game state. Deduct 5 points if game state can become corrupted during play, 3 points if the turn management can fail in edge cases, and 3 points if win detection has flaws. 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, UI state corruption, rapid clicking, etc.) and provide friendly error handling or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Card play hints/suggestions 2. Game history replay 3. Different difficulty levels for AI 4. Card 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 card validation methods) 2. Function modules unrelated to the Dou Dizhu game (e.g., unnecessary minigames) 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/AI strategy 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 separation between UI and game logic. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Clear card representation and differentiation 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 difficult-to-distinguish cards, and 5 points for chaotic player/card layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Card selection feedback delay ≤ 100ms 2) Card dealing and playing animations between 300-500ms 3) Clear visual guidance for whose turn it is. Deduct 5 points for each operation without feedback, 3 points for laggy card animations, and 5 points for unclear turn indicators. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "hard"
-}

package/library/game_development-strategy/html-tower-defense-mini-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 1379,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable and can be demonstrated. Create a tower defense mini-game that can run in HTML.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core tower defense gameplay implemented?",
-      "description": "Evaluate whether the game implements essential tower defense mechanics: enemy pathing along a defined route, tower placement system, firing/damage mechanics, wave progression, and win/loss conditions. Score 0 if core mechanics are missing, 5 if basic mechanics work but lack depth, 10 if all expected tower defense mechanics are properly implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the tower variety and upgrade system functional?",
-      "description": "Check if the game offers multiple tower types with distinct attributes (damage, range, attack speed, special effects) and an upgrade system. Deduct 3 points if fewer than 3 tower types are implemented, 3 points if towers lack meaningful differentiation, and 5 points if the upgrade mechanism is missing or broken. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the enemy wave system properly designed?",
-      "description": "Assess if the game features increasing difficulty through progressive waves with varied enemy types (different speeds, health, resistances). Check if wave timing, spawn rates, and difficulty scaling are balanced. Deduct 5 points if enemy variety is missing, 3 points if difficulty progression is flat, and 3 points if wave announcements/timing are unclear. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the resource/economy system balanced?",
-      "description": "Evaluate the implementation of a resource system (money/currency) that rewards player actions and enables strategic decisions between saving and spending. Check if initial resources, costs, and earning rates create meaningful choices. Deduct 5 points if the economy is easily exploitable, 5 points if resource gain is too slow/fast disrupting game balance, and 3 points if visual feedback for transactions 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 rapid clicking, invalid tower placement, browser resizing, etc.) and provide friendly error handling 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. Special tower abilities/combos 2. Environmental interactions 3. Dynamic weather effects that impact gameplay 4. Unlockable achievements). 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 overlapping damage calculation systems) 2. Function modules unrelated to tower defense (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive particle effects causing lag). 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 entities, rendering, and game logic), proper encapsulation of game objects, and efficient collision detection algorithms. 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 separation between game logic and rendering. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern game UI principles: 1) Consistent visual theme with harmonious color palette 2) Clear distinction between interactive and decorative elements 3) Intuitive tower selection and placement UI 4) Visible status indicators for health, resources, and wave information. Deduct 3 points for cluttered UI, 5 points for illegible text or icons, and 5 points for confusing game state representation. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the game interactions meet performance standards: 1) Consistent frame rate (min. 30 FPS) 2) Responsive tower placement/selection (≤ 100ms delay) 3) Clear visual feedback for tower attacks, enemy damage, and resource changes 4) Smooth animations for game entities. Deduct 5 points for stuttering gameplay, 3 points for delayed feedback on critical actions, and 5 points for unclear visual indication of game state changes. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "hard"
-}