Team Composition

Team Composition

What Is This?

The Team Composition skill (team-combat) on the Happycapy Skills platform is a structured orchestration tool designed to coordinate a multidisciplinary team in designing, implementing, and validating a combat feature for a game. This skill guides the collaboration of six essential roles: game-designer, gameplay-programmer, AI-programmer, technical-artist, sound-designer, and QA-tester. Each member contributes their expertise at specific phases, ensuring that the combat feature is thoroughly planned, constructed, and refined. The skill is invoked by providing a description of the combat feature to be developed, which then initiates a pipeline involving user-driven decision points at every major phase.

Why Use It?

Developing robust and engaging combat systems in games requires seamless collaboration across various disciplines. The Team Composition skill offers a structured approach to this process, delivering several benefits:

• Clarity in Role Responsibilities: Each team member knows their specific contributions, reducing overlap and confusion.
• Structured Workflow: The skill enforces a phased pipeline, ensuring that each aspect of the feature is addressed in sequence and nothing is overlooked.
• User-Guided Decisions: At every major transition, the user is presented with proposals and asked to approve or select options, keeping the process transparent and interactive.
• End-to-End Coverage: From the initial design to technical implementation, content creation, and quality assurance, the entire pipeline is covered.
• Automation with Control: The skill automates orchestration but always waits for user review before moving forward, enabling a balance between efficiency and oversight.

This approach reduces miscommunication, ensures higher-quality outcomes, and supports iterative refinement with deliberate checkpoints.

How to Use It

The team-combat skill is invoked via a command that includes a descriptive argument of the combat feature to be developed. For example:

/team-combat melee parry system

If the command is issued without a feature description, the system responds with:

"Usage: /team-combat [combat feature description] - Provide a description of the combat feature to design and implement (e.g., melee parry system, ranged weapon spread)."

Pipeline Overview

Once invoked with a valid argument, the skill orchestrates the following roles and activities:

1. Game Designer
   • Defines the core mechanic, including rules, formulas, and edge cases.
   • Example output:
     plaintext

     Parry triggers if player faces attacker and presses the parry button within 0.3s of attack windup.
     Formula: parry_window = 0.3f; // seconds

2. Gameplay Programmer
   • Implements the mechanic in code, integrating designer specifications.
   • Example code:
     csharp

     if (input.ParryPressed && Time.time - attackStartTime <= parry_window)
     {
         TriggerParrySuccess();
     }

3. AI Programmer
   • Develops AI behaviors to interact with or counter the mechanic.
   • Example AI logic:
     python

     if player.is_parrying:
         enemy.choose_attack('feint')

4. Technical Artist
   • Produces visual feedback, effects, and shaders to represent the mechanic.
   • Example: Assigning a particle system to the parry event.
5. Sound Designer
   • Specifies and implements sound cues for mechanics (e.g., audio feedback on successful/failed parry).
   • Example:
     plaintext

     PlaySound("parry_success.wav");

6. QA Tester
   • Validates the feature, tests edge cases, and reports bugs or inconsistencies.

At each phase transition, the skill uses AskUserQuestion to present the user with proposals from the respective subagent (role). The user reviews, selects, or approves a proposal before the process continues. This ensures that each critical decision is validated and agreed upon.

Example Workflow

1. User invokes: /team-combat melee parry system
2. Skill presents game designer's proposals for the mechanic.
3. User selects or approves a proposal.
4. Skill moves to the gameplay programmer, who presents code strategies.
5. User approves or selects.
6. Process continues through the pipeline: AI, technical art, sound, QA.
7. At completion, the user has an end-to-end, validated combat feature.

When to Use It

Use the Team Composition skill whenever you need to design and implement a new combat feature in a game and want to ensure that all relevant disciplines are included and coordinated. This is especially valuable for:

• Prototyping new mechanics before full production.
• Iterating on existing systems with multidisciplinary input.
• Ensuring clarity and accountability across roles.
• Teaching best practices for cross-functional collaboration.

It is not intended for non-combat features or for situations where a single person handles all roles.

Important Notes

• Argument Requirement: The skill requires a clear combat feature description as an argument. Without it, the process halts and displays usage instructions.
• Strict Phase Control: No phase is executed without explicit user approval, ensuring oversight and accountability.
• Role Definitions: Each role is specialized. For example, the technical artist only handles visuals, while the gameplay programmer focuses on code implementation.
• Allowed Tools: The skill can use Read, Glob, Grep, Write, Edit, Bash, Task, AskUserQuestion, and TodoWrite tools, enabling both analysis and code generation.
• No File Access or Subagent Spawning Without Approval: The skill does not read files or spawn subagents until the user provides a valid argument and approves decisions.

By following this structure, the Team Composition skill ensures that combat features are developed thoroughly, collaboratively, and with a high standard of quality assurance.