@getollie/cli 0.0.1

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

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

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

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

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

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

@@ -0,0 +1,68 @@
+{
+  "index": 301,
+  "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 display. Write a frontend program that simulates the celestial bodies of the solar system in motion.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the solar system model complete and accurate?",
+      "description": "Evaluate whether the code accurately represents all major celestial bodies of the solar system (Sun, 8 planets, major moons, asteroid belt). Check if relative sizes, distances, and orbital characteristics are proportionally represented (can use scale factors but must be consistent). Score 0 if only basic planets are shown, 5 if most bodies are included but with inaccurate proportions, and 10 if the model is comprehensive and scientifically accurate.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the orbital motion physics correctly implemented?",
+      "description": "Review whether the code implements proper celestial mechanics including elliptical orbits, Kepler's laws, correct orbital periods, and proper angular momentum. Check if planets rotate on their axes with correct tilt angles and rotation periods. Deduct 5 points if orbits are simplified to circular paths, 3 points if orbital speeds are inaccurate, and 2 points if axial rotation is missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the 3D rendering and visualization effective?",
+      "description": "Assess whether the simulation uses proper 3D rendering techniques (WebGL/Three.js/Canvas) with appropriate camera controls, lighting effects, and texture mapping. Check for proper perspective, depth perception, and the ability to view the system from different angles. Award 10 points for full 3D implementation with realistic textures and lighting, 5 points for basic 3D with limited view controls, and 0 points if only 2D representation is used.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are interactive features and user controls implemented?",
+      "description": "Evaluate whether the simulation provides user interaction features like zoom in/out, speed control, focus tracking of specific planets, time manipulation, and information display. Check for smooth transitions between views and intuitive control mechanisms. Deduct 2 points for each missing core interaction feature, and award full 10 points if the simulation offers comprehensive, intuitive controls that enhance educational value.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as browser compatibility issues, WebGL capability detection, memory management for large textures, responsive design for various screen sizes, etc.) and provide friendly error prompts or fallback 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. Spacecraft trajectory simulation 2. Historical astronomical events recreation 3. Gravity visualization 4. Educational overlays with scientific facts). 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 calculation of orbital parameters that could be pre-computed 2. Function modules unrelated to astronomical simulation (e.g., unnecessary UI elements) 3. Excessive effects that affect performance (e.g., too many particle effects or overly detailed textures). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core simulation is significantly slowed by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating physics engine/rendering/user interface layers), performance optimization techniques (object pooling, texture atlasing), and adherence to frontend best practices. Deduct 5 points if global namespace pollution is found; deduct 5 points if the code lacks comments or documentation; deduct 5 points if no performance optimization is implemented for this graphics-intensive application. 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 astronomical visualization standards: 1) Scientific color schemes for celestial bodies 2) Proper scale indicators and measurement units 3) Clean UI with minimal obstruction of the simulation view. Deduct 3 points for each misrepresentation of celestial appearance, 5 points for cluttered controls that obscure the simulation, and 5 points for missing essential legends or labels. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the simulation maintains consistent frame rates (minimum 30 FPS) even with multiple celestial bodies. Check that: 1) Camera transitions are smooth with proper easing 2) Time acceleration/deceleration produces continuous motion 3) Orbital paths are rendered without jitter. Deduct 5 points for frame drops below 20 FPS on standard hardware, 3 points for jarring camera movements, and 5 points for any motion that breaks the illusion of continuous celestial movement. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Simulation & Modeling-Physics Simulation",
+  "difficulty": "hard"
+}

package/library/simulation___modeling-physics_simulation/circuit-experimental-simulator-with-drag-and-drop.json

@@ -0,0 +1,68 @@
+{
+  "index": 500,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure that the generated code is executable and displayable.\n\n======== ROLE ========\nYou are an experienced code expert. You have been provided with a software development requirement description and are asked to generate project code based on this requirement. Follow the rules strictly to help users generate complete project code with comprehensive comments in simple, easy-to-understand language. Do not output anything else.\n\n======== OUTPUT RULES ========\n1. Always generate complete, runnable project code. Make sure the project is fully executable\n2. Ensure all code files you output are complete, with no omitted code\n3. Carefully review and check all code before final output, evaluating its executability. If the code cannot be executed or contains errors, it needs to be regenerated\n4. If the requirements involve external API access or need to use user data (images, videos, audio, etc.), please provide simulated data\n\n======== PROJECT REQUIREMENTS ========\nDevelop a multi-step experimental simulator (such as a physics circuit experiment) where users can drag and drop components like batteries, resistors, and wires onto a workspace to form a circuit. Contact points are automatically generated when components touch. Users can double-click on components to set properties (such as voltage). A \"Start Test\" button on the right side verifies if the circuit is closed - if successful, it displays the current intensity; if unsuccessful, it highlights the disconnected location.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the drag-and-drop functionality for circuit components properly implemented?",
+      "description": "Check if the code implements a complete drag-and-drop system for circuit components (batteries, resistors, wires, etc.) with accurate positioning, smooth movement, and proper event handling. Components should be draggable from a component palette to the workspace and repositionable within the workspace. Verify if the drag system handles z-index correctly to prevent visual glitches when components overlap. Score 0 if drag-and-drop is not implemented, 5 if basic movement is implemented but with bugs, and 10 if the system is complete with snap-to-grid and intuitive user feedback.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the automatic contact point detection system functional?",
+      "description": "Evaluate the implementation of the contact point detection algorithm. The system should accurately detect when component terminals are close enough to form connections, visualize these connections appropriately, and update the circuit graph model. Check if the code handles different component orientations and contains collision detection logic with appropriate tolerances. Deduct 5 points if the detection is imprecise (>5px tolerance), 3 points if connection visualization is unclear, and 5 points if the underlying circuit graph is not properly updated. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the component property editing functionality complete?",
+      "description": "Verify if double-clicking on components opens a properly designed properties dialog that allows users to modify relevant parameters (voltage for batteries, resistance for resistors, etc.). The interface should validate inputs, prevent invalid values, and immediately update the circuit model after changes. Deduct 3 points if validation is missing, 4 points if the UI is not intuitive, and 5 points if property changes don't update the underlying model. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the circuit verification and simulation system correctly implemented?",
+      "description": "Check if the 'Start Test' button triggers appropriate circuit analysis, including closed-circuit verification, current flow calculation using Ohm's Law and Kirchhoff's Laws, and proper visual feedback. The system should identify disconnected points with clear highlighting and display accurate current values for working circuits. Deduct 5 points if the circuit analysis is incomplete, 5 points if the current calculation is incorrect, and 3 points if the visual feedback is inadequate. 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 component manipulation, invalid circuit configurations, extreme property values, 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 circuit analysis visualization 2. Component behavior animation when current flows 3. Export/import of circuit designs 4. Multiple experiment templates). 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 create connections) 2. Function modules unrelated to circuit simulation (e.g., unnecessary game-like elements) 3. Fancy effects that affect performance (e.g., excessive animations that slow down the simulation). 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 circuit model/view/simulation logic), 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) Immediate feedback when dragging components 2) Transition animation duration controlled between 300-500ms for property changes 3) Clear visual feedback for successful/unsuccessful connections. Deduct 5 points for each operation without feedback, 3 points for jerky component movement, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Simulation & Modeling-Physics Simulation",
+  "difficulty": "hard"
+}

package/library/simulation___modeling-physics_simulation/conservation-of-momentum-animations.json

@@ -0,0 +1,68 @@
+{
+  "index": 1559,
+  "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. I am a high school physics teacher preparing to teach the law of conservation of momentum. Could you create a series of clear and accurate demonstration animations and organize them into a simple HTML presentation?",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Are the physics principles accurately implemented?",
+      "description": "Review whether the code correctly implements the law of conservation of momentum with accurate mathematical formulas (p = mv, Σp_before = Σp_after). Check if collision calculations properly handle elastic/inelastic collisions, mass conservation, and velocity calculations. Score 0 if physics formulas are incorrect, 5 if basic momentum is shown but calculations are imprecise, and 10 if all momentum conservation scenarios are accurately modeled with correct physics equations.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are comprehensive demonstration scenarios provided?",
+      "description": "Evaluate whether the animations cover essential momentum conservation scenarios: 1) Two objects colliding (elastic collision) 2) Inelastic collision with objects sticking together 3) Explosion/separation scenarios 4) Different mass ratios demonstrations. Each scenario should be visually distinct and educationally valuable. Deduct 3 points for each missing core scenario. Full score requires at least 4 different momentum conservation demonstrations.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the animations educationally effective and scientifically clear?",
+      "description": "Check if animations include real-time display of momentum values, velocity vectors, and mass indicators. Evaluate whether the animation speed allows students to observe and understand the physics process (2-5 seconds per collision cycle). Animations should show before/after momentum calculations clearly. Deduct 5 points if momentum values are not displayed, 3 points if animations are too fast to follow, and 5 points if vector representations are missing.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the HTML presentation structure well-organized for teaching?",
+      "description": "Review whether the presentation includes: 1) Clear navigation between different scenarios 2) Step-by-step progression from simple to complex examples 3) Interactive controls (play/pause/reset) 4) Educational annotations explaining each demonstration. Check if the presentation flow follows pedagogical best practices. Deduct 5 points if navigation is confusing, 3 points if interactive controls are missing, and 5 points if educational context is insufficient.",
+      "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 momentum calculations, extreme velocity values, browser compatibility issues, animation frame drops, etc.) and provide stable performance across different devices. Code with strong robustness should effectively handle edge cases and maintain smooth animations. Give 10 points if fully robust, 5 points if average robustness, and 0 points if no exception handling.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative educational features that enhance learning?",
+      "description": "Check whether the code includes educational enhancements such as: 1) Interactive parameter adjustment (mass/velocity sliders) 2) Real-time momentum vector visualization 3) Slow-motion replay functionality 4) Comparative analysis tools 5) Quiz/assessment integration. Add 2-3 points for each practical educational feature implemented (maximum 10 points). Features must genuinely enhance physics understanding.",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1) Redundant animation implementations or duplicate physics calculations 2) Features unrelated to momentum conservation (e.g., sound effects, decorative elements that distract from learning) 3) Over-complicated visual effects that obscure the physics principles. Deduct 3 points for each redundancy found, and directly deduct 10 points if educational clarity is compromised by unnecessary features.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (separating physics calculations, animation rendering, and UI controls), code organization, and maintainability. Check for proper variable naming, function separation, and code reusability. Deduct 5 points if physics calculations are mixed with rendering code; deduct 5 points if code duplication rate exceeds 30%; deduct 5 points if global variables are overused. Full score requires clean, modular, and maintainable code structure.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface design meet educational presentation standards?",
+      "description": "Evaluate whether the design follows educational material principles: 1) High contrast for classroom projection (dark text on light background) 2) Clear, readable fonts (minimum 16px for body text) 3) Logical layout with proper spacing 4) Color coding that aids understanding (e.g., different colors for different objects). Deduct 3 points for each hard-to-read element, 5 points for poor color contrast, and 5 points for cluttered layout that impedes learning.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Are the animations smooth and pedagogically appropriate?",
+      "description": "Judge whether animations are optimized for educational use: 1) Consistent frame rate (minimum 30fps) 2) Appropriate animation speed for observation and learning 3) Clear visual feedback for user interactions 4) Smooth transitions between different scenarios. Deduct 5 points for choppy animations, 3 points for inappropriate speed that hinders comprehension, and 5 points for poor transition effects. Animations should enhance rather than distract from physics understanding.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Simulation & Modeling-Physics Simulation",
+  "difficulty": "medium"
+}

package/library/simulation___modeling-physics_simulation/draw-lichtenberg-figures-javascript-html5-canvas.json

@@ -0,0 +1,68 @@
+{
+  "index": 330,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate, professional responses. Make sure the code you generate is executable for display. Use JavaScript and HTML5 canvas to draw Lichtenberg figures.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Lichtenberg figure generation algorithm correctly implemented?",
+      "description": "Examine whether the code implements a proper dielectric breakdown model (DBM) or similar fractal algorithm for Lichtenberg figures, with appropriate randomization and branching probabilities. Verify that the algorithm follows physical principles like path of least resistance, proper bifurcation patterns, and gradual branch thinning. Score 0 if no fractal algorithm is implemented, 5 if basic branching exists but lacks physical accuracy, 10 if the algorithm produces realistic lightning-like patterns with proper physics.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the Canvas API properly utilized for rendering?",
+      "description": "Check if the code correctly initializes the HTML5 Canvas context, sets appropriate dimensions, and uses proper drawing methods (like lineTo, moveTo, stroke) efficiently. Verify proper use of canvas transformations if needed, and assess if the implementation avoids unnecessary redrawing. Deduct 5 points if canvas operations are inefficient, 3 points if resolution/scaling issues exist, and 2 points if canvas clearing/state management is improper. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there effective parameter control for the visualization?",
+      "description": "Evaluate whether the code allows for controlling key parameters of Lichtenberg figures, such as branching probability, segment length, angles, color gradients, and growth speed. Check if at least 5 parameters can be adjusted via UI controls (sliders, inputs, etc.). Score 0 if no parameters are customizable, 5 if only basic parameters exist, 10 if comprehensive controls with real-time updates are implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the animation/growth process smooth and visually appealing?",
+      "description": "Assess if the Lichtenberg figure grows organically over time with smooth animation rather than appearing instantly. Check if requestAnimationFrame is used for rendering, growth speed is controllable, and the animation maintains consistent FPS (ideally 60fps). Deduct 5 points if the animation is choppy or inconsistent, 3 points if growth appears unnatural, and 2 points if there's no visualization of the growth process. 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 resize, user input errors, performance degradation with complex figures, 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 figure manipulation by mouse/touch 2. Multiple color schemes or visual styles 3. Ability to save/export the generated figures). 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 drawing routines that do the same thing) 2. Function modules unrelated to Lichtenberg figure generation (e.g., unnecessary UI elements) 3. Fancy effects that affect performance (e.g., excessive particle effects that slow down the main visualization). 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/rendering/UI layers), maintainability, and optimization for performance. 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 no performance optimizations are implemented for complex figures. 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 the UI (complementing the Lichtenberg figure colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Parameter adjustment reflects immediately in the visualization 3) Clear visual focus guidance for interactive elements. Deduct 5 points for each operation without feedback, 3 points for significant lag when adjusting parameters, and 5 points for controls that don't clearly indicate their function. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Simulation & Modeling-Physics Simulation",
+  "difficulty": "medium"
+}