[Unity] Game Creator 2 — How to Build Your First Game Step by Step

Thank you for visiting this site.

In this article, we will explain how to combine Game Creator 2’s core features with other tools to “implement common game features”.

This is a practical game development guide aimed at answering the question “I want to do X — what should I use?”.

Official documentation: Game Creator 2 Documentation

You can find a list of all articles in this series below.

Complete Article List — Game Creator 2 Complete Guide Series Indexen.senkohome.com/gamecreator2-series-index/

---

Fundamental Approach to Building Games with GC2

You Don’t Need to “Build Everything with GC2”

GC2 is not an engine that handles all aspects of game creation — it is a toolkit for rapidly building the gameplay logic layer.

• What GC2 excels at: Character control, camera work, event-driven game logic, save & load, audio management
• What to leave to other tools: UI layout, particles, shaders, physics materials, terrain, NavMesh baking, etc.
• When to write custom scripts: Complex numerical calculations (custom ballistics, etc.), real-time networking, procedural generation

”Event → Condition Check → Execute Instructions” Is the Foundation of Everything

GC2’s game logic is built from combinations of just 3 elements.

Trigger (when something happens) → Conditions (if conditions are met) → Actions (do something)

No matter how complex a game appears, each individual behavior is a small event-driven accumulation like “pressed button in front of door → if player has key → open door”.

Manage “State” with Variables

All game progression state (flags, scores, ammo count, current phase, etc.) is stored in Variables. Designing around Variables means:

• Accessible from anywhere (Global Variables)
• Automatically compatible with save & load
• Easy branching with Conditions

Build Small, Then Connect

GC2’s Actions are “a list of instructions that do one thing”. Rather than cramming complex logic into one giant Actions:

1. Create multiple small Actions (open door, give item, switch camera…)
2. Call them with Triggers
3. Branch with Conditions

Building at this granularity makes reuse, debugging, and modification all easier.

---

3 Keywords to Understand GC2’s Design Philosophy

High-Level Scripting

GC2’s instructions are designed at “the granularity humans think in”.

Low-level calculations are handled internally by GC2, so you just describe “what you want to do” and it works.

Dynamic Value Resolution via Properties

Many instruction parameters are defined as Properties (dynamic value sources). For example, when specifying “destination”:

• Fixed coordinates (direct Vector3)
• Player’s current position
• A specific Marker’s position
• Coordinates stored in a variable
• Main Camera position

…can be switched via dropdown. Being able to switch between “fixed values” and “runtime-determined values” without writing code is why GC2 enables flexible design.

Loose Coupling via Signals

Direct references work fine, but using Signals (broadcast of named messages):

• Sender and receiver don’t need to know about each other
• Strong for prefabbing and scene splitting
• Receivers can be added later (boss-defeated signal triggers door opening, BGM change, UI update…)

Signal-based design becomes increasingly valuable at larger scales.

---

”What I Want to Do” → “What to Use” Reverse Lookup Map

Character Movement

Camera

Game Progression & Events

Object Control

UI (User Interface)

Audio & Effects

Save & Load

AI & NPC Behavior (Core Only)

With the Behavior module: State Machine, Behavior Tree, GOAP, and Utility AI — 4 methods become available for visually building complex AI.

Combat (Core Only)

With Melee / Shooter modules: Combo systems, parry, Motion Warp, recoil, ballistics, aiming, weapon switching — all buildable with dedicated assets + UI.

---

Practical Patterns Using Core Features Only

Below are 33 practical patterns implementable with just the GC2 core. Due to article length, only a selection of representative patterns are shown here — see the full list in the Japanese version for all 33 patterns.

4.1 Locked Door

The most fundamental “conditional interaction” pattern.

Required:

• Door object (with Trigger + Hotspot)
• Global Variable: has_key (Boolean, initial value false)
• Key object (sets has_key to true when picked up)

Door Trigger setup:

Event: On Interact
→ Conditions:
    Branch 1: [Compare Boolean: has_key == true]
        → Change Rotation (door 90 degrees, Duration: 0.8, Easing: EaseInOut)
        → Play Sound Effect (door open/close SFX)
    Branch 2: [Always True (else equivalent)]
        → Play Sound Effect (locked SFX)
        → Change Text ("The door is locked")

Key object Trigger setup:

Event: On Interact
→ Set Bool (has_key = true)
→ Play Sound Effect (pickup SFX)
→ Set Active (key object = false)
→ Change Text ("You got the key")

4.2 Dialogue (Without Dialogue Module)

Simple text display can be handled with just the core.

NPC Trigger setup:

Event: On Interact
→ Is Controllable (Player, false)
→ Canvas Group Alpha (dialogue panel = 1, Duration: 0.3)
→ Change Text ("Hello, traveler.")
→ Wait Seconds (2)
→ Change Text ("Be careful in the cave ahead.")
→ Wait Seconds (2)
→ Canvas Group Alpha (dialogue panel = 0, Duration: 0.3)
→ Is Controllable (Player, true)

With the Dialogue module: Choice-based branching conversations, speaker icons, text advancement (click-to-continue), conditional branch nodes — all available with standard UI skins.

4.3 Score System

Score object Trigger setup:

Event: On Trigger Enter Tag (Tag: "Player")
→ Increment Number (score, +100)
→ Change Text (score Text Value via Property from score Variable)
→ Play Sound Effect (score SFX)
→ Destroy (this object)

4.4 Moving Platform / Elevator

Trigger setup:

Event: On Start
→ Change Position (upper position, Duration: 3, Easing: EaseInOut)
→ Wait Seconds (2)
→ Change Position (lower position, Duration: 3, Easing: EaseInOut)
→ Wait Seconds (2)
→ Restart Instructions

Note: GC2’s Character is controlled by its own CharacterController/NavMeshAgent/Rigidbody, so making the character a child of the platform with Set Parent may not make it follow. As a workaround, give the character the same movement vector with Move Direction while the platform moves, or make the platform a Rigidbody (Is Kinematic) and change the Character’s Driver to Rigidbody.

4.7 Cutscene (Camera Direction + Character Movement)

Trigger setup:

Event: On Trigger Enter Tag (Tag: "Player")
→ Is Controllable (Player, false)
→ Change To Shot (Angle A, Duration: 1.5)
→ Move To (NPC → Marker_NPC_Position)
→ Wait Seconds (1)
→ Change To Shot (Angle B, Duration: 1.0)
→ Play Gesture (NPC, wave animation)
→ Wait Seconds (1.5)
→ Change To Shot (Angle C, Duration: 0.8)
→ Change Text ("It's dangerous beyond here.")
→ Wait Seconds (2)
→ Canvas Group Alpha (dialogue panel = 0, Duration: 0.3)
→ Revert To Previous Shot (Duration: 1.0)
→ Is Controllable (Player, true)

Key points:

• Setting Change To Shot Duration above 0 creates smooth blend transitions
• Revert To Previous Shot returns to the pre-cutscene Shot (Shots are stack-managed)
• Move To waits for arrival before the next Instruction (Wait to Complete is ON by default)

4.8 Multi-Object Coordination with Signals

A pattern for notifying multiple independent objects from a single event.

Situation: When the boss is defeated, the door opens + BGM changes + UI updates

The boss side only calls Emit Signal once. No changes needed regardless of how many receivers exist, and each receiver can be prefabbed for reuse.

4.12 Simple Damage System

Player attack Trigger (input handler):

Trigger Event: On Input Button (Attack button)
→ Check Conditions: [Is Available: Player]
    → Play Gesture (Player, attack animation, Wait to Complete: false)
    → Wait Seconds (0.2)            ← Wait for swing start
    → Enable Collider (weapon Collider)
    → Wait Seconds (0.3)            ← Hit detection duration
    → Disable Collider (weapon Collider)

Enemy damage receiver Trigger:

Event: On Trigger Enter Tag (Tag: "PlayerWeapon")
→ Check Conditions: [Is Invincible: Enemy == false]
    → Subtract Numbers (enemy_hp, 25)
    → Set Invincible (Enemy, Duration: 0.5)   ← Prevent multi-hit
    → Play Gesture (Enemy, hit reaction animation)
    → Play Sound Effect (hit SFX)
    → Check Conditions: [Compare Decimal: enemy_hp <= 0]
        → Kill Character (Enemy)
        → Emit Signal ("enemy-defeated")

4.16 Slow Motion Effect

On special move hit:

→ Time Scale (0.2, Blend Time: 0.1, Layer: 1)    ← Slow to 0.2x
→ Shake Camera Burst (Duration: 0.3, Magnitude: 0.5, Roughness: 10)
→ Wait Seconds (0.5, Mode: Unscaled Time)        ← Wait 0.5s in real time
→ Time Scale (1.0, Blend Time: 0.3, Layer: 1)    ← Return to normal speed

• Setting Wait Seconds Mode to Unscaled Time waits in real time unaffected by TimeScale
• Characters with Update Time set to Unscaled Time move at normal speed during slow motion

4.24 Enemy Spawning (Wave System)

Wave start Trigger:

Trigger Event: On Receive Signal ("start-wave")
→ Increment Number (current_wave, +1)
→ Check Conditions:
    Branch 1: [Compare Decimal: current_wave == 1]
        → Set Number (enemies_alive = 3)
        → Instantiate (Enemy A Prefab × 3)
    Branch 2: [Compare Decimal: current_wave == 2]
        → Set Number (enemies_alive = 5)
        → Instantiate (Enemy A × 2 + Enemy B × 3)
    Branch 3: [Compare Decimal: current_wave == 3]
        → Set Number (enemies_alive = 1)
        → Instantiate (Boss Prefab)

4.33 Party / Companion Following

Multiple companion formation (staggered distance):

Companion 1: Start Following (Target: Player, Min: 2.0, Max: 3.5)
Companion 2: Start Following (Target: Companion 1, Min: 2.0, Max: 3.5)
Companion 3: Start Following (Target: Companion 2, Min: 2.0, Max: 3.5)

Create formations with a chain structure where “Companion 2 follows Companion 1”.

---

GC2 and Coexistence with Other Assets & Tools

GC2 is a toolkit that handles only specific areas of Unity’s framework.

Areas GC2 Occupies (Watch for Conflicts)

The following are areas GC2 fully controls internally — using another asset that handles the same area has a high chance of conflict.

Areas GC2 Does Not Control (Free to Choose)

GC2 does not control these areas at all — use Unity standard or any third-party asset you like.

Conflict Assessment Principle

Can this asset coexist with GC2?
    ├── Does the asset try to control "GC2's Character"?
    │       → Yes → Conflict
    │       → No  → Compatible
    ├── Does the asset control "Main Camera Position/Rotation" every frame?
    │       → Yes, and you also want GC2's Camera Shot → Conflict
    │       → Yes, but you won't use GC2's camera features → Compatible
    │       → No  → Compatible
    └── Does the asset handle areas GC2 does not control?
            → Yes → Free to use

Assets in the “Gray Zone” (Caution Required)

• Cinemachine: Conflicts if controlling the same Main Camera as GC2’s Camera Shot (frame-by-frame fight). Compatible if used for a separate camera (minimap, etc.)
• Animancer: Conflicts if directly manipulating GC2 Character’s Animator. Fine for non-GC2 Character GameObjects
• Playmaker / Unity Visual Scripting: Compatible. Explicitly stated in official documentation
• DOTween / LeanTween: Fine for objects not managed by GC2

---

What’s Difficult with Core Alone (The Value of GC2 Modules)

The greatest strength of GC2 modules is that they are fully integrated with GC2’s Visual Scripting, Variables, and Save & Load.

Inventory (Item Management)

Core only: Store item IDs in List Variables, manually build add/remove logic, construct Bag UI from scratch.

With Inventory module: Define with Item assets → manage with Bag components — done. Runtime Items (individual instance concept), Equipment (equipment slots), Currency, Merchants, Tinkering (crafting/dismantling), and Loot Tables (probability drops) are all included.

AI (Complex NPC Behavior)

Core only: With more than 4-5 states, tracking which Trigger corresponds to which state becomes difficult.

With Behavior module: 4 methods — State Machine/Behavior Tree/GOAP/Utility AI — with runtime visualization of currently executing nodes, making debugging dramatically easier.

Combat (Melee / Ranged)

Core only: Building combos (A→A→B for 3-hit chain) with Conditions makes input buffer and timing window implementation extremely tedious.

With Melee/Shooter modules: Phase management with Skill asset Sequencer, automatic input queue absorption with Combo asset Input Buffer, and Shield asset parry functionality are standard.

Perception

Core only: Spherical Trigger Colliders have no field-of-vision concept and detect through walls.

With Perception module: 4 sensors (Sight/Hearing/Smell/Feel), Awareness (gradual recognition), Luminance (light/dark) + Camouflage for a full stealth system.

Stats & RPG Number Systems

Core only: Damage formulas must be written each time with Math instruction chains, and equipment bonuses managed manually.

With Stats module: Define formulas in one place with Formula assets, auto-manage equipment bonuses with Stat Modifiers, and implement status effects simply by defining Status Effects.

”Painful Without Modules” Threshold Guide

---

Cross-Module Integration and Combinations

The true value of GC2 modules lies in modules working together.

Representative Combinations

• Stats × Melee / Shooter: Auto-calculate damage with Formulas on Hit. Equipment Stat Modifiers auto-applied
• Stats × Inventory: Equipping to equipment slots auto-applies Stat Modifiers. Unequipping reverts them
• Perception × Behavior: When Awareness reaches Alert, State Machine transitions to chase
• Dialogue × Stats: Set “STR ≥ 15” as a dialogue node condition. Options don’t appear if strength is insufficient
• Quests × Dialogue: Accept quests during NPC conversations, rewards auto-fire on report
• Inventory × Dialogue × Quests: Classic RPG setup. Item collection → Task completion → Rewards

Recommended Combinations (By Genre)

---

Module Adoption Decision Criteria

Decision Flowchart

"Can this feature be built with core alone?"
    → Yes, and implementation is simple (~30 min) → Build with core
    → Yes, but requires significant effort → Consider a module
    → No (the concept doesn't exist in core) → Module required or custom script

Recommended Adoption Order

1. Start by building with core only — You can’t master modules without understanding the basics
2. Add 1-2 modules central to your game genre
   • RPG: Stats + Inventory
   • Adventure: Dialogue + Inventory
   • Action: Melee or Shooter
3. Add more after playtesting reveals gaps — Buy when you need it
4. Consider AI modules (Behavior + Perception) when you have multiple enemy types — A single simple enemy type works fine with core

---

Common Implementation Patterns

Scene Transition (With Loading)

Trigger Event: On Interact (touch a door)
→ Is Controllable (Player, false)
→ Canvas Group Alpha (black overlay = 1, Duration: 0.5)
→ Save Game (slot: 0)
→ Load Scene ("NextStage", Async: true)

Use the free Transitions Extension for loading screens and fade effects with dedicated components.

Multiple Endings

Global Variables:
  - ending_flag (Number): 0=undecided, 1=Good, 2=Bad, 3=True

Final scene Conditions:
  Branch 1: [ending_flag == 1] → Good End cutscene
  Branch 2: [ending_flag == 2] → Bad End cutscene
  Branch 3: [ending_flag == 3] → True End cutscene
  Branch 4: [Always True]       → Normal End

The design involves rewriting ending_flag based on choices and actions during gameplay.

---

Troubleshooting and Design Tips

Common Problems and Solutions

Design Tips

1. Variable names in English snake_case — player_hp, has_key_blue, quest_01_complete
2. Signal names in subject-verb format — boss-defeated, door-opened, timer-expired
3. Register Signals as favorites — Prevents typos
4. 1 Actions = 1 responsibility — Keep each single-purpose
5. Conditions evaluate from top — Put the most specific condition in the first Branch
6. Attach Hotspots to all interactable targets — Always show players “what they can do”
7. Use On Trigger Enter Tag — Tag filtering prevents unnecessary firing

Performance Awareness

• On Update / On Fixed Update run every frame — keep usage to a minimum (consider On Interval instead)
• When using Instantiate heavily, pre-pool with Pool Prewarm
• Deactivate unused Actions/Triggers with Set Active(false)
• With NavMesh Agent and many NPCs, pathfinding load increases. Widen On Interval spacing

---

Official Links

• Game Creator 2 Official Documentation
• Game Creator 2 — Unity Asset Store

---

Summary

In this article, we covered how to build games with Game Creator 2 through practical patterns.

Key takeaways:

1. Master Trigger + Actions + Conditions + Variables and you can build the majority of game logic
2. GC2 occupies 4 areas: character control, camera management, game logic, and save & load. Everything else is freely selectable
3. The criterion for asset conflict is “whether it tries to control the same GameObject as GC2’s Character/Camera”
4. “Inventory management”, “complex AI”, “combat feel”, “gradual perception”, and “RPG number systems” have skyrocketing implementation costs with core alone — this is where modules provide value
5. Cross-module integration multiplies that value further (Stats × Melee for auto damage calculation, Perception × Behavior for perception-driven AI, etc.)

By thinking in terms of “small event-driven accumulations”, core + the right module combinations can handle almost any game genre.

Complete Article List — Game Creator 2 Complete Guide Series Indexen.senkohome.com/gamecreator2-series-index/

We hope you’ll check out our other articles as well.