@getollie/cli 0.0.5 → 0.2.1

package/library/game_development-strategy/robot-war-game-with-ai-battle.json

@@ -1,68 +0,0 @@
-{
-  "index": 153,
-  "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.\n\nPlease use HTML and JavaScript to implement a Robot War game where players control robots to battle. Requirements: Implement robot AI and battle system.\n\nPlease include comments in your code to help other developers understand your implementation process.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core robot battle system fully implemented?",
-      "description": "Check if the code implements a complete battle system including robot movement mechanics, attack capabilities, collision detection, and damage calculation. Score 0 if core battle logic is missing, 5 points if only basic combat mechanics are implemented, and 10 points if the system includes advanced features like different attack types, defensive mechanisms, and battle physics.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the robot AI system properly developed?",
-      "description": "Evaluate the quality of the AI implementation. Check for different AI difficulty levels, decision-making algorithms, pathfinding capabilities, and strategic behaviors. Score 0 if AI is non-existent, 5 points for basic AI that can perform simple actions, and 10 points for sophisticated AI with adaptive behavior, multiple strategies, and different personality types.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the game UI/UX well-designed?",
-      "description": "Assess the interface design of the robot war game. Check for intuitive controls, clear battle indicators (health bars, power levels, etc.), and game status displays. Score 0 if the UI is missing essential elements, 5 points for a functional but basic UI, and 10 points for a polished interface with responsive design and clear visual feedback.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there a balanced game progression system?",
-      "description": "Examine if the game includes features like robot upgrades, skill progression, or battle difficulty scaling. Score 0 if progression elements are absent, 5 points if basic progression exists (like simple leveling), and 10 points for a comprehensive system with multiple upgrade paths, unlockable content, and balanced difficulty progression.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid user inputs, browser variations, performance issues on different devices). 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. Custom robot builders 2. Environment interactions that affect battles 3. Multiplayer capabilities 4. Spectator mode with battle replays). 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 different damage calculation systems) 2. Function modules unrelated to the robot war gameplay 3. Fancy effects that affect performance (e.g., excessive particle effects that slow down 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/rendering/input handling), code organization, maintainability, and use of appropriate design patterns. Check that comments are comprehensive and helpful. Deduct 5 points if global state pollution is found; deduct 5 points if the code duplication rate is high; deduct 5 points if comments are missing or unhelpful. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern game UI principles: 1) Consistent visual theme appropriate for a robot battle game 2) Proper layout with clear battle arena boundaries and UI elements 3) Appropriate use of color for game state indication (health, energy, etc.). Deduct 3 points for each crowded visual element, 5 points for a visually confusing interface, and 5 points for poor readability during gameplay. 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: 1) Robot movements and attacks have appropriate visual feedback 2) Frame rate remains stable during intense battle sequences 3) Game controls are responsive (≤100ms reaction time). Deduct 5 points for laggy animations, 3 points for inconsistent game speed, and 5 points for unresponsive controls. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "medium"
-}

package/library/game_development-strategy/sanguosha-like-card-game-implementation.json

@@ -1,68 +0,0 @@
-{
-  "index": 1127,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code whenever possible. Write a game code where the gameplay is similar to the card game \"Legend of the Three Kingdoms\" (Sanguosha).",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core card game system fully implemented?",
-      "description": "Review whether the code accurately implements the fundamental mechanics of Sanguosha, including proper card definitions (Basic, Strategy, Equipment), character abilities, and the turn-based gameplay flow. Score 0 if core mechanisms are missing, 5 if only basic card interactions are implemented, and 10 if special character abilities and complex card interactions (like chain reactions) are included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are the phase-based turn mechanics correctly implemented?",
-      "description": "Check if the code properly implements Sanguosha's distinct turn phases (Draw, Play, Discard), with phase-specific validations and event triggers. Verify that abilities that activate in specific phases function correctly. Deduct 3 points if phase transitions lack proper event handling, 5 points if certain phases are missing or incorrectly implemented. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the health and damage system appropriately designed?",
-      "description": "Evaluate if the health system correctly handles damage allocation, armor effects, character-specific health values, and dying/elimination conditions. Check for proper implementation of Wine effects on damage, Peach healing, and special abilities that alter damage (like Zhang Fei's). Deduct 5 points if wine/peach effects are missing, and 3 points if character-specific health modifications aren't handled. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Does the game handle character abilities and card effects correctly?",
-      "description": "Assess whether the code implements distinct character abilities (passive and active) and handles special card effects with proper timing triggers. Check for implementation of key cards like Duel, Barbarian Invasion, etc. Deduct 5 points if abilities lack proper activation conditions, and 3 points if card resolving order isn't handled correctly. Full score is 10 points for comprehensive implementation.",
-      "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, user operation errors, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. AI opponents with different difficulty levels 2. Customizable card decks and house rules 3. Animation and sound effects for critical actions). 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 damage calculation systems coexisting) 2. Function modules unrelated to Sanguosha (e.g., a built-in currency system) 3. Fancy effects that affect performance (e.g., excessive particle effects). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/view/controller layers), 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 reflecting the Three Kingdoms theme 2) Proper layout spacing for cards, characters, and action buttons 3) Professional font system with readable card text and clear status indicators. Deduct 3 points for each cluttered game element, 5 points for poor thematic design integration, and 5 points for illegible card information. 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 and targeting response ≤ 100ms 2) Card animation duration controlled between 300-500ms 3) Clear visual indicators for game state and available actions. Deduct 5 points for each operation without feedback, 3 points for laggy card movements, and 5 points for unclear turn progression indicators. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "hard"
-}

package/library/game_development-strategy/sichuan-mahjong-mini-game-rules.json

@@ -1,68 +0,0 @@
-{
-  "index": 366,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the code you generate is executable for demonstration. Please use HTML code to help me create a Sichuan Mahjong mini-game. The game should include rules for \"chi\" (eating), \"peng\" (claiming), and \"gang\" (kong). Make it visually appealing and provide the complete code.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Core Mahjong Game Mechanics Implementation",
-      "description": "Evaluate whether the code accurately implements the core mechanics of Sichuan Mahjong including tile representation, distribution, and gameplay rules.Score 0 if basic tile representation is missing, 5 points if basic gameplay is implemented but with incomplete rules, 10 points if the code fully implements all Sichuan Mahjong rules including correct tile sets (characters, dots, bamboos, dragons, winds), proper shuffling, wall building, and drawing mechanisms.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "'Chi', 'Peng', and 'Gang' Action Implementation",
-      "description": "Check if the special Mahjong actions are correctly implemented with proper validation logic.Deduct 3 points if any of the three actions (chi, peng, gang) is missing; deduct 2 points if the validation logic for these actions is incorrect; deduct 2 points if the concealed kong (an gang) vs. exposed kong (ming gang) distinction is not implemented. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Hand Evaluation and Scoring System",
-      "description": "Assess whether the code implements a proper Sichuan Mahjong scoring system with pattern recognition.Score 0 if there's no winning condition checking, 5 points if basic winning combinations are implemented but without proper point calculation, 10 points if the code fully implements Sichuan Mahjong's unique scoring patterns, fan (doubles) calculation, and accurate point distribution among players.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Game Flow and Turn Management",
-      "description": "Evaluate whether the game properly manages player turns, action priorities, and the overall game flow.Score 0 if turn management is not implemented, 5 points if basic turns exist but without proper action priorities (e.g., peng/gang taking precedence over drawing), 10 points if the code correctly implements the complete Mahjong turn cycle including proper timing windows for claiming discarded tiles and managing interruptions to the normal flow.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid moves, illegal actions, 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. Interactive tutorials for beginners 2. Game history replay 3. AI opponents with different difficulty levels 4. Custom tile themes).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 calculate the same score) 2. Function modules unrelated to Sichuan Mahjong (e.g., a built-in unrelated mini-game) 3. Fancy effects that affect performance (e.g., excessive animations when revealing tiles).Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/view/controller layers), code organization, and maintainability.Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no clear separation between game logic and presentation. 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 effectively represents Mahjong tiles with appropriate Chinese styling while maintaining modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (clear differentiation between players' hands, discards, and game information) 3) Professional font system (clear character rendering, especially for Chinese characters).Deduct 3 points for poorly rendered tiles, 5 points for a glaring color combination, and 5 points for chaotic layout that makes it difficult to understand the game state. 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 natural and responsive: 1) Clear visual indication of available actions (chi/peng/gang/hu) 2) Smooth animations when tiles are moved or revealed 3) Intuitive UI for selecting tiles and performing actions.Deduct 5 points for operations without feedback, 3 points for sluggish animations, and 5 points for confusing UI that makes it difficult to understand available actions. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "hard"
-}

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

@@ -1,68 +0,0 @@
-{
-  "index": 867,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to make any code you provide executable. Help me write code for a single-player Texas Hold'em poker game.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core Texas Hold'em game logic fully implemented?",
-      "description": "Review whether the code accurately implements the complete poker hand evaluation system, betting rounds (pre-flop, flop, turn, river), and proper hand ranking determination. Score 0 if core game logic is missing, 5 if basic hand evaluation exists but with errors, and 10 if all poker rules are correctly implemented including tie-breakers and special hand combinations.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the player interaction system properly implemented?",
-      "description": "Check if the game allows for all standard Texas Hold'em player actions (fold, check, call, raise, all-in) with appropriate validation of each action based on the current game state. Verify that the player can only perform legal actions at each stage. Deduct 5 points if action validation is missing, 3 points if the betting system doesn't enforce proper limits. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the AI opponent behavior realistic and challenging?",
-      "description": "Evaluate if the computer opponent uses strategic decision-making rather than purely random choices. Check for different difficulty levels, bluffing mechanics, and adaptation to the player's style. Deduct 5 points if the AI makes obviously poor decisions, 3 points if it lacks any strategic variation. Look for evidence of probability-based decision making. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the game state management comprehensive?",
-      "description": "Verify if the code properly manages the complete game lifecycle including dealing cards, transitioning between betting rounds, pot management, and determining winners. Check if game history is tracked for reviewing past hands. Deduct 5 points if state transitions are inconsistent, 3 points if pot calculation errors exist. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle edge cases such as all-in situations, side pots, insufficient funds, and invalid user inputs. Code with strong robustness should gracefully handle these scenarios with appropriate error messages or recovery mechanisms. Give 10 points if thoroughly implemented, 5 points if basic error handling exists, and 0 points if exceptions are unhandled.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Odds calculator during gameplay 2. Player statistics tracking 3. Customizable AI personalities 4. Hand strength visualizer). 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 evaluation algorithms) 2. Function modules unrelated to poker (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/card evaluation), proper class design, and maintainable code organization. Deduct 5 points if global state pollution is found or object-oriented principles are violated; 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 card display, table layout, and player information follow professional poker game conventions: 1) Clear card visibility and distinction 2) Intuitive chip representation and bet sizing 3) Appropriate use of poker terminology and symbols. Deduct 3 points for cluttered layouts, 5 points for unclear card representations, and 5 points for confusing betting interfaces. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the game flow and animations enhance the poker experience: 1) Card dealing animations under 500ms 2) Clear betting round transitions 3) Highlighted winning hands and pot distribution. Deduct 5 points for abrupt state changes without feedback, 3 points for unclear turn indicators, and 5 points for confusing or missing end-of-hand resolution displays. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "hard"
-}

package/library/game_development-strategy/solitaire-card-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 1466,
-  "question": "You are a coding expert. Please use your professional knowledge to generate accurate, professional responses. Be sure to provide code that is executable and displayable. Program a Solitaire card game.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core Solitaire game logic fully implemented?",
-      "description": "Review whether the code accurately implements the classic Solitaire rules including proper foundation building (Ace to King in same suit), tableau movement (descending order with alternating colors), and stock/waste pile management. Score 0 if core game mechanics are missing, 5 if basic card movement is implemented but with rule errors, and 10 if all Solitaire rules are properly enforced with win condition detection.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the card deck manipulation system well-designed?",
-      "description": "Check the implementation of card dealing, flipping, and movement between different game areas (tableau, foundations, stock, and waste). Proper card flipping animation should be included, and the waste-to-stock recycling mechanism should be implemented. Deduct 5 points if cards cannot be properly moved between all required areas, 3 points if the recycling mechanism is missing, and 2 points if card flipping is not visually indicated. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are the game's move validation and undo functionality implemented?",
-      "description": "Evaluate whether the code includes proper move validation to prevent illegal moves and an undo system that allows players to reverse their actions. Check for multiple undo levels and proper state management. Deduct 5 points if move validation is incomplete, 5 points if undo functionality is missing, and 3 points if the undo system can only revert a single move. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the game state persistence and scoring system implemented?",
-      "description": "Check if the game includes a way to save and restore games (local storage), and if it implements a proper scoring system (time-based, move-based, or traditional Solitaire scoring). Deduct 5 points if game saving is not implemented, 3 points if loading saved games doesn't restore the exact state, and 2 points if scoring is absent. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid clicking, illegal drag-and-drop attempts, browser refresh, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Automated smart move suggestions 2. Multiple card themes/designs 3. Statistics tracking for games played/won). 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 movement systems) 2. Function modules unrelated to Solitaire (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive animations that slow down 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), 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 card design and layout follow professional standards: 1) Clear card visibility (appropriate size and contrast) 2) Proper spacing between tableau columns 3) Professional color scheme for the game board (felt green or other suitable background). Deduct 3 points for cramped card layout, 5 points for poor card readability, and 5 points for unprofessional visual elements like pixelated card images. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the card movements and interactions conform to user expectations: 1) Responsive drag-and-drop mechanics with visual feedback 2) Smooth card flipping animations (150-300ms) 3) Clear indication of valid drop targets. Deduct 5 points for laggy card movement, 3 points for missing drag-and-drop visual feedback, and 5 points for confusing or inconsistent interaction patterns. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "medium"
-}

package/library/game_development-strategy/space-exploration-team-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 79,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Make sure the generated code is executable for demonstration purposes.\nPlease implement a Space Exploration Team game using HTML and JavaScript where players need to manage the team's resources and missions.\nSuggestion: Implement resource management and mission assignment systems.\nInclude comments in your code to help other developers understand your implementation process.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the resource management system fully implemented?",
-      "description": "Review whether the code implements a comprehensive resource management system (oxygen, fuel, food, materials, etc.) with proper balance mechanics. Check for resource generation, consumption, and storage limits. Score 0 if no resource system exists, 5 if only basic resources without dynamics are implemented, and 10 if resources have interdependencies and strategic management options.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the mission assignment system properly designed?",
-      "description": "Evaluate the mission system's complexity and engagement. Check for different mission types, varying difficulties, resource requirements, success/failure conditions, and rewards. Deduct 5 points if missions lack variety, 3 points if there's no risk-reward balance, and 5 points if crew assignment mechanics are missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the game progression system implemented?",
-      "description": "Check whether the game includes a meaningful progression system with technology research, base/ship upgrades, crew skill development, or story advancement. Deduct 5 points if progression is linear without player choices, 3 points if there's no long-term goal, and 5 points if progression milestones lack meaningful rewards. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the crew management system detailed and functional?",
-      "description": "Assess the depth of the crew management system including recruitment, skill specialization, fatigue/morale mechanics, and assignment logic. Look for crew member individuality and specialization. Score 0 if crew management is absent, 5 if it's basic with minimal differentiation, and 10 if crew members have distinct skills, personalities, and development paths.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as resource depletion, all crew members unavailable, mission failures, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Random space events affecting gameplay 2. Diplomatic relations with alien civilizations 3. Dynamic universe with changing conditions). 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 tracking systems coexisting) 2. Function modules unrelated to space exploration (e.g., a built-in music player) 3. Fancy effects that affect performance (e.g., excessive particle animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/view/data models), code comments as required by the task, 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 insufficient or misleading. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Space-themed color palette that's consistent and thematic 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 indicators for resource changes and mission status. Deduct 5 points for each operation without feedback, 3 points for visual after-images during fast updates, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "medium"
-}

package/library/game_development-strategy/spider-solitaire-game-implementation.json

@@ -1,68 +0,0 @@
-{
-  "index": 1756,
-  "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 write a Spider Solitaire game using JavaScript.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Spider Solitaire game core mechanics fully implemented?",
-      "description": "Review whether the code accurately implements the complete Spider Solitaire game mechanics including deck creation, card dealing, move validation, sequence building, and completion detection. Score 0 if the core mechanics are missing, 5 if only basic card movement is implemented, and 10 if all standard Spider Solitaire rules (including different difficulty levels with 1-4 suits) are fully included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the card manipulation and movement system properly implemented?",
-      "description": "Check if the code implements proper card dragging, dropping, flipping, and stacking according to Spider Solitaire rules. Verify that cards can only be moved according to valid sequences (descending order), and that completed sequences (K through A of the same suit) are automatically removed. Deduct 5 points if validation rules are incorrect, 3 points if sequence completion detection is faulty. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Does the game include all essential Spider Solitaire features?",
-      "description": "Evaluate whether the implementation includes dealing additional cards when needed, undo/redo functionality, scoring system, game timer, and different difficulty options (1, 2, or 4 suits). Deduct 3 points if dealing additional cards is not implemented, 2 points for missing undo/redo, 2 points for no scoring system, and 3 points for missing difficulty options. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the game state management properly implemented?",
-      "description": "Check whether the code includes proper game state management, including initialization, save/load functionality, win/lose detection, and game statistics tracking. Deduct 5 points if game state persistence is not implemented, and 3 points if win condition detection is incorrect. Give 10 points if fully implemented with proper state transitions.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid moves, rapid clicking, browser refreshes, 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. Automatic move suggestions 2. Game statistics and achievements 3. Custom card themes/designs). 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 movement handlers) 2. Function modules unrelated to Spider Solitaire (e.g., unrelated mini-games) 3. Fancy effects that affect performance (e.g., excessive animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/view layers), code organization, naming conventions, and documentation. 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 card design and layout follow traditional card game aesthetics: 1) Clear card visuals with proper suit and rank indicators 2) Proper spacing between tableau columns 3) Professional font system for game UI elements. Deduct 3 points for each hard-to-distinguish card element, 5 points for poor contrast between cards and background, and 5 points for chaotic tableau layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the card movement animations and interactions conform to user expectations: 1) Card drag-and-drop feels natural with <100ms response time 2) Card flip animations complete within 300ms 3) Clear visual feedback for valid and invalid moves. Deduct 5 points for each interaction without feedback, 3 points for jerky card movements, and 5 points for confusing or misleading visual cues. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "hard"
-}

package/library/game_development-strategy/teamfight-tactics-html-implementation.json

@@ -1,68 +0,0 @@
-{
-  "index": 259,
-  "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 purposes. Implement Teamfight Tactics using HTML.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core game board and piece placement system implemented?",
-      "description": "Check whether the HTML/CSS/JavaScript code accurately implements the hexagonal game board used in TFT, with correct grid alignment and piece placement. Verify if unit positioning logic is implemented, including bench positions and board positions. Score 0 if the hexagonal board isn't implemented, 5 if only basic positioning exists, and 10 if the complete board with proper unit dragging/positioning is fully functional.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the champion/unit system properly implemented?",
-      "description": "Evaluate if the code includes proper representation of champions with their attributes (cost, stars, traits, abilities), and if unit upgrading mechanics (combining 3 identical units) are implemented. Check if unit stats and abilities are displayed when selected. Deduct 3 points if champions lack proper traits/synergies, 5 points if unit upgrading is missing, and 3 points if unit stats display is incomplete. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are team synergies and trait bonuses implemented?",
-      "description": "Verify whether the code calculates and displays trait synergies based on active units on the board. Check if trait thresholds and corresponding bonuses are implemented correctly and visually indicated. Score 0 if synergies aren't implemented, 5 if basic trait counting exists but without effects, and 10 if complete synergy system with visual indicators and actual gameplay effects is implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the game economy and shop system implemented?",
-      "description": "Check if the shop system allows purchasing units, refreshing the shop, and if the player economy (gold accumulation, interest system) is implemented. Verify if leveling up mechanics and shop odds based on player level work correctly. Deduct 3 points if gold interest isn't calculated, 5 points if shop probabilities don't change with levels, and 3 points if bench management is problematic. 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 unit placements, attempting actions without sufficient gold, browser window resizing, 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 combat simulations 2. Detailed damage/healing statistics 3. Item combination guide overlays). 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 calculate damage) 2. Function modules unrelated to TFT core gameplay (e.g., unnecessary social features) 3. Fancy effects that affect performance (e.g., excessive animations that slow down unit movement). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/view/data management layers), component reusability, and code organization. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no clear separation between game mechanics and UI rendering. 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 reflects TFT's visual identity 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system with clear readability for unit stats and traits. Deduct 3 points for each crowded visual element, 5 points for inconsistent visual styles, and 5 points for poor information hierarchy. 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 game requirements: 1) Responsive drag-and-drop for unit placement (≤ 50ms lag) 2) Clear visual feedback when performing actions (purchasing, combining units, activating synergies) 3) Intuitive UI for shop refreshes and unit management. Deduct 5 points for sluggish drag-and-drop mechanics, 3 points for unclear visual feedback on important actions, and 5 points for unintuitive gameplay controls. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "hard"
-}