@getollie/cli 0.0.5 → 0.2.1

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

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

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

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

package/library/game_development-strategy/programming-for-a-game-of-fight-the-landlord.json

@@ -1,68 +0,0 @@
-{
-  "index": 1571,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code for demonstration purposes. Create the programming for a game of \"Fight the Landlord\" (Chinese poker).",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core card game logic fully implemented?",
-      "description": "Review whether the code accurately implements the 'Fight the Landlord' card rules, including proper card representation, card combinations validation (singles, pairs, triples, straights, etc.), and winning condition detection. Score 0 if core game mechanics are missing, 5 if basic card play is implemented but with rule gaps, and 10 if all game rules are complete and accurate.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are the player roles and bidding phase properly handled?",
-      "description": "Evaluate the implementation of the landlord selection process, including bidding mechanism, role assignment (landlord vs farmers), and the proper handling of the three extra cards for the landlord. Deduct 5 points if bidding is not implemented, 3 points if the role assignment is incomplete, and 2 points if the extra cards mechanism is incorrect. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the turn-based gameplay properly implemented?",
-      "description": "Check whether the code enforces correct turn order, validates if a player's move is legal based on previous plays (card combinations must beat previous plays or start a new combination), and properly handles passing. Deduct 5 points for incorrect turn management, 3 points for faulty play validation logic, and 2 points for improper pass handling. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there a complete AI opponent implementation?",
-      "description": "Assess whether computer players can make strategic decisions based on card combinations in their hands, understand the game state, and execute competitive play strategies. Basic AI should at least play valid cards; intermediate AI should recognize optimal plays; advanced AI should employ strategic thinking. Score 3 for basic, 7 for intermediate, and 10 for advanced AI implementation.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid card selections, incorrect turn operations, edge case card combinations) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Card combination suggestion system 2. Game history recording with replay 3. Dynamic difficulty adjustment for AI 4. Multiplayer online capabilities). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple card validation systems) 2. Function modules unrelated to the card game (e.g., unrelated mini-games) 3. Fancy effects that affect performance (e.g., excessive animations that slow gameplay). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/view/player input layers), unit test coverage, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional card visualization (clear suit and rank display, intuitive selection mechanism). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for unclear card representation. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Card selection feedback delay ≤ 100ms 2) Card dealing and movement animations controlled between 300-500ms 3) Clear visual indication of whose turn it is and what cards were played last. Deduct 5 points for each operation without feedback, 3 points for choppy card animations, and 5 points for unclear turn indicators. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "hard"
-}

package/library/game_development-strategy/python-chinese-chess-xiangqi-visualization.json

@@ -1,68 +0,0 @@
-{
-  "index": 1573,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure the generated code is executable for demonstration. Create a visualization of Chinese chess (Xiangqi) using Python language.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Chinese chess (Xiangqi) board correctly implemented?",
-      "description": "Verify if the code correctly implements the 9x10 board with river in the middle, palace areas, and proper piece starting positions according to official Xiangqi rules. Check if the coordinate system is properly established. Score 0 if the board is incorrectly structured, 5 if basic structure is present but with minor inaccuracies, and 10 if perfectly implemented with proper board markings and proportions.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are all Chinese chess pieces properly represented with correct movement rules?",
-      "description": "Evaluate if all 7 types of pieces (General, Advisor, Elephant, Horse, Chariot, Cannon, and Soldier) are implemented with their correct movement patterns and restrictions. Each piece should follow Chinese chess rules, including the river crossing rules for soldiers and palace confinement for generals and advisors. Deduct 1.5 points for each piece type with incorrect movement rules. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the game logic fully implemented with proper turn-taking and victory conditions?",
-      "description": "Review if the code includes complete game rules including turn alternation, check detection, checkmate detection, and stalemate scenarios. Check if special rules like the 'flying general' illegal move and perpetual check restrictions are handled. Score 0 if basic game flow is missing, 5 if only simple turn-taking is implemented without check/checkmate detection, and 10 if all official Xiangqi rules are properly enforced.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the visualization clear, culturally appropriate and interactive?",
-      "description": "Assess if the visualization uses traditional Chinese chess piece representations (either Chinese characters or symbolic representations), appropriate colors (traditionally red vs. black), and allows for clear piece differentiation. Check if the user can interact with the board through intuitive mouse or keyboard commands. Deduct 3 points if pieces are difficult to distinguish, 3 points if interaction is unintuitive, and 4 points if the visual style doesn't reflect Chinese chess traditions.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as illegal moves, improper input, out-of-bounds selections, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Move suggestions 2. Game recording and replay functionality 3. Different visual themes 4. AI opponent with difficulty levels). 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 pieces) 2. Function modules unrelated to Chinese chess (e.g., unnecessary animations) 3. Overly complex code that could be simplified. 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 from visualization), code organization, documentation, and maintainability. Assess if proper Python conventions are followed, including naming conventions, docstrings, and type hints. Deduct 5 points if global state pollution is found; deduct 3 points if the code lacks comments/documentation; deduct 3 points if the code has poor organization with 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 visualization follows good design principles: 1) Consistent visual style 2) Proper contrast between pieces and board 3) Clear indication of selected pieces and valid moves 4) Appropriate board proportions. Deduct 3 points for poor color contrast making pieces hard to read, 3 points for inconsistent styling, and 4 points for cluttered or confusing layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and responsive?",
-      "description": "Judge whether the program performs efficiently and responds quickly: 1) Piece movement is smooth with appropriate visual feedback 2) Selection/deselection actions are responsive 3) The game maintains consistent performance throughout gameplay. Deduct 3 points for laggy animations, 3 points for delayed response to user input, and 4 points for performance degradation during prolonged play. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "hard"
-}

package/library/game_development-strategy/random-level-generation-html-javascript.json

@@ -1,68 +0,0 @@
-{
-  "index": 193,
-  "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.\nPlease use HTML and JavaScript to implement randomly generated levels.\n\n**Task**: Implement a simple random level generation feature that creates different level layouts each time the game starts.\n\n**Hint**: You can use a random number generator and predefined level modules to dynamically create levels.\n\nInclude comments in your code so that other developers can understand your implementation process.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the random level generation algorithm correctly implemented?",
-      "description": "Review whether the code implements effective random level generation logic through HTML/JavaScript, including proper random number generation, level layout algorithms (such as procedural generation, template-based generation, or rule-based generation), and ensures each generated level is playable and balanced. Score 0 if no random generation is implemented, 5 if only basic random placement is implemented, and 10 if a sophisticated generation algorithm with validation is fully included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are predefined level modules and templates properly designed?",
-      "description": "Check whether the implementation includes well-structured predefined level components, templates, or building blocks that can be combined randomly. Evaluate if the modular system supports scalability and variation. The system should include different types of level elements (obstacles, paths, collectibles, etc.) and rules for their combination. Deduct 5 points if modules are too simple or limited, and 3 points if combination rules are poorly defined. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is level validation and playability assurance implemented?",
-      "description": "Evaluate whether the random generation includes validation mechanisms to ensure generated levels are completable and balanced. This should include path-finding validation, difficulty balancing, and rejection of impossible or trivial layouts. Check if the system can regenerate levels that fail validation. Deduct 5 points if no validation exists, 3 points if validation is incomplete. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the level generation system flexible and configurable?",
-      "description": "Check whether the code provides configurable parameters for level generation (such as difficulty settings, size parameters, density controls, theme variations). Evaluate if the system supports different generation modes or styles. The implementation should allow easy modification of generation parameters without code changes. Deduct 5 points if the system is hardcoded with no flexibility, and 3 points if configuration options are limited. Give 10 points if fully configurable.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid random seeds, generation failures, memory constraints, infinite loops in generation algorithms, 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. Biome-based generation with smooth transitions 2. Procedural narrative elements 3. Adaptive difficulty based on player performance 4. Level sharing via seed codes 5. Real-time generation preview). 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 generation functions (e.g., multiple random algorithms doing the same thing) 2. Function modules unrelated to level generation (e.g., built-in music player, unnecessary animations) 3. Overly complex generation that affects performance (e.g., generating too much detail that isn't used). Deduct 3 points for each redundancy found, and directly deduct 10 points if core generation 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 generation logic/rendering/data structures), code documentation quality, and proper commenting as specified in requirements. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if comments are insufficient or unclear for other developers to understand. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the level visualization follows modern design principles: 1) Harmonious color matching for different level elements (no more than 3 primary colors per theme) 2) Proper visual hierarchy and spacing (element spacing follows the 8px multiple principle) 3) Clear visual distinction between different level components 4) Professional rendering quality. Deduct 3 points for each visually confusing element, 5 points for poor color combinations that make gameplay difficult, and 5 points for chaotic visual layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the level generation and rendering performance optimized?",
-      "description": "Judge whether the generation and display performance meets user expectations: 1) Level generation time ≤ 2 seconds for complex levels 2) Smooth rendering without frame drops during generation 3) Efficient memory usage without leaks 4) Responsive UI during generation process. Deduct 5 points for each generation that takes too long, 3 points for visible performance issues during rendering, and 5 points for unresponsive interface during generation. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "easy"
-}

package/library/game_development-strategy/recurrent-neural-network-rock-paper-scissors-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 161,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Game Rules\n- **Choose a Gesture**: Select rock, paper, or scissors by clicking the buttons.\n- **Machine Learning Opponent**: The computer uses a recurrent neural network to predict and react to the player's moves.\n\n### Game Features\n- **AI Technology**: Neural network implemented using the `brain.js` library.\n- **Real-time Learning**: The AI learns and adapts in real-time based on the player's choices.\n\n### Game Tips\n- **Vary Your Strategy**: Frequently change your move patterns to increase the difficulty for AI prediction.\n- **Observe AI Patterns**: Pay attention to the AI's move tendencies and adjust your strategy accordingly.\n\n### Summary\n\"Recurrent Neural Network - Rock, Paper, Scissors\" is an interactive experience that uses neural network technology to simulate the rock, paper, scissors game. Players compete against a computer based on machine learning algorithms, predicting and making moves. This game demonstrates the application of artificial intelligence in gaming, providing a novel experience of competing against AI.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the RNN implementation for the AI opponent correctly implemented?",
-      "description": "Check whether the code correctly implements a recurrent neural network using brain.js library. Verify that the network architecture is appropriate for sequence prediction (has memory cells, proper input/output dimensions, and appropriate activation functions). Score 0 if there's no neural network implementation, 5 if a basic neural network exists but lacks recurrent connections, and 10 if a proper RNN is implemented with appropriate parameters.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Does the game implement real-time learning capabilities?",
-      "description": "Evaluate whether the AI can learn from player's moves in real-time. Check for: 1) Move history tracking mechanism 2) Periodic retraining of the network with new data 3) Clear evidence that AI predictions change based on player's patterns. Deduct 5 points if learning only happens at game restart, 3 points if the learning rate is too low to notice adaptation. Full score requires demonstrating that the AI improves predictions after recognizing patterns.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the rock-paper-scissors game logic correctly implemented?",
-      "description": "Review the core game logic implementation, including win determination, score tracking, and game state management. Check that rock beats scissors, scissors beats paper, and paper beats rock. Verify that ties are correctly identified. Deduct 5 points if any rule is implemented incorrectly, 3 points if edge cases (like simultaneous moves) aren't handled properly. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Does the interface provide meaningful feedback on the AI's learning process?",
-      "description": "Assess whether the interface shows the player how the AI is learning and adapting. Check for: 1) Visualization of AI confidence levels 2) Pattern recognition indicators 3) Prediction probability display. Deduct 3 points for each missing feedback element that would help the player understand the AI's decision-making process. Full score requires clear visualization of how the AI is adapting to the player's strategy.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as unexpected inputs, connection issues with brain.js library, 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. Visualization of neural network structure 2. Pattern analysis of player's moves 3. Difficulty levels that adjust the AI's learning rate). 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 prediction algorithms running simultaneously) 2. Function modules unrelated to the rock-paper-scissors game (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive animations that slow down AI response). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/view/AI logic layers), code organization, and optimization for browser performance. 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 error handling for the brain.js library integration. 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) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance when making selections. Deduct 5 points for each operation without feedback, 3 points for visual stuttering during animations, and 5 points if the game controls are not intuitive. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "hard"
-}

package/library/game_development-strategy/resource-management-game-with-building-upgrades.json

@@ -1,68 +0,0 @@
-{
-  "index": 179,
-  "question": "You are a code expert, please use your professional knowledge to generate accurate, professional responses. Be sure to ensure that the generated code is executable for demonstration.\n\nPlease use HTML and JavaScript to implement a resource management game where **Task**: Design a resource management system in which players need to collect and manage resources to build and upgrade buildings. **Hint**: Set up resource points where players can gather or trade resources, and use these resources for construction or upgrades.\n\nInclude comments in your code so that other developers can understand your implementation process.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the resource collection system fully implemented?",
-      "description": "Review whether the code accurately implements resource gathering mechanics (clicking on resource points, automatic collection over time, etc.) and resource storage/inventory system. Score 0 if resource collection is not implemented, 5 if only basic collection is implemented without variety, and 10 if the system includes multiple resource types with different collection methods and rates.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the building construction and upgrade system functional?",
-      "description": "Evaluate if the code includes a complete building system with construction prerequisites, resource costs, construction time, and meaningful upgrades. Check if buildings have different tiers/levels and if upgrades provide tangible benefits. Deduct 5 points if buildings don't have multiple upgrade levels, and 3 points if upgrades don't affect gameplay. Give 10 points for a comprehensive system with meaningful progression.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the resource trading or economy system implemented?",
-      "description": "Check if there's a mechanism for trading resources (market, exchange rates, NPC traders) or some form of economic gameplay. Evaluate whether the economy is balanced with appropriate resource values and exchange rates. Deduct 5 points if trading is one-dimensional, and 3 points if there's no price fluctuation or strategic depth. Full score for a dynamic economy with meaningful player decisions.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there a complete game progression and goal system?",
-      "description": "Assess whether the game has clear objectives, progression milestones, and win conditions (or endless play with increasing challenges). Check for tutorial elements, achievement systems, or quest/mission structure. Deduct 5 points if the game lacks direction, and 3 points if progression is linear with no strategic choices. Give 10 points for well-defined goals with multiple paths to success.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid resource counts, impossible building placements, race conditions in resource gathering, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Dynamic resource visualization 2. Weather/season effects on resource generation 3. Interactive tutorial 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 resource collection logics coexisting) 2. Function modules unrelated to resource management (e.g., a built-in unrelated mini-game) 3. Fancy effects that affect performance (e.g., excessive particle animations for simple actions). 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/resource management layers), code organization, and proper use of JavaScript 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 there's insufficient code commenting as requested in the requirements. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching that represents different resources distinctly 2) Proper layout spacing between resource counters, buildings, and action buttons 3) Clear visual hierarchy highlighting important game elements. Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic resource/building displays. 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) Resource collection feedback is immediate (≤ 100ms) 2) Building construction/upgrade animations have appropriate duration 3) Resource counters update smoothly rather than jumping. Deduct 5 points for each operation without feedback, 3 points for laggy animations during resource transactions, and 5 points for unintuitive building placement controls. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "easy"
-}