[C] Gestione input Game Engine 2D Game

[gaten]

Ragazzi, stò creando un piccolissimo engine per un giochino 2D, ho iniziato a introdurre le funzioni basilari che serviranno per il giochino:

Engine.h:

#ifndef _ENGINE_H
#define _ENGINE_H

#include <stdio.h>
#include <stdlib.h>

#define TICKGAME 1000                    // FPS ( Frame Per Second )

typedef void (*GAMELOOP)(void);
typedef void (*RENDERFRAME)(void);
typedef void (*PROCESSINPUT)(void);
typedef void (*UPDATE)(void);

typedef struct _engine
{
    int TickGame;
    GAMELOOP        GameLoop;
    RENDERFRAME        RenderFrame;
    PROCESSINPUT    ProcessInput;
    UPDATE            Update;
} ENGINE;

ENGINE* Init();
void    GameLoop();                // Main Game Loop
void    RenderFrame();            // Renderizza un frame
void    ProcessInput();            // Processa l'input dell'utente
void    Update();                // Aggiorna tutti i componenti interni dell'Engine

#endif

Engine.c

#include "Engine.h"

ENGINE* Init() {
    ENGINE *engine = malloc(sizeof(ENGINE));
    engine->GameLoop        = &GameLoop;
    engine->RenderFrame        = &RenderFrame;
    engine->ProcessInput    = &ProcessInput;
    engine->Update            = &Update;

    return engine;
}

void GameLoop()
{
    int TickGameBefore, TickGameAfter;
    // Clock attuale
    TickGameBefore = clock();
    do {
        // Clock all'inizio del gameloop
        TickGameAfter = clock();
        // Se sono passati TICKGAME( millisecondi ) allora eseguo il tick di gioco
        if (TickGameAfter - TickGameBefore > TICKGAME) 
        {
            ProcessInput();
            Update();
            RenderFrame();
            // Clock alla fine di un tick di gioco
            TickGameBefore = TickGameAfter;
        }
    } while (1); // Continuo fino a quando non clicco ESC
}

void RenderFrame()
{
    printf("RenderFrame Function\n");
}

void ProcessInput()
{
    printf("ProcessInput Function\n");
}

void Update() 
{
    printf("Update Function\n");
}

main.c

#include "Console.h"
#include "Engine.h"

int main()
{
    printf("Benvenuti nel gioco\n");
    printf("***********************\n\n");
    ENGINE *engine = Init();
    engine->GameLoop();

    return 0;
}

Ora mi è sorto un dubbio:

Le funzioni che sono all'interno del GameLoop, cioè "ProcessInput", "Update" e "RenderFrame", a loro volta cosa faranno precisamente? Per intenderci. Ora vorrei fare in modo che quando clicco "ESC", devo uscire dal gameloop e quindi terminare il gioco, questa cosa va gestita all'interno della funzione ProcessInput?

premetto che in "Console.c", ho un metodo LeggiTasto che è il seguente:

int LeggiTasto
(   int Wait           // Input: attesa massima in millesimi di secondo
)                      //        -1 attesa infinita;  0 non attende
{   int Prima, Dopo,
        Tasto = 0;

    Prima = clock();   // lettura in millesimi di secondo
    if (Wait<0) Wait = 0x7FFFFFFF;      // circa 25 giorni

    do Dopo = clock(); while (Dopo-Prima<Wait && !_kbhit());

    if (_kbhit())
    {   Tasto = _getch();
        if (Tasto == 0 || Tasto == 224) Tasto = _getch() + 256;
    }
    return ( Tasto );
}

Io credo che l'input debba essere qualcosa di globale nel gioco, non credete?

In definitiva chiedo, come mi consigliate di gestire l'input ?

[Scara95]

Essendo il tuo game engine organizzato a callbacks ogni callback dovrà svolgere una singola funzione, inoltre ogni callback dovrà accettare dei parametri contestuali.
Ad esempio per la gestione dell'input avrai una callback che accetta l'input da gestire e decide cosa fare, ma sarà il game engine a occuparsi di accettare l'input e passare i dati alla callback che lo gestisce.

[gaten]

Essendo il tuo game engine organizzato a callbacks ogni callback dovrà svolgere una singola funzione, inoltre ogni callback dovrà accettare dei parametri contestuali.
Ad esempio per la gestione dell'input avrai una callback che accetta l'input da gestire e decide cosa fare, ma sarà il game engine a occuparsi di accettare l'input e passare i dati alla callback che lo gestisce.

Utilizzando il C, per "simulare" la OOP stò cercando di usare le funzioni di callback e l'idea è creare una struttura ENGINE che abbia tutti i metodi di cui necessito... come giustamente dicevi , ogni funzione si occuperà di qualcosa. Potresti illustrarmi un esempio su come far gestire l'input all'engine.. te ne sarei grato.