@getollie/cli 0.0.5 → 0.2.1

package/library/game_development-sports/sports-game-spectator-atmosphere.json

@@ -1,68 +0,0 @@
-{
-  "index": 76,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable when possible.\n\nPlease use HTML and JavaScript to implement a sports game: Spectators and Atmosphere Creation\n\n**Task**: Design a spectator system where audiences react and cheer in different game scenarios to enhance the game atmosphere.\n\n**Hint**: You can use simple animations and sound effects to simulate audience reactions.\n\nPlease create the game and include comments in your code to help other developers understand your implementation process.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the spectator system fully implemented?",
-      "description": "Review whether the code implements a dynamic spectator system with varied reactions to different game events. Score 0 if spectators are just static images, 5 if basic crowd animations exist but with limited variety, and 10 if spectators show contextually appropriate reactions to multiple game scenarios (e.g., cheering for goals, disappointed reactions for misses, wave animations during slow moments).",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the audience reaction system event-driven?",
-      "description": "Check if the audience reactions are properly triggered by game events through an event system. The implementation should include event listeners for game scenarios, randomized reaction selection based on event type, and smooth transitions between different crowd states. Deduct 5 points if reactions are hard-coded/timed rather than event-driven, and 3 points if there's no variation in reactions to similar events. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the sound effect system comprehensive?",
-      "description": "Evaluate whether appropriate sound effects are implemented for crowd reactions (cheers, gasps, applause, boos, chants, etc.) with volume control and proper audio layering. Assess if sounds match the visual reactions and game context. Deduct 5 points if sound effects don't vary by event intensity, 3 points if there's no volume control based on event importance, and 5 points if there are no sounds at all. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the atmosphere creation system scalable?",
-      "description": "Analyze whether the code implements a scalable system that can adjust crowd density, reaction intensity, and home/away fan distribution. Check for parameters that control crowd bias, crowd size, enthusiasm levels, and noise levels. Deduct 5 points if the system has fixed crowd settings, 3 points if it lacks home/away fan distinction, and 3 points if crowd enthusiasm doesn't change throughout the game. 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-fire events, audio playback issues, browser compatibility issues, etc.) and provide fallback mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Dynamic weather affecting crowd appearance/behavior 2. Crowd-initiated Mexican waves or chants 3. Fan rivalries visualized in different sections). 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 crowd reactions (e.g., multiple cheer animations triggered by the same event) 2. Function modules unrelated to spectator atmosphere (e.g., unnecessary game mechanics) 3. Fancy effects that affect performance (e.g., too many individual spectator animations running simultaneously). 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 crowd logic/view/audio systems), cohesive organization of related functionality, and performance optimization for animations and sound. 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 no performance considerations are implemented for large crowds. 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) Realistic or stylistically consistent crowd rendering 2) Proper visual hierarchy between game action and spectators 3) Appropriate use of color to distinguish fan sections or reactions. Deduct 3 points for each visual inconsistency in crowd appearance, 5 points for spectator visuals that distract from main gameplay, and 5 points for unrealistic or jarring crowd positioning. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the spectator animations and transitions conform to human perception characteristics: 1) Natural crowd movement patterns (not robotic synchronization) 2) Gradual build-up and fade of crowd reactions 3) Varied timing of individual spectator reactions within a group. Deduct 5 points for unnatural synchronized movements, 3 points for abrupt transitions between crowd states, and 5 points for animations that freeze or stutter during high activity. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Sports",
-  "difficulty": "medium"
-}

package/library/game_development-sports/sports-team-management-season-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 99,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable when possible.\n\nPlease use HTML and JavaScript to implement a Sports: Team Management and Season Mode\n\n**Task**: Implement a team management system where players can manage team rosters, training, and tactics, and participate in a complete season of matches.\n\n**Hint**: You can design a season progression system, and adjust team performance and player rankings based on match results.\n\nGame, and include some comments in the code so that other developers can understand your implementation process.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the team management system fully implemented?",
-      "description": "Review whether the code accurately implements team roster management through HTML/JavaScript, including player recruitment, release, position assignment, and attribute management (skills, stamina, morale, etc.). Check if training systems are implemented with proper progression mechanics. Score 0 if core team management is missing, 5 if only basic roster operations exist, and 10 if comprehensive team management with training and player development is fully included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the season mode progression system implemented?",
-      "description": "Check whether the season system includes complete match scheduling, league tables, playoff structures, and season calendar management. Evaluate if match simulation logic considers team tactics, player conditions, and realistic scoring mechanisms. Deduct 5 points if match results are purely random, and 3 points if season progression lacks proper pacing or milestone events. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the tactical system designed with strategic depth?",
-      "description": "Evaluate whether the tactical system allows formation changes, strategy adjustments (offensive/defensive styles), and player role assignments that meaningfully impact match outcomes. Check if tactics interact with player attributes and opponent strategies. Deduct 5 points if tactics are cosmetic only, and 3 points if the system lacks tactical variety or counter-strategies. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the performance tracking and ranking system constructed?",
-      "description": "Check whether the code includes comprehensive statistics tracking for both teams and individual players, dynamic ranking systems that update based on performance, and historical data preservation across seasons. Evaluate if performance metrics influence player values, team reputation, and future opportunities. Deduct 5 points if statistics are not persistent, and 3 points if ranking algorithms are overly simplistic. Give 10 points if fully implemented with detailed analytics.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid player transfers, corrupted save data, simulation 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-powered scouting recommendations 2. Dynamic weather effects on matches 3. Social media simulation for team popularity 4. Injury recovery mini-games). 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 save/load systems coexisting) 2. Function modules unrelated to sports management (e.g., built-in social media feed) 3. Fancy effects that affect performance (e.g., complex 3D stadium renders). Deduct 3 points for each redundancy found, and directly deduct 10 points if core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/UI/data management layers), code documentation quality, and maintainable architecture patterns. Deduct 5 points if global state pollution is found or proper encapsulation is missing; deduct 5 points if the code lacks sufficient comments or has poor naming conventions; deduct 3 points if data structures are inefficient. 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 sports management UI principles: 1) Consistent color scheme reflecting team branding 2) Dashboard layout with clear information hierarchy 3) Professional typography with readable statistics tables. Deduct 3 points for each cluttered interface section, 5 points for poor color contrast in data visualization, and 5 points for inconsistent spacing or alignment. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the interactive elements provide appropriate feedback: 1) Drag-and-drop for player transfers with visual confirmation 2) Smooth transitions between different management screens 3) Real-time updates during match simulations with proper pacing. Deduct 5 points for each unresponsive interaction, 3 points for jarring transitions between screens, and 5 points for poorly paced match simulation that feels rushed or tedious. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Sports",
-  "difficulty": "medium"
-}

package/library/game_development-strategy/3d-checkers-game-multiplayer.json

@@ -1,68 +0,0 @@
-{
-  "index": 1000,
-  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Be sure to make the generated code executable for demonstration. Please write me a code for a 3D checkers game that I can play with my desktop friends.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the 3D checkers game board and piece visualization properly implemented?",
-      "description": "Review whether the code implements a true 3D representation of the checkers board and pieces using appropriate technologies (Three.js, WebGL, etc.). Check if the perspective allows clear view of all positions, pieces are distinguishable, and the 3D coordinate system is properly mapped to game logic. Score 0 if only 2D visualization, 5 if basic 3D with limited camera angles, and 10 if full 3D implementation with adjustable camera angles.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are the checkers game rules correctly implemented?",
-      "description": "Evaluate whether the code implements all standard checkers rules: piece movement, capturing mechanics (including multiple jumps), king promotion, and win conditions. Check if the game properly validates legal moves and prevents illegal ones. Deduct 5 points if king movement rules are incorrect, 3 points if multiple jumps aren't enforced when available, and 5 points if win conditions are improperly detected.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the local multiplayer functionality properly implemented?",
-      "description": "Check whether the code includes proper turn management between players, clear indication of whose turn it is, and suitable mechanics for local play (such as board rotation between turns or clear player indicators). Deduct 5 points if the turn system is buggy, 3 points if there's no visual indication of current player, and 5 points if the game doesn't properly reset between matches.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the user interaction with the 3D environment intuitive and responsive?",
-      "description": "Assess whether the code implements intuitive selection and movement of pieces in 3D space. Check if there's highlighting of valid moves, clear feedback on selection, and smooth animation of moves. Deduct 5 points if piece selection is unreliable, 3 points if valid moves aren't highlighted, and 5 points if movement animations are jarring or missing.",
-      "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, 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. Different visual themes for the board and pieces 2. Replay functionality with move history 3. Customizable piece animations or special effects). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to select pieces) 2. Function modules unrelated to the checkers game (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive particle effects or shader complexity). 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/3D rendering/user input 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 rendering and 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 overall design follows modern design principles: 1) Harmonious color matching for the 3D environment and UI elements 2) Proper layout spacing for UI components 3) Clear distinction between game elements and controls. Deduct 3 points for each cluttered UI element, 5 points for poor contrast between board and pieces, and 5 points for inconsistent design language between 3D elements and UI. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the 3D performance optimized for desktop play?",
-      "description": "Judge whether the 3D implementation is optimized for desktop environments: 1) Maintains stable 60fps on mid-range hardware 2) Uses appropriate level of detail for models and textures 3) Implements proper culling and rendering optimizations. Deduct 5 points for noticeable frame drops during normal play, 3 points for excessive memory usage, and 5 points for lack of graphics options to accommodate different hardware capabilities. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "hard"
-}

package/library/game_development-strategy/agar-io-web-game-html-javascript.json

@@ -1,68 +0,0 @@
-{
-  "index": 1642,
-  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Be careful to ensure that the generated code is executable for demonstration. Help me create a web game similar to Agar.io, requiring it to be identical to the original. I have no programming knowledge whatsoever. It should be made in a format that can be saved as a notepad file, then directly run in a web browser.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core gameplay of Agar.io accurately implemented?",
-      "description": "Review whether the code correctly implements the fundamental mechanics of Agar.io: 1) Player-controlled cell that grows by consuming smaller cells 2) Shrinking mechanism when splitting 3) Cell splitting functionality 4) Proper mass/size relationship. Score 0 if these core mechanics are missing, 5 if only basic movement and consumption are implemented, and 10 if all features including splitting, ejecting mass, and proper growth/shrinkage dynamics are included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the multiplayer simulation properly implemented?",
-      "description": "Check whether the code includes AI opponents that mimic player behavior when real multiplayer is unavailable (since true multiplayer would require server infrastructure). Evaluate if these AI cells follow convincing movement patterns, demonstrate varied strategies (aggressive/passive), and properly interact with the player's cell. Deduct 5 points if AI behavior is too predictable, 3 points if they don't react to player actions. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are the physics and collision detection accurately implemented?",
-      "description": "Assess whether the physics system correctly handles: 1) Size-based consumption rules 2) Momentum and mass effects on movement speed 3) Collision detection between cells of different sizes 4) Proper handling of cell merging after splitting. Deduct 3 points for each physics inconsistency with the original game, and 5 points if cells pass through each other incorrectly. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the game environment and food generation system properly implemented?",
-      "description": "Evaluate the implementation of: 1) Randomly generated food pellets 2) Properly scaled game map 3) Zoom functionality that adjusts based on player cell size 4) Virus cells that can split larger players. Deduct 3 points if food generation is not continuous, 5 points if the map lacks boundaries, and 5 points if viruses don't function correctly. 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 mouse movements, browser resize, performance issues on slower devices) 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 beyond the original Agar.io (e.g., 1. Custom skins selection 2. Local high score tracking 3. Different game modes like timed challenges). 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 implementations of similar functions (e.g., multiple ways to handle the same game event) 2. Function modules unrelated to the Agar.io concept (e.g., unnecessary menu systems) 3. Fancy effects that affect performance (e.g., excessive particle effects or 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/rendering/input handling), code organization, and whether the single HTML file structure is well-organized for a beginner to understand. Deduct 5 points if global variable pollution is excessive; deduct 5 points if the code is not commented or explained for beginners; deduct 5 points if the game loop implementation is inefficient. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision match the original Agar.io design?",
-      "description": "Evaluate whether the visual implementation matches Agar.io's clean aesthetic: 1) Simple colored circles with proper gradients 2) Clear size differentiation 3) Minimal UI elements for score and leaderboard 4) Clean playing field with subtle grid pattern. Deduct 3 points for each visual element that differs significantly from the original, 5 points for an overcomplicated interface, and 5 points for missing essential UI components like the leaderboard. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and responsive?",
-      "description": "Judge whether the game's interactions match the original Agar.io experience: 1) Smooth mouse-following movement 2) Responsive splitting with Space key 3) Proper mass ejection with W key 4) Seamless camera zoom as player grows. Deduct 5 points for input lag exceeding 100ms, 3 points for choppy animations during rapid growth/movement, and 5 points for incorrect handling of key commands. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "hard"
-}

package/library/game_development-strategy/ai-chess-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 1122,
-  "question": "You are a coding expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the generated code is executable when possible. Create code for an AI chess game.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the chess game core mechanics fully implemented?",
-      "description": "Review whether the code accurately implements the chessboard representation, piece movement rules, and game state management. Check if all chess pieces (pawns, knights, bishops, rooks, queens, kings) follow standard chess rules. Score 0 if the core game logic is missing, 5 if basic movement is implemented but with rule gaps, and 10 if all standard chess rules are correctly implemented including special moves (castling, en passant, promotion).",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the AI opponent functionality properly implemented?",
-      "description": "Evaluate the AI algorithm's implementation and complexity. Check if it uses appropriate techniques like minimax with alpha-beta pruning, evaluation functions, or more advanced approaches like neural networks. Score 3 for basic random move selection, 7 for a medium-difficulty AI that can anticipate a few moves ahead, and 10 for a sophisticated AI that implements multiple difficulty levels and demonstrates strategic play.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is there a complete game state management system?",
-      "description": "Check whether the code includes game initialization, turn tracking, win/loss/draw detection, and game history recording. Verify if checkmate, stalemate, and draw conditions (50-move rule, threefold repetition, insufficient material) are properly detected. Deduct 3 points if any critical chess rules are missing, 2 points if game history is not maintained, and 2 points if draw conditions are not fully implemented. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the UI representation of the chess game properly implemented?",
-      "description": "Assess whether the chess board is correctly rendered with alternating colors, pieces are visually distinguishable, and the current game state is clearly displayed. Check if legal moves are visually indicated and if there's visual feedback for check, checkmate, and game end conditions. Deduct 5 points for missing visual cues, 3 points for poor piece differentiation, and 3 points for lack of game state indicators. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid moves, interrupted games, etc.) and provide friendly error handling or recovery mechanisms. Code with strong robustness should effectively handle edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exception handling exists, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Move suggestions for beginners 2. Game analysis after completion 3. Different AI personalities/playing styles 4. Interactive tutorials). 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 move validation logics) 2. Function modules unrelated to chess (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/UI/AI components), code organization, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the code lacks appropriate comments or documentation. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual feedback for piece selection, move execution, and game events. Deduct 5 points for each operation without feedback, 3 points for visual after-images during animations, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "easy"
-}

package/library/game_development-strategy/ancient-civilization-city-building-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 39,
-  "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.\n\nPlease implement an Ancient Civilization game using HTML and JavaScript where players need to rebuild an ancient city. \nHint: Implement city planning and civilization development.\n\nInclude some comments in your code so other developers can understand your implementation process.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the city planning system fully implemented?",
-      "description": "Review whether the code accurately implements a grid-based city planning system through HTML/JavaScript, including building placement mechanics, terrain constraints, and zoning functionality (residential, commercial, industrial areas). Score 0 if core city building mechanics are missing, 5 if only basic building placement is implemented, and 10 if comprehensive city planning with zoning restrictions and adjacency bonuses is fully included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the civilization development progression system implemented?",
-      "description": "Check whether the game includes a complete civilization advancement system with technology trees, resource management (food, materials, population), and era progression. Evaluate if research mechanics, resource production chains, and population growth are properly simulated. Deduct 5 points if resource balancing is missing, and 3 points if technology prerequisites are not enforced. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the ancient city rebuilding mechanic designed with historical authenticity?",
-      "description": "Evaluate whether the rebuilding system reflects authentic ancient civilization elements including appropriate building types (temples, markets, granaries, walls), historical resource constraints, and period-accurate visual design. Check if the game includes realistic construction timelines and resource requirements. Deduct 5 points if buildings lack historical context, and 3 points if the rebuilding progression feels anachronistic. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the complete game state management and save system constructed?",
-      "description": "Check whether the code includes comprehensive game state persistence, including city layout serialization, civilization progress tracking, and local storage integration. Evaluate if the game can resume from saved states and handle multiple save slots. Deduct 5 points if game state serialization is not implemented, and 3 points if the save/load mechanism is unreliable. Give 10 points if fully implemented with robust state management.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid building placements, resource shortage scenarios, browser compatibility issues, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the ancient civilization experience (e.g., 1. Dynamic weather affecting city development 2. Historical events and random challenges 3. Archaeological discovery mini-games 4. Trade route establishment with other civilizations). 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 calculation systems coexisting) 2. Function modules unrelated to ancient civilization building (e.g., modern technology elements) 3. Overly complex animations that affect gameplay performance (e.g., excessive particle effects for construction). Deduct 3 points for each redundancy found, and directly deduct 10 points if core city-building 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/UI management layers), code organization with proper commenting as requested, and maintainable architecture. Deduct 5 points if global state pollution is found or object-oriented principles are not followed; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if insufficient commenting makes the code hard to understand for other developers. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards with ancient civilization theming?",
-      "description": "Evaluate whether the overall design follows ancient civilization aesthetics: 1) Appropriate color palette evoking ancient times (earth tones, stone textures) 2) Proper layout spacing with clear building grid visualization 3) Thematic UI elements that match the ancient setting. Deduct 3 points for each anachronistic visual element, 5 points for color schemes that break immersion, and 5 points for UI elements that don't match the ancient theme. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless for city building?",
-      "description": "Judge whether the city building interactions conform to user expectations: 1) Building placement feedback with hover previews 2) Smooth camera/viewport controls for city navigation 3) Clear visual indicators for buildable areas and resource flows 4) Responsive building construction animations. Deduct 5 points for each building action without proper feedback, 3 points for laggy city navigation, and 5 points for unclear building placement indicators. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "hard"
-}

package/library/game_development-strategy/aura-rune-build-calculator-aoki-legend.json

@@ -1,68 +0,0 @@
-{
-  "index": 1400,
-  "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. Can you help me create a specific calculator for the Aura Rune builds in the Aoki Legend mobile game, which calculates optimal rune set combinations?",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Aura Rune calculation algorithm correctly implemented?",
-      "description": "Review whether the code accurately implements the Aura Rune stat calculation formulas, including base stats, percentage bonuses, set effects, and multiplicative stacking rules. Check if all rune types (ATK, HP, DEF, SPD, CRIT, etc.) are properly defined with correct coefficient calculations. Score 0 if core calculation logic is missing, 5 if only basic stat additions are implemented, and 10 if all complex multiplier interactions and diminishing returns are accurately calculated.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the optimal combination recommendation engine fully functional?",
-      "description": "Evaluate whether the optimization algorithm can effectively compare different rune set combinations and recommend the best builds based on user-defined priorities (damage output, survivability, speed tuning). Check if the system implements proper weight scoring, considers set bonuses, and handles constraint optimization (e.g., minimum speed requirements). Deduct 5 points if the algorithm uses simple brute force without optimization, and 3 points if set synergy effects are not considered. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the rune database and filtering system comprehensive?",
-      "description": "Check whether the system includes a complete rune database with all available rune sets from Aoki Legend, proper categorization by main stats and substats, and advanced filtering options. Evaluate if users can input their current rune inventory and filter by quality grades, enhancement levels, and specific stat ranges. Deduct 5 points if rune data is incomplete or outdated, and 3 points if filtering functionality is limited. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are build comparison and export features properly implemented?",
-      "description": "Assess whether the calculator provides side-by-side build comparisons with detailed stat breakdowns, damage calculations against different enemy types, and export functionality for sharing builds. Check if the system includes build saving/loading, team synergy analysis, and integration with popular gaming platforms or forums. Deduct 5 points if comparison features are superficial, and 3 points if export formats are limited. Give 10 points if fully implemented with multiple export options.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid rune inputs, calculation overflow, missing data, network timeouts when fetching game data, 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 calculator experience (e.g., 1. Real-time damage simulation against boss mechanics 2. AI-powered build suggestions based on current meta 3. Integration with game APIs for automatic rune import 4. Advanced statistical analysis with build performance tracking). 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 calculation methods (e.g., multiple stat computation engines coexisting) 2. Function modules unrelated to rune optimization (e.g., built-in character tier lists or gacha simulators) 3. Overly complex animations that slow down calculations (e.g., elaborate 3D rune visualizations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core calculation 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 calculation engine/UI components/data layers), unit test coverage for critical calculation functions, 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 calculation accuracy is not validated through comprehensive testing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the calculator interface follows modern design principles: 1) Gaming-appropriate color scheme that matches Aoki Legend's aesthetic (no more than 4 primary colors) 2) Proper layout spacing with clear sections for input/results/comparison (element spacing follows the 8px multiple principle) 3) Professional typography with readable fonts (body font size ≥ 14px, line height over 1.5 times) 4) Intuitive iconography for different rune types. Deduct 3 points for each crowded visual element, 5 points for color combinations that strain the eyes during long calculation sessions, and 5 points for chaotic data presentation layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the calculator interactions conform to user expectations: 1) Calculation updates with input delay ≤ 200ms for real-time feedback 2) Smooth transitions between different build configurations (300-500ms) 3) Clear visual indicators for loading states during complex optimizations 4) Intuitive drag-and-drop or click interactions for rune selection. Deduct 5 points for each operation without proper feedback, 3 points for laggy performance during intensive calculations, and 5 points for confusing navigation between calculator sections. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "hard"
-}

package/library/game_development-strategy/beautiful-interactive-web-page-garbage-sorting-mini-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 1060,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable for demonstration. Help me create a beautiful, interactive web page for a garbage sorting mini-game.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core garbage sorting game mechanism fully implemented?",
-      "description": "Check if the code implements the complete game logic including: item classification into correct categories (recyclable, hazardous, kitchen waste, other waste), scoring system, and validation of correct/incorrect sorting. Score 0 if core sorting mechanics are missing, 5 if basic sorting is implemented but lacks comprehensive validation, 10 if the system handles all waste types with proper feedback and scoring.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the drag-and-drop interaction properly implemented?",
-      "description": "Evaluate the implementation of the drag-and-drop functionality: verify if items can be smoothly dragged, if the hitbox detection works accurately when dropping items into bins, and if there's appropriate visual feedback during the dragging process. Deduct 5 points if mobile touch events aren't supported, 3 points if accessibility features are missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is there a complete game progression structure?",
-      "description": "Assess if the game has a proper structure with levels of increasing difficulty, clear goals, progress tracking, and performance metrics (time, accuracy, score). Check if there's a tutorial/onboarding experience for new players. Deduct 5 points if the difficulty curve is missing, 3 points if there's no feedback on player progress. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the educational content about garbage sorting accurate and complete?",
-      "description": "Review whether the game provides accurate information about different waste categories, sorting guidelines, and environmental impact. Check if it includes tooltips, explanations for incorrect sorting, or educational facts. Deduct 5 points if information is inaccurate, 3 points if explanations for sorting decisions are missing. 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 incorrect user inputs, browser compatibility issues, performance on different devices) 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. Real-time environmental impact calculation 2. Leaderboard with social sharing 3. Animated educational sequences about waste processing). 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 scoring systems) 2. Function modules unrelated to garbage sorting (e.g., unrelated 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/data 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 separation between game assets and logic. 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 (environmental theme with consistent palette) 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) Immediate visual feedback when items are sorted correctly/incorrectly 2) Smooth animations for dragging/dropping waste items 3) Clear visual cues for interactive elements. Deduct 5 points for each operation without feedback, 3 points for jerky animations, and 5 points for confusing interaction design. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "medium"
-}