[JAVA] BeanShell e problema di loop in ricorsione

[EdSoNaRaNtEs]

Salve ragazzi,sno nuovo qui,mi sono appena iscritto.
Dunque,ho realizzato un progettino x l'università,si tratta del gioco Campo Minato in beanshell ed ho un piccolissimo problema (si spera ;P)..
Il programma funziona alla perfezione,o quasi, l'unico problema
è un piccolo bug nella ricorsione, che genera un loop
se si mette come primo input la diagonale in basso a dx( del tipo tabella di dimensione 18, se metto 17 17 mi da questo errore, ho notato che lo fa solo con numeri alti)questo ERRORE è dovuto a beanshell.
Qualcuno potrebbe aiutarmi a risolvere questo piccolo problema?Sono giorni che ci lavoro ma nn trovo la soluzione,tra l'altro fra due giorni devo consegnarlo quindi sn molto incasinato!
Vi posto il codice del programma che ho fatto..



Aspetto vostre notizie.
Grazie in anticipo.

Pelè

[EdSoNaRaNtEs]

ecco il codice,nn riesco ad inserirlo come allegato!

//Campominato.bsh
import java.util.Scanner;
import java.io.*;
source("start.bsh");
pannello();

//campoRandom.bsh
/*campoRandom
questo file permette di creare una tabella di gioco,
nello specifico crea una matrice di interi con un numero di bombe pari alla dimensione
del file, tutto generato in maniera casuale
*/
import java.util.Random;
private int dim;
private int[][] matrix;
//metodo principale
public campoRandom(int n)
{
dim=n;
matrix=new int[dim][dim];
azzeramatrix();
minaRandom();

}
//metodo che inizializza a 0 tutta la matrice
public void azzeramatrix()
{
for( int i=0; i<dim;i++)
for(int j=0;j<dim;j++)
matrix[i][j]=0;
}
//metodo che
public void minaRandom()
{
Random rand=new Random();
int nminex=0,nminey=0,incremento=0;
do
{

do
{
nminex=rand.nextInt(dim);
nminey=rand.nextInt(dim);
//System.out.println( "x: "+nminex+" y: "+nminey);
}while(matrix[nminex][nminey]==-1);
matrix[nminex][nminey]=-1;
incremento++;
}while(incremento<dim);

}
public int[][] tabella()
{
return matrix;
}
public void stampa()
{
for(int i=0;i<dim;i++)
{
for(int j=0;j<dim;j++)
{
System.out.print(matrix[i][j]+" ");
}
System.out.println();
}
}


//controllamappa.bsh

/*controllomappa.bsh
questo file contiene i metodi per caricare il campo da un file di tipo testuale
sono stati sviluppati metodi per rilevare la giusta composizione del file testuale
dimodoche sia possibile da utilizzare durante lo svolgimento di una partita
*/
import java.util.Scanner;
import java.io.*;
private String file;
private Scanner scan;
private int[][] matrix;
private int n=0,bomba=0;
/*controllomappa
metodo principale della classe che permette di utilizzare in maniera
logica e appropriata tutti i metodi del file per il giusto svolgimento
del programma
*/
public controllomappa()throws Exception
{ /*ciclo che permette di caricare il file; nel caso in cui
la condizione non si verifichi, viene richiesto l'inserimento del nome del file
il ciclo verifica che il numero di bombe trovate all'interno del file, coincida
con le dimensioni del file.
*/
do
{
nomefile();
LeggiFile();
}while(bomba!=n);
System.out.println("file caricato con successo!!");
}
/* nomefile()
questo metodo permette attraverso la classe Scanner, di ricevere in input
il nome del file di testo digitato sulla tastiera(new Scanner(System.in))
attraverso il metodo nextLine(); il valore digitato sulla tastiera viene
memorizzato nell'oggetto di tipo Stringa file.
*/
public void nomefile()
{
scan=new Scanner(System.in);
System.out.println("Inserisci il nome del file: ");
file=scan.nextLine();

}
/*LeggiFile
questo metodo è il metodo principale della lettura del file, in quanto gestisce la maggior
parte delle eccezioni ed il modo di cattura dei caratteri del file testuale
e di trasferirli all'interno della matrice di gioco.
è di tipo int e questo comporta alla restituzione di un valore numerico( nel nostro caso il numero di bombe
all'interno del file
*/
public int LeggiFile()throws Exception
{
try
{
Scanner scan=new Scanner(new File(file));
String linea;

/*n
ciclo di lettura del file:
l'oggetto scan rileva la presenza di righe all'interno del file;
appena le righe finiscono scan interrompe il ciclo(condizione scan.hasNextLine())
quando è verificata(true, fa continuare il ciclo while, appena diventa non verificata
false termina il ciclo; questo ciclo ci serve per sapere di quante righe è composto il file testuale,
in quanto ogni volta che viene letta una riga, viene incrementata una variabile di tipo intero
*/
while(scan.hasNextLine())
{ scan.nextLine();
n++;
}
System.out.println("colonne= "+n);
/* viene inizializzato la matrice di tipo intero con dimensione nxn
*/
matrix=new int[n][n];
int j=0;
/*viene ricaricato il file nell'oggetto Scanner,e a questo punto procede
il ciclo di lettura del file
*/
scan=new Scanner(new File(file));
while(scan.hasNextLine())
{
/* questo ciclo for permette di scorrere le colonne della matrice
e di memorizzare dopo verifica il dato all'interno della matrice stessa
nella posizione giusta
*/
for(int a=0;a<n;a++)
{
//nextInt() restituisce l'intero nello dallo scanner
int c=scan.nextInt();
/*con lo switch verifichiamo che ci siano i giusti caratteri
all'interno del file, prima della memorizzazione nella matrice;
se ciò risulta falso, la situazione viene catturata e gestita dall'eccezione
(Exception)
nel caso in cui la variabile intera c restituisca il valore intero -1, viene incrementata
una variabile intera per il conteggio delle bombe:bomba++
*/
switch(c)
{
case 0:matrix[j][a]=c;
break;
case -1:matrix[j][a]=c;
bomba++;
break;
default: throw new Exception("errore carattere non valido");
}
}
//j è l'atra variabile usata come indice all'interno della matrice per scorrerla
// in questo caso serve per scorrere le righe(viene incrementata in fondo al ciclo
// while prima di ricominciare(se il ciclo è ancora verificato)
j++;
}

}catch(IOException e)
{
throw new Exception("Errore file non trovato", e);
}
if(bomba!=n)
System.out.println("Errore numero di bombe non esatto: "+bomba+" n="+n);
return bomba;
}
//metodo banale che stampa il file
public void stampaFile(int[][] m)
{
for(int i=0;i<m.length;i++)
{
for(int j=0;j<m[i].length;j++)
{
System.out.print(m[i][j]+" ");
}
System.out.println();
}
}
//metodo che ritorna il valore della matrice
public int[][] tabella()
{
return matrix;
}

//gioco.bsh

private int [][] tabella;
private int incremento=0;
private int n;
public gioco(int[][] m)
{
tabella=m;
n=tabella.length;
game();
}
private boolean limit(int riga,int colo)
{
boolean result=false;
if(riga>=0&&riga<tabella.length&&colo>=0&&colo<tab ella[riga].length)
result=true;
return result;
}
public void verifica(int riga,int colo,int dirX,int dirY)
{
if(limit(riga+dirX,colo+dirY))
{
if(tabella[riga+dirX][colo+dirY]==-1)
{
incremento++;
if(tabella[riga][colo]!=-1)
tabella[riga][colo]=incremento;
}
}
}
public void game()
{
int[] dirX = {0, 0, 1, -1, 1, -1, 1, -1};
int[] dirY = {-1, 1, 0, 0, -1, -1, 1, 1};
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
{
incremento=0;
for(int h=0;h<8;h++)
verifica(i,j,dirX[h],dirY[h]);
}

}
}
public int[][] returnTab()
{
return tabella;
}

//start.bsh

import java.util.Scanner;
import java.io.*;
source("controllomappa.bsh");
source("campoRandom.bsh");
source("gioco.bsh");
private Scanner scan=new Scanner(System.in);
private int [][] tabs;
private int x,y;
private String [][] vide;
public void pannello()throws Exception
{
char input;
print("*******************\n* campo minato *\n*******************");
print("Vuoi caricare una mappa da un file?? premi il tasto f;\n vuoi una mappa random?? premi r\n a te la scelta: ");
do
{
//scan=new Scanner(System.in);
input=scan.next().charAt(0);
if(input!='r' && input!='f')
print("digitazione sbagliata:\npremi r o f");
}while(input!='r' && input!='f');
if(input=='f')
{
controllomappa();
tabs=tabella();
gioco(tabs);
tabs=returnTab();
print( "verifica tabella");
stampaFile(tabs);
}
if(input=='r')
{
print("scegli la dimensione della tabella");
campoRandom(scan.nextInt());
tabs=tabella();
gioco(tabs);
tabs=returnTab();
print( "verifica tabella");
stampaFile(tabs);
}


print( "Inizia a giocare");
print(tabs.length);
video();
StampaVideo();
coordinate();

}
public void video()
{
int num=tabs.length;
vide=new String[num][num];
for(int i=0;i<vide.length;i++)
for(int j=0;j<vide.length;j++)
vide[i][j]="X";
}
public void coordinate()
{
do
{
do
{
scan=new Scanner(System.in);
String s;
print("inserisci le coordinate");
s=scan.nextLine();
// da sistemare il comando exit
//if(s=="exit")
// System.exit(0);
scan=new Scanner(s);

y=-1;
if(scan.hasNextInt())
x=scan.nextInt();
else
x=-1;
if(scan.hasNextInt())
y=scan.nextInt();
else
y=-1;
if(x<0 || x>=tabs.length && y<0 ||y>=tabs.length)
print("Errore coordinate sbagliate");
}while(x<0 || x>=tabs.length && y<0 ||y>=tabs.length);
//stampa le coordinate digitate
if(vide[x][y]!="X")
print("zona gia scoperta");
}while( vide[x][y]!="X");
print(x+" "+y);
game2();
}
private boolean valid(int riga,int colo)
{
boolean result=false;
if(riga>=0&&riga<tabs.length&&colo>=0&&colo<tabs[riga].length)
if(tabs[riga][colo]!=-1)
result=true;
return result;
}
public boolean found(int riga,int colo)
{
boolean done=false;
if(valid(riga,colo))
{
if (tabs[riga][colo]==0)
{
vide[riga][colo]=""+tabs[riga][colo];
tabs[riga][colo]=-2;

done=found(riga+1,colo);
if(!done)
done=found(riga,colo+1);

if(!done)
done=found(riga+1,colo+1);

if(!done)
done=found(riga-1,colo+1);

if(!done)
done=found(riga-1,colo-1);

if(!done)
done=found(riga,colo-1);

if(!done)
done=found(riga+1,colo-1);

if(!done)
done=found(riga-1,colo);

}
else
{
if (tabs[riga][colo]!=-1&&tabs[riga][colo]!=-2)

vide[riga][colo]=""+tabs[riga][colo];
}


}
return done;
}
/*public void verifica2(int riga,int colo,int dirX,int dirY)
{
if(limitz(riga+dirX,colo+dirY))
{
if(tabs[riga+dirX][colo+dirY]==0)
vide[riga+dirX][colo+dirY]=="0";
}
}*/
public void game2()
{

if(tabs[x][y]==-1)
{
print("hai perso");
System.exit(0);
}
else
vide[x][y]=""+tabs[x][y];
if(vittoria())
{
print("Hai vinto");
StampaVideo();
System.exit(0);
}
found(x,y);
StampaVideo();
coordinate();

}

public void StampaVideoorizz()
{
System.out.print("---");
for(int i=0; i<tabs.length;i++)
System.out.print("---");
System.out.println("--");
System.out.print(" -|");
for(int i=0; i<tabs.length;i++)
System.out.print((i<=10)?" "+i+" ":i+" ");
System.out.println("|");
System.out.print("---");
for(int i=0; i<tabs.length;i++)
System.out.print("---");
System.out.println("--");
}
public void StampaVideo()
{
StampaVideoorizz();
for(int i=0; i<tabs.length;i++)
{
System.out.print((i<10)?i+" |":i+"|");
for(int j=0; j<tabs.length;j++)
System.out.print(" "+vide[i][j]+" ");
System.out.println(" |");
}
StampaVideoorizz();
}
public void stampaFile(int[][] m)
{
for(int i=0;i<m.length;i++)
{
for(int j=0;j<m.length;j++)
{
System.out.print(m[i][j]+" ");
}
System.out.println();
}
}
public boolean vittoria()
{
boolean win=false;
int forwin=0;
for(int i=0; i<vide.length;i++)
{
for(int j=0;j<vide.length;j++)
{
if(vide[i][j]=="X")
forwin++;
}
}
if(forwin==vide.length)
win=true;
return win;
}


//tabgame.bsh
private int[][] tabgame;
public tabgame(int[][] m)
{
tabgame=m;
StampaVideo();
}
public void StampaVideo()
{
System.out.print("---");
for(int i=0; i<tabgame.length;i++)
System.out.print("-");
System.out.println("--");
System.out.print("-| ");
for(int i=0; i<tabgame.length;i++)
System.out.print(i);
System.out.println(" |");
System.out.print("---");
for(int i=0; i<tabgame.length;i++)
System.out.print("-");
System.out.println("--");

}


Questo è quanto..se qualcuno può aiutarmi glie ne sarai eternamente grato ;P
grazie ancora..

Pelè