@getollie/cli 0.0.1

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

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

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

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

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

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

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

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

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

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

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

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

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

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