@getollie/cli 0.0.1

package/library/simulation___modeling-3d_simulation/python-3d-robotic-arm-visualization-network-data.json

@@ -0,0 +1,68 @@
+{
+  "index": 1455,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code when possible. How can I create a Python program for 3D visualization of robotic arm movements, where the arm data is received through network transmission?",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the robotic arm 3D model correctly implemented?",
+      "description": "Review whether the code implements an accurate 3D model of a robotic arm with proper joints, segments, and movement constraints. The model should include proper hierarchical structure (base, joints, links, end-effector) with appropriate degrees of freedom for each joint. Score 0 if the model is not implemented, 5 if only basic structure exists, and 10 if a complete, anatomically correct robotic arm with configurable parameters is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the network data reception mechanism properly designed?",
+      "description": "Evaluate the implementation of network communication for receiving robotic arm data. Check for proper socket programming, protocol handling (TCP/UDP), error handling, reconnection logic, and data buffer management. Verify if the code handles connection timeouts, packet loss, and data integrity validation. Deduct 5 points if no error handling exists, 3 points if reconnection logic is missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the data parsing and transformation pipeline correctly implemented?",
+      "description": "Check if the received network data is properly parsed, validated, and transformed into the appropriate coordinate system for 3D visualization. Look for coordinate system transformations (e.g., from robot coordinate system to world coordinate system), unit conversions, and proper handling of different data formats (JSON, binary, custom protocols). Deduct 5 points if coordinate transformations are incorrect or missing, 3 points if data validation is inadequate. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the 3D visualization framework properly utilized?",
+      "description": "Assess the implementation of the 3D visualization using appropriate Python libraries (e.g., VTK, PyOpenGL, Matplotlib, PyVista, Mayavi). Check if the code properly initializes the 3D environment, handles camera positioning, implements lighting, and renders the robotic arm in real-time. Deduct 5 points if the visualization is static only, 3 points if performance optimization for real-time rendering is 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 malformed network data, connection loss, memory constraints, hardware limitations) 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 collision detection 2. Path planning visualization 3. Interactive manipulation through UI 4. Recording and playback of movements 5. Multiple visualization perspectives). 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 visualization methods running simultaneously) 2. Function modules unrelated to robotic arm visualization (e.g., unnecessary image processing) 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 network, data processing, and visualization components), unit test coverage, and appropriate documentation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there is no error logging or debugging functionality. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the visualization interface follows professional design principles: 1) Consistent color scheme for different robot components 2) Clear labeling of axes, joints, and controls 3) Proper use of lighting and shadows for depth perception 4) Appropriate camera angles and zoom levels. Deduct 3 points for cluttered visualization, 5 points for poor color choices affecting readability, and 5 points for difficult navigation controls. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and responsive?",
+      "description": "Judge whether the dynamic visualization performs well: 1) Smooth animation of robotic movements (≥30 FPS) 2) Responsive UI controls with feedback ≤150ms 3) Efficient handling of complex movements without lag. Deduct 5 points if the visualization stutters during complex movements, 3 points if there's significant delay between network data reception and visualization update, and 5 points if user interactions feel unresponsive. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Simulation & Modeling-3D Simulation",
+  "difficulty": "medium"
+}

package/library/simulation___modeling-3d_simulation/python-3d-visualization-tool-saas-composer.json

@@ -0,0 +1,68 @@
+{
+  "index": 1492,
+  "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. Write a visualization tool with buttons in Python. The tool requirements are: it should help quickly bind data in work environments, allow 3D model fine-tuning, enable local interaction with SaaS composer, and automatically complete 3D configurations based on images of venues and scenes.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Data binding implementation",
+      "description": "Review whether the code implements comprehensive data binding functionality for work environments, including support for multiple data formats (CSV, JSON, SQL databases), preview capabilities, and real-time synchronization. Score 0 if data binding is absent, 5 if basic binding is implemented but lacks flexibility, and 10 if the solution provides robust two-way binding with validation and error handling.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "3D model fine-tuning capabilities",
+      "description": "Evaluate the implementation of 3D model manipulation tools. Check whether the code provides essential manipulation functions (scaling, rotation, translation), material/texture editing, and lighting adjustment controls. Deduct 3 points if transformation controls are incomplete, 3 points if material editing is missing, and 2 points if lighting controls are absent. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Local SaaS composer interaction",
+      "description": "Assess whether the code establishes effective local interaction with SaaS composer services, including authentication mechanisms, API integration, and state synchronization. Deduct 5 points if authentication is insecure or missing, 3 points if API calls lack error handling, and 2 points if there's no offline capability. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Automatic 3D configuration from images",
+      "description": "Examine the implementation of image-to-3D conversion functionality. Verify if the code includes computer vision algorithms for scene recognition, depth estimation, and 3D reconstruction. Score 0 if the feature is missing, 5 if basic recognition exists but produces inaccurate results, and 10 if the system effectively generates realistic 3D environments with proper spatial relationships from venue images.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Code robustness",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid inputs, network failures, resource-intensive operations) and provide friendly error messages or recovery mechanisms. Code with strong robustness should effectively handle edge cases, scoring 10 points. If robustness is average, score 5 points, and if exceptions are unhandled, score 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Innovative features",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. AI-assisted scene recognition 2. Real-time collaboration capabilities 3. VR/AR preview mode). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Code efficiency and optimization",
+      "description": "Strictly check three types of inefficiencies: 1. Computational bottlenecks in 3D rendering 2. Memory leaks or excessive memory usage 3. Inefficient algorithms for image processing. Deduct 3 points for each significant inefficiency found, and directly deduct 10 points if the tool becomes unusable due to performance issues under normal operating conditions.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Engineering quality",
+      "description": "Review modular design (such as separating UI/business logic/data processing/3D rendering), unit test coverage, and proper dependency management. Deduct 5 points if global state is unmanaged or design patterns are misused; deduct 3 points if code duplication rate exceeds 20%; deduct 2 points if dependencies are hardcoded without version control. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Interface design and usability",
+      "description": "Evaluate whether the UI follows professional design principles: 1) Intuitive layout with logical grouping of controls 2) Clear visual hierarchy with proper spacing 3) Consistent color scheme and component styling. Deduct 3 points for cluttered interfaces, 3 points for inconsistent visual language, and 4 points if essential functions require more than 3 clicks to access. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Interactive experience and responsiveness",
+      "description": "Judge whether the application provides smooth interaction: 1) Real-time feedback for user actions 2) Progress indicators for long-running processes 3) Appropriate keyboard shortcuts and mouse interactions for 3D manipulation. Deduct 3 points for each operation with delayed feedback (>200ms), 3 points for missing progress indicators, and 4 points if the UI freezes during resource-intensive operations. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Simulation & Modeling-3D Simulation",
+  "difficulty": "hard"
+}

package/library/simulation___modeling-3d_simulation/radar-point-cloud-to-3d-scene.json

@@ -0,0 +1,68 @@
+{
+  "index": 990,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be careful to ensure that the generated code is executable for demonstration. I now have radar point cloud data and several corresponding photos. Could you write code that would render and reconstruct this into a three-dimensional scene?",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the point cloud data processing pipeline fully implemented?",
+      "description": "Review whether the code accurately implements data parsing, filtering, and preprocessing of radar point cloud data. Score 0 if there's no implementation for handling raw point cloud data, 5 if basic parsing is implemented but lacks noise filtering and outlier removal, and 10 if the code includes comprehensive point cloud processing with normalization, downsampling, and statistical outlier removal techniques.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the image-to-point cloud registration process properly implemented?",
+      "description": "Evaluate whether the code implements camera calibration and fusion of 2D images with 3D point cloud data. Check if transformation matrices are properly calculated and applied. Deduct 5 points if camera intrinsic parameters are hardcoded without calibration options, 3 points if the registration process lacks error metrics. The registration should handle multiple viewpoints correctly and provide visual validation of the alignment quality.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the 3D scene reconstruction algorithm effectively implemented?",
+      "description": "Check whether the code implements appropriate scene reconstruction techniques such as SLAM, Structure from Motion, or other 3D reconstruction methods. Score 0 if no reconstruction logic exists, 5 if a basic reconstruction is implemented but lacks texture mapping or surface refinement, and 10 if the implementation includes advanced features like mesh generation, texture mapping, and surface optimization algorithms.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the 3D visualization component comprehensive and interactive?",
+      "description": "Assess whether the visualization supports essential features like camera controls (orbit, pan, zoom), point/mesh rendering options, color mapping from images to points/meshes, and interactive selection of regions. Deduct 5 points if the visualization lacks navigation controls, 3 points if color mapping from photos is not implemented, and 5 points if there's no interactive element to explore the scene.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as corrupted point cloud data, misaligned images, memory limitations with large datasets, 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 point cloud segmentation 2. Automatic semantic labeling of objects in the scene 3. AR/VR export capabilities 4. Temporal tracking of dynamic objects). 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 rendering pipelines 2. Function modules unrelated to 3D reconstruction (e.g., unrelated image processing tools) 3. Computationally expensive visualizations that don't contribute to understanding the scene. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating data processing/reconstruction/visualization layers), unit test coverage, and scalability for large datasets. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no consideration for performance optimization with large point clouds. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional visualization standards?",
+      "description": "Evaluate whether the 3D scene visualization follows modern design principles: 1) Appropriate color mapping for point cloud data (scientific colormaps for depth/intensity) 2) Clear distinction between rendered points/meshes and UI elements 3) Professional camera controls with visual cues. Deduct 3 points for poor color representation of data, 5 points for cluttered interface elements overlapping with the 3D view, and 5 points for lack of spatial references (grid, axes). The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the 3D interaction conforms to expected behavior: 1) Responsive navigation of the 3D scene (< 60ms latency) 2) Smooth transitions when switching between views 3) Progressive loading for large point clouds to maintain framerate. Deduct 5 points for jerky rotations or movements, 3 points if the scene becomes unresponsive with moderate-sized point clouds, and 5 points if there's no visual feedback during long processing operations. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Simulation & Modeling-3D Simulation",
+  "difficulty": "hard"
+}

package/library/simulation___modeling-3d_simulation/shanghai-bund-light-show-html-simulation.json

@@ -0,0 +1,68 @@
+{
+  "index": 350,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code for demonstration purposes. Create an HTML simulation of a light show at Shanghai's Bund.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the simulation accurately representing Shanghai's Bund cityscape?",
+      "description": "Evaluate whether the HTML/CSS implementation properly recreates the iconic Bund skyline with recognizable landmarks (Oriental Pearl Tower, Shanghai Tower, Jin Mao Tower, etc.). Score 0 if no recognizable elements exist, 5 if basic skyline is implemented, and 10 if detailed architectural features of the Bund are accurately represented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the light show animation system fully implemented?",
+      "description": "Review whether the code implements dynamic lighting effects using CSS animations, Canvas API, or WebGL. Check for color transitions, movement patterns, and synchronization mechanisms. Score 0 if no animation exists, 5 if basic animations are implemented, and 10 if the solution includes complex, synchronized light patterns similar to real Bund light shows.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there a day/night cycle or time-based lighting variation?",
+      "description": "Check if the simulation includes transitioning between daytime and nighttime views or allows users to select different timing states. Evaluate whether ambient lighting changes realistically and if the reflection on the Huangpu River is properly implemented. Deduct 5 points if transitions are abrupt, and 3 points if reflections are missing or unrealistic. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there interactive control for the light show?",
+      "description": "Evaluate whether users can interact with the light show (e.g., start/stop, change colors, speed, patterns, or trigger special effects). Deduct 5 points if basic controls are missing, and 3 points if the control panel is not intuitive. Give 10 points if the interface provides comprehensive yet user-friendly controls.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as browser resize, different screen sizes, slower devices, etc.) and provide fallbacks or adaptive designs. 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. Weather effects like rain or snow 2. Audio synchronization with light patterns 3. Virtual tourists/camera shots). 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 implementations of similar effects (e.g., multiple animation systems running simultaneously) 2. Function modules unrelated to the Bund light show 3. Excessive effects that cause performance issues. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating rendering logic/animation effects/user interface), performance optimization techniques, and code organization. Deduct 5 points if global state pollution is found; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there are no performance considerations for animation rendering. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Realistic or stylized but consistent visual style 2) Proper contrast between buildings and lights 3) Attention to detail in architectural elements and lighting effects. Deduct 3 points for each visual inconsistency, 5 points for unrealistic lighting physics, and 5 points for poor composition of the scene. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the performance optimization properly implemented?",
+      "description": "Judge whether the implementation considers performance: 1) Using requestAnimationFrame for smooth animations 2) Implementing hardware acceleration where appropriate 3) Managing memory for long-running animations. Deduct 5 points for frame rates below 30fps on standard devices, 3 points for memory leaks during long sessions, and 5 points for noticeable jank during complex light sequences. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Simulation & Modeling-3D Simulation",
+  "difficulty": "hard"
+}

package/library/simulation___modeling-3d_simulation/solar-system-motion-simulation-html.json

@@ -0,0 +1,68 @@
+{
+  "index": 373,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Make sure to ensure that the generated code is executable for demonstration. Generate an HTML file that simulates the solar system in motion.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the solar system model accurately represented?",
+      "description": "Evaluate whether the code correctly implements the solar system with proper relative sizes and orbital distances of celestial bodies. Check if the Sun is positioned at the center and if at least the 8 major planets (Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, and Neptune) are included. Award 10 points for accurate representation with correct relative sizes and distances, 5 points if major planets are present but with inaccurate proportions, 0 points if the model is fundamentally flawed.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the planetary motion physics correctly implemented?",
+      "description": "Review whether the orbital mechanics follow Kepler's laws with proper elliptical paths, varying orbital velocities (faster when closer to the Sun), and correct orbital periods (relative to each other). Deduct 5 points if orbits are perfectly circular instead of elliptical, deduct 3 points if orbital speeds are constant, and deduct 5 points if orbital periods don't maintain correct proportions between planets. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are visual celestial body details and textures implemented?",
+      "description": "Check if the planets have distinctive visual characteristics (Jupiter's storm, Saturn's rings, Earth's blue color and continents, etc.). Award 10 points for detailed textures and visual effects for each planet, 5 points if basic color differences are present but without detailed textures, 0 points if all planets look identical with no distinguishing features.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there interactive functionality for user engagement?",
+      "description": "Evaluate whether the simulation allows for user interaction such as zooming in/out, changing the viewing angle, adjusting simulation speed, or clicking on planets for information. Award 10 points for multiple intuitive interactive features, 5 points for basic controls, 0 points for a completely static non-interactive visualization.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as browser resizing, different screen resolutions, device compatibility) and provide graceful degradation. 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. Day/night cycles on Earth 2. Realistic stars in the background 3. Comet or asteroid visualizations 4. Moon systems around planets). 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 functions 2. Feature modules unrelated to the solar system (e.g., unrelated UI elements) 3. Fancy effects that affect performance (e.g., excessive particle effects that cause lag). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating astronomy calculation logic/rendering/user interaction layers), code reusability, 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 no performance optimizations are implemented for smooth animation. 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) Appropriate use of space visualization (correct perspective, lighting, and shadows) 2) Proper layout spacing for any UI controls 3) Professional typography for any informational text (readable font size and contrast). Deduct 3 points for each visual inaccuracy in space representation, 5 points for poor lighting that makes planets difficult to distinguish, and 5 points for unreadable or poorly positioned text elements. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the animation smooth and performant?",
+      "description": "Judge whether the animation runs at a consistent frame rate (ideally 60fps) without stuttering: 1) Smooth planetary rotation and revolution 2) Consistent performance over time 3) No visual glitches during continuous operation. Deduct 5 points for frame rate below 30fps on standard hardware, 3 points for visual jitter during animation, and 5 points for increasing performance degradation over time. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Simulation & Modeling-3D Simulation",
+  "difficulty": "medium"
+}

package/library/simulation___modeling-3d_simulation/solar-system-simulation-frontend-program.json

@@ -0,0 +1,68 @@
+{
+  "index": 275,
+  "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. Create a frontend program that simulates the solar system.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the solar system model astronomically accurate?",
+      "description": "Review whether the code accurately simulates the correct number of planets, their relative sizes, orbital distances, and rotation speeds. Check if the sun is positioned correctly at the center. Score 0 if fewer than 5 planets are implemented, 5 if all 8 planets are present but with inaccurate proportions, and 10 if all celestial bodies (including dwarf planets and major moons) are implemented with scientifically accurate proportions.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the orbital physics implementation correct?",
+      "description": "Evaluate whether the code implements Kepler's laws of planetary motion, including elliptical orbits, orbital speed variations (faster when closer to the sun), and correct orbital periods. Check if planets rotate on their own axes. Deduct 5 points if orbits are perfectly circular instead of elliptical, and 3 points if orbital speed is constant. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the user interaction system comprehensive?",
+      "description": "Check if the interface allows users to control the simulation (pause/play, speed up/slow down), zoom in/out, and change viewing angles. Evaluate if users can click on planets to get information about them. Deduct 3 points if basic controls are missing, 5 points if the camera system is fixed with no perspective changes possible, and 3 points if there is no way to access information about celestial bodies. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the simulation technically optimized?",
+      "description": "Assess whether the code uses efficient rendering techniques like WebGL instead of Canvas for better performance, implements object pooling for particle effects, and uses requestAnimationFrame properly. Check if the simulation maintains 60 FPS even with all planets visible. Deduct 5 points for frame rate drops below 30 FPS on standard hardware, and 5 points for inefficient rendering approaches that cause unnecessary repaints. 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, tab switching, device rotation, 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. Realistic lighting effects with shadows 2. Comet or asteroid visualizations 3. Historical space mission trajectories). 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 camera control systems) 2. Function modules unrelated to the solar system (e.g., a built-in weather widget) 3. Fancy effects that affect performance (e.g., excessive particle systems). 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 physics engine/rendering/UI layers), code reusability, 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 no performance optimizations are implemented for 3D rendering. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color scheme that represents space accurately (dark background with appropriate lighting) 2) Proper layout for controls that doesn't obstruct the visualization 3) Professional font system for labels and information panels (body font size ≥ 14px, high contrast for readability). Deduct 3 points for cluttered controls, 5 points for inappropriate color schemes that don't resemble space, and 5 points for poor text readability. 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) Smooth planet rotations and orbits without jitter 2) Transition animations when zooming or focusing on planets (300-500ms) 3) Clear visual cues when selecting objects. Deduct 5 points for jerky animations, 3 points for abrupt camera movements, and 5 points for lack of visual feedback when interacting with celestial bodies. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Simulation & Modeling-3D Simulation",
+  "difficulty": "medium"
+}

package/library/simulation___modeling-3d_simulation/threejs-antd-upload-model-texture.json

@@ -0,0 +1,68 @@
+{
+  "index": 352,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the generated code is executable for display. When a model is imported in threejs and there are several elements in the children array, how can you set a texture for the first element using an image file selected through the antd upload component?",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Three.js model loading implementation correct?",
+      "description": "Evaluate whether the code correctly imports and uses Three.js for model loading (GLTFLoader/OBJLoader), and if it properly accesses the model's children array. Check if the first element is properly identified and referenced. Score 0 if Three.js setup is missing, 5 if basic loading is implemented but with errors in accessing children, and 10 if the model loading and children access is fully correct.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the Ant Design Upload component integration complete?",
+      "description": "Check whether the implementation correctly uses the Ant Design Upload component with proper event handling for file selection. Verify that onChange/beforeUpload handlers are properly implemented, and file type validation for images is present. Deduct 5 points if upload callbacks are missing, and 3 points if file type validation is inadequate. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the texture creation and application process correct?",
+      "description": "Assess whether the code properly converts the selected file to a valid Three.js texture using TextureLoader, and correctly applies it to the target mesh material. Check if proper texture parameters are set (wrapping, filtering, etc.). Deduct 5 points if texture loading is implemented incorrectly, and 3 points if texture parameters are not optimized. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there proper error handling for file loading and texture application?",
+      "description": "Evaluate if the code includes error handling for file loading failures, invalid file types, texture loading errors, and model access issues. Check for loading indicators during the process. Deduct 5 points if error handling is missing, and 3 points if user feedback during loading 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 missing model children, unsupported texture formats, memory leaks from unmanaged textures, 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. Texture preview before application 2. Material property adjustment panel 3. Texture transformation 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 texture loading methods) 2. Function modules unrelated to texture application (e.g., unnecessary animation systems) 3. Fancy effects that affect performance (e.g., excessive rendering passes). 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 Three.js rendering/React component/file handling layers), proper resource disposal (texture/geometry disposal), and memory management. 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 texture resources aren't properly disposed when no longer needed. 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 integration of Ant Design components with the 3D viewer 2) Proper layout spacing for controls and the 3D view 3) Consistent visual feedback when applying textures. Deduct 3 points for each disjointed UI element, 5 points for inconsistent styling between React and Three.js elements, and 5 points for poor visual feedback during texture application. 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) Texture application happens within 300ms after selection 2) Loading indicators for lengthy operations 3) Smooth transition when textures are applied to the model. Deduct 5 points for each operation without feedback, 3 points for jarring visual updates when textures are applied, and 5 points for sluggish rendering performance after texture application. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Simulation & Modeling-3D Simulation",
+  "difficulty": "easy"
+}

package/library/simulation___modeling-3d_simulation/threejs-mouse-drag-object-movement.json

@@ -0,0 +1,68 @@
+{
+  "index": 274,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the code you generate is executable for demonstration. three.js mouse drag object movement",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Three.js setup correctly implemented?",
+      "description": "Review whether the code correctly initializes the Three.js environment (renderer, scene, camera, lighting). Check if the canvas is properly configured for responsive design, if WebGL detection is implemented, and if there's a proper animation loop. Score 0 if setup is missing, 5 if basic setup exists but lacks optimization, 10 if fully optimized with fallback options.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the mouse drag object movement functionality properly implemented?",
+      "description": "Evaluate the implementation of raycasting for object selection and the drag-and-drop mechanics. Check if the code handles mouse/touch events correctly (mousedown, mousemove, mouseup), implements proper object selection via raycasting, and maintains object position relative to camera view during drag. Deduct 5 points if dragging works only on one plane, 3 points if there's noticeable lag during dragging. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is collision detection implemented during object movement?",
+      "description": "Check if the code implements collision detection when objects are being dragged. Evaluate whether it uses bounding box, bounding sphere, or more complex collision algorithms appropriate for the scenario. Deduct 5 points if collision is detected but objects can still intersect, 3 points if collision is limited to specific object types. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the implementation handle multi-object selection and movement?",
+      "description": "Review whether the code supports selecting and moving multiple objects simultaneously, including group transformation controls. Check if there's a clear selection indication (highlighting, outline) and if proper transformation gizmos are implemented. Score 0 if only single object movement is supported, 5 if multi-selection exists but with limitations, 10 if full group transformation capabilities are implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as objects moving off-screen, rapid mouse movements, browser resizing, etc.) and provide graceful error handling. 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. Physics-based movement with inertia 2. Gesture support for mobile devices 3. Constraints on object movement like grid snapping). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant event listeners causing performance issues 2. Unnecessary rendering when no interaction occurs 3. Excessive visual effects that impact performance. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core movement functionality is interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating 3D scene setup, interaction logic, and UI components), code organization, and performance optimization techniques like object pooling or frustum culling. Deduct 5 points if global state pollution is found; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if no performance optimizations are implemented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the 3D environment follows proper visual design principles: 1) Appropriate lighting and shadows 2) Clear distinction between background and interactive objects 3) Visual cues for draggable objects. Deduct 3 points for poor lighting that makes objects difficult to see, 5 points for unclear visual hierarchy, and 5 points for lack of visual feedback during interaction. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the object movement feels natural and responsive: 1) No visible lag between mouse movement and object movement (≤ 16ms) 2) Smooth transition effects if implemented 3) Proper depth perception during movement across the 3D space. Deduct 5 points for each jerky movement, 3 points for disorienting camera behavior during drag operations, and 5 points for inconsistent movement speed. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Simulation & Modeling-3D Simulation",
+  "difficulty": "hard"
+}