@getollie/cli 0.0.5 → 0.2.0

package/library/simulation___modeling-3d_simulation/fire-evacuation-simulation-cesium-animation.json

@@ -1,68 +0,0 @@
-{
-  "index": 876,
-  "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 implement a step-by-step animation simulation of fire evacuation based on Cesium, including steps such as fire outbreak, alarm activation, personnel evacuation, fire truck arrival, firefighting, etc.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Cesium environment properly initialized with appropriate terrain and imagery?",
-      "description": "Check if the code includes proper Cesium initialization, with correct API keys, terrain provider configuration, and high-resolution imagery for realistic building representation. The viewer should have proper camera controls and navigation settings. Score 0 if Cesium is not initialized, 5 if basic initialization is present but lacks optimization, and 10 if fully configured with performance optimizations.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are the fire simulation physics and visual effects realistically implemented?",
-      "description": "Review the fire simulation algorithm for realism including fire spread patterns, smoke propagation physics, and environmental factors (wind, building materials). Visual effects should include particle systems for flames/smoke with proper opacity, color gradients, and lighting. Deduct 5 points if fire spread is unrealistic, 3 points if smoke physics is missing, and 3 points if visual effects lack dynamic elements. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the evacuation path-finding and crowd simulation properly implemented?",
-      "description": "Evaluate the evacuation algorithm implementation including A* or Dijkstra's for path-finding, crowd density considerations, and bottleneck handling. Check for agent-based modeling with realistic human behaviors (panic, group dynamics, leader-following). Deduct 5 points if basic path-finding is missing, 3 points if crowd density is not considered, and 5 points if evacuation doesn't account for fire spread. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are the emergency response elements (alarm systems, fire trucks, firefighters) accurately modeled?",
-      "description": "Examine implementation of alarm activation logic, emergency vehicle routing with traffic consideration, and firefighter deployment strategies. Check for realistic time delays between steps and proper coordination of resources. Deduct 3 points if alarms don't trigger properly, 5 points if emergency vehicles don't follow realistic routes, and 5 points if firefighting logic doesn't consider fire intensity and type. 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 3D models, API failures, user operation errors, 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 statistics dashboard of evacuees 2. Multiple fire scenarios with different outcomes 3. Interactive training mode for evacuation planning). 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 path-finding algorithms running simultaneously) 2. Function modules unrelated to fire evacuation (e.g., unnecessary weather effects) 3. Fancy effects that affect performance (e.g., excessive particle systems that slow rendering). 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 fire simulation/evacuation logic/rendering 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 UI elements and fire visualization 2) Proper layout spacing for control panels and information displays 3) Professional font system for alerts and statistics. 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 transitions between evacuation phases feel natural: 1) Smooth camera transitions between scenes 2) Proper timing of events in the evacuation sequence 3) Clear visual indicators of the current phase. Deduct 5 points for jerky camera movements, 3 points for unrealistic timing between evacuation steps, and 5 points for lack of user controls to pause/resume the simulation. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Simulation & Modeling-3D Simulation",
-  "difficulty": "hard"
-}

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

@@ -1,68 +0,0 @@
-{
-  "index": 435,
-  "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. Write 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 represents the planets in our solar system with correct relative sizes, distances, and orbital parameters. Check if the sun is positioned at the center and planets revolve around it following Kepler's laws. Score 0 if planets are arbitrarily positioned, 5 if basic orbits are implemented but with inaccurate parameters, and 10 if the simulation closely matches real astronomical data.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are planetary movements and rotations properly implemented?",
-      "description": "Evaluate whether each planet rotates on its axis and revolves around the sun at appropriate speeds. Check if orbital periods and rotation periods are proportionally accurate (not necessarily real-time, but maintaining correct ratios). Deduct 3 points if rotation is missing, 5 points if orbital mechanics are incorrect, and 2 points if the speed controls aren't implemented. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the simulation interactive with proper user controls?",
-      "description": "Check whether users can interact with the solar system through features like zoom in/out, changing perspective/angles, adjusting simulation speed, or clicking on planets for information. Deduct 3 points for each missing basic control (zoom, rotation, speed). Give full 10 points if the interface includes advanced features like following a specific planet's orbit or viewing from a planet's perspective.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are visual details of celestial bodies well-implemented?",
-      "description": "Assess whether planets have distinctive textures/colors matching their real appearance, proper lighting/shading from the sun, and additional details like rings for Saturn or cloud patterns for gas giants. Score 3 points for basic colored spheres, 7 points for textured planets with simple lighting, and 10 points for detailed rendering with atmospheric effects and accurate surface features.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as window resizing, browser compatibility issues, performance constraints on different devices, etc.) and provide graceful degradation for older browsers. 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 cycle visualization on planets 2. Displaying planetary information on hover/click 3. Visualization of gravitational fields or orbital paths 4. Inclusion of major moons or asteroid belts). 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 methods 2. Function modules unrelated to the solar system simulation 3. Fancy effects that significantly impact performance without adding educational or visual value. 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 for celestial body creation, and performance optimization techniques. 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 optimization for rendering efficiency. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Clean space-themed color palette (dark background with appropriate contrast) 2) Proper layout spacing for controls and information panels 3) Professional font system that's readable against the space background. Deduct 3 points for cluttered controls, 5 points for color combinations that reduce visibility of celestial bodies, and 5 points for poor information hierarchy. 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 animation with consistent frame rates ≥ 30fps 2) Responsive controls with immediate visual feedback 3) Proper camera transitions when changing views. Deduct 5 points for jerky animations, 3 points for delayed response to user input, and 5 points for disorienting camera movements. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Simulation & Modeling-3D Simulation",
-  "difficulty": "easy"
-}

package/library/simulation___modeling-3d_simulation/indoor-3d-pathfinding-uniapp-mini-program.json

@@ -1,68 +0,0 @@
-{
-  "index": 1697,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Be sure to provide executable code when possible. How can I integrate indoor 3D models with pathfinding to develop indoor path planning code for a UniApp mini-program?",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the 3D model loading and rendering system properly implemented?",
-      "description": "Evaluate whether the code efficiently loads and renders 3D models using appropriate frameworks (Three.js, Babylon.js) compatible with UniApp. Check for proper model optimization techniques (LOD, texture compression, geometry instancing). Score 0 if no 3D rendering code is provided, 5 if basic rendering is implemented without optimization, and 10 if fully optimized rendering with proper memory management is included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the pathfinding algorithm implementation complete and efficient?",
-      "description": "Review the implementation of pathfinding algorithms (A*, Dijkstra, NavMesh). Assess whether the algorithm handles indoor constraints (walls, doors, stairs) correctly. Verify performance optimization such as spatial indexing for large environments. Deduct 3 points if only basic algorithms are implemented without spatial optimization, 5 points if the algorithm doesn't handle multi-level navigation (stairs/elevators), and 2 points if no performance benchmarks are provided. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is there a proper integration between 3D models and navigation data?",
-      "description": "Check whether the code includes a system to extract or map navigation data from 3D models or integrate external navigation meshes. Evaluate if the system handles model coordinate systems properly and includes a mechanism to update navigation data when the model changes. Deduct 5 points if manual mapping is required, 3 points if there's no update mechanism, and 5 points if coordinate transformations are incorrect. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the UniApp integration handled correctly for cross-platform compatibility?",
-      "description": "Assess whether the code properly uses UniApp APIs and follows its lifecycle management. Check if the implementation handles platform differences (iOS/Android/H5) and uses appropriate rendering contexts. Deduct 5 points if WebView performance is not optimized, 3 points if platform-specific code is not separated appropriately, and 5 points if the solution doesn't work on all major platforms. 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 model loading failures, navigation errors, memory constraints on mobile devices, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Real-time rerouting when obstacles appear 2. AR visualization of paths 3. Indoor positioning integration 4. Voice guidance for navigation). 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 functions (e.g., multiple pathfinding algorithms without clear purpose) 2. Function modules unrelated to indoor navigation (e.g., unnecessary social features) 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 3D rendering/navigation/UI 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 for UniApp. 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) Clear visualization of 3D space with proper lighting and materials 2) Intuitive path representation (contrasting colors, proper width) 3) UI elements that don't obstruct the 3D view but remain accessible. Deduct 3 points for cluttered navigation indicators, 5 points for poor contrast between paths and environment, and 5 points for UI elements that obscure important parts of the navigation. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and performance-optimized?",
-      "description": "Judge whether the application maintains good performance on mobile devices: 1) Stable 30+ FPS during navigation 2) Responsive controls with touch feedback ≤ 100ms 3) Efficient memory usage (under 300MB) for 3D models. Deduct 5 points for frame drops during camera movement, 3 points for navigation calculation delays over 500ms, and 5 points for memory leaks during extended usage. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Simulation & Modeling-3D Simulation",
-  "difficulty": "hard"
-}

package/library/simulation___modeling-3d_simulation/nurbs-curve-3d-graph-control-points.json

@@ -1,68 +0,0 @@
-{
-  "index": 1065,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to generate executable code for demonstration. Help me create a program for a NURBS curve in a three-dimensional graph, which should display both the NURBS curve and its control points, then visualize this program.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the NURBS curve implementation mathematically correct?",
-      "description": "Review whether the code accurately implements the NURBS curve mathematical formulation, including basis functions, knot vectors, weights, and proper parameterization. Score 0 if the core NURBS formula is incorrect, 5 if basic B-spline functionality is implemented but weights aren't properly handled, and 10 if the implementation fully supports rational curves with mathematically sound calculations.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the 3D visualization of the NURBS curve properly implemented?",
-      "description": "Check whether the visualization correctly renders the NURBS curve in 3D space with appropriate resolution (enough points to make the curve appear smooth). The curve should be continuously rendered without visual artifacts or gaps. Deduct 5 points for discontinuities in the curve, 3 points for insufficient sampling causing a 'jagged' appearance, and 2 points if curve extremities are improperly handled. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are control points properly visualized and interactive?",
-      "description": "Evaluate whether control points are clearly visible as distinct markers in the 3D space, with appropriate size and contrast against the curve. Check for interactive features such as hovering effects, selection capability, or dragging functionality to modify curve shape. Deduct 5 points if control points lack visual distinction, 5 points if no interaction with control points is possible, and 2 points if the control polygon (lines connecting control points) is missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the relationship between control points and the resulting curve visually clear?",
-      "description": "Assess whether the program visually demonstrates the influence of control points on the curve shape, potentially through real-time updates when points are moved or through visual cues like control polygons or influence regions. Deduct 5 points if changes to control points don't update the curve in real-time, and 3 points if the visual connection between points and curve isn't intuitive. Give 10 points if the relationship is immediately clear and educational.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle edge cases such as coincident control points, extreme weight values, or high-degree curves without crashing. Test boundary conditions like minimum number of control points for the specified degree. Code with strong robustness should gracefully handle these cases with appropriate error messages or constraints. Give 10 points for comprehensive error handling, 5 points for basic validation only, and 0 points if the code fails under common edge cases.",
-      "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. Dynamic knot insertion/removal visualization 2. Degree elevation demonstration 3. Surface generation from multiple curves 4. Curvature visualization). 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 basis functions when they could be cached 2. Visualization features unrelated to NURBS demonstration (e.g., unrelated 3D models) 3. Fancy effects that affect performance without educational benefit. 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 (separate modules for math, visualization, interaction), appropriate commenting, and efficient algorithms (e.g., de Boor algorithm for evaluation). Deduct 5 points if global state is overused; deduct 5 points if the NURBS evaluation algorithm is inefficient (e.g., naive implementation instead of optimized recursive approaches); deduct 5 points if mathematical operations aren't numerically stable. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the 3D visualization follows professional design principles: 1) Appropriate color contrast between curve, control points, and background 2) Clear labeling of axes and UI elements 3) Professional camera controls (pan/zoom/rotate). Deduct 3 points for poor color choices that make elements hard to distinguish, 5 points for missing or confusing navigation controls, and 5 points for cluttered UI that obscures the mathematical visualization. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects support understanding of NURBS: 1) Control point manipulation has immediate visual feedback 2) Camera/view manipulation is smooth and intuitive 3) Curve recomputation after parameter changes occurs within 100ms. Deduct 5 points for laggy response when manipulating control points, 3 points for jerky animation during camera movement, and 5 points if curve parameter adjustments (degree, knot insertions) don't provide clear visual feedback. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Simulation & Modeling-3D Simulation",
-  "difficulty": "easy"
-}

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

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

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

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

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