@getollie/cli 0.0.5 → 0.2.0

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

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

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

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

package/library/game_development-puzzle/html5-sudoku-game-development.json

@@ -1,68 +0,0 @@
-{
-  "index": 375,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code when possible. Write a Sudoku game using HTML5 and related technologies.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Sudoku game core logic fully implemented?",
-      "description": "Review whether the code accurately implements the fundamental Sudoku rules (no duplicate numbers in rows, columns, and 3x3 boxes). Check if puzzle generation algorithms produce valid, unique-solution puzzles with appropriate difficulty levels. Score 0 if core validation logic is missing, 5 if only basic validation is implemented, and 10 if puzzle generation and complete validation are properly implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are the game interface and user interaction features complete?",
-      "description": "Evaluate if the interface includes essential Sudoku game features: number selection mechanism, highlighting of conflicting cells, notes/pencil marks system, undo/redo functionality, and visual indication of completed rows/columns/boxes. Deduct 2 points for each missing critical feature. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the puzzle generation and difficulty system implemented properly?",
-      "description": "Check if the code includes algorithms for generating puzzles of varying difficulties (easy, medium, hard) with guaranteed unique solutions. Examine whether difficulty is calculated using recognized metrics (e.g., minimum required techniques, number of givens). Deduct 5 points if puzzles are hardcoded rather than generated, 3 points if difficulty levels are absent. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there a hint system and solver implementation?",
-      "description": "Assess whether the game provides intelligent hints (beyond random solutions) that teach solving techniques, and whether it includes a step-by-step solver demonstrating solution paths. Deduct 5 points if no hint system exists, 3 points if hints simply reveal answers without explanation, and 5 points if no solver is implemented. 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, browser compatibility issues, performance optimization for large puzzles) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Visual solving technique tutorials 2. Daily puzzles with global leaderboards 3. Custom puzzle creation/sharing 4. Advanced statistics tracking). Add 2.5 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple validation methods that accomplish the same thing) 2. Function modules unrelated to Sudoku (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive animations that slow down gameplay). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/UI/data models), code reusability, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 3 points if the code duplication rate is too high (over 30%); deduct 2 points if the code lacks comments or documentation. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching with good contrast for numbers 2) Proper layout spacing with clear grid lines and visual hierarchy 3) Professional font system with legible numbers even on small screens. Deduct 3 points for poor number visibility, 4 points for confusing UI elements, and 3 points for inconsistent styling. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Immediate feedback when entering numbers 2) Smooth transitions when highlighting related cells 3) Clear visual indication for valid/invalid entries. Deduct 4 points for laggy number input, 3 points for confusing selection states, and 3 points for disorienting transitions between game states. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "hard"
-}

package/library/game_development-puzzle/icon-matching-game-implementation.json

@@ -1,68 +0,0 @@
-{
-  "index": 966,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure that any code you generate is executable. Based on existing matching games in the market, help me design a similar matching game where players can eliminate identical icons by clicking on them. Please provide the game code that runs as a mouse-operated application rather than a command-line program.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core matching mechanism properly implemented?",
-      "description": "Check whether the code implements a complete matching mechanism that allows players to select and eliminate identical icons. The matching logic should include: detection of identical icons, removal animation, and score calculation. Score 0 if the core matching logic is missing, 5 if only basic matching is implemented without proper validation, and 10 if the solution includes comprehensive matching rules with edge cases handling (such as no more possible matches detection).",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the game board generation and management implemented correctly?",
-      "description": "Evaluate if the game dynamically generates a proper grid of icons with sufficient variety while ensuring the game is solvable. Check if the board is refilled correctly after eliminations and whether the code ensures there are always possible matches available. Deduct 5 points if the board generation doesn't guarantee solvable states, 3 points if refilling mechanism is flawed, and 2 points if icon variety is too limited. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are the mouse interaction controls intuitive and responsive?",
-      "description": "Since the game is specifically required to be mouse-operated, examine if click/hover events are properly implemented, with clear visual feedback on selection and matching. Check for smooth highlighting of selected icons and intuitive error feedback for invalid moves. Deduct 5 points if there are click response delays (>100ms), 3 points if visual feedback is unclear, and 5 points if the mouse interaction isn't intuitive. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the game state management comprehensive?",
-      "description": "Check if the code implements proper game state management including start/pause/restart/end game states, score tracking, timer functionality (if applicable), and level progression. Examine if game data persists between sessions using local storage. Deduct 5 points if critical game states are missing, 3 points if score tracking is implemented poorly, and 2 points if there's no session persistence. 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 multiple clicks, browser resize events, or unexpected user interactions) 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 combo elimination mechanics 2. Power-ups or special tiles 3. Adaptive difficulty level based on player performance). 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 matching games (e.g., an unnecessary login system) 3. Fancy effects that affect performance (e.g., excessive animations that slow down gameplay). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/view/UI layers), code reusability, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the code lacks comments or documentation. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern game design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (clear grid structure with consistent margins) 3) Professional font system (readable score displays, clear instructions). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic UI layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the animations and transitions enhance gameplay: 1) Icon selection feedback is immediate (≤ 50ms) 2) Matching elimination animations are satisfying but quick (200-400ms) 3) Board refill animations are smooth and logical. Deduct 5 points for static gameplay without animations, 3 points for animations that hinder gameplay speed, and 5 points for confusing visual effects that don't clearly communicate game state. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "medium"
-}

package/library/game_development-puzzle/javascript-canvas-match-3-puzzle-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 1193,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the code you generate is executable for demonstration purposes. Use JavaScript and canvas to implement a complete match-3 puzzle game.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the match-3 core game mechanics fully implemented?",
-      "description": "Review whether the code accurately implements the match-3 puzzle logic through JavaScript/Canvas, including gem grid generation, match detection (horizontal/vertical 3+ matches), cascading elimination, and gravity-based gem falling. Score 0 if core matching logic is missing, 5 if only basic 3-match detection exists, and 10 if advanced combos (L-shape, T-shape, 4+ matches) and special gems are fully implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the interactive control system responsive and intuitive?",
-      "description": "Check whether mouse/touch input handling includes accurate gem selection, drag-and-drop swapping, swap validation (only adjacent gems), and illegal move rejection with visual feedback. Deduct 5 points if swap animations are missing, 3 points if touch responsiveness is poor (>150ms delay), and 2 points if visual feedback for invalid moves is absent. Full score requires smooth gesture recognition.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the game progression and scoring system complete?",
-      "description": "Evaluate whether the scoring system includes combo multipliers, cascade bonuses, level progression with increasing difficulty, and objective-based gameplay (score targets, limited moves, or time constraints). Deduct 5 points if no level progression exists, 3 points if scoring lacks combo rewards, and 2 points if no clear win/lose conditions are defined. Full implementation should include multiple game modes.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are visual effects and animations polished and engaging?",
-      "description": "Check whether the code includes smooth gem elimination animations, particle effects for matches, screen shake for large combos, and satisfying visual feedback. Animations should use easing functions and proper timing (200-400ms for swaps, 300-600ms for eliminations). Deduct 5 points if animations are choppy or missing, 3 points if no particle effects exist, and 2 points if visual hierarchy is unclear during gameplay.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid clicking, boundary detection errors, invalid gem states, canvas rendering failures, etc.) and provide friendly error handling or recovery mechanisms. Code with strong robustness should effectively prevent game state corruption and handle edge cases gracefully, 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 enhance gameplay?",
-      "description": "Check whether the code includes compelling features that elevate the experience (e.g., 1. Power-up gems with special abilities 2. Daily challenges or puzzle modes 3. Hint system for possible moves 4. Undo functionality 5. Save/load game state). Add 2-3 points for each well-implemented innovative feature (maximum 10 points). Features must be functional, not just cosmetic.",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features or performance issues?",
-      "description": "Strictly check three types of problems: 1. Redundant implementation of similar functions (e.g., multiple animation systems coexisting) 2. Unnecessary features unrelated to match-3 gameplay 3. Performance-heavy effects that cause frame drops (excessive particles, inefficient canvas clearing). Deduct 3 points for each redundancy found, and directly deduct 10 points if core gameplay is affected by performance issues or bloated code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (separating game logic, rendering, input handling), clean code structure, and performance optimization (efficient canvas operations, object pooling for particles). Deduct 5 points if code structure is monolithic or poorly organized; deduct 3 points if canvas operations are inefficient (unnecessary redraws); deduct 2 points if no comments or documentation exist. Full score requires professional code organization.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the visual design meet professional game UI standards?",
-      "description": "Evaluate whether the visual design follows modern game UI principles: 1) Cohesive color palette with proper contrast for gameplay clarity 2) Consistent gem designs that are easily distinguishable 3) Clear UI hierarchy with readable fonts (≥16px for game text) 4) Proper spacing and alignment of game elements. Deduct 3 points for each unclear visual element, 5 points for poor color accessibility, and 5 points for cluttered interface design. Full score requires polished, professional appearance.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the game interaction smooth and responsive?",
-      "description": "Judge whether the interactive experience meets gaming standards: 1) Input response time ≤ 100ms 2) Animation frame rate consistently above 30fps 3) Smooth gem movement with proper easing 4) Clear visual feedback for all user actions 5) Intuitive game flow without confusing states. Deduct 5 points for each laggy interaction, 3 points for inconsistent frame rates, and 5 points for unclear or missing user feedback. Full score requires console-quality smoothness.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "hard"
-}

package/library/game_development-puzzle/lianliankan-puzzle-game-with-optimal-path.json

@@ -1,68 +0,0 @@
-{
-  "index": 1710,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable for demonstration purposes. Referring to https://blog.csdn.net/liuyinghui523/article/details/111638194?ops_request_misc=&request_id=&biz_id=102&utm_term=%E8%BF%9E%E8%BF%9E%E7%9C%8B%E6%B6%88%E6%B6%88%E4%B9%90%E7%9A%84%E7%AE%97%E6%B3%95&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-1-111638194.142^v102^control&spm=1018.2226.3001.4187, develop a Lianliankan (matching pairs) elimination algorithm with optimal path recommendation, and create a small Lianliankan puzzle game using Flutter.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core Lianliankan elimination algorithm correctly implemented?",
-      "description": "Check if the algorithm can accurately determine whether two tiles can be connected with at most two turns. The implementation should include proper validation of matching pairs, path-finding logic, and boundary checks. Score 0 if the core algorithm is missing, 5 if basic matching works but has edge case issues, 10 if the algorithm is complete and handles all scenarios correctly.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the optimal path recommendation feature properly implemented?",
-      "description": "Evaluate whether the code includes an algorithm to find and highlight the shortest connecting path between two matching tiles. Check if it considers all possible paths and selects the optimal one with minimum turns. Score 0 if path recommendation is missing, 5 if basic path finding exists but isn't always optimal, 10 if the recommendation system consistently finds the best path.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the game board generation and shuffling mechanism effectively designed?",
-      "description": "Review the algorithm for generating the game board with guaranteed solvable layouts. Check if the code ensures that all tiles have possible matches and includes a proper shuffling mechanism when no matches are available. Score 0 if board generation is missing or broken, 5 if basic board generation exists but may create unsolvable states, 10 if the system guarantees solvable boards and handles reshuffling appropriately.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the Flutter UI implementation complete for the Lianliankan game?",
-      "description": "Check if the Flutter implementation includes all necessary UI components: game board with tiles, animation for selection and matching, score display, timer, and game control buttons. Score 0 if the Flutter implementation is missing, 5 if basic UI exists but lacks essential game elements, 10 if the UI is complete with all necessary components for a fully functional game.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid selections, edge cases in path finding, premature game termination) and provides friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Different difficulty levels 2. Custom themes or tile designs 3. Hint system with cooldown 4. Special power-ups or game 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 path-finding algorithms without clear purpose) 2. Function modules unrelated to Lianliankan (e.g., unrelated mini-games) 3. Fancy effects that affect performance (e.g., excessive animations slowing 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/state management layers), widget composition, state management approach, and code organization. Deduct 5 points if global state pollution is found or Flutter best practices aren't followed; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no separation between UI and game logic. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional typography (readable font sizes, appropriate contrast). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for poorly aligned or inconsistent UI elements. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the game interactions conform to human perception characteristics: 1) Responsive tile selection feedback ≤ 100ms 2) Smooth matching animations with appropriate duration (300-500ms) 3) Clear visual indication of successful matches and possible paths. Deduct 5 points for each operation without feedback, 3 points for laggy animations during gameplay, and 5 points for confusing or unclear game state indicators. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "hard"
-}

package/library/game_development-puzzle/magic-forest-game-with-puzzles.json

@@ -1,68 +0,0 @@
-{
-  "index": 117,
-  "question": "You are a code expert, please use your professional knowledge to generate accurate and expert responses. Be sure to ensure that the code you generate is executable.\n\nPlease use HTML and JavaScript to implement a Magic Forest game where players need to solve magical puzzles within the forest.\n\nHint: Design a forest environment and magical puzzle system.\n\nPlease include comments in your code so that other developers can understand your implementation process.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the forest environment visualization fully implemented?",
-      "description": "Review whether the code creates an immersive forest environment through HTML/CSS/JavaScript, including appropriate background imagery, forest elements (trees, paths, magical items), and ambient effects. Score 0 if the environment is not implemented, 5 if a basic static forest is created, and 10 if the forest is visually rich with dynamic elements and responsive design.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are the magical puzzles properly designed and implemented?",
-      "description": "Evaluate the puzzle system implementation: check if there are multiple puzzle types, clear objectives, validation logic, and progression mechanics. Scoring: 0 points if puzzles are missing/non-functional, 5 points for basic puzzles without variety, 10 points for diverse, challenging puzzles with proper solution validation and feedback systems.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is there a player interaction and progression system?",
-      "description": "Check for player state management, progression tracking, and reward systems. Review whether the code implements player movement/controls, inventory management if applicable, and a logical puzzle progression sequence. Deduct 5 points if there's no state persistence between puzzles, and 3 points if player progress isn't tracked. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the game's magical element system engaging and interactive?",
-      "description": "Assess whether magical elements (spells, enchanted objects, magical creatures) are interactive and enhance gameplay. Check for special effects when magic is used, appropriate visual feedback, and integration with puzzle mechanics. Deduct 5 points if magical elements are purely decorative, 3 points if interactions are limited. Give 10 points for a fully developed magical system that's central to gameplay.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid inputs, browser compatibility issues, resolution changes, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Dynamic weather effects that affect puzzles 2. Procedurally generated forest elements 3. Adaptive difficulty based on player performance). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to track player progress) 2. Function modules unrelated to the magic forest theme (e.g., unrelated 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/interaction layers), code organization, use of design patterns, and quality of comments. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if comments are missing or insufficient. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching that evokes a magical forest atmosphere 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 clashing 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 interactive elements in the forest. Deduct 5 points for each operation without feedback, 3 points for visual after-images during interactions, and 5 points for hard-to-find key interactive elements. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "medium"
-}