@getollie/cli 0.0.1

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

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

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

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

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

package/library/simulation___modeling-mathematical_abstraction/graphic-intersection-blending-square-circle.json

@@ -0,0 +1,68 @@
+{
+  "index": 378,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Pay attention to ensuring that the generated code is executable for demonstration. Use Node.js in WebStorm to implement a graphic showing the intersection/blending of a square and a circle.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the geometric representation of both shapes implemented correctly?",
+      "description": "Review whether the code accurately defines and renders both the square and circle with proper parameters (coordinates, dimensions, radius). The square should have consistent side lengths, and the circle should be mathematically accurate. Score 0 if shapes are incorrectly implemented, 5 if basic shapes are drawn but with minor inaccuracies, and 10 if both shapes are perfectly implemented with proper mathematical properties.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the intersection/blending calculation algorithm implemented correctly?",
+      "description": "Check whether the code accurately calculates the intersection between the square and circle using proper mathematical formulas. The intersection should be precisely determined with appropriate geometric calculations (distance checks, boundary evaluations). Deduct 5 points if the algorithm only approximates the intersection, 3 points if edge cases aren't handled (e.g., tangent points, complete overlap). The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the visual representation of the intersection/blending rendered properly?",
+      "description": "Evaluate how the intersection/blending is visually displayed. The overlapping area should be clearly distinguishable from the non-overlapping parts with appropriate visual treatment (different color, opacity, or pattern). Deduct 5 points if the intersection area is not visually distinct, and 3 points if the blending effect lacks visual clarity. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the implementation provide interactive capabilities?",
+      "description": "Assess whether the code allows users to interact with the shapes (e.g., moving shapes, resizing, changing parameters). Check for event listeners that enable drag-and-drop functionality or parameter adjustments. Deduct 3 points if only basic interactions are implemented, 5 points if interactions are limited to only one shape, and 5 points if real-time intersection updates 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 invalid inputs, edge cases in shape positioning, rendering issues, 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. Multiple blending modes like SVG's 'multiply', 'screen', etc. 2. Mathematical formulas display alongside visualization 3. Animation showing how intersection changes with movement). 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 calculations or rendering passes that affect performance 2. Unnecessary complexity in algorithms where simpler solutions exist 3. Extraneous visual elements unrelated to the geometric intersection task. 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": "Does the code have engineering quality?",
+      "description": "Review modular design (separating rendering logic from calculation logic), proper variable naming, code comments, and application of appropriate design patterns. Deduct 5 points if global variables are overused; deduct 5 points if the code is not organized into logical functions or classes; deduct 5 points if documentation is missing for complex algorithms. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Clean and minimal UI that doesn't distract from the geometric visualization. Deduct 3 points for each visually distracting element, 5 points for poor color choices that make intersection difficult to see, and 5 points for cluttered controls. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and responsive?",
+      "description": "Judge whether the rendering and calculation performance meets standards: 1) Rendering updates occur at 60fps without visible lag 2) Intersection calculations complete within 16ms to maintain smooth framerate 3) Shape manipulations respond instantly to user input. Deduct 5 points for noticeable lag during interaction, 3 points for jerky animations, and 5 points for calculation delays that affect user experience. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Simulation & Modeling-Mathematical Abstraction",
+  "difficulty": "easy"
+}

package/library/simulation___modeling-mathematical_abstraction/interactive-rectangle-cylinder-manipulation.json

@@ -0,0 +1,68 @@
+{
+  "index": 1157,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Try to ensure the generated code is executable for display. Please use JavaScript+CSS+HTML to help me implement the following requirements:\n\n1. The system generates a rectangle that can be resized by dragging to change its length and width.\n2. When a student selects one edge of the rectangle and clicks the \"Rotate\" button, the rectangle rotates around the line containing that edge for one complete revolution, generating a cylinder model.\n3. When a student clicks the \"Reset\" button, the display returns to the initial rectangle. Students can change the rectangle's length or width, or select a different edge for rotation to observe the corresponding cylinder that is generated.\n4. When a student clicks the \"Cut\" button, the cylinder is cut along any generatrix, opening the lateral surface of the cylinder and laying it flat on a plane, with an animation effect.\n5. When a student clicks the \"Pen\" button, they can annotate letters on the cylinder or rectangle.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the interactive resizable rectangle fully implemented?",
+      "description": "Review whether the code correctly implements a rectangle that can be resized by dragging its edges or corners. The implementation should include handle points for resizing, visual feedback during the dragging operation, and smooth size updates. Score 0 if resizing functionality is missing, 5 if basic resizing is implemented but with usability issues, and 10 if resizing works smoothly with proper constraints and visual feedback.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the cylinder rotation functionality properly implemented?",
+      "description": "Check if the code properly implements the rotation of the rectangle around a selected edge to form a cylinder. This should include: edge selection mechanism, 3D transformation using CSS or a library like Three.js, complete 360-degree rotation animation, and proper perspective rendering. Deduct 5 points if the rotation is not around the selected edge, 3 points if the animation is not smooth, and 2 points if the 3D perspective is incorrect. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Does the reset functionality restore the original state?",
+      "description": "Evaluate if clicking the 'Reset' button correctly returns the display to the initial rectangle state. The system should maintain the original dimensions or reset to default values, clear any annotations, and cancel any in-progress transformations. Check if students can modify the rectangle after reset and repeat the cylinder generation process. Deduct 5 points if the reset is incomplete, 3 points if previous state information influences the reset state. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the cylinder cutting and unfolding animation properly implemented?",
+      "description": "Assess if the 'Cut' button functionality correctly simulates cutting the cylinder along a generatrix and unfolding it onto a plane. The animation should be mathematically accurate (rectangle width = cylinder circumference, height = cylinder height), include proper transition phases, and demonstrate the relationship between 3D and 2D forms. Deduct 5 points if the mathematical relationship is incorrect, 3 points if the animation lacks intermediate steps, and 2 points if the final unfolded state is not properly aligned. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid sequential clicks on different buttons, browser resizing, invalid user inputs on dimensions, 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. Measurement tools showing dimensions 2. Different texture options for the cylinder 3. View angle controls for better 3D observation). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to reset the view) 2. Function modules unrelated to the geometric transformation task (e.g., unnecessary media players) 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 geometric logic/view/interaction 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 code contains performance bottlenecks that cause noticeable lag during animations. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the annotation functionality well-implemented?",
+      "description": "Judge whether the 'Pen' button enables effective annotation on both rectangle and cylinder. Check for: 1) Smooth drawing experience with proper event handling 2) Annotations that maintain position relevance when switching between 2D and 3D views 3) Clear visual rendering of annotations with appropriate styling. Deduct 5 points if annotations disappear during transformations, 3 points if the drawing experience is laggy or imprecise, and 5 points if annotations don't properly adhere to the surface in 3D view. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Simulation & Modeling-Mathematical Abstraction",
+  "difficulty": "hard"
+}

package/library/simulation___modeling-mathematical_abstraction/js-sphere-conways-game-life-multicolor-simulation.json

@@ -0,0 +1,68 @@
+{
+  "index": 10,
+  "question": "You are a code expert. Please use your professional knowledge to provide accurate and professional responses. Make sure the generated code is executable for demonstration purposes. I'd like to make a JS simulation of a sphere where the universe of Conway's Game of Life is unfolding, multicolor, lots of small squares, on a black background.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is Conway's Game of Life algorithm correctly implemented?",
+      "description": "Review whether the code accurately implements Conway's Game of Life rules: 1) Live cells with 2-3 neighbors survive 2) Dead cells with exactly 3 neighbors become alive 3) All other cells die or remain dead. Check if the algorithm uses proper neighbor counting for spherical topology (handling pole singularities and longitude wrapping). Score 0 if core rules are missing, 5 if basic rules work but topology is incorrect, 10 if fully implemented with proper spherical neighbor calculation.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the spherical 3D visualization properly rendered?",
+      "description": "Evaluate whether the sphere rendering uses appropriate 3D graphics (WebGL/Three.js) with correct UV mapping for cellular automata grid projection. Check if the sphere maintains consistent cell size across surface, handles texture distortion at poles, and implements proper camera controls (rotation, zoom). Deduct 5 points if using 2D approximation instead of true 3D sphere, 3 points if pole distortion is severe. Full score requires smooth sphere with uniform cell distribution.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are multicolor visual effects and animations implemented effectively?",
+      "description": "Check whether the visualization includes dynamic color systems: 1) Different colors for cell states/ages 2) Smooth color transitions during state changes 3) Visually appealing color palette against black background. Evaluate animation smoothness (60fps target) and visual clarity of individual cells. Deduct 5 points if colors are static or harsh, 3 points if animation stutters or cells are hard to distinguish. Requires color coding system and smooth real-time updates.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the grid resolution and performance optimization adequate?",
+      "description": "Assess whether the implementation supports 'lots of small squares' (minimum 100x50 grid resolution) while maintaining smooth performance. Check for optimization techniques like efficient neighbor calculation, WebGL batching, or delta-based updates. Evaluate if the system can handle multiple generations without performance degradation. Deduct 5 points if grid resolution is too low (<50x25), 5 points if frame rate drops below 30fps, 3 points if memory usage grows unbounded over time.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as WebGL context loss, browser compatibility issues, extreme zoom levels, invalid initial patterns, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should gracefully degrade on older browsers and handle edge cases effectively, 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 seeding by clicking on sphere 2. Multiple preset patterns (gliders, oscillators) adapted for spherical topology 3. Speed controls and generation counter 4. Cell age visualization with color gradients 5. Export/import pattern functionality). Add 2 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple rendering pipelines coexisting) 2. Function modules unrelated to Game of Life simulation (e.g., built-in audio player) 3. Fancy effects that severely impact performance (e.g., excessive particle systems, complex shaders). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core simulation performance is compromised by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game logic/rendering/input handling), code organization, and maintainability. Check for proper separation of concerns between Game of Life engine and 3D visualization. Deduct 5 points if global state pollution is found or no clear architecture; deduct 5 points if the code duplication rate is too high (over 30%); deduct 3 points if hardcoded magic numbers are excessive. The full score requires clean, well-structured code with clear separation of responsibilities.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern 3D visualization principles: 1) High contrast multicolor cells against pure black background for optimal visibility 2) Appropriate cell size ensuring individual squares are distinguishable 3) Professional color palette with sufficient variety but visual harmony 4) Clean UI controls if present. Deduct 3 points for poor color choices that reduce visibility, 5 points if cells are too small/large to distinguish effectively, 5 points for cluttered or unprofessional visual appearance.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the 3D interaction and animation conform to user expectations: 1) Smooth sphere rotation with mouse/touch controls 2) Responsive zoom without breaking cell visibility 3) Consistent animation timing for Game of Life generations 4) Immediate visual feedback for any interactive elements. Deduct 5 points for laggy or jerky sphere manipulation, 3 points for inconsistent animation timing, 5 points for unresponsive controls or poor camera behavior. Full score requires fluid 60fps 3D interaction.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Simulation & Modeling-Mathematical Abstraction",
+  "difficulty": "medium"
+}

package/library/simulation___modeling-mathematical_abstraction/uniapp-vue3-graphology-path-planning-example-code.json

@@ -0,0 +1,68 @@
+{
+  "index": 786,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure that the code you generate is executable for demonstration purposes. uniapp vue3 example code for Graphology path planning.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core graphology path planning algorithm properly implemented?",
+      "description": "Review whether the code properly implements one or more path planning algorithms (e.g., Dijkstra, A*, BFS, DFS) suitable for graphology applications. Check if the algorithm correctly calculates the shortest/optimal path between nodes. Score 0 if no algorithm is implemented, 5 if a basic algorithm is implemented with flaws, and 10 if the algorithm is correctly implemented with optimizations for graphology use cases.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the graph data structure appropriately designed for uniapp?",
+      "description": "Evaluate the data structure design for storing and manipulating the graph. Check whether it efficiently represents vertices, edges, weights, and other properties relevant to graphology. Verify compatibility with Vue 3 reactivity system and proper state management. Deduct 5 points if the structure is inefficient or incompatible with Vue 3, deduct 3 points if it lacks proper indexing or lookup optimization. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Does the implementation use Vue 3/uniapp features correctly?",
+      "description": "Assess whether the code properly utilizes Vue 3 composition API, reactive states, lifecycle hooks, and uniapp-specific features. Check if the solution follows best practices for component design, state management (e.g., Pinia/Vuex), and event handling. Deduct 5 points for using Options API instead of Composition API without reason, 3 points for improper reactivity usage, and 5 points for not utilizing uniapp cross-platform features. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the graph visualization properly implemented?",
+      "description": "Check whether the code includes proper visualization of the graph and the calculated path. Verify if it uses appropriate visualization libraries or canvas/SVG rendering that works across multiple platforms supported by uniapp. Evaluate the clarity of node and edge representations. Deduct 5 points if the visualization is static, 5 points if it's not responsive to different screen sizes, and 3 points if it lacks animation for path traversal. 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 disconnected graphs, invalid input, edge cases in the algorithm, platform-specific issues in uniapp) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Interactive graph manipulation 2. Multiple algorithm comparisons with performance metrics 3. Custom node/edge styling 4. User-defined heuristics for A*). 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 graph traversal algorithms without clear purpose) 2. Function modules unrelated to graphology path planning (e.g., unnecessary media players) 3. Fancy effects that affect performance (e.g., excessive animations that slow down the application). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating algorithm/view/model layers), component reusability, and build process compatibility with uniapp. 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 file structure doesn't follow uniapp conventions. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless across platforms?",
+      "description": "Judge whether the dynamic effects conform to uniapp cross-platform capabilities: 1) Consistent performance across iOS, Android, and H5 2) Transition animation duration controlled between 300-500ms 3) Proper touch feedback for mobile devices. Deduct 5 points for each operation without proper mobile feedback, 3 points for performance inconsistencies between platforms, and 5 points for unresponsive UI during algorithm execution. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Simulation & Modeling-Mathematical Abstraction",
+  "difficulty": "easy"
+}