@getollie/cli 0.0.1

package/library/game_development-puzzle/windows-spider-solitaire-game-html.json

@@ -0,0 +1,68 @@
+{
+  "index": 933,
+  "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 and can be displayed. I want to create a Windows built-in Spider Solitaire game and need to generate an HTML file.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core Spider Solitaire game logic fully implemented?",
+      "description": "Review whether the code accurately implements the Spider Solitaire game mechanics, including deck generation, card dealing, valid move detection, completion sequences (when 13 cards of the same suit are collected), and game win/loss conditions. Score 0 if core game rules are missing, 5 if basic card movement is implemented but with rule errors, and 10 if all official Spider Solitaire rules are correctly implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the different difficulty levels (1, 2, or 4 suits) properly implemented?",
+      "description": "Check if the code includes options for playing with 1 suit (easiest), 2 suits (intermediate), or 4 suits (hardest) as in the Windows version. Verify that the deck is properly constructed for each difficulty (e.g., 8 complete suit sets using different proportions based on the selected difficulty). Deduct 5 points if only one difficulty level is implemented, and 3 points if the suit distribution is incorrect. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the deal mechanism and stock pile functionality correctly implemented?",
+      "description": "Evaluate whether the initial deal correctly places cards (face down and face up as appropriate) and if the stock pile allows dealing additional cards when no moves are available (10 cards at a time, once per click). Check if the game prevents dealing when there are empty columns. Deduct 5 points if the initial deal is incorrect, and 5 points if the stock pile mechanics have errors. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are the move tracking and undo/restart features implemented?",
+      "description": "Check if the game tracks moves to allow undoing actions and if it provides a restart option without refreshing the page. The undo system should restore the exact game state before the last move, including card positions and facing. Deduct 5 points if undo only works for simple moves but not for completed sequences, and 5 points if the restart function doesn't preserve the same card arrangement for the current game. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle edge cases like rapid clicking, dragging cards outside the playable area, browser resizing, and attempting illegal moves. Code with strong robustness should prevent game-breaking scenarios and provide helpful feedback. Give 10 points if all common edge cases are handled, 5 points if only some are addressed, and 0 points if the game breaks easily under stress conditions.",
+      "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. Card movement animations that mimic physical cards 2. Hint system for possible moves 3. Statistics tracking for games played/won 4. Auto-complete feature when win is guaranteed). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple card movement algorithms) 2. Function modules unrelated to Spider Solitaire (e.g., unrelated 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 (separation of game logic, UI rendering, event handling), code readability, and implementation efficiency. Check if the code uses appropriate data structures for card representation and game state management. Deduct 5 points if global variables are overused; deduct 5 points if the code has significant duplication; deduct 5 points if the implementation uses inefficient algorithms that cause noticeable lag. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the game visually resembles the Windows Spider Solitaire: 1) Proper card design with clear suit symbols and numbers 2) Professional table background (green felt or similar) 3) Well-designed layout with appropriate spacing between columns. Deduct 3 points for unclear card designs, 5 points for inappropriate color schemes that hinder visibility, and 5 points for disorganized column arrangement. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge the quality of drag-and-drop implementation, card flipping animations, and sequence completion effects: 1) Cards should follow cursor precisely when dragged 2) Visual feedback should indicate valid/invalid drop targets 3) Completed sequences should have a satisfying animation when removed. Deduct 5 points for laggy card movement, 3 points for missing visual cues on valid/invalid moves, and 5 points if drag-and-drop is implemented but feels unnatural or clunky. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "hard"
+}

package/library/game_development-puzzle/word-connection-game-upload-play.json

@@ -0,0 +1,68 @@
+{
+  "index": 796,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure to provide executable code when possible. I want to create a word connection game where I upload words and then play the game based on those words. What information do I need to provide you with?",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the word upload and management system fully implemented?",
+      "description": "Review whether the code includes a complete word upload interface (file upload/manual input), word validation (duplicate checking, format verification), and word library management functionality. Check if it supports multiple file formats (txt/csv/json) and includes word preprocessing (trimming, case normalization). Score 0 if basic upload is missing, 5 if only simple upload is implemented, and 10 if comprehensive word management with validation is included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the word connection game logic correctly implemented?",
+      "description": "Evaluate whether the core game mechanics are properly implemented: word chain validation (last letter of previous word matches first letter of next word), used word tracking, valid word verification against the uploaded dictionary, and game state management (current player, remaining words, score calculation). Deduct 5 points if connection rules are incomplete, 3 points if word validation is missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the game interface intuitive and functional?",
+      "description": "Check whether the game interface includes essential elements: current word display, input field with auto-suggestions, word history panel, remaining word count, timer/scoring system, and clear game status indicators. The interface should provide real-time feedback for valid/invalid connections. Deduct 5 points if key interface elements are missing, 3 points if user feedback is inadequate. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are advanced game features and modes implemented?",
+      "description": "Assess whether the code includes enhanced gameplay features: difficulty levels (word length restrictions, category filtering), multiplayer support, hint system, word definitions/meanings display, game statistics tracking, and customizable game rules (time limits, scoring systems). Give 10 points if multiple advanced features are implemented, 5 points for basic enhancements, 0 points if only core functionality exists.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid file uploads, empty word lists, invalid user input, network interruptions, 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. AI-powered word suggestions 2. Word etymology/definition integration 3. Social sharing of game results 4. Voice input support 5. Themed word categories with visual elements). 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 word validation logics coexisting) 2. Function modules unrelated to word games (e.g., built-in social media integration) 3. Fancy effects that affect performance (e.g., excessive animations during word input). 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 management layers), unit test coverage, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (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) 4) Clear visual hierarchy for word lists and game elements. Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text 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) Input validation feedback delay ≤ 100ms 2) Word transition animations controlled between 300-500ms 3) Clear visual focus guidance for active input fields 4) Smooth word list scrolling and filtering. Deduct 5 points for each operation without feedback, 3 points for visual lag during word input, 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/word-guessing-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 188,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Word Guessing Game\n\n### Gameplay\n1. **Choose a Letter**: Players select a letter to try to fill in the blanks of the word.\n2. **Feedback**: If the selected letter exists in the word, it will be displayed in the correct position; if it doesn't exist, the letter will be marked as incorrect and appear in the list below.\n3. **Guess the Word**: Through continuous testing and elimination of letters, players try to guess the complete word.\n\n### Game Features\n- **Logic and Memory**: The game not only tests players' logical thinking abilities but also requires good memory to recall which letters have already been tried.\n- **Learn New Vocabulary**: By constantly guessing different words, players can learn and memorize new vocabulary.\n- **Suitable for All Ages**: This game has no age restrictions; people of all ages can learn new words and test their memory through this format.\n\n### Game Tips\n- **Frequent Letters First**: First try using the most frequently occurring letters in English, such as E, A, R, etc.\n- **Start from Parts of Speech**: Based on the length of the word and known letters, predict the possible part of speech, such as verb, noun, etc.\n- **Pay Attention to Letter Combinations**: Consider common letter combinations like \"CH\", \"ST\", etc., which can help quickly narrow down the word range.\n\n### Summary\n\"Word Guessing Game\" is an educational and challenging game suitable for players who want to improve their vocabulary and logical thinking skills. This game format is simple but can effectively exercise the brain, making it suitable as a learning tool or recreational game.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Does the game correctly implement the core word guessing mechanics?",
+      "description": "Check whether the code provides a complete word guessing system with proper word selection, letter validation, and state management. Look for proper initialization of a hidden word, tracking of guessed letters, and validation of player inputs. Score 0 if basic mechanics are missing, 5 if implementation is basic but functional, and 10 if the system properly handles all core gameplay elements with clean state management.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the game's visual feedback and UI implementation complete?",
+      "description": "Evaluate if the game provides clear visual representation of the word being guessed (blanks/letters), already guessed letters (both correct and incorrect), and remaining attempts. Check if the UI updates appropriately after each guess. Score 0 if visual representation is missing, 5 if basic display is implemented but lacking polish, and 10 if the UI clearly communicates game state with proper styling and responsive design.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Does the game include a diverse and appropriate word database?",
+      "description": "Verify if the game includes a sufficiently large and varied word database, or implements functionality to fetch words from an external source. Check if words are categorized by difficulty levels or themes. Deduct 5 points if the game has fewer than 20 words, 3 points if words lack variety in length and difficulty. Award full 10 points for implementations with robust word databases or API integrations.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are the educational aspects of the game implemented?",
+      "description": "Assess whether the game includes educational features like word definitions, usage examples, or learning aids. Check if there's a system to track player vocabulary progress or word learning history. Score 0 if no educational elements exist, 5 if basic learning features are present, and 10 if comprehensive educational tools are integrated that align with the game's learning objectives.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid inputs, repeated letter guesses, special characters, 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. Hint system with intelligent suggestions 2. Word difficulty prediction 3. Statistics tracking and achievements 4. Multiplayer or competitive 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 ways to check letter validity) 2. Function modules unrelated to word guessing (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive animations that distract from gameplay). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game logic/view/data layers), unit test coverage, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (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 letter selection. Deduct 5 points for each operation without feedback, 3 points for visual after-images during fast interactions, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "easy"
+}

package/library/game_development-puzzle/word-matching-game-shanghai-oxford-textbook.json

@@ -0,0 +1,68 @@
+{
+  "index": 774,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure that the code you generate is executable when displayed. Help me create a word matching game program based on the vocabulary list from the Shanghai Education Oxford Textbook series.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the word matching game core mechanism fully implemented?",
+      "description": "Review whether the code accurately implements word-definition matching logic through HTML/JavaScript, including vocabulary loading from Shanghai Education Oxford Textbook series, randomized word selection, drag-and-drop or click-to-match interactions, and scoring system. Score 0 if the core matching logic is not implemented, 5 if only basic word display is implemented, and 10 if complete matching mechanics with feedback are included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the vocabulary management system properly structured?",
+      "description": "Check whether the vocabulary data structure includes proper categorization by grade levels, units, and difficulty levels from Shanghai Education Oxford series. Evaluate if the system supports dynamic vocabulary loading, progress tracking, and adaptive difficulty adjustment. Deduct 5 points if vocabulary is hardcoded without structure, and 3 points if no difficulty progression is implemented. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are comprehensive learning features and game modes implemented?",
+      "description": "Evaluate whether multiple game modes are provided (timed challenges, practice mode, review mode), along with learning aids like pronunciation, example sentences, and hint systems. Check for progress saving and performance analytics. Deduct 5 points if only one game mode exists, and 3 points if no learning assistance features are provided. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the user progress and achievement system complete?",
+      "description": "Check whether the code includes comprehensive progress tracking, including completion rates per unit/grade, streak counters, accuracy statistics, and achievement unlocking mechanisms. Evaluate if local storage or backend integration preserves user data across sessions. Deduct 5 points if no progress persistence exists, and 3 points if achievement system is missing. Give 10 points if fully implemented with detailed analytics.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid vocabulary data, network failures for audio resources, user input errors, browser compatibility issues, 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. Voice recognition for pronunciation practice 2. AI-powered personalized difficulty adjustment 3. Social features like leaderboards or sharing achievements 4. Gamification elements like virtual rewards). 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 vocabulary learning (e.g., built-in calculator or weather widget) 3. Fancy effects that affect performance (e.g., excessive particle animations during matching). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core learning 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 layers), vocabulary data management efficiency, and code 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 vocabulary loading is inefficient or memory-intensive. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet educational design standards?",
+      "description": "Evaluate whether the overall design follows educational app design principles: 1) Age-appropriate color scheme that aids learning focus 2) Clear typography with sufficient contrast for readability 3) Intuitive iconography and button placement 4) Consistent visual hierarchy. Deduct 3 points for each distracting visual element, 5 points for poor color contrast affecting readability, and 5 points for confusing navigation layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the interactive experience smooth and educationally effective?",
+      "description": "Judge whether the interactions support effective learning: 1) Immediate feedback on correct/incorrect matches ≤ 200ms 2) Smooth drag-and-drop or touch interactions 3) Clear visual cues for available actions 4) Appropriate animation timing that doesn't distract from learning. Deduct 5 points for each interaction without clear feedback, 3 points for laggy animations during gameplay, and 5 points for unclear game state indicators. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "medium"
+}

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

@@ -0,0 +1,68 @@
+{
+  "index": 1090,
+  "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. I want to develop a word-matching game (similar to \"Link-Link\") with custom word uploading functionality, implemented using HTML+CSS+JS.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core word-matching game mechanism fully implemented?",
+      "description": "Review whether the code accurately implements the word-matching system through HTML/JavaScript, including word pair detection, successful matching logic, and game progression tracking. Check for proper randomization of word positions, clear highlighting of selected words, and verification of valid matches. Score 0 if the core game logic is missing, 5 if basic matching is implemented but with flaws, and 10 if the mechanism works flawlessly with proper game flow.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the custom word uploading functionality properly implemented?",
+      "description": "Evaluate the implementation of the word upload system, including input validation, proper storage mechanism (localStorage, sessionStorage, or other client-side solutions), and integration with the game system. Check if users can upload their own word sets, if the system validates entries (preventing duplicates, empty strings, etc.), and if uploaded words are properly incorporated into the game. Deduct 5 points if validation is missing, 3 points if the storage mechanism is insecure or inefficient.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there a complete game state management system?",
+      "description": "Check whether the code includes proper game state management like tracking matches, score calculation, win/lose conditions, game reset, and saving game progress. Verify if the game properly transitions between states (start screen, gameplay, victory/defeat screens) and maintains game context correctly. Deduct 5 points if score tracking is missing or flawed, 3 points if state transitions are buggy, and 5 points if there's no proper game ending logic.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there an effective timer and scoring system?",
+      "description": "Assess the implementation of time constraints and scoring mechanics. Check for a visual timer display, score calculation based on match speed/difficulty, and potentially bonus points for consecutive matches. Verify that the scoring system is fair and the timer functions correctly (pausing when necessary, proper countdown visualization). Deduct 5 points for missing timer, 3 points for overly simplistic scoring, and 5 points for timer bugs affecting gameplay.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as incorrect selections, rapid clicking, browser refresh, empty word lists, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Difficulty levels with varying time constraints 2. Visual/audio effects for successful matches 3. Leaderboard system 4. Word categories or themes). 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 scoring systems coexisting) 2. Function modules unrelated to word-matching (e.g., unnecessary animations or widgets) 3. Fancy effects that affect performance (e.g., excessive particles or 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/controller layers), code organization, naming conventions, and maintainability. Deduct 5 points if global variable 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 for complex 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 font system (body font size ≥ 14px, line height over 1.5 times) 4) Responsive design for different screen sizes. 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 selected words 4) Smooth animations for matching and clearing words. Deduct 5 points for each operation without feedback, 3 points for jarring animations or transitions, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "easy"
+}

package/library/game_development-role-playing/character-customization-game-html-javascript.json

@@ -0,0 +1,68 @@
+{
+  "index": 48,
+  "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 whenever possible.\n\nPlease use HTML and JavaScript to implement a character customization game that allows players to customize their character's appearance and abilities. You should provide a user interface that allows players to select different skins, colors, and ability configurations.\n\nInclude comments in your code so other developers can understand your implementation process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the character customization interface fully implemented?",
+      "description": "Review whether the code accurately implements all core customization elements including skin selection, color customization, and ability configuration through HTML/JavaScript. Score 0 if the core interface elements are missing, 5 if only partial customization options are available, and 10 if the interface provides comprehensive character customization with visual previews.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the appearance customization system comprehensive?",
+      "description": "Evaluate the range and depth of appearance customization options. Check for variety in character elements (face, hair, body, clothing, accessories), color selection mechanisms (RGB/HSL pickers, preset palettes), and whether changes are immediately reflected in a preview. Deduct 3 points if fewer than 3 customizable appearance elements are available, 3 points if color customization is limited, and 2 points if there's no real-time preview. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the ability configuration system balanced and interactive?",
+      "description": "Check whether the ability configuration system includes a balanced point allocation mechanism (e.g., limited total points, trade-offs between different abilities), visual representation of character stats, and effect demonstration. Deduct 5 points if there are no constraints on ability allocation, 3 points if visual feedback on abilities is missing, and 2 points if there's no effect preview or explanation. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is persistence and state management properly implemented?",
+      "description": "Evaluate whether the code includes state management to persist customization choices (localStorage/sessionStorage), undo/redo functionality, save/load character presets, and clean state transitions. Deduct 5 points if no persistence mechanism exists, 3 points if state history management is absent, and 2 points if there are no preset management features. 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 under heavy customization, 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. Randomize character feature 2. Social sharing of character designs 3. Animation of character based on ability scores 4. AR/camera integration for custom faces). 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 color pickers with the same functionality) 2. Function modules unrelated to character customization (e.g., an unnecessary minigame) 3. Fancy effects that affect performance (e.g., excessive particle effects). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating UI/logic/data layers), code comments as requested, consistency in naming conventions, and overall architecture. 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 code comments are insufficient or misleading. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (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) Changes to character appearance are instantly reflected (≤ 100ms) 2) Transition animations when switching between customization sections (300-500ms) 3) Clear visual feedback when selecting options. Deduct 5 points for each operation without feedback, 3 points for lagging character preview updates, and 5 points for unintuitive navigation between customization sections. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Role-Playing",
+  "difficulty": "medium"
+}

package/library/game_development-role-playing/character-dialogue-system-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 162,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable for demonstration.\n\nPlease use HTML and JavaScript to implement a character dialogue system game where players can interact with NPCs, obtain information or quests. Set up dialogue boxes and conversation options, and trigger different dialogue content based on the player's choices.\n\nInclude comments in your code so other developers can understand your implementation process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the dialogue system core functionality fully implemented?",
+      "description": "Review whether the code accurately implements a dialogue box system with NPC conversations and player response options. Check if the dialogue content changes based on player choices and if the dialogue flow is properly managed. Score 0 if the core dialogue interaction is not implemented, 5 if only basic dialogue display is implemented without branching, and 10 if the system includes conditional dialogue paths, dialogue history, and proper state management.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the NPC interaction system properly designed?",
+      "description": "Evaluate if the code includes a well-structured NPC system with unique characters having different dialogue options. Check if NPCs can store state (like remembering previous conversations) and if their dialogue changes based on player history or game state. Deduct 5 points if NPCs are just static dialogue dispensers without memory, 3 points if there's no variety in NPC personalities or dialogue styles. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is a quest/information system integrated with the dialogue?",
+      "description": "Check if the system allows NPCs to provide quests or important information through dialogue, with proper tracking mechanisms. Verify if quests can be accepted, tracked, completed, and rewarded through the dialogue system. Deduct 5 points if there's no actual quest functionality tied to dialogue, 3 points if quest states aren't properly tracked or don't affect subsequent dialogue. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the dialogue UI design user-friendly and well-implemented?",
+      "description": "Assess if the dialogue UI is well-designed with clear indication of who's speaking, readable text presentation, obvious player choices, and smooth transitions between dialogue states. Check if the UI adapts to different text lengths and number of options. Deduct 5 points for poor text presentation (too small, bad contrast), 3 points for confusing option selection mechanisms, and 3 points for jarring transitions. 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 unexpected user input, clicking rapidly through dialogue, or skipping conversations) and provide friendly error handling. Code with strong robustness should prevent dialogue state corruption and handle edge cases gracefully, 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. Character portraits that change with emotions 2. Voice/sound effects for dialogue 3. Typewriter text effect 4. Dialogue history/log system 5. Keyword highlighting in important dialogue). Add 2 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar dialogue functions (e.g., multiple text display mechanisms) 2. Function modules unrelated to dialogue (e.g., complex combat systems) 3. Fancy effects that affect readability or usability of dialogue. 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 dialogue data/logic/UI layers), code organization, and proper commenting as specified in the requirements. Deduct 5 points if global state pollution is found or dialogue data is hardcoded throughout; deduct 3 points if the code lacks the requested comments; deduct 5 points if the code duplication rate is too high (over 30%). The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the dialogue UI follows modern design principles: 1) Harmonious color matching for dialogue boxes and character identification 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional typography (body font size ≥ 14px, line height over 1.5 times, proper contrast). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for poor text readability. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects in dialogue conform to human perception characteristics: 1) Response delay when selecting options ≤ 100ms 2) Smooth transitions between dialogue segments 3) Clear visual feedback when making choices. Deduct 5 points for each interaction without feedback, 3 points for jarring transitions between dialogue states, and 5 points for confusing navigation through dialogue options. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Role-Playing",
+  "difficulty": "easy"
+}

package/library/game_development-role-playing/character-leveling-skill-tree-system.json

@@ -0,0 +1,68 @@
+{
+  "index": 2,
+  "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.\nPlease use HTML and JavaScript to implement a character leveling up and skill tree system.\n\n**Task**: Implement a character leveling system where characters can level up by collecting experience points, unlock new skills or enhance attributes.\n\n**Hint**: You can use a simple experience point system and skill tree structure to manage upgrades and skill unlocking.\n\nGame, and add some comments to your code so other developers can understand your implementation process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the character leveling system implemented correctly?",
+      "description": "Review whether the code accurately implements an experience point tracking system, level calculation, and level-up events. Check if the experience requirements for each level follow a logical progression (e.g., logarithmic or exponential growth). Verify if the code handles edge cases like max level cap and experience overflow. Score 0 if the core level system is missing, 5 if only basic leveling is implemented, and 10 if it includes animations, sound effects, and visual feedback for level-up events.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "How well is the skill tree structure designed?",
+      "description": "Evaluate if the skill tree has a logical hierarchical structure with clear dependencies between skills. Check if there are multiple branching paths, prerequisites for skill unlocks, and proper visualization of connections between related skills. Verify if skill nodes store proper metadata (cost, effects, requirements). Deduct 5 points if skills aren't organized in a tree/graph structure, 3 points if there are no skill dependencies/prerequisites, and 2 points if the tree doesn't visually represent relationships between skills. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the skill unlocking mechanism properly implemented?",
+      "description": "Check if the code validates all conditions before unlocking skills (level requirements, skill points, prerequisites). Verify if the system prevents invalid operations like unlocking unavailable skills or spending more points than available. Examine if there's proper state management for locked/unlocked skills and visual indication of available/unavailable skills. Deduct 5 points if prerequisite validation is missing and 5 points if there's no proper error handling for invalid unlock attempts. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are character attributes and their enhancement implemented?",
+      "description": "Assess if the system includes character attributes (like strength, intelligence, etc.) that can be enhanced through leveling or skill points. Check if attribute changes affect character capabilities in meaningful ways. Verify if there are attribute caps or diminishing returns implemented. Deduct 3 points if attributes don't impact gameplay/visuals, 4 points if there's no way to customize attribute distribution, and 3 points if attribute scaling is unbalanced. 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, skill point misallocation, attribute reset requests, 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. Skill preview animations 2. Respec/reset mechanisms with appropriate costs 3. Skill combos for special effects when certain combinations are unlocked). 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 calculate the same attribute bonus) 2. Function modules unrelated to the skill tree system (e.g., an unnecessary inventory system) 3. Fancy effects that affect performance (e.g., excessive particle effects on every skill hover). 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 character data/skill tree logic/UI layers), code organization, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the code lacks proper comments as requested in the requirements. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the skill tree UI 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 when allocating points or unlocking skills 2) Transition animations when unlocking skills or leveling up controlled between 300-500ms 3) Clear visual focus guidance highlighting available skills or next level milestone. Deduct 5 points for each operation without feedback, 3 points for sluggish animations during skill tree navigation, and 5 points for hard-to-find important UI elements like available skill points or level progress. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Role-Playing",
+  "difficulty": "easy"
+}