@getollie/cli 0.0.1

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

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

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

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

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

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

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

@@ -0,0 +1,68 @@
+{
+  "index": 746,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the code you generate is executable for demonstration. Please create a Texas Hold'em poker game code.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core Texas Hold'em game logic fully implemented?",
+      "description": "Review whether the code accurately implements the poker hand evaluation system (high card, pair, two pair, three of a kind, straight, flush, full house, four of a kind, straight flush, royal flush), betting rounds structure (pre-flop, flop, turn, river), and proper blinds handling. Score 0 if core game logic is missing, 5 if basic hand comparison works but lacks betting rounds, and 10 if all official Texas Hold'em rules are correctly implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the player actions and betting mechanics properly implemented?",
+      "description": "Check whether all standard poker actions (fold, check, call, bet, raise, all-in) are implemented with proper validation. Ensure pot calculation is correct including side pots when players go all-in. Deduct 5 points if betting limits aren't enforced correctly, 3 points if side pots are incorrectly calculated, and 2 points if minimum raises aren't handled properly. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there a complete dealer/game flow management system?",
+      "description": "Evaluate whether the code includes proper dealer button rotation, blind progression, showdown management, and hand progression logic. Check if the game properly manages the sequence of play, including skipping folded players and handling all-in situations. Deduct 5 points if dealer rotation is incorrect, 3 points if blind progression doesn't work properly, and 3 points if showdown logic is incomplete. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the card deck management and dealing system correctly implemented?",
+      "description": "Check if the code includes proper 52-card deck generation, shuffling algorithm with sufficient randomness, and correct card dealing procedures (2 hole cards per player, 3 cards for flop, 1 for turn, 1 for river). Ensure cards are not duplicated and that burn cards are handled correctly between dealing rounds. Deduct 5 points if the shuffling algorithm has poor randomness, and 5 points if dealing procedures don't follow standard Texas Hold'em rules. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid bets, out-of-turn actions, disconnected players, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Odds calculator for current hand 2. Hand history with replay functionality 3. Player statistics tracking 4. Tournament support with blinds progression). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple hand evaluation algorithms coexisting) 2. Function modules unrelated to poker (e.g., a built-in chat system) 3. Fancy effects that affect performance (e.g., excessive animations during card dealing). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating card logic/betting logic/UI layers), unit test coverage for critical components like hand evaluation, and readability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there are no tests for critical game logic. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the poker table design follows professional principles: 1) Proper card and chip visualization with clear suits and denominations 2) Intuitive player positions around the table 3) Clear indication of betting amounts, pot size, and player actions. Deduct 3 points for unclear card representation, 5 points for confusing bet amount display, and 5 points for poor player status indicators. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the game flow and interactions conform to player expectations: 1) Clear indication of current player turn with ≤ 100ms feedback 2) Smooth animations for dealing cards and moving chips (300-500ms) 3) Accessible betting controls with clear value indicators. Deduct 5 points for unclear turn indicators, 3 points for jarring animations, and 5 points for confusing betting interfaces. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "hard"
+}

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

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

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

@@ -0,0 +1,68 @@
+{
+  "index": 70,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Try to ensure the generated code is executable for demonstration.\n\nPlease use HTML and JavaScript to implement a virtual currency game.\n\n**Task**: Design a virtual currency system where players can earn virtual currency through in-game activities and use it to purchase items and equipment.\n\n**Hint**: Set up functions for earning and spending virtual currency, and provide various options for items and equipment.\n\nPlease include comments in your code to help other developers understand your implementation process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core virtual currency earning and spending system fully implemented?",
+      "description": "Review whether the code accurately implements mechanisms for players to earn virtual currency (e.g., completing tasks, winning games, daily rewards) and spend it (purchasing items/equipment). Check if the currency balance updates correctly and transactions are properly validated. Score 0 if the core currency system is missing, 5 if only basic earning OR spending is implemented, and 10 if both earning AND spending mechanisms are complete with proper validation.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the item/equipment inventory system properly implemented?",
+      "description": "Evaluate whether the code includes a complete inventory system that tracks purchased items, displays owned items, and implements item effects or stats. Check if items have proper attributes (e.g., price, type, effects) and if the inventory persists across sessions (using localStorage or similar). Deduct 5 points if items lack attributes beyond name/price, and 3 points if there's no persistence mechanism. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are various in-game activities for earning currency implemented?",
+      "description": "Check for the presence of multiple meaningful activities to earn currency (e.g., games, tasks, quests, timed rewards). Each activity should have a unique implementation with appropriate rewards based on difficulty/time. Give 10 points for 3+ well-implemented activities, 5 points for 1-2 basic activities, and 0 points if earning mechanics are trivial (e.g., just clicking a button).",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a complete game economy balance design?",
+      "description": "Evaluate whether the virtual economy is properly balanced—income rates vs. item prices should create meaningful progression. Check for currencies sink mechanisms to prevent inflation, progression scaling, and whether there are premium/rare items that take significant time to acquire. Deduct 3 points if the economy allows instant acquisition of all items, 5 points if there's no long-term progression design, and 3 points if currency generation has no limits. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as negative currency values, purchasing items without sufficient funds, invalid inputs) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Currency exchange rates between different types of currencies 2. Special time-limited offers or discounts 3. Achievements system tied to purchases). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple methods to update currency) 2. Function modules unrelated to the virtual currency game (e.g., a built-in calculator) 3. Fancy effects that affect performance (e.g., excessive animations that slow down transactions). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating currency logic/item management/UI layers), code organization, and quality of comments as requested in the task. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if comments are missing or unhelpful. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Visual feedback when earning/spending currency 2) Transition animations when purchasing items 3) Clear visual focus on important elements like balance and available items. Deduct 5 points for each operation without feedback, 3 points for jarring transitions when updating currency values, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "easy"
+}