@getollie/cli 0.0.1

package/library/game_development-action_rhythm/tiktok-douyin-agar-io-mini-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1681,
+  "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. Help me design a mini-game similar to Agar.io for TikTok/Douyin, and first generate HTML code so I can try running it.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core game mechanic of Agar.io properly implemented?",
+      "description": "Review whether the code implements the fundamental player blob movement, growth mechanics, and collision detection. The player should be able to move using mouse or touch controls, consume smaller elements to grow, and be consumed by larger players. Score 0 if core mechanics are missing, 5 if basic movement and growth are implemented, and 10 if all Agar.io-style mechanics (splitting, ejecting mass, etc.) are fully included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the canvas rendering optimized for mobile performance?",
+      "description": "Check if the game uses efficient canvas rendering techniques suitable for TikTok/Douyin's mobile environment. Verify if the game implements viewport culling (only rendering objects in view), uses requestAnimationFrame properly, and optimizes for mobile GPU. Deduct 3 points for frame drops below 30fps on mid-range devices, 4 points if mobile touch controls are not properly implemented, and 3 points if the game doesn't scale properly across different screen sizes. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Does the game implement social/viral features suitable for TikTok/Douyin?",
+      "description": "Evaluate whether the game includes features that make it shareable and engaging for TikTok/Douyin users, such as quick match sessions (under 2 minutes), score sharing capabilities, personalized avatars, or replay highlights. Deduct 5 points if the game lacks any TikTok/Douyin integration hooks, 3 points if session length is inappropriate for short-form content platforms, and 2 points if there are no viral sharing mechanics. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are the AI opponents' behaviors properly implemented?",
+      "description": "Assess the implementation of AI opponents, which are crucial for an engaging single-player experience. Check for varied AI behavior patterns (aggressive, defensive, etc.), pathfinding algorithms, and difficulty scaling. Deduct 3 points if AI movement is predictable/robotic, 4 points if there's no difficulty progression, and 3 points if AI doesn't adapt to player behavior. 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 screen rotation, browser tab switching, touch event conflicts with the platform, network latency, 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. Special power-ups unique to this implementation 2. Real-time leaderboard with animation 3. Dynamic background themes based on player size). 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 movement control systems) 2. Function modules unrelated to the Agar.io gameplay (e.g., unnecessary mini-games within) 3. Fancy effects that affect mobile 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 logic/view/input handling layers), code organization, and optimization for TikTok/Douyin's WebView environment. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the code isn't bundled or minified for production. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet short-form video platform standards?",
+      "description": "Evaluate whether the overall design follows mobile-first principles: 1) Bold, vibrant colors that stand out on video feeds 2) Large, touch-friendly UI elements (minimum 44×44px tap targets) 3) Minimal text with large fonts (≥16px). Deduct 3 points for hard-to-see elements on mobile, 5 points for cluttered interfaces, and 5 points for UI that obscures gameplay. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and optimized for short gameplay sessions?",
+      "description": "Judge whether the game is designed for TikTok/Douyin's fast-paced environment: 1) Initial load time ≤ 2 seconds 2) Game start to active play ≤ 3 seconds 3) Responsive controls with ≤ 50ms input lag. Deduct 5 points for each second of loading beyond thresholds, 3 points for each extra step before gameplay begins, and 5 points if touch controls aren't properly calibrated for mobile devices. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Action/Rhythm",
+  "difficulty": "medium"
+}

package/library/game_development-action_rhythm/two-figures-fighting-animation-mobile.json

@@ -0,0 +1,68 @@
+{
+  "index": 212,
+  "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. Create an animation code of two little figures fighting - one red figure and one blue figure. Don't use simple blocks to represent the figures; they should have relatively realistic human body shapes with heads, hands, and feet. Both figures should be holding knives. The code should be directly runnable on mobile phones!",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Are the human figure representations anatomically reasonable?",
+      "description": "Evaluate whether the figures have realistic human body proportions with clearly defined heads, torsos, arms, legs, and feet. The figures should not be simplistic stick figures or blocks. Check whether the body parts are properly connected and move naturally during the animation. Score 0 if only basic shapes are used, 5 if figures have basic body parts but with unrealistic proportions, and 10 if figures appear realistic with proper anatomical structure.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the knife-holding combat animation properly implemented?",
+      "description": "Review the implementation of weapon holding and combat movements. The knives should be visually distinct objects that remain properly positioned in the figures' hands during movement. Combat animations should include attack motions, defensive postures, and appropriate weapon trajectories. Deduct 5 points if weapons float disconnected from hands, 3 points if combat movements are too simplistic (less than 3 distinct fighting moves). Give 10 points if weapons appear naturally held with realistic combat movements.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is color differentiation and character distinction effective?",
+      "description": "Assess whether the red and blue figures are clearly distinguishable not just by color but also potentially by subtle differences in appearance or fighting style. Color contrast should be sufficient for visibility on various backgrounds. Deduct 3 points if the color difference is the only distinguishing feature, 5 points if the figures are identical apart from color. The full score is 10 points for characters with unique identities beyond color.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the animation optimized for mobile devices?",
+      "description": "Check whether the code is specifically optimized for mobile execution, including touch controls if interactive, responsive design that adapts to different screen sizes, and performance optimization techniques. Verify mobile viewport settings and touch event handling if applicable. Deduct 5 points if no mobile-specific optimizations exist, 3 points if performance issues would occur on mid-range devices. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as browser compatibility issues, screen resizing, device rotation, etc.) and provide graceful fallbacks. 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 lighting effects during combat 2. Environmental interactions like surfaces breaking 3. Combat progression with changing fighting styles). 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 animation loops or duplicate rendering code 2. Unnecessary features unrelated to the fighting animation (e.g., unrelated background animations) 3. Excessive effects that cause performance issues on mobile devices. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core animation is interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating animation logic/rendering/control layers), code reusability, and performance optimization. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if no performance optimizations for animation are implemented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the visual design meet professional animation standards?",
+      "description": "Evaluate whether the overall design follows animation principles: 1) Anticipation before movements 2) Proper squash and stretch for impact 3) Professional timing and spacing for realistic motion. Deduct 3 points for each jerky movement, 5 points for unrealistic motion physics, and 5 points for inconsistent animation quality between characters. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the animation smooth and performant?",
+      "description": "Judge whether the animation maintains consistent frame rates on mobile devices: 1) At least 30fps performance on mid-range phones 2) No visual stuttering during complex movements 3) Efficient use of resources (memory/CPU/GPU). Deduct 5 points for each noticeable frame drop, 3 points for jittery transitions between animation sequences, and 5 points if the animation causes significant battery drain. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Action/Rhythm",
+  "difficulty": "easy"
+}

package/library/game_development-action_rhythm/two-player-fighting-web-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1419,
+  "question": "You are a coding expert. Please use your professional knowledge to generate accurate and professional responses. Make sure that the code you generate is executable and displayable. Please create a two-player fighting web game code for me again, ensuring advanced code logic that can run completely.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core combat system fully implemented?",
+      "description": "Review whether the code accurately implements player movement, attacks, and collision detection mechanisms. Check if there are health systems, damage calculation, and hit detection logic. Score 0 if the core interaction logic is not implemented, 5 if only basic movement and attacks exist, and 10 if advanced combat mechanics (combos, special moves, blocking) are fully included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the two-player functionality properly implemented?",
+      "description": "Evaluate whether the code properly handles two players on the same screen or via network. Check for proper input handling for both players (keyboard controls for local play or WebSocket for online). Deduct 5 points if player states are not properly separated and synchronized, and 3 points if there's no mechanism to prevent input conflicts. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the game state management robust and comprehensive?",
+      "description": "Check if the code includes proper state management for the fighting game (character selection, round start/end, win/lose conditions, timing). Evaluate whether game rounds are properly tracked and if there's a clear victory determination system. Deduct 5 points if the game state is inconsistent after multiple rounds, and 3 points if timeout handling is missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the character balance and game mechanics well-designed?",
+      "description": "Assess whether the fighting game has balanced characters with distinct abilities, hitboxes, and movement speeds. Check if the combat mechanics are fair and engaging. Deduct 5 points if one character has clear advantages over others, and 3 points if the combat feels too simplistic or lacks strategy. 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 input spamming, out-of-bounds movement, timing 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. Dynamic environmental effects that impact gameplay 2. Replay system with slow-motion highlights 3. Character progression or unlockable moves). 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 coexisting) 2. Function modules unrelated to fighting gameplay (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive particle effects 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/input handling layers), proper class hierarchies for characters/moves, and performance optimization. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no performance optimization for animation rendering. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional fighting game standards?",
+      "description": "Evaluate whether the overall design follows fighting game visual conventions: 1) Clear health bars and round indicators 2) Responsive character animations with proper hit feedback 3) Distinct visual cues for special moves and attacks. Deduct 3 points for unclear UI elements, 5 points for animations that don't properly communicate gameplay, and 5 points for poor visual feedback on hits/blocks. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and responsive?",
+      "description": "Judge whether the game controls and animations conform to fighting game standards: 1) Input response time ≤ 50ms 2) Proper attack startup and recovery frames 3) Smooth animation transitions between moves. Deduct 5 points for input lag, 3 points for jerky or inconsistent animations, and 5 points for poor hit feedback and impact visualization. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Action/Rhythm",
+  "difficulty": "medium"
+}

package/library/game_development-action_rhythm/web-animation-stick-figures-fighting.json

@@ -0,0 +1,68 @@
+{
+  "index": 208,
+  "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 whenever possible. I am a programming beginner, please help me create a web-based animation showing stick figures fighting each other, and guide me on how to use it.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the stick figure fighting animation properly implemented?",
+      "description": "Review whether the code correctly implements stick figure characters with proper joint connections and movement capabilities. Check if the animation includes proper physics for realistic movements (e.g., gravity, momentum). Score 0 if stick figures are not properly rendered, 5 if basic static figures are drawn but animation is limited, and 10 if fully articulated stick figures with smooth movements are implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the fighting interaction between stick figures implemented?",
+      "description": "Evaluate the implementation of combat mechanics between stick figures. Check for collision detection between figures, attack animations, defensive moves, and health/damage systems. Score 0 if no interaction exists, 5 if basic collision is implemented but combat feels unrealistic, and 10 if there's a comprehensive combat system with various attacks, defenses, and believable physics.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there user control for the stick figures?",
+      "description": "Assess the implementation of keyboard/mouse controls that allow users to manipulate at least one of the stick figures. Check for responsiveness (inputs registered within 100ms), intuitiveness of controls, and whether instructions are provided. Deduct 5 points if controls are limited to basic movements, 3 points if there are no alternative control schemes. Full score requires comprehensive controls for both movement and combat actions.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the animation loop and game state management properly implemented?",
+      "description": "Examine whether the code implements proper requestAnimationFrame usage, maintains consistent frame rates (target 60fps), and handles game states (start, pause, resume, end conditions). Check for memory leaks during long gameplay. Deduct 5 points for frame rate issues, 5 points if there's no proper game state handling, and 3 points if animation timing is inconsistent.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code handles common edge cases (browser compatibility, window resizing, input device variations, performance degradation). Code with strong robustness should gracefully handle these scenarios with fallback mechanisms. Give 10 points for comprehensive error handling and browser compatibility, 5 points for average robustness, and 0 points if the code breaks easily under common variations.",
+      "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. Special moves or combos 2. Environmental interactions like obstacles 3. Different fighting styles for stick figures 4. Sound effects synchronized with animations). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant animation loops or rendering processes 2. Unnecessary visual elements unrelated to the fighting animation 3. Complex effects that impact performance without adding value to the core experience. Deduct 3 points for each redundancy found, and directly deduct 10 points if redundant code significantly impacts core animation performance.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (separation of animation logic, rendering, and user input handling), clean code practices, and maintainability. Deduct 5 points if global variable pollution is excessive; deduct 5 points if there's high code duplication (over 30%); deduct 5 points if the code lacks proper commenting for a beginner to understand. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the animation canvas is properly positioned with adequate margins, if controls/UI elements follow consistent design principles, and if the overall visual presentation is clean. Deduct 3 points for poorly positioned elements, 5 points for inconsistent visual style between UI and animation, and 5 points for lack of visual feedback during interactions. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the beginner guidance comprehensive and educational?",
+      "description": "Assess the quality of instructions provided for beginners: 1) Clear setup instructions that work without advanced knowledge 2) Explanation of code concepts used in the animation 3) Guidance on how to modify or extend the animation. Deduct 5 points if setup instructions are incomplete, 5 points if there's no explanation of core animation concepts, and 3 points if there's no guidance for customization. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Action/Rhythm",
+  "difficulty": "easy"
+}

package/library/game_development-action_rhythm/wong-ka-kui-parkour-game-html.json

@@ -0,0 +1,68 @@
+{
+  "index": 765,
+  "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. Help me create a parkour game where the character is Wong Ka Kui (Beyond's lead vocalist), controlled by the A, W, S, D keys, in HTML format.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the basic parkour game mechanics fully implemented?",
+      "description": "Review whether the code implements core parkour mechanics including: character movement, jumping mechanism, obstacle generation and collision detection. Score 0 if the character cannot move, 5 if only basic left-right movement exists, and 10 if complete parkour mechanics (including jumping, dodging, and progressive difficulty) are implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the Wong Ka Kui character properly implemented and designed?",
+      "description": "Check whether the Wong Ka Kui character is visually recognizable (either through sprites or CSS design), has appropriate animations for different actions (running, jumping, falling), and maintains the iconic elements associated with the Beyond vocalist. Deduct 5 points if the character lacks recognizable features, 3 points if animations are missing, and 2 points if proportions are significantly distorted. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the A, W, S, D key control system properly implemented?",
+      "description": "Evaluate whether the WASD key controls are responsive (≤100ms delay), intuitive (W for jump, A/D for left/right movement, S for ducking/sliding), and handle edge cases like multiple key presses. Check for keyboard event listeners and proper key mapping. Deduct 5 points if controls are unresponsive or laggy, and 5 points if key combinations aren't handled properly. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the game environment and obstacle system well-designed?",
+      "description": "Assess whether the game includes varied obstacles that spawn progressively, a scoring system that tracks the player's progress, and background elements that create an engaging parkour environment. Deduct 3 points for monotonous obstacles, 3 points for missing score tracking, and 4 points if the difficulty doesn't increase over time. 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 key presses, browser resizing, performance issues on slower devices, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Beyond music integration 2. Special power-ups related to Wong Ka Kui or Beyond 3. Easter eggs from Beyond's music history). 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 the parkour game (e.g., unnecessary menus or settings) 3. Fancy effects that affect performance (e.g., excessive particles or 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 game logic/rendering/input handling), code organization, and maintainability. Deduct 5 points if global state pollution is found or if game functions are not encapsulated properly; 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 overall design follows modern game design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout of game elements (score display, character, obstacles) 3) Professional font system for game text (instructions, score, game over). 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 game's dynamic effects conform to human perception characteristics: 1) Character responds to controls within 100ms 2) Animation transitions are smooth (60fps target) 3) Collision feedback is clear and precise. Deduct 5 points if controls feel unresponsive, 3 points for jerky animations or frame drops, and 5 points for unclear collision boundaries or feedback. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Action/Rhythm",
+  "difficulty": "medium"
+}

package/library/game_development-adventure/ancient-ruins-adventure-game-html-js.json

@@ -0,0 +1,68 @@
+{
+  "index": 137,
+  "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 use HTML and JavaScript to implement an Ancient Ruins adventure game where players need to explore ruins and discover secrets. Tip: Implement exploration and decryption mechanisms.\nPlease include comments in your code to help other developers understand your implementation process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Ancient Ruins exploration system fully implemented?",
+      "description": "Review whether the code implements a navigable ruins environment with interactive elements (rooms, corridors, landmarks) and clear spatial relationships. Check if the player can move between different areas of the ruins with appropriate transitions and if the environment provides adequate visual/textual feedback about the current location. Score 0 if there's no exploration functionality, 5 if basic movement between fixed locations exists, and 10 if a comprehensive ruins exploration system with multiple paths and areas is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are puzzle/decryption mechanisms properly integrated?",
+      "description": "Evaluate the implementation of puzzles or decryption challenges within the game. Check for variety (at least 3 different types), increasing difficulty progression, clear feedback on success/failure, and hint systems. Puzzles should be contextually appropriate for ancient ruins (hieroglyphics, symbol matching, sequence puzzles, etc.). Deduct 5 points if puzzles are too simplistic or illogical, 3 points if there's no difficulty curve, and 5 points if puzzle completion doesn't meaningfully advance gameplay.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there a discovery/reward system for exploration?",
+      "description": "Check whether the game includes a system for discovering artifacts, treasures, or secrets that rewards player exploration. Evaluate if found items are tracked in an inventory, if discoveries reveal lore/story elements, and if there are hidden areas requiring specific actions to access. Deduct 3 points if discoveries are purely cosmetic with no gameplay effect, 5 points if there's no tracking system, and 5 points if discoveries aren't integrated into the overall game narrative.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the game state persistence implemented?",
+      "description": "Assess whether the game implements state management to save player progress, discovered items, and solved puzzles. Check for local storage implementation, save/load functionality, and whether the game state persists across browser sessions. Deduct 3 points if only partial game state is saved, 5 points if there's no auto-save feature, and 8 points if progress is completely lost on page refresh.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid player input, browser compatibility issues, resource loading failures) 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 lighting/shadow effects matching the ruins theme 2. Environmental sound effects triggered by player actions 3. Procedurally generated room layouts for replayability). 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 movement control systems) 2. Function modules unrelated to the ruins exploration theme (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive particle systems or 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 game logic/view/input handling), code organization, quality of comments, and reusability of components. 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. 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 while maintaining an ancient ruins aesthetic: 1) Thematic color palette suitable for ruins (earthy tones, stone textures) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Atmospheric typography (readable yet thematic fonts). Deduct 3 points for inconsistent visual elements, 5 points for unreadable text or controls, and 5 points for visuals that break immersion. 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 animations between ruins areas feel natural (300-500ms) 3) Clear visual indicators for interactive elements. Deduct 5 points for each operation without feedback, 3 points for jarring transitions between scenes, and 5 points for interactive elements that aren't clearly distinguishable from decorative ones. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Adventure",
+  "difficulty": "medium"
+}

package/library/game_development-adventure/character-disappears-scene-appears-mouse-click.json

@@ -0,0 +1,68 @@
+{
+  "index": 928,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Ensure that the generated code is executable for demonstration. How would you create code for effects like in games where a character disappears and a scene appears after a mouse click?",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the character transition effect properly implemented?",
+      "description": "Review whether the code implements a smooth transition effect for the character's disappearance. Check for fade-out animations, opacity transitions, or other visual effects that make the character disappear naturally rather than abruptly. Score 0 if no transition effect is implemented, 5 if basic disappearance is achieved, and 10 if the transition includes polished animations like dissolve, particle effects, or custom easing functions.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the scene appearance transition properly implemented?",
+      "description": "Evaluate the scene appearance mechanism after the character disappears. Look for proper scene loading, fade-in effects, and smooth transitions. The code should demonstrate techniques like preloading, cross-fading between scenes, or progressive reveal. Deduct 5 points if the scene appears abruptly without animation, and 3 points if the transition is basic but lacks polish. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the click event handling properly implemented?",
+      "description": "Check if the click event is correctly captured and processed to trigger the transition. The implementation should include event listeners with proper scope, preventing event bubbling issues, and handling multiple clicks gracefully (preventing users from triggering the transition multiple times). Deduct 5 points if click handling is basic without safeguards, and 3 points if edge cases like rapid clicking aren't addressed. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is asset preloading/management handled effectively?",
+      "description": "Assess whether the code properly handles loading and management of visual assets required for both character and scene. Look for techniques like image preloading, texture atlases, or resource management systems. Code should avoid visible loading delays during the transition. Deduct 5 points if assets are loaded only when needed causing delays, and 3 points if loading indicators are missing. Give 10 points if asset management is comprehensive with loading optimization.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as missing assets, browser incompatibilities, performance issues on slower devices, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Interactive elements during the transition 2. Sound effects synchronized with visual changes 3. Responsive design adaptation for different screen sizes). 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 transition effects that overlap or conflict 2. Unnecessary DOM manipulations that could be handled more efficiently 3. Excessive animations that affect performance or distract from the main transition. 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 animation logic from event handling and scene management), potential for reusability, and code organization. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the code 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 overall design follows modern design principles: 1) Visual consistency between character and scene elements 2) Proper use of visual hierarchy to guide attention 3) Appropriate use of color, contrast, and space to create mood and atmosphere. Deduct 3 points for each visual inconsistency, 5 points for clashing visual elements, and 5 points for poor composition that disrupts the transition effect. 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 after click (≤ 100ms) 2) Natural-feeling transition timing (neither too fast nor too slow) 3) Proper use of easing functions for organic movement. Deduct 5 points for jerky animations, 3 points for frame rate drops during transitions, and 5 points for awkward timing that breaks immersion. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Adventure",
+  "difficulty": "easy"
+}

package/library/game_development-adventure/complete-text-adventure-game-code.json

@@ -0,0 +1,68 @@
+{
+  "index": 1441,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code when possible. Complete text adventure game code",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the text adventure game core engine fully implemented?",
+      "description": "Review whether the code accurately implements a complete game engine including room/location system, inventory management, command parsing, and game state persistence. Check if the parser can handle natural language commands (go north, take key, use item) and includes command aliases. Score 0 if basic navigation is missing, 5 if only simple move/look commands work, and 10 if complex multi-word commands and contextual responses are fully supported.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the interactive narrative system comprehensive?",
+      "description": "Evaluate whether the game includes a rich story framework with branching narratives, character dialogue systems, and quest/puzzle mechanics. Check for dynamic text generation, story progression tracking, and multiple endings based on player choices. Deduct 5 points if dialogue lacks depth or character development, 3 points if puzzles are too simplistic. Full score requires complex narrative branching with meaningful consequences.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the game world architecture well-designed and scalable?",
+      "description": "Assess whether the game world uses proper data structures for rooms, items, NPCs, and their relationships. Check for modular design allowing easy addition of new locations and content. Evaluate if the world state management supports complex interactions like item combinations, environmental changes, and persistent world modifications. Deduct 5 points if world data is hardcoded without extensibility, 3 points if object relationships are poorly structured.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the save/load and game progression system implemented?",
+      "description": "Check whether the code includes comprehensive save game functionality with multiple save slots, auto-save features, and game state serialization. Evaluate if the system can restore complex game states including inventory, world changes, story progress, and NPC states. Deduct 5 points if save system only covers basic variables, 3 points if no auto-save or crash recovery exists. Requires full state persistence for maximum score.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid commands, empty input, malformed save files, memory constraints, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should gracefully handle edge cases like circular command loops, null object references, and provide helpful hints for confused players. Give 10 points if fully robust, 5 points if average robustness, and 0 points if no exception handling exists.",
+      "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 gaming experience (e.g., 1. Dynamic ASCII art generation 2. Voice-to-text command input 3. Procedural content generation 4. Multi-language support 5. Achievement/statistics system 6. Interactive help system with contextual hints). 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 command parsers coexisting) 2. Function modules unrelated to text adventure gaming (e.g., built-in calculator or unrelated mini-games) 3. Over-complicated features that detract from core gameplay (e.g., unnecessary graphics overlays in a text game). Deduct 3 points for each redundancy found, and directly deduct 10 points if core text adventure mechanics 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/parser/data layers), code documentation, and maintainability. Check for proper class/function organization, consistent naming conventions, and separation of concerns. Deduct 5 points if global state pollution is found or no design patterns are used; deduct 5 points if code duplication rate is too high (over 30%); deduct 5 points if code lacks comments or documentation. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the text interface design meet professional standards?",
+      "description": "Evaluate whether the text presentation follows good typography principles: 1) Consistent text formatting and spacing 2) Clear visual hierarchy for different types of content (descriptions, dialogue, system messages) 3) Readable font choices and appropriate line spacing 4) Proper use of colors/styling to distinguish content types. Deduct 3 points for inconsistent formatting, 5 points for poor readability or eye strain, and 5 points for confusing visual hierarchy. Screenshots should show clean, professional text layout.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the user interaction smooth and intuitive?",
+      "description": "Judge whether the command interface provides smooth user experience: 1) Command response time ≤ 200ms 2) Clear feedback for all player actions 3) Intuitive command structure that feels natural 4) Helpful error messages and suggestions for invalid commands 5) Consistent interaction patterns throughout the game. Deduct 5 points for each operation without clear feedback, 3 points for confusing command syntax, and 5 points for inconsistent interaction patterns. Screenshots should demonstrate responsive and user-friendly interface.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Adventure",
+  "difficulty": "easy"
+}