Conway's Game of Life C #

Invece di creare un array temporaneo da utilizzare quando si aggiorna la griglia di gioco, è possibile ottenere un algoritmo più semplice e una velocità migliore se si creano 2 griglie e si riempie una griglia utilizzando i dati dell'altro. In questo modo non devi preoccuparti di non sovrascrivere i dati correnti nel prossimo passaggio.

vale a dire. le griglie, a turno, vengono aggiornate;

1. riempi la griglia1 con l'impostazione iniziale
2. aggiorna il display usando grid1
3. crea griglia2 utilizzando i dati in grid1
4. scambia griglia1 e griglia2
5. vai al passaggio 2

La tua proposta suona bene; non vincerai alcun record di velocità, ma imparerai sicuramente come costruire un'implementazione Life di base.

Una volta che tutto funziona sfruttando la semplice implementazione, prendi in considerazione l'implementazione dell'algoritmo di Gosper. È possibile calcolare miliardi di generazioni al secondo su schede che sono miliardi di volte più grandi di quanto si possa pensare nella memoria; utilizza tecniche di programmazione funzionale per ottenere un'immensa compressione di tempo e spazio. Imparerai molto sia sulla grafica che sulle strutture dati.

In realtà l'ho fatto io stesso in C #, e l'ho fatto praticamente nello stesso modo in cui lo descrivi. Non era molto veloce, ma essenzialmente avevo una serie di celle e ogni volta creavo una matrice temporanea e la popolava in base alla matrice corrente, poi la copiavo nella nuova, una specie di doppio buffering.

Esistono algoritmi più veloci per il gioco della vita che passare attraverso ciascuna cella uno per uno che può dare risultati quasi istantanei, ma non ho studiato l'argomento abbastanza per dirti qualcosa su di loro.

Ci proverei, e so che questo è in qualche modo possibile in .NET, per posticipare il ridisegno "fisico" della griglia finché a tutte le celle non è stato assegnato il loro nuovo valore. La libreria grafica e l'hardware possono ridisegnare l'intero

Un suggerimento per calcolare la popolazione della nuova cella è di evitare di fare aggiunte per le otto celle circostanti ogni volta. Invece, tieni un contatore e alcune somme per le colonne sinistra e destra quando ti sposti alla prossima cella a destra:

counter = counter - lastLeftSum + newRightSum

Questo ti farà risparmiare un sacco di indicizzazione degli array e calcolo delle addizioni.

Ho anche provato l'idea di partizionare la scheda per evitare il calcolo su ampie aree vuote, ma non è passata attraverso l'implementazione (la complessità esplode). Tuttavia, penso che questo approccio consenta al tuo programma di gestire le schede enormi in modo piacevole. Riesco a vedere alcuni miglioramenti immediati consentiti dal partioning:

1. Consente di memorizzare alcuni modelli comuni per prevedere la situazione della scheda senza calcolo.
2. Elaborazione parallela.

Con un simulatore più veloce, è possibile scoprire una configurazione più interessante.