[Java]Game Of Life, aiutatemi a progettarlo

[:.Blizzard.:]

Ciao a tutti
Vi espongo subito il mio problema: il 14 Settembre devo presentare un progetto-esame in Java e io ho scelto di fare Game of Life ( http://www.bitstorm.org/gameoflife/ ). C'è solo un problemone ... ovvero io non ho frequentato il corso per motivi che non stò qui a spiegarvi. Ho letto un pò le linee guida del Java, ma visto che il tempo stringe ho deciso di aprire questo topic nella speranza di ricevere un vostro aiuto. Non vi chiedo assolutamente di scrivermi le righe di codice, al massimo di correggere quelle che farò io e di darmi alcuni consigli.
Detto questo, partiamo con la descrizione del progetto. La consegna è la seguente:



Life applet: scrivere un'applet che rappresenti l'andamento della vita di una popolazione di individui monocellulari su una matrice in un universo toroidale, (rappresentato da una matrice A di dimensione m x n in cui gli elementi della prima riga si considerano adiacenti a quelli dell'ultima riga, e quelli della prima colonna adiacenti all'ultima) vivono microorganismi cellulari booleani (A[i,j]=true rappresenta che "esiste una cellula nella posizione i,j"). Inizialmente gli organismi possono essere casualmente inseriti dall'utente tramite mouse.
La vita della matrice si evolve di istante in istante secondo le seguenti regole:

1- Sesso ternario. Le cellule si riproducono attraverso una sessualità ternaria: se una casella vuota all'istante i è circondata ESATTAMENTE da 3 cellule, all'istante i+1 verrà generata una nuova cellula in tale casella.

2- Morte per isolamento. Se una cellula non è circondata da alcuna altra cellula, all'istante successivo essa muore per isolamento e quindi la corrispondente casella sarà vuota in tale istante.

3- Morte per sovrappopolazione. Se una cellula è circondata da 4 o più cellule essa muore per sovrappopolazione all'istante successivo.

Si considerino adiacenti alla casella le 8 caselle confinanti, anche in diagonale.
L'utente deve poter scegliere tramite un menu la dimensione della matrice.


Ora, se avete guardato il link postato a inizio topic potete notare che quel progetto rispecchia in gran parte quella che dovrà essere la mia consegna. Ovviamente NON ho intenzione di copiare alcuna riga di sorgente, anche perchè dovrò discutere in sede di esame come ho costruito il tutto.

Detto questo e fatte le dovute considerazioni nonchè ringraziamenti per essere arrivati a leggere fin quà, direi che posso iniziare con la prima domanda: come organizzare il tutto?


Io avevo pensato di dividere il progetto in due package, uno per la gestione della parte grafica e uno riguardante il motore del programma. Quindi, a grandi linee:

1) Package Motore

La logica del gioco suggerisce l'utilizzo di due matrici booleane (lasciando per adesso da parte la loro grandezza). Inizialmente l'oggetto matrice A conterrà solo 0 (ovvero il campo sarà privo di cellule) e posso scrivere una procedura che riempia a random le caselle. Una volta che ho una matrice con delle cellule posso scrivere una procedura che legga casella per casella e tramite alcuni if mi scriva in una seconda matrice B quali sarà lo stato successivo. La matrice A poi verrà azzerata e il ruolo da essa svolto precedentemente sarà ricoperto dalla matrice B.

2) Package Grafica

Il risvolto grafico sarà rappresentato da un pannello contenente m x n rettangolini che verranno riempiti o meno a seconda degli 0 e degli 1.


Per ora ho pensato a queste cose. Conto sul vostro aiuto e sulle vostre idee e vi chiedo un attimo di pazienza e del vostro tempo nell'aiutarmi.
Un grazie in anticipo a tutti colore replyeranno (vi stò facendo abbastanza pena? ).

Betto.

[thebol]

potresti risparmiarti una matrice in questa maniera:

1)la matrice non la fai di booleani, ma la fai di oggetti. Ad esempio l'oggetto cellula. L'oggetto conterrà il booleano.


2)usi il pattern command sull'oggetto cellula. Praticamente ti scorri una volta la matrice, analizzi ogni cellula e assegni a ogni cellula l'azione da fare(rappresentata da una classe)(cancellare/rimanere/nascere).
Poi ti riscorri la matrice e esegui le varie azioni(resettandole).

Questo vuol dire scorrere 2 volte la matrice, ma guadagni spazio.

[:.Blizzard.:]

Originariamente inviato da thebol

potresti risparmiarti una matrice in questa maniera:

1)la matrice non la fai di booleani, ma la fai di oggetti. Ad esempio l'oggetto cellula. L'oggetto conterrà il booleano.


2)usi il pattern command sull'oggetto cellula. Praticamente ti scorri una volta la matrice, analizzi ogni cellula e assegni a ogni cellula l'azione da fare(rappresentata da una classe)(cancellare/rimanere/nascere).
Poi ti riscorri la matrice e esegui le varie azioni(resettandole).

Questo vuol dire scorrere 2 volte la matrice, ma guadagni spazio.

Quella della matrice di oggetti era un'idea che avevo inizialmente. Il problema è: conviene? Non sarebbe meno costoso creare una semplice matrice di booleani?

[thebol]

Originariamente inviato da :.Blizzard.:

Quella della matrice di oggetti era un'idea che avevo inizialmente. Il problema è: conviene? Non sarebbe meno costoso creare una semplice matrice di booleani?

da un punto di vista "minimalista" conviene lavorare con oggetti primitivo. Ma è meno maleabile, e il costo per realizzare un oggetto e quasi insignificante.

In piu creando un oggetto, puoi modificarlo.

Ad esempio a un oggetto puoi assegnare uno stato(ce o non cè la cellula e delle azioni), o un comportamento(il pattern command di prima).

In questa maniera riescia a separare le varie azioni che puoi fare su una cella in diverse classi

[:.Blizzard.:]

Ok ... cmq ... per ora stò seguendo un'altra strada e ho un problema:

Data una matrice A[][] di tipo boolean, devo riempirla a random con valori true e false. Tralasciando il discorso dell'usare due cicli annidati, esiste nella libreria java qualche procedura che esegua una simile operazione?

[Barbalbero]

Originariamente inviato da thebol

Questo vuol dire scorrere 2 volte la matrice, ma guadagni spazio.

In ogni caso dovresti scorrere una volta entrambe le matrici, quindi l'idea di thebol, a mio avviso, è molto valida, ed è più elegante.

[Barbalbero]

Originariamente inviato da :.Blizzard.:

Data una matrice A[][] di tipo boolean, devo riempirla a random con valori true e false. Tralasciando il discorso dell'usare due cicli annidati, esiste nella libreria java qualche procedura che esegua una simile operazione?

Secondo me nel tempo che cerchi questa fantomatica procedura, hai già scritto dieci volte i due cicli for annidati!!!

[AngeL)]

se vi serve uno spunto ho trovato il codice

Spoiler:

http://www.bitstorm.org/gameoflife/code/

[:.Blizzard.:]

Originariamente inviato da AngeL)

se vi serve uno spunto ho trovato il codice

Ti ringrazio, l'ho osservato attentamente ed è troppo complicato per i miei gusti e per le kmie capacità. Ad ogni modo ho appena terminato la classe Griglia. Il gioco è perfettamente funzionante su carta ... nel senso che su console stampo prima una matrice A con valori random, poi un'altra matrice che rappresenta la sua evoluzione secondo le regole del gioco e ... funziona!
Devo ancora aggiustare alcune cosette e poi inizio a progettare la gui.

[AngeL)]

complimenti!

[:.Blizzard.:]

Eccomi di nuovo qua. Il progetto ormai volge verso l'ultima fase di completamento ... solo che ho bisogno di un aiuto adesso.
Mancano tre cose da completare.

1- Possibilità di creare nuove cellule cliccando con il mouse sulla relativa casella.
2- Creare un tasto "Start/Stop" che una volta cliccato crei la nuova generazione di cellule a ciclo infinito fino a quando non lo riclikko.
3- Creare una slide bar che regoli la velocità con cui viene rappresentata la nuova generazione

Ora come ora l'unica cosa che sono riuscito a fare è il tasto "Step" che mi calcola direttamente una nuova generazione ogni volta che clikko (dopo aver generato con un tasto "Casuale" una colonia di cellule random visto che per ora nn è possibile inserirla tramite mouse).
Avete qualche dritta da darmi?

[:.Blizzard.:]

nessuno nessuno?