Discussione AI gioco RTS

Ho un progetto per creare un gioco di strategia in tempo reale da zero. Sono ancora nella fase di pianificazione iniziale, ma ho programmato un po 'per vedere la meccanica.

So programmare. Ho anche una buona idea di come strutturerò le classi di gioco e l'intelligenza artificiale basata su regole per computer player.

Voglio sviluppare Dottrine, che daranno un comportamento specifico a un'unità specifica (ma che possono essere utilizzate su più unità contemporaneamente), come Scout, Segui la Missione, mantieni la Posizione (attacca qualsiasi nemico in avvicinamento o ritirati se sopraffatto) , eccetera...

Le dottrine si applicheranno solo alle unità, quindi avranno una prospettiva unitaria e non saranno consapevoli dell'intera sitatuazione della mappa.

L'intelligenza artificiale del computer analizzerà l'intera mappa visibile e deciderà su quale soctrina assegnare ciascuna unità in base a un altro insieme di regole.

Lo sto facendo in C # con OpenGL.

Per ora, non ho molto, solo alcune cose nei test prima di iniziare la mia concezione principale. Ho un ciclo di gioco in cui avverrà tutta l'elaborazione del gioco (dove chiamerò l'aggiornamento mouvement, combattimento, rendering, ecc., Uno dopo l'altro), viene chiamato molto spesso se l'evento Application.Idle.

Ora mi stavo chiedendo. Dal momento che ci saranno molte cose da elaborare nel gameloop, l'AI del computer e le Unità dovrebbero selezionare le loro azioni in quel ciclo o sarà troppo lento?

Se voglio che tutte le cose siano simultanee, dovrei creare un thread separato per l'IA del computer? O anche un thread separato per ogni unità?

Non ho molta esperienza con il multi-threading. Quale sarebbe l'approccio migliore per questo?

Che cosa significa "da zero"? Puoi usare qualcosa come XNA invece con DirectX?

Dovresti eseguire il rendering di qualcosa tra 30 e 60 fotogrammi al secondo per avere un movimento fluido. Non c'è davvero bisogno di avere più fps.

Se rendering + la logica richiede meno dei 16ms che ti dà 60fps, allora non dovrebbe essere necessario un thread AI.

Se non avrai abbastanza tempo tra il rendering dei frame, dovrai pensare attentamente a cosa deve essere aggiornato ogni frame e cosa no.

Immagino che la parte delle "dottrine" dovrebbe essere il più semplice ed efficiente possibile in modo che possa essere aggiornata ogni frame, almeno per le unità visibili e altre unità vicine. Le unità che non influenzano direttamente le unità visibili possono essere aggiornate con minore frequenza (e, di conseguenza, con un delta T maggiore).

L'IA principale ha più lavoro da eseguire, in quanto deve elaborare tutte le unità sulla mappa e capire una strategia, quindi dovrebbe richiedere la maggior parte del tempo di calcolo. È il primo candidato per un thread separato.

Nota che potresti voler aggiungere un altro livello tra i due, qualcosa come un'intelligenza artificiale a livello di squadra. Fondamentalmente, l'IA di ogni unità dovrebbe assicurarsi che l'unità risponda "in modo intelligente" alla situazione immediata, quindi deve essere veloce e reattiva. L'intelligenza artificiale della squadra è responsabile delle azioni "intelligenti" di diverse unità, distribuite su diversi secondi, come trovare un ponte se la squadra ha bisogno di attraversare un fiume. E l'IA principale dovrebbe dirigere le azioni di molte squadre per un lungo periodo di tempo.

Soprattutto se non hai molta esperienza, non fare il threading se non è necessario. Questo sarà complicato in quanto è senza un onere aggiuntivo. Puoi imparare il multithreading come progetto separato o come estensione di questo una volta che è in uno stato funzionante . In bocca al lupo!

Avere un thread separato per AI. Ma non per ogni unità poiché consumerebbe troppe risorse del sistema operativo e la sincronizzazione sarebbe un incubo.

Assicurati che il thread AI trovi un'opportunità da eseguire. Non prenderlo alla leggera, se il thread principale fa troppe cose, potrebbe non trovare mai questa opportunità! Se dai semplicemente maggiore priorità al thread AI, il gioco non risponde, il che è inaccettabile.

Quindi, seleziona attentamente i punti di sincronizzazione e / o gli eventi nel loop principale e consenti al thread AI di completare i suoi calcoli mentre il thread principale si interrompe. Ad esempio, se l'unità utente vede un'altra unità AI, sincronizzala, in modo che l'unità veda un'unità aggiornata viceversa.

Sto anche lavorando a un gioco RTS da zero. Non l'ho ancora provato, ma la mia idea era quella di eseguire l'unità AI nel ciclo di gioco principale per tutte le unità che sono attualmente visibili al giocatore (nella parte dello schermo che il giocatore vede effettivamente o vicino al bordo dello schermo ), poiché è più probabile che il giocatore sposti un po 'lo schermo.

Le altre unità sono controllate in un thread separato e ho due priorità: 1. Unità che si trovano in punti che sono visibili all'utente se sposta la schermata lì. 2. Unità che si trovano in aree nascoste (non ancora esplorate e "nebbia di guerra").

Per le unità con la priorità dei secondi, eseguo il loop meno spesso e compenso spostandole in modo retrospettivo quando necessario.

Che tu abbia bisogno del multithreading o meno, potrebbe essere una buona idea preparare l'IA al multithreading.

Il tuo thread principale aggiorna il mondo, spunta la fisica, ecc., Quindi popola una struttura di dati che rappresenta la visione del mondo dell'IA: posizione delle unità, stato delle risorse, ecc. Questa struttura di dati memorizzerebbe nella cache i sistemi principali, piuttosto non limitarti a trattenerli. Questo a volte viene chiamato punto di sincronizzazione.

Passa questa struttura di dati all'intelligenza artificiale e consenti solo di ragionare sul contenuto di questa struttura. Se ritieni che l'IA richieda ulteriori informazioni, aggiungila alla struttura. Nel linguaggio dell'IA questo è spesso chiamato lavagna ma potrebbe anche essere definito cache. Non lasciare mai che l'IA scriva nella cache, l'output dovrebbe arrivare attraverso una struttura di dati separata.

Questa configurazione ti consentirà di parallelizzare il gioco perché l'IA non ha più alcuna dipendenza diretta dagli altri sistemi di gioco. Questi sistemi non devono essere sicuri per i thread e non si dovrebbero mai ottenere blocchi. Puoi eseguire in modo sicuro il renderer o qualcosa mentre l'IA si allontana.

Come vantaggio secondario, in futuro è possibile estendere la cache decadendo nel tempo le informazioni ottenute dagli altri sistemi, simulando l'incertezza anziché la conoscenza esatta.