@zeyue0329/xiaoma-cli 1.0.8 → 1.0.10

package/expansion-packs/bmad-2d-unity-game-dev/tasks/correct-course-game.md

@@ -0,0 +1,143 @@
+<!-- Powered by BMAD™ Core -->
+
+# Correct Course Task - Game Development
+
+## Purpose
+
+- Guide a structured response to game development change triggers using the `{root}/checklists/game-change-checklist`.
+- Analyze the impacts of changes on game features, technical systems, and milestone deliverables.
+- Explore game-specific solutions (e.g., performance optimizations, feature scaling, platform adjustments).
+- Draft specific, actionable proposed updates to affected game artifacts (e.g., GDD sections, technical specs, Unity configurations).
+- Produce a consolidated "Game Development Change Proposal" document for review and approval.
+- Ensure clear handoff path for changes requiring fundamental redesign or technical architecture updates.
+
+## Instructions
+
+### 1. Initial Setup & Mode Selection
+
+- **Acknowledge Task & Inputs:**
+  - Confirm with the user that the "Game Development Correct Course Task" is being initiated.
+  - Verify the change trigger (e.g., performance issue, platform constraint, gameplay feedback, technical blocker).
+  - Confirm access to relevant game artifacts:
+    - Game Design Document (GDD)
+    - Technical Design Documents
+    - Unity Architecture specifications
+    - Performance budgets and platform requirements
+    - Current sprint's game stories and epics
+    - Asset specifications and pipelines
+  - Confirm access to `{root}/checklists/game-change-checklist`.
+
+- **Establish Interaction Mode:**
+  - Ask the user their preferred interaction mode:
+    - **"Incrementally (Default & Recommended):** Work through the game-change-checklist section by section, discussing findings and drafting changes collaboratively. Best for complex technical or gameplay changes."
+    - **"YOLO Mode (Batch Processing):** Conduct batched analysis and present consolidated findings. Suitable for straightforward performance optimizations or minor adjustments."
+  - Confirm the selected mode and inform: "We will now use the game-change-checklist to analyze the change and draft proposed updates specific to our Unity game development context."
+
+### 2. Execute Game Development Checklist Analysis
+
+- Systematically work through the game-change-checklist sections:
+  1. **Change Context & Game Impact**
+  2. **Feature/System Impact Analysis**
+  3. **Technical Artifact Conflict Resolution**
+  4. **Performance & Platform Evaluation**
+  5. **Path Forward Recommendation**
+
+- For each checklist section:
+  - Present game-specific prompts and considerations
+  - Analyze impacts on:
+    - Unity scenes and prefabs
+    - Component dependencies
+    - Performance metrics (FPS, memory, build size)
+    - Platform-specific code paths
+    - Asset loading and management
+    - Third-party plugins/SDKs
+  - Discuss findings with clear technical context
+  - Record status: `[x] Addressed`, `[N/A]`, `[!] Further Action Needed`
+  - Document Unity-specific decisions and constraints
+
+### 3. Draft Game-Specific Proposed Changes
+
+Based on the analysis and agreed path forward:
+
+- **Identify affected game artifacts requiring updates:**
+  - GDD sections (mechanics, systems, progression)
+  - Technical specifications (architecture, performance targets)
+  - Unity-specific configurations (build settings, quality settings)
+  - Game story modifications (scope, acceptance criteria)
+  - Asset pipeline adjustments
+  - Platform-specific adaptations
+
+- **Draft explicit changes for each artifact:**
+  - **Game Stories:** Revise story text, Unity-specific acceptance criteria, technical constraints
+  - **Technical Specs:** Update architecture diagrams, component hierarchies, performance budgets
+  - **Unity Configurations:** Propose settings changes, optimization strategies, platform variants
+  - **GDD Updates:** Modify feature descriptions, balance parameters, progression systems
+  - **Asset Specifications:** Adjust texture sizes, model complexity, audio compression
+  - **Performance Targets:** Update FPS goals, memory limits, load time requirements
+
+- **Include Unity-specific details:**
+  - Prefab structure changes
+  - Scene organization updates
+  - Component refactoring needs
+  - Shader/material optimizations
+  - Build pipeline modifications
+
+### 4. Generate "Game Development Change Proposal"
+
+- Create a comprehensive proposal document containing:
+
+  **A. Change Summary:**
+  - Original issue (performance, gameplay, technical constraint)
+  - Game systems affected
+  - Platform/performance implications
+  - Chosen solution approach
+
+  **B. Technical Impact Analysis:**
+  - Unity architecture changes needed
+  - Performance implications (with metrics)
+  - Platform compatibility effects
+  - Asset pipeline modifications
+  - Third-party dependency impacts
+
+  **C. Specific Proposed Edits:**
+  - For each game story: "Change Story GS-X.Y from: [old] To: [new]"
+  - For technical specs: "Update Unity Architecture Section X: [changes]"
+  - For GDD: "Modify [Feature] in Section Y: [updates]"
+  - For configurations: "Change [Setting] from [old_value] to [new_value]"
+
+  **D. Implementation Considerations:**
+  - Required Unity version updates
+  - Asset reimport needs
+  - Shader recompilation requirements
+  - Platform-specific testing needs
+
+### 5. Finalize & Determine Next Steps
+
+- Obtain explicit approval for the "Game Development Change Proposal"
+- Provide the finalized document to the user
+
+- **Based on change scope:**
+  - **Minor adjustments (can be handled in current sprint):**
+    - Confirm task completion
+    - Suggest handoff to game-dev agent for implementation
+    - Note any required playtesting validation
+  - **Major changes (require replanning):**
+    - Clearly state need for deeper technical review
+    - Recommend engaging Game Architect or Technical Lead
+    - Provide proposal as input for architecture revision
+    - Flag any milestone/deadline impacts
+
+## Output Deliverables
+
+- **Primary:** "Game Development Change Proposal" document containing:
+  - Game-specific change analysis
+  - Technical impact assessment with Unity context
+  - Platform and performance considerations
+  - Clearly drafted updates for all affected game artifacts
+  - Implementation guidance and constraints
+
+- **Secondary:** Annotated game-change-checklist showing:
+  - Technical decisions made
+  - Performance trade-offs considered
+  - Platform-specific accommodations
+  - Unity-specific implementation notes

package/expansion-packs/bmad-2d-unity-game-dev/tasks/create-game-story.md

@@ -0,0 +1,186 @@
+<!-- Powered by BMAD™ Core -->
+
+# Create Game Story Task
+
+## Purpose
+
+To identify the next logical game story based on project progress and epic definitions, and then to prepare a comprehensive, self-contained, and actionable story file using the `Game Story Template`. This task ensures the story is enriched with all necessary technical context, Unity-specific requirements, and acceptance criteria, making it ready for efficient implementation by a Game Developer Agent with minimal need for additional research or finding its own context.
+
+## SEQUENTIAL Task Execution (Do not proceed until current Task is complete)
+
+### 0. Load Core Configuration and Check Workflow
+
+- Load `{root}/core-config.yaml` from the project root
+- If the file does not exist, HALT and inform the user: "core-config.yaml not found. This file is required for story creation. You can either: 1) Copy core-config.yaml from GITHUB bmad-core/ and configure it for your game project OR 2) Run the BMad installer against your project to upgrade and add the file automatically. Please add and configure before proceeding."
+- Extract key configurations: `devStoryLocation`, `gdd.*`, `gamearchitecture.*`, `workflow.*`
+
+### 1. Identify Next Story for Preparation
+
+#### 1.1 Locate Epic Files and Review Existing Stories
+
+- Based on `gddSharded` from config, locate epic files (sharded location/pattern or monolithic GDD sections)
+- If `devStoryLocation` has story files, load the highest `{epicNum}.{storyNum}.story.md` file
+- **If highest story exists:**
+  - Verify status is 'Done'. If not, alert user: "ALERT: Found incomplete story! File: {lastEpicNum}.{lastStoryNum}.story.md Status: [current status] You should fix this story first, but would you like to accept risk & override to create the next story in draft?"
+  - If proceeding, select next sequential story in the current epic
+  - If epic is complete, prompt user: "Epic {epicNum} Complete: All stories in Epic {epicNum} have been completed. Would you like to: 1) Begin Epic {epicNum + 1} with story 1 2) Select a specific story to work on 3) Cancel story creation"
+  - **CRITICAL**: NEVER automatically skip to another epic. User MUST explicitly instruct which story to create.
+- **If no story files exist:** The next story is ALWAYS 1.1 (first story of first epic)
+- Announce the identified story to the user: "Identified next story for preparation: {epicNum}.{storyNum} - {Story Title}"
+
+### 2. Gather Story Requirements and Previous Story Context
+
+- Extract story requirements from the identified epic file or GDD section
+- If previous story exists, review Dev Agent Record sections for:
+  - Completion Notes and Debug Log References
+  - Implementation deviations and technical decisions
+  - Unity-specific challenges (prefab issues, scene management, performance)
+  - Asset pipeline decisions and optimizations
+- Extract relevant insights that inform the current story's preparation
+
+### 3. Gather Architecture Context
+
+#### 3.1 Determine Architecture Reading Strategy
+
+- **If `gamearchitectureVersion: >= v3` and `gamearchitectureSharded: true`**: Read `{gamearchitectureShardedLocation}/index.md` then follow structured reading order below
+- **Else**: Use monolithic `gamearchitectureFile` for similar sections
+
+#### 3.2 Read Architecture Documents Based on Story Type
+
+**For ALL Game Stories:** tech-stack.md, unity-project-structure.md, coding-standards.md, testing-resilience-architecture.md
+
+**For Gameplay/Mechanics Stories, additionally:** gameplay-systems-architecture.md, component-architecture-details.md, physics-config.md, input-system.md, state-machines.md, game-data-models.md
+
+**For UI/UX Stories, additionally:** ui-architecture.md, ui-components.md, ui-state-management.md, scene-management.md
+
+**For Backend/Services Stories, additionally:** game-data-models.md, data-persistence.md, save-system.md, analytics-integration.md, multiplayer-architecture.md
+
+**For Graphics/Rendering Stories, additionally:** rendering-pipeline.md, shader-guidelines.md, sprite-management.md, particle-systems.md
+
+**For Audio Stories, additionally:** audio-architecture.md, audio-mixing.md, sound-banks.md
+
+#### 3.3 Extract Story-Specific Technical Details
+
+Extract ONLY information directly relevant to implementing the current story. Do NOT invent new patterns, systems, or standards not in the source documents.
+
+Extract:
+
+- Specific Unity components and MonoBehaviours the story will use
+- Unity Package Manager dependencies and their APIs (e.g., Cinemachine, Input System, URP)
+- Package-specific configurations and setup requirements
+- Prefab structures and scene organization requirements
+- Input system bindings and configurations
+- Physics settings and collision layers
+- UI canvas and layout specifications
+- Asset naming conventions and folder structures
+- Performance budgets (target FPS, memory limits, draw calls)
+- Platform-specific considerations (mobile vs desktop)
+- Testing requirements specific to Unity features
+
+ALWAYS cite source documents: `[Source: gamearchitecture/{filename}.md#{section}]`
+
+### 4. Unity-Specific Technical Analysis
+
+#### 4.1 Package Dependencies Analysis
+
+- Identify Unity Package Manager packages required for the story
+- Document package versions from manifest.json
+- Note any package-specific APIs or components being used
+- List package configuration requirements (e.g., Input System settings, URP asset config)
+- Identify any third-party Asset Store packages and their integration points
+
+#### 4.2 Scene and Prefab Planning
+
+- Identify which scenes will be modified or created
+- List prefabs that need to be created or updated
+- Document prefab variant requirements
+- Specify scene loading/unloading requirements
+
+#### 4.3 Component Architecture
+
+- Define MonoBehaviour scripts needed
+- Specify ScriptableObject assets required
+- Document component dependencies and execution order
+- Identify required Unity Events and UnityActions
+- Note any package-specific components (e.g., Cinemachine VirtualCamera, InputActionAsset)
+
+#### 4.4 Asset Requirements
+
+- List sprite/texture requirements with resolution specs
+- Define animation clips and animator controllers needed
+- Specify audio clips and their import settings
+- Document any shader or material requirements
+- Note any package-specific assets (e.g., URP materials, Input Action maps)
+
+### 5. Populate Story Template with Full Context
+
+- Create new story file: `{devStoryLocation}/{epicNum}.{storyNum}.story.md` using Game Story Template
+- Fill in basic story information: Title, Status (Draft), Story statement, Acceptance Criteria from Epic/GDD
+- **`Dev Notes` section (CRITICAL):**
+  - CRITICAL: This section MUST contain ONLY information extracted from gamearchitecture documents and GDD. NEVER invent or assume technical details.
+  - Include ALL relevant technical details from Steps 2-4, organized by category:
+    - **Previous Story Insights**: Key learnings from previous story implementation
+    - **Package Dependencies**: Unity packages required, versions, configurations [with source references]
+    - **Unity Components**: Specific MonoBehaviours, ScriptableObjects, systems [with source references]
+    - **Scene & Prefab Specs**: Scene modifications, prefab structures, variants [with source references]
+    - **Input Configuration**: Input actions, bindings, control schemes [with source references]
+    - **UI Implementation**: Canvas setup, layout groups, UI events [with source references]
+    - **Asset Pipeline**: Asset requirements, import settings, optimization notes
+    - **Performance Targets**: FPS targets, memory budgets, profiler metrics
+    - **Platform Considerations**: Mobile vs desktop differences, input variations
+    - **Testing Requirements**: PlayMode tests, Unity Test Framework specifics
+  - Every technical detail MUST include its source reference: `[Source: gamearchitecture/{filename}.md#{section}]`
+  - If information for a category is not found in the gamearchitecture docs, explicitly state: "No specific guidance found in gamearchitecture docs"
+- **`Tasks / Subtasks` section:**
+  - Generate detailed, sequential list of technical tasks based ONLY on: Epic/GDD Requirements, Story AC, Reviewed GameArchitecture Information
+  - Include Unity-specific tasks:
+    - Scene setup and configuration
+    - Prefab creation and testing
+    - Component implementation with proper lifecycle methods
+    - Input system integration
+    - Physics configuration
+    - UI implementation with proper anchoring
+    - Performance profiling checkpoints
+  - Each task must reference relevant gamearchitecture documentation
+  - Include PlayMode testing as explicit subtasks
+  - Link tasks to ACs where applicable (e.g., `Task 1 (AC: 1, 3)`)
+- Add notes on Unity project structure alignment or discrepancies found in Step 4
+
+### 6. Story Draft Completion and Review
+
+- Review all sections for completeness and accuracy
+- Verify all source references are included for technical details
+- Ensure Unity-specific requirements are comprehensive:
+  - All scenes and prefabs documented
+  - Component dependencies clear
+  - Asset requirements specified
+  - Performance targets defined
+- Update status to "Draft" and save the story file
+- Execute `{root}/tasks/execute-checklist` `{root}/checklists/game-story-dod-checklist`
+- Provide summary to user including:
+  - Story created: `{devStoryLocation}/{epicNum}.{storyNum}.story.md`
+  - Status: Draft
+  - Key Unity components and systems included
+  - Scene/prefab modifications required
+  - Asset requirements identified
+  - Any deviations or conflicts noted between GDD and gamearchitecture
+  - Checklist Results
+  - Next steps: For complex Unity features, suggest the user review the story draft and optionally test critical assumptions in Unity Editor
+
+### 7. Unity-Specific Validation
+
+Before finalizing, ensure:
+
+- [ ] All required Unity packages are documented with versions
+- [ ] Package-specific APIs and configurations are included
+- [ ] All MonoBehaviour lifecycle methods are considered
+- [ ] Prefab workflows are clearly defined
+- [ ] Scene management approach is specified
+- [ ] Input system integration is complete (legacy or new Input System)
+- [ ] UI canvas setup follows Unity best practices
+- [ ] Performance profiling points are identified
+- [ ] Asset import settings are documented
+- [ ] Platform-specific code paths are noted
+- [ ] Package compatibility is verified (e.g., URP vs Built-in pipeline)
+
+This task ensures game development stories are immediately actionable and enable efficient AI-driven development of Unity 2D game features.

package/expansion-packs/bmad-2d-unity-game-dev/tasks/game-design-brainstorming.md

@@ -0,0 +1,292 @@
+<!-- Powered by BMAD™ Core -->
+
+# Game Design Brainstorming Techniques Task
+
+This task provides a comprehensive toolkit of creative brainstorming techniques specifically designed for game design ideation and innovative thinking. The game designer can use these techniques to facilitate productive brainstorming sessions focused on game mechanics, player experience, and creative concepts.
+
+## Process
+
+### 1. Session Setup
+
+[[LLM: Begin by understanding the game design context and goals. Ask clarifying questions if needed to determine the best approach for game-specific ideation.]]
+
+1. **Establish Game Context**
+   - Understand the game genre or opportunity area
+   - Identify target audience and platform constraints
+   - Determine session goals (concept exploration vs. mechanic refinement)
+   - Clarify scope (full game vs. specific feature)
+
+2. **Select Technique Approach**
+   - Option A: User selects specific game design techniques
+   - Option B: Game Designer recommends techniques based on context
+   - Option C: Random technique selection for creative variety
+   - Option D: Progressive technique flow (broad concepts to specific mechanics)
+
+### 2. Game Design Brainstorming Techniques
+
+#### Game Concept Expansion Techniques
+
+1. **"What If" Game Scenarios**
+   [[LLM: Generate provocative what-if questions that challenge game design assumptions and expand thinking beyond current genre limitations.]]
+   - What if players could rewind time in any genre?
+   - What if the game world reacted to the player's real-world location?
+   - What if failure was more rewarding than success?
+   - What if players controlled the antagonist instead?
+   - What if the game played itself when no one was watching?
+
+2. **Cross-Genre Fusion**
+   [[LLM: Help user combine unexpected game genres and mechanics to create unique experiences.]]
+   - "How might [genre A] mechanics work in [genre B]?"
+   - Puzzle mechanics in action games
+   - Dating sim elements in strategy games
+   - Horror elements in racing games
+   - Educational content in roguelike structure
+
+3. **Player Motivation Reversal**
+   [[LLM: Flip traditional player motivations to reveal new gameplay possibilities.]]
+   - What if losing was the goal?
+   - What if cooperation was forced in competitive games?
+   - What if players had to help their enemies?
+   - What if progress meant giving up abilities?
+
+4. **Core Loop Deconstruction**
+   [[LLM: Break down successful games to fundamental mechanics and rebuild differently.]]
+   - What are the essential 3 actions in this game type?
+   - How could we make each action more interesting?
+   - What if we changed the order of these actions?
+   - What if players could skip or automate certain actions?
+
+#### Mechanic Innovation Frameworks
+
+1. **SCAMPER for Game Mechanics**
+   [[LLM: Guide through each SCAMPER prompt specifically for game design.]]
+   - **S** = Substitute: What mechanics can be substituted? (walking → flying → swimming)
+   - **C** = Combine: What systems can be merged? (inventory + character growth)
+   - **A** = Adapt: What mechanics from other media? (books, movies, sports)
+   - **M** = Modify/Magnify: What can be exaggerated? (super speed, massive scale)
+   - **P** = Put to other uses: What else could this mechanic do? (jumping → attacking)
+   - **E** = Eliminate: What can be removed? (UI, tutorials, fail states)
+   - **R** = Reverse/Rearrange: What sequence changes? (end-to-start, simultaneous)
+
+2. **Player Agency Spectrum**
+   [[LLM: Explore different levels of player control and agency across game systems.]]
+   - Full Control: Direct character movement, combat, building
+   - Indirect Control: Setting rules, giving commands, environmental changes
+   - Influence Only: Suggestions, preferences, emotional reactions
+   - No Control: Observation, interpretation, passive experience
+
+3. **Temporal Game Design**
+   [[LLM: Explore how time affects gameplay and player experience.]]
+   - Real-time vs. turn-based mechanics
+   - Time travel and manipulation
+   - Persistent vs. session-based progress
+   - Asynchronous multiplayer timing
+   - Seasonal and event-based content
+
+#### Player Experience Ideation
+
+1. **Emotion-First Design**
+   [[LLM: Start with target emotions and work backward to mechanics that create them.]]
+   - Target Emotion: Wonder → Mechanics: Discovery, mystery, scale
+   - Target Emotion: Triumph → Mechanics: Challenge, skill growth, recognition
+   - Target Emotion: Connection → Mechanics: Cooperation, shared goals, communication
+   - Target Emotion: Flow → Mechanics: Clear feedback, progressive difficulty
+
+2. **Player Archetype Brainstorming**
+   [[LLM: Design for different player types and motivations.]]
+   - Achievers: Progression, completion, mastery
+   - Explorers: Discovery, secrets, world-building
+   - Socializers: Interaction, cooperation, community
+   - Killers: Competition, dominance, conflict
+   - Creators: Building, customization, expression
+
+3. **Accessibility-First Innovation**
+   [[LLM: Generate ideas that make games more accessible while creating new gameplay.]]
+   - Visual impairment considerations leading to audio-focused mechanics
+   - Motor accessibility inspiring one-handed or simplified controls
+   - Cognitive accessibility driving clear feedback and pacing
+   - Economic accessibility creating free-to-play innovations
+
+#### Narrative and World Building
+
+1. **Environmental Storytelling**
+   [[LLM: Brainstorm ways the game world itself tells stories without explicit narrative.]]
+   - How does the environment show history?
+   - What do interactive objects reveal about characters?
+   - How can level design communicate mood?
+   - What stories do systems and mechanics tell?
+
+2. **Player-Generated Narrative**
+   [[LLM: Explore ways players create their own stories through gameplay.]]
+   - Emergent storytelling through player choices
+   - Procedural narrative generation
+   - Player-to-player story sharing
+   - Community-driven world events
+
+3. **Genre Expectation Subversion**
+   [[LLM: Identify and deliberately subvert player expectations within genres.]]
+   - Fantasy RPG where magic is mundane
+   - Horror game where monsters are friendly
+   - Racing game where going slow is optimal
+   - Puzzle game where there are multiple correct answers
+
+#### Technical Innovation Inspiration
+
+1. **Platform-Specific Design**
+   [[LLM: Generate ideas that leverage unique platform capabilities.]]
+   - Mobile: GPS, accelerometer, camera, always-connected
+   - Web: URLs, tabs, social sharing, real-time collaboration
+   - Console: Controllers, TV viewing, couch co-op
+   - VR/AR: Physical movement, spatial interaction, presence
+
+2. **Constraint-Based Creativity**
+   [[LLM: Use technical or design constraints as creative catalysts.]]
+   - One-button games
+   - Games without graphics
+   - Games that play in notification bars
+   - Games using only system sounds
+   - Games with intentionally bad graphics
+
+### 3. Game-Specific Technique Selection
+
+[[LLM: Help user select appropriate techniques based on their specific game design needs.]]
+
+**For Initial Game Concepts:**
+
+- What If Game Scenarios
+- Cross-Genre Fusion
+- Emotion-First Design
+
+**For Stuck/Blocked Creativity:**
+
+- Player Motivation Reversal
+- Constraint-Based Creativity
+- Genre Expectation Subversion
+
+**For Mechanic Development:**
+
+- SCAMPER for Game Mechanics
+- Core Loop Deconstruction
+- Player Agency Spectrum
+
+**For Player Experience:**
+
+- Player Archetype Brainstorming
+- Emotion-First Design
+- Accessibility-First Innovation
+
+**For World Building:**
+
+- Environmental Storytelling
+- Player-Generated Narrative
+- Platform-Specific Design
+
+### 4. Game Design Session Flow
+
+[[LLM: Guide the brainstorming session with appropriate pacing for game design exploration.]]
+
+1. **Inspiration Phase** (10-15 min)
+   - Reference existing games and mechanics
+   - Explore player experiences and emotions
+   - Gather visual and thematic inspiration
+
+2. **Divergent Exploration** (25-35 min)
+   - Generate many game concepts or mechanics
+   - Use expansion and fusion techniques
+   - Encourage wild and impossible ideas
+
+3. **Player-Centered Filtering** (15-20 min)
+   - Consider target audience reactions
+   - Evaluate emotional impact and engagement
+   - Group ideas by player experience goals
+
+4. **Feasibility and Synthesis** (15-20 min)
+   - Assess technical and design feasibility
+   - Combine complementary ideas
+   - Develop most promising concepts
+
+### 5. Game Design Output Format
+
+[[LLM: Present brainstorming results in a format useful for game development.]]
+
+**Session Summary:**
+
+- Techniques used and focus areas
+- Total concepts/mechanics generated
+- Key themes and patterns identified
+
+**Game Concept Categories:**
+
+1. **Core Game Ideas** - Complete game concepts ready for prototyping
+2. **Mechanic Innovations** - Specific gameplay mechanics to explore
+3. **Player Experience Goals** - Emotional and engagement targets
+4. **Technical Experiments** - Platform or technology-focused concepts
+5. **Long-term Vision** - Ambitious ideas for future development
+
+**Development Readiness:**
+
+**Prototype-Ready Ideas:**
+
+- Ideas that can be tested immediately
+- Minimum viable implementations
+- Quick validation approaches
+
+**Research-Required Ideas:**
+
+- Concepts needing technical investigation
+- Player testing and market research needs
+- Competitive analysis requirements
+
+**Future Innovation Pipeline:**
+
+- Ideas requiring significant development
+- Technology-dependent concepts
+- Market timing considerations
+
+**Next Steps:**
+
+- Which concepts to prototype first
+- Recommended research areas
+- Suggested playtesting approaches
+- Documentation and GDD planning
+
+## Game Design Specific Considerations
+
+### Platform and Audience Awareness
+
+- Always consider target platform limitations and advantages
+- Keep target audience preferences and expectations in mind
+- Balance innovation with familiar game design patterns
+- Consider monetization and business model implications
+
+### Rapid Prototyping Mindset
+
+- Focus on ideas that can be quickly tested
+- Emphasize core mechanics over complex features
+- Design for iteration and player feedback
+- Consider digital and paper prototyping approaches
+
+### Player Psychology Integration
+
+- Understand motivation and engagement drivers
+- Consider learning curves and skill development
+- Design for different play session lengths
+- Balance challenge and reward appropriately
+
+### Technical Feasibility
+
+- Keep development resources and timeline in mind
+- Consider art and audio asset requirements
+- Think about performance and optimization needs
+- Plan for testing and debugging complexity
+
+## Important Notes for Game Design Sessions
+
+- Encourage "impossible" ideas - constraints can be added later
+- Build on game mechanics that have proven engagement
+- Consider how ideas scale from prototype to full game
+- Document player experience goals alongside mechanics
+- Think about community and social aspects of gameplay
+- Consider accessibility and inclusivity from the start
+- Balance innovation with market viability
+- Plan for iteration based on player feedback