@getollie/cli 0.0.4 → 0.2.0

package/library/game_development-puzzle/sokoban-box-pushing-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 1748,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Make sure the code you generate is executable and displayable. Please write a suggested Sokoban (box-pushing) game that I can run in my browser.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Sokoban game core mechanics fully implemented?",
-      "description": "Review whether the code accurately implements the core Sokoban mechanics including player movement, box pushing, collision detection with walls, and win condition verification. Score 0 if the basic push mechanics are missing, 5 if only basic movement is implemented without proper collision detection, and 10 if all game rules are fully included with proper win state detection.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are level design and progression implemented?",
-      "description": "Check whether the code includes a level system with multiple puzzles of increasing difficulty. Evaluate if levels are properly stored/loaded and if there's a progression system that tracks completed levels. Deduct 3 points if only a single level exists, 5 points if level progression is missing, and 2 points if difficulty scaling is poorly implemented. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the game state management properly implemented?",
-      "description": "Evaluate whether the game implements proper state management including undo functionality, level restart, game saving/loading, and move counting. Deduct 3 points if undo functionality is missing, 3 points if there's no way to restart a level, and 4 points if game progress cannot be saved/loaded. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the game responsive and browser-compatible?",
-      "description": "Check whether the game renders properly across different screen sizes and browsers. Verify if the game adapts to different viewport dimensions, has touchscreen support for mobile play, and maintains aspect ratio without breaking the layout. Deduct 3 points for each major browser incompatibility, 5 points if the game is unplayable on mobile, and 2 points if the UI breaks on window resize. 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 refresh, window resizing, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Custom level editor 2. Move optimization suggestions 3. Time-based challenges 4. Animation effects for pushing). 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 restart a level) 2. Function modules unrelated to Sokoban (e.g., unnecessary minigames within the main game) 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/input handling), code organization, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no clear separation between game logic and rendering. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (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) Movement response delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual feedback for valid/invalid moves. Deduct 5 points for each operation without feedback, 3 points for sluggish animations, and 5 points for confusing game state indicators. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "medium"
-}

package/library/game_development-puzzle/sokoban-game-implementation.json

@@ -1,68 +0,0 @@
-{
-  "index": 880,
-  "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 perfectly functioning Sokoban game.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Sokoban game core mechanics fully implemented?",
-      "description": "Check whether the code implements all core game mechanics: player movement (up/down/left/right), box pushing, collision detection with walls, valid win condition checking. Score 0 if movement isn't implemented, 5 if only basic movement works without proper collision handling, and 10 if all core mechanics function perfectly including undoing moves.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are the level design and loading mechanisms properly implemented?",
-      "description": "Evaluate whether the game includes a level system with multiple puzzles, level loading mechanism, and proper level representation (using arrays or matrices). Check if the game correctly renders different elements (walls, boxes, goals, player). Deduct 3 points if only one hardcoded level exists, 5 points if level design is flawed (e.g., unsolvable puzzles), and 3 points if there's no level completion tracking.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the game state management well-designed?",
-      "description": "Check if the code properly manages game states including player position, box positions, goal positions, move history for undo functionality, and level completion detection. Deduct 5 points if there's no move history tracking, 3 points if the win condition check is faulty, and 5 points if state reset between levels is buggy.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Does the game include essential quality-of-life features?",
-      "description": "Evaluate if the implementation includes: move counter, undo functionality, level reset, level selection, and game completion tracking. Deduct 2 points for each missing feature. Check if the game saves progress between sessions (local storage); deduct 3 points if missing.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid moves, edge cases in level design, browser resize events) 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 optimization suggestions 2. Automatic puzzle solver 3. Custom level editor 4. Score/time tracking system). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple movement handling logics coexisting) 2. Function modules unrelated to Sokoban (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive animations slowing 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/input handling 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 3 points if variable/function naming is unclear or inconsistent. 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 design principles: 1) Clear visual distinction between game elements (walls, boxes, goals, player) 2) Proper layout and proportions (grid cells properly sized and aligned) 3) Professional visual feedback for interactions (movement, successful/unsuccessful pushes). Deduct 3 points for unclear visual distinctions, 5 points for inconsistent or cluttered layout, and 5 points for lack of visual feedback. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and responsive?",
-      "description": "Judge whether the game controls and animations conform to human perception characteristics: 1) Input response delay ≤ 100ms 2) Smooth movement animations (if implemented) 3) Clear visual and audio feedback for actions. Deduct 5 points for laggy movement, 3 points for jarring transitions between actions, and 5 points for confusing or missing feedback when attempting invalid moves. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "medium"
-}

package/library/game_development-puzzle/sokoban-nezha-puzzle-game-10-levels.json

@@ -1,68 +0,0 @@
-{
-  "index": 908,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Be sure to provide executable code in your demonstration. I would like to create a computer version of the Sokoban puzzle game with 10 levels, ranging from easy to difficult. The main character should be a pixel art version of Nezha. Please generate the code for me.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Sokoban game core mechanics fully implemented?",
-      "description": "Review whether the code accurately implements the core Sokoban mechanics including character movement, box pushing rules, collision detection with walls, and goal completion logic. Score 0 if the core mechanics are missing, 5 if basic movement and pushing are implemented but with flaws, and 10 if the complete Sokoban ruleset is properly implemented with accurate collision detection.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are all 10 levels implemented with appropriate difficulty progression?",
-      "description": "Verify that exactly 10 levels are implemented with a clear progression from easy to difficult. Each level should be solvable and properly tested. Deduct 2 points if fewer than 10 levels are provided, 5 points if difficulty progression is inconsistent or poorly balanced, and 3 points if any level is unsolvable. Check for level data structure organization and whether levels load correctly.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the Nezha pixel art character properly implemented?",
-      "description": "Evaluate the quality of the Nezha pixel art character implementation. The character should be recognizable as Nezha with distinct features (like the Fire-Tipped Spear, Universe Ring, or Wind Fire Wheels), have proper animations for different movements (up, down, left, right), and maintain pixel art aesthetic quality. Deduct 5 points if the character doesn't resemble Nezha, 3 points if animations are missing or poor, and 2 points if the pixel art style is inconsistent.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are the game state management and undo functionality properly implemented?",
-      "description": "Check whether the code includes proper game state management for tracking box positions, player position, and move history. An undo function should be available to revert previous moves. Deduct 5 points if there's no undo functionality, 3 points if state management is flawed or allows impossible states, and 2 points if the undo function has limitations (like limited steps). The full score requires a robust state management system.",
-      "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, window resizing, 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. Level editor 2. Move counter and optimal solution hints 3. Special animations for level completion 4. Sound effects for movement and completion). 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 movement control systems) 2. Function modules unrelated to Sokoban gameplay 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 layers), code organization, reusability, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the code lacks comments or documentation. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows good pixel art game design principles: 1) Consistent pixel art style throughout (character, boxes, walls, goals) 2) Clear visual distinction between game elements 3) Proper UI for level selection, game controls, and feedback. Deduct 3 points for inconsistent art style, 5 points for unclear visual elements that affect gameplay, and 5 points for poor UI layout or information display. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the game responsive and provides good user experience?",
-      "description": "Judge whether the game provides good usability and interaction design: 1) Responsive controls with minimal input lag 2) Clear visual feedback for valid/invalid moves 3) Proper level restart and navigation options 4) Game progress saving functionality. Deduct 3 points for control lag or unresponsiveness, 3 points for lack of visual feedback, 2 points for missing restart option, and 2 points for no save functionality. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "hard"
-}

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

@@ -1,68 +0,0 @@
-{
-  "index": 860,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the code you generate is executable for demonstration. Help me write a code for Spider Solitaire that can be directly saved in a document and be ready to run.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Spider Solitaire game mechanics fully implemented?",
-      "description": "Review whether the code accurately implements the standard Spider Solitaire rules with card stacking sequences (King to Ace), moving complete sequences, and the ability to deal new cards when all columns have at least one card. Score 0 if core game mechanics are missing, 5 if basic card movement is implemented but with rule errors, and 10 if all standard rules are correctly implemented including different difficulty levels (1, 2, or 4 suits).",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the card deal and deck management properly implemented?",
-      "description": "Check if the game correctly initializes with 10 columns of cards (with appropriate face-up/face-down distribution), handles the stock pile (5 additional deals of 10 cards each), and maintains proper game state between deals. Verify that cards can only be dealt when all columns have at least one card. Deduct 3 points if the initial deal is incorrect, 4 points if the stock pile management has errors, and 5 points if card dealing conditions aren't properly checked. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the card sequence completion and removal logic correct?",
-      "description": "Evaluate whether the code correctly identifies and handles completed sequences (King to Ace of the same suit) and automatically removes them from the tableau to the foundation. Check for proper validation of sequence completeness before removal and appropriate visual feedback. Deduct 5 points if completed sequences aren't detected properly, 3 points if removal animation is missing, and 5 points if the foundation display is not implemented. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the move validation and undo functionality implemented?",
-      "description": "Check if the game validates all card moves according to Spider Solitaire rules (cards can only be placed on cards of next-higher rank regardless of suit, only sequences of same suit can be moved as a unit). Verify that an undo system tracks all moves and allows reversing actions. Deduct 5 points if move validation has errors, 3 points if undo functionality is limited or buggy, and 5 points if the game allows illegal moves. 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 user clicks, attempting illegal moves, edge cases in game state) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should 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. Auto-complete functionality when game is solvable 2. Hint system that suggests possible moves 3. Statistics tracking for wins/losses/time 4. Different card themes/backgrounds). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple card movement logics) 2. Function modules unrelated to Spider Solitaire (e.g., embedded mini-games) 3. Fancy effects that affect performance (e.g., excessive animations that slow down gameplay). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/view/controller layers), code organization, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the code lacks comments or documentation. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the game's visual design follows modern design principles: 1) Card design clarity and readability 2) Proper layout spacing between columns and cards 3) Professional color scheme with good contrast. Deduct 3 points for cluttered visuals, 5 points for poor card visibility or distinguishability, and 5 points for chaotic tableau layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the card interactions conform to user expectations: 1) Responsive drag-and-drop implementation 2) Clear visual feedback for valid/invalid moves 3) Smooth card dealing and sequence completion animations. Deduct 5 points for laggy card movement, 3 points for missing visual feedback during interactions, and 5 points for confusing or unintuitive controls. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "hard"
-}

package/library/game_development-puzzle/sudoku-game-implementation.json

@@ -1,68 +0,0 @@
-{
-  "index": 1094,
-  "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 demonstration. Help me write a Sudoku game.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Sudoku game's core logic fully implemented?",
-      "description": "Review whether the code accurately implements the Sudoku board generation algorithm with unique solutions, validation of user inputs against Sudoku rules (no repeats in rows, columns, and 3x3 sub-grids), and puzzle difficulty levels. Score 0 if the core game logic is missing, 5 if only basic validation is implemented, and 10 if complete with puzzle generation, validation, and difficulty selection.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the Sudoku puzzle generation algorithm effective?",
-      "description": "Evaluate if the code includes a robust algorithm for generating valid Sudoku puzzles with unique solutions. Check for backtracking or other efficient techniques, proper removal of digits to create puzzles of varying difficulties, and verification that puzzles remain solvable. Deduct 5 points if puzzles have multiple solutions, 3 points if generation is inefficient (>500ms), and 5 points if difficulty levels aren't properly calibrated. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are the user interaction features comprehensive?",
-      "description": "Check if the implementation includes essential Sudoku gameplay features: number input methods (keyboard/mouse), cell selection highlighting, candidate notation (pencil marks), mistake highlighting, undo/redo functionality, and timer. Deduct 2 points for each missing feature. Award full 10 points only if all these interaction elements are present and functioning correctly.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there a hint/solving system implemented?",
-      "description": "Assess whether the game provides player assistance features like hints for the next move, checking current progress, or auto-solving capabilities. Examine if the solver uses efficient algorithms (e.g., constraint propagation, backtracking). Deduct 5 points if hints are random rather than strategic, 3 points if solving is brute-force only, and 2 points if visualization of the solving process is 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 invalid inputs, conflicting entries, unsolvable puzzles) 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 solving techniques highlighting 2. Statistics tracking and performance analytics 3. Interactive tutorial mode 4. Multiple visually distinct themes). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple validation methods doing the same thing) 2. Function modules unrelated to Sudoku (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive animations during number entry). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/view/controller layers), unit test coverage, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching with clear distinction between givens and user inputs 2) Proper layout spacing with well-defined grid lines and sub-grid boundaries 3) Professional font system with legible numbers and appropriate size contrast between candidates and confirmed digits. Deduct 3 points for each crowded visual element, 5 points for poor number legibility, and 5 points for insufficient visual distinction between interactive elements. 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 feedback on number entry ≤ 100ms 2) Smooth transitions when highlighting rows/columns/boxes 3) Clear visual indication of conflicts and errors. Deduct 5 points for each operation without feedback, 3 points for laggy transitions between game states, and 5 points for confusing selection highlighting. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "medium"
-}

package/library/game_development-puzzle/tangram-puzzle-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 541,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Ensure that the generated code is executable and functional.\n\n## Role ##\nYou are an experienced code expert. You are provided with a software development requirement description and asked to generate project code based on these requirements. Strictly follow the rules to help users generate complete project code that is fully commented with simple, easy-to-understand language, without outputting anything else.\n\n## Output Rules ##\n1. Always generate complete, runnable project code, ensuring the project is fully executable\n2. Ensure that all code files you output are complete, without omitting any code\n3. Carefully review and check all code before final output, evaluating its executability. If the code cannot be executed or contains errors, it needs to be regenerated\n4. If the requirements involve external API access or user data (images, videos, audio, etc.), please provide simulated data\n\n## Project Requirements Description ##\nPlease develop a 'Tangram' puzzle game. The game interface is divided into two parts: an area displaying the target shape, and an area where players can manipulate the tangram pieces. The tangram consists of 7 geometric shapes (2 large triangles, 1 medium triangle, 2 small triangles, 1 square, and 1 parallelogram). Players can move each shape by dragging, rotate a shape by clicking on it, and flip a shape by double-clicking it. The goal of the game is to use these 7 shapes to create the target shape. The game should provide multiple target shapes of varying difficulty to choose from, a reset button to restore all shapes to their initial positions, and a hint feature (briefly showing the correct position of one shape). When the player successfully completes the target shape, display a congratulatory message and the time taken.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the tangram puzzle game fully implemented with all 7 geometric shapes?",
-      "description": "Check if the code correctly implements all 7 tangram pieces (2 large triangles, 1 medium triangle, 2 small triangles, 1 square, and 1 parallelogram) with appropriate visual representation. Each shape should have distinct characteristics and proper proportional sizes. Verify that the shapes can be properly rendered on the canvas/display area without visual artifacts. Score 0 if pieces are missing or incorrectly implemented, 5 if basic shapes are implemented but with proportion/rendering issues, and 10 if all shapes are perfectly implemented with proper scaling.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are all the required manipulation functionalities implemented correctly?",
-      "description": "Evaluate if the code implements all required piece manipulation: dragging (move), clicking (rotate), and double-clicking (flip). Check if event handlers are properly set up for each interaction type and if the geometric transformations are mathematically correct. Test edge cases like rapid consecutive clicks or interactions with partially off-screen pieces. Deduct 3 points if any manipulation feature is missing, 3 points if transformations have mathematical errors, and 2 points if edge cases cause visual glitches. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the target shape system implemented with multiple difficulty levels?",
-      "description": "Check if the code includes a variety of target shapes with different difficulty levels. Verify that target shapes are properly displayed and that the system can accurately determine when a player's arrangement matches the target (accounting for reasonable tolerance). Deduct 5 points if fewer than 5 different target shapes are available, 3 points if difficulty progression is not clear, and 5 points if the shape matching algorithm is inaccurate. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are the game's supporting features (reset, hints, completion detection) implemented?",
-      "description": "Evaluate if the code includes a reset function to restore pieces to initial positions, a hint feature that temporarily shows the correct position of one piece, and accurate completion detection with a congratulatory message and time tracking. Deduct 3 points if reset doesn't properly restore all pieces, 3 points if the hint system is ineffective, and 4 points if completion detection is unreliable or time tracking is inaccurate. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common edge cases (such as rapid interactions, browser resizing, touch vs. mouse input, etc.) and provide graceful degradation. Code should handle piece overlap conflicts, boundary conditions, and prevent pieces from becoming unusable (e.g., moved off-screen). Deduct 3 points for each unhandled edge case and 5 points if the game becomes unplayable due to common user interactions. The full score is 10 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. Animation effects when completing a shape 2. Custom tangram piece themes/colors 3. Progressive hint system that becomes less revealing with each use 4. Puzzle creation mode for users to design their own challenges). 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 reset the game) 2. Function modules unrelated to the tangram puzzle (e.g., a built-in calculator) 3. Fancy effects that affect performance (e.g., excessive particle 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/input handling), code organization, and maintainability. Check if the game uses appropriate data structures for piece management and transformation operations. Deduct 3 points if global state is overused, 3 points if the code duplication rate is high, 2 points if there's poor separation of concerns, and 2 points if variable/function naming is unclear. 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) Clear visual distinction between the target area and manipulation area 2) Harmonious color scheme with good contrast between pieces 3) Professional layout with proper spacing between UI elements 4) Responsive design that works on different screen sizes. Deduct 3 points for cluttered interface elements, 3 points for poor color contrast making pieces hard to differentiate, and 4 points for non-responsive layouts that break on different devices. 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 feels natural and responsive (≤ 100ms lag) 2) Rotation and flipping animations enhance understanding of the transformation 3) Clear visual feedback when pieces are selected or when a puzzle is completed. Deduct 4 points for laggy piece movement, 3 points for abrupt transitions during rotations/flips, and 3 points for lack of visual feedback during interactions. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "hard"
-}

package/library/game_development-puzzle/tetris-game-html-display.json

@@ -1,68 +0,0 @@
-{
-  "index": 749,
-  "question": "You are a coding expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code for display whenever possible. Help me create a beautiful Tetris game with HTML display.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core Tetris gameplay mechanic fully implemented?",
-      "description": "Review whether the code accurately implements the standard Tetris game mechanics including piece rotation, movement, hard/soft drop, line clearing, scoring system, and level progression. Score 0 if core gameplay is missing, 5 if basic movement is implemented but lacks features like wall kicks or proper collision detection, and 10 if all standard Tetris mechanics are properly implemented according to modern Tetris guidelines.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are all seven standard Tetriminos (I, O, T, S, Z, J, L) properly implemented?",
-      "description": "Check if all seven standard Tetriminos are correctly implemented with proper colors, shapes, and rotation systems. The code should use the SRS (Super Rotation System) or a similar modern rotation system. Deduct 1 point for each incorrectly implemented piece shape, 2 points for incorrect rotation behavior, and 5 points if the randomizer doesn't follow the 7-bag system or another fair distribution method. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is there a complete game state management system?",
-      "description": "Evaluate whether the code includes proper game state management with start/pause/resume/game over states, level progression, score tracking, and next piece preview. Deduct 3 points if there's no pause functionality, 3 points if level progression is missing, 2 points if there's no next piece preview, and 2 points if high score persistence is not implemented. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there a responsive control system with keyboard support?",
-      "description": "Check if the game implements smooth, responsive controls with support for standard keyboard inputs (arrow keys, spacebar, etc.) and possibly touch controls for mobile. Deduct 3 points if keyboard controls are laggy or unresponsive, 3 points if there's no key repeat for horizontal movement, 2 points if hard drop is missing, and 2 points if there's no support for holding a piece. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common edge cases (such as rapid inputs, boundary conditions, browser resize events) and provide appropriate error handling. Code with strong robustness should handle frame rate independence, input buffering, and browser compatibility issues. Give 10 points if the code handles all these scenarios well, 5 points if it's average, and 0 points if critical robustness issues are present.",
-      "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. Ghost piece showing landing position 2. Hold piece functionality 3. Particle effects for line clears 4. Custom themes/skins 5. Sound effects and music with mute option). Add 2 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 Tetris gameplay (e.g., unnecessary animations) 3. Fancy effects that affect performance (e.g., excessive particle systems that cause lag). 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), code organization, and performance optimization. Deduct 3 points if global state is overused, 3 points if the code has poor separation of concerns, 2 points if there's significant code duplication, and 2 points if rendering performance is poor (< 30 FPS). The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the visual design follows modern principles: 1) Clean and consistent color scheme that enhances gameplay 2) Well-designed game board with clear grid lines and block visibility 3) Readable UI for score, level, and next piece display 4) Proper responsive layout for different screen sizes. Deduct 2 points for each visual inconsistency, 3 points for poor readability, 3 points for non-responsive design, and 2 points for cluttered interface. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the game's animations and interactions feel satisfying and responsive: 1) Pieces move fluidly with appropriate speed 2) Line clear animations are visually satisfying 3) Game over sequence provides clear feedback 4) Transitions between game states are smooth. Deduct 3 points for jerky animations, 3 points for missing visual feedback on important actions, 2 points for inconsistent game speed, and 2 points for abrupt transitions. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "hard"
-}

package/library/game_development-puzzle/tetris-game-implementation.json

@@ -1,68 +0,0 @@
-{
-  "index": 942,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Take care to ensure that the code you generate is executable and can be demonstrated. Help me write a Tetris game using HTML.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core Tetris game mechanics fully implemented?",
-      "description": "Review whether the code accurately implements the standard Tetris mechanics including piece rotation, movement, collision detection, line clearing, and scoring. Score 0 if the core mechanics are missing, 5 if only basic movement is implemented, and 10 if all standard Tetris rules (including wall kicks, hard/soft drops, and piece holding) are fully included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the game board and tetromino rendering correctly implemented?",
-      "description": "Check whether the game renders the 10×20 standard Tetris board correctly, displays all seven tetromino shapes with proper colors, shows upcoming pieces, and maintains visual clarity. Deduct 3 points if the board dimensions are non-standard, 3 points if tetrominoes aren't visually distinguishable, and 5 points if the grid alignment is inconsistent. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the keyboard control system responsive and intuitive?",
-      "description": "Evaluate whether the game handles keyboard inputs appropriately (arrow keys for movement/rotation, space for hard drop, etc.), includes key repeat for continuous movement, and prevents input lag. Deduct 5 points if standard Tetris controls are missing, 3 points if there's noticeable input lag, and 2 points if there's no key repeat for continuous sideways movement. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are game state management and level progression implemented?",
-      "description": "Check whether the code includes proper game state management (start, pause, game over), level progression based on lines cleared or score, and increasing difficulty (speed). Deduct 4 points if state transitions are missing, 3 points if level progression isn't implemented, and 3 points if difficulty doesn't increase with levels. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle edge cases (rapid inputs, browser resize, tab switching, etc.) and prevent game state corruption. Code with strong robustness should have appropriate event listeners cleanup, animation frame management, and handle browser-specific quirks. Give 10 points for comprehensive error handling, 5 points for average robustness, and 0 points if critical bugs occur during normal gameplay.",
-      "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. Ghost piece preview showing where pieces will land 2. Piece holding system 3. Combo scoring system 4. Animated line clears or special effects). 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 collision detection methods) 2. Function modules unrelated to Tetris gameplay (e.g., unnecessary animations) 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 (separating game logic from rendering), code maintainability, and performance optimization. Deduct 5 points if global variables are excessively used, 3 points if game loop isn't optimized (e.g., using setInterval instead of requestAnimationFrame), and 2 points if there's significant code duplication. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the UI follows classic Tetris design principles: 1) Clear block colors with appropriate contrast 2) Proper sizing and spacing of game elements 3) Clean layout with separate areas for score, next piece, and game board. Deduct 3 points for cluttered layouts, 4 points for poor color choices making pieces hard to distinguish, and 3 points for inconsistent visual styling. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the piece movements and animations feel responsive and smooth: 1) Pieces move without stuttering 2) Line clear animations are satisfying but quick 3) Game over and level-up transitions are clear but non-disruptive. Deduct 4 points for stuttering movement, 3 points for jarring animations, and 3 points for delayed response to user input. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "hard"
-}