@getollie/cli 0.0.5 → 0.2.0

package/library/game_development-puzzle/html-javascript-rubiks-cube-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 17,
-  "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 and displayable.\n\nPlease use HTML and JavaScript to implement a:\n\n### Gameplay\n1. **Choose Cube Level**: Players can select 2x2, 3x3, 4x4, or 5x5 Rubik's cubes.\n2. **Manipulate the Cube**: Rotate different layers of the cube using mouse controls.\n3. **Complete Restoration**: The goal is to unify the colors of all faces, with each face having a single color.\n\n### Game Features\n- **Highly Interactive**: Using Three.js technology, the game provides smooth 3D visual effects and a highly interactive user experience.\n- **Multiple Levels**: Offers different difficulty levels suitable for players of varying skill levels.\n- **Educational Value**: Exercises players' spatial imagination and logical thinking abilities.\n\n### Game Tips\n- **Learn Basic Formulas**: Understand and master some basic cube restoration formulas, such as top layer cross, corner block permutation, etc.\n- **Simple to Complex**: Beginners can start with lower-order cubes and gradually transition to higher-order cubes to progressively improve solving techniques.\n- **Practice Observation Skills**: When manipulating the cube, pay attention to color distribution and layer relationships to improve restoration efficiency.\n\n### Summary\n\"The Cube\" is not only a highly entertaining digital game but also an educational tool beneficial for mental development. It's suitable for players of all ages, whether cube enthusiasts or those seeking a challenge.\n\nPlease include comments in your code to help other developers understand your implementation process.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Rubik's Cube core structure properly implemented?",
-      "description": "Review whether the code accurately implements the Rubik's Cube data structure through Three.js, correctly representing the cube's internal state with appropriate face/cubelet relationships. Check if the code maintains proper geometry for each cube level (2x2, 3x3, 4x4, 5x5) with accurate mapping of colors to faces.Score 0 if the core structure is missing, 5 if only basic representation exists, 10 if all cube levels are properly implemented with correct internal state management.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the cube rotation mechanism fully functional?",
-      "description": "Evaluate whether the code properly handles layer rotation mechanics, including face turns, middle layer rotations, and whole cube rotation. Check for quaternion-based rotation calculations, proper animation transitions between states, and maintenance of cube integrity during rotations.Score 0 if rotation is not implemented, 5 points for basic single-face rotations, 10 points for complete implementation including complex rotation patterns and animation transitions.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are the different cube levels (2x2 to 5x5) properly implemented?",
-      "description": "Check if the code dynamically generates and handles different cube sizes from 2x2 to 5x5, with appropriate scaling, positioning, and rotation mechanics for each level. Verify that the complexity scales appropriately with cube size.Deduct 2.5 points for each missing or incomplete cube level. Give full 10 points only if all four cube levels function correctly with appropriate mechanics for each.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the solved-state detection mechanism implemented?",
-      "description": "Assess whether the code includes a system to detect when the cube is solved (all faces have uniform colors). Check for efficient algorithms that verify the solved state after each move without excessive performance impact.Score 0 if no detection exists, 5 points if basic detection is implemented with flaws, and 10 points for complete, efficient implementation with appropriate user feedback.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid mouse movements, browser resize events, performance limitations on different devices) and provide friendly error prompts or recovery mechanisms.Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Cube solving algorithms visualization 2. Move history with undo/redo 3. Pattern generation for practice 4. Timer and move counter statistics).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 rotation handling systems) 2. Function modules unrelated to the Rubik's cube (e.g., unnecessary game elements) 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 cube logic/rendering/interaction layers), code organization, and optimization techniques. Check for proper use of Three.js best practices and efficient rendering approaches.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 rendering optimization techniques are not implemented. 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 (beyond just the cube colors) 2) Proper layout spacing for UI controls 3) Professional font system for instructions and UI elements.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 3D interactions conform to human perception characteristics: 1) Cube rotation responsiveness ≤ 100ms 2) Smooth animation transitions between 300-500ms 3) Intuitive mouse/touch controls for cube manipulation.Deduct 5 points for each operation without feedback, 3 points for jerky animations during rotations, and 5 points for unintuitive or hard-to-discover interaction controls. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "hard"
-}

package/library/game_development-puzzle/html-javascript-sudoku-solver.json

@@ -1,68 +0,0 @@
-{
-  "index": 1762,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable. \n\nRow 1: 0, 0, 6, 0, 8, 0, 2, 4, 0\nRow 2: 5, 0, 2, 0, 0, 6, 0, 0, 0\nRow 3: 4, 0, 0, 0, 0, 0, 0, 3, 6\nRow 4: 0, 4, 0, 8, 0, 1, 0, 0, 0\nRow 5: 7, 0, 0, 0, 0, 0, 0, 0, 2\nRow 6: 0, 0, 0, 4, 0, 5, 0, 8, 0\nRow 7: 6, 1, 0, 0, 0, 0, 0, 0, 4\nRow 8: 0, 0, 0, 1, 0, 0, 5, 0, 8\nRow 9: 0, 5, 7, 0, 6, 0, 9, 0, 0\n\nThe number 0 represents blank spaces.\nPlease generate JavaScript code embedded in HTML to solve this Sudoku puzzle.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Sudoku solver algorithm correctly implemented?",
-      "description": "Evaluate whether the algorithm (backtracking, constraint propagation, etc.) correctly solves the given puzzle. Check if all Sudoku rules are enforced: each row, column, and 3x3 grid contains digits 1-9 without repetition. Award 0 points if the solver doesn't work, 5 points if it works but with inefficient algorithm (e.g., brute force without optimizations), and 10 points if it implements an efficient algorithm with proper constraint checking.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the initial Sudoku grid properly represented and displayed?",
-      "description": "Check if the provided initial Sudoku grid (with the specific numbers in the question) is correctly displayed in the UI. Verify that the grid structure maintains 9x9 format with clearly visible 3x3 subgrids. Award 0 points if the grid is incorrect, 5 points if partially implemented with visual issues, and 10 points for perfect representation with appropriate styling.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Does the solution provide visual feedback during the solving process?",
-      "description": "Assess whether the solution visualizes the solving process (e.g., step-by-step animation, highlighting cells being considered, showing backtracking). Award 0 points for no visualization, 5 points for basic changes only at the end, and 10 points for comprehensive visualization with speed control or step-by-step options.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is user interaction implemented for manual solving assistance?",
-      "description": "Evaluate whether the implementation allows user interaction such as manually entering numbers, requesting hints, or controlling the solving process (start/pause/resume/step). Award 0 points for no interaction, 5 points for basic controls, and 10 points for comprehensive interaction including validation of user inputs against Sudoku rules.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle edge cases (invalid inputs, unsolvable puzzles, multiple solutions). Check for appropriate error handling and user feedback. 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. Multiple solving algorithms with comparison 2. Performance statistics of solving time/steps 3. Mobile-responsive design 4. Dark mode toggle). 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 solving algorithms without clear purpose) 2. Function modules unrelated to Sudoku solving (e.g., unnecessary animations) 3. Fancy effects that affect performance (e.g., excessive DOM manipulations). 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 UI logic from solving algorithm), 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 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 (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) Cell highlighting and number updates occur without visual lag 2) Transition animations when displaying solutions are controlled between 300-500ms 3) Clear visual distinction between original numbers and solved numbers. Deduct 5 points for each operation without feedback, 3 points for visual jarring during fast solving, and 5 points for confusing visual states. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "easy"
-}

package/library/game_development-puzzle/html-math-game-quadratic-equations-radicals.json

@@ -1,68 +0,0 @@
-{
-  "index": 1777,
-  "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 and functional. Design an HTML-based math game centered around quadratic radical operations and solving linear quadratic equations. Include a scoring system and a time limit system.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core quadratic radical operation functionality fully implemented?",
-      "description": "Review whether the code accurately implements a system for quadratic radical operations (simplification, addition, multiplication, etc.). Check if the mathematical logic correctly handles operations like √(a²) = |a|, √(a × b) = √a × √b when a,b ≥ 0. Score 0 if the core math operations are incorrect, 5 if basic operations work but edge cases are unhandled, and 10 if all operations are mathematically sound with proper error handling.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the linear quadratic equation solving system properly implemented?",
-      "description": "Evaluate whether the code can generate valid linear and quadratic equations for solving, with proper validation of user input and solution verification. Check if the quadratic formula (-b ± √(b² - 4ac))/2a is correctly implemented with discriminant handling. Deduct 5 points if the system only handles specific coefficient cases, 3 points if imaginary solutions aren't properly addressed, and 2 points if rounding errors affect solution validation. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the scoring system comprehensive and fair?",
-      "description": "Check whether the scoring logic rewards correct answers appropriately with graduated difficulty levels. Verify if the system handles partial credit for multi-step problems, and if score tracking persists across game sessions. Deduct 4 points if scoring doesn't account for problem difficulty, 3 points if there's no visual feedback after scoring events, and 3 points if high scores aren't tracked. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the time limit system properly implemented and user-friendly?",
-      "description": "Assess whether the timer is accurately implemented with appropriate visual cues as time runs low. Check if the system has pause/resume functionality and handles timeout events gracefully. Deduct 4 points if the timer has synchronization issues, 3 points if there's no warning for low time remaining, and 3 points if time penalties/bonuses aren't incorporated for wrong/right answers. 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, division by zero, incorrect equation formats, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle mathematical edge cases (e.g., irrational results, large numbers), 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 representation of equations/solutions 2. Progressive difficulty adjustment based on user performance 3. Step-by-step solution explanations). 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 mathematical functions (e.g., multiple equation-solving algorithms) 2. Function modules unrelated to math learning (e.g., unnecessary animations) 3. Fancy effects that affect performance or distract from the learning experience. 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 math logic/view/game state management), unit test coverage for mathematical operations, and clean implementation. 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 mathematical functions aren't properly abstracted. 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) Mathematical notation is clear and properly rendered (e.g., using MathJax/KaTeX) 2) Proper layout spacing for equations and input fields 3) Professional font system with appropriate sizing for mathematical expressions. Deduct 3 points for each hard-to-read equation, 5 points for cluttered mathematical notation, and 5 points for inconsistent mathematical formatting. 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 answer submission ≤ 100ms 2) Smooth transitions between problems 3) Clear visual guidance when entering mathematical expressions. Deduct 5 points for each math operation without feedback, 3 points for laggy equation rendering, and 5 points for confusing input methods for mathematical symbols. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "medium"
-}

package/library/game_development-puzzle/html-math-game-triangles-line-segment.json

@@ -1,68 +0,0 @@
-{
-  "index": 351,
-  "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. Create an HTML code game for teaching mathematics with triangles. First, there will be a line segment, and when the teacher clicks the mouse anywhere, a triangle will be generated using that point and the line segment.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the basic triangle generation functionality correctly implemented?",
-      "description": "Check if the code properly creates a triangle when a user clicks, using the clicked point and the existing line segment as vertices. Ensure the triangle is mathematically accurate with correct coordinates. Score 0 if triangles aren't created, 5 if they're created but with positioning issues, and 10 if triangles are perfectly generated with accurate geometric properties.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Does the implementation include interactive line segment creation and manipulation?",
-      "description": "Evaluate if the code allows teachers to create and/or modify the initial line segment. Check if there are controls to adjust the line segment's position, length, or orientation. Deduct 5 points if line segments are fixed with no way to adjust them, and 3 points if adjustments are limited. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are mathematical properties of triangles displayed?",
-      "description": "Assess whether the code calculates and displays key mathematical properties of the created triangles (e.g., angles, area, perimeter, type of triangle). Deduct 3 points if only basic properties are shown, 5 points if calculations contain errors, and give full points if comprehensive properties with accurate calculations are displayed. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there an educational component that explains triangle concepts?",
-      "description": "Check if the implementation includes explanations, formulas, or teaching aids that help understand triangle concepts. Look for interactive elements that demonstrate how changing the triangle affects its properties. Deduct 5 points if educational content is minimal, and give full points if comprehensive educational materials are integrated with the interactive elements. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle edge cases (e.g., clicks very close to the line segment, rapid multiple clicks, clicks outside the canvas). Code with strong robustness should prevent invalid triangles and provide appropriate feedback. Give 10 points if all common edge cases are handled, 5 points if some are addressed, and 0 points if the code breaks easily.",
-      "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 learning experience (e.g., 1. Animation showing triangle formation 2. Dynamic visualization of geometric theorems 3. Interactive challenges to create specific types of triangles). 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 create triangles that cause confusion) 2. Function modules unrelated to triangle mathematics (e.g., unnecessary graphics) 3. Fancy effects that affect performance (e.g., excessive animations that distract from learning). 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 geometric calculation/view/interaction layers), code organization, and maintainability. Deduct 5 points if global state pollution is found or if mathematical calculations are mixed with rendering code; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no clear structure 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 educational interface principles: 1) Clear visual distinction between the line segment and generated triangles 2) Proper layout with sufficient workspace 3) Professional font system for mathematical notation and explanations. Deduct 3 points for each cluttered visual element, 5 points for poor color choices that hinder visibility, and 5 points for text-image layout that impedes understanding. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the triangle creation process is intuitive and responsive: 1) Immediate visual feedback when clicking 2) Smooth transitions when triangles are formed 3) Clear visual indication of interactive elements. Deduct 5 points for each operation without feedback, 3 points for laggy triangle generation, and 5 points for confusing interaction patterns. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "easy"
-}

package/library/game_development-puzzle/html-mini-game-city-landmark-memory-challenge.json

@@ -1,68 +0,0 @@
-{
-  "index": 213,
-  "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 when possible. Help me create an HTML mini-game for a city landmark memory challenge.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the city landmark memory game core mechanics fully implemented?",
-      "description": "Check if the code implements the essential memory game mechanics: landmark cards display, card flipping animation, match detection, and game completion logic. Score 0 if core mechanics are missing, 5 if basic functionality works but with limitations, and 10 if the memory matching system is complete with proper state management.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the landmark content and representation well-designed?",
-      "description": "Evaluate if the game includes real city landmark images or high-quality illustrations, proper attribution, and informative tooltips/descriptions for educational value. Deduct 3 points if generic images are used, 5 points if landmark information is missing, and 2 points if visual representation is inconsistent. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Does the game include difficulty levels and progression?",
-      "description": "Check if the game offers multiple difficulty levels (e.g., number of cards, time limits) and a progression system (e.g., unlocking new landmark sets, increasing complexity). Score 0 if there's only one static difficulty, 5 if basic difficulty options exist, and 10 if the game includes a comprehensive progression system that adapts to player skill.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the scoring and feedback system implemented effectively?",
-      "description": "Assess if the game includes a score tracking system, performance metrics (time, moves, accuracy), and meaningful feedback (animations, sounds, messages). Deduct 3 points if score display is missing, 4 points if there's no feedback for correct/incorrect matches, and 3 points if end-game statistics are absent. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid clicking, browser refresh, different screen sizes, touch vs. mouse input) 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. Geolocation integration to prioritize local landmarks 2. AR view option for landmark cards 3. Social sharing of completion times). 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 reset the game) 2. Function modules unrelated to the memory game (e.g., unnecessary mini-games within) 3. Fancy effects that affect performance (e.g., excessive animations that slow down card flipping). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/UI/data), code organization, and performance optimization. Deduct 5 points if global state pollution is found or if there's no separation of concerns; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there are no performance considerations for image loading and animations. 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 complements landmark imagery 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) Card flip animations complete within 300ms 2) Match/mismatch feedback appears within 100ms 3) Clear visual indication of clickable elements. Deduct 5 points for each operation without feedback, 3 points for choppy animations during rapid play, and 5 points for confusing interaction states. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "medium"
-}

package/library/game_development-puzzle/html-party-member-quiz-competition-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 1499,
-  "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. Help me design a small quiz competition game tool in HTML format, with content suitable for Party member study.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the quiz competition core system fully implemented?",
-      "description": "Review whether the code accurately implements essential quiz functionalities including question display, answer selection mechanism, scoring system, and timer functions. Score 0 if core quiz logic is missing, 5 if only basic question display is implemented, and 10 if it includes a complete question bank with randomization, timing, and scoring mechanics.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the Party member study content appropriately integrated?",
-      "description": "Evaluate whether the quiz contains relevant content related to Party history, principles, policies, or current affairs. The questions should be factually accurate, educational, and aligned with Party values. Deduct 5 points if content is sparse or irrelevant, 3 points if content lacks depth or variety. Award full points only if content is comprehensive, educational and properly cited where necessary.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Does the game include progress tracking and feedback mechanisms?",
-      "description": "Check if the code implements user progress tracking (such as current score, questions answered, success rate) and provides meaningful feedback after answers (explanations for correct answers, learning points for incorrect ones). Deduct 5 points if there's no progress indicator, 3 points if feedback is minimal. Full points require comprehensive statistics and educational feedback.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there competition or multiplayer functionality?",
-      "description": "Assess whether the tool includes any competitive elements such as leaderboards, time-based challenges, multi-player functionality, or achievement systems. Score 3 points for basic score comparison, 7 points for a functional leaderboard, and 10 points for implemented real-time or turn-based multiplayer competition with proper user identification.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid inputs, unexpected user behavior, browser compatibility 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. Dynamic difficulty adjustment based on user performance 2. Interactive educational content between questions 3. Visual representations of Party history or achievements). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple scoring systems coexisting) 2. Function modules unrelated to Party education or quiz gameplay 3. Fancy effects that affect performance (e.g., excessive animations that slow down question transitions). 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 quiz logic/view 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 HTML structure is not semantic or accessible. 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 (preferably using official Party colors appropriately) 2) Proper layout spacing (element spacing follows consistent principles) 3) Professional font system (body font size ≥ 14px, clear hierarchy). Deduct 3 points for each crowded visual element, 5 points for inappropriate color combinations, and 5 points for chaotic text-image layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance for quiz navigation. Deduct 5 points for each operation without feedback, 3 points for jarring transitions between questions, and 5 points for confusing navigation or answer selection mechanics. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "easy"
-}

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

@@ -1,68 +0,0 @@
-{
-  "index": 357,
-  "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 purposes. Write code for an HTML Tetris game.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core Tetris game mechanics fully implemented?",
-      "description": "Review whether the code accurately implements the standard Tetris mechanics including tetromino generation, rotation, movement, line clearing, and scoring. Check if the game follows official Tetris guidelines for piece spawning positions and rotation systems (SRS). Score 0 if basic tetromino movement is missing, 5 if basic mechanics work but advanced features (wall kicks, T-spins) are missing, and 10 if a complete implementation following Tetris guidelines is provided.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the game board rendering and collision detection properly implemented?",
-      "description": "Evaluate the code for proper rendering of the game grid, active tetromino, preview of the next piece, and ghost piece (showing where the current piece will land). Check if collision detection works correctly for wall boundaries, floor, and occupied cells. Deduct 5 points if ghost piece is missing, 3 points if next piece preview is missing, and 5 points if collision detection has flaws. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are the game controls and input handling well-implemented?",
-      "description": "Check if the code properly handles keyboard input for movement (left/right/down), rotation, hard drop, and pause functionality. Verify if the code implements standard control schemes and allows for customizable controls. Deduct 3 points if only basic controls are implemented, 3 points if input handling is laggy or unresponsive, and 5 points if key rebinding is not possible. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the scoring system and level progression implemented correctly?",
-      "description": "Assess whether the game includes a proper scoring system that rewards line clears (especially multi-line clears like Tetris), implements increasing difficulty through speed progression, and tracks high scores. Deduct 3 points if multi-line clear bonuses are missing, 3 points if difficulty doesn't increase with levels, and 5 points if there's no high score tracking. 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 input, browser resizing, focus loss, etc.) and provide friendly error handling 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. Hold piece functionality 2. Battle mode with garbage lines 3. Special effects for Tetris clears 4. Mobile touch support). 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 the game) 2. Function modules unrelated to Tetris (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive animations 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/rendering/input handling), code organization, maintainability, and performance optimization. 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 game loop implementation causes performance issues. 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 (clear distinction between tetrominos, background and UI elements) 2) Proper layout spacing (clear separation between game board, next piece preview, score display) 3) Professional font system (readable score and level indicators, consistent styling). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Immediate response to key presses (≤ 50ms) 2) Smooth animation for line clears and piece movements 3) Clear visual and audio feedback for game events (line clears, game over). Deduct 5 points for each operation without feedback, 3 points for stuttering animations during fast movement, and 5 points for inconsistent game speed. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "hard"
-}

package/library/game_development-puzzle/html-tetris-mini-game-creation.json

@@ -1,68 +0,0 @@
-{
-  "index": 1485,
-  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Be careful to ensure that the generated code is executable for display. Please help me continue creating a Tetris \"mini-game\" using HTML. All code should be saved in a single HTML file.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Tetris game core mechanics fully implemented?",
-      "description": "Check if the code implements all essential Tetris mechanics: tetromino generation with proper shapes (I, J, L, O, S, T, Z), rotation logic (including wall kicks), collision detection, line clearing, and scoring. Score 0 if core mechanics are missing, 5 if only basic functionality works, and 10 if all standard Tetris mechanics are properly implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the game loop and tetromino movement properly handled?",
-      "description": "Evaluate if the game uses requestAnimationFrame or setInterval for the game loop with appropriate timing. Check if tetrominoes fall at a consistent speed with gradual difficulty increase. Verify that horizontal movement, rotation, and hard/soft drop commands work correctly with proper collision detection. Deduct 3 points if movement feels sluggish, 5 points if timing is inconsistent, and 5 points if difficulty progression is missing.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is there complete user input handling?",
-      "description": "Check if the code properly handles keyboard input (arrow keys, space bar, etc.) with both keydown and keyup events. Verify if mobile touch controls are implemented. Evaluate if there's input buffering for quick rotations and movements. Deduct 3 points for missing mobile support, 5 points for poor input responsiveness, and 5 points if key mapping customization is not available.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the game state management and UI feedback comprehensive?",
-      "description": "Review if the game displays next piece preview, score tracking, level indicator, and game over detection. Check if pause/resume functionality works properly and if there's a high score system (preferably with localStorage). Deduct 3 points if next piece preview is missing, 3 points without score/level indicators, and 5 points without proper game start/end states.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid inputs, browser refresh, resizing) and provide friendly error handling. Check if the game state is properly managed to prevent memory leaks. Code with strong robustness should handle these edge cases effectively, giving 10 points. If 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. Ghost piece showing where tetromino will land 2. Hold piece functionality 3. Special effects for Tetris clears 4. Power-ups or special modes). 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 Tetris (e.g., unnecessary social sharing features) 3. Fancy effects that affect performance (e.g., excessive animations 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 (separating game logic/rendering/input handling), code organization, and maintainability. Check for proper variable/function naming, comments, and consistent coding style. Deduct 5 points if global state is overused; deduct 3 points if the code is not properly structured; deduct 5 points if the code is difficult to understand or maintain. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the game follows modern design principles: 1) Clean, readable game board with appropriate grid lines 2) Consistent color scheme for tetrominoes 3) Proper contrast between pieces and background 4) Professional UI elements for score, level, and controls. Deduct 3 points for poor tetromino visibility, 5 points for cluttered UI, 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 game animations and interactions feel natural: 1) Tetromino movement is smooth without stuttering 2) Line clear animations are satisfying 3) Input response feels immediate (≤ 100ms). Deduct 5 points for jerky animations, 3 points for inconsistent frame rates during fast drops, and 5 points if game freezes during line clears. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "hard"
-}