Skip to content

Overview

Jump to bottom
Ali Badpa edited this page Apr 16, 2026 · 1 revision

Core

The Core module contains the fundamental architecture of the framework. It defines the key concepts, base structures, and core keywords used to build systems within RealMethod. This layer forms the foundation that the rest of the framework is built upon.

Core module have some elements that work together to manage the game lifecycle, scenes, and global systems in a structured way.The main concepts in the Core module are: Game, World, GameManager, Service, GameConfig, and GameBridge

Game

Is the central and global class of the RealMethod architecture. A single instance of this class is created when the game starts on the target platform and remains alive until the application is closed. Because of this, the Game instance is always loaded in memory and is responsible for controlling high-level game operations such as:

  • Opening or changing scenes
  • Quitting the game
  • Accessing managers
  • Coordinating global systems

The Game class acts as the main entry point for interacting with the framework during runtime.

How To Use

  • Create a custom Game class:
    1. In the Unity Project window, click the Add (+) buttonor right‑click inside the Project window.
    2. Navigate to:Create → Scripting → RealMethod → Essential → Game
    3. Choose a name for your Game class (for example: MyGame).
  • Assigning the Game Class:
    1. Open ProjectSettings in Unity.
    2. Navigate to RealMethod.
    3. In the GameClass field, select your newly created Game class.

Once selected, RealMethod will use this class when the game starts.

Note: Creating a custom Game class is optional. If you prefer, you can skip this step and use the built‑in DefaultGame class provided by RealMethod. This is useful for quick setups or simple projects where custom global logic is not required.

World

Represents a scene-level controller. Each Unity scene should contain one World instance (or a class that inherits from World). The World class is responsible for controlling and initializing the scene environment. Its responsibilities typically include:

  • Preparing the scene when it loads
  • Spawning or setting up the player
  • Initializing scene-specific systems
  • Managing objects that belong to that scene

In simple terms, while Game controls the application, World controls the current scene.

Note: If you have two world component in scene realmethod automaticly desable second one

How To Use

  • Create a custom World class:
    1. In the Unity Project window, click the Add (+) button or right‑click inside the Project window.
    2. Navigate to:Create → Scripting → RealMethod → Essential → World
    3. Choose a name for your World class (for example: GamePlayWorld).
  • Assigning the World Class:
    1. In the Unity Hierarchy window, click the Add (+) button or right‑click inside the Project window.
    2. Create Empty GameObjcet
    3. Add Your Custom World as Component in GameObject
    4. Commonly you change GameObject name to World

Note: Creating a custom World class is optional. If you prefer, you can skip this step and use the built‑in DefaultWorld class provided by RealMethod. This is useful for quick setups or simple projects where custom global logic is not required.

For fast setup just click the Add (+) button and navigate to:RealMethod → Essential → World in Hierarchy

GameManager

IGameManager is an interface with three method that allows any MonoBehaviour to be registered as a manager within the RealMethod architecture. GameManagers can be accessed globally through the Game class using:

Game.FindManager<T>()

GameManagers are initialized by the RealMethod lifecycle, which runs before Unity’s standard MonoBehaviour lifecycle(Awake,....) methods. Because of this, managers are not meant to be spawned dynamically in the scene. Instead, they are configured and initialized by the framework. A key feature of GameManager is that managers can exist in two different scopes(Game,World), that developer decide to chose one.

  1. GameScope Managers in GameScope are set beside the Game Class and developer can do this with StartPrefabs and these managers like Game remain alive until the game closes. These managers handle systems that must persist across all scenes Examples:

    • SaveManager (handles loading and saving game data)
    • MusicManager (controls background music across the entire game)
    • ScreenManager (all screens between loading scenes or others)

  2. WorldScope Managers with WorldScope exist only while a specific scene (World) is active. When the scene changes, these managers are destroyed and recreated for the new scene, Developer with added these manager in GameObject include World class can add Manager in WorldScope. Examples:

    • HUDManager (controls UI elements specific to a level)
    • SoundManager (handles scene-based sound effects)

GameScope: Add GameManager Componet in StartPrefabs(We explain is below) WorldScope: Add GameManger Component in World GameObject or Chiled

How To Use

  • Create new Manager:
    1. In the Unity Project window, click the Add (+) button or right‑click inside the Project window.
    2. Navigate to:Create → Scripting → RealMethod → Manager → BaseManager
    3. Choose a name for your GameManager class (for example: EnemyManager). OR
    4. Open You any Monobehavior script
    5. Implement IGameManager Interface into your class.
  • Add In scope for initiateing in game
    1. Define you wnat your manager always loaded or just useful for target scene
    2. Add your Manager component beside World component for WorldScope or in StartPrefab for GameScope

Service

The Service class in RealMethod represents a lightweight runtime object designed purely for programmatic use — it has no visual or serialized representation in the Unity Editor. Services are created and destroyed dynamically during gameplay, and their lifecycle is fully managed by the programmer, giving total flexibility over when and how they exist.

Created:

Game.AddService<T>(object author)

Removed:

Game.RemoveService<T>();

Whenever a service is created or destroyed, all managers that implement the GameManager interface are automatically notified. This communication allows managers to adapt their behavior based on available services.

Use Case Example Imagine a MusicManager that adjusts game music depending on the current game state. When a GameStateService is created, the MusicManager detects this and begins playing the track that corresponds to the current state. If the service is removed, the manager can stop or change its behavior accordingly.

You can even create a Service with DirectorService name that stores and updates gameplay data such as difficulty or global parameters across scenes

Relation Between Manager and Service During the initialization phase, any manager can verify if a service exists before performing its setup using:

Game.TryFindService<T>(out T service);

This method lets managers adapt their initial behavior depending on which services are active, enhancing modularity and making RealMethod’s architecture highly responsive and flexible.

Example:

public class MyCustomManager : MonoBehaviour, IGameManager
{
        // Implement IGameManager Interface
        MonoBehaviour IGameManager.GetManagerClass()
        {
            return this;
        }
        void IGameManager.InitiateManager(bool alwaysLoaded)
        {
            if(Game.TryFindService(out MyCustomService service))
            {
                DoSomting();
            }
        }
        void IGameManager.ResolveService(Service service, bool active)
        {
            if(active)
            {
                if(service is MyCustomService)
                {
                    DoSomting();
                }
            }
        }
}

How To Use

  • Create new Service:
    1. In the Unity Project window, click the Add (+) button or right‑click inside the Project window.
    2. Navigate to:Create → Scripting → RealMethod → Service → BaseService
    3. Choose a name for your Service class (for example: Director).
  • Active your Service:
    1. Any time you need you can use Game.AddService<>() to create service instance and notify to all manager
    2. Any time you need you can use Game.RemoveService<>() to notify to all manager and remove service instance

GameConfig

GameConfig is a ConfigAsset used by RealMethod to store global, designer‑driven data. Technically, GameConfig is a ScriptableObject, but for now it is enough to know that it is a read‑only configuration asset. GameConfig loaded automatically when Game initializes. You can be accessed globally via:

Game.Config

Purpose GameConfig is intended to hold data that designers may need to tweak, without changing code. Because it is read‑only at runtime, it provides a safe and predictable way to define game‑wide parameters. Typical use cases include:

  • Difficulty parameters
  • Global balance values
  • Feature toggles
  • References to other configuration assets

Example: If your game supports multiple difficulty levels, you can implement difficulty‑related parameters (such as enemy health multipliers, damage scaling, or spawn rates) inside your GameConfig. Designers can then create different GameConfig assets for test each difficulty.

You can't change GameConfig at runtime. A GameConfig asset can also reference other configuration assets or data objects, making it easy to organize complex configuration setups in a modular way.

This approach keeps gameplay logic clean while giving designers full control over tunable game data, all centralized in a single, globally accessible configuration system.

How To Use

  • Create Custom GameConfig Class:
    1. In the Unity Project window, click the Add (+) button or right‑click inside the Project window.
    2. Navigate to:Create → Scripting → RealMethod → Asset → Config → GameConfig
    3. Choose a name for your GameConfig class (for example: MyGameConfigAsset).
  • Create your GameConfig Asset:
    1. In your script top of class these is CreateAssetMenu macro in menuname section you can address that to create Asset content.
  • Assigning the GameConfgi Asset:
    1. Open ProjectSettings in Unity.
    2. Navigate to RealMethod.
    3. In the GameConfig field, select your newly created GameConfig asset.

GameBridge

GameBridge is the class responsible for handling the relationship between the Game and World classes, as well as managing scene loading within the RealMethod framework. A single instance of GameBridge is created after the game starts and remains alive until the application closes. It acts as the central coordinator for scene transitions and world activation.

Game ↔ World Connection When a World is connected to the Game, RealMethod takes control of how Worlds are activated with GameBridge. If a new World is detected in a loaded scene, RealMethod automatically disables it by default. This ensures that scene activation is always managed through RealMethod’s lifecycle rather than Unity’s default behavior. Because of this, RealMethod uses its own scene‑loading approach instead of relying directly on Unity’s standard flow. Scene Loading Strategy By default, RealMethod:

  1. Unloads the current scene
  2. Loads the new scene
  3. Displays a loading screen to the player (With ScreenManager)

A loading screen can be implemented using a ScreenManager (or your custom Manager) registered in GameScope, ensuring it persists across scene transitions. This controlled process guarantees consistent world initialization and clean transitions between scenes. Customization and Extensibility If you want to change how the Game and World interact, customize scene loading behavior, or integrate a third‑party scene management package, you can extend or replace the GameBridge implementation. By customizing GameBridge, you can define:

  • How Worlds become active
  • How scenes are loaded or unloaded
  • Whether scenes are loaded additively or replaced
  • How loading screens or transitions are handled

Scenes can be opened or added through the Game class:

OpenScene(int sceneIndex)
OpenScene(SceneReference scene)
OpenScene(string sceneName)
OpenWorld(WorldSceneConfig WorldScene)
ReOpenScene()
AddScene(int sceneIndex)
AddScene(SceneReference scene)
AddScene(string sceneName)

These methods internally call the corresponding logic inside the GameBridge class, keeping scene management centralized and consistent across the framework.

SceneReference & WorldSceneConfig it will be explained later.

How To Use

  • Create Custom GameConfig Class:
    1. In the Unity Project window, click the Add (+) button or right‑click inside the Project window.
    2. Navigate to:Create → Scripting → RealMethod → Essential → GameBridge
    3. Choose a name for your GameBridge class (for example: MyBridge).
  • Assigning the GameBridge Class:
    1. Open ProjectSettings in Unity.
    2. Navigate to RealMethod.
    3. In the GameBridge field, select your newly created GameBridge class.

RootA ChildA SubChildA RootB ChildB

Clone this wiki locally