@getollie/cli 0.0.1

package/library/other-web_development/create-dynamic-website-from-existing-one.json

@@ -0,0 +1,68 @@
+{
+  "index": 325,
+  "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. Could you create a similar dynamic website based on an existing one, and provide me with the source code? If you're confident you can do this, I'll share the website with you. How does that sound?",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Website Structure Implementation",
+      "description": "Evaluate whether the code properly implements the basic structure of the website, including HTML markup, CSS styling, and JavaScript functionality that mirrors the reference site.Score 0 if the structure is completely different from the reference, 5 if it has similar structure but significant differences, and 10 if it accurately reproduces the reference site's structure with proper semantic HTML elements.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Visual Design Fidelity",
+      "description": "Assess how closely the implementation matches the visual design of the reference site, including colors, typography, spacing, and overall layout.Deduct 2 points for each significant visual discrepancy from the reference site (colors off by more than 10% in RGB values, font sizes different by more than 2px, layout spacing off by more than 15px). The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Interactive Elements Functionality",
+      "description": "Check whether all interactive elements (buttons, forms, dropdowns, etc.) function similarly to the reference site, including proper hover states, click events, and form validations.Deduct 2 points for each non-functional interactive element, and 1 point for each element with partial functionality (e.g., hover states work but click events don't). Give 10 points if all interactive elements work as expected.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Responsive Design Implementation",
+      "description": "Evaluate whether the site is responsive like the reference site, adapting properly to different screen sizes (mobile, tablet, desktop) with appropriate breakpoints and media queries.Score 0 if no responsive design is implemented, 5 if basic responsiveness exists but with layout issues at certain breakpoints, and 10 if the implementation adjusts smoothly across all screen sizes matching the reference site's behavior.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as incorrect user input, network failures, resources failing to load, 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 or improvements over the reference site that enhance the experience (e.g., 1. Performance optimizations 2. Accessibility improvements 3. Enhanced animations or transitions).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 2. Function modules unrelated to the reference site 3. Fancy effects that affect performance and weren't in the original site.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 components, styles, and logic), code organization, best practices for the technologies used, and build process implementation.Deduct 5 points if global style/script pollution is found; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no separation of concerns. 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 2) Proper layout spacing 3) Professional font system (body font size ≥ 14px, line height over 1.5 times).Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance.Deduct 5 points for each operation without feedback, 3 points for visual after-images during fast interactions, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Other-Web Development",
+  "difficulty": "hard"
+}

package/library/simulation___modeling-3d_simulation/3d-earth-view-tianditu-supermap.json

@@ -0,0 +1,68 @@
+{
+  "index": 831,
+  "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 ready for demonstration. Create a 3D Earth view by loading satellite imagery and Chinese annotation services from Tianditu (China's map service), combined with SuperMap terrain services. Please provide the project structure and related code.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the 3D Earth visualization fully implemented?",
+      "description": "Evaluate whether the code accurately implements a 3D Earth globe using WebGL/Three.js, with proper sphere geometry, texture mapping of satellite imagery, and camera controls for rotation/zoom. Check if the Earth has realistic shading, atmosphere effects, and proper geographic coordinate mapping. Score 0 if basic Earth rendering is missing, 5 if only a simple textured sphere is implemented, and 10 if a complete Earth representation with proper lighting and atmosphere is achieved.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is Tianditu satellite imagery integration properly implemented?",
+      "description": "Check whether the code correctly implements the Tianditu API for satellite imagery, including proper API key authentication, tile loading system, level-of-detail management, and tile caching mechanisms. Verify if the imagery properly wraps around the Earth sphere with correct geographic positioning. Deduct 5 points if imagery appears distorted, 3 points if there's no caching strategy, and 5 points if tile loading doesn't implement progressive resolution. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are Chinese annotation services correctly integrated?",
+      "description": "Evaluate whether the Chinese annotation layer from Tianditu is properly implemented, including city names, geographic features, and administrative boundaries in Chinese language. Check for proper label placement, collision detection, and dynamic visibility based on zoom level. Deduct 5 points if annotations appear at incorrect geographic positions, 3 points if there's no label prioritization system, and 5 points if Chinese characters render incorrectly. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the SuperMap terrain service integration successful?",
+      "description": "Assess whether the code correctly implements SuperMap terrain services for elevation data, with proper heightmap sampling, terrain mesh generation, and texture blending. Check if the terrain has appropriate detail levels based on viewing distance, and if it correctly aligns with the satellite imagery. Deduct 5 points if terrain appears disconnected from imagery, 3 points if there's no level-of-detail system, and 5 points if elevation data loading doesn't handle errors gracefully. 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 API failures, network interruptions, unsupported browsers, and WebGL limitations) and provide friendly error prompts or fallback mechanisms. Code with strong robustness should implement retry logic for failed tile loading, graceful degradation for older browsers, and memory management for large datasets. Give 10 points if all major edge cases are handled, 5 points if only basic error handling exists, and 0 points if exceptions are not addressed.",
+      "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. Time-based day/night cycle visualization 2. Weather data overlay 3. Historical imagery comparison 4. Point-of-interest search functionality 5. Flight path animations). 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 Earth rendering engines coexisting) 2. Function modules unrelated to the Earth visualization (e.g., unrelated UI components) 3. Fancy effects that affect performance (e.g., excessive shader effects that cause framerate drops). 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 visualization logic/data loading/UI layers), dependency management, code reusability, 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 controls that don't interfere with map visualization 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system with proper support for both Latin and Chinese characters (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) Earth rotation and zoom response ≤ 60ms for smooth 60fps rendering 2) Tile loading with proper visual feedback during retrieval 3) Smooth level-of-detail transitions without popping artifacts. Deduct 5 points for jerky rotation or zoom, 3 points for visible texture popping during navigation, and 5 points for unresponsive controls during data loading. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Simulation & Modeling-3D Simulation",
+  "difficulty": "easy"
+}

package/library/simulation___modeling-3d_simulation/3d-li6ps5cl-crystal-lattice.json

@@ -0,0 +1,68 @@
+{
+  "index": 217,
+  "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. Please help me create a 3D model in HTML format showing the Li₆PS₅Cl crystal lattice with co-doping of Cl and Br elements, and indicate the migration pathways of various ions.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the 3D crystal lattice structure of Li₆PS₅Cl accurately implemented?",
+      "description": "Evaluate whether the code correctly represents the Li₆PS₅Cl crystal structure with proper atom positions, bond lengths, and lattice parameters according to crystallographic data. Check if the code uses the correct space group (F-43m) and includes all atomic positions for Li, P, S, and Cl atoms. Score 0 if the structure is completely inaccurate, 5 if basic structure is present but with significant errors, and 10 if the structure matches published crystallographic data with high accuracy.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the co-doping of Cl and Br elements properly visualized?",
+      "description": "Assess whether the code implements the substitutional doping of Br at Cl sites with appropriate visualization (distinct colors, sizes, or labels). The implementation should show the distribution of dopants either randomly or at specific sites based on energetic considerations. Deduct 5 points if only one halogen element is shown, 3 points if the doping is visually indistinguishable, and 2 points if the doping ratio is unrealistic. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the ion migration pathways clearly visualized?",
+      "description": "Check whether the code effectively visualizes Li+ ion migration pathways through the crystal structure, showing the energy landscape and bottlenecks. The visualization should distinguish between different pathway types (intra-cage vs. inter-cage transitions) and indicate energy barriers. Deduct 5 points if pathways are static only, 5 points if energy barriers are not indicated, and 3 points if the coordination environment changes during migration are not shown. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the implementation use appropriate 3D rendering techniques?",
+      "description": "Evaluate the 3D rendering implementation using WebGL (Three.js, Babylon.js) or similar technologies. The rendering should include proper lighting, camera controls, perspective, material properties, and anti-aliasing. Deduct 3 points for missing camera controls, 3 points for improper lighting that obscures structural details, 2 points for lack of material differentiation between elements, and 2 points for missing anti-aliasing. 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 compatibility issues, WebGL not supported, performance on low-end devices, etc.) and provide friendly error prompts or fallback mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the scientific visualization experience (e.g., 1. Interactive property calculations 2. Real-time manipulation of doping concentration 3. Energy barrier visualization along migration paths 4. Cross-sectional view capabilities). 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 visualization methods 2. Function modules unrelated to crystal structure visualization (e.g., unnecessary UI elements) 3. Effects that affect performance without adding scientific value (e.g., excessive particles or animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core visualization 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 crystal structure data/rendering/interaction layers), performance optimization techniques, and code maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 3 points if the code doesn't implement memory management for large structures; deduct 2 points if the render loop isn't optimized for performance. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional scientific visualization standards?",
+      "description": "Evaluate whether the visualization follows scientific standards: 1) Appropriate color scheme for different elements (following CPK or similar convention) 2) Proper scale representation with measurement indicators 3) Clean interface with scientific annotations and legends. Deduct 3 points for incorrect atom coloring, 3 points for missing scale indicators, and 4 points for lack of proper legends explaining visual elements. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the interactive experience intuitive and educational?",
+      "description": "Judge whether the interactive features enhance understanding: 1) Responsive rotation, zoom, and pan controls 2) Interactive selection of specific atoms or pathways 3) Visual feedback when examining structures 4) Educational tooltips or information panels. Deduct 3 points for sluggish controls, 2 points for missing selection capabilities, 3 points for lack of educational content, and 2 points for unintuitive UI elements. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Simulation & Modeling-3D Simulation",
+  "difficulty": "hard"
+}

package/library/simulation___modeling-3d_simulation/display-unstructured-vtk-models-threejs.json

@@ -0,0 +1,68 @@
+{
+  "index": 387,
+  "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 demonstration. How to display unstructured .vtk models in Three.js? Please provide code.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "1. Is the VTK file loading mechanism properly implemented?",
+      "description": "Evaluate whether the code correctly implements a loading mechanism for .vtk files. Check if it handles different VTK formats (ASCII/binary), supports various VTK datasets (structured/unstructured), and provides proper error handling during file parsing. Score 0 if no loading mechanism exists, 5 if only basic ASCII VTK is supported, and 10 if comprehensive VTK format support is implemented with robust error handling.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "2. Is the conversion from VTK to Three.js geometry properly implemented?",
+      "description": "Assess whether the code correctly transforms VTK geometric elements (points, cells) into appropriate Three.js geometries. Check if it handles different cell types (tetrahedra, hexahedra, etc.) and properly constructs faces/edges. Verify if attributes like normals and colors are preserved. Score 0 if no conversion exists, 5 if only basic conversions are implemented, and 10 if all common VTK element types are properly converted with attribute preservation.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "3. Does the code handle unstructured grid visualization specifically?",
+      "description": "Check whether the code specifically addresses the challenges of unstructured grids in VTK. Verify if it properly handles the irregular topology, performs efficient triangulation for visualization, and maintains topological relationships. Deduct 5 points if the implementation only handles structured grids, and 3 points if the unstructured visualization is inefficient. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "4. Are visualization controls and interactions implemented?",
+      "description": "Evaluate if the code provides essential visualization controls (rotation, pan, zoom) and additional interactions like section cutting, clipping planes, or picking. Check if camera controls are smooth and intuitive. Deduct 5 points if basic controls are missing, and 3 points if advanced interactions are absent. Give 10 points if comprehensive interaction features are implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "5. Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as malformed VTK files, memory limitations with large models, 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": "6. Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. On-the-fly scalar field visualization 2. Cross-section analysis tools 3. Dynamic mesh refinement). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "7. Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant data processing steps that could be optimized 2. Visualization features unrelated to VTK model display 3. Fancy effects that affect rendering performance unnecessarily. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functionality is compromised by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "8. Does the code have engineering quality?",
+      "description": "Review modular design (such as separating VTK parsing/geometry conversion/rendering), code reusability, and memory management for large models. 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 attention is paid to memory optimization for large meshes. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "9. Does the interface vision meet professional visualization standards?",
+      "description": "Evaluate whether the visualization follows scientific visualization principles: 1) Appropriate color maps for scalar data 2) Clear distinction between model components 3) Professional lighting setup that enhances geometric perception. Deduct 3 points for poor color choices that obscure data patterns, 5 points for inadequate lighting that flattens 3D perception, and 5 points for cluttered visual presentation. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "10. Is the rendering performance optimized?",
+      "description": "Judge whether the rendering is optimized for performance: 1) Appropriate use of BufferGeometry for large meshes 2) Level-of-detail techniques for complex models 3) Efficient shader usage. Deduct 5 points for each performance bottleneck (frame rate below 30fps for moderate-sized models), 3 points for missing optimizations with large datasets, and 5 points if memory leaks occur during model switching. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Simulation & Modeling-3D Simulation",
+  "difficulty": "medium"
+}

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

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

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

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

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