@getollie/cli 0.0.1

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

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

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

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

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

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

package/library/game_development-strategy/interactive-chess-board-game-svg.json

@@ -0,0 +1,68 @@
+{
+  "index": 199,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable for demonstration.\n\nPlease help me implement the following requirement using code, specifically using SVG code. The requirement is to create: Design an interactive chess/board game, displaying the game pieces using SVG graphics.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the SVG-based chessboard correctly implemented?",
+      "description": "Evaluate whether the SVG chessboard is properly structured with the correct dimensions, grid layout (8x8 for chess), and appropriate coordinate system. Check if the squares are correctly colored in an alternating pattern. Deduct 5 points if the grid is inconsistent, 3 points if coordinates are missing or incorrect. Give full 10 points only if the board has proper scaling and responsive design.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the chess pieces accurately represented using SVG?",
+      "description": "Examine whether all chess pieces (pawns, rooks, knights, bishops, queen, and king) are properly implemented as SVG elements with appropriate paths/shapes. Each piece should be visually distinct and follow traditional chess iconography. Deduct 2 points for each piece with significant visual issues, 5 points if pieces lack detail or are difficult to distinguish from each other. Award full 10 points only if pieces demonstrate professional-level SVG craftsmanship with proper scaling and viewBox attributes.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the piece movement interaction properly implemented?",
+      "description": "Review the implementation of drag-and-drop (or click-to-select-and-move) functionality for moving chess pieces. Check if the code includes event listeners for mouse/touch interactions, proper handling of piece selection and placement, and visual feedback during moves. Deduct 5 points if pieces cannot be moved interactively, 3 points if movement lacks visual feedback or has noticeable glitches. Award 10 points if movements are smooth and include proper animations for transitions.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the implementation enforce chess rules correctly?",
+      "description": "Verify that the code enforces standard chess rules: legal move validation, turn-taking, check/checkmate detection, special moves (castling, en passant, promotion), and win conditions. Deduct 2 points for each missing rule implementation, 5 points if the core movement rules are incorrect or inconsistent. Give 10 points only if the implementation handles all standard chess rules including edge cases.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid moves, unexpected user interactions, browser compatibility issues) and provide friendly error messages 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. Visual highlighting of possible moves 2. SVG animations for captures 3. Undo/redo functionality with visual history 4. Piece movement trails or effects). Add 2-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 SVG elements 2. Unnecessary complex SVG paths that could be simplified 3. Extra visual effects that harm performance or distract from 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 SVG rendering/game logic/interaction handlers), code organization, and maintainability. Deduct 5 points if SVG elements are not properly grouped or structured; deduct 5 points if the code lacks comments or documentation; deduct 5 points if there's significant duplication in SVG definitions or JS functions. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the SVG visual design follows modern design principles: 1) Harmonious color scheme for the board and pieces 2) Proper proportions and consistent styling of chess pieces 3) Clear visual distinction between the pieces with appropriate contrast. Deduct 3 points for inconsistent piece styling, 5 points for poor color choices that affect readability, and 5 points for chaotic layout or proportions. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the SVG interactions conform to human perception characteristics: 1) Immediate visual feedback on piece selection 2) Smooth animations for piece movement (150-300ms) 3) Clear visual cues for legal moves and captures. Deduct 5 points for each interaction without feedback, 3 points for jerky or missing animations, and 5 points for confusing interaction patterns that make it difficult to understand game state. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "hard"
+}

package/library/game_development-strategy/interactive-chess-game-svg-javascript.json

@@ -0,0 +1,68 @@
+{
+  "index": 9,
+  "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 purposes. \n\nPlease help me implement the following requirements using SVG code: Design an interactive chess game that allows users to move pieces and view game history, implemented using SVG and JavaScript.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the chess board and pieces visualization accurately implemented using SVG?",
+      "description": "Review whether the SVG code correctly implements the 8x8 chess board grid with proper colors (alternating light and dark squares) and all chess pieces with standard representations. Check if the elements have appropriate ids/classes for manipulation. Pieces should be properly sized and centered in squares. Score 0 if the board is incomplete, 5 if board exists but pieces are improperly represented, 10 if all pieces have proper SVG paths with clean design.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is piece movement and selection properly implemented?",
+      "description": "Evaluate the interaction mechanism for selecting and moving pieces. Check if the code includes proper event listeners (mousedown/click/drag), visual feedback for selection, and validation for legal chess moves. Deduct 5 points if drag-and-drop functionality is missing, 3 points if there's no visual indication of selected pieces, and 5 points if legal move validation is absent. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the chess game logic fully implemented?",
+      "description": "Assess whether the code implements the complete ruleset of chess, including special moves like castling, en passant, pawn promotion, and checks/checkmates. Examine if turn-based gameplay is enforced. Score 0 if basic piece movement rules are missing, 5 if basic rules exist but special moves are not implemented, and 10 if all chess rules are correctly enforced with proper game state management.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the game history viewer functional and comprehensive?",
+      "description": "Check whether the game history is properly recorded and displayed using a standardized format (like algebraic notation). Verify if users can navigate through previous moves, with the board updating accordingly. Deduct 5 points if history is not visually accessible, 3 points if the notation is non-standard or difficult to read, and 5 points if historical positions cannot be reviewed on the board. 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 resizing, out-of-sequence operations) 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 highlighting 2. Captured pieces display 3. Check/checkmate animations or indicators 4. Interactive move analysis). Add 2.5 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to select pieces) 2. Function modules unrelated to chess visualization (e.g., unnecessary animations) 3. Fancy effects that affect performance (e.g., complex shadows or gradients that slow rendering). 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/user interaction layers), code organization, and maintainability. Check if SVG elements are properly structured and manipulated. Deduct 5 points if global state pollution is found; deduct 5 points if the code lacks comments or uses cryptic variable names; deduct 5 points if SVG manipulation is inefficient or uses poor practices. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the SVG design follows modern design principles: 1) Harmonious color matching between board and pieces 2) Proper visual hierarchy with clear distinction between interactive and static elements 3) Clean, readable design for game history view. Deduct 3 points for each visually cluttered element, 5 points for poor color combinations that affect readability, and 5 points for inconsistent styling. 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 animations feel natural (200-300ms) 2) Selection and highlighting provide immediate visual feedback (≤100ms) 3) Game history navigation is intuitive and responsive. Deduct 5 points for choppy animations, 3 points for delayed visual feedback, and 5 points if the interface becomes unresponsive during animations. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "hard"
+}

package/library/game_development-strategy/javascript-planet-defense-game-introduction.json

@@ -0,0 +1,68 @@
+{
+  "index": 4,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. JS Planet Defense Game Introduction\n\n**Game Overview:**\n\"JS Planet Defense Game\" is a strategy defense game developed with JavaScript. Players take on the role of a defense commander in space, operating the only target to combat incoming enemies.\n\n**Gameplay:**\nIn \"JS Planet Defense Game,\" players control a single target, which is the only unit capable of attacking enemies. Players need to use the target's weapon systems and tactical abilities to precisely strike incoming enemies, preventing them from causing damage to Earth or other important objectives. As the game progresses, enemies become increasingly powerful and complex, requiring players to continuously optimize their tactics and strategies to protect their objectives.\n\n**Game Features:**\n1. **Unique Operation Experience**: The uniqueness of the game lies in the fact that players can only operate one target, requiring precise control of movement and attacks to maximize defense effectiveness.\n\n2. **Challenging Level Design**: The game features multiple challenging levels, each with numerous objectives and enemies, demanding flexible thinking and quick reaction from players.\n\n**Game Tips:**\n- **Precise Target Control**: Learn to accurately control the target's movement and attacks, leveraging the characteristics of weapon systems to maximize impact on enemies.\n\n- **Tactical Positioning**: Choose appropriate positions for your target based on enemy movement paths and attack patterns to enhance defensive effectiveness.\n\n- **Tactical Upgrades and Optimization**: Utilize resources and upgrade systems in the game to continuously enhance your target's combat capability and survivability to face increasingly complex enemy challenges.\n\nOverall, \"JS Planet Defense Game\" offers players a brand new space defense challenge through its unique operational experience and deep tactical strategy. Whether pursuing high scores or exploring new tactical layouts, players can find lasting challenges and satisfaction in the game. Please include comments in your code to help other developers understand your implementation process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core target control system properly implemented?",
+      "description": "Evaluate whether the code accurately implements target movement and attack mechanics through JavaScript. Check if the control system includes smooth movement (acceleration/deceleration), precision targeting (hit detection), and proper response to user input (mouse/keyboard). Score 0 if core controls are non-functional, 5 if basic movement and shooting are implemented but lack precision, and 10 if the control system feels responsive and precise with advanced features like aim assist or predictive targeting.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the enemy AI and attack patterns implemented?",
+      "description": "Check whether the code includes sophisticated enemy behavior patterns, varying enemy types with distinct movement and attack strategies, and proper difficulty scaling between levels. Examine if enemies respond dynamically to player positioning. Deduct 5 points if enemies follow only linear paths, 3 points if difficulty scaling is absent, and 2 points if there's no variety in enemy types. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the level design system properly structured?",
+      "description": "Review whether the code implements a comprehensive level progression system with increasing challenges, multiple objectives, and diverse enemy configurations. Check for level parameters configuration, wave management, and event triggering mechanisms. Deduct 5 points if levels are hard-coded with no flexible configuration system, and 3 points if there's no proper game state management between levels. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the tactical upgrade system implemented?",
+      "description": "Assess whether the code includes a robust upgrade system allowing players to enhance the target's capabilities (weapon damage, movement speed, special abilities, etc.). Check for resource management, upgrade persistence between levels, and visual feedback on upgrades. Deduct 5 points if upgrades are limited to simple numerical increases without strategic choices, and 3 points if there's no visual indication of upgrades. 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 fire spamming, browser resizing, off-screen enemies, simultaneous input conflicts, 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 affecting gameplay 2. Voice-controlled alternative inputs 3. Multiplayer observation mode with chat). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple collision detection algorithms) 2. Function modules unrelated to the space defense theme (e.g., a built-in cryptocurrency miner) 3. Fancy effects that affect performance (e.g., excessive particle systems causing frame drops). 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), object-oriented patterns implementation, and performance optimization techniques. 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 no performance optimizations are implemented for rendering or calculations. 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) Space-themed color scheme with appropriate contrast 2) Clear visual hierarchy for game elements (target, enemies, projectiles, and UI) 3) Non-intrusive HUD displaying critical information (health, score, level progress). Deduct 3 points for cluttered UI elements, 5 points for poor contrast making game elements hard to distinguish, and 5 points for essential information being difficult to locate or read. 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) Target response to input under 50ms 2) Visual feedback for hits, misses, and damage 3) Appropriate game pacing with breaks between intense waves. Deduct 5 points for input lag exceeding 100ms, 3 points for missing visual feedback on critical actions, and 5 points for frame rate drops below 30fps during normal gameplay. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "hard"
+}