Roles, Teams & Game Design Workflow

Core Concepts in Game Design Collaboration

1. Roles in a Game Development Team

Game design is rarely a solo effort. Teams consist of specialized roles, each contributing unique skills. Below is a breakdown of key roles and their responsibilities:

classDiagram
    class GameDesigner {
        +Designs game mechanics
        +Creates level layouts
        +Writes design documents
    }
    class Programmer {
        +Implements game logic
        +Develops engines/tools
        +Optimizes performance
    }
    class Artist {
        +Designs characters/environments
        +Animates assets
        +Creates UI/UX elements
    }
    class SoundDesigner {
        +Composes music
        +Designs sound effects
        +Records voiceovers
    }
    class Producer {
        +Manages budgets/timelines
        +Coordinates teams
        +Oversees marketing
    }
    GameDesigner --> Programmer : "Collaborates on mechanics"
    Programmer --> Artist : "Implements art assets"
    Artist --> SoundDesigner : "Syncs audio with visuals"
    Producer --> GameDesigner : "Sets design goals"

Real-World Example:

• Pathao’s "Pathao Play" Game (Nepal): The game’s design team included a Game Designer (who created the ride-matching mechanics), a Programmer (who built the real-time location system), and a Producer (who ensured the game integrated smoothly with Pathao’s existing app). The Sound Designer added Nepalese voice prompts for accessibility.

2. Team Structures in Game Development

Teams can be organized in different ways, depending on the project’s scale and scope. Common structures include:

3. Game Design Workflow

The workflow is a cyclical process involving prototyping, iteration, and testing. Here’s a simplified version:

flowchart TD
    A["Idea & Concept"] --> B["Design Document"]
    B --> C["Prototype"]
    C --> D["Playtest"]
    D -->|"Feedback"| E["Iterate"]
    E --> C
    C --> F["Polish"]
    F --> G["Release"]
    G --> H["Post-Launch Support"]
    H -->|"Updates"| C

Key Phases:

1. Pre-Production:

   • Design Document: A blueprint outlining game mechanics, story, and art style. Example: The design doc for Among Us included rules for crewmates vs. impostors, voting mechanics, and map layouts.
   • GDD (Game Design Document): A 50–100-page document used in AAA studios. Indie teams often use a one-pager or Google Doc.
   • Wireframes: Rough sketches of UI/levels.

2. Production:

   • Prototyping: Rapid testing of core mechanics (e.g., a Flappy Bird-like game where the player taps to jump).
   • Iteration: Refining based on playtester feedback. Worked Example:
     • Problem: In Pathao Play, players complained the ride-matching was too slow.
     • Solution: The team added a "Quick Match" button (reducing wait time by 30%).

3. Post-Production:

   • Polish: Final art, sound, and bug fixes.
   • QA Testing: Identifying and fixing bugs (e.g., Cyberpunk 2077’s infamous bugs were caught too late due to rushed QA).

4. Tools of the Trade

Game designers use specialized software to streamline workflows:

5. Challenges in Game Design Collaboration

Working in a team introduces unique challenges:

• Communication Gaps:

  • Example: A programmer in Kathmandu and an artist in Pokhara might misalign on asset specifications.
  • Solution: Use Slack/Discord for real-time updates and Confluence for documentation.

• Scope Creep:

  • Adding too many features late in development (e.g., No Man’s Sky’s delayed launch due to over-scoping).
  • Solution: Stick to the design doc and prioritize features.

• Cultural Differences:

  • Example: A Nepali team working with a US studio might clash over humor or references.
  • Solution: Define cultural norms early (e.g., "Use Nepali idioms in dialogue").

In the Real World

1. eSewa’s "eSewa Play" (Nepal):

   • Idea Used: Prototyping and Iteration
   • How: The team started with a simple quiz game to teach financial literacy. After playtesting with rural users, they added Nepali voiceovers and offline mode (critical for areas with poor internet).

2. Google’s "Google Stadia" (Global):

   • Idea Used: AAA Team Structure
   • How: Google hired hundreds of specialists (e.g., cloud engineers for streaming, UI designers for controllers). The project failed partly due to poor workflow coordination between teams.

3. Ncell’s "Ncell Cricket" (Nepal):

   • Idea Used: Freelance Collaboration
   • How: Ncell outsourced 2D art to freelancers on Fiverr and backend coding to a Kathmandu-based studio. The Producer used Trello to track progress.

Worked Example: Designing a "Khalti Cash Rush" Game

Scenario: Khalti wants a mini-game to teach financial literacy. Your team has:

• 1 Game Designer (you)
• 1 Programmer (handles Unity)
• 1 Artist (creates pixel art)

Steps:

1. Design Document:

   • Core Mechanic: Players "earn" virtual Khalti coins by completing tasks (e.g., "Save 20% by comparing prices on Daraz").
   • UI: Simple pixel-art buttons with Nepali text.

2. Prototype:

   • Programmer sets up a Unity scene with a player character and a "shop" where players spend coins.
   • Artist creates 3 sprites: player, coin, and shop items.

3. Playtest:

   • Test with 10 users. Feedback:
     • "The shop items are too confusing."
     • "We want more tasks."
   • Iteration: Add tool tips and a "Task Library" tab.

4. Polish:

   • Add Nepali voice narration (e.g., "Dhanyabad! You saved Rs. 500!").
   • Fix a bug where coins disappeared after refreshing.

5. Release:

   • Deploy on Khalti’s app as a promotional feature.

Exam Tip

For TU/PU exams, focus on:

1. Definitions:

   • Know the difference between a Game Designer, Producer, and Programmer.
   • Understand scope creep and iteration.

2. Diagrams:

   • Be ready to draw a team structure (e.g., AAA vs. indie) or a workflow diagram.
   • Label key tools like Unity, Figma, and Trello.

3. Real-World Applications:

   • Link concepts to Nepali examples:
     • eSewa Play → Prototyping
     • Pathao Play → Team Roles
     • Ncell Cricket → Outsourcing

4. Short-Answer Questions:

   • Practice explaining:
     • Why a design doc is important.
     • How playtesting improves a game (use Among Us or Flappy Bird as examples).

5. Case Study Questions:

   • Given a scenario (e.g., "A Nepali team is making a mobile game but artists and programmers are misaligned"), suggest solutions like:
     • Use Figma for UI mockups.
     • Hold weekly sync meetings.

Visual Summary:

mindmap
  root((Game Design Workflow))
    Pre-Production
      Design Document
      Wireframes
    Production
      Prototyping
      Iteration
      Playtesting
    Post-Production
      Polish
      QA Testing
    Tools
      Unity
      Figma
      Trello
    Challenges
      Communication
      Scope Creep
      Cultural Differences