@getollie/cli 0.0.5 → 0.2.1

package/library/game_development-strategy/interactive-chess-board-game-svg.json

@@ -1,68 +0,0 @@
-{
-  "index": 199,
-  "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.\n\nPlease help me implement the following requirement using code, specifically using SVG code. The requirement is to create: Design an interactive chess/board game, displaying the game pieces using SVG graphics.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the SVG-based chessboard correctly implemented?",
-      "description": "Evaluate whether the SVG chessboard is properly structured with the correct dimensions, grid layout (8x8 for chess), and appropriate coordinate system. Check if the squares are correctly colored in an alternating pattern. Deduct 5 points if the grid is inconsistent, 3 points if coordinates are missing or incorrect. Give full 10 points only if the board has proper scaling and responsive design.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are the chess pieces accurately represented using SVG?",
-      "description": "Examine whether all chess pieces (pawns, rooks, knights, bishops, queen, and king) are properly implemented as SVG elements with appropriate paths/shapes. Each piece should be visually distinct and follow traditional chess iconography. Deduct 2 points for each piece with significant visual issues, 5 points if pieces lack detail or are difficult to distinguish from each other. Award full 10 points only if pieces demonstrate professional-level SVG craftsmanship with proper scaling and viewBox attributes.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the piece movement interaction properly implemented?",
-      "description": "Review the implementation of drag-and-drop (or click-to-select-and-move) functionality for moving chess pieces. Check if the code includes event listeners for mouse/touch interactions, proper handling of piece selection and placement, and visual feedback during moves. Deduct 5 points if pieces cannot be moved interactively, 3 points if movement lacks visual feedback or has noticeable glitches. Award 10 points if movements are smooth and include proper animations for transitions.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Does the implementation enforce chess rules correctly?",
-      "description": "Verify that the code enforces standard chess rules: legal move validation, turn-taking, check/checkmate detection, special moves (castling, en passant, promotion), and win conditions. Deduct 2 points for each missing rule implementation, 5 points if the core movement rules are incorrect or inconsistent. Give 10 points only if the implementation handles all standard chess rules including edge cases.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid moves, unexpected user interactions, browser compatibility issues) and provide friendly error messages 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 highlighting of possible moves 2. SVG animations for captures 3. Undo/redo functionality with visual history 4. Piece movement trails or effects). Add 2-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 SVG elements 2. Unnecessary complex SVG paths that could be simplified 3. Extra visual effects that harm performance or distract from 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 SVG rendering/game logic/interaction handlers), code organization, and maintainability. Deduct 5 points if SVG elements are not properly grouped or structured; deduct 5 points if the code lacks comments or documentation; deduct 5 points if there's significant duplication in SVG definitions or JS functions. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the SVG visual design follows modern design principles: 1) Harmonious color scheme for the board and pieces 2) Proper proportions and consistent styling of chess pieces 3) Clear visual distinction between the pieces with appropriate contrast. Deduct 3 points for inconsistent piece styling, 5 points for poor color choices that affect readability, and 5 points for chaotic layout or proportions. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the SVG interactions conform to human perception characteristics: 1) Immediate visual feedback on piece selection 2) Smooth animations for piece movement (150-300ms) 3) Clear visual cues for legal moves and captures. Deduct 5 points for each interaction without feedback, 3 points for jerky or missing animations, and 5 points for confusing interaction patterns that make it difficult to understand game state. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "hard"
-}

package/library/game_development-strategy/interactive-chess-game-svg-javascript.json

@@ -1,68 +0,0 @@
-{
-  "index": 9,
-  "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. \n\nPlease help me implement the following requirements using SVG code: Design an interactive chess game that allows users to move pieces and view game history, implemented using SVG and JavaScript.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the chess board and pieces visualization accurately implemented using SVG?",
-      "description": "Review whether the SVG code correctly implements the 8x8 chess board grid with proper colors (alternating light and dark squares) and all chess pieces with standard representations. Check if the elements have appropriate ids/classes for manipulation. Pieces should be properly sized and centered in squares. Score 0 if the board is incomplete, 5 if board exists but pieces are improperly represented, 10 if all pieces have proper SVG paths with clean design.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is piece movement and selection properly implemented?",
-      "description": "Evaluate the interaction mechanism for selecting and moving pieces. Check if the code includes proper event listeners (mousedown/click/drag), visual feedback for selection, and validation for legal chess moves. Deduct 5 points if drag-and-drop functionality is missing, 3 points if there's no visual indication of selected pieces, and 5 points if legal move validation is absent. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the chess game logic fully implemented?",
-      "description": "Assess whether the code implements the complete ruleset of chess, including special moves like castling, en passant, pawn promotion, and checks/checkmates. Examine if turn-based gameplay is enforced. Score 0 if basic piece movement rules are missing, 5 if basic rules exist but special moves are not implemented, and 10 if all chess rules are correctly enforced with proper game state management.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the game history viewer functional and comprehensive?",
-      "description": "Check whether the game history is properly recorded and displayed using a standardized format (like algebraic notation). Verify if users can navigate through previous moves, with the board updating accordingly. Deduct 5 points if history is not visually accessible, 3 points if the notation is non-standard or difficult to read, and 5 points if historical positions cannot be reviewed on the board. 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, browser resizing, out-of-sequence operations) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Move suggestions highlighting 2. Captured pieces display 3. Check/checkmate animations or indicators 4. Interactive move analysis). Add 2.5 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 chess visualization (e.g., unnecessary animations) 3. Fancy effects that affect performance (e.g., complex shadows or gradients that slow rendering). 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/user interaction layers), code organization, and maintainability. Check if SVG elements are properly structured and manipulated. Deduct 5 points if global state pollution is found; deduct 5 points if the code lacks comments or uses cryptic variable names; deduct 5 points if SVG manipulation is inefficient or uses poor practices. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the SVG design follows modern design principles: 1) Harmonious color matching between board and pieces 2) Proper visual hierarchy with clear distinction between interactive and static elements 3) Clean, readable design for game history view. Deduct 3 points for each visually cluttered element, 5 points for poor color combinations that affect readability, and 5 points for inconsistent styling. 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) Piece movement animations feel natural (200-300ms) 2) Selection and highlighting provide immediate visual feedback (≤100ms) 3) Game history navigation is intuitive and responsive. Deduct 5 points for choppy animations, 3 points for delayed visual feedback, and 5 points if the interface becomes unresponsive during animations. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "hard"
-}

package/library/game_development-strategy/javascript-planet-defense-game-introduction.json

@@ -1,68 +0,0 @@
-{
-  "index": 4,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. JS Planet Defense Game Introduction\n\n**Game Overview:**\n\"JS Planet Defense Game\" is a strategy defense game developed with JavaScript. Players take on the role of a defense commander in space, operating the only target to combat incoming enemies.\n\n**Gameplay:**\nIn \"JS Planet Defense Game,\" players control a single target, which is the only unit capable of attacking enemies. Players need to use the target's weapon systems and tactical abilities to precisely strike incoming enemies, preventing them from causing damage to Earth or other important objectives. As the game progresses, enemies become increasingly powerful and complex, requiring players to continuously optimize their tactics and strategies to protect their objectives.\n\n**Game Features:**\n1. **Unique Operation Experience**: The uniqueness of the game lies in the fact that players can only operate one target, requiring precise control of movement and attacks to maximize defense effectiveness.\n\n2. **Challenging Level Design**: The game features multiple challenging levels, each with numerous objectives and enemies, demanding flexible thinking and quick reaction from players.\n\n**Game Tips:**\n- **Precise Target Control**: Learn to accurately control the target's movement and attacks, leveraging the characteristics of weapon systems to maximize impact on enemies.\n\n- **Tactical Positioning**: Choose appropriate positions for your target based on enemy movement paths and attack patterns to enhance defensive effectiveness.\n\n- **Tactical Upgrades and Optimization**: Utilize resources and upgrade systems in the game to continuously enhance your target's combat capability and survivability to face increasingly complex enemy challenges.\n\nOverall, \"JS Planet Defense Game\" offers players a brand new space defense challenge through its unique operational experience and deep tactical strategy. Whether pursuing high scores or exploring new tactical layouts, players can find lasting challenges and satisfaction in the game. Please include comments in your code to help other developers understand your implementation process.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core target control system properly implemented?",
-      "description": "Evaluate whether the code accurately implements target movement and attack mechanics through JavaScript. Check if the control system includes smooth movement (acceleration/deceleration), precision targeting (hit detection), and proper response to user input (mouse/keyboard). Score 0 if core controls are non-functional, 5 if basic movement and shooting are implemented but lack precision, and 10 if the control system feels responsive and precise with advanced features like aim assist or predictive targeting.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are the enemy AI and attack patterns implemented?",
-      "description": "Check whether the code includes sophisticated enemy behavior patterns, varying enemy types with distinct movement and attack strategies, and proper difficulty scaling between levels. Examine if enemies respond dynamically to player positioning. Deduct 5 points if enemies follow only linear paths, 3 points if difficulty scaling is absent, and 2 points if there's no variety in enemy types. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the level design system properly structured?",
-      "description": "Review whether the code implements a comprehensive level progression system with increasing challenges, multiple objectives, and diverse enemy configurations. Check for level parameters configuration, wave management, and event triggering mechanisms. Deduct 5 points if levels are hard-coded with no flexible configuration system, and 3 points if there's no proper game state management between levels. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the tactical upgrade system implemented?",
-      "description": "Assess whether the code includes a robust upgrade system allowing players to enhance the target's capabilities (weapon damage, movement speed, special abilities, etc.). Check for resource management, upgrade persistence between levels, and visual feedback on upgrades. Deduct 5 points if upgrades are limited to simple numerical increases without strategic choices, and 3 points if there's no visual indication of upgrades. 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 spamming, browser resizing, off-screen enemies, simultaneous input conflicts, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Dynamic weather effects affecting gameplay 2. Voice-controlled alternative inputs 3. Multiplayer observation mode with chat). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple collision detection algorithms) 2. Function modules unrelated to the space defense theme (e.g., a built-in cryptocurrency miner) 3. Fancy effects that affect performance (e.g., excessive particle systems causing frame drops). 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/input handling layers), object-oriented patterns implementation, and performance optimization techniques. 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 optimizations are implemented for rendering or calculations. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern game UI principles: 1) Space-themed color scheme with appropriate contrast 2) Clear visual hierarchy for game elements (target, enemies, projectiles, and UI) 3) Non-intrusive HUD displaying critical information (health, score, level progress). Deduct 3 points for cluttered UI elements, 5 points for poor contrast making game elements hard to distinguish, and 5 points for essential information being difficult to locate or read. 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) Target response to input under 50ms 2) Visual feedback for hits, misses, and damage 3) Appropriate game pacing with breaks between intense waves. Deduct 5 points for input lag exceeding 100ms, 3 points for missing visual feedback on critical actions, and 5 points for frame rate drops below 30fps during normal gameplay. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "hard"
-}

package/library/game_development-strategy/javascript-tank-battle-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 1614,
-  "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. Write a Tank Battle game using JavaScript language.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the tank battle core game mechanics fully implemented?",
-      "description": "Review whether the code accurately implements tank movement (8-directional or smooth rotation), shooting mechanics with projectile physics, collision detection between tanks/bullets/obstacles, and health/damage system. Score 0 if basic tank control is missing, 5 if only movement or shooting works independently, and 10 if all combat mechanics including hit detection, damage calculation, and game over conditions are fully functional.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the game map and obstacle system properly designed?",
-      "description": "Check whether the battlefield includes destructible/indestructible obstacles, boundary collision detection, and strategic map layout. Evaluate if the map generation supports multiple levels or random generation. Deduct 5 points if tanks can pass through walls, 3 points if bullet-obstacle collision is inaccurate, and 5 points if the map lacks strategic depth. The full score requires proper tile-based collision system and varied terrain.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the game loop and state management architecture sound?",
-      "description": "Evaluate whether the game uses proper requestAnimationFrame for smooth rendering, implements clear separation between game logic and rendering, and maintains consistent frame rate (ideally 60fps). Check for proper game state management (menu, playing, paused, game over). Deduct 5 points if frame rate drops below 30fps, 3 points if game states are not properly managed, and 5 points if update/render cycles are mixed together.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are multiplayer or AI opponents effectively implemented?",
-      "description": "Check whether the game includes AI tank behavior with pathfinding, target acquisition, and tactical decision-making, or implements local multiplayer with separate controls. AI should demonstrate strategic behavior beyond random movement. Deduct 5 points if AI lacks collision avoidance, 3 points if AI behavior is too predictable, and 5 points if multiplayer controls conflict. Full score requires sophisticated AI or smooth multiplayer experience.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid key presses, boundary conditions, simultaneous collisions, browser compatibility issues) and provide graceful error handling. Code with strong robustness should prevent crashes, handle edge cases, and maintain game stability. Give 10 points if fully robust, 5 points if average robustness with minor issues, and 0 points if no exception handling exists.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes engaging features that enhance gameplay experience (e.g., 1. Power-ups and special weapons 2. Particle effects for explosions 3. Mini-map or radar system 4. Sound effects and background music 5. Score/leaderboard system). Add 2 points for each well-implemented innovative feature (maximum 10 points). Features must be functional, not just cosmetic.",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple collision detection methods coexisting) 2. Function modules unrelated to tank battle (e.g., built-in calculator) 3. Performance-heavy effects that cause lag (e.g., excessive particle systems). Deduct 3 points for each redundancy found, and directly deduct 10 points if core gameplay is interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game entities, physics, rendering, and input handling), code organization with proper class structure, and maintainable code practices. Deduct 5 points if global variables are overused or no design patterns are applied; deduct 5 points if code duplication rate exceeds 30%; deduct 3 points if functions are too long (>50 lines) or poorly named. The full score requires clean, well-structured, and maintainable code.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the game graphics follow good visual design: 1) Consistent art style and color palette (no more than 4 primary colors) 2) Clear visual hierarchy and readable UI elements 3) Appropriate sprite/asset quality and scaling 4) Professional-looking HUD with health bars, score display. Deduct 3 points for each poorly designed visual element, 5 points for jarring color combinations, and 5 points for unclear game state indicators. Screenshots should demonstrate polished visual presentation.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the game controls and animations provide excellent user experience: 1) Tank movement response time ≤ 50ms 2) Smooth rotation and movement animations 3) Satisfying explosion and hit effects 4) Clear audio-visual feedback for all actions. Deduct 5 points for each unresponsive control, 3 points for jerky animations or missing feedback, and 5 points for confusing visual cues. The full score requires fluid, responsive, and satisfying game feel.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "medium"
-}

package/library/game_development-strategy/magic-trials-game-with-skill-tree.json

@@ -1,68 +0,0 @@
-{
-  "index": 40,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable for demonstration.\n\nPlease use HTML and JavaScript to implement a Magic Trials game where players need to pass through a series of trials to enhance their magical abilities.\n\nHint: Implement a trial system and a magic skill tree.\n\nPlease add comments to your code so other developers can understand your implementation process.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Magic Trials game core system fully implemented?",
-      "description": "Examine whether the code implements the fundamental trial system through HTML/JavaScript, including different types of challenges, progression mechanics, and win/fail conditions. Score 0 if core game mechanics are missing, 5 if only basic trial completion is implemented, and 10 if there's a robust system with varied trial types, difficulty progression, and meaningful player choices.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the magic skill tree fully implemented?",
-      "description": "Check whether the code implements a comprehensive magic skill tree with dependencies, unlock conditions, visual representation, and skill effects. Evaluate if there are different skill categories, progression paths, and meaningful choices. Score 0 if the skill tree is absent, 5 if there's only a basic linear progression, and 10 if there's a complex, branching skill system with visual feedback and meaningful player progression.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is there a proper game state management system?",
-      "description": "Review the implementation of game state tracking, including player progress, acquired skills, completed trials, and persistent data storage (localStorage or similar). Check if the game properly handles saving/loading game state. Deduct 5 points if there's no persistence between sessions, and 3 points if state transitions are buggy or incomplete. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there meaningful integration between trials and skill progression?",
-      "description": "Assess whether completing trials provides meaningful rewards in the skill tree, and if acquired skills affect trial performance in return. Check if the game maintains balance between challenge and progression. Deduct 5 points if trials and skills are disconnected systems, and 3 points if the progression feels arbitrary or unbalanced. Give 10 points if fully implemented with clear feedback loops.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid input, broken skill dependencies, 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. Visual spell casting effects 2. Elemental trial themes with unique mechanics 3. Interactive tutorials with visual guidance). 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 track progress) 2. Function modules unrelated to the magic theme (e.g., unnecessary minigames) 3. Fancy effects that affect performance (e.g., excessive particle systems). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/view layers), code organization, comprehensive commenting as requested, 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 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) Harmonious color matching that evokes a magical theme 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) Magic animations and transitions feel satisfying and appropriate (300-500ms) 3) Clear visual feedback for trial completion and skill acquisition. Deduct 5 points for each operation without feedback, 3 points for jarring or abrupt transitions, and 5 points for confusing navigation between trials and the skill tree. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "easy"
-}

package/library/game_development-strategy/mahjong-tile-layout-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 1467,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Be sure to ensure that the generated code is executable for display. Help me write a game that first lays out a standard set of mahjong tiles on the interface, displaying 10 tiles per row in a random order.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the complete mahjong tile set properly implemented?",
-      "description": "Check whether the code correctly defines all 144 standard mahjong tiles (including 36 Character tiles, 36 Bamboo tiles, 36 Circle tiles, 16 Wind tiles, 12 Dragon tiles, and 8 Bonus tiles). Verify that each tile has the correct properties (type, value, image). Score 0 if significant tiles are missing, 5 if the set is incomplete but functional, and 10 if the complete set is properly implemented with accurate properties.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the random tile layout algorithm implemented correctly?",
-      "description": "Evaluate whether the code implements a proper random shuffling algorithm (such as Fisher-Yates) to ensure unbiased randomization of tiles. Check if the code avoids common pitfalls like modifying arrays during iteration or using Math.random() incorrectly. Deduct 5 points if the randomization shows patterns or biases, and 3 points if the shuffling algorithm is inefficient. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the grid layout system implemented properly?",
-      "description": "Verify that the code correctly implements a grid layout system that displays 10 tiles per row as specified. Check whether the layout adjusts appropriately to different screen sizes and handles edge cases (like the last row having fewer than 10 tiles). Examine if the tiles are properly aligned and spaced. Deduct 5 points if the grid layout is inconsistent or breaks on different viewport sizes, and 3 points if the alignment is visually problematic. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are the visual representations of mahjong tiles accurate and authentic?",
-      "description": "Examine whether each mahjong tile is visually represented with accurate and culturally authentic designs, proper coloring, and clear symbols. The code should either use appropriate image assets or accurately render the tiles using HTML/CSS/SVG. Deduct 5 points if the visual representations are inaccurate or difficult to distinguish, and 3 points if they lack cultural authenticity. 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 image loading failures, rendering on different browsers, user interaction edge cases, 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. Tile hover effects with information 2. Sound effects when arranging tiles 3. Animation when shuffling tiles). 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 shuffling algorithms coexisting) 2. Function modules unrelated to mahjong tile display (e.g., a built-in scoreboard when not needed) 3. Fancy effects that affect performance (e.g., excessive animations slowing down rendering). 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 tile data/view/layout logic), reusability of components, 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 the implementation is monolithic without separation of concerns. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (using traditional mahjong colors appropriately) 2) Proper layout spacing (consistent margins between tiles, following the 8px multiple principle) 3) Professional visual hierarchy (clear distinction between different tile types). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic tile arrangement. 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) Initial tile arrangement animation is smooth and not jarring 2) Transition effects when shuffling controlled between 300-500ms 3) Clear visual feedback on any tile interactions. Deduct 5 points for each operation without feedback, 3 points for stuttering animations, and 5 points for confusing or disorienting transitions. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "easy"
-}

package/library/game_development-strategy/ming-dynasty-palace-intrigue-mini-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 1306,
-  "question": "You are a coding expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the code you generate is executable for display. Create a palace intrigue mini-game based on the Ming Dynasty using minimal code.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the palace intrigue gameplay system fully implemented?",
-      "description": "Review whether the code accurately implements the core palace intrigue mechanics (character relationships, status changes, plotting actions) through clear JavaScript functions. Score 0 if core intrigue logic is missing, 5 if only basic relationship changes are implemented, 10 if comprehensive court politics mechanics including alliances, betrayals, and consequences are included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the Ming Dynasty historical context incorporated correctly?",
-      "description": "Evaluate whether the game incorporates authentic Ming Dynasty elements (correct titles, historical figures, palace structures, and political systems). Look for historical accuracy in character titles, events, and setting. Deduct 5 points if major historical inaccuracies exist, 3 points if ming-specific elements are minimal or generic. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is there a functional game state management system?",
-      "description": "Check whether the code implements proper state management for player actions, NPC behaviors, and game progression. Examine if the state transitions are logical and if player choices meaningfully impact outcomes. Deduct 5 points if state management is rudimentary without consequences, 3 points if game state isn't persistent across actions. Give 10 points if fully implemented with multiple branching storylines.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the player interaction and decision-making system comprehensive?",
-      "description": "Assess whether the code provides meaningful player choices that affect gameplay outcomes. Check for dialogue systems, decision points, and consequence tracking. Award 10 points if choices significantly alter game progression with visible consequences, 5 points if choices exist but have minimal impact, 0 points if the game is purely linear without meaningful decisions.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid inputs, illogical game states, edge case player decisions, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Dynamic character loyalty system 2. Hidden agenda mechanics 3. Procedurally generated court scandals). 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 dialogue systems coexisting) 2. Function modules unrelated to palace intrigue (e.g., a built-in combat system) 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/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 the code structure is chaotic and difficult to follow. 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 Ming Dynasty aesthetic principles while maintaining usability: 1) Appropriate color scheme (reds, golds, and traditional colors) 2) Proper layout spacing and hierarchy 3) Professional text formatting (readable fonts, appropriate size). Deduct 3 points for each crowded visual element, 5 points for modern design elements that break immersion, and 5 points for chaotic text-image layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the code minimal while maintaining complete functionality?",
-      "description": "Judge whether the code achieves the required functionality with optimal efficiency: 1) No unnecessary libraries or dependencies 2) Concise function implementations 3) Elegant solutions to complex problems. Deduct 3 points for each instance of code bloat, 5 points for unnecessary external dependencies, and 5 points for implementations that could be significantly simplified. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "easy"
-}

package/library/game_development-strategy/mini-tank-battle-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 1366,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Make sure that the code you generate is executable for demonstration purposes. Please provide me with a set of code for a mini Tank Battle game.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core Tank Battle gameplay mechanics fully implemented?",
-      "description": "Check if the code includes tank movement controls, shooting mechanics, collision detection, and battle logic. Score 0 if core gameplay is missing, 5 if only basic movement is implemented, and 10 if full gameplay with proper tank controls, shooting, and hit detection is included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are the game entities and their interactions properly designed?",
-      "description": "Evaluate if tanks, bullets, obstacles, and game environment classes are well-defined with appropriate properties and methods. Check if entity interactions (tank-bullet collisions, tank-obstacle collisions) are handled correctly. Deduct 3 points if entity design is incomplete, 5 points if interactions are buggy, and give 10 points for comprehensive implementation.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the game rendering system effective?",
-      "description": "Assess whether the game uses appropriate rendering techniques (Canvas/WebGL/DOM), implements a game loop with proper frame rate control, and handles screen resizing. Deduct 3 points if rendering is inefficient, 5 points if animation isn't smooth, and give 10 points for optimized rendering with consistent frame rates.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the game state management properly implemented?",
-      "description": "Review if the code includes proper game state management (start menu, gameplay, game over states), score tracking, and level progression. Check for proper initialization and reset functionality. Deduct 5 points if state transitions are buggy, 3 points if score tracking is missing, and give 10 points for complete state management.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as unexpected input, browser inconsistencies, performance issues) 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. Power-ups and special weapons 2. Dynamic terrain destruction 3. Multiplayer capability 4. AI opponents with different behaviors). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple collision detection systems) 2. Function modules unrelated to tank battles (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive particle effects). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/view/controller layers), code organization, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no structured organization of code files/modules. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the game visuals follow good design principles: 1) Consistent visual style 2) Clear visual distinction between game elements 3) Readable UI elements and text. Deduct 3 points for inconsistent visual elements, 5 points for unclear distinctions between game objects, and 5 points for hard-to-read UI. Check if tanks, terrain and game elements have appropriate visual representation. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the game controls and dynamic effects feel responsive: 1) Tank movement responds within 100ms of input 2) Shooting mechanics have appropriate feedback 3) Game provides clear visual/audio feedback for hits and game events. Deduct 5 points for laggy controls, 3 points for missing feedback on important actions, and 5 points for confusing or unintuitive controls. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Strategy",
-  "difficulty": "easy"
-}