Advertisement
Guest User

ultimatumprojectus

a guest
May 27th, 2018
66
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 10.53 KB | None | 0 0
  1. import java.io.File;
  2. import java.io.FileNotFoundException;
  3. import java.io.FileOutputStream;
  4. import java.io.FileWriter;
  5. import java.io.IOException;
  6. import java.io.OutputStreamWriter;
  7. import java.io.PrintWriter;
  8. import java.text.DateFormat;
  9. import java.text.SimpleDateFormat;
  10. import java.util.*;
  11.  
  12. public class CopyOfProjecteUF3 {
  13.  
  14.     public static int filPepito;
  15.     public static int colPepito;
  16.     public static int filSortida;
  17.     public static int colSortida;
  18.     public static int numLaberints = 0;
  19.     static char[][][] testlaberints = new char[20][][];
  20.  
  21.     /**
  22.      * Mostrar menu
  23.      */
  24.     public static void mostrarMenu(){
  25.  
  26.  
  27.         System.out.println("Tria entre les següents opcions:");
  28.         System.out.println("1 - Importar laberints");
  29.         System.out.println("2 - Jugar");
  30.         System.out.println("3 - Mostrar resultats");
  31.         System.out.println("0 - Sortir");
  32.     }
  33.  
  34.     // Funcio que guardara els resultats dins d' un fitxer
  35.  
  36.     public static void guardarResultats (int laberint,String jugador, String acabat, int moviments) throws IOException{
  37.  
  38.  
  39.         DateFormat formatdata = new SimpleDateFormat("dd/MM/yyyy HH:mm");
  40.         Date data = new Date();
  41.  
  42.         PrintWriter importfichero = new PrintWriter(new OutputStreamWriter(new FileOutputStream("resultats.txt", true), "UTF-8"));//new PrintWriter((new FileWriter("laberints.txt", true)));
  43.         importfichero.println(formatdata.format(data)+ " " + laberint + " " + jugador + " " + acabat + " " + moviments);
  44.         importfichero.close();
  45.  
  46.     }
  47.  
  48.     /**
  49.      * S'importen els laberints des de fitxer
  50.      * Heu de pensar els parà metres d'entrada i els valors de sortida
  51.      * @throws FileNotFoundException
  52.      */
  53.  
  54.  
  55.     public static void importarLaberints() throws FileNotFoundException{
  56.  
  57.         int fila = 0;
  58.         int col= 0;
  59.         Scanner fichero = new Scanner(new File("laberints.txt"), "UTF-8");
  60.  
  61.         while (fichero.hasNextInt() && CopyOfProjecteUF3.numLaberints <= 20) {
  62.  
  63.             fila = fichero.nextInt();
  64.             col = fichero.nextInt();
  65.  
  66.             System.out.println(fila + " " + col);
  67.             testlaberints[numLaberints] = new char [fila][col];
  68.  
  69.  
  70.             for (int i = 0; i < fila; i++) {
  71.                 int contador = 0;
  72.                 String totaLinia = fichero.next();
  73.                 for (int j = 0; j < col; j ++) {
  74.  
  75.  
  76.                     testlaberints[numLaberints][i][j] = (totaLinia.charAt(contador));
  77.                     System.out.print(testlaberints[numLaberints][i][j]);
  78.                     contador ++;
  79.                 }System.out.println();
  80.             }
  81.             if(obtenirFilColPepitoSortida(testlaberints[numLaberints], '☺', '♠')) {
  82.                 numLaberints++;
  83.             }
  84.             else {
  85.                 System.out.println("El laverint no te pepito o no te sortida, per aixo no sera importat");
  86.             }
  87.         }
  88.         fichero.close();
  89.  
  90.  
  91.     }
  92.  
  93.  
  94.     /**
  95.      * Cerca a la matriu la posició on està  el pepito i el caràcter de sortida dins del laberint
  96.      * i les desa a les variables globals filPepito, colPepito, filSortida, colSortida
  97.      * @param matriu
  98.      * @param pepito
  99.      * @param sortida
  100.      * @return
  101.      */
  102.     public static boolean obtenirFilColPepitoSortida(char[][] matriu, char pepito, char sortida){
  103.  
  104.         //Considerem que al laberint hi ha el caràcter del pepito i el de sortida
  105.         boolean trobatPepitoSortida = true;
  106.  
  107.         //Inicialitzem les files a -1 per després saber si hem trobat la posició o no de cada caràcter
  108.         filPepito = -1;
  109.         filSortida = -1;
  110.  
  111.         //Recorrem la matriu per trobar el caràcter del pepito i de la sortida
  112.         for (int i = 0; i < matriu.length; i++){
  113.             for(int j = 0; j < matriu[i].length; j++){
  114.                 if(matriu[i][j] == pepito){
  115.                     //Hem trobat el pepito desem la seva fila i la seva columna a les variables globals filPepito i colPepito
  116.                     filPepito = i;
  117.                     colPepito = j;
  118.                 }else if(matriu[i][j] == sortida){
  119.                     //Hem trobat la sortida desem la seva fila i la seva columna a les variables globals filSortida i colSortida
  120.                     filSortida = i;
  121.                     colSortida = j;
  122.                 }
  123.             }
  124.         }
  125.  
  126.         //Si no hem trobat algun dels dos caràcters (pepito, sortida) retornem que no ha anat bé amb false
  127.         //per despres mostrar un missatge a l'usuari
  128.         if(filPepito == -1 || filSortida == -1){
  129.             trobatPepitoSortida = false;
  130.         }
  131.  
  132.         return trobatPepitoSortida;
  133.  
  134.     }
  135.  
  136.     /**
  137.      * Imprimeix la matriu per pantalla
  138.      * @param matriu Matriu a imprimir
  139.      */
  140.     public static void imprimirMatriu(char[][] matriu) {
  141.  
  142.         //Imprimim la matriu
  143.         for (int fil = 0; fil < matriu.length; fil++) {
  144.  
  145.             for (int col = 0; col < matriu[fil].length; col++) {
  146.                 System.out.print(matriu[fil][col]);
  147.             }
  148.             System.out.println();
  149.         }
  150.     }
  151.  
  152.     /**
  153.      * En aquesta funció haureu de dir a l'usuari que triï laberint d'entre els que hi ha i quan acabi de jugar desar els resultats
  154.      * Heu de pensar els parà metres d'entrada i els valors de sortida
  155.      * @throws IOException
  156.      */
  157.     public static void jugar(char[][][] laberints, Scanner teclat, char pepito, char sortida) throws IOException{
  158.  
  159.         System.out.println("Introdueix el número del laberint al que vols jugar del 1 al "+ (numLaberints));
  160.         int opcioLaberint = teclat.nextInt();
  161.         teclat.nextLine();
  162.         System.out.println("Nom del jugador?");
  163.         String nomjugador = teclat.nextLine();
  164.         char[][]matriu = laberints[opcioLaberint-1];
  165.  
  166.         //Mirem en quina fila i columna estan els caràcters pepito '☺' i sortida '♠'.
  167.         //filPepito, colPepito, filSortida, colSortida són variables globals
  168.         boolean caractersOK = obtenirFilColPepitoSortida(matriu, pepito, sortida);
  169.  
  170.         //Si tenim el pepito i la sortida al laberint podem jugar amb aquell laberint
  171.         if(caractersOK){
  172.  
  173.             imprimirMatriu(matriu);
  174.  
  175.             char opcio = teclat.next().charAt(0); //Si l'usuari introdueix una m vol dir que vol acabar la partida
  176.  
  177.             boolean aturarPartida = false;
  178.             boolean finalPartida = false;
  179.             int moviments = 0;
  180.             while (!aturarPartida && !finalPartida) {
  181.  
  182.                 boolean opcioOK = false;
  183.  
  184.                 //Baixar
  185.                 if (opcio == 's' || opcio == 'S') {
  186.  
  187.                     //Comprovem si podem baixar
  188.                     if (filPepito < matriu.length -1) {
  189.  
  190.                         //Comprovem si la cel·la de sota està  lliure
  191.                         if (matriu[filPepito+1][colPepito] == '·') {
  192.  
  193.                             //Movem el pepito
  194.                             matriu[filPepito][colPepito] = '·';
  195.                             filPepito++;
  196.                             matriu[filPepito][colPepito] = pepito;
  197.  
  198.                         }else if(matriu[filPepito+1][colPepito] == sortida){
  199.                             finalPartida = true;
  200.                             //Movem el pepito al final
  201.                             matriu[filPepito][colPepito] = '♠';
  202.                             filPepito++;
  203.                             matriu[filPepito][colPepito] = pepito;
  204.                         }
  205.                     }
  206.                     opcioOK = true;
  207.  
  208.                     //Pujar
  209.                 }else if (opcio == 'w' || opcio == 'W') {
  210.  
  211.                     //Comprovem si podem pujar
  212.                     if (filPepito > 0) {
  213.  
  214.                         //Comprovem si la cel·la de dalt està  lliure
  215.                         if (matriu[filPepito-1][colPepito] == '·') {
  216.  
  217.                             //Movem el pepito
  218.                             matriu[filPepito][colPepito] = '·';
  219.                             filPepito--;
  220.                             matriu[filPepito][colPepito] = pepito;
  221.  
  222.                         }else if(matriu[filPepito-1][colPepito] == sortida){
  223.                             finalPartida = true;
  224.                             //Movem el pepito al final
  225.                             matriu[filPepito][colPepito] = '♠';
  226.                             filPepito--;
  227.                             matriu[filPepito][colPepito] = pepito;
  228.                         }
  229.                     }
  230.                     opcioOK = true;
  231.  
  232.                     // Dreta
  233.                 }else if (opcio == 'd' || opcio == 'D') {
  234.  
  235.                     //Comprovem si podem tirar a la dreta
  236.                     if (colPepito < matriu[0].length - 1) {
  237.  
  238.                         //Comprovem si la cel·la de la dreta està  lliure
  239.                         if (matriu[filPepito][colPepito+1] == '·') {
  240.  
  241.                             //Movem el pepito
  242.                             matriu[filPepito][colPepito] = '·';
  243.                             colPepito++;
  244.                             matriu[filPepito][colPepito] = pepito;
  245.  
  246.                         }else if(matriu[filPepito][colPepito+1] == sortida){
  247.                             finalPartida = true;
  248.                             //Movem el pepito al final
  249.                             matriu[filPepito][colPepito] = '♠';
  250.                             colPepito++;
  251.                             matriu[filPepito][colPepito] = pepito;
  252.                         }
  253.                     }
  254.                     opcioOK = true;
  255.  
  256.                     //Esquerra
  257.                 } else if (opcio == 'a' || opcio == 'A') {
  258.  
  259.                     //Comprovem si podem anar a l'esquerra
  260.                     if (colPepito > 0) {
  261.  
  262.                         //Comprovem si la cel·la de l'esquerra està  lliure
  263.                         if (matriu[filPepito][colPepito-1] == '·') {
  264.  
  265.                             //Movem el pepito
  266.                             matriu[filPepito][colPepito] = '·';
  267.                             colPepito--;
  268.                             matriu[filPepito][colPepito] = pepito;
  269.  
  270.                         }else if(matriu[filPepito][colPepito-1] == sortida){
  271.                             finalPartida = true;
  272.                             //Movem el pepito al final
  273.                             matriu[filPepito][colPepito] = '♠';
  274.                             colPepito--;
  275.                             matriu[filPepito][colPepito] = pepito;
  276.                         }
  277.                     }
  278.                     opcioOK = true;
  279.                 }
  280.                 moviments++;
  281.                 //Aturarem la partida si l'usuari no introdueix cap tecla que sigui de pujar, baixar, dreta, esquerra
  282.                 aturarPartida = !opcioOK;
  283.  
  284.                 //Imprimim la matriu
  285.                 imprimirMatriu(matriu);
  286.  
  287.                 if(!aturarPartida && !finalPartida){
  288.                     opcio = teclat.next().charAt(0);
  289.                 }else if(aturarPartida){
  290.                     System.out.println("Has aturat la partida");
  291.                     guardarResultats(opcioLaberint ,nomjugador, "No", moviments);
  292.                 }else if(finalPartida){
  293.                     System.out.println("Has finalitzat la partida felicitats!");
  294.                     guardarResultats(opcioLaberint ,nomjugador, "Si", moviments);
  295.                 }
  296.  
  297.             }
  298.  
  299.         }else{
  300.             //No hi ha el pepito o la sortida al laberint
  301.             System.out.println("No hi ha el pepito o la sortida al laberint");
  302.         }
  303.  
  304.     }
  305.  
  306.     /**
  307.      * Es desen els resultats de la partida quan el jugador ja no vol jugar més
  308.      * Heu de pensar els paràmetres d'entrada i els valors de sortida
  309.      */
  310.     public static void desarResultats(){
  311.  
  312.  
  313.     }
  314.  
  315.     /**
  316.      * Es recuperen els resultats de l'usuari actual i es mostren els seus resultats
  317.      * Heu de pensar els paràmetres d'entrada i els valors de sortida
  318.      * @throws FileNotFoundException
  319.      */
  320.     public static void mostrarResultats() throws FileNotFoundException{
  321.  
  322.         Scanner fichero = new Scanner(new File("resultats.txt"), "utf-8");
  323.         while (fichero.hasNextLine()) {
  324.             System.out.println(fichero.nextLine());
  325.  
  326.  
  327.         }
  328.         fichero.close();
  329.     }
  330.  
  331.     public static void main(String[] args) throws IOException {
  332.  
  333.         //Declarem i inicialitzem variables
  334.         Scanner teclat = new Scanner(System.in);
  335.         char [][][] laberintsTurpedo = new char [0][][];
  336.         char pepito = '☺';
  337.         char sortida = '♠';
  338.  
  339.         //Mostrem el menú i li demanem l'opcio a l'usuari
  340.         mostrarMenu();
  341.         int opcioMenu = teclat.nextInt();
  342.         teclat.nextLine();
  343.  
  344.         boolean sortir = false;
  345.  
  346.         while (!sortir) {
  347.  
  348.             switch(opcioMenu){
  349.             case 1: importarLaberints();break;
  350.             case 2: jugar(testlaberints,teclat,pepito,sortida);break; //inclou escollir laberint
  351.             case 3: mostrarResultats();break;
  352.             case 0: default: sortir = true;
  353.             }
  354.  
  355.  
  356.  
  357.  
  358.             if(!sortir){
  359.                 //Mostrem el menú i li demanem l'opcio a l'usuari
  360.                 mostrarMenu();
  361.                 opcioMenu = teclat.nextInt();
  362.                 teclat.nextLine();
  363.             }
  364.         }
  365.         teclat.close();
  366.     }
  367.  
  368. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement