@getollie/cli 0.0.1

package/library/game_development-action_rhythm/html5-game-virtual-joystick-npc-combat-vehicles-missions-map.json

@@ -0,0 +1,68 @@
+{
+  "index": 423,
+  "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 a complete HTML5 game code that includes virtual joystick controls, mobile system, NPC combat, vehicle driving and mission systems, with some NPCs owning vehicles that we can steal, and featuring a large map.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the virtual joystick control system properly implemented?",
+      "description": "Examine whether the virtual joystick provides smooth, responsive touch controls with proper event handling, tactile feedback, and customizable sensitivity. Check if it handles multi-touch events, provides visual feedback, and adapts to different screen sizes. Score 0 if joystick controls are missing, 5 if basic implementation exists but lacks responsiveness or visual feedback, and 10 if fully implemented with configurable deadzones and multi-directional input support.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the mobile-friendly architecture properly designed and implemented?",
+      "description": "Evaluate if the code uses responsive design principles, optimizes for mobile performance (e.g., texture compression, asset loading strategies), implements proper touch events handling, and includes mobile-specific features like device orientation controls. Deduct 5 points if mobile detection and adaptation are missing, and 3 points if performance optimizations for mobile devices are inadequate. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the NPC combat system fully functional?",
+      "description": "Analyze if NPCs have proper AI behaviors (pathfinding, aggression ranges, combat tactics), health/damage systems, and provide appropriate challenge levels. Check for combat mechanics like hitboxes, weapon systems, and damage indicators. Deduct 5 points if NPCs lack basic AI behaviors, 3 points if combat interactions are buggy or incomplete. Give 10 points for a complete system with varied NPC types and combat behaviors.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the vehicle system and theft mechanic completely implemented?",
+      "description": "Check if vehicles have realistic physics (acceleration, braking, steering), collision detection, enter/exit animations, and if NPCs can own and drive vehicles. Validate if the player can approach NPC vehicles, steal them through appropriate mechanics, and if NPCs respond accordingly. Deduct 5 points if vehicle physics are unrealistic, and 5 points if the stealing mechanic is missing or poorly implemented. 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 touch event errors, device orientation issues, resource loading failures, 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. Weather systems affecting gameplay 2. In-game economy with shops/upgrades 3. Day/night cycle with different NPC behaviors). 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 systems that conflict) 2. Function modules unrelated to the core gameplay (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive particle effects that slow down mobile devices). 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 systems), proper use of design patterns, code organization, and asset management. 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 proper asset preloading and caching strategies are missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional game design standards?",
+      "description": "Evaluate whether the UI follows modern game design principles: 1) Clear, non-intrusive HUD elements 2) Proper scaling across different device sizes 3) Consistent visual language and readable text (minimum 16px on mobile). Deduct 3 points for cluttered UI elements, 5 points for poor visibility during gameplay, and 5 points for inconsistent UI styling. 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 performance: 1) Minimum 30 FPS during gameplay 2) Loading times under 5 seconds for scene transitions 3) Responsive controls with input lag under 100ms. Deduct 5 points for frequent frame drops, 3 points for janky animations, and 5 points for unresponsive controls during intense gameplay. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Action/Rhythm",
+  "difficulty": "hard"
+}

package/library/game_development-action_rhythm/mario-style-game-html.json

@@ -0,0 +1,68 @@
+{
+  "index": 425,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure any code you generate is executable for demonstration. Create a Mario-style game using HTML.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core Mario game mechanics fully implemented?",
+      "description": "Review whether the code accurately implements fundamental mechanics like character movement (left/right running, jumping), gravity physics, collision detection with platforms/blocks, and enemy interactions. Score 0 if core mechanics are missing, 5 points if only basic movement is implemented, and 10 points if all classic Mario mechanics (including jumping on enemies, breaking blocks, collecting coins) are properly implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the level design system properly constructed?",
+      "description": "Check whether the code provides a flexible system for defining game levels, including platform placement, enemy positioning, item distribution, and scrolling functionality. Evaluate if the level structure supports horizontal scrolling as Mario moves. Deduct 5 points if scrolling is missing, 3 points if collision detection with level elements is inconsistent. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are classic Mario game elements included?",
+      "description": "Evaluate whether the implementation includes recognizable Mario elements like coins, mushrooms for power-ups, question blocks, pipes, different enemy types, and end-level flags. Deduct 2 points for each missing classic element that affects the authentic Mario experience. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the game state and scoring system properly implemented?",
+      "description": "Check whether the code includes game state management (lives system, level progression, score tracking), power-up status effects, and proper restart/game over conditions. Deduct 3 points if the scoring system is missing, 3 points if power-up effects don't change gameplay, and 4 points if level progression or game over handling is absent. 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 changes, browser resizing, performance issues on different devices) and provide friendly error handling 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. Custom level editor 2. Modern visual effects while maintaining retro style 3. Mobile-friendly touch controls 4. Local 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 movement control systems) 2. Function modules unrelated to the Mario game (e.g., unrelated mini-games) 3. Fancy effects that affect performance (e.g., excessive particle effects 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 engine/rendering/input handling), code reusability, and maintainability. Evaluate whether the game loop uses requestAnimationFrame properly and maintains consistent FPS. 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 the game performance degrades significantly during play. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the visual design balances retro Mario aesthetics with modern web standards: 1) Consistent pixel art style that respects the original design 2) Proper UI scaling for different screen sizes 3) Clean HUD layout showing score, lives, and level information. Deduct 3 points for inconsistent visual style, 5 points for unreadable UI elements, and 5 points for poor responsive design. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the game controls and animations feel responsive and natural: 1) Input response delay ≤ 50ms 2) Smooth character animations for running, jumping, and state changes 3) Consistent frame rate without stuttering. Deduct 5 points for input lag, 3 points for choppy animations, and 5 points for unresponsive controls during complex actions. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Action/Rhythm",
+  "difficulty": "hard"
+}

package/library/game_development-action_rhythm/monkey-king-havoc-in-heaven-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1729,
+  "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. Create a game about Monkey King's Havoc in Heaven and generate the code for it.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core gameplay mechanic of Monkey King's Havoc in Heaven properly implemented?",
+      "description": "Review whether the code accurately implements the core gameplay elements of Monkey King fighting against heavenly forces. Check for proper character movement controls, combat mechanics (attacks, special abilities like cloud-riding, somersaults, staff transformation), and enemy AI behaviors. Score 0 if core gameplay is missing, 5 if basic movement and combat exist, and 10 if the gameplay includes signature Monkey King abilities from the classic story.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the game progression system well-designed?",
+      "description": "Evaluate whether the game includes level progression that follows the narrative of Monkey King's journey (Havoc in Heaven storyline with recognizable scenes like the celestial palace, Dragon King's underwater palace, etc.). Check if there are boss battles with known characters from the story (Jade Emperor, Erlang Shen, Nezha). Deduct 5 points if the game lacks progression logic, and 3 points if the progression doesn't follow the traditional narrative. Give 10 points for a comprehensive story-based level system.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the key character abilities and transformations of Monkey King implemented?",
+      "description": "Check whether the code implements Monkey King's signature abilities: 1) Staff transformation (extending/shrinking), 2) 72 transformations or shapeshifting, 3) Cloud-somersault travel, 4) Hair magic tricks. Deduct 3 points for each missing signature ability. The full score is 10 points for including all or most iconic abilities with proper visual feedback.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the game's visual style consistent with Chinese mythological aesthetics?",
+      "description": "Assess whether the visual elements (character designs, environments, animations) reflect traditional Chinese art styles appropriate for the Journey to the West theme. Check for proper use of colors symbolic in Chinese culture, traditional architectural elements, and authentic character designs. Deduct 5 points if the visuals are generic without Chinese cultural elements, and 3 points if the style is inconsistent. 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 out-of-bounds input, resource loading failures, user operation errors, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Dynamic weather systems affecting gameplay 2. Procedurally generated heavenly palaces 3. Interactive storytelling with famous scenes from Journey to the West). 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 Monkey King theme (e.g., unrelated mini-games) 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 logic/view/physics/input layers), resource management efficiency, 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 optimization for asset loading and rendering. 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 matching reflecting Chinese cultural aesthetics 2) Proper layout spacing for game HUD elements 3) Professional font system with legible text that fits the theme (possibly stylized Chinese-inspired fonts). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic UI layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Responsive controls with input lag ≤ 100ms 2) Smooth animations for Monkey King's movements and transformations 3) Clear visual feedback for player actions and game events. Deduct 5 points for each operation without feedback, 3 points for choppy animations during fast movements, and 5 points for unclear combat hit detection or feedback. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Action/Rhythm",
+  "difficulty": "medium"
+}

package/library/game_development-action_rhythm/music-rhythm-training-application.json

@@ -0,0 +1,68 @@
+{
+  "index": 645,
+  "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. Design a music rhythm training application where users listen to beats at different speeds and then practice by clicking a beat button within a specified time period. The system compares the user's clicking rhythm with the standard rhythm to calculate a score, displaying the user's rhythm accuracy.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the audio playback system properly implemented?",
+      "description": "Review whether the code accurately implements audio playback functionality using Web Audio API or similar technology, with proper handling of timing precision. Check if it includes adjustable tempo controls (BPM range at least 40-240), metronome sounds with appropriate attack and decay, and the ability to schedule beats with millisecond precision. Score 0 if core audio playback is not implemented, 5 if basic playback without precise timing is implemented, and 10 if the system has precise timing and all required controls.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the rhythm detection and scoring mechanism accurate?",
+      "description": "Evaluate whether the application correctly measures the time difference between user clicks and expected beats. The scoring system should account for human reaction time (typically 150-250ms) and have a graded scoring scale based on timing accuracy. Check for proper handling of early/late clicks with visualization of deviations. Deduct 5 points if the scoring doesn't account for human reaction time, and 3 points if the scoring lacks granularity (e.g., just right/wrong). The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the training progression system comprehensive?",
+      "description": "Check whether the application provides a structured learning approach with increasing difficulty levels (e.g., starting with simple quarter notes and progressing to complex polyrhythms). Verify if it includes exercises with varying time signatures (3/4, 4/4, 5/8, etc.) and rhythm patterns. Evaluate if there's a clear progression path with unlockable levels based on performance. Deduct 5 points if progression is linear without adaptivity, and 3 points if variety in rhythm patterns is limited. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is performance analysis and feedback implemented?",
+      "description": "Assess whether the application provides detailed performance metrics and visual feedback. Look for features like historical performance tracking, visualization of timing errors (e.g., waveform or graph showing deviations), and actionable improvement suggestions. The system should store and display progress over time. Deduct 5 points if only basic scoring is provided without visual representation, and 3 points if historical tracking is missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as audio context initialization failures, timing drift, browser compatibility issues, etc.) and provide friendly error prompts or recovery mechanisms. Check for proper cleanup of audio resources and event listeners. 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. Visualization of rhythm patterns with animations 2. AI-assisted rhythm correction 3. Social features for comparing scores with friends 4. Exportable practice recordings). 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 timing systems coexisting) 2. Function modules unrelated to rhythm training (e.g., a built-in music player without training purpose) 3. Fancy effects that affect performance (e.g., excessive animations that impact timing accuracy). 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 audio engine/UI/scoring logic), unit test coverage for timing-critical components, 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). Check if visual cues for rhythm are intuitive and clear. 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) Input latency ≤ 50ms (critical for rhythm applications) 2) Visual feedback synchronized with audio events 3) Clear visual indication of successful/missed beats. Check if the application feels responsive during interaction. Deduct 5 points for perceptible input lag, 3 points for audio-visual synchronization issues, and 5 points for confusing feedback during rhythm exercises. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Action/Rhythm",
+  "difficulty": "hard"
+}

package/library/game_development-action_rhythm/musical-rhythm-key-response-action-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 38,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the generated code is executable for display.\n\nPlease use HTML and JavaScript to implement an action game - rhythm game: Musical rhythm and key response\n\n**Task**: Design a rhythm game system where players need to press corresponding keys according to the music rhythm to score points.\n\n**Hint**: You can use audio analysis or time nodes to synchronize key inputs with music rhythm.\n\nPlease create the game and add some comments in the code so other developers can understand your implementation process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the rhythm game core mechanics fully implemented?",
+      "description": "Review whether the code accurately implements the key note system through HTML/JavaScript, including note generation, timing detection, and scoring calculation. Check if there's proper synchronization between the music and falling notes. Score 0 if the core mechanics are missing, 5 if basic note detection works but with timing issues, and 10 if the system has precise timing windows with appropriate visual feedback.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the audio synchronization mechanism properly designed?",
+      "description": "Evaluate whether the game implements proper audio synchronization using either audio analysis (frequency/beat detection) or predefined time nodes. Check for audio calibration options to handle different devices/browsers. Deduct 5 points if there's noticeable lag between audio and visuals, 3 points if there's no calibration system, and 2 points if the synchronization degrades over time. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is a comprehensive scoring system implemented?",
+      "description": "Check whether the code includes a multi-tier scoring system (Perfect/Great/Good/Miss) with appropriate timing windows, combo multipliers, and visual/audio feedback for each tier. Evaluate if the scoring algorithm rewards consistency and includes features like combo breaks and recovery. Deduct 5 points if only binary hit/miss detection exists, and 3 points if combo tracking is missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a complete song/level management system?",
+      "description": "Review if the code includes functionality for multiple songs/difficulty levels with different note patterns. Check if there's a difficulty rating system, song selection interface, and progression tracking (high scores, grade rankings). Deduct 5 points if only a single song is supported, 3 points if difficulty options are missing, and 2 points if there's no score persistence. 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 audio loading failures, browser audio API limitations, irregular key presses, 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 difficulty adjustment 2. Custom beatmap creator 3. Visual effects synchronized with music intensity). 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 input detection logic (e.g., multiple keyboard event listeners with overlapping functionality) 2. Function modules unrelated to rhythm gameplay (e.g., unnecessary mini-games) 3. Excessive visual effects that cause performance issues on regular devices. 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 audio handling, note generation, input detection, and rendering), code readability (including the requested developer comments), and performance optimization. Deduct 5 points if global variable abuse is found; deduct 5 points if the code lacks meaningful comments as requested; deduct 5 points if there are performance bottlenecks causing frame drops. 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 note highway with distinct lane separation 2) High contrast between notes and background for visibility 3) Coherent color scheme that matches the musical theme. Deduct 3 points for each hard-to-see element, 5 points for cluttered UI that obscures 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's response and animations conform to rhythm game standards: 1) Input lag ≤ 50ms for responsive feel 2) Smooth note movement at minimum 60fps 3) Clear hit/miss feedback with appropriate duration. Deduct 5 points for each noticeable input delay, 3 points for jerky note movement, and 5 points for confusing or missing hit feedback. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Action/Rhythm",
+  "difficulty": "hard"
+}

package/library/game_development-action_rhythm/pacman-web-game-html-css-javascript.json

@@ -0,0 +1,68 @@
+{
+  "index": 299,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure the code you provide is executable and ready to demonstrate. Write a complete Pacman web game using HTML, CSS, and JavaScript.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core Pacman gameplay mechanics fully implemented?",
+      "description": "Review whether the code correctly implements the classic Pacman mechanics: pac-dots collection, ghost AI behaviors (chase, scatter, frightened modes), power pellets that make ghosts vulnerable, player movement in four directions, and collision detection. Score 0 if core mechanics are absent, 5 if basic movement and pac-dot collection work but ghost AI is simplistic, 10 if all classic mechanics are faithfully implemented including proper ghost personalities and mode switching.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the game board and level design properly implemented?",
+      "description": "Check whether the game has a well-structured maze with walls, paths, pac-dots, power pellets, and ghost home areas. Evaluate if the collision detection with walls works accurately, if the level design is playable, and if the game includes multiple levels or difficulty progression. Deduct 5 points if the maze doesn't match classic Pacman layouts, 3 points if collision detection is buggy, and 2 points if there's no level progression. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the game state management and scoring system complete?",
+      "description": "Evaluate if the game properly manages states (start screen, active game, pause, game over, level completion) and includes accurate scoring (points for eating pac-dots, power pellets, vulnerable ghosts with increasing values for consecutive ghosts). Check if it tracks lives, high scores, and bonus fruit appearances. Deduct 5 points for incomplete state management, 3 points for inaccurate scoring system, and 2 points if high score persistence is missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are the animations and visual effects authentic to the Pacman experience?",
+      "description": "Assess whether the game includes classic Pacman animations: Pacman's mouth opening/closing while moving, ghost animations (including eyes that indicate direction), ghost vulnerability state with flashing before recovery, death animation, level introduction sequences, and fruit appearances. Deduct 3 points for each missing key animation and 5 points if animations significantly impact gameplay performance. 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 changes, browser resizing, timing issues, frame rate drops) and provide friendly error recovery. Code with strong robustness should maintain consistent gameplay experience across different devices and browsers. Give 10 points for excellent error handling and performance optimization, 5 points for average robustness with minor issues, and 0 points if game frequently breaks under normal usage conditions.",
+      "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. Custom level editor 2. Modern visual effects while maintaining classic gameplay 3. Adjustable difficulty settings 4. Mobile-friendly controls). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple movement control systems) 2. Function modules unrelated to Pacman gameplay (e.g., unnecessary mini-games) 3. Visual effects that affect performance without enhancing the core experience. 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, reuse of common functions, and performance optimization. Deduct 5 points if global variable pollution is excessive; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there are no 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 balances authenticity to classic Pacman with modern web standards: 1) Appropriate color scheme maintaining the classic look 2) Clean, readable UI elements for score, lives, and messages 3) Responsive layout that works across different screen sizes. Deduct 3 points for each usability issue, 5 points for significant departure from recognizable Pacman aesthetics without justification, and 5 points for non-responsive design. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the player control experience smooth and responsive?",
+      "description": "Judge whether the control system provides a satisfying experience: 1) Input response time ≤ 50ms 2) Support for both keyboard and touch controls on appropriate devices 3) Predictable and consistent movement behavior. Deduct 5 points for perceivable input lag, 3 points for missing alternative control schemes, and 5 points if the movement feels erratic or unpredictable. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Action/Rhythm",
+  "difficulty": "hard"
+}

package/library/game_development-action_rhythm/pixel-dance-rhythm-music-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 8,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable for demonstration purposes.\n\nPlease use HTML and JavaScript to implement \"Pixel Dance!\", an interactive rhythm and music-based game. The game provides a stage where characters dance to music. Players need to follow arrow prompts displayed at the bottom of the screen to control and complete correct dance moves. The game's objective is to accurately complete a series of actions according to the rhythm to achieve the highest score.\n\n### Gameplay\n- **Follow Instructions**: Follow the arrow directions shown on screen, input all direction keys and press the space bar at the right moment.\n- **Rhythm Matching**: Synchronize with the background music's rhythm to complete dance moves.\n\n### Game Features\n- **Visual Effects**: Dynamic pixel art style and visual effects.\n- **Music Interaction**: Gameplay closely integrated with musical rhythm.\n\n### Game Tips\n- **Pay Attention to Rhythm**: Closely follow the music rhythm and screen instructions to ensure accuracy of movements.\n- **Reaction Speed**: Quickly respond to screen instructions to improve scoring rate.\n\n### Summary\nThis game combines music, dance, and pixel art to provide players with a challenging and entertaining gaming experience. Please implement the game and include comments in the code to help other developers understand your implementation process.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core rhythm-based input system fully implemented?",
+      "description": "Evaluate whether the code implements a rhythm-based input system that accurately detects key presses (arrow keys and space bar) synchronized with music beats. Check for timing windows that categorize inputs as 'Perfect', 'Good', or 'Miss'. Score 0 if input detection is missing, 5 if basic key detection exists without timing precision, and 10 if the system includes accurate beat synchronization with visual feedback.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the music synchronization mechanism properly implemented?",
+      "description": "Check whether arrow prompts are correctly synchronized with the music beats, including proper preloading of audio assets and precise timing calculations. Verify that the game has a calibration system or offset adjustment to account for audio latency. Deduct 3 points if synchronization drifts over time, 5 points if there's no preloading mechanism for audio, and 3 points if there's no way to handle audio latency. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the dance animation system responsive and visually satisfying?",
+      "description": "Assess whether character animations transition smoothly in response to player inputs, with different animations for successful vs. failed moves. Evaluate the pixel art quality and whether animations match the rhythm. Deduct 5 points if animations are jerky or delayed, 3 points if there's no visual difference between successful/failed moves, and 2 points if animations don't match the music's rhythm. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the scoring and feedback system comprehensive?",
+      "description": "Evaluate whether the game provides clear scoring feedback (Perfect/Good/Miss indicators), maintains combo counters, and calculates final scores based on accuracy and combo chains. Check if there's appropriate visual and audio feedback for different quality inputs. Deduct 3 points if visual feedback is delayed, 3 points if the combo system is missing, and 4 points if there's no end-game score summary. 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 audio loading failures, unsupported browsers, unexpected key presses, 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. Custom difficulty settings 2. Ability to import custom songs/charts 3. Multiplayer functionality 4. Performance replay features). 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 input detection systems) 2. Function modules unrelated to rhythm gaming (e.g., unnecessary mini-games) 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 logic/view/audio handling/input detection), 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 pixel art style is consistent and polished: 1) Proper color palette suitable for pixel art (limited colors per element) 2) Consistent pixel sizing (no mixed resolutions) 3) Clear UI elements that don't obstruct gameplay. Deduct 3 points for inconsistent pixel art style, 3 points for poor contrast between UI and game elements, and 4 points for cluttered or confusing interface 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 performance meets rhythm game requirements: 1) Input lag under 50ms 2) Stable frame rate (minimum 60fps) 3) Smooth transitions between dance moves. Deduct 5 points for noticeable input delay, 3 points for frame rate drops during complex animations, and 2 points for jarring transitions between animations. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Action/Rhythm",
+  "difficulty": "hard"
+}

package/library/game_development-action_rhythm/pixel-racing-game.json

@@ -0,0 +1,68 @@
+{
+  "index": 1070,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to make the generated code executable for demonstration. Create a running pixel racing game.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core racing game engine fully implemented?",
+      "description": "Review whether the code accurately implements the fundamental racing mechanics including player movement, collision detection, and race track boundaries. Assess the physics implementation for vehicle handling (acceleration, deceleration, steering). Score 0 if the core movement mechanics are missing, 5 if basic movement is implemented without proper physics, and 10 if the game includes realistic pixel-style racing physics with proper friction and momentum handling.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the pixel art style properly executed?",
+      "description": "Evaluate whether the game consistently maintains an authentic pixel art aesthetic throughout all visual elements (vehicles, tracks, UI, effects). Check for appropriate pixel density, limited color palette usage, and proper pixel-perfect scaling. Deduct 5 points if the pixel art is inconsistent or mixed with non-pixel art elements, 3 points if anti-aliasing is incorrectly applied breaking the pixel aesthetic. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the game loop and racing progression system implemented?",
+      "description": "Check whether the code implements a complete game loop including starting sequence, lap counting, finish line detection, and race completion states. Verify if there's a timing/scoring system that tracks player performance. Deduct 5 points if lap tracking is missing, 3 points if there's no race completion state, and 5 points if there's no timing system. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there an opponent AI or multiplayer system?",
+      "description": "Assess whether the game includes AI opponents with reasonable pathfinding and difficulty scaling, or a multiplayer system allowing for competitive racing. Evaluate the AI's ability to navigate the track and provide challenge without cheating. Score 0 if no opponents exist, 5 if basic AI opponents are present but lack sophisticated behavior, and 10 if either well-implemented AI with different difficulty levels or functional multiplayer racing is available.",
+      "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 resize, frame rate drops, 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 weather effects 2. Vehicle customization options 3. Procedurally generated tracks 4. Power-ups or special abilities). 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 without purpose) 2. Function modules unrelated to racing (e.g., unnecessary mini-games) 3. Fancy effects that affect performance (e.g., excessive particle systems causing 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 logic/rendering/input handling), use of appropriate design patterns for game development, and code maintainability. Deduct 5 points if global state management is chaotic; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the game loop implementation causes performance issues. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional game design standards?",
+      "description": "Evaluate whether the overall design follows pixel game design principles: 1) Consistent pixel art style throughout UI elements 2) Readable pixel fonts at intended resolution 3) Clear visual hierarchy in game screens and HUD elements. Deduct 3 points for each inconsistent UI element, 5 points for unreadable text, and 5 points for cluttered or confusing HUD layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the gameplay smooth and responsive?",
+      "description": "Judge whether the game meets performance standards: 1) Consistent frame rate (minimum 30 FPS) 2) Input latency under 100ms 3) Smooth animations without stuttering. Deduct 5 points for noticeable frame drops during normal gameplay, 3 points for input lag affecting player control, and 5 points if collision detection feels inconsistent or unfair. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Game Development-Action/Rhythm",
+  "difficulty": "medium"
+}