diff --git a/copa.csv b/copa.csv index 69ead00..8cd85fa 100644 --- a/copa.csv +++ b/copa.csv @@ -13,7 +13,7 @@ Hungria, UEFA, 7, ns Polonia, UEFA, 7, ns Japao, AFC, 7, ns Australia, AFC, 7, ns -Qatar, AFC, 5, ns +Qatar, AFC, 5, sede Coreia do Sul, AFC, 6, ns Ira, AFC, 6, ns Camaroes, CAF, 6, ns @@ -29,4 +29,4 @@ Argentina, CONMEBOL, 9, ns Uruguai, CONMEBOL, 9, ns Colombia, CONMEBOL, 8, ns Chile, CONMEBOL, 7, ns -Nova Zelandia, OFC, 4, sede \ No newline at end of file +Nova Zelandia, OFC, 4, ns \ No newline at end of file diff --git a/copa_menu.py b/copa_menu.py new file mode 100644 index 0000000..4e9b25d --- /dev/null +++ b/copa_menu.py @@ -0,0 +1,181 @@ +# Código por Gustavo Albuquerque - 05/05/2021 +from PySimpleGUI import PySimpleGUI as sg +from sorteio import sorteio_copa +from v2_simulador_grupos import tabela_grupos, textos_grupo +from v2_matamata import copa_mundo, textos_matamata + +# fonte +ft = 'Bahnschrift' + +# tamanho da janela +tam = (800, 450) + +grupos = sorteio_copa() +GA = tabela_grupos(grupos[0]) +GB = tabela_grupos(grupos[1]) +GC = tabela_grupos(grupos[2]) +GD = tabela_grupos(grupos[3]) +GE = tabela_grupos(grupos[4]) +GF = tabela_grupos(grupos[5]) +GG = tabela_grupos(grupos[6]) +GH = tabela_grupos(grupos[7]) +copa = copa_mundo(grupos, GA, GB, GC, GD, GE, GF, GG, GH) +oit1, oit2, oit3, oit4, qua1, qua2, sem, ter, fin = textos_matamata(*copa) + +lg = [GA, GB, GC, GD, GE, GF, GG, GH] +lf = [oit1, oit2, oit3, oit4, qua1, qua2, sem, ter, fin] +lgru = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'] +lfas = ['Oitavas de Final 1/4', 'Oitavas de Final 2/4', 'Oitavas de Final 3/4', + 'Oitavas de Final 4/4', 'Quartas de Final 1/2', 'Quartas de Final 2/2', + 'Semi-Final', 'Decisão de 3º Lugar', 'Final'] +i = 0 +j = 0 + +topo = f'Grupo {lgru[i]}' +topo2 = f'{lfas[j]}' + +# layout +sg.theme('Dark Brown 1') +menu_principal = [ + [sg.Text('Simulador de Copa do Mundo (Iniciante)', + size=(100, 5), + justification='center', font=ft)], + [sg.Text('V2.0 / Gustavo Albuquerque 06/05/2021', + size=(100, 5), + justification='center', font=ft)], + [sg.Button('Começar!')], +] + +layout = menu_principal +# janela +janela = sg.Window('Simulador de Copa do Mundo V2.0', layout, + element_justification='c', size=tam) + +# eventos +while True: + eventos, valores = janela.read() + if eventos == sg.WINDOW_CLOSED: + break + if eventos == 'Começar!': + layout = [ + [sg.Text(topo, + font=ft)], + [sg.Text(textos_grupo(*(lg[i]))[0], + font=ft)], + [sg.Text(textos_grupo(*(lg[i]))[1], + justification='center', font=ft), + sg.Text(textos_grupo(*(lg[i]))[2], + justification='center', font=ft), + sg.Text(textos_grupo(*(lg[i]))[3], + justification='center', font=ft)], + [sg.Button('Próximo')] + ] + janela.close() + janela = sg.Window('Simulador de Copa do Mundo Beta V2.0', + layout, element_justification='c', size=tam) + + if eventos == 'Próximo': + i = i + 1 + topo = f'Grupo {lgru[i]}' + layout = [ + [sg.Text(topo, + font=ft)], + [sg.Text(textos_grupo(*(lg[i]))[0], + font=ft)], + [sg.Text(textos_grupo(*(lg[i]))[1], + justification='center', font=ft), + sg.Text(textos_grupo(*(lg[i]))[2], + justification='center', font=ft), + sg.Text(textos_grupo(*(lg[i]))[3], + justification='center', font=ft)], + [sg.Button('Voltar'), sg.Text(' '), sg.Button('Próximo')] + ] + janela.close() + janela = sg.Window('Simulador de Copa do Mundo Beta V2.0', + layout, element_justification='c', size=tam) + + if eventos == 'Voltar': + if i != 0: + j = 0 + i = i - 1 + topo = f'Grupo {lgru[i]}' + layout = [ + [sg.Text(topo, + font=ft)], + [sg.Text(textos_grupo(*(lg[i]))[0], + font=ft)], + [sg.Text(textos_grupo(*(lg[i]))[1], + justification='center', font=ft), + sg.Text(textos_grupo(*(lg[i]))[2], + justification='center', font=ft), + sg.Text(textos_grupo(*(lg[i]))[3], + justification='center', font=ft)], + [sg.Button('Voltar'), sg.Text(' '), sg.Button('Próximo')] + ] + janela.close() + janela = sg.Window('Simulador de Copa do Mundo Beta V2.0', + layout, element_justification='c', size=tam) + + if i == 7: + layout = [ + [sg.Text(topo, + font=ft)], + [sg.Text(textos_grupo(*(lg[i]))[0], + font=ft)], + [sg.Text(textos_grupo(*(lg[i]))[1], + justification='center', font=ft), + sg.Text(textos_grupo(*(lg[i]))[2], + justification='center', font=ft), + sg.Text(textos_grupo(*(lg[i]))[3], + justification='center', font=ft)], + [sg.Button('Voltar'), sg.Text(' '), sg.Button('Oitavas')] + ] + janela.close() + janela = sg.Window('Simulador de Copa do Mundo Beta V2.0', + layout, element_justification='c', size=tam) + + if eventos == 'Oitavas': + j = 0 + topo2 = f'{lfas[j]}' + layout = [ + [sg.Text(topo2, + font=ft)], + [sg.Text(lf[j], + font=ft)], + [sg.Button('Voltar'), sg.Text(' '), sg.Button('Avançar')] + ] + janela.close() + janela = sg.Window('Simulador de Copa do Mundo Beta V2.0', + layout, element_justification='c', size=tam) + + if eventos == 'Avançar': + if j == 8: + topo2 = 'Fim da Simulação! - Gustavo Albuquerque 06/05/2021' + layout = [ + [sg.Text(topo2, justification='center', + font=ft)], + + [sg.Button('Voltar'), sg.Text(' '), sg.Button('Fim')] + ] + janela.close() + janela = sg.Window('Simulador de Copa do Mundo Beta V2.0', + layout, + element_justification='c', size=(500, 500)) + else: + j = j + 1 + topo2 = f'{lfas[j]}' + layout = [ + [sg.Text(topo2, + font=ft)], + [sg.Text(lf[j], + font=ft)], + [sg.Button('Voltar'), sg.Text(' '), sg.Button('Avançar')] + ] + janela.close() + janela = sg.Window('Simulador de Copa do Mundo Beta V2.0', + layout, element_justification='c', size=tam) + + if eventos == 'Fim': + janela.close() + +print('Código por Gustavo Albuquerque - 06/05/2021') diff --git a/sorteio.py b/sorteio.py index 030ff2b..ecf5c10 100644 --- a/sorteio.py +++ b/sorteio.py @@ -34,34 +34,47 @@ def sorteio_copa(): dict_sel = {'País': dados_sel[0], 'Confederação': dados_sel[1], 'Nível': dados_sel[2], 'Sede?': dados_sel[3]} - if '10' in dict_sel.get('Nível'): + if 'sede' in dict_sel.get('Sede?'): + pais_sede = dict_sel + + if ('10' in dict_sel.get('Nível') and 'sede' + not in dict_sel.get('Sede?')): lista10.append(dict_sel) - elif '9' in dict_sel.get('Nível'): + elif ('9' in dict_sel.get('Nível') and 'sede' + not in dict_sel.get('Sede?')): lista9.append(dict_sel) - elif '8' in dict_sel.get('Nível'): + elif ('8' in dict_sel.get('Nível') and 'sede' + not in dict_sel.get('Sede?')): lista8.append(dict_sel) - elif '7' in dict_sel.get('Nível'): + elif ('7' in dict_sel.get('Nível') and 'sede' + not in dict_sel.get('Sede?')): lista7.append(dict_sel) - elif '6' in dict_sel.get('Nível'): + elif ('6' in dict_sel.get('Nível') and 'sede' + not in dict_sel.get('Sede?')): lista6.append(dict_sel) - elif '5' in dict_sel.get('Nível'): + elif ('5' in dict_sel.get('Nível') and 'sede' + not in dict_sel.get('Sede?')): lista5.append(dict_sel) - elif '4' in dict_sel.get('Nível'): + elif ('4' in dict_sel.get('Nível') and 'sede' + not in dict_sel.get('Sede?')): lista4.append(dict_sel) - elif '3' in dict_sel.get('Nível'): + elif ('3' in dict_sel.get('Nível') and 'sede' + not in dict_sel.get('Sede?')): lista3.append(dict_sel) - elif '2' in dict_sel.get('Nível'): + elif ('2' in dict_sel.get('Nível') and 'sede' + not in dict_sel.get('Sede?')): lista2.append(dict_sel) - elif '1' in dict_sel.get('Nível'): + elif ('1' in dict_sel.get('Nível') and 'sede' + not in dict_sel.get('Sede?')): lista1.append(dict_sel) else: @@ -70,10 +83,11 @@ def sorteio_copa(): ordem = (lista10 + lista9 + lista8 + lista7 + lista6 + lista5 + lista4 + lista3 + lista2 + lista1) - pote1 = list(ordem[:8]) - pote2 = list(ordem[8:16]) - pote3 = list(ordem[16:24]) - pote4 = list(ordem[24:]) + pote1 = [pais_sede, ordem[0], ordem[1], ordem[2], + ordem[3], ordem[4], ordem[5], ordem[6]] + pote2 = list(ordem[7:15]) + pote3 = list(ordem[15:23]) + pote4 = list(ordem[23:]) # print('O pote 1 consiste em:\n {} \n'.format(pote1)) # print('O pote 2 consiste em:\n {} \n'.format(pote2)) @@ -88,6 +102,27 @@ def sorteio_copa(): # sortear os grupos através dos indices dos potes # CICLO DE GERAÇÃO DE NUMÉROS ALEATÓRIOS + pote1_sort = [1, 2, 3, 4, 5, 6, 7] + alep1 = choice(pote1_sort) + pote1_sort.remove(alep1) + + alep2 = choice(pote1_sort) + pote1_sort.remove(alep2) + + alep3 = choice(pote1_sort) + pote1_sort.remove(alep3) + + alep4 = choice(pote1_sort) + pote1_sort.remove(alep4) + + alep5 = choice(pote1_sort) + pote1_sort.remove(alep5) + + alep6 = choice(pote1_sort) + pote1_sort.remove(alep6) + + alep7 = choice(pote1_sort) + pote1_sort.remove(alep7) potes_sort = [0, 1, 2, 3, 4, 5, 6, 7] # posicoes do pote @@ -132,31 +167,31 @@ def sorteio_copa(): # print(potes_sort) # fim do oitavo ciclo - grupoA = [pote1[ale1], pote2[ale8], pote3[ale7], pote4[ale6]] - grupoB = [pote1[ale2], pote2[ale7], pote3[ale5], pote4[ale4]] - grupoC = [pote1[ale3], pote2[ale6], pote3[ale3], pote4[ale2]] - grupoD = [pote1[ale4], pote2[ale5], pote3[ale1], pote4[ale8]] - grupoE = [pote1[ale5], pote2[ale4], pote3[ale8], pote4[ale1]] - grupoF = [pote1[ale6], pote2[ale3], pote3[ale4], pote4[ale3]] - grupoG = [pote1[ale7], pote2[ale2], pote3[ale6], pote4[ale5]] - grupoH = [pote1[ale8], pote2[ale1], pote3[ale2], pote4[ale7]] + grupoA = [pote1[0], pote2[ale8], pote3[ale7], pote4[ale6]] + grupoB = [pote1[alep1], pote2[ale7], pote3[ale5], pote4[ale4]] + grupoC = [pote1[alep2], pote2[ale6], pote3[ale3], pote4[ale2]] + grupoD = [pote1[alep3], pote2[ale5], pote3[ale1], pote4[ale8]] + grupoE = [pote1[alep4], pote2[ale4], pote3[ale8], pote4[ale1]] + grupoF = [pote1[alep5], pote2[ale3], pote3[ale4], pote4[ale3]] + grupoG = [pote1[alep6], pote2[ale2], pote3[ale6], pote4[ale5]] + grupoH = [pote1[alep7], pote2[ale1], pote3[ale2], pote4[ale7]] # Grupos contendo apenas as confederações dos países escolhidos - confgrupoA = [pote1[ale1]['Confederação'], pote2[ale8]['Confederação'], + confgrupoA = [pote1[0]['Confederação'], pote2[ale8]['Confederação'], pote3[ale7]['Confederação'], pote4[ale6]['Confederação']] - confgrupoB = [pote1[ale2]['Confederação'], pote2[ale7]['Confederação'], + confgrupoB = [pote1[alep1]['Confederação'], pote2[ale7]['Confederação'], pote3[ale5]['Confederação'], pote4[ale4]['Confederação']] - confgrupoC = [pote1[ale3]['Confederação'], pote2[ale6]['Confederação'], + confgrupoC = [pote1[alep2]['Confederação'], pote2[ale6]['Confederação'], pote3[ale3]['Confederação'], pote4[ale2]['Confederação']] - confgrupoD = [pote1[ale4]['Confederação'], pote2[ale5]['Confederação'], + confgrupoD = [pote1[alep3]['Confederação'], pote2[ale5]['Confederação'], pote3[ale1]['Confederação'], pote4[ale8]['Confederação']] - confgrupoE = [pote1[ale5]['Confederação'], pote2[ale4]['Confederação'], + confgrupoE = [pote1[alep4]['Confederação'], pote2[ale4]['Confederação'], pote3[ale8]['Confederação'], pote4[ale1]['Confederação']] - confgrupoF = [pote1[ale6]['Confederação'], pote2[ale3]['Confederação'], + confgrupoF = [pote1[alep5]['Confederação'], pote2[ale3]['Confederação'], pote3[ale4]['Confederação'], pote4[ale3]['Confederação']] - confgrupoG = [pote1[ale7]['Confederação'], pote2[ale2]['Confederação'], + confgrupoG = [pote1[alep6]['Confederação'], pote2[ale2]['Confederação'], pote3[ale6]['Confederação'], pote4[ale5]['Confederação']] - confgrupoH = [pote1[ale8]['Confederação'], pote2[ale1]['Confederação'], + confgrupoH = [pote1[alep7]['Confederação'], pote2[ale1]['Confederação'], pote3[ale2]['Confederação'], pote4[ale7]['Confederação']] # print('O Grupo A é: \n {}'.format(grupoA)) # print('O Grupo B é: \n {}'.format(grupoB)) @@ -262,21 +297,23 @@ def sorteio_copa(): # FIM DA FUNÇÃO SORTEIO -grupos = sorteio_copa() -GA = grupos[0] -GB = grupos[1] -GC = grupos[2] -GD = grupos[3] -GE = grupos[4] -GF = grupos[5] -GG = grupos[6] -GH = grupos[7] - -print('Grupo A:\n{}\n'.format(GA)) -print('Grupo B:\n{}\n'.format(GB)) -print('Grupo C:\n{}\n'.format(GC)) -print('Grupo D:\n{}\n'.format(GD)) -print('Grupo E:\n{}\n'.format(GE)) -print('Grupo F:\n{}\n'.format(GF)) -print('Grupo G:\n{}\n'.format(GG)) -print('Grupo H:\n{}\n'.format(GH)) +if __name__ == '__main__': + + grupos = sorteio_copa() + GA = grupos[0] + GB = grupos[1] + GC = grupos[2] + GD = grupos[3] + GE = grupos[4] + GF = grupos[5] + GG = grupos[6] + GH = grupos[7] + + print('Grupo A:\n{}\n'.format(GA)) + print('Grupo B:\n{}\n'.format(GB)) + print('Grupo C:\n{}\n'.format(GC)) + print('Grupo D:\n{}\n'.format(GD)) + print('Grupo E:\n{}\n'.format(GE)) + print('Grupo F:\n{}\n'.format(GF)) + print('Grupo G:\n{}\n'.format(GG)) + print('Grupo H:\n{}\n'.format(GH)) diff --git a/v2_matamata.py b/v2_matamata.py new file mode 100644 index 0000000..0952136 --- /dev/null +++ b/v2_matamata.py @@ -0,0 +1,573 @@ +# Código por Gustavo Albuquerque - 20/04/2021 +from v2_simulador_grupos import tabela_grupos +from sorteio import sorteio_copa +from placar import resultado +from penaltis import desempate + + +def copa_mundo(grupos, RA, RB, RC, RD, RE, RF, RG, RH): + # os grupos em si, com as forças atreladas ao time + timesA = grupos[0] + timesB = grupos[1] + timesC = grupos[2] + timesD = grupos[3] + timesE = grupos[4] + timesF = grupos[5] + timesG = grupos[6] + timesH = grupos[7] + # tabela dos grupos + classif_A = RA[0] + classif_B = RB[0] + classif_C = RC[0] + classif_D = RD[0] + classif_E = RE[0] + classif_F = RF[0] + classif_G = RG[0] + classif_H = RH[0] + + # esvaziando string penaltis dos duelos + TO1P = " " + TO2P = " " + TO3P = " " + TO4P = " " + TO5P = " " + TO6P = " " + TO7P = " " + TO8P = " " + TQ1P = " " + TQ2P = " " + TQ3P = " " + TQ4P = " " + TSF1P = " " + TSF2P = " " + TTLP = " " + TFINALP = " " + + # MONTANDO OS CLASSIFICADOS E OS NÍVEIS + + for time in timesA: + if time['País'] == classif_A[0][0]: + A1 = [time['País'], time['Nível']] + + for time in timesA: + if time['País'] == classif_A[1][0]: + A2 = [time['País'], time['Nível']] + + for time in timesB: + if time['País'] == classif_B[0][0]: + B1 = [time['País'], time['Nível']] + + for time in timesB: + if time['País'] == classif_B[1][0]: + B2 = [time['País'], time['Nível']] + + for time in timesC: + if time['País'] == classif_C[0][0]: + C1 = [time['País'], time['Nível']] + + for time in timesC: + if time['País'] == classif_C[1][0]: + C2 = [time['País'], time['Nível']] + + for time in timesD: + if time['País'] == classif_D[0][0]: + D1 = [time['País'], time['Nível']] + + for time in timesD: + if time['País'] == classif_D[1][0]: + D2 = [time['País'], time['Nível']] + + for time in timesE: + if time['País'] == classif_E[0][0]: + E1 = [time['País'], time['Nível']] + + for time in timesE: + if time['País'] == classif_E[1][0]: + E2 = [time['País'], time['Nível']] + + for time in timesF: + if time['País'] == classif_F[0][0]: + F1 = [time['País'], time['Nível']] + + for time in timesF: + if time['País'] == classif_F[1][0]: + F2 = [time['País'], time['Nível']] + + for time in timesG: + if time['País'] == classif_G[0][0]: + G1 = [time['País'], time['Nível']] + + for time in timesG: + if time['País'] == classif_G[1][0]: + G2 = [time['País'], time['Nível']] + + for time in timesH: + if time['País'] == classif_H[0][0]: + H1 = [time['País'], time['Nível']] + + for time in timesH: + if time['País'] == classif_H[1][0]: + H2 = [time['País'], time['Nível']] + + # Jogo O1 + + O1 = resultado(int(A1[1]), int(B2[1])) + + TO1 = ('\n{} {} x {} {}\n'.format(A1[0], + O1[0], O1[1], B2[0])) + + # Estrutura de classificação: + if O1[0] > O1[1]: + QF1_1 = A1 + elif O1[0] < O1[1]: + QF1_1 = B2 + else: + O1 = desempate() + TO1P = ('Penaltis: \n{} {} x {} {}\n'.format(A1[0], + O1[0], O1[1], B2[0])) + if O1[0] > O1[1]: + QF1_1 = A1 + else: + QF1_1 = B2 + # Fim do jogo O1 + + # Jogo O2 + + O2 = resultado(int(C1[1]), int(D2[1])) + + TO2 = ('\n{} {} x {} {}\n'.format(C1[0], + O2[0], O2[1], D2[0])) + + # Estrutura de classificação: + if O2[0] > O2[1]: + QF1_2 = C1 + elif O2[0] < O2[1]: + QF1_2 = D2 + else: + O2 = desempate() + TO2P = ('Penaltis: \n{} {} x {} {}\n'.format(C1[0], + O2[0], O2[1], D2[0])) + if O2[0] > O2[1]: + QF1_2 = C1 + else: + QF1_2 = D2 + # Fim do jogo O2 + + # Jogo O3 + O3 = resultado(int(E1[1]), int(F2[1])) + + TO3 = ('\n{} {} x {} {}\n'.format(E1[0], + O3[0], O3[1], F2[0])) + + # Estrutura de classificação: + if O3[0] > O3[1]: + QF2_1 = E1 + elif O3[0] < O3[1]: + QF2_1 = F2 + else: + O3 = desempate() + TO3P = ('Penaltis: \n{} {} x {} {}\n'.format(E1[0], + O3[0], O3[1], F2[0])) + if O3[0] > O3[1]: + QF2_1 = E1 + else: + QF2_1 = F2 + # Fim do jogo O3 + + # Jogo O4 + + O4 = resultado(int(G1[1]), int(H2[1])) + + TO4 = ('\n{} {} x {} {}\n'.format(G1[0], + O4[0], O4[1], H2[0])) + + # Estrutura de classificação: + if O4[0] > O4[1]: + QF2_2 = G1 + elif O4[0] < O4[1]: + QF2_2 = H2 + else: + O4 = desempate() + TO4P = ('Penaltis: \n{} {} x {} {}\n'.format(G1[0], + O4[0], O4[1], H2[0])) + if O4[0] > O4[1]: + QF2_2 = G1 + else: + QF2_2 = H2 + # Fim do jogo O4 + + # Jogo O5 + + O5 = resultado(int(B1[1]), int(A2[1])) + + TO5 = ('\n{} {} x {} {}\n'.format(B1[0], + O5[0], O5[1], A2[0])) + + # Estrutura de classificação: + if O5[0] > O5[1]: + QF3_1 = B1 + elif O5[0] < O5[1]: + QF3_1 = A2 + else: + O5 = desempate() + TO5P = ('Penaltis: \n{} {} x {} {}\n'.format(B1[0], + O5[0], O5[1], A2[0])) + if O5[0] > O5[1]: + QF3_1 = B1 + else: + QF3_1 = A2 + # Fim do jogo O5 + + # Jogo O6 + + O6 = resultado(int(D1[1]), int(C2[1])) + + TO6 = ('\n{} {} x {} {}\n'.format(D1[0], + O6[0], O6[1], C2[0])) + + # Estrutura de classificação: + if O6[0] > O6[1]: + QF3_2 = D1 + elif O6[0] < O6[1]: + QF3_2 = C2 + else: + O6 = desempate() + TO6P = ('Penaltis: \n{} {} x {} {}\n'.format(D1[0], + O6[0], O6[1], C2[0])) + if O6[0] > O6[1]: + QF3_2 = D1 + else: + QF3_2 = C2 + # Fim do jogo O6 + + # Jogo O7 + + O7 = resultado(int(F1[1]), int(E2[1])) + + TO7 = ('\n{} {} x {} {}\n'.format(F1[0], + O7[0], O7[1], E2[0])) + + # Estrutura de classificação: + if O7[0] > O7[1]: + QF4_1 = F1 + elif O7[0] < O7[1]: + QF4_1 = E2 + else: + O7 = desempate() + TO7P = ('Penaltis: \n{} {} x {} {}\n'.format(F1[0], + O7[0], O7[1], E2[0])) + if O7[0] > O7[1]: + QF4_1 = F1 + else: + QF4_1 = E2 + + # Fim do jogo O7 + + # Jogo O8 + O8 = resultado(int(H1[1]), int(G2[1])) + + TO8 = ('\n{} {} x {} {}\n'.format(H1[0], + O8[0], O8[1], G2[0])) + + # Estrutura de classificação: + if O8[0] > O8[1]: + QF4_2 = H1 + elif O8[0] < O8[1]: + QF4_2 = G2 + else: + O8 = desempate() + TO8P = ('Penaltis: \n{} {} x {} {}\n'.format(H1[0], + O8[0], O8[1], G2[0])) + if O8[0] > O8[1]: + QF4_2 = H1 + else: + QF4_2 = G2 + # Fim do jogo O8 + + # QUARTAS DE FINAL: + + # Jogo QF1 + + QF1 = resultado(int(QF1_1[1]), int(QF1_2[1])) + + TQ1 = ('\n{} {} x {} {}\n'.format(QF1_1[0], + QF1[0], QF1[1], QF1_2[0])) + + # Estrutura de classificação: + if QF1[0] > QF1[1]: + SF1_1 = QF1_1 + elif QF1[0] < QF1[1]: + SF1_1 = QF1_2 + else: + QF1 = desempate() + TQ1P = ('Penaltis: \n{} {} x {} {}\n'.format(QF1_1[0], + QF1[0], QF1[1], QF1_2[0])) + if QF1[0] > QF1[1]: + SF1_1 = QF1_1 + else: + SF1_1 = QF1_2 + + # Fim do jogo QF1 + + # Jogo QF2 + + QF2 = resultado(int(QF2_1[1]), int(QF2_2[1])) + + TQ2 = ('\n{} {} x {} {}\n'.format(QF2_1[0], + QF2[0], QF2[1], QF2_2[0])) + + # Estrutura de classificação: + if QF2[0] > QF2[1]: + SF1_2 = QF2_1 + elif QF2[0] < QF2[1]: + SF1_2 = QF2_2 + else: + QF2 = desempate() + TQ2P = ('Penaltis: \n{} {} x {} {}\n'.format(QF2_1[0], + QF2[0], QF2[1], QF2_2[0])) + if QF2[0] > QF2[1]: + SF1_2 = QF2_1 + else: + SF1_2 = QF2_2 + # Fim do jogo QF2 + + # Jogo QF3 + + QF3 = resultado(int(QF3_1[1]), int(QF3_2[1])) + + TQ3 = ('\n{} {} x {} {}\n'.format(QF3_1[0], + QF3[0], QF3[1], QF3_2[0])) + + # Estrutura de classificação: + if QF3[0] > QF3[1]: + SF2_1 = QF3_1 + elif QF3[0] < QF3[1]: + SF2_1 = QF3_2 + else: + QF3 = desempate() + TQ3P = ('Penaltis: \n{} {} x {} {}\n'.format(QF3_1[0], + QF3[0], QF3[1], QF3_2[0])) + if QF3[0] > QF3[1]: + SF2_1 = QF3_1 + else: + SF2_1 = QF3_2 + # Fim do jogo QF3 + + # Jogo QF4 + + QF4 = resultado(int(QF4_1[1]), int(QF4_2[1])) + + TQ4 = ('\n{} {} x {} {}\n'.format(QF4_1[0], + QF4[0], QF4[1], QF4_2[0])) + + # Estrutura de classificação: + if QF4[0] > QF4[1]: + SF2_2 = QF4_1 + elif QF4[0] < QF4[1]: + SF2_2 = QF4_2 + else: + QF4 = desempate() + TQ4P = ('Penaltis: \n{} {} x {} {}\n'.format(QF4_1[0], + QF4[0], QF4[1], QF4_2[0])) + if QF4[0] > QF4[1]: + SF2_2 = QF4_1 + else: + SF2_2 = QF4_2 + # Fim do jogo QF4 + + # SEMI FINAL + # Jogo SF1 + + SF1 = resultado(int(SF1_1[1]), int(SF1_2[1])) + + TSF1 = ('\n{} {} x {} {}\n'.format(SF1_1[0], + SF1[0], SF1[1], SF1_2[0])) + + # Estrutura de classificação: + if SF1[0] > SF1[1]: + FINAL_1 = SF1_1 + TL1 = SF1_2 + elif SF1[0] < SF1[1]: + FINAL_1 = SF1_2 + TL1 = SF1_1 + else: + SF1 = desempate() + TSF1P = ('Penaltis: \n{} {} x {} {}\n'.format( + SF1_1[0], SF1[0], SF1[1], SF1_2[0])) + if SF1[0] > SF1[1]: + FINAL_1 = SF1_1 + TL1 = SF1_2 + else: + FINAL_1 = SF1_2 + TL1 = SF1_1 + # Fim do jogo SF1 + + # Jogo SF2 + + SF2 = resultado(int(SF2_1[1]), int(SF2_2[1])) + + TSF2 = ('\n{} {} x {} {}\n'.format(SF2_1[0], + SF2[0], SF2[1], SF2_2[0])) + + # Estrutura de classificação: + if SF2[0] > SF2[1]: + FINAL_2 = SF2_1 + TL2 = SF2_2 + elif SF2[0] < SF2[1]: + FINAL_2 = SF2_2 + TL2 = SF2_1 + else: + SF2 = desempate() + TSF2P = ('Penaltis: \n{} {} x {} {}\n'.format( + SF2_1[0], SF2[0], SF2[1], SF2_2[0])) + if SF2[0] > SF2[1]: + FINAL_2 = SF2_1 + TL2 = SF2_2 + else: + FINAL_2 = SF2_2 + TL2 = SF2_1 + # Fim do jogo SF2 + + print('__DISPUTA DE TERCEIRO LUGAR__') + # Jogo TL + print('______________________________') + + TL = resultado(int(TL1[1]), int(TL2[1])) + + TTL = ('\n{} {} x {} {}\n'.format(TL1[0], + TL[0], TL[1], TL2[0])) + + # Estrutura de classificação: + if TL[0] > TL[1]: + Terceiro = TL1 + Quarto = TL2 + + elif TL[0] < TL[1]: + Terceiro = TL2 + Quarto = TL1 + + else: + TL = desempate() + TTLP = ('Penaltis: \n{} {} x {} {}\n'.format(TL1[0], + TL[0], TL[1], TL2[0])) + if TL[0] > TL[1]: + Terceiro = TL1 + Quarto = TL2 + + else: + Terceiro = TL2 + Quarto = TL1 + + # Fim do jogo TL + + # Jogo final + + final = resultado(int(FINAL_1[1]), int(FINAL_2[1])) + + TFINAL = ('\n{} {} x {} {}\n'.format(FINAL_1[0], + final[0], final[1], FINAL_2[0])) + + # Estrutura de classificação: + if final[0] > final[1]: + Camp = FINAL_1 + Vice = FINAL_2 + elif final[0] < final[1]: + Camp = FINAL_2 + Vice = FINAL_1 + else: + final = desempate() + TFINALP = ('Penaltis: \n{} {} x {} {}\n'.format( + FINAL_1[0], final[0], final[1], FINAL_2[0])) + if final[0] > final[1]: + Camp = FINAL_1 + Vice = FINAL_2 + + else: + Camp = FINAL_2 + Vice = FINAL_1 + + # Fim do Mata Mata + + print('{} foi a seleção vencedora da Copa do Mundo!'.format(Camp)) + print('{} foi a seleção vice'.format(Vice)) + print('{} foi a seleção que ficou em terceiro'.format(Terceiro)) + print('{} foi a seleção que ficou em quarto'.format(Quarto)) + + return (TO1, TO2, TO3, TO4, TO5, TO6, TO7, TO8, + TO1P, TO2P, TO3P, TO4P, TO5P, TO6P, TO7P, TO8P, + TQ1, TQ2, TQ3, TQ4, TSF1, TSF2, TTL, TFINAL, + TQ1P, TQ2P, TQ3P, TQ4P, TSF1P, TSF2P, TTLP, TFINALP) + + +def textos_matamata(oi1, oi2, oi3, oi4, oi5, oi6, oi7, oi8, + oi1p, oi2p, oi3p, oi4p, oi5p, oi6p, oi7p, oi8p, + ql1, ql2, ql3, ql4, se1, se2, ter, fin, + ql1p, ql2p, ql3p, ql4p, se1p, se2p, terp, finp): + + texto_oi1 = f""" + {oi1} + {oi1p} + {oi2} + {oi2p} + """ + texto_oi2 = f""" + {oi3} + {oi3p} + {oi4} + {oi4p} + """ + texto_oi3 = f""" + {oi5} + {oi5p} + {oi6} + {oi6p} + """ + texto_oi4 = f""" + {oi7} + {oi7p} + {oi8} + {oi8p} + """ + texto_qua1 = f""" + {ql1} + {ql1p} + {ql2} + {ql2p} + """ + texto_qua2 = f""" + {ql3} + {ql3p} + {ql4} + {ql4p} + """ + texto_semi = f""" + {se1} + {se1p} + {se2} + {se2p} + """ + texto_tl = f""" + {ter} + {terp} + """ + texto_final = f""" + {fin} + {finp} + """ + + return [texto_oi1, texto_oi2, texto_oi3, texto_oi4, + texto_qua1, texto_qua2, texto_semi, texto_tl, texto_final] + + +if __name__ == '__main__': + grupinhos = sorteio_copa() + RG1 = tabela_grupos(grupinhos[0]) + RG2 = tabela_grupos(grupinhos[1]) + RG3 = tabela_grupos(grupinhos[2]) + RG4 = tabela_grupos(grupinhos[3]) + RG5 = tabela_grupos(grupinhos[4]) + RG6 = tabela_grupos(grupinhos[5]) + RG7 = tabela_grupos(grupinhos[6]) + RG8 = tabela_grupos(grupinhos[7]) + copa = copa_mundo(grupinhos, RG1, RG2, RG3, RG4, RG5, RG6, RG7, RG8) + t1, t2, t3, t4, t5, t6, t7, t8, t9 = textos_matamata(*copa) diff --git a/v2_simulador_grupos.py b/v2_simulador_grupos.py new file mode 100644 index 0000000..e73352e --- /dev/null +++ b/v2_simulador_grupos.py @@ -0,0 +1,142 @@ +from placar import resultado +import operator + + +def tabela_grupos(grupo): + PA0, PA1, PA2, PA3 = 0, 0, 0, 0 + + A1J1 = resultado(int(grupo[0]['Nível']), int(grupo[1]['Nível'])) + + # Estrutura de pontuação da partida: + if A1J1[0] > A1J1[1]: + PA0 = PA0 + 3 + elif A1J1[0] < A1J1[1]: + PA1 = PA1 + 3 + else: + PA0 = PA0 + 1 + PA1 = PA1 + 1 + # FIM DO JOGO 1 + A1J2 = resultado(int(grupo[2]['Nível']), int(grupo[3]['Nível'])) + + # Estrutura de pontuação da partida: + if A1J2[0] > A1J2[1]: + PA2 = PA2 + 3 + elif A1J2[0] < A1J2[1]: + PA3 = PA3 + 3 + else: + PA2 = PA2 + 1 + PA3 = PA3 + 1 + # FIM DO JOGO 2 + + # Grupo A, rodada 2: + + A2J1 = resultado(int(grupo[0]['Nível']), int(grupo[2]['Nível'])) + + # Estrutura de pontuação da partida: + if A2J1[0] > A2J1[1]: + PA0 = PA0 + 3 + elif A2J1[0] < A2J1[1]: + PA2 = PA2 + 3 + else: + PA0 = PA0 + 1 + PA2 = PA2 + 1 + # FIM DO JOGO 1 + + A2J2 = resultado(int(grupo[1]['Nível']), int(grupo[3]['Nível'])) + + # Estrutura de pontuação da partida: + if A2J2[0] > A2J2[1]: + PA1 = PA1 + 3 + elif A2J2[0] < A2J2[1]: + PA3 = PA3 + 3 + else: + PA1 = PA1 + 1 + PA3 = PA3 + 1 + # FIM DO JOGO 2 + + # Grupo A, rodada 3: + A3J1 = resultado(int(grupo[0]['Nível']), int(grupo[3]['Nível'])) + + # Estrutura de pontuação da partida: + if A3J1[0] > A3J1[1]: + PA0 = PA0 + 3 + elif A3J1[0] < A3J1[1]: + PA3 = PA3 + 3 + else: + PA0 = PA0 + 1 + PA3 = PA3 + 1 + # FIM DO JOGO 1 + + A3J2 = resultado(int(grupo[1]['Nível']), int(grupo[2]['Nível'])) + + # Estrutura de pontuação da partida: + if A3J2[0] > A3J2[1]: + PA1 = PA1 + 3 + elif A3J2[0] < A3J2[1]: + PA2 = PA2 + 3 + else: + PA1 = PA1 + 1 + PA2 = PA2 + 1 + # FIM DO JOGO 2 + # SALDOS: + gfA0 = A1J1[0] + A2J1[0] + A3J1[0] + gsA0 = A1J1[1] + A2J1[1] + A3J1[1] + + gfA1 = A1J1[1] + A2J2[0] + A3J2[0] + gsA1 = A1J1[0] + A2J2[1] + A3J2[1] + + gfA2 = A1J2[0] + A2J1[1] + A3J2[1] + gsA2 = A1J2[1] + A2J1[0] + A3J2[0] + + gfA3 = A1J2[1] + A2J2[1] + A3J1[1] + gsA3 = A1J2[0] + A2J2[0] + A3J1[0] + + tabelagrupo = [[grupo[0]['País'], PA0, gfA0, gsA0, gfA0 - gsA0], + [grupo[1]['País'], PA1, gfA1, gsA1, gfA1 - gsA1], + [grupo[2]['País'], PA2, gfA2, gsA2, gfA2 - gsA2], + [grupo[3]['País'], PA3, gfA3, gsA3, gfA3 - gsA3]] + + ordenacao = sorted(tabelagrupo, key=operator.itemgetter(1, 4, 2)) + classificacao = [ordenacao[3], ordenacao[2], ordenacao[1], ordenacao[0]] + jogos = { + 'R1': [ + [grupo[0]['País'], A1J1[0], A1J1[1], grupo[1]['País']], + [grupo[2]['País'], A1J2[0], A1J2[1], grupo[3]['País']] + ], + 'R2': [ + [grupo[0]['País'], A2J1[0], A2J1[1], grupo[2]['País']], + [grupo[1]['País'], A2J2[0], A2J2[1], grupo[3]['País']], + ], + 'R3': [ + [grupo[0]['País'], A3J1[0], A3J1[1], grupo[3]['País']], + [grupo[1]['País'], A3J2[0], A3J2[1], grupo[2]['País']], + ] + } + return [classificacao, jogos] + + +def textos_grupo(classif, j): + texto_classif = f""" + CLASSIFICAÇÃO: + País / Pontos / GF / GS / SG + {classif[0]} + {classif[1]} + {classif[2]} + {classif[3]} + """ + texto_1rod = f""" + \nPRIMEIRA RODADA:\n + {j['R1'][0][0]} {j['R1'][0][1]} x {j['R1'][0][2]} {j['R1'][0][3]}\n + {j['R1'][1][0]} {j['R1'][1][1]} x {j['R1'][1][2]} {j['R1'][1][3]}\n + """ + texto_2rod = f""" + \nSEGUNDA RODADA:\n + {j['R2'][0][0]} {j['R2'][0][1]} x {j['R2'][0][2]} {j['R2'][0][3]}\n + {j['R2'][1][0]} {j['R2'][1][1]} x {j['R2'][1][2]} {j['R2'][1][3]}\n + """ + texto_3rod = f""" + \nTERCEIRA RODADA:\n + {j['R3'][0][0]} {j['R3'][0][1]} x {j['R3'][0][2]} {j['R3'][0][3]}\n + {j['R3'][1][0]} {j['R3'][1][1]} x {j['R3'][1][2]} {j['R3'][1][3]}\n + """ + return [texto_classif, texto_1rod, texto_2rod, texto_3rod]