@getollie/cli 0.0.5 → 0.2.1

package/library/simulation___modeling-mathematical_abstraction/graphic-intersection-blending-square-circle.json

@@ -1,68 +0,0 @@
-{
-  "index": 378,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Pay attention to ensuring that the generated code is executable for demonstration. Use Node.js in WebStorm to implement a graphic showing the intersection/blending of a square and a circle.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the geometric representation of both shapes implemented correctly?",
-      "description": "Review whether the code accurately defines and renders both the square and circle with proper parameters (coordinates, dimensions, radius). The square should have consistent side lengths, and the circle should be mathematically accurate. Score 0 if shapes are incorrectly implemented, 5 if basic shapes are drawn but with minor inaccuracies, and 10 if both shapes are perfectly implemented with proper mathematical properties.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the intersection/blending calculation algorithm implemented correctly?",
-      "description": "Check whether the code accurately calculates the intersection between the square and circle using proper mathematical formulas. The intersection should be precisely determined with appropriate geometric calculations (distance checks, boundary evaluations). Deduct 5 points if the algorithm only approximates the intersection, 3 points if edge cases aren't handled (e.g., tangent points, complete overlap). The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the visual representation of the intersection/blending rendered properly?",
-      "description": "Evaluate how the intersection/blending is visually displayed. The overlapping area should be clearly distinguishable from the non-overlapping parts with appropriate visual treatment (different color, opacity, or pattern). Deduct 5 points if the intersection area is not visually distinct, and 3 points if the blending effect lacks visual clarity. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Does the implementation provide interactive capabilities?",
-      "description": "Assess whether the code allows users to interact with the shapes (e.g., moving shapes, resizing, changing parameters). Check for event listeners that enable drag-and-drop functionality or parameter adjustments. Deduct 3 points if only basic interactions are implemented, 5 points if interactions are limited to only one shape, and 5 points if real-time intersection updates are missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid inputs, edge cases in shape positioning, rendering 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. Multiple blending modes like SVG's 'multiply', 'screen', etc. 2. Mathematical formulas display alongside visualization 3. Animation showing how intersection changes with 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 calculations or rendering passes that affect performance 2. Unnecessary complexity in algorithms where simpler solutions exist 3. Extraneous visual elements unrelated to the geometric intersection task. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functionality is compromised by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (separating rendering logic from calculation logic), proper variable naming, code comments, and application of appropriate design patterns. Deduct 5 points if global variables are overused; deduct 5 points if the code is not organized into logical functions or classes; deduct 5 points if documentation is missing for complex algorithms. 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) Clean and minimal UI that doesn't distract from the geometric visualization. Deduct 3 points for each visually distracting element, 5 points for poor color choices that make intersection difficult to see, and 5 points for cluttered controls. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and responsive?",
-      "description": "Judge whether the rendering and calculation performance meets standards: 1) Rendering updates occur at 60fps without visible lag 2) Intersection calculations complete within 16ms to maintain smooth framerate 3) Shape manipulations respond instantly to user input. Deduct 5 points for noticeable lag during interaction, 3 points for jerky animations, and 5 points for calculation delays that affect user experience. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Simulation & Modeling-Mathematical Abstraction",
-  "difficulty": "easy"
-}

package/library/simulation___modeling-mathematical_abstraction/interactive-rectangle-cylinder-manipulation.json

@@ -1,68 +0,0 @@
-{
-  "index": 1157,
-  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Try to ensure the generated code is executable for display. Please use JavaScript+CSS+HTML to help me implement the following requirements:\n\n1. The system generates a rectangle that can be resized by dragging to change its length and width.\n2. When a student selects one edge of the rectangle and clicks the \"Rotate\" button, the rectangle rotates around the line containing that edge for one complete revolution, generating a cylinder model.\n3. When a student clicks the \"Reset\" button, the display returns to the initial rectangle. Students can change the rectangle's length or width, or select a different edge for rotation to observe the corresponding cylinder that is generated.\n4. When a student clicks the \"Cut\" button, the cylinder is cut along any generatrix, opening the lateral surface of the cylinder and laying it flat on a plane, with an animation effect.\n5. When a student clicks the \"Pen\" button, they can annotate letters on the cylinder or rectangle.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the interactive resizable rectangle fully implemented?",
-      "description": "Review whether the code correctly implements a rectangle that can be resized by dragging its edges or corners. The implementation should include handle points for resizing, visual feedback during the dragging operation, and smooth size updates. Score 0 if resizing functionality is missing, 5 if basic resizing is implemented but with usability issues, and 10 if resizing works smoothly with proper constraints and visual feedback.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the cylinder rotation functionality properly implemented?",
-      "description": "Check if the code properly implements the rotation of the rectangle around a selected edge to form a cylinder. This should include: edge selection mechanism, 3D transformation using CSS or a library like Three.js, complete 360-degree rotation animation, and proper perspective rendering. Deduct 5 points if the rotation is not around the selected edge, 3 points if the animation is not smooth, and 2 points if the 3D perspective is incorrect. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Does the reset functionality restore the original state?",
-      "description": "Evaluate if clicking the 'Reset' button correctly returns the display to the initial rectangle state. The system should maintain the original dimensions or reset to default values, clear any annotations, and cancel any in-progress transformations. Check if students can modify the rectangle after reset and repeat the cylinder generation process. Deduct 5 points if the reset is incomplete, 3 points if previous state information influences the reset state. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the cylinder cutting and unfolding animation properly implemented?",
-      "description": "Assess if the 'Cut' button functionality correctly simulates cutting the cylinder along a generatrix and unfolding it onto a plane. The animation should be mathematically accurate (rectangle width = cylinder circumference, height = cylinder height), include proper transition phases, and demonstrate the relationship between 3D and 2D forms. Deduct 5 points if the mathematical relationship is incorrect, 3 points if the animation lacks intermediate steps, and 2 points if the final unfolded state is not properly aligned. 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 sequential clicks on different buttons, browser resizing, invalid user inputs on dimensions, 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. Measurement tools showing dimensions 2. Different texture options for the cylinder 3. View angle controls for better 3D observation). 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 view) 2. Function modules unrelated to the geometric transformation task (e.g., unnecessary media players) 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 geometric logic/view/interaction 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 the code contains performance bottlenecks that cause noticeable lag during animations. 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 annotation functionality well-implemented?",
-      "description": "Judge whether the 'Pen' button enables effective annotation on both rectangle and cylinder. Check for: 1) Smooth drawing experience with proper event handling 2) Annotations that maintain position relevance when switching between 2D and 3D views 3) Clear visual rendering of annotations with appropriate styling. Deduct 5 points if annotations disappear during transformations, 3 points if the drawing experience is laggy or imprecise, and 5 points if annotations don't properly adhere to the surface in 3D view. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Simulation & Modeling-Mathematical Abstraction",
-  "difficulty": "hard"
-}

package/library/simulation___modeling-mathematical_abstraction/js-sphere-conways-game-life-multicolor-simulation.json

@@ -1,68 +0,0 @@
-{
-  "index": 10,
-  "question": "You are a code expert. Please use your professional knowledge to provide accurate and professional responses. Make sure the generated code is executable for demonstration purposes. I'd like to make a JS simulation of a sphere where the universe of Conway's Game of Life is unfolding, multicolor, lots of small squares, on a black background.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is Conway's Game of Life algorithm correctly implemented?",
-      "description": "Review whether the code accurately implements Conway's Game of Life rules: 1) Live cells with 2-3 neighbors survive 2) Dead cells with exactly 3 neighbors become alive 3) All other cells die or remain dead. Check if the algorithm uses proper neighbor counting for spherical topology (handling pole singularities and longitude wrapping). Score 0 if core rules are missing, 5 if basic rules work but topology is incorrect, 10 if fully implemented with proper spherical neighbor calculation.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the spherical 3D visualization properly rendered?",
-      "description": "Evaluate whether the sphere rendering uses appropriate 3D graphics (WebGL/Three.js) with correct UV mapping for cellular automata grid projection. Check if the sphere maintains consistent cell size across surface, handles texture distortion at poles, and implements proper camera controls (rotation, zoom). Deduct 5 points if using 2D approximation instead of true 3D sphere, 3 points if pole distortion is severe. Full score requires smooth sphere with uniform cell distribution.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are multicolor visual effects and animations implemented effectively?",
-      "description": "Check whether the visualization includes dynamic color systems: 1) Different colors for cell states/ages 2) Smooth color transitions during state changes 3) Visually appealing color palette against black background. Evaluate animation smoothness (60fps target) and visual clarity of individual cells. Deduct 5 points if colors are static or harsh, 3 points if animation stutters or cells are hard to distinguish. Requires color coding system and smooth real-time updates.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the grid resolution and performance optimization adequate?",
-      "description": "Assess whether the implementation supports 'lots of small squares' (minimum 100x50 grid resolution) while maintaining smooth performance. Check for optimization techniques like efficient neighbor calculation, WebGL batching, or delta-based updates. Evaluate if the system can handle multiple generations without performance degradation. Deduct 5 points if grid resolution is too low (<50x25), 5 points if frame rate drops below 30fps, 3 points if memory usage grows unbounded over time.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as WebGL context loss, browser compatibility issues, extreme zoom levels, invalid initial patterns, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should gracefully degrade on older browsers and handle edge cases effectively, 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 seeding by clicking on sphere 2. Multiple preset patterns (gliders, oscillators) adapted for spherical topology 3. Speed controls and generation counter 4. Cell age visualization with color gradients 5. Export/import pattern 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 rendering pipelines coexisting) 2. Function modules unrelated to Game of Life simulation (e.g., built-in audio player) 3. Fancy effects that severely impact performance (e.g., excessive particle systems, complex shaders). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core simulation performance is compromised 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), code organization, and maintainability. Check for proper separation of concerns between Game of Life engine and 3D visualization. Deduct 5 points if global state pollution is found or no clear architecture; deduct 5 points if the code duplication rate is too high (over 30%); deduct 3 points if hardcoded magic numbers are excessive. The full score requires clean, well-structured code with clear separation of responsibilities.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern 3D visualization principles: 1) High contrast multicolor cells against pure black background for optimal visibility 2) Appropriate cell size ensuring individual squares are distinguishable 3) Professional color palette with sufficient variety but visual harmony 4) Clean UI controls if present. Deduct 3 points for poor color choices that reduce visibility, 5 points if cells are too small/large to distinguish effectively, 5 points for cluttered or unprofessional visual appearance.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the 3D interaction and animation conform to user expectations: 1) Smooth sphere rotation with mouse/touch controls 2) Responsive zoom without breaking cell visibility 3) Consistent animation timing for Game of Life generations 4) Immediate visual feedback for any interactive elements. Deduct 5 points for laggy or jerky sphere manipulation, 3 points for inconsistent animation timing, 5 points for unresponsive controls or poor camera behavior. Full score requires fluid 60fps 3D interaction.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Simulation & Modeling-Mathematical Abstraction",
-  "difficulty": "medium"
-}

package/library/simulation___modeling-mathematical_abstraction/uniapp-vue3-graphology-path-planning-example-code.json

@@ -1,68 +0,0 @@
-{
-  "index": 786,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure that the code you generate is executable for demonstration purposes. uniapp vue3 example code for Graphology path planning.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core graphology path planning algorithm properly implemented?",
-      "description": "Review whether the code properly implements one or more path planning algorithms (e.g., Dijkstra, A*, BFS, DFS) suitable for graphology applications. Check if the algorithm correctly calculates the shortest/optimal path between nodes. Score 0 if no algorithm is implemented, 5 if a basic algorithm is implemented with flaws, and 10 if the algorithm is correctly implemented with optimizations for graphology use cases.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the graph data structure appropriately designed for uniapp?",
-      "description": "Evaluate the data structure design for storing and manipulating the graph. Check whether it efficiently represents vertices, edges, weights, and other properties relevant to graphology. Verify compatibility with Vue 3 reactivity system and proper state management. Deduct 5 points if the structure is inefficient or incompatible with Vue 3, deduct 3 points if it lacks proper indexing or lookup optimization. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Does the implementation use Vue 3/uniapp features correctly?",
-      "description": "Assess whether the code properly utilizes Vue 3 composition API, reactive states, lifecycle hooks, and uniapp-specific features. Check if the solution follows best practices for component design, state management (e.g., Pinia/Vuex), and event handling. Deduct 5 points for using Options API instead of Composition API without reason, 3 points for improper reactivity usage, and 5 points for not utilizing uniapp cross-platform features. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the graph visualization properly implemented?",
-      "description": "Check whether the code includes proper visualization of the graph and the calculated path. Verify if it uses appropriate visualization libraries or canvas/SVG rendering that works across multiple platforms supported by uniapp. Evaluate the clarity of node and edge representations. Deduct 5 points if the visualization is static, 5 points if it's not responsive to different screen sizes, and 3 points if it lacks animation for path traversal. 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 disconnected graphs, invalid input, edge cases in the algorithm, platform-specific issues in uniapp) 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 graph manipulation 2. Multiple algorithm comparisons with performance metrics 3. Custom node/edge styling 4. User-defined heuristics for A*). 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 graph traversal algorithms without clear purpose) 2. Function modules unrelated to graphology path planning (e.g., unnecessary media players) 3. Fancy effects that affect performance (e.g., excessive animations that slow down the application). 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 algorithm/view/model layers), component reusability, and build process compatibility with uniapp. 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 file structure doesn't follow uniapp conventions. 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 across platforms?",
-      "description": "Judge whether the dynamic effects conform to uniapp cross-platform capabilities: 1) Consistent performance across iOS, Android, and H5 2) Transition animation duration controlled between 300-500ms 3) Proper touch feedback for mobile devices. Deduct 5 points for each operation without proper mobile feedback, 3 points for performance inconsistencies between platforms, and 5 points for unresponsive UI during algorithm execution. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Simulation & Modeling-Mathematical Abstraction",
-  "difficulty": "easy"
-}

package/library/simulation___modeling-mathematical_abstraction/web-program-simulate-mqtt-iot-data-transmission.json

@@ -1,68 +0,0 @@
-{
-  "index": 930,
-  "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. Help me write a web program that simulates the MQTT protocol for IoT, specifically demonstrating the data transmission process.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the MQTT simulation core functionality fully implemented?",
-      "description": "Review whether the code correctly implements the core MQTT features including connect, publish, subscribe, unsubscribe and disconnect operations. Check if quality of service (QoS) levels (0, 1, 2) are properly simulated. Score 0 if core MQTT operations are missing, 5 if basic pub/sub is implemented without QoS support, and 10 if all core MQTT operations with QoS levels are fully simulated.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the broker simulation component properly designed?",
-      "description": "Evaluate if the code includes a properly designed broker component that handles client connections, topic subscriptions, message routing, and session management. Check if the broker maintains subscription lists and efficiently delivers messages to subscribers. Deduct 5 points if the broker doesn't handle retained messages, 3 points if it lacks proper client ID management, and 3 points if it doesn't implement last will message functionality. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the client-broker interaction flow visually demonstrated?",
-      "description": "Check whether the simulation visually demonstrates the message flow between clients and broker with clear packet visualization (CONNECT, CONNACK, PUBLISH, PUBACK, etc.). Assess if the visualization shows packet headers, payload content, and direction of transmission. Deduct 5 points if packet structure is not displayed, 3 points if message flow direction is unclear, and 3 points if packet timing is not represented. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Does the simulation demonstrate typical IoT scenarios?",
-      "description": "Assess whether the code includes practical IoT scenarios such as sensor data publishing, device state changes, command reception, or telemetry reporting. Check if realistic topic structures are used (e.g., 'devices/sensor1/temperature'). Award 3 points for each well-implemented IoT scenario (up to 10 points). Deduct 5 points if scenarios are technically accurate but not representative of real IoT use cases.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as connection failures, network interruptions, malformed packets, 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. Real-time network traffic visualization 2. Interactive message inspector 3. Protocol comparison with HTTP/WebSockets 4. Simulated network latency/packet loss controls). 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 message handling logics coexisting) 2. Function modules unrelated to MQTT simulation (e.g., unrelated animations) 3. Fancy effects that affect performance (e.g., excessive visual elements). 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 protocol logic/view/network layers), unit test coverage, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Message transmission animations reflect actual protocol timing 2) Transition animation duration controlled between 300-500ms 3) Clear visual indication of connection states and events. Deduct 5 points for each operation without feedback, 3 points for visual after-images during fast message exchanges, and 5 points for hard-to-follow message flows. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Simulation & Modeling-Mathematical Abstraction",
-  "difficulty": "hard"
-}

package/library/simulation___modeling-physics_simulation/brownian-motion-web-page.json

@@ -1,68 +0,0 @@
-{
-  "index": 1709,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Take care to ensure that the code you generate is executable and displayable. Create a web page file demonstrating Brownian motion.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Brownian motion correctly implemented according to mathematical principles?",
-      "description": "Examine whether the code implements true Brownian motion with proper stochastic processes and random walk principles. The implementation should use correct mathematical formulas for random displacement. Score 0 if the motion is just random movement without proper Brownian characteristics, 5 if basic Brownian motion is implemented, and 10 if it includes refinements like proper scaling factors and time-step adjustments.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are particle dynamics and visualization properly rendered?",
-      "description": "Check whether particles display smooth motion with proper frame rate (≥30fps), whether collisions with boundaries are handled correctly, and if the visualization clearly shows the random nature of Brownian motion. Deduct 3 points if motion appears jerky, 3 points if boundary collisions are improperly handled, and 4 points if the visualization fails to clearly demonstrate the principle. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are interactive controls for simulation parameters provided?",
-      "description": "Evaluate whether users can adjust key parameters such as number of particles, temperature (affecting motion intensity), particle size, and viscosity. Give 2 points for each well-implemented control up to a maximum of 10 points. Controls should provide immediate visual feedback when adjusted.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there an educational explanation or visualization of the physics involved?",
-      "description": "Assess whether the implementation includes explanatory elements about Brownian motion physics, such as trajectory tracking, motion heat maps, statistical distribution graphs of particle displacement, or textual explanations. Award up to 10 points based on the depth and clarity of the educational components.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as browser resizing, extreme parameter inputs, performance degradation with many particles, etc.) and provide graceful fallbacks. 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 visualization modes 2. Particle interaction physics 3. Data export for analysis). 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 animation loops 2. Function modules unrelated to Brownian motion 3. Fancy effects that affect performance without contributing to the demonstration. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core simulation is interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating physics engine/visualization/user interface), performance optimization techniques (like requestAnimationFrame usage, canvas vs. DOM rendering choices), and code maintainability. Deduct 5 points if global state pollution is found; deduct 3 points if the animation loop is inefficiently implemented; deduct 5 points if the code has poor organization. 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 animation performance and interactivity meet high standards: 1) Consistent frame rate without drops 2) Smooth parameter adjustment effects 3) Responsive design that works across devices. Deduct 5 points if the animation stutters frequently, 3 points if controls have noticeable lag, and 5 points if the visualization breaks on different screen sizes. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Simulation & Modeling-Physics Simulation",
-  "difficulty": "easy"
-}

package/library/simulation___modeling-physics_simulation/bs-ns3-simulation-frontend-display.json

@@ -1,68 +0,0 @@
-{
-  "index": 1056,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable for demonstration purposes. Create a BS (Browser-Server) architecture code where the backend uses NS3 for simulation, and the frontend displays the simulation results and status, including the spatiotemporal positions of nodes, connection relationships, topology, traffic flow, packet loss rate, etc.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the NS3 simulation environment properly configured and integrated?",
-      "description": "Review whether the code correctly sets up NS3, defines simulation parameters, and implements simulation scenarios. Check if the code includes proper node configuration, mobility models, network protocols, and channel characteristics. Score 0 if NS3 integration is missing, 5 if basic simulation is implemented without customization, and 10 if a comprehensive simulation environment is configured with appropriate parameters for the networking scenario.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is there an effective data extraction and processing mechanism from NS3?",
-      "description": "Evaluate how simulation data is captured, processed, and prepared for transmission to the frontend. Check for implementations of trace sources, callbacks, or logging mechanisms to collect data about node positions, connections, packet flows, and network statistics. Deduct 5 points if only basic position data is captured, 3 points if statistical aggregation is missing, and 2 points if the data format is inefficient for transmission. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is there a well-designed communication interface between backend and frontend?",
-      "description": "Check the implementation of the server-side API endpoint architecture. Assess whether WebSockets are used for real-time data transmission or if REST APIs are properly designed for data queries. Examine if the communication protocol handles data serialization efficiently. Deduct 5 points if only one-way communication is implemented, 3 points if data compression is missing for large datasets, and 5 points if there's no error handling for communication failures. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Does the visualization accurately represent network topology and dynamics?",
-      "description": "Evaluate the visual representation of network elements (nodes, links, packets) and whether it correctly reflects the simulation data. Check if the visualization updates in real-time or near real-time to show dynamic changes in the network. Deduct 5 points if node positions are inaccurate, 3 points if connection states aren't visually distinguishable, and 5 points if packet flows aren't animated. Give 10 points for comprehensive visualization that clearly represents all network aspects.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as simulation crashes, connection interruptions, malformed data, 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. User-configurable simulation parameters through the UI 2. Multi-view perspectives of the network 3. Time-lapse replay of simulation history 4. Comparative visualization of multiple simulation runs). Add 2.5 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant data processing pipelines that could be streamlined 2. Visualization elements that don't contribute to network understanding 3. Computationally expensive features that don't add value to the simulation analysis. 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 simulation logic/visualization/data processing 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 network elements (distinguishable but cohesive) 2) Proper layout spacing for controls and visualization 3) Professional font system for labels and statistics. Deduct 3 points for each crowded visual element, 5 points for indistinguishable network components, and 5 points for chaotic data presentation. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the interface allows intuitive interaction with the simulation: 1) Pan/zoom/selection response within 100ms 2) Smooth transitions when updating network state 3) Clear visual indicators for simulation status and progress. Deduct 5 points for each operation without feedback, 3 points for laggy visualization during simulation updates, and 5 points for difficult navigation between different visualization aspects. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Simulation & Modeling-Physics Simulation",
-  "difficulty": "hard"
-}

package/library/simulation___modeling-physics_simulation/celestial-body-motion-simulation-frontend-program.json

@@ -1,68 +0,0 @@
-{
-  "index": 437,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you provide is executable for demonstration. Write a frontend program that simulates celestial body motion.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the celestial body physics simulation accurately implemented?",
-      "description": "Review whether the code correctly implements fundamental physics laws including gravitational force calculations (F = G*m1*m2/r²), orbital mechanics, and velocity/acceleration updates using proper numerical integration methods (Euler, Verlet, or Runge-Kutta). Score 0 if basic physics is missing, 5 if only simple circular orbits are implemented, and 10 if realistic elliptical orbits with proper gravitational interactions between multiple bodies are included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the real-time rendering and animation system properly constructed?",
-      "description": "Check whether the animation loop uses requestAnimationFrame for smooth 60fps rendering, includes proper time-step management for consistent simulation speed, and implements efficient canvas/WebGL rendering with object pooling. Deduct 5 points if frame rate drops below 30fps with multiple celestial bodies, and 3 points if animation stutters during rapid zooming or panning. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are interactive controls and camera system fully developed?",
-      "description": "Evaluate whether the program includes intuitive camera controls (pan, zoom, rotate), interactive celestial body manipulation (drag to adjust position/velocity), and simulation speed controls (pause/play/fast-forward). Check for smooth camera transitions and proper coordinate system transformations. Deduct 5 points if controls are unresponsive or jerky, and 3 points if zoom limits cause rendering issues. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is comprehensive simulation configuration and preset scenarios implemented?",
-      "description": "Check whether the code includes multiple preset scenarios (solar system, binary stars, asteroid field), customizable celestial body properties (mass, radius, initial velocity), and simulation parameter controls (gravitational constant, time scale). Deduct 5 points if only single scenario is available, and 3 points if celestial body properties cannot be modified dynamically. Give 10 points if multiple realistic astronomical scenarios are provided.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as division by zero in gravitational calculations, numerical instability, extreme zoom levels, invalid user 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. Orbital trajectory prediction and visualization 2. Real-time gravitational field visualization 3. Celestial body collision detection and effects 4. Export simulation as video/GIF 5. Educational information panels). 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 rendering loops coexisting) 2. Function modules unrelated to celestial simulation (e.g., built-in games or social features) 3. Fancy effects that affect performance (e.g., excessive particle systems or complex shaders). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core simulation 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 physics engine/renderer/UI components), performance optimization techniques, and maintainable code structure. Deduct 5 points if global state pollution is found or physics calculations are mixed with rendering code; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if no performance monitoring or optimization is implemented. 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 suitable for space theme (no more than 3 primary colors) 2) Proper layout spacing for control panels (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times) 4) Appropriate celestial body visual scaling and contrast. Deduct 3 points for each crowded visual element, 5 points for glaring color combinations that hurt visibility, and 5 points for chaotic UI layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Control response delay ≤ 100ms for camera and simulation controls 2) Smooth transition animations for zoom/pan operations (300-500ms duration) 3) Clear visual feedback for interactive elements 4) Intuitive celestial body selection and manipulation. Deduct 5 points for each unresponsive control operation, 3 points for visual lag during real-time simulation, and 5 points for unintuitive or hard-to-discover interaction methods. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Simulation & Modeling-Physics Simulation",
-  "difficulty": "medium"
-}