[JAVA]: Realizzazione progetto "Game of Life"

[Blizzard86]

Ciao a tutti
Chiedo scusa per il titolo che da regolamento non può essere ammesso, ma non sono riuscito a trovarne uno migliore visto che ho bisogno di un "aiuto generale".
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? :sofico: ).

Betto.

[alka]

Il titolo direi che va bene, in quanto mi pare che il nome del progetto - probabilmente derivante dall'algoritmo implementato - sia abbastanza conosciuto, visto che ne esiste una definizione anche su Wikipedia.

Si suppone quindi che, qualora un utente volesse cercare informazioni su questo algoritmo/gioco, lo faccia usando il nome come parola chiave.

Ciao e buona prosecuzione!

[Magnaccio]

Originariamente inviato da Blizzard86
Ciao a tutti
Chiedo scusa per il titolo che da regolamento non può essere ammesso, ma non sono riuscito a trovarne uno migliore visto che ho bisogno di un "aiuto generale".
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? :sofico: ).

Betto.

Prentendi di fare questo gioco leggendo qualche guida in java? Per implementare questo gioco, senza offessa, ci vuole un po più di una semplice infarinatura. Ad esempio, per la riproduzione delle cellule bisogna usare l'ereditarietà. Il progetto, visto interamente, risulta di una discreta complessità. Poi, tu le interfacce grafiche le hai mai usate? Certo non sono difficili, ma se non hai mai avuto a che fare con Container, JPanel ecc risulterà un po difficile iniziare direttamente con questo gioco.
Ciao

[Blizzard86]

Non importa, mi arrangio con le conoscenze che ho e imparando strada facendo

Questo è il "motore" del gioco. Eseguendolo sullo schermo compariranno due matrici.
La prima rappresenta una matrice i cui valori sono stati messi a random.
La seconda rappresenta la sua "evoluzione" stando alle regole del gioco descritte nel mio primo post (faccio notare che a differenza delle regole ufficiali una cellula con un solo vicino NON muore di isolamento, ma mantiene il suo stato invariato).
Devo ancora aggiungere commenti e correggere alcune cosette, cmq non ci sono errori:

public class Griglia {
	private int rig, col;
	private boolean[][] A;
	
	public Griglia(int rig, int col) {
		this.rig=rig;
		this.col=col;
		A = new boolean[rig][col];
	}
	
	
	public void pulisci(){
		int i,j;
		for(i=0;i<rig;i++)
			for(j=0;j<col;j++)
				A[i][j]=false;
	}
	
	
	public void casuale(){
		double spia;
		int i,j;
		for(i=0;i<rig;i++)
			for(j=0;j<col;j++) {
				spia = Math.random();
				A[i][j] = spia < 0.5;
			}
	}
	
	
	public void scriviElemento(int x, int y, boolean vivo){
		A[x][y] = vivo;
	}
	
	
	public void proxgen() {
		
		boolean[][] B = new boolean[rig][col];
		int i,j;
		for(i=0;i<rig;i++){
			for(j=0;j<col;j++)
				B[i][j] = verifica(i,j);
		}
		A=B;
	}
		
		
	public boolean verifica(int x, int y) {
		int vive=0;
		int destra = (y >= col-1) ? 0 : y+1;
		int sinistra = (y <= 0) ? col-1 : y-1;
		int alto = (x <= 0) ? rig-1 : x-1;
		int basso = (x >= rig-1) ? 0 : x+1;
		
		if(A[alto][y]) vive++;
		if(A[alto][sinistra]) vive++;
		if(A[x][sinistra]) vive++;
		if(A[basso][sinistra]) vive++;
		if(A[basso][y]) vive++;
		if(A[basso][destra]) vive++;
		if(A[x][destra]) vive++;
		if(A[alto][destra]) vive++;
		
		if(vive>=4 || vive<=0)
			return false;
		if(vive==3)
			return true;
		else
			return A[x][y];		
	}
	
	
	public void stampa(){
		int i,j;
		for(i=0;i<rig;i++) {
			for(j=0;j<col;j++) {
				if(A[i][j]) System.out.print("1 ");
				else System.out.print("0 ");
			}
			System.out.println();
		}				
		
	}
	
	public boolean leggiElemento(int x, int y) {
		return A[x][y];
	}
	
	
	

}

public class collaudo {
    public static void main(String[] args) {
    	Griglia mtx = new Griglia(10,10);
    	mtx.casuale();
    	mtx.stampa();
    	mtx.proxgen();
    	System.out.println();
    	mtx.stampa();
    }
}

A presto per eventuali aggiornamenti, soprattutto per quanto riguarda la GUI