@getollie/cli 0.0.1

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

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

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

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

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

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

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

@@ -0,0 +1,68 @@
+{
+  "index": 1137,
+  "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. Help me create a small HTML game for memorizing vocabulary words.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core vocabulary memorization mechanism properly implemented?",
+      "description": "Review whether the code implements a proper spaced repetition system or other memory-enhancing algorithm. Check if words are shown at appropriate intervals based on user performance, and if there's a scoring mechanism that tracks learning progress. Score 0 if no memorization system exists, 5 if basic flashcards are implemented, and 10 if an advanced algorithm (like Leitner or SuperMemo) is properly coded.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the word database structure well-designed?",
+      "description": "Evaluate the data structure used for vocabulary storage. It should include at minimum: word, definition, example usage, and memorization metadata (like success rate or next review date). Check if the data persistence is implemented (LocalStorage, IndexedDB, etc.) and if there's import/export functionality for vocabulary lists. Deduct 5 points for missing persistence, and 3 points for limited word metadata. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are there appropriate learning modes and difficulty levels?",
+      "description": "Check whether the game offers different learning modes (e.g., flashcards, multiple choice, spelling test, matching) and adjustable difficulty levels. Deduct 3 points for each missing core learning mode, and 5 points if difficulty adjustment is absent. The system should adapt to user performance. Give 10 points only if at least three different learning modes are fully implemented with difficulty adaptation.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a complete progress tracking and statistics system?",
+      "description": "Assess whether the code includes comprehensive tracking of user learning progress, including statistics on retention rate, commonly missed words, learning streaks, and visual progress charts. Deduct 5 points if there's no visualization of progress, 3 points if historical performance cannot be reviewed, and 2 points if no session-based feedback is provided. 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 empty word lists, network interruption for external dictionary APIs if used, invalid user input, 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 learning experience (e.g., 1. Pronunciation audio for words 2. Visual mnemonics or image associations 3. Gamification elements like badges or leaderboards). 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 learning methods 2. Function modules unrelated to vocabulary memorization 3. Fancy effects that affect performance and distract from the learning process. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core memorization functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game logic/view/data layers), maintainability, and code organization. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there are no comments or documentation for complex functions. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance for learning flow. Deduct 5 points for each operation without feedback, 3 points for distracting animations that impede learning, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "medium"
+}

package/library/game_development-puzzle/html-word-matching-game-with-upload.json

@@ -0,0 +1,68 @@
+{
+  "index": 856,
+  "question": "You are a coding expert, please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable for demonstration. I'm a beginner and want to create a word-matching game in HTML where I can upload word information and then play the game based on my words. What information do I need to provide to you?\n\nThe structure of the Excel file is shown in the image:",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the word-matching game core functionality fully implemented?",
+      "description": "Review whether the code implements the basic word-matching game mechanics, including word pairing logic, input validation, and scoring system. Score 0 if core game logic is missing, 5 if basic matching is implemented without validation, and 10 if the game includes comprehensive matching mechanisms with proper feedback.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the Excel file upload and parsing functionality properly implemented?",
+      "description": "Check whether the code handles Excel file uploads correctly, parses the structure according to the specified format, and handles errors gracefully. Deduct 5 points if parsing is incomplete or error-prone, 3 points if only limited file formats are supported. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there proper data validation and error handling for the uploaded content?",
+      "description": "Evaluate whether the code validates the uploaded Excel data (checking for empty cells, incorrect formats, etc.) and provides clear feedback to users. Deduct 3 points if basic validation is missing, 5 points if error messages are not user-friendly. Check if the system can handle malformed Excel files or unexpected content. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a proper mechanism for word storage and game state persistence?",
+      "description": "Assess whether the game maintains state between sessions (using localStorage, cookies, or server storage) and saves user progress. Deduct 5 points if the game doesn't save progress at all, 3 points if it only uses temporary storage. 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 file formats, network issues during upload, 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. Multiple game modes like timed challenges 2. Visual animations for successful matches 3. Progress tracking and 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 ways to upload files) 2. Function modules unrelated to word matching (e.g., unnecessary media players) 3. Fancy effects that affect performance (e.g., excessive animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game logic/view/data management layers), code organization, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no error handling for the file upload process. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance. Deduct 5 points for each operation without feedback, 3 points for visual after-images during fast gameplay, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "hard"
+}

package/library/game_development-puzzle/html5-merge-big-watermelon-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1818,
+  "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. Use HTML5 to create a \"Merge Big Watermelon\" game.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core merge mechanic properly implemented?",
+      "description": "Evaluate whether the code implements the core fruit merging logic correctly: collision detection between fruits of the same type, combining into the next level fruit upon contact, and appropriate physics for the merged fruit. Deduct 5 points if fruits don't merge correctly, 3 points if physics is unrealistic, and 5 points if the merge animation is missing or abrupt. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the fruit dropping and placement system functional?",
+      "description": "Check if players can properly drop fruits from the top of the screen, whether the position indicator works correctly, and if the dropping physics is natural. Deduct 5 points if dropping positioning is inaccurate, 3 points if there's no drop preview/indicator, and 5 points if the next fruit display is missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the game board and collision system correctly implemented?",
+      "description": "Review the implementation of the game board boundaries, collision handling between fruits, and stacking behavior. Check if fruits properly stack on top of each other and if boundary collisions are detected accurately. Deduct 5 points if fruits clip through each other, 5 points if boundary detection fails, and 3 points if stacking physics is unrealistic. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the complete game lifecycle and scoring system implemented?",
+      "description": "Assess whether the game includes proper game states (start, play, game over), score calculation based on fruit merges, and progression tracking. Deduct 5 points if game over conditions (fruits stacking beyond the top line) aren't implemented, 3 points if scoring is inaccurate, and 3 points if there's no way to restart the game. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid clicks, browser resizing, touchscreen vs. mouse input, 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. Special fruit effects when merged 2. Combo scoring system 3. Progressive difficulty increase). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple collision detection systems) 2. Function modules unrelated to the core gameplay (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive particle effects 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/physics layers), use of appropriate design patterns for game development, and optimization techniques. Deduct 5 points if global state pollution is found; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if no optimization techniques are applied for smooth animation. 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) Visually appealing fruit graphics with clear progression in size 2) Proper layout with score display and next fruit preview 3) Appropriate color palette that makes different fruit types easily distinguishable. Deduct 3 points for poor fruit visualization, 5 points for unclear UI elements, and 5 points for confusing visual hierarchy. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Responsive fruit dropping controls 2) Smooth physics animation for fruit movement and merging 3) Clear visual and audio feedback for successful merges. Deduct 5 points for laggy animations, 3 points for unresponsive controls, and 5 points for missing feedback when important game events occur. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "hard"
+}