@getollie/cli 0.0.1

package/library/game_development-puzzle/match-three-puzzle-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1035,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the code you generate is executable for demonstration purposes. Write a program for a match-three puzzle game.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core match-three game logic fully implemented?",
+      "description": "Review whether the code accurately implements the match detection algorithm, board generation with guaranteed matches, piece swapping mechanics, and cascading effects when matches are cleared. Score 0 if the core game logic is missing, 5 if only basic matching is implemented without cascades, and 10 if the game includes proper matching, cascading, and board refilling mechanics.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the game board rendering and user interaction properly implemented?",
+      "description": "Evaluate whether the game board is correctly rendered with a grid system, pieces have distinct visual appearances, and user interactions (selection, swapping) are intuitive and responsive. Check for proper highlighting of selected pieces and visual feedback for valid/invalid moves. Deduct 3 points if selection feedback is missing, 3 points if swap animations are absent, and 4 points if the board rendering has alignment issues.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are game mechanics like scoring system and level progression implemented?",
+      "description": "Check if the game includes a scoring system that rewards larger matches and cascades, tracks player progress, implements level difficulty progression (increasing targets, decreasing moves/time), and provides clear win/lose conditions. Score 0 if scoring is absent, 5 if basic scoring exists without progression, and 10 if full scoring with level progression is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are special game elements and power-ups included?",
+      "description": "Assess whether the game includes special pieces created from larger matches (4+ pieces), power-ups with unique effects (row/column clearers, bombs, etc.), and obstacle tiles that add strategic depth. Score 3 points for basic special pieces, 3 points for power-up implementation, and 4 points for strategic obstacle integration.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle edge cases such as no possible matches, invalid moves, rapid user inputs, and browser resizing. Code with strong robustness should gracefully recover from these scenarios, providing board reshuffling when no matches are possible and blocking input during animations. Give 10 points for comprehensive edge case handling, 5 points for basic error prevention, and 0 points if critical edge cases are unhandled.",
+      "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. Unique match patterns beyond straight lines 2. Physics-based falling animations 3. Theme customization options 4. Accessibility features like colorblind 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 ways to detect matches) 2. Function modules unrelated to match-three gameplay (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive particle effects that slow down gameplay). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game logic/view/input handling), proper object-oriented or component-based architecture, and performance optimization techniques. Deduct 5 points if global state pollution is found; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if no performance considerations exist for large board sizes. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern game UI principles: 1) Harmonious color palette that enhances gem visibility 2) Clear visual hierarchy with emphasized game elements 3) Consistent style for UI components (buttons, panels, score displays). Deduct 3 points for poor color contrast between pieces, 5 points for cluttered UI, and 3 points for inconsistent button styling or poorly readable text. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the game animations follow satisfying principles: 1) Piece swapping completes within 200-300ms 2) Match clearing and cascading have sequential timing with proper pacing 3) Smooth transitions between game states (level start/end, special effects). Deduct 4 points for jerky animations, 3 points for overlapping animations that cause visual confusion, and 3 points for missing transition effects between game states. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "medium"
+}

package/library/game_development-puzzle/matching-game-lianliankan-html-small-animals.json

@@ -0,0 +1,68 @@
+{
+  "index": 1825,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Be sure to make the generated code executable for demonstration. Write a matching game (Lianliankan) using HTML language, displaying small animals.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core matching game (Lianliankan) logic fully implemented?",
+      "description": "Review whether the code accurately implements the matching logic where players connect identical animal tiles that can be linked by a line with at most two turns. Check if the code includes validation for matching pairs, path-finding algorithm, and scoring mechanism. Score 0 if the core matching logic is not implemented, 5 if only basic pair validation exists without path-finding, and 10 if complete matching rules with proper path visualization are implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are animal graphics properly implemented and displayed?",
+      "description": "Evaluate whether the game uses proper animal graphics (at least 6 different animal types), with consistent style and clear visibility. Check if images are preloaded to prevent flickering during gameplay. Deduct 3 points if fewer than 6 animal types are used, 4 points if images have inconsistent sizes or styles, and 5 points if images fail to load properly. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the game board generation and layout properly implemented?",
+      "description": "Check if the code generates a balanced game board with proper randomization that ensures all pairs can be matched. Verify that the board layout is responsive and properly aligned. Deduct 5 points if the board generation doesn't ensure solvability, 3 points if the layout is fixed and not responsive, and 2 points if the tile arrangement is visually confusing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there proper game state management and progression?",
+      "description": "Evaluate if the game includes proper state management (start, play, win/lose conditions), timer functionality, scoring system, and level progression. Deduct 3 points if win/lose conditions aren't properly detected, 3 points if there's no timer or scoring system, and 4 points if the game lacks level progression or difficulty adjustment. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid clicking, clicking already matched tiles, invalid connections) and provide friendly error handling or recovery mechanisms. Code with strong robustness should prevent game-breaking behaviors and handle edge cases effectively, giving 10 points. If the robustness is average, give 5 points, and if no exception handling exists, 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 that helps players find matches 2. Special effects for successful matches 3. Combo system for consecutive quick matches 4. Different difficulty 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 reset the game) 2. Function modules unrelated to the matching game (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive animations that slow down gameplay). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game logic/view/controller layers), code organization, and readability. Deduct 5 points if global variables are excessively used or if there's no separation of concerns; deduct 5 points if the code duplication rate is too high (over 30%); deduct 3 points if the code lacks proper comments or documentation. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (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 for matching animations 3) Clear visual indication of selected tiles and valid/invalid matches. Deduct 5 points for each operation without feedback, 3 points for animations that are too slow or jerky, and 5 points for unclear selection indicators. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "easy"
+}

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

@@ -0,0 +1,68 @@
+{
+  "index": 1821,
+  "question": "You are a coding expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code for demonstration purposes. Write a Minesweeper game using HTML code.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core Minesweeper game mechanics fully implemented?",
+      "description": "Check if the code correctly implements mine placement, cell revealing logic, and win/loss detection. The game should generate random mine positions, calculate adjacent mine counts, handle recursive revealing of empty cells, and detect game completion conditions. Score 0 if core game mechanics are missing, 5 if basic functionality works but with flaws, 10 if completely implemented according to traditional Minesweeper rules.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the game board dynamically generated with configurable difficulty levels?",
+      "description": "Evaluate if the code allows for different board sizes (beginner: 9x9 with 10 mines, intermediate: 16x16 with 40 mines, expert: 30x16 with 99 mines) and proper mine density. The board should be generated programmatically, not hardcoded. Deduct 5 points if only one difficulty level is implemented, 3 points if the mine distribution algorithm has clustering issues, and 2 points if board size isn't responsive to window size.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are all user interactions properly handled?",
+      "description": "Check if the game properly handles left-click (reveal cell), right-click (flag/mark mine), and potentially middle-click (chord) operations. Timer functionality should start on first click, and the first click should never be a mine. Award 10 points if all standard Minesweeper interactions are implemented, 5 points if basic interactions work but with limitations, 0 points if interactions are broken or inconsistent.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a functional game state management system?",
+      "description": "Evaluate if the game tracks and manages states properly (new game, in-progress, won, lost) with appropriate UI indicators. Check if the game includes a counter for remaining mines/flags, a timer, and a way to restart the game. Deduct 3 points if state transitions are buggy, 3 points if game statistics aren't displayed, and 4 points if there's no game reset functionality.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle edge cases (such as rapid clicking, right-clicking already revealed cells, resizing the window, etc.) and prevent common bugs like accidental page navigation on right-click. 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. Save/load game state 2. Custom themes or color schemes 3. Animation effects for explosions or victories 4. Hint system or undo functionality). 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 event handlers that could cause memory leaks 2. Unnecessary DOM manipulation that could be handled more efficiently 3. Fancy effects that affect performance without enhancing 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, and event handling), code organization, and maintainability. Check for proper use of constants, meaningful variable names, and appropriate comments. Deduct 5 points if global scope is polluted with variables, 3 points if there's significant code duplication, and 2 points if the HTML structure is not semantic. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the game UI follows classic Minesweeper aesthetics while maintaining modern design principles: 1) Clear visual distinction between revealed/unrevealed cells 2) Proper color coding for numbers 3) Proportional grid sizing and readable font. Deduct 3 points for poor cell spacing, 4 points for unclear number colors, and 3 points for inconsistent styling. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the game provides immediate visual feedback for user actions: 1) Cell reveal animations under 100ms 2) Clear visual indication of flagged cells and revealed numbers 3) Distinct game over state visualization. Deduct 3 points for laggy cell reveals, 3 points for unclear flagging indicators, and 4 points for abrupt or jarring game over presentation. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "medium"
+}

package/library/game_development-puzzle/minesweeper-game-implementation.json

@@ -0,0 +1,68 @@
+{
+  "index": 1006,
+  "question": "You are a coding expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you provide is executable for demonstration. Help me write the code to create a Minesweeper game.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core Minesweeper game mechanics fully implemented?",
+      "description": "Check if the code implements all essential Minesweeper game mechanics: random mine placement, number calculation for adjacent cells, revealing cells with cascading effect for empty cells, and flagging suspected mines. Score 0 if core mechanics are missing, 5 if basic mine detection works but cascading reveals are absent, and 10 if all standard Minesweeper mechanics are properly implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the game board generation and initialization complete?",
+      "description": "Evaluate whether the code correctly generates a customizable game board with appropriate difficulty levels (at least Beginner 9x9 with 10 mines, Intermediate 16x16 with 40 mines, Expert 16x30 with 99 mines). Check if mines are randomly distributed and numbers correctly calculated. Deduct 5 points if only one difficulty level is implemented, 3 points if board sizes aren't customizable, and 3 points if mine distribution isn't truly random. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are win and loss conditions properly implemented?",
+      "description": "Verify if the game correctly detects win conditions (all non-mine cells revealed) and loss conditions (mine clicked). Check if the game reveals all mines upon loss and prevents further interaction. Ensure proper game state management for restart functionality. Deduct 5 points if win detection is faulty, 5 points if loss handling is incomplete, and 3 points if restart functionality is missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a functional timer and mine counter?",
+      "description": "Assess whether the game includes a working timer that starts on first click and stops on game end, and a mine counter that tracks remaining unflagged mines. The timer should count seconds accurately, and the counter should update with each flag placement/removal. Deduct 5 points if the timer is missing/non-functional, 3 points if the mine counter doesn't update correctly, and 2 points if visual display is unclear. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid clicking, right-click on revealed cells, browser resizing, 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. First-click safety guarantee 2. Custom themes or skins 3. Save/load game state 4. Intelligent hint system). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to restart the game) 2. Function modules unrelated to Minesweeper (e.g., a built-in calculator) 3. Fancy effects that affect performance (e.g., excessive animations when revealing cells). 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/event handling), 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 comments or documentation. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows classic Minesweeper aesthetics while maintaining modern UI principles: 1) Clear visual distinction between revealed/unrevealed cells 2) Proper color coding for numbers (1=blue, 2=green, 3=red, etc.) 3) Professional font system and clean grid layout. Deduct 3 points for unclear cell states, 5 points for non-standard number coloring, and 5 points for misaligned or inconsistent grid cells. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the game interactions feel responsive and intuitive: 1) Left-click reveals cells instantly 2) Right-click cycles between unmarked, flagged, and question mark states 3) Double-click reveals surrounding cells when requirements are met. Deduct 5 points for delayed click responses, 3 points for unintuitive controls without instructions, and 5 points if the chording feature (clicking both mouse buttons) is missing. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "easy"
+}

package/library/game_development-puzzle/minesweeper-game-with-home-demo-tabs.json

@@ -0,0 +1,68 @@
+{
+  "index": 1754,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the generated code is executable for display. Create a complete Minesweeper game and save it in two navigation tabs, namely \"Home\" and \"Demo\", to facilitate future maintenance.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Minesweeper core gameplay fully implemented?",
+      "description": "Review whether the code accurately implements the Minesweeper game mechanics including mine placement, cell revealing logic, adjacent mine counting, and win/loss detection. Score 0 if the core interaction logic is not implemented, 5 if only basic cell revealing is implemented without proper win/loss conditions, and 10 if all standard Minesweeper rules are fully included with proper flagging functionality.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the game board generation algorithm properly implemented?",
+      "description": "Evaluate whether the mine placement algorithm ensures fair distribution (not clustering excessively) and guarantees the first click is always safe. Check if the algorithm initializes the board only after the first click to prevent unfair game starts. Deduct 5 points if mines can appear on first click, 3 points if distribution is too clustered, and 3 points if board size options are missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the game difficulty levels and customization options implemented?",
+      "description": "Check whether the code includes at least three standard difficulty levels (Beginner: 9×9 with 10 mines, Intermediate: 16×16 with 40 mines, Expert: 30×16 with 99 mines) and an option for custom board size and mine count. Deduct 4 points for each missing difficulty level, and 5 points if custom options aren't available. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the navigation system between Home and Demo tabs properly implemented?",
+      "description": "Verify that the code implements proper navigation between the Home and Demo tabs without page reloads (using client-side rendering), maintaining game state when switching tabs, and providing clear visual indicators for the active tab. Deduct 5 points if navigation causes game reset, 3 points if tab indicators are unclear, and 5 points if navigation doesn't work correctly. 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 user inputs, rapid clicking, right-click menu prevention, 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. Timer and high score system 2. Themes or visual customization 3. Game state saving/loading 4. Animated reveals). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to reset the game) 2. Function modules unrelated to Minesweeper (e.g., a built-in calculator) 3. Fancy effects that affect performance (e.g., excessive animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game logic/view/state management layers), function encapsulation, and code organization. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there are no comments 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). 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) Cell revealing animations are quick but visible 3) Clear visual feedback for flagging and game outcome. Deduct 5 points for each operation without feedback, 3 points for laggy animations during rapid cell reveals, and 5 points for confusing state indicators (unclear if a cell is flagged or revealed). The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "easy"
+}

package/library/game_development-puzzle/minesweeper-mini-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1071,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Be sure to ensure that the generated code is executable for demonstration purposes. Create a minesweeper-like mini-game for me.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core game mechanic fully implemented?",
+      "description": "Evaluate whether the code accurately implements the fundamental minesweeper game mechanics: grid generation, mine placement, cell revealing, flag placement, and win/loss conditions. Score 0 if these core mechanics are missing, 5 if basic functionality is implemented but with issues, and 10 if all features work correctly with proper game state management.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the mine generation algorithm well-designed?",
+      "description": "Check if the algorithm randomly distributes mines across the board while ensuring the first click is never a mine (industry standard). Evaluate if the density distribution is appropriate and configurable. Deduct 5 points if the first click can be a mine, 3 points if the mine distribution is noticeably uneven or predictable, and 2 points if mine density isn't configurable.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the adjacent mine counting system correctly implemented?",
+      "description": "Review the implementation of the neighbor counting algorithm that displays numbers in revealed cells. Test edge cases like corners and borders. The algorithm should efficiently calculate adjacent mines without redundant calculations. Score 10 points for an optimized implementation that works in all cases, 5 points for functional but inefficient code, and 0 points for incorrect calculations.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the flood fill reveal system work properly?",
+      "description": "Evaluate the implementation of the flood fill algorithm that automatically reveals adjacent empty cells when an empty cell is clicked. Check for proper recursion limits, handling of grid boundaries, and performance with large open areas. Deduct 5 points for stack overflow risks, 3 points for inefficient implementation (O(n²) or worse), and 2 points for improper boundary handling.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid inputs, rapid consecutive clicks, browser resize events) 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. Custom difficulty settings 2. Timer and high score system 3. Animated reveals 4. Hint system 5. Undo functionality). 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 board generation algorithms) 2. Function modules unrelated to minesweeper (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 (such as separating game logic/view/controller 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 3 points if naming conventions are inconsistent or unclear. 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) Clean and consistent grid visualization 2) Clear distinction between revealed/unrevealed cells and flagged mines 3) Proper spacing and sizing for easy interaction on different devices. Deduct 3 points for inconsistent cell styling, 5 points for poor visual hierarchy making game state unclear, and 5 points for elements that are too small for comfortable interaction. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Immediate feedback on cell clicks 2) Clear distinction between left-click (reveal) and right-click (flag) actions 3) Visual indication of game state (playing/won/lost). Deduct 5 points for delayed click responses, 3 points for confusing interactions, and 5 points for lack of visual feedback when the game ends. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "easy"
+}

package/library/game_development-puzzle/mobile-tetris-game-development.json

@@ -0,0 +1,68 @@
+{
+  "index": 1142,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Make sure the code you produce is executable for demonstration. Create a Tetris game that can run locally on a mobile device.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core Tetris game logic fully implemented?",
+      "description": "Evaluate whether the code includes all essential Tetris mechanics: piece rotation, movement, collision detection, line clearing, and scoring. Check if the game implements standard Tetris rules (7 tetromino types, proper rotation behavior including wall kicks, ghost pieces). Score 0 if fundamental game mechanics are missing, 5 if basic movement and collision are implemented but with flaws, 10 if all standard Tetris mechanics are properly implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the mobile-specific implementation adequate?",
+      "description": "Assess if the game is properly optimized for mobile devices: responsive design that adapts to different screen sizes, touch controls (swipe gestures for movement/rotation, tap for hard drop), appropriate button sizing (≥44px), and proper viewport settings. Deduct 5 points if touch controls are missing or poorly implemented, 3 points if the UI doesn't adapt well to different mobile screen sizes. Full score requires implementation of device orientation changes and proper handling of touch events.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is local data persistence implemented?",
+      "description": "Check if the game can save high scores, game state (for resuming interrupted games), and user preferences locally on the device using appropriate technologies (localStorage, IndexedDB, etc.). Verify that the game handles application lifecycle events (page visibility changes, browser closing) to properly save state. Deduct 5 points if game state isn't saved during interruptions, 3 points if high scores aren't persistent. Full score requires complete offline functionality with local data persistence.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the mobile performance optimized?",
+      "description": "Evaluate if the game runs smoothly on mobile devices: maintains 60fps, optimizes rendering (canvas vs DOM), minimizes layout thrashing, implements efficient collision detection, and handles touch events without lag. Check for battery usage optimization techniques like requestAnimationFrame. Deduct 5 points if frame rate drops are noticeable, 5 points if the game consumes excessive battery power. Full score requires stable performance across multiple device types.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as incorrect user input, device orientation changes, browser compatibility issues, memory constraints) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Multiple game modes like marathon/sprint/ultra 2. Custom themes or skins 3. Haptic feedback on mobile 4. Social media score sharing). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple collision detection algorithms) 2. Function modules unrelated to Tetris gameplay (e.g., unnecessary social features) 3. Fancy effects that affect performance (e.g., excessive animations that slow down gameplay). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game logic/view/input handling layers), code organization, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no clear separation between game logic and rendering. 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 (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Touch-friendly controls (minimum tap target of 44px) 4) Clear game area with appropriate contrast. Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for inaccessible controls. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and responsive?",
+      "description": "Judge whether the game controls respond appropriately to touch input: 1) Touch response delay ≤ 100ms 2) Smooth piece movement and rotation without visual lag 3) Clear visual and possibly haptic feedback for actions. Deduct 5 points for input lag over 100ms, 3 points for jerky animations, and 5 points for unclear or missing visual feedback. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "hard"
+}

package/library/game_development-puzzle/mobile-tetris-game-with-instructions.json

@@ -0,0 +1,68 @@
+{
+  "index": 1252,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable when possible. Help me create a Tetris game code that can be played on mobile devices, along with detailed usage instructions.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core Tetris game mechanics fully implemented?",
+      "description": "Review whether the code accurately implements standard Tetris mechanics including: tetromino generation (all 7 shapes), rotation system (preferably SRS), collision detection, line clearing, and scoring system. Score 0 if the core game logic is missing, 5 if basic mechanics are implemented but with flaws, 10 if all standard mechanics are properly implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is mobile responsiveness properly implemented?",
+      "description": "Evaluate if the game adapts to different screen sizes and orientations on mobile devices. Check for viewport meta tags, responsive CSS (using media queries, relative units, or flexible layouts), and touch-friendly UI elements. Deduct 5 points if the game doesn't resize properly on different devices, 3 points if touch targets are smaller than 44px×44px. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are mobile-specific touch controls implemented?",
+      "description": "Assess the implementation of touch controls for mobile gameplay: swipe gestures (left/right for movement, down for soft drop, up for hard drop), tap controls for rotation, and possibly shake for hold/swap function. Check if controls are customizable and have visual indicators. Deduct 5 points if basic touch controls are missing, 3 points if there's no visual feedback for touch interactions. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are the usage instructions comprehensive and clear?",
+      "description": "Review whether detailed usage instructions are provided, including: game controls explanation, scoring system details, special features description, and mobile-specific instructions (e.g., device orientation recommendations, touch gesture guides). Instructions should be accessible from within the game. Deduct 3 points for each major omission. 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 browser back navigation, screen rotation, incoming calls/notifications, device sleep/wake cycles) 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 tetromino themes 2. Progressive difficulty levels 3. Challenge modes beyond classic Tetris 4. Haptic feedback for mobile 5. Local high score system). 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 ways to handle the same input) 2. Function modules unrelated to Tetris gameplay (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive particle effects that cause lag on mobile). 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/input handling layers), code readability, performance optimization for mobile, and offline capability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code is not optimized for mobile performance; deduct 5 points if the game can't be played without an internet connection. 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 (no more than 3 primary colors) 2) Proper layout spacing (game board clearly visible without scrolling) 3) Touch-friendly UI with elements sized appropriately for fingers 4) Clear game status indicators (score, level, next piece). Deduct 3 points for each poorly designed element, 5 points for cluttered interface, and 5 points for poor visibility of game elements. 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 mobile interaction standards: 1) Touch response delay ≤ 100ms 2) Smooth tetromino movement at minimum 30fps 3) Clear visual feedback for all interactions 4) Game state persistence when app is minimized. Deduct 5 points for laggy animations, 3 points for missed touch inputs, 5 points for game reset on browser refresh or app minimization. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Puzzle",
+  "difficulty": "hard"
+}