Foros aprenderaprogramar.com
Didáctica y divulgación de la programación

Hola a todos. Necesito modelar un tad RG que me pide lo siguiente :

Un RG se inicializa con un tablero de dimensiones preestablecidas (N y M). Las posiciones en el tablero serán los lugares donde los jugadores pondrán sus rectángulos por turnos hasta que se acabe el espacio disponible para uno nuevo, regidos con las siguientes reglas1:

a) Cada jugador juega alternadamente en su turno. Cuando le toca su turno, el jugador arroja dos dados y deberá, de ser posible, dibujar un rectángulo en el tablero, tal que:
a.1) La altura (A) del rectángulo estará determinada por el dado1
a.2) El ancho (L) del rectángulo estará determinado por el dado2

b) El rectángulo de dimensiones A x L se ubicará en el tablero respetando las reglas c y d. Si es posible dibujarlo, incrementará el área ocupada por el jugador.

c) El rectángulo entra en el tablero si tiene espacio disponible, de manera que no se solape con otros rectángulos.

d) El rectángulo que se agrega al tablero debe estar pegado por lo menos por espacio con otro rectángulo del mismo jugador. Excepto el 1er rectángulo de cada jugador, que no puede cumplir esta regla.

e) Si un jugador no puede dibujar su rectángulo, debe pasar el turno al otro jugador.

f) Si durante dos turnos consecutivos no se puede dibujar, termina el juego, inclusive si queda espacio libre en el tablero.

g) El jugador que tiene el turno, puede elegir eliminar un rectángulo del otro jugador, en lugar de agregar uno nuevo. En ese caso se eliminará un rectángulo al azar del mismo.

El jugador que ocupa más área al final es el ganador.

El juego es automático, no se va a realizar una interfaz de usuario, se simulan las jugadas de cada jugador (¡esto no significa que se deba diseñar un TAD jugador solo por este requerimiento!)

Ademas, debe usarse al menos una vez: - StringBuilder, cuyo uso debe basarse en la necesidad de modificar su capacidad y  Iteradores, para recorrer las colecciones de Java y para alguna de las clases de usuario que implemente.

Intentamos hacerlo con una matriz pero estamos atascados en la parte de ubicar un nuevo rectángulo que este pegado a otro a continuación les dejo las clases que implementamos y las salidas del programa .

las salidas son las siguientes :

| 1 || 1 || 1 |  este es el ultimo rectángulo del j1
| 1 || 1 || 1 |
| 1 || 1 || 1 |

Estado del Juego:
| 1 || 1 || 1 || 1 || 1 || 6 || 6 || 6 || 0 || 0 |  aquí pusimos seis porque en el método de   
| 1 || 1 || 1 || 1 || 1 || 6 || 6 || 6 || 0 || 0 |  ubicar nuevo rec1 al querer dibujarlo con 1
| 1 || 1 || 1 || 1 || 1 || 6 || 6 || 6 || 0 || 0 |  no no deja pero con otro valor si jejeje.
| 1 || 1 || 1 || 1 || 1 || 0 || 0 || 0 || 0 || 0 |
| 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 |
| 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 |
| 0 || 0 || 0 || 0 || 0 || 0 || 0 || 2 || 2 || 2 |
| 0 || 0 || 0 || 0 || 0 || 0 || 0 || 2 || 2 || 2 |
| 0 || 0 || 0 || 0 || 0 || 0 || 0 || 2 || 2 || 2 |
| 0 || 0 || 0 || 0 || 0 || 0 || 0 || 2 || 2 || 2 |


Clase Gr

public class Gr {
    Tablero tablero;
    Rectangulo ultRec;
    Dados d;

    public Gr (int x, int y){
        this.tablero= new Tablero (x,y);

    }
   
    public void jugar(){
        this.d=new Dados();
        Rectangulo j1=new Rectangulo (d.aleatoriX(),d.aleatoriY());
        j1.rec1();
        tablero.ubicar1erRec1(j1);
        //ultRec=j1;

        Rectangulo j2=new Rectangulo (d.aleatoriX(),d.aleatoriY());
        j2.rec2();
        tablero.ubicar2doRec2(j2);

        Rectangulo j3=new Rectangulo (d.aleatoriX(),d.aleatoriY());
        j3.rec1();
        tablero.ubicarNuevoRec1(j3);
        ultRec=j3;
        ;
    }

    public void eliminarRect(){     }
   
    public Rectangulo ultimoRectangulo(){
        return this.ultRec;
    }

    public String toString(){
        return this.tablero.toString();
    }

    public static void main(String[] args) {
        Gr g=new Gr (10,10);
        g.jugar();
        System.out.println(g.ultimoRectangulo());
        System.out.println(g.toString());
    }
}


Clase Dados

import java.util.Random;

public class Dados {
int x;
int y;

public int aleatoriX(){
Random aleatorio = new Random();
int n= aleatorio.nextInt(5)+1;
this.x=n;
return this.x;

}
public int aleatoriY(){
Random aleatorio = new Random();
int n= aleatorio.nextInt(5)+1;
this.y=n;
return this.y;
}
}


Clase Rectangulo

public class Rectangulo {
    int [][]rec;
    int x;
    int y;

    public Rectangulo(int x,int y){
        this.rec=new int [x][y];
        this.x=x;
        this.y=y;

    }
    public void rec1(){
        for (int i = 0; i < rec.length; i++) {
            for (int j = 0; j < rec[i].length; j++) {

                this.rec[i][j]=1;
            }
        }
    }

    public void rec2(){
        for (int i = 0; i < rec.length; i++) {
            for (int j = 0; j < rec[i].length; j++) {

                rec[i][j]=2;
            }
        }
    }

    public String toString(){
        String salida="";
        for (int f=0;f<this.rec.length;f++){
            for (int c=0; c<this.rec[f].length;c++){
                salida+="| "+rec[f][c]+" |";
            }
            salida+="\n";
        }
        return salida;
    }
}


Clase Tablero

public class Tablero {
    int [][] tab;

    public Tablero(int x,int y){
        this.tab=new int [x][y];
        /*for (int i = 0; i < tab.length; i++) {
        for (int j = 0; j < tab[i].length; j++) {

        tab[i][j]=0;
        }
        }
         */
    }

    public void ubicar1erRec1(Rectangulo rec){
        for (int i =0; i < rec.rec.length; i++) {
            for (int j =0; j < rec.rec[i].length; j++) {

                tab[i][j]=rec.rec[i][j];
            }
        }}

    public void ubicar2doRec2(Rectangulo rec){

        for (int  x=0; x < rec.rec.length; x++) {
            for (int z=0; z < rec.rec[x].length; z++)
                for (int i =tab.length-1; i >=tab.length-rec.rec.length; i--) {
                    for (int j =tab[i].length-1; j >=tab[i].length-rec.rec[x].length ; j--){
                        {
                            tab[i][j]=rec.rec[x][z];}
                    }
                }
        }

    }
    public void ubicarNuevoRec1(Rectangulo rec){
        for (int i = 0; i < tab.length; i++) {
            for (int j = 0; j < tab[i].length; j++){
                if(this.tab[i][j]==1 && tab[i][j+1]==0){
                    for (int x =i; x < rec.x; x++){
                        for (int y = j+1; y < j+1+rec.y; y++){
                            tab[x][y]=5;}
                    }
                }
            }
        }



    }

    public void ubicarNuevoRec2(Rectangulo rec){
        for (int i = 0; i < tab.length; i++) {
            for (int j = 0; j < tab[i].length; j++){
                if(this.tab[i][j]==2 && tab[i][j-1]==0){
                    for (int x =i+(tab.length-rec.x); x < tab.length-1; x++){
                        for (int y = j-rec.y; y < y-1+rec.y; y++){
                            tab[x][y]=8;}
                    }
                }
            }
        }

    }

    public String toString(){
        String salida="Estado del Juego: \n";
        for (int f=0;f<this.tab.length;f++){
            for (int c=0; c<this.tab[f].length;c++){
                salida+="| "+tab[f][c]+" |";
            }
            salida+="\n";
        }
        return salida;
    }

    public static void main(String[] args) {
        Tablero tab;
        tab=new Tablero(5,5);
        System.out.println(tab.toString());
    }
}