@getollie/cli 0.0.1

package/library/data_science-statistical_analysis/stock-selection-yearly-moving-average-breakthrough.json

@@ -0,0 +1,68 @@
+{
+  "index": 1221,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional replies. Make sure any code you generate is executable and functional. Help me write a small stock selection program with the condition: stocks that have broken through their yearly moving average within the last 7 days.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the stock data source integration properly implemented?",
+      "description": "Check if the code includes reliable API connections (Yahoo Finance, Alpha Vantage, etc.) with proper error handling. Verify if the data fetching includes necessary authentication, rate limiting management, and handling of network failures. Score 0 if no data source is specified, 5 if basic APIs are used without error handling, 10 if comprehensive data retrieval with fallback mechanisms is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the yearly moving average calculation correct?",
+      "description": "Verify the yearly moving average calculation methodology (standard 250 or 252 trading days). Check if the formula properly handles weekends/holidays and data gaps. Ensure the calculation doesn't suffer from look-ahead bias. Score 0 if calculation is mathematically incorrect, 5 if basic calculation is present but edge cases aren't handled, 10 if implementation is statistically sound.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the breakthrough detection algorithm properly implemented?",
+      "description": "Assess the breakthrough definition - verify if the code checks both price crossing above the moving average and the timing within the 7-day window. Check if the algorithm handles false signals (e.g., requiring confirmation over multiple periods). Deduct 5 points if the algorithm doesn't handle price gaps, and 3 points if it doesn't account for volatility. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the program include adequate screening parameters and filters?",
+      "description": "Evaluate if the program allows filtering by market capitalization, sector, trading volume, or other relevant metrics beyond just the moving average breakthrough. Check if parameters are configurable by users. Score 3 points for each useful filter implemented (volume threshold, sector selection, volatility filter), up to 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as missing data points, API failures, invalid inputs, 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. Visualization of breakthrough patterns 2. Historical backtest capabilities 3. Alert system for new breakthroughs 4. Integration with fundamental data). 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 screening methods 2. Function modules unrelated to stock selection 3. Computationally expensive operations that don't contribute to the core functionality. 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 data retrieval/analysis/presentation 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 for stock charts (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) Data refresh/update delay ≤ 500ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus on breakthrough stocks. Deduct 5 points for each operation without feedback, 3 points for visual after-images during rapid data updates, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Data Science-Statistical Analysis",
+  "difficulty": "medium"
+}

package/library/data_science-statistical_analysis/web-page-compare-number-frequency-shuffle-reorder.json

@@ -0,0 +1,68 @@
+{
+  "index": 1805,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate, professional responses. Ensure that the generated code is executable for display. Help me write a web page code that can compare multiple sets of numbers, list the frequency of each number in order with color markers, and include a function to shuffle the numbers and then reorder them.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the number comparison system fully implemented?",
+      "description": "Evaluate whether the code provides a complete mechanism to input and compare multiple sets of numbers. Check if it allows users to input/define multiple datasets or import data from external sources. Score 0 if comparison functionality is missing, 5 if basic comparison is implemented but with limitations, and 10 if the system handles arbitrary numbers of datasets with proper validation.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the frequency calculation and ordering function implemented correctly?",
+      "description": "Examine the algorithm that calculates the frequency of each number and orders them. Verify the algorithm's correctness through edge cases (empty arrays, duplicate values, very large/small numbers). Deduct 3 points if the frequency calculation is incorrect, 4 points if ordering doesn't work properly, and 3 points if edge cases aren't handled. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are color markers implemented effectively for visual representation?",
+      "description": "Assess the color marker implementation for representing frequencies. Evaluate whether the color scheme is visually informative (e.g., heat map style), accessible (sufficient contrast ratio ≥4.5:1), and properly conveys data intensity. Deduct 5 points if colors don't correlate with frequency values, 3 points if the color scheme is confusing or inaccessible, and 2 points if there's no legend explaining the color mapping. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the shuffle and reorder functionality implemented effectively?",
+      "description": "Review the shuffle algorithm implementation (preferably Fisher-Yates or equivalent) and the reordering mechanism. Verify that shuffling is truly random and the reordering process works consistently. Check for animation transitions between states. Deduct 4 points for biased shuffle algorithms, 3 points for inconsistent reordering, and 3 points if there's no visual feedback during state transitions. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as non-numeric inputs, extremely large datasets, 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 experience (e.g., 1. Interactive visualization options 2. Data export/import capabilities 3. Statistical analysis of number patterns). 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 sorting algorithms) 2. Function modules unrelated to number comparison (e.g., unrelated data visualization) 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 logic/view layers), code organization, and performance optimization. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there are no performance considerations for large datasets. 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 plus their shades) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance. Deduct 5 points for each operation without feedback, 3 points for visual lag during data reordering, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Data Science-Statistical Analysis",
+  "difficulty": "easy"
+}

package/library/game_development-action_rhythm/browser-dinosaur-game-theme.json

@@ -0,0 +1,68 @@
+{
+  "index": 1744,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable for demonstration. Create a browser dinosaur game themed game.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core dinosaur game mechanics fully implemented?",
+      "description": "Review whether the code accurately implements the dinosaur character movement (jump/duck), obstacle generation system, and collision detection through HTML/JavaScript. Check if it includes proper physics simulation for jumping arc and gravity effects. Score 0 if core game loop is missing, 5 if only basic jumping is implemented, and 10 if all mechanics including ducking, variable jump height, and accurate collision boundaries are fully included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the progressive difficulty and scoring system implemented?",
+      "description": "Evaluate whether the game includes dynamic speed acceleration, obstacle frequency adjustment, and a comprehensive scoring mechanism. Check if the difficulty curve is well-balanced with proper obstacle spacing and speed ramping. Deduct 5 points if speed doesn't increase over time, 3 points if obstacle generation is static, and 2 points if scoring system lacks milestone rewards. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the game state management and restart functionality properly designed?",
+      "description": "Check whether the code includes complete game state transitions (start/playing/game over/restart), high score persistence using localStorage, and smooth state switching. Evaluate if the restart mechanism properly resets all game variables and maintains score history. Deduct 5 points if game states are not properly managed, 3 points if high scores aren't saved, and 2 points if restart doesn't clean up properly. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the visual rendering and animation system comprehensive?",
+      "description": "Assess whether the code implements smooth sprite animations for the dinosaur (running/jumping/ducking), scrolling background effects, and obstacle animations. Check if the rendering uses efficient techniques like requestAnimationFrame and proper sprite management. Give 10 points if all animations are smooth and optimized, 5 points if basic animations exist but lack polish, and 0 points if animations are choppy or missing. Deduct 3 points for performance issues during rendering.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid key presses, browser tab switching, window resizing, and edge case collisions) and provide appropriate error handling. Code with strong robustness should effectively manage game pause/resume when tab loses focus, handle multiple simultaneous inputs gracefully, and recover from unexpected errors. Give 10 points for comprehensive error handling, 5 points for basic robustness, and 0 points if no exception handling exists.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that enhance gameplay?",
+      "description": "Check whether the code includes engaging features beyond basic gameplay (e.g., 1. Multiple obstacle types with different behaviors 2. Power-ups or special abilities 3. Day/night cycle or weather effects 4. Sound effects and background music 5. Particle effects for actions). Add 2-3 points for each well-implemented innovative feature that adds meaningful gameplay value (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple collision detection systems) 2. Features unrelated to the dinosaur game concept (e.g., built-in chat system) 3. Overly complex visual effects that impact performance (e.g., excessive particle systems). Deduct 3 points for each redundancy found, and directly deduct 10 points if core game performance is significantly impacted by unnecessary features.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (separating game logic/rendering/input handling), code organization with clear class structures, and proper variable naming conventions. Deduct 5 points if global variables are overused or game logic is mixed with rendering; deduct 5 points if code duplication rate exceeds 30%; deduct 3 points if functions are overly long (>50 lines) without proper decomposition. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface design meet modern game UI standards?",
+      "description": "Evaluate whether the visual design follows game UI principles: 1) Cohesive pixel art or modern graphic style 2) Readable score display with appropriate contrast 3) Clear game state indicators (start screen, game over screen) 4) Proper use of colors that don't strain eyes during extended play. Deduct 3 points for each UI element that lacks visual hierarchy, 5 points for poor color choices that affect gameplay visibility, and 5 points for inconsistent art style. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Are the controls responsive and gameplay smooth?",
+      "description": "Judge whether the game controls meet responsive gaming standards: 1) Input response delay ≤ 50ms for jump/duck actions 2) Consistent 60fps performance during gameplay 3) Smooth collision feedback without jarring interruptions 4) Intuitive control scheme (spacebar/arrow keys). Deduct 5 points for each control that feels unresponsive, 3 points for frame rate drops during normal gameplay, and 5 points for unclear visual feedback on player actions. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Action/Rhythm",
+  "difficulty": "medium"
+}

package/library/game_development-action_rhythm/catch-fruit-game-html-javascript.json

@@ -0,0 +1,68 @@
+{
+  "index": 72,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable for demonstration.\n\nPlease implement a \"Catch Fruit\" game using HTML and JavaScript.\n\nTask: Create a fruit-catching game where players need to catch falling fruits within a limited time.\n\nHint: Use timers and collision detection to implement the game logic.\n\nPlease include comments in your code to help other developers understand your implementation process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core game loop fully implemented?",
+      "description": "Review whether the code implements the essential game mechanics through HTML/JavaScript, including fruit generation, gravity simulation for falling objects, player-controlled basket/character movement, and precise collision detection. Score 0 if the core interaction logic is missing, 5 if only basic movement without proper collision detection is implemented, and 10 if the complete game cycle with variable difficulty is included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the timer and scoring system implemented correctly?",
+      "description": "Check if the game includes a functional countdown timer that properly terminates the game, and a scoring system that accurately tracks successful fruit catches. Verify that the score is properly incremented when fruits are caught and that the timer decrements correctly. Deduct 5 points if the timer doesn't end the game, 3 points if score calculation has bugs, and 2 points if there's no visual feedback when points are earned. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are multiple fruit types implemented with varying behaviors?",
+      "description": "Evaluate whether the game features different fruit types with distinct visual appearances, falling speeds, point values, or special effects. Deduct 5 points if only a single fruit type exists, 3 points if fruits look different but behave identically, and 2 points if there's insufficient variety (less than 3 types). Give full 10 points for rich variety with meaningful gameplay differences.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the game difficulty progression properly implemented?",
+      "description": "Assess if the game's difficulty increases over time through mechanisms like faster falling fruits, more fruits appearing simultaneously, or introduction of obstacles/distractions. Check if level progression or wave system is clearly communicated to players. Deduct 5 points if difficulty remains static throughout gameplay, and 3 points if difficulty curve is too steep or unbalanced. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as browser resizing, rapid input changes, performance issues on slower devices, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Special bonus fruits with unique effects 2. Power-ups that modify gameplay 3. Combo system for catching multiple fruits in succession). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple collision detection systems coexisting) 2. Function modules unrelated to fruit catching (e.g., unnecessary minigames) 3. Fancy effects that affect performance (e.g., excessive particle effects). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game entities, physics, rendering, and input handling), code readability, and comprehensive commenting as requested. 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 comments are missing or unhelpful. 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 (clear separation between game area, score display, and timer) 3) Professional font system (readable text size, consistent styling). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Responsive player movement with minimal input lag 2) Smooth animations for falling fruits and catching interactions 3) Clear visual and audio feedback when fruits are caught or missed. Deduct 5 points for each operation without feedback, 3 points for choppy animations during gameplay, and 5 points for unresponsive controls. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Action/Rhythm",
+  "difficulty": "easy"
+}

package/library/game_development-action_rhythm/character-animation-state-switching.json

@@ -0,0 +1,68 @@
+{
+  "index": 69,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable and demonstrable.\n\nPlease use HTML and JavaScript to implement an animation transition: enable character animation switching between different states, such as walking, running, jumping, and other different actions.\n[CHAT_SEP]Please optimize the above game response and add some comments in the code so that other developers can understand your implementation process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the character animation system properly implemented?",
+      "description": "Check if the code implements the core animation system with state management for different character actions (walking, running, jumping). Evaluate the state machine architecture, handling transitions between animation states cleanly. Score 0 if no state transitions exist, 5 if only basic transitions are implemented, and 10 if all specified actions with seamless transitions are included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is sprite sheet or animation framework implementation correct?",
+      "description": "Review the implementation of sprite animation technique (whether using sprite sheets, CSS animations, or canvas-based animation). Check for proper frame sequencing, timing control, and animation loops. Deduct 5 points if animation frames are incorrectly sequenced, 3 points if timing control is inconsistent. Full score requires proper sprite resource management and optimization.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the animation transitions smooth and natural?",
+      "description": "Evaluate the transition logic between different animation states (e.g., walking to running, running to jumping). Check for interpolation techniques, easing functions, and blending between animations. Deduct 5 points for abrupt transitions, 3 points for inconsistent animation speeds. 10 points for natural, realistic transitions that follow physical movement principles.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is user input handling implemented correctly for animation control?",
+      "description": "Examine if the code includes proper event listeners for keyboard/mouse/touch input to trigger different animation states. Check if there's debouncing for rapid input changes and proper handling of simultaneous inputs. Deduct 5 points if input lag exceeds 100ms, 3 points if certain input combinations cause animation glitches. Full score requires responsive and intuitive controls.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code handles edge cases like rapid state transitions, browser compatibility issues, and resource loading failures. Code with strong robustness should implement error boundaries and fallback animations. Deduct 5 points for each unhandled edge case. Give 10 points if all common exceptions are properly managed with graceful fallbacks.",
+      "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. Particle effects during transitions 2. Dynamic camera following 3. Interactive environment reactions to movement). 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 animation loops or duplicate frame calculations 2. Unnecessary rendering cycles that affect performance 3. Overlapping event listeners causing multiple triggers. Deduct 3 points for each redundancy found, and directly deduct 10 points if core animation functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (separating animation logic, rendering, and input handling), code reusability, and performance optimization. Deduct 5 points if animation and business logic are tightly coupled; deduct 5 points if requestAnimationFrame is not properly implemented; deduct 5 points if there's no performance consideration for mobile devices. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the character and animation design follows good visual principles: 1) Consistent art style and proportions 2) Clear silhouette during different actions 3) Appropriate use of color to indicate different states. Deduct 3 points for inconsistent art style, 5 points for unclear visual feedback during state changes, and 5 points for poor contrast against backgrounds. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the animation performance optimized?",
+      "description": "Judge whether the animations run smoothly at 60fps: 1) Proper use of GPU acceleration techniques 2) Efficient DOM manipulation or Canvas drawing 3) Asset preloading and memory management. Deduct 5 points for frame drops below 45fps on standard devices, 3 points for memory leaks during long animation sequences, and 5 points for not implementing any performance optimization techniques. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Action/Rhythm",
+  "difficulty": "easy"
+}

package/library/game_development-action_rhythm/classic-brick-breaking-game-code.json

@@ -0,0 +1,68 @@
+{
+  "index": 1517,
+  "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 whenever possible. The classic brick-breaking game code can be run in a browser.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core brick-breaking gameplay mechanics fully implemented?",
+      "description": "Review whether the code accurately implements essential game elements: paddle control, ball physics, brick collision detection, and score tracking. Score 0 if the core mechanics are missing, 5 if only basic collisions work, and 10 if all expected features (varying brick types, ball physics, proper boundary handling) are present.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Does the game have proper collision detection and physics?",
+      "description": "Evaluate ball physics implementation including angle reflection on paddle hits, proper wall bouncing, and brick collision accuracy. Check for edge cases like corner hits and multi-brick collisions. Deduct 3 points for unrealistic physics, 5 points for major collision bugs. Full score requires smooth, realistic physics with proper acceleration handling.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the game's difficulty progression and level design implemented?",
+      "description": "Check if the code includes multiple levels or difficulty progression (increasing speed, complex brick patterns, special bricks). Examine if there's a proper game loop with level transitions. Award 10 points for comprehensive level systems with increasing challenge, 5 points for basic progression, 0 for single-state gameplay.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are power-ups and special game features implemented?",
+      "description": "Assess the implementation of game-enhancing features like paddle size changes, multi-ball, ball speed modifications, or special brick types. Look for proper visual feedback when acquiring power-ups and their effect timing management. Award 10 points for diverse, well-balanced power-up system, 5 for basic power-ups, 0 if none exist.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid input changes, browser resize, focus loss, etc.) and provide friendly error handling or recovery mechanisms. Code with strong robustness should effectively manage 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. Particle effects on brick destruction 2. Dynamic soundtrack that changes with gameplay 3. Unique themes or visual styles). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple collision detection systems) 2. Function modules unrelated to brick-breaking (e.g., unintegrated mini-games) 3. Fancy effects that affect performance (e.g., excessive particle systems causing lag). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game logic/rendering/input handling), proper use of OOP or functional patterns, and code maintainability. Deduct 5 points if global state is overused or if game loop timing isn't handled properly; deduct 5 points if the code duplication rate is too high; deduct 5 points if there's no separation between game mechanics 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 game visuals follow modern game design principles: 1) Consistent visual style and color palette 2) Clear visual hierarchy and readable UI elements 3) Appropriate use of animation and transitions that don't interfere with gameplay. Deduct 3 points for inconsistent visual elements, 5 points for poor readability or usability issues, and 5 points for visual elements that hinder gameplay. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the game responsive and provides good user feedback?",
+      "description": "Judge whether the game provides appropriate feedback to user actions: 1) Immediate paddle response to input (≤ 50ms) 2) Clear visual and possibly audio feedback on collisions 3) Readable score display and game state indicators. Deduct 5 points for input lag, 3 points for missing collision feedback, and 5 points for unclear game state information. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Action/Rhythm",
+  "difficulty": "medium"
+}

package/library/game_development-action_rhythm/create-dancing-pixel-ponies.json

@@ -0,0 +1,68 @@
+{
+  "index": 1229,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Be sure to provide executable code for demonstration. I'd like to see you create dancing pixel ponies with code.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the dancing pixel pony animation fully implemented?",
+      "description": "Check if the code creates a complete pixel pony character with proper sprite sheet or pixel-by-pixel rendering. The pony should have a distinct outline and recognizable pony features (head, body, legs, tail). Deduct 5 points if the pony shape is unclear, 3 points if proportions are significantly off. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the dancing animation sequence implemented with smooth transitions?",
+      "description": "Evaluate the animation loop that creates the dancing effect. Look for frame-by-frame animation or procedural movement that creates a natural dancing motion (leg movements, body bobbing, etc.). Animations should run at minimum 12fps for smoothness. Score 10 for fluid, natural movement; 5 for basic animation with some jerkiness; 0 if the pony is static or barely moves.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there variety in the dance movements or multiple dance patterns?",
+      "description": "Check whether the code implements multiple dance patterns, transitions between dance moves, or randomized movement variations. Award 10 points for 3+ distinct dance patterns with smooth transitions; 5 points for 1-2 patterns; 0 points if only one repetitive movement exists.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there an interactive element allowing user control or influence?",
+      "description": "Assess if the implementation includes user interaction to control the dancing ponies (e.g., mouse/keyboard input to change dance styles, speed, colors, or trigger special moves). Give 10 points for comprehensive interaction; 5 points for basic controls; 0 points for no interaction.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as browser resizing, performance optimization for different devices, error handling for missing resources). 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. Music synchronization with dance moves 2. Customizable pony colors/accessories 3. Particle effects or environmental elements like disco lights). 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 animation loops or overlapping timers 2. Function modules unrelated to the dancing ponies 3. Excessive visual effects that cause performance issues. 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 animation logic/rendering/user input handling), performance optimization techniques (e.g., requestAnimationFrame usage, canvas vs. DOM manipulation choices), 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 performance considerations are absent. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the visual implementation meet professional design standards?",
+      "description": "Evaluate whether the pony design shows artistic quality: 1) Consistent pixel art style with appropriate resolution 2) Harmonious color palette (no more than 3-4 primary colors unless intentionally colorful) 3) Proper use of animation principles like squash, stretch, anticipation. Deduct 3 points for inconsistent pixel sizing, 5 points for visually jarring color combinations, and 5 points for anatomically impossible animations unless stylistically justified. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the rendering performance optimized and cross-browser compatible?",
+      "description": "Judge whether the implementation is efficient and widely compatible: 1) Maintains 60fps on modern devices 2) Uses appropriate rendering technology (Canvas/WebGL for complex animations, SVG/CSS for simpler ones) 3) Implements fallbacks for different browsers. Deduct 5 points for each noticeable frame drop during animation, 3 points for missing browser compatibility considerations, and 5 points if the animation significantly taxes CPU/GPU on standard devices. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Action/Rhythm",
+  "difficulty": "hard"
+}

package/library/game_development-action_rhythm/crossy-road-game-threejs-implementation.json

@@ -0,0 +1,68 @@
+{
+  "index": 18,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable for demonstration purposes.\n\nPlease implement a Crossy Road game using HTML and JavaScript.\n\n### Gameplay\n- **Movement Control**: Use keyboard or on-screen buttons to control character movement in four directions.\n- **Avoid Obstacles**: Dodge oncoming vehicles and other obstacles.\n\n### Game Features\n- **3D Graphics**: Use the three.js library to create an engaging 3D environment.\n- **Increasing Difficulty**: As the player progresses, the speed and frequency of obstacles increase.\n\n### Game Tips\n- **Predict Routes**: Observe and predict vehicle travel paths to make movement decisions in advance.\n- **Patient Waiting**: When necessary, wait for safe crossing opportunities.\n\n### Summary\n\"Crossy Road with threejs\" is a 3D road-crossing game based on three.js. Players control a small animal, moving quickly and strategically to avoid vehicles with the goal of crossing roads as much as possible. This game provides an exciting gaming experience suitable for players who enjoy testing their reaction speed and strategic planning abilities. Please include some comments in your code to help other developers understand your implementation process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core Crossy Road gameplay mechanics fully implemented?",
+      "description": "Review whether the code accurately implements the essential gameplay mechanics: character movement in four directions, obstacle avoidance, and game progression logic. Check if keyboard controls and optional on-screen buttons are functional.Score 0 if core movement and collision detection are not implemented, 5 if basic movement works but collision is unreliable, 10 if movement is smooth with proper collision detection and game progression logic is complete.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the 3D environment properly created using three.js?",
+      "description": "Evaluate the implementation of 3D graphics using three.js. Check for proper scene setup, camera positioning, lighting, and rendering. Assess whether the 3D environment effectively mimics the Crossy Road aesthetic with proper geometry, materials, and textures.Score 0 if three.js is not implemented or severely broken, 5 if basic 3D rendering works but lacks visual polish or proper camera work, 10 if the 3D environment is well-constructed with appropriate lighting, textures, and camera angles.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the difficulty progression implemented?",
+      "description": "Check whether the game implements increasing difficulty as the player progresses. This should include faster vehicles, more frequent obstacles, or decreased spacing between safe zones. Verify that the difficulty curve is balanced and not overly punishing.Score 0 if no difficulty progression exists, 5 if basic difficulty increase is present but poorly balanced, 10 if well-implemented difficulty scaling that creates appropriate challenge over time.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are the obstacle generation and movement systems effectively implemented?",
+      "description": "Assess the code for vehicle/obstacle generation, movement patterns, and variety. Check if obstacles move at different speeds, come from different directions, and create interesting gameplay scenarios. Evaluate the randomness and predictability balance.Score 0 if obstacles are static or non-existent, 5 if basic movement patterns exist but lack variety, 10 if obstacles have diverse, interesting patterns that create genuine strategic challenges.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid input sequences, browser resizing, focus loss, performance degradation) and provide friendly error prompts or recovery mechanisms. Check for proper event handling and cleanup.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. Character customization 2. Special power-ups 3. Environmental effects like day/night cycles 4. Persistent high scores).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 2. Function modules unrelated to the Crossy Road game 3. Fancy effects that affect performance (e.g., unnecessary particle systems or post-processing).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), code organization, and maintainability. Check for proper use of three.js best practices and game development patterns.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 is difficult to understand or poorly commented despite the requirement. 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 2) Proper UI layout 3) Clean game HUD that doesn't interfere with gameplay visibility. Check if the visual style is consistent with the Crossy Road aesthetic.Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic UI layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the game performance optimized and responsive?",
+      "description": "Judge whether the game runs smoothly: 1) Maintains consistent frame rate (ideally 60fps) 2) Proper memory management 3) Efficient use of three.js features without unnecessary calculations. Check for input responsiveness and game feel.Deduct 5 points for noticeable frame drops during normal gameplay, 3 points for input lag over 100ms, and 5 points for memory leaks or growing performance issues over time. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Action/Rhythm",
+  "difficulty": "medium"
+}