@getollie/cli 0.0.4 → 0.2.0

package/library/game_development-role-playing/dynamic-npc-companion-system.json

@@ -1,68 +0,0 @@
-{
-  "index": 118,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate, expert responses. Make sure the code you generate is executable.\nPlease use HTML and JavaScript to implement a dynamic NPC companion system.\n\n**Task**: Implement a dynamic NPC companion system where players can command teammates in combat or puzzle-solving.\n\n**Hint**: You can set up a simple command system such as attack, follow, hold position, and have companions act according to the player's commands.\n\nPlease include some comments in your code so other developers can understand your implementation process.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the NPC companion command system fully implemented?",
-      "description": "Review whether the code accurately implements the core command system (attack, follow, hold position) through HTML/JavaScript, including command issuance, command visualization, and command execution by NPCs. Score 0 if no command system is implemented, 5 if only basic commands exist without proper execution logic, and 10 if a complete command system with visual feedback is implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the NPC AI behavior system properly designed?",
-      "description": "Evaluate the AI decision-making logic for NPC companions. Check for state machines or behavior trees that govern NPC responses to commands and environmental conditions. Companion NPCs should exhibit appropriate autonomous behavior when not directly commanded. Deduct 3 points if NPCs lack situational awareness, 5 points if they don't have independent decision-making capabilities, and 3 points if path-finding is missing or broken. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are combat and puzzle-solving interactions implemented?",
-      "description": "Check whether the system includes both combat mechanics (such as targeting, attacking, damage calculation) and puzzle-solving capabilities (such as object interaction, position-based puzzles). NPCs should be able to assist in both contexts based on player commands. Deduct 5 points if either combat or puzzle systems are missing, and 3 points if the implemented systems lack depth or meaningful interaction. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there a well-designed NPC status and feedback system?",
-      "description": "Assess whether the implementation includes visual indicators of NPC status (health, current command, action state) and provides feedback when commands are issued or completed. The system should communicate NPC states clearly to the player. Deduct 3 points if status indicators are missing, 4 points if command feedback is inadequate, and 3 points if there's no indication of task completion. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid commands, NPCs being unable to reach targets, collision detection 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. Adaptive NPC personalities 2. Dynamic dialogue system based on situation 3. Learning system where NPCs improve based on player actions). 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 handling systems) 2. Function modules unrelated to the NPC companion system (e.g., unrelated game mechanics) 3. Fancy effects that affect performance (e.g., excessive particle effects). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating NPC logic/command system/UI layers), code documentation quality, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if comments are insufficient or misleading. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching for command UI and NPC indicators 2) Proper layout spacing for command buttons and status displays 3) Clear visual hierarchy between player and NPC elements. Deduct 3 points for each crowded visual element, 5 points for a confusing or inconsistent UI, and 5 points for poor command visibility during action sequences. 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) Command execution feedback delay ≤ 100ms 2) NPC animation transitions are smooth and natural 3) Clear visual indication when switching between command modes. Deduct 5 points for each command without feedback, 3 points for jerky NPC movements or animations, and 5 points for confusing command state visualization. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Role-Playing",
-  "difficulty": "medium"
-}

package/library/game_development-role-playing/family-generational-marriage-drama-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 220,
-  "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 display. Create a family generational game with a fictional background that is comfortable and peaceful. Avoid fantasy, blood, horror, poisoning, birthmarks, metaphors, revenge, previous dynasties, urgent choices, and focus more on character development. I am the young lady of the family, with a mother and a random number of siblings. The game includes ancient professions like officials, scholars, warriors, doctors, merchants, farmers, etc., and differentiates between nobility and commoners. The game mainly focuses on marriage and family drama. The relationship development should progress naturally with reasonable scenarios and dialogues that match character personalities. In intimate scenes, use more casual and open language, and use parentheses to show physical actions or thoughts to create embarrassing, strong emotional experiences with colorful details of emotional reactions. No poison plots, scheming, or active seduction. I just want to have a romantic relationship with some spice.\n\nReply settings: Update the time and character information in the main interface for each round. Wrap all information in pseudo code blocks. Use asterisks for prompts, quotation marks for dialogues, and add emoji expressions. Use tree diagrams to show character relationship networks. The code blocks should fit mobile display dimensions. Reply \"next month\" to advance to the next month, or \"restart\" to regenerate character information.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core family simulation system implemented comprehensively?",
-      "description": "Review whether the code accurately implements a family generational simulator with proper character creation, attribute systems, and relationship tracking. Check for implementation of noble/commoner distinction, ancient profession system, and family hierarchy dynamics within the specified comfortable setting.Score 0 if core simulation is missing, 5 if basic family structure exists but lacks depth, 10 if the system fully models complex family relationships with appropriate attribute tracking and status changes based on interactions.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the character development and relationship progression logic properly implemented?",
-      "description": "Evaluate whether the code includes mechanisms for natural relationship development with context-appropriate dialogues and personality-driven interactions. Check if the system avoids prohibited themes (fantasy, horror, revenge plots) while still creating engaging relationship mechanics.Deduct 5 points if relationship progression is purely random without personality considerations. Deduct 3 points if dialogues don't reflect character personalities. The full score is 10 points for a robust character development system that progresses naturally with meaningful choice consequences.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are the game mechanics for time progression and event generation implemented?",
-      "description": "Check whether the code implements a functional month-by-month progression system with appropriate events, character aging, relationship changes, and new scenario generation. Verify that the \"next month\" command properly advances game state and updates all relevant variables.Award 0 points if time progression is missing, 5 points if basic monthly updates occur but lack event variety or consequence, and 10 points for a comprehensive system with appropriate life events, seasonal changes, and character development milestones.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the user interface implementation complete with all required display elements?",
-      "description": "Verify that the code properly implements all specified UI elements: code blocks for information, proper use of asterisks for prompts, quotation marks for dialogues, emojis for expressions, and relationship tree diagrams. Check if the display is optimized for mobile dimensions as requested.Deduct 2 points for each missing UI element (time/character updates, code blocks, asterisks for prompts, quotation marks for dialogues, emojis, relationship trees). Award 10 points only if all elements are properly implemented and responsive to game state changes.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid commands, unexpected input, state inconsistencies) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle edge cases.Give 10 points for comprehensive error handling and state validation, 5 points for average robustness with some edge case handling, and 0 points if no exceptions are handled.",
-      "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. Procedurally generated character backstories 2. Dynamic personality evolution based on life events 3. Seasonal festivals or special events 4. Family heirlooms or traditions that develop over time).Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple character generation systems) 2. Function modules unrelated to family simulation (e.g., unrelated mini-games) 3. Fancy effects that affect performance (e.g., excessive animations or graphics).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/state management layers), code organization, and maintainability. Check for proper encapsulation of game mechanics and state management.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 clear separation between UI and game logic. 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 for relationship trees and character information 3) Professional text formatting with consistent use of prompts, dialogue markers, and emojis.Deduct 3 points for each cluttered visual element, 5 points for inconsistent text formatting, and 5 points for poorly organized relationship trees. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the command processing and game state updates are responsive and intuitive: 1) Command feedback delay is minimal 2) State transitions are clear with appropriate feedback 3) Character and relationship updates are visually obvious after changes.Deduct 5 points for each operation without feedback, 3 points for confusing state transitions, and 5 points for difficulty in tracking relationship or character changes. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Role-Playing",
-  "difficulty": "easy"
-}

package/library/game_development-role-playing/game-backpack-item-management-system.json

@@ -1,68 +0,0 @@
-{
-  "index": 169,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable for demonstration purposes.\nPlease use HTML and JavaScript to implement a Backpack and Item Management system.\n**Task**: Implement a backpack system that allows players to collect, view, and use different items.\n**Tip**: You can use a simple list to manage items and set different effects for each item.\ngame, and include some comments in the code so other developers can understand your implementation process.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the basic backpack UI structure properly implemented?",
-      "description": "Check if the HTML/CSS implementation creates a visually distinct backpack interface with appropriate grid or list layout. Verify that items are visually represented (with icons or images) and have clear boundaries. Score 3 if only basic HTML is used without styling, 7 if the backpack has basic styling but lacks visual hierarchy, and 10 if the implementation includes a polished interface with proper spacing, borders, and item slots.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the item management system functionality complete?",
-      "description": "Evaluate whether core backpack operations are implemented: adding items, removing items, and displaying item information. Check if items have properties (like name, description, type, quantity). Verify that the system manages item stacking or unique items appropriately. Score 3 if only basic item display is implemented, 7 if basic operations work but with limitations, and 10 if all core functionality is present including proper handling of edge cases (full inventory, duplicate items, etc.).",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are item interactions and usage mechanisms implemented?",
-      "description": "Assess if the code includes ways to use or interact with items (clicking/selecting to use, equipping, consuming). Verify that different item types have different usage effects. Score 3 if items can only be selected but not used, 5 if basic usage is implemented but all items behave the same way, and 10 if multiple interaction types are implemented with different effects based on item type.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is data persistence or state management implemented?",
-      "description": "Check if the backpack system maintains state between operations and if any form of data persistence is implemented (localStorage, sessionStorage, or simulated server-side storage). Verify if item quantities and states are properly tracked and updated. Score 3 if state is lost on page refresh, 7 if basic state management exists but has flaws, and 10 if robust state management with persistence is implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as adding items to a full backpack, using items with insufficient quantity, invalid user inputs, 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. Drag-and-drop inventory management 2. Item categories with filtering 3. Item combination/crafting system 4. Visual effects when using items). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to handle item addition) 2. Function modules unrelated to inventory management (e.g., embedded mini-games) 3. Fancy effects that affect performance (e.g., excessive animations for simple interactions). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating data model/view/controllers), code comments quality, and adherence to JavaScript best practices. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if variable/function names are unclear or inconsistent. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance. Deduct 5 points for each operation without feedback, 3 points for laggy animations during item management, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Role-Playing",
-  "difficulty": "easy"
-}

package/library/game_development-role-playing/game-stat-allocation-simulator-web-wordpress.json

@@ -1,68 +0,0 @@
-{
-  "index": 379,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be careful to ensure that the code you generate is executable for demonstration. I want to create a game stat allocation simulator - a web version that can be embedded into WordPress. I will give you the rules below. Let's complete this step by step. I hope you will remember the code we create each time.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the stat allocation core system fully implemented?",
-      "description": "Review whether the code implements a complete stat allocation system that allows users to distribute points among different attributes. Check if it includes minimum/maximum constraints for each stat, total points limitation, and real-time validation. Score 0 if the core allocation logic is missing, 5 if basic allocation is implemented but lacks constraints, and 10 if the system fully handles allocation rules with proper validation.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the WordPress integration properly designed?",
-      "description": "Evaluate whether the code can be properly embedded into WordPress as required. Check for WordPress-compatible initialization (e.g., using wp_enqueue_script), proper namespacing to avoid conflicts, and responsive design that adapts to WordPress themes. Deduct 5 points if the code lacks WordPress hooks, 3 points if it doesn't handle theme compatibility, and 2 points if it doesn't use proper WordPress coding standards.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is there a save/load mechanism for stat configurations?",
-      "description": "Check if users can save their stat configurations and load them later. Examine whether the solution uses local storage appropriately, includes export/import functionality, and maintains data persistence. Deduct 5 points if saving is implemented but loading is unreliable, 3 points if there's no export/import feature, and give 0 points if no persistence mechanism exists.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there visual feedback for stat effects?",
-      "description": "Assess whether the simulator provides visual representations of how stat changes affect character abilities or game parameters. Look for graphs, charts, derived stat calculations, or other visual aids. Give 10 points for comprehensive visual feedback with multiple representation options, 5 points for basic feedback, and 0 points if visual representation is absent.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid inputs, script loading errors, browser compatibility issues, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Stat presets for different play styles 2. Comparison mode between configurations 3. Character preview based on stats). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to reset stats) 2. Function modules unrelated to stat allocation (e.g., a built-in chat system) 3. Fancy effects that affect performance (e.g., excessive animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating UI/logic/data layers), use of appropriate design patterns, and maintainable structure. Deduct 5 points if global state pollution is found; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no clear organization of components. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Immediate feedback when adjusting stats 2) Smooth transition animations for stat changes 3) Clear visual cues for available/unavailable actions. Deduct 5 points for each operation without feedback, 3 points for jerky animations during stat adjustments, and 5 points for confusing UI state representation. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Role-Playing",
-  "difficulty": "hard"
-}

package/library/game_development-role-playing/honkai-star-rail-critical-damage-attribute-multipliers.json

@@ -1,68 +0,0 @@
-{
-  "index": 1141,
-  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Pay attention to ensure that the generated code is executable for demonstration. Firstly, comment on each line. Secondly, look for examples from Honkai: Star Rail where critical damage is displayed as 200%, 150%, etc. Finally, for normal attacks, skills, etc., show what attribute multipliers are used without providing specific values.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the code provided with comprehensive line-by-line comments?",
-      "description": "Review whether each line of code includes meaningful comments that explain the purpose, logic, or functionality. Comments should be clear, concise, and add value beyond what is obvious from the code itself. Evaluate whether comments follow consistent formatting and explain complex algorithms or decision points. Score 0 if no comments are present, 5 if comments are sparse or superficial, and 10 if comments are comprehensive and insightful.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Does the code accurately implement critical damage visualization systems similar to Honkai: Star Rail?",
-      "description": "Check if the implementation correctly displays critical damage percentages (200%, 150%, etc.) in a visually distinct way. The visualization should include: 1) Different text color/size for critical hits 2) Animated effects that scale with critical damage multiplier 3) Appropriate timing for displaying the percentage. Deduct 3 points if critical values don't match the game reference, 5 points if animations are missing, and 3 points if critical hit indicators are not visually prominent. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the attribute multiplier system for different attack types properly implemented?",
-      "description": "Evaluate whether the code correctly implements different attribute multipliers for normal attacks, skills, and ultimates without hardcoding specific values. Check if the system: 1) Uses a flexible formula system that can draw from character stats 2) Separates base damage calculation from multiplier application 3) Handles special conditions like elemental weaknesses. Deduct 5 points if multipliers are hardcoded, 3 points if attack type differentiation is missing, and 5 points if the damage calculation pipeline is incomplete. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Does the implementation include a proper damage calculation system that integrates with the visualization?",
-      "description": "Assess whether the code connects the damage calculation system with the visualization components. Look for: 1) Event-based architecture for damage events 2) Proper separation between calculation logic and display logic 3) Performance optimization for multiple simultaneous damage numbers. Deduct 3 points if calculation and visualization are tightly coupled, 5 points if the system doesn't scale well with multiple damage instances, and 3 points if performance issues are evident. 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 null inputs, division by zero, unexpected data types, animation timing conflicts, etc.) and provide graceful fallbacks 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. Damage type-specific visual effects 2. Contextual damage indicators based on hit locations 3. Responsive audio cues for critical hits). 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 animation functions 2. Feature creep beyond damage calculation/visualization (e.g., unnecessary inventory systems) 3. Overly complex effects that affect performance without adding value. 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 damage calculation/visualization/animation layers), potential for unit testing, and maintainability. Deduct 5 points if global state pollution is found or proper 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 organized into logical classes or modules. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the visual design follows modern game UI principles: 1) Harmonious color matching for damage numbers (critical vs. normal) 2) Proper layout and positioning of damage indicators 3) Professional typography with appropriate size and readability. Deduct 3 points for each visual crowding issue, 5 points for poor color contrast or illegibility, and 5 points for inconsistent visual style compared to the reference game. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the animation effects conform to game feedback characteristics: 1) Damage number appearance timing is appropriate 2) Animation duration controlled for readability without blocking gameplay 3) Clear visual hierarchy between normal and critical damage. Deduct 5 points for jerky animations, 3 points for overlapping damage numbers that cause readability issues, and 5 points for animations that distract from core gameplay. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Role-Playing",
-  "difficulty": "hard"
-}

package/library/game_development-role-playing/html-three-kingdoms-role-playing-game.json

@@ -1,68 +0,0 @@
-{
-  "index": 841,
-  "question": "You are a coding expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you produce is executable and can be demonstrated. Create a Three Kingdoms role-playing game using HTML, featuring rich storylines and comprehensive gameplay mechanics.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the Three Kingdoms setting authentically implemented?",
-      "description": "Check whether the code implements an immersive Three Kingdoms environment with historically accurate characters (e.g., Liu Bei, Guan Yu, Zhang Fei, Cao Cao, Sun Quan), events, and locations from the era. Score 0 if there are no authentic Three Kingdoms elements, 5 if only basic character references are included, and 10 if the game features rich historical context with accurate representation of major battles, alliances, and political dynamics.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the role-playing system comprehensively developed?",
-      "description": "Evaluate whether the code implements core RPG mechanics including character attributes (strength, intelligence, leadership, etc.), skill trees specific to different Three Kingdoms heroes, equipment systems, and character progression. Deduct 5 points if character attributes don't influence gameplay, 3 points if skill acquisition is linear rather than branching, and 2 points if equipment has no meaningful impact on gameplay. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the storyline rich and engaging with multiple paths?",
-      "description": "Check if the game offers branching storylines where player choices impact the narrative progression. Look for multiple story arcs (minimum 3 major storylines representing Wei, Shu, and Wu kingdoms), dialogue systems with meaningful choices, and consequences that alter the game world. Deduct 5 points if the story is completely linear, 3 points if choices don't meaningfully impact outcomes, and 2 points if historical events aren't incorporated into the narrative. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are the gameplay mechanics comprehensive and balanced?",
-      "description": "Assess whether the game includes strategic battles, resource management, diplomacy systems, and character relationships. Each system should be interconnected and balanced. Examine if battle mechanics include terrain effects, unit types, and tactical options. Score 0 if core gameplay mechanics are missing, 5 if mechanics exist but lack depth or balance, and 10 if all systems are fully implemented with proper balancing and strategic depth.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid inputs, resource loading failures, browser compatibility issues, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Dynamic weather system affecting battles 2. Historical advisor system providing authentic context 3. Dynasty reputation mechanics influencing NPC interactions). 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 inventory systems coexisting) 2. Function modules unrelated to the Three Kingdoms setting (e.g., anachronistic elements) 3. Fancy effects that affect performance (e.g., excessive particle effects during routine actions). 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/data layers), code reusability for similar character abilities or battle mechanics, and asset management efficiency. 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 assets aren't properly optimized for web performance. 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 authentically represents the Three Kingdoms era while following design principles: 1) Period-appropriate color palette and motifs 2) Consistent UI elements that don't break immersion 3) Proper typography that balances readability with thematic elements. Deduct 3 points for anachronistic visual elements, 5 points for inconsistent UI design, and 5 points for illegible text or overcrowded interfaces. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the game responds fluidly to player actions: 1) Battle animations that are visually distinct and provide clear feedback 2) Smooth transitions between game states (exploration, battle, dialogue) 3) Intuitive controls with appropriate visual and audio feedback. Deduct 5 points for laggy animations, 3 points for jarring transitions between game modes, and 5 points for unintuitive navigation that hinders gameplay. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Role-Playing",
-  "difficulty": "medium"
-}

package/library/game_development-role-playing/interactive-npc-system-html-javascript.json

@@ -1,68 +0,0 @@
-{
-  "index": 3,
-  "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.\n\nPlease use HTML and JavaScript to implement an interactive NPC.\n\n**Task**: Implement an interactive NPC system where players can converse with NPCs, accept quests, or obtain clues.\n\n**Hint**: You can set different dialogue content and tasks for each NPC, and adjust the game progression based on player choices.\n\nInclude comments in your code to help other developers understand your implementation process.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the NPC dialogue system fully implemented?",
-      "description": "Review whether the code implements a complete dialogue system that includes multiple conversation paths, branching dialogue options, and persistent dialogue state tracking. Score 0 if basic dialogue display is missing, 5 if only linear conversations are supported, and 10 if the system handles complex branching dialogues with contextual responses based on previous player choices.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the quest/task system functional?",
-      "description": "Evaluate whether the code includes a quest management system that allows NPCs to offer quests, track quest progress, and provide appropriate rewards. Check if there are quest states (available, active, completed, failed). Deduct 5 points if quest tracking is absent, 3 points if quest state persistence is missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the NPC state management implemented?",
-      "description": "Check if NPCs have different states and behaviors based on game progression, player actions, or time of day. NPCs should remember past interactions and adjust their dialogue/behavior accordingly. Deduct 5 points if NPCs have static behavior regardless of player actions, 3 points if state changes aren't persistent. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there a clue/information system that affects gameplay?",
-      "description": "Assess whether information/clues provided by NPCs are tracked and have actual impact on gameplay mechanics or story progression. Check if the system includes hints, critical information, or red herrings that influence player decisions. Deduct 5 points if information has no gameplay impact, 3 points if the information system lacks variety. 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 undefined inputs, missing data, 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. NPC mood/relationship system 2. Voice acting integration 3. Dynamic facial expressions/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 implementation of similar functions (e.g., multiple dialogue display systems) 2. Function modules unrelated to NPC interaction (e.g., a built-in inventory system not connected to dialogues) 3. Fancy effects that affect performance (e.g., unnecessary animations or transitions). 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 dialogue logic/view/data layers), code organization, and developer documentation through comments. 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 helpful comments are missing or inadequate. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the NPC interaction interface follows modern design principles: 1) Harmonious color matching for dialogue boxes and UI elements 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (dialogue text size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the NPC interaction experience conforms to human perception characteristics: 1) Dialogue response delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual indication of dialogue options and NPC status. Deduct 5 points for each interaction without feedback, 3 points for jarring transitions between dialogue states, and 5 points for confusing navigation in conversation trees. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Role-Playing",
-  "difficulty": "easy"
-}

package/library/game_development-role-playing/javascript-weekly-quest-system.json

@@ -1,68 +0,0 @@
-{
-  "index": 1511,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the code you generate is executable for display. Write a weekly quest system in JS where players can only claim a task once every seven days.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the weekly quest timing mechanism correctly implemented?",
-      "description": "Check if the code properly implements a 7-day cooldown period using Date objects and timestamp comparisons. Verify that the system prevents claiming the same quest before 7 days have elapsed. Score 0 if time tracking is missing, 5 if basic timestamp comparison exists but has edge cases (like timezone issues), 10 if the implementation is robust with proper date manipulation.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is quest state persistence implemented effectively?",
-      "description": "Review whether the code includes a proper persistence mechanism (localStorage, sessionStorage, cookies, or simulated database) to track claimed quests across browser sessions. Deduct 5 points if data is only stored in memory and lost on refresh, 3 points if persistence exists but without expiry management. Full points require proper data serialization and retrieval with error handling.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the quest data structure well-designed?",
-      "description": "Evaluate if the quest objects are properly structured with necessary properties (ID, title, description, rewards, cooldown period, completion criteria, etc.). Deduct 3 points for each missing essential property, 5 points if quests lack unique identifiers, and 5 points if the data structure doesn't support quest status tracking. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the user interface for the quest system complete and functional?",
-      "description": "Check if the code implements a proper UI for displaying available quests, claimed quests, cooldown timers, and reward information. Score 0 if no UI exists, 5 if a basic list is provided without visual cues for status, 10 if the interface clearly shows quest status with countdown timers and responsive design.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid dates, browser storage limitations, data corruption, 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. Visual countdown timers 2. Quest categories or difficulty levels 3. Progressive reward systems). 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 timer implementations) 2. Function modules unrelated to quest system (e.g., unrelated game mechanics) 3. Fancy effects that affect performance (e.g., unnecessary 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 quest logic/view/data layers), function organization, and code reusability. 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 separation between UI rendering and business logic. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the quest claiming interaction conforms to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance for available vs. cooldown quests. Deduct 5 points for each operation without feedback, 3 points for jarring transitions when claiming quests, and 5 points for confusing status indicators. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Role-Playing",
-  "difficulty": "easy"
-}