@getollie/cli 0.0.1

package/library/game_development-strategy/multiplayer-battles-network-synchronization.json

@@ -0,0 +1,68 @@
+{
+  "index": 135,
+  "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 card/board game: multiplayer battles with network synchronization.\n\n**Task**: Implement a multiplayer battle system where players can compete with other players in real-time via network, with synchronized game states.\n\n**Hint**: You can use network synchronization technology to maintain consistency of the game state and handle network latency.\n\nImplement the game and include some comments in the code to help other developers understand your implementation process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the multiplayer battle system core logic fully implemented?",
+      "description": "Review whether the code accurately implements the battle mechanics through HTML/JavaScript, including turn management, player actions, win/loss conditions, and game rule enforcement. Check if battle state transitions are properly handled and if all game actions are validated. Score 0 if core battle logic is missing, 5 if only basic turn-based mechanics are implemented, and 10 if complete battle system with all rules and edge cases are covered.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the network synchronization mechanism properly implemented?",
+      "description": "Evaluate whether the network synchronization uses WebSocket or similar real-time communication protocol with proper message serialization/deserialization. Check for conflict resolution mechanisms when simultaneous actions occur, and whether the system handles out-of-order message delivery. Deduct 5 points if no conflict resolution exists, 3 points if message ordering is not guaranteed. Full score requires robust synchronization with state consistency verification.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is network latency compensation and prediction implemented?",
+      "description": "Check whether the system implements client-side prediction, lag compensation, and rollback mechanisms to handle network delays. Evaluate if the system provides smooth user experience despite network latency through techniques like input buffering or interpolation. Deduct 5 points if no latency compensation exists, 3 points if prediction accuracy is poor. Full score requires sophisticated latency handling with seamless user experience.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the multiplayer session management complete?",
+      "description": "Assess whether the code includes comprehensive session management: player matchmaking, room creation/joining, player disconnection handling, and game state persistence. Check for reconnection capabilities and spectator support. Deduct 5 points if session persistence is missing, 3 points if disconnection recovery is incomplete. Give 10 points if full session lifecycle is managed with graceful error handling.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as network interruption, invalid player inputs, server timeouts, concurrent action conflicts, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should effectively handle edge cases and maintain game integrity under stress conditions. Give 10 points for excellent error handling, 5 points for basic exception handling, and 0 points if no error handling exists.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that enhance gameplay?",
+      "description": "Check whether the code includes compelling features that improve user experience (e.g., 1. Real-time spectator mode with commentary 2. Replay system with action timeline 3. Advanced matchmaking with skill ratings 4. In-game communication tools). Add 3 points for each well-implemented innovative feature that adds genuine value to the multiplayer experience (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Duplicate network communication logic or redundant synchronization mechanisms 2. Unnecessary UI components unrelated to core gameplay 3. Performance-heavy visual effects that don't contribute to user experience. Deduct 3 points for each redundancy found, and directly deduct 10 points if redundant code interferes with core multiplayer functionality or network performance.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular architecture (separation of game logic, network layer, UI components), code organization, and maintainability. Check for proper error logging, configuration management, and scalability considerations. Deduct 5 points if network and game logic are tightly coupled; deduct 5 points if code duplication exceeds 25%; deduct 5 points if no separation of concerns exists. Full score requires clean architecture with proper abstraction layers.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface design meet professional gaming standards?",
+      "description": "Evaluate whether the UI follows modern game interface principles: 1) Clear visual hierarchy with consistent color scheme (max 4 primary colors) 2) Intuitive layout with proper spacing (elements follow 8px grid system) 3) Readable typography (game text ≥ 14px, UI elements ≥ 12px, line height ≥ 1.4). Deduct 3 points for cluttered interface elements, 5 points for poor color contrast or readability issues, and 5 points for confusing navigation or information architecture.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Are the real-time interactions smooth and responsive?",
+      "description": "Judge whether multiplayer interactions meet real-time gaming standards: 1) Input response time ≤ 50ms for local actions 2) Network action feedback within 200ms 3) Smooth animation transitions (200-400ms duration) 4) Clear visual indicators for multiplayer state changes. Deduct 5 points for each unresponsive interaction, 3 points for laggy animations during network updates, and 5 points if multiplayer state changes lack visual feedback.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "hard"
+}

package/library/game_development-strategy/multiplayer-cooperative-mode-implementation.json

@@ -0,0 +1,68 @@
+{
+  "index": 31,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Make sure the code you generate is executable.\n\nPlease use HTML and JavaScript to implement a multiplayer cooperative mode.\n\n**Task**: Implement a multiplayer cooperative mode allowing multiple players to complete tasks together.\n\n**Hint**: You can use network communication to synchronize actions between players and design levels suitable for multiplayer cooperation.\n\nPlease include comments in your code to help other developers understand your implementation process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the multiplayer cooperative foundation implemented?",
+      "description": "Review whether the code establishes the core multiplayer structure through HTML/JavaScript, including player representation, shared game state, and basic interaction mechanisms. Score 0 if multiplayer functionality is absent, 5 if only basic player representation exists, and 10 if the system properly manages multiple simultaneous players with distinct roles or capabilities.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the network communication for player synchronization implemented?",
+      "description": "Check if the code includes WebSocket/WebRTC implementation with proper state synchronization between players. Look for connection handling, data serialization, and conflict resolution. Deduct 5 points if there's no reconnection mechanism, 3 points if latency handling is missing, and 5 points if the synchronization is one-way only. Full score requires bidirectional real-time updates with error handling.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are cooperative gameplay mechanics implemented?",
+      "description": "Evaluate whether the code implements true cooperative mechanics requiring multiple players working together (e.g., one player holding a door while another passes through, players combining abilities, or shared resource management). Score 0 if no cooperative mechanics exist, 5 if basic interactions between players are possible, and 10 if the gameplay genuinely requires coordination and cannot be completed alone.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is level design or task structure suitable for multiplayer cooperation?",
+      "description": "Assess whether the implemented levels/tasks are specifically designed for multiplayer interaction with clear cooperative objectives. Check for player-specific roles, complementary abilities, or puzzles requiring multiple participants. Deduct 5 points if levels can be completed solo, 3 points if cooperative elements feel artificially inserted. The full score requires thoughtfully designed challenges that naturally encourage teamwork.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as out-of-bounds input, network interruption, player joining/leaving mid-game, 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 cooperative experience (e.g., 1. Real-time voice/text chat integration 2. Dynamic difficulty scaling based on player count 3. Asymmetric player roles with unique interfaces). 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 communication channels doing the same thing) 2. Function modules unrelated to multiplayer cooperation (e.g., complex single-player features) 3. Fancy effects that affect performance for all connected players. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core multiplayer 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/network layers), code comments as requested in the requirements, and maintainable architecture. 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 code 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) Clear visual distinction between different players and their actions. Deduct 3 points for each confusing player representation, 5 points for unclear action feedback, and 5 points for interfaces that don't clearly communicate cooperative requirements. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the multiplayer interaction smooth and responsive?",
+      "description": "Judge whether the multiplayer experience is fluid and responsive: 1) Player actions visible to others within 200ms 2) Clear visual/audio cues when coordination is required or achieved 3) Graceful handling of network hiccups without disrupting gameplay flow. Deduct 5 points for laggy interactions, 3 points for missing cooperative success feedback, and 5 points for coordination mechanics that feel unresponsive. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "hard"
+}

package/library/game_development-strategy/northern-expedition-monopoly-game-html.json

@@ -0,0 +1,68 @@
+{
+  "index": 282,
+  "question": "You are a coding expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable. Help me design a \"Northern Expedition Monopoly\" game programming in HTML format, with detailed specifications.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core Monopoly game mechanics fully implemented?",
+      "description": "Review whether the code accurately implements the monopoly board with property acquisition, movement mechanics, and token handling through HTML/JavaScript. Score 0 if the core game loop isn't implemented, 5 if only basic movement is implemented, and 10 if property ownership, rent collection, and special tile actions (like chance cards, jail) are fully included with Northern Expedition theme integration.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the Northern Expedition theme properly integrated?",
+      "description": "Check whether the historical context of the Northern Expedition (1926-1928) is accurately represented in the game elements. Properties should reflect historical locations, cards should include period-appropriate events, and visual elements should match the historical setting. Deduct 5 points if the theme is superficial, 3 points if historical inaccuracies are present. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the game state management effectively implemented?",
+      "description": "Evaluate whether the code includes complete game state tracking (player turns, property ownership, money, position) and persistence between turns. Check if state changes are properly triggered by player actions and if the game state can be saved/loaded. Deduct 5 points if state management is buggy, and 3 points if there's no save/load functionality. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the player interaction system intuitive and complete?",
+      "description": "Assess whether the game provides clear UI elements for player actions (rolling dice, buying properties, ending turns, trading) and if feedback is provided for all actions. Check if the game supports multiple players and handles player turns correctly. Deduct 5 points if core actions are missing UI elements, 3 points if player feedback is unclear. 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, unexpected user inputs, browser compatibility issues, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Historical events that affect gameplay 2. Character selection with different abilities based on historical figures 3. Dynamic board that evolves with game progress). 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 handle the same game event) 2. Function modules unrelated to the Northern Expedition Monopoly theme (e.g., irrelevant 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/controller layers), reusability of components, and code maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there are no comments or documentation. 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 while incorporating period-appropriate aesthetics: 1) Harmonious color matching that evokes 1920s China 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Typography that balances readability with period-appropriate styling. 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) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance for whose turn it is and what actions are available. Deduct 5 points for each operation without feedback, 3 points for animation stuttering during dice rolls or token movement, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "hard"
+}

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

@@ -0,0 +1,68 @@
+{
+  "index": 377,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure that the generated code is executable and demonstrable. Create a Plants vs. Zombies code that can run directly in a browser. No computer operations needed, just a link that can be run in a browser.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core Plants vs. Zombies game mechanics fully implemented?",
+      "description": "Review whether the code accurately implements the essential game mechanics including plant placement, zombie movement, sun collection, and combat interactions. Score 0 if core gameplay is missing, 5 if only basic elements exist, and 10 if the implementation includes multiple plant types, zombie varieties, and proper collision detection.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Does the game include a complete level progression system?",
+      "description": "Evaluate whether the game includes multiple levels with increasing difficulty, different zombie waves, and a level completion system. Deduct 5 points if there's only a single level, 3 points if difficulty progression is missing. Full score requires at least 3 distinct levels with proper wave management.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the resource management system properly implemented?",
+      "description": "Check if the sun collection mechanic works correctly, plants have appropriate costs, and cooldown timers function as expected. Score 0 if resource management is absent, 5 if basic sun collection exists but lacks cooldowns, and 10 if all resource aspects (sun generation, collection, plant costs, and cooldowns) are properly balanced.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the browser compatibility and performance optimized?",
+      "description": "Assess whether the game runs smoothly in multiple browsers without lag, maintains consistent frame rates even with many entities, and uses proper performance optimization techniques. Deduct 5 points for noticeable lag with 10+ entities on screen, 3 points if the game doesn't work in at least 3 major browsers, and 5 points if animation frame handling is inefficient.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid clicking, out-of-bounds placement attempts, browser resizing, etc.) and provide friendly error handling. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Special power-ups 2. Weather effects impacting gameplay 3. Mobile touch optimizations 4. Achievement system). 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 hit detection systems) 2. Function modules unrelated to PvZ gameplay (e.g., unnecessary mini-games) 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/entities), asset management, and code organization patterns. 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 asset loading is not optimized. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the visual design matches the original game's aesthetic while following modern design principles: 1) Consistent art style for plants and zombies 2) Clear visual distinction between game elements 3) Readable UI elements and proper scaling across screen sizes. Deduct 3 points for inconsistent art styles, 5 points for unclear visual hierarchy, and 5 points for unresponsive layouts. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the game interactions feel responsive and intuitive: 1) Plants place immediately on valid click 2) Zombies move smoothly with proper animations 3) Sun collection feels satisfying with visual/audio feedback. Deduct 5 points for delayed plant placement (>200ms), 3 points for jerky zombie movement, and 5 points for unresponsive sun collection. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "hard"
+}

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

@@ -0,0 +1,68 @@
+{
+  "index": 340,
+  "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. Please help me create a Plants vs. Zombies game using HTML, with all code saved in a single HTML file.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core game mechanics fully implemented?",
+      "description": "Check if the code implements the core gameplay mechanics of Plants vs. Zombies: plant placement, zombie movement, sun resource collection, and proper collision detection. Score 0 if these fundamentals are missing, 5 if only basic mechanics work, and 10 if it includes special plant abilities (like pea shooters, sunflowers, wall-nuts) and different zombie types with varying behaviors and health values.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the game grid system properly implemented?",
+      "description": "Verify the lawn grid implementation (typically 5×9 or similar), whether plants can be placed correctly in grid cells, and if zombies follow proper lane-based movement. Check if the coordinate system handles collisions accurately and if visual elements align with their logical positions. Deduct 5 points if grid alignment is inconsistent, 3 points if placement validation is missing, and give 10 points for a completely functional grid with proper validation.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the resource management system implemented?",
+      "description": "Evaluate the sun resource collection and spending mechanism, cooldown timers for plant selection, and plant card selection interface. Check if sun drops automatically and/or from sunflowers, if collection requires user interaction, and if resource costs are balanced. Deduct 4 points if sun collection is missing, 3 points if cooldowns aren't implemented, and 3 points if the plant selection UI is non-functional.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the wave management and game progression implemented?",
+      "description": "Analyze the zombie wave spawning system, difficulty progression, and win/lose conditions. Verify if zombie waves increase in difficulty over time, if there's a proper level end mechanism, and if the game detects when zombies reach the player's house. Deduct 4 points if wave progression is static or missing, 3 points if winning/losing conditions aren't defined, and 3 points if the difficulty never increases.",
+      "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, extreme game states) and provide friendly error handling. Code with strong robustness should prevent game-breaking exploits like placing plants without sufficient resources or off-grid. Give 10 points for comprehensive error handling, 5 points for basic validations, and 0 points if the game breaks easily.",
+      "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. Level editor 2. Special power-ups or abilities 3. Day/night cycle affecting gameplay). 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 (e.g., unrelated 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/animation layers), code organization, and performance optimization. Deduct 5 points if global state pollution is found or if game objects aren't properly encapsulated; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if no performance considerations are made (e.g., inefficient loops or animations). The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the visual design resembles the original PvZ game's aesthetic while maintaining modern design principles: 1) Consistent art style for plants, zombies, and background 2) Proper UI layout with clear plant selection area, sun counter, and game field 3) Appropriate use of color and contrast for gameplay clarity. Deduct 3 points for inconsistent art style, 5 points for cluttered or confusing UI, and 5 points for poor visual hierarchy. 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) Plants have planting animations 2) Zombies have walking and attack animations 3) Projectiles show smooth movement with collision effects. Deduct 3 points for static or missing plant animations, 3 points for zombie movement without proper animation, and 4 points for absent or glitchy collision feedback. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "hard"
+}

package/library/game_development-strategy/plants-vs-zombies-unlimited-sunshine.json

@@ -0,0 +1,68 @@
+{
+  "index": 762,
+  "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 display purposes. Help me write code for a single-player Plants vs. Zombies game with unlimited sunshine.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Plants vs. Zombies game core mechanics fully implemented?",
+      "description": "Review whether the code successfully implements the fundamental PvZ gameplay, including planting mechanics, zombie movement patterns, collision detection, and plant-zombie interaction. Score 0 if the core mechanics are missing, 5 if only basic functionality exists, and 10 if all standard PvZ mechanics (including shooting, sun collection, and different zombie types) are properly implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the unlimited sunshine feature correctly implemented?",
+      "description": "Check if the code properly implements unlimited sunshine as specified. This requires maintaining a high or constantly replenishing sun count, bypassing normal sun collection mechanics without breaking game balance. Deduct 5 points if sun still needs collection, 3 points if there are arbitrary sun limits, and 2 points if the implementation conflicts with other game systems. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are various plant types and zombies with different behaviors implemented?",
+      "description": "Evaluate whether the code includes at least 5 different plant types (e.g., Peashooter, Sunflower, Wall-nut, Cherry Bomb, Snow Pea) and 3 zombie types with distinct behaviors and attributes. Deduct 2 points for each missing plant type below 5 and 3 points for each missing zombie type. Give 10 points if the implementation includes proper class inheritance and behavior differentiation.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the level progression system with increasing difficulty implemented?",
+      "description": "Assess whether the game includes a proper level system with progressive difficulty (increasing zombie spawn rates, introducing new zombie types, etc.). Check if wave management logic exists and whether the game properly handles level completion conditions. Deduct 5 points if there's no level progression, 3 points if difficulty scaling is absent, and 2 points if win/lose conditions are not properly implemented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common edge cases (such as rapid clicking, overlapping plants, boundary zombies, browser resizing, etc.) and provide appropriate error handling or recovery mechanisms. Code with strong robustness should effectively manage these scenarios, giving 10 points. If the robustness is average, give 5 points, and if no edge cases are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Special power-ups not in original game 2. Weather effects affecting gameplay 3. Unique zombie or plant abilities). 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 game mechanics (e.g., multiple plant selection systems) 2. Function modules unrelated to PvZ gameplay (e.g., unnecessary mini-games) 3. Heavy visual effects that affect performance. Deduct 3 points for each redundancy found, and directly deduct 10 points if core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (separating game logic from rendering, proper class structure for plants/zombies), code reuse, and performance optimization. Deduct 5 points if global state is overused; deduct 5 points if code duplication rate is high (over 30%); deduct 5 points if animation frame management is inefficient. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the visual design matches the PvZ aesthetic while following good design principles: 1) Consistent art style for plants and zombies 2) Clear lawn grid system with proper spacing 3) Readable UI elements with sufficient contrast. Deduct 3 points for inconsistent visual styles, 5 points for unclear playfield boundaries, and 5 points for poor information hierarchy (e.g., hard to read sun count). The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the game interactions feel responsive and intuitive: 1) Plant placement feedback ≤ 100ms 2) Smooth zombie walking animations 3) Clear visual feedback for attacks and damage. Deduct 5 points for laggy animations, 3 points for unresponsive plant selection/placement, and 5 points for unclear visual feedback when plants attack or zombies take damage. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "hard"
+}

package/library/game_development-strategy/points-system-with-rewards.json

@@ -0,0 +1,68 @@
+{
+  "index": 36,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure that the generated code is executable and demonstrable.\n\nPlease use HTML and JavaScript to implement a points system.\n\n**Task**: Implement a points system where players can earn points by completing tasks and defeating enemies, which can be used to redeem rewards.\n\n**Hint**: Set up point earning and redemption functions, and provide various reward options.\n\nPlease add comments in the code so other developers can understand your implementation process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the points earning mechanism fully implemented?",
+      "description": "Review whether the code accurately implements multiple point earning scenarios through HTML/JavaScript, including task completion rewards, enemy defeat bonuses, and achievement unlocks. Check if point calculations are precise and if different earning rates are properly configured. Score 0 if no earning logic is implemented, 5 if only basic single-source earning exists, and 10 if multiple comprehensive earning mechanisms with proper validation are included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the points redemption system properly designed?",
+      "description": "Check whether the redemption system includes comprehensive reward categories, proper point deduction logic, and transaction validation. Evaluate if the system handles insufficient points gracefully and maintains transaction integrity. Deduct 5 points if redemption validation is missing, and 3 points if transaction rollback mechanisms are not implemented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is persistent data storage and retrieval implemented?",
+      "description": "Evaluate whether the system uses appropriate storage mechanisms (localStorage/sessionStorage/IndexedDB) for maintaining player points and transaction history. Check if data persistence survives page refreshes and browser sessions. Deduct 5 points if data is lost on refresh, and 3 points if transaction history is not properly maintained. Require proper data serialization and deserialization. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is comprehensive points management interface constructed?",
+      "description": "Check whether the code includes complete points management features, including real-time balance display, transaction history viewing, reward catalog browsing, and point earning progress tracking. Deduct 5 points if balance updates are not real-time, and 3 points if transaction history lacks proper filtering/sorting. Give 10 points if all management features are fully implemented with proper user feedback.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as negative point attempts, invalid redemption requests, data corruption, concurrent operations, 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. Point multiplier events/bonuses 2. Achievement badges and progress visualization 3. Point prediction and earning analytics 4. Social sharing of achievements). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple point calculation logics coexisting) 2. Function modules unrelated to points system (e.g., built-in games or media players) 3. Fancy effects that affect performance (e.g., excessive animations on every point change). 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 points logic/UI/storage layers), proper commenting for developer understanding, and code organization. Deduct 5 points if global state pollution is found or no design patterns are used; deduct 5 points if code comments are insufficient or unclear (less than 20% comment coverage); deduct 5 points if the code structure is poorly organized. 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) 4) Clear visual hierarchy for points display and rewards. 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) Point earning feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance for redemption actions 4) Smooth point counter animations. Deduct 5 points for each operation without feedback, 3 points for jarring point updates without smooth transitions, and 5 points for hard-to-find reward categories or redemption buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "easy"
+}

package/library/game_development-strategy/pokemon-type-matchup-query-mini-program.json

@@ -0,0 +1,68 @@
+{
+  "index": 1807,
+  "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. I would like you to create a Pokémon type matchup query mini-program based on your knowledge and what's available on the internet. The requirement is that when I click to select an opponent's type, it recommends Pokémon types that are effective against it. The selection buttons should not require scrolling after clicking - all type buttons should fit on a single screen.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the type matchup system correctly implemented?",
+      "description": "Review whether the code accurately implements the Pokémon type effectiveness chart with all 18 types, including dual-type calculations. Check if the effectiveness multipliers (2x, 0.5x, 0x) are correctly applied. Score 0 if the type matchup data is incorrect, 5 if only single-type matchups are implemented, and 10 if both single and dual-type calculations are fully accurate.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Does the UI display all Pokémon types without requiring scrolling?",
+      "description": "Evaluate if all 18 Pokémon type buttons fit on a single screen without requiring scrolling. The layout should be responsive to different screen sizes and maintain visibility of all options. Deduct 5 points if scrolling is needed on standard desktop screens, and 10 points if multiple types are hidden or inaccessible without scrolling. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the type selection interface intuitive and user-friendly?",
+      "description": "Check if the type selection mechanism is intuitive with clear visual distinction between selected and unselected states. The interface should allow for easy selection/deselection of single or dual types. Deduct 3 points if the selection state isn't clearly visible, 5 points if the dual-type selection is confusing, and 8 points if the selection mechanism is completely non-intuitive. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are the recommended counter types clearly presented?",
+      "description": "Assess if the recommended counter types are visually distinct and sorted by effectiveness. The results should show why a type is recommended (e.g., '4x effective against Fire/Steel'). Deduct 3 points if effectiveness multipliers aren't shown, 5 points if recommendations aren't sorted by effectiveness, and 8 points if the results are difficult to interpret. 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 type combinations, browser compatibility issues, mobile responsiveness, 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 type icons with official Pokémon styling 2. Showing example Pokémon of recommended types 3. Interactive visualization of effectiveness relationships). 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 select types) 2. Function modules unrelated to type matchups (e.g., a Pokédex that distracts from the core functionality) 3. Fancy effects that affect performance (e.g., unnecessary animations when selecting types). 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 data/view/logic 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 lacks comments or documentation. 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 official Pokémon type 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) Type selection feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual feedback when displaying effectiveness results. Deduct 5 points for each operation without feedback, 3 points for visual after-images during rapid type selection, and 5 points for hard-to-find effectiveness information. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "easy"
+}