Tema: Crear un main
Ver Mensaje Individual
  #1 (permalink)  
Antiguo 25/11/2014, 06:13
scuvi96
 
Fecha de Ingreso: octubre-2014
Mensajes: 46
Antigüedad: 10 años, 3 meses
Puntos: 0
Exclamación Crear un main
Hola tengo estas dos clases dadas:

Código Java: 
Ver original
  1. import java.util.*;
  2.  
  3. /**
  4.  * Clase que contiene un robot que se mueve por un recinto
  5.  */
  6. public class Robot
  7. {
  8.  
  9.     /**
  10.      * Constante estatica para la direccion; 
  11.      * es relativa a la orientacion del robot
  12.      */
  13.     public static int DELANTE=Recinto.DELANTE;
  14.  
  15.     /**
  16.      * Constante estatica para la direccion; 
  17.      * es relativa a la orientacion del robot
  18.      */
  19.     public static int DETRAS=Recinto.DETRAS;
  20.  
  21.     /**
  22.      * Constante estatica para la direccion; 
  23.      * es relativa a la orientacion del robot
  24.      */
  25.     public static int IZQDA=Recinto.IZQDA;
  26.  
  27.     /**
  28.      * Constante estatica para la direccion; 
  29.      * es relativa a la orientacion del robot
  30.      */
  31.     public static int DCHA=Recinto.DCHA;
  32.     
  33.     // posicion del robot, en celdas, y angulo, en cuadrantes (0, 1, 2, 3)
  34.     private int posX, posY;
  35.     private int angulo; // expresado en cuadrantes
  36.     // recinto en el que se mueve el robot
  37.     private Recinto rec;
  38.  
  39.     /**
  40.      * Constructor al que se le pasa la posicion inicial en celdas,
  41.      * y el angulo inicial en grados (multiplo de 90) 
  42.      */
  43.     public Robot(int posX, int posY, int angulo)
  44.     {
  45.         this.angulo=(angulo%360)/90;
  46.         rec=new Recinto();
  47.         if (rec.posicionValida(posX,posY)) {
  48.             this.posX=posX;
  49.             this.posY=posY;
  50.             rec.cambiaRobot(posX, posY,angulo);
  51.         } else {
  52.             System.out.println("La posicion "+posX+","+
  53.                posY+"no es valida");
  54.             System.out.println("Se inicializa el robot en 25,25");
  55.             this.posX=25;
  56.             this.posY=25;
  57.             rec.cambiaRobot(25, 25,angulo);            
  58.         }
  59.     }
  60.  
  61.     /**
  62.      * Avanza el robot una celda si se puede; 
  63.      * retorna true si avanzo, o false si habia un obstaculo delante
  64.      */
  65.     public boolean avanza()
  66.     {
  67.         if (rec.hayObstaculo(Recinto.DELANTE)) {
  68.             return false;
  69.         } else {
  70.             switch (angulo) {
  71.                 case 0: posX++; break;
  72.                 case 1: posY--; break;
  73.                 case 2: posX--; break;
  74.                 case 3: posY++;
  75.             }
  76.             rec.cambiaRobot(posX,posY,angulo*90);
  77.             return true;
  78.         }
  79.     }
  80.     
  81.     /**
  82.      * Gira el robot 90 grados
  83.      */
  84.     public void gira90() {
  85.         angulo=(angulo+1)%4;
  86.         rec.cambiaRobot(posX,posY,angulo*90);
  87.     }
  88.     
  89.     /**
  90.      * Indica si el robot tiene un obstaculo en la direccion indicada
  91.      * La direccion se expresa mediante las constantes estaticas 
  92.      * DELANTE, DETRAS, IZQDA, DCHA, y es relativa al angulo actual del robot
  93.      */
  94.     public boolean hayObstaculo(int direccion) {
  95.         return rec.hayObstaculo(direccion);
  96.     }
  97.     
  98.     /**
  99.      * Pinta el robot y el recinto
  100.      */
  101.     public void pinta() {
  102.         espera(50);
  103.         rec.pinta();
  104.     }
  105.     
  106.     // Espera un rato expresado en milisegundos
  107.      
  108.     private void espera(int milisegundos) {
  109.         try {
  110.            Thread.sleep(milisegundos);
  111.         } catch (InterruptedException e) {
  112.         }
  113.     }
  114.     
  115.     /**
  116.      * Indica si el robot esta dentro del laberinto
  117.      */
  118.     public boolean estaDentroLaberinto() {
  119.         return 30<=posX && posX<=80 && 30<=posY && posY<=80;
  120.     }
  121. }

Código Java: 
Ver original
  1. import fundamentos.Dibujo;
  2. import fundamentos.ColorFig;
  3.  
  4. /**
  5.  * Clase que representa un recinto con obstaculos, en el que se
  6.  * mueve un robot movil
  7.  */
  8. public class Recinto
  9. {
  10.  
  11.     /**
  12.      *  Constante para la direccion de movimiento; 
  13.      *  es relativa a la orientacion del robot
  14.      */
  15.     public static int DELANTE=0;
  16.  
  17.     /**
  18.      *  Constante para la direccion de movimiento; 
  19.      *  es relativa a la orientacion del robot
  20.      */
  21.     public static int DETRAS=2;
  22.  
  23.     /**
  24.      *  Constante para la direccion de movimiento; 
  25.      *  es relativa a la orientacion del robot
  26.      */
  27.     public static int IZQDA=1;
  28.  
  29.     /**
  30.      *  Constante para la direccion de movimiento; 
  31.      *  es relativa a la orientacion del robot
  32.      */
  33.     public static int DCHA=3;
  34.     
  35.     // ventana para hacer el dibujo
  36.     private Dibujo dib;
  37.     
  38.     // iconos disponibles
  39.     private static final String[] fichIcono=
  40.        {"icono0.png","icono90.png","icono180.png","icono270.png"}; 
  41.     
  42.     // posicion del icono
  43.     private int posX=0, posY=0;
  44.     // icono a usar 0, 1, 2, 3, para 0, 90, 180, 270 grados
  45.     private int icono=0; 
  46.     
  47.     //celda del recinto, que define los obstaculos a dibujar
  48.     // true indica que la celda esta ocupada por un obstaculo
  49.     private boolean[][] celda;
  50.     // obstaculos a usar, teniendo en cuenta que el robot mide mas
  51.     // de una celda. Contiene el dibijo de las celdas, aumentado
  52.     // true indica que la celda esta ocupada por un obstaculo
  53.     private boolean[][] obstaculo;
  54.     
  55.     // maximo numero de celdas contenidas en el recinto
  56.     private int maxX=120;
  57.     private int maxY=120;
  58.     
  59.     //Tamano de las celdas del dibujo
  60.     private int paso=5;
  61.     
  62.     // margen que debe librarse alrededor del robot, en celdas
  63.     // el robot mide (2*margen+1)*paso
  64.     private int margen=2;
  65.  
  66.     // limites del dibujo
  67.     private int limiteX=paso*(maxX+2);
  68.     private int limiteY=paso*(maxY+2);
  69.  
  70.     /**
  71.      * Constructor que da un valor concreto al recinto
  72.      */
  73.     public Recinto()
  74.     {
  75.         dib= new Dibujo("Recinto",limiteX,limiteY);
  76.         celda= new boolean[maxX][maxY]; // se inicializa a false por omision
  77.         obstaculo= new boolean[maxX][maxY]; // se inicializa a false por omision
  78.         // colocar los bordes superior e inferior del recinto
  79.         for (int i=0; i<maxX; i++) {
  80.             celda[i][0]=true;
  81.             celda[i][maxY-1]=true;
  82.         }
  83.         // colocar los bordes izqdo y dcho del recinto
  84.         for (int i=0; i<maxY; i++) {
  85.             celda[0][i]=true;
  86.             celda[maxX-1][i]=true;
  87.         }
  88.         
  89.         // crear un laberinto en el centro
  90.         // lineas horizontales
  91.         for (int i=30; i<=80; i++) {
  92.             celda[i][30]=true;
  93.         }
  94.         for (int i=30; i<=70; i++) {
  95.             celda[i][40]=true;
  96.         }
  97.         for (int i=40; i<=50; i++) {
  98.             celda[i][50]=true;
  99.         }
  100.         for (int i=60; i<=70; i++) {
  101.             celda[i][50]=true;
  102.         }
  103.         for (int i=40; i<=50; i++) {
  104.             celda[i][70]=true;
  105.         }
  106.         for (int i=30; i<=80; i++) {
  107.             celda[i][80]=true;
  108.         }
  109.         // lineas verticales
  110.         for (int i=40; i<=80; i++) {
  111.             celda[30][i]=true;
  112.         }
  113.         for (int i=40; i<=50; i++) {
  114.             celda[40][i]=true;
  115.         }
  116.         for (int i=50; i<=70; i++) {
  117.             celda[50][i]=true;
  118.         }
  119.         for (int i=60; i<=80; i++) {
  120.             celda[60][i]=true;
  121.         }
  122.         for (int i=40; i<=70; i++) {
  123.             celda[70][i]=true;
  124.         }
  125.         for (int i=30; i<=80; i++) {
  126.             celda[80][i]=true;
  127.         }
  128.         // Colocar los obstaculos
  129.         for (int i=0; i<maxX; i++) {
  130.             for (int j=0; j<maxY; j++) {
  131.                 if (celda[i][j]) {
  132.                     for (int x=Math.max(0,i-margen); 
  133.                         x<=Math.min(maxX-1,i+margen); x++) 
  134.                     {
  135.                         for (int y=Math.max(0,j-margen); 
  136.                             y<=Math.min(maxY-1,j+margen); y++) 
  137.                         {
  138.                             obstaculo[x][y]=true;
  139.                         }
  140.                     }
  141.                 }
  142.             }
  143.         }
  144.     }
  145.     
  146.     // transforma coordenada x de celda al dibujo
  147.     private int coordX(int x) {
  148.         return x*paso+paso;
  149.     }
  150.  
  151.     // transforma coordenada x de celda al dibujo
  152.     private int coordY(int y) {
  153.         return y*paso+paso;
  154.     }
  155.  
  156.     /**
  157.      * Pintar el dibujo
  158.      */
  159.     public void pinta()
  160.     {
  161.         dib.borra(ColorFig.blanco);
  162.         dib.ponGrosorLapiz(1);
  163.         dib.ponColorLapiz(ColorFig.rojo);
  164.         dib.ponRelleno(ColorFig.rojo);
  165.         for (int x=0; x<maxX; x++) {
  166.             for (int y=0; y<maxX; y++) {
  167.                 if (celda[x][y]) {
  168.                     dib.dibujaRectangulo(coordX(x),coordY(y),coordX(x)+paso,coordY(y)+paso);
  169.                 }
  170.             }
  171.         }
  172.         dib.dibujaImagen(coordX(posX)-margen*paso,coordY(posY)-margen*paso,fichIcono[icono]);
  173.         dib.pinta();
  174.     }
  175.     
  176.     /**
  177.      * Cambia la posicion y angulo del robot.
  178.      * El angulo debe ser multiplo de 90
  179.      */
  180.     public void cambiaRobot(int posX, int posY, int angulo) {
  181.         this.posX=posX;
  182.         this.posY=posY;
  183.         angulo=angulo%360;
  184.         icono=angulo/90;
  185.     }
  186.     
  187.     /**
  188.      * Indica si el robot tiene un obstaculo en la direccion indicada
  189.      */
  190.     public boolean hayObstaculo(int direccion) {
  191.         switch ((icono+direccion)%4) {
  192.            case 0: return obstaculo[posX+1][posY];
  193.            case 1: return obstaculo[posX][posY-1];
  194.            case 2: return obstaculo[posX-1][posY];
  195.            case 3: return obstaculo[posX][posY+1];
  196.            default: return false;
  197.         }
  198.     }
  199.     
  200.     /**
  201.      * Indica si estas coordenadas son validas para poner el robot
  202.      */
  203.     public boolean posicionValida(int x, int y) {
  204.         return !obstaculo[x][y];
  205.     }
  206. }



Quiero crear un main para comprobar que mi clase mueverobot funciona correctamente pero no se.