@getollie/cli 0.0.1

package/library/svg_generation-svg_images/concave-octagon-division-into-quadrilaterals.json

@@ -0,0 +1,68 @@
+{
+  "index": 432,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable for demonstration. A 'concave shape' is composed of 8 vertices, and we can draw a 'concave' or concave-like octagon by following vertices A through H in either clockwise or counterclockwise order. Now you need to determine, when a concave octagon is drawn on the canvas, how to identify two concave vertices and extend lines from these vertices to two edges, dividing the concave octagon into three quadrilaterals. You should draw using red solid lines, label each vertex (ABCDEFGH), mark the two intersection points of the extension lines with the edges as I and J, and represent the extension lines with blue dashed lines. Finally, output a complete HTML file.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the concave octagon geometry correctly implemented?",
+      "description": "Review whether the code accurately implements a concave octagon with 8 vertices (A-H) following proper geometric principles. Check if the vertices are positioned to create a valid concave shape with exactly 2 concave vertices (interior angles > 180°). Score 0 if the shape is not octagonal or lacks concave properties, 5 if basic octagon is drawn but concave vertices are incorrectly identified, and 10 if the concave octagon geometry is mathematically accurate with proper vertex positioning.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the concave vertices correctly identified and extension lines properly calculated?",
+      "description": "Evaluate whether the algorithm correctly identifies the two concave vertices through angle calculation or vector analysis. Check if extension lines from concave vertices to opposite edges are mathematically accurate and create exactly three quadrilaterals. Deduct 5 points if concave vertex detection is incorrect, 3 points if extension line calculations have geometric errors, and 5 points if the division doesn't result in proper quadrilaterals. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are intersection points I and J correctly calculated and marked?",
+      "description": "Check whether the intersection points I and J are accurately computed using line-segment intersection algorithms. Verify that these points lie on the octagon edges and are properly marked/labeled. The intersection calculation should handle edge cases like parallel lines or points outside polygon bounds. Deduct 5 points if intersection calculations are mathematically incorrect, 3 points if points are not properly constrained to edges, and 2 points for missing edge case handling. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the complete geometric division into three quadrilaterals achieved?",
+      "description": "Evaluate whether the final result correctly divides the concave octagon into exactly three distinct quadrilaterals through the extension lines. Check if each resulting shape has 4 vertices and proper geometric properties. Verify that no area is left uncovered and no overlapping occurs. Deduct 5 points if division results in non-quadrilateral shapes, 3 points if area coverage is incomplete, and 2 points for overlapping regions. Give 10 points if perfect geometric division is achieved.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as degenerate polygons, collinear vertices, floating-point precision errors, canvas size variations, etc.) and provide friendly error handling or recovery mechanisms. Code with strong robustness should effectively handle edge cases in geometric calculations, giving 10 points. If 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 geometric visualization experience (e.g., 1. Interactive vertex dragging to modify octagon shape 2. Animation showing step-by-step construction process 3. Real-time angle measurements display 4. Multiple octagon examples with different concave configurations). 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 geometric calculation methods (e.g., multiple angle detection algorithms coexisting) 2. Function modules unrelated to geometric visualization (e.g., built-in games or unrelated animations) 3. Excessive visual effects that distract from geometric clarity (e.g., rainbow colors, particle systems). Deduct 3 points for each redundancy found, and directly deduct 10 points if core geometric 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 calculations/rendering/interaction layers), code organization, and mathematical accuracy. Deduct 5 points if global state pollution is found or proper geometric abstractions are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if mathematical functions lack proper documentation or comments. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the geometric visualization follows clear design principles: 1) Red solid lines for octagon edges are clearly visible (stroke-width ≥ 2px) 2) Blue dashed lines for extensions are distinguishable (proper dash pattern) 3) Vertex labels A-H and intersection points I,J are readable (font-size ≥ 12px) 4) Proper canvas size and coordinate system. Deduct 3 points for each unclear visual element, 5 points for poor color contrast, and 5 points for illegible labels. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the geometric rendering accurate and visually clear?",
+      "description": "Judge whether the geometric elements are rendered with mathematical precision: 1) Lines connect exact vertex coordinates without gaps 2) Dashed extension lines have consistent styling 3) All geometric relationships are visually apparent 4) Proper scaling and positioning within canvas bounds. Deduct 5 points for each rendering inaccuracy, 3 points for inconsistent line styles, and 5 points for geometric elements extending outside visible area. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "SVG Generation-SVG Images",
+  "difficulty": "hard"
+}

package/library/svg_generation-svg_images/create-bicycle-smallest-transportation-tool.json

@@ -0,0 +1,68 @@
+{
+  "index": 190,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable for demonstration purposes.\nPlease help me implement the following requirement using code, specifically with SVG code: create a bicycle, which is the smallest transportation tool.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the bicycle structure completely implemented in SVG?",
+      "description": "Evaluate whether the SVG code accurately implements all essential parts of a bicycle: frame (including top tube, down tube, seat tube, seat stays, chain stays), wheels (with spokes and hubs), handlebar, seat, pedals, and chain. Score 0 if more than two essential components are missing, 5 if only one component is missing or poorly implemented, and 10 if all components are properly structured with appropriate proportions.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the geometric proportions and measurements realistic?",
+      "description": "Check whether the bicycle's proportions follow real-world bicycle geometry: wheels should be of equal size, the frame should form proper triangles for structural integrity, and components should have realistic dimensions relative to each other. Deduct 3 points if the wheels are disproportionate, 3 points if the frame geometry is structurally unsound, and 4 points if overall proportions make the bicycle appear unrealistic. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the SVG implementation technically sound?",
+      "description": "Review whether the SVG code uses appropriate elements for different parts (circles for wheels, paths for frame, etc.), utilizes grouping (<g>) for related elements, implements proper coordinate systems, and employs SVG-specific attributes effectively. Score 10 for exemplary implementation with optimized path commands and transforms, 5 for functional but unoptimized implementation, and 0 for implementation with significant technical flaws.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the bicycle include any interactive or animated elements?",
+      "description": "Assess whether the implementation includes animations or interactivity such as rotating wheels, moving pedals, turning handlebars, or user-triggered movements. Award 10 points for fully implemented, smooth animations that simulate actual bicycle mechanics, 5 points for basic animations that lack physical accuracy, and 0 points if no animations or interactivity are present.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle viewing across different browsers and screen sizes through responsive design techniques like viewBox attributes, percentage-based dimensions, or media queries. Check for defensive coding practices like avoiding hard-coded absolute positions. Score 10 for fully responsive implementations that work across all modern browsers, 5 for partially responsive implementations, and 0 if the design breaks easily on different screen sizes.",
+      "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. Color customization options 2. Realistic lighting and shadows 3. Physics-based animation of the bicycle in motion). 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. Duplicate element definitions that could be reused 2. Unnecessarily complex paths that could be simplified 3. Decorative elements that significantly increase file size without adding value to the bicycle representation. Deduct 3 points for each redundancy found, and directly deduct 10 points if redundant code significantly impacts performance.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modularity (such as separating different bicycle components into reusable groups), code organization, proper naming conventions, and efficient path definitions. Deduct 5 points if SVG elements lack meaningful IDs or classes; deduct 3 points if the code lacks comments for complex sections; deduct 2 points if the SVG structure doesn't follow logical grouping. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the visual design follows professional principles: 1) Appropriate use of color (harmonious, with good contrast) 2) Clean, polished appearance with attention to detail (like rounded corners where appropriate) 3) Visual balance and proper proportions. Deduct 3 points for clashing colors, 4 points for rough or jagged edges where smoothness is expected, and 3 points for poor visual hierarchy. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether any animations or interactive elements feel natural: 1) Appropriate easing functions for moving parts 2) Realistic physics in wheel rotation and chain movement 3) Smooth transitions between states. Deduct 4 points for jarring or unrealistic animations, 3 points for inconsistent movement speeds, and 3 points for animation timing that doesn't match real bicycle mechanics. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "SVG Generation-SVG Images",
+  "difficulty": "hard"
+}

package/library/svg_generation-svg_images/cubic-box-packaging-svg-code.json

@@ -0,0 +1,68 @@
+{
+  "index": 154,
+  "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 for demonstration.\n\nPlease help me implement the following requirement using code. Create a: cubic box packaging using SVG code.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the cubic box structure accurately represented in SVG?",
+      "description": "Review whether the SVG code correctly implements a 3D cubic box with proper perspective, including front, back, top, bottom, left and right faces. Score 0 if the implementation is 2D only, 5 if the cube faces exist but with perspective errors, and 10 if all faces are properly positioned with correct perspective representation.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the SVG geometry elements properly used for the cubic representation?",
+      "description": "Check whether appropriate SVG elements (<path>, <polygon>, <rect>, etc.) are used efficiently to construct the cubic box. Evaluate if the coordinate calculations are mathematically correct for a 3D projection. Deduct 5 points if elements are used inappropriately, and 3 points if the coordinate system is inconsistent. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the cubic box visually distinguishable as a package/box?",
+      "description": "Evaluate whether the implementation includes packaging-specific features such as flaps, folds, or tape indicators that make it recognizable as a box rather than just a geometric cube. Deduct 5 points if it's just a plain cube without packaging elements, and 3 points if the packaging elements are unrealistic. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the implementation include interactive or dynamic features?",
+      "description": "Check whether the cubic box implementation includes interactive elements (rotation, unfolding, opening) or animations that enhance the visualization experience. Award 0 points for static-only implementations, 5 points for basic interactivity, and 10 points for comprehensive interactive features with smooth animations.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as browser compatibility issues, responsive layout adaptation, parameter validation) and provide 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 experience (e.g., 1. Texture mapping on cube faces 2. Dynamic lighting effects 3. Box opening/closing animation). 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 drawing functions 2. Function modules unrelated to the cubic box visualization 3. Fancy effects that affect performance (e.g., unnecessary complex animations). 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 drawing logic/interaction/styling), maintainability, and reusability. Deduct 5 points if global namespace pollution is found or if drawing functions are not properly encapsulated; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the SVG generation is not parameterized. 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 proportions and perspective consistent with real-world expectations 3) Professional use of shadows, gradients and lighting. Deduct 3 points for each unrealistic visual element, 5 points for a jarring color combination, and 5 points for inconsistent proportions. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether any dynamic effects conform to human perception characteristics: 1) Smooth transitions if rotation is implemented 2) Animation duration controlled between 300-500ms 3) Natural cubic box behavior in response to user interaction. Deduct 5 points for each operation without feedback, 3 points for visual glitches during animations, and 5 points for unnatural cubic box movements. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "SVG Generation-SVG Images",
+  "difficulty": "hard"
+}

package/library/svg_generation-svg_images/domino-game-tiles-fun.json

@@ -0,0 +1,68 @@
+{
+  "index": 180,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and expert responses. Be sure to ensure that the code you generate is executable and can be displayed. Please help me implement this SVG image using code. Play the game of domino with tiles for fun.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the domino game structure and visual representation implemented with SVG?",
+      "description": "Check if the code properly creates domino tiles using SVG, with correct proportions, clear visual separation between tile halves, and proper value representation (dots). Score 0 if basic domino representation is missing, 5 if tiles are created but with visual defects, 10 if tiles look professional with proper dimensions and styling.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the domino game mechanics implemented?",
+      "description": "Verify if the code implements essential domino game functionality including: tile distribution, matching rules for placing tiles, turn management, and win condition checking. Deduct 5 points if matching logic is incorrect, 3 points if turn management is missing, and 5 points if win conditions are not implemented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the domino layout and placement system correctly implemented?",
+      "description": "Evaluate whether the code properly handles tile placement in a logical pattern (linear, L-shape, or branching patterns as in traditional dominoes), maintains proper spacing between tiles, and correctly orients tiles when placed. Deduct 5 points if tiles overlap incorrectly, 3 points if orientation logic fails at corners, and 2 points if spacing is inconsistent. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the user interaction for playing domino tiles intuitive and responsive?",
+      "description": "Assess whether the implementation allows players to select and place dominoes through intuitive interactions (drag-drop or click-based), provides visual feedback for valid/invalid moves, and includes animations for tile placement. Deduct 5 points for difficult tile selection, 3 points for missing move validation feedback, and 2 points for abrupt tile placement without animation. 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 moves, edge placement scenarios, unexpected user interactions, 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. Automatic tile suggestions 2. Different game variants (Mexican Train, Chicken Foot) 3. Tile placement sound effects 4. Progressive difficulty levels). 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 draw tiles) 2. Function modules unrelated to dominoes (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive animations that slow down gameplay). 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 game logic/view/interaction layers), code reusability, and maintenance practices. 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 SVG elements are generated inefficiently or without proper organization. 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 dominoes and background 2) Proper layout spacing between game elements 3) Clear visual hierarchy between player areas, tile stack, and play area. Deduct 3 points for each crowded visual element, 5 points for poor color contrast making dots hard to see, and 5 points for chaotic game board organization. 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) Tile selection feedback delay ≤ 100ms 2) Placement animation duration controlled between 300-500ms 3) Clear visual indicators for valid placement positions. Deduct 5 points for each operation without feedback, 3 points for jerky animations when placing tiles, and 5 points for unclear indication of whose turn it is. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "SVG Generation-SVG Images",
+  "difficulty": "hard"
+}

package/library/svg_generation-svg_images/draw-a-heart-program.json

@@ -0,0 +1,68 @@
+{
+  "index": 1577,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code for demonstration whenever possible. Write a program that draws a heart.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the heart shape correctly implemented?",
+      "description": "Verify if the code correctly generates a mathematically accurate heart shape. The heart should have a clear central V-point at the bottom, symmetrical lobes at the top, and smooth curves throughout. Deduct 5 points if the proportions are off, 7 points if the shape is distorted or asymmetrical. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the visualization method appropriate for the task?",
+      "description": "Evaluate whether the chosen visualization method (SVG, Canvas, CSS, ASCII art, etc.) is suitable and efficient for drawing a heart. Check if the code leverages the chosen technology's strengths. Score 10 points for optimal technology choice with proper implementation, 5 points if the technology is appropriate but implementation is suboptimal, 0 points if an inappropriate method is chosen.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Does the code provide customization options?",
+      "description": "Check if the code allows for customization of the heart's properties such as size, color, rotation, border style, or fill pattern. Award 3 points for each independently adjustable property (size, color, position, animation, fill pattern), up to a maximum of 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the heart rendering responsive and adaptable?",
+      "description": "Assess whether the heart scales appropriately across different screen sizes and resolutions. The heart should maintain its proportions and quality regardless of the viewing device. Deduct 5 points if the heart distorts on resizing, 3 points if it doesn't adapt to the container size. 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, browser compatibility issues, rendering 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. Pulsating animation 2. Particle effects 3. Interactive elements that respond to user input). 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 drawing methods coexisting) 2. Function modules unrelated to heart drawing (e.g., unnecessary UI controls) 3. Fancy effects that affect performance (e.g., excessive animations that slow down 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 drawing logic/view/interaction layers), reusability, and code organization. Deduct 5 points if global namespace 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 lacks comments or documentation. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the heart design follows modern design principles: 1) Harmonious color choice for the heart and background 2) Proper spacing and positioning within the viewport 3) Clean rendering with smooth edges (no jagged lines or pixelation). Deduct 3 points for poor color contrast, 5 points for pixelated or rough edges, and 5 points for poor positioning or framing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether any dynamic effects (if implemented) conform to human perception characteristics: 1) Animation timing feels natural (not too fast or slow) 2) Transition effects are smooth without stuttering 3) Interactive elements respond immediately to user input. Deduct 5 points for jerky animations, 3 points for delayed responses to user interaction, and 5 points for animations that feel unnatural or distracting. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "SVG Generation-SVG Images",
+  "difficulty": "easy"
+}

package/library/svg_generation-svg_images/drinking-with-cup-at-bar-svg.json

@@ -0,0 +1,68 @@
+{
+  "index": 187,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Make sure the code you generate is executable and can be displayed.\nPlease help me implement the following requirement using SVG code: create a scene of \"me drinking with a cup at a bar.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the basic bar scene properly rendered?",
+      "description": "Check if the SVG properly creates a recognizable bar environment with correct perspective, depth, and lighting. Elements should include a bar counter, bar stools, shelves with bottles, and appropriate background details that establish the setting. Scoring: 0 points if the scene is unidentifiable as a bar; 5 points if basic elements exist but lack detail; 10 points for a comprehensive and detailed bar setting.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the character representation accurate and detailed?",
+      "description": "Evaluate the character ('me') representation including body proportions, posture (sitting position should be natural), facial features, and expression. The character should be properly positioned at the bar. Deduct 3 points if proportions are significantly off; deduct 3 points if the posture looks unnatural; deduct 2 points if facial details are missing or poorly executed; deduct 2 points if the character placement doesn't integrate well with the scene.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the cup/glass properly designed and positioned?",
+      "description": "Assess the drink container design (glass type appropriate for a bar setting), positioning in the character's hand, and details like liquid content, ice, garnish, etc. The character should be in a drinking pose or motion. Deduct 3 points if the glass design is too simplistic; deduct 3 points if the hand-glass interaction looks unnatural; deduct 2 points if liquid details are missing; deduct 2 points if the drinking action isn't clearly depicted.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the SVG implementation technically correct?",
+      "description": "Review the technical aspects of SVG implementation, including proper structure, appropriate use of SVG elements (path, rect, circle, etc.), correct attributes, and syntactical correctness. Check for proper viewBox setting, grouping of related elements (<g> tags), and use of reusable components like definitions (<defs>). Deduct 5 points for incorrect SVG syntax; deduct 3 points for improper viewBox; deduct 2 points for inefficient element usage.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle different viewport sizes through responsive design techniques (preserveAspectRatio attribute, percentage-based positioning, etc.). Check if the SVG scales properly without distortion. Deduct 5 points if the image severely distorts when resized; deduct 3 points if elements overlap incorrectly when viewed at different sizes; deduct 2 points if text becomes illegible when scaled.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the SVG includes surprise features that enhance the experience (e.g., 1. Animation of drinking motion 2. Interactive elements that respond to user input 3. Gradient lighting effects that create atmosphere 4. Creative use of filters or masks). 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. Duplicate SVG elements that serve the same purpose 2. Excessive detail that doesn't contribute to the scene but increases file size 3. Unnecessary animations or effects that distract from the main subject. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core elements are obscured by redundant elements.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular organization (such as grouping related elements), code readability (meaningful ids/classes, comments for complex paths), and optimization (reduced path points, proper use of transforms instead of absolute coordinates). Deduct 5 points if the code lacks organization; deduct 3 points if paths are unnecessarily complex; deduct 2 points if the code uses absolute positioning when transforms would be more efficient.",
+      "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 palette with appropriate contrast 2) Proper composition and balance of elements 3) Consistent style throughout (not mixing different visual styles). Deduct 3 points for clashing colors or poor contrast; deduct 3 points for awkward composition; deduct 4 points for inconsistent stylistic approaches.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the visual storytelling effective?",
+      "description": "Judge whether the scene successfully communicates the narrative of 'drinking at a bar' through visual cues, character expression, environmental details, and composition. The scene should feel authentic and convey mood/atmosphere. Deduct 3 points if the activity is ambiguous; deduct 4 points if the emotional tone/atmosphere is missing; deduct 3 points if contextual details that would enhance the storytelling are absent.",
+      "maxScore": 10
+    }
+  ],
+  "class": "SVG Generation-SVG Images",
+  "difficulty": "medium"
+}

package/library/svg_generation-svg_images/dynamic-svg-realtime-stock-chart-animate.json

@@ -0,0 +1,68 @@
+{
+  "index": 177,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable for demonstration.\n\nPlease help me implement the following requirements using SVG code. The requirement is to create: Create a dynamic SVG chart that displays real-time stock data, using the <animate> element to achieve smooth transitions.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the basic SVG chart structure properly implemented?",
+      "description": "Check if the SVG contains essential chart elements like axes, grid lines, labels, and viewBox attribute with appropriate dimensions. The SVG should provide a clear container for data visualization with proper coordinate system. Score 0 if the SVG structure is missing or broken, 5 if basic structure exists but with issues, 10 if implemented professionally with all necessary components.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the stock data visualization components complete?",
+      "description": "Evaluate whether the chart includes necessary stock data visualization elements such as candlestick/line/bar representations, volume indicators, price labels, and time axis. Deduct 3 points if any essential component is missing, deduct 5 points if the visualization doesn't reflect standard stock charting conventions. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the <animate> element properly implemented for smooth transitions?",
+      "description": "Review how <animate> elements are used to create transitions between data states. Check for proper attributes (attributeName, from, to, dur, fill, etc.). Deduct 5 points if transitions are jerky or incomplete, deduct 3 points if easing functions are inappropriate for financial data visualization. Give 0 if animations are missing entirely. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a real-time data update mechanism implemented?",
+      "description": "Assess if the code includes methods to fetch and update stock data in real-time (WebSocket/polling/SSE), and properly integrates this with the SVG visualization. Check if there's appropriate handling of data arrival and smooth incorporation into the chart. Deduct 5 points if updates cause visual disruptions, deduct 3 points if update frequency is inappropriate. 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 points, extreme price movements, connection issues, etc.) and provide 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 experience (e.g., 1. Interactive tooltips showing detailed price information 2. Zoom/pan capabilities 3. Technical indicators overlay like moving averages). 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 frameworks mixed) 2. Function modules unrelated to stock visualization (e.g., unnecessary decorative elements) 3. Fancy effects that affect performance (e.g., excessive animations that obscure data clarity). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating data processing/visualization/animation logic), code reusability, and performance optimization. Deduct 5 points if global variable pollution is found; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if performance bottlenecks exist in animation handling. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional financial visualization standards?",
+      "description": "Evaluate whether the design follows professional financial charting principles: 1) Color scheme appropriate for financial data (distinguishing up/down movements, using appropriate contrast) 2) Clear visual hierarchy for different information types 3) Proper data-ink ratio without chart junk. Deduct 3 points for poor color choices that hinder data interpretation, 5 points for cluttered visuals, and 5 points for misleading visual representations of data. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and responsive?",
+      "description": "Judge whether the animations and transitions enhance data understanding: 1) Transition durations appropriate for financial data context (200-400ms) 2) Animation smoothness at 60fps without jank 3) Visual continuity during data updates. Deduct 5 points for animations that distract from data interpretation, 3 points for performance issues during transitions, and 5 points for animations that cause data misrepresentation. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "SVG Generation-SVG Images",
+  "difficulty": "hard"
+}

package/library/svg_generation-svg_images/dynamic-svg-traffic-map.json

@@ -0,0 +1,68 @@
+{
+  "index": 102,
+  "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 purposes.\nPlease help me implement the following requirement using code, creating it with SVG code. The requirement is to create: Create a dynamic SVG map that displays traffic information.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the SVG map structure properly implemented?",
+      "description": "Evaluate whether the code creates a well-structured SVG with appropriate viewBox, dimensions, and organization. Check for proper path elements for roads, grouping of related elements, and proper layering. Score 0 if no SVG structure exists, 5 if basic structure exists but with issues, and 10 if the SVG structure follows best practices with proper organization.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the traffic information visualization implemented effectively?",
+      "description": "Review whether the code implements traffic visualization through color coding (e.g., green/yellow/red for traffic levels), animation effects for moving traffic, or other visual indicators. Check for proper legends or indicators that explain the visualization. Deduct 5 points if visualization is static only, and 3 points if the visual metaphors are confusing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there a data binding mechanism for real-time updates?",
+      "description": "Assess whether the code includes JavaScript functions that can update the SVG elements based on changing traffic data. Look for event listeners, data fetching mechanisms (like fetch API or WebSockets), and data-driven attribute updates. Deduct 5 points if updates require page refresh, and 3 points if the update mechanism has significant delay (>2 seconds). The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the map include interactive elements for user engagement?",
+      "description": "Check whether the implementation includes interactive features such as zooming, panning, clicking on roads for details, hovering effects to show additional information, or filtering options for different traffic conditions. Give 10 points if multiple intuitive interactions are implemented, 5 points if only basic interactions exist, and 0 points if the map is entirely static.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as missing data, malformed data, browser compatibility issues, etc.) and provide fallbacks or error handling. Code with strong robustness should degrade gracefully when features are not supported or data is unavailable, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Weather overlay affecting traffic 2. Time-of-day visual changes 3. Heat maps for congestion patterns over time). 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 logic 2. Feature modules unrelated to traffic visualization (e.g., unnecessary animations) 3. Complex effects that affect performance (e.g., excessive filters or gradients 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 (separation of SVG generation, data processing, and interaction logic), code reusability, and maintainability. Deduct 5 points if global variables are excessively used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no clear separation between presentation and business logic. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the map visual design follows cartographic principles: 1) Appropriate color scheme for map features and traffic indicators 2) Proper visual hierarchy with main roads more prominent than minor ones 3) Clear and legible labels with appropriate font choices. Deduct 3 points for poor contrast between map elements, 5 points for indistinguishable traffic indicators, and 5 points for cluttered or overlapping labels. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the SVG animations and transitions are performance-optimized and visually pleasing: 1) Smooth traffic flow animations without jank 2) Responsive interaction feedback within 100ms 3) Efficient update rendering without freezing the UI. Deduct 5 points for animations that cause performance issues, 3 points for delayed visual updates after data changes, and 5 points for jerky or inconsistent animation timing. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "SVG Generation-SVG Images",
+  "difficulty": "easy"
+}