Advertisement
luanloose

Jogadores

Jun 22nd, 2018
102
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 12.92 KB | None | 0 0
  1. import java.util.Scanner;
  2.  
  3. public class Jogadores {
  4.     public static void main(String[] args) {
  5.  
  6.         // Inicio do trabalho
  7.         System.out.println("\n");
  8.         System.out.println("Trabalho de Algoritimo I\nProfessora: Renata Leite"
  9.                 + "\nIntegrantes do grupo: Guilherme, Isaac, Luan" + "\nTema: Jogadores de games");
  10.         System.out.println("\n\n-------------------------------------------------------------\n\n");
  11.  
  12.         // Variaveis auxiliares
  13.         Scanner scan = new Scanner(System.in);
  14.         int jogo = 0;
  15.         int player1 = 0;
  16.         int player2 = 0;
  17.         int partida = 1;
  18.         int exit = 1;
  19.         int win = 0;
  20.         int op = 0;
  21.         String busca = "";
  22.         String nome = "";
  23.         boolean invalido = false;
  24.  
  25.  
  26.         // Instanciar constantes
  27.  
  28.         final int lin = 5; // Jogador
  29.         final int col = 5; // Jogo
  30.  
  31.         // Instanciar vetores e matriz
  32.         String[] nomePlayer = new String[lin];
  33.         String[] nomeJogos = new String[lin];
  34.         int[] ganhou = new int[lin];
  35.         int[][] resultado = new int[lin][col];
  36.        
  37.         System.out.println("------------ BEM VINDO AO E-CHAMPIONSHIP MANAGER -----------\n\n");
  38.  
  39.         System.out.println("Para iniciar preencha o nome dos 5 jogadores\nOBS: Limite de 5 caracteres");
  40.  
  41.         // Preenche vetor jogadores com teste para saber se ja tem cadastrado
  42.         for (int i = 0; i < nomePlayer.length; i++) {
  43.            
  44.             System.out.println("\nDigite o nome do "+(i+1)+"º player e aperte ENTER\n");
  45.             nome = scan.next();
  46.            
  47.             for (int j = 0; j < lin; j++) {
  48.                
  49.                 if (nomePlayer[j] == null) {
  50.                    
  51.                     j = lin;
  52.                    
  53.                 } else { if (nomePlayer[j].toLowerCase().equals(nome.toLowerCase())) {
  54.                        
  55.                         invalido = true;
  56.                         j = lin;
  57.                    
  58.                     }
  59.                        
  60.                 } // Fim condicional
  61.                
  62.             } // Fim loop 2
  63.                
  64.            
  65.             if (nome.length() <= 5 && invalido == false) { //testa o limite de caracteres
  66.                
  67.                 nomePlayer[i] = nome;
  68.  
  69.                
  70.             } else { if(invalido == false) {
  71.                
  72.                 System.out.println("\nLimite de caracteres alcancado, repita a operacao.\n");
  73.                 i -= 1;
  74.                
  75.             } else {
  76.                
  77.                 System.out.println("\nJogador já cadastrado, repita a operacao.\n");
  78.                 i -= 1;
  79.                 invalido = false;
  80.                
  81.                 }
  82.                    
  83.             } // Fim condicional
  84.            
  85.         } // Fim do loop 1
  86.        
  87.        
  88.         System.out.println("Jogadores cadastrados com sucesso!\n"
  89.                 + "Continue preenchendo o nome dos 5 jogos do evento.");
  90.        
  91.         // Preenche vetor de jogos com teste para saber se ja tem cadastrado
  92.         for (int i = 0; i < nomeJogos.length; i++) {
  93.            
  94.             System.out.println("\n\nDigite o nome do "+(i+1)+"º jogo e aperte ENTER");
  95.             nome = scan.next();
  96.            
  97.             for (int j = 0; j < lin; j++) {
  98.                
  99.                 if (nomeJogos[j] == null) {
  100.                    
  101.                     nomeJogos[i] = nome;
  102.                     j = lin;
  103.                    
  104.                 }else { if (nomeJogos[j].toLowerCase().equals(nome.toLowerCase())) {
  105.                        
  106.                     System.out.println("\n\nJogo já cadastrado, repita a operacao.\n");
  107.                     j = lin;
  108.                     i -= 1;
  109.  
  110.                        
  111.                     }
  112.                        
  113.                 }
  114.                
  115.             } // Fim do loop 2
  116.                
  117.         } // Fim do loop 1
  118.        
  119.         System.out.println("Jogos cadastrados com sucesso!\n");
  120.        
  121.  
  122.         System.out.println("----------------- MENU DO EVENTO ----------------\n\n");
  123.  
  124.         // Menu do evento
  125.         do {
  126.  
  127.             System.out.printf("Escolha uma opcao de 1 a 6 e aperte ENTER: \n1 - Definir partida (Player X Player)"
  128.                     + "\n2 - Definir Pontuacao da %dº partida\n3 - Resultado parcial geral\n4 - Alterar resultado"
  129.                     + "\n5 - Pesquisar pontos por jogo ou jogador\n6 - Sair do programa e mostrar resultado final \n\n",
  130.                     partida);
  131.  
  132.             op = scan.nextInt();
  133.  
  134.             System.out.println("\n\n------------------------------------------------------------\n\n");
  135.  
  136.             if (op <= 0 || op > 6) { // Se cair aqui quer dizer q o usuario digitou algo invalido
  137.  
  138.                 System.out.println("ESCOLHA INVALIDA, DIGITE NOVAMENTE!! \n");
  139.                 System.out.println("\n\n------------------------------------------------------------\n\n");
  140.  
  141.             } else {
  142.  
  143.                 switch (op) {
  144.  
  145.                 case 1:
  146.                     // Saber qual jogo sera jogado
  147.                     System.out.println("Qual jogo será jogado?\nEscolha de 1 a 5 e aperte ENTER ");
  148.  
  149.                     for (int i = 0; i < lin; i++) {
  150.  
  151.                         System.out.println(" " + (i + 1) + " - " + nomeJogos[i]);
  152.  
  153.                     }
  154.  
  155.                     jogo = scan.nextInt();
  156.  
  157.                     // Definir partida
  158.                     System.out.println(
  159.                             "\nQuais os jogadores que vão enfrentar-se? \nEscolha de 1 à 5 e " + "aperte 'ENTER' ");
  160.  
  161.                     for (int i = 0; i < lin; i++) {
  162.  
  163.                         System.out.println(" " + (i + 1) + " - " + nomePlayer[i]);
  164.  
  165.                     }
  166.  
  167.                     if (jogo > 5 || jogo <= 0) {
  168.  
  169.                         System.out.println("Escolha invalida!!! VOLTANDO AO MENU PRINCIPAL!!!");
  170.                         System.out.println("\n\n------------------------------------------------------------\n\n");
  171.                         break;
  172.  
  173.                     }
  174.  
  175.                     player1 = scan.nextInt(); // Define nome do jogador 1
  176.  
  177.                     System.out.println("\nEscolha o proximo Jogador de 1 a 5 e aperte ENTER: ");
  178.  
  179.                     player2 = scan.nextInt(); // Define o nome do jogador 2
  180.  
  181.                     System.out.println(" ");
  182.  
  183.                     System.out.println("Partida " + partida + " Jogo: " + nomeJogos[jogo - 1]);
  184.  
  185.                     System.out.println(nomePlayer[player1 - 1] + " X " + nomePlayer[player2 - 1]);
  186.  
  187.                     // Verificar se os dados sao validos
  188.                     if (player1 > 5 || player2 > 5 || player1 == player2 || player1 <= 0 || player2 <= 0) {
  189.  
  190.                         System.out.println("Escolha invalida!!! VOLTANDO AO MENU PRINCIPAL!!!");
  191.                         System.out.println("\n\n------------------------------------------------------------\n\n");
  192.                         break;
  193.  
  194.                     }
  195.  
  196.                     System.out.println("------------------------------------------------------------\n\n");
  197.  
  198.                     break;
  199.  
  200.                 case 2:
  201.  
  202.                     // Verifica se a partida ja foi definida
  203.                     if (player1 != 0 || player2 != 0) {
  204.  
  205.                         System.out.println("----------------- PARTIDA " + partida + " -------------------"); // Partida
  206.                                                                                                                 // correspondente
  207.  
  208.                         System.out.println("\nJOGO " + nomeJogos[jogo - 1]);
  209.  
  210.                         System.out.println("\nPLAYER 1        PLAYER 2");
  211.  
  212.                         System.out.println(
  213.                                 "\n" + nomePlayer[player1 - 1] + "     X     " + nomePlayer[player2 - 1] + "\n");
  214.  
  215.                         // Mostra os pontos
  216.                         System.out.println("Esquema de pontuação: vitoria conta 3 pontos  / derrota conta 0 pontos\n");
  217.  
  218.                         System.out.println("------------------------------------------------------------\n\n");
  219.  
  220.                         // Escreve na partida correspondente o resultado do jogo
  221.  
  222.                         System.out.println();
  223.  
  224.                         System.out.println("Quem venceu ?\nPlayer 1 " + nomePlayer[player1 - 1] + " ou " + "Player 2 "
  225.                                 + nomePlayer[player2 - 1] + " ?\nEscolha 1 ou 2 e aperte ENTER");
  226.  
  227.                         win = scan.nextInt();
  228.  
  229.                         // Verifica quem ganhou e coloca altomaticamente o valor e checa validez da
  230.                         // informacao
  231.                         if (win == 1) {
  232.  
  233.                             resultado[player1 - 1][jogo - 1] += 3;
  234.  
  235.                         } else {
  236.                             if (win == 2) {
  237.  
  238.                                 resultado[player2 - 1][jogo - 1] += 3;
  239.  
  240.                             } else {
  241.  
  242.                                 System.out.println("\nEscolha inválida!!! VOLTANDO AO MENU PRINCIPAL!!!");
  243.                                 System.out.println("------------------------------------------------------------\n\n");
  244.  
  245.                                 break;
  246.  
  247.                             }
  248.  
  249.                         }
  250.  
  251.                         partida += 1; // Somar a partida para mostrar a proxima
  252.                         System.out.println("------------------------------------------------------------\n\n");
  253.  
  254.                         break;
  255.  
  256.                     } else {
  257.  
  258.                         System.out.println("Vc ainda nao definiu a partida!!! VOLTANDO AO MENU PRINCIPAL\n\n");
  259.  
  260.                         System.out.println("------------------------------------------------------------\n\n");
  261.  
  262.                         break;
  263.  
  264.                     } // Fim do condicional
  265.  
  266.                 case 3:
  267.  
  268.                     System.out.println("Pontuacão parcial do evento\n");
  269.                     System.out.print("\t");
  270.  
  271.                     for (int i = 0; i < lin; i++) {
  272.  
  273.                         System.out.print(nomeJogos[i] + "  ");
  274.  
  275.                     }
  276.  
  277.                     System.out.println("");
  278.  
  279.                     for (int i = 0; i < lin; i++) { // Exibe matriz completa com os registros atuais
  280.  
  281.                         System.out.print(nomePlayer[i] + "\t");
  282.  
  283.                         for (int j = 0; j < col; j++) {
  284.  
  285.                             System.out.print(resultado[i][j] + "\t");
  286.  
  287.                         }
  288.  
  289.                         System.out.println(" ");
  290.  
  291.                     } // Fim do loop
  292.  
  293.                     System.out.println("------------------------------------------------------------\n\n");
  294.  
  295.                     break;
  296.  
  297.                 case 4:
  298.  
  299.                     // Exibir os jogos para definir novos pontos
  300.                     System.out.println(
  301.                             "Escolha um jogo da lista (de 1 à 5) para definir nova pontuacao e aperte ENTER: ");
  302.  
  303.                     for (int i = 0; i < lin; i++) {
  304.  
  305.                         System.out.println(" " + (i + 1) + " - " + nomeJogos[i]);
  306.  
  307.                     }
  308.  
  309.                     jogo = scan.nextInt();
  310.  
  311.                     // Exibir jogadores para efetuar a troca de pontuacao
  312.                     System.out
  313.                             .println("Qual jogador sera trocada a pontuacão? \nEscolha de 1 à 5 e " + "aperte 'ENTER' ");
  314.  
  315.                     for (int i = 0; i < lin; i++) {
  316.  
  317.                         System.out.println(" " + (i + 1) + " - " + nomePlayer[i]);
  318.  
  319.                     }
  320.  
  321.                     player1 = scan.nextInt(); // Define nome do jogador para trocar pontos
  322.  
  323.                     System.out.println("Quantas partidas o " + nomePlayer[player1 - 1] + " ganhou no jogo "
  324.                             + nomeJogos[jogo - 1] + "?" + "\nDigite o numero de partidas vencidas e aperte ENTER\n"
  325.                                     + "Caso o jogador tenha sido desclassificado no jogo "+nomeJogos[jogo - 1]+""
  326.                                             + " digite ZERO e aperte ENTER");
  327.  
  328.                     win = scan.nextInt() * 3;
  329.  
  330.                     if (win < 0) {
  331.  
  332.                         System.out.println("ERRO, PONTUACÃO INVALIDA!!!");
  333.  
  334.                     } else {
  335.  
  336.                         resultado[player1 - 1][jogo - 1] = win;
  337.  
  338.                         System.out.println("\nNova Pontuação \nPlayer " + nomePlayer[player1 - 1] + "" + ", jogo "
  339.                                 + nomeJogos[jogo - 1] + "\nNova pontuação: " + resultado[player1 - 1][jogo - 1]
  340.                                 + " pontos\n\n"); // Mostra a pontucao nova
  341.  
  342.                         System.out.println("PONTUÇÃO ATUALIZADA COM SUCESSO!!!\n");
  343.  
  344.                     }
  345.  
  346.                     System.out.println("------------------------------------------------------------\n\n");
  347.  
  348.                     break;
  349.  
  350.                 case 5:
  351.  
  352.                     System.out.print("\nDigite o nome do player ou o jogo para saber a pontuacão"
  353.                             + "e a quantidade de partidas vencidas, depois aperte ENTER: \n");
  354.  
  355.                     busca = scan.next().toLowerCase();
  356.  
  357.                     System.out.print("\n");
  358.  
  359.                     for (int i = 0; i < lin; i++) { // Exibe matriz completa com os registros atuais
  360.  
  361.                         if (nomePlayer[i].toLowerCase().equals(busca)) {
  362.  
  363.                             System.out.print(nomePlayer[i] + " teve os seguintes pontos: \n");
  364.  
  365.                             for (int j = 0; j < col; j++) {
  366.  
  367.                                 System.out.print(nomeJogos[j] + ": " + resultado[i][j] + "   ");
  368.  
  369.                                 ganhou[i] += resultado[i][j];
  370.  
  371.                             }
  372.  
  373.                             // Mostra a quantidade parcial de partidas vencidas pelo jogador pesquisado
  374.                             System.out.print("\n" + nomePlayer[i] + " ganhou: " + ganhou[i] / 3 + " partidas ");
  375.  
  376.                             i = lin;
  377.  
  378.                         } else {
  379.                             if (nomeJogos[i].toLowerCase().equals(busca)) {
  380.  
  381.                                 System.out.print(nomeJogos[i] + " teve os seguintes pontos dos jogadores: \n");
  382.  
  383.                                 for (int j = 0; j < col; j++) {
  384.  
  385.                                     System.out.print(nomePlayer[j] + ": " + resultado[j][i] + "   ");
  386.  
  387.                                 }
  388.  
  389.                                 i = lin;
  390.  
  391.                             } else {
  392.                                 if (i == lin - 1) {
  393.  
  394.                                     System.out.print(
  395.                                             "Player ou jogo selecionado nao existe no nosso sistema!!!\nVOLTANDO AO MENU PRINCIPAL!!!");
  396.                                     System.out.println(
  397.                                             "------------------------------------------------------------\n\n");
  398.  
  399.                                 }
  400.  
  401.                             }
  402.  
  403.                         } // Fim dos condicionais
  404.  
  405.                     } // Fim do loop
  406.  
  407.                     System.out.print("\n\n\n");
  408.                     System.out.println("------------------------------------------------------------\n\n");
  409.  
  410.                     break;
  411.  
  412.                 case 6:
  413.  
  414.                     exit = 0;
  415.                     System.out.println("------------------------------------------------------------\n\n");
  416.  
  417.                     break;
  418.  
  419.                 }
  420.  
  421.             } // Fim do teste para saber se o op eh valido
  422.  
  423.         } while (exit != 0);
  424.  
  425.         // Mostra resultado final do jogo
  426.         System.out.println("Resultado final do evento de cada jogador\n");
  427.  
  428.         System.out.print("\t");
  429.  
  430.         for (int i = 0; i < lin; i++) { // Exibe nome dos jogos em linha reta para desenhar a tabela
  431.  
  432.             System.out.print(nomeJogos[i] + "  ");
  433.  
  434.         }
  435.  
  436.         System.out.println("");
  437.  
  438.         for (int i = 0; i < lin; i++) { // Exibe matriz completa com os registros atuais
  439.  
  440.             System.out.print(nomePlayer[i] + "\t");
  441.  
  442.             for (int j = 0; j < col; j++) {
  443.  
  444.                 System.out.print(resultado[i][j] + "\t");
  445.                 ganhou[i] += resultado[i][j];
  446.  
  447.             }
  448.  
  449.             System.out.println(" ");
  450.  
  451.         } // Fim do loop
  452.             System.out.println(" ");
  453.  
  454.         // Ver quem ganhou o evento
  455.         // Reaproveitar variaveis que tem nome sugestivo ao uso
  456.         win = ganhou[0];
  457.         jogo = 0;
  458.  
  459.         for (int i = 1; i < lin; i++) {
  460.  
  461.             if (ganhou[i] > win) {
  462.  
  463.                 win = ganhou[i];
  464.  
  465.                 jogo = i;
  466.  
  467.             }
  468.  
  469.         } // Fim do loop
  470.  
  471.         System.out.println(" ");
  472.  
  473.         // Verificar se a variavel win tem pontos, se nao tiver ninguem ganhou
  474.         if (win != 0) {
  475.  
  476.             System.out.println("O vencedor do torneiro é " + nomePlayer[jogo] + " com o total de " + ganhou[jogo] + ""
  477.                     + " no placar geral\nPARABENS\n!!!");
  478.  
  479.         } else {
  480.  
  481.             System.out.println("Por incrível que pareça ninguém ganhou!!!!!\n\n\n");
  482.  
  483.         } // Fim do condicional
  484.  
  485.         System.out.println("\nFIM DO PROGRAMA");
  486.  
  487.     } // Fim do metodo main
  488.  
  489. } // Fim da classe Jogadores
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement