GameHostBase.cs

using Gondwana.Configuration;
using Gondwana.Logging;
using Gondwana.Rendering;
using Gondwana.Scenes;
using Gondwana.Widgets;
using Microsoft.Extensions.Logging;
 
namespace Gondwana.Hosting;

public abstract class GameHostBase : IDisposable
{
    private bool _disposed;
    private bool _initialized;
    private bool _engineInitialized;
    private bool _engineStarted;
 
    private WidgetInputRouter? _widgetInputRouter;

    public Engine Engine => Engine.Instance;

    public Scene? Scene { get; protected set; }

    protected WidgetInputRouter? WidgetInputRouter => _widgetInputRouter;

    public void Initialize(
        string? configPath = null,
        bool? autoSaveConfig = null,
        LogLevel logLevel = LogLevel.Warning)
        => InitializeCore(configPath, autoSaveConfig, logLevel, configurationStore: null);

    public void InitializeWithConfigurationStore(
        IEngineConfigurationStore configurationStore,
        bool? autoSaveConfig = null,
        LogLevel logLevel = LogLevel.Warning)
    {
        ArgumentNullException.ThrowIfNull(configurationStore);
        InitializeCore(configPath: null, autoSaveConfig, logLevel, configurationStore);
    }
 
    private void InitializeCore(
        string? configPath,
        bool? autoSaveConfig,
        LogLevel logLevel,
        IEngineConfigurationStore? configurationStore)
    {
        EnsureNotDisposed();
        EnsureNotInitialized();
 
        OnInitializing();
 
        ConfigureLogging(logLevel);
        ConfigurePlatform();
        ConfigureInput();
        InitializeGameContent();
 
        InitializeEngine(configPath, autoSaveConfig, configurationStore);
        StartEngine();
 
        _initialized = true;
 
        OnInitialized();
    }

    protected void InitializeWidgetInput(RenderSurfaceHostBase renderSurfaceHost)
    {
        ArgumentNullException.ThrowIfNull(renderSurfaceHost);
 
        _widgetInputRouter?.Dispose();
 
        var keyboardPoller = Engine.Input.KeyboardEventPoller;
        var mousePoller = Engine.Input.MouseEventPoller;
        var touchPoller = Engine.Input.TouchEventPoller;
 
        mousePoller?.StartMonitoringMouse(
            trackMouseMovement: true);
 
        _widgetInputRouter = new WidgetInputRouter(
            renderSurfaceHost,
            keyboardPoller,
            mousePoller,
            touchPoller);
 
        _widgetInputRouter.Start();
    }

    protected virtual void OnInitializing()
    {
    }

    protected void ConfigureLogging(
        LogLevel logLevel)
    {
        EngineLogger.SetLogLevel(logLevel);
    }

    protected abstract void ConfigurePlatform();

    protected void ConfigureInput()
    {
        ConfigureKeyboard();
        ConfigureMouse();
        ConfigureGamepads();
        ConfigureTouch();
 
        OnInputConfigured();
    }

    protected virtual void ConfigureKeyboard()
    {
    }

    protected virtual void ConfigureMouse()
    {
    }

    protected virtual void ConfigureGamepads()
    {
    }

    protected virtual void ConfigureTouch()
    {
    }

    protected virtual void OnInputConfigured()
    {
    }

    protected void InitializeGameContent()
    {
        LoadContent();
        CreateSceneGraph();
        BindScene();
        OnSceneBound();
        InitializeSceneObjects();
    }

    protected void LoadContent()
    {
        LoadAssets();
        LoadTilesheets();
        LoadAnimationCycles();
    }

    protected virtual void LoadAssets()
    {
    }

    protected virtual void LoadTilesheets()
    {
    }

    protected virtual void LoadAnimationCycles()
    {
    }

    protected void CreateSceneGraph()
    {
        Scene = CreateInitialScene()
            ?? throw new InvalidOperationException(
                $"{nameof(CreateInitialScene)} returned null.");
 
        CreateInitialViews();
        OnSceneGraphCreated();
    }

    protected virtual void OnSceneGraphCreated()
    {
    }

    protected virtual Scene CreateInitialScene()
    {
        return Scene.Empty;
    }

    protected virtual void CreateInitialViews()
    {
    }

    protected virtual void BindScene()
    {
    }

    protected virtual void OnSceneBound()
    {
    }

    protected void InitializeSceneObjects()
    {
        CreateSprites();
        CreateDirectDrawings();
    }

    protected virtual void CreateSprites()
    {
    }

    protected virtual void CreateDirectDrawings()
    {
    }

    protected void InitializeEngine(
        string? configPath,
        bool? autoSaveConfig)
        => InitializeEngine(configPath, autoSaveConfig, configurationStore: null);

    protected void InitializeEngine(
        string? configPath,
        bool? autoSaveConfig,
        IEngineConfigurationStore? configurationStore)
    {
        if (configurationStore is null)
        {
            Engine.Instance.Initialize(
                configFileName: configPath,
                autoSaveConfig: autoSaveConfig);
        }
        else
        {
            Engine.Instance.InitializeWithConfigurationStore(
                configurationStore,
                autoSaveConfig: autoSaveConfig);
        }
        _engineInitialized = true;
 
        OnEngineInitialized();
    }

    protected virtual void OnEngineInitialized()
    {
    }

    protected void StartEngine()
    {
        var syncContext = GetSynchronizationContext()
            ?? throw new InvalidOperationException(
                $"{nameof(Initialize)} must be called on a thread with a current {nameof(SynchronizationContext)}.");
 
        StartEngineCore(syncContext);
        _engineStarted = true;
 
        OnEngineStarted();
    }

    protected virtual void StartEngineCore(
        SynchronizationContext syncContext)
    {
        Engine.Instance.Start(syncContext);
    }

    protected virtual SynchronizationContext? GetSynchronizationContext()
    {
        return SynchronizationContext.Current;
    }

    protected virtual void OnEngineStarted()
    {
    }

    protected virtual void OnInitialized()
    {
    }

    protected virtual void UnhookEvents()
    {
    }

    protected void StopEngine()
    {
        StopEngineCore();
        _engineStarted = false;
    }

    protected virtual void StopEngineCore()
    {
        Engine.Instance.Stop();
    }

    protected void DisposeEngine()
    {
        Engine.Instance.Dispose();
        _engineInitialized = false;
    }

    protected virtual void OnDisposing()
    {
    }

    protected virtual void OnDisposed()
    {
    }

    protected void EnsureNotInitialized()
    {
        if (_initialized)
        {
            throw new InvalidOperationException(
                $"{GetType().Name} has already been initialized.");
        }
    }

    protected void EnsureNotDisposed()
    {
        ObjectDisposedException.ThrowIf(_disposed, this);
    }

    public void Dispose()
    {
        if (_disposed)
            return;
 
        // Stop platform scheduling and wait for rendering before any hook can release
        // native drawing resources. Stop alone only requests that the loop exit.
        if (_engineStarted)
            StopEngine();
 
        if (_engineInitialized)
            Engine.StopAndWait();
 
        OnDisposing();
 
        _widgetInputRouter?.Dispose();
        _widgetInputRouter = null;
 
        UnhookEvents();
 
        if (_engineInitialized)
            DisposeEngine();
 
        _disposed = true;
 
        OnDisposed();
 
        GC.SuppressFinalize(this);
    }
}