@getollie/cli 0.0.5 → 0.2.1

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

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

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

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

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

package/library/simulation___modeling-3d_simulation/virtual-photography-studio-lighting-scenario.json

@@ -1,68 +0,0 @@
-{
-  "index": 726,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you provide is executable and can be demonstrated. I am a photography practical training instructor, and when conducting portrait photography sessions in a studio, lighting setup is a challenging aspect. I would like to design a virtual photography studio lighting scenario. Please help me design the code for this.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the virtual photography studio environment fully implemented?",
-      "description": "Review whether the code accurately creates a 3D/2D virtual studio environment with proper spatial dimensions, camera positioning, and subject placement. Check if the studio can be viewed from multiple angles. Score 0 if no proper environment is created, 5 if a basic environment exists but lacks detail, and 10 if the studio environment is complete with proper scale and perspectives.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the lighting system comprehensive and realistic?",
-      "description": "Evaluate whether the code implements various lighting types (key light, fill light, rim light, background light, etc.) with adjustable parameters (intensity, color temperature, softness, angle). Check if light modifiers (softboxes, umbrellas, reflectors, snoots) are implemented. Deduct 5 points if only basic lighting is available, 3 points if light modifiers are missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the lighting effect rendering accurate and physically based?",
-      "description": "Check whether the lighting effects follow physical principles, including proper shadow casting, light falloff with distance, color blending, and reflections. Verify if the code simulates the inverse-square law for light intensity. Deduct 5 points if shadows are unrealistic, 3 points if light falloff is incorrect. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the user interface for lighting manipulation intuitive and comprehensive?",
-      "description": "Assess whether the interface allows users to easily add, remove, position, and adjust lighting equipment with visual feedback. Check if it includes drag-and-drop functionality, sliders for intensity/temperature controls, and visual indicators of light direction. Deduct 3 points for each essential control missing, and 5 points if the interface is confusing or unintuitive. 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 extreme lighting values, browser resizing, incompatible 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 histogram display 2. Lighting setup templates/presets 3. Before/after comparison views 4. Simulated portrait with different skin tones). 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 lighting controls 2. Function modules unrelated to photography lighting 3. Fancy effects that affect performance and distract from the educational purpose. 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 lighting logic/view/rendering layers), code organization, and performance optimization. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the rendering performance is poor on standard hardware. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching suitable for a photography application (neutral, non-distracting colors) 2) Proper layout spacing for lighting controls 3) Professional font system with clear labeling of lighting equipment. Deduct 3 points for each crowded visual element, 5 points for a distracting color scheme that makes light evaluation difficult, 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 educational?",
-      "description": "Judge whether the lighting adjustments provide immediate visual feedback and educational value: 1) Light adjustment feedback delay ≤ 100ms 2) Visual representation of how changing parameters affects the image 3) Clear indication of lighting principles in action. Deduct 5 points for each lighting adjustment without visible feedback, 3 points for laggy rendering during adjustments, and 5 points for lack of educational context in the simulation. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Simulation & Modeling-3D Simulation",
-  "difficulty": "hard"
-}

package/library/simulation___modeling-3d_simulation/vr-panoramic-tour-script-framework.json

@@ -1,68 +0,0 @@
-{
-  "index": 1507,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure that any code you generate is executable for demonstration purposes. • VR panoramic tour script framework",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the VR panoramic engine core correctly implemented?",
-      "description": "Evaluate if the code implements essential VR panorama functionality including equirectangular projection handling, sphere or cube mapping, proper field of view (FOV) calculations, and camera orientation controls. Score 0 if core rendering is missing, 5 if basic equirectangular display works but has distortion issues, 10 if it properly handles all projection types with correct perspective.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Does the code implement a proper navigation system for VR tour points?",
-      "description": "Check if the codebase provides a complete tour point system with hotspot management, scene transitions, waypoint visualization, and navigation controls. Deduct 3 points if hotspots aren't interactive, 4 points if scene transitions lack smooth blending effects, and 3 points if the tour graph structure isn't properly maintained. Full score requires a complete navigation state machine with history tracking.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is device orientation and control handling properly implemented?",
-      "description": "Verify if the code includes comprehensive device orientation support using gyroscope/accelerometer for mobile devices, mouse/touch drag controls, and proper handling of different input methods. Deduct 5 points if orientation controls aren't normalized across devices, 3 points if there's no device capability detection, and 2 points if smooth inertial movement is missing. Full implementation should include proper permission handling for device sensors.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Does the framework provide proper VR stereo rendering and WebXR integration?",
-      "description": "Assess whether the code implements proper stereoscopic rendering for VR headsets, includes WebXR API integration, handles correct interpupillary distance calculations, and manages head tracking. Deduct 5 points if stereo rendering is missing, 3 points if WebXR integration is incomplete, and 2 points if there's no fallback for non-WebXR browsers. The full score requires distortion correction for VR lenses.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code handles common VR-specific issues like device orientation permission denials, WebGL context loss, texture loading failures, and memory management for large panoramas. Code should gracefully degrade when features aren't available and provide clear error feedback. Deduct 3 points for each unhandled critical error scenario, and 2 points if performance monitoring is absent.",
-      "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. Spatial audio integration 2. Interactive annotations with multimedia support 3. Procedural environment effects like weather/lighting 4. Auto-tour capabilities with timed transitions). Add 2.5 points for each practical innovative feature implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant rendering paths that could be unified 2. Feature modules unrelated to VR panoramic functionality 3. Heavy visual effects that significantly impact performance on mobile devices. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core VR experience is compromised by unnecessary code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review the architecture for separation of concerns (renderer/controller/data model), proper asset loading pipeline, memory management for large panoramic images, and optimization techniques. Deduct 3 points for global state pollution, 3 points for lack of texture compression options, 2 points if there's no progressive loading for panoramas, and 2 points if the build process isn't optimized for web delivery.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the VR UI follows best practices: 1) Proper depth positioning of UI elements (0.5-2m virtual distance) 2) Ergonomic placement avoiding neck strain (within 30° vertical FOV) 3) Sufficient contrast and legibility at various distances 4) Gaze/controller interaction affordances. Deduct 3 points for each violation of VR ergonomic principles and 5 points for interfaces causing potential motion sickness.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the VR experience smooth and comfortable?",
-      "description": "Judge whether the implementation prioritizes user comfort: 1) Maintains min. 60fps without frame drops 2) Implements proper motion damping to prevent nausea 3) Avoids sudden camera movements or rotations 4) Includes comfort settings for movement speed and FOV adjustments. Deduct 3 points for each performance bottleneck identified, 5 points for missing comfort options, and 2 points if the experience doesn't gracefully handle variable device performance.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Simulation & Modeling-3D Simulation",
-  "difficulty": "medium"
-}

package/library/simulation___modeling-3d_simulation/vue-3-cesium-wms-terrain-excavation-effects.json

@@ -1,68 +0,0 @@
-{
-  "index": 1592,
-  "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. Create Vue 3 code for loading WMS layers in Cesium and implementing terrain excavation (hole digging) effects.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Vue 3 integration with CesiumJS properly implemented?",
-      "description": "Evaluate whether the code correctly integrates Vue 3 with CesiumJS using proper lifecycle hooks (onMounted, onBeforeUnmount). Check for proper viewer initialization, resource cleanup, and whether Vue reactivity is leveraged for Cesium entity management. Score 0 if there's no Vue 3 integration, 5 if basic integration exists but with flaws, 10 if integration follows Vue 3 best practices with Composition API.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the WMS layer loading functionality complete and configurable?",
-      "description": "Examine whether the code implements proper WMS layer loading with all necessary parameters (URL, layers, format, transparent, etc.). Check if the implementation allows for dynamic layer switching, opacity control, and visibility toggling. Deduct 3 points if basic WMS parameters are missing, 3 points if there's no error handling for failed layer loading, and 2 points if layer customization options are limited. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the terrain excavation (hole digging) functionality correctly implemented?",
-      "description": "Analyze the implementation of terrain excavation using techniques like ClippingPlanes or inverse polygon clipping. Check if the code handles proper depth testing, supports dynamic hole shapes, and maintains proper rendering performance. Score 0 if terrain excavation is not implemented, 5 if basic hole digging works but has visual artifacts or performance issues, 10 if the implementation is complete with smooth edges and proper depth handling.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Does the code provide interactive controls for excavation manipulation?",
-      "description": "Evaluate whether the code allows users to interactively define and modify excavation areas through mouse/touch interactions. Check for features like drawing polygons, resizing holes, and adjusting excavation depth. Deduct 3 points if only predefined excavation areas are supported, 4 points if interaction is limited to basic operations, and 5 points if the interaction is not intuitive or has usability issues. 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 WMS service unavailability, incorrect layer parameters, WebGL context loss, 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 excavation volume calculation 2. Multiple simultaneous excavation areas 3. Excavation animation effects with timing 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 implementations of similar functions (e.g., multiple clipping mechanisms coexisting) 2. Function modules unrelated to the core requirements (e.g., unnecessary camera animations) 3. Fancy effects that affect performance (e.g., excessive post-processing 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 Cesium logic/Vue components/utility functions), component reusability, and proper TypeScript typing (if applicable). Deduct 5 points if global state pollution is found or composition functions are not properly used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if proper types/interfaces are not defined for critical operations. 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 controls and visualization (no more than 3 primary colors) 2) Proper layout spacing for control panels (element spacing follows the 8px multiple principle) 3) Professional font system for labels and instructions (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Immediate visual feedback when defining excavation areas 2) Smooth camera transitions when focusing on areas 3) Responsive UI controls with clear state indication. Deduct 5 points for laggy excavation rendering, 3 points for jerky camera movements during interactions, and 5 points for delayed response when modifying excavation parameters. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Simulation & Modeling-3D Simulation",
-  "difficulty": "medium"
-}

package/library/simulation___modeling-3d_simulation/vue-vtk-animate-nodal-displacement.json

@@ -1,68 +0,0 @@
-{
-  "index": 1568,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable.\n\n```javascript\n@wraps(animate_nodal_solution)\ndef animate_nodal_displacement(self, *args, **kwargs):\n    \"\"\"wraps animate_nodal_solution\"\"\"\n    return self.animate_nodal_solution(*args, **kwargs)\n\ndef animate_nodal_solution(\n    self,\n    rnum,\n    comp=\"norm\",\n    node_components=None,\n    element_components=None,\n    sel_type_all=True,\n    add_text=True,\n    displacement_factor=0.1,\n    n_frames=100,\n    loop=True,\n    movie_filename=None,\n    progress_bar=True,\n    **kwargs,\n):\n    \"\"\"Animate nodal solution.\n\n    Assumes nodal solution is a displacement array from a modal or static\n    solution.\n\n    rnum : int or list\n        Cumulative result number with zero based indexing, or a\n        list containing (step, substep) of the requested result.\n\n    comp : str, default: \"norm\"\n        Scalar component to display.  Options are ``'x'``,\n        ``'y'``, ``'z'``, and ``'norm'``, and ``None``.\n\n    node_components : list, optional\n        Accepts either a string or a list strings of node\n        components to plot.  For example:\n        ``['MY_COMPONENT', 'MY_OTHER_COMPONENT]``\n\n    element_components : list, optional\n        Accepts either a string or a list strings of element\n        components to plot.  For example:\n        ``['MY_COMPONENT', 'MY_OTHER_COMPONENT]``\n\n    sel_type_all : bool, optional\n        If node_components is specified, plots those elements\n        containing all nodes of the component.  Default ``True``.\n\n    add_text : bool, optional\n        Adds information about the result.\n\n    displacement_factor : float, optional\n        Increases or decreases displacement by a factor.\n\n    n_frames : int, optional\n        Number of \"frames\" between each full cycle.\n\n    loop : bool, optional\n        Loop the animation.  Default ``True``.  Disable this to\n        animate once and close.  Automatically disabled when\n        ``off_screen=True`` and ``movie_filename`` is set.\n\n    movie_filename : str, pathlib.Path, optional\n        Filename of the movie to open.  Filename should end in\n        ``'mp4'``, but other filetypes may be supported like\n        ``\"gif\"``.  See ``imagio.get_writer``.  A single loop of\n        the mode will be recorded.\n\n    progress_bar : bool, default: True\n        Displays a progress bar when generating a movie while\n        ``off_screen=True``.\n\n    kwargs : optional keyword arguments\n        See :func:`pyvista.plot` for additional keyword arguments.\n\n    Examples\n    --------\n    Animate the first result interactively.\n\n    >>> rst.animate_nodal_solution(0)\n\n    Animate second result while displaying the x scalars\n    without looping\n\n    >>> rst.animate_nodal_solution(1, comp='x', loop=False)\n\n    Animate the second result and save as a movie.\n\n    >>> rst.animate_nodal_solution(0, movie_filename='disp.mp4')\n\n    Animate the second result and save as a movie in the background.\n\n    >>> rst.animate_nodal_solution(0, movie_filename='disp.mp4', off_screen=True)\n\n    Disable plotting within the notebook.\n\n    >>> rst.animate_nodal_solution(0, notebook=False)\n\n    \"\"\"\n```\n\nThis is the source code of animate_nodal_displacement in pyansys. Please rewrite this code using Vue's vtk.js to implement the same functionality.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Vue/vtk.js implementation of animate_nodal_solution complete?",
-      "description": "Review whether the code accurately translates the PyANSYS animation functionality to Vue/vtk.js. Check for correct handling of displacement visualization, component selection (x, y, z, norm), and proper animation cycle implementation. Verify the displacement factor parameter is properly applied to exaggerate/diminish the visualization.Score 0 if core functionality is missing, 5 if basic animation works but lacks component selection, 10 if fully implemented with all parameter options.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the result selection and processing correctly implemented?",
-      "description": "Evaluate the handling of 'rnum' parameter (result number or step/substep list) in the Vue/vtk.js version. Check if the code properly extracts and processes nodal solution data from selected results, including proper data mapping for visualization. The implementation must handle both single result numbers and step/substep pairs.Deduct 5 points if only single result numbers are supported, 3 points if data mapping is incorrect, and 5 points if the extraction logic is missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are node and element component selection capabilities implemented?",
-      "description": "Check if the code correctly implements the node_components and element_components parameters, allowing users to select specific components for visualization. Verify that sel_type_all parameter works as expected for element selection based on node components.Deduct 5 points if component selection is missing, 3 points if sel_type_all logic is incorrect, and 2 points if the component filtering is inefficient. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the animation control system effectively translated from PyANSYS to Vue/vtk.js?",
-      "description": "Verify the implementation of animation parameters (n_frames, loop, movie_filename). Check if the animation correctly cycles through frames with proper timing, respects the loop parameter, and supports exporting to video files where applicable in the Vue ecosystem.Deduct 4 points if frame control is missing, 3 points if looping doesn't work correctly, and 3 points if video export capabilities are missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as missing data, invalid parameters, browser compatibility issues) and provide friendly error prompts or recovery mechanisms. Check for proper validation of input parameters and graceful degradation when features are unavailable.Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Interactive scalar selection during animation 2. Real-time statistics of displacement values 3. Animation speed control). Look for features that go beyond the original PyANSYS implementation while maintaining compatibility.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 animation loops) 2. Function modules unrelated to visualization (e.g., unnecessary UI elements) 3. Fancy effects that affect performance (e.g., excessive WebGL effects that slow rendering). Assess if the code maintains focus on core functionality.Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review Vue component design (such as separating visualization logic/UI controls/data processing), test coverage, and build process integration. Check for proper use of Vue reactivity system, component lifecycle hooks, and vtk.js best practices. Examine code organization and maintainability.Deduct 5 points if global state pollution is found or Vue 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 integration is incomplete. 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 modern design principles: 1) Harmonious color mapping for scalar visualization 2) Proper layout of controls and viewport 3) Clear labeling and information presentation. Check if the add_text parameter is properly implemented to show result information.Deduct 3 points for each crowded visual element, 5 points for poor color mapping choices, and 5 points for chaotic control layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Responsive UI controls 2) Smooth animation transitions 3) Proper frame rate during animation. Check if the progress_bar parameter is properly implemented and provides useful feedback during processing or export operations.Deduct 5 points for each operation without feedback, 3 points for stuttering during animation, and 5 points for hard-to-use animation controls. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Simulation & Modeling-3D Simulation",
-  "difficulty": "hard"
-}