30/11/09 9:57
kevinpirola
Salve a tutti! Sono lieto di presentarmi su questo forum, che trovo molto interessante e molto utile.
Sono uno studente di ingegneria elettronica a padova, amo la programmazione e la grafica.
Vi scrivo perchè vorrei fare quattro chiacchiere con qualcuno che se ne intende più di me di programming.
Vi spiego cosa devo fare. Per l'esame di D.A. mi è stato assegnato un progetto dal libro Goodrich-Tamassia, Strutture dati e Algoritmi in Java, il P-7.8.
In sostanza devo creare un gioco del tris al quale si possa giocare contro il computer. per ovvi motivi non posso prenderne uno già fatto poichè devo poi spiegarlo all'orale. Se posso allora vi scrivo le mie idee e mi dite se sto sbagliado.
In sostanza devo implementare l'albero di gioco in java e poi fargli calcolare tramite il "minmax" la mossa migliore da fare.
Ho provato a far generare tutto l'albero di combinazioni al momento dell'avvio del programma, ho però grossi problemi con il peso delle operazioni. Il computer infatti va in errore di memoria prima di poter giungere al termine delle operazioni. Ho quindi pensato di fargli calcolare di nodo in nodo i vari figli che mi servono. Però ho le idee molto confuse (e forse si vede anche
)
vi posto il codice che ho scritto finora, con una piccola classe di prova che mostra a grandi linee come avevo pensato la struttura del codice. Accetto aiuti, critiche di ogni tipo sul codice, però quello che più mi preme è capire cosa devo fare
ecco le classi:
Classe Albero
Classe Campo
Classe Tris
Classe Giocatore
Classe di prova TrisTest
aperto a tutti i commenti.
ditemi quello che vi pare, anche se secondo voi ho fatto un mare di cavolate, farò tesoro di quello che mi direte.
Così com'è la classe funziona se si gioca uno contro uno. La classe prova dà la possibilità di testare la mossa del computer premendo al posto del numero di casella la lettera c. Per il momento funziona solo se il PC deve completare la mossa vincendo ovvero deve mettere il suo simbolo in linea con altri due.
Spero di essere stato esaustivo, se avete qualsiasi domanda chiedete...
EDIT: leggo che il presumibilmente sopra il codice è sbagliato, è tutto Java
Sono uno studente di ingegneria elettronica a padova, amo la programmazione e la grafica.
Vi scrivo perchè vorrei fare quattro chiacchiere con qualcuno che se ne intende più di me di programming.
Vi spiego cosa devo fare. Per l'esame di D.A. mi è stato assegnato un progetto dal libro Goodrich-Tamassia, Strutture dati e Algoritmi in Java, il P-7.8.
In sostanza devo creare un gioco del tris al quale si possa giocare contro il computer. per ovvi motivi non posso prenderne uno già fatto poichè devo poi spiegarlo all'orale. Se posso allora vi scrivo le mie idee e mi dite se sto sbagliado.
In sostanza devo implementare l'albero di gioco in java e poi fargli calcolare tramite il "minmax" la mossa migliore da fare.
Ho provato a far generare tutto l'albero di combinazioni al momento dell'avvio del programma, ho però grossi problemi con il peso delle operazioni. Il computer infatti va in errore di memoria prima di poter giungere al termine delle operazioni. Ho quindi pensato di fargli calcolare di nodo in nodo i vari figli che mi servono. Però ho le idee molto confuse (e forse si vede anche
)
vi posto il codice che ho scritto finora, con una piccola classe di prova che mostra a grandi linee come avevo pensato la struttura del codice. Accetto aiuti, critiche di ogni tipo sul codice, però quello che più mi preme è capire cosa devo fare
ecco le classi:
Classe Albero
import java.util.ArrayList;
public class Albero
{
private Campo c;
private static final int NUMFIGLI = 9;
private static final int MAXDEPTH = 8;
private int nFigli;
private int depth;
private ArrayList<Albero> arrFigli;
private Albero padre;
public Albero() //genera la root
{
padre = null;
c = new Campo();
arrFigli = new ArrayList<Albero>(NUMFIGLI);
depth = 0;
nFigli = NUMFIGLI-depth;
}
public Albero(Albero p,int prof,Campo cmp) //generatore per i figli
{
padre = p;
depth = prof + 1;
nFigli = NUMFIGLI - depth;
c = cmp;
arrFigli = new ArrayList<Albero>(nFigli);
}
public void generaFigli() //ArrayList<Albero>
{
for(int i = 0; i < nFigli; i++)
{
Campo cmp = new Campo(c,i,depth);
Albero alb = new Albero(this,depth,cmp);
arrFigli.add(i,alb);
}
//return arrFigli;
}
public int getNumFigli()
{
return nFigli;
}
public int getDepth()
{
return depth;
}
private void setNumFigli(int prof)
{
nFigli = NUMFIGLI - prof;
}
public Albero getFiglio(int n)
{
Albero figlio = arrFigli.get(n);
return figlio;
}
public Campo getCampo(){
return c;
}
public void getMossaMigliore()
{
this.generaFigli();
for(int i=0;i<arrFigli.size();i++)
System.out.println(arrFigli.get(i));
}
public String toString()
{
String r = ""+c;
return r;
}
}
Classe Campo
public class Campo{
private int[][] c;
public Campo(){
c = new int[3][3];
}
public Campo(int ri,int co){ //costruttore inizializzo il campo con tutti zeri(default)
c = new int[ri][co];
}
public Campo(Campo cmp,int ri,int co,int prof){ //costruttore inizializzo il campo con tutti zeri(default)
c = clonaCampo(cmp.c);
int v = getValPl(prof);
c[ri][co] = v;
}
public Campo(Campo attuale,int step, int val){
int v = getValPl(val);
c = clonaCampo(attuale.c);
for(int i=0; i < c.length; i++){
for(int j=0; j < c.length; j++){
if(attuale.c[i][j] == 0){
if(step == 0){
c[i][j] = v;
return;
}else{
step--;
}
}
}
}
}
public void setCampo(int ri,int co,int val){
c[ri][co] = val;
}
public int getValPl(int val)
{
int v=2;
int r = val % 2;
switch(r){
case 0:
v = 1;
break;
case 1:
v = -1;
break;
}
return v;
}
public boolean isMossaValida(int ri,int co)
{
if(c[ri][co]==0) return true;
return false;
}
public int chiVince(){
int m = 0;
int s = 0;
for(int i=0; i<3; i++){
int n = 0;
int t = 0;
for(int j=0; j<3; j++){
n += c[i][j]; //RIGA
t += c[j][i]; //COLONNA
}
m += c[i][i]; //DIAGONALE 1
s += c[i][2-i]; //DIAGONALE 2
if(n==3||t==3) return 1;
if(n==-3||t==-3) return -1;
}
if(m==3||s==3) return 1;
if(m==-3||s==-3) return -1;
return 0;
}
private int[][] clonaCampo(int[][] cmp){
int[][] r = new int[3][3];
for(int i = 0; i < 3; i++){
for(int j = 0; j < 3; j++){
r[i][j] = cmp[i][j];
}
}
return r;
}
public String toString(){
String r = "\n";
for(int i = 0; i<3; i++){
r += "|";
for(int j = 0; j<3; j++){
switch (this.c[i][j]){
case 0:
r += " ";
break;
case 1:
r += "X";
break;
case -1:
r += "O";
break;
}
//r += this.c[i][j];
r += "|";
}
r += "\n";
}
return r;
}
}
Classe Tris
public class Tris
{
private Albero a;
private Campo campo;
private static final int RIGHE = 3;
private static final int COLON = 3;
private Giocatore giocatore1,giocatore2,currentpl,winner;
public Tris(boolean g1PC,boolean g2PC)
{
nuovaPartita(g1PC,g2PC);
}
private void nuovaPartita(boolean g1PC,boolean g2PC)
{
a = new Albero();
campo = new Campo(); //vuoto
giocatore1 = new Giocatore(g1PC);
giocatore2 = new Giocatore(g2PC);
currentpl = giocatore1;
winner = null;
}
public Giocatore getCurrentPl()
{
return currentpl;
}
public Giocatore getWinner()
{
return winner;
}
public boolean doMossaGiocatore(int input)
{
int ri=2;
int co=2;
switch(input)
{
case 1:
ri=0;
co=0;
break;
case 2:
ri=0;
co=1;
break;
case 3:
ri=0;
co=2;
break;
case 4:
ri=1;
co=0;
break;
case 5:
ri=1;
co=1;
break;
case 6:
ri=1;
co=2;
break;
case 7:
ri=2;
co=0;
break;
case 8:
ri=2;
co=1;
break;
case 9:
ri=2;
co=2;
break;
}
if(campo.isMossaValida(ri,co)){
campo = new Campo(campo,ri,co,a.getDepth());
a = new Albero(a,a.getDepth(),campo);
return true;
}
return false;
}
public void vince()
{
int vinc = campo.chiVince();
System.out.println(campo);
if(vinc != 0) winner=currentpl;
}
public boolean partitaFinita()
{
if(winner != null) return true;
return false;
}
public void doMossaComputer()
{
a.generaFigli();
for(int i = 0; i < a.getNumFigli(); i++)
{
if(a.getFiglio(i).getCampo().chiVince() == -(a.getFiglio(i).getCampo().getValPl(a.getDepth())))
{
return;
}
else if(a.getFiglio(i).getCampo().chiVince() == a.getFiglio(i).getCampo().getValPl(a.getDepth()))
{
a = a.getFiglio(i);
campo = a.getCampo();
return;
}
else //se pari
{
//sceglie la migliore
}
}
}
public void cambiaGiocatore(){
if(currentpl == giocatore1){ currentpl = giocatore2;
}
else if(currentpl == giocatore2){ currentpl = giocatore1;}
else{ return; }
}
}
Classe Giocatore
public class Giocatore
{
private static int numGiocatore = 1;
private boolean PC = false;
String nome;
public Giocatore(boolean PCpl)
{
if(numGiocatore%2==1){
PC = PCpl;
nome = "Giocatore1[X]";
numGiocatore++;
}
else
{
PC = PCpl;
nome = "Giocatore2[O]";
numGiocatore++;
}
}
public boolean isPC()
{
return PC;
}
public String toString(){
return nome;
}
}
Classe di prova TrisTest
import java.util.Scanner;
import java.io.*;
import java.lang.String;
public class TrisTest
{
public static void main(String[]arg) throws IOException {
Scanner in = new Scanner(System.in);
System.out.println("Giocatore 1 - Umano[U] o Computer[C]? (default umano)");
String input = in.next();
boolean g1PC = (input.equalsIgnoreCase("c"));
System.out.println("Giocatore 2 - Umano[U] o Computer[C]?");
input = in.next();
boolean g2PC = (input.equalsIgnoreCase("c"));
Tris game = new Tris(g1PC,g2PC);
while(!game.partitaFinita())
{
System.out.println("\n");
System.out.println(game.getCurrentPl());
System.out.println("Inserire il numero della casella da occupare");
String num = in.next();
if(!num.equals("c")){
if(game.doMossaGiocatore(Integer.parseInt(num))){
game.vince();
game.cambiaGiocatore();
}
}
else
{
game.doMossaComputer();
game.vince();
game.cambiaGiocatore();
}
}
}
}
aperto a tutti i commenti.
ditemi quello che vi pare, anche se secondo voi ho fatto un mare di cavolate, farò tesoro di quello che mi direte.
Così com'è la classe funziona se si gioca uno contro uno. La classe prova dà la possibilità di testare la mossa del computer premendo al posto del numero di casella la lettera c. Per il momento funziona solo se il PC deve completare la mossa vincendo ovvero deve mettere il suo simbolo in linea con altri due.
Spero di essere stato esaustivo, se avete qualsiasi domanda chiedete...
EDIT: leggo che il presumibilmente sopra il codice è sbagliato, è tutto Java
Ultima modifica effettuata da kevinpirola 30/11/09 9:59
aaa
