@getollie/cli 0.0.1

package/library/game_development-strategy/javascript-tank-battle-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1614,
+  "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. Write a Tank Battle game using JavaScript language.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the tank battle core game mechanics fully implemented?",
+      "description": "Review whether the code accurately implements tank movement (8-directional or smooth rotation), shooting mechanics with projectile physics, collision detection between tanks/bullets/obstacles, and health/damage system. Score 0 if basic tank control is missing, 5 if only movement or shooting works independently, and 10 if all combat mechanics including hit detection, damage calculation, and game over conditions are fully functional.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the game map and obstacle system properly designed?",
+      "description": "Check whether the battlefield includes destructible/indestructible obstacles, boundary collision detection, and strategic map layout. Evaluate if the map generation supports multiple levels or random generation. Deduct 5 points if tanks can pass through walls, 3 points if bullet-obstacle collision is inaccurate, and 5 points if the map lacks strategic depth. The full score requires proper tile-based collision system and varied terrain.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the game loop and state management architecture sound?",
+      "description": "Evaluate whether the game uses proper requestAnimationFrame for smooth rendering, implements clear separation between game logic and rendering, and maintains consistent frame rate (ideally 60fps). Check for proper game state management (menu, playing, paused, game over). Deduct 5 points if frame rate drops below 30fps, 3 points if game states are not properly managed, and 5 points if update/render cycles are mixed together.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are multiplayer or AI opponents effectively implemented?",
+      "description": "Check whether the game includes AI tank behavior with pathfinding, target acquisition, and tactical decision-making, or implements local multiplayer with separate controls. AI should demonstrate strategic behavior beyond random movement. Deduct 5 points if AI lacks collision avoidance, 3 points if AI behavior is too predictable, and 5 points if multiplayer controls conflict. Full score requires sophisticated AI or smooth multiplayer experience.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid key presses, boundary conditions, simultaneous collisions, browser compatibility issues) and provide graceful error handling. Code with strong robustness should prevent crashes, handle edge cases, and maintain game stability. Give 10 points if fully robust, 5 points if average robustness with minor issues, and 0 points if no exception handling exists.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes engaging features that enhance gameplay experience (e.g., 1. Power-ups and special weapons 2. Particle effects for explosions 3. Mini-map or radar system 4. Sound effects and background music 5. Score/leaderboard system). Add 2 points for each well-implemented innovative feature (maximum 10 points). Features must be functional, not just cosmetic.",
+      "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 methods coexisting) 2. Function modules unrelated to tank battle (e.g., built-in calculator) 3. Performance-heavy effects that cause lag (e.g., excessive particle systems). Deduct 3 points for each redundancy found, and directly deduct 10 points if core gameplay is 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, physics, rendering, and input handling), code organization with proper class structure, and maintainable code practices. Deduct 5 points if global variables are overused or no design patterns are applied; deduct 5 points if code duplication rate exceeds 30%; deduct 3 points if functions are too long (>50 lines) or poorly named. The full score requires clean, well-structured, and maintainable code.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the game graphics follow good visual design: 1) Consistent art style and color palette (no more than 4 primary colors) 2) Clear visual hierarchy and readable UI elements 3) Appropriate sprite/asset quality and scaling 4) Professional-looking HUD with health bars, score display. Deduct 3 points for each poorly designed visual element, 5 points for jarring color combinations, and 5 points for unclear game state indicators. Screenshots should demonstrate polished visual presentation.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the game controls and animations provide excellent user experience: 1) Tank movement response time ≤ 50ms 2) Smooth rotation and movement animations 3) Satisfying explosion and hit effects 4) Clear audio-visual feedback for all actions. Deduct 5 points for each unresponsive control, 3 points for jerky animations or missing feedback, and 5 points for confusing visual cues. The full score requires fluid, responsive, and satisfying game feel.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "medium"
+}

package/library/game_development-strategy/magic-trials-game-with-skill-tree.json

@@ -0,0 +1,68 @@
+{
+  "index": 40,
+  "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.\n\nPlease use HTML and JavaScript to implement a Magic Trials game where players need to pass through a series of trials to enhance their magical abilities.\n\nHint: Implement a trial system and a magic skill tree.\n\nPlease add comments to your code so other developers can understand your implementation process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Magic Trials game core system fully implemented?",
+      "description": "Examine whether the code implements the fundamental trial system through HTML/JavaScript, including different types of challenges, progression mechanics, and win/fail conditions. Score 0 if core game mechanics are missing, 5 if only basic trial completion is implemented, and 10 if there's a robust system with varied trial types, difficulty progression, and meaningful player choices.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the magic skill tree fully implemented?",
+      "description": "Check whether the code implements a comprehensive magic skill tree with dependencies, unlock conditions, visual representation, and skill effects. Evaluate if there are different skill categories, progression paths, and meaningful choices. Score 0 if the skill tree is absent, 5 if there's only a basic linear progression, and 10 if there's a complex, branching skill system with visual feedback and meaningful player progression.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there a proper game state management system?",
+      "description": "Review the implementation of game state tracking, including player progress, acquired skills, completed trials, and persistent data storage (localStorage or similar). Check if the game properly handles saving/loading game state. Deduct 5 points if there's no persistence between sessions, and 3 points if state transitions are buggy or incomplete. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there meaningful integration between trials and skill progression?",
+      "description": "Assess whether completing trials provides meaningful rewards in the skill tree, and if acquired skills affect trial performance in return. Check if the game maintains balance between challenge and progression. Deduct 5 points if trials and skills are disconnected systems, and 3 points if the progression feels arbitrary or unbalanced. Give 10 points if fully implemented with clear feedback loops.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid input, broken skill dependencies, user operation errors, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Visual spell casting effects 2. Elemental trial themes with unique mechanics 3. Interactive tutorials with visual guidance). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to track progress) 2. Function modules unrelated to the magic theme (e.g., unnecessary minigames) 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 logic/view layers), code organization, comprehensive commenting as requested, 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 comments are insufficient or misleading. 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 that evokes a magical theme 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Magic animations and transitions feel satisfying and appropriate (300-500ms) 3) Clear visual feedback for trial completion and skill acquisition. Deduct 5 points for each operation without feedback, 3 points for jarring or abrupt transitions, and 5 points for confusing navigation between trials and the skill tree. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "easy"
+}

package/library/game_development-strategy/mahjong-tile-layout-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1467,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Be sure to ensure that the generated code is executable for display. Help me write a game that first lays out a standard set of mahjong tiles on the interface, displaying 10 tiles per row in a random order.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the complete mahjong tile set properly implemented?",
+      "description": "Check whether the code correctly defines all 144 standard mahjong tiles (including 36 Character tiles, 36 Bamboo tiles, 36 Circle tiles, 16 Wind tiles, 12 Dragon tiles, and 8 Bonus tiles). Verify that each tile has the correct properties (type, value, image). Score 0 if significant tiles are missing, 5 if the set is incomplete but functional, and 10 if the complete set is properly implemented with accurate properties.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the random tile layout algorithm implemented correctly?",
+      "description": "Evaluate whether the code implements a proper random shuffling algorithm (such as Fisher-Yates) to ensure unbiased randomization of tiles. Check if the code avoids common pitfalls like modifying arrays during iteration or using Math.random() incorrectly. Deduct 5 points if the randomization shows patterns or biases, and 3 points if the shuffling algorithm is inefficient. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the grid layout system implemented properly?",
+      "description": "Verify that the code correctly implements a grid layout system that displays 10 tiles per row as specified. Check whether the layout adjusts appropriately to different screen sizes and handles edge cases (like the last row having fewer than 10 tiles). Examine if the tiles are properly aligned and spaced. Deduct 5 points if the grid layout is inconsistent or breaks on different viewport sizes, and 3 points if the alignment is visually problematic. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are the visual representations of mahjong tiles accurate and authentic?",
+      "description": "Examine whether each mahjong tile is visually represented with accurate and culturally authentic designs, proper coloring, and clear symbols. The code should either use appropriate image assets or accurately render the tiles using HTML/CSS/SVG. Deduct 5 points if the visual representations are inaccurate or difficult to distinguish, and 3 points if they lack cultural authenticity. 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 image loading failures, rendering on different browsers, user interaction edge cases, 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. Tile hover effects with information 2. Sound effects when arranging tiles 3. Animation when shuffling tiles). 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 shuffling algorithms coexisting) 2. Function modules unrelated to mahjong tile display (e.g., a built-in scoreboard when not needed) 3. Fancy effects that affect performance (e.g., excessive animations slowing down 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 tile data/view/layout logic), reusability of components, and code organization. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the implementation is monolithic without 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 overall design follows modern design principles: 1) Harmonious color matching (using traditional mahjong colors appropriately) 2) Proper layout spacing (consistent margins between tiles, following the 8px multiple principle) 3) Professional visual hierarchy (clear distinction between different tile types). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic tile arrangement. 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) Initial tile arrangement animation is smooth and not jarring 2) Transition effects when shuffling controlled between 300-500ms 3) Clear visual feedback on any tile interactions. Deduct 5 points for each operation without feedback, 3 points for stuttering animations, and 5 points for confusing or disorienting transitions. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "easy"
+}

package/library/game_development-strategy/ming-dynasty-palace-intrigue-mini-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1306,
+  "question": "You are a coding expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the code you generate is executable for display. Create a palace intrigue mini-game based on the Ming Dynasty using minimal code.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the palace intrigue gameplay system fully implemented?",
+      "description": "Review whether the code accurately implements the core palace intrigue mechanics (character relationships, status changes, plotting actions) through clear JavaScript functions. Score 0 if core intrigue logic is missing, 5 if only basic relationship changes are implemented, 10 if comprehensive court politics mechanics including alliances, betrayals, and consequences are included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the Ming Dynasty historical context incorporated correctly?",
+      "description": "Evaluate whether the game incorporates authentic Ming Dynasty elements (correct titles, historical figures, palace structures, and political systems). Look for historical accuracy in character titles, events, and setting. Deduct 5 points if major historical inaccuracies exist, 3 points if ming-specific elements are minimal or generic. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there a functional game state management system?",
+      "description": "Check whether the code implements proper state management for player actions, NPC behaviors, and game progression. Examine if the state transitions are logical and if player choices meaningfully impact outcomes. Deduct 5 points if state management is rudimentary without consequences, 3 points if game state isn't persistent across actions. Give 10 points if fully implemented with multiple branching storylines.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the player interaction and decision-making system comprehensive?",
+      "description": "Assess whether the code provides meaningful player choices that affect gameplay outcomes. Check for dialogue systems, decision points, and consequence tracking. Award 10 points if choices significantly alter game progression with visible consequences, 5 points if choices exist but have minimal impact, 0 points if the game is purely linear without meaningful decisions.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid inputs, illogical game states, edge case player decisions, 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 character loyalty system 2. Hidden agenda mechanics 3. Procedurally generated court scandals). 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 dialogue systems coexisting) 2. Function modules unrelated to palace intrigue (e.g., a built-in combat system) 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 game logic/view/data 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 and difficult to follow. 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 Ming Dynasty aesthetic principles while maintaining usability: 1) Appropriate color scheme (reds, golds, and traditional colors) 2) Proper layout spacing and hierarchy 3) Professional text formatting (readable fonts, appropriate size). Deduct 3 points for each crowded visual element, 5 points for modern design elements that break immersion, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the code minimal while maintaining complete functionality?",
+      "description": "Judge whether the code achieves the required functionality with optimal efficiency: 1) No unnecessary libraries or dependencies 2) Concise function implementations 3) Elegant solutions to complex problems. Deduct 3 points for each instance of code bloat, 5 points for unnecessary external dependencies, and 5 points for implementations that could be significantly simplified. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "easy"
+}

package/library/game_development-strategy/mini-tank-battle-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1366,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Make sure that the code you generate is executable for demonstration purposes. Please provide me with a set of code for a mini Tank Battle game.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core Tank Battle gameplay mechanics fully implemented?",
+      "description": "Check if the code includes tank movement controls, shooting mechanics, collision detection, and battle logic. Score 0 if core gameplay is missing, 5 if only basic movement is implemented, and 10 if full gameplay with proper tank controls, shooting, and hit detection is included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the game entities and their interactions properly designed?",
+      "description": "Evaluate if tanks, bullets, obstacles, and game environment classes are well-defined with appropriate properties and methods. Check if entity interactions (tank-bullet collisions, tank-obstacle collisions) are handled correctly. Deduct 3 points if entity design is incomplete, 5 points if interactions are buggy, and give 10 points for comprehensive implementation.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the game rendering system effective?",
+      "description": "Assess whether the game uses appropriate rendering techniques (Canvas/WebGL/DOM), implements a game loop with proper frame rate control, and handles screen resizing. Deduct 3 points if rendering is inefficient, 5 points if animation isn't smooth, and give 10 points for optimized rendering with consistent frame rates.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the game state management properly implemented?",
+      "description": "Review if the code includes proper game state management (start menu, gameplay, game over states), score tracking, and level progression. Check for proper initialization and reset functionality. Deduct 5 points if state transitions are buggy, 3 points if score tracking is missing, and give 10 points for complete state management.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as unexpected input, browser inconsistencies, performance issues) 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. Power-ups and special weapons 2. Dynamic terrain destruction 3. Multiplayer capability 4. AI opponents with different behaviors). 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 tank battles (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive particle effects). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game logic/view/controller layers), code organization, 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 structured organization of code files/modules. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the game visuals follow good design principles: 1) Consistent visual style 2) Clear visual distinction between game elements 3) Readable UI elements and text. Deduct 3 points for inconsistent visual elements, 5 points for unclear distinctions between game objects, and 5 points for hard-to-read UI. Check if tanks, terrain and game elements have appropriate visual representation. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the game controls and dynamic effects feel responsive: 1) Tank movement responds within 100ms of input 2) Shooting mechanics have appropriate feedback 3) Game provides clear visual/audio feedback for hits and game events. Deduct 5 points for laggy controls, 3 points for missing feedback on important actions, and 5 points for confusing or unintuitive controls. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "easy"
+}

package/library/game_development-strategy/mobile-chinese-chess-human-vs-computer.json

@@ -0,0 +1,68 @@
+{
+  "index": 1789,
+  "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. Create a mobile version of Chinese chess (Xiangqi) that allows for human vs. computer gameplay, which can be opened directly on a mobile phone.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core Chinese chess (Xiangqi) game logic fully implemented?",
+      "description": "Review whether the code accurately implements the board structure (9x10 grid), all pieces with correct movement rules (General/King, Advisor, Elephant, Horse, Chariot, Cannon, Soldier/Pawn), and game rules (check, checkmate, stalemate, river crossing for pawns). Score 0 if the core logic is missing, 5 if only basic piece movement is implemented, and 10 if all Chinese chess rules are correctly implemented with move validation.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the human vs. computer AI opponent functionality implemented?",
+      "description": "Evaluate the AI implementation for the computer opponent. Check for basic move generation, evaluation function, search algorithms (minimax/alpha-beta pruning/MCTS), and difficulty levels. Deduct 5 points if AI makes illegal moves, 3 points if AI strategy is too simplistic (random moves), and 2 points if there are no difficulty options. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the mobile-specific UI/UX properly implemented?",
+      "description": "Assess if the interface is truly mobile-optimized with responsive design, touch controls (vs. mouse events), proper viewport settings, and mobile gestures support. Deduct 5 points if the board doesn't resize properly for different screens, 3 points if touch areas are too small (<44px), and 3 points if no mobile-specific meta tags are implemented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the game state management and persistence implemented?",
+      "description": "Check whether the code includes game state management (move history, undo/redo functionality) and persistence (saving game state locally via localStorage/IndexedDB). Evaluate if players can continue games after closing the browser. Deduct 5 points if move history isn't tracked, 5 points if no save/load functionality exists, and 3 points if the persistence mechanism isn't reliable. 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 back button usage, network fluctuations, device orientation changes, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Move hints with color-coded suggestions 2. Audio feedback with traditional Chinese sounds 3. Animation for capturing pieces 4. AR view of the chessboard). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple move validation logics) 2. Function modules unrelated to Chinese chess (e.g., unnecessary social sharing features) 3. Fancy effects that affect performance on mobile devices (e.g., excessive animations that drain battery). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game logic/view/controller layers), optimization for mobile (asset loading strategy, touch event debouncing), and offline capabilities. Deduct 5 points if global state pollution is found or proper patterns aren't used; deduct 5 points if the code isn't minified/optimized for mobile; deduct 5 points if there's no manifest file or offline support. 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 mobile design principles: 1) Traditional Chinese chess aesthetics with modern UI elements 2) Proper touch target sizing (minimum 44×44px) 3) Clear visual hierarchy with contrasting piece colors. Deduct 3 points for each hard-to-see game element, 5 points for poor contrast between pieces and board, and 5 points for text that's too small to read on mobile (<16px). The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and responsive on mobile devices?",
+      "description": "Judge whether the dynamic effects are optimized for mobile: 1) Touch response delay ≤ 100ms 2) Smooth piece movement animation (60fps) 3) Clear visual/haptic feedback for moves. Deduct 5 points for laggy animations on mid-range devices, 3 points for lack of touch feedback, and 5 points for non-optimized assets causing slowdowns. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "hard"
+}

package/library/game_development-strategy/monopoly-game-web-browser.json

@@ -0,0 +1,68 @@
+{
+  "index": 1552,
+  "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. Write a Monopoly game that can be run on a web browser.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Monopoly game board fully implemented?",
+      "description": "Review whether the code accurately implements the Monopoly board layout with all 40 standard spaces (properties, utilities, railroads, chance/community chest, Go, Jail, etc.) through HTML/CSS/JavaScript. Check if property information (prices, rent structures, color groups) is correctly defined. Score 0 if the board is incomplete, 5 if basic layout exists but lacks details, 10 if the full Monopoly board with accurate property details is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the core Monopoly game mechanics implemented?",
+      "description": "Evaluate if the code includes essential game mechanics: dice rolling, player movement, property purchasing, rent collection, passing GO ($200), Chance/Community Chest cards, Jail mechanics, house/hotel building, and mortgaging properties. Deduct 2 points for each missing core mechanic. The full implementation should include proper turn management and transaction handling between players.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is player interaction and game flow properly managed?",
+      "description": "Check if the game flow follows Monopoly rules with clear turn progression: roll dice, move, land on space, take appropriate action, and end turn. Evaluate if the UI provides proper controls for each action (buy property, build houses, mortgage, trade, etc.). Deduct 3 points if turn sequence is incorrect, 3 points if core actions aren't available at appropriate times, and 4 points if important decision points lack user feedback.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is multi-player functionality implemented?",
+      "description": "Assess whether the game supports 2-8 players as per standard Monopoly rules, with appropriate player setup, turn management, and transaction handling between players. Check if the game tracks player statistics (cash, properties owned, position) correctly. Score 0 if only single-player exists, 5 if basic multiplayer exists but with flaws, 10 if full multiplayer with proper turn handling and player interactions is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle edge cases like bankruptcy procedures, property auctions when players decline to buy, trading with negative cash balance, and unusual dice roll combinations. Code with strong robustness should validate all user inputs, prevent illegal moves, and maintain game state consistency. Give 10 points if these edge cases are handled properly, 5 points if partially handled, and 0 points if major game-breaking issues exist.",
+      "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. Game history/statistics visualization 2. Custom house rules options 3. Animated dice and player tokens 4. AI opponents with different strategies 5. Save/load functionality). Add 2 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to handle the same game event) 2. Function modules unrelated to Monopoly (e.g., unrelated mini-games) 3. Fancy effects that affect performance (e.g., excessive animations that slow 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/state management), code organization, and maintainability. Deduct 3 points if global state is poorly managed; deduct 3 points if code lacks comments or documentation; deduct 4 points if there's significant code duplication or spaghetti code. The full score is 10 points for clean, maintainable code with good separation of concerns.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the design follows Monopoly's traditional aesthetic while maintaining usability: 1) Appropriate color scheme matching traditional Monopoly colors 2) Clear property ownership indicators 3) Readable game information displays (cash, properties, current player). Deduct 3 points for cluttered UI, 3 points for poor readability of critical information, 4 points for confusing layout that impedes gameplay. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the game provides appropriate feedback for all actions: 1) Visual feedback for dice rolls and movements 2) Clear indicators for property purchases and rent payments 3) Smooth transitions between player turns. Deduct 3 points for delayed feedback on actions, 3 points for unclear turn transitions, 4 points if critical game events occur without appropriate visual/audio cues. The full score is 10 points for a game that maintains player awareness through appropriate feedback.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "hard"
+}

package/library/game_development-strategy/multi-faction-diplomacy-strategy-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 89,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you provide is executable when possible.\n\nPlease implement a strategy game using HTML and JavaScript: Multiple Factions and Diplomatic System\n\n**Task**: Design a multi-faction system where players can engage in diplomacy, form alliances or wage war with other factions. Different diplomatic strategies will influence the game's outcome.\n\n**Hint**: You can use a diplomatic relations table to manage relationships between factions and adjust AI behavior based on player decisions.\n\nPlease include comments in your code to help other developers understand your implementation process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the multi-faction system fully implemented?",
+      "description": "Review whether the code accurately implements distinct factions with unique attributes (resources, strengths, territories). Check if each faction has its own AI behavior patterns and strategic tendencies. Score 0 if factions are merely cosmetic, 5 if basic faction differences exist but lack strategic depth, and 10 if factions have meaningful gameplay differences with unique mechanics.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the diplomatic relations system properly implemented?",
+      "description": "Evaluate whether the code implements a comprehensive diplomatic relations table that tracks relationships between all factions. Check for multiple relationship states (alliance, peace, tension, war, etc.) and proper transitioning mechanisms between states. Deduct 5 points if relationships are binary (ally/enemy only), 3 points if relationship changes lack proper conditions or consequences. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are diplomatic actions and negotiations implemented?",
+      "description": "Check whether the code includes a range of diplomatic actions (trade agreements, alliances, non-aggression pacts, ultimatums, etc.) and a negotiation system where factions can propose and respond to diplomatic offers. Deduct 5 points if diplomatic actions are limited to basic declarations, 3 points if negotiations lack counteroffer capabilities. Score 10 points if the system includes complex diplomatic chains and conditional agreements.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the AI behavior properly responsive to diplomatic relationships?",
+      "description": "Assess whether the AI adapts its behavior based on diplomatic status and player decisions. The AI should consider diplomatic relationships when making strategic decisions about resource allocation, military movements, and diplomatic initiatives. Deduct 5 points if AI ignores relationships in decision-making, 3 points if AI responses are predictable or lack strategic depth. Give 10 points for sophisticated AI that considers complex diplomatic webs and adapts to changing circumstances.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid diplomatic actions, conflicting AI decisions, edge case diplomatic scenarios, 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 reputation system that affects diplomatic options 2. Historical grudges/favors that persist across game sessions 3. Secret diplomatic channels with concealed information). 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 diplomatic actions (e.g., multiple alliance formation mechanisms) 2. Function modules unrelated to diplomacy or strategy (e.g., unnecessary minigames) 3. Fancy effects that affect performance (e.g., excessive animations when forming alliances). 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 diplomacy logic/visualization/AI decision-making layers), unit test coverage, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors per faction, with clear faction identification) 2) Proper layout spacing (diplomatic interface elements follow the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded diplomatic menu, 5 points for confusing faction visual indicators, and 5 points for chaotic diplomatic status representation. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the diplomatic interaction smooth and intuitive?",
+      "description": "Judge whether the diplomatic system is intuitive to use and provides clear feedback: 1) Diplomatic action feedback delay ≤ 100ms 2) Clear visual representation of diplomatic status changes 3) Intuitive pathways for proposing and responding to diplomatic offers. Deduct 5 points for each diplomatic action without clear feedback, 3 points for confusing relationship status indicators, and 5 points for diplomatic options that are difficult to discover. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "medium"
+}