Come posso aggiornare le impostazioni di visualizzazione da una schermata Opzioni senza riavviare?

Attualmente sto creando un gioco di ruolo 2D in C ++ 11 con Allegro 5 e boost.

Il mio obiettivo è in qualche modo aggiornare le mie impostazioni di gioco quando un'opzione viene modificata nel menu Opzioni. Non voglio forzare l'utente a riavviare il gioco. Altri giochi non richiedono un riavvio quando si cambia risoluzione o si passa da schermo intero a finestre, quindi neanche il mio gioco. Si prega di vedere una vista semplificata del sistema di seguito.

Nota che non voglio necessariamente chiamare direttamente il mio oggetto di gioco dalla schermata Opzioni. La linea tratteggiata serve semplicemente a illustrare l'effetto che sto cercando di ottenere; causare in qualche modo un aggiornamento del gioco quando un'opzione viene cambiata in una parte diversa del sistema.

Spiegazione dettagliata

ScreenManager contiene un elenco di tutti gli GameScreenoggetti attualmente esistenti. Queste saranno varie schermate del gioco inclusi i popup. Questo design aderisce più o meno all'esempio di gestione dello stato di gioco in C # / XNA .

Il ScreenManagercontiene un riferimento al mio Gameoggetto. L' Gameoggetto inizializza e modifica le impostazioni del gioco. Se voglio cambiare la risoluzione, passare a schermo intero o disattivare il volume, lo farei in Gameclasse.

Tuttavia, OptionsScreen al momento non può accedere alla classe di gioco. Vedi lo schema seguente:

Un GameScreen può segnalare tre eventi, onFinished, onTransitionStarte onTransitionEnd. Non c'è onOptionsChangedperché solo una schermata lo fa. ScreenManager non può impostare la gestione degli eventi per questo perché gestisce tutte le schermate come GameScreen.

La mia domanda è: come posso cambiare il mio design in modo che una modifica nel menu Opzioni non richieda un riavvio, ma venga cambiata immediatamente? Preferirei che il mio Gameoggetto si aggiornasse dopo aver fatto clic sul pulsante Applica.

Da quello che ho visto, l'approccio più semplice è leggere un file di opzioni all'avvio per determinare le impostazioni di visualizzazione correnti; quindi, quando viene visualizzata la schermata delle opzioni, carica tutte le opzioni correnti da un file.

Quando le modifiche vengono finalizzate tramite un pulsante applyo ok, vengono salvate in un file. Se qualche modifica ha effetto sul display, avvisa l'utente che il gioco deve essere riavviato affinché abbiano effetto.

Al riavvio del gioco, le impostazioni di visualizzazione (ora nuove) vengono nuovamente lette dal file.

--MODIFICARE--

Annd ... sarebbe stato d'aiuto se avessi notato l'ultima frase. Non è necessario riavviare. Rende le cose un po 'più difficili a seconda dell'implementazione e della libreria grafica di back-end.

IIRC, Allegro ha una chiamata di funzione che consente di modificare al volo le impostazioni di visualizzazione. Non sono ancora aggiornato su Allegro 5, ma so che potresti farlo in 4.

Questo è quello che faccio per il mio gioco. Ho 2 funzioni separate per l'inizializzazione delle cose, 'init' e 'reset'. Init viene chiamato solo una volta all'avvio e fa cose che non si basano su alcuna impostazione, come il caricamento delle risorse principali. Il ripristino fa cose come il layout dell'interfaccia utente in base alla risoluzione dello schermo, quindi viene chiamato ogni volta che cambiano le impostazioni.

init();
bool quit = false;
while( !quit )
{
    createWindow();
    reset();

    bool settings_changed = false;
    while( !quit && !settings_changed )
    {
        ... main loop
        // set quit=true if user clicks 'quit' in main menu
        // set settings_changed=true if user clicks 'apply' in options
    }

    destroyCurrentWindow();
}

Non ho familiarità con Allegro, ma la mia risposta è abbastanza generale, quindi spero che aiuti te o chiunque altro con un problema simile.

Senza incasinare la tua architettura attuale, vedo due modi. Innanzitutto, è possibile memorizzare un puntatore Gameall'istanza nella OptionsScreenclasse. In secondo luogo, è possibile che la Gameclasse recuperi le impostazioni correnti in un determinato intervallo, ad esempio ogni secondo.

Per adattarsi effettivamente alle nuove impostazioni, la Gameclasse deve implementare una sorta di funzioni di ripristino che recupera le impostazioni correnti e reinizializza in base a quelle.

Per una soluzione pulita hai bisogno di un gestore globale di qualche tipo, quindi è più difficile implementarlo. Ad esempio un sistema di eventi o un sistema di messaggistica. È molto utile consentire alle classi di comunicare senza vincoli così forti come aggregazione o composizione e così via.

Con un gestore di eventi globale, OptionsScreenpotrebbe semplicemente lanciare a livello globale un evento di ridisegno che Gameè già stato registrato per l'ascolto.

Generalmente è possibile implementare una classe manager che memorizza eventi e callback ascoltandoli in una mappa hash. Quindi è possibile creare una singola istanza di quel gestore e passarvi i puntatori ai componenti. L'utilizzo del C ++ più recente è abbastanza semplice poiché è possibile utilizzare std::unordered_mapcome hash map e std::functionarchiviare i callback. Esistono diversi approcci che puoi usare come chiave. Ad esempio, è possibile rendere basata sulla stringa del gestore eventi che rende i componenti ancora più indipendenti. In tal caso, useresti std::stringcome chiave nella mappa hash. Personalmente mi piace questo e sicuramente non è un problema di prestazioni, ma la maggior parte dei sistemi di eventi tradizionali funziona con eventi come classi.

Bene, questo è un caso specifico del modello Observer.

Esiste una soluzione che prevede callback. Questo è il modo migliore per farlo se si desidera un accoppiamento lento e penso che sia anche il più pulito. Ciò non coinvolgerà alcun manager globale o singoli.

Fondamentalmente, dovrai avere una sorta di SettingsStore. Lì memorizzi le impostazioni. Quando crei una nuova schermata, avranno bisogno di un puntatore al negozio. In questo caso OptionsScreenmodificherà alcuni dei valori delle impostazioni stesse. Nel caso in GameScreencui li leggerà e basta. Quindi, nel tuo gioco creeresti solo un'istanza, che verrà passata lungo tutte le schermate che ne richiedono una.

Ora, quella SettingsStoreclasse avrà un elenco di notifiables. Sono classi che implementano una certa ISettingChangedinterfaccia. L'interfaccia sarebbe semplice e contiene il seguente metodo:

void settingChanged(std::string setting);

Quindi nella tua schermata implementerai la logica per ogni impostazione che ti interessa. Quindi, aggiungere se stessi al negozio da notificare: store->notifyOnChange(this);. Quando si modifica un'impostazione, il callback viene chiamato con il nome dell'impostazione. Il nuovo valore di impostazione può quindi essere recuperato da SettingsStore.

Ora, questo può essere ulteriormente aumentato con le seguenti idee:

• Utilizzare una classe che memorizza le stringhe delle impostazioni - potrebbe essere anche la SettingsStore(stringhe const) al fine di impedire il copia-incolla delle stringhe in giro.
• Ancora meglio, invece di una stringa, usa un enum per specificare quali impostazioni hai
• È anche possibile specificare i valori vecchi e nuovi come argomenti nel callback, ma sarebbe più contorto, dato che si possono avere valori stringa o int o quant'altro. Tocca a voi.

Leggi le tue impostazioni da un file in variabili. Tieni traccia del tuo Screen Manager se la schermata da cui era appena arrivata era la schermata Opzioni e, se lo fosse, ricarica le tue impostazioni dalle variabili. Quando l'utente esce dal gioco, riscrivi le impostazioni nelle variabili nel file.