gioco "Campo Minato"

[GianniMal]

Devo sviluppare il famoso gioco campo minato senza alcuna grafica.
L'eserzio che devo fare mi fa sviluppare man mano i metodi che mi servono per poter alla fine simulare una partita.
Ho crato una classe CampoMinato.java descritta di seguito:

public class CampoMinato {
	
    private int[][] matr;  // matrice che rappresenta il campo
    private int righe;  // numero delle righe 
    private int colonne;  // numero delle colonne 
    private int mine;   // numero delle mine
    private int celleScoperte;   // numero delle cellescoperte 
    
    private static final int NONSC = -1;  // si puo' scegliere un qualunque valore k<0
    private static final int MINA = -2;    

    private static char NONSC_CHAR = '-';    // carattere per rappresentare una cella non scoperta
    private static char MINA_CHAR = '*';     // carattere per rappresentare una cella con mina
    
    public CampoMinato(int r, int c){
    	matr = new int[r][c];
    	for(int i=0;i<matr.length;i++)
    		for(int j=0;j<matr.length;j++)
    			matr[i][j] = NONSC;
    	righe = r;
    	colonne = c;
    }
    
    public CampoMinato(int dim){
    	this(dim,dim);
    }
    
    public int getRighe(){
    	return righe;
    }
    
    public int getColonne(){
    	return colonne;
    }
    
    public int getMine(){
    	return mine;
    }
    
    public int getCelleScoperte(){
    	for(int i=0;i<righe;i++){
    		for(int j=0;j<colonne;j++){
    			if(matr[i][j] == NONSC_CHAR)
    				celleScoperte++;
    		}
    	}
    	return celleScoperte;
    }
    
    public int getCelleDaScoprire(){
    	int celleDaScoprire = (righe * colonne) - getCelleScoperte();
    	return celleDaScoprire;
    }
    
    public static void setMinaChar(char ch){
    	MINA_CHAR = ch;
    }
    
    public static void setNonscChar(char ch){
    	NONSC_CHAR = ch;
    }
    
    private void stampa(char cMina){
    	
        MINA_CHAR = cMina;	
        //prima riga
        System.out.print("  ");
        for (int i=0; i<colonne; i++) {
          System.out.printf("%3d", i);
        }
        System.out.println();

        //righe successive
        for (int j=0; j<matr.length; j++) {
        	System.out.printf("%2d", j);
          for (int g=0; g<matr[0].length; g++) {
            if (matr[j][g] == MINA){
            	System.out.printf(" %2c", MINA_CHAR);
            }
            else {
            	System.out.printf(" %2c", NONSC_CHAR);
            }
          }
          System.out.println();
        }
        
    }
    
    public void stampaSenzaMine(){
		stampa(NONSC_CHAR);
	}
	
 	public void stampaTutto(){
		stampa(MINA_CHAR);
	}
 	
 	public boolean inCampo(int r, int c){
 		if(r<=this.righe && c<=this.colonne)
 			return true;
 		return false;
 	}
 	
 	public void mettiMina(int r, int c){
 		if((r<=this.righe && c<=this.colonne) && (MINA_CHAR == '*')){
 			matr[r][c] = MINA;	
 			mine++;	
 		}
 	}
 	
 	public boolean contieneMina(int r, int c){
 		if((r<=this.righe && c<=this.colonne) && (matr[r][c] == MINA))
 			return true;
 		return false;
 	}
}

il problema che ho riscontrato fin ora è che non riesco ad implementare il metodo getCelleScoperte() perchè mi restituisce sempre 0. Ed ovviamente anche il metodo che segue mi restituisce un numero sbagliato.
Dove sbaglio?

Questa è la stampa del campo anche se nn si vede bene cmq è allineata

    0  1  2  3  4  5  6  7  8  9 10 11 12 13 14
 0  *  -  -  -  -  -  -  *  -  *  -  -  -  -  -
 1  -  -  -  *  *  -  -  *  -  *  -  -  -  -  *
 2  -  -  -  -  -  *  -  -  -  *  -  *  -  -  -
 3  -  -  -  -  -  *  -  -  -  -  -  -  -  -  -
 4  *  *  *  -  -  -  -  *  -  *  -  -  -  *  -
 5  *  -  *  -  -  -  -  *  -  -  -  -  *  -  -
 6  *  *  *  -  -  -  *  *  *  *  -  -  -  -  -
 7  -  -  -  -  -  -  -  -  -  -  -  -  -  -  *
 8  -  *  -  *  -  *  -  -  -  *  -  -  -  -  -
 9  *  -  -  -  -  -  -  -  -  -  -  *  -  -  -
10  -  -  *  -  *  -  -  *  -  -  -  -  -  -  *
11  -  -  -  -  -  -  -  -  -  *  -  -  -  -  -

[lolide]

Perchè usi una matrice di int?

[GianniMal]

Perchè mi viene chiesto dalla traccia dell'esercizio...

[valia]

perché tu hai una matrice che riempi con un valore e poi controlli per un altro valore, cioè

 public CampoMinato(int r, int c){
    	matr = new int[r][c];
    	for(int i=0;i<matr.length;i++)
    		for(int j=0;j<matr.length;j++)
    			matr[i][j] = NONSC;
    	righe = r;
    	colonne = c;
    }

ma poi

    public int getCelleScoperte(){
    	for(int i=0;i<righe;i++){
    		for(int j=0;j<colonne;j++){
    			if(matr[i][j] == NONSC_CHAR)
    				celleScoperte++;
    		}
    	}
    	return celleScoperte;
    }

se prima assegni il valore di NOSC e poi controlli con NONSC_CHAR non vai lontano.
il carattere "-" lo visualizzi a video indipendentemente da come sotto rappresenti il dato (questo vuole dire separare la rappresentazione effettiva delle informazioni dalla rappresentazione grafica).

[GianniMal]

Grazie...
però ragionando se le celle sono in totale 180 ed ho 41 mine le celle da scoprire devono essere 180 - 41 = 139 celle o no???
modificando il metodo di prima secondo la tua indicazione mi dava 108 scelle scoperte e 72 da scoprire che nn mi sembra esatto.

public int getCelleScoperte(){
        int a = 0;
    	for(int i=0;i<righe;i++){
    		for(int j=0;j<colonne;j++){
    			if(matr[i][j] == NONSC_CHAR)
    				a++;
    		}
    	}
    	return a;
}
    
public int getCelleDaScoprire(){
    	int celleDaScoprire = (righe * colonne) - mine;
    	return celleDaScoprire;
}

poi ho un altro problema quello di mettere i numeri vicino alle celle e verificare quante mine ci sono nelle celle adiacenti a quella cliccata...mi spiego meglio:
Le celle non scoperte sono quelle il cui valore e' NONSC (costante definita
da un campo statico della classe).

- private int contaMine(int r, int c)

Si assume che (r,c) sia una cella che non contiene la mina.
Il metodo restituisce il numero di mine nelle celle adiacenti a (r,c).

Usare il metodo contieneMina che controlla che (r,c) sia una cella del campo.

Notare che il metodo contaMine e' privato, quindi non e' utilizzabile fuori dalla classe.

- public void scopriCella(int r, int c)

Se (r,c) e' una cella del campo che non e' ancora stata scoperta e (r,c) non contiene la mina
scopre la cella (r,c) ponendo in essa il numero delle mine nelle celle adiacenti.
Altrimenti il metodo non compie alcuna operazione.
ho provato ad implementare il primo metodo:

private int contaMine(int r, int c){
 	int m = 0;
 	if(this.contieneMina(r,c) == false)
 		for(int i=r-1;i<r+1;i++){
 			for(int j=c-1;j<c+1;j++){
 				if(matr[i][j] == MINA_CHAR)
 					m++;
 			}
 		}
 	return m;
 }
 	
public int numMine(int r, int c){
	int n = this.contaMine(r, c);
	return n;
}

ma non funziona bene...praticamente ho ragionato così:
se prendo la cella (4,12) devo verificare se ci sono le mine nelle celle
(3,11),(3,12),(3,13)...(4,11),(4,13)...(5,11),(5,1 2),(5,13) e questo dovrebbero fare i 2 cicli for ma nn va

[valia]

allora io ti ho corretto l'errore lampante, per sapere quello che dici tu dovrei debuggare il tuo codice (oltretutto non è un errore localizzato ma generico).
Ti posso consigliare di rivedere l'algoritmo con cui inizializzi le mine (cioè con cui dici quante mine piazzi nel quadro).

Ma è un esercizio per la scuola? ci sono tanti limiti (statici), non so.
Beh ti dò un indizio: per ogni cella devi fare:

1. controlla se sei dentro il quadro
2. cella scoperta non fai niente
3. cella non scoperta controlla che non sia mina
controlla quante mine intorno hai (facendo un calcolo con l'intorno, in tutto 8 mine e contando quante celle adiacenti sono mine)
4. stampa il numero esatto

[GianniMal]

E' un esercizio di laboratorio di università...
Allora non ho capito bene come verificare se una cella è stata scoperta o meno per poi controllare il num di mine ecc ecc...

nel metodo contaMine faccio if() per controllare se c'è una mina e basta, quindi implicitamente mi considero dentro il campo...però nn capisco cm devo controllare i primi 2 punti

[valia]

ecco che era un esercizio.
Ti chiedo, se tu hai una matrice 9x9, le righe vanno da 0 a 8 e le colonne pure. Se io ti dò il punto (10, 5) sono fuori dalla matrice, così come se ricevi (5,-2)

queste dovresti controllarle in maniera banale (che non sto qui a scriverti).

Ad ogni cella hai associato uno stato, che può essere scoperto, non scoperto ecc....ma devi ricordarti dove hai posizionato le mine, sicuramente avrai una matrice delle stesse dimensioni in cui hai 2 stati diversi, tipo mina/non mina quindi non fai altro che controllare l'altro.

questa è la prima idea che mi viene in mente su due piedi

[GianniMal]

i campi ed il costruttore della classe sono:

private int[][] matr;  // matrice che rappresenta il campo
private int righe;  // numero delle righe 
private int colonne;  // numero delle colonne 
private int mine;   // numero delle mine
private int celleScoperte;   // numero delle cellescoperte 
   
private static final int NONSC = -1;  // si puo' scegliere un qualunque valore k<0
private static final int MINA = -2;    

private static char NONSC_CHAR = '-';    // carattere per rappresentare una cella non scoperta
private static char MINA_CHAR = '*';     // carattere per rappresentare una cella con mina
    
public CampoMinato(int r, int c){
        matr = new int[r][c];
    	for(int i=0;i<matr.length;i++)
    		for(int j=0;j<matr.length;j++)
    			matr[i][j] = NONSC;
    	righe = r;
    	colonne = c;
}

quindi inizialmente tutte le celle sono NONSC.
il controllo se mi trovo nel campo o meno l'ho capito, bastano degli if su r e c...
poi...

// inserisco la mina
public void mettiMina(int r, int c){
 	if((r<=this.righe && c<=this.colonne) && (MINA_CHAR == '*')){
 		matr[r][c] = MINA;	
 		mine++;	
 	}
 }

public boolean contieneMina(int r, int c){
 	if((r<=this.righe && c<=this.colonne) && (matr[r][c] == MINA))
 		return true;
 	return false;
 }

questo metodo verifica se c'è la mina o meno...forse sbaglio a risponderti ma ho solo una matrice popolata di mine

[valia]

non sbagli, ma ti chiedo per quale motivo.
Allora riguardo al controllo io ti ho fatto 2 esempi calzanti di proposito

private boolean isOk(int riga, int colonna){
  if (riga <= 0 || riga >= righe ) return false; 
  if (colonna <= 0 || colonna >= colonne ) return false; 
return true;
}

questo verifica se hai preso un intorno valido.

un altro metodo ti tiene conto se è una mina oppure no (controllando nella matrice delle mine o nell'elenco delle mine dove vuoi tu)

Poi per organizzarti il lavoro hai 2 scelte: una matrice che può prendere diversi stati

1. non scoperta
2. scoperta
3. mina non scoperta
4. mina scoperta

oppure fare due cose, tenerti una matrice in cui hai solo 2 stati, scoperto, non scoperto e un'altra matrice che tiene conto di dove sono le mine.
Per scoperto puoi tenere qualsiasi valore diverso da non scoperto (tenuto conto che butti ad esempio il numero di mine nell'intorno).

Io ti sto dando la logica che seguirei io senza complicarmi troppo la vita, non è detto che sia giusta o che sia l'unica, se hai altre idee scrivile per carità. Il confronto va sempre bene