# realvirtual Init Sequence

Unity's default execution order provides a solid foundation for initialization but often lacks the granular control needed for complex scenarios—particularly when integrating third-party solutions, orchestrating sequence events across different GameObjects, or dealing with additive scene loading. To address these challenges, **realvirtual** introduces an additional initialization sequence managed by the **realvirtualController**.

***

### Overview

By extending Unity’s built-in lifecycle, **realvirtual** ensures a more predictable and step-by-step setup process across complex multi-scene projects. This is especially helpful for coordinating dependencies among third-party plugins, custom systems, and multi-scene workflows.

The extended lifecycle adds five main phases:

1. **InitStart**
2. **InitAwake**
3. **InitEnable**
4. **InitAllScenesLoaded**
5. **InitPostAllScenesLoaded**

Each phase is opt-in; you only need to implement the corresponding interface or override the provided method in your scripts.

> **Debugging Tip**\
> You can enable **DebugMode** on the **realvirtualController** (e.g., via the Inspector) to see detailed console logs showing the exact sequence of calls. This is especially useful if you need to confirm your **InitStart**, **InitAwake**, **InitEnable**, and **InitAllScenesLoaded** methods are running at the expected times.

<figure><img src="https://260262196-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FpYxFg97YnJX96UzNNTSd%2Fuploads%2Fgit-blob-e284c9d7a4ade697a37f7b9e6a155366c10cbd40%2Fdebugmode.png?alt=media" alt=""><figcaption></figcaption></figure>

***

### Sequence Flow

1. **Scene Load (Unity)**
2. **realvirtualController Recognition**
3. **InitStart → InitAwake → InitEnable → (Additive Scenes Load) → InitAllScenesLoaded → InitPostAllScenesLoaded**

Below is a closer look at each phase.

***

### 1. InitStart

* **Triggered When**: The **realvirtualController** is first recognized.
* **Key Tasks**:
  * Reads and applies any saved settings (e.g., `DebugMode`, `ConnectionMode` from `PlayerPrefs`).
  * Invokes any script that implements the `IInitStart` interface.

#### Code Example

```csharp
using realvirtual;
using UnityEngine;

public class MyInitStartExample : MonoBehaviour, IInitStart
{
    public void OnInitStart()
    {
        // Perform essential setup, e.g., loading configuration from PlayerPrefs
        Debug.Log("InitStart: Essential setup complete.");
    }
}
```

***

### 2. InitAwake

* **Triggered When**: **realvirtualController**'s standard Awake method is called.
* **Key Tasks**:
  * Unity’s standard `Awake()` can happen before or after this, depending on Unity’s internal ordering.
  * Use `IInitAwake` for additional initialization logic that should pair with Unity’s Awake but be orchestrated by **realvirtualController**.

#### Code Example

```csharp
using realvirtual;
using UnityEngine;

public class MyInitAwakeExample : MonoBehaviour, IInitAwake
{
    public void OnInitAwake()
    {
        // Perform Awake-like setup, e.g., references or data initialization
        Debug.Log("InitAwake: More initialization logic here.");
    }
}
```

***

### 3. InitEnable

* **Triggered When**: **realvirtualController** is enabled (similar to Unity’s `OnEnable()`).
* **Key Tasks**:
  * Standard `OnEnable()` may occur before or after this, again depending on Unity’s internal ordering.
  * Regardless of the active status of your script derived from `realvirtualBehavior`, this will still be called.

#### Code Example

```csharp
using realvirtual;
using UnityEngine;

public class MyInitEnableExample : MonoBehaviour, IInitEnable
{
    public void OnInitEnable()
    {
        // Setup activation-related logic, e.g., attaching event listeners
        Debug.Log("InitEnable: Components are ready to be enabled.");
    }
}
```

***

### 4. InitAllScenesLoaded

* **Triggered When**: All scenes (including additive scenes) have been loaded.
* **Key Tasks**:
  * If no additional scenes are loaded, this runs immediately after `InitEnable`.
  * Typically used for final cross-scene references or enabling/disabling systems that depend on every scene being ready.
  * Implement `IAllScenesLoaded` or override `OnAllScenesLoaded` in your `realvirtualBehavior`.

#### Code Example

```csharp
using realvirtual;
using UnityEngine;

public class MyAllScenesLoadedExample : realvirtualBehavior, IAllScenesLoaded
{
    public void OnAllScenesLoaded()
    {
        // Access objects across multiple scenes, finalize cross-scene references, etc.
        Debug.Log("All Scenes Loaded: Multi-scene references can now be set up.");
    }

    // If overriding in realvirtualBehavior, you can also do:
    // protected override void OnAllScenesLoaded() { ... }
}
```

***

### 5. InitPostAllScenesLoaded

* **Triggered When**: Immediately after `InitAllScenesLoaded`.
* **Key Tasks**:
  * Allows “late-late” initialization logic—when you want to ensure everything in `InitAllScenesLoaded` (including other scripts) has completed.

#### Multi-Phase Example

Below is an example of a script that handles multiple phases by implementing multiple interfaces:

```csharp
using UnityEngine;
using realvirtual;

public class MyMultiStageScript : MonoBehaviour,
    IInitStart,
    IInitAwake,
    IInitEnable,
    IAllScenesLoaded
{
    public void OnInitStart()
    {
        Debug.Log("OnInitStart: Reading configuration...");
    }

    public void OnInitAwake()
    {
        Debug.Log("OnInitAwake: Setting up references...");
    }

    public void OnInitEnable()
    {
        Debug.Log("OnInitEnable: Attaching event listeners...");
    }

    public void OnAllScenesLoaded()
    {
        Debug.Log("OnAllScenesLoaded: Final cross-scene linking...");
    }
}
```

***

### Summary of Customizable Methods

| Method / Interface                        | Description                                                                                                            |
| ----------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
| **InitStart**`IInitStart`                 | Earliest moment after the **realvirtualController** is recognized. Useful for reading config or setting global states. |
| **InitAwake**`IInitAwake`                 | Pairs with Unity’s `Awake()` for orchestrated initialization.                                                          |
| **InitEnable**`IInitEnable`               | Pairs with Unity’s `OnEnable()`, for activation-related logic.                                                         |
| **InitAllScenesLoaded**`IAllScenesLoaded` | Ensures all scenes (including additive scenes) are loaded before proceeding. Ideal for cross-scene references.         |
| **InitPostAllScenesLoaded**               | Late-late initialization after all scenes and logic in `InitAllScenesLoaded`.                                          |