@getollie/cli 0.0.5 → 0.2.0

package/library/game_development-strategy/texas-holdem-poker-game-code.json

@@ -1,68 +0,0 @@
-{
-  "index": 746,
-  "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. Please create a Texas Hold'em poker game code.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core Texas Hold'em game logic fully implemented?",
-      "description": "Review whether the code accurately implements the poker hand evaluation system (high card, pair, two pair, three of a kind, straight, flush, full house, four of a kind, straight flush, royal flush), betting rounds structure (pre-flop, flop, turn, river), and proper blinds handling. Score 0 if core game logic is missing, 5 if basic hand comparison works but lacks betting rounds, and 10 if all official Texas Hold'em rules are correctly implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are the player actions and betting mechanics properly implemented?",
-      "description": "Check whether all standard poker actions (fold, check, call, bet, raise, all-in) are implemented with proper validation. Ensure pot calculation is correct including side pots when players go all-in. Deduct 5 points if betting limits aren't enforced correctly, 3 points if side pots are incorrectly calculated, and 2 points if minimum raises aren't handled properly. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is there a complete dealer/game flow management system?",
-      "description": "Evaluate whether the code includes proper dealer button rotation, blind progression, showdown management, and hand progression logic. Check if the game properly manages the sequence of play, including skipping folded players and handling all-in situations. Deduct 5 points if dealer rotation is incorrect, 3 points if blind progression doesn't work properly, and 3 points if showdown logic is incomplete. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the card deck management and dealing system correctly implemented?",
-      "description": "Check if the code includes proper 52-card deck generation, shuffling algorithm with sufficient randomness, and correct card dealing procedures (2 hole cards per player, 3 cards for flop, 1 for turn, 1 for river). Ensure cards are not duplicated and that burn cards are handled correctly between dealing rounds. Deduct 5 points if the shuffling algorithm has poor randomness, and 5 points if dealing procedures don't follow standard Texas Hold'em rules. 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 bets, out-of-turn actions, disconnected players, 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. Odds calculator for current hand 2. Hand history with replay functionality 3. Player statistics tracking 4. Tournament support with blinds progression). 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 hand evaluation algorithms coexisting) 2. Function modules unrelated to poker (e.g., a built-in chat system) 3. Fancy effects that affect performance (e.g., excessive animations during card dealing). 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 card logic/betting logic/UI layers), unit test coverage for critical components like hand evaluation, and readability. 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 tests for critical game logic. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the poker table design follows professional principles: 1) Proper card and chip visualization with clear suits and denominations 2) Intuitive player positions around the table 3) Clear indication of betting amounts, pot size, and player actions. Deduct 3 points for unclear card representation, 5 points for confusing bet amount display, and 5 points for poor player status indicators. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the game flow and interactions conform to player expectations: 1) Clear indication of current player turn with ≤ 100ms feedback 2) Smooth animations for dealing cards and moving chips (300-500ms) 3) Accessible betting controls with clear value indicators. Deduct 5 points for unclear turn indicators, 3 points for jarring animations, and 5 points for confusing betting interfaces. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "hard"
-}

package/library/game_development-strategy/ugui-2d-grid-map-system.json

@@ -1,68 +0,0 @@
-{
-  "index": 1136,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure that the code you generate is executable. Implement a 2D grid map system on UGUI with a size of 100*100.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the 2D grid map system core implementation complete?",
-      "description": "Review whether the code accurately implements a 100x100 grid system using UGUI components (GridLayoutGroup or custom implementation). Check if the grid cells are properly instantiated, positioned, and managed through efficient methods to avoid performance issues with 10,000 elements. Score 0 if no grid implementation exists, 5 if only basic grid layout is created without proper cell management, and 10 if the implementation includes efficient cell pooling or virtualization techniques for the large grid.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the grid cell data structure implementation effective?",
-      "description": "Evaluate if the code includes a proper data structure for managing 10,000 grid cells with clear separation between data models and visual representation. Check if it uses a 2D array, dictionary, or other appropriate collection to manage cell states. Deduct 5 points if no dedicated data structure exists, and 3 points if the implementation doesn't account for sparse data optimization. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the grid visualization and rendering optimized?",
-      "description": "Check if the rendering approach employs virtualization or object pooling techniques necessary for a 100x100 grid (10,000 cells). Look for implementations like only rendering visible cells in the viewport, recycling UI elements, or using texture-based optimizations. Deduct 10 points if all 10,000 cells are instantiated at once with no optimization, 5 points if basic culling exists but frame rate drops are evident in scrolling/zooming operations. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Does the grid system provide necessary interaction capabilities?",
-      "description": "Evaluate whether the grid system supports core interactions: 1) Cell selection 2) Navigation/scrolling across the large grid 3) Zooming in/out functionality. Check for proper event handling that works efficiently across all 10,000 potential cells. Deduct 3 points for each missing interaction feature, and 5 points if the interaction handlers cause significant performance issues. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as different screen resolutions, dynamic resizing, fast scrolling edge cases, out-of-bounds access) and provide friendly error handling. Code with strong robustness should maintain performance even when rapidly manipulating the grid. Give 10 points for comprehensive error handling and graceful degradation, 5 points if only basic error checks exist, and 0 points if no exception handling is implemented.",
-      "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. Heat map visualization mode 2. A* pathfinding demonstration 3. Custom themes/skins for grid cells 4. Mini-map navigation for the large grid). 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 calculations that could be cached (e.g., repeatedly calculating grid positions) 2. Unnecessary component additions that affect performance (e.g., adding colliders to each cell) 3. Overly complex visual effects that aren't needed for a grid system (e.g., cell rotation animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core grid functionality is compromised by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating grid data/view/controller layers), proper UGUI optimization practices, and adherence to Unity coding standards. Deduct 5 points if global variables are overused; deduct 5 points if there's no separation between grid logic and presentation; deduct 5 points if inefficient UI update patterns are used (e.g., frequent GetComponent calls). The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the grid design follows Unity UI best practices: 1) Proper anchoring and layout considerations for different screen sizes 2) Consistent cell sizing and spacing 3) Visual hierarchy that clearly distinguishes grid from UI controls. Deduct 3 points for misaligned grid cells, 5 points for visual inconsistencies across the grid, and 5 points for poor contrast making grid elements difficult to distinguish. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the performance optimized for the large grid size?",
-      "description": "Judge whether the implementation can maintain at least 30fps on a mid-range device with the full 100x100 grid: 1) Frame rate consistency during scrolling 2) Memory usage optimization 3) Efficient update loops without excessive GC allocations. Deduct 5 points for each noticeable performance drop during grid operations, 3 points for excessive memory usage, and 5 points for frame freezes during grid manipulation. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "hard"
-}

package/library/game_development-strategy/virtual-currency-game-system.json

@@ -1,68 +0,0 @@
-{
-  "index": 70,
-  "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.\n\nPlease use HTML and JavaScript to implement a virtual currency game.\n\n**Task**: Design a virtual currency system where players can earn virtual currency through in-game activities and use it to purchase items and equipment.\n\n**Hint**: Set up functions for earning and spending virtual currency, and provide various options for items and equipment.\n\nPlease include comments in your code to help other developers understand your implementation process.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core virtual currency earning and spending system fully implemented?",
-      "description": "Review whether the code accurately implements mechanisms for players to earn virtual currency (e.g., completing tasks, winning games, daily rewards) and spend it (purchasing items/equipment). Check if the currency balance updates correctly and transactions are properly validated. Score 0 if the core currency system is missing, 5 if only basic earning OR spending is implemented, and 10 if both earning AND spending mechanisms are complete with proper validation.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the item/equipment inventory system properly implemented?",
-      "description": "Evaluate whether the code includes a complete inventory system that tracks purchased items, displays owned items, and implements item effects or stats. Check if items have proper attributes (e.g., price, type, effects) and if the inventory persists across sessions (using localStorage or similar). Deduct 5 points if items lack attributes beyond name/price, and 3 points if there's no persistence mechanism. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are various in-game activities for earning currency implemented?",
-      "description": "Check for the presence of multiple meaningful activities to earn currency (e.g., games, tasks, quests, timed rewards). Each activity should have a unique implementation with appropriate rewards based on difficulty/time. Give 10 points for 3+ well-implemented activities, 5 points for 1-2 basic activities, and 0 points if earning mechanics are trivial (e.g., just clicking a button).",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there a complete game economy balance design?",
-      "description": "Evaluate whether the virtual economy is properly balanced—income rates vs. item prices should create meaningful progression. Check for currencies sink mechanisms to prevent inflation, progression scaling, and whether there are premium/rare items that take significant time to acquire. Deduct 3 points if the economy allows instant acquisition of all items, 5 points if there's no long-term progression design, and 3 points if currency generation has no limits. 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 negative currency values, purchasing items without sufficient funds, invalid inputs) 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. Currency exchange rates between different types of currencies 2. Special time-limited offers or discounts 3. Achievements system tied to purchases). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple methods to update currency) 2. Function modules unrelated to the virtual currency game (e.g., a built-in calculator) 3. Fancy effects that affect performance (e.g., excessive animations that slow down transactions). 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 currency logic/item management/UI layers), code organization, and quality of comments as requested in the task. 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 missing or unhelpful. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional 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) Visual feedback when earning/spending currency 2) Transition animations when purchasing items 3) Clear visual focus on important elements like balance and available items. Deduct 5 points for each operation without feedback, 3 points for jarring transitions when updating currency values, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "easy"
-}

package/library/game_development-strategy/web-based-racing-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 1110,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable for demonstration. Write code for a web-based racing game.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core racing game mechanics fully implemented?",
-      "description": "Review whether the code accurately implements the racing physics system through JavaScript, including collision detection, acceleration/deceleration, handling, and track boundaries. Score 0 if the core game loop is missing, 5 if only basic movement is implemented, and 10 if it includes realistic physics like friction, drift, and aerodynamics.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the racing track and environment well-designed?",
-      "description": "Check whether the code creates a compelling racing environment with a clearly defined track, obstacles, and visual indicators for player guidance. Deduct 3 points if the track is too simplistic (just straight lines), 5 points if collision boundaries are inconsistent with visuals, and 2 points if there's no track variety. Full score requires at least one complete circuit with proper checkpoints.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is there a proper game progression and scoring system?",
-      "description": "Evaluate whether the game includes lap counting, timing system, position tracking (for multiple racers), and performance metrics. Deduct 3 points for missing lap verification, 3 points for no time tracking, and 4 points if there's no way to determine race completion. The full score requires a complete race lifecycle from start to finish.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are AI opponents or multiplayer capabilities implemented?",
-      "description": "Assess whether the game includes computer-controlled opponents with proper path-finding and difficulty levels, or multiplayer functionality. Score 3 points for basic AI that follows predefined paths, 7 points for AI with adaptive difficulty, or 10 points for working multiplayer implementation with proper synchronization.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid input changes, browser performance issues, or unexpected user interactions) 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. Car customization options 3. Interactive race replays with highlights). 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 control schemes that conflict) 2. Function modules unrelated to racing (e.g., mini-games that distract from the main experience) 3. Fancy effects that affect performance (e.g., excessive particle effects causing frame drops). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/rendering/input handling), memory management, and optimization techniques. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no performance optimization for smooth gameplay. 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) Clear heads-up display (speedometer, lap counter, position) 2) Proper visual hierarchy (important info more prominent) 3) Non-intrusive UI elements that don't obstruct gameplay. Deduct 3 points for cluttered UI elements, 5 points for poor readability during gameplay, and 5 points for missing critical race information. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and responsive?",
-      "description": "Judge whether the controls and animations conform to racing game expectations: 1) Input response delay ≤ 50ms 2) Consistent frame rate (minimum 30fps) 3) Appropriate feedback for collisions and speed changes. Deduct 5 points for noticeable input lag, 3 points for jerky animations during turns or collisions, and 5 points for inconsistent physics behavior. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Action/Rhythm",
-  "difficulty": "hard"
-}

package/library/game_development-strategy/web-based-tank-battle-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 1420,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Be careful to ensure the generated code is executable for demonstration. Please generate web-based code for a Tank Battle game.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the tank movement and control system fully implemented?",
-      "description": "Review whether the code accurately implements tank movement controls using keyboard events, includes collision detection with boundaries and obstacles, and handles rotation/direction appropriately. Score 0 if core movement is missing, 5 if only basic movement works, and 10 if smooth movement with proper acceleration/deceleration physics is implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the combat system properly implemented?",
-      "description": "Examine whether the shooting mechanism functions correctly, including projectile physics, cooldown timers, collision detection with obstacles and enemies, and damage calculation. Check if visual and audio feedback is provided when firing and upon hits. Deduct 5 points if hitbox detection is inaccurate, 3 points if projectiles don't respect physics. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are game mechanics and enemy AI implemented?",
-      "description": "Evaluate whether the game includes enemy tanks with functioning AI that can pursue the player, avoid obstacles, and engage in combat with reasonable strategy. Check if power-ups, level progression, or difficulty scaling is implemented. Score 0 if enemies don't move or react, 5 if basic enemy movement exists, and 10 if sophisticated enemy behaviors are implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the complete game lifecycle management constructed?",
-      "description": "Check whether the code includes game initialization, state management (start/pause/resume/game over), score tracking, lives system, and level progression. Deduct 5 points if game state persistence is missing, and 3 points if there's no proper game loop with timing control. Give 10 points if fully implemented with clean transitions between states.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid input changes, browser resizing, out-of-bounds movement, etc.) and provide friendly error handling. Code with strong robustness should prevent game-breaking bugs and maintain consistent gameplay under stress. Give 10 points for comprehensive error handling, 5 for basic handling, and 0 for frequent crashes or bugs.",
-      "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. Destructible environment 2. Weather effects affecting gameplay 3. Multiple tank types with unique abilities 4. Split-screen multiplayer). 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., a built-in calculator) 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 entities, rendering, and physics systems), use of design patterns, and code organization. Deduct 5 points if global state pollution is found; deduct 5 points if the code duplication rate is too high; deduct 5 points if there's no clear 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 game UI principles: 1) Clear and intuitive HUD elements (health, ammo, score) 2) Consistent visual theme and color palette 3) Appropriate contrast between game elements and background. Deduct 3 points for cluttered UI elements, 5 points for poor readability during gameplay, and 5 points for inconsistent visual style. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the game maintains consistent frame rate (minimum 30 FPS), provides immediate feedback for player actions, and implements smooth animations for movement, explosions, and transitions. Deduct 5 points for noticeable performance drops, 3 points for input lag, and 5 points for jerky or missing animations. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "hard"
-}

package/library/game_development-strategy/web-plants-vs-zombies-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 348,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Be sure to provide executable code for demonstration whenever possible. Help me write a web-based version of Plants vs. Zombies.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core plant and zombie interaction system fully implemented?",
-      "description": "Review whether the code accurately implements the plant placement grid system, zombie movement paths, collision detection, and damage calculations. Check if plant types have different attack patterns (single, area, slow-down effects) and if zombies have varied movement speeds and health points. Score 0 if the core interaction is missing, 5 if only basic attacks exist, and 10 if varied plant/zombie types with unique behaviors are implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the resource management and progression system functional?",
-      "description": "Evaluate the implementation of sun collection mechanics, plant cooldown timers, and wave progression logic. Check if the sun economy is balanced (sun generation rate vs plant costs) and if the wave system increases in difficulty over time. Deduct 5 points if sun collection doesn't work properly, 3 points if cooldown timers are inconsistent, and 3 points if zombie waves don't escalate properly. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are the game mechanics and rules properly implemented?",
-      "description": "Check whether the code implements the essential PvZ mechanics: lawn mowers as last defense, day/night cycle (if included), plant selection screen before levels, and win/lose conditions. Verify that zombies entering the house trigger a game over and that clearing all waves leads to victory. Deduct 3 points for each missing core mechanic. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there proper animation and visual feedback implementation?",
-      "description": "Assess whether plants have planting animations, attack animations, and damage states. Check if zombies have walking animations, eating animations, and death animations. Verify visual feedback for sun collection, plant selection, and game state changes. Deduct 3 points if static images are used without animation, 5 points for missing critical feedback (like zombie approach or plant damage). The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid clicking, invalid plant placement attempts, browser resizing, or game pausing) 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. New unique plant/zombie types not in the original game 2. Weather effects that impact gameplay 3. Customizable gardens or layouts). 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 PvZ gameplay (e.g., an irrelevant minigame) 3. Fancy effects that affect performance (e.g., excessive particle systems that cause lag). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game entities, rendering, and game logic), usage of design patterns appropriate for game development (like Observer for events or Factory for creating plants/zombies), and code reusability. Deduct 5 points if global state pollution is found; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no proper asset preloading mechanism. 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 is faithful to the PvZ aesthetic while following modern web design principles: 1) Consistent art style between UI elements and game assets 2) Proper layout and scaling for different screen sizes 3) Clear visual hierarchies for game information (sun count, wave progress). Deduct 3 points for inconsistent art styles, 5 points for unresponsive designs that break on different screens, and 5 points for cluttered or confusing UI. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the game performs well and has responsive controls: 1) Plant placement should respond within 100ms of clicking 2) Game maintains consistent framerate (min 30fps) even with many entities 3) Audio feedback is synchronized with visual events. Deduct 5 points for noticeable input lag, 5 points for framerate drops during normal gameplay, and 3 points for missing or misaligned audio-visual feedback. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "hard"
-}

package/library/game_development-strategy/web-plants-vs-zombies-naruto-edition.json

@@ -1,68 +0,0 @@
-{
-  "index": 1462,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable whenever possible. Help me create a web-based version of Plants vs. Zombies: Naruto Edition.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core game mechanics properly implemented?",
-      "description": "Evaluate whether the code accurately implements the basic Plants vs. Zombies gameplay mechanics with Naruto theme: plant placement, zombie movement, collision detection, sun resource collection, and wave management. Score 0 if core mechanics are missing, 5 if basic functionality exists but lacks refinement, and 10 if all mechanics are properly implemented with appropriate Naruto character adaptations.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are the Naruto-themed characters and abilities properly integrated?",
-      "description": "Check whether the code includes Naruto universe characters as both plants (defenders) and zombies (attackers) with appropriate abilities reflecting their canonical powers. Each character should have unique animations, attack patterns, and special abilities that align with their representation in the Naruto series. Deduct 3 points if characters are merely reskins without unique abilities, 5 points if abilities don't match Naruto lore. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the level progression and difficulty scaling implemented?",
-      "description": "Assess whether the game includes progressive difficulty through multiple levels with increasing challenges. Check for implementation of different terrains (forests, villages, etc. from Naruto universe), day/night cycles affecting gameplay, and special events like boss battles. Deduct 5 points if difficulty doesn't scale properly, 3 points if level variety is minimal. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the chakra/energy resource system properly implemented?",
-      "description": "Evaluate the implementation of a resource system equivalent to the sun collection in the original game, but themed around chakra or energy in the Naruto universe. Check whether the code includes methods for generating resources, storing them, and using them to deploy defenders. There should be visual feedback and appropriate animations. Deduct 5 points if the resource economy is unbalanced, 3 points if visual feedback is inadequate. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid clicking, browser resizing, invalid plant placements, etc.) and provide friendly error handling or recovery mechanisms. Code with strong robustness should be able to effectively handle edge cases like interrupted animations or memory leaks, 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. Jutsu combo system 2. Character evolution based on combat performance 3. Multiplayer mode where one player controls zombies 4. Interactive cutscenes featuring Naruto storylines). Add 2.5 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar characters (e.g., multiple characters with identical abilities but different sprites) 2. Function modules unrelated to the core gameplay (e.g., unnecessary mini-games) 3. Excessive visual effects that affect performance (e.g., particle systems that cause lag). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review the modular design (separation of game logic, rendering, asset management), maintainability (appropriate comments, consistent naming conventions), and optimization (efficient collision detection, sprite batching, asset preloading). Deduct 5 points if global state pollution is found or if design patterns are not used; deduct 3 points if code duplication rate is high; deduct 2 points if there's no performance optimization for mobile devices. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the game UI follows both the original Plants vs. Zombies layout style and integrates Naruto visual elements appropriately: 1) Thematic color palette matching Naruto's world 2) Clean and intuitive grid system for plant placement 3) Clear indicators for resources, waves, and special abilities 4) Proper integration of Naruto iconography and symbols. Deduct 3 points for inconsistent visual style, 4 points for cluttered UI elements, and 3 points for poor readability. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the game animations and interactions feel responsive and satisfying: 1) Plant selection and placement feels immediate (≤ 100ms response) 2) Attack animations are fluid and impactful 3) Zombie defeat animations provide satisfying feedback 4) Special jutsu effects are visually distinctive without obstructing gameplay. Deduct 3 points for sluggish controls, 4 points for choppy animations during intense moments, and 3 points for confusing visual feedback. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "hard"
-}

package/library/game_development-strategy/zombie-survival-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 166,
-  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Try to ensure the code you generate is executable for demonstration.\n\nPlease use HTML and JavaScript to implement a zombie survival game where players need to survive zombie attacks while searching for resources.\nHint: Implement enemy AI behavior and resource management mechanisms.\n\nPlease include comments in your code so other developers can understand your implementation process.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core zombie survival game mechanics fully implemented?",
-      "description": "Check if the code implements the essential gameplay mechanics: player movement controls, zombie AI with pathfinding, collision detection, and combat system. Score 0 if core mechanics are missing, 5 if basic movement and combat are implemented but lack depth, and 10 if all mechanics are fully functional with smooth integration.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "How sophisticated is the enemy zombie AI behavior?",
-      "description": "Evaluate the zombie AI implementation - does it include pathfinding algorithms (A*, Dijkstra's), different zombie types with varied behaviors, adaptive difficulty scaling, and sensory systems (sight, hearing)? Deduct 3 points if zombies move randomly without pathfinding, 3 points if there's no variety in zombie types, and 2 points if zombies don't react to environmental stimuli (sound, light).",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the resource management system comprehensive?",
-      "description": "Assess if the game has a robust resource system including inventory management, item collection, resource scarcity mechanics, and crafting/combining items. Check if resources affect gameplay (health, stamina, ammunition). Deduct 4 points if there's no inventory system, 3 points if resources don't meaningfully impact survival, and 3 points if resource distribution lacks balance.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Does the game include progression and survival mechanics?",
-      "description": "Check for survival mechanics like health/stamina management, day/night cycles, hunger/thirst systems, and progression elements (skills, upgrades, safe zones). Score 0 if no survival mechanics exist, 5 if basic health system is implemented but lacks depth, and 10 if comprehensive survival systems create meaningful gameplay decisions.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code handles common abnormal situations (out-of-bounds movements, resource overflow/underflow, collision edge cases, etc.) and provides appropriate error handling. Code with strong robustness should effectively handle these edge cases, giving 10 points. If 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 affecting gameplay 2. Procedurally generated maps 3. Advanced gore/dismemberment system 4. Unique zombie mutation mechanics). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple healing systems coexisting) 2. Function modules unrelated to zombie survival (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/input layers), code organization, comments quality, 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 missing or unhelpful for understanding the implementation. 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) Harmonious color palette fitting the zombie theme 2) Clear HUD elements showing critical survival information 3) Proper feedback for damage, resource collection, and enemy presence. Deduct 3 points for cluttered UI elements, 5 points for poor visual hierarchy that obscures important information, and 5 points for inconsistent visual language. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the game's responsiveness and feedback conform to player expectations: 1) Input response time ≤ 100ms 2) Clear visual/audio feedback for hits, damage, and resource collection 3) Appropriate difficulty curve and tutorial elements. Deduct 5 points for each action without feedback, 3 points for jerky animations or inconsistent frame rates, and 5 points for unintuitive controls or confusing game states. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "medium"
-}