@getollie/cli 0.0.1

package/library/game_development-strategy/web-based-racing-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1110,
+  "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. Write code for a web-based racing game.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core racing game mechanics fully implemented?",
+      "description": "Review whether the code accurately implements the racing physics system through JavaScript, including collision detection, acceleration/deceleration, handling, and track boundaries. Score 0 if the core game loop is missing, 5 if only basic movement is implemented, and 10 if it includes realistic physics like friction, drift, and aerodynamics.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the racing track and environment well-designed?",
+      "description": "Check whether the code creates a compelling racing environment with a clearly defined track, obstacles, and visual indicators for player guidance. Deduct 3 points if the track is too simplistic (just straight lines), 5 points if collision boundaries are inconsistent with visuals, and 2 points if there's no track variety. Full score requires at least one complete circuit with proper checkpoints.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there a proper game progression and scoring system?",
+      "description": "Evaluate whether the game includes lap counting, timing system, position tracking (for multiple racers), and performance metrics. Deduct 3 points for missing lap verification, 3 points for no time tracking, and 4 points if there's no way to determine race completion. The full score requires a complete race lifecycle from start to finish.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are AI opponents or multiplayer capabilities implemented?",
+      "description": "Assess whether the game includes computer-controlled opponents with proper path-finding and difficulty levels, or multiplayer functionality. Score 3 points for basic AI that follows predefined paths, 7 points for AI with adaptive difficulty, or 10 points for working multiplayer implementation with proper synchronization.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid input changes, browser performance issues, or unexpected user interactions) 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. Dynamic weather effects 2. Car customization options 3. Interactive race replays with highlights). 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 control schemes that conflict) 2. Function modules unrelated to racing (e.g., mini-games that distract from the main experience) 3. Fancy effects that affect performance (e.g., excessive particle effects causing frame drops). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game logic/rendering/input handling), memory management, and optimization techniques. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no performance optimization for smooth gameplay. 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 game UI principles: 1) Clear heads-up display (speedometer, lap counter, position) 2) Proper visual hierarchy (important info more prominent) 3) Non-intrusive UI elements that don't obstruct gameplay. Deduct 3 points for cluttered UI elements, 5 points for poor readability during gameplay, and 5 points for missing critical race information. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and responsive?",
+      "description": "Judge whether the controls and animations conform to racing game expectations: 1) Input response delay ≤ 50ms 2) Consistent frame rate (minimum 30fps) 3) Appropriate feedback for collisions and speed changes. Deduct 5 points for noticeable input lag, 3 points for jerky animations during turns or collisions, and 5 points for inconsistent physics behavior. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Action/Rhythm",
+  "difficulty": "hard"
+}

package/library/game_development-strategy/web-based-tank-battle-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1420,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Be careful to ensure the generated code is executable for demonstration. Please generate web-based code for a Tank Battle game.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the tank movement and control system fully implemented?",
+      "description": "Review whether the code accurately implements tank movement controls using keyboard events, includes collision detection with boundaries and obstacles, and handles rotation/direction appropriately. Score 0 if core movement is missing, 5 if only basic movement works, and 10 if smooth movement with proper acceleration/deceleration physics is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the combat system properly implemented?",
+      "description": "Examine whether the shooting mechanism functions correctly, including projectile physics, cooldown timers, collision detection with obstacles and enemies, and damage calculation. Check if visual and audio feedback is provided when firing and upon hits. Deduct 5 points if hitbox detection is inaccurate, 3 points if projectiles don't respect physics. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are game mechanics and enemy AI implemented?",
+      "description": "Evaluate whether the game includes enemy tanks with functioning AI that can pursue the player, avoid obstacles, and engage in combat with reasonable strategy. Check if power-ups, level progression, or difficulty scaling is implemented. Score 0 if enemies don't move or react, 5 if basic enemy movement exists, and 10 if sophisticated enemy behaviors are implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the complete game lifecycle management constructed?",
+      "description": "Check whether the code includes game initialization, state management (start/pause/resume/game over), score tracking, lives system, and level progression. Deduct 5 points if game state persistence is missing, and 3 points if there's no proper game loop with timing control. Give 10 points if fully implemented with clean transitions between states.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid input changes, browser resizing, out-of-bounds movement, etc.) and provide friendly error handling. Code with strong robustness should prevent game-breaking bugs and maintain consistent gameplay under stress. Give 10 points for comprehensive error handling, 5 for basic handling, and 0 for frequent crashes or bugs.",
+      "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. Destructible environment 2. Weather effects affecting gameplay 3. Multiple tank types with unique abilities 4. Split-screen multiplayer). 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 collision detection systems) 2. Function modules unrelated to tank battles (e.g., a built-in calculator) 3. Fancy effects that affect performance (e.g., excessive particle systems). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game entities, rendering, and physics systems), use of design patterns, and code organization. Deduct 5 points if global state pollution is found; deduct 5 points if the code duplication rate is too high; deduct 5 points if there's no clear separation of concerns. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern game UI principles: 1) Clear and intuitive HUD elements (health, ammo, score) 2) Consistent visual theme and color palette 3) Appropriate contrast between game elements and background. Deduct 3 points for cluttered UI elements, 5 points for poor readability during gameplay, and 5 points for inconsistent visual style. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the game maintains consistent frame rate (minimum 30 FPS), provides immediate feedback for player actions, and implements smooth animations for movement, explosions, and transitions. Deduct 5 points for noticeable performance drops, 3 points for input lag, and 5 points for jerky or missing animations. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "hard"
+}

package/library/game_development-strategy/web-plants-vs-zombies-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 348,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Be sure to provide executable code for demonstration whenever possible. Help me write a web-based version of Plants vs. Zombies.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core plant and zombie interaction system fully implemented?",
+      "description": "Review whether the code accurately implements the plant placement grid system, zombie movement paths, collision detection, and damage calculations. Check if plant types have different attack patterns (single, area, slow-down effects) and if zombies have varied movement speeds and health points. Score 0 if the core interaction is missing, 5 if only basic attacks exist, and 10 if varied plant/zombie types with unique behaviors are implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the resource management and progression system functional?",
+      "description": "Evaluate the implementation of sun collection mechanics, plant cooldown timers, and wave progression logic. Check if the sun economy is balanced (sun generation rate vs plant costs) and if the wave system increases in difficulty over time. Deduct 5 points if sun collection doesn't work properly, 3 points if cooldown timers are inconsistent, and 3 points if zombie waves don't escalate properly. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the game mechanics and rules properly implemented?",
+      "description": "Check whether the code implements the essential PvZ mechanics: lawn mowers as last defense, day/night cycle (if included), plant selection screen before levels, and win/lose conditions. Verify that zombies entering the house trigger a game over and that clearing all waves leads to victory. Deduct 3 points for each missing core mechanic. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there proper animation and visual feedback implementation?",
+      "description": "Assess whether plants have planting animations, attack animations, and damage states. Check if zombies have walking animations, eating animations, and death animations. Verify visual feedback for sun collection, plant selection, and game state changes. Deduct 3 points if static images are used without animation, 5 points for missing critical feedback (like zombie approach or plant damage). 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 clicking, invalid plant placement attempts, browser resizing, or game pausing) 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. New unique plant/zombie types not in the original game 2. Weather effects that impact gameplay 3. Customizable gardens or layouts). 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 collision detection systems) 2. Function modules unrelated to PvZ gameplay (e.g., an irrelevant minigame) 3. Fancy effects that affect performance (e.g., excessive particle systems that cause lag). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating game entities, rendering, and game logic), usage of design patterns appropriate for game development (like Observer for events or Factory for creating plants/zombies), and code reusability. Deduct 5 points if global state pollution is found; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no proper asset preloading mechanism. 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 is faithful to the PvZ aesthetic while following modern web design principles: 1) Consistent art style between UI elements and game assets 2) Proper layout and scaling for different screen sizes 3) Clear visual hierarchies for game information (sun count, wave progress). Deduct 3 points for inconsistent art styles, 5 points for unresponsive designs that break on different screens, and 5 points for cluttered or confusing UI. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the game performs well and has responsive controls: 1) Plant placement should respond within 100ms of clicking 2) Game maintains consistent framerate (min 30fps) even with many entities 3) Audio feedback is synchronized with visual events. Deduct 5 points for noticeable input lag, 5 points for framerate drops during normal gameplay, and 3 points for missing or misaligned audio-visual feedback. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "hard"
+}

package/library/game_development-strategy/web-plants-vs-zombies-naruto-edition.json

@@ -0,0 +1,68 @@
+{
+  "index": 1462,
+  "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 whenever possible. Help me create a web-based version of Plants vs. Zombies: Naruto Edition.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core game mechanics properly implemented?",
+      "description": "Evaluate whether the code accurately implements the basic Plants vs. Zombies gameplay mechanics with Naruto theme: plant placement, zombie movement, collision detection, sun resource collection, and wave management. Score 0 if core mechanics are missing, 5 if basic functionality exists but lacks refinement, and 10 if all mechanics are properly implemented with appropriate Naruto character adaptations.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the Naruto-themed characters and abilities properly integrated?",
+      "description": "Check whether the code includes Naruto universe characters as both plants (defenders) and zombies (attackers) with appropriate abilities reflecting their canonical powers. Each character should have unique animations, attack patterns, and special abilities that align with their representation in the Naruto series. Deduct 3 points if characters are merely reskins without unique abilities, 5 points if abilities don't match Naruto lore. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the level progression and difficulty scaling implemented?",
+      "description": "Assess whether the game includes progressive difficulty through multiple levels with increasing challenges. Check for implementation of different terrains (forests, villages, etc. from Naruto universe), day/night cycles affecting gameplay, and special events like boss battles. Deduct 5 points if difficulty doesn't scale properly, 3 points if level variety is minimal. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the chakra/energy resource system properly implemented?",
+      "description": "Evaluate the implementation of a resource system equivalent to the sun collection in the original game, but themed around chakra or energy in the Naruto universe. Check whether the code includes methods for generating resources, storing them, and using them to deploy defenders. There should be visual feedback and appropriate animations. Deduct 5 points if the resource economy is unbalanced, 3 points if visual feedback is inadequate. 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 clicking, browser resizing, invalid plant placements, etc.) and provide friendly error handling or recovery mechanisms. Code with strong robustness should be able to effectively handle edge cases like interrupted animations or memory leaks, 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. Jutsu combo system 2. Character evolution based on combat performance 3. Multiplayer mode where one player controls zombies 4. Interactive cutscenes featuring Naruto storylines). Add 2.5 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 characters (e.g., multiple characters with identical abilities but different sprites) 2. Function modules unrelated to the core gameplay (e.g., unnecessary mini-games) 3. Excessive visual effects that affect performance (e.g., particle systems that cause lag). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review the modular design (separation of game logic, rendering, asset management), maintainability (appropriate comments, consistent naming conventions), and optimization (efficient collision detection, sprite batching, asset preloading). Deduct 5 points if global state pollution is found or if design patterns are not used; deduct 3 points if code duplication rate is high; deduct 2 points if there's no performance optimization for mobile devices. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the game UI follows both the original Plants vs. Zombies layout style and integrates Naruto visual elements appropriately: 1) Thematic color palette matching Naruto's world 2) Clean and intuitive grid system for plant placement 3) Clear indicators for resources, waves, and special abilities 4) Proper integration of Naruto iconography and symbols. Deduct 3 points for inconsistent visual style, 4 points for cluttered UI elements, and 3 points for poor readability. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the game animations and interactions feel responsive and satisfying: 1) Plant selection and placement feels immediate (≤ 100ms response) 2) Attack animations are fluid and impactful 3) Zombie defeat animations provide satisfying feedback 4) Special jutsu effects are visually distinctive without obstructing gameplay. Deduct 3 points for sluggish controls, 4 points for choppy animations during intense moments, and 3 points for confusing visual feedback. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "hard"
+}

package/library/game_development-strategy/zombie-survival-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 166,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Try to ensure the code you generate is executable for demonstration.\n\nPlease use HTML and JavaScript to implement a zombie survival game where players need to survive zombie attacks while searching for resources.\nHint: Implement enemy AI behavior and resource management mechanisms.\n\nPlease include comments in your code so other developers can understand your implementation process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core zombie survival game mechanics fully implemented?",
+      "description": "Check if the code implements the essential gameplay mechanics: player movement controls, zombie AI with pathfinding, collision detection, and combat system. Score 0 if core mechanics are missing, 5 if basic movement and combat are implemented but lack depth, and 10 if all mechanics are fully functional with smooth integration.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "How sophisticated is the enemy zombie AI behavior?",
+      "description": "Evaluate the zombie AI implementation - does it include pathfinding algorithms (A*, Dijkstra's), different zombie types with varied behaviors, adaptive difficulty scaling, and sensory systems (sight, hearing)? Deduct 3 points if zombies move randomly without pathfinding, 3 points if there's no variety in zombie types, and 2 points if zombies don't react to environmental stimuli (sound, light).",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the resource management system comprehensive?",
+      "description": "Assess if the game has a robust resource system including inventory management, item collection, resource scarcity mechanics, and crafting/combining items. Check if resources affect gameplay (health, stamina, ammunition). Deduct 4 points if there's no inventory system, 3 points if resources don't meaningfully impact survival, and 3 points if resource distribution lacks balance.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the game include progression and survival mechanics?",
+      "description": "Check for survival mechanics like health/stamina management, day/night cycles, hunger/thirst systems, and progression elements (skills, upgrades, safe zones). Score 0 if no survival mechanics exist, 5 if basic health system is implemented but lacks depth, and 10 if comprehensive survival systems create meaningful gameplay decisions.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code handles common abnormal situations (out-of-bounds movements, resource overflow/underflow, collision edge cases, etc.) and provides appropriate error handling. Code with strong robustness should effectively handle these edge cases, 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 experience (e.g., 1. Dynamic weather affecting gameplay 2. Procedurally generated maps 3. Advanced gore/dismemberment system 4. Unique zombie mutation mechanics). 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 healing systems coexisting) 2. Function modules unrelated to zombie survival (e.g., unnecessary mini-games) 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 game logic/view/input layers), code organization, comments quality, and maintainability. 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 comments are missing or unhelpful for understanding the implementation. 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 game UI principles: 1) Harmonious color palette fitting the zombie theme 2) Clear HUD elements showing critical survival information 3) Proper feedback for damage, resource collection, and enemy presence. Deduct 3 points for cluttered UI elements, 5 points for poor visual hierarchy that obscures important information, and 5 points for inconsistent visual language. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the game's responsiveness and feedback conform to player expectations: 1) Input response time ≤ 100ms 2) Clear visual/audio feedback for hits, damage, and resource collection 3) Appropriate difficulty curve and tutorial elements. Deduct 5 points for each action without feedback, 3 points for jerky animations or inconsistent frame rates, and 5 points for unintuitive controls or confusing game states. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Strategy",
+  "difficulty": "medium"
+}

package/library/management_systems-file_management/building-blueprint-management-system-cad-viewer.json

@@ -0,0 +1,68 @@
+{
+  "index": 565,
+  "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. Implement a building blueprint management system that allows online preview of CAD files, supports layer toggle control, provides version comparison (highlighting modified sections), allows construction teams to submit questions about drawings (pinpointing specific coordinates), and automatically generates change notification forms.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the online CAD file preview system fully implemented?",
+      "description": "Review whether the code correctly implements a web-based CAD viewer using technologies like Three.js, SVG, or canvas. Check for essential viewing controls (pan/zoom/rotate), proper rendering of CAD formats (DXF/DWG), and handling of large files through progressive loading or LOD techniques. Score 0 if no preview functionality exists, 5 if basic viewing is implemented, and 10 if a complete professional-grade CAD viewing experience is provided.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the layer toggle control system properly designed?",
+      "description": "Evaluate the implementation of layer management, including visibility toggles for each layer, proper naming/organization, and performance optimization when toggling multiple layers. Check if the system preserves layer information from original CAD files and if layer states persist between sessions. Deduct 5 points if layer categories are not hierarchically organized, 3 points if toggling causes performance issues, and 2 points if layer visibility states are not saved. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the version comparison and highlight functionality effective?",
+      "description": "Examine the diff visualization system that highlights changes between blueprint versions. Check for color-coded change indication (additions/modifications/deletions), ability to toggle between versions, and performance when comparing complex drawings. Proper implementation should include metadata about what changed and when. Deduct 5 points if the comparison is manual rather than automated, 3 points if only basic highlighting is available, and 2 points if the system can't handle complex blueprint differences. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the coordinate-based question submission system implemented?",
+      "description": "Assess the implementation of the annotation/question system that allows construction teams to submit queries about specific coordinates. Check for spatial pinpointing accuracy, metadata capture (who/when/what), notification system for responses, and historical tracking of resolved questions. A robust implementation should include categorization of question types and priority levels. Deduct 3 points if coordinate accuracy is poor, 3 points if there's no tracking system, and 4 points if the question resolution workflow is incomplete. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as malformed CAD files, network interruptions, concurrent edits, browser compatibility 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. AI-assisted blueprint analysis to detect potential design conflicts 2. AR/VR integration for immersive blueprint review 3. Automated measurement tools that calculate materials needed). 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 file parsers doing the same job) 2. Function modules unrelated to blueprint management (e.g., a built-in generic chat system) 3. Fancy effects that affect performance (e.g., unnecessary 3D animations when 2D would suffice). 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 CAD processing/UI/annotation layers), unit test coverage, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (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?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance. Deduct 5 points for each operation without feedback, 3 points for visual after-images during fast CAD manipulation, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Management Systems-File Management",
+  "difficulty": "hard"
+}

package/library/management_systems-file_management/csharp-sql-server-image-management-system.json

@@ -0,0 +1,68 @@
+{
+  "index": 452,
+  "question": "You are a code expert. Please utilize your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable for demonstration. Please design an image management system using Visual Studio C# that can store images from a folder into a SQL Server database table through a form interface, and also read images from the SQL Server table and display them one by one. How should this be implemented?",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the database design and connection properly implemented?",
+      "description": "Review whether the code includes appropriate table schema with image data type (varbinary/image), proper connection string management, and parameterized queries to prevent SQL injection. Check if error handling for database connections is implemented. Score 0 if database connectivity is missing, 5 if basic connection exists but has security issues, 10 if fully implemented with transaction support and connection pooling.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the image import functionality fully implemented?",
+      "description": "Evaluate whether the code allows browsing and selecting folder(s), handles multiple file formats (at least JPG, PNG, GIF, BMP), validates file sizes and types, shows progress during batch uploads, and properly converts images to binary data. Deduct 3 points if no file type validation exists, 3 points if progress indication is missing during large uploads, and 5 points if multi-file selection is not implemented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the image retrieval and display functionality properly implemented?",
+      "description": "Check whether the code efficiently loads images from the database, implements pagination or lazy loading for large collections, provides thumbnail generation, and properly handles image display with zoom/pan capabilities. Score 0 if image retrieval is not implemented, 5 if basic display exists but lacks optimization, and 10 if advanced features like caching and metadata display are included.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are image manipulation features available?",
+      "description": "Assess whether the application includes basic image manipulation features such as rotation, resizing, cropping, adding metadata, or applying simple filters before saving to the database. Each implemented feature counts for 2 points, with a maximum of 10 points. If no manipulation features are available, score 0.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as database connection failures, invalid image files, out-of-memory issues during large image processing, etc.) and provide friendly error prompts or recovery mechanisms. Check for exception handling, input validation, and graceful degradation. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Image metadata extraction and searching 2. Facial recognition for organizing photos 3. Batch processing with customizable templates 4. Cloud backup integration). 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 image loading methods that do the same thing) 2. Function modules unrelated to image management (e.g., a built-in web browser) 3. Fancy effects that affect performance (e.g., unnecessary animations during database operations). 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 database access/business logic/UI layers), naming conventions adherence, commenting quality, and error logging. Deduct 5 points if global variables are overused; deduct 3 points if the code lacks proper documentation; deduct 5 points if the code duplication rate is too high (over 30%). Check if the code follows C# best practices and design patterns. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface design meet professional standards?",
+      "description": "Evaluate whether the UI follows Windows design guidelines: 1) Consistent control spacing and alignment 2) Proper form layout (logical grouping of controls) 3) Appropriate use of standard Windows controls vs. custom controls 4) Responsive design that handles window resizing. Deduct 3 points for misaligned controls, 3 points for confusing navigation, and 5 points for non-standard UI patterns that would confuse users. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the application performance optimized?",
+      "description": "Judge whether the application handles resources efficiently: 1) Proper memory management when dealing with large images 2) Database query optimization (indexing, paging) 3) Background processing for time-consuming operations 4) Resource disposal using IDisposable pattern. Deduct 3 points for memory leaks, 3 points for UI freezing during operations, 5 points for inefficient database queries loading entire image collections at once. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Management Systems-File Management",
+  "difficulty": "medium"
+}

package/library/management_systems-file_management/draggable-directory-upload-page.json

@@ -0,0 +1,68 @@
+{
+  "index": 1669,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the generated code is executable for demonstration. Create a page with draggable directory upload functionality using HTML and JavaScript.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the drag-and-drop directory upload functionality fully implemented?",
+      "description": "Check if the code implements the core HTML5 FileSystem API with proper directory reading capabilities. Verify that it handles the 'webkitdirectory' attribute for input elements and uses DataTransfer API for drag operations. Score 0 if drag-and-drop is not implemented, 5 if only file (not directory) upload works, and 10 if full directory structure upload is supported with proper event handling.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the directory structure properly maintained and displayed?",
+      "description": "Evaluate whether the uploaded directory structure is preserved and visually represented to the user. Check if the code processes the relative paths from FileList entries and rebuilds the nested structure accurately. Deduct 5 points if folders are flattened, 3 points if subfolder nesting is limited to a single level. Award full points only if the complete directory hierarchy is preserved with proper indentation or tree visualization.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are appropriate file handling mechanisms implemented?",
+      "description": "Review the implementation of file handling including type detection, size validation, and preview generation. Check if the code provides file type icons, size formatting (KB/MB), and thumbnail previews for supported formats (images, PDFs). Deduct 3 points if there's no file size limit, 4 points if file type validation is missing, and 3 points if there are no file previews. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there proper user feedback during the upload process?",
+      "description": "Check if the code provides visual feedback for the upload process including drag-over states, progress indicators, success/error notifications, and abort capabilities. Deduct 3 points for missing drag-over visual cues, 4 points for no upload progress indicator, and 3 points for absence of completion/error feedback. 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 unsupported browsers, invalid file types, empty directories, oversized files, 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. Instant search within uploaded files 2. Auto-categorization of files by type 3. File preview directly in the interface). 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 file parsing methods) 2. Function modules unrelated to directory upload (e.g., unnecessary analytics) 3. Fancy effects that affect performance (e.g., excessive 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 UI/logic/data processing layers), event delegation usage, and memory management. 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 memory leaks are detected in large file handling. 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 upload area styling (clear drop zone with proper contrast). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for an ambiguous drop target area. 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 dragging over drop zone 2) Smooth transition animations for file listing (300-500ms) 3) Clear visual hierarchy in directory tree display. Deduct 5 points for each operation without feedback, 3 points for janky animations during directory expansion, and 5 points for confusing interaction patterns. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Management Systems-File Management",
+  "difficulty": "easy"
+}