@getollie/cli 0.0.4 → 0.2.0

package/library/game_development-puzzle/wechat-tetris-game-code.json

@@ -1,68 +0,0 @@
-{
-  "index": 1077,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure that the code you provide is executable and can be demonstrated. Help me design a Tetris game code that can run directly in WeChat.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core Tetris gameplay mechanism fully implemented?",
-      "description": "Review whether the code implements the complete Tetris game logic including random block generation, rotation, movement, collision detection, and line clearing. Score 0 if core gameplay is missing, 5 if basic movement is implemented but with defects, and 10 if all standard Tetris mechanics are properly implemented including wall kicks and SRS rotation system.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the game properly optimized for WeChat Mini Program environment?",
-      "description": "Check if the code follows WeChat Mini Program development standards, uses appropriate APIs (wx.createCanvas, wx.createInnerAudioContext, etc.), and conforms to package size limitations (<2MB). Deduct 5 points if using incompatible libraries, 3 points if not using WeChat's lifecycle properly, and 2 points if not handling touch events correctly. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is mobile-specific control properly implemented for touch devices?",
-      "description": "Evaluate whether the game implements intuitive touch controls (swipe gestures, tap areas) specifically designed for mobile interaction. Check if controls are responsive (<100ms latency), have proper hitbox sizes (≥44px), and include visual feedback. Deduct 5 points for desktop-only controls, 3 points for unresponsive touch areas. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Does the game implement appropriate score and difficulty progression?",
-      "description": "Check if the code implements Tetris scoring system (single/double/triple/tetris line clears), increasing difficulty (speed levels), and proper game progression management. Deduct 5 points if scoring is absent, 3 points if difficulty doesn't increase, and 5 points if there's no game over condition or restart mechanism. 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 focus loss, WeChat app switching, memory limitations, unexpected user input) and provide friendly error handling or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Ghost piece preview 2. Hold piece function 3. Next pieces queue preview 4. WeChat friend leaderboards 5. Custom themes). Add 2 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple game loop systems) 2. Function modules unrelated to Tetris gameplay (e.g., irrelevant mini-games) 3. Fancy effects that affect performance (e.g., excessive particle 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 (separation of game logic/rendering/input handling), code organization, and WeChat Mini Program best practices. 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 not using appropriate framework features like Component behaviors. 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 mobile game design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout for portrait mode (elements properly scaled and positioned) 3) Respects different screen sizes (uses relative positioning/flex layouts). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for layouts that break on different devices. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the game performance and animations conform to mobile gaming standards: 1) Consistent 60fps framerate 2) Piece movement/rotation animations complete within 100ms 3) Line clear animations between 300-500ms 4) No input lag on controls. Deduct 5 points for frequent framerate drops, 3 points for jerky animations, and 5 points for delayed input response. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "hard"
-}

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

@@ -1,68 +0,0 @@
-{
-  "index": 716,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate can be executed and displayed properly. Help me write code for a Tetris game that can be played on WeChat.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core Tetris game mechanics fully implemented?",
-      "description": "Review if the code accurately implements all essential Tetris mechanics: block rotation, movement, collision detection, line clearing, and scoring. The implementation should handle the seven standard Tetrimino shapes with proper rotation states. Score 0 if the core game logic is missing, 5 if only basic movement is implemented, and 10 if all standard Tetris rules (including wall kicks, hard/soft drops) are correctly implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the WeChat Mini Program integration properly implemented?",
-      "description": "Check if the code follows WeChat Mini Program development standards and utilizes the appropriate WeChat APIs (wx.* namespace). The implementation should use the correct project structure (app.js, pages structure, etc.), configuration files (app.json, project.config.json), and lifecycle methods. Deduct 5 points if the code doesn't use WeChat's rendering context properly, 3 points if it doesn't handle device adaptation, and 5 points if essential Mini Program files are missing.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is touch-based mobile control implemented effectively?",
-      "description": "Evaluate whether the game implements intuitive touch controls suitable for mobile devices, including swipe gestures for movement, tap for rotation, and potentially accelerometer integration. The implementation should be responsive (< 100ms latency) and include visual feedback for touch interactions. Deduct 5 points if touch zones are too small for comfortable play, 3 points if gestures are unintuitive, and 5 points if alternative control schemes are not provided.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Does the game implement WeChat social features?",
-      "description": "Check whether the code integrates WeChat social capabilities such as sharing game results, competing with friends, or maintaining a leaderboard using WeChat Open Data API. The implementation should allow score comparison, challenge invitations, or gameplay sharing. Deduct 3 points for each missing social feature (maximum 10 points deduction) that would enhance the WeChat gameplay experience.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as out-of-bounds input, network interruption, user operation errors, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Customizable Tetrimino themes/skins 2. Power-ups or special items 3. Alternative game modes like time attack or puzzle mode). 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 game loop implementations) 2. Function modules unrelated to Tetris or WeChat integration 3. Fancy effects that affect performance on mobile devices (e.g., excessive particle effects). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/view/controller layers), appropriate use of WeChat Mini Program best practices, and optimization for mobile performance. Deduct 5 points if global state is poorly managed; deduct 5 points if code reuse opportunities are missed (DRY principle violations); deduct 5 points if the code doesn't optimize for WeChat's rendering pipeline. 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 mobile design principles: 1) Harmonious color matching suitable for extended gameplay 2) Proper layout optimized for portrait orientation and various screen sizes 3) Professional font system with adequate size for mobile viewing (minimum touch target size of 44×44 points). Deduct 3 points for each hard-to-read UI element, 5 points for poor screen space utilization, and 5 points for designs that don't follow WeChat's visual language. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the game performs smoothly on mobile devices: 1) Consistent frame rate (minimum 30 FPS) 2) Responsive controls with clear visual feedback 3) Smooth animations for block movement and line clearing. Deduct 5 points for noticeable frame drops during gameplay, 3 points for laggy touch response, and 5 points for jarring or missing transition animations. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "hard"
-}

package/library/game_development-puzzle/wechat-tetris-mini-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 1348,
-  "question": "You are a coding expert. Please use your professional knowledge to generate accurate and expert responses. Make sure the code you provide is executable. Rewrite a Tetris mini-game for WeChat, with all detailed steps clearly explained.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Tetris core game logic fully implemented?",
-      "description": "Review whether the code accurately implements the Tetris game mechanics through HTML/JavaScript, including 7 standard Tetromino pieces (I, O, T, S, Z, J, L), piece rotation system, line clearing logic, and collision detection. Score 0 if core game mechanics are missing, 5 if only basic piece movement is implemented, and 10 if all standard Tetris rules including T-spin detection and proper rotation systems are fully included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is WeChat Mini Program integration properly implemented?",
-      "description": "Check whether the code follows WeChat Mini Program development standards, including proper use of WXML/WXSS/JavaScript structure, WeChat API integration for features like sharing scores, and compliance with WeChat's performance guidelines. Deduct 5 points if not using proper WeChat component lifecycle methods, and 3 points if missing WeChat-specific optimizations like canvas performance tuning. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the game state management and persistence mechanism designed?",
-      "description": "Evaluate whether the game implements proper state management including score tracking, level progression, high score persistence using WeChat's local storage, and pause/resume functionality. Two-way verification of game state consistency is required. Deduct 5 points if game state can be corrupted during interruptions. Check whether game progress can be saved and restored when users switch between apps. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the complete game experience and social features constructed?",
-      "description": "Check whether the code includes complete Tetris experience features like increasing speed levels, preview of next pieces, hold functionality, and WeChat social integration such as leaderboards and score sharing. Deduct 5 points if standard Tetris preview/hold mechanics are not implemented, and 3 points if WeChat sharing capabilities are missing. Give 10 points if fully implemented with smooth social integration.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid key presses, app backgrounding, memory limitations, network interruptions, and user operation errors) 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 Tetris experience (e.g., 1. Special effects for T-spins and Tetris clears 2. Achievement system integrated with WeChat 3. Ghost piece preview 4. Customizable themes 5. Vibration feedback for line clears). 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 Tetris gameplay (e.g., built-in chat system) 3. Fancy effects that affect game performance (e.g., excessive particle systems during line clears). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core Tetris gameplay is interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating game logic/rendering/input handling), WeChat Mini Program best practices compliance, and code organization. Deduct 5 points if global state pollution is found or improper WeChat component usage; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if not following WeChat Mini Program performance optimization guidelines. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the Tetris interface follows modern mobile game design principles: 1) Clear game board visibility with proper contrast 2) Intuitive control layout optimized for mobile touch 3) Consistent visual hierarchy for game info (score, level, next piece) 4) Professional color scheme that doesn't strain eyes during long play sessions. Deduct 3 points for each cramped UI element, 5 points for poor contrast affecting gameplay visibility, and 5 points for confusing control layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the game interaction smooth and responsive?",
-      "description": "Judge whether the game controls and animations conform to mobile gaming standards: 1) Touch response delay ≤ 50ms for critical game actions 2) Smooth piece movement at 60fps 3) Proper tactile feedback for WeChat platform 4) Intuitive gesture controls (tap to rotate, swipe to move/drop). Deduct 5 points for each laggy control response, 3 points for choppy animations during fast gameplay, and 5 points for unintuitive control scheme. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Puzzle",
-  "difficulty": "hard"
-}

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

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

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

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

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

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