C / C++ Programa do Bolão da copa

[NullS3c]

Eu tive que fazer um trabalho valendo nota de prova pra criar um programa que fizesse um bolão da copa do mundo, tentei implementar as regras de negocio e sei que algumas coisinhas estão funcionando eu não sei pois metade do código não era minha parte e implementei no dia da apresentação e não testei... enfim tá ai o código, espero que isso sirva para incrementar um pouco de conhecimento aos iniciantes e lógica também, pois queimei a mufa por 3 dias fazendo.

#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#include<string.h>

void menup();//menu principal
void cad_paism();//cadastra paises manualmente
void cad_paisa();//cadastra paises automaticamente
void cad_part();//cadastra participantes
void f_primeira();//função da primeira chave
void f_oitava();//funçao para determinar times da oitavas de final e gerar tabela das quarta
void f_quarta();//funçao para determinar times da quarta de final e gerar tabela das semi
void f_semi();//funçao para determinar times que vao para a final e 3° e 4° colocado
void f_final();//funçao para determinar time vencedor e semi
void f_terceiro();//funçao que determina terceiro e quarto
void m_placar();//sub-menu de saida de placares
void p_fase1();//placares da primeira fase
void p_oitava();//placar das oitavas de final
void p_quarta();//placar das quartas de final
void p_semi();//placar das semi finais
void p_final();//placar da final
void p_terceiro();//placar da decisao de terceiro e quarto colocado
void info_pais();//funçao que mostra dados de cada pais cadastrado
void info_part();//funão que mostra informaçoes dos participantes
void pontos_part();//funçao que define o quanto de pontos cada jogador fez
void part_gan();

//fase1_scan = serve para automatizar o processo de ler o placar que o usuario escolheu pra cada time de cada chave e faz a soma de numero de pontos
//numero de vitorias, empates e derrotas
#define fase1_scan\
printf("%s\tvs.\t%s\t\n\n%s: ", ID_pais[conf[x][0]].nome_pais, ID_pais[conf[x][1]].nome_pais, ID_pais[conf[x][0]].nome_pais);\
scanf("%d", &conf[x][2]);ID_pais[conf[x][0]].njogos++;\
ID_pais[conf[x][0]].gols = ID_pais[conf[x][0]].gols + conf[x][2];\
printf("%s: ",ID_pais[conf[x][1]].nome_pais);\
scanf("%d", &conf[x][3]);ID_pais[conf[x][1]].njogos++;\
ID_pais[conf[x][1]].gols = ID_pais[conf[x][1]].gols + conf[x][3];\
if(conf[x][2] > conf[x][3]){\
ID_pais[conf[x][0]].vitorias++;ID_pais[conf[x][0]].pontos = (ID_pais[conf[x][0]].pontos + 3);\
ID_pais[conf[x][1]].derrotas++;}else if(conf[x][2] < conf[x][3]){\
ID_pais[conf[x][1]].vitorias++;ID_pais[conf[x][1]].pontos = (ID_pais[conf[x][1]].pontos + 3);ID_pais[conf[x][0]].derrotas++;\
}else{ID_pais[conf[x][1]].empates++;ID_pais[conf[x][1]].pontos = ID_pais[conf[x][1]].pontos + 1;\
ID_pais[conf[x][0]].empates++;ID_pais[conf[x][0]].pontos = ID_pais[conf[x][0]].pontos + 1;}\
printf("\n\n");\
}

//fase1_conf = serve para automatizar o processo de determinar quais paises vai se enfrentrar dentro de cada chave
#define fase1_conf\
conf[n][0] = chaves[s][0];\
conf[n][1] = chaves[s][1];\
n++;\
conf[n][0] = chaves[s][0];\
conf[n][1] = chaves[s][2];\
n++;\
conf[n][0] = chaves[s][0];\
conf[n][1] = chaves[s][3];\
n++;\
conf[n][0] = chaves[s][1];\
conf[n][1] = chaves[s][2];\
n++;\
conf[n][0] = chaves[s][1];\
conf[n][1] = chaves[s][3];\
n++;\
conf[n][0] = chaves[s][2];\
conf[n][1] = chaves[s][3];\
n++;\
}

//opcao = opicao que o usuario escolhe no menu
//ponto_total = ponto somado de todos os partifipantes
//chaves = tabelha que vai organizar os times pela chave
//conf = tabela com todos os confrontos, tendo os respectivos times e placar da primeira fase
//conf8 = tabela com os confrontos das oitavas de final
//qua = tabela com os paises que foram para as quartas
//conf4 = tabela de confrontos das quartas de finais
//semi = tabela de paises que foram para as semi-finais
//conf_semi = tabela de confrontos da semi-final
//ter = tabela de confronto pelo 3° lugar
//fin = tabela de confronto pelo 1° lugar
//four = tabela de dos paises que ficaram de 1° á 4° lugar
//gan = variavel que diz qual o participante ganhador
int opcao,ponto_total,chaves[8][4],conf[48][4],oit[8][2],conf8[8][4],qua[8],conf4[4][4],semi[4],conf_semi[2][4],ter[2][2],fin[2][2],four[4];
float valor_total;//valor total de pontos de todos os participanter

typedef struct{
char continente[25];
char nome_pais[25];
int pontos;//pontos adiquirido, quando o pais ganha uma partida ele ganha 3 pontos, se empata ele ganha 1 ponto
int gols;//total de gols por pais
int vitorias;//total de vitorias
int derrotas;//total de derrotas
int empates;//total de empates
int njogos;//numero de vezes que jogou
char chave;//letra da chave a que pertence
}Pais;
Pais ID_pais[32];

typedef struct{
char nome_part[10];//nome do participante
int ponto_part;//quantidade de pontos que o participante tem
float valor_dado;//valor que o participante deu
int quarta[8];//tabela de paises apostados pra quarta de final pelo participante
int semi[4];//tabela de paises apostados pra semi de final pelo participante
int final[2];//tabela depaises apostados para a final
int quarto;//paises apostados pra 4° colocado pelo participante
int terceiro;//paises apostados pra 3° colocado pelo participante
int vice;//paises apostados pra 2° colocado pelo participante
int vencedor;//paises apostados pra 1° colocado pelo participante
}Ficha;
Ficha ficha[10];

main(){
system("color f0");//fundo branco letra preta
int fim=1;
do{
menup();//gunçao em que tem os prints de cada opçao
switch (opcao){
case 1rintf("\a");
cad_paism();
break;
case 2rintf("\a");
cad_paisa();
break;
case 3rintf("\a");
cad_part();
break;
case 4rintf("\a");
f_primeira();
break;
case 5rintf("\a");
m_placar();
break;
case 6rintf("\a");
part_gan();
break;
case 7rintf("\a");
info_part();
break;
case 8rintf("\a");
info_pais();
break;
case 9rintf("\a");
fim=0;
break;
default: printf("Opcao invalida\n");
getch();
}
}while(fim);
printf("================================= FIM PROGRAMA ================================");
getch();
}

void menup(){
system("cls");
printf("========================= M E N U P R I N C I P A L =========================\n");
printf("\n\nENTRADA:\n");
printf("\n1 - Cadastro de paises manualmente\n");
printf("\n2 - Cadastro de paises automaticamente\n");
printf("\n3 - Cadastrar participantes do bolao\n");
printf("\n4 - Definir placares\n");
printf("\n\nSAIDA:\n");
printf("\n5 - Mostrar placar\n");
printf("\n6 - Mostrar vencedor do bolao\n");
printf("\n7 - Mostrar informacoes dos participantes\n");
printf("\n8 - Mostrar informacoes dos paises\n");
printf("\n\n9 - Sair\n");
printf("\nEscolha uma das opcoes: ");
scanf("%d",&opcao);
}

void cad_paism(){//funçao que cadastra manualmente informaçoes principais dos paises para os jogos
for(int x = 0;x<32;x++){
system("cls");
printf("============================== CADASTRO DE PAISES ==============================\n");
printf("Digite o continente do pais de ID %d: ",x);
scanf(" %s",&ID_pais[x].continente);
printf("Digite o nome do pais de ID %d: ",x);
scanf(" %s",&ID_pais[x].nome_pais);
printf("Digite a chave: ");
scanf(" %c",&ID_pais[x].chave);
}
}

void cad_part(){//cadastra os participantes do bolao manuamente com suas informaçoes
for(int x = 0;x<10;x++){
system("cls");
printf("=========================== CADASTRO DE PARTICIPANTES ==========================\n");
printf("TABELA DE PAISES:\n\nID\tNOME\n");

for(int y = 0;y<32;y++){
printf("%d\t%s\n",y, ID_pais[y].nome_pais);

}
printf("\nDigite o nome do participante %d: ",x+1);
scanf(" %s",&ficha[x].nome_part);
printf("\nDigite a aposta dos paises que vao para as quartas de final pelo ID: \n");
for(int y = 0;y<8;y++){
scanf("%d",&ficha[x].quarta[y]);
}
printf("\nDigite a aposta dos paises que vao para as semi-finais pelo ID: \n");
for(int y = 0;y<4;y++){
scanf("%d",&ficha[x].semi[y]);
}
printf("\nDigite a aposta dos paises que para as finais pelo ID: \n");
for(int y =0;y<2;y++){
scanf(" %d",&ficha[x].final[y]);
}
printf("\nDigite a aposta do pais que vai ficar em quarto lugar: ");
scanf("%d",&ficha[x].quarto);
printf("\nDigite a aposta do pais que vai ficar em terceiro lugar: ");
scanf("%d",&ficha[x].terceiro);
printf("\nDigite a aposta do pais que vai ser vice: ");
scanf("%d",&ficha[x].semi);
printf("\nDigite a aposta do que vai ser campeao: ");
scanf("%d",&ficha[x].vencedor);
printf("\nDigite o valor dado pelo participante: R$ ");
scanf("%f",&ficha[x].valor_dado);
valor_total += ficha[x].valor_dado;
}
}

void cad_paisa(){//faz cadastro automatico de cada pais
strcpy(ID_pais[0].continente, "Europa");
strcpy(ID_pais[0].nome_pais, "Alemanha");
ID_pais[0].chave = 'A';

strcpy(ID_pais[1].continente, "Europa");
strcpy(ID_pais[1].nome_pais, "Croacia");
ID_pais[1].chave = 'F';

strcpy(ID_pais[2].continente, "Europa");
strcpy(ID_pais[2].nome_pais, "Franca");
ID_pais[2].chave = 'G';

strcpy(ID_pais[3].continente, "Europa");
strcpy(ID_pais[3].nome_pais, "Paises Baixos");
ID_pais[3].chave = 'C';

strcpy(ID_pais[4].continente, "Europa");
strcpy(ID_pais[4].nome_pais, "Inglaterra");
ID_pais[4].chave = 'B';

strcpy(ID_pais[5].continente, "Europa");
strcpy(ID_pais[5].nome_pais, "Italia");
ID_pais[5].chave = 'E';

strcpy(ID_pais[6].continente, "Europa");
strcpy(ID_pais[6].nome_pais, "Polonia");
ID_pais[6].chave = 'A';

strcpy(ID_pais[7].continente, "Europa");
strcpy(ID_pais[7].nome_pais, "Portugal");
ID_pais[7].chave = 'D';

strcpy(ID_pais[8].continente, "Europa");
strcpy(ID_pais[8].nome_pais, "Servia e Montenegro");
ID_pais[8].chave = 'C';

strcpy(ID_pais[9].continente, "Europa");
strcpy(ID_pais[9].nome_pais, "Suecia");
ID_pais[9].chave = 'B';

strcpy(ID_pais[10].continente, "Europa");
strcpy(ID_pais[10].nome_pais, "Ucrania");
ID_pais[10].chave = 'H';

strcpy(ID_pais[11].continente, "Europa");
strcpy(ID_pais[11].nome_pais, "Suica");
ID_pais[11].chave = 'G';

strcpy(ID_pais[12].continente, "Europa");
strcpy(ID_pais[12].nome_pais, "Espanha");
ID_pais[12].chave = 'H';

strcpy(ID_pais[13].continente, "Europa");
strcpy(ID_pais[13].nome_pais, "Republica Tcheca");
ID_pais[13].chave = 'E';

strcpy(ID_pais[14].continente, "America do Sul");
strcpy(ID_pais[14].nome_pais, "Argentina");
ID_pais[14].chave = 'C';

strcpy(ID_pais[15].continente, "America do Sul");
strcpy(ID_pais[15].nome_pais, "Brasil");
ID_pais[15].chave = 'F';

strcpy(ID_pais[16].continente, "America do Sul");
strcpy(ID_pais[16].nome_pais, "Equador");
ID_pais[16].chave = 'A';

strcpy(ID_pais[17].continente, "America do Sul");
strcpy(ID_pais[17].nome_pais, "Paraguai");
ID_pais[17].chave = 'B';

strcpy(ID_pais[18].continente, "America do Norte");
strcpy(ID_pais[18].nome_pais, "Estados Unidos");
ID_pais[18].chave = 'E';

strcpy(ID_pais[19].continente, "America do Norte");
strcpy(ID_pais[19].nome_pais, "Mexico");
ID_pais[19].chave = 'D';

strcpy(ID_pais[20].continente, "America Central");
strcpy(ID_pais[20].nome_pais, "Trinidad e Tobago");
ID_pais[20].chave = 'B';

strcpy(ID_pais[21].continente, "America Central");
strcpy(ID_pais[21].nome_pais, "Costa Rica");
ID_pais[21].chave = 'A';

strcpy(ID_pais[22].continente, "Asia");
strcpy(ID_pais[22].nome_pais, "Arabia Saudita");
ID_pais[22].chave = 'H';

strcpy(ID_pais[23].continente, "Asia");
strcpy(ID_pais[23].nome_pais, "Coreia do Sul");
ID_pais[23].chave = 'G';

strcpy(ID_pais[24].continente, "Asia");
strcpy(ID_pais[24].nome_pais, "Japao");
ID_pais[24].chave = 'F';

strcpy(ID_pais[25].continente, "Asia");
strcpy(ID_pais[25].nome_pais, "Ira");
ID_pais[25].chave = 'D';

strcpy(ID_pais[26].continente, "Africa");
strcpy(ID_pais[26].nome_pais, "Angola");
ID_pais[26].chave = 'D';

strcpy(ID_pais[27].continente, "Africa");
strcpy(ID_pais[27].nome_pais, "Costa do Marfim");
ID_pais[27].chave = 'C';

strcpy(ID_pais[28].continente, "Africa");
strcpy(ID_pais[28].nome_pais, "Gana");
ID_pais[28].chave = 'E';

strcpy(ID_pais[29].continente, "Africa");
strcpy(ID_pais[29].nome_pais, "Togo");
ID_pais[29].chave = 'G';

strcpy(ID_pais[30].continente, "Africa");
strcpy(ID_pais[30].nome_pais, "Tunisia");
ID_pais[30].chave = 'H';

strcpy(ID_pais[31].continente, "Oceania");
strcpy(ID_pais[31].nome_pais, "Australia");
ID_pais[31].chave = 'F';
}

void f_primeira(){
system("cls");
printf("================================ PRIMEIRA FASE =================================\n\n");
//funçao que serve para fazer
// y = numero referente ao grupo, demais letras fazem o controle dos times que vão entrar em cada grupo
for(int y=0;y<8;y++)
for(int x=0,a=0,b=0,c=0,d=0,e=0,f=0,g=0,h=0;x<32;x++){
if(ID_pais[x].chave == 'A' && y==0){
chaves[y][a] = x;
a++;
}else if(ID_pais[x].chave == 'B' && y==1){
chaves[y][b] = x;
b++;
}else if(ID_pais[x].chave == 'C' && y==2){
chaves[y][c] = x;
c++;
}else if(ID_pais[x].chave == 'D' && y==3){
chaves[y][d] = x;
d++;
}else if(ID_pais[x].chave == 'E' && y==4){
chaves[y][e] = x;
e++;
}else if(ID_pais[x].chave == 'F' && y==5){
chaves[y][f] = x;
f++;
}else if(ID_pais[x].chave == 'G' && y==6){
chaves[y][g] = x;
g++;
}else if(ID_pais[x].chave == 'H' && y==7){
chaves[y][h] = x;
h++;
}
}


printf("\nConfrontos da chave A:\n\n");
// n = numero do confronto
//s = chave, 2° campo de conf é primeiro time e segundo time, 2° campo de chaves é um time especifico
for(int x=0,n=0,s=0;x<1;x++){
fase1_conf;

for(int x=0,n=6,s=1;x<1;x++){
fase1_conf;

for(int x=0,n=12,s=2;x<1;x++){
fase1_conf;

for(int x=0,n=18,s=3;x<1;x++){
fase1_conf;

for(int x=0,n=24,s=4;x<1;x++){
fase1_conf;

for(int x=0,n=30,s=5;x<1;x++){
fase1_conf;

for(int x=0,n=36,s=6;x<1;x++){
fase1_conf;

for(int x=0,n=42,s=7;x<1;x++){
fase1_conf;

system("cls");
printf("\nConfrontos da chave A:\n\n\t PAISES\n\n");
for(int x=0;x<6;x++){
fase1_scan;

system("cls");
printf("\nConfrontos da chave B:\n\n\t PAISES\n\n");
for(int x=6;x<(2*6);x++){
fase1_scan;

system("cls");
printf("\nConfrontos da chave C:\n\n\t PAISES\n\n");
for(int x=12;x<(3*6);x++){
fase1_scan;

system("cls");
printf("\nConfrontos da chave D:\n\n\t PAISES\n\n");
for(int x=18;x<(4*6);x++){
fase1_scan;

system("cls");
printf("\nConfrontos da chave E:\n\n\t PAISES\n\n");
for(int x=24;x<(5*6);x++){
fase1_scan;

system("cls");
printf("\nConfrontos da chave F:\n\n\t PAISES\n\n");
for(int x=30;x<(6*6);x++){
fase1_scan;

system("cls");
printf("\nConfrontos da chave G:\n\n\t PAISES\n\n");
for(int x=36;x<(7*6);x++){
fase1_scan;

system("cls");
printf("\nConfrontos da chave H:\n\n\t PAISES\n\n");
for(int x=42;x<(8*6);x++){
fase1_scan;

int a=3,auxiliar;
for(int w=0;w<8;w++){
for(int b=0;b<a;b++)
for(int c=0;c<a;c++)
if(ID_pais[chaves[w][c]].pontos>ID_pais[chaves[w][c+1]].pontos){
auxiliar=chaves[w][c];
chaves[w][c]=chaves[w][c+1];
chaves[w][c+1]=auxiliar;
}

if(ID_pais[chaves[w][3]].pontos == 9){
oit[w][0] = chaves[w][3];
printf("pt %d primeiro , pais %d\n",ID_pais[chaves[w][3]].pontos, oit[w][0]);
oit[w][1] = chaves[w][2];
printf("pt %d segundo , pais %d\n\n",ID_pais[chaves[w][2]].pontos, oit[w][1]);
}else if(ID_pais[chaves[w][3]].gols > ID_pais[chaves[w][2]].gols){
oit[w][0] = chaves[w][3];
printf("pt %d primeiro , pais %d\n",ID_pais[chaves[w][3]].pontos, oit[w][0]);
oit[w][1] = chaves[w][2];
printf("pt %d segundo , pais %d\n\n",ID_pais[chaves[w][2]].pontos, oit[w][1]);
}else{
oit[w][0] = chaves[w][2];
printf("pt %d primeiro , pais %d\n",ID_pais[chaves[w][3]].pontos, oit[w][0]);
oit[w][1] = chaves[w][3];
printf("pt %d segundo , pais %d\n\n",ID_pais[chaves[w][2]].pontos, oit[w][1]);
}
}

getch();
f_oitava();
}


void f_oitava(){
system("cls");
printf("=============================== OITAVAS DE FINAL ===============================\n\n");

printf("Confrontos das oitavas de final");
for(int x=0,y=0,w;x<4;x++,y++){
w=y+1;
conf8[y][0]=oit[y][0];
conf8[y][1]=oit[w][1];
y++;
w=y-1;
conf8[y][0]=oit[w][1];
conf8[y][1]=oit[y][0];
}


for(int x=0;x<8;x++){
printf("\n\n%s\t vs.\t%s\n\n%s: ",ID_pais[conf8[x][0]].nome_pais, ID_pais[conf8[x][1]].nome_pais, ID_pais[conf8[x][0]].nome_pais);
scanf(" %d",&conf8[x][2]);
ID_pais[conf8[x][0]].gols += conf8[x][2];
ID_pais[conf8[x][0]].njogos++;
printf("%s: ",ID_pais[conf8[x][1]].nome_pais);
scanf(" %d",&conf8[x][3]);
ID_pais[conf8[x][1]].gols += conf8[x][3];
ID_pais[conf8[x][1]].njogos++;
}

for(int x=0;x<8;x++){
if(conf8[x][2] < conf8[x][3]){
qua[x] = conf8[x][1];
ID_pais[conf8[x][1]].vitorias++;
ID_pais[conf8[x][0]].derrotas++;
}else{
qua[x] = conf8[x][0];
ID_pais[conf8[x][0]].vitorias++;
ID_pais[conf8[x][1]].derrotas++;
}
}

for(int x=0;x<4;x++)
conf4[x][0] = qua[x];
for(int x=0,y=4;x<4;x++,y++)
conf4[x][1] = qua[y];
getch();
f_quarta();
}

void f_quarta(){
system("cls");
printf("=============================== QUARTAS DE FINAL ===============================");

for(int x=0;x<4;x++){
printf("\n\n%s\tvs.\t%s\n\n%s: ",ID_pais[conf4[x][0]].nome_pais,ID_pais[conf4[x][1]].nome_pais,ID_pais[conf4[x][0]].nome_pais);
scanf("%d",&conf4[x][2]);
ID_pais[conf4[x][0]].gols += conf4[x][2];
ID_pais[conf4[x][0]].njogos++;
printf("%s: ",ID_pais[conf4[x][1]].nome_pais);
scanf("%d",&conf4[x][3]);
ID_pais[conf4[x][1]].gols += conf4[x][3];
ID_pais[conf4[x][1]].njogos++;
}

for(int x=0;x<4;x++){
if(conf4[x][2] < conf4[x][3]){
semi[x] = conf4[x][1];
ID_pais[conf4[x][1]].vitorias++;
ID_pais[conf4[x][0]].derrotas++;
}else{
semi[x] = conf4[x][0];
ID_pais[conf4[x][0]].vitorias++;
ID_pais[conf4[x][1]].derrotas++;
}
}

for(int x=0;x<2;x++)
conf_semi[x][0] = semi[x];
for(int x=0,y=2;x<2;x++,y++)
conf_semi[x][1] = semi[y];

getch();
f_semi();
}

void f_semi(){
system("cls");
printf("================================== SEMI FINAIS =================================");

for(int x=0;x<2;x++){
printf("\n\n%s\tvs.\t%s\n\n%s: ",ID_pais[conf_semi[x][0]].nome_pais,ID_pais[conf_semi[x][1]].nome_pais,ID_pais[conf_semi[x][0]].nome_pais);
scanf("%d",&conf_semi[x][2]);
ID_pais[conf_semi[x][0]].gols += conf_semi[x][2];
ID_pais[conf_semi[x][0]].njogos++;
printf("%s: ",ID_pais[conf_semi[x][1]].nome_pais);
scanf("%d",&conf_semi[x][3]);
ID_pais[conf_semi[x][1]].gols += conf_semi[x][3];
ID_pais[conf_semi[x][1]].njogos++;
}


for(int x=0;x<2;x++){
if(conf_semi[x][2] < conf_semi[x][3]){
fin[x][0] = conf_semi[x][1];
ter[x][0] = conf_semi[x][0];
ID_pais[conf_semi[x][1]].vitorias++;
ID_pais[conf_semi[x][0]].derrotas++;
}else{
fin[x][0] = conf_semi[x][0];
ter[x][0] = conf_semi[x][1];
ID_pais[conf_semi[x][0]].vitorias++;
ID_pais[conf_semi[x][1]].derrotas++;
}
}

getch();
f_final();
}

void f_final(){
system("cls");
printf("===================================== FINAL ====================================");

printf("\n\n%s\tvs.\t%s\n\n%s: ",ID_pais[fin[0][0]].nome_pais,ID_pais[fin[1][0]].nome_pais,ID_pais[fin[0][0]].nome_pais);
scanf("%d",&fin[0][1]);
ID_pais[fin[0][0]].gols += fin[0][1];
ID_pais[fin[0][0]].njogos++;
printf("%s: ",ID_pais[fin[1][0]].nome_pais);
scanf("%d",&fin[1][1]);
ID_pais[fin[1][0]].gols += fin[1][1];
ID_pais[fin[1][0]].njogos++;

if(fin[0][1] < fin[1][1]){
printf("\n\nThe %s is the WINNER !!!",ID_pais[fin[1][0]].nome_pais);
four[0] = fin[1][0];
four[1] = fin[0][0];
ID_pais[fin[1][0]].vitorias++;
ID_pais[fin[0][0]].derrotas++;
}else{
printf("\n\nThe %s is the WINNER !!!",ID_pais[fin[0][0]].nome_pais);
four[0] = fin[0][0];
four[1] = fin[1][0];
ID_pais[fin[0][0]].vitorias++;
ID_pais[fin[1][0]].derrotas++;
}

getch();
f_terceiro();
}

void f_terceiro(){
system("cls");
printf("============================= DECISAO TERCEIRO LUGAR ===========================\n\n");

printf("\n\n%s\tvs.\t%s\n\n%s: ",ID_pais[ter[0][0]].nome_pais,ID_pais[ter[1][0]].nome_pais,ID_pais[ter[0][0]].nome_pais);
scanf("%d",&ter[0][1]);
ID_pais[ter[0][0]].gols += ter[0][1];
ID_pais[ter[0][0]].njogos++;
printf("%s: ",ID_pais[ter[1][0]].nome_pais);
scanf("%d",&ter[1][1]);
ID_pais[ter[1][0]].gols += ter[1][1];
ID_pais[ter[1][0]].njogos++;

if(ter[0][1] < ter[1][1]){
printf("\n\n%s ficou em terceiro",ID_pais[ter[1][0]].nome_pais);
four[2] = ter[1][0];
four[3] = ter[0][0];
ID_pais[ter[1][0]].vitorias++;
ID_pais[ter[0][0]].derrotas++;
}else{
printf("\n\n%s ficou em terceiro",ID_pais[ter[0][0]].nome_pais);
four[2] = ter[0][0];
four[3] = ter[1][0];
ID_pais[ter[0][0]].vitorias++;
ID_pais[ter[1][0]].derrotas++;
}

getch();
pontos_part();
}

void m_placar(){

int end=1;
do{
system("cls");
printf("=============================== SUB-MENU: PLACARES =============================\n\n");
printf("1 - Mostrar placar da primeira fase\n");
printf("\n2 - Mostrar placar das oitavas de final\n");
printf("\n3 - Mostrar placar das quartas de final\n");
printf("\n4 - Mostrar placar das semi-finais\n");
printf("\n5 - Mostrar placar da final\n");
printf("\n6 - Mostrar placar do confronto pelo terceiro lugar\n");
printf("\n7 - Mostrar placar de todos os jogos\n");
printf("\n8 - Voltar ao menu anterior\n\n");
printf("Opcao selecionada: ");
scanf("%d",&opcao);
switch(opcao){
case 1rintf("\a");
p_fase1();
break;
case 2rintf("\a");
p_oitava();
break;
case 3rintf("\a");
p_quarta();
break;
case 4rintf("\a");
p_semi();
break;
case 5rintf("\a");
p_final();
break;
case 6rintf("\a");
p_terceiro();
break;
case 7rintf("\a");
p_fase1();
printf("\n\n");
p_oitava();
printf("\n\n");
p_quarta();
printf("\n\n");
p_semi();
printf("\n\n");
p_final();
printf("\n\n");
p_terceiro();
break;
case 8rintf("\a");
end=0;
break;
default: printf("Opcao invalida\n");
getch();
}
}while(end);
}


void p_fase1(){
system("cls");
printf("============================== PLACAR PRIMEIRA FASE ============================\n\n");
printf("\nConfrontos da chave A:\n\n\t PAISES\n\n");
for(int x=0;x<6;x++)
printf("%s\tvs.\t%s\n\n%s\tGol(s): %d\n%s\tGol(s): %d\n\n", ID_pais[conf[x][0]].nome_pais, ID_pais[conf[x][1]].nome_pais,ID_pais[conf[x][0]].nome_pais,conf[x][2],ID_pais[conf[x][1]].nome_pais,conf[x][3]);

printf("\nConfrontos da chave B:\n\n\t PAISES\n\n");
for(int x=6;x<(2*6);x++)
printf("%s\tvs.\t%s\n\n%s\tGol(s): %d\n%s\tGol(s): %d\n\n", ID_pais[conf[x][0]].nome_pais, ID_pais[conf[x][1]].nome_pais,ID_pais[conf[x][0]].nome_pais,conf[x][2],ID_pais[conf[x][1]].nome_pais,conf[x][3]);

printf("\nConfrontos da chave C:\n\n\t PAISES\n\n");
for(int x=12;x<(3*6);x++)
printf("%s\tvs.\t%s\n\n%s\tGol(s): %d\n%s\tGol(s): %d\n\n", ID_pais[conf[x][0]].nome_pais, ID_pais[conf[x][1]].nome_pais,ID_pais[conf[x][0]].nome_pais,conf[x][2],ID_pais[conf[x][1]].nome_pais,conf[x][3]);

printf("\nConfrontos da chave D:\n\n\t PAISES\n\n");
for(int x=18;x<(4*6);x++)
printf("%s\tvs.\t%s\n\n%s\tGol(s): %d\n%s\tGol(s): %d\n\n", ID_pais[conf[x][0]].nome_pais, ID_pais[conf[x][1]].nome_pais,ID_pais[conf[x][0]].nome_pais,conf[x][2],ID_pais[conf[x][1]].nome_pais,conf[x][3]);

printf("\nConfrontos da chave E:\n\n\t PAISES\n\n");
for(int x=24;x<(5*6);x++)
printf("%s\tvs.\t%s\n\n%s\tGol(s): %d\n%s\tGol(s): %d\n\n", ID_pais[conf[x][0]].nome_pais, ID_pais[conf[x][1]].nome_pais,ID_pais[conf[x][0]].nome_pais,conf[x][2],ID_pais[conf[x][1]].nome_pais,conf[x][3]);

printf("\nConfrontos da chave F:\n\n\t PAISES\n\n");
for(int x=30;x<(6*6);x++)
printf("%s\tvs.\t%s\n\n%s\tGol(s): %d\n%s\tGol(s): %d\n\n", ID_pais[conf[x][0]].nome_pais, ID_pais[conf[x][1]].nome_pais,ID_pais[conf[x][0]].nome_pais,conf[x][2],ID_pais[conf[x][1]].nome_pais,conf[x][3]);

printf("\nConfrontos da chave G:\n\n\t PAISES\n\n");
for(int x=36;x<(7*6);x++)
printf("%s\tvs.\t%s\n\n%s\tGol(s): %d\n%s\tGol(s): %d\n\n", ID_pais[conf[x][0]].nome_pais, ID_pais[conf[x][1]].nome_pais,ID_pais[conf[x][0]].nome_pais,conf[x][2],ID_pais[conf[x][1]].nome_pais,conf[x][3]);

printf("\nConfrontos da chave H:\n\n\t PAISES\n\n");
for(int x=42;x<(8*6);x++)
printf("%s\tvs.\t%s\n\n%s\tGol(s): %d\n%s\tGol(s): %d\n\n", ID_pais[conf[x][0]].nome_pais, ID_pais[conf[x][1]].nome_pais,ID_pais[conf[x][0]].nome_pais,conf[x][2],ID_pais[conf[x][1]].nome_pais,conf[x][3]);

printf("\nConfrontos da chave H:\n\n\t PAISES\n\n");

printf("\nGanhadores da primeira fase:\n\n");

printf("\nGrupo A\nPrimeiro colocado: %s\tPontos: %d\nSegundo colocado: %s\tPontos: %d\n", ID_pais[oit[0][0]].nome_pais,ID_pais[oit[0][0]].pontos,ID_pais[oit[0][1]].nome_pais,ID_pais[oit[0][1]].pontos);
printf("\nGrupo B\nPrimeiro colocado: %s\tPontos: %d\nSegundo colocado: %s\tPontos: %d\n", ID_pais[oit[1][0]].nome_pais,ID_pais[oit[1][0]].pontos,ID_pais[oit[1][1]].nome_pais,ID_pais[oit[1][1]].pontos);
printf("\nGrupo C\nPrimeiro colocado: %s\tPontos: %d\nSegundo colocado: %s\tPontos: %d\n", ID_pais[oit[2][0]].nome_pais,ID_pais[oit[2][0]].pontos,ID_pais[oit[2][1]].nome_pais,ID_pais[oit[2][1]].pontos);
printf("\nGrupo D\nPrimeiro colocado: %s\tPontos: %d\nSegundo colocado: %s\tPontos: %d\n", ID_pais[oit[3][0]].nome_pais,ID_pais[oit[3][0]].pontos,ID_pais[oit[3][1]].nome_pais,ID_pais[oit[3][1]].pontos);
printf("\nGrupo E\nPrimeiro colocado: %s\tPontos: %d\nSegundo colocado: %s\tPontos: %d\n", ID_pais[oit[4][0]].nome_pais,ID_pais[oit[4][0]].pontos,ID_pais[oit[4][1]].nome_pais,ID_pais[oit[4][1]].pontos);
printf("\nGrupo F\nPrimeiro colocado: %s\tPontos: %d\nSegundo colocado: %s\tPontos: %d\n", ID_pais[oit[5][0]].nome_pais,ID_pais[oit[5][0]].pontos,ID_pais[oit[5][1]].nome_pais,ID_pais[oit[5][1]].pontos);
printf("\nGrupo G\nPrimeiro colocado: %s\tPontos: %d\nSegundo colocado: %s\tPontos: %d\n", ID_pais[oit[6][0]].nome_pais,ID_pais[oit[6][0]].pontos,ID_pais[oit[6][1]].nome_pais,ID_pais[oit[6][1]].pontos);
printf("\nGrupo H\nPrimeiro colocado: %s\tPontos: %d\nSegundo colocado: %s\tPontos: %d\n", ID_pais[oit[7][0]].nome_pais,ID_pais[oit[7][0]].pontos,ID_pais[oit[7][1]].nome_pais,ID_pais[oit[7][1]].pontos);
getch();
}

void p_oitava(){
printf("\n\n============================ PLACAR OITAVAS DE FINAL ===========================\n\n");
for(int x=0;x<8;x++)
printf("\n%s\t vs.\t%s\n\n%s\tGol(s): %d\n%s\tGol(s): %d\n\n: ",ID_pais[conf8[x][0]].nome_pais, ID_pais[conf8[x][1]].nome_pais, ID_pais[conf8[x][0]].nome_pais,conf8[x][2],ID_pais[conf8[x][1]].nome_pais,conf8[x][3]);

printf("Ganhadores das oitavas de final para as quartas de final:\n");
for(int x=0;x<8;x++)
printf("%s\n",ID_pais[qua[x]].nome_pais);

getch();
}

void p_quarta(){
printf("\n\n============================ PLACAR QUARTAS DE FINAL ===========================\n\n");
for(int x=0;x<4;x++)
printf("\n%s\t vs.\t%s\n\n%s\tGol(s): %d\n%s\tGol(s): %d\n\n: ",ID_pais[conf4[x][0]].nome_pais, ID_pais[conf4[x][1]].nome_pais, ID_pais[conf4[x][0]].nome_pais,conf4[x][2],ID_pais[conf4[x][1]].nome_pais,conf4[x][3]);

printf("Ganhadores das quartas de final para as semi finais:\n");
for(int x=0;x<4;x++)
printf("%s\n",ID_pais[semi[x]].nome_pais);
getch();
}

void p_semi(){
printf("\n\n=============================== PLACAR SEMI FINAIS =============================\n\n");
for(int x=0;x<2;x++)
printf("\n%s\t vs.\t%s\n\n%s\tGol(s): %d\n%s\tGol(s): %d\n\n ",ID_pais[conf_semi[x][0]].nome_pais, ID_pais[conf_semi[x][1]].nome_pais, ID_pais[conf_semi[x][0]].nome_pais,conf_semi[x][2],ID_pais[conf_semi[x][1]].nome_pais,conf_semi[x][3]);

printf("Ganhadores das semi finais para a final:\n");
for(int x=0;x<2;x++)
printf("%s\n",ID_pais[four[x]].nome_pais);

printf("Perdedores das semi finais para competir o terceiro lugar:\n");
for(int x=2;x<4;x++)
printf("%s\n",ID_pais[four[x]].nome_pais);

getch();
}

void p_final(){
printf("\n\n================================= PLACAR DA FINAL ==============================\n\n");

printf("\n%s\t vs.\t%s\n\n%s\tGol(s): %d\n%s\tGol(s): %d: ",ID_pais[fin[0][0]].nome_pais, ID_pais[fin[1][0]].nome_pais, ID_pais[fin[0][0]].nome_pais,fin[0][1],ID_pais[fin[1][0]].nome_pais,fin[1][1]);

printf("\n\nPrimeiro lugar: %s\nsegundo lugar: %s",ID_pais[four[0]].nome_pais,ID_pais[four[1]].nome_pais);

getch();
}

void p_terceiro(){
printf("\n\n====================== PLACAR DEFINICAO TERCEIRO E QUARTO ======================\n\n");

printf("\n%s\t vs.\t%s\n\n%s\tGol(s): %d\n%s\tGol(s): %d: ",ID_pais[ter[0][0]].nome_pais, ID_pais[ter[1][0]].nome_pais, ID_pais[ter[0][0]].nome_pais,ter[0][1],ID_pais[ter[1][0]].nome_pais,ter[1][1]);

printf("\n\nTerceiro lugar: %s\nquarto lugar: %s",ID_pais[four[2]].nome_pais,ID_pais[four[3]].nome_pais);

getch();
}

void info_pais(){
system("cls");
printf("============================ INFORMACOES DOS PAISES ============================\n\n");
for(int x=0;x<32;x++)
printf("Nome: %s\nContinente: %s\nChave: %c\nID: %d\nVitorias: %d\nDerrotas: %d\nEmpates: %d\nNumero de jogos: %d\nPontos da primeira fase: %d\nNumero de gols: %d\n\n",ID_pais[x].nome_pais,ID_pais[x].continente,ID_pais[x].chave,x,ID_pais[x].vitorias,ID_pais[x].derrotas,ID_pais[x].empates,ID_pais[x].njogos,ID_pais[x].pontos,ID_pais[x].gols);

getch();
}

void info_part(){
system("cls");
printf("======================== INFORMACOES DOS PARTICIPANTES =========================\n\n");

for(int x=0;x<10;x++){
printf("\n\nNome: %s\nValor dado: R$ %1.2f\nPaises apostados para quarta de final: \n",ficha[x].nome_part,ficha[x].valor_dado);
for(int q=0;q<8;q++)
printf("%s\n",ID_pais[ficha[x].quarta[q]].nome_pais);
printf("\nPaises apostados para semi finais:\n");
for(int e=0;e<4;e++)
printf("%s\n",ID_pais[ficha[x].semi[e]].nome_pais);
printf("\nPaises apostados para a final:\n");
for(int e=0;e<2;e++)
printf("%s\n",ID_pais[ficha[x].final[e]].nome_pais);
printf("\nPaises apostados para o quarto colocado: %s",ID_pais[ficha[x].quarto].nome_pais);
printf("\nPaises apostados para o terceiro colocado: %s",ID_pais[ficha[x].terceiro].nome_pais);
printf("\nPaises apostados para o vice: %s",ID_pais[ficha[x].vice].nome_pais);
printf("\nPaises apostados para o vencedor: %s",ID_pais[ficha[x].vencedor].nome_pais);
printf("\nPontos: %d",ficha[x].ponto_part);
}
getch();
}

void pontos_part(){
for(int x=0;x<10;x++)
for(int y=0;y<8;y++)
for(int d=0;d<8;d++){
if(ficha[x].quarta[y] == qua[d]){
ficha[x].ponto_part += 5;
ponto_total += 5;
}
}

for(int x=0;x<10;x++)
for(int y=0;y<4;y++)
for(int d=0;d<4;d++){
if(ficha[x].semi[y] == semi[d]){
ficha[x].ponto_part += 10;
ponto_total += 10;
}
}

for(int x=0;x<10;x++)
for(int y=0;y<2;y++)
for(int d=0;d<2;d++){
if(ficha[x].final[y] == fin[d][0]){
ficha[x].ponto_part += 15;
ponto_total += 15;
}
}

for(int x=0;x<10;x++){
if(ficha[x].quarto == four[3]){
ficha[x].ponto_part += 20;
ponto_total += 20;
}
}

for(int x=0;x<10;x++){
if(ficha[x].terceiro == four[2]){
ficha[x].ponto_part += 30;
ponto_total += 30;
}
}

for(int x=0;x<10;x++){
if(ficha[x].vice == four[1]){
ficha[x].ponto_part += 40;
ponto_total += 40;
}
}

for(int x=0;x<10;x++){
if(ficha[x].vencedor == four[0]){
ficha[x].ponto_part += 50;
ponto_total += 50;
}
}

}

void part_gan(){
int va=0,gan;
for(int x=0;x<10;x++){
if(ficha[x].ponto_part > va){
gan = x;
}
}

system("cls");
printf("=================================== PARABENS ===================================\n\n");
printf("%s ganhou com %d pontos",ficha[gan].nome_part,ficha[gan].ponto_part);
getch();
}