Relatorio Final Completo

UFSC - UNIVERSIDADE FEDERAL DE SANTA CATARINA
DEPARTAMEMENTO DE INFORMTICA E
ESTATTISTICA
BACHARELADO EM SISTEMAS DE INFORMAO
DESENVOLVIMENTO DE UM SOFTWARE DE
GERENCIAMENTO DE CAMPEONATOS DE FUTEBOL
Fernando Peron
Trabalho de concluso de curso apresentado
como parte dos requisitos para obteno do
grau de Bacharel em Sistemas de Informao
Florianpolis - SC
2005/1
Fernando Peron
Trabalho de concluso de curso apresentado como parte dos requisitos para

obteno do grau de Bacharel em Sistemas de Informao.
_______________________________________________
Orientador: Prof. Fernando Augusto da Silva Cruz, Dr.
Banca Examinadora:
_______________________________________
Prof. Ricardo Pereira e Silva, Dr.
_______________________________________
Prof. Rosvelter Coelho da Costa, Dr.
Sumrio
SUMRIO .......................................................................................................... 3
LISTA DE FIGURAS.......................................................................................... 6
RESUMO ........................................................................................................... 8
1 INTRODUO ............................................................................................... 9
1.1
Objetivos .................................................................................................................................9
1.2
Motivao................................................................................................................................9
1.3
Contextualizao do Problema ............................................................................................. 10
1.4
Organizao do Trabalho..................................................................................................... 11
2 ORGANIZAO DOS CAMPEONATOS DE FUTEBOL E REGRAS......... 12

2.1
Campeonatos e Frmulas de Disputa ................................................................................... 12
2.2
Pontuao.............................................................................................................................. 13
2.3
Tabela de Classificao e Critrios de Desempate ............................................................... 13
2.4
Smula da partida de futebol ............................................................................................... 14
2.5
Tribunal Desportivo ............................................................................................................. 14
3 ESTADO DA ARTE ..................................................................................... 16

3.1
Software LeaguePad ............................................................................................................. 16
3.2
Football League Tracker (LTracker) - Verso 5.6............................................................... 20
3.3
Gerenciador de Campeonato V1.0 - Trilikix........................................................................ 23
4 FUNDAMENTOS TERICOS...................................................................... 26
4.1
Fundamentos Tericos.......................................................................................................... 26
4.2
UML...................................................................................................................................... 27
4.3
Passos para o Desenvolvimento do Programa ...................................................................... 27
4.3.1
A Fase Planejar e Elaborar .................................................................................................. 28
4.3.2
A Fase Construir................................................................................................................... 28
4.3.3
Fase Analisar ........................................................................................................................ 30
4.3.4
Fase Projetar......................................................................................................................... 31
4.3.5
Fase Testar............................................................................................................................ 31
4.3.6
Fase Instalar ......................................................................................................................... 31
5 PROPOSTA DO TRABALHO...................................................................... 33
5.1
Programa de Controle de Campeonatos de Futebol ............................................................ 33
5.2
Definio dos usurios do Sistema........................................................................................ 34
5.3
Definindo as reas do Sistema e os Casos de Uso ................................................................ 35
5.3.1
Manuteno de Campeonatos............................................................................................... 36
5.3.2
Manuteno de Equipes........................................................................................................ 38
5.3.3
Manuteno de Estdios ....................................................................................................... 39
5.3.4
Administrao de Temporadas............................................................................................. 41
5.3.4.1
Manuteno de Temporadas............................................................................................ 43
5.3.4.2
Equipes Participantes....................................................................................................... 46
5.3.4.3
Manuteno de Jogadores................................................................................................ 47
5.3.4.4
Manuteno de rbitros .................................................................................................. 50
5.3.4.5
Manuteno da Estrutura do Campeonato ..................................................................... 51
5.3.4.6
Punies............................................................................................................................ 56
5.3.4.7
Administrao de Jogos ................................................................................................... 58
5.3.4.7.1
Manuteno da Tabela de Jogos ...................................................................................... 60
5.3.4.7.2
Manuteno da Escalao do Jogo................................................................................... 62
5.3.4.7.3
Manuteno de Eventos do Jogo...................................................................................... 65
5.4
O Modelo Conceitual ............................................................................................................ 68
5.5
Diagramas de Classes de Projeto.......................................................................................... 70
6 CONSIDERAES DO PROJETO E IMPLEMENTAO DO PROG ....... 75

6.1
A Abertura do Sistema ......................................................................................................... 75
6.2
Os Cadastros......................................................................................................................... 76
6.2.1
Cadastro de Campeonato ..................................................................................................... 76
6.2.2
Cadastro de Temporada ....................................................................................................... 77
6.2.3
Cadastro de Equipe .............................................................................................................. 78
6.2.4
Cadastro de Estdios ............................................................................................................ 79
6.3
A Administrao de Temporada .......................................................................................... 80
6.3.1
Cadastro da Estrutura da Temporada ................................................................................. 81
6.3.2
Cadastro de rbitro.............................................................................................................. 81
6.3.3
Incluir Equipe na Disputa da Temporada............................................................................ 82
6.3.4
Cadastro de Jogador............................................................................................................. 83
6.3.5
Punies do Tribunal ............................................................................................................ 84
6.4
Administrao da Tabela de Jogos....................................................................................... 85
6.4.1
Manuteno de Jogos............................................................................................................ 86
6.4.2
Definir Escalao de um Jogo............................................................................................... 89
6.4.3
Definir Lances da Partida..................................................................................................... 91
6.5
As Estatsticas ....................................................................................................................... 91
6.5.1
Tabela de Classificao......................................................................................................... 92
6.5.2
Campanha por Equipe.......................................................................................................... 93
7 CONCLUSES E TRABALHOS FUTUROS ............................................... 95

BIBLIOGRAFIAS REFERENCIADAS ............................................................. 98
BIBLIOGRAFIAS CONSULTADAS................................................................. 98
ANEXO 1 BANCO DE DADOS: MODELO LGICO E.R. ........................... 99
ANEXO 2 BANCO DE DADOS: IMPLEMENTAO FSICA .................... 100
ANEXO 3 CDIGO FONTE DO SISTEMA................................................. 105
ANEXO 4 - ARTIGO ...................................................................................... 241
Lista de Figuras
Figura 3.1. LeguePad: Tela de Abertura....................................................................
16
Figura 3.2. LeguePad: Tabela de Jogos.....................................................................
17
Figura 3.3. LeguePad: Tabela de Classificao.........................................................
18
Figura 3.4. LeguePad: Baixar base de dados de um campeonato..............................
19
Figura 3.5. LTracker: Interface inicial do sistema.....................................................
20
Figura 3.6. LTracker: Tabela de classificao...........................................................
21
Figura 3.7. LTracker: Grfico de desempenho da equipe no campeonato................
22
Figura 3.8. LTracker: Tabela de jogos.......................................................................
23
Figura 3.9. Trilikix: Tabela de jogos..........................................................................
24
Figura 3.10. Trilikix: Tabela de classificao............................................................
25
Figura 5.1. Usurios do Sistema................................................................................
34
Figura 5.2. Pacote da rea do usurio........................................................................
35
Figura 5.3. Diagrama de caso de uso para Manuteno de Campeonatos.................
36
Figura 5.4. Diagrama de caso de uso para Manuteno de Equipes..........................
38
Figura 5.5. Diagrama de caso de uso para Manuteno de Estdios.........................
40
Figura 5.6. Pacote da rea do usurio com casos de usos definidos..........................
43
Figura 5.7. Diagrama de caso de uso para Manuteno de Temporadas...................
44
Figura 5.8. Diagrama de caso de uso para Equipes Participantes..............................
46
Figura 5.9. Diagrama de caso de uso para Manuteno de Jogadores.......................
48
Figura 5.10. Diagrama de caso de uso para Manuteno de rbitros.......................
50
Figura 5.11. Diagrama de caso de uso para Manuteno da Est. Temporada...........
53
Figura 5.12. Diagrama de caso de uso para Punies................................................
57
Figura 5.13. Diagrama de caso de uso para Administrao de Temporadas.............
59
Figura 5.14. Diagrama de caso de uso para Administrao de Jogos........................
60
Figura 5.15. Diagrama de caso de uso para Manuteno da Tabela de Jogos...........
60
Figura 5.16. Diagrama de caso de uso para Manuteno da Escalao Jogo............
63
Figura 5.17. Diagrama de caso de uso para Manuteno de Eventos do Jogo..........
65
Figura 5.18. Diagrama de caso de uso para Administrao de Jogos........................
68
Figura 5.19. Modelo Conceitual................................................................................
70
Figura 5.20. Diagrama de Classes do Projeto - A......................................................
72
Figura 5.21. Diagrama de Classes do Projeto - B......................................................
73
Figura 6.1. Sistema: Tela inicial................................................................................
75
Figura 6.2. Sistema: Cadastro de Campeonatos.........................................................
77
Figura 6.3. Sistema: Cadastro de Temporadas...........................................................
78
Figura 6.4. Sistema: Cadastro de Equipes..................................................................
79
Figura 6.5. Sistema: Cadastro de Estdios.................................................................
80
Figura 6.6. Sistema: Cadastro da Estrutura da Temporada........................................
81
Figura 6.7. Sistema: Cadastro de rbitros.................................................................
82
Figura 6.8. Sistema: Equipes que disputam a Temporada.........................................
83
Figura 6.9. Sistema: Cadastro de Jogadores..............................................................
84
Figura 6.10. Sistema: Punies do Tribunal..............................................................
85
Figura 6.11. Sistema: Administrao da Tabela de Jogos.........................................
86
Figura 6.12. Sistema: Cadastro de um novo jogo......................................................
87
Figura 6.13. Sistema: Cadastro de Jogo Estatsticas...............................................
88
Figura 6.14. Sistema: Cadastro de Jogo - Comentrios.............................................
88
Figura 6.15. Sistema: Cadastro de Jogo - Fotos.........................................................
89
Figura 6.16. Sistema: Escalao das Equipes............................................................
90
Figura 6.17. Sistema: Lances da Partida....................................................................
91
Figura 6.18. Sistema: Tabela de Classificao..........................................................
92
Figura 6.19. Sistema: Campanha por Equipe.............................................................
93
Resumo
O presente trabalho apresenta o desenvolvimento de um sistema de informao
para campeonatos de futebol.
O trabalho contextualiza o leitor para o entendimento do problema e mostra,
resumidamente, uma abordagem para o desenvolvimento de software orientado a
objetos.
Sua finalidade a da aplicao prtica dos conhecimentos adquiridos ao longo
do curso de Sistemas de Informao, alm de disponibilizar uma ferramenta com
qualidade que supri algumas deficincias dos sistemas similares no mercado.
Palavras-Chaves:
Sistemas
de
Informao,
Desenvolvimento
de
Software,
Programao Orientada a Objetos, Programa de Controle de Campeonatos de Futebol.
Captulo 1
Introduo
Neste captulo sero destacados o tema e a motivao para o desenvolvimento
deste projeto, contextualizando-o apresentando seus objetivos gerais e especficos, alm
da forma como o trabalho ser apresentado.
1.1 Objetivos
1.1.1
Objetivo Geral
O objetivo o desenvolvimento de um programa de computadores exercitando
na prtica os conhecimentos adquiridos durante o curso de Sistema de Informao, com

maior nfase para os conhecimentos de Programao Orientada a Objetos, Anlise e
Projeto de Software, Banco de Dados, Engenharia de Usabilidade e Engenharia de
Software. O software ser uma aplicao capaz de fazer o gerenciamento completo de
um campeonato de futebol desde controle de tabela de jogos e resultados, alm da
gerao automtica de relatrios, estatsticas e grficos que permitam ao usurio
entender melhor a competio.
1.1.2
Objetivo Especfico
Como objetivo especfico, o trabalho tem por finalidade por em prtica os
conhecimentos adquiridos durante o transcorrer do Curso de Sistemas de Informao.

Entender o escopo do problema, apresentando os aspectos relevantes de um
campeonato de futebol;
Anlise e projeto do sistema utilizando UML Unified Modeling Language;
Implementao do sistema utilizando linguagem orientada a objetos Delphi
verso 8;
Construo de um modelo relacional ER e implementao utilizando Banco
de Dados Interbase verso 7.1;
O projeto ainda utilizar conhecimentos e a prtica de Gerenciamento de
Projetos, Engenharia de Software e Engenharia de Usabilidade.
1.2 Motivao
O presente trabalho tem como tema, o desenvolvimento de um sistema de

informao computacional para auxiliar o controle de campeonatos de futebol.
O futebol o esporte mais popular e praticado no Brasil. o esporte de maior
interesse seja na programao da televiso quanto em notcias nos jornais; lota estdios.
A paixo pelo esporte grande e o brasileiro se julga um grande conhecedor do esporte.
O futebol assunto de discusso em todos os ambientes: bares, empresas, colgios, etc.
Este esporte tambm movimenta grandes quantias de dinheiro dentro e fora dos
campos. O sucesso de uma equipe num campeonato e certeza de grandes lucros.
Invariavelmente, jogadores e treinadores possuem rendimentos altssimos. Por outro
lado, fora dos gramados existem loterias pagam prmios milionrios a apostadores que
acertam os resultados dos jogos.
Este trabalho tem por objetivo apresentar-se com uma ferramenta capaz de
auxiliar os fs do esporte a acompanhar o campeonato com o apoio de grande
quantidade de informaes. Alm disso, o f poder ter nesta ferramenta, uma grande
base de dados do futebol ao seu dispor. Outra finalidade do trabalho a utilizao da
ferramenta por apostadores de loterias que podero ter nela, uma boa fundamentao de
informaes para suas apostas. Por ltimo, ela pode ser utilizada por profissionais do
esporte, como tcnicos ou clubes de futebol a fim de organizar as informaes dos
campeonatos que disputam.
1.3 Contextualizao do Problema

Conforme apresentado nos tpicos anteriores, este trabalho tem por objetivo
criar uma ferramenta para auxiliar desde simples torcedores de futebol, gerentes
profissionais de equipes de futebol at apostadores de loterias, a gerenciar campeonatos
de futebol.
Assim sendo, o sistema deve:
Apresentar solues para gerenciamento de campeonatos com as mais diferentes
frmulas de disputa;
Ter a capacidade de gerenciar as informaes que o usurio deseja controlar, ou
seja, cada usurio tem um interesse no uso do sistema e ele deve prover
condies de que cada um utilize da forma mais conveniente aos seus objetivos;
Apresentar a maior quantidade de estatsticas que as informaes que foram
inseridas no sistema possam gerar.
10
1.4 Organizao do Trabalho

Este trabalho, em seu segundo captulo contextualizar o funcionamento dos
campeonatos de futebol, apresentando as variaes de regulamentos de disputa e como
isso afeta um sistema de gerenciamento de campeonatos de futebol. Neste mesmo
captulo ser tambm apresentado uma viso das funcionalidades que devero estar
presentes no software, assim como as suas limitaes.
O captulo terceiro mostra algumas ferramentas existentes para controle de
campeonato de futebol e faz uma anlise de cada uma delas. O contedo deste captulo,
alm de ajudar no entendimento do problema, ajuda tambm na avaliao do resultado
deste trabalho, medida que permite uma comparao.
No quarto captulo, o trabalho apresentada o um processo de desenvolvimento
de software em todas as suas fases. O objetivo utilizar este processo, com algumas
variaes e aplic-lo no desenvolvimento deste software.
No captulo cinco, mostra a anlise e projeto do sistema. Este captulo mostra
como o software foi pensado e planejado antes de ser implementado. J o captulo seis
apresenta o resultado final da implementao do sistema, onde possvel verificar os
resultados finais do trabalho.
Por fim, so apresentadas uma breve concluso do trabalho e algumas propostas
para futuros trabalhos relacionados ao tema.
11
Captulo 2
Organizao dos Campeonatos de Futebol e
Regras
Introduo
O futebol conhecido como um esporte com regras conservadoras, ou seja, de
poucas mudanas ao longo do tempo. Ao mesmo tempo, para tornar o futebol mais
atraente para o pblico, as frmulas de disputa dos campeonatos de futebol so bastante
diversificadas. O objetivo deste captulo apresentar as principais variaes das
formulas de disputa dos campeonatos, alm de eventuais variaes das aplicaes da
regra do esporte. Por fim, tambm so apresentados os pontos fundamentais de
organizao do campeonato, como a Smula do Jogo e a influncia do Tribunal
Desportivo. Todos os pontos abordados neste captulo devero se concretizar em
solues flexveis dentro do software desenvolvido.
2.1 Campeonatos e Frmulas de Disputa

As frmulas de disputas de um campeonato o mecanismo que organiza a
maneira de como ser disputada a competio. Na frmula de disputa de uma
competio definido de que forma ser conhecido o campeo da disputa, a ordem de
classificao, os times que sero rebaixados, etc.
Os campeonatos de futebol so organizados por diferentes frmulas de disputa.
Uma Copa do Mundo, por ser um campeonato disputado num espao de tempo curto e
possuir uma grande quantidade de equipes participantes, possui uma frmula de disputa
bastante particular. A Copa do Mundo dividida em fases. Dentro de cada fase, as
equipes so dividas em Grupos. Os melhores colocados de cada um dos grupos se
classificam para fase seguinte, at a grande final do campeonato, onde o vencedor o
campeo.
12
J os campeonatos nacionais, como, por exemplo, o Campeonato Brasileiro de

2004 e Campeonato Ingls, possuem frmula de disputa mais tradicional, adequado ao
tempo de disputa e ao pequeno nmero de times participantes. Neste tipo de
campeonato, a disputa numa nica fase e um nico grupo. Todos jogam entre si, uma,
duas, trs ou quatro vezes dependendo da frmula de disputa do campeonato. Ao final
do campeonato, o campeo a equipe que mais acumular pontos ao longo do
campeonato. Neste tipo de frmula de disputa no existe a grande final.
2.2 Pontuao
Este outro importante item que pode variar de campeonato para campeonato e
at mesmo, sofrer alteraes ao longo do tempo. Basta citar que at 1994, a equipe
vencedora dos jogos ganhava dois pontos pelo feito.
As regras de pontuao adotadas pela FIFA, organizao que dirige o futebol no
mundo estabelece as seguintes pontuaes: trs pontos ao time vencedor ou, em caso de
empate, um ponto para cada time.
Esta pontuao adota pela maioria dos campeonatos de futebol do mundo.
Porm, at pouco tempo atrs, as regras de pontuao eram diferentes. At a Copa do
Mundo de 1994, a FIFA estabelecia as seguintes pontuaes: dois pontos ao time
vencedor ou, em caso de empate, um ponto para cada time.
Existem ainda algumas variaes adotadas por alguns campeonatos, por
exemplo, o campeonato do EUA, os jogos que acabam empatados, existe uma disputa
de Shut-Out, uma espcie de disputa de pnaltis. Este tipo de regra j foi adotado
recentemente no Campeonato Brasileiro. A regra de pontuao deste tipo de
campeonato a seguinte: trs pontos ao time vencedor ou em caso de empate no tempo
normal de jogo, dois pontos ao time vencedor na prorrogao ou nos pnaltis e um
ponto para o time perdedor na prorrogao e nos pnaltis.
2.3 Tabela de Classificao e Critrios de Desempate

A principal informao de um campeonato de futebol, alm do resultado da
partida, a tabela de classificao. A tabela de classificao mostra as somas de pontos
13
alcanadas pelas equipes no campeonato. ela que determina a posio de cada equipe
no campeonato.
A tabela de classificao de um campeonato tambm contempla outras
informaes. Estas informaes, em geral, so os critrios de desempates. Os critrios
de desempate, em geral, so os mesmos em todos os campeonatos. O que muda a
ordem de importncia. Em todos os campeonatos, o primeiro critrio o nmero de
pontos ganhos. O segundo critrio, para o caso de empate o nmero de vitrias para
alguns campeonatos, enquanto que em outros campeonatos, o segundo critrio o saldo
de gols. Tambm so utilizados como critrios de desempate o nmero de gols
marcados.
2.4 Smula da partida de futebol

Para todo jogo de futebol realizado existe um documento oficial intitulado
Smula que possui o resumo dos acontecimentos do jogo. A smula preenchida
pelos rbitros da partida. Nela so colocadas as seguintes informaes:
Times que disputaram a partida, resultado da partida, data e hora do jogo. Constam
tambm quais os jogadores marcaram os gols da partida. Alm disso, nela h os
jogadores que disputaram a partida e as substituies ocorridas no transcorrer do jogo.
Tambm esto inclusos neste documento, as penalidades aplicadas pelo rbitro, como
cartes amarelo e vermelho.
O software deste trabalho tem o objetivo fazer um resumo desta smula da
partida, podendo at mesmo, incluir informaes que no constam na smula oficial,
com a finalidade de gerar uma variedade maior de estatsticas do campeonato.
2.5 Tribunal Desportivo

O Tribunal Desportivo um rgo responsvel por aplicar as leis descritas nas
regras do futebol e no regulamento das competies. O Tribunal Desportivo aplica
sanses as equipes e jogadores do campeonato e muitas destas sanes possuem
influencia direta no campeonato, como por exemplo a perda de pontos, perda de mando
de campo ou suspenso de jogadores.
14
Concluso
A ferramenta proposta neste trabalho deve ter grande flexibilidade para aceitar
que as diferentes competies de futebol possam ser controladas. aceitvel que em
virtude desta flexibilidade, o sistema possa perder qualidade em legibilidade e
usabilidade.
O software tambm tem por objetivo gerar uma grande quantidade de estatstica
do campeonato, das equipes e dos jogadores. Fica evidenciado desta forma, que no
pode simplesmente fazer uma cpia eletrnica da Smula. necessrio obter outras
informaes da partida para gerar tais estatsticas.
15
Captulo 3
Estado da Arte
Introduo
Este captulo apresenta trs ferramentas disponveis na Internet para download
que tem objetivos semelhantes aplicao objeto deste trabalho. O captulo apresenta os
pontos positivos e negativos de cada uma das ferramentas. O aproveitamento das boas
solues e a precauo com as franquezas das ferramentas existentes colaboraram para
o desenvolvimento de um software completo e eficiente. Tambm ter a finalidade de
estabelecer um parmetro de qualificao do resultado deste trabalho.
3.1 Software LeaguePad

O software LeaguePad, disponvel para download gratuito de sua verso trial e
com algumas limitaes de recursos em http://www.leaguepad.com/, uma das
aplicaes mais interessantes e conhecidas na internet com a finalidade de administrar
estatsticas de campeonatos de futebol. Suas interfaces com o usurio esto disponveis
em trs diferentes lnguas: ingls, francs e espanhol.
Figura 3.1. LeguePad: Tela de Abertura.
16
O LeaguePad um software extremamente flexvel. Atravs dele possvel

gerenciar qualquer tipo de competio de futebol.
O software tambm se adapta as necessidades do usurio. Para os usurios que
querem obter grandes quantidades de informaes, o software atende a quase tudo que
se possa imaginar. Por outro lado, caso o usurio queira apenas ter a tabela de jogos, os
resultados e a classificao atualizada automaticamente, este software se adapta
perfeitamente. A figura 3.2 mostra a tela do sistema onde o usurio gerencia a tabela de
jogos do sistema. Nela possvel perceber a riqueza de informaes de uma partida que
o sistema permite inserir.
Figura 3.2. LeguePad: Tabela de Jogos.

J a figura 3.3 mostra a tabela de classificao gerada automaticamente pelo
sistema a partir das informaes inseridas na tabela de jogos. outro relatrio do
sistema com riqueza de informaes. Nesta mesma imagem, possvel observar no
menu do lado direito da interface, a grande quantidade de relatrios e estatsticas
oferecidos pelo sistema. Tanto na figura 3.2 quanto 3.3, percebe-se o cuidado dos
desenvolvedores do software com a interface do sistema, que tem um visual bastante
moderno.
17
Figura 3.3. LeguePad: Tabela de Classificao.

Outro ponto forte , para o caso dos usurios que no querem inserir as
informaes no sistema, o que uma tarefa bastante trabalhosa, ele permite baixar
atualizaes dos campeonatos pela Internet, conforme mostra a figura 3.4. Assim, o
usurio tem a possibilidade de acessar as diversas estatsticas geradas pelo sistema sem
ter qualquer trabalho. Estas atualizaes so postadas por usurios que gerenciam seus
campeonatos e compartilham as informaes com os demais.
18
Figura 3.4. LeguePad: Baixar base de dados de um campeonato.

Tambm interessante o site www.soccerstats.com, que utiliza da base de dados
do sistema para mostrar na Internet as estatsticas para os usurios que no adquiram o
sistema. Porm, nem todas as estatsticas que o software gera so mostradas no site.
O ponto fraco deste software o fato de ele tratar cada temporada de um
campeonato de forma independente. Isso quer dizer que no possvel fazer uma
anlise entre duas temporadas de um campeonato de um determinado pas. O mesmo
problema ocorre com as equipes. Elas so tratadas de forma independente dentro de
cada campeonato. Assim, se uma equipe A disputa dois campeonatos cadastrados no
sistema. O sistema interpreta com duas equipes distintas, no sendo possvel gerar
estatsticas da equipe A nestes dois campeonatos que disputou.
A ferramenta foi desenvolvida na Frana e custa entre
50,00 e
90,00,
dependendo da verso. Por se tratar de uma ferramenta bastante completa e com

servios de atualizao de dados on-line sem custos adicionais, o valor justificvel.
Porm, para os padres brasileiros, pode ser considerado um custo elevado.
19
3.2 Football League Tracker (LTracker) - Verso 5.6

O Football League Tracker outro bom software que se prope a fazer o
controle de campeonatos de futebol. Desenvolvido por Sr. Nigel Thomas, o programa
de origem inglesa e est disponvel para download gratuito no endereo
www.ngthomas.co.uk.
Figura 3.5. LTracker: Interface inicial do sistema Manuteno de Campeonato.

Este programa tambm bastante completo. Abrange quase todas as estatsticas
que o jogo de futebol pode gerar. possvel controlar alm da tabela de classificao,
dados a respeito dos jogadores, como, por exemplo, lista de artilheiros e jogadores que
marcaram gols contra. Tambm possvel acessar uma tabela de informaes sobre as
arbitragens do campeonato. Nesta tabela possvel saber quantos cartes o juiz aplicou
durante o campeonato, qual a mdia de faltas que ele marca por jogo, quantos gols em
mdia ocorrem durante os jogos que um determinado arbitro apita.
20
Figura 3.6. LTracker: Tabela de classificao.

O software tambm repleto de grficos para mostrar o desempenho das equipes
ao longo do certame. Grficos que mostram, por exemplo, a posio na classificao de
um determinado time ao longo da competio, conforme a figura 3.7. Outro grfico
mostra uma comparao de desempenho entre um time e os lideres do campeonato.
21
Figura 3.7. LTracker: Grfico de desempenho da equipe no campeonato.

O programa deixa a desejar em sua interface de difcil compreenso. Algumas
tabelas possuem seus cabealhos com as palavras pela metade, no sendo possvel saber
que dado est inserido na coluna da tabela. O procedimento para inserir os jogos e
placares, alm das estatsticas tambm no simples. Requer bastante trabalho do
usurio para aprender e posteriormente usar. Existe tambm uma grande quantidade de
menus em algumas interfaces. A figura 3.8 ilustra este problema. Nela observa-se um
menu inferior e outro menu na parte superior da interface.
22
Figura 3.8. LTracker: Tabela de jogos.

O maior problema do software est no fato de ter sido projetado para
acompanhar exclusivamente campeonatos com frmulas de disputa semelhante aos
disputados pelos campeonatos nacionais disputado na Europa. invivel inserir no
sistema campeonatos organizados por Fase e Grupos. Outro problema semelhante ao
LeguePad o fato do sistema interpretar cada campeonato de forma independente.
3.3 Gerenciador de Campeonato V1.0 - Trilikix

O Gerenciador de Campeonato Verso 1.0, disponvel para download em verso
Demo no endereo http://www.trilikix.com/gerenciador.php, uma ferramenta de
controle de campeonatos de futebol desenvolvida no Brasil.
um software mais simples que o LeaguePad e o LTracker. Suas
funcionalidades basicamente servem para o acompanhamento da tabela de jogos e seus
respectivos resultados e a gerao automtica da tabela de classificao a partir dos
placares inseridos nos jogos.
23
Figura 3.9. Trilikix: Tabela de jogos.

Como o programa somente insere placar do resultado do jogo, no tendo a
possibilidade de inserir estatsticas da partida ou escalao das equipes, a qualidade das
informaes geradas pelo sistema ruim. As estatsticas so feitas exclusivamente sobre
os resultados dos jogos.
O software no consegue gerenciar as diferentes frmulas de disputas de
campeonatos. Est adaptado exclusivamente para os campeonatos com frmula de
disputa semelhante aos dos campeonatos nacionais disputados na Europa. Nestes
campeonatos, as equipes jogam entre si e a que somar mais pontos a campe. No caso
de haver interesse por inserir um campeonato onde as equipes so organizadas em
Grupos e a competio tem diferentes fases de disputa, o software no gerencia estas
situaes.
24
Figura 3.10. Trilikix: Tabela de classificao.

Mesmo sendo um software com muitos defeitos e poucas qualidades, o custo
para aquisio da verso licenciada de R$ 149,90.
Concluso
Existem ferramentas disponveis no mercado com a finalidade de gerenciar
campeonatos de futebol. Embora algumas delas possuam boas qualidades, no foi
identificada nenhuma ferramenta completa. Os valores para aquisio deste programas
tambm no so baratos. Um software bom deve ter a capacidade de se adaptar as
diferentes frmulas de disputa dos campeonatos. Tambm deve ser capaz de administrar
todas as informaes inerentes a realizao de um jogo, mas deixando a critrio do
usurio fazer uso destas informaes ou no. Gerar boa qualidade de estatsticas
preferencialmente no tratando cada campeonato ou equipe de forma individualizada. E
por fim, ter um custo mais acessvel ao mercado nacional.
25
Captulo 4
Fundamentos Tericos
Introduo
Neste captulo apresentada a fundamentao terica que se utilizar para o
desenvolvimento do programa de Controle de Campeonatos. So descritos os conceitos
e uma seqncia de atividades que resultaro em um sistema orientado a objetos bem
projetado.
4.1 Fundamentos Tericos

A Programao Orientada a Objetos uma extenso natural da programao
estruturada. Sua essncia a reutilizao de cdigo. Uma vez que voc cria um objeto
para uma aplicao, este objeto poder (e dever) ser utilizado em novas aplicaes
[SIL 00].
Conforme descrito no captulo 1 deste trabalho, o objetivo especfico de
construir um programa para computadores utilizando os conceitos de programao
orientada a objetos. Porm, a construo de um bom programa orientado a objetos vai
alm de saber o dominar uma linguagem orientada a objetos, como por exemplo, Java
ou Delphi. Este apenas o primeiro passo para construo. fundamental para
obteno do sucesso do trabalho uma boa anlise e um bom projeto.
Assim, o trabalho se basear na metodologia proposta pelo livro de Craig
Larman: Utilizando UML e Padres. Este livro apresenta um exemplo de processo de
desenvolvimento, o qual descreve uma possvel ordem de atividades e um ciclo de vida
de desenvolvimento. Contudo, ele no prescreve um processo ou metodologia
definitiva; ele fornece um exemplo de passos comuns.
Porm, antes de apresentar a metodologia proposta por Craig Larman, o trabalho
far uma breve explicao sobre UML.
26
4.2 UML
Unified Modeling Leaguage Linguagem de Modelagem Unificada ou
somente UML uma linguagem visual para modelar sistemas computacionais
orientados a objetos. Possui um sistema de notao incluindo semntica para suas
notaes dirigida a modelagem de sistemas, usando conceitos orientados a objeto. A
UML uma linguagem para especificar, visualizar e construir os artefatos de sistema de
software.
UML tem o poder de transformar idias em modelos reais. uma linguagem
destina estruturao de projetos. Um dos principais objetivos da UML tornar todo o
processo de desenvolvimento totalmente transparente e organizado [SOA 01].
A UML uma notao grfica usada para expressar a anlise e criao de
projetos de software e para comunic-los a outros. A UML independente de
linguagem, mas destina-se a descrever projetos orientados a linguagem. Como
enfatizam os criadores da UML, ela no uma metodologia em si; pode ser usada como
ferramenta descritiva independente de qual seu processo de projeto [CAN 00].
Para Craig Larman, ...os autores da UML Booch, Jocobson e Rumbaugh prestaram
um grande servio comunidade da tecnologia orientada a objetos ao criar uma
linguagem de modelagem padronizada que elegante, expressiva e flexvel. e
prossegue ... UML recebeu a aprovao de facto pela indstria, uma vez que seus
criadores representam mtodos de anlise e / ou projeto de primeira gerao muito
populares..
Porm, Craig Larman adverte que UML uma linguagem para modelagem; ela
no guia um desenvolvedor em como fazer anlise e projeto orientados a objetos, ou
qual processo de desenvolvimento a ser seguido. Conseqentemente, os metodologistas
continuaro a definir mtodos, modelagem e processos de desenvolvimento para a
criao efetiva de sistemas de software; no entanto, agora, podem faz-lo, usando uma
linguagem comum UML.
4.3 Passos para o Desenvolvimento do Programa

Em sua metodologia, Craig Larman esclarece que Em um nvel alto, os
principais passos at a entregar uma aplicao incluem os seguintes:
27
1. Planejar e Elaborar Planejamento, definio de requisitos, construo de

prottipos e assim por diante.
2. Construir A construo do sistema.
3. Instalar A implantao do sistema para uso.
Ele complementa dizendo que Um processo de desenvolvimento de software
um mtodo para organizar as atividades relacionadas com a criao, entrega e
manuteno de sistemas de software.
4.3.1 A Fase Planejar e Elaborar

Para Craig Larman, A fase Planejar e Elaborar de um projeto inclui a
concepo inicial, a investigao de alternativas, o planejamento, a especificao de
requisitos e assim por diante.
Uma lista de artefatos que esta fase do projeto deve gerar listada abaixo:
1. Plano cronograma, recursos, oramento, etc.
2. Relatrio de Investigao Preliminar motivao, alternativas, necessidades
de negcio.
3. Especificao de Requisitos: exposio declarativa dos requisitos;
4. Casos de Uso: descrio em prosa de processos do domnio;
5. Diagramas de Casos de Uso: ilustrao de todos os casos de uso e seus
relacionamentos.
6. Rascunho do modelo conceitual: um modelo conceitual preliminar
aproximado, para ajuda na sua compreenso de como ele se relaciona com os casos de
uso e a especificao dos requisitos.
A construo dos artefatos cima listados no deve ser feita em ordem linear.
Pelo contrrio. Ser freqente s vezes em que duas ou mais tarefas sero desenvolvidas
em paralelo, embora em alguns casos fique evidente a necessidade de uma tarefa antevir
a outra, como por exemplo, a definio dos casos de uso vir a ser feita antes do
rascunho do modelo conceitual.
4.3.2 A Fase Construir

A fase construir envolve a implementao do projeto em software e em
hardware. Envolve repetidos ciclos de desenvolvimento (provavelmente limitadas em
28
tempo), dentro dos quais o sistema estendido. O objetivo final um sistema de

software em operao que atenda corretamente os requisitos.
Um ciclo de desenvolvimento na fase construir compreende as seguintes etapas:
refinar plano, sincronizar artefatos, analisar, projetar, construir, testar.
Antes de falar sobre cada uma das etapas da fase construir, importante definir
um ciclo de desenvolvimento do projeto. Craig Larman prope um ciclo de
desenvolvimento chamado de Iterativo.
Um Ciclo de Desenvolvimento, ou tambm chamado de ciclo de vida, Iterativo
se baseia no aumento e no refinamento sucessivo de um sistema atravs de mltiplos
ciclos de desenvolvimentos de anlise, de projeto, de implementao e de testes.
O sistema cresce pelo acrscimo de novas funes em cada ciclo de
desenvolvimento. Depois de uma fase preliminar de Planejar e Elaborar, o
desenvolvimento continua numa fase Construir atravs de uma srie de ciclos de
desenvolvimento.
Cada ciclo trata de um conjunto relativamente pequeno de requisitos,
procedendo atravs da anlise, do projeto, da construo e do teste. O sistema cresce
incrementalmente, medida que cada ciclo completado.
O desenvolvimento iterativo no significa desenvolver um trabalho banal por um
tempo, atingir um marco no projeto e, ento, experimentar mais um pouco. Uma
definio do desenvolvimento iterativo que ele um processo planejado para voltar a
uma rea repetidamente, cada vez, complementando o sistema. Ele um processo
formalmente planejado e escalonado, e no algo que acontece ao acaso.
A definio de desenvolvimento incremental adicionar funcionalidades a um
sistema durante vrios ciclos de liberao de produto; cada incremental (nova verso do
produto) contm mais funcionalidades. importante no confundir: uma verso
incremental composta de mltiplos ciclos de desenvolvimento.
A principal desvantagem do desenvolvimento iterativo e incremental o
aumento das expectativas. Uma vez que esse processo permite que sejam efetuadas
demonstraes, logo tende-se a pensar que o sistema est quase pronto.
Um Caso de Uso uma descrio narrativa de um processo do domnio. Ciclos
de desenvolvimento interativos so organizados por requisitos de casos de uso.
Os Casos de Uso deveriam ser priorizados, e os de alta prioridade deveriam ser
atacados nos ciclos de desenvolvimentos iniciais. A estratgia abrangente , primeiro,
pegar os casos de uso que influenciam significativamente o ncleo da arquitetura,
29
materializando as camadas do domnio e dos servios de alto nvel, ou aqueles que so

de uso crticos de alto risco.
Os dois principais passos da fase construir - analisar e projetar so as fases
abordadas no livro de Craig Larman com grande nfase. Abaixo apresentado em
detalhes o desenvolvimento de cada uma destas duas etapas.
Para criar um software de uma aplicao, necessria uma descrio do
problema e dos seus requisitos o que o problema e o que o sistema deve fazer. A
anlise enfatiza uma investigao do problema, de como uma soluo definida.
Para desenvolver uma aplicao tambm necessrio ter descries de alto
nvel e descries detalhadas da soluo lgica e de como ela atende os requisitos e as
restries. O projeto enfatiza uma soluo lgica, ou seja, como o sistema atende os
requisitos, afinal, projetos devem ser implementados em software e hardware.
4.3.3 Fase Analisar

Segundo Craig Larman, A essncia da anlise e do projeto orientados a objeto
enfatizar a considerao de um domnio de problema e uma soluo lgica, segundo a
perspectiva de objetos (coisas, conceitos ou entidades). Na anlise orientada a objetos,
h uma nfase na descoberta e na descrio dos objetos ou conceitos do domnio do
problema.
A Fase Analisar deve abranger as seguintes etapas:
1. Construir um modelo conceitual inicial, identificando os conceitos, atributos e
suas corretas associaes.
2. Fazer Diagrama de seqncia para os casos de uso identificando os eventos e
as operaes do sistema. Este diagrama de seqncias mostrado por Craig Larman no
pertence notao UML, porm ser um importante artefato para a construo do
Diagrama de Interao da UML na fase Projetar.
3. Criar contratos para as operaes do sistema que um documento o que uma
operao se compromete a atingir. Usualmente, ele segue um estilo declarativo,
enfatizando o que acontecer, em vez de como ser conseguido. comum em termos de
mudanas de estado definidas por pr-condies e ps-condies. Um contrato pode ser
escrito para um mtodo individual de uma classe de software ou para uma operao
mais abrangente do sistema.
30
Durante um ciclo de desenvolvimento iterativo, possvel passar para a fase de

projeto desde que estes documentos de anlise estejam completos.
4.3.4 Fase Projetar

Para Craig Larman Durante o projeto orientado a objetos existe uma nfase na
definio de elementos lgicos de software, os quais, em ltima instncia, sero
implementados em uma linguagem de programao orientada a objetos. Estes objetos de
software tm atributos e mtodos. Finalmente, durante a construo ou programao
orientada a objetos, os componentes do projeto so implementados, tais como uma
classe.
Durante este passo, desenvolvida uma soluo lgica baseada no paradigma
orientado a objetos. O corao desta soluo a criao de diagramas de interao, os
quais ilustram como os objetos devem se comunicar de maneira a atender os requisitos.
Em seguida gerao de diagramas de interaes, podem ser desenhados diagramas de
classes, os quais sumarizam a definio das classes (e interfaces) que devem ser
implementadas em software.
A criao de diagramas de interao requer a aplicao de princpios para a
atribuio de responsabilidades e visibilidades.
4.3.5 Fase Testar

A fase Testar tem por objetivo verificar eventuais falhas de desenvolvimento no
sistema. Devem avaliar basicamente trs quesitos: funcionalidade (o sistema executa
corretamente suas funes normais), recuperao (o sistema recupera-se adequadamente
em caso de falha); desempenho (o sistema apresenta tempo de resposta adequado).
Geralmente, a fase Testar entendida com o ltimo passo dentro de um ciclo de
desenvolvimento. Porm, recomenda-se que seja uma atividade permanente durante a
fase Construir.
4.3.6 Fase Instalar

A fase instalar envolve a colocao do sistema em produo. Para o software
desenvolvimento com finalidades comerciais, isso significa que ele j est venda e
31
disponvel para os clientes; para o software desenvolvido em uma instalao, significa

que ele est em uso operacional.
Concluso
Possuir conhecimentos avanados de uma linguagem de programao orientada
a objetos ou mesmo de UML no garante a produo de bom programa de computador.
So apenas requisitos. Para o desenvolvimento de grandes projetos com sucesso,
necessrio uma metodologia de desenvolvimento de software. A metodologia prope
um processo de desenvolvimento de software iterativo, incremental e guiado por casos
de usos. Este estabelece ciclos de desenvolvimentos dentro de janelas de tempo de
forma a organizar o projeto. Por ser uma metodologia criada para ajudar estudantes e
desenvolvedores a criar melhores projetos orientados a objetos, ser a metodologia
seguida no desenvolvimento deste trabalho.
32
Captulo 5
Proposta do Trabalho
Introduo
Nos captulos 2 foram apresentadas informaes do domnio do problema acerca
do funcionamento de um campeonato de futebol. No captulo 3, foram apresentados trs
softwares que so soluo para administrar a complexidade dos campeonatos de futebol.
Este captulo tem por funo apresentar o que se deseja construir neste software para
gerenciar os campeonato, aproveitando-se dos conhecimentos obtidos no captulo 2 e 3.
Alm disso, neste captulo tambm descrito os resultados obtidos das fases de anlise
e planejamento do sistema, para no prximo capitulo demonstrar o resultado final.
5.1 Programa de Controle de Campeonatos de Futebol

A proposta deste trabalho a criao de um programa de computador para fazer
o controle de campeonatos de futebol.
De acordo com a literatura apresentada no captulo 3 deste trabalho, um bom
sistema de controle de campeonatos deve ser capaz de gerenciar vrios campeonatos de
futebol. Dentro de cada campeonato, deve ser possvel incluir as equipes que disputam a
competio e os jogadores inscritos por estas equipes. Tambm fazem parte de um
campeonato, os rbitros que apitam um jogo e o sistema tambm deve abranger este
fato.
Um sistema robusto para controle de campeonatos, deve principalmente ser
capaz de aceitar o gerenciamento dos mais diferentes tipos de competies de futebol.
sabido, conforme explicado no captulo 2, que cada tipo de competio tem suas
frmulas de disputa. Uma Copa do Mundo, exemplo, numa primeira fase as equipes so
divididas em grupos. As equipes melhores colocadas avanam para fase seguinte, onde
novamente se organizam em grupos e assim sucessivamente at chegar a grande final.
J num campeonato nacional disputado em um pas da Europa, como por exemplo, o
Campeonato Ingls de Futebol, possui uma frmula de disputa diferente da frmula de
33
disputa da Copa do Mundo. No Campeonato Ingls, as equipes jogam todas entre si em

uma nica fase em um nico grupo. A que somar mais pontos a grande campe.
Tambm a de se esperar de um bom software de Controle de Campeonatos a
possibilidade de gerenciar os jogos dentro da competio, incluindo a escalao das
equipes e juizes. Alm do simples placar do jogo, deve ser possvel inserir no sistema as
diversas estatsticas inerentes a uma partida de futebol. Em contrapartida, desejvel
que este sistema nos mostre de forma automtica, uma porca de relatrios estatsticos
que nos ajudem a compreender a competio.
Desta forma, o que se pretende neste captulo fazer uma descrio detalhada
das funcionalidades esperadas pelo software que ser desenvolvido neste trabalho.
Estas funcionalidades do software podem ser divididas em duas partes: Mdulo
de Gerenciamento do Campeonato e Mdulo de Gerao de Relatrios e Grficos. No
Mdulo de Gerenciamento do Campeonato onde as informaes do campeonato so
includas no sistema. J o Mdulo de Gerao de Relatrios e Grficos a parte do
sistema que abastecido das informaes entradas na rea de Gerenciamento do
Campeonato, gera os relatrios e grficos. Abaixo veremos uma descrio mais
detalhada do que cada parte do sistema compreende.
5.2 Definio dos usurios do Sistema

O sistema no exige grandes preocupaes com controles de acesso. Por se tratar
de informaes facilmente encontradas em peridicos e na Internet, no existe qualquer
controle a ser feito quanto restrio de acesso as informaes. Assim, podemos
imaginar um nico usurio interagindo com o sistema, sendo capaz de realizar todas as
operaes disponveis.
Assim, no seguimento deste trabalho, as interaes deste usurio com o sistema
sero representados da seguinte forma:
Figura 5.1. Usurios do Sistema.
34
5.3 Definindo as reas do Sistema e os Casos de Uso

O sistema deve ser capaz de suportar o controle de diversos campeonatos. Os
campeonatos so disputados em sua grande maioria anualmente. Cada edio de um
campeonato recebe o nome de Temporada. Assim, um campeonato deve ser cadastrado
uma nica vez. Por exemplo, o Campeonato Brasileiro da Srie A corresponde a um
nico cadastro. Cada edio deste campeonato corresponde a uma temporada. Esta
separao entre Campeonato e Temporada permitir ao sistema gerar informaes de
um Campeonato ao longo das diversas Edies. Com isso, o conceito de campeonato no
sistema bastante simples, entretanto o conceito de Temporada muito mais complexo,
pois na temporada que efetivamente registradas as tabelas de jogos e implicaes.
Suas funes sero descritas com maiores detalhes ainda neste captulo.
Outros dois importantes conceitos que o sistema administrar de forma nica so
as Equipes e os Estdios. Assim como os campeonatos, uma Equipe e um Estdio sero
cadastrados uma nica vez. Desta forma ser possvel gerar todas as informaes
referentes a uma Equipe ao longo das diferentes competies que disputou.
Assim, a rea de acesso do sistema de um usurio pode ser dividida, inicialmente
em quatro diferentes atividades, conforme demonstra a Figura 5.2.
Figura 5.2. Pacote da rea do usurio.

A seguir, cada um dos pacotes ser detalhado, descrevendo seus casos de usos,
para melhorar o entendimento de cada rea do sistema. Para cada caso de uso descrito
ao longo deste captulo, foi implementado um diagrama de seqncia, porm, para
facilitar a compreenso do trabalho, eles no sero descritos neste captulo.
35
5.3.1 Manuteno de Campeonatos

A Manuteno de Campeonatos a rea onde o usurio efetuar o cadastro das
diferentes competies. Nesta rea, as trs principais tarefas a serem realizadas so a
Criao de novo campeonato, a Alterao dos dados de um campeonato e a Excluso de
um Campeonato do sistema.
Figura 5.3. Diagrama de caso de uso para Manuteno de Campeonatos.

Abaixo descrito cada um destes processos em detalhes:
Criar um novo Campeonato

Procedimentos:
1. O sistema exibe o formulrio para cadastro de novo campeonato.
2. O usurio informa os dados do Campeonato (Nome do Campeonato e o Pas
onde disputado), escolhe o Tipo de Competio (Campeonato Nacional,
Campeonato Internacional de Clubes, Campeonato de Selees ou Demais
Campeonatos) e solicita a gravao do cadastro.
3. O sistema verifica se todos os dados foram informados e se esto corretos. Caso
estejam, o cadastro efetivado no sistema.
Alternativas:
1. Todos os obrigatrios no foram preenchidos. O sistema informa ao usurio
quais os campos que no foram preenchidos e solicita ao usurio que corrija o
erro.
Selecionar um Campeonato
36
Procedimentos:
1. O sistema exibe a lista de Campeonatos Cadastrados.
2. O Usurio seleciona o Campeonato desejado e escolhe a opo de manuteno
(Alterar Dados ou Excluir Campeonato).
Alternativas:
1. No existem Campeonatos cadastrados. O sistema desabilita as funes de
manuteno de Campeonato, no permitindo ao usurio Alterar Dados ou
Excluir Campeonato.
Alterar dados de um Campeonato

Procedimentos:
1. O sistema busca no banco de dados os dados do cadastro e exibe em um
formulrio.
2. O Usurio altera os dados desejados e solicita a gravao das alteraes.
Alternativas:
1. Os dados do campeonato selecionado no existem ou esto corrompidos. O
sistema exibe uma mensagem de alerta quanto ao problema encontrado.
erro.
Excluir um Campeonato
Procedimentos:
1. O sistema solicita a confirmao da excluso do Campeonato.
2. Aps a confirmao do usurio o sistema exclui o Campeonato do banco de
dados.
Alternativas:
1. O usurio no confirma a inteno de excluso do Campeonato. O sistema no
procede operao de excluso do Campeonato.
2. O Campeonato j possui uma Temporada cadastrada, sendo referenciado por
outros dados. O sistema alerta o usurio da impossibilidade de excluso do
Campeonato.
37
5.3.2 Manuteno de Equipes

A Manuteno de Equipes a rea onde o usurio efetuar o cadastro das
Equipes. Nesta rea, as trs principais tarefas a serem realizadas so a Criao de nova
Equipe, a Alterao dos dados de uma Equipe e a Excluso de uma Equipe do sistema.
Figura 5.4. Diagrama de caso de uso para Manuteno de Equipes.

Criar uma nova Equipe

Procedimentos:
1. O sistema exibe o formulrio para cadastro de nova Equipe.
2. O usurio informa os dados da Equipe (Nome, Nome Completo, Cidade, Pas,
Data de Fundao, Nome do Estdio e a imagem do Escudo), escolhe o Tipo de
Equipe (Equipe ou Seleo) e solicita a gravao do cadastro.
Alternativas:
erro.
Selecionar uma Equipe

Procedimentos:
1. O sistema exibe a lista de Equipes Cadastradas.
38
2. O Usurio seleciona a Equipe desejada e escolhe a opo de manuteno

(Alterar Dados ou Excluir Equipe).
Alternativas:
1. No existem Equipes cadastradas. O sistema desabilita as funes de
manuteno de Equipes, no permitindo ao usurio Alterar Dados ou Excluir
Equipe.
Alterar dados de uma Equipe

Procedimentos:
1. O Sistema busca no banco de dados os dados do cadastro e exibe em um
formulrio.
Alternativas:
1. Os dados da Equipe selecionada no existem ou esto corrompidos. O sistema
exibe uma mensagem de alerta quanto ao problema encontrado.
erro.
Excluir uma Equipe

Procedimentos:
1. O sistema solicita a confirmao da excluso da Equipe.
2. Aps a confirmao do usurio o sistema exclui a Equipe do banco de dados.
Alternativas:
1. O usurio no confirma a inteno de excluso da Equipe. O sistema no
procede operao de excluso da Equipe.
2. A Equipe j est inclusa na disputa de uma Temporada de um Campeonato,
sendo referenciado por outros dados. O sistema alerta o usurio da
impossibilidade de excluso da Equipe.
5.3.3 Manuteno de Estdios

A Manuteno de Estdios a rea onde o usurio efetuar o cadastro dos
Estdios de Futebol. Nesta rea, as trs principais tarefas a serem realizadas so a
39
Criao de novo Estdio, a Alterao dos dados de um Estdio e a Excluso de um

Estdio do sistema.
Figura 5.5. Diagrama de caso de uso para Manuteno de Estdios.

Criar um novo Estdio

Procedimentos:
1. O sistema exibe o formulrio para cadastro de novo Estdio.
2. O usurio informa os dados do Estdio (Nome Usual do Estdio, Nome Oficial,
Capacidade, Cidade, Pas e a Foto) e solicita a gravao do cadastro.
Alternativas:
erro.
Selecionar um Estdio
Procedimentos:
1. O sistema exibe a lista de Estdios cadastrados.
2. O Usurio seleciona o Estdio desejado e escolhe a opo de manuteno
(Alterar Dados ou Excluir Estdio).
Alternativas:
40
1. No existem Estdios cadastrados. O sistema desabilita as funes de

manuteno de Estdio, no permitindo ao usurio Alterar Dados ou Excluir
Estdio.
Alterar dados de um Estdio

Procedimentos:
formulrio.
Alternativas:
1. Os dados do Estdio selecionado no existem ou esto corrompidos. O sistema
erro.
Excluir um Estdio
Procedimentos:
1. O sistema solicita a confirmao da excluso do Estdio.
2. Aps a confirmao do usurio o sistema exclui o Estdio do banco de dados.
Alternativas:
1. O usurio no confirma a inteno de excluso do Estdio. O sistema no
procede operao de excluso do Estdio.
2. O Estdio j est vinculado a uma Equipe, sendo referenciado por outros dados.
O sistema alerta o usurio da impossibilidade de excluso do Estdio.
3. O Estdio j est vinculado a um Jogo, sendo referenciado por outros dados. O
sistema alerta o usurio da impossibilidade de excluso do Estdio.
5.3.4 Administrao de Temporadas

Esta uma atividade das mais complexas no sistema e nesta tarefa onde se
efetivamente controlara os campeonatos de futebol gerando as respectivas estatsticas.
Por isso, precisa ser divida em outras tarefas menores.
41
Entre as atividades que compem a Administrao de Temporadas, a primeira

dela a Manuteno de Temporadas. nesta tarefa que as temporadas sero cadastradas
e parametrizadas. Toda Temporada estar relacionada a um Campeonato previamente
cadastrado.
Outro conceito a ser tratado na Administrao de Temporadas a Estrutura da
disputa da competio. nesta rea do sistema, denominada Manuteno da Estrutura
da Temporada, que o usurio ir configurar as Fases, Grupos e Rodadas que a
Temporada ir ter.
Ainda uma rea para incluir as Equipes participantes de uma temporada, haja
visto que um campeonato a cada Temporada possui diferentes Equipes na disputa.
Um requisito importante do sistema que gere estatsticas tanto das equipes
quanto dos jogadores. Desta forma, necessrio termos uma rea no sistema onde o
usurio entre com o cadastro dos jogadores de cada equipe. Por uma opo de projeto,
ao contrrio das estatsticas das equipes, onde se deseja obter informaes
independentes de temporadas, exigindo um cadastro nico, para os Jogadores, somente
ser necessrio obter as estatsticas dentro de uma determinada Temporada, como por
exemplo, nmero de cartes recebidos, gols feitos, partidas jogadas, etc. Assim, um
jogador ser cadastrado uma vez para cada temporada de campeonato que dispute.
Outra rea do sistema que tem requisitos anlogos ao dos Jogadores a de
Manuteno de rbitros. desejvel que fique registrado nas partidas de futebol
inseridos no sistema qual rbitro apitou e que estas informaes gerem estatsticas.
O Tribunal Desportivo de um Campeonato aplica diversas sanes aos clubes.
Destas sanes, um tipo especfico de sano implica na perda ou ganho de pontos na
tabela de classificao. Desta forma, o sistema deve ter uma rea onde estas decises do
tribunal sejam refletidas inseridas. A rea responsvel por esta tarefa denominada
Punies.
Por fim, a mais importante da Administrao de Temporadas a Administrao
dos Jogos. Esta tambm uma rea complexa do sistema que para ser mais bem
compreendida ser divida em reas menores ser adiante explicada. Na Figura 5.6
ilustra a anlise feita at o momento.
42
Figura 5.6. Pacote da rea do usurio com casos de usos definidos.

5.3.4.1 Manuteno de Temporadas

A Manuteno de Temporadas a rea onde o usurio efetuar o cadastro de
cada uma das edies de um Campeonato. Desta forma, exigido que para se cadastrar
uma temporada, j exista o respectivo Campeonato Cadastrado. Nesta rea, as trs
principais tarefas a serem realizadas so a Criao de novo Estdio, a Alterao dos
dados de um Estdio e a Excluso de um Estdio do sistema.
43
Figura 5.7. Diagrama de caso de uso para Manuteno de Temporadas.

Abaixo descrito cada um destes casos de uso em detalhes:
Criar uma nova Temporada

Procedimentos:
1. O sistema exibe o formulrio para cadastro de nova Temporada.
2. O usurio informa os dados da Temporada (nome da temporada, escolha do
campeonato a que se refere, descrio da frmula de disputa, pontos por vitria
no tempo normal, na prorrogao e nos pnaltis, pontos por empate no tempo
normal e na prorrogao, pontos por derrota na prorrogao e nos pnaltis,
critrio de desempate da tabela de classificao, nmero de equipes promovidas
para diviso superior, nmero de equipes classificadas para competio 1,
nmero de equipes classificadas para competio 2, nmero de equipes para
disputa do play-off de rebaixamento e nmero de equipes rebaixadas para
diviso inferior) e solicita a gravao do cadastro.
Alternativas:
erro.
44
Selecionar uma Temporada

Procedimentos:
1. O sistema exibe a lista das Temporadas cadastradas.
2. O Usurio seleciona a Temporada desejada e escolhe a opo de manuteno
(Alterar Dados ou Excluir Temporada).
Alternativas:
1. No existe temporada cadastrada. O sistema desabilita as funes de
manuteno de temporada, no permitindo ao usurio alterar dados ou excluir
temporada.
Alterar dados de uma Temporada

Procedimentos:
formulrio.
Alternativas:
1. Os dados da temporada selecionada no existem ou esto corrompidos. O
sistema exibe uma mensagem de alerta quanto ao problema encontrado.
erro.
Excluir uma Temporada

Procedimentos:
1. O sistema solicita a confirmao da excluso da Temporada.
2. Aps a confirmao do usurio o sistema exclui a Temporada do banco de
dados.
Alternativas:
1. O usurio no confirma a inteno de excluso da Temporada. O sistema no
procede operao de excluso da Temporada.
2. A Temporada j possui equipes includas na disputa, ou rbitros cadastrados, ou
Estrutura da Temporada, sendo referenciado por outros dados. O sistema alerta o
usurio da impossibilidade de excluso da Temporada.
45
Abrir Dados de uma Temporada

Procedimentos:
1. O sistema opera com uma temporada aberta. Limpa os dados da Temporada
anteriormente aberta. Ele seta seus valores para nova temporada aberta
apresentando suas informaes.
Alternativas:
1. No existe nenhuma temporada cadastrada. O sistema desabilita a possibilidade
de abrir uma temporada. Apresenta os dados em branco e no permite as demais
operaes da Administrao de Temporada.
5.3.4.2 Equipes Participantes

Nesta rea do sistema, o usurio dever determinar, entre as equipes j
cadastradas no sistema, quais disputaram a temporada do campeonato. O sistema s
permitir inserir jogos na temporada das equipes includas na disputa. As principais
tarefas a serem realizadas so a incluso de equipe na disputa da temporada e a excluso
da equipe da disputa da temporada.
Figura 5.8. Diagrama de caso de uso para Equipes Participantes.

Abaixo descrito cada um dos casos de uso em detalhes:
Selecionar uma Equipe Cadastrada

Procedimentos:
1. O sistema exibe a lista das equipes cadastradas que no esto disputando a
temporadas a qual est sendo includa.
2. O usurio seleciona a temporada desejada e escolhe a opo de incluso.
Alternativas:
46
1. No existe equipe cadastrada que no j no esteja includa no campeonato. O

sistema desabilita a operao de incluso de equipe na disputa da temporada.
Incluir Equipe na Disputa da Temporada

Procedimentos:
1. O usurio seleciona a equipe e solicita a incluso na disputa da temporada.
2. O sistema efetiva a incluso da equipe na disputa da temporada no sistema.
Selecionar uma Equipe que Disputa a Temporada

Procedimentos:
1. O sistema exibe a lista das equipes que esto disputando a temporada aberta.
2. O usurio seleciona a equipe desejada e escolhe a opo de excluir da disputa.
Alternativas:
1. No existe nenhuma equipe includa na disputa da temporada. O sistema
desabilita a operao de excluso da equipe na disputa da temporada
Excluir Equipe da Disputa da Temporada

Procedimentos:
1. O usurio seleciona a equipe e solicita a da excluso da disputa da Temporada.
3. Aps a confirmao do usurio o sistema exclui a Temporada do banco de
dados.
Alternativas:
1. A equipe j possui jogadores cadastrados, sendo referenciado por outros dados.
O sistema alerta o usurio da impossibilidade de excluso da equipe.
2. A equipe j possui jogos cadastrados, sendo referenciado por outros dados. O
sistema alerta o usurio da impossibilidade de excluso da equipe.
3. A equipe j possui punies no sistema, sendo referenciado por outros dados. O
sistema alerta o usurio da impossibilidade de excluso da equipe.
5.3.4.3 Manuteno de Jogadores

Nesta rea do sistema, o usurio dever determinar, entre as equipes includas na
disputa da temporada, os jogadores inscritos por elas para disputa da temporada. Nesta
47
rea, as trs principais tarefas a serem realizadas so a Criao de um novo Jogador, a

Alterao dos dados de um Jogador e a Excluso de um Jogador do sistema.
Figura 5.9. Diagrama de caso de uso para Manuteno de Jogadores.

Abaixo descrito cada um dos casos de uso em detalhes:
Selecionar uma Equipe que Disputa a Temporada

Procedimentos:
1. O sistema exibe a lista das equipes que esto disputando a temporada aberta.
2. O usurio seleciona a equipe desejada.
3. O sistema apresenta a lista dos jogadores j cadastrados da equipe para a
temporada aberta no sistema.
Alternativas:
1. No existe nenhuma equipe inclusa na disputa da temporada. O sistema
desabilita a operao de criar de novo jogador.
Criar um novo Jogador

Procedimentos:
1. O sistema exibe o formulrio para cadastro de novo jogador.
2. O usurio informa os dados do jogador (apelido, nome completo, nmero da
camisa, posio, nacionalidade, data de nascimento, e-mail e fotografia) e
solicita a gravao do cadastro.
Alternativas:
48

erro.
Selecionar um Jogador
Procedimentos:
1. O sistema exibe a lista dos jogadores que esto cadastrados para disputa da
temporada pela equipes selecionada.
2. O usurio seleciona o jogador desejado e escolhe a opo de manuteno (alterar
dados ou excluir um jogador).
Alternativas:
2. No existe nenhum jogador cadastrado para a equipe na disputa da temporada. O
sistema desabilita as operaes de alterao de dados ou excluso de jogador.
Alterar dados de um Jogador

Procedimentos:
1. O Sistema busca no banco de dados o cadastro e exibe em um formulrio.
Alternativas:
1. Os dados do jogador selecionado no existem ou esto corrompidos. O sistema
erro.
Excluir um Jogador
Procedimentos:
1. O sistema solicita a confirmao da excluso do jogador.
2. Aps a confirmao do usurio o sistema exclui o jogador do banco de dados.
Alternativas:
1. O usurio no confirma a inteno de excluso do jogador. O sistema no
procede operao de excluso do jogador.
3. O jogador j possui participao em um jogo, sendo referenciado por outros
dados. O sistema alerta o usurio da impossibilidade de excluso do jogador.
49
5.3.4.4 Manuteno de rbitros

A Manuteno de rbitros a rea onde o usurio efetuar o cadastro dos
rbitros da Temporada. Nesta rea, as trs principais tarefas a serem realizadas so a
Criao de novo rbitro, a Alterao dos dados de um rbitro e a Excluso de um
rbitro do sistema.
Figura 5.10. Diagrama de caso de uso para Manuteno de rbitros.

Criar um novo rbitro

Procedimentos:
1. O sistema exibe o formulrio para cadastro de novo rbitro.
2. O usurio informa os dados do rbitro (nome, data de nascimento e fotografia) e
solicita a gravao do cadastro.
Alternativas:
erro.
Selecionar um rbitro
Procedimentos:
50
1. O sistema exibe a lista dos rbitros cadastrados para a temporada aberta.

2. O usurio seleciona o rbitro desejado e escolhe a opo de manuteno (alterar
dados ou excluir rbitro).
Alternativas:
1. No existem rbitros cadastrados na temporada aberta. O sistema desabilita as
funes de manuteno de rbitro, no permitindo ao usurio alterar dados ou
excluir cadastro.
Alterar dados de um rbitro

Procedimentos:
formulrio.
2. O usurio altera os dados desejados e solicita a gravao das alteraes.
Alternativas:
1. Os dados do rbitro selecionado no existem ou esto corrompidos. O sistema
erro.
Excluir um rbitro
Procedimentos:
1. O sistema solicita a confirmao da excluso do rbitro.
2. Aps a confirmao do usurio o sistema exclui o rbitro do banco de dados.
Alternativas:
1. O usurio no confirma a inteno de excluso do rbitro. O sistema no
procede operao de excluso do rbitro.
2. O rbitro j est vinculado a um jogo, sendo referenciado por outros dados. O
sistema alerta o usurio da impossibilidade de excluso do arbitro.
5.3.4.5 Manuteno da Estrutura do Campeonato

Esta uma rea do sistema de grande complexidade a ser administrada. Em
virtude da grande variedade de frmulas de disputas j criadas e as que ainda podero
51
ser criadas. A idia de que um bom software de controle de campeonatos tenha a

capacidade de gerenciar toda e qualquer frmula de disputa de campeonato.
No estudo das frmulas de disputadas de diversos campeonatos realizado nos
mais diversos paises e tempos, ficou observado que, em geral, as frmulas de disputa
seguem a seguinte estrutura, semelhante de uma rvore:
Uma Temporada de um Campeonato de futebol dividida em Fases: alguns
campeonatos possuem apenas uma fase campeonatos nacionais disputados nos paises
da Europa - enquanto outros possuem diversas fases Copa do Mundo.
Uma Fase divide as equipes em grupos: verdade que nos campeonatos
nacionais disputados na Europa no existe diviso de equipes em grupos, mas mesmo
assim, podemos dizer que as equipes so dividas em um nico Grupo. J em
Campeonatos como a Copa do Mundo, a diviso das equipes em grupos sempre ocorre.
Dentro de uma Fase e um Grupo, ocorrem vrias Rodadas: Em uma rodada,
todas as equipes jogam dentro de seu grupo entre si.
Assim, o software deve gerenciar as frmulas de disputa e esta rotina ser uma
das diferenas do programa deste trabalho em relao aos demais software existentes no
mercado para esta mesma finalidade.
52
Figura 5.11. Diagrama de caso de uso para Manuteno da Estrutura Temporada.

Criar uma nova Fase

Procedimentos:
1. O sistema exibe o formulrio para cadastro de nova fase.
2. O usurio informa o nome da fase e solicita a gravao do cadastro.
3. O sistema verifica se o nome foi preenchido. Caso esteja, o cadastro efetivado
no sistema.
Alternativas:
1. O nome da fase no foi preenchido. O sistema informa ao usurio e solicita ao
usurio que corrija o erro.
53
Selecionar uma Fase

Procedimentos:
1. O sistema exibe a lista das fases cadastradas para a temporada aberta.
2. O usurio seleciona a fase desejada e escolhe a opo de manuteno (alterar
dados ou excluir fase).
3. Quando o usurio seleciona a fase, realiza o procedimento de abertura da fase,
mostrando todos os grupos cadastrados nesta fase.
Alternativas:
1. No existem fases cadastradas na temporada aberta. O sistema desabilita as
funes de manuteno de fase, no permitindo ao usurio alterar dados ou
excluir cadastro de uma fase ou criar uma nova rodada.
Alterar dados de uma Fase

Procedimentos:
formulrio.
Alternativas:
1. Os dados da fase selecionada no existem ou esto corrompidos. O sistema
2. Todos os dados obrigatrios no foram preenchidos. O sistema informa ao
usurio quais os campos que no foram preenchidos e solicita ao usurio que
corrija o erro.
Excluir uma Fase

Procedimentos:
1. Aps a solicitao do usurio o sistema exclui a fase do banco de dados.
Alternativas:
1. A fase j est possui grupos cadastrados, sendo referenciado por outros dados. O
sistema alerta o usurio da impossibilidade de excluso da fase.
Criar um novo Grupo

Procedimentos:
54
1. O sistema exibe o formulrio para cadastro de novo grupo.

2. O usurio informa o nome do grupo e solicita a gravao do cadastro.
2. O sistema verifica se o nome foi preenchido. Caso esteja, o cadastro efetivado
no sistema.
Alternativas:
1. O nome do grupo no foi preenchido. O sistema informa ao usurio e solicita ao
usurio que corrija o erro.
Selecionar um Grupo
Procedimentos:
1. O sistema exibe a lista dos grupos cadastrados para a fase aberta.
2. O usurio seleciona o grupo desejado e escolhe a opo de manuteno (alterar
dados ou excluir grupo).
3. Quando o usurio seleciona a grupo, realiza o procedimento de abertura do
grupo, mostrando todas as rodadas cadastradas neste grupo.
Alternativas:
1. No existem grupos cadastrados na fase aberta. O sistema desabilita as funes
de manuteno de grupo, no permitindo ao usurio alterar dados, excluir grupo
e criar rodadas.
Alterar dados de um Grupo

Procedimentos:
formulrio.
Alternativas:
1. Os dados do grupo selecionado no existem ou esto corrompidos. O sistema
corrija o erro.
Excluir um Grupo
Procedimentos:
55
1. Aps a solicitao do usurio o sistema exclui o grupo do banco de dados.

Alternativas:
1. O grupo j est possui rodadas cadastradas, sendo referenciado por outros dados.
O sistema alerta o usurio da impossibilidade de excluso do grupo.
Adicionar uma nova Rodada

Procedimentos:
1. O usurio informa o solicita a criao de uma nova rodada.
2. O sistema cria uma nova rodada com numero seguinte a ltima rodada
cadastrada no grupo selecionado.
Diminuir uma Rodada

Procedimentos:
1. O usurio solicita a diminuio de uma rodada.
2. O sistema exclui a ultima rodada do grupo aberto do banco de dados.
Alternativas:
1. A rodada j est possui jogos cadastrados, sendo referenciado por outros dados.
O sistema alerta o usurio da impossibilidade de excluso da rodada.
5.3.4.6 Punies
Esta uma rea do sistema responsvel por aplicar no sistema as decises dos
tribunais desportivos com perda de pontos para um time e ganho de pontos por outros.
Est rea possui trs importantes procedimentos: criar uma nova punio, alterar dados
de uma punio e excluir uma punio. A incluso de uma punio no sistema deve
refletir automaticamente na tabela de classificao do campeonato.
56
Figura 5.12. Diagrama de caso de uso para Punies.

Criar uma nova Punio

Procedimentos:
1. O sistema exibe o formulrio para cadastro de uma nova punio.
2. O usurio informa os dados da punio (estrutura da temporada que ocorreu a
punio, a equipe, a data da punio, o nmero de pontos diminudos ou ganhos
e o motivo da punio) e solicita a gravao do cadastro.
Alternativas:
erro.
Selecionar uma Punio

Procedimentos:
1. O sistema exibe a lista das punies cadastradas na temporada aberta.
2. O usurio seleciona a punio e escolhe a opo de manuteno (alterar dados
ou excluir uma punio).
Alternativas:
57
1. No existem punies cadastradas na temporada aberta. O sistema desabilita os

procedimentos de manuteno de punies, no permitindo ao usurio alterar
dados ou excluir punies.
Alterar dados de uma Punio

Procedimentos:
formulrio.
Alternativas:
1. Os dados do rbitro selecionado no existem ou esto corrompidos. O sistema
erro.
Excluir uma Punio

Procedimentos:
1. O usurio solicita a da excluso de uma punio
2. O sistema exclui a punio do banco de dados.
5.3.4.7 Administrao de Jogos

Mais uma vez, dado a grande complexidade da tarefa e sua fundamental
importncia para o sistema, faz-se necessrio dividir esta rea do sistema em pequenos
procedimentos. A rea de Administrao de Jogos deve compreender as atividades de
Manuteno da Tabela de Jogos, onde todos os confrontos so cadastrados no sistema
sejam eles j realizados, com o placar do jogo j definido ou ainda por realizar. O
sistema inda deve contemplar uma rea para incluso das escalaes das equipes de um
jogo e por fim a incluso dos principais eventos do jogo, como por exemplo, quais
jogadores anotaram os gols do confronto, receberam cartes, etc. Estas duas reas do
sistema so intituladas Manuteno de Escalao e Manuteno de Eventos
respectivamente.
58
A figura 5.13 representa os estudos de casos de usos realizados na rea de

Administrao de Temporadas.
Figura 5.13. Diagrama de caso de uso para Administrao de Temporadas.

A ltima rea do sistema, de Administrao de Jogos, demonstrada na figura
5.14, descrita em detalhes em detalhes abaixo.
59
Figura 5.14. Diagrama de caso de uso para Administrao de Jogos.
5.3.4.7.1 Manuteno da Tabela de Jogos

A Manuteno de Tabela de Jogos a onde o usurio efetuar o
acompanhamento da do calendrio de jogos do campeonato, includo seus jogos e todas
as principais informaes da smula da partida. A figura 5.15 ilustra os casos de uso
desta atividade e cada um deles descrito em abaixo.
Figura 5.15. Diagrama de caso de uso para Manuteno da Tabela de Jogos.
Selecionar uma Estrutura da Temporada (Rodada)

Procedimentos:
1. O sistema exibe a lista das fases da temporada aberta.
2. O usurio seleciona a fase desejada.
60
3. O sistema exibe a lista dos grupos da fase selecionada pelo usurio.

4. O usurio seleciona o grupo desejado.
5. O sistema exibe a lista das rodadas do grupo selecionado pelo usurio.
6. O usurio seleciona a rodada.
7. O sistema exibe a tabela de jogos da rodada selecionada pelo usurio e ele
escolhe a opo de Criar um novo Jogo ou selecionar um Jogo.
Alternativas:
1. No existem fases cadastradas na temporada aberta, ou grupos cadastrados na
fase selecionada, ou rodadas cadastradas no grupo selecionado. Em qualquer
destes casos, o sistema impossibilita a incluso de um novo jogo.
Criar um novo Jogo

Procedimentos:
1. O sistema exibe o formulrio para cadastro de um novo jogo.
2. O usurio informa os dados do jogo (Equipe Anfitri, Equipe Visitante,
Resultado do Jogo, Data e Hora, Estdio, rbitro, TV, Estatsticas, Comentrio
do Jogo, e Fotos) e solicita a gravao do cadastro.
Alternativas:
erro.
Selecionar um Jogo
Procedimentos:
1. O sistema exibe a lista dos jogos cadastradas na rodada aberta.
2. O usurio seleciona o jogo e escolhe a opo de manuteno (alterar dados de
um jogo, excluir um jogo, definir a escalao das equipes de um jogo, definir os
eventos de um jogo).
Alternativas:
1. No existem jogos cadastrados na rodada selecionada. O sistema desabilita os
procedimentos de manuteno de manuteno de jogo.
61
Alterar dados de um Jogo

Procedimentos:
formulrio.
Alternativas:
1. Os dados do jogo selecionado no existem ou esto corrompidos. O sistema
corrija o erro.
Excluir um Jogo
Procedimentos:
1. O usurio solicita a excluso do jogo selecionado.
2. O sistema exclui o jogo do banco de dados.
Alternativas:
1. O jogo possui escalao definida e ou eventos, sendo referenciados por estes
dados. O sistema alerta o usurio, e pede a confirmao da inteno de excluir o
jogo.
2. O usurio confirma a inteno de excluir o jogo.
3. O sistema excluir o jogo, a escalao do jogo e todos os eventos do jogo, do
banco de dados.
4. Caso o usurio no confirme a inteno de excluir a partida, o sistema no
procede a excluso dos dados.
5.3.4.7.2 Manuteno da Escalao do Jogo

Est a rea onde o usurio poder definir a escalao das equipes em um
confronto. A consistncia destas informaes importante para gerao dos relatrios
estatsticos dos jogadores na temporada. Est rea, alm de requerer a incluso de onze
jogadores titulares de cada equipe, ainda solicita ao usurio as trs possveis
substituies efetuadas pela equipe no decorrer da partida. A figura 5.16 ilustra as
interaes do usurio com o sistema pra a definio da escalao.
62
Figura 5.16. Diagrama de caso de uso para Manuteno da Escalao do Jogo.

Observa-se na figura 5.16, que os casos de uso se repetem com o mesmo nome,
mudando apenas o fato de a operao ser feita no time da casa ou no time visitante. Na
seqncia do trabalho sero descritos apenas os casos de uso do time da casa, haja visto
que os casos de uso so iguais, re-salvando a substituio do time da casa pelo visitante
para o entendimento dos casos de usos no descritos.
Tambm h de se observar que no ser obrigatria a incluso, no sistema, da
escalao das equipes. Apenas as estatsticas referentes aos jogadores que no sero
obtidas, sendo garantida a exibio daquelas estatsticas que no sofrem influncia da
escalao das equipes.
Selecionar Jogador do Time da Casa

Procedimentos:
1. O sistema exibe a lista dos jogadores cadastrados na temporada do time da casa
do jogo selecionado.
63
2. O usurio seleciona o jogador desejado e escolhe a opo de escalar jogador

como titular.
Alternativas:
1. No existem jogadores cadastrados do time da casa na temporada. O sistema
impossibilita a incluso de um jogador como titular e substituio de jogador.
Incluir Jogador Titular no Time da Casa

Procedimentos:
1. O usurio solicita a incluso do jogador selecionado na escalao como titular
do time da casa no jogo.
2. A incluso efetivada pelo sistema.
Alternativas:
1. J foram inclusos todos os onze jogadores titulares do time da casa no jogo. O
sistema no procede a incluso do jogador, informando o usurio do erro.
Selecionar Jogador Escalado do Time da Casa

Procedimentos:
1. O sistema exibe a lista dos jogadores do time da casa escalados no jogo
selecionado.
2. O usurio seleciona o jogador desejado e escolhe a opo de excluir a escalao
do jogador.
Alternativas:
1. No existem jogadores escalados no time da casa. O sistema impossibilita as
aes de excluir escalao de jogador do time da casa e substituir jogador.
Excluir Escalao de Jogador do Time da Casa

Procedimentos:
1. O usurio solicita a excluso da escalao do jogador selecionado.
2. A excluso efetivada pelo sistema.
Alternativas:
1. O jogador selecionado j foi substitudo por outro jogador. O sistema
impossibilita sua excluso da escalao, informando ao usurio da necessidade
de desfazer primeiro a substituio para depois efetuar a excluso da escalao.
64
Substituir Jogador do Time da Casa

Procedimentos:
1. O usurio seleciona um jogador no escalado e um jogador escalado do time da
casa no jogo selecionado, informa o tempo de jogo em que ocorreu a
substituio e solicita que o sistema proceda a substituio.
2. A substituio efetivada pelo sistema.
Exibir Substituies Realizadas pelo Time da Casa

Procedimentos:
1. O Sistema exibe at trs substituies efetuadas no time da casa.
2. O usurio solicita desfazer uma das substituies efetuadas.
Alternativas:
1. No foram efetuadas substituies. O sistema impossibilita a operao de o
usurio desfazer substituio.
Desfazer Substituio do Time da Casa

Procedimentos:
1. O usurio solicita a excluso de uma substituio do time da Casa
2. O sistema exclui a substituio.
5.3.4.7.3 Manuteno de Eventos do Jogo

Nesta rea do sistema, o usurio informar os eventos ocorridos na partida,
como por exemplo, o jogador que anotou um gol e em que minuto ocorreu ou o jogador
que recebeu um carto. As trs principais atividades desta tarefa so criar um novo
evento e excluir um evento. O diagrama de caso de uso apresentado na figura 5.17.
65
Figura 5.17. Diagrama de caso de uso para Manuteno de Eventos do Jogo.

Tambm se observa na figura 5.17, casos de uso que se repetem com o mesmo
nome, mudando apenas o fato de a operao ser feita no time da casa ou no time
visitante. Na descrio dos casos de uso, apenas os casos de uso do time da casa sero
descritos. Para compreenso dos casos de uso do Time Visitante, basta a substituio do
termo time da casa pelo termo time visitante para o entendimento dos casos de usos no
descritos.
Tambm h de se observar que no ser obrigatria a incluso, no sistema, dos
eventos da partida. Apenas as estatsticas referentes aos eventos que no sero obtidas
neste caso, sendo garantida a exibio das outras estatsticas.
Definir Eventos
Procedimentos:
1. O sistema exibe o formulrio para definio de eventos para o time da casa e
para o time visitante.
2. O usurio efetua a ao de incluir um evento ou excluir um evento no jogo
selecionado.
Procedimentos:
1. O jogo no foi realizado. O sistema impossibilita a incluso de qualquer evento.
Selecionar Jogador do Time da Casa

Procedimentos:
1. O sistema exibe a lista dos jogadores cadastrados na temporada do time da casa
do jogo selecionado.
2. O usurio seleciona o jogador desejado e escolhe a faz a incluso de um evento.
66
Alternativas:
1. No existem jogadores cadastrados do time da casa na temporada. O sistema
impossibilita a incluso de um evento.
2. O sistema apresenta a lista de todos os jogadores cadastrados pelo time ou
apenas dos escalados no jogo.
Criar um novo Evento do Time da Casa

Procedimentos:
1. O usurio seleciona um jogador do time que esta incluindo o evento, informa o
tipo de evento (gol, gol de pnalti, gol contra, carto amarelo, carto amarelo e
vermelho e carto vermelho) e o tempo de jogo, e solicita a gravao.
Alternativas:
1. Todos os eventos de gol j foram inseridos, e o usurio solicita a incluso de
outro gol. O sistema informa o usurio do erro e no inclui o evento.
Selecionar Evento do Jogo

Procedimentos:
1. O sistema exibe a lista dos eventos cadastrados no jogo selecionado.
2. O usurio seleciona o evento desejado a opo de excluir evento.
Alternativas:
1. No existem eventos cadastrados. O sistema impossibilita a excluso de um
evento.
Excluir um evento
Procedimentos:
1. O usurio seleciona um evento e solicita a excluso do evento
2. O sistema exclui o evento da base de dados.
Assim, com a concluso das descries dos casos de uso, o pacote da rea de
administrao de jogos ilustrado na figura 5.18.
67
Figura 5.18. Diagrama de caso de uso para Administrao de Jogos.
5.4 O Modelo Conceitual

O Modelo Conceitual uma representao de conceitos em um domnio de
problema. Ele deve ser uma representao de coisas do mundo real e no de
componentes de software. Sua criao feita a partir dos casos de uso e de outros
documentos da anlise, de onde so identificados conceitos (objetos).
O Modelo Conceitual apresenta conceitos, associaes entre conceitos e
atributos de conceitos. Por no ser um modelo de projeto de software, os mtodos no
so descritos nele.
68
O objetivo do Modelo Conceitual capturar as abstraes essenciais e as

informaes requeridas para compreender o domnio, no contexto dos requisitos
presentes.
A figura 5.19 ilustra o Modelo Conceitual para o sistema de gerenciamento de
campeonatos de futebol, construdo a partir do estudo dos casos de uso anteriormente
abortado, identificando os principais conceitos envolvidos e as associaes. Tambm
neste modelo, so apresentados os atributos que foram claramente identificados como
necessrios para a correta implementao dos casos de uso. Este modelo
especialmente preparado para auxiliar no desenvolvimento dos diagramas de seqncias
que, eventualmente pode sugerir mudanas ou outros conceitos ainda no identificados
que se refletiro no Diagrama de Classes que ser apresentado no prximo tpico deste
captulo.
69
Figura 5.19. Modelo Conceitual.
5.5 Diagramas de Classes de Projeto

Um diagrama de classes de projeto ilustra as especificaes para as classes de
software e de interfaces de uma aplicao. [LAR 00]. A diferena entre o modelo
conceitual e o diagrama de classes, que o primeiro uma abstrao de um conceito do
mundo real a qual se est interessado em fazer afirmaes e estabelecer definies e o
segundo expressa a definio de classes como componentes de software.
70
Aps ter sido completado a construo dos diagramas de interao, que podem
ser visualizados no Anexo 1 deste trabalho, possvel identificar as classes de software,
seus atributos e mtodos. Porm, antes de apresentar o diagrama de classes, necessrio
fazer algumas consideraes para que o diagrama seja facilmente compreendido.
Primeiramente necessrio explicar que o diagrama de classes foi dividido em
duas figuras. Na verdade, as duas figuras representam um nico diagrama de classes.
Esta adaptao foi necessria para que para que pudesse ter uma melhor legibilidade do
diagrama. As figuras foram centradas em dois enfoques. Na primeira, a relao de todas
as classes com a classe Temporada. Na segunda figura, a relao de todas as classes
com a classe Jogo. Desta forma, as classes que possuem relao com ambas, so
apresentadas nas duas figuras de forma repetida, mas no diagrama original, representam
a implementao de uma nica classe no sistema.
Tambm cabe ressaltar que os parmetros dos mtodos e o retorno no so
apresentados nas duas tambm para dar melhor legibilidade ao diagrama. Por fim, os
mtodos de acesso as variveis protegidas das classes, mtodos de construo e
destruio das classes, atributos de acesso ao banco de dados e classes de interfaces
tambm no esto presentes nos diagrama de classes apresentados neste trabalho.
Abaixo apresentado, nas figuras 5.20 e 5.21, o diagrama de classes do projeto.
71
Figura 5.20. Diagrama de Classes do Projeto - A.
72
Figura 5.21. Diagrama de Classes do Projeto - B.
Concluso
Este captulo mostrou o resultado do trabalho das fases de projeto e anlise do
sistema. Cabe destacar que o resultado apresentado nos diagramas no foi
imediatamente obtido aps uma nica fase de anlise. Na verdade, este foi o resultado
73
final aps vrios ciclos de desenvolvimento do sistema, onde, em cada ciclo,

compreendia a fase de anlise e projeto e implementao alm de uma pequena
transio entre eles. Em cada ciclo, uma quantidade maior de informaes surgia e
novas descobertas eram feitas, alm de algumas mudanas, inevitavelmente haviam de
ser realizadas naquilo que j estava pronto.
O prximo captulo do trabalho apresenta ficou o sistema aps a sua
implementao.
74
Captulo 6
Consideraes do Projeto e Implementao
do Programa
Introduo
Este captulo do trabalho tem por objetivo apresentar como ficou o software
aps o seu desenvolvimento. Sero ilustradas as interfaces e explicadas como procedem
as rotinas e a importncia de cada uma delas para o sistema.
6.1 A Abertura do Sistema

O sistema de controle de campeonato, j em sua tela inicial de abertura,
apresenta os dados do ltimo campeonato aberto no sistema. Sua tela j apresenta as
principais informaes do campeonato, ou seja, a tabela de jogos e a classificao
resumida. A partir da tela inicial, mostrada pela figura 6.1, o usurio poder ter acesso
as demais funcionalidades do sistema.
Figura 6.1. Sistema: Tela inicial.

A figura 6.1 mostra que o campeonato as informaes do Campeonato Brasileiro
Srie A, Temporada 2005 que est aberto Para abrir os dados de um outro campeonato
75
basta que o usurio selecione, na parte superior da figura, o campeonato desejado na

lista dos campeonatos cadastrados e clique no boto abrir. Na mesma figura, podemos
observar no lado direito, a estrutura da temporada, ou seja, as fases, grupos e rodadas
cadastradas para a temporada aberta. No centro da tela, est a tabela de jogos com os
botes de manuteno e ao lado esquerdo, a tabela de classificao resumida da
estrutura da temporada selecionada.
Na mesma Figura podemos observar os menus superiores, onde so realizados
os principais cadastros de gerenciamento do sistema, que so mostradas na seqncia do
trabalho.
6.2 Os Cadastros
O menu cadastro disponibiliza ao usurio as seguintes funes: Cadastro de
Campeonato, Temporada, Equipes e Estdio.
6.2.1 Cadastro de Campeonato

A figura 6.2 apresenta o formulrio de cadastro de campeonatos, que a interface
pelo qual o usurio efetua os cadastros dos campeonatos que deseja controlar no
sistema. Conforme explicado nos captulos anteriores, os campeonatos so cadastrados
uma nica vez no sistema e para fazer o controle de um campeonato ainda necessrio
que o usurio cadastre a temporada do campeonato que deseja controlar. Uma vez feito
o cadastro do campeonato, podem ser controladas quantas temporadas forem desejadas
e, desta forma, o sistema fica apto a fazer relaes e apresentar estatsticas de um
campeonato ao longo da disputa de diferentes temporadas.
76
Figura 6.2. Sistema: Cadastro de Campeonatos.

A figura 6.2 apresenta em seu lado esquerdo a lista dos campeonatos cadastrados
no sistema e os botes que permitem as trs operaes de manuteno: incluir um novo
campeonato, alterar dados de um campeonato e excluir um campeonato. J no lado
esquerdo, a figura apresenta um cadastro sendo editado. O sistema permite ao usurio
gravar as alteraes ou cancelar alm de fechar a tela.
6.2.2 Cadastro de Temporada

Para efetuar o cadastro de uma temporada, necessrio que o campeonato j
esteja cadastrado. A figura 6.3 apresenta como foi desenvolvido o formulrio de
cadastro de temporadas. aps o cadastro da temporada efetuar os cadastros de todos
os dados relativos a disputa dela.
77
Figura 6.3. Sistema: Cadastro de Temporadas.

A figura 6.3 apresenta em seu lado esquerdo a lista das temporadas cadastradas e
abaixo da lista, os botes de manuteno. No lado esquerdo da mesma interface, est o
formulrio propriamente dito. Na figura esto sendo editados os dados da Temporada
2005 do Campeonato Brasileiro Srie B. O usurio deve responder aos parmetros
para que o sistema controle corretamente as informaes da temporada.
6.2.3 Cadastro de Equipe

A figura 6.4 mostra a interface do sistema onde o usurio pode efetuar o cadastro
das equipes. Assim como os campeonatos, as equipes so cadastradas uma nica vez no
sistema. Isso permite ao sistema gerar dados estatsticos referentes a diferentes
competies que participou, desde que tenham sido inseridas no sistema.
78
Figura 6.4. Sistema: Cadastro de Equipes.

No lado esquerdo da figura 6.4 est a lista das equipes j cadastradas no sistema
e logo abaixo da lista esto os botes de manuteno de cadastro. No lado direito est o
formulrio do cadastro de equipe. Na figura, est em edio o cadastro do Grmio. Um
dos itens do formulrio do cadastro de equipes referente ao estdio, de preenchimento
opcional. Para o preenchimento deste campo, necessrio o cadastro do estdio em
outro formulrio do sistema, que ser visto no item seguinte deste captulo.
6.2.4 Cadastro de Estdios

O ltimo dos menus de cadastros do sistema o de cadastro de estdios. O
cadastro de estdios s se faz necessrio para os usurios que desejarem obter
informaes do local de realizao das partidas e, eventualmente, de alguns relatrios
estatsticos gerados pelo sistema. Para os usurios que no tiverem interesse neste tipo
de informao, no necessrio este cadastro, pois em momento algum o sistema
exigira do usurio esta informao.
79
Figura 6.5. Sistema: Cadastro de Estdios.

A figura 6.5 apresenta como foi desenvolvido no sistema a interface para
cadastro de estdios: ao lado esquerdo da figura esto listados os estdios cadastrados e
abaixo da lista os botes de manuteno de cadastro. No lado direito da figura, o
formulrio de cadastro de estdio, que est em edio o registro do Estdio Orlando
Scarpelli.
6.3 A Administrao de Temporada

O menu superior Temporada da interface do sistema apresenta as principais
funes de administrao de temporada. Acessando este menu, o usurio poder
selecionar as seguintes operaes: Cadastrado da Estrutura da Temporada (Fases,
Grupos e Rodadas), Cadastro de rbitros, Incluir uma equipe na disputa da temporada,
incluir os jogadores inscritos pelas equipes para disputa da competio e, finalmente,
registrar as punies do tribunal desportivo. Todas as operaes realizadas neste menu
sero concretizadas na temporada atualmente aberta no sistema.
A administrao da tabela de jogos feita diretamente na tela principal do
sistema que ser detalhadamente explicada na seqncia do trabalho.
80
6.3.1 Cadastro da Estrutura da Temporada

nesta interface do sistema que so definidas as fases, os grupos e as rodadas
que compem a temporada aberta.
Figura 6.6. Sistema: Cadastro da Estrutura da Temporada.

A figura 6.5 mostra que em apenas uma interface o usurio pode efetuar o
cadastro de fases, grupos e rodadas. O sistema apresenta uma espcie de hierarquia para
o cadastro da estrutura da temporada. Primeiro necessrio efetuar o cadastro das fases,
mostrado na parte esquerda da figura. Aps o cadastro da fase, o usurio a seleciona, e
na parte central da figura, ele efetua o cadastro dos grupos que compem a fase
selecionada. Por fim, no lado direito da figura, o usurio acrescenta as rodadas do grupo
selecionado.
6.3.2 Cadastro de rbitro

Nesta rea do sistema so efetuados os cadastros dos rbitros credenciados pelos
organizadores do campeonato para dirigirem as partidas. Os rbitros devem ser
cadastrados para cada temporada do sistema, e s necessrio para os usurios que
desejam registrar esta informao para os jogos do campeonato e observar os relatrios
81
estatsticos gerados pelo sistema referente s arbitragens. Para os usurios que no tem
interesse nesta informao, o cadastro de rbitro dispensvel.
Figura 6.7. Sistema: Cadastro de rbitros.

A figura 6.7 mostra a interface para cadastro de rbitros. Em seu lado esquerdo,
a interface apresenta a lista dos rbitros cadastrados na temporada aberta e os botes
para manuteno de cadastro. No lado direito da interface est o formulrio de cadastro.
6.3.3 Incluir Equipe na Disputa da Temporada

uma funo fundamental para o controle da temporada. Nesta rotina, o usurio
define quais equipes, que j foram previamente cadastradas no sistema, disputam a
temporada. Este procedimento feito, geralmente, uma nica vez, logo aps o cadastro
da temporada. Seu funcionamento muito simples. A figura 6.8 ilustra a interface.
82
Figura 6.8. Sistema: Equipes que disputam a Temporada.

Na figura 6.8, a interface apresenta duas listas: a primeira, do lado esquerdo da
imagem, a lista de todas as equipes cadastradas no sistema e a segunda, do lado direito
da imagem, a lista das equipes que foram selecionadas para a disputada da temporada.
No centro, existem dois botes pelo qual o usurio efetua a incluso ou excluso da
equipe da disputa. Ainda existe um atalho para o cadastro de equipes para facilitar a
interao do usurio.
6.3.4 Cadastro de Jogador

Nesta rea do sistema efetuado o cadastro dos jogadores inscritos pelas equipes
para a disputa da temporada que esto participando. Essa operao tambm opcional.
Somente necessrio para os usurios que desejam incluir a escalao das equipes nos
jogos que participam ou incluir os lances d jogo. A partir destas duas informaes
inseridas pelo usurio, o sistema possui a capacidade de gerar estatsticas sobre a
participao dos jogadores na competio.
83
Figura 6.9. Sistema: Cadastro de Jogadores.

A figura 6.9 apresenta a interface apresenta a interface do sistema para o
cadastro de jogadores. No lado esquerdo superior da imagem, o primeiro campo a
seleo da equipe que participa da temporada. No exemplo, a equipe selecionada o
Gois. Aps a seleo da equipe, o sistema apresenta abaixo a lista dos jogadores
cadastrados e os botes de manuteno do cadastro: incluir um novo jogador, alterar
dados de um jogador ou excluir um jogador. J no lado esquerdo da figura apresentado
o formulrio que o usurio deve responder para o efetivo cadastro de um jogador.
6.3.5 Punies do Tribunal

Esta uma rotina usada eventualmente pelo usurio, mas por influenciar
diretamente na tabela de classificaes, fundamental a sua existncia. O objetivo
registrar no sistema as decises do tribunal desportivo da competio que retiram ou
atribuem pontos a determinadas equipes em virtude de comportamentos irregulares no
decorrer da competio.
84
Figura 6.10. Sistema: Punies do Tribunal.

Na figura 6.10 apresentado como o sistema possibilita o registro destas
punies. Na parte superior so listadas as punies j inseridas no sistema, assim como
os botes de manuteno de punio. Ao incluir um novo registro, o usurio deve
responder ao formulrio na parte inferior da imagem. Deve primeiro selecionar a fase e
o grupo que a punio ir refletir na classificao. Logo aps, deve selecionar a equipe
que sofreu a punio, a data da deciso do tribunal, os pontos que ganhou ou perdeu e o
motivo.
6.4 Administrao da Tabela de Jogos

nesta atividade que o usurio gastar a maior parte do tempo para o controle
de campeonatos de futebol. Para administrao da Tabela de Jogos, so necessrios que
os procedimentos de cadastros j estejam efetuados, principalmente os cadastros de
campeonato, temporada, equipes e incluso das equipes na disputa da temporada. Os
demais cadastros podem ser efetuados a medida que o controle da temporada for sendo
85
realizado. A figura 6.11 mostra a tabela de jogos do Campeonato Brasileiro Srie A

2005. Nesta figura, esto selecionados a fase e grupo nico. Os jogos apresentados so
da 7 rodada. Na rea central, a lista dos jogos. Parte dos jogos listados j possui
resultado, ou seja, j foram realizados, enquanto a outra parte s foram agendados, mas
inda no foram realizados e seus resultados ainda no existem. Abaixo da lista de jogos
existem cinco botes de manuteno da tabela de jogos: incluir um novo jogo, alterar
dados de um jogo, excluir um jogo, definir escalao das equipes e definir lances da
partida. Cada uma destas operaes descrita na seqncia deste trabalho.
Figura 6.11. Sistema: Administrao da Tabela de Jogos.
6.4.1 Manuteno de Jogos

A rotina de incluso de jogos permite ao usurio inserir as mais diversas
informaes a respeito do jogo. Ao mesmo tempo, para os usurios que esto
interessando em um controle do campeonato, porm, sem gastar muito tempo
preenchendo as informaes e obtendo a classificao atualizada, o sistema tambm tem
uma boa soluo, pois no obriga o preenchimento da grande parte das informaes.
A rotina de alterao de jogos semelhante a rotina de incluso. Todos os dados
so do jogo so apresentados ao usurio que pode editar e salvar as alteraes. Os
nicos dados que o sistema no permite alterao, so os dados da parte superior da
figura 6.12. Caso o usurio tenha inteno de modificar uma destas informaes, ele
dever excluir o jogo e cadastrar um novo confronto.
86
J a rotina de excluso de um jogo excluir o confronto do sistema, assim como

suas informaes relacionadas: escalao e eventos, que sero detalhadas ainda neste
captulo.
Ao acessar a rotina de incluso de um novo jogo, o sistema apresentar a
interface representada pela figura 6.12.
Figura 6.12. Sistema: Cadastro de um novo jogo.

A parte superior da figura 6.12 onde o usurio informa o confronto: o time
anfitrio que joga em seu estdio e a equipe visitante. Quando o jogo j foi
realizado, o usurio ao efetuar o cadastro do confronto, j pode inserir o resultado da
partida. O sistema permite incluir o resultado do jogo no tempo normal e,
opcionalmente, prorrogao e pnaltis.
Na parte inferior da interface, o sistema possui quatro orelhas: geral, estatsticas,
comentrios e fotos. Na orelha geral, a selecionada na figura 6.12, o nico campo de
preenchimento obrigatrio: a data e hora do jogo e mesmo assim, o sistema apresenta
automaticamente a data e hora do ltimo jogo inserido para facilitar o servio do
usurio. Opcionalmente o usurio pode informar o estdio onde o jogo foi realizado, o
rbitro do jogo, o pblico e a emissora de tv que transmitir o jogo. A interface oferece
ao usurio atalhos para o cadastro de um novo estdio e rbitro.
87
Figura 6.13. Sistema: Cadastro de Jogo Estatsticas.

A orelha seguinte, de estatsticas, apresentada na figura 6.13. Nesta parte da
interface o usurio pode inserir os nmeros do jogo. A incluso destes nmeros
possibilita ao sistema gerar relatrios a respeito destas informaes.
Figura 6.14. Sistema: Cadastro de Jogo - Comentrios.

A figura 6.14 mostra a terceira orelha da interface de cadastro de jogos. Nela o
usurio pode inserir uma notcia, um comentrio ou at mesmo, a narrao dos eventos
do jogo. O objetivo de apenas registrar um relato do jogo.
88
Figura 6.15. Sistema: Cadastro de Jogo - Fotos.

Na figura 6.15, a ltima orelha apresentada. Nesta parte da interface, o usurio
tem a possibilidade de gravar at duas fotos do jogo no banco de dados do sistema.
6.4.2 Definir Escalao de um Jogo

Aps a incluso de um jogo, o usurio pode definir a escalao das duas equipes.
O sistema possui uma interface especfica para esta rotina. Alm de servir como um
registro das equipes, a incluso da escalao no sistema tambm possibilita ao sistema
gerar relatrios estatsticos dos jogadores.
89
Figura 6.16. Sistema: Escalao das Equipes.

A figura 5.16 demonstra a interface da atividade de definir escalao das
equipes. Existem duas orelhas, uma para cada equipe da partida e com o mesmo aspecto
visual. Para definir a escalao, o sistema apresenta a lista dos jogadores cadastrados no
lado esquerdo. A segunda lista dos jogadores escalados para o jogo. Na parte inferior
da interface, o usurio pode registrar as substituies ocorridas na partida ou remover
uma das substituies. O sistema ainda tem um atalho para o cadastro de jogadores e no
lado direito, apresenta as informaes detalhadas dos jogadores relacionados na partida.
90
6.4.3 Definir Lances da Partida
Figura 6.17. Sistema: Lances da Partida.

A figura 5.17 demonstra a interface do sistema para incluso dos lances da
partida. No lado esquerdo est o formulrio para incluso dos lances. O usurio
seleciona a equipe, o jogador que realizou o lance, o tipo do lance, o minuto que ocorreu
e solicita a incluso do evento. O lado direito da interface apresenta a relao de todos
os eventos j inseridos do jogo.
A incluso dos eventos do jogo possibilita ao sistema gerar informaes como o
artilheiro da competio alm de controle de cartes amarelos, porm est rotina de
preenchimento opcional.
6.5 As Estatsticas
O menu de estatsticas, disponibiliza o usurio consultar as informaes
referentes a temporada que est trabalhando. Abaixo so mostrados dois relatrios: A
tabela de classificao e a campanha da equipe. Todos os relatrios estatsticos so
gerados automaticamente pelo sistema, desde que o usurio insira as informaes nas
rotinas de manuteno da tabela de jogos.
91
6.5.1 Tabela de Classificao
Figura 6.18. Sistema: Tabela de Classificao.

A figura 6.18 demonstra a tabela de classificao da temporada 2005 do
Campeonato Brasileiro. O sistema permite ao usurio interagir podendo escolher
visualizar a tabela de classificao ordenada por diferentes critrios, conforme
possvel observar na parte esquerda da imagem. Os botes na parte inferior da tabela
permitem ao usurio escolher se os pontos devem ser considerando apenas os jogos
realizados em sua casa ou como visitante.
As cores apresentadas na tabela so resultado dos parmetros inseridos no
cadastro da temporada. Serem para visualizar quais os times esto classificados para
uma determinada competio e quais esto sendo rebaixados para uma diviso inferior.
Por ltimo, obrigatoriamente o usurio deve selecionar, para parte do lado
direito da interface, qual a fase da competio e o grupo que deseja visualizar a tabela
de classificao.
92
6.5.2 Campanha por Equipe
Figura 6.19. Sistema: Campanha por Equipe.

A figura 6.19 apresenta a campanha da equipe Atltico-MG na temporada 2005
do Campeonato Brasileiro. O usurio pode selecionar nesta interface, a campanha de
qualquer uma das equipes que disputam a temporada, selecionado-a no campo
especfico.
Na tabela campanha, o sistema apresenta o desempenho da equipe por meio de
diversos itens, fazendo a comparao com os jogos realizados em sua casa e como
visitante.
Na tabela de jogos so mostrados os compromissos da equipe e os resultados
obtidos. O usurio pode fazer filtros para que o sistema apresente somente os jogos
realizados em casa ou como visitante, ou ainda, apresentar somente os compromissos
em que obteve um determinado resultado.
Concluso
Com a apresentao final do sistema possvel concluir que todas as atividades
inerentes ao controle de campeonatos de futebol foram desenvolvidas. Conforme ser
93
discutido mais detalhadamente no captulo final deste trabalho, percebe-se que o sistema
necessita de um refinamento dos relatrios estatsticos e uma melhoria no visual das
interfaces para dar ao sistema um melhor entendimento das suas rotinas e torn-lo mais
atraente para o usurio final.
94
Captulo 7
Concluses e Trabalhos Futuros
O presente trabalho apresentou os detalhes que envolvem a disputa de um
campeonato de futebol para servir de base para o desenvolvimento do software. A
concluso deste trabalho destaca dois distintos contedos: o primeiro referente a
metodologia aplicada e o segundo, em relao ao programa propriamente dito.
A metodologia possui bastante contedo e auxilia muito na transio das etapas
do desenvolvimento e os resultados a serem obtidos em cada etapa. A fases de projeto e
anlise foram importantes. Foi til para delimitar com exatido o problema a ser
resolvido. Os casos de uso a serem trabalhados e os requisitos do sistema. J a fase de
anlise diminui a complexidade do problema. O desenvolvimento foi feito em partes. Os
casos de uso so classificados de acordo com a relevncia para o sistema. Primeiro so
atacados os casos de usos fundamentais e em seguida os de menores importncia e
opcionais. Isso deu segurana ao desenvolvimento, pois os resultados vo aparecendo j
nos primeiros ciclos de desenvolvimento e, em momento algum, se cria dvidas quanto
ao andamento do projeto.
Conforme descrito no projeto, a ferramenta de desenvolvimento utilizada foi o
Delphi verso 8. A ferramenta Delphi amplamente conhecida e utilizada no mercado
de desenvolvimento de software, porm, est verso do produto ficou pouco tempo no
mercado, sendo logo substituda pela verso 2005. Isso gerou alguns problemas no
desenvolvimento. Poucos so as referencias na Internet sobre esta verso
especificamente, e o principalmente problema est no fato de no se encontrar
componentes para download compatveis com est verso. Os componentes Delphi
disponveis para download na Internet, em geral, enriquecem as possibilidades de
criao de um software e ao mesmo tempo pode reduzir o tempo de desenvolvimento. A
utilizao de uma verso inferior, como a verso 5, de uso mais consagrado, ou
posterior, como a verso 2005, possivelmente, teria sido mais eficiente.
J a escolha do banco de dados Interbase foi bastante interessante. Permite ao
sistema a utilizao do conceito de transaes, que garante consistncia e aumenta a
segurana dos dados do sistema. O desempenho obtido tambm foi bom. As consultas
so feitas com velocidade. Para fins didticos ele mostrou-se muito apropriada. Porm
95
exige que o usurio final do sistema instale o banco de dados no seu computador. Esta
parece ser uma desvantagem em relao aos sistemas similares apresentados no captulo
3 deste trabalho. Isso porque estes sistemas utilizam o banco de dados Access, que
mais simples que o Interbase, porm, geralmente j instalado pr-instalado nos
computadores, ou at mesmo arquivos de dados. Para tornar o sistema de
Gerenciamento de Campeonatos um produto comercial, de se imaginar a possibilidade
da converso do sistema para o banco de dados Access ou trabalhar com arquivos,
mesmo que a performance do sistema e a segurana dos dados diminuam.
A continuao deste trabalho pode ser realizada, primeiramente, tornando o
produto mais comercial. Para isso, se faz necessrio um aperfeioamento das interfaces
do usurio, deixando-as mais interessantes visualmente alm de auto-explicativas,
permitindo ao usurio uma interao direta, sem maiores auxlios de manuais. Tambm
necessrio se refinar os relatrios estatsticos dos campeonatos gerando informaes
relevantes, objetivo principal de todos os sistemas de informaes. Um interessante
refinamento dos relatrios estatsticos a gerao de prognsticos das partidas baseado
no retrospecto. Outro uma tabela de possibilidades de rebaixamento e classificao. O
sistema, no atual estado de implementao, possivelmente j armazena as informaes
histricas para gerao destes relatrios, restando apenas a definio de um mtodo
estatstico e a implementao.
Para trabalhos futuros, tambm interessante se imaginar uma integrao as
informaes do software e as pginas da Internet, como a criao de um grande portal
de futebol. Para Internet tambm possvel imaginar o compartilhamento das
informaes, ou seja, ao invs de vrios usurios inserirem as informaes de um
campeonato, o que requer grande disponibilidade de tempo, um usurio apenas insere os
dados e compartilha com os demais que fazem a atualizao destes dados.
Outra proposta interessante para futuros trabalhos a generalizao do domnio
do problema para o controle de campeonatos de diferentes esportes. Podemos imaginar
que para o controle de um campeonato de futebol de salo, que possui domnio do
problema semelhante ao do futebol, para adaptar este software, basta que criemos
alguns parmetros e algumas linhas de cdigo e estar pronto. Porm, se imaginarmos
campeonatos de Vlei, Basquete pode no ser to simples a adaptao. E provavelmente
o desenvolvedor se deparar com a seguinte dvida: partir deste software para chegar a
uma soluo para estes tipos de campeonatos ou construir um novo software do zero.
Nestes casos, o mais correto parece ser a construo de um framework genrico para
96
controle de campeonatos, a partir do sistema de controle de campeonatos de futebol.

Um framework um conjunto de classes reutilizveis e usualmente extensveis que
fornecem servios para objetos persistentes. Uma caracterstica importante dos
frameworks que eles exigem poucas modificaes no cdigo existente e devem ser
fceis de usar pelo programador. Assim, mesmo que seja necessrio construir
aplicativos diferentes, o projeto no comea do zero. Na verdade j parte de uma
soluo testada e aplicada que, sabidamente, funciona sem erros.
97
Bibliografias Referenciadas
[LAR 00]
Larman, Craig. Utilizando UML e Padres Uma Introduo

Anlise e ao Projeto Orientado a Objetos. Editora Bookman. 2000.
[HEU 01]
Heusser, Carlos Alberto. Projeto de Banco de Dados 4 Edio.

Editora Sagra Luzzatto. 2001.
[CAN 03]
Cant, Marco. Dominando o Delphi 7: a Bblia. Editora Person / Makron

Books. 2003
[OLI 00]
Oliveira, Wilson Jos de. Banco de Dados InterBase com Delphi.

Visual Books. 2000.
[SIL 00]
Silva, Ivan Jos de Mecenas Silva. Delphi 5 Objetos e Herana. Book

Express. 2000.
[SOA 01]
Soares, Walace. Crie um Site B2C com PHP 4 e MySQL. Editora

rica. 2001.
Bibliografias Consultadas
Silva, Ricardo Pereira e. Engenharia de Software Apostila das disciplinas INE5322
e INE 5614. Editora rica. Mar/03.
Varela, Marcelo. Trabalhando com arquivos .INI no Windows. Site iMasters.

17/Jun/02.
Disponvel em: <http://www.imasters.com.br/artigo.php?cn=346&cc=49>
Site: Active Delphi.

Disponvel em: < http://www.activedelphi.com.br/>
Site: Planeta Delphi.

Disponvel em: < http://www.delphi.eti.br/>
98
Anexo 1
Banco de Dados: Modelo Lgico Entidade Relacionamento
OBS: Muitos atributos das tabelas foram omitidos nesta representao para que a
visualizao fosse melhor compreendida. A lista completa dos atributos pode ser
visualizada no anexo seguinte.
99
Anexo 2
Banco de Dados: Implementao Fsica
========================================================================================
====
TABELA ARBITRO
========================================================================================
====
CREATE TABLE "ARBITRO"
(
"CODARBITRO" INTEGER NOT NULL,
"CODTEMPORADA"
INTEGER NOT NULL,
"NOMEARBITRO"
VARCHAR(150),
"DATANASCIMENTO"
DATE,
"FOTO"
BLOB SUB_TYPE -1 SEGMENT SIZE 80,
PRIMARY KEY ("CODARBITRO")
);
ALTER TABLE "ARBITRO" ADD FOREIGN KEY ("CODTEMPORADA") REFERENCES "TEMPORADA"
("CODTEMPORADA");
========================================================================================
====
TABELA CAMPEONATO
========================================================================================
====
CREATE TABLE "CAMPEONATO"
(
"CODCAMPEONATO"
INTEGER NOT NULL,
"NOME"
VARCHAR(150) NOT NULL,
"TIPO"
INTEGER NOT NULL,
"PAIS"
VARCHAR(30),
"ESCUDO"
PRIMARY KEY ("CODCAMPEONATO")
);
========================================================================================
====
TABELA CLASSIFICAO
========================================================================================
====
CREATE TABLE "CLASSIFICACAO"
(
"CODCLASSIFICACAO" INTEGER NOT NULL,
"CODESTRUTURATEMPORADA"
INTEGER NOT NULL,
"DATAJOGO"
DATE NOT NULL,
"CODEQUIPE" INTEGER NOT NULL,
"PONTOS"
INTEGER default 0,
"VITORIA"
INTEGER default 0,
"EMPATE"
INTEGER default 0,
"DERROTA"
INTEGER default 0,
"VITORIAPRORROGACAO" INTEGER default 0,
"VITORIAPENALTIS"
INTEGER default 0,
"DERROTAPRORROGACAO" INTEGER default 0,
"DERROTAPENALTIS"
INTEGER default 0,
"GOLSPRO"
INTEGER default 0,
"GOLSCONTRA" INTEGER default 0,
"SALDOGOLS"
COMPUTED BY (GolsPro - GolsContra),
"PUBLICO"
INTEGER,
"LOCAL"
"REALIZADO" INTEGER NOT NULL,
"JOGOS"
INTEGER,
"EMPATEPRORROGACAO" INTEGER,
PRIMARY KEY ("CODCLASSIFICACAO")
);
ALTER TABLE "CLASSIFICACAO" ADD FOREIGN KEY ("CODESTRUTURATEMPORADA") REFERENCES
"ESTRUTURATEMPORADA" ("CODESTRUTURATEMPORADA");
ALTER TABLE "CLASSIFICACAO" ADD FOREIGN KEY ("CODEQUIPE") REFERENCES "EQUIPE"
("CODEQUIPE");
========================================================================================
====
TABELA EQUIPE
========================================================================================
====
CREATE TABLE "EQUIPE"
100
(
"NOMEEQUIPE" VARCHAR(50) NOT NULL,
"NOMECOMPLETOEQUIPE" VARCHAR(200),
"DATAFUNDACAO"
DATE,
"CIDADE"
VARCHAR(30),
"PAIS"
VARCHAR(30),
"TIPOEQUIPE" INTEGER,
"ESCUDO"
"CODESTADIO" INTEGER,
PRIMARY KEY ("CODEQUIPE")
);
========================================================================================
====
TABELA EQUIPECOMPETETEMPORADA
========================================================================================
====
CREATE TABLE "EQUIPECOMPETETEMPORADA"
(
"CODTEMPORADA"
INTEGER NOT NULL,
PRIMARY KEY ("CODEQUIPE", "CODTEMPORADA")
);
ALTER TABLE "EQUIPECOMPETETEMPORADA" ADD FOREIGN KEY ("CODEQUIPE") REFERENCES "EQUIPE"
("CODEQUIPE");
ALTER TABLE "EQUIPECOMPETETEMPORADA" ADD FOREIGN KEY ("CODTEMPORADA") REFERENCES
"TEMPORADA" ("CODTEMPORADA");
========================================================================================
====
TABELA ESCALACAOJOGO
========================================================================================
====
CREATE TABLE "ESCALACAOJOGO"
(
"CODJOGO"
INTEGER NOT NULL,
"CODJOGADOR" INTEGER NOT NULL,
"CODJOGADORENTROU" INTEGER,
"STATUS"
VARCHAR(1),
"SAIU"
VARCHAR(1),
"TEMPOJOGADO"
INTEGER,
"MINUTOSUBSTITUICAO" INTEGER,
PRIMARY KEY ("CODJOGO", "CODEQUIPE", "CODJOGADOR")
);
ALTER TABLE "ESCALACAOJOGO" ADD FOREIGN KEY ("CODJOGO") REFERENCES "JOGO" ("CODJOGO");
ALTER TABLE "ESCALACAOJOGO" ADD FOREIGN KEY ("CODEQUIPE") REFERENCES "EQUIPE"
("CODEQUIPE");
ALTER TABLE "ESCALACAOJOGO" ADD FOREIGN KEY ("CODJOGADOR") REFERENCES "JOGADOR"
("CODJOGADOR");
ALTER TABLE "ESCALACAOJOGO" ADD FOREIGN KEY ("CODJOGADORENTROU") REFERENCES "JOGADOR"
("CODJOGADOR");
========================================================================================
====
TABELA ESTADIO
========================================================================================
====
CREATE TABLE "ESTADIO"
(
"CODESTADIO" INTEGER NOT NULL,
"NOMEESTADIO"
"NOMECOMPLETOESTADIO"
VARCHAR(200),
"CAPACIDADEESTADIO" INTEGER,
"CIDADEESTADIO"
VARCHAR(30),
"FOTO"
"PAIS"
VARCHAR(30),
PRIMARY KEY ("CODESTADIO")
);
========================================================================================
====
TABELA ESTRUTURATEMPORADA
========================================================================================
====
CREATE TABLE "ESTRUTURATEMPORADA"
(
INTEGER NOT NULL,
"CODTEMPORADA"
INTEGER NOT NULL,
"NOMEESTRUTURATEMPORADA"
101
"CODGRUPO"
INTEGER,
"CODFASE"
INTEGER,
PRIMARY KEY ("CODESTRUTURATEMPORADA")
);
ALTER TABLE "ESTRUTURATEMPORADA" ADD FOREIGN KEY ("CODTEMPORADA") REFERENCES "TEMPORADA"
("CODTEMPORADA");
========================================================================================
====
TABELA GERADOR
========================================================================================
====
CREATE TABLE "GERADOR"
(
"OID" INTEGER NOT NULL,
PRIMARY KEY ("OID")
);
========================================================================================
====
TABELA JOGADOR
========================================================================================
====
CREATE TABLE "JOGADOR"
(
"CODTEMPORADA"
INTEGER NOT NULL,
"APELIDOJOGADOR"
"NOMEJOGADOR"
VARCHAR(150),
"NUMEROCAMISA"
INTEGER,
"DATANASCIMENTO"
DATE,
"NACIONALIDADE"
VARCHAR(30),
"POSICAO"
INTEGER,
"STATUS"
VARCHAR(1) default 'A',
"EMAIL"
VARCHAR(100),
"FOTO"
PRIMARY KEY ("CODJOGADOR")
);
ALTER TABLE "JOGADOR" ADD FOREIGN KEY ("CODEQUIPE") REFERENCES "EQUIPE" ("CODEQUIPE");
ALTER TABLE "JOGADOR" ADD FOREIGN KEY ("CODTEMPORADA") REFERENCES "TEMPORADA"
("CODTEMPORADA");
========================================================================================
====
TABELA JOGO
========================================================================================
====
CREATE TABLE "JOGO"
(
"CODJOGO"
INTEGER NOT NULL,
INTEGER NOT NULL,
"CODEQUIPECASA"
INTEGER NOT NULL,
"CODEQUIPEFORA"
INTEGER NOT NULL,
"TV" VARCHAR(10),
"NOMEESTADIO"
VARCHAR(30),
"GOLSTIMECASA"
INTEGER,
"GOLSTIMEFORA"
INTEGER,
"GOLSTIMECASAPRITEM" INTEGER,
"GOLSTIMEFORAPRITEM" INTEGER,
"PRORROGACAO"
INTEGER default 0,
"PENALTIS"
INTEGER default 0,
"GOLSTIMECASAPRORROGACAO"
INTEGER,
"GOLSTIMEFORAPRORROGACAO"
INTEGER,
"GOLSTIMECASAPENALTIS"
INTEGER,
"GOLSTIMEFORAPENALTIS"
INTEGER,
"PUBLICO"
INTEGER,
"NOTICIA"
BLOB SUB_TYPE TEXT SEGMENT SIZE 80,
"REALIZADO" INTEGER NOT NULL,
"ESTATCHUTECASA"
INTEGER default 0,
"ESTATCHUTEFORA"
INTEGER default 0,
"ESTATFALTACASA"
INTEGER default 0,
"ESTATFALTAFORA"
INTEGER default 0,
"ESTATESCANTEIOCASA" INTEGER default 0,
"ESTATESCANTEIOFORA" INTEGER default 0,
"ESTATIMPEDIMENTOCASA"
INTEGER default 0,
"ESTATIMPEDIMENTOFORA"
INTEGER default 0,
"DATAHORAJOGO"
TIMESTAMP,
"CODARBITRO" INTEGER,
"CODESTADIO" INTEGER,
102
"FOTO1"
"FOTO2"
"CODCLASSIFICACAOTIMECASA" INTEGER NOT NULL,
"CODCLASSIFICACAOTIMEFORA" INTEGER NOT NULL,
PRIMARY KEY ("CODJOGO")
);
ALTER TABLE "JOGO" ADD FOREIGN KEY ("CODESTRUTURATEMPORADA") REFERENCES
ALTER TABLE "JOGO" ADD FOREIGN KEY ("CODEQUIPECASA") REFERENCES "EQUIPE" ("CODEQUIPE");
ALTER TABLE "JOGO" ADD FOREIGN KEY ("CODEQUIPEFORA") REFERENCES "EQUIPE" ("CODEQUIPE");
========================================================================================
====
TABELA LANCEPARTIDA
========================================================================================
====
CREATE TABLE "LANCEPARTIDA"
(
"CODLANCEPARTIDA"
INTEGER NOT NULL,
"CODJOGO"
INTEGER NOT NULL,
"TIPOLANCE" INTEGER NOT NULL,
"MINUTO"
INTEGER,
"CODEQUIPELANCE"
INTEGER NOT NULL,
"CODEQUIPEJOGADOR" INTEGER NOT NULL,
PRIMARY KEY ("CODLANCEPARTIDA")
);
ALTER TABLE "LANCEPARTIDA" ADD FOREIGN KEY ("CODEQUIPELANCE") REFERENCES "EQUIPE"
("CODEQUIPE");
ALTER TABLE "LANCEPARTIDA" ADD FOREIGN KEY ("CODJOGO") REFERENCES "JOGO" ("CODJOGO");
ALTER TABLE "LANCEPARTIDA" ADD FOREIGN KEY ("CODJOGADOR") REFERENCES "JOGADOR"
("CODJOGADOR");
========================================================================================
====
TABELA NARRACAO
========================================================================================
====
CREATE TABLE "NARRACAO"
(
"CODNARRACAO"
INTEGER NOT NULL,
"CODJOGO"
INTEGER NOT NULL,
"MINUTO"
INTEGER,
"NARRACAO"
BLOB SUB_TYPE TEXT SEGMENT SIZE 80,
PRIMARY KEY ("CODNARRACAO")
);
ALTER TABLE "NARRACAO" ADD FOREIGN KEY ("CODJOGO") REFERENCES "JOGO" ("CODJOGO");
========================================================================================
====
TABELA PUNICAO
========================================================================================
====
CREATE TABLE "PUNICAO"
(
"CODPUNICAO" INTEGER NOT NULL,
INTEGER NOT NULL,
"PONTOS"
INTEGER NOT NULL,
"MOTIVO"
VARCHAR(100),
"DATA"
DATE,
"CODCLASSIFICACAO" INTEGER NOT NULL,
PRIMARY KEY ("CODPUNICAO")
);
ALTER TABLE "PUNICAO" ADD FOREIGN KEY ("CODESTRUTURATEMPORADA") REFERENCES
ALTER TABLE "PUNICAO" ADD FOREIGN KEY ("CODEQUIPE") REFERENCES "EQUIPE" ("CODEQUIPE");
========================================================================================
====
TABELA TEMPORADA
========================================================================================
====
CREATE TABLE "TEMPORADA"
(
"CODTEMPORADA"
INTEGER NOT NULL,
"CODCAMPEONATO"
INTEGER NOT NULL,
"NOMETEMPORADA"
"PONTOSVITORIA"
INTEGER default 3,
"PONTOSEMPATE"
INTEGER default 1,
"PONTOSVITORIAPRORROGACAO" INTEGER default 0,
103
"PONTOSVITORIAPENALTIS"
INTEGER default 0,
"PONTOSDERROTAPRORROGACAO" INTEGER default 0,
"PONTOSDERROTAPENALTIS"
INTEGER default 0,
"DESCRICAO" BLOB SUB_TYPE TEXT SEGMENT SIZE 80,
"NUMTIMEREBAIXADO" INTEGER default 0,
"NUMTIMEPROMOVIDO" INTEGER default 0,
"PONTOSEMPATEPRORROGACAO"
INTEGER,
"SQLDESEMPATE"
"NUMTIMECOMPET1"
INTEGER NOT NULL,
"NUMTIMECOMPET2"
INTEGER NOT NULL,
"NUMTIMEPOREBAIXAMENTO"
INTEGER NOT NULL,
PRIMARY KEY ("CODTEMPORADA")
);
ALTER TABLE "TEMPORADA" ADD FOREIGN KEY ("CODCAMPEONATO") REFERENCES "CAMPEONATO"
("CODCAMPEONATO");
========================================================================================
====
104
Anexo 3
Cdigo Fonte do Sistema
========================================================================================
====
ARQUIVO: UTemporada.pas
========================================================================================
====
unit UTemporada;
interface
Uses
UDMDados, SysUtils, Borland.Vcl.Classes, UEquipe, UEstadio, UArbitro,
UEstruturaTemporada, UDMClasses, UCampeonato, UPunicao;
type
TTemporada = class
private
protected
BD: TDtMdlClasses;
conBD: TDtMdlDados;
CodTemporada: Integer;
Campeonato: TCampeonato;
NomeTemporada: String;
PontosVitoria: Integer;
PontosEmpate: Integer;
PontosVitoriaProrrogacao: Integer;
PontosVitoriaPenaltis: Integer;
PontosDerrotaProrrogacao: Integer;
PontosDerrotaPenaltis: Integer;
PontosEmpateProrrogacao: Integer;
Descricao: String;
NumTimeRebaixado: Integer;
NumTimeCompet1: Integer;
NumTimeCompet2: Integer;
NumTimePORebaixamento: Integer;
NumTimePromovido: Integer;
SQLDesempate: String;
NumFases: Integer;
public
procedure SetBD (var umaConBD: TDtMdlDados);
procedure Materializar (Cod: Integer);
procedure NovaTemporada(CodCamp, PtsVitTN, PtsEmpTN, PtsVitPro, PtsEmpPro, PtsDerPro,
PtsVitPen, PtsDerPen, NumPro, NumComp1, NumComp2, NumPOReb, NumReb:
Integer;
NomeTemp, Descr, Criterio: String);
procedure AlterarTemporada(CodCamp, PtsVitTN, PtsEmpTN, PtsVitPro, PtsEmpPro,
PtsDerPro,
PtsVitPen, PtsDerPen, NumPro, NumComp1, NumComp2, NumPOReb, NumReb:
Integer;
function GetCodTemporada: Integer;
function GetPontosVitoria: Integer;
function GetNumTimePromovido: Integer;
function GetNumTimeCompet1: Integer;
function GetNumTimeCompet2: Integer;
function GetNumTimePORebaixamento: Integer;
function GetNumTimeRebaixado: Integer;
function GetNomeTemporada: String;
function GetSQLDesempate: String;
function NovoJogo(CodEstTemp, CodTimeCasa, CodTimeFora: Integer; DataHoraJogo:
TDateTime;
CodArbitro, CodEstadio, Realizado, GolsTimeCasa, GolsTimeFora,
Prorrogacao,
GolsTimeCasaProrrog, GolsTimeForaProrrog, Penaltis, GolsTimeCasaPen,
GolsTimeForaPen, Publico, ChutesTimeCasa, ChutesTimeFora,
ImpedTimeCasa,
ImpedTimeFora, FaltasTimeCasa, FaltasTimeFora, EscanteiosTimeCasa,
EscanteiosTimeFora: Integer; Noticia, TV: String; Foto1,
Foto2: TMemoryStream) : Boolean;
105
function AlterarJogo(CodJogo, CodEstTemp, CodTimeCasa, CodTimeFora : Integer;

DataHoraJogo : TDateTime;
CodArbitro, CodEstadio, Realizado, GolsTimeCasa, GolsTimeFora,
Prorrogacao,
GolsTimeCasaProrrog, GolsTimeForaProrrog, Penaltis, GolsTimeCasaPen,
ImpedTimeCasa,
ImpedTimeFora, FaltasTimeCasa, FaltasTimeFora, EscanteiosTimeCasa,
procedure AlteraDataRodada (umCodRodada: Integer; umaDataHoraJogo: TDateTime; SeTodos:
String);
destructor Destroy; Override;
procedure AlterarArbitro(codArbitro: Integer; umNome: String; umaData: TDateTime;
Foto: TMemoryStream);
procedure IncluirArbitro(umNome: String; umaData: TDateTime; Foto: TMemoryStream);
procedure IncluirFase(umNome: String);
procedure AlterarFase(umCodFase:Integer; umNome: String);
procedure IncluirGrupo(umNome: String; umCodFase: Integer);
procedure AlterarGrupo(umCodGrupo: Integer; umNome: String);
procedure IncluirRodada(umNome: String; umCodFase, umCodGrupo: Integer);
function ExcluirEstruturaTemporada(umCod: Integer) : Boolean;
procedure IncluirEquipeNaDisputa(Equipe: TEquipe);
function ExcluirEquipeDaDisputa(Equipe: TEquipe) : Boolean;
procedure IncluirPunicao (CodEstTemp, CodEquipe, Pts: Integer; DataPunicao: TDateTime;
Motivo: String);
procedure AlterarPunicao (CodPunicao, CodEstTemp, CodEquipe, Pts: Integer;
DataPunicao: TDateTime; Motivo: String);
procedure ExcluirPunicao (CodPunicao: Integer);
end;
implementation
procedure TTemporada.SetBD (var umaConBD: TDtMdlDados);
begin
conBD := umaConBD;
BD := TDtMdlClasses.create(nil);
BD.SetConexaoBD (conBD)
end;
function TTemporada.GetCodTemporada : Integer;
begin
GetCodTemporada := CodTemporada;
end;
procedure TTemporada.Materializar (Cod: Integer);
begin
BD.SQLDtStDados.CommandText := 'SELECT * FROM TEMPORADA WHERE CODTEMPORADA = ' +
IntToStr(Cod);
with BD.ClntDtStDados do begin
Close;
Open;
First;
codTemporada := FieldByName('CodTemporada').asInteger;
Campeonato := TCampeonato.Create; Campeonato.SetBD(ConBD);
Campeonato.Materializar(FieldByName('CodCampeonato').asInteger);
NomeTemporada := FieldByName('NomeTemporada').asString;
PontosVitoria := FieldByName('PontosVitoria').asInteger;
PontosEmpate := FieldByName('PontosEmpate').asInteger;
PontosVitoriaProrrogacao := FieldByName('PontosVitoriaProrrogacao').asInteger;
PontosVitoriaPenaltis := FieldByName('PontosVitoriaPenaltis').asInteger;
PontosDerrotaProrrogacao := FieldByName('PontosDerrotaProrrogacao').asInteger;
PontosDerrotaPenaltis := FieldByName('PontosDerrotaPenaltis').asInteger;
PontosEmpateProrrogacao := FieldByName('PontosEmpateProrrogacao').asInteger;
Descricao := FieldByName('Descricao').asString;
NumTimeRebaixado := FieldByName('NumTimeRebaixado').asInteger;
NumTimePromovido := FieldByName('NumTimePromovido').asInteger;
NumTimeCompet1 := FieldByName('NumTimeCompet1').asInteger;
NumTimeCompet2 := FieldByName('NumTimeCompet2').asInteger;
NumTimePORebaixamento := FieldByName('NumTimePORebaixamento').asInteger;
SQLDesempate := FieldByName('SQLDesempate').asString;
end;
end;
procedure TTemporada.NovaTemporada(CodCamp, PtsVitTN, PtsEmpTN, PtsVitPro, PtsEmpPro,
PtsDerPro,
106
PtsVitPen, PtsDerPen, NumPro, NumComp1, NumComp2, NumPOReb,

NumReb: Integer;
var
SQL: String;
begin
Campeonato.Materializar(CodCamp);
NomeTemporada := NomeTemp;
PontosVitoria := PtsVitTN;
PontosEmpate := PtsEmpTN;
PontosVitoriaProrrogacao := PtsVitPro;
PontosEmpateProrrogacao := PtsEmpPro;
PontosDerrotaProrrogacao := PtsDerPro;
PontosVitoriaPenaltis := PtsVitPen;
PontosDerrotaPenaltis := PtsDerPen;
Descricao := Descr;
NumTimeRebaixado := NumReb;
NumTimeCompet1 := NumComp1;
NumTimePORebaixamento := NumPOReb;
NumTimePromovido := NumPro;
SQLDesempate := Criterio;
BD.SQLDtStDados.CommandText := 'SELECT OID FROM GERADOR';
Close;
Open;
First;
CodTemporada := FieldByName('OID').asInteger;
end;
BD.SQLDtStDados.CommandText := 'UPDATE GERADOR SET OID = OID + 1;';
BD.SQLDtStDados.ExecSQL();
SQL := 'Insert into TEMPORADA (CODTEMPORADA, CODCAMPEONATO, NOMETEMPORADA,
PONTOSVITORIA, PONTOSEMPATE, ';
SQL := SQL + 'PONTOSVITORIAPRORROGACAO, PONTOSEMPATEPRORROGACAO,
PONTOSDERROTAPRORROGACAO, ';
SQL := SQL + 'PONTOSVITORIAPENALTIS, PONTOSDERROTAPENALTIS, NUMTIMEREBAIXADO,
NUMTIMEPOREBAIXAMENTO, ';
SQL := SQL + 'NUMTIMEPROMOVIDO, NUMTIMECOMPET1, NUMTIMECOMPET2, SQLDESEMPATE,
DESCRICAO) VALUES (';
SQL := SQL + IntToStr(CodTemporada) + ', ';
SQL := SQL + IntToStr(Campeonato.GetCodCampeonato) + ', ';
SQL := SQL + '''' + NomeTemporada + ''', ';
SQL := SQL + IntToStr(PontosVitoria) + ', ';
SQL := SQL + IntToStr(PontosEmpate) + ', ';
SQL := SQL + IntToStr(PontosVitoriaProrrogacao) + ', ';
SQL := SQL + IntToStr(PontosEmpateProrrogacao) + ', ';
SQL := SQL + IntToStr(PontosDerrotaProrrogacao) + ', ';
SQL := SQL + IntToStr(PontosVitoriaPenaltis) + ', ';
SQL := SQL + IntToStr(PontosDerrotaPenaltis) + ', ';
SQL := SQL + IntToStr(NumTimeRebaixado) + ', ';
SQL := SQL + IntToStr(NumTimePORebaixamento) + ', ';
SQL := SQL + IntToStr(NumTimePromovido) + ', ';
SQL := SQL + IntToStr(NumTimeCompet1) + ', ';
SQL := SQL + IntToStr(NumTimeCompet2) + ', ';
SQL := SQL + '''' + SQLDesempate + ''', :Desc)';
BD.SQLDtStDados.CommandText := SQL;
BD.SQLDtStDados.ParamByName('Desc').asMemo := Descricao;
end;
procedure TTemporada.AlterarTemporada(CodCamp, PtsVitTN, PtsEmpTN, PtsVitPro, PtsEmpPro,
PtsDerPro,
PtsVitPen, PtsDerPen, NumPro, NumComp1, NumComp2, NumPOReb,
NumReb: Integer;
var
SQL: String;
begin
Campeonato.Materializar(CodCamp);
NomeTemporada := NomeTemp;
PontosVitoria := PtsVitTN;
PontosEmpate := PtsEmpTN;
PontosVitoriaProrrogacao := PtsVitPro;
PontosEmpateProrrogacao := PtsEmpPro;
PontosDerrotaProrrogacao := PtsDerPro;
107
PontosVitoriaPenaltis := PtsVitPen;
PontosDerrotaPenaltis := PtsDerPen;
Descricao := Descr;
NumTimeRebaixado := NumReb;
NumTimePORebaixamento := NumPOReb;
NumTimePromovido := NumPro;
SQLDesempate := Criterio;
SQL := 'Update TEMPORADA set ';
SQL := SQL + 'CODCAMPEONATO=' + IntToStr(Campeonato.GetCodCampeonato) + ', ';
SQL := SQL + 'NOMETEMPORADA=''' + NomeTemporada + ''', ';
SQL := SQL + 'PONTOSVITORIA=' + IntToStr(PontosVitoria) + ', ';
SQL := SQL + 'PONTOSEMPATE=' + IntToStr(PontosEmpate) + ', ';
SQL := SQL + 'PONTOSVITORIAPRORROGACAO=' + IntToStr(PontosVitoriaProrrogacao) + ', ';
SQL := SQL + 'PONTOSEMPATEPRORROGACAO=' + IntToStr(PontosEmpateProrrogacao) + ', ';
SQL := SQL + 'PONTOSDERROTAPRORROGACAO=' + IntToStr(PontosDerrotaProrrogacao) + ', ';
SQL := SQL + 'PONTOSVITORIAPENALTIS=' + IntToStr(PontosVitoriaPenaltis) + ', ';
SQL := SQL + 'PONTOSDERROTAPENALTIS=' + IntToStr(PontosDerrotaPenaltis) + ', ';
SQL := SQL + 'NUMTIMEREBAIXADO=' + IntToStr(NumTimeRebaixado) + ', ';
SQL := SQL + 'NUMTIMEPOREBAIXAMENTO=' + IntToStr(NumTimePORebaixamento) + ', ';
SQL := SQL + 'NUMTIMEPROMOVIDO=' + IntToStr(NumTimePromovido) + ', ';
SQL := SQL + 'NUMTIMECOMPET1=' + IntToStr(NumTimeCompet1) + ', ';
SQL := SQL + 'NUMTIMECOMPET2=' + IntToStr(NumTimeCompet2) + ', ';
SQL := SQL + 'SQLDESEMPATE=''' + SQLDesempate + ''', DESCRICAO=:Desc ';
SQL := SQL + 'Where CodTemporada=' + IntToStr(CodTemporada);
BD.SQLDtStDados.ParamByName('Desc').asMemo := Descricao;
end;
function TTemporada.NovoJogo(CodEstTemp, CodTimeCasa, CodTimeFora : Integer;

CodArbitro, CodEstadio, Realizado, GolsTimeCasa,
GolsTimeFora, Prorrogacao,
GolsTimeCasaProrrog, GolsTimeForaProrrog, Penaltis,
GolsTimeCasaPen,
ImpedTimeCasa,
ImpedTimeFora, FaltasTimeCasa, FaltasTimeFora,
EscanteiosTimeCasa,
var
EquipeCasa, EquipeFora : TEquipe;
Arbitro : TArbitro;
Estadio : TEstadio;
EstruturaTemporada : TEstruturaTemporada;
begin
EquipeCasa := TEquipe.Create; EquipeCasa.SetBD(ConBD);
EquipeCasa.Materializar (CodTimeCasa);
EquipeFora :=TEquipe.Create; EquipeFora.SetBD(ConBD);
EquipeFora.Materializar (CodTimeFora);
Arbitro := TArbitro.Create; Arbitro.SetBD(ConBD);
Arbitro.Materializar (CodArbitro);
Estadio := TEstadio.Create; Estadio.SetBD(ConBD);
Estadio.Materializar (CodEstadio);
EstruturaTemporada := TEstruturaTemporada.Create; EstruturaTemporada.SetBD(ConBD);
EstruturaTemporada.Materializar (CodEstTemp);
EstruturaTemporada.NovoJogo (EquipeCasa, EquipeFora, DataHoraJogo, Arbitro, Estadio,
Realizado,
GolsTimeCasa, GolsTimeFora, Prorrogacao,
GolsTimeCasaProrrog,
GolsTimeForaProrrog, Penaltis, GolsTimeCasaPen,
GolsTimeForaPen, Publico,
ChutesTimeCasa, ChutesTimeFora, ImpedTimeCasa,
ImpedTimeFora,
FaltasTimeCasa, FaltasTimeFora, EscanteiosTimeCasa,
EscanteiosTimeFora,
Noticia, TV, Foto1, Foto2, PontosVitoria, PontosEmpate,
PontosVitoriaProrrogacao, PontosEmpateProrrogacao,
PontosDerrotaProrrogacao,
PontosVitoriaPenaltis, PontosDerrotaPenaltis);
EquipeCasa.Destroy;
EquipeFora.Destroy;
Arbitro.Destroy;
108
Estadio.Destroy;
Foto1.Free; Foto2.Free;
EstruturaTemporada.Destroy;
end;
function TTemporada.AlterarJogo(CodJogo, CodEstTemp, CodTimeCasa, CodTimeFora : Integer;
CodArbitro, CodEstadio, Realizado, GolsTimeCasa,
GolsTimeFora, Prorrogacao,
GolsTimeCasaProrrog, GolsTimeForaProrrog, Penaltis,
GolsTimeCasaPen,
ImpedTimeCasa,
ImpedTimeFora, FaltasTimeCasa, FaltasTimeFora,
EscanteiosTimeCasa,
var
EquipeCasa, EquipeFora : TEquipe;
Arbitro : TArbitro;
Estadio : TEstadio;
begin
EquipeCasa.Materializar (CodTimeCasa);
EquipeFora :=TEquipe.Create; EquipeFora.SetBD(ConBD);
EquipeFora.Materializar (CodTimeFora);
EstruturaTemporada.Materializar (CodEstTemp);
EstruturaTemporada.AlterarJogo (CodJogo, EquipeCasa, EquipeFora, DataHoraJogo,
Arbitro, Estadio, Realizado,
GolsTimeCasa, GolsTimeFora, Prorrogacao,
GolsTimeForaProrrog, Penaltis, GolsTimeCasaPen,
GolsTimeForaPen, Publico,
ChutesTimeCasa, ChutesTimeFora, ImpedTimeCasa,
ImpedTimeFora,
FaltasTimeCasa, FaltasTimeFora, EscanteiosTimeCasa,
EscanteiosTimeFora,
Noticia, TV, Foto1, Foto2, PontosVitoria, PontosEmpate,
PontosVitoriaProrrogacao, PontosEmpateProrrogacao,
PontosDerrotaProrrogacao,
PontosVitoriaPenaltis, PontosDerrotaPenaltis);
EquipeCasa.Destroy;
EquipeFora.Destroy;
Arbitro.Destroy;
Estadio.Destroy;
Foto1.Free; Foto2.Free;
end;
procedure TTemporada.AlteraDataRodada (umCodRodada: Integer; umaDataHoraJogo: TDateTime;
SeTodos: String);
var
begin
EstruturaTemporada.Materializar (umCodRodada);
EstruturaTemporada.AlterarDataRodada (umaDataHoraJogo, SeTodos);
end;
procedure TTemporada.IncluirArbitro (umNome: String; umaData: TDateTime; Foto:
TMemoryStream);
var
Arbitro: TArbitro;
begin
Arbitro.NovoArbitro(CodTemporada, umNome, umaData, Foto);
Arbitro.Destroy;
end;
109
procedure TTemporada.AlterarArbitro (codArbitro: Integer; umNome: String; umaData:

TDateTime; Foto: TMemoryStream);
var
Arbitro: TArbitro;
begin
Arbitro.AlterarArbitro(umNome, umaData, Foto);
Arbitro.Destroy;
end;
destructor TTemporada.Destroy;
begin
Campeonato.Destroy;
end;
procedure TTemporada.IncluirFase(umNome: String);
var
EstruturaTemporada: TEstruturaTemporada;
begin
EstruturaTemporada.NovaFase(CodTemporada, umNome);
end;
procedure TTemporada.AlterarFase(umCodFase:Integer; umNome: String);
var
begin
EstruturaTemporada.Materializar(umCodFase);
EstruturaTemporada.AlterarFase(umNome);
end;
procedure TTemporada.IncluirGrupo(umNome: String; umCodFase: Integer);
var
begin
EstruturaTemporada.NovoGrupo(CodTemporada, umCodFase, umNome);
end;
procedure TTemporada.AlterarGrupo(umCodGrupo: Integer; umNome: String);
var
begin
EstruturaTemporada.Materializar(umCodGrupo);
EstruturaTemporada.AlterarGrupo(umNome);
end;
procedure TTemporada.IncluirRodada(umNome: String; umCodFase, umCodGrupo: Integer);
var
begin
EstruturaTemporada.NovaRodada(CodTemporada, umCodFase, umCodGrupo, umNome);
end;
function TTemporada.ExcluirEstruturaTemporada(umCod:Integer) : Boolean;
var
begin
EstruturaTemporada.Materializar(umCod);
ExcluirEstruturaTemporada := EstruturaTemporada.ExcluirEstruturaTemporada;
end;
function TTemporada.GetNomeTemporada : String;
begin
GetNomeTemporada := Campeonato.GetNomeCampeonato + ' ' + NomeTemporada;
end;
110
procedure TTemporada.IncluirEquipeNaDisputa(Equipe: TEquipe);

var
SQL: String;
begin
SQL := 'Insert into EQUIPECOMPETETEMPORADA (CODEQUIPE, CODTEMPORADA) VALUES (';
SQL := SQL + IntToStr(Equipe.GetCodEquipe) + ', ';
SQL := SQL + IntToStr(CodTemporada) + ')';
end;
function TTemporada.ExcluirEquipeDaDisputa(Equipe: TEquipe) : Boolean;
var
SQL: String;
begin
SQL := 'Select Count(*) from JOGO J, ESTRUTURATEMPORADA ET where (J.CODEQUIPECASA=';
SQL := SQL + IntToStr(Equipe.GetCodEquipe) + ' or J.CODEQUIPEFORA=' +
IntToStr(Equipe.GetCodEquipe);
SQL := SQL + ') and ET.CODTEMPORADA=' + IntToStr(CodTemporada);
SQL := SQL + ' and J.CODESTRUTURATEMPORADA=ET.CODESTRUTURATEMPORADA';
BD.ClntDtStDados.Close;
BD.ClntDtStDados.Open;
if BD.ClntDtStDados.FieldByName('COUNT').AsInteger = 0 then begin
SQL := 'Delete from EQUIPECOMPETETEMPORADA where ';
SQL := SQL + 'CODEQUIPE=' + IntToStr(Equipe.GetCodEquipe) + ' and ';
SQL := SQL + 'CODTEMPORADA=' + IntToStr(CodTemporada);
ExcluirEquipeDaDisputa := True;
end else begin
ExcluirEquipeDaDisputa := False;
end;
end;
procedure TTemporada.IncluirPunicao (CodEstTemp, CodEquipe, Pts: Integer; DataPunicao:
TDateTime; Motivo: String);
var
EstTemp: TEstruturaTemporada;
Equipe: TEquipe;
Punicao: TPunicao;
begin
EstTemp := TEstruturaTemporada.Create; EstTemp.SetBD(ConBD);
EstTemp.Materializar(CodEstTemp);
Equipe := TEquipe.Create; Equipe.SetBD(ConBD);
Equipe.Materializar(CodEquipe);
Punicao := TPunicao.Create; Punicao.SetBD(ConBD);
Punicao.NovaPunicao(EstTemp, Equipe, DataPunicao, Pts, Motivo);
Punicao.Destroy;
Equipe.Destroy;
EstTemp.Destroy;
end;
procedure TTemporada.AlterarPunicao (CodPunicao, CodEstTemp, CodEquipe, Pts: Integer;
DataPunicao: TDateTime; Motivo: String);
var
EstTemp: TEstruturaTemporada;
Equipe: TEquipe;
Punicao: TPunicao;
begin
EstTemp := TEstruturaTemporada.Create; EstTemp.SetBD(ConBD);
EstTemp.Materializar(CodEstTemp);
Punicao.Materializar(CodPunicao);
Punicao.AlterarPunicao(EstTemp, Equipe, DataPunicao, Pts, Motivo);
Punicao.Destroy;
Equipe.Destroy;
EstTemp.Destroy;
end;
procedure TTemporada.ExcluirPunicao (CodPunicao: Integer);
var
Punicao: TPunicao;
begin
111

Punicao.Materializar(CodPunicao);
Punicao.ExcluirPunicao;
Punicao.Destroy;
end;
function TTemporada.GetNumTimePromovido: Integer;
begin
GetNumTimePromovido := NumTimePromovido;
end;
function TTemporada.GetNumTimeCompet1: Integer;
begin
GetNumTimeCompet1 := NumTimeCompet1;
end;
function TTemporada.GetNumTimeCompet2: Integer;
begin
GetNumTimeCompet2 := NumTimeCompet2;
end;
function TTemporada.GetNumTimePORebaixamento: Integer;
begin
GetNumTimePORebaixamento := NumTimePORebaixamento;
end;
function TTemporada.GetNumTimeRebaixado: Integer;
begin
GetNumTimeRebaixado := NumTimeRebaixado;
end;
function TTemporada.GetSQLDesempate: String;
var
Texto: String;
i: Integer;
begin
Texto := '';
for i:=1 to Length(SQLDesempate) do begin
if SQLDesempate[i] = '1' then begin
Texto := Texto + '8 DESC';
end else begin
end else begin
end else begin
Texto := Texto + '6 DESC'; // Corrigir: Gols na casa do adversario
end;
end;
end;
end;
if i <> 4 then begin
Texto := Texto + ', ';
end;
end;
GetSQLDesempate := Texto;
end;
function TTemporada.GetPontosVitoria: Integer;
begin
GetPontosVitoria := PontosVitoria;
end;
end.
========================================================================================
====
ARQUIVO: UPunicao.pas
========================================================================================
====
unit UPunicao;
interface
Uses
112
UDMDados, SysUtils, UMeuUtils, UDMClasses,

Borland.Vcl.Classes, UEstruturaTemporada, UEquipe, UClassificacao;
type
TPunicao = class
protected
conBD: TDtMdlDados;
BD: TDtMdlClasses;
MeusUtils: TMeusUtils;
CodPunicao: Integer;
Equipe: TEquipe;
DataPunicao: TDateTime;
Classificacao: TClassificacao;
Pontos: Integer;
Motivo: String;
public
constructor Create; overload;
function GetCodPunicao : Integer;
Destructor Destroy; override;
procedure NovaPunicao(EstTemp: TEstruturaTemporada; umaEquipe: TEquipe; umaData:
TDateTime; osPontos: Integer; umMotivo: String);
procedure AlterarPunicao(EstTemp: TEstruturaTemporada; umaEquipe: TEquipe; umaData:
TDateTime; osPontos: Integer; umMotivo: String);
procedure ExcluirPunicao;
end;
implementation
constructor TPunicao.Create;
begin
inherited;
MeusUtils := TMeusUtils.Create;
end;
procedure TPunicao.SetBD (var umaConBD: TDtMdlDados);
begin
conBD := umaConBD;
end;
procedure TPunicao.Materializar (Cod: Integer);
begin
BD.SQLDtStDados.CommandText := 'SELECT * FROM PUNICAO WHERE CODPUNICAO=' +
IntToStr(Cod);
Close;
Open;
First;
CodPunicao := FieldByName('CodPunicao').asInteger;
EstruturaTemporada.Materializar(FieldByName('CodEstruturaTemporada').asInteger);
Equipe.Materializar(FieldByName('CodEquipe').asInteger);
DataPunicao := FieldByName('Data').asDateTime;
Classificacao := TClassificacao.Create; Classificacao.SetBD(ConBD);
Classificacao.Materializar (FieldByName('CodClassificacao').asInteger);
Pontos := FieldByName('Pontos').asInteger;
Motivo := FieldByName('Motivo').asString;
end;
end;
procedure TPunicao.NovaPunicao(EstTemp: TEstruturaTemporada; umaEquipe: TEquipe;
umaData: TDateTime; osPontos: Integer; umMotivo: String);
var
SQL: String;
begin
EstruturaTemporada := EstTemp;
Equipe := umaEquipe;
DataPunicao := umaData;
Pontos := osPontos;
Motivo := umMotivo;
Classificacao := TClassificacao.Create; Classificacao.SetBD(ConBD);
113
Classificacao.NovaClassificacaoPunicao(EstruturaTemporada.GetCodEstruturaTemporada,
DataPunicao, Equipe, Pontos);
Close;
Open;
First;
CodPunicao := FieldByName('OID').asInteger;
end;
SQL := 'Insert into PUNICAO (CODPUNICAO, CODESTRUTURATEMPORADA, CODEQUIPE,
CODCLASSIFICACAO, PONTOS, MOTIVO, DATA) values (';
SQL := SQL + IntToStr(CodPunicao) + ', ';
SQL := SQL + IntToStr(EstruturaTemporada.GetCodEstruturaTemporada) + ', ';
SQL := SQL + IntToStr(Classificacao.GetCodClassificacao) + ', ';
SQL := SQL + IntToStr(Pontos) + ', ';
SQL := SQL + '''' + Motivo + ''', ';
SQL := SQL + '''' + MeusUtils.DataParaBD (DataPunicao) + ''')';
end;
procedure TPunicao.AlterarPunicao(EstTemp: TEstruturaTemporada; umaEquipe: TEquipe;
umaData: TDateTime; osPontos: Integer; umMotivo: String);
var
SQL: String;
begin
EstruturaTemporada := EstTemp;
Pontos := osPontos;
Motivo := umMotivo;
Classificacao.AlterarClassificacaoPunicao(EstruturaTemporada.GetCodEstruturaTemporada,
DataPunicao, Equipe, Pontos);
SQL := 'Update PUNICAO set ';
SQL := SQL + 'CODESTRUTURATEMPORADA=' +
IntToStr(EstruturaTemporada.GetCodEstruturaTemporada) + ', ';
SQL := SQL + 'CODEQUIPE=' + IntToStr(Equipe.GetCodEquipe) + ', ';
SQL := SQL + 'CODCLASSIFICACAO=' + IntToStr(Classificacao.GetCodClassificacao) + ', ';
SQL := SQL + 'PONTOS=' + IntToStr(Pontos) + ', ';
SQL := SQL + 'MOTIVO=''' + Motivo + ''', ';
SQL := SQL + 'DATA=''' + MeusUtils.DataParaBD(DataPunicao) + ''' ';
SQL := SQL + 'where CODPUNICAO=' + IntToStr(CodPunicao);
end;
procedure TPunicao.ExcluirPunicao;
var
SQL: String;
begin
Classificacao.ExcluirClassificacao;
SQL := 'Delete from PUNICAO where CODPUNICAO=' + IntToStr(CodPunicao);
end;
function TPunicao.GetCodPunicao : Integer;
begin
GetCodPunicao := CodPunicao;
end;
destructor TPunicao.Destroy;
begin
BD.Destroy;
Classificacao.Destroy;
Equipe.Destroy;
end;
end.
========================================================================================
====
114
ARQUIVO: UMeuUtils.pas
========================================================================================
====
unit UMeuUtils;
interface
Uses
SysUtils, Borland.Vcl.Controls, Borland.Vcl.IniFiles;
type
TMeusUtils = class
private
protected
posicao: Integer;
public
function GeraPosicao: String;
function DiaDaSemana (aData : TDate) : string;
function DataParaBD (aData : TDateTime) : String;
function DataHoraParaBD (aData : TDateTime) : String;
function CalcAnos(DataOrigem: TDateTime): integer;
procedure GravaIni (NomeArq: String);
end;
implementation
constructor TMeusUtils.Create;
begin
inherited;
Posicao := 0;
end;
function TMeusUtils.GeraPosicao: String;
begin
Posicao := Posicao + 1;
GeraPosicao := IntToStr(Posicao) + '';
end;
function TMeusUtils.DiaDaSemana (aData :TDate) : string;
var
Dia: Integer;
begin
Dia := DayOfWeek (int(aData));
case Dia of
1 : DiaDaSemana := 'DOM';
2 : DiaDaSemana := 'SEG';
3 : DiaDaSemana := 'TER';
4 : DiaDaSemana := 'QUA';
5 : DiaDaSemana := 'QUI';
6 : DiaDaSemana := 'SEX';
7 : DiaDaSemana := 'SAB';
end;
end;
function TMeusUtils.DataParaBD (aData : TDateTime) : String;
var
Dia, Mes, Ano : String;
begin
DateTimeToString(Dia, 'dd', aData);
DateTimeToString(Mes, 'mmm', aData);
DateTimeToString(Ano, 'yyyy', aData);
if Mes = 'fev' then Mes := 'FEB';
if Mes = 'abr' then Mes := 'APR';
if Mes = 'mai' then Mes := 'MAY';
if Mes = 'ago' then Mes := 'AUG';
if Mes = 'set' then Mes := 'SEP';
if Mes = 'out' then Mes := 'OCT';
if Mes = 'dez' then Mes := 'DEC';
DataParaBD := Dia + '-' + Mes + '-' + Ano;
end;
function TMeusUtils.DataHoraParaBD (aData : TDateTime) : String;
var
Dia, Mes, Ano, Hora, Minuto : String;
115
begin
DateTimeToString(Dia, 'dd', aData);
DateTimeToString(Mes, 'mmm', aData);
DateTimeToString(Ano, 'yyyy', aData);
DateTimeToString(Hora, 'hh', aData);
DateTimeToString(Minuto, 'nn', aData);
if Mes = 'fev' then Mes := 'FEB';
if Mes = 'abr' then Mes := 'APR';
if Mes = 'mai' then Mes := 'MAY';
if Mes = 'ago' then Mes := 'AUG';
if Mes = 'set' then Mes := 'SEP';
if Mes = 'out' then Mes := 'OCT';
if Mes = 'dez' then Mes := 'DEC';
DataHoraParaBD := Dia + '-' + Mes + '-' + Ano + ' ' + Hora + ':' + Minuto + ':00';
end;
function TMeusUtils.CalcAnos(DataOrigem: TDateTime): integer;
var
D1, M1, A1,
D2, M2, A2: Word;
begin
DecodeDate(DataOrigem, A1, M1, D1);
DecodeDate(Date, A2, M2, D2);
Result := A2 - A1;
if (M1 > M2) or ((M1 = M2) and (D1 > D2)) then Dec(Result);
end;
procedure TMeusUtils.GravaIni (NomeArq: String);
var
ArqIni : TIniFile;
begin
if not FileExists (NomeArq) then begin
ArqIni := TIniFile.Create(NomeArq);
Try
ArqIni.WriteString('CadJogo', 'Data', DateToStr(Date));
ArqIni.WriteString('CadJogo', 'Hora', TimeToStr(Time));
ArqIni.WriteInteger('Temporada', 'Atual', 0);
Finally
ArqIni.Free;
end;
end;
end;
end.
========================================================================================
====
ARQUIVO: ULanceJogo.pas
========================================================================================
====
unit ULanceJogo;
interface
Uses
UDMDados, SysUtils, Borland.Vcl.Classes, Borland.Vcl.DBXpress, UMeuUtils,
Borland.Vcl.Db, UDMClasses, UJogador, UEquipe;
type
TLanceJogo = class
protected
conBD: TDtMdlDados;
BD: TDtMdlClasses;
MeusUtils : TMeusUtils;
CodLancePartida: Integer;
CodJogo: Integer;
EquipeLance: TEquipe;
EquipeJogador: TEquipe;
Jogador: TJogador;
TipoLance: Integer; // 1:Gol; 2:GolPenalti; 3:GolContra; 4:Amarelo; 5-AmaVer;
5:Vermelho.
Minuto: Integer;
public
constructor Create; Overload;
procedure Materializar (umCod: Integer);
116
function GetCodLancePartida : Integer;

procedure NovoLancePartida (umCodJogo: Integer; umaEquipeLance, umaEquipeJogador:
TEquipe; CodJogador, umTipoLance, oMinuto: Integer);
procedure ExcluirLancePartida;
function GetTipoLance : Integer;
function GetCodEquipeLance : Integer;
end;
implementation
constructor TLanceJogo.Create;
begin
inherited;
end;
procedure TLanceJogo.SetBD (var umaConBD: TDtMdlDados);
begin
conBD := umaConBD;
end;
procedure TLanceJogo.Materializar (umCod: Integer);
begin
BD.SQLDtStDados.CommandText := 'SELECT * FROM LANCEPARTIDA WHERE CODLANCEPARTIDA=' +
IntToStr(umCod);
Close;
Open;
First;
CodLancePartida := FieldByName('CodLancePartida').asInteger;
CodJogo := FieldByName('CodJogo').asInteger;
EquipeLance := TEquipe.Create; EquipeLance.SetBD(ConBD);
EquipeLance.Materializar(FieldByName('CodEquipeLance').asInteger);
EquipeJogador := TEquipe.Create; EquipeJogador.SetBD(ConBD);
EquipeJogador.Materializar(FieldByName('CodEquipeJogador').asInteger);
Jogador := EquipeJogador.GetJogador(FieldByName('CodJogador').asInteger);
TipoLance := FieldByName('TipoLance').asInteger;
Minuto := FieldByName('Minuto').asInteger;
end;
end;
procedure TLanceJogo.NovoLancePartida (umCodJogo: Integer; umaEquipeLance,
umaEquipeJogador: TEquipe; CodJogador, umTipoLance, oMinuto: Integer);
var
SQL: String;
begin
Close;
Open;
First;
CodLancePartida := FieldByName('OID').asInteger;
end;
CodJogo := umCodJogo;
EquipeLance := umaEquipeLance;
EquipeJogador := umaEquipeJogador;
Jogador := EquipeJogador.GetJogador(CodJogador);
TipoLance := umTipoLance;
Minuto := oMinuto;
SQL := 'Insert into LANCEPARTIDA (CODLANCEPARTIDA, CODJOGO, CODEQUIPELANCE,
CODEQUIPEJOGADOR, CODJOGADOR, TIPOLANCE, MINUTO) VALUES (';
SQL := SQL + IntToStr(CodLancePartida) + ', ';
SQL := SQL + IntToStr(CodJogo) + ', ';
SQL := SQL + IntToStr(EquipeLance.GetCodEquipe) + ', ';
SQL := SQL + IntToStr(EquipeJogador.GetCodEquipe) + ', ';
SQL := SQL + IntToStr(Jogador.GetCodJogador) + ', ';
SQL := SQL + IntToStr(TipoLance) + ', ';
SQL := SQL + IntToStr(Minuto) + ')';
end;
117
procedure TLanceJogo.ExcluirLancePartida;
var
SQL: String;
begin
BD.SQLDtStDados.CommandText := 'Delete from LANCEPARTIDA where CODLANCEPARTIDA=' +
IntToStr(CodLancePartida);
end;
function TLanceJogo.GetCodLancePartida : Integer;
begin
GetCodLancePartida := CodLancePartida;
end;
destructor TLanceJogo.Destroy;
begin
BD.Destroy;
MeusUtils.Free;
EquipeLance.Destroy;
EquipeJogador.Destroy;
Jogador.Destroy;
end;
function TLanceJogo.GetTipoLance : Integer;
begin
GetTipoLance := TipoLance;
end;
function TLanceJogo.GetCodEquipeLance : Integer;
begin
GetCodEquipeLance := EquipeLance.GetCodEquipe;
end;
end.
========================================================================================
====
ARQUIVO: UJogo.pas
========================================================================================
====
unit UJogo;
interface
Uses
UDMDados, SysUtils, UEquipe, UArbitro, UEstadio, Borland.Vcl.Classes,
UClassificacao, Borland.Vcl.DBXpress, UMeuUtils, Borland.Vcl.Db,
UDMClasses, UItemEscalacao, ULanceJogo, UJogador;
type
TJogo = class
protected
conBD: TDtMdlDados;
BD: TDtMdlClasses;
CodJogo: Integer;
CodEstruturaTemporada: Integer;
EquipeCasa: TEquipe;
EquipeFora: TEquipe;
DataHoraJogo: TDateTime;
Arbitro: TArbitro;
TV: String;
Estadio: TEstadio;
NomeEstadio: String;
GolsTimeCasa: Integer;
GolsTimeFora: Integer;
GolsTimeCasaPriTem: Integer;
GolsTimeForaPriTem: Integer;
Realizado: Integer;
Prorrogacao: Integer;
Penaltis: Integer;
GolsTimeCasaProrrogacao: Integer;
GolsTimeForaProrrogacao: Integer;
GolsTimeCasaPenaltis: Integer;
GolsTimeForaPenaltis: Integer;
Publico: Integer;
118
Noticia: String;
EstatChuteCasa: Integer;
EstatChuteFora: Integer;
EstatFaltaCasa: Integer;
EstatFaltaFora: Integer;
EstatEscanteioCasa: Integer;
EstatEscanteioFora: Integer;
EstatImpedimentoCasa: Integer;
EstatImpedimentoFora: Integer;
//Variveis da Classificacao
ClassificacaoTimeCasa: TClassificacao;
ClassificacaoTimeFora: TClassificacao;
// Variveis da Escalacao
NumTitTC, NumTitTF, NumSubstTC, NumSubstTF: Integer;
EscalacaoTC : Array [1..14] of TItemEscalacao;
EscalacaoTF : Array [1..14] of TItemEscalacao;
// Variveis LanceJogo
LancesJogo: Array [1..50] of TLanceJogo;
NumLancesJogo: Integer;
NumLancesGolsTC, NumLancesGolsTF: Integer;
public
function NovoJogo (codEstTemp: Integer; var umTimeCasa, umTimeFora: TEquipe;
umaDataHoraJogo: TDateTime;
var umArbitro: TArbitro; var umEstadio: TEstadio; umRealizado,
osGolsTimeCasa, osGolsTimeFora,
umProrrogacao, osGolsTimeCasaProrrog, osGolsTimeForaProrrog,
umPenaltis, osGolsTimeCasaPen,
osGolsTimeForaPen, umPublico, osChutesTimeCasa, osChutesTimeFora,
osImpedTimeCasa,
osImpedTimeFora, osFaltasTimeCasa, osFaltasTimeFora,
osEscanteiosTimeCasa,
osEscanteiosTimeFora: Integer; umaNoticia, umaTV: String; var
Foto1, Foto2: TMemoryStream;
PtsVit, PtsEmp, PtsVitProrrog, PtsEmpProrrog, PtsDerProrrog,
PtsVitPen, PtsDerPen: Integer) : boolean;
function AlterarJogo (codEstTemp: Integer; var umTimeCasa, umTimeFora: TEquipe;
osImpedTimeCasa,
function ExcluirJogo : Boolean;
function PossuiEventos : Boolean;
procedure CalcularJogo (codEstTemp: Integer; var umTimeCasa, umTimeFora: TEquipe;
osImpedTimeCasa,
osEscanteiosTimeFora: Integer; umaNoticia, umaTV: String;
PtsVitPen, PtsDerPen: Integer);
// Mtodos de Escalacao
procedure MaterializarEscalacao;
procedure EscalarJogador (umCodEquipe, umCodJogador, TempoJogado: Integer);
procedure RemoverEscalacaoJogador (umCodEquipe, umCodJogador: Integer);
procedure PromoverSubst (umCodEquipe, CodJogadorSaiu, TempoJogadoSaiu,
CodJogadorEntrou, TempoJogadoEntrou, MinutoSubst: Integer);
procedure RemoverSubstituicao (umCodEquipe, CodJogadorSaiu, CodJogadorEntrou,
TempoJogado: Integer);
//Mtodos LancePartida
119
procedure IncluirLancePartida (umCodEquipeLance, umCodEquipeJogador, CodJogador,

TipoLance, Minuto: Integer);
procedure ExcluirLancePartida (umCodLance: Integer);
procedure MaterializarLancesJogo;
function
function
function
function
function
function
GetNumLancesGolsTC: Integer;
GetGolsTimeCasa: Integer;
GetGolsTimeFora: Integer;
GetNumLancesGolsTF: Integer;
GetGolsTimeCasaProrrogacao: Integer;
GetGolsTimeForaProrrogacao: Integer;
destructor Destroy; override;

end;
implementation
constructor TJogo.Create;
begin
inherited;
end;
procedure TJogo.SetBD (var umaConBD: TDtMdlDados);
begin
conBD := umaConBD;
BD.SetConexaoBD (conBD);
ClassificacaoTimeCasa := TClassificacao.create; ClassificacaoTimeCasa.SetBD(ConBD);
ClassificacaoTimeFora := TClassificacao.create; ClassificacaoTimeFora.SetBD(ConBD);
end;
procedure TJogo.Materializar (Cod: Integer);
begin
BD.SQLDtStDados.CommandText := 'SELECT * FROM JOGO WHERE CODJOGO = ' + IntToStr(Cod);
Close;
Open;
First;
CodEstruturaTemporada := FieldByName('CodEstruturaTemporada').asInteger;
EquipeCasa.Materializar(FieldByName('CodEquipeCasa').asInteger);
EquipeFora := TEquipe.Create; EquipeFora.SetBD(ConBD);
EquipeFora.Materializar(FieldByName('CodEquipeFora').asInteger);
DataHoraJogo := FieldByName('DataHoraJogo').asDateTime;
Arbitro.Materializar(FieldByName('CodArbitro').asInteger);
TV := FieldByName('TV').asString;
Estadio.Materializar(FieldByName('CodEstadio').asInteger);
NomeEstadio := FieldByName('NomeEstadio').asString;
GolsTimeCasa := FieldByName('GolsTimeCasa').asInteger;
GolsTimeFora := FieldByName('GolsTimeFora').asInteger;
GolsTimeCasaPriTem := FieldByName('GolsTimeCasaPriTem').asInteger;
GolsTimeForaPriTem := FieldByName('GolsTimeForaPriTem').asInteger;
Realizado := FieldByName('Realizado').asInteger;
Prorrogacao := FieldByname('Prorrogacao').asInteger;
Penaltis := FieldByname('Penaltis').asInteger;
GolsTimeCasaProrrogacao := FieldByname('GolsTimeCasaProrrogacao').asInteger;
GolsTimeForaProrrogacao := FieldByname('GolsTimeForaProrrogacao').asInteger;
GolsTimeCasaPenaltis := FieldByname('GolsTimeCasaPenaltis').asInteger;
GolsTimeForaPenaltis := FieldByname('GolsTimeForaPenaltis').asInteger;
Publico := FieldByname('Publico').asInteger;
Noticia := FieldByname('Noticia').asString;
EstatChuteCasa := FieldByname('EstatChuteCasa').asInteger;
EstatChuteFora := FieldByname('EstatChuteFora').asInteger;
EstatFaltaCasa := FieldByname('EstatFaltaCasa').asInteger;
EstatFaltaFora := FieldByname('EstatFaltaFora').asInteger;
EstatEscanteioCasa := FieldByname('EstatEscanteioCasa').asInteger;
EstatEscanteioFora := FieldByname('EstatEscanteioFora').asInteger;
EstatImpedimentoCasa := FieldByname('EstatImpedimentoCasa').asInteger;
EstatImpedimentoFora := FieldByname('EstatImpedimentoFora').asInteger;
ClassificacaoTimeCasa.Materializar
(FieldByname('CodClassificacaoTimeCasa').asInteger);
ClassificacaoTimeFora.Materializar
(FieldByname('CodClassificacaoTimeFora').asInteger);
120
end;
Self.MaterializarEscalacao;
Self.MaterializarLancesJogo;
end;
procedure TJogo.MaterializarEscalacao;
var
SQL: String;
umItemEscalacao: TItemEscalacao;
begin
NumTitTC := 0;
NumSubstTC := 0;
BD.SQLDtStDados.CommandText := 'SELECT * FROM ESCALACAOJOGO WHERE CODJOGO=' +
IntToStr(CodJogo) + ' AND CODEQUIPE=' + IntToStr(EquipeCasa.GetCodEquipe);
Close;
Open;
First;
while not eof do begin
umItemEscalacao := TItemEscalacao.Create; umItemEscalacao.SetBD(ConBD);
umItemEscalacao.Materializar (CodJogo, FieldByName('CodJogador').asInteger,
EquipeCasa.GetCodEquipe);
if FieldByName('Status').asString = 'T' then begin
NumTitTC := NumTitTC + 1;
end else begin
NumSubstTC := NumSubstTC + 1;
end;
EscalacaoTC[NumTitTC+NumSubstTC] := umItemEscalacao;
Next;
end;
end;
NumTitTF := 0;
NumSubstTF := 0;
IntToStr(CodJogo) + ' AND CODEQUIPE=' + IntToStr(EquipeFora.GetCodEquipe);
Close;
Open;
First;
umItemEscalacao.Materializar (CodJogo, FieldByName('CodJogador').asInteger,
EquipeFora.GetCodEquipe);
if FieldByName('Status').asString = 'T' then begin
NumTitTF := NumTitTF + 1;
end else begin
NumSubstTF := NumSubstTF + 1;
end;
EscalacaoTF[NumTitTF+NumSubstTF] := umItemEscalacao;
Next;
end;
end;
end;
procedure TJogo.MaterializarLancesJogo;
var
SQL: String;
umLanceJogo: TLanceJogo;
begin
NumLancesJogo := 0;
NumLancesGolsTC := 0;
NumLancesGolsTF := 0;
SQL := 'Select COUNT(*) from LANCEPARTIDA where ((CODEQUIPELANCE=' +
IntToStr(EquipeCasa.GetCodEquipe) + ') and ';
SQL := SQL + '((TIPOLANCE=1) or (TIPOLANCE=2) or (TIPOLANCE=3))) and CodJogo=' +
IntToStr(CodJogo);
Close;
Open;
First;
NumLancesGolsTC := FieldByName('COUNT').asInteger;
end;
SQL := 'Select COUNT(*) from LANCEPARTIDA where ((CODEQUIPELANCE=' +
IntToStr(EquipeFora.GetCodEquipe) + ') and ';
SQL := SQL + '((TIPOLANCE=1) or (TIPOLANCE=2) or (TIPOLANCE=3))) and CodJogo=' +
IntToStr(CodJogo);;
121
Close;
Open;
First;
NumLancesGolsTF := FieldByName('COUNT').asInteger;
end;
SQL := 'Select * from LANCEPARTIDA where CODJOGO=' + IntToStr(CodJogo);
Close;
Open;
First;
umLanceJogo := TLanceJogo.Create; umLanceJogo.SetBD(ConBD);
umLanceJogo.Materializar(FieldByName('CodLancePartida').asInteger);
NumLancesJogo := NumLancesJogo + 1;
LancesJogo[NumLancesJogo] := umLanceJogo;
Next;
end;
end;
end;
function TJogo.NovoJogo (codEstTemp: Integer; var umTimeCasa, umTimeFora: TEquipe;
osGolsTimeForaPen, umPublico, osChutesTimeCasa,
osChutesTimeFora, osImpedTimeCasa,
var
SQL: String;
begin
Self.CalcularJogo (codEstTemp, umTimeCasa, umTimeFora, umaDataHoraJogo, umArbitro,
umEstadio, umRealizado,
osGolsTimeCasa, osGolsTimeFora, umProrrogacao,
osGolsTimeCasaProrrog,
osGolsTimeForaProrrog, umPenaltis, osGolsTimeCasaPen,
osGolsTimeForaPen, umPublico,
osChutesTimeCasa, osChutesTimeFora, osImpedTimeCasa,
osImpedTimeFora, osFaltasTimeCasa,
osFaltasTimeFora, osEscanteiosTimeCasa, osEscanteiosTimeFora,
umaNoticia, umaTV,
PtsVitPen, PtsDerPen);
Close;
Open;
First;
CodJogo := FieldByName('OID').asInteger;
end;
ClassificacaoTimeCasa := TClassificacao.create; ClassificacaoTimeCasa.SetBD(ConBD);
ClassificacaoTimeFora := TClassificacao.create; ClassificacaoTimeFora.SetBD(ConBD);
ClassificacaoTimeCasa.NovaClassificacao (CodEstTemp, umaDataHoraJogo, EquipeCasa,
umRealizado,
osGolsTimeForaPen,
umPublico, 'C', PtsVit, PtsEmp, PtsVitProrrog, PtsEmpProrrog,
PtsDerProrrog,
ClassificacaoTimeFora.NovaClassificacao (CodEstTemp, umaDataHoraJogo, EquipeFora,
umRealizado,
osGolsTimeFora, osGolsTimeCasa, umProrrogacao,
osGolsTimeForaProrrog,
122
osGolsTimeCasaProrrog, umPenaltis, osGolsTimeForaPen,

osGolsTimeCasaPen,
umPublico, 'F', PtsVit, PtsEmp, PtsVitProrrog, PtsEmpProrrog,
PtsDerProrrog,
SQL := 'INSERT INTO JOGO (CODJOGO, CODESTRUTURATEMPORADA, CODEQUIPECASA,
CODEQUIPEFORA, DATAHORAJOGO, CODARBITRO, ';
SQL := SQL + 'TV, NOMEESTADIO, CODESTADIO, GOLSTIMECASA, GOLSTIMEFORA,
GOLSTIMECASAPRITEM, GOLSTIMEFORAPRITEM, ';
SQL := SQL + 'PRORROGACAO, PENALTIS, GOLSTIMECASAPRORROGACAO, GOLSTIMEFORAPRORROGACAO,
GOLSTIMECASAPENALTIS, ';
SQL := SQL + 'GOLSTIMEFORAPENALTIS, PUBLICO, NOTICIA, REALIZADO, ESTATCHUTECASA,
ESTATCHUTEFORA, ESTATFALTACASA, ';
SQL := SQL + 'ESTATFALTAFORA, ESTATESCANTEIOCASA, ESTATESCANTEIOFORA,
ESTATIMPEDIMENTOCASA, ESTATIMPEDIMENTOFORA, ';
SQL := SQL + 'CODCLASSIFICACAOTIMECASA, CODCLASSIFICACAOTIMEFORA, FOTO1, FOTO2) VALUES
(';
SQL := SQL + IntToStr(CodEstruturaTemporada) + ', ';
SQL := SQL + IntToStr(EquipeCasa.GetCodEquipe) + ', ';
SQL := SQL + IntToStr(EquipeFora.GetCodEquipe) + ', ';
SQL := SQL + '''' + MeusUtils.DataHoraParaBD (DataHoraJogo) + ''', ';
SQL := SQL + IntToStr(Arbitro.GetCodArbitro) + ', ';
SQL := SQL + '''' + TV + ''', ';
SQL := SQL + '''' + NomeEstadio + ''', ';
SQL := SQL + IntToStr(Estadio.GetCodEstadio) + ', ';
SQL := SQL + IntToStr(GolsTimeCasa) + ', ';
SQL := SQL + IntToStr(GolsTimeFora) + ', ';
SQL := SQL + IntToStr(GolsTimeCasaPriTem) + ', ';
SQL := SQL + IntToStr(GolsTimeForaPriTem) + ', ';
SQL := SQL + IntToStr(Prorrogacao) + ', ';
SQL := SQL + IntToStr(Penaltis) + ', ';
SQL := SQL + IntToStr(GolsTimeCasaProrrogacao) + ', ';
SQL := SQL + IntToStr(GolsTimeForaProrrogacao) + ', ';
SQL := SQL + IntToStr(GolsTimeCasaPenaltis) + ', ';
SQL := SQL + IntToStr(GolsTimeForaPenaltis) + ', ';
SQL := SQL + IntToStr(Publico) + ', ';
SQL := SQL + ':Noticia, ';
SQL := SQL + IntToStr(Realizado) + ', ';
SQL := SQL + IntToStr(EstatChuteCasa) + ', ';
SQL := SQL + IntToStr(EstatChuteFora) + ', ';
SQL := SQL + IntToStr(EstatFaltaCasa) + ', ';
SQL := SQL + IntToStr(EstatFaltaFora) + ', ';
SQL := SQL + IntToStr(EstatEscanteioCasa) + ', ';
SQL := SQL + IntToStr(EstatEscanteioFora) + ', ';
SQL := SQL + IntToStr(EstatImpedimentoCasa) + ', ';
SQL := SQL + IntToStr(EstatImpedimentoFora) + ', ';
SQL := SQL + IntToStr(ClassificacaoTimeCasa.GetCodClassificacao) + ', ';
SQL := SQL + IntToStr(ClassificacaoTimeFora.GetCodClassificacao) + ',';
SQL := SQL + ':Foto1, :Foto2);';
BD.SQLDtStDados.ParamByName('Noticia').asMemo := Noticia;
BD.SQLDtStDados.ParamByName('Foto1').LoadFromStream(Foto1,ftBlob);
Foto1.Free;
Foto2.Free;
end;
function TJogo.ExcluirJogo : Boolean;
var
i,k : Integer;
SQL: String;
begin
ClassificacaoTimeCasa.ExcluirClassificacao;
ClassificacaoTimeFora.ExcluirClassificacao;
for i := 1 to NumLancesJogo do begin
LancesJogo[i].ExcluirLancePartida;
end;
k := NumTitTC + NumSubstTC;
for i := 1 to k do begin
EscalacaoTC[i].RemoverEscalacao;
end;
k := NumTitTF + NumSubstTF;
for i := 1 to k do begin
EscalacaoTF[i].RemoverEscalacao;
end;
123
SQL := 'Delete from JOGO where CODJOGO=' + IntToStr(CodJogo);

end;
function TJogo.PossuiEventos : Boolean;
begin
if ((NumLancesJogo>0) or (NumTitTC>0) or (NumTitTF>0)) then begin
PossuiEventos := True;
end else begin
PossuiEventos := False;
end;
end;
procedure TJogo.CalcularJogo (codEstTemp: Integer; var umTimeCasa, umTimeFora: TEquipe;
osGolsTimeForaPen, umPublico, osChutesTimeCasa,
osChutesTimeFora, osImpedTimeCasa,
osEscanteiosTimeFora: Integer; umaNoticia, umaTV: String;
begin
CodEstruturaTemporada := codEstTemp;
EquipeCasa := umTimeCasa;
EquipeFora := umTimeFora;
DataHoraJogo := umaDataHoraJogo;
Arbitro := umArbitro;
TV := umaTV;
Estadio := umEstadio;
NomeEstadio := '';
GolsTimeCasa := osGolsTimeCasa;
GolsTimeFora := osGolsTimeFora;
GolsTimeCasaPriTem := 0;
GolsTimeForaPriTem := 0;
Realizado := umRealizado;
Prorrogacao := umProrrogacao;
Penaltis := umPenaltis;
GolsTimeCasaProrrogacao := osGolsTimeCasaProrrog;
GolsTimeForaProrrogacao := osGolsTimeForaProrrog;
GolsTimeCasaPenaltis := osGolsTimeCasaPen;
GolsTimeForaPenaltis := osGolsTimeForaPen;
Publico := umPublico;
Noticia := umaNoticia;
EstatChuteCasa := osChutesTimeCasa;
EstatChuteFora := osChutesTimeFora;
EstatFaltaCasa := osFaltasTimeCasa;
EstatFaltaFora := osFaltasTimeFora;
EstatEscanteioCasa := osEscanteiosTimeCasa;
EstatEscanteioFora := osEscanteiosTimeFora;
EstatImpedimentoCasa := osImpedTimeCasa;
EstatImpedimentoFora := osImpedTimeFora;
end;
function TJogo.AlterarJogo (codEstTemp: Integer; var umTimeCasa, umTimeFora: TEquipe;
osImpedTimeCasa,
var
SQL: String;
begin
124
Self.CalcularJogo (codEstTemp, umTimeCasa, umTimeFora, umaDataHoraJogo, umArbitro,

umEstadio, umRealizado,
osGolsTimeForaPen, umPublico,
osChutesTimeCasa, osChutesTimeFora, osImpedTimeCasa,
osImpedTimeFora, osFaltasTimeCasa,
osFaltasTimeFora, osEscanteiosTimeCasa, osEscanteiosTimeFora,
umaNoticia, umaTV, PtsVit,
PtsEmp, PtsVitProrrog, PtsEmpProrrog, PtsDerProrrog, PtsVitPen,
PtsDerPen);
ClassificacaoTimeCasa.AlterarClassificacao (CodEstTemp, umaDataHoraJogo, EquipeCasa,
umRealizado,
osGolsTimeForaPen,
umPublico, 'C', PtsVit, PtsEmp, PtsVitProrrog, PtsEmpProrrog,
PtsDerProrrog,
ClassificacaoTimeFora.AlterarClassificacao (CodEstTemp, umaDataHoraJogo, EquipeFora,
umRealizado,
osGolsTimeFora, osGolsTimeCasa, umProrrogacao,
osGolsTimeForaProrrog,
osGolsTimeCasaProrrog, umPenaltis, osGolsTimeForaPen,
osGolsTimeCasaPen,
umPublico, 'F', PtsVit, PtsEmp, PtsVitProrrog, PtsEmpProrrog,
PtsDerProrrog,
SQL := 'UPDATE JOGO SET ';
SQL := SQL + 'CodEstruturaTemporada = ' + IntToStr(CodEstruturaTemporada) + ', ';
SQL := SQL + 'CodEquipeCasa = ' + IntToStr(EquipeCasa.GetCodEquipe) + ', ';
SQL := SQL + 'CodEquipeFora = ' + IntToStr(EquipeFora.GetCodEquipe) + ', ';
SQL := SQL + 'DataHoraJogo = ''' + MeusUtils.DataHoraParaBD (DataHoraJogo) + ''', ';
SQL := SQL + 'CodArbitro = ' + IntToStr(Arbitro.GetCodArbitro) + ', ';
SQL := SQL + 'TV = ''' + TV + ''', ';
SQL := SQL + 'NomeEstadio = ''' + NomeEstadio + ''', ';
SQL := SQL + 'CodEstadio = ' + IntToStr(Estadio.GetCodEstadio) + ', ';
SQL := SQL + 'GolsTimeCasa = ' + IntToStr(GolsTimeCasa) + ', ';
SQL := SQL + 'GolsTimeFora = ' + IntToStr(GolsTimeFora) + ', ';
SQL := SQL + 'GolsTimeCasaPriTem = ' + IntToStr(GolsTimeCasaPriTem) + ', ';
SQL := SQL + 'GolsTimeForaPriTem = ' + IntToStr(GolsTimeForaPriTem) + ', ';
SQL := SQL + 'Prorrogacao = ' + IntToStr(Prorrogacao) + ', ';
SQL := SQL + 'Penaltis = ' + IntToStr(Penaltis) + ', ';
SQL := SQL + 'GolsTimeCasaProrrogacao = ' + IntToStr(GolsTimeCasaProrrogacao) + ', ';
SQL := SQL + 'GolsTimeForaProrrogacao = ' + IntToStr(GolsTimeForaProrrogacao) + ', ';
SQL := SQL + 'GolsTimeCasaPenaltis = ' + IntToStr(GolsTimeCasaPenaltis) + ', ';
SQL := SQL + 'GolsTimeForaPenaltis = ' + IntToStr(GolsTimeForaPenaltis) + ', ';
SQL := SQL + 'Publico = ' + IntToStr(Publico) + ', ';
SQL := SQL + 'Noticia = :Noticia, ';
SQL := SQL + 'Realizado = ' + IntToStr(Realizado) + ', ';
SQL := SQL + 'EstatChuteCasa = ' + IntToStr(EstatChuteCasa) + ', ';
SQL := SQL + 'EstatChuteFora = ' + IntToStr(EstatChuteFora) + ', ';
SQL := SQL + 'EstatFaltaCasa = ' + IntToStr(EstatFaltaCasa) + ', ';
SQL := SQL + 'EstatFaltaFora = ' + IntToStr(EstatFaltaFora) + ', ';
SQL := SQL + 'EstatEscanteioCasa = ' + IntToStr(EstatEscanteioCasa) + ', ';
SQL := SQL + 'EstatEscanteioFora = ' + IntToStr(EstatEscanteioFora) + ', ';
SQL := SQL + 'EstatImpedimentoCasa = ' + IntToStr(EstatImpedimentoCasa) + ', ';
SQL := SQL + 'EstatImpedimentoFora = ' + IntToStr(EstatImpedimentoFora) + ', ';
SQL := SQL + 'CodClassificacaoTimeCasa = ' +
IntToStr(ClassificacaoTimeCasa.GetCodClassificacao) + ', ';
SQL := SQL + 'CodClassificacaoTimeFora = ' +
IntToStr(ClassificacaoTimeFora.GetCodClassificacao) + ', ';
SQL := SQL + 'Foto1 = :Foto1, Foto2 = :Foto2 ';
SQL := SQL + 'WHERE CODJOGO = ' + IntToStr(CodJogo);
BD.SQLDtStDados.ParamByName('Noticia').asMemo := Noticia;
Foto1.Free;
Foto2.Free;
end;
procedure TJogo.EscalarJogador (umCodEquipe, umCodJogador, TempoJogado: Integer);
var
125
Jogador: TJogador;
begin
if EquipeCasa.GetCodEquipe = umCodEquipe then begin
Jogador := EquipeCasa.GetJogador(umCodJogador);
umItemEscalacao.Escalacao(CodJogo, EquipeCasa.GetCodEquipe, TempoJogado, Jogador,
'T');
NumTitTC := NumTitTC + 1;
EscalacaoTC[NumTitTC+ NumSubstTC] := umItemEscalacao;
end else begin
Jogador := EquipeFora.GetJogador(umCodJogador);
umItemEscalacao.Escalacao(CodJogo, EquipeFora.GetCodEquipe, TempoJogado, Jogador,
'T');
NumTitTF := NumTitTF + 1;
EscalacaoTF[NumTitTF+ NumSubstTF] := umItemEscalacao;
end;
end;
procedure TJogo.RemoverEscalacaoJogador (umCodEquipe, umCodJogador: Integer);
var
i, k: Integer;
Achou: boolean;
begin
Achou := false;
i := 1;
while (i <= k) and not Achou do begin
if EscalacaoTC[i].GetCodJogador = umCodJogador then begin
Achou := True;
end;
i := i + 1;
end;
end else begin
if EscalacaoTF[i].GetCodJogador = umCodJogador then begin
Achou := True;
end;
i := i + 1;
end;
end;
end;
procedure TJogo.PromoverSubst (umCodEquipe, CodJogadorSaiu, TempoJogadoSaiu,
CodJogadorEntrou, TempoJogadoEntrou, MinutoSubst: Integer);
var
Jogador: TJogador;
i, k: Integer;
achou: boolean;
JogadorEntrou: TJogador;
begin
achou := false;
i := 1;
while (i <= k) and not achou do begin
if EscalacaoTC[i].GetCodJogador = CodJogadorSaiu then begin
achou := true;
JogadorEntrou := EquipeCasa.GetJogador(CodJogadorEntrou);
EscalacaoTC[i].Substituicao (TempoJogadoSaiu, MinutoSubst, JogadorEntrou);
umItemEscalacao.Escalacao(CodJogo, EquipeCasa.GetCodEquipe, TempoJogadoEntrou,
JogadorEntrou, 'R');
NumSubstTC := NumSubstTC + 1;
EscalacaoTC[NumTitTC+ NumSubstTC] := umItemEscalacao;
end;
i := i + 1;
end;
end else begin
126

if EscalacaoTF[i].GetCodJogador = CodJogadorSaiu then begin
Achou := True;
JogadorEntrou := EquipeFora.GetJogador(CodJogadorEntrou);
EscalacaoTF[i].Substituicao (TempoJogadoSaiu, MinutoSubst, JogadorEntrou);
umItemEscalacao.Escalacao(CodJogo, EquipeFora.GetCodEquipe, TempoJogadoEntrou,
JogadorEntrou, 'R');
NumSubstTF := NumSubstTF + 1;
EscalacaoTF[NumTitTF+ NumSubstTF] := umItemEscalacao;
end;
i := i + 1;
end;
end;
end;
destructor TJogo.Destroy;
var
i, tot: Integer;
begin
BD.Destroy;
ClassificacaoTimeCasa.Destroy;
ClassificacaoTimeFora.Destroy;
MeusUtils.Free;
EquipeCasa.Destroy;
EquipeFora.Destroy;
Estadio.Destroy;
Arbitro.Destroy;
for i := 1 to NumLancesJogo do begin
LancesJogo[i].Destroy;
end;
tot := NumTitTC + NumSubstTC;
for i:=1 to tot do begin
EscalacaoTC[i].Destroy;
end;
tot := NumTitTF + NumSubstTF;
for i:=1 to tot do begin
EscalacaoTF[i].Destroy;
end;
end;
procedure TJogo.RemoverSubstituicao (umCodEquipe, CodJogadorSaiu, CodJogadorEntrou,
TempoJogado: Integer);
var
i, k: Integer;
AchouEntrou, AchouSaiu: boolean;
begin
AchouEntrou := False;
AchouSaiu := False;
i := 1;
while (i <= k) and ((not achouEntrou) or (not AchouSaiu)) do begin
if EscalacaoTC[i].GetCodJogador = CodJogadorSaiu then begin
AchouSaiu := True;
EscalacaoTC[i].DesfazerSubstituicao (TempoJogado);
end;
if EscalacaoTC[i].GetCodJogador = CodJogadorEntrou then begin
AchouEntrou := True;
end;
i := i + 1;
end
end else begin
while (i <= k) and ((not AchouEntrou) or (not AchouSaiu)) do begin
if EscalacaoTF[i].GetCodJogador = CodJogadorSaiu then begin
AchouSaiu := True;
EscalacaoTF[i].DesfazerSubstituicao (TempoJogado);
end;
if EscalacaoTF[i].GetCodJogador = CodJogadorEntrou then begin
AchouEntrou := True;
end;
i := i + 1;
127
end
end;
end;
procedure TJogo.IncluirLancePartida (umCodEquipeLance, umCodEquipeJogador, CodJogador,
TipoLance, Minuto: Integer);
var
umLanceJogo: TLanceJogo;
begin
umLanceJogo := TLanceJogo.Create; umLanceJogo.SetBD(ConBD);
if umCodEquipeLance = EquipeCasa.GetCodEquipe then begin
// Se Equipe Casa
if ((TipoLance=1) or (TipoLance=2)) then begin //Se Gol a Favor
if GolsTimeCasa + GolsTimeCasaProrrogacao > NumLancesGolsTC then begin // Se
possui gols
umLanceJogo.NovoLancePartida (CodJogo, EquipeCasa, EquipeCasa, CodJogador,
TipoLance, Minuto);
NumLancesGolsTC := NumLancesGolsTC + 1;
end;
end else begin
if TipoLance=3 then begin
// se gol contra
if GolsTimeFora + GolsTimeForaProrrogacao > NumLancesGolsTF then begin // Se
possui gols
umLanceJogo.NovoLancePartida (CodJogo, EquipeFora, EquipeCasa, CodJogador,
TipoLance, Minuto);
NumLancesGolsTF := NumLancesGolsTF + 1;
end;
end else begin
// Se Carto
umLanceJogo.NovoLancePartida (CodJogo, EquipeCasa, EquipeCasa, CodJogador,
TipoLance, Minuto);
end;
end;
end else begin
if ((TipoLance=1) or (TipoLance=2)) then begin //Se Gol a Favor
if GolsTimeFora + GolsTimeForaProrrogacao > NumLancesGolsTF then begin // Se
possui gols
umLanceJogo.NovoLancePartida (CodJogo, EquipeFora, EquipeFora, CodJogador,
TipoLance, Minuto);
NumLancesGolsTF := NumLancesGolsTF + 1;
end;
end else begin
if TipoLance=3 then begin
// se gol contra
if GolsTimeCasa + GolsTimeCasaProrrogacao > NumLancesGolsTC then begin // Se
possui gols
umLanceJogo.NovoLancePartida (CodJogo, EquipeCasa, EquipeFora, CodJogador,
TipoLance, Minuto);
NumLancesGolsTC := NumLancesGolsTC + 1;
end;
end else begin
// Se Carto
umLanceJogo.NovoLancePartida (CodJogo, EquipeFora, EquipeFora, CodJogador,
TipoLance, Minuto);
end;
end;
end;
end;
procedure TJogo.ExcluirLancePartida (umCodLance: Integer);
var
i, y: Integer;
achou: Boolean;
begin
i := 1;
achou := false;
while ((i <= NumLancesJogo) and (achou = false)) do begin
if LancesJogo[i].GetCodLancePartida = umCodLance then begin
if ((LancesJogo[i].GetTipoLance=1) or (LancesJogo[i].GetTipoLance=2) or
(LancesJogo[i].GetTipoLance=3)) then begin
if LancesJogo[i].GetCodEquipeLance = EquipeCasa.GetCodEquipe then begin
NumLancesGolsTC := NumLancesGolsTC - 1;
end else begin
NumLancesGolsTF := NumLancesGolsTF - 1;
end;
end;
LancesJogo[i].ExcluirLancePartida;
128
achou := true;
for y := i+1 to NumLancesJogo do begin
LancesJogo[y-1] := LancesJogo[y];
end;
NumLancesJogo := NumLancesJogo - 1;
end;
i := i + 1;
end;
end;
function TJogo.GetNumLancesGolsTC : Integer;
begin
GetNumLancesGolsTC := NumLancesGolsTC;
end;
function TJogo.GetNumLancesGolsTF : Integer;
begin
GetNumLancesGolsTF := NumLancesGolsTF;
end;
function TJogo.GetGolsTimeCasa : Integer;
begin
GetGolsTimeCasa := GolsTimeCasa;
end;
function TJogo.GetGolsTimeFora : Integer;
begin
GetGolsTimeFora := GolsTimeFora;
end;
function TJogo.GetGolsTimeCasaProrrogacao: Integer;
begin
GetGolsTimeCasaProrrogacao := GolsTimeCasaProrrogacao;
end;
function TJogo.GetGolsTimeForaProrrogacao: Integer;
begin
GetGolsTimeForaProrrogacao := GolsTimeForaProrrogacao;
end;
end.
========================================================================================
====
ARQUIVO: UJogador.pas
========================================================================================
====
unit UJogador;
interface
Uses
Borland.Vcl.Db, UDMClasses;
type
TJogador = class
protected
conBD: TDtMdlDados;
BD: TDtMdlClasses;
CodJogador: Integer;
CodEquipe: Integer;
ApelidoJogador: String;
NomeJogador: String;
NumeroCamisa: Integer;
DataNascimento: TDateTime;
Nacionalidade: String;
Posicao: Integer; //1: Gol/2: Lat/3: Zag/4: MC/5: ATA
Status: String; // 'A': Ativo / 'V': Vendido
EMail: String;
public
procedure Materializar (umCodJogador, umCodEquipe: Integer);
129
function GetCodJogador : Integer;

procedure NovoJogador(umCodTemp, umCodEquipe: Integer; umApelido, umNome,
umaNacionalidade,
umEMail: String; umNumero, umaPosicao: Integer; umaData: TDateTime;
procedure AlterarJogador(umApelido, umNome, umaNacionalidade, umEMail: String;
umNumero,
umaPosicao: Integer; umaData: TDateTime; Foto: TMemoryStream);
function ExcluirJogador : Boolean;
function PossuiAtuacoes : Boolean;
end;
implementation
constructor TJogador.Create;
begin
inherited;
end;
procedure TJogador.SetBD (var umaConBD: TDtMdlDados);
begin
conBD := umaConBD;
end;
procedure TJogador.Materializar (umCodJogador, umCodEquipe: Integer);
begin
BD.SQLDtStDados.CommandText := 'SELECT * FROM JOGADOR WHERE CODJOGADOR=' +
IntToStr(umCodJogador) + ' AND CODEQUIPE=' + IntToStr(umCodEquipe);
Close;
Open;
First;
CodJogador := FieldByName('CodJogador').asInteger;
CodTemporada := FieldByName('CodTemporada').asInteger;
CodEquipe := FieldByName('CodEquipe').asInteger;
ApelidoJogador := FieldByName('ApelidoJogador').asString;
NomeJogador := FieldByName('NomeJogador').asString;
NumeroCamisa := FieldByName('NumeroCamisa').asInteger;
DataNascimento := FieldByName('DataNascimento').asDateTime;
Nacionalidade := FieldByName('Nacionalidade').asString;
Posicao := FieldByName('Posicao').asInteger;
Status := FieldByName('Status').asString;
EMail := FieldByName('EMail').asString;
end;
end;
procedure TJogador.NovoJogador(umCodTemp, umCodEquipe: Integer; umApelido, umNome,
umaNacionalidade, umEMail: String; umNumero,
umaPosicao: Integer; umaData: TDateTime; Foto: TMemoryStream);
var
SQL: String;
begin
CodTemporada := umCodTemp;
CodEquipe := umCodEquipe;
ApelidoJogador := umApelido;
NomeJogador := umNome;
NumeroCamisa := umNumero;
DataNascimento := umaData;
Nacionalidade := umaNacionalidade;
Posicao := umaPosicao;
EMail := umEMail;
Close;
Open;
First;
CodJogador := FieldByName('OID').asInteger;
end;
SQL := 'Insert into JOGADOR (CODJOGADOR, CODTEMPORADA, CODEQUIPE, APELIDOJOGADOR, ';
SQL := SQL + 'NOMEJOGADOR, NUMEROCAMISA, DATANASCIMENTO, NACIONALIDADE, POSICAO, ';
SQL := SQL + 'STATUS, EMAIL, FOTO) values (';
130
SQL := SQL + IntToStr(CodJogador) + ', ';

SQL := SQL + IntToStr(CodEquipe) + ', ';
SQL := SQL + '''' + ApelidoJogador + ''', ';
SQL := SQL + '''' + NomeJogador + ''', ';
SQL := SQL + IntToStr(NumeroCamisa) + ', ';
SQL := SQL + '''' + MeusUtils.DataParaBD (DataNascimento) + ''', ';
SQL := SQL + '''' + Nacionalidade + ''', ';
SQL := SQL + IntToStr(Posicao) + ', ';
SQL := SQL + '''A'', ';
SQL := SQL + '''' + EMail + ''', ';
SQL := SQL + ':Foto)';
BD.SQLDtStDados.ParamByName('Foto').LoadFromStream(Foto,ftBlob);
end;
procedure TJogador.AlterarJogador(umApelido, umNome, umaNacionalidade, umEMail: String;
umNumero, umaPosicao: Integer; umaData: TDateTime; Foto:
TMemoryStream);
var
SQL: String;
begin
ApelidoJogador := umApelido;
NomeJogador := umNome;
NumeroCamisa := umNumero;
Nacionalidade := umaNacionalidade;
Posicao := umaPosicao;
EMail := umEMail;
SQL := 'Update JOGADOR set ';
SQL := SQL + 'APELIDOJOGADOR=''' + ApelidoJogador + ''', ';
SQL := SQL + 'NOMEJOGADOR=''' + NomeJogador + ''', ';
SQL := SQL + 'NUMEROCAMISA=' + IntToStr(NumeroCamisa) + ', ';
SQL := SQL + 'DATANASCIMENTO=''' + MeusUtils.DataParaBD (DataNascimento) + ''', ';
SQL := SQL + 'NACIONALIDADE=''' + Nacionalidade + ''', ';
SQL := SQL + 'POSICAO=' + IntToStr(Posicao) + ', ';
SQL := SQL + 'STATUS=''A'', ';
SQL := SQL + 'EMAIL=''' + EMail + ''', ';
SQL := SQL + 'FOTO=:Foto where CODJOGADOR=' + IntToStr(CodJogador);
end;
function TJogador.ExcluirJogador : Boolean;
var
SQL: String;
begin
if Self.PossuiAtuacoes = False then begin
SQL := 'Delete from JOGADOR where CODJOGADOR=' + IntToStr(CodJogador);
ExcluirJogador := True;
end else begin
ExcluirJogador := False;
end;
end;
function TJogador.PossuiAtuacoes : Boolean;
var
SQL: String;
NumAtuacoes: Integer;
begin
SQL := 'Select Count(*) from ESCALACAOJOGO where CODJOGADOR=' + IntToStr(CodJogador);
SQL := SQL + ' or CODJOGADORENTROU=' + IntToStr(CodJogador);
Close;
Open;
First;
NumAtuacoes := FieldByName('COUNT').asInteger;
end;
if NumAtuacoes > 0 then begin
PossuiAtuacoes := True;
end else begin
SQL := 'Select Count(*) from LANCEPARTIDA where CODJOGADOR=' + IntToStr(CodJogador);
131
Close;
Open;
First;
NumAtuacoes := FieldByName('COUNT').asInteger;
end;
if NumAtuacoes > 0 then begin
PossuiAtuacoes := True;
end else begin
PossuiAtuacoes := False;
end;
end;
end;
function TJogador.GetCodJogador;
begin
GetCodJogador := CodJogador;
end;
destructor TJogador.Destroy;
begin
inherited;
BD.Destroy;
MeusUtils.Free;
end;
end.
========================================================================================
====
ARQUIVO: UItemEscalacao.pas
========================================================================================
====
unit UItemEscalacao;
interface
Uses
Borland.Vcl.Db, UDMClasses, UJogador;
type
TItemEscalacao = class
protected
conBD: TDtMdlDados;
BD: TDtMdlClasses;
CodJogo: Integer;
CodEquipe: Integer;
Jogador: TJogador;
TempoJogado: Integer;
MinutoSubstituicao: Integer;
JogadorEntrou: TJogador;
Status: String; // T: Titular // R: Reserva
Saiu: String; // S: Foi Substituido // N: No foi substituido
public
procedure Materializar (umCodJogo, umCodJogador, umCodEquipe: Integer);
procedure Escalacao (umCodJogo, umCodEquipe, oTempoJogado: Integer; var umJogador:
TJogador; umStatus: String);
procedure Substituicao (oTempoJogado, oMinutoSubst: Integer; var umJogadorEntrou:
TJogador);
procedure DesfazerSubstituicao (oTempoJogado: Integer);
procedure RemoverEscalacao;
function GetCodJogador : Integer;
end;
implementation
constructor TItemEscalacao.Create;
begin
inherited;
132
end;
procedure TItemEscalacao.SetBD (var umaConBD: TDtMdlDados);
begin
conBD := umaConBD;
end;
procedure TItemEscalacao.Materializar (umCodJogo, umCodJogador, umCodEquipe: Integer);
begin
IntToStr(umCodJogo) + ' AND CODJOGADOR=' + IntToStr(umCodJogador) + ' AND CODEQUIPE=' +
IntToStr(umCodEquipe);
Close;
Open;
First;
CodEquipe := FieldByName('CodEquipe').asInteger;
Jogador := TJogador.Create; Jogador.SetBD(ConBD);
Jogador.Materializar(FieldByName('CodJogador').asInteger,
FieldByName('CodEquipe').asInteger);
TempoJogado := FieldByName('TempoJogado').asInteger;
Status := FieldByName('Status').asString;
Saiu := FieldByName('Saiu').asString;
if Saiu = 'S' then begin
JogadorEntrou := TJogador.Create; JogadorEntrou.SetBD(ConBD);
JogadorEntrou.Materializar(FieldByName('CodJogadorEntrou').asInteger,
FieldByName('CodEquipe').asInteger);
MinutoSubstituicao := FieldByName('MinutoSubstituicao').asInteger;
end;
end;
end;
procedure TItemEscalacao.Escalacao (umCodJogo, umCodEquipe, oTempoJogado: Integer; var
umJogador: TJogador; umStatus: String);
var
SQL: String;
begin
CodEquipe := umCodEquipe;
Jogador := umJogador;
TempoJogado := oTempoJogado;
Status := umStatus;
Saiu := 'N';
SQL := 'INSERT INTO ESCALACAOJOGO (CODJOGO, CODEQUIPE, CODJOGADOR, TEMPOJOGADO,
STATUS, SAIU) VALUES (';
SQL := SQL + IntToStr(CodEquipe) + ', ';
SQL := SQL + IntToStr(Jogador.GetCodJogador) + ', ';
SQL := SQL + IntToStr(TempoJogado) + ', ';
SQL := SQL + '''' + Status + ''', ';
SQL := SQL + '''' + Saiu + ''')';
end;
procedure TItemEscalacao.Substituicao (oTempoJogado, oMinutoSubst: Integer; var
umJogadorEntrou: TJogador);
var
SQL: String;
begin
JogadorEntrou := umJogadorEntrou;
MinutoSubstituicao := oMinutoSubst;
Saiu := 'S';
SQL := 'UPDATE ESCALACAOJOGO SET ';
SQL := SQL + 'CODJOGADORENTROU=' + IntToStr(JogadorEntrou.GetCodJogador) + ', ';
SQL := SQL + 'SAIU=''' + Saiu + ''', ';
SQL := SQL + 'TEMPOJOGADO=' + IntToStr(TempoJogado) + ', ';
SQL := SQL + 'MINUTOSUBSTITUICAO=' + IntToStr(MinutoSubstituicao) + ' ';
SQL := SQL + 'WHERE CODJOGO=' + IntToStr(CodJogo) + ' AND CODJOGADOR=' +
IntToStr(Jogador.GetCodJogador);
end;
133
procedure TItemEscalacao.DesfazerSubstituicao (oTempoJogado: Integer);

var
SQL: String;
begin
JogadorEntrou.Free;
MinutoSubstituicao := 0;
Status := 'T';
Saiu := 'N';
SQL := 'UPDATE ESCALACAOJOGO SET ';
SQL := SQL + 'CODJOGADORENTROU=NULL, ';
SQL := SQL + 'STATUS=''' + Status + ''', ';
SQL := SQL + 'SAIU=''' + Saiu + ''', ';
SQL := SQL + 'TEMPOJOGADO=' + IntToStr(TempoJogado) + ', ';
SQL := SQL + 'MINUTOSUBSTITUICAO=' + IntToStr(MinutoSubstituicao) + ' ';
SQL := SQL + 'WHERE CODJOGO=' + IntToStr(CodJogo) + ' AND CODJOGADOR=' +
IntToStr(Jogador.GetCodJogador);
end;
procedure TItemEscalacao.RemoverEscalacao;
var
SQL: String;
begin
SQL := 'DELETE FROM ESCALACAOJOGO WHERE CODJOGO=' + IntToStr(CodJogo) + ' AND
CODJOGADOR=' + IntToStr(Jogador.GetCodJogador);
end;
function TItemEscalacao.GetCodJogador : Integer;
begin
GetCodJogador := Jogador.GetCodJogador;
end;
destructor TItemEscalacao.Destroy;
begin
inherited;
BD.Destroy;
Jogador.Destroy;
MeusUtils.Free;
end;
end.
========================================================================================
====
ARQUIVO: UItemCombo.pas
========================================================================================
====
unit UItemCombo;
interface
uses Borland.Vcl.Classes, Graphics,
Windows, Messages, SysUtils, Variants, Controls, Forms,
Dialogs, Borland.Vcl.StdCtrls, Borland.Vcl.DBCtrls, Borland.Vcl.ComCtrls,
Borland.Vcl.ExtCtrls, Borland.Vcl.Mask, System.ComponentModel, DBXpress,
FMTBcd, Borland.Vcl.Buttons;
Type
TItemCombo = class
protected
Nome: String;
Oid, Oid2: Integer;
Imagem: TStream;
public
function GetOid: Integer;
procedure SetOid(Value: Integer);
function GetOid2: Integer;
procedure SetOid2(Value: Integer);
function GetNome: String;
procedure SetNome(Value: String);
134

end;
implementation
{ TItemCombo }
function TItemCombo.GetNome: String;
begin
GetNome := Nome;
end;
function TItemCombo.GetOid: Integer;
begin
GetOid := Oid;
end;
function TItemCombo.GetOid2: Integer;
begin
GetOid2 := Oid2;
end;
procedure TItemCombo.SetNome(Value: String);
begin
Nome := Value;
end;
procedure TItemCombo.SetOid(Value: Integer);
begin
Oid := Value;
end;
procedure TItemCombo.SetOid2(Value: Integer);
begin
Oid2 := Value;
end;
destructor TItemCombo.Destroy;
begin
inherited;
Imagem.Free;
end;
end.
========================================================================================
====
ARQUIVO: UITabClassificacao.pas
========================================================================================
====
unit UITabClassificacao;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, FMTBcd, Borland.Vcl.Db, Borland.Vcl.DBClient,
Borland.Vcl.Provider, Borland.Vcl.SqlExpr, System.ComponentModel,
Borland.Vcl.Grids, Borland.Vcl.DBGrids, Borland.Vcl.StdCtrls,
Borland.Vcl.Buttons, Borland.Vcl.ExtCtrls, Borland.Vcl.ComCtrls, UTemporada,
UDMDados, UDMITabClassificacao, UItemCombo;
type
TFrmTabClassificacao = class(TForm)
PageControl1: TPageControl;
TabSheet1: TTabSheet;
StrGrdClass: TStringGrid;
PnlClassificacao: TPanel;
DBGrdGrupos: TDBGrid;
Panel3: TPanel;
Panel4: TPanel;
DBGrdFases: TDBGrid;
BtnFechar: TBitBtn;
DBGrdJogos: TDBGrid;
135
Panel1: TPanel;
CmbBxEquipe: TComboBox;
Panel2: TPanel;
Panel7: TPanel;
ImgTime: TImage;
RdGrpOrdem: TRadioGroup;
ChckBxTodosGrupos: TCheckBox;
ChckBxTodasFases: TCheckBox;
RdGrpResultado: TRadioGroup;
PnlJgsEquipe: TPanel;
StrGrdCampanha: TStringGrid;
BtnTodos: TButton;
BtnCasa: TButton;
BtnFora: TButton;
Button1: TButton;
Button2: TButton;
Button3: TButton;
RdGrpTabelaJgs: TRadioGroup;
StrGrdEstatTemp: TStringGrid;
Panel5: TPanel;
procedure FormCreate(Sender: TObject);
procedure StrGrdClassDrawCell(Sender: TObject; ACol, ARow: Integer;
Rect: TRect; State: TGridDrawState);
procedure BtnFecharClick(Sender: TObject);
procedure FormClose(Sender: TObject; var Action: TCloseAction);
procedure DBGrdFasesCellClick(Column: TColumn);
procedure DBGrdGruposCellClick(Column: TColumn);
procedure BtnTodosClick(Sender: TObject);
procedure BtnCasaClick(Sender: TObject);
procedure BtnForaClick(Sender: TObject);
procedure ChckBxTodosGruposClick(Sender: TObject);
procedure ChckBxTodasFasesClick(Sender: TObject);
procedure RdGrpOrdemClick(Sender: TObject);
procedure CmbBxEquipeChange(Sender: TObject);
procedure FormShow(Sender: TObject);
procedure StrGrdCampanhaDrawCell(Sender: TObject; ACol, ARow: Integer;
private
{ Private declarations }
Temporada: TTemporada;
BD: TDtMdlITabClassificacao;
TotalClass, Promovido, Compet1, Compet2, PORebaixamento, Rebaixado : Integer;
SQLSelect, SQLWhere, SQLGroupBy, SQLOrderBy: String;
TipoClass, PnlTabJgs, PnlResJgs: String;
public
{ Public declarations }
procedure SetBD (var conBD: TDtMdlDados);
procedure Mostrar (Temp: TTemporada);
procedure AtualizarFases;
procedure AtualizarGrupos;
procedure AtualizarClassificacao;
procedure AtualizarSQLClassificacao;
procedure CarregarComboCampanha;
procedure AtualizarCampanha;
procedure AtualizarEstatTemp;
end;
var
FrmTabClassificacao: TFrmTabClassificacao;
implementation
{$R *.nfm}
procedure TFrmTabClassificacao.SetBD (var conBD: TDtMdlDados);
begin
BD := TDtMdlITabClassificacao.Create(nil);
BD.SetConexaoBD(conBD);
end;
procedure TFrmTabClassificacao.Mostrar (Temp: TTemporada);

begin
Temporada := Temp;
TipoClass := 'todos';
Self.CarregarComboCampanha;
136
Self.AtualizarFases;
Self.ShowModal;
end;
procedure TFrmTabClassificacao.AtualizarCampanha;
var
i: Integer;
begin
SQLSelect := 'select * from Equipe EC, Equipe EF, JOGO J, ESTRUTURATEMPORADA ET ';
SQLWhere := 'WHERE J.CodEquipeCasa=EC.CodEquipe and J.CodEquipeFora=EF.CodEquipe ';
SQLWhere := SQLWhere + 'and J.CODESTRUTURATEMPORADA=ET.CODESTRUTURATEMPORADA ';
if ChckBxTodosGrupos.Checked = False then begin
SQLWhere := SQLWhere + ' AND ET.CODGRUPO=' +
BD.ClntDtStGrupos.FieldByName('CodEstruturaTemporada').AsString;
end else begin
if ChckBxTodasFases.Checked = False then begin
SQLWhere := SQLWhere + ' AND ET.CODFASE=' +
BD.ClntDtStFases.FieldByName('CodEstruturaTemporada').AsString;
end else begin
SQLWhere := SQLWhere + ' AND ET.CODTEMPORADA=' +
IntToStr(Temporada.GetCodTemporada);
end;
end;
if TipoClass = 'todos' then begin
case RdGrpResultado.ItemIndex of
0: SQLWhere := SQLWhere + ' AND (J.CODEQUIPECASA=:CodEquipe or
J.CODEQUIPEFORA=:CodEquipe) ';
1: SQLWhere := SQLWhere + ' AND ((J.CODEQUIPECASA=:CodEquipe and
J.GOLSTIMECASA>J.GOLSTIMEFORA) or (J.CODEQUIPEFORA=:CodEquipe AND
J.GOLSTIMEFORA>J.GOLSTIMECASA)) ';
J.GOLSTIMECASA=J.GOLSTIMEFORA) or (J.CODEQUIPEFORA=:CodEquipe AND
J.GOLSTIMEFORA=J.GOLSTIMECASA)) ';
J.GOLSTIMECASA<J.GOLSTIMEFORA) or (J.CODEQUIPEFORA=:CodEquipe AND
J.GOLSTIMEFORA<J.GOLSTIMECASA)) ';
end;
case RdGrpTabelaJgs.ItemIndex of
1: SQLWhere := SQLWhere + ' and J.REALIZADO=1 ';
2: SQLWhere := SQLWhere + ' and J.REALIZADO=0 ';
end;
end else begin
if TipoClass = 'casa' then begin
0: SQLWhere := SQLWhere + ' AND J.CODEQUIPECASA=:CodEquipe ';
1: SQLWhere := SQLWhere + ' AND J.CODEQUIPECASA=:CodEquipe and
J.GOLSTIMECASA>J.GOLSTIMEFORA ';
J.GOLSTIMECASA=J.GOLSTIMEFORA AND J.REALIZADO=1 ';
J.GOLSTIMECASA<J.GOLSTIMEFORA ';
end;
end else begin
0: SQLWhere := SQLWhere + ' AND J.CODEQUIPEFORA=:CodEquipe ';
1: SQLWhere := SQLWhere + ' AND J.CODEQUIPEFORA=:CodEquipe and
J.GOLSTIMEFORA>J.GOLSTIMECASA ';
J.GOLSTIMEFORA=J.GOLSTIMECASA AND J.REALIZADO=1 ';
J.GOLSTIMEFORA<J.GOLSTIMECASA ';
end;
end;
end;
SQLOrderBy := ' order by J.DataHoraJogo';
BD.SQLDtStJogos.CommandText := SQLSelect + SQLWhere + SQLOrderBy;
BD.SQLDtStJogos.ParamByName('CodEquipe').AsInteger :=
TItemCombo(CmbBxEquipe.Items.Objects[CmbBxEquipe.ItemIndex]).GetOid;
BD.ClntDtStJogos.Close;
BD.ClntDtStJogos.Open;
BD.ClntDtStJogos.First;
//STRGRID CAMPANHA
for i:= 1 to 3 do begin
SQLSelect := 'Select SUM(C.PONTOS) PTS, SUM(C.JOGOS) JGS, SUM(C.VITORIA) VIT,
SUM(C.EMPATE) EMP, ';
SQLSelect := SQLSelect + 'SUM(C.DERROTA) DER, SUM(GOLSPRO) GP, SUM(GOLSCONTRA) GC,
';
137
SQLSelect := SQLSelect + 'SUM(C.SALDOGOLS) SG, E.NOMEEQUIPE from CLASSIFICACAO C,

EQUIPE E, ';
SQLSelect := SQLSelect + 'ESTRUTURATEMPORADA ET ';
SQLWhere := 'where C.REALIZADO=1 AND C.CODEQUIPE=:CODEQUIPE AND
C.CODEQUIPE=E.CODEQUIPE AND ';
SQLWhere := SQLWhere + 'C.CODESTRUTURATEMPORADA=ET.CODESTRUTURATEMPORADA AND ';
if i=1 then SQLWhere := SQLWhere + ' C.LOCAL=''C'' AND ';
if i=2 then SQLWhere := SQLWhere + ' C.LOCAL=''F'' AND ';
SQLWhere := SQLWhere + '(ET.CODGRUPO=' +
SQLWhere := SQLWhere + ' or ET.CODESTRUTURATEMPORADA=' +
BD.ClntDtStGrupos.FieldByName('CodEstruturaTemporada').AsString + ') ';
end else begin
SQLWhere := SQLWhere + ' ET.CODFASE=' +
end else begin
SQLWhere := SQLWhere + ' ET.CODTEMPORADA=' +
end;
end;
SQLGroupBy := 'group by E.NOMEEQUIPE ';
BD.SQLDtStDados.CommandText := SQLSelect + SQLWhere + SQLGroupBy;
BD.SQLDtStDados.ParamByName('CodEquipe').AsInteger :=
BD.ClntDtStDados.First;
if not BD.ClntDtStDados.EOF then begin
StrGrdCampanha.Cells[i,1] := BD.ClntDtStDados.FieldByName('PTS').asString;
if BD.ClntDtStDados.FieldByName('JGS').asInteger > 0 then begin
StrGrdCampanha.Cells[i,2] := FormatFloat ('0.0', 100 *
BD.ClntDtStDados.FieldByName('PTS').asInteger /
(BD.ClntDtStDados.FieldByName('JGS').asInteger * Temporada.GetPontosVitoria)) + '%';
BD.ClntDtStDados.FieldByName('VIT').AsInteger /
BD.ClntDtStDados.FieldByName('JGS').asInteger) + '%';
BD.ClntDtStDados.FieldByName('EMP').AsInteger /
BD.ClntDtStDados.FieldByName('DER').AsInteger /
StrGrdCampanha.Cells[i,11] := FormatFloat ('0.0',
BD.ClntDtStDados.FieldByName('GP').AsInteger /
BD.ClntDtStDados.FieldByName('JGS').asInteger);
BD.ClntDtStDados.FieldByName('GC').AsInteger /
end else begin
StrGrdCampanha.Cells[i,2] := '0,0%';
StrGrdCampanha.Cells[i,6] := '0';
StrGrdCampanha.Cells[i,11] := '0,0';
end;
StrGrdCampanha.Cells[i,3] := BD.ClntDtStDados.FieldByName('VIT').asString;
StrGrdCampanha.Cells[i,4] := BD.ClntDtStDados.FieldByName('EMP').asString;
StrGrdCampanha.Cells[i,5] := BD.ClntDtStDados.FieldByName('DER').asString;
StrGrdCampanha.Cells[i,9] := BD.ClntDtStDados.FieldByName('GP').asString;
StrGrdCampanha.Cells[i,10] := BD.ClntDtStDados.FieldByName('GC').asString;
StrGrdCampanha.Cells[i,13] := BD.ClntDtStDados.FieldByName('SG').asString;
end else begin
StrGrdCampanha.Cells[i,1] := '';
138
end;
end;
end;
procedure TFrmTabClassificacao.AtualizarEstatTemp;
var
i: Integer;
begin
//STRGRID CAMPANHA
SQLSelect := SQLSelect + 'SUM(C.DERROTA) DER, SUM(GOLSPRO) GP, SUM(GOLSCONTRA) GC,
';
EQUIPE E, ';
SQLWhere := 'where C.REALIZADO=1 AND C.CODEQUIPE=:CODEQUIPE AND
C.CODEQUIPE=E.CODEQUIPE AND ';
SQLWhere := SQLWhere + 'C.CODESTRUTURATEMPORADA=ET.CODESTRUTURATEMPORADA AND ';
if i=1 then SQLWhere := SQLWhere + ' C.LOCAL=''C'' AND ';
if i=2 then SQLWhere := SQLWhere + ' C.LOCAL=''F'' AND ';
end else begin
end else begin
SQLWhere := SQLWhere + ' ET.CODTEMPORADA=' +
end;
end;
BD.SQLDtStDados.CommandText := SQLSelect + SQLWhere + SQLGroupBy;
BD.SQLDtStDados.ParamByName('CodEquipe').AsInteger :=
BD.ClntDtStDados.First;
if not BD.ClntDtStDados.EOF then begin
StrGrdCampanha.Cells[i,1] := BD.ClntDtStDados.FieldByName('PTS').asString;
if BD.ClntDtStDados.FieldByName('JGS').asInteger > 0 then begin
BD.ClntDtStDados.FieldByName('PTS').asInteger /
(BD.ClntDtStDados.FieldByName('JGS').asInteger * Temporada.GetPontosVitoria)) + '%';
BD.ClntDtStDados.FieldByName('VIT').AsInteger /
BD.ClntDtStDados.FieldByName('EMP').AsInteger /
BD.ClntDtStDados.FieldByName('DER').AsInteger /
BD.ClntDtStDados.FieldByName('GP').AsInteger /
BD.ClntDtStDados.FieldByName('GC').AsInteger /
end else begin
StrGrdCampanha.Cells[i,2] := '0,0%';
end;
StrGrdCampanha.Cells[i,3] := BD.ClntDtStDados.FieldByName('VIT').asString;
StrGrdCampanha.Cells[i,4] := BD.ClntDtStDados.FieldByName('EMP').asString;
StrGrdCampanha.Cells[i,5] := BD.ClntDtStDados.FieldByName('DER').asString;
StrGrdCampanha.Cells[i,9] := BD.ClntDtStDados.FieldByName('GP').asString;
139
StrGrdCampanha.Cells[i,10] := BD.ClntDtStDados.FieldByName('GC').asString;
StrGrdCampanha.Cells[i,13] := BD.ClntDtStDados.FieldByName('SG').asString;
end else begin
end;
end;
end;
procedure TFrmTabClassificacao.CarregarComboCampanha;
var
SQL: String;
ItemCombo: TItemCombo;
begin
BD.SQLDtStEquipeDisputaTemp.ParamByName('CodTemp').AsInteger :=
Temporada.GetCodTemporada;
with BD.ClntDtStEquipeDisputaTemp do begin
Close;
Open;
First;
ImgTime.Picture.Bitmap.LoadFromStream(CreateBlobStream(FieldByName('Escudo'),bmRead));
ItemCombo := TItemCombo.Create;
ItemCombo.SetOid(FieldByName('CodEquipe').AsInteger);
CmbBxEquipe.Items.AddObject(FieldByName('NomeEquipe').asString, ItemCombo);
ItemCombo.Free;
Next;
end;
CmbBxEquipe.ItemIndex := 0;
end;
end;
procedure TFrmTabClassificacao.AtualizarFases;
begin
BD.SQLDtStFases.ParamByName('codTemp').AsInteger := Temporada.GetCodTemporada;
BD.ClntDtStFases.Close;
BD.ClntDtStFases.Open;
BD.ClntDtStFases.First;
Self.AtualizarGrupos;
end;
procedure TFrmTabClassificacao.AtualizarGrupos;
begin
BD.SQLDtStGrupos.ParamByName('CodFase').AsInteger :=
BD.ClntDtStFases.FieldByName('CodEstruturaTemporada').AsInteger;
BD.ClntDtStGrupos.Close;
BD.ClntDtStGrupos.Open;
BD.ClntDtStGrupos.First;
Self.AtualizarClassificacao;
end;
procedure TFrmTabClassificacao.AtualizarClassificacao;
var
i: Integer;
Aprov: Double;
begin
Self.AtualizarSQLClassificacao;
BD.ClntDtStClassificacao.Close;
BD.ClntDtStClassificacao.Open;
BD.ClntDtStClassificacao.Last;
i := 1;
StrGrdClass.RowCount := 2;
StrGrdClass.Cells[0,1] := '';
140
Promovido := Temporada.GetNumTimePromovido;
Compet1 := Temporada.GetNumTimeCompet1;
PORebaixamento := Temporada.GetNumTimePORebaixamento;
Rebaixado := Temporada.GetNumTimeRebaixado;
while not BD.ClntDtStClassificacao.Bof do begin
StrGrdClass.RowCount := i + 1;
StrGrdClass.Cells[0,i] := IntToStr(i) + '';
StrGrdClass.Cells[1,i] :=
BD.ClntDtStClassificacao.FieldByName('NomeEquipe').asString;
StrGrdClass.Cells[2,i] := BD.ClntDtStClassificacao.FieldByName('PTS').asString;
StrGrdClass.Cells[3,i] := BD.ClntDtStClassificacao.FieldByName('JGS').asString;
StrGrdClass.Cells[4,i] := BD.ClntDtStClassificacao.FieldByName('VIT').asString;
StrGrdClass.Cells[5,i] := BD.ClntDtStClassificacao.FieldByName('EMP').asString;
StrGrdClass.Cells[6,i] := BD.ClntDtStClassificacao.FieldByName('DER').asString;
StrGrdClass.Cells[7,i] := BD.ClntDtStClassificacao.FieldByName('GP').asString;
StrGrdClass.Cells[8,i] := BD.ClntDtStClassificacao.FieldByName('GC').asString;
StrGrdClass.Cells[9,i] := BD.ClntDtStClassificacao.FieldByName('SG').asString;
if BD.ClntDtStClassificacao.FieldByName('JGS').asInteger <> 0 then begin
Aprov := (BD.ClntDtStClassificacao.FieldByName('PTS').asInteger /
(BD.ClntDtStClassificacao.FieldByName('JGS').asInteger * Temporada.GetPontosVitoria)) *
100;
Aprov := Trunc(Aprov*10.0)/10.0;
end else begin
Aprov := 0;
end;
StrGrdClass.Cells[10,i] := FormatFloat('0.0', Aprov);
i := i + 1;
BD.ClntDtStClassificacao.Prior;
end;
TotalClass := i;
Self.AtualizarCampanha;
end;
procedure TFrmTabClassificacao.AtualizarSQLClassificacao;
var
i: Integer;
Aprov: Double;
begin
SQLSelect := SQLSelect + 'SUM(C.DERROTA) DER, SUM(GOLSPRO) GP, SUM(GOLSCONTRA) GC, ';
EQUIPE E, ';
SQLWhere := 'where C.CODEQUIPE=E.CODEQUIPE AND
C.CODESTRUTURATEMPORADA=ET.CODESTRUTURATEMPORADA AND ';
end else begin
end else begin
SQLWhere := SQLWhere + ' ET.CODTEMPORADA=' + IntToStr(Temporada.GetCodTemporada);
end;
end;
if TipoClass = 'casa' then begin
SQLWhere := SQLWhere + ' and C.LOCAL=''C'' ';
end;
if TipoClass = 'fora' then begin
SQLWhere := SQLWhere + ' and C.LOCAL=''F'' ';
end;
case RdGrpOrdem.ItemIndex of
0: SQLOrderBy := 'order by 1 desc, ' + Temporada.GetSQLDesempate;
141
1: SQLOrderBy := 'order by 3 desc, 1 desc, ' + Temporada.GetSQLDesempate;

3: SQLOrderBy := 'order by 5, 1 desc, ' + Temporada.GetSQLDesempate;
5: SQLOrderBy := 'order by 7, 1 desc, ' + Temporada.GetSQLDesempate;
else SQLOrderBy := ' ';
end;
BD.SQLDtStClassificacao.CommandText := SQLSelect + SQLWhere + SQLGroupBy + SQLOrderBy;
end;
procedure TFrmTabClassificacao.FormCreate(Sender: TObject);
begin
StrGrdClass.Cells[0,0] := 'POS';
StrGrdClass.Cells[1,0] := 'EQUIPE';
StrGrdClass.Cells[2,0] := 'PTS';
StrGrdClass.Cells[3,0] := 'J';
StrGrdClass.Cells[4,0] := 'V';
StrGrdClass.Cells[5,0] := 'E';
StrGrdClass.Cells[6,0] := 'D';
StrGrdClass.Cells[7,0] := 'GP';
StrGrdClass.Cells[8,0] := 'GC';
StrGrdClass.Cells[9,0] := 'SG';
StrGrdClass.Cells[10,0] := '%';
StrGrdCampanha.Cells[0,0] := 'CAMPANHA';
StrGrdCampanha.Cells[1,0] := 'CASA';
StrGrdCampanha.Cells[2,0] := 'FORA';
StrGrdCampanha.Cells[3,0] := 'TOTAL';
StrGrdCampanha.Cells[0,1] := 'Pontos';
StrGrdCampanha.Cells[0,2] := 'Aproveitamento (%)';
StrGrdCampanha.Cells[0,3] := 'Vitrias';
StrGrdCampanha.Cells[0,4] := 'Empates';
StrGrdCampanha.Cells[0,5] := 'Derrotas';
StrGrdCampanha.Cells[0,6] := '% de Vitrias';
StrGrdCampanha.Cells[0,7] := '% de Empates';
StrGrdCampanha.Cells[0,8] := '% de Derrotas';
StrGrdCampanha.Cells[0,9] := 'Gols Pr';
StrGrdCampanha.Cells[0,10] := 'Gols Contra';
StrGrdCampanha.Cells[0,11] := 'Mdia de Gols Pr';
StrGrdCampanha.Cells[0,12] := 'Mdia de Gols Contra';
StrGrdCampanha.Cells[0,13] := 'Saldo de Gols';
StrGrdEstatTemp.Cells[0,0] := 'ESTATSTICA';
StrGrdEstatTemp.Cells[1,0] := 'ANFITRIO';
StrGrdEstatTemp.Cells[2,0] := 'VISITANTE';
StrGrdEstatTemp.Cells[3,0] := 'TOTAL';
StrGrdEstatTemp.Cells[0,1] := 'Jogos Realizados';
StrGrdEstatTemp.Cells[0,2] := 'Nmero de Gols';
StrGrdEstatTemp.Cells[0,3] := 'Mdia de Gols';
StrGrdEstatTemp.Cells[0,4] := 'Vitrias';
StrGrdEstatTemp.Cells[0,5] := 'Empates';
StrGrdEstatTemp.Cells[0,6] := 'Derrotas';
StrGrdEstatTemp.Cells[0,7] := '% de Vitrias';
StrGrdEstatTemp.Cells[0,8] := '% de Empates';
StrGrdEstatTemp.Cells[0,9] := '% de Derrotas';
end;
procedure TFrmTabClassificacao.StrGrdClassDrawCell(Sender: TObject; ACol,
ARow: Integer; Rect: TRect; State: TGridDrawState);
var
Texto: String;
X: Integer;
begin
if TotalClass > 1 then begin
if (ARow <= Promovido) and (ARow > 0) then begin
StrGrdClass.Canvas.Brush.Color := clLime;
end;
if (ARow > Promovido) and (ARow <= Compet1+Promovido) then begin
StrGrdClass.Canvas.Brush.Color := clAqua;
end;
if (ARow > Promovido+Compet1) and (ARow <= Compet1+Promovido+Compet2) then begin
StrGrdClass.Canvas.Brush.Color := clSkyBlue;
end;
if (ARow >= TotalClass-PORebaixamento-Rebaixado) and (ARow < TotalClass-Rebaixado)
then begin
StrGrdClass.Canvas.Brush.Color := clYellow;
end;
if (ARow >= TotalClass-Rebaixado) then begin
142
StrGrdClass.Canvas.Brush.Color := clRed;
StrGrdClass.Canvas.Font.Color := clWhite;
end;
end;
case RdGrpOrdem.ItemIndex of
0: begin
if (ACol=2) and (ARow > 0) then begin
StrGrdClass.Canvas.Brush.Color := clMoneyGreen;
StrGrdClass.Canvas.Font.Color := clBlack;
end;
end;
1: begin
end;
end;
2: begin
end;
end;
3: begin
end;
end;
4: begin
end;
end;
5: begin
end;
end;
6: begin
end;
end;
end;
StrGrdClass.Canvas.FillRect(Rect);
StrGrdClass.Canvas.TextOut(Rect.Left+2,Rect.Top,StrGrdClass.Cells[acol,arow]);
if (ACol<>1) then begin
Texto := StrGrdClass.Cells[ACol, ARow];
X := Rect.Right - StrGrdClass.Canvas.TextWidth(Texto) - 2;
StrGrdClass.Canvas.TextRect(Rect, X, Rect.Top+2, Texto);
if gdFocused in State then begin
StrGrdClass.Canvas.DrawFocusRect(Rect);
end;
end;
end;
procedure TFrmTabClassificacao.BtnFecharClick(Sender: TObject);
begin
Self.Close;
end;
procedure TFrmTabClassificacao.FormClose(Sender: TObject; var Action: TCloseAction);
var
i: Integer;
begin
BD.Destroy;
for i:=1 to CmbBxEquipe.Items.Count-1 do begin
TItemCombo(CmbBxEquipe.Items.Objects[i]).Destroy;
end;
end;
procedure TFrmTabClassificacao.DBGrdFasesCellClick(Column: TColumn);
begin
143
end;
procedure TFrmTabClassificacao.DBGrdGruposCellClick(Column: TColumn);
begin
end;
procedure TFrmTabClassificacao.BtnTodosClick(Sender: TObject);
begin
TipoClass := 'todos';
PnlClassificacao.Caption := 'CLASSIFICAO (TODOS OS JOGOS)';
end;
procedure TFrmTabClassificacao.BtnCasaClick(Sender: TObject);
begin
TipoClass := 'casa';
PnlClassificacao.Caption := 'CLASSIFICAO (SOMENTE JOGOS COMO ANFITRIO)';
end;
procedure TFrmTabClassificacao.BtnForaClick(Sender: TObject);
begin
TipoClass := 'fora';
PnlClassificacao.Caption := 'CLASSIFICAO (SOMENTE JOGOS COMO VISITANTE)';
end;
procedure TFrmTabClassificacao.ChckBxTodosGruposClick(Sender: TObject);
begin
if ChckBxTodosGrupos.Checked = True then begin
DBGrdGrupos.Enabled := False;
ChckBxTodasFases.Enabled := True;
end else begin
DBGrdGrupos.Enabled := True;
ChckBxTodasFases.Checked := False;
ChckBxTodasFases.Enabled := False;
end;
end;
procedure TFrmTabClassificacao.ChckBxTodasFasesClick(Sender: TObject);
begin
if ChckBxTodasFases.Checked = True then begin
DBGrdFases.Enabled := False;
end else begin
DBGrdFases.Enabled := True;
end;
end;
procedure TFrmTabClassificacao.RdGrpOrdemClick(Sender: TObject);
begin
0: PnlTabJgs := 'TODOS - ';
1: PnlTabJgs := 'REALIZADOS - ';
2: PnlTabJgs := 'A REALIZAR - ';
end;
0: PnlResJgs := '';
1: PnlResJgs := 'VITRIAS';
2: PnlResJgs := 'EMPATES';
3: PnlResJgs := 'DERROTAS';
end;
PnlJgsEquipe.Caption := 'TABELA DE JOGOS: ' + PnlTabJgs + PnlResJgs;
end;
procedure TFrmTabClassificacao.CmbBxEquipeChange(Sender: TObject);
var
SQL: String;
begin
ImgTime.Picture.Destroy;
144
SQL := 'select ESCUDO from EQUIPE where CODEQUIPE=' +

IntToStr(TItemCombo(CmbBxEquipe.Items.Objects[CmbBxEquipe.ItemIndex]).GetOid);
Close;
Open;
First;
ImgTime.Picture.Bitmap.LoadFromStream(BD.ClntDtStDados.CreateBlobStream(BD.ClntDtStDados
.FieldByName('Escudo'),bmRead));
end;
ImgTime.Picture.Destroy;
Self.AtualizarCampanha;
end;
procedure TFrmTabClassificacao.FormShow(Sender: TObject);
begin
PageControl1.ActivePage := TabSheet1;
end;
procedure TFrmTabClassificacao.StrGrdCampanhaDrawCell(Sender: TObject;
ACol, ARow: Integer; Rect: TRect; State: TGridDrawState);
var
LarguraTexto, AlturaTexto, X, Y: integer;
Texto: String;
begin
if (ACol=1) or (ACol=2) or (ACol=3) then begin
Texto := StrGrdCampanha.Cells[ACol, ARow];
LarguraTexto := StrGrdCampanha.Canvas.TextWidth(Texto);
AlturaTexto := StrGrdCampanha.Canvas.TextHeight(Texto);
X := Rect.Left + (Rect.Right - Rect.Left) div 2 - LarguraTexto div 2;
Y := Rect.Top + (Rect.Bottom - Rect.Top) div 2 - AlturaTexto div 2;
StrGrdCampanha.Canvas.TextRect(Rect, X, Y, Texto);
end;
end;
end.
========================================================================================
====
ARQUIVO: UIPunicoes.pas
========================================================================================
====
unit UIPunicoes;
interface
uses
Dialogs, Borland.Vcl.Buttons, Borland.Vcl.ExtCtrls, Borland.Vcl.StdCtrls,
Borland.Vcl.Grids, Borland.Vcl.DBGrids, System.ComponentModel,
Borland.Vcl.ComCtrls, FMTBcd, Borland.Vcl.Db, Borland.Vcl.DBClient,
Borland.Vcl.Provider, Borland.Vcl.SqlExpr, UDMDados, UTemporada, UItemCombo;
type
TFrmPunicoes = class(TForm)
Panel3: TPanel;
DBPunicoes: TDBGrid;
PnlDadosCamp: TPanel;
Label1: TLabel;
Label3: TLabel;
EdtMotivo: TEdit;
EdtPts: TEdit;
PnlBtns: TPanel;
BtnGravar: TBitBtn;
BtnCancelar: TBitBtn;
Panel4: TPanel;
Panel1: TPanel;
Panel5: TPanel;
Label2: TLabel;
DtData: TDateTimePicker;
BtnFechar: TBitBtn;
SQLDtStDados: TSQLDataSet;
DtStPrvdrDados: TDataSetProvider;
145
ClntDtStDados: TClientDataSet;
SQLDtStFases: TSQLDataSet;
DtStPrvdrFases: TDataSetProvider;
ClntDtStFases: TClientDataSet;
DtSrcFases: TDataSource;
SQLDtStGrupos: TSQLDataSet;
DtStPrvdrGrupos: TDataSetProvider;
ClntDtStGrupos: TClientDataSet;
DtSrcGrupos: TDataSource;
SQLDtStPunicoes: TSQLDataSet;
DtStPrvdrPunicoes: TDataSetProvider;
ClntDtStPunicoes: TClientDataSet;
DtSrcPunicoes: TDataSource;
ClntDtStPunicoesCODPUNICAO: TIntegerField;
ClntDtStPunicoesCODESTRUTURATEMPORADA: TIntegerField;
ClntDtStPunicoesCODEQUIPE: TIntegerField;
ClntDtStPunicoesCODCLASSIFICACAO: TIntegerField;
ClntDtStPunicoesPONTOS: TIntegerField;
ClntDtStPunicoesMOTIVO: TStringField;
ClntDtStPunicoesDATA: TDateField;
ClntDtStPunicoesCODEQUIPE_1: TIntegerField;
ClntDtStPunicoesNOMEEQUIPE: TStringField;
ClntDtStPunicoesNOMECOMPLETOEQUIPE: TStringField;
ClntDtStPunicoesDATAFUNDACAO: TDateField;
ClntDtStPunicoesCIDADE: TStringField;
ClntDtStPunicoesPAIS: TStringField;
ClntDtStPunicoesTIPOEQUIPE: TIntegerField;
ClntDtStPunicoesESCUDO: TBlobField;
ClntDtStPunicoesCODESTADIO: TIntegerField;
ClntDtStPunicoesCODESTRUTURATEMPORADA_1: TIntegerField;
ClntDtStPunicoesCODTEMPORADA: TIntegerField;
ClntDtStPunicoesNOMEESTRUTURATEMPORADA: TStringField;
ClntDtStPunicoesCODGRUPO: TIntegerField;
ClntDtStPunicoesCODFASE: TIntegerField;
SQLDtStEquipeDisputaTemp: TSQLDataSet;
DtStPrvdrEquipeDisputaTemp: TDataSetProvider;
ClntDtStEquipeDisputaTemp: TClientDataSet;
ClntDtStEquipeDisputaTempCODEQUIPE: TIntegerField;
ClntDtStEquipeDisputaTempCODTEMPORADA: TIntegerField;
ClntDtStEquipeDisputaTempCODEQUIPE_1: TIntegerField;
ClntDtStEquipeDisputaTempNOMEEQUIPE: TStringField;
ClntDtStEquipeDisputaTempNOMECOMPLETOEQUIPE: TStringField;
ClntDtStEquipeDisputaTempDATAFUNDACAO: TDateField;
ClntDtStEquipeDisputaTempCIDADE: TStringField;
ClntDtStEquipeDisputaTempPAIS: TStringField;
ClntDtStEquipeDisputaTempTIPOEQUIPE: TIntegerField;
ClntDtStEquipeDisputaTempESCUDO: TBlobField;
ClntDtStEquipeDisputaTempCODESTADIO: TIntegerField;
DtSrcEquipeDisputaTemp: TDataSource;
ClntDtStGruposCODESTRUTURATEMPORADA: TIntegerField;
ClntDtStGruposCODTEMPORADA: TIntegerField;
ClntDtStGruposNOMEESTRUTURATEMPORADA: TStringField;
ClntDtStGruposCODGRUPO: TIntegerField;
ClntDtStGruposCODFASE: TIntegerField;
BtnIncluirPunicao: TBitBtn;
BtnAlterarPunicao: TBitBtn;
BtnExcluirPunicao: TBitBtn;
procedure EdtPtsKeyPress(Sender: TObject; var Key: Char);
procedure BtnIncluirPunicaoClick(Sender: TObject);
procedure BtnCancelarClick(Sender: TObject);
procedure BtnGravarClick(Sender: TObject);
procedure BtnAlterarPunicaoClick(Sender: TObject);
procedure BtnExcluirPunicaoClick(Sender: TObject);
private
conBD: TDtMdlDados;
Status: String;
CodPunicao: Integer;
NumEquipes, NumFases, NumGrupos, NumPunicoes: Integer;
procedure AtualizaPunicoes;
procedure AtualizaFases;
procedure AtualizaGrupos;
procedure AtualizaEquipes;
procedure BloqueiaFormulario;
146
procedure AtivaFormulario;
public
procedure Mostrar (umaTemp: TTemporada);
end;
var
FrmPunicoes: TFrmPunicoes;
implementation
{$R *.nfm}
procedure TFrmPunicoes.BtnFecharClick(Sender: TObject);
begin
Self.Close;
end;
procedure TFrmPunicoes.SetBD (var umaConBD: TDtMdlDados);
begin
conBD := umaConBD;
end;
procedure TFrmPunicoes.Mostrar (umaTemp: TTemporada);
begin
Temporada := umaTemp;
Self.AtualizaPunicoes;
Self.AtualizaFases;
if NumFases > 0 then begin
Self.AtualizaGrupos;
if NumGrupos > 0 then begin
Self.AtualizaEquipes;
if NumEquipes > 0 then begin
Self.BloqueiaFormulario;
ShowModal;
end else begin
ShowMessage('No existem Equipes Cadastradas nesta temporada');
end;
end else begin
ShowMessage('Estrutura da Temporada Indefinida');
end;
end else begin
ShowMessage('Estrutura da Temporada Indefinida');
end;
end;
procedure TFrmPunicoes.AtualizaPunicoes;
var
SQL: String;
begin
SQL := 'select COUNT(*) from PUNICAO P, ESTRUTURATEMPORADA ET where ';
SQL := SQL + 'ET.CODTEMPORADA=' + IntToStr(Temporada.GetCodTemporada) + ' and
P.CodEstruturaTemporada=ET.CodEstruturaTemporada';
SQLDtStDados.CommandText := SQL;
ClntDtStDados.Close;
ClntDtStDados.Open;
ClntDtStDados.First;
NumPunicoes := ClntDtStDados.FieldByName('Count').AsInteger;
SQLDtStPunicoes.ParamByName('CodTemp').Asinteger := Temporada.GetCodTemporada;
ClntDtStPunicoes.Close;
ClntDtStPunicoes.Open;
ClntDtStPunicoes.First;
if NumPunicoes > 0 then begin
BtnAlterarPunicao.Enabled := True;
BtnExcluirPunicao.Enabled := True;
end else begin
BtnAlterarPunicao.Enabled := False;
BtnExcluirPunicao.Enabled := False;
end;
end;
procedure TFrmPunicoes.AtualizaFases;
var
SQL: String;
begin
147
SQL := 'select COUNT(*) from ESTRUTURATEMPORADA where CODTEMPORADA=';

SQL := SQL + IntToStr (Temporada.GetCodTemporada) + ' and CODFASE is null';
ClntDtStDados.Open;
NumFases := ClntDtStDados.FieldByName('Count').AsInteger;
SQLDtStFases.ParamByName('codTemp').AsInteger := Temporada.GetCodTemporada;
ClntDtStFases.Close;
ClntDtStFases.Open;
ClntDtStFases.First;
end;
procedure TFrmPunicoes.AtualizaGrupos;
var
SQL: String;
begin
SQL := 'select COUNT(*) from ESTRUTURATEMPORADA where CODFASE=';
SQL := SQL + ClntDtStFases.FieldByName('CodEstruturaTemporada').AsString + ' and
CodGrupo is null';
ClntDtStDados.Open;
NumGrupos := ClntDtStDados.FieldByName('Count').AsInteger;
SQLDtStGrupos.ParamByName('CodFase').AsInteger :=
ClntDtStFases.FieldByName('CodEstruturaTemporada').AsInteger;
ClntDtStGrupos.Close;
ClntDtStGrupos.Open;
ClntDtStGrupos.First;
end;
procedure TFrmPunicoes.AtualizaEquipes;
var
SQL: String;
begin
SQL := 'Select Count(*) from EQUIPECOMPETETEMPORADA where CODTEMPORADA=' + IntToStr
(Temporada.GetCodTemporada);
ClntDtStDados.Open;
NumEquipes := ClntDtStDados.FieldByName('Count').AsInteger;
if NumEquipes > 0 then begin
SQLDtStEquipeDisputaTemp.ParamByName('CodTemp').AsInteger :=
with ClntDtStEquipeDisputaTemp do begin
Close;
Open;
First;
Next;
ItemCombo.Free;
end;
CmbBxEquipe.ItemIndex := 0;
end;
end;
end;
procedure TFrmPunicoes.BloqueiaFormulario;
begin
DBGrdFases.Enabled := False;
DBGrdGrupos.Enabled := False;
CmbBxEquipe.Enabled := False;
EdtPts.Text := '';
EdtMotivo.Text := '';
DtData.Enabled := False;
EdtPts.Enabled := False;
EdtMotivo.Enabled := False;
BtnGravar.Enabled := False;
BtnCancelar.Enabled := False;
end;
148
procedure TFrmPunicoes.AtivaFormulario;
begin
DBGrdFases.Enabled := True;
DBGrdGrupos.Enabled := True;
CmbBxEquipe.Enabled := True;
EdtPts.Text := '';
EdtMotivo.Text := '';
DtData.Enabled := True;
EdtPts.Enabled := True;
EdtMotivo.Enabled := True;
BtnGravar.Enabled := True;
BtnCancelar.Enabled := True;
end;
procedure TFrmPunicoes.EdtPtsKeyPress(Sender: TObject; var Key: Char);
begin
if not (Key in ['0'..'9', #8,#0,'-']) then begin
Key := #0;
Beep;
end;
end;
procedure TFrmPunicoes.BtnIncluirPunicaoClick(Sender: TObject);
begin
Status := 'N';
Self.AtivaFormulario;
DBGrdFases.SetFocus;
end;
procedure TFrmPunicoes.BtnCancelarClick(Sender: TObject);
begin
end;
procedure TFrmPunicoes.BtnGravarClick(Sender: TObject);
var
Pts: Integer;
Motivo: String;
DataPunicao: TDateTime;
CodEstTemp, CodEquipe: Integer;
begin
if EdtPts.Text = '' then EdtPts.Text := '0';
try
Pts := StrToInt (EdtPts.Text);
DataPunicao := DtData.DateTime;
Motivo := EdtMotivo.Text;
CodEstTemp := ClntDtStGrupos.FieldByName('CodEstruturaTemporada').AsInteger;
CodEquipe := TItemCombo(CmbBxEquipe.Items.Objects[CmbBxEquipe.ItemIndex]).GetOid;
if Status='N' then begin
Temporada.IncluirPunicao(CodEstTemp, CodEquipe, Pts, DataPunicao, Motivo);
end else begin
Temporada.AlterarPunicao(CodPunicao, CodEstTemp, CodEquipe, Pts, DataPunicao,
Motivo);
end;
Except
on E: EConvertError do begin
ShowMessage ('ERRO: ' + E.Message + #10 + 'Anote a mensagem e contacte o
Suporte');
end;
on E: Exception do begin
Suporte');
end;
end;
end;
procedure TFrmPunicoes.BtnAlterarPunicaoClick(Sender: TObject);
var
i: Integer;
Achou: Boolean;
begin
Status := 'A';
CodPunicao := ClntDtStPunicoes.FieldByName('CodPunicao').asInteger;
EdtPts.Text := ClntDtStPunicoes.FieldByName('Pontos').asString;
149
EdtMotivo.Text := ClntDtStPunicoes.FieldByName('Motivo').asString;
DtData.DateTime := ClntDtStPunicoes.FieldByName('Data').asDateTime;
i := 0;
Achou := False;
while ((i <= CmbBxEquipe.Items.Count-1) and (not Achou)) do begin
if ClntDtStPunicoes.FieldByName('CodEquipe').asInteger =
TItemCombo(CmbBxEquipe.Items.Objects[i]).GetOid then begin
Achou := True;
CmbBxEquipe.ItemIndex := i;
end;
i := i + 1;
end;
Achou := False;
with ClntDtStFases do begin
Close;
Open;
First;
while ((not eof) and (not achou)) do begin
if ClntDtStFases.FieldByName('CodEstruturaTemporada').AsInteger =
ClntDtStPunicoes.FieldByName('CodFase').asInteger then begin
Achou := True;
end else begin;
Next;
end;
end;
end;
Achou := False;
with ClntDtStGrupos do begin
Close;
Open;
First;
while ((not eof) and (not achou)) do begin
if ClntDtStGrupos.FieldByName('CodEstruturaTemporada').AsInteger =
ClntDtStPunicoes.FieldByName('CodEstruturaTemporada').asInteger then begin
Achou := True;
end else begin;
Next;
end;
end;
end;
DBGrdFases.SetFocus;
end;
procedure TFrmPunicoes.BtnExcluirPunicaoClick(Sender: TObject);
begin
Temporada.ExcluirPunicao(ClntDtStPunicoes.FieldByName('CodPunicao').AsInteger);
end;
procedure TFrmPunicoes.DBGrdFasesCellClick(Column: TColumn);
begin
end;
end.
========================================================================================
====
ARQUIVO: UInterface.pas
========================================================================================
====
unit UInterface;
interface
uses
Dialogs, Borland.Vcl.StdCtrls, Borland.Vcl.Buttons, Borland.Vcl.Grids,
Borland.Vcl.DBGrids, Borland.Vcl.ExtCtrls, Borland.Vcl.ComCtrls,
Borland.Vcl.Menus, System.ComponentModel, DBXpress, FMTBcd,
Borland.Vcl.Provider, Borland.Vcl.DBClient, Borland.Vcl.Db,
Borland.Vcl.SqlExpr, URodada, UGrupo, UFase, Borland.Vcl.DBCtrls,
Borland.Vcl.DBCGrids, UICadJogos, UTemporada, UMeuUtils, UIEscalacao,
UDMDados, UDMInterface, UILancesJogo, UICadCampeonato, UICadEquipe,
UICadEstadio, UICadArbitro, UItemCombo, UICadTemporada, UICadJogador,
UICadEstruturaTemporada, UICadEquipeCompeteTemporada, UJogo, UIPunicoes,
150
Borland.Vcl.IniFiles, UITabClassificacao, UIImporta, UIAlteraDataRodada;

type
TFrmListaJogos = class(TForm)
MainMenu1: TMainMenu;
Arquivo1: TMenuItem;
CadCampeonato: TMenuItem;
CadEquipe: TMenuItem;
CadEstadio: TMenuItem;
StatusBar1: TStatusBar;
Panel1: TPanel;
Panel2: TPanel;
Panel3: TPanel;
Panel4: TPanel;
Panel5: TPanel;
DBGrdRodadas: TDBGrid;
DBGrdJogos: TDBGrid;
PnlPlacarProrrogacao: TPanel;
Panel8: TPanel;
PnlNomeTC: TPanel;
PnlNomeTF: TPanel;
PnlPlacarJogo: TPanel;
Panel7: TPanel;
PnlDadosJogo1: TPanel;
Panel14: TPanel;
CmbBxCampeonatos: TComboBox;
Label1: TLabel;
PnlPlacarPenaltis: TPanel;
CadTemporada: TMenuItem;
N1: TMenuItem;
emporada2: TMenuItem;
EstruturaCampeonato: TMenuItem;
ImgBranco: TImage;
ImgTimeCasa: TImage;
ImgTimeFora: TImage;
Arbitro: TMenuItem;
BtnAbrirCamp: TBitBtn;
IncluirEquipe: TMenuItem;
BtnCadEstruturaTemporada: TButton;
Jogador: TMenuItem;
Punies1: TMenuItem;
StrGrdClass: TStringGrid;
E1: TMenuItem;
Ajuda1: TMenuItem;
Sobre1: TMenuItem;
Campeonato1: TMenuItem;
N2: TMenuItem;
ImportarTabeladeJogos1: TMenuItem;
PopupMenu1: TPopupMenu;
AlterarDatas1: TMenuItem;
BtnIncluir: TBitBtn;
BtnAlterar: TBitBtn;
BtnExcluir: TBitBtn;
BtnEscalacao: TBitBtn;
BtnLancesJogo: TBitBtn;
procedure BtnIncluirClick(Sender: TObject);
procedure DBGrdRodadasCellClick(Column: TColumn);
procedure BtnAlterarClick(Sender: TObject);
procedure BtnEscalacaoClick(Sender: TObject);
procedure DBGrdJogosDblClick(Sender: TObject);
procedure DBGrdJogosCellClick(Column: TColumn);
procedure BtnLancesJogoClick(Sender: TObject);
procedure CadCampeonatoClick(Sender: TObject);
procedure CadEquipeClick(Sender: TObject);
procedure CadEstadioClick(Sender: TObject);
procedure ArbitroClick(Sender: TObject);
procedure BtnAbrirCampClick(Sender: TObject);
procedure CadTemporadaClick(Sender: TObject);
procedure EstruturaCampeonatoClick(Sender: TObject);
procedure IncluirEquipeClick(Sender: TObject);
procedure BtnCadEstruturaTemporadaClick(Sender: TObject);
procedure JogadorClick(Sender: TObject);
151
procedure BtnExcluirClick(Sender: TObject);

procedure FormKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
procedure Punies1Click(Sender: TObject);
procedure StrGrdClassDrawCell(Sender: TObject; ACol, ARow: Integer;
procedure Campeonato1Click(Sender: TObject);
procedure ImportarTabeladeJogos1Click(Sender: TObject);
procedure DBGrdJogosMouseDown(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
procedure AlterarDatas1Click(Sender: TObject);
private
conBD: TDtMdlDados;
BD: TDtMdlInterface;
FrmCadJogos: TFrmCadJogos;
FrmEscalacao: TFrmEscalacao;
FrmLancesJogo: TFrmLancesJogo;
FrmCadCampeonato: TFrmCadCampeonato;
FrmCadEquipe: TFrmCadEquipe;
TotalClass, Promovido, Compet1, Compet2, PORebaixamento, Rebaixado : Integer;
public
procedure AtualizarCampeonatos;
procedure AtualizarRodadas;
procedure AtualizarJogos;
procedure AtualizarClassificacao;
procedure AtualizarDadosJogos;
end;
var
FrmListaJogos: TFrmListaJogos;
implementation
uses UDataModule;
{$R *.nfm}
procedure TFrmListaJogos.FormCreate(Sender: TObject);
begin
conBD := TDtMdlDados.Create(nil);
BD := TDtMdlInterface.Create(nil);
MeusUtils.GravaIni(ChangeFileExt(Application.Exename, '..INI'));
StrGrdClass.Cells[0,0] := 'Pos.';
StrGrdClass.Cells[1,0] := 'Equipe';
StrGrdClass.Cells[2,0] := 'Pts.';
StrGrdClass.Cells[3,0] := 'Jgs.';
Self.AtualizarCampeonatos;
Self.BtnAbrirCampClick(Sender);
self.AtualizarFases;
end;
procedure TFrmListaJogos.AtualizarCampeonatos;
var
SQL: String;
NomeCamp: String;
ArqIni: TIniFile;
i: Integer;
UltCampAberto: Integer;
Achou: Boolean;
begin
for i:=0 to CmbBxCampeonatos.Items.Count-1 do begin
TItemCombo(CmbBxCampeonatos.Items.Objects[i]).Destroy;
end;
CmbBxCampeonatos.Items.Clear;
ArqIni := TIniFile.Create(ChangeFileExt(Application.Exename, '..INI'));
UltCampAberto := ArqIni.ReadInteger('Temporada', 'Atual', UltCampAberto);
ArqIni.Free;
SQL := 'Select * from TEMPORADA T, CAMPEONATO C where T.CODCAMPEONATO =
C.CODCAMPEONATO order by C.NOME, T.NOMETEMPORADA';
152
i := 0;
Achou := False;
Close;
Open;
First;
ItemCombo.SetOid(FieldByName('CodTemporada').asInteger);
NomeCamp := FieldByName('Nome').asString + ' ' +
FieldByName('NomeTemporada').asString;
ItemCombo.SetNome(NomeCamp);
CmbBxCampeonatos.Items.AddObject(NomeCamp, ItemCombo);
if not Achou then begin
i := i + 1;
if FieldByName('CodTemporada').asInteger = UltCampAberto then begin
Achou := True;
end;
end;
next;
end;
end;
CmbBxCampeonatos.ItemIndex := i - 1;
end;
procedure TFrmListaJogos.AtualizarFases;
begin
BD.SQLDtStFases.ParamByName('codTemp').AsInteger := Temporada.GetCodTemporada;
BD.ClntDtStFases.Close;
BD.ClntDtStFases.Open;
BD.ClntDtStFases.First;
end;
procedure TFrmListaJogos.AtualizarGrupos;
begin
BD.SQLDtStGrupos.ParamByName('CodFase').AsInteger :=
BD.ClntDtStFases.FieldByName('CodEstruturaTemporada').AsInteger;
BD.ClntDtStGrupos.Close;
BD.ClntDtStGrupos.Open;
BD.ClntDtStGrupos.First;
Self.AtualizarRodadas;
end;
procedure TFrmListaJogos.AtualizarRodadas;
begin
BD.SQLDtStRodadas.ParamByName('CodGrupo').AsInteger :=
BD.ClntDtStGrupos.FieldByName('CodEstruturaTemporada').AsInteger;
BD.ClntDtStRodadas.Close;
BD.ClntDtStRodadas.Open;
BD.ClntDtStRodadas.First;
if not BD.ClntDtStRodadas.eof then begin
Panel1.Caption := 'JOGOS DA FASE: ' +
BD.ClntDtStFases.FieldByName('NomeEstruturaTemporada').AsString + ' GRUPO: ' +
BD.ClntDtStGrupos.FieldByName('NomeEstruturaTemporada').AsString + ' RODADA: ' +
BD.ClntDtStRodadas.FieldByName('NomeEstruturaTemporada').AsString;
BtnIncluir.Enabled := True;
end else begin
BtnIncluir.Enabled := False;
Panel1.Caption := '';
end;
Self.AtualizarJogos;
end;
procedure TFrmListaJogos.AtualizarJogos;
begin
BD.SQLDtStJogos.ParamByName('ET').AsInteger :=
BD.ClntDtStRodadas.FieldByName('CodEstruturaTemporada').AsInteger;
BD.ClntDtStJogos.Close;
BD.ClntDtStJogos.Open;
BD.ClntDtStJogos.First;
if BD.ClntDtStJogos.eof then begin
BtnAlterar.Enabled := False;
BtnExcluir.Enabled := False;
BtnEscalacao.Enabled := False;
BtnLancesJogo.Enabled := False;
153
end else begin

BtnAlterar.Enabled := True;
BtnExcluir.Enabled := True;
BtnEscalacao.Enabled := True;
BtnLancesJogo.Enabled := True;
end;
Self.AtualizarDadosJogos;
end;
procedure TFrmListaJogos.AtualizarDadosJogos;
var
SQL: String;
begin
ImgTimeCasa.Picture := ImgBranco.Picture;
ImgTimeFora.Picture := ImgBranco.Picture;
PnlNomeTC.Caption := '';
PnlNomeTF.Caption := '';
PnlDadosJogo1.Caption := '';
PnlPlacarJogo.Caption := '';
PnlPlacarProrrogacao.Caption := '';
PnlPlacarPenaltis.Caption := '';
ImgTimeCasa.Picture.Bitmap.LoadFromStream(BD.ClntDtStJogos.CreateBlobStream(BD.ClntDtStJ
ogos.FieldByName('Escudo'),bmRead));
ImgTimeFora.Picture.Bitmap.LoadFromStream(BD.ClntDtStJogos.CreateBlobStream(BD.ClntDtStJ
ogos.FieldByName('Escudo_1'),bmRead));
PnlNomeTC.Caption := BD.ClntDtStJogos.FieldByName('NomeEquipe').asString;
PnlNomeTF.Caption := BD.ClntDtStJogos.FieldByName('NomeEquipe_1').asString;
if BD.ClntDtStJogos.FieldByName('CodEstadio_2').asInteger <> 0 then begin
SQL := 'Select * from Estadio where CodEstadio=' +
BD.ClntDtStJogos.FieldByName('CodEstadio_2').asString;
Close;
Open;
First;
end;
PnlDadosJogo1.Caption := BD.ClntDtStDados.FieldByName('NomeEstadio').asString + ' ' + BD.ClntDtStDados.FieldByName('CidadeEstadio').asString + ' - ' +
BD.ClntDtStDados.FieldByName('Pais').asString;
end;
if BD.ClntDtStJogos.FieldByName('Realizado').asInteger = 1 then begin
PnlPlacarJogo.Caption := BD.ClntDtStJogos.FieldByName('GolsTimeCasa').asString + ' ' + BD.ClntDtStJogos.FieldByName('GolsTimeFora').asString;
if BD.ClntDtStJogos.FieldByName('Prorrogacao').asInteger = 1 then begin
PnlPlacarProrrogacao.Caption :=
BD.ClntDtStJogos.FieldByName('GolsTimeCasaProrrogacao').asString + ' - Pro - ' +
BD.ClntDtStJogos.FieldByName('GolsTimeForaProrrogacao').asString;
end;
if BD.ClntDtStJogos.FieldByName('Penaltis').asInteger = 1 then begin
PnlPlacarPenaltis.Caption :=
BD.ClntDtStJogos.FieldByName('GolsTimeCasaPenaltis').asString + ' - Pn - ' +
BD.ClntDtStJogos.FieldByName('GolsTimeForaPenaltis').asString;
end;
end;
ImgTimeFora.Picture.Destroy;
ImgTimeCasa.Picture.Destroy;
end;
procedure TFrmListaJogos.AtualizarClassificacao;
var
i: Integer;
SQLText: String;
begin
SQLText := 'Select SUM(C.PONTOS) PTS, SUM(C.JOGOS) JGS, SUM(C.VITORIA) VIT,
SQLText := SQLText + 'SUM(C.DERROTA) DER, SUM(GOLSPRO) GP, SUM(GOLSCONTRA) GC, ';
SQLText := SQLText + 'SUM(C.SALDOGOLS) SG, E.NOMEEQUIPE from CLASSIFICACAO C, EQUIPE
E, ';
SQLText := SQLText + 'ESTRUTURATEMPORADA ET ';
SQLText := SQLText + 'where C.CODEQUIPE=E.CODEQUIPE AND
C.CODESTRUTURATEMPORADA=ET.CODESTRUTURATEMPORADA AND ';
SQLText := SQLText + '(ET.CODGRUPO=:CODGRUPO or ET.CODESTRUTURATEMPORADA=:CODGRUPO) ';
SQLText := SQLText + 'group by E.NOMEEQUIPE ';
SQLText := SQLText + 'order by 1 desc, ' + Temporada.GetSQLDesempate;
154
BD.SQLDtStClassificacao.CommandText := SQLText;
BD.SQLDtStClassificacao.ParamByName('CODGRUPO').AsInteger :=
BD.ClntDtStGrupos.FieldByName('CODESTRUTURATEMPORADA').AsInteger;
BD.ClntDtStClassificacao.Close;
BD.ClntDtStClassificacao.Open;
BD.ClntDtStClassificacao.Last;
i := 1;
StrGrdClass.RowCount := 2;
Promovido := Temporada.GetNumTimePromovido;
PORebaixamento := Temporada.GetNumTimePORebaixamento;
Rebaixado := Temporada.GetNumTimeRebaixado;
while not BD.ClntDtStClassificacao.Bof do begin
StrGrdClass.RowCount := i + 1;
StrGrdClass.Cells[0,i] := IntToStr(i) + '';
StrGrdClass.Cells[1,i] :=
BD.ClntDtStClassificacao.FieldByName('NomeEquipe').asString;
StrGrdClass.Cells[2,i] := BD.ClntDtStClassificacao.FieldByName('PTS').asString;
StrGrdClass.Cells[3,i] := BD.ClntDtStClassificacao.FieldByName('SG').asString;
i := i + 1;
BD.ClntDtStClassificacao.Prior;
end;
TotalClass := i;
end;
procedure TFrmListaJogos.DBGrdFasesCellClick(Column: TColumn);
begin
self.AtualizarGrupos;
end;
procedure TFrmListaJogos.DBGrdGruposCellClick(Column: TColumn);
begin
self.AtualizarRodadas;
end;
procedure TFrmListaJogos.BtnIncluirClick(Sender: TObject);
begin
FrmCadJogos := TFrmCadJogos.create(nil); FrmCadJogos.SetBD(conBD);
FrmCadJogos.Mostrar (Temporada,
BD.ClntDtStRodadas.FieldByName('CodTemporada').AsInteger,
BD.ClntDtStRodadas.FieldByName('CodFase').AsInteger,
BD.ClntDtStRodadas.FieldByName('CodGrupo').AsInteger,
BD.ClntDtStRodadas.FieldByName('CodEstruturaTemporada').AsInteger, 0, 'N');
FreeAndNil (FrmCadJogos);
end;
procedure TFrmListaJogos.DBGrdRodadasCellClick(Column: TColumn);
begin
self.AtualizarJogos;
end;
procedure TFrmListaJogos.BtnAlterarClick(Sender: TObject);
begin
FrmCadJogos := TFrmCadJogos.create(nil); FrmCadJogos.SetBD(conBD);
FrmCadJogos.Mostrar (Temporada,
BD.ClntDtStRodadas.FieldByName('CodTemporada').AsInteger,
BD.ClntDtStRodadas.FieldByName('CodFase').AsInteger,
BD.ClntDtStRodadas.FieldByName('CodGrupo').AsInteger,
BD.ClntDtStRodadas.FieldByName('CodEstruturaTemporada').AsInteger,
BD.ClntDtStJogos.FieldByName('CodJogo').AsInteger, 'A');
FrmCadJogos.Destroy;
end;
procedure TFrmListaJogos.BtnEscalacaoClick(Sender: TObject);
begin
FrmEscalacao := TFrmEscalacao.Create(nil); FrmEscalacao.SetBD(conBD);
FrmEscalacao.DefinirEscalacao (Temporada,
BD.ClntDtStJogos.FieldByName('CodJogo').AsInteger);
FrmEscalacao.Destroy;
end;
155
procedure TFrmListaJogos.DBGrdJogosDblClick(Sender: TObject);

begin
Self.BtnAlterarClick(Sender);
end;
procedure TFrmListaJogos.DBGrdJogosCellClick(Column: TColumn);
begin
self.AtualizarDadosJogos;
end;
procedure TFrmListaJogos.BtnLancesJogoClick(Sender: TObject);
begin
FrmLancesJogo := TFrmLancesJogo.Create(nil); FrmLancesJogo.SetBD(ConBD);
FrmLancesJogo.DefinirLancesJogo (Temporada,
BD.ClntDtStJogos.FieldByName('CodJogo').AsInteger);
FrmLancesJogo.Destroy;
end;
procedure TFrmListaJogos.CadCampeonatoClick(Sender: TObject);
begin
FrmCadCampeonato := TFrmCadCampeonato.Create(nil); FrmCadCampeonato.SetBD(ConBD);
FrmCadCampeonato.Mostrar;
FrmCadCampeonato.Destroy;
end;
procedure TFrmListaJogos.CadEquipeClick(Sender: TObject);
begin
FrmCadEquipe := TFrmCadEquipe.Create(nil); FrmCadEquipe.SetBD(ConBD);
FrmCadEquipe.Mostrar;
FrmCadEquipe.Destroy;
end;
procedure TFrmListaJogos.CadEstadioClick(Sender: TObject);
var
FrmCadEstadio: TFrmCadEstadio;
begin
FrmCadEstadio := TFrmCadEstadio.Create(nil); FrmCadEstadio.SetBD(conBD);
FrmCadEstadio.Mostrar;
FrmCadEstadio.Destroy;
end;
procedure TFrmListaJogos.ArbitroClick(Sender: TObject);
var
FrmCadArbitro: TFrmCadArbitro;
begin
FrmCadArbitro := TFrmCadArbitro.Create(nil); FrmCadArbitro.SetBD(conBD);
FrmCadArbitro.Mostrar (Temporada);
FrmCadArbitro.Destroy;
end;
procedure TFrmListaJogos.BtnAbrirCampClick(Sender: TObject);
var
ArqIni: TIniFile;
begin
Temporada := TTemporada.create; Temporada.SetBD(ConBD);
Temporada.Materializar
(TItemCombo(CmbBxCampeonatos.Items.Objects[CmbBxCampeonatos.ItemIndex]).GetOid);
Self.Caption :=
TItemCombo(CmbBxCampeonatos.Items.Objects[CmbBxCampeonatos.ItemIndex]).GetNome;
ArqIni.WriteInteger('Temporada', 'Atual', Temporada.GetCodTemporada);
ArqIni.Free;
self.AtualizarFases;
end;
procedure TFrmListaJogos.CadTemporadaClick(Sender: TObject);
var
FrmCadTemporada: TFrmCadTemporada;
begin
FrmCadTemporada := TFrmCadTemporada.Create(nil); FrmCadTemporada.SetBD(conBD);
FrmCadTemporada.Mostrar;
FrmCadTemporada.Destroy;
Self.AtualizarCampeonatos;
end;
156
procedure TFrmListaJogos.EstruturaCampeonatoClick(Sender: TObject);

var
FrmCadEstruturaTemporada: TFrmCadEstruturaTemporada;
begin
FrmCadEstruturaTemporada := TFrmCadEstruturaTemporada.Create(nil);
FrmCadEstruturaTemporada.SetBD(conBD);
FrmCadEstruturaTemporada.Mostrar(Temporada);
FrmCadEstruturaTemporada.Destroy;
end;
procedure TFrmListaJogos.IncluirEquipeClick(Sender: TObject);
var
FrmCadEquipeCompeteTemporada: TFrmCadEquipeCompeteTemporada;
begin
FrmCadEquipeCompeteTemporada := TFrmCadEquipeCompeteTemporada.Create(nil);
FrmCadEquipeCompeteTemporada.SetBD(conBD);
FrmCadEquipeCompeteTemporada.Mostrar(Temporada);
FrmCadEquipeCompeteTemporada.Destroy;
end;
procedure TFrmListaJogos.BtnCadEstruturaTemporadaClick(Sender: TObject);
begin
Self.EstruturaCampeonatoClick(Sender);
end;
procedure TFrmListaJogos.JogadorClick(Sender: TObject);
var
FrmCadJogador: TFrmCadJogador;
begin
FrmCadJogador := TFrmCadJogador.Create(nil); FrmCadJogador.SetBD(conBD);
FrmCadJogador.Mostrar(Temporada, 0);
FrmCadJogador.Destroy;
end;
procedure TFrmListaJogos.BtnExcluirClick(Sender: TObject);
var
Jogo: TJogo;
nCode1: Word;
begin
nCode1 := MessageDlg ('Voc relamente deseja excluir o Jogo?', mtConfirmation,
mbYesNo, 0);
case nCode1 of
mrYes: begin
try
Jogo := TJogo.Create; Jogo.SetBD(ConBD);
Jogo.Materializar(BD.ClntDtStJogos.FieldByName('CodJogo').AsInteger);
if Jogo.PossuiEventos = False then begin
Jogo.ExcluirJogo;
end else begin
if MessageDlg ('Este Jogo possui Eventos ou Escalao associados. Tem certeza
que deseja remove-lo?', mtConfirmation, [mbYes, mbNo], 0) = MrYes then begin
Jogo.ExcluirJogo;
end;
end;
Jogo.Destroy;
except
ShowMessage ('ERRO: ' + E.Message + #10 + 'Contacte o Suporte');
end;
end;
end;
end;
end;
procedure TFrmListaJogos.FormKeyDown(Sender: TObject; var Key: Word;
Shift: TShiftState);
begin
if key = VK_INSERT then begin
if BtnIncluir.Enabled = True then begin
end;
end;
if key = VK_DELETE then begin
if BtnExcluir.Enabled = True then begin
Self.BtnExcluirClick(Sender);
157
end;
end;
if key = 13 then begin
if BtnAlterar.Enabled = True then begin
end;
end;
end;
procedure TFrmListaJogos.Punies1Click(Sender: TObject);
var
FrmPunicoes: TFrmPunicoes;
begin
FrmPunicoes := TFrmPunicoes.Create(nil); FrmPunicoes.SetBD(conBD);
FrmPunicoes.Mostrar(Temporada);
FrmPunicoes.Destroy;
end;
procedure TFrmListaJogos.StrGrdClassDrawCell(Sender: TObject; ACol,
var
Texto: string;
X: Integer;
begin
if TotalClass > 1 then begin
if (ARow <= Promovido) and (ARow > 0) then begin
StrGrdClass.Canvas.Brush.Color := clLime;
end;
if (ARow > Promovido) and (ARow <= Compet1+Promovido) then begin
StrGrdClass.Canvas.Brush.Color := clAqua;
end;
if (ARow > Promovido+Compet1) and (ARow <= Compet1+Promovido+Compet2) then begin
StrGrdClass.Canvas.Brush.Color := clSkyBlue;
end;
if (ARow >= TotalClass-PORebaixamento-Rebaixado) and (ARow < TotalClass-Rebaixado)
then begin
StrGrdClass.Canvas.Brush.Color := clYellow;
end;
if (ARow >= TotalClass-Rebaixado) then begin
StrGrdClass.Canvas.Brush.Color := clRed;
StrGrdClass.Canvas.Font.Color := clWhite;
end;
end;
StrGrdClass.Canvas.FillRect(Rect);
StrGrdClass.Canvas.TextOut(Rect.Left+2,Rect.Top,StrGrdClass.Cells[acol,arow]);
if (ACol<>1) then begin
Texto := StrGrdClass.Cells[ACol, ARow];
X := Rect.Right - StrGrdClass.Canvas.TextWidth(Texto) - 2;
StrGrdClass.Canvas.TextRect(Rect, X, Rect.Top+2, Texto);
StrGrdClass.Canvas.DrawFocusRect(Rect);
end;
end;
end;
procedure TFrmListaJogos.Campeonato1Click(Sender: TObject);
var
FrmTabClassificacao: TFrmTabClassificacao;
begin
FrmTabClassificacao := TFrmTabClassificacao.Create(nil);
FrmTabClassificacao.SetBD(conBD);
FrmTabClassificacao.Mostrar (Temporada);
FrmTabClassificacao.Destroy;
end;
procedure TFrmListaJogos.ImportarTabeladeJogos1Click(Sender: TObject);
var
FrmImporta: TFrmImporta;
begin
FrmImporta := TFrmImporta.Create(nil); FrmImporta.SetBD(conBD);
FrmImporta.Mostrar(Temporada);
FrmImporta.Destroy;
end;
procedure TFrmListaJogos.DBGrdJogosMouseDown(Sender: TObject;
158
Button: TMouseButton; Shift: TShiftState; X, Y: Integer);

var
Point : TPoint;
begin
GetCursorPos(Point);
if Button = mbRight then PopupMenu1.PopUp(Point.X,Point.Y);
end;
procedure TFrmListaJogos.AlterarDatas1Click(Sender: TObject);
var
FrmAlteraDataRodada: TFrmAlteraDataRodada;
begin
FrmAlteraDataRodada := TFrmAlteraDataRodada.Create(nil);
FrmAlteraDataRodada.Mostrar(Temporada,
BD.ClntDtStRodadas.FieldByName('CodEstruturaTemporada').AsInteger);
FrmAlteraDataRodada.Destroy;
end;
end.
========================================================================================
====
ARQUIVO: UILanceJogo.pas
========================================================================================
====
unit UILancesJogo;
interface
uses
Dialogs, Borland.Vcl.ExtCtrls, Borland.Vcl.StdCtrls, Borland.Vcl.DBGrids,
Borland.Vcl.ComCtrls, System.ComponentModel, Borland.Vcl.Grids, UDMDados,
UDMILancesJogo, UTemporada, UJogo, Borland.Vcl.Db, FMTBcd,
Borland.Vcl.SqlExpr, Borland.Vcl.DBClient, Borland.Vcl.Provider,
Borland.Vcl.Menus, UItemCombo, UICadJogador;
type
TFrmLancesJogo = class(TForm)
StrGrdEventosJogo: TStringGrid;
PageControl1: TPageControl;
TbShtTimeCasa: TTabSheet;
TbShtTimeFora: TTabSheet;
Panel2: TPanel;
Label1: TLabel;
Label3: TLabel;
Label2: TLabel;
DBGrdTitularesFora: TDBGrid;
CmbBxEventoFora: TComboBox;
PnlJogadorEventoFora: TPanel;
CmbBxMinutosFora: TComboBox;
ChckBxTitularesFora: TCheckBox;
PnlPlacarProrrogacao: TPanel;
Panel8: TPanel;
ImgTimeFora: TImage;
PnlNomeTC: TPanel;
PnlNomeTF: TPanel;
PnlPlacarJogo: TPanel;
Panel7: TPanel;
ImgTimeCasa: TImage;
PnlDadosJogo1: TPanel;
PnlPlacarPenaltis: TPanel;
PnlTimeFora: TPanel;
Panel3: TPanel;
BtnIncluirEventoTF: TButton;
ImgGol: TImage;
ImgGolPen: TImage;
ImgGolContra: TImage;
ImgAmarelo: TImage;
ImgVermelho: TImage;
ImgAmaVer: TImage;
ImgSubst: TImage;
PopupMenu1: TPopupMenu;
ExcluirEvento1: TMenuItem;
Panel1: TPanel;
Label4: TLabel;
159
Label5: TLabel;
Label6: TLabel;
DBGrdTitularesCasa: TDBGrid;
CmbBxEventoCasa: TComboBox;
PnlJogadorEventoCasa: TPanel;
CmbBxMinutosCasa: TComboBox;
ChckBxTitularesCasa: TCheckBox;
PnlTimeCasa: TPanel;
Panel6: TPanel;
BtnIncluirEventoTC: TButton;
BtnCadJogadoresTF: TButton;
Button1: TButton;
procedure ChckBxTitularesForaClick(Sender: TObject);
procedure DBGrdTitularesForaCellClick(Column: TColumn);
procedure StrGrdEventosJogoDrawCell(Sender: TObject; ACol,
procedure BtnIncluirEventoTFClick(Sender: TObject);
procedure FormDestroy(Sender: TObject);
procedure StrGrdEventosJogoMouseDown(Sender: TObject;
procedure ExcluirEvento1Click(Sender: TObject);
procedure BtnIncluirEventoTCClick(Sender: TObject);
procedure ChckBxTitularesCasaClick(Sender: TObject);
procedure DBGrdTitularesCasaCellClick(Column: TColumn);
procedure BtnCadJogadoresTFClick(Sender: TObject);
private
ConBD: TDtMdlDados;
BD: TDtMdlLancesJogo;
Jogo: TJogo;
CodJogo: Integer;
codTemporada: Integer;
ImagensLanceJogo: Array [0..49,1..2] of Integer; //(Coluna da imagem , Tipo da
Imagem)
TotEventos: Integer;
CountEventos: Integer;
public
procedure SetBD (var umaConBD:TDtMdlDados);
procedure DefinirLancesJogo (umaTemporada: TTemporada; umCodJogo: Integer);
procedure AtualizarInterfaceTC;
procedure AtualizarInterfaceTF;
procedure AtualizarDadosJogos;
procedure AtualizarLancesJogo;
end;
var
FrmLancesJogo: TFrmLancesJogo;
implementation
{$R *.nfm}
procedure TFrmLancesJogo.SetBD (var umaConBD:TDtMdlDados);
begin
BD := TDtMdlLancesJogo.Create(nil);
BD.SetConexaoBD (umaConBD);
conBD := umaConBD;
end;
procedure TFrmLancesJogo.DefinirLancesJogo (umaTemporada: TTemporada; umCodJogo:
Integer);
var
Minutos, i: Integer;
begin
Temporada := UmaTemporada;
CodTemporada := Temporada.GetCodTemporada;
BD.SQLDtStJogo.ParamByName('Cod').asInteger := CodJogo;
BD.ClntDtStJogo.Close;
BD.ClntDtStJogo.Open;
BD.ClntDtStJogo.First;
Jogo := TJogo.Create; Jogo.SetBD (ConBD);
Jogo.Materializar(umCodJogo);
Self.AtualizarInterfaceTC;
Self.AtualizarInterfaceTF;
160
Self.AtualizarDadosJogos;
Self.AtualizarLancesJogo;
TbShtTimeCasa.Caption := BD.ClntDtStJogo.FieldByName('NomeEquipe').AsString;
TbShtTimeFora.Caption := BD.ClntDtStJogo.FieldByName('NomeEquipe_1').AsString;
Minutos := 90;
if BD.ClntDtStJogo.FieldByName('Prorrogacao').AsInteger = 1 then Minutos := 120;
for i:=1 to minutos do begin
CmbBxMinutosCasa.Items.Add(IntToStr(i) + '''');
end;
CmbBxMinutosFora.Items.Add(IntToStr(i) + '''');
end;
CmbBxMinutosCasa.ItemIndex := 0;
CmbBxMinutosFora.ItemIndex := 0;
PageControl1.ActivePage := TbShtTimeCasa;
ShowModal;
end;
procedure TFrmLancesJogo.AtualizarInterfaceTC;
var
SQL: String;
begin
PnlTimeCasa.Caption := BD.ClntDtStJogo.FieldByName('NomeEquipe').AsString;
if ChckBxTitularesCasa.Checked = True then begin
SQL := 'Select * from Jogador J, EscalacaoJogo EJ where J.CodJogador = EJ.CodJogador
and EJ.CodJogo=' + IntToStr(CodJogo) + ' and EJ.CodEquipe=' +
IntToStr(BD.ClntDtStJogo.FieldByName('CodEquipeCasa').AsInteger);
end else begin
SQL := 'Select * from Jogador J where J.CodEquipe=' +
BD.ClntDtStJogo.FieldByName('CodEquipeCasa').AsString + ' and J.CodTemporada=' +
IntToStr(CodTemporada);
end;
BD.SQLDtStJogadoresCasa.CommandText := SQL;
with BD.ClntDtStJogadoresCasa do begin
Close;
Open;
First;
end;
PnlJogadorEventoCasa.Caption := ' ' +
BD.ClntDtStJogadoresCasa.FieldByName('ApelidoJogador').asString;
end;
procedure TFrmLancesJogo.AtualizarInterfaceTF;
var
SQL: String;
begin
PnlTimeFora.Caption := BD.ClntDtStJogo.FieldByName('NomeEquipe_1').AsString;
if ChckBxTitularesFora.Checked = True then begin
SQL := 'Select * from Jogador J, EscalacaoJogo EJ where J.CodJogador = EJ.CodJogador
and EJ.CodJogo=' + IntToStr(CodJogo) + ' and EJ.CodEquipe=' +
IntToStr(BD.ClntDtStJogo.FieldByName('CodEquipeFora').AsInteger);
end else begin
SQL := 'Select * from Jogador J where J.CodEquipe=' +
BD.ClntDtStJogo.FieldByName('CodEquipeFora').AsString + ' and J.CodTemporada=' +
IntToStr(CodTemporada);
end;
BD.SQLDtStJogadoresFora.CommandText := SQL;
with BD.ClntDtStJogadoresFora do begin
Close;
Open;
First;
end;
PnlJogadorEventoFora.Caption := ' ' +
BD.ClntDtStJogadoresFora.FieldByName('ApelidoJogador').asString;
end;
procedure TFrmLancesJogo.ChckBxTitularesForaClick(Sender: TObject);
begin
end;
procedure TFrmLancesJogo.DBGrdTitularesForaCellClick(Column: TColumn);
begin
PnlJogadorEventoFora.Caption := ' ' +
BD.ClntDtStJogadoresFora.FieldByName('ApelidoJogador').asString;
end;
161
procedure TFrmLancesJogo.AtualizarDadosJogos;
var
SQL: String;
begin
ImgTimeCasa.Picture.Bitmap.FreeImage;
ImgTimeFora.Picture.Bitmap.FreeImage;
PnlNomeTC.Caption := '';
PnlNomeTF.Caption := '';
PnlDadosJogo1.Caption := '';
PnlPlacarJogo.Caption := '';
PnlPlacarProrrogacao.Caption := '';
PnlPlacarPenaltis.Caption := '';
ImgTimeCasa.Picture.Bitmap.LoadFromStream(BD.ClntDtStJogo.CreateBlobStream(BD.ClntDtStJo
go.FieldByName('Escudo'),bmRead));
ImgTimeFora.Picture.Bitmap.LoadFromStream(BD.ClntDtStJogo.CreateBlobStream(BD.ClntDtStJo
go.FieldByName('Escudo_1'),bmRead));
PnlNomeTC.Caption := BD.ClntDtStJogo.FieldByName('NomeEquipe').asString;
PnlNomeTF.Caption := BD.ClntDtStJogo.FieldByName('NomeEquipe_1').asString;
if BD.ClntDtStJogo.FieldByName('CodEstadio').asInteger <> 0 then begin
SQL := 'Select * from Estadio where CodEstadio=' +
BD.ClntDtStJogo.FieldByName('CodEstadio').asString;
Close;
Open;
First;
end;
PnlDadosJogo1.Caption := BD.ClntDtStDados.FieldByName('NomeEstadio').asString + ' ' + BD.ClntDtStDados.FieldByName('CidadeEstadio').asString + ' - ' +
BD.ClntDtStDados.FieldByName('Pais').asString;
end;
if BD.ClntDtStJogo.FieldByName('Realizado').asInteger = 1 then begin
PnlPlacarJogo.Caption := BD.ClntDtStJogo.FieldByName('GolsTimeCasa').asString + ' ' + BD.ClntDtStJogo.FieldByName('GolsTimeFora').asString;
if BD.ClntDtStJogo.FieldByName('Prorrogacao').asInteger = 1 then begin
PnlPlacarProrrogacao.Caption :=
BD.ClntDtStJogo.FieldByName('GolsTimeCasaProrrogacao').asString + ' - Pro - ' +
BD.ClntDtStJogo.FieldByName('GolsTimeForaProrrogacao').asString;
end;
if BD.ClntDtStJogo.FieldByName('Penaltis').asInteger = 1 then begin
PnlPlacarPenaltis.Caption :=
BD.ClntDtStJogo.FieldByName('GolsTimeCasaPenaltis').asString + ' - Pn - ' +
BD.ClntDtStJogo.FieldByName('GolsTimeForaPenaltis').asString;
end;
end;
end;
procedure TFrmLancesJogo.AtualizarLancesJogo;
var
MinutosSubst, MinutosLance: Integer;
Subst, Lance: boolean;
Evento: Integer;
MinutoUltimoLance: Integer;
x,y: integer;
TC, TF: Integer;
begin
// Limpa o String Grid
for x:=0 to StrGrdEventosJogo.ColCount do begin
for y:=0 to StrGrdEventosJogo.RowCount do begin
StrGrdEventosJogo.Cells[x,y]:='';
end;
end;
// Inicia as variaveis
Evento := 0;
MinutoUltimoLance := 0;
Subst := True;
Lance := True;
MinutosSubst := 0;
MinutosSubst := 0;
TC := BD.ClntDtStJogo.FieldByName('CodEquipeCasa').AsInteger;
TF := BD.ClntDtStJogo.FieldByName('CodEquipeFora').AsInteger;
// Busca no BD as Substituicoes
BD.SQLDtStSubst.ParamByName('CodJogo').AsInteger := CodJogo;
BD.SQLDtStSubst.ParamByName('CodEquipeCasa').AsInteger := TC;
162
BD.SQLDtStSubst.ParamByName('CodEquipeFora').AsInteger := TF;
with BD.ClntDtStSubst do begin
Close;
Open;
First;
end;
BD.SQLDtStLancesJogo.ParamByName('CodJogo').AsInteger := CodJogo;
BD.SQLDtStLancesJogo.ParamByName('CodEquipeCasa').AsInteger := TC;
BD.SQLDtStLancesJogo.ParamByName('CodEquipeFora').AsInteger := TF;
with BD.ClntDtStLancesJogo do begin
Close;
Open;
First;
end;
repeat
if BD.ClntDtStSubst.Eof = False then begin
MinutosSubst := BD.ClntDtStSubst.FieldByName('MinutoSubstituicao').asInteger;
end else begin
Subst := False;
end;
if BD.ClntDtStLancesJogo.Eof = False then begin
MinutosLance := BD.ClntDtStLancesJogo.FieldByName('Minuto').asInteger;
end else begin
Lance := False;
end;
if ((Subst=True) and (Lance=True)) then begin
if MinutosSubst < MinutosLance then begin
if BD.ClntDtStSubst.FieldByName('CodEquipe').AsInteger = TC then begin
StrGrdEventosJogo.Cells[0,Evento] := 'In:' +
BD.ClntDtStSubst.FieldByName('ApelidoJogador').asString + ' / Out:' +
BD.ClntDtStSubst.FieldByName('ApelidoJogador_1').asString;
ImagensLanceJogo [Evento,1] := 1; //(Coluna da imagem , Tipo da Imagem)
ImagensLanceJogo [Evento,2] := 1;
end else begin
end;
if MinutosSubst <> MinutoUltimoLance then begin
StrGrdEventosJogo.Cells[2,Evento] := intToStr(MinutosSubst) + '''';
MinutoUltimoLance := MinutosSubst;
end;
BD.ClntDtStSubst.Next;
end else begin
ItemCombo.setOid(BD.ClntDtStLancesJogo.FieldByName('CodLancePartida').asInteger);
case BD.ClntDtStLancesJogo.FieldByName('TipoLance').AsInteger of
1: begin // Gol
if BD.ClntDtStLancesJogo.FieldByName('CodEquipeLance').AsInteger = TC
then begin
StrGrdEventosJogo.Cells[0,Evento] :=
BD.ClntDtStLancesJogo.FieldByName('ApelidoJogador').asString;
StrGrdEventosJogo.Objects[0,Evento] := ItemCombo;
end else begin
end;
end;
2: begin // Gol de Penalti
then begin
end else begin
163
end;
end;
3: begin // Gol Contra
then begin
end else begin
end;
end;
4: begin // Carto Amarelo
then begin
end else begin
end;
end;
5: begin // Carto Amarelo e Vermelho
then begin
end else begin
end;
end;
6: begin // Carto Vermelho
then begin
end else begin
end;
end;
end;
ItemCombo.Free;
if MinutosLance <> MinutoUltimoLance then begin
StrGrdEventosJogo.Cells[2,Evento] := intToStr(MinutosLance) + '''';
MinutoUltimoLance := MinutosLance;
end;
BD.ClntDtStLancesJogo.Next;
end;
164
Evento := Evento + 1;
end else begin
if (Subst=True) then begin
if BD.ClntDtStSubst.FieldByName('CodEquipe').AsInteger = TC then begin
end else begin
end;
if MinutosSubst <> MinutoUltimoLance then begin
StrGrdEventosJogo.Cells[2,Evento] := intToStr(MinutosSubst) + '''';
MinutoUltimoLance := MinutosSubst;
end;
BD.ClntDtStSubst.Next;
end else begin
if (Lance=True) then begin
ItemCombo.setOid(BD.ClntDtStLancesJogo.FieldByName('CodLancePartida').asInteger);
case BD.ClntDtStLancesJogo.FieldByName('TipoLance').AsInteger of
1: begin // Gol
then begin
ImagensLanceJogo [Evento,1] := 1; //(Coluna da imagem , Tipo da
Imagem)
end else begin
Imagem)
end;
end;
2: begin // Gol de Penalti
then begin
Imagem)
end else begin
Imagem)
end;
end;
3: begin // Gol Contra
then begin
Imagem)
end else begin
165

Imagem)
end;
end;
4: begin // Carto Amarelo
then begin
Imagem)
end else begin
Imagem)
end;
end;
5: begin // Carto Amarelo e Vermelho
then begin
Imagem)
end else begin
Imagem)
end;
end;
6: begin // Carto Vermelho
then begin
Imagem)
end else begin
Imagem)
end;
end;
end;
ItemCombo.Free;
if MinutosLance <> MinutoUltimoLance then begin
StrGrdEventosJogo.Cells[2,Evento] := intToStr(MinutosLance) + '''';
MinutoUltimoLance := MinutosLance;
end;
BD.ClntDtStLancesJogo.Next;
end;
end;
Evento := Evento + 1;
end;
TotEventos := Evento - 1;
StrGrdEventosJogo.RowCount := Evento + 1;
until ((Subst=False) and (Lance=False));
end;
procedure TFrmLancesJogo.StrGrdEventosJogoDrawCell(Sender: TObject; ACol,
166

var
Texto: string;
X: Integer;
begin
// Coloca Desenho
if ARow <= TotEventos-1 then begin
if (ACol = ImagensLanceJogo[ARow,1]) then begin
with StrGrdEventosJogo.Canvas do begin
case ImagensLanceJogo[ARow,2] of
1: Draw(Rect.Left, Rect.Top, ImgSubst.Picture.Graphic);
2: Draw(Rect.Left, Rect.Top, ImgGol.Picture.Graphic);
3: Draw(Rect.Left, Rect.Top, ImgGolPen.Picture.Graphic);
4: Draw(Rect.Left, Rect.Top, ImgGolContra.Picture.Graphic);
5: Draw(Rect.Left, Rect.Top, ImgAmarelo.Picture.Graphic);
6: Draw(Rect.Left, Rect.Top, ImgAmaVer.Picture.Graphic);
7: Draw(Rect.Left, Rect.Top, ImgVermelho.Picture.Graphic);
end;
end;
end;
end;
Texto := StrGrdEventosJogo.Cells[ACol, ARow];
if ACol = 0 then begin
X := Rect.Right - StrGrdEventosJogo.Canvas.TextWidth(Texto) - 2;
StrGrdEventosJogo.Canvas.TextRect(Rect, X, Rect.Top+2, Texto);
StrGrdEventosJogo.Canvas.DrawFocusRect(Rect);
end;
end else begin
if ACol = 2 then begin
X := Rect.Left + ((Rect.Right - Rect.Left) StrGrdEventosJogo.Canvas.TextWidth(Texto)) div 2;
StrGrdEventosJogo.Canvas.TextRect(Rect, X, Rect.Top+2, Texto);
StrGrdEventosJogo.Canvas.DrawFocusRect(Rect);
end;
end;
end;
end;
procedure TFrmLancesJogo.BtnIncluirEventoTFClick(Sender: TObject);
var
TC, TF: Integer;
Minuto: Integer;
TempoJogo: String;
begin
TempoJogo := CmbBxMinutosFora.Text;
SetLength(TempoJogo, Length(TempoJogo) - 1);
Minuto := StrToInt(TempoJogo);
try
Case CmbBxEventoFora.ItemIndex of
0:
begin
if Jogo.GetNumLancesGolsTF < Jogo.GetGolsTimeFora +
Jogo.GetGolsTimeForaProrrogacao then begin
Jogo.IncluirLancePartida (TF, TF,
BD.ClntDtStJogadoresFora.FieldByName('CodJogador').AsInteger,
CmbBxEventoFora.ItemIndex+1, Minuto);
end else begin
ShowMessage ('J Foram inclusos todos os eventos de gols deste time');
end;
end;
1:
begin
end else begin
end;
end;
2:
begin
167
if Jogo.GetNumLancesGolsTC < Jogo.GetGolsTimeCasa +

Jogo.GetGolsTimeCasaProrrogacao then begin
Jogo.IncluirLancePartida (TF, TC,
end else begin
end;
end
else begin
end;
end;
except
Suporte');
end;
end;
end;
procedure TFrmLancesJogo.FormDestroy(Sender: TObject);
begin
BD.Destroy;
Jogo.Destroy;
Temporada.Destroy;
end;
procedure TFrmLancesJogo.StrGrdEventosJogoMouseDown(Sender: TObject;
var
Point : TPoint;
begin
GetCursorPos(Point);
if Button = mbRight then PopupMenu1.PopUp(Point.X,Point.Y);
end;
procedure TFrmLancesJogo.ExcluirEvento1Click(Sender: TObject);
var
Selecionado: TRect;
X, Y: Integer;
begin
Selecionado := StrGrdEventosJogo.Selection;
Y := Selecionado.Top;
X := Selecionado.Right;
try
if TItemCombo(StrGrdEventosJogo.Objects[X,Y]).GetOid <> 0 then begin
Jogo.ExcluirLancePartida(TItemCombo(StrGrdEventosJogo.Objects[X,Y]).GetOid);
TItemCombo(StrGrdEventosJogo.Objects[X,Y]).SetOid(0);
end else begin
ShowMessage ('ERRO: No possvel excluir o evento selecionado');
end;
except
ShowMessage ('ERRO: No possvel excluir o evento selecionado');
end;
end;
end;
procedure TFrmLancesJogo.BtnIncluirEventoTCClick(Sender: TObject);
var
TC, TF: Integer;
Minuto: Integer;
TempoJogo: String;
begin
TempoJogo := CmbBxMinutosCasa.Text;
Minuto := StrToInt(TempoJogo);
try
Case CmbBxEventoCasa.ItemIndex of
0:
168
begin
Jogo.IncluirLancePartida (TC, TC,
BD.ClntDtStJogadoresCasa.FieldByName('CodJogador').AsInteger,
CmbBxEventoCasa.ItemIndex+1, Minuto);
end else begin
end;
end;
1:
begin
end else begin
end;
end;
2:
begin
Jogo.IncluirLancePartida (TC, TF,
end else begin
end;
end
else begin
end;
end;
except
Suporte');
end;
end;
end;
procedure TFrmLancesJogo.ChckBxTitularesCasaClick(Sender: TObject);
begin
end;
procedure TFrmLancesJogo.DBGrdTitularesCasaCellClick(Column: TColumn);
begin
PnlJogadorEventoCasa.Caption := ' ' +
BD.ClntDtStJogadoresCasa.FieldByName('ApelidoJogador').asString;
end;
procedure TFrmLancesJogo.BtnCadJogadoresTFClick(Sender: TObject);
var
begin
FrmCadJogador.Mostrar(Temporada,
BD.ClntDtStJogo.FieldByName('CodEquipeCasa').AsInteger);
end;
end.
========================================================================================
====
ARQUIVO: UImporta.pas
========================================================================================
====
169
unit UIImporta;
interface
uses
Dialogs, Borland.Vcl.Buttons, Borland.Vcl.StdCtrls, System.ComponentModel,
UDMDados, Borland.Vcl.Grids, Borland.Vcl.DBGrids, Borland.Vcl.ExtCtrls,
FMTBcd, Borland.Vcl.Db, Borland.Vcl.DBClient, Borland.Vcl.Provider,
Borland.Vcl.SqlExpr, UTemporada, UIEquipeEquivalente,
Borland.Vcl.ComCtrls;
type
TFrmImporta = class(TForm)
OpenDialog1: TOpenDialog;
Panel5: TPanel;
SQLDtStRodadas: TSQLDataSet;
DtStPrvdrRodadas: TDataSetProvider;
ClntDtStRodadas: TClientDataSet;
DtSrcRodadas: TDataSource;
LstBxJogos: TListBox;
Panel6: TPanel;
ImgBranco: TImage;
Panel7: TPanel;
Panel8: TPanel;
Label1: TLabel;
LstBxCampos: TListBox;
LstBxCamposImportados: TListBox;
BtnIncluirCampo: TButton;
BtnExcluirCampo: TButton;
Button1: TButton;
EdtNomeArquivo: TEdit;
Panel3: TPanel;
Panel4: TPanel;
Panel1: TPanel;
Panel2: TPanel;
PrgrssBrLinhas: TProgressBar;
PnlLinhas: TPanel;
Label2: TLabel;
DtTmPckrDataJogo: TDateTimePicker;
BtnImportar: TBitBtn;
BtnFechar: TBitBtn;
procedure BtnIncluirCampoClick(Sender: TObject);
procedure BtnExcluirCampoClick(Sender: TObject);
procedure LstBxCamposDblClick(Sender: TObject);
procedure LstBxCamposImportadosDblClick(Sender: TObject);
procedure Button1Click(Sender: TObject);
procedure BtnImportarClick(Sender: TObject);
private
conBD: TDtMdlDados;
NumRodadas: Integer;
FrmEquipeEquivalente: TFrmEquipeEquivalente;
Foto1, Foto2 : TMemoryStream;
public
170
procedure
procedure
procedure
procedure
procedure
procedure
end;
SetBD(var umaConBD: TDtMdlDados);

AtualizarFases;
AtualizarGrupos;
AtualizarRodadas;
AdicionarRodada;
GravaJogo;
var
FrmImporta: TFrmImporta;
implementation
{$R *.nfm}
procedure TFrmImporta.SetBD (var umaConBD: TDtMdlDados);
begin
conBD := umaConBD;
end;
procedure TFrmImporta.Mostrar(umaTemp: TTemporada);
begin
FrmEquipeEquivalente := TFrmEquipeEquivalente.Create(nil);
FrmEquipeEquivalente.SetBD(conBD); FrmEquipeEquivalente.SetTemporada(Temporada);
Self.ShowModal;
end;
procedure TFrmImporta.BtnFecharClick(Sender: TObject);
begin
Self.Close;
end;
procedure TFrmImporta.BtnIncluirCampoClick(Sender: TObject);
begin
if LstBxCampos.itemindex >= 0 then begin
LstBxCamposImportados.Items.Add(LstBxCampos.items[LstBxCampos.itemindex]);
LstBxCampos.Items.delete(LstBxCampos.itemindex);
end;
end;
procedure TFrmImporta.BtnExcluirCampoClick(Sender: TObject);
begin
if LstBxCamposImportados.itemindex >= 0 then begin
LstBxCampos.Items.Add(LstBxCamposImportados.items[LstBxCamposImportados.itemindex]);
LstBxCamposImportados.Items.delete(LstBxCamposImportados.itemindex);
end;
end;
procedure TFrmImporta.LstBxCamposDblClick(Sender: TObject);
begin
Self.BtnIncluirCampoClick(Sender);
end;
procedure TFrmImporta.LstBxCamposImportadosDblClick(Sender: TObject);
begin
Self.BtnExcluirCampoClick(Sender);
end;
procedure TFrmImporta.Button1Click(Sender: TObject);
begin
if OpenDialog1.Execute then begin
EdtNomeArquivo.Text := OpenDialog1.FileName;
end;
end;
procedure TFrmImporta.BtnImportarClick(Sender: TObject);
var
Arquivo: TextFile;
Linha, Palavra, Letra, LetraAnterior: String;
TamLinha, i: Integer;
Comecou, NovaRodada: Boolean;
begin
PrgrssBrLinhas.Max := 0;
PrgrssBrLinhas.Min := 0;
PrgrssBrLinhas.Position := 0;
171
if fileExists(EdtNomeArquivo.Text) then begin

assignFile(Arquivo, EdtNomeArquivo.Text);
reset(Arquivo);
while not eof(Arquivo) do begin
readln(Arquivo);
PrgrssBrLinhas.Max := PrgrssBrLinhas.Max + 1;
end;
reset(Arquivo);
readln(Arquivo, Linha);
NovaRodada := True;
while not eof(Arquivo) do begin
Comecou := False;
LetraAnterior := ' ';
TamLinha := length(Linha);
if TamLinha < 11 then begin
try
DtTmPckrDataJogo.DateTime := StrToDateTime (Linha);
Except
NovaRodada := True;
end;
end;
end else begin
for i := 1 to TamLinha do begin
if Linha[i] = #9 then begin
Letra := ' ';
end else begin
Letra := Linha[i];
end;
if ((Letra = ' ') and ((LetraAnterior = ' ') or (LetraAnterior = ' '))) then
begin
Letra := ' ';
end;
if Letra <> ' ' then begin
if not Comecou then begin
Palavra := Letra;
Comecou := True;
end else begin
if Letra <> ' ' then begin
Palavra := Palavra + Letra;
end;
end;
end else begin
if Comecou then begin
LstBxJogos.Items.Add(Palavra);
comecou := false;
end;
end;
LetraAnterior := Letra;
end;
if Comecou then begin
LstBxJogos.Items.Add(Palavra);
Comecou := False;
end;
if NovaRodada = True then begin
Self.AdicionarRodada;
ClntDtStRodadas.Last;
NovaRodada := False;
end;
Self.GravaJogo;
end;
PrgrssBrLinhas.Position := PrgrssBrLinhas.Position + 1;
PnlLinhas.Caption := IntToStr(PrgrssBrLinhas.Position) + ' Linhas Lidas de ' +
IntToStr(PrgrssBrLinhas.Max);
readln(Arquivo, Linha);
end;
CloseFile(Arquivo);
end else begin
ShowMessage ('Arquivo Inexistente');
end;
end;
procedure TFrmImporta.AtualizarFases;
begin
SQLDtStFases.ParamByName('codTemp').AsInteger := Temporada.GetCodTemporada;
172
ClntDtStFases.Open;
end;
procedure TFrmImporta.AtualizarGrupos;
begin
end;
procedure TFrmImporta.AtualizarRodadas;
var
SQL: String;
begin
SQLDtStRodadas.ParamByName('CodGrupo').AsInteger :=
ClntDtStGrupos.FieldByName('CodEstruturaTemporada').AsInteger;
ClntDtStRodadas.Close;
ClntDtStRodadas.Open;
ClntDtStRodadas.First;
SQL := 'Select COUNT(*) from ESTRUTURATEMPORADA where CODGRUPO=' +
ClntDtStGrupos.FieldByName('CodEstruturaTemporada').AsString;
ClntDtStDados.Open;
NumRodadas := ClntDtStDados.FieldByName('Count').AsInteger;
end;
procedure TFrmImporta.AdicionarRodada;
begin
try
if NumRodadas < 9 then begin
Temporada.IncluirRodada('0'+IntToStr(NumRodadas+1),
ClntDtStFases.FieldByName('codEstruturaTemporada').AsInteger,
ClntDtStGrupos.FieldByName('codEstruturaTemporada').AsInteger);
end else begin
Temporada.IncluirRodada(IntToStr(NumRodadas+1),
end;
Except
Suporte');
end;
end;
end;
procedure TFrmImporta.GravaJogo;
var
i, CodEstTemp, CodEquipeCasa, CodEquipeFora, GolsEquipeCasa, GolsEquipeFora, Publico,
Realizado, CodEstadio: Integer;
begin
if LstBxJogos.Items.Count <> LstBxCamposImportados.Items.Count then begin
ShowMessage('Erro na Linha');
end else begin
CodEquipeCasa := 0;
CodEstadio := 0;
CodEquipeFora := 0;
GolsEquipeCasa := 0;
GolsEquipeFora := 0;
Publico := 0;
Realizado := 0;
for i := 0 to LstBxCamposImportados.items.Count-1 do begin
if LstBxCamposImportados.Items[i] = 'Equipe da Casa' then begin
CodEquipeCasa := FrmEquipeEquivalente.RetorneCodigoEquipe(LstBxJogos.Items[i]);
CodEstadio := FrmEquipeEquivalente.GetCodEstadio(CodEquipeCasa);
end;
if LstBxCamposImportados.Items[i] = 'Equipe Visitante' then begin
CodEquipeFora := FrmEquipeEquivalente.RetorneCodigoEquipe(LstBxJogos.Items[i]);
end;
173
if LstBxCamposImportados.Items[i] = 'Gols Equipe da Casa' then begin

GolsEquipeCasa := StrToInt(LstBxJogos.Items[i]);
end;
if LstBxCamposImportados.Items[i] = 'Gols Equipe Visitante' then begin
GolsEquipeFora := StrToInt(LstBxJogos.Items[i]);
Realizado := 1;
end;
if LstBxCamposImportados.Items[i] = 'Data' then begin
DtTmPckrDataJogo.DateTime := StrToDateTime(LstBxJogos.Items[i]);
end;
if LstBxCamposImportados.Items[i] = 'Pblico' then begin
Publico := StrToInt(LstBxJogos.Items[i]);
end;
end;
CodEstTemp := ClntDtStRodadas.FieldByName('CodEstruturaTemporada').AsInteger;
try
Temporada.NovoJogo(CodEstTemp, CodEquipeCasa, CodEquipeFora,
DtTmPckrDataJogo.DateTime, 0, CodEstadio, Realizado, GolsEquipeCasa,
GolsEquipeFora, 0, 0, 0, 0, 0, 0, Publico, 0, 0, 0, 0, 0, 0, 0, 0, '',
'', Foto1, Foto2);
except
end;
end;
LstBxJogos.Items.Clear;
end;
end;
procedure TFrmImporta.FormCreate(Sender: TObject);
begin
Foto1 := TMemoryStream.Create;
ImgBranco.Picture.Graphic.SaveToStream(Foto1);
ImgBranco.Picture.Graphic.SaveToStream(Foto2);
end;
procedure TFrmImporta.FormDestroy(Sender: TObject);
begin
Foto1.Free;
Foto2.Free;
FrmEquipeEquivalente.Destroy;
end;
procedure TFrmImporta.DBGrdFasesCellClick(Column: TColumn);
begin
end;
procedure TFrmImporta.DBGrdGruposCellClick(Column: TColumn);
begin
end;
end.
========================================================================================
====
ARQUIVO: UIEscalacao.pas
========================================================================================
====
unit UIEscalacao;
interface
uses
Dialogs, Borland.Vcl.Grids, System.ComponentModel, Borland.Vcl.StdCtrls,
Borland.Vcl.ExtCtrls, Borland.Vcl.ComCtrls, Borland.Vcl.Buttons,
UDMIEscalacao, UDMDados, UTemporada, UItemCombo, Borland.Vcl.DBGrids,
FMTBcd, DBXpress, Borland.Vcl.Db, Borland.Vcl.SqlExpr, UJogo,
Borland.Vcl.DBClient, Borland.Vcl.Provider, UICadJogador;
type
TFrmEscalacao = class(TForm)
TPageControl1: TPageControl;
TbShtTimeCasa: TTabSheet;
174
TbShtTimeFora: TTabSheet;
Panel1: TPanel;
GrpBxSubFora: TGroupBox;
Label1: TLabel;
Label2: TLabel;
Label3: TLabel;
CmbBxReservasFora: TComboBox;
CmbBxTitularesFora: TComboBox;
CmbBxMinutosFora: TComboBox;
BtnSubFora: TButton;
BtnEscalarJF: TButton;
BtnDesEscalarJF: TButton;
PnlTimeFora: TPanel;
BtnFechar: TBitBtn;
BtnCadJogadoresTF: TButton;
DBGrdJogadoresFora: TDBGrid;
DBGrdTitularesFora: TDBGrid;
GrpBxSubFeitasFora: TGroupBox;
BtnRemoverSubst1TF: TButton;
SQLDtStJogadorFora: TSQLDataSet;
DtStPrvdrJogadorFora: TDataSetProvider;
ClntDtStJogadorFora: TClientDataSet;
ClntDtStJogadorForaCODJOGADOR: TIntegerField;
ClntDtStJogadorForaCODEQUIPE: TIntegerField;
ClntDtStJogadorForaCODTEMPORADA: TIntegerField;
ClntDtStJogadorForaAPELIDOJOGADOR: TStringField;
ClntDtStJogadorForaNOMEJOGADOR: TStringField;
ClntDtStJogadorForaNUMEROCAMISA: TIntegerField;
ClntDtStJogadorForaDATANASCIMENTO: TDateField;
ClntDtStJogadorForaNACIONALIDADE: TStringField;
ClntDtStJogadorForaPOSICAO: TIntegerField;
ClntDtStJogadorForaSTATUS: TStringField;
ClntDtStJogadorForaEMAIL: TStringField;
ClntDtStJogadorForaFOTO: TBlobField;
DtSrcJogadorFora: TDataSource;
SQLDtStEscJogoFora: TSQLDataSet;
DtStPrvdrEscJogoFora: TDataSetProvider;
ClntDtStEscJogoFora: TClientDataSet;
ClntDtStEscJogoForaCODJOGADOR: TIntegerField;
ClntDtStEscJogoForaCODEQUIPE: TIntegerField;
ClntDtStEscJogoForaCODTEMPORADA: TIntegerField;
ClntDtStEscJogoForaAPELIDOJOGADOR: TStringField;
ClntDtStEscJogoForaNOMEJOGADOR: TStringField;
ClntDtStEscJogoForaNUMEROCAMISA: TIntegerField;
ClntDtStEscJogoForaDATANASCIMENTO: TDateField;
ClntDtStEscJogoForaNACIONALIDADE: TStringField;
ClntDtStEscJogoForaPOSICAO: TIntegerField;
ClntDtStEscJogoForaEMAIL: TStringField;
ClntDtStEscJogoForaFOTO: TBlobField;
ClntDtStEscJogoForaCODJOGO: TIntegerField;
ClntDtStEscJogoForaCODEQUIPE_1: TIntegerField;
ClntDtStEscJogoForaCODJOGADOR_1: TIntegerField;
ClntDtStEscJogoForaSTATUS_1: TStringField;
ClntDtStEscJogoForaCODJOGADORENTROU: TIntegerField;
ClntDtStEscJogoForaPos: TStringField;
ClntDtStEscJogoForaMin: TStringField;
DtSrcEscJogoFora: TDataSource;
Panel2: TPanel;
Panel8: TPanel;
ImgJF: TImage;
LblNomeJF: TLabel;
LblCamisaJF: TLabel;
LblPosicaoJF: TLabel;
LblIdadeJF: TLabel;
LblNacionalidadeJF: TLabel;
ClntDtStEscJogoForaSAIU: TStringField;
ClntDtStEscJogoForaSTATUS: TStringField;
Panel3: TPanel;
GrpBxSubCasa: TGroupBox;
Label4: TLabel;
Label5: TLabel;
Label6: TLabel;
CmbBxReservasCasa: TComboBox;
CmbBxTitularesCasa: TComboBox;
CmbBxMinutosCasa: TComboBox;
175
BtnSubCasa: TButton;
BtnEscalarJC: TButton;
BtnDesEscalarJC: TButton;
PnlTimeCasa: TPanel;
BtnCadJogadoresTC: TButton;
DBGrdJogadoresCasa: TDBGrid;
DBGrdTitularesCasa: TDBGrid;
GrpBxSubFeitasCasa: TGroupBox;
BtnRemoverSubst1TC: TButton;
Panel5: TPanel;
LblNomeJC: TLabel;
LblCamisaJC: TLabel;
LblPosicaoJC: TLabel;
LblIdadeJC: TLabel;
LblNacionalidadeJC: TLabel;
Panel6: TPanel;
ImgJC: TImage;
SQLDtStEscJogoCasa: TSQLDataSet;
DtStPrvdrEscJogoCasa: TDataSetProvider;
ClntDtStEscJogoCasa: TClientDataSet;
DtSrcEscJogoCasa: TDataSource;
SQLDtStJogadorCasa: TSQLDataSet;
DtStPrvdrJogadorCasa: TDataSetProvider;
ClntDtStJogadorCasa: TClientDataSet;
IntegerField11: TIntegerField;
StringField10: TStringField;
DateField2: TDateField;
BlobField2: TBlobField;
DtSrcJogadorCasa: TDataSource;
ClntDtStEscJogoCasaCODJOGADOR: TIntegerField;
ClntDtStEscJogoCasaCODEQUIPE: TIntegerField;
ClntDtStEscJogoCasaCODTEMPORADA: TIntegerField;
ClntDtStEscJogoCasaAPELIDOJOGADOR: TStringField;
ClntDtStEscJogoCasaNOMEJOGADOR: TStringField;
ClntDtStEscJogoCasaNUMEROCAMISA: TIntegerField;
ClntDtStEscJogoCasaDATANASCIMENTO: TDateField;
ClntDtStEscJogoCasaNACIONALIDADE: TStringField;
ClntDtStEscJogoCasaPOSICAO: TIntegerField;
ClntDtStEscJogoCasaSTATUS: TStringField;
ClntDtStEscJogoCasaEMAIL: TStringField;
ClntDtStEscJogoCasaFOTO: TBlobField;
ClntDtStEscJogoCasaCODJOGO: TIntegerField;
ClntDtStEscJogoCasaCODEQUIPE_1: TIntegerField;
ClntDtStEscJogoCasaCODJOGADOR_1: TIntegerField;
ClntDtStEscJogoCasaCODJOGADORENTROU: TIntegerField;
ClntDtStEscJogoCasaSTATUS_1: TStringField;
ClntDtStEscJogoCasaSAIU: TStringField;
ClntDtStEscJogoCasaPos: TStringField;
ClntDtStEscJogoCasaMin: TStringField;
ClntDtStEscJogoCasaTEMPOJOGADO: TIntegerField;
ClntDtStEscJogoCasaMINUTOSUBSTITUICAO: TIntegerField;
ClntDtStEscJogoForaTEMPOJOGADO: TIntegerField;
ClntDtStEscJogoForaMINUTOSUBSTITUICAO: TIntegerField;
procedure ClntDtStEscJogoForaCalcFields(DataSet: TDataSet);
procedure DBGrdTitularesForaCellClick(Column: TColumn);
procedure BtnEscalarJFClick(Sender: TObject);
procedure BtnDesEscalarJFClick(Sender: TObject);
procedure DBGrdJogadoresForaDblClick(Sender: TObject);
procedure BtnSubForaClick(Sender: TObject);
procedure ClntDtStEscJogoCasaCalcFields(DataSet: TDataSet);
procedure BtnEscalarJCClick(Sender: TObject);
procedure BtnDesEscalarJCClick(Sender: TObject);
procedure BtnSubCasaClick(Sender: TObject);
procedure BtnRemoverSubst1TCClick(Sender: TObject);
176

procedure BtnRemoverSubst1TFClick(Sender: TObject);
procedure DBGrdTitularesCasaCellClick(Column: TColumn);
procedure DBGrdJogadoresCasaDblClick(Sender: TObject);
procedure BtnCadJogadoresTCClick(Sender: TObject);
procedure BtnCadJogadoresTFClick(Sender: TObject);
private
BD: TDtMdlIEscalacao;
conBD: TDtMdlDados;
Jogo: TJogo;
CodJogo: Integer;
codTemporada: Integer;
Minutos: Integer;
SubstituicoesTF: Array [1..3, 1..2] of Integer;
SubstituicoesTC: Array [1..3, 1..2] of Integer;
NumJogadoresEscaladosTF, NumJogadoresEscaladosTC: Integer;
NumSubstEfetuadasTF, NumSubstEfetuadasTC: Integer;
NumJogInscTF, NumJogInscTC: Integer;
public
procedure DefinirEscalacao (umaTemporada: TTemporada; umCodJogo: Integer);
procedure AtualizarInterfaceTF;
procedure AtualizarInterfaceTC;
procedure RemoverSubstituicaoTC (i: Integer);
procedure RemoverSubstituicaoTF (i: Integer);
end;
var
FrmEscalacao: TFrmEscalacao;
implementation
{$R *.nfm}
procedure TFrmEscalacao.SetBD (var umaConBD:TDtMdlDados);
begin
BD := TDtMdlIEscalacao.Create(nil);
BD.SetConexaoBD (umaConBD);
conBD := umaConBD;
end;
procedure TFrmEscalacao.DefinirEscalacao (umaTemporada: TTemporada; umCodJogo: Integer);
begin
Temporada := UmaTemporada;
CodTemporada := Temporada.GetCodTemporada;
BD.SQLDtStJogo.ParamByName('Cod').asInteger := CodJogo;
BD.ClntDtStJogo.Close;
BD.ClntDtStJogo.Open;
BD.ClntDtStJogo.First;
Jogo := TJogo.Create; Jogo.SetBD (ConBD);
Jogo.Materializar(umCodJogo);
self.AtualizarInterfaceTC;
self.AtualizarInterfaceTF;
TbShtTimeCasa.Caption := BD.ClntDtStJogo.FieldByName('NomeEquipe').AsString;
TbShtTimeFora.Caption := BD.ClntDtStJogo.FieldByName('NomeEquipe_1').AsString;
PnlTimeCasa.Caption := BD.ClntDtStJogo.FieldByName('NomeEquipe').AsString;
PnlTimeFora.Caption := BD.ClntDtStJogo.FieldByName('NomeEquipe_1').AsString;
TPageControl1.ActivePage := TbShtTimeCasa;
ShowModal;
end;
procedure TFrmEscalacao.AtualizarInterfaceTF;
var
i: Integer;
SQL: String;
begin
// Destroi os objetos dentro dos ComboBox se houverem.
i := 1;
while (i < CmbBxReservasFora.Items.Count) do begin
177
TItemCombo(CmbBxReservasFora.Items.Objects[i]).Destroy;
i := i + 1;
end;
i := 1;
while (i < CmbBxTitularesFora.Items.Count) do begin
TItemCombo(CmbBxTitularesFora.Items.Objects[i]).Destroy;
i := i + 1;
end;
// Verifica quantos jogadores j foram escalados como titulares na Equipe Fora
SQL := 'select Count(*) from EscalacaoJogo EJ where EJ.CodJogo = ' +
IntToStr(CodJogo);
SQL := SQL + ' and EJ.CodEquipe = ' +
BD.ClntDtStJogo.FieldByName('CodEquipeFora').AsString + ' and STATUS=''T''';
Close;
Open;
First;
NumJogadoresEscaladosTF := FieldByName('Count').asInteger;
end;
// Verifica quantos Jogadores a equipe tem inscrita no campeonato e que ainda no fora
escaladas
SQL := 'select Count(*) from Jogador J where J.CodEquipe=' +
BD.ClntDtStJogo.FieldByName('CodEquipeFora').AsString;
SQL := SQL + ' AND J.CodTemporada=' + IntToStr(CodTemporada) + ' AND J.CodJogador not
in (select CodJogador from EscalacaoJogo where CodJogo=';
SQL := SQL + IntToStr(CodJogo) + ' AND CodEquipe=' +
BD.ClntDtStJogo.FieldByName('CodEquipeFora').AsString + ')';
Close;
Open;
First;
NumJogInscTF := FieldByName('Count').asInteger;
end;
// Habilita boto de remover Escalao se existe pelo menos 1 jogador escalado e
desabilita boto de escalacao se j tem 11 jogadores escalados
if NumJogInscTF > 0 then begin
BtnEscalarJF.Enabled := True;
end else begin
BtnEscalarJF.Enabled := False;
end;
if NumJogadoresEscaladosTF > 0 then begin
BtnDesEscalarJF.Enabled := True;
if NumJogadoresEscaladosTF >= 11 then begin
BtnEscalarJF.Enabled := False;
end;
end else begin
BtnDesEscalarJF.Enabled := False;
end;
SQLDtStJogadorFora.ParamByName('CodEquipe').asInteger :=
BD.ClntDtStJogo.FieldByName('CodEquipeFora').AsInteger;
SQLDtStJogadorFora.ParamByName('CodTemp').asInteger := CodTemporada;
SQLDtStJogadorFora.ParamByName('CodJogo').asInteger := CodJogo;
ClntDtStJogadorFora.Close;
ClntDtStJogadorFora.Open;
SQLDtStEscJogoFora.ParamByName('CodEquipe').asInteger :=
BD.ClntDtStJogo.FieldByName('CodEquipeFora').AsInteger;
SQLDtStEscJogoFora.ParamByName('CodJogo').asInteger := CodJogo;
// Atualiza Combo dos Minutos da Substituio
minutos := 90;
CmbBxMinutosFora.Items.Clear;
if BD.ClntDtStJogo.FieldByName('Realizado').AsInteger = 1 then begin
// Verifica quantos jogadores j foram Substituidos na Equipe Fora
SQL := 'select * from Jogador JT, Jogador JR, EscalacaoJogo EJ where EJ.CodJogo = '
+ IntToStr(CodJogo) + ' and EJ.CodEquipe = ' +
BD.ClntDtStJogo.FieldByName('CodEquipeFora').AsString + ' and JT.CodJogador =
EJ.CodJogador and JR.CodJogador = EJ.CodJogadorEntrou and EJ.Saiu = ''S''';
NumSubstEfetuadasTF := 0;
BtnRemoverSubst1TF.Enabled := False;
Close;
Open;
First;
178

NumSubstEfetuadasTF := NumSubstEfetuadasTF + 1;
if NumSubstEfetuadasTF = 1 then begin
BtnRemoverSubst1TF.Enabled := True;
BtnRemoverSubst1TF.Caption :=
BD.ClntDtStDados.FieldByName('ApelidoJogador').AsString + '/' +
BD.ClntDtStDados.FieldByName('ApelidoJogador_1').AsString;
GrpBxSubFora.Caption := 'Substituio 2';
SubstituicoesTF[1,1] :=
BD.ClntDtStDados.FieldByName('CodJogador_2').AsInteger;
end else begin
if NumSubstEfetuadasTF = 2 then begin
GrpBxSubFora.Caption := 'Substituio 3';
end else begin
BtnSubFora.Enabled := False;
end;
end;
Next;
end;
end;
GrpBxSubFora.Caption := 'Substituio ' + IntToStr(NumSubstEfetuadasTF + 1);
if ((NumSubstEfetuadasTF < 3) and (NumJogInscTF > 0) and (NumJogadoresEscaladosTF >
0)) then begin
BtnSubFora.Enabled := True;
end else begin
BtnSubFora.Enabled := False;
end;
if BD.ClntDtStJogo.FieldByName('Prorrogacao').AsInteger = 1 then minutos := 120;
end;
CmbBxMinutosFora.Items.Add(IntToStr(i) + '''');
end;
CmbBxMinutosFora.ItemIndex := 0;
// Atualiza Combo dos Jogadores Reservas que podem entrar no jogo
CmbBxReservasFora.Items.Clear;
with ClntDtStJogadorFora do begin
Close;
Open;
First;
ItemCombo.SetOid(FieldByName('CodJogador').asInteger);
ItemCombo.SetNome(FieldByName('ApelidoJogador').asString);
CmbBxReservasFora.Items.AddObject(FieldByName('ApelidoJogador').asString,
ItemCombo);
Next;
end;
CmbBxReservasFora.ItemIndex := 0;
First;
end;
// Atualiza Combo dos Jogadores Titulares que podem ser substituidos no jogo
CmbBxTitularesFora.Items.Clear;
with ClntDtStEscJogoFora do begin
Close;
Open;
First;
if FieldByName('Saiu').asString <> 'S' then begin // Se j substituido no aparece
179
CmbBxTitularesFora.Items.AddObject(FieldByName('ApelidoJogador').asString,
ItemCombo);
end;
Next;
end;
CmbBxTitularesFora.ItemIndex := 0;
First;
end;
// Mostra dados Completos do jogador selecionado
if NumJogadoresEscaladosTF > 0 then begin
LblNomeJF.Caption := ClntDtStEscJogoFora.FieldByName('NomeJogador').asString;
LblCamisaJF.Caption := 'Camisa N: ' +
ClntDtStEscJogoFora.FieldByName('NumeroCamisa').asString;
case ClntDtStEscJogoFora.FieldByName('Posicao').asInteger of
1 : LblPosicaoJF.Caption := 'GOLEIRO';
2 : LblPosicaoJF.Caption := 'LATERAL';
3 : LblPosicaoJF.Caption := 'ZAGUEIRO';
4 : LblPosicaoJF.Caption := 'MEIO-CAMPO';
5 : LblPosicaoJF.Caption := 'ATACANTE';
end;
LblIdadeJF.Caption := 'Idade: ' + FormatDateTime('yy', (Date ClntDtStEscJogoFora.FieldByName('DataNascimento').asDateTime)) + ' Anos';
LblNacionalidadeJF.Caption :=
ClntDtStEscJogoFora.FieldByName('Nacionalidade').asString;
ImgJF.Picture.Bitmap.LoadFromStream(ClntDtStEscJogoFora.CreateBlobStream(ClntDtStEscJogo
Fora.FieldByName('Foto'),bmRead));
end else begin
LblNomeJF.Caption := '';
LblCamisaJF.Caption := '';
LblPosicaoJF.Caption := '';
LblIdadeJF.Caption := '';
LblNacionalidadeJF.Caption := '';
ImgJF.Picture.Bitmap.FreeImage;
end;
end;
procedure TFrmEscalacao.AtualizarInterfaceTC;
var
i: Integer;
SQL: String;
begin
// Destroi os objetos dentro dos ComboBox se houverem.
i := 1;
while (i < CmbBxReservasCasa.Items.Count) do begin
TItemCombo(CmbBxReservasCasa.Items.Objects[i]).Destroy;
i := i + 1;
end;
i := 1;
while (i < CmbBxTitularesCasa.Items.Count) do begin
TItemCombo(CmbBxTitularesCasa.Items.Objects[i]).Destroy;
i := i + 1;
end;
// Verifica quantos jogadores j foram escalados como titulares na Equipe Fora
SQL := 'select Count(*) from EscalacaoJogo EJ where EJ.CodJogo = ' +
IntToStr(CodJogo);
SQL := SQL + ' and EJ.CodEquipe = ' +
BD.ClntDtStJogo.FieldByName('CodEquipeCasa').AsString + ' and STATUS=''T''';
Close;
Open;
First;
NumJogadoresEscaladosTC := FieldByName('Count').asInteger;
end;
// Verifica quantos Jogadores a equipe tem inscrita no campeonato e que ainda no fora
escaladas
SQL := 'select Count(*) from Jogador J where J.CodEquipe=' +
BD.ClntDtStJogo.FieldByName('CodEquipeCasa').AsString;
SQL := SQL + ' AND J.CodTemporada=' + IntToStr(CodTemporada) + ' AND J.CodJogador not
in (select CodJogador from EscalacaoJogo where CodJogo=';
SQL := SQL + IntToStr(CodJogo) + ' AND CodEquipe=' +
BD.ClntDtStJogo.FieldByName('CodEquipeCasa').AsString + ')';
180

Close;
Open;
First;
NumJogInscTC := FieldByName('Count').asInteger;
end;
// Habilita boto de remover Escalao se existe pelo menos 1 jogador escalado e
desabilita boto de escalacao se j tem 11 jogadores escalados
if NumJogInscTC > 0 then begin
BtnEscalarJC.Enabled := True;
end else begin
BtnEscalarJC.Enabled := False;
end;
if NumJogadoresEscaladosTC > 0 then begin
BtnDesEscalarJC.Enabled := True;
if NumJogadoresEscaladosTC >= 11 then begin
BtnEscalarJC.Enabled := False;
end;
end else begin
BtnDesEscalarJC.Enabled := False;
end;
SQLDtStJogadorCasa.ParamByName('CodEquipe').asInteger :=
BD.ClntDtStJogo.FieldByName('CodEquipeCasa').AsInteger;
SQLDtStJogadorCasa.ParamByName('CodTemp').asInteger := CodTemporada;
SQLDtStJogadorCasa.ParamByName('CodJogo').asInteger := CodJogo;
ClntDtStJogadorCasa.Close;
ClntDtStJogadorCasa.Open;
SQLDtStEscJogoCasa.ParamByName('CodEquipe').asInteger :=
BD.ClntDtStJogo.FieldByName('CodEquipeCasa').AsInteger;
SQLDtStEscJogoCasa.ParamByName('CodJogo').asInteger := CodJogo;
// Atualiza Combo dos Minutos da Substituio
minutos := 90;
CmbBxMinutosCasa.Items.Clear;
if BD.ClntDtStJogo.FieldByName('Realizado').AsInteger = 1 then begin
// Verifica quantos jogadores j foram Substituidos na Equipe Fora
SQL := 'select * from Jogador JT, Jogador JR, EscalacaoJogo EJ where EJ.CodJogo = '
+ IntToStr(CodJogo) + ' and EJ.CodEquipe = ' +
BD.ClntDtStJogo.FieldByName('CodEquipeCasa').AsString + ' and JT.CodJogador =
EJ.CodJogador and JR.CodJogador = EJ.CodJogadorEntrou and EJ.Saiu = ''S''';
NumSubstEfetuadasTC := 0;
BtnRemoverSubst1TC.Enabled := False;
Close;
Open;
First;
NumSubstEfetuadasTC := NumSubstEfetuadasTC + 1;
if NumSubstEfetuadasTC = 1 then begin
BtnRemoverSubst1TC.Enabled := True;
BtnRemoverSubst1TC.Caption :=
GrpBxSubCasa.Caption := 'Substituio 2';
SubstituicoesTC[1,1] :=
end else begin
if NumSubstEfetuadasTC = 2 then begin
GrpBxSubCasa.Caption := 'Substituio 3';
end else begin
BtnSubCasa.Enabled := False;
181
end;
end;
Next;
end;
end;
GrpBxSubCasa.Caption := 'Substituio ' + IntToStr(NumSubstEfetuadasTC + 1);
if ((NumSubstEfetuadasTC < 3) and (NumJogInscTC > 0) and (NumJogadoresEscaladosTC >
0)) then begin
BtnSubCasa.Enabled := True;
end else begin
BtnSubCasa.Enabled := False;
end;
if BD.ClntDtStJogo.FieldByName('Prorrogacao').AsInteger = 1 then minutos := 120;
end;
CmbBxMinutosCasa.Items.Add(IntToStr(i) + '''');
end;
CmbBxMinutosCasa.ItemIndex := 0;
// Atualiza Combo dos Jogadores Reservas que podem entrar no jogo
CmbBxReservasCasa.Items.Clear;
with ClntDtStJogadorCasa do begin
Close;
Open;
First;
CmbBxReservasCasa.Items.AddObject(FieldByName('ApelidoJogador').asString,
ItemCombo);
Next;
end;
CmbBxReservasCasa.ItemIndex := 0;
First;
end;
// Atualiza Combo dos Jogadores Titulares que podem ser substituidos no jogo
CmbBxTitularesCasa.Items.Clear;
with ClntDtStEscJogoCasa do begin
Close;
Open;
First;
if FieldByName('Saiu').asString <> 'S' then begin // Se j substituido no aparece
CmbBxTitularesCasa.Items.AddObject(FieldByName('ApelidoJogador').asString,
ItemCombo);
end;
Next;
end;
CmbBxTitularesCasa.ItemIndex := 0;
First;
end;
// Mostra dados Completos do jogador selecionado
if NumJogadoresEscaladosTC > 0 then begin
LblNomeJC.Caption := ClntDtStEscJogoCasa.FieldByName('NomeJogador').asString;
LblCamisaJC.Caption := 'Camisa N: ' +
ClntDtStEscJogoCasa.FieldByName('NumeroCamisa').asString;
case ClntDtStEscJogoCasa.FieldByName('Posicao').asInteger of
1 : LblPosicaoJC.Caption := 'GOLEIRO';
2 : LblPosicaoJC.Caption := 'LATERAL';
3 : LblPosicaoJC.Caption := 'ZAGUEIRO';
4 : LblPosicaoJC.Caption := 'MEIO-CAMPO';
5 : LblPosicaoJC.Caption := 'ATACANTE';
end;
LblIdadeJC.Caption := 'Idade: ' + FormatDateTime('yy', (Date ClntDtStEscJogoCasa.FieldByName('DataNascimento').asDateTime)) + ' Anos';
LblNacionalidadeJC.Caption :=
ClntDtStEscJogoCasa.FieldByName('Nacionalidade').asString;
ImgJC.Picture.Bitmap.LoadFromStream(ClntDtStEscJogoCasa.CreateBlobStream(ClntDtStEscJogo
Casa.FieldByName('Foto'),bmRead));
182
end else begin

LblNomeJC.Caption := '';
LblCamisaJC.Caption := '';
LblPosicaoJC.Caption := '';
LblIdadeJC.Caption := '';
LblNacionalidadeJC.Caption := '';
ImgJC.Picture.Bitmap.FreeImage;
end;
end;
procedure TFrmEscalacao.BtnFecharClick(Sender: TObject);
begin
Close;
end;
procedure TFrmEscalacao.ClntDtStEscJogoForaCalcFields(DataSet: TDataSet);
begin
if ClntDtStEscJogoForaPosicao.Value = 1 then ClntDtStEscJogoForaPos.Value
ClntDtStEscJogoForaMin.Value := ClntDtStEscJogoForaTempoJogado.asString +
end;
:= 'GOL';
:= 'LAT';
:= 'ZAG';
:= 'MC';
:= 'ATA';
'''';
procedure TFrmEscalacao.DBGrdTitularesForaCellClick(Column: TColumn);

begin
LblNomeJF.Caption := ClntDtStEscJogoFora.FieldByName('NomeJogador').asString;
LblCamisaJF.Caption := 'Camisa N: ' +
ClntDtStEscJogoFora.FieldByName('NumeroCamisa').asString;
case ClntDtStEscJogoFora.FieldByName('Posicao').asInteger of
1 : LblPosicaoJF.Caption := 'GOLEIRO';
2 : LblPosicaoJF.Caption := 'LATERAL';
3 : LblPosicaoJF.Caption := 'ZAGUEIRO';
4 : LblPosicaoJF.Caption := 'MEIO-CAMPO';
5 : LblPosicaoJF.Caption := 'ATACANTE';
end;
LblIdadeJF.Caption := 'Idade: ' + FormatDateTime('yy', (Date ClntDtStEscJogoFora.FieldByName('DataNascimento').asDateTime)) + ' Anos';
LblNacionalidadeJF.Caption :=
ClntDtStEscJogoFora.FieldByName('Nacionalidade').asString;
ImgJF.Picture.Bitmap.LoadFromStream(ClntDtStEscJogoFora.CreateBlobStream(ClntDtStEscJogo
Fora.FieldByName('Foto'),bmRead));
end;
procedure TFrmEscalacao.BtnEscalarJFClick(Sender: TObject);
var
MinutosJogados: Integer;
begin
MinutosJogados := 0;
end;
end;
try
Jogo.EscalarJogador (ClntDtStJogadorFora.FieldByName('CodEquipe').asInteger,
ClntDtStJogadorFora.FieldByName('CodJogador').asInteger, MinutosJogados);
except
Suporte');
end;
end;
end;
procedure TFrmEscalacao.BtnDesEscalarJFClick(Sender: TObject);
begin
if ((ClntDtStEscJogoFora.FieldByName('Status_1').asString = 'T') and
(ClntDtStEscJogoFora.FieldByName('Saiu').asString = 'N')) then begin
try
Jogo.RemoverEscalacaoJogador
(ClntDtStEscJogoFora.FieldByName('CodEquipe').asInteger,
ClntDtStEscJogoFora.FieldByName('CodJogador').asInteger);
183
except
Suporte');
end;
end;
end else begin
ShowMessage ('Operao Invlida');
end;
end;
procedure TFrmEscalacao.DBGrdJogadoresForaDblClick(Sender: TObject);
begin
if NumJogadoresEscaladosTF < 11 then begin
self.BtnEscalarJFClick (Sender);
end else begin
ShowMessage ('Erro: J foram escalados 11 Jogadores Titulares');
end;
end;
procedure TFrmEscalacao.BtnSubForaClick(Sender: TObject);
var
CodJogadorEntrou, CodJogadorSaiu: Integer;
MinutosJogadosEntrou, MinutosJogadosSaiu: Integer;
TempoJogo: String;
SQL: String;
begin
CodJogadorEntrou :=
TItemCombo(CmbBxReservasFora.Items.Objects[CmbBxReservasFora.ItemIndex]).GetOid;
CodJogadorSaiu :=
TItemCombo(CmbBxTitularesFora.Items.Objects[CmbBxTitularesFora.ItemIndex]).GetOid;
TempoJogo := CmbBxMinutosFora.Text;
MinutosJogadosEntrou := Minutos - StrToInt(TempoJogo);
SQL := 'Select TempoJogado from EscalacaoJogo where CodJogo=' + IntToStr(CodJogo) + '
And CodJogador=' + IntToStr(CodJogadorSaiu);
Close;
Open;
First;
MinutosJogadosSaiu := FieldByName('TempoJogado').asInteger - MinutosJogadosEntrou;
end;
try
Jogo.PromoverSubst (BD.ClntDtStJogo.FieldByName('CodEquipeFora').asInteger,
CodJogadorSaiu, MinutosJogadosSaiu, CodJogadorEntrou, MinutosJogadosEntrou,
StrToInt(TempoJogo));
except
Suporte');
end;
end;
end;
procedure TFrmEscalacao.RemoverSubstituicaoTF (i: Integer);
var
SQL: String;
begin
And CodJogador=' + IntToStr(SubstituicoesTF[i,1]);
Close;
Open;
First;
MinutosJogadosSaiu := FieldByName('TempoJogado').asInteger;
end;
And CodJogador=' + IntToStr(SubstituicoesTF[i,2]);
Close;
Open;
184
First;
MinutosJogadosEntrou := FieldByName('TempoJogado').asInteger;
end;
try
Jogo.RemoverSubstituicao (BD.ClntDtStJogo.FieldByName('CodEquipeFora').asInteger,
SubstituicoesTF[i,1], SubstituicoesTF[i,2], (MinutosJogadosSaiu +
MinutosJogadosEntrou));
except
Suporte');
end;
end;
end;
procedure TFrmEscalacao.FormDestroy(Sender: TObject);
var
i: Integer;
begin
i := 1;
while (i < CmbBxReservasFora.Items.Count) do begin
TItemCombo(CmbBxReservasFora.Items.Objects[i]).Destroy;
i := i + 1;
end;
i := 1;
while (i < CmbBxTitularesFora.Items.Count) do begin
TItemCombo(CmbBxTitularesFora.Items.Objects[i]).Destroy;
i := i + 1;
end;
BD.Destroy;
Jogo.Destroy;
Temporada.Destroy;
end;
procedure TFrmEscalacao.ClntDtStEscJogoCasaCalcFields(DataSet: TDataSet);
begin
if ClntDtStEscJogoCasaPosicao.Value = 1 then ClntDtStEscJogoCasaPos.Value
ClntDtStEscJogoCasaMin.Value := ClntDtStEscJogoCasaTempoJogado.asString +
end;
:= 'GOL';
:= 'LAT';
:= 'ZAG';
:= 'MC';
:= 'ATA';
'''';
procedure TFrmEscalacao.BtnEscalarJCClick(Sender: TObject);

var
MinutosJogados: Integer;
begin
end;
end;
try
Jogo.EscalarJogador (ClntDtStJogadorCasa.FieldByName('CodEquipe').asInteger,
ClntDtStJogadorCasa.FieldByName('CodJogador').asInteger, MinutosJogados);
except
Suporte');
end;
end;
end;
procedure TFrmEscalacao.BtnDesEscalarJCClick(Sender: TObject);
begin
if ((ClntDtStEscJogoCasa.FieldByName('Status_1').asString = 'T') and
(ClntDtStEscJogoCasa.FieldByName('Saiu').asString = 'N')) then begin
try
Jogo.RemoverEscalacaoJogador
(ClntDtStEscJogoCasa.FieldByName('CodEquipe').asInteger,
ClntDtStEscJogoCasa.FieldByName('CodJogador').asInteger);
except
185
Suporte');
end;
end;
end else begin
ShowMessage ('Operao Invlida');
end;
end;
procedure TFrmEscalacao.RemoverSubstituicaoTC (i: Integer);
var
SQL: String;
begin
And CodJogador=' + IntToStr(SubstituicoesTC[i,1]);
Close;
Open;
First;
MinutosJogadosSaiu := FieldByName('TempoJogado').asInteger;
end;
And CodJogador=' + IntToStr(SubstituicoesTC[i,2]);
Close;
Open;
First;
MinutosJogadosEntrou := FieldByName('TempoJogado').asInteger;
end;
try
Jogo.RemoverSubstituicao (BD.ClntDtStJogo.FieldByName('CodEquipeCasa').asInteger,
SubstituicoesTC[i,1], SubstituicoesTC[i,2], (MinutosJogadosSaiu +
MinutosJogadosEntrou));
except
Suporte');
end;
end;
end;
procedure TFrmEscalacao.BtnSubCasaClick(Sender: TObject);
var
CodJogadorEntrou, CodJogadorSaiu: Integer;
TempoJogo: String;
SQL: String;
begin
CodJogadorEntrou :=
TItemCombo(CmbBxReservasCasa.Items.Objects[CmbBxReservasCasa.ItemIndex]).GetOid;
CodJogadorSaiu :=
TItemCombo(CmbBxTitularesCasa.Items.Objects[CmbBxTitularesCasa.ItemIndex]).GetOid;
TempoJogo := CmbBxMinutosCasa.Text;
MinutosJogadosEntrou := Minutos - StrToInt(TempoJogo);
And CodJogador=' + IntToStr(CodJogadorSaiu);
Close;
Open;
First;
MinutosJogadosSaiu := FieldByName('TempoJogado').asInteger - MinutosJogadosEntrou;
end;
try
Jogo.PromoverSubst (BD.ClntDtStJogo.FieldByName('CodEquipeCasa').asInteger,
CodJogadorSaiu, MinutosJogadosSaiu, CodJogadorEntrou, MinutosJogadosEntrou,
StrToInt(TempoJogo));
except
186

Suporte');
end;
end;
end;
procedure TFrmEscalacao.BtnRemoverSubst1TCClick(Sender: TObject);
begin
Self.RemoverSubstituicaoTC(1);
end;
begin
end;
begin
end;
procedure TFrmEscalacao.BtnRemoverSubst1TFClick(Sender: TObject);
begin
Self.RemoverSubstituicaoTF(1);
end;
begin
end;
begin
end;
procedure TFrmEscalacao.DBGrdTitularesCasaCellClick(Column: TColumn);
begin
LblNomeJC.Caption := ClntDtStEscJogoCasa.FieldByName('NomeJogador').asString;
LblCamisaJC.Caption := 'Camisa N: ' +
ClntDtStEscJogoCasa.FieldByName('NumeroCamisa').asString;
case ClntDtStEscJogoCasa.FieldByName('Posicao').asInteger of
1 : LblPosicaoJC.Caption := 'GOLEIRO';
2 : LblPosicaoJC.Caption := 'LATERAL';
3 : LblPosicaoJC.Caption := 'ZAGUEIRO';
4 : LblPosicaoJC.Caption := 'MEIO-CAMPO';
5 : LblPosicaoJC.Caption := 'ATACANTE';
end;
LblIdadeJC.Caption := 'Idade: ' + FormatDateTime('yy', (Date ClntDtStEscJogoCasa.FieldByName('DataNascimento').asDateTime)) + ' Anos';
LblNacionalidadeJC.Caption :=
ClntDtStEscJogoCasa.FieldByName('Nacionalidade').asString;
ImgJC.Picture.Bitmap.LoadFromStream(ClntDtStEscJogoCasa.CreateBlobStream(ClntDtStEscJogo
Casa.FieldByName('Foto'),bmRead));
end;
procedure TFrmEscalacao.DBGrdJogadoresCasaDblClick(Sender: TObject);
begin
if NumJogadoresEscaladosTC < 11 then begin
self.BtnEscalarJCClick (Sender);
end else begin
ShowMessage ('Erro: J foram escalados 11 Jogadores Titulares');
end;
end;
procedure TFrmEscalacao.BtnCadJogadoresTCClick(Sender: TObject);
var
begin
BD.ClntDtStJogo.FieldByName('CodEquipeCasa').AsInteger);
end;
187
procedure TFrmEscalacao.BtnCadJogadoresTFClick(Sender: TObject);

var
begin
BD.ClntDtStJogo.FieldByName('CodEquipeFora').AsInteger);
end;
end.
========================================================================================
====
ARQUIVO: UIEquipeEquivalente.pas
========================================================================================
====
unit UIEquipeEquivalente;
interface
uses
Dialogs, Borland.Vcl.StdCtrls, Borland.Vcl.Buttons, Borland.Vcl.ExtCtrls,
System.ComponentModel, Borland.Vcl.Grids, Borland.Vcl.DBGrids, FMTBcd,
Borland.Vcl.Provider, Borland.Vcl.SqlExpr, Borland.Vcl.Db,
Borland.Vcl.DBClient, UTemporada, UDMDados, Borland.Vcl.StrUtils,
UICadEquipeCompeteTemporada;
type
ColecaoEquipes = record
Nome: String;
Codigo: Integer;
CodEstadio: Integer;
end;
type
TFrmEquipeEquivalente = class(TForm)
Panel2: TPanel;
PnlEquipe: TPanel;
PnlEquipeEquivalente: TPanel;
Label2: TLabel;
Label1: TLabel;
Panel3: TPanel;
Panel4: TPanel;
BtnFechar: TBitBtn;
DBGrdEquipes: TDBGrid;
Panel1: TPanel;
Panel5: TPanel;
ChckBxTodasEquipes: TCheckBox;
Button1: TButton;
procedure DBGrdEquipesDblClick(Sender: TObject);
procedure DBGrdEquipesCellClick(Column: TColumn);
procedure ChckBxTodasEquipesClick(Sender: TObject);
procedure Button1Click(Sender: TObject);
private
conBD: TDtMdlDados;
188
CodEquipe: Integer;
Equipes: Array [1..50] of ColecaoEquipes;
TotEquipes: Integer;
Nome: String;
public
procedure SetTemporada (umaTemp: TTemporada);
procedure Mostrar;
procedure AtualizaInterface;
function GetCodEquipe: Integer;
function RetorneCodigoEquipe(umNome: String): Integer;
function GetCodEstadio (umCodEquipe: Integer): Integer;
end;
var
FrmEquipeEquivalente: TFrmEquipeEquivalente;
implementation
{$R *.nfm}
function TFrmEquipeEquivalente.RetorneCodigoEquipe(umNome: String): Integer;
var
i: Integer;
Achou: Boolean;
begin
Achou := False;
i := 1;
Nome := umNome;
while ((Achou=False) and (i <= TotEquipes)) do begin
if Equipes[i].Nome = Nome then begin
CodEquipe := Equipes[i].Codigo;
Achou := True;
end;
Inc(i);
end;
if (Achou = False) then begin
Self.Mostrar;
CodEquipe := ClntDtStEquipeDisputaTemp.FieldByName('CodEquipe').AsInteger;
CodEstadio := ClntDtStEquipeDisputaTemp.FieldByName('CodEstadio').AsInteger;
Equipes[TotEquipes + 1].Nome := Nome;
Equipes[TotEquipes + 1].Codigo := CodEquipe;
Equipes[TotEquipes + 1].CodEstadio := CodEstadio;
inc(TotEquipes);
end;
RetorneCodigoEquipe := CodEquipe;
end;
procedure TFrmEquipeEquivalente.SetBD (var umaConBD: TDtMdlDados);
begin
conBD := umaConBD;
end;
procedure TFrmEquipeEquivalente.SetTemporada (umaTemp: TTemporada);
begin
TotEquipes := 0;
end;
procedure TFrmEquipeEquivalente.Mostrar;
begin
PnlEquipe.Text := Nome;
Self.AtualizaInterface;
ShowModal;
end;
procedure TFrmEquipeEquivalente.AtualizaInterface;
var
SQL: String;
i: Integer;
Achou: Boolean;
begin
if ChckBxTodasEquipes.Checked = False then begin
SQL := 'Select * FROM EQUIPECOMPETETEMPORADA ECT, EQUIPE E where
CODTEMPORADA=:CodTemp and ';
189
SQL := SQL + 'ECT.CODEQUIPE=E.CODEQUIPE ';

for i:=1 to TotEquipes do begin
SQL := SQL + ' and ECT.CodEquipe<>' + IntToStr(Equipes[i].Codigo) + ' ';
end;
SQL := SQL + 'Order by NOMEEQUIPE';
end else begin
SQL := 'Select * FROM EQUIPECOMPETETEMPORADA ECT, EQUIPE E where
CODTEMPORADA=:CodTemp and ';
SQL := SQL + 'ECT.CODEQUIPE=E.CODEQUIPE Order by NOMEEQUIPE';
end;
SQLDtStEquipeDisputaTemp.CommandText := SQL;
SQLDtStEquipeDisputaTemp.ParamByName('CodTemp').asInteger :=
ClntDtStEquipeDisputaTemp.Close;
ClntDtStEquipeDisputaTemp.Open;
ClntDtStEquipeDisputaTemp.First;
Achou := false;
While ((ClntDtStEquipeDisputaTemp.Eof=false) and (Achou=false)) do begin
if SoundexSimilar(Nome,
ClntDtStEquipeDisputaTemp.FieldByName('NomeEquipe').AsString) then begin
Achou := true;
end else begin
ClntDtStEquipeDisputaTemp.Next;
end;
end;
if (Achou=false) then begin
ClntDtStEquipeDisputaTemp.First;
end;
PnlEquipeEquivalente.Text :=
ClntDtStEquipeDisputaTemp.FieldByName('NomeEquipe').AsString;
end;
procedure TFrmEquipeEquivalente.DBGrdEquipesDblClick(Sender: TObject);
begin
Self.BtnFecharClick(Sender);
end;
procedure TFrmEquipeEquivalente.BtnFecharClick(Sender: TObject);
begin
Self.Close;
end;
function TFrmEquipeEquivalente.GetCodEquipe: Integer;
begin
GetCodEquipe := CodEquipe;
end;
procedure TFrmEquipeEquivalente.DBGrdEquipesCellClick(Column: TColumn);
begin
end;
procedure TFrmEquipeEquivalente.ChckBxTodasEquipesClick(Sender: TObject);
begin
end;
procedure TFrmEquipeEquivalente.Button1Click(Sender: TObject);
var
begin
FrmCadEquipeCompeteTemporada := TFrmCadEquipeCompeteTemporada.Create(nil);
FrmCadEquipeCompeteTemporada.SetBD(conBD);
FrmCadEquipeCompeteTemporada.Mostrar(Temporada);
FrmCadEquipeCompeteTemporada.Destroy;
end;
function TFrmEquipeEquivalente.GetCodEstadio (umCodEquipe: Integer): Integer;
var
Achou: Boolean;
i: Integer;
begin
i := 1;
190
Achou := False;
while ((achou=false) and (i<=TotEquipes)) do begin
if Equipes[i].Codigo = umCodEquipe then begin
GetCodEstadio := Equipes[i].CodEstadio;
Achou := True;
end;
Inc(i);
end;
end;
end.
========================================================================================
====
ARQUIVO: UICadTemporada.pas
========================================================================================
====
unit UICadTemporada;
interface
uses
Dialogs, Borland.Vcl.StdCtrls, Borland.Vcl.Buttons,
System.ComponentModel, Borland.Vcl.ExtCtrls, Borland.Vcl.Grids,
Borland.Vcl.DBGrids, FMTBcd, Borland.Vcl.Provider, Borland.Vcl.SqlExpr,
Borland.Vcl.Db, Borland.Vcl.DBClient, UDMDados, UItemCombo, UICadCampeonato,
UTemporada;
type
TFrmCadTemporada = class(TForm)
PnlDados: TPanel;
Label5: TLabel;
EdtNomeTemporada: TEdit;
GrpBxTN: TGroupBox;
Label9: TLabel;
Label10: TLabel;
EdtPtsVitTN: TEdit;
EdtPtsEmpTN: TEdit;
GrpBxPro: TGroupBox;
Label6: TLabel;
Label7: TLabel;
Label8: TLabel;
EdtPtsVitPro: TEdit;
EdtPtsEmpPro: TEdit;
EdtPtsDerPro: TEdit;
GrpBxPen: TGroupBox;
Label11: TLabel;
Label12: TLabel;
EdtPtsVitPen: TEdit;
EdtPtsDerPen: TEdit;
MmDescricao: TMemo;
Label2: TLabel;
GrpBxClas: TGroupBox;
Label3: TLabel;
EdtNumPro: TEdit;
LstBxCriterioDesempate: TListBox;
Label1: TLabel;
BtnSubir: TBitBtn;
BtnDescer: TBitBtn;
Label14: TLabel;
EdtNumComp1: TEdit;
Label4: TLabel;
EdtNumComp2: TEdit;
EdtNumPOReb: TEdit;
Label13: TLabel;
EdtNumReb: TEdit;
Label15: TLabel;
CmbBxCampeonato: TComboBox;
DBGrdEquipe: TDBGrid;
Panel3: TPanel;
PnlBtns: TPanel;
BtnGravar: TBitBtn;
Label16: TLabel;
ClntDtStCampeonato: TClientDataSet;
DtSrcCampeonato: TDataSource;
191
SQLDtStCampeonato: TSQLDataSet;
DtStPrvdrCampeonato: TDataSetProvider;
ClntDtStCampeonatoCODTEMPORADA: TIntegerField;
ClntDtStCampeonatoCODCAMPEONATO: TIntegerField;
ClntDtStCampeonatoNOMETEMPORADA: TStringField;
ClntDtStCampeonatoPONTOSVITORIA: TIntegerField;
ClntDtStCampeonatoPONTOSEMPATE: TIntegerField;
ClntDtStCampeonatoPONTOSVITORIAPRORROGACAO: TIntegerField;
ClntDtStCampeonatoPONTOSVITORIAPENALTIS: TIntegerField;
ClntDtStCampeonatoPONTOSDERROTAPRORROGACAO: TIntegerField;
ClntDtStCampeonatoPONTOSDERROTAPENALTIS: TIntegerField;
ClntDtStCampeonatoDESCRICAO: TMemoField;
ClntDtStCampeonatoNUMTIMEREBAIXADO: TIntegerField;
ClntDtStCampeonatoNUMTIMEPROMOVIDO: TIntegerField;
ClntDtStCampeonatoPONTOSEMPATEPRORROGACAO: TIntegerField;
ClntDtStCampeonatoCODCAMPEONATO_1: TIntegerField;
ClntDtStCampeonatoNOME: TStringField;
ClntDtStCampeonatoTIPO: TIntegerField;
ClntDtStCampeonatoPAIS: TStringField;
ClntDtStCampeonatoESCUDO: TBlobField;
ClntDtStCampeonatoNomeCampeoTemp: TStringField;
ClntDtStCampeonatoSQLDESEMPATE: TStringField;
ClntDtStCampeonatoNUMTIMECOMPET1: TIntegerField;
ClntDtStCampeonatoNUMTIMECOMPET2: TIntegerField;
ClntDtStCampeonatoNUMTIMEPOREBAIXAMENTO: TIntegerField;
BtnIncluirCampeonato: TButton;
BtnFechar: TBitBtn;
BtnIncluirTemporada: TBitBtn;
BtnAlterarTemporada: TBitBtn;
BtnExcluirTemporada: TBitBtn;
procedure ClntDtStCampeonatoCalcFields(DataSet: TDataSet);
procedure EdtPtsVitTNKeyPress(Sender: TObject; var Key: Char);
procedure BtnIncluirTemporadaClick(Sender: TObject);
procedure BtnIncluirCampeonatoClick(Sender: TObject);
procedure BtnAlterarTemporadaClick(Sender: TObject);
procedure FormShow(Sender: TObject);
procedure DBGrdEquipeDblClick(Sender: TObject);
procedure BtnSubirClick(Sender: TObject);
procedure BtnDescerClick(Sender: TObject);
private
conBD: TDtMdlDados;
Status: String;
NumTempCadastradas: Integer;
procedure CarregarCmbBxCampeonato;
procedure LimparCmbBxEstadioEquipe;
procedure AtivaFormulario;
function GetCriterioDesempate: String;
function validaCadastro: Boolean;
procedure AtualizaLstBxCriterioDesempate (Texto: String);
public
procedure SetBD(var umaConBD: TDtMdlDados);
procedure Mostrar;
end;
var
FrmCadTemporada: TFrmCadTemporada;
implementation
{$R *.nfm}
procedure TFrmCadTemporada.SetBD (var umaConBD: TDtMdlDados);
begin
conBD := umaConBD;
end;
192
procedure TFrmCadTemporada.BtnFecharClick(Sender: TObject);

begin
Self.Close;
end;
procedure TFrmCadTemporada.Mostrar;
begin
ClntDtStCampeonato.Close;
ClntDtStCampeonato.Open;
ShowModal;
end;
procedure TFrmCadTemporada.ClntDtStCampeonatoCalcFields(DataSet: TDataSet);
begin
ClntDtStCampeonatoNomeCampeoTemp.Value := ClntDtStCampeonatoNome.Value + ' ' +
ClntDtStCampeonatoNomeTemporada.Value;
end;
procedure TFrmCadTemporada.BtnCancelarClick(Sender: TObject);
begin
end;
procedure TFrmCadTemporada.EdtPtsVitTNKeyPress(Sender: TObject; var Key: Char);
begin
if not (Key in ['0'..'9', #8,#0]) then begin
Key := #0;
Beep;
end;
end;
procedure TFrmCadTemporada.CarregarCmbBxCampeonato;
var
SQL: String;
begin
SQL := 'Select * from CAMPEONATO ORDER BY NOME';
with ClntDtStDados do begin
Close;
Open;
First;
ItemCombo.SetOid(FieldByName('CodCampeonato').AsInteger);
CmbBxCampeonato.Items.AddObject(FieldByName('Nome').asString, ItemCombo);
Next;
end;
CmbBxCampeonato.ItemIndex := 0;
end;
ItemCombo.Free;
end;
procedure TFrmCadTemporada.LimparCmbBxEstadioEquipe;
var
i: Integer;
begin
for i:=1 to CmbBxCampeonato.Items.Count-1 do begin
TItemCombo(CmbBxCampeonato.Items.Objects[i]).Destroy;
end;
CmbBxCampeonato.Clear;
end;
procedure TFrmCadTemporada.FormDestroy(Sender: TObject);

begin
Self.LimparCmbBxEstadioEquipe;
end;
procedure TFrmCadTemporada.BtnIncluirTemporadaClick(Sender: TObject);
begin
Status := 'N';
EdtNomeTemporada.Text := '';
193
MmDescricao.Lines.Clear;
EdtPtsVitTN.Text := '3';
EdtPtsEmpTN.Text := '1';
EdtPtsVitPro.Text := '0';
EdtPtsEmpPro.Text := '0';
EdtPtsDerPro.Text := '0';
EdtPtsVitPen.Text := '0';
EdtPtsDerPen.Text := '0';
EdtNumPro.Text := '0';
EdtNumComp1.Text := '0';
EdtNumComp2.Text := '0';
EdtNumPOReb.Text := '0';
EdtNumReb.Text := '0';
end;
procedure TFrmCadTemporada.AtivaFormulario;
begin
Self.CarregarCmbBxCampeonato;
CmbBxCampeonato.Enabled := True;
EdtNomeTemporada.Enabled := True;
MmDescricao.Enabled := True;
EdtPtsVitTN.Enabled := True;
EdtPtsEmpTN.Enabled := True;
EdtPtsVitPro.Enabled := True;
EdtPtsEmpPro.Enabled := True;
EdtPtsDerPro.Enabled := True;
EdtPtsVitPen.Enabled := True;
EdtPtsDerPen.Enabled := True;
EdtNumPro.Enabled := True;
EdtNumComp1.Enabled := True;
EdtNumComp2.Enabled := True;
EdtNumPOReb.Enabled := True;
EdtNumReb.Enabled := True;
BtnSubir.Enabled := True;
BtnDescer.Enabled := True;
BtnIncluirCampeonato.Enabled := True;
LstBxCriterioDesempate.Enabled := True;
CmbBxCampeonato.SetFocus;
end;
procedure TFrmCadTemporada.BloqueiaFormulario;
begin
EdtNomeTemporada.Text := '';
MmDescricao.Lines.Clear;
EdtPtsVitTN.Text := '';
EdtPtsEmpTN.Text := '';
EdtPtsVitPro.Text := '';
EdtPtsEmpPro.Text := '';
EdtPtsDerPro.Text := '';
EdtPtsVitPen.Text := '';
EdtPtsDerPen.Text := '';
EdtNumPro.Text := '';
EdtNumComp1.Text := '';
EdtNumComp2.Text := '';
EdtNumPOReb.Text := '';
EdtNumReb.Text := '';
CmbBxCampeonato.Enabled := False;
EdtNomeTemporada.Enabled := False;
MmDescricao.Enabled := False;
EdtPtsVitTN.Enabled := False;
EdtPtsEmpTN.Enabled := False;
EdtPtsVitPro.Enabled := False;
EdtPtsEmpPro.Enabled := False;
EdtPtsDerPro.Enabled := False;
EdtPtsVitPen.Enabled := False;
EdtPtsDerPen.Enabled := False;
EdtNumPro.Enabled := False;
EdtNumComp1.Enabled := False;
EdtNumComp2.Enabled := False;
EdtNumPOReb.Enabled := False;
EdtNumReb.Enabled := False;
BtnSubir.Enabled := False;
BtnDescer.Enabled := False;
LstBxCriterioDesempate.Enabled := False;
194
BtnIncluirCampeonato.Enabled := False;
SQLDtStDados.CommandText := 'Select Count(*) from Temporada';
ClntDtStDados.Open;
NumTempCadastradas := ClntDtStDados.FieldByName('Count').AsInteger;
if NumTempCadastradas = 0 then begin
BtnAlterarTemporada.Enabled := False;
end else begin
BtnAlterarTemporada.Enabled := True;
end;
end;
procedure TFrmCadTemporada.BtnIncluirCampeonatoClick(Sender: TObject);
var
FrmCadCampeonato: TFrmCadCampeonato;
begin
FrmCadCampeonato := TFrmCadCampeonato.Create(nil); FrmCadCampeonato.SetBD(ConBD);
FrmCadCampeonato.Mostrar;
FrmCadCampeonato.Destroy;
Self.CarregarCmbBxCampeonato;
end;
procedure TFrmCadTemporada.BtnAlterarTemporadaClick(Sender: TObject);
var
i: Integer;
achou: Boolean;
begin
Status := 'A';
CodTemporada := ClntDtStCampeonato.FieldByName('CodTemporada').asInteger;
EdtNomeTemporada.Text := ClntDtStCampeonato.FieldByName('NomeTemporada').asString;
MmDescricao.Lines.Add (ClntDtStCampeonato.FieldByName('Descricao').asString);
EdtPtsVitTN.Text := ClntDtStCampeonato.FieldByName('PontosVitoria').asString;
EdtPtsEmpTN.Text := ClntDtStCampeonato.FieldByName('PontosEmpate').asString;
EdtPtsVitPro.Text :=
ClntDtStCampeonato.FieldByName('PontosVitoriaProrrogacao').asString;
EdtPtsEmpPro.Text :=
ClntDtStCampeonato.FieldByName('PontosEmpateProrrogacao').asString;
EdtPtsDerPro.Text :=
ClntDtStCampeonato.FieldByName('PontosDerrotaProrrogacao').asString;
EdtPtsVitPen.Text := ClntDtStCampeonato.FieldByName('PontosVitoriaPenaltis').asString;
EdtPtsDerPen.Text := ClntDtStCampeonato.FieldByName('PontosDerrotaPenaltis').asString;
EdtNumPro.Text := ClntDtStCampeonato.FieldByName('NumTimePromovido').asString;
EdtNumComp1.Text := ClntDtStCampeonato.FieldByName('NumTimeCompet1').asString;
EdtNumComp2.Text := ClntDtStCampeonato.FieldByName('NumTimeCompet2').asString;
EdtNumPOReb.Text := ClntDtStCampeonato.FieldByName('NumTimePORebaixamento').asString;
EdtNumReb.Text := ClntDtStCampeonato.FieldByName('NumTimeRebaixado').asString;
while ((i < CmbBxCampeonato.Items.Count) and (not achou)) do begin
if TItemCombo(CmbBxCampeonato.Items.Objects[i]).GetOid =
ClntDtStCampeonato.FieldByName('CodCampeonato').AsInteger then begin
CmbBxCampeonato.ItemIndex := i;
achou := true;
end;
i := i + 1;
end;
LstBxCriterioDesempate.Items.Clear;
Self.AtualizaLstBxCriterioDesempate(ClntDtStCampeonato.FieldByName('SQLDesempate').asStr
ing);
end;
procedure TFrmCadTemporada.FormShow(Sender: TObject);
begin
end;
procedure TFrmCadTemporada.DBGrdEquipeDblClick(Sender: TObject);
begin
if NumTempCadastradas > 0 then begin
Self.BtnAlterarTemporadaClick(Sender);
end;
end;
procedure TFrmCadTemporada.BtnGravarClick(Sender: TObject);
195
var
CodCampeonato, PtsVit, PtsEmp, PtsVitPro, PtsEmpPro, PtsDerPro, PtsVitPen, PtsDerPen:
Integer;
NumPro, NumComp1, NumComp2, NumPOReb, NumReb: Integer;
NomeTemporada, Descricao, Criterio: String;
begin
if Self.ValidaCadastro then begin
CodCampeonato :=
TItemCombo(CmbBxCampeonato.Items.Objects[CmbBxCampeonato.ItemIndex]).GetOid;
NomeTemporada := EdtNomeTemporada.Text;
Descricao := MmDescricao.Text;
Criterio := Self.GetCriterioDesempate;
PtsVit := StrToInt(EdtPtsVitTN.Text);
PtsEmp := StrToInt(EdtPtsEmpTN.Text);
PtsVitPro := StrToInt(EdtPtsVitPro.Text);
PtsEmpPro := StrToInt(EdtPtsEmpPro.Text);
PtsDerPro := StrToInt(EdtPtsDerpro.Text);
PtsVitPen := StrToInt(EdtPtsVitPen.Text);
PtsDerPen := StrToInt(EdtPtsDerPen.Text);
NumPro := StrToInt(EdtNumPro.Text);
NumComp1 := StrToInt(EdtNumComp1.Text);
NumComp2 := StrToInt(EdtNumComp2.Text);
NumPOReb := StrToInt(EdtNumPOReb.Text);
NumReb := StrToInt(EdtNumReb.Text);
try
Temporada := TTemporada.Create; Temporada.SetBD(ConBD);
if Status = 'N' then begin
Temporada.NovaTemporada(CodCampeonato, PtsVit, PtsEmp, PtsVitPro, PtsEmpPro,
PtsDerPro, PtsVitPen,
PtsDerPen, NumPro, NumComp1, NumComp2, NumPOReb, NumReb, NomeTemporada,
Descricao, Criterio);
end else begin
Temporada.Materializar (CodTemporada);
Temporada.AlterarTemporada(CodCampeonato, PtsVit, PtsEmp, PtsVitPro, PtsEmpPro,
PtsDerPro,
PtsVitPen, PtsDerPen, NumPro, NumComp1, NumComp2, NumPOReb, NumReb,
NomeTemporada, Descricao, Criterio);
end;
ClntDtStCampeonato.Close;
ClntDtStCampeonato.Open;
Temporada.Destroy;
Except
Suporte');
end;
end;
end;
end;
function TFrmCadTemporada.validaCadastro: Boolean;
begin
if CmbBxCampeonato.ItemIndex < 0 then begin
ShowMessage('Voc deve incluir um Campeonato antes de Incluir a Temporada');
BtnIncluirCampeonato.SetFocus;
end else begin
if EdtNomeTemporada.Text = '' then begin
ShowMessage('Nome da Temporada Invlido');
EdtNomeTemporada.SetFocus;
end else begin
ValidaCadastro := True;
if EdtPtsVitTN.Text = '' then EdtPtsVitTN.Text := '3';
if EdtPtsEmpTN.Text = '' then EdtPtsEmpTN.Text := '1';
if EdtPtsVitPro.Text = '' then EdtPtsVitPro.Text := '0';
if EdtPtsEmpPro.Text = '' then EdtPtsEmpPro.Text := '0';
if EdtPtsDerPro.Text = '' then EdtPtsEmpPro.Text := '0';
if EdtPtsVitPen.Text = '' then EdtPtsVitPen.Text := '0';
if EdtPtsDerPen.Text = '' then EdtPtsDerPen.Text := '0';
if EdtNumPro.Text = '' then EdtNumPro.Text := '0';
if EdtNumComp1.Text = '' then EdtNumComp1.Text := '0';
if EdtNumComp2.Text = '' then EdtNumComp2.Text := '0';
if EdtNumPOReb.Text = '' then EdtNumPOReb.Text := '0';
if EdtNumReb.Text = '' then EdtNumReb.Text := '0';
end;
end;
196
end;
function TFrmCadTemporada.GetCriterioDesempate: String;
var
SQL: String;
i: integer;
begin
// Saldo de Gols:1; Vitorias: 2; GolsPro: 3; Gols Fora: 4
SQL := '';
if LstBxCriterioDesempate.Items[i] = 'Saldo de Gols' then begin
SQL := SQL + '1';
end else begin
if LstBxCriterioDesempate.Items[i] = 'Numero de Vitorias' then begin
SQL := SQL + '2';
end else begin
if LstBxCriterioDesempate.Items[i] = 'Gols Pro' then begin
SQL := SQL + '3';
end else begin
SQL := SQL + '4'; // Gols Fora de Casa
end;
end;
end;
end;
GetCriterioDesempate := SQL;
end;
procedure TFrmCadTemporada.FormCreate(Sender: TObject);
begin
LstBxCriterioDesempate.ItemIndex := 0;
end;
procedure TFrmCadTemporada.AtualizaLstBxCriterioDesempate (Texto: String);
var
i: Integer;
begin
for i:=1 to Length(Texto) do begin
if Texto[i] = '1' then begin
LstBxCriterioDesempate.Items.Add('Saldo de Gols');
end else begin
LstBxCriterioDesempate.Items.Add('Numero de Vitorias');
end else begin
LstBxCriterioDesempate.Items.Add('Gols Pro');
end else begin
LstBxCriterioDesempate.Items.Add('Gols Fora de Casa');
end;
end;
end;
end;
end;
end;
procedure TFrmCadTemporada.BtnSubirClick(Sender: TObject);
var
Texto: String;
begin
if LstBxCriterioDesempate.ItemIndex <> 0 then begin
Texto := LstBxCriterioDesempate.Items[LstBxCriterioDesempate.ItemIndex-1];
LstBxCriterioDesempate.Items[LstBxCriterioDesempate.ItemIndex-1] :=
LstBxCriterioDesempate.Items[LstBxCriterioDesempate.ItemIndex];
LstBxCriterioDesempate.Items[LstBxCriterioDesempate.ItemIndex] := Texto;
LstBxCriterioDesempate.ItemIndex := LstBxCriterioDesempate.ItemIndex - 1;
end;
end;
procedure TFrmCadTemporada.BtnDescerClick(Sender: TObject);
var
Texto: String;
begin
if LstBxCriterioDesempate.ItemIndex <> 3 then begin
Texto := LstBxCriterioDesempate.Items[LstBxCriterioDesempate.ItemIndex+1];
LstBxCriterioDesempate.Items[LstBxCriterioDesempate.ItemIndex+1] :=
LstBxCriterioDesempate.Items[LstBxCriterioDesempate.ItemIndex];
LstBxCriterioDesempate.Items[LstBxCriterioDesempate.ItemIndex] := Texto;
197
LstBxCriterioDesempate.ItemIndex := LstBxCriterioDesempate.ItemIndex + 1;
end;
end;
end.
========================================================================================
====
ARQUIVO: UICadJogos.pas
========================================================================================
====
unit UICadJogos;
interface
uses
Dialogs, Borland.Vcl.StdCtrls, Borland.Vcl.DBCtrls, Borland.Vcl.ComCtrls,
Borland.Vcl.ExtCtrls, Borland.Vcl.Mask, System.ComponentModel, DBXpress,
FMTBcd, Borland.Vcl.Provider, Borland.Vcl.DBClient, Borland.Vcl.Db,
Borland.Vcl.SqlExpr, Borland.Vcl.Buttons, UTemporada, UItemCombo, UMeuUtils,
UDMDados, Borland.Vcl.ExtDlgs, UDMICadJogos, UICadEstadio, UICadArbitro,
Borland.Vcl.IniFiles;
type
TFrmCadJogos = class(TForm)
Panel1: TPanel;
PgCntrlDados: TPageControl;
PnlTmpNormal: TPanel;
PnlProrrog: TPanel;
PnlPen: TPanel;
ChckBxTempoNormal: TCheckBox;
ChckBxProrrogacao: TCheckBox;
ChckBxPenaltis: TCheckBox;
Label1: TLabel;
DtTmPckrDataJogo: TDateTimePicker;
Label2: TLabel;
Label5: TLabel;
BtnIncluirArbitro: TButton;
Label4: TLabel;
CmbBxEstadio: TComboBox;
BtnIncluirEstadio: TButton;
Label3: TLabel;
BtnGravar: TBitBtn;
Panel5: TPanel;
Panel6: TPanel;
Panel7: TPanel;
Label7: TLabel;
EdtTV: TEdit;
Panel8: TPanel;
Panel9: TPanel;
Panel10: TPanel;
Panel11: TPanel;
MmComentarios: TMemo;
Label6: TLabel;
PnlDiaSemana: TPanel;
CmbBxEquipeCasa: TComboBox;
CmbBxEquipeFora: TComboBox;
EdtGolsCasa: TEdit;
EdtGolsCasaProrrog: TEdit;
EdtGolsCasaPen: TEdit;
EdtGolsFora: TEdit;
EdtGolsForaProrrog: TEdit;
EdtGolsForaPen: TEdit;
EdtPublico: TEdit;
EdtHoraJogo: TMaskEdit;
CmbBxArbitro: TComboBox;
PnlEquipeCasa: TPanel;
Panel13: TPanel;
PnlEquipeFora: TPanel;
EdtChutesCasa: TEdit;
EdtFaltasCasa: TEdit;
EdtEscanteiosCasa: TEdit;
198
EdtImpedimentosCasa: TEdit;
EdtChutesFora: TEdit;
EdtFaltasFora: TEdit;
EdtImpedimentosFora: TEdit;
EdtEscanteiosFora: TEdit;
Panel12: TPanel;
ImgEquipeFora: TImage;
Panel14: TPanel;
ImgEquipeCasa: TImage;
Panel15: TPanel;
ImgEstadio: TImage;
BtnFoto1: TButton;
Panel17: TPanel;
BtnFoto2: TButton;
OpenPictureDialog1: TOpenPictureDialog;
ImgJogo2: TImage;
Panel16: TPanel;
ImgJogo1: TImage;
ImgBranco: TImage;
procedure ChckBxTempoNormalClick(Sender: TObject);
procedure ChckBxProrrogacaoClick(Sender: TObject);
procedure ChckBxPenaltisClick(Sender: TObject);
procedure DtTmPckrDataJogoChange(Sender: TObject);
procedure EdtGolsForaKeyPress(Sender: TObject; var Key: Char);
procedure CmbBxEquipeCasaChange(Sender: TObject);
procedure CmbBxEquipeForaChange(Sender: TObject);
procedure CmbBxEstadioChange(Sender: TObject);
procedure BtnFoto1Click(Sender: TObject);
procedure BtnFoto2Click(Sender: TObject);
procedure BtnIncluirEstadioClick(Sender: TObject);
procedure BtnIncluirArbitroClick(Sender: TObject);
procedure AtualizaCmbBxEstadio;
procedure AtualizaCmbBxArbitro;
procedure EdtHoraJogoChange(Sender: TObject);
private
CodTemporada, CodFase, CodGrupo, CodRodada, CodJogo : integer;
conBD: TDtMdlDados;
BD: TDtMdlICadJogos;
Status: String; //A: Alterar Jogo; N: NovoJogo;
public
procedure Mostrar (umaTemporada : TTemporada; umCodTemp, umaFase, umGrupo,
umaRodada, umCodJogo : integer; umStatus: String);
procedure SetBD (var conBD: TDtMdlDados);
procedure CarregarDadosJogo;
procedure AtualizarDadosJogo;
procedure SetEstadio;
function ValidaJogo : boolean;
function TestaHorario : boolean;
end;
var
FrmCadJogos: TFrmCadJogos;
implementation
{$R *.nfm}
procedure TFrmCadJogos.Mostrar (umaTemporada : TTemporada; umCodTemp, umaFase, umGrupo,
umaRodada, umCodJogo : integer; umStatus: String);
var
SQL: String;
NumTimesCadastrados: Integer;
umaData, umaHora: String;
ArqIni: TIniFile;
begin
Temporada := umaTemporada;
CodTemporada := umCodTemp;
CodFase := umaFase;
CodGrupo := umGrupo;
199
CodRodada := umaRodada;
Status := umStatus;
umaData := ArqIni.ReadString('CadJogo', 'Data', umaData);
umaHora := ArqIni.ReadString('CadJogo', 'Hora', umaHora);
DtTmPckrDataJogo.DateTime := StrToDateTime(umaData);
EdtHoraJogo.Text := umaHora;
ArqIni.Free;
SQL := 'Select COUNT(*) from EQUIPECOMPETETEMPORADA where CODTEMPORADA=' +
Close;
Open;
First;
NumTimesCadastrados := FieldByName('Count').asInteger;
end;
if NumTimesCadastrados > 1 then begin
Self.AtualizarDadosJogo;
if Status = 'A' then begin
Self.CarregarDadosJogo;
end;
PnlDiaSemana.Caption := MeusUtils.DiaDaSemana(DtTmPckrDataJogo.Date);
showModal;
end else begin
ShowMessage('Esta Temporada no possui equipes para incluir o jogo');
end;
end;
procedure TFrmCadJogos.CarregarDadosJogo;
var
codEst, i : integer;
achou : boolean;
Hora, Minuto: String;
begin
BD.SQLDtStJogo.ParamByName('Cod').AsInteger := codJogo;
with BD.ClntDtStJogo do begin
Close;
Open;
First;
// ------ Atualiza o Time da Casa
achou := false;
i:= 0;
while (achou=false) and (i < CmbBxEquipeCasa.Items.Count) do begin
if TItemCombo(CmbBxEquipeCasa.Items.Objects[i]).GetOid =
FieldByName('CodEquipeCasa').asInteger then begin
Achou := true;
CmbBxEquipeCasa.ItemIndex := i;
end;
i := i + 1;
end;
PnlEquipeCasa.caption := CmbBxEquipeCasa.Items.Strings[CmbBxEquipeCasa.ItemIndex];
Self.CmbBxEquipeCasaChange(nil);
// ------ Atualiza o Time da Fora
achou := false;
i:= 0;
while (achou=false) and (i < CmbBxEquipeFora.Items.Count) do begin
if TItemCombo(CmbBxEquipeFora.Items.Objects[i]).GetOid =
FieldByName('CodEquipeFora').asInteger then begin
Achou := true;
CmbBxEquipeFora.ItemIndex := i;
end;
i := i + 1;
end;
PnlEquipeFora.caption := CmbBxEquipeFora.Items.Strings[CmbBxEquipeFora.ItemIndex];
Self.CmbBxEquipeForaChange(nil);
// ------ Atualiza o Estadio do Jogo
achou := false;
i:= 0;
while (achou=false) and (i < CmbBxEstadio.Items.Count) do begin
if TItemCombo(CmbBxEstadio.Items.Objects[i]).GetOid =
FieldByName('CodEstadio').asInteger then begin
Achou := true;
CmbBxEstadio.ItemIndex := i;
end;
i := i + 1;
200
end;
Self.CmbBxEstadioChange(nil);
// ------ Atualiza o Arbitro do Jogo
achou := false;
i:= 0;
while (achou=false) and (i < CmbBxArbitro.Items.Count) do begin
if TItemCombo(CmbBxArbitro.Items.Objects[i]).GetOid =
FieldByName('CodArbitro').asInteger then begin
Achou := true;
CmbBxArbitro.ItemIndex := i;
end;
i := i + 1;
end;
// ------ Atualiza Demais campos
if FieldByName('Realizado').asInteger = 1 then begin
CmbBxEquipeCasa.Enabled := False;
CmbBxEquipeFora.Enabled := False;
ChckBxTempoNormal.Checked := True;
ChckBxTempoNormal.Enabled := True;
EdtGolsCasa.Enabled := True;
EdtGolsCasa.Text := FieldByName('GolsTimeCasa').asString;
EdtGolsFora.Enabled := True;
EdtGolsFora.Text := FieldByName('GolsTimeFora').asString;
EdtFaltasCasa.Enabled := True;
EdtFaltasCasa.Text := FieldByName('EstatFaltaCasa').asString;
EdtFaltasFora.Enabled := True;
EdtFaltasFora.Text := FieldByName('EstatFaltaFora').asString;
EdtEscanteiosCasa.Enabled := True;
EdtEscanteiosCasa.Text := FieldByName('EstatEscanteioCasa').asString;
EdtEscanteiosFora.Enabled := True;
EdtEscanteiosFora.Text := FieldByName('EstatEscanteioFora').asString;
EdtImpedimentosCasa.Enabled := True;
EdtImpedimentosCasa.Text := FieldByName('EstatImpedimentoCasa').asString;
EdtImpedimentosFora.Enabled := True;
EdtImpedimentosFora.Text := FieldByName('EstatImpedimentoFora').asString;
EdtChutesCasa.Enabled := True;
EdtChutesCasa.Text := FieldByName('EstatChuteCasa').asString;
EdtChutesFora.Enabled := True;
EdtChutesFora.Text := FieldByName('EstatChuteFora').asString;
EdtPublico.Text := FieldByName('Publico').asString;
if FieldByName('Prorrogacao').asInteger = 1 then begin
ChckBxProrrogacao.Checked := True;
ChckBxProrrogacao.Enabled := True;
EdtGolsCasaProrrog.Text := FieldByName('GolsTimeCasaProrrogacao').asString;
EdtGolsForaProrrog.Text := FieldByName('GolsTimeForaProrrogacao').asString;
if FieldByName('Penaltis').asInteger = 1 then begin
ChckBxPenaltis.Checked := True;
ChckBxPenaltis.Enabled := True;
EdtGolsCasaPen.Text := FieldByName('GolsTimeCasaPenaltis').asString;
EdtGolsForaPen.Text := FieldByName('GolsTimeForaPenaltis').asString;
end;
end;
end;
EdtTV.Text := FieldByName('TV').asString;
DtTmPckrDataJogo.DateTime := FieldByName('DataHoraJogo').asDateTime;
Hora := TimeToStr(FieldByName('DataHoraJogo').asDateTime).Substring(0,2);
Minuto := TimeToStr(FieldByName('DataHoraJogo').asDateTime).Substring(3,2);
EdtHoraJogo.Text := Hora + ':' + Minuto;
MmComentarios.Lines.Add (FieldByName('Noticia').asString);
ImgJogo1.Picture.BitMap.LoadFromStream(CreateBlobStream(FieldByName('Foto1'),bmRead));
ImgJogo2.Picture.BitMap.LoadFromStream(CreateBlobStream(FieldByName('Foto2'),bmRead));
end;
end;
procedure TFrmCadJogos.SetBD (var conBD: TDtMdlDados);
begin
BD := TDtMdlICadJogos.Create(nil);
end;
procedure TFrmCadJogos.AtualizarDadosJogo;
var
ItemCombo : TItemCombo;
Imagem: TStream;
umaData: String;
201
begin
// ------ Atualiza os ComboBox dos Times da Casa e dos Times de Fora ----------BD.SQLDtStEquipe.ParamByName('codTemp').AsInteger := codTemporada;
with BD.ClntDtStEquipe do begin
Close;
Open;
First;
ItemCombo.setOid(FieldByName('CodEquipe').asInteger);
ItemCombo.SetNome(FieldByName('NomeEquipe').asString);
ItemCombo.setOid2(FieldByName('CodEstadio').asInteger);
CmbBxEquipeCasa.Items.AddObject(FieldByName('NomeEquipe').asString, ItemCombo);
CmbBxEquipeFora.Items.AddObject(FieldByName('NomeEquipe').asString, ItemCombo);
Next;
end;
end;
CmbBxEquipeCasa.ItemIndex := 0;
CmbBxEquipeFora.ItemIndex := 1;
// ------ Atualiza os ComboBox do Juiz ----------Self.AtualizaCmbBxArbitro;
// ------ Atualiza os ComboBox do Estdio ----------Self.AtualizaCmbBxEstadio;
Self.CmbBxEquipeCasaChange(nil);
Self.CmbBxEquipeForaChange(nil);
end;
procedure TFrmCadJogos.AtualizaCmbBxArbitro;
var
i: Integer;
begin
for i:=0 to CmbBxArbitro.Items.Count-1 do begin
TItemCombo(CmbBxArbitro.Items.Objects[i]).Destroy;
end;
CmbBxArbitro.Items.Clear;
ItemCombo.setOid(0);
CmbBxArbitro.Items.AddObject('', ItemCombo);
BD.SQLDtStArbitro.ParamByName('codTemp').AsInteger := codTemporada;
with BD.ClntDtStArbitro do begin
Close;
Open;
First;
ItemCombo.setOid(FieldByName('CodArbitro').asInteger);
ItemCombo.SetNome(FieldByName('NomeArbitro').asString);
CmbBxArbitro.Items.AddObject(FieldByName('NomeArbitro').asString, ItemCombo);
Next;
end;
end;
CmbBxArbitro.ItemIndex := 0;
end;
procedure TFrmCadJogos.AtualizaCmbBxEstadio;
var
Imagem: TStream;
i: Integer;
begin
for i:=0 to CmbBxEstadio.Items.Count-1 do begin
TItemCombo(CmbBxEstadio.Items.Objects[i]).Destroy;
end;
CmbBxEstadio.Items.Clear;
CmbBxEstadio.Items.AddObject('', ItemCombo);
with BD.ClntDtStEstadio do begin
Close;
Open;
First;
ItemCombo.setOid(FieldByName('CodEstadio').asInteger);
202
ItemCombo.SetNome(FieldByName('NomeEstadio').asString);
CmbBxEstadio.Items.AddObject(FieldByName('NomeEstadio').asString + ', ' +
FieldByName('CidadeEstadio').asString, ItemCombo);
Next;
end;
end;
Self.SetEstadio;
Self.CmbBxEstadioChange(nil);
end;
procedure TFrmCadJogos.BtnGravarClick(Sender: TObject);
var
Retorno : String;
CodEstTemp, CodEquipeCasa, CodEquipeFora, CodArbitro, CodEstadio, Realizado,
Prorrogacao, Penaltis: Integer;
GolsTimeCasa, GolsTimeFora, GolsTimeCasaProrrog, GolsTimeForaProrrog, GolsTimeCasaPen,
GolsTimeForaPen : Integer;
Publico, ChutesTimeCasa, ChutesTimeFora, ImpedTimeCasa, ImpedTimeFora,
EscanteiosTimeCasa, EscanteiosTimeFora, FaltasTimeCasa, FaltasTimeFora : Integer;
DataHoraJogo: TDateTime;
Noticia : String;
Tv : String;
Foto1, Foto2 : TMemoryStream;
begin
if ValidaJogo then begin
CodEstTemp := CodRodada;
CodEquipeCasa :=
TItemCombo(CmbBxEquipeCasa.Items.Objects[CmbBxEquipeCasa.ItemIndex]).GetOid;
CodEquipeFora :=
TItemCombo(CmbBxEquipeFora.Items.Objects[CmbBxEquipeFora.ItemIndex]).GetOid;
CodArbitro := TItemCombo(CmbBxArbitro.Items.Objects[CmbBxArbitro.ItemIndex]).GetOid;
CodEstadio := TItemCombo(CmbBxEstadio.Items.Objects[CmbBxEstadio.ItemIndex]).GetOid;
TV := EdtTV.Text;
Noticia := MmComentarios.Lines.Text;
if ChckBxTempoNormal.Checked = True then Realizado := 1 else Realizado := 0;
GolsTimeCasa := StrToInt(EdtGolsCasa.Text);
GolsTimeFora := StrToInt(EdtGolsFora.Text);
ChutesTimeCasa := StrToInt(EdtChutesCasa.Text);
ChutesTimeFora := StrToInt(EdtChutesFora.Text);
ImpedTimeCasa := StrToInt(EdtImpedimentosCasa.Text);
ImpedTimeFora := StrToInt(EdtImpedimentosFora.Text);
EscanteiosTimeCasa := StrToInt(EdtEscanteiosCasa.Text);
EscanteiosTimeFora := StrToInt(EdtEscanteiosFora.Text);
FaltasTimeCasa := StrToInt(EdtFaltasCasa.Text);
FaltasTimeFora := StrToInt(EdtFaltasFora.Text);
Publico := StrToInt(EdtPublico.Text);
if ChckBxProrrogacao.Checked = True then Prorrogacao := 1 else Prorrogacao := 0;
GolsTimeCasaProrrog := StrToInt(EdtGolsCasaProrrog.Text);
GolsTimeForaProrrog := StrToInt(EdtGolsForaProrrog.Text);
if ChckBxPenaltis.Checked = True then Penaltis := 1 else Penaltis := 0;
GolsTimeCasaPen := StrToInt(EdtGolsCasaPen.Text);
GolsTimeForaPen := StrToInt(EdtGolsForaPen.Text);
DataHoraJogo := Int(DtTmPckrDataJogo.date) + Frac(StrToTime(EdtHoraJogo.Text));
ImgJogo1.Picture.Graphic.SaveToStream(Foto1);
ImgJogo2.Picture.Graphic.SaveToStream(Foto2);
if status = 'N' then begin
try
Temporada.NovoJogo(CodEstTemp, CodEquipeCasa, CodEquipeFora, DataHoraJogo,
CodArbitro, CodEstadio,
Realizado, GolsTimeCasa, GolsTimeFora, Prorrogacao,
GolsTimeForaProrrog, Penaltis, GolsTimeCasaPen, GolsTimeForaPen,
Publico,
ChutesTimeCasa, ChutesTimeFora, ImpedTimeCasa, ImpedTimeFora,
FaltasTimeCasa,
FaltasTimeFora, EscanteiosTimeCasa, EscanteiosTimeFora, Noticia,
TV, Foto1, Foto2);
except
end;
end;
end else begin
try
203
Temporada.AlterarJogo(CodJogo, CodEstTemp, CodEquipeCasa, CodEquipeFora,

DataHoraJogo, CodArbitro,
CodEstadio, Realizado, GolsTimeCasa, GolsTimeFora, Prorrogacao,
GolsTimeForaProrrog, Penaltis, GolsTimeCasaPen, GolsTimeForaPen,
Publico,
ChutesTimeCasa, ChutesTimeFora, ImpedTimeCasa, ImpedTimeFora,
FaltasTimeCasa,
FaltasTimeFora, EscanteiosTimeCasa, EscanteiosTimeFora, Noticia,
TV, Foto1, Foto2);
except
Suporte');
end;
end;
end;
self.Close;
end;
end;
function TFrmCadJogos.ValidaJogo : boolean;
var
Hora : TDateTime;
begin
if TItemCombo(CmbBxEquipeCasa.Items.Objects[CmbBxEquipeCasa.ItemIndex]).GetOid =
TItemCombo(CmbBxEquipeFora.Items.Objects[CmbBxEquipeFora.ItemIndex]).GetOid then begin
showMessage ('Erro: Time Anfitrio = Time Visitante');
CmbBxEquipeCasa.SetFocus;
ValidaJogo := false;
end else begin
if (ChckBxTempoNormal.Checked = True) and (EdtGolsCasa.Text = '') then begin
showMessage ('Erro: Placar Invlido no Tempo Normal');
EdtGolsCasa.SetFocus;
end else begin
if (ChckBxTempoNormal.Checked = True) and (EdtGolsFora.Text = '') then begin
showMessage ('Erro: Placar Invlido no Tempo Normal');
EdtGolsFora.SetFocus;
end else begin
if (ChckBxProrrogacao.Checked = True) and (EdtGolsCasaProrrog.Text = '') then
begin
ShowMessage ('Erro: Placar Invlido na Prorrogao');
EdtGolsCasaProrrog.SetFocus;
end else begin
if (ChckBxProrrogacao.Checked = True) and (EdtGolsForaProrrog.Text = '') then
begin
showMessage ('Erro: Placar Invlido na Prorrogao');
EdtGolsForaProrrog.SetFocus;
end else begin
if (ChckBxPenaltis.Checked = True) and (EdtGolsCasaPen.Text = '') then begin
ShowMessage ('Erro: Placar Invlido nos Pnaltis');
EdtGolsCasaPen.SetFocus;
end else begin
if (ChckBxPenaltis.Checked = True) and (EdtGolsForaPen.Text = '') then
begin
showMessage ('Erro: Placar Invlido nos Pnatils');
EdtGolsForaPen.SetFocus;
end else begin
if (EdtGolsCasaPen.Text = EdtGolsForaPen.Text) and
(ChckBxPenaltis.Checked = True) then begin
showMessage ('Erro: No pode haver empate nos penaltis');
EdtGolsCasaPen.SetFocus;
end else begin
if self.TestaHorario = false then begin
showMessage ('Erro: Horrio Invlido');
EdtHoraJogo.SetFocus;
end else begin
if (EdtGolsCasa.Text = '') or (ChckBxTempoNormal.Checked = False)
then EdtGolsCasa.Text := '0';
204
if (EdtGolsFora.Text = '') or (ChckBxTempoNormal.Checked = False)

then EdtGolsFora.Text := '0';
if (EdtGolsCasaProrrog.Text = '') or (ChckBxProrrogacao.Checked =
False) then EdtGolsCasaProrrog.Text := '0';
if (EdtGolsForaProrrog.Text = '') or (ChckBxProrrogacao.Checked =
False) then EdtGolsForaProrrog.Text := '0';
if (EdtGolsCasaPen.Text = '') or (ChckBxPenaltis.Checked = False)
then EdtGolsCasaPen.Text := '0';
if (EdtGolsForaPen.Text = '') or (ChckBxPenaltis.Checked = False)
then EdtGolsForaPen.Text := '0';
if (EdtChutesCasa.Text = '') or (ChckBxTempoNormal.Checked = False)
then EdtChutesCasa.Text := '0';
if (EdtChutesFora.Text = '') or (ChckBxTempoNormal.Checked = False)
then EdtChutesFora.Text := '0';
if (EdtImpedimentosCasa.Text = '') or (ChckBxTempoNormal.Checked =
False) then EdtImpedimentosCasa.Text := '0';
if (EdtImpedimentosFora.Text = '') or (ChckBxTempoNormal.Checked =
False) then EdtImpedimentosFora.Text := '0';
if (EdtEscanteiosCasa.Text = '') or (ChckBxTempoNormal.Checked =
False) then EdtEscanteiosCasa.Text := '0';
if (EdtEscanteiosFora.Text = '') or (ChckBxTempoNormal.Checked =
False) then EdtEscanteiosFora.Text := '0';
if (EdtFaltasCasa.Text = '') or (ChckBxTempoNormal.Checked = False)
then EdtFaltasCasa.Text := '0';
if (EdtFaltasFora.Text = '') or (ChckBxTempoNormal.Checked = False)
then EdtFaltasFora.Text := '0';
if (EdtPublico.Text = '') or (ChckBxTempoNormal.Checked = False)
then EdtPublico.Text := '0';
if (EdtHoraJogo.Text = ' : ') then EdtHoraJogo.Text := '00:00';
ValidaJogo := true;
end;
end;
end;
end;
end;
end;
end;
end;
end;
end;
procedure TFrmCadJogos.ChckBxTempoNormalClick(Sender: TObject);
begin
if ChckBxTempoNormal.Checked = True then begin
EdtGolsCasa.Enabled := True;
EdtGolsFora.Enabled := True;
ChckBxProrrogacao.Enabled := True;
ChckBxPenaltis.Enabled := True;
EdtFaltasCasa.Enabled := True;
EdtFaltasFora.Enabled := True;
EdtEscanteiosCasa.Enabled := True;
EdtEscanteiosFora.Enabled := True;
EdtImpedimentosCasa.Enabled := True;
EdtImpedimentosFora.Enabled := True;
EdtChutesCasa.Enabled := True;
EdtChutesFora.Enabled := True;
end else begin
ChckBxProrrogacao.Checked := False;
ChckBxPenaltis.Checked := False;
EdtGolsCasa.Enabled := False;
EdtGolsFora.Enabled := False;
ChckBxProrrogacao.Enabled := False;
ChckBxPenaltis.Enabled := False;
EdtFaltasCasa.Enabled := False;
EdtFaltasFora.Enabled := False;
EdtEscanteiosCasa.Enabled := False;
EdtEscanteiosFora.Enabled := False;
EdtImpedimentosCasa.Enabled := False;
EdtImpedimentosFora.Enabled := False;
EdtChutesCasa.Enabled := False;
EdtChutesFora.Enabled := False;
end;
end;
procedure TFrmCadJogos.ChckBxProrrogacaoClick(Sender: TObject);
begin
if ChckBxProrrogacao.Checked = True then begin
205
EdtGolsCasaProrrog.Enabled
EdtGolsForaProrrog.Enabled
end else begin
EdtGolsCasaProrrog.Enabled
EdtGolsForaProrrog.Enabled
end;
end;
:= True;
:= True;
:= False;
:= False;
procedure TFrmCadJogos.ChckBxPenaltisClick(Sender: TObject);

begin
if ChckBxPenaltis.Checked = True then begin
EdtGolsCasaPen.Enabled := True;
EdtGolsForaPen.Enabled := True;
end else begin
EdtGolsCasaPen.Enabled := False;
EdtGolsForaPen.Enabled := False;
end;
end;
procedure TFrmCadJogos.DtTmPckrDataJogoChange(Sender: TObject);
var
ArqIni: TIniFile;
begin
PnlDiaSemana.Caption := MeusUtils.DiaDaSemana (DtTmPckrDataJogo.Date);
try
ArqIni.WriteString('CadJogo', 'Data', DateTimeToStr(DtTmPckrDataJogo.DateTime));
Finally
ArqIni.Free;
end;
end;
procedure TFrmCadJogos.EdtGolsForaKeyPress(Sender: TObject; var Key: Char);
begin
Key := #0;
Beep;
end;
end;
procedure TFrmCadJogos.SetEstadio;
var
codEst, i : integer;
achou : boolean;
begin
codEst :=
TItemCombo(CmbBxEquipeCasa.Items.Objects[CmbBxEquipeCasa.ItemIndex]).GetOid2;
achou := false;
i:= 1;
while (achou=false) and (i < CmbBxEstadio.Items.Count) do begin
if TItemCombo(CmbBxEstadio.Items.Objects[i]).GetOid = codEst then begin
Achou := true;
CmbBxEstadio.ItemIndex := i;
end;
i := i + 1;
end;
if Achou = false then begin
CmbBxEstadio.ItemIndex := 0;
end;
Self.CmbBxEstadioChange(nil)
end;
procedure TFrmCadJogos.CmbBxEquipeCasaChange(Sender: TObject);
var
SQL: String;
begin
Self.SetEstadio;
IntToStr(TItemCombo(CmbBxEquipeCasa.Items.Objects[CmbBxEquipeCasa.ItemIndex]).GetOid);
Close;
Open;
First;
206
ImgEquipeCasa.Picture.Bitmap.LoadFromStream(BD.ClntDtStDados.CreateBlobStream(BD.ClntDtS
tDados.FieldByName('Escudo'),bmRead));
end;
ImgEquipeCasa.Picture.Bitmap.Destroy;
end;
procedure TFrmCadJogos.FormCreate(Sender: TObject);
begin
PgCntrlDados.ActivePage := TabSheet1;
end;
procedure TFrmCadJogos.CmbBxEquipeForaChange(Sender: TObject);
var
SQL: String;
begin
IntToStr(TItemCombo(CmbBxEquipeFora.Items.Objects[CmbBxEquipeFora.ItemIndex]).GetOid);
Close;
Open;
First;
ImgEquipeFora.Picture.Bitmap.LoadFromStream(BD.ClntDtStDados.CreateBlobStream(BD.ClntDtS
tDados.FieldByName('Escudo'),bmRead));
end;
ImgEquipeFora.Picture.Bitmap.Destroy;
end;
function TFrmCadJogos.TestaHorario : boolean;
var
Hora : TDateTime;
begin
if edtHoraJogo.Text <> ' : ' then begin
try
Hora := StrToTime (edtHoraJogo.Text);
TestaHorario := true;
except
on e: EConvertError do begin
TestaHorario := false;
end;
end;
end else begin
TestaHorario := true;
end;
end;
procedure TFrmCadJogos.FormDestroy(Sender: TObject);
var
i: Integer;
begin
for i:=0 to CmbBxEquipeCasa.Items.Count-1 do begin
TItemCombo(CmbBxEquipeCasa.Items.Objects[i]).Destroy;
end;
for i:=0 to CmbBxEquipeFora.Items.Count-1 do begin
TItemCombo(CmbBxEquipeFora.Items.Objects[i]).Destroy;
end;
for i:=0 to CmbBxEstadio.Items.Count-1 do begin
TItemCombo(CmbBxEstadio.Items.Objects[i]).Destroy;
end;
for i:=0 to CmbBxArbitro.Items.Count-1 do begin
TItemCombo(CmbBxArbitro.Items.Objects[i]).Destroy;
end;
BD.Destroy;
MeusUtils.Free;
Temporada.Destroy;
end;
procedure TFrmCadJogos.CmbBxEstadioChange(Sender: TObject);
var
SQL: String;
begin
if CmbBxEstadio.ItemIndex <> 0 then begin
207
SQL := 'select FOTO from ESTADIO where CODESTADIO=' +

IntToStr(TItemCombo(CmbBxEstadio.Items.Objects[CmbBxEstadio.ItemIndex]).GetOid);
Close;
Open;
First;
ImgEstadio.Picture.Bitmap.LoadFromStream(BD.ClntDtStDados.CreateBlobStream(BD.ClntDtStDa
dos.FieldByName('Foto'),bmRead));
end;
end else begin
ImgEstadio.Picture := ImgBranco.Picture;
end;
ImgEstadio.Picture.Bitmap.Destroy;
end;
procedure TFrmCadJogos.BtnFoto1Click(Sender: TObject);
begin
if OpenPictureDialog1.Execute then begin
ImgJogo1.Picture.LoadFromFile(OpenPictureDialog1.FileName);
end;
end;
procedure TFrmCadJogos.BtnFoto2Click(Sender: TObject);
begin
ImgJogo2.Picture.LoadFromFile(OpenPictureDialog1.FileName);
end;
end;
procedure TFrmCadJogos.BtnCancelarClick(Sender: TObject);
begin
self.Close;
end;
procedure TFrmCadJogos.BtnIncluirEstadioClick(Sender: TObject);
var
begin
Self.AtualizaCmbBxEstadio;
end;
procedure TFrmCadJogos.BtnIncluirArbitroClick(Sender: TObject);
var
FrmCadArbitro: TFrmCadArbitro;
begin
FrmCadArbitro := TFrmCadArbitro.Create(nil); FrmCadArbitro.SetBD(conBD);
FrmCadArbitro.Mostrar (Temporada);
FrmCadArbitro.Destroy;
Self.AtualizaCmbBxArbitro;
end;
procedure TFrmCadJogos.EdtHoraJogoChange(Sender: TObject);
var
ArqIni: TIniFile;
begin
try
ArqIni.WriteString('CadJogo', 'Hora', EdtHoraJogo.Text);
Finally
ArqIni.Free;
end;
end;
end.
========================================================================================
====
ARQUIVO: UICadJogador.pas
========================================================================================
====
unit UICadJogador;
208
interface
uses
Dialogs, FMTBcd, Borland.Vcl.Provider, Borland.Vcl.SqlExpr,
Borland.Vcl.Db, Borland.Vcl.DBClient, Borland.Vcl.ExtDlgs,
Borland.Vcl.Grids, Borland.Vcl.DBGrids, Borland.Vcl.Buttons,
Borland.Vcl.ComCtrls, Borland.Vcl.StdCtrls, Borland.Vcl.ExtCtrls,
System.ComponentModel, UDMDados, UTemporada, UMeuUtils, UItemCombo, UEquipe;
type
TFrmCadJogador = class(TForm)
ImgBranco: TImage;
Label1: TLabel;
Label2: TLabel;
Label3: TLabel;
Label4: TLabel;
Label5: TLabel;
Label6: TLabel;
Label7: TLabel;
Label8: TLabel;
EdtNomeJogador: TEdit;
EdtNacionalidade: TEdit;
CmbBxPosicao: TComboBox;
Panel7: TPanel;
ImgJogador: TImage;
BtnCarregarImg: TButton;
EdtApelidoJogador: TEdit;
DtDataNascimento: TDateTimePicker;
EdtNumCamisa: TEdit;
PnlIdade: TPanel;
PnlBtns: TPanel;
BtnGravar: TBitBtn;
DBGrdJogadores: TDBGrid;
Panel3: TPanel;
Panel1: TPanel;
EdtEmail: TEdit;
SQLDtStJogador: TSQLDataSet;
DtStPrvdrJogador: TDataSetProvider;
ClntDtStJogador: TClientDataSet;
DateField2: TDateField;
BlobField2: TBlobField;
DtSrcJogador: TDataSource;
BtnFechar: TBitBtn;
BtnIncluirJogador: TBitBtn;
209
BtnAlterarJogador: TBitBtn;
BtnExcluirJogador: TBitBtn;
procedure CmbBxEquipeChange(Sender: TObject);
procedure BtnCarregarImgClick(Sender: TObject);
procedure EdtNumCamisaKeyPress(Sender: TObject; var Key: Char);
procedure BtnIncluirJogadorClick(Sender: TObject);
procedure DtDataNascimentoChange(Sender: TObject);
procedure BtnAlterarJogadorClick(Sender: TObject);
function ValidaFormulario : Boolean;
procedure DBGrdJogadoresDblClick(Sender: TObject);
procedure BtnExcluirJogadorClick(Sender: TObject);
private
conBD: TDtMdlDados;
Status: String;
CodJogador: Integer;
CodEquipe: Integer;
NumTimes: Integer;
procedure LiberaFormulario;
public
procedure Mostrar (umaTemp: TTemporada; umCodEquipe: Integer);
end;
var
implementation
{$R *.nfm}
procedure TFrmCadJogador.BtnFecharClick(Sender: TObject);
begin
Self.Close;
end;
procedure TFrmCadJogador.SetBD (var umaConBD: TDtMdlDados);
begin
conBD := umaConBD;
end;
procedure TFrmCadJogador.Mostrar (umaTemp: TTemporada; umCodEquipe: Integer);
var
SQL: String;
Achou: Boolean;
i: Integer;
begin
SQL := 'Select Count(*) from EQUIPECOMPETETEMPORADA where CODTEMPORADA=' + IntToStr
ClntDtStDados.Open;
NumTimes := ClntDtStDados.FieldByName('Count').AsInteger;
if NumTimes > 0 then begin
Achou := False;
SQLDtStEquipeDisputaTemp.ParamByName('CodTemp').AsInteger :=
with ClntDtStEquipeDisputaTemp do begin
Close;
Open;
First;
i := 0;
210
if ((not Achou) and (umCodEquipe >0)) then begin
i := i + 1;
if FieldByName('CodEquipe').AsInteger = umCodEquipe then begin
Achou := True;
i := i - 1;
end;
end;
Next;
end;
CmbBxEquipe.ItemIndex := i;
end;
ItemCombo.Free;
end;
ShowModal;
end;
procedure TFrmCadJogador.AtualizaInterface;
var
NumJogadores: Integer;
SQL: String;
begin
SQL := 'Select Count(*) from JOGADOR where CODTEMPORADA=' + IntToStr
SQL := SQL + ' and CODEQUIPE=' + IntToStr
(TItemCombo(CmbBxEquipe.Items.Objects[CmbBxEquipe.ItemIndex]).GetOid);
ClntDtStDados.Open;
NumJogadores := ClntDtStDados.FieldByName('Count').AsInteger;
SQLDtStJogador.ParamByName('CodTemp').AsInteger := Temporada.GetCodTemporada;
SQLDtStJogador.ParamByName('CodEquipe').AsInteger :=
ClntDtStJogador.Close;
ClntDtStJogador.Open;
ClntDtStJogador.First;
BtnIncluirJogador.Enabled := True;
if NumJogadores > 0 then begin
BtnAlterarJogador.Enabled := True;
BtnExcluirJogador.Enabled := True;
end else begin
BtnAlterarJogador.Enabled := False;
BtnExcluirJogador.Enabled := False;
end;
end;
procedure TFrmCadJogador.FormDestroy(Sender: TObject);
var
i: Integer;
begin
for i:=1 to CmbBxEquipe.Items.Count-1 do begin
TItemCombo(CmbBxEquipe.Items.Objects[i]).Destroy;
end;
MeusUtils.Free;
Temporada.Destroy;
end;
procedure TFrmCadJogador.BloqueiaFormulario;
begin
EdtApelidoJogador.Text := '';
EdtNomeJogador.Text := '';
EdtNumCamisa.Text := '';
CmbBxPosicao.ItemIndex := 0;
EdtNacionalidade.Text := '';
EdtEmail.Text := '';
PnlIdade.Caption := '';
ImgJogador.Picture := ImgBranco.Picture;
EdtApelidoJogador.Enabled := False;
EdtNomeJogador.Enabled := False;
EdtNumCamisa.Enabled := False;
CmbBxPosicao.Enabled := False;
EdtNacionalidade.Enabled := False;
DtDataNascimento.Enabled := False;
EdtEmail.Enabled := False;
211
BtnCarregarImg.Enabled := False;
BtnIncluirJogador.SetFocus;
end;
procedure TFrmCadJogador.LiberaFormulario;
begin
ImgJogador.Picture := ImgJogador.Picture;
EdtApelidoJogador.Enabled := True;
EdtNomeJogador.Enabled := True;
EdtNumCamisa.Enabled := True;
CmbBxPosicao.Enabled := True;
EdtNacionalidade.Enabled := True;
DtDataNascimento.Enabled := True;
EdtEmail.Enabled := True;
BtnCarregarImg.Enabled := True;
PnlIdade.Caption := IntToStr(MeusUtils.CalcAnos (DtDataNascimento.DateTime)) + '
ANOS';
EdtApelidoJogador.SetFocus;
end;
procedure TFrmCadJogador.CmbBxEquipeChange(Sender: TObject);
begin
end;
procedure TFrmCadJogador.BtnCancelarClick(Sender: TObject);
begin
end;
procedure TFrmCadJogador.BtnCarregarImgClick(Sender: TObject);
var
FileName : String;
begin
FileName := OpenPictureDialog1.FileName;
ImgJogador.Picture.LoadFromFile(FileName);
end;
end;
procedure TFrmCadJogador.EdtNumCamisaKeyPress(Sender: TObject; var Key: Char);
begin
Key := #0;
Beep;
end;
end;
procedure TFrmCadJogador.BtnIncluirJogadorClick(Sender: TObject);
begin
Status := 'N';
Self.LiberaFormulario;
end;
procedure TFrmCadJogador.DtDataNascimentoChange(Sender: TObject);
begin
ANOS';
end;
procedure TFrmCadJogador.BtnAlterarJogadorClick(Sender: TObject);
begin
Status := 'A';
CodJogador := ClntDtStJogador.FieldByName('CodJogador').AsInteger;
Self.LiberaFormulario;
EdtApelidoJogador.Text := ClntDtStJogador.FieldByName('ApelidoJogador').AsString;
EdtNomeJogador.Text := ClntDtStJogador.FieldByName('NomeJogador').AsString;
EdtNumCamisa.Text := ClntDtStJogador.FieldByName('NumeroCamisa').AsString;
212
Case ClntDtStJogador.FieldByName('Posicao').AsInteger of
1: CmbBxPosicao.ItemIndex := 0;
end;
EdtNacionalidade.Text := ClntDtStJogador.FieldByName('Nacionalidade').AsString;
EdtEmail.Text := ClntDtStJogador.FieldByName('EMail').AsString;
DtDataNascimento.DateTime := ClntDtStJogador.FieldByName('DataNascimento').AsDateTime;
ANOS';
ImgJogador.Picture.Bitmap.LoadFromStream(ClntDtStJogador.CreateBlobStream(ClntDtStJogado
r.FieldByName('Foto'),bmRead));
end;
procedure TFrmCadJogador.BtnGravarClick(Sender: TObject);
var
Apelido, Nome, Nacionalidade, Email: String;
Camisa, Posicao: Integer;
DataNasc: TDateTime;
Foto: TMemoryStream;
Equipe: TEquipe;
begin
if Self.ValidaFormulario = True then begin
try
Apelido := EdtApelidoJogador.Text;
Nome := EdtNomeJogador.Text;
Nacionalidade := EdtNacionalidade.Text;
Email := EdtEmail.Text;
Camisa := StrToInt(EdtNumCamisa.Text);
Case CmbBxPosicao.ItemIndex of
0: Posicao := 1;
1: Posicao := 2;
2: Posicao := 3;
3: Posicao := 4;
4: Posicao := 5;
end;
DataNasc := DtDataNascimento.DateTime;
Foto := TMemoryStream.Create;
ImgJogador.Picture.Graphic.SaveToStream(Foto);
Equipe.IncluirJogador (Temporada.GetCodTemporada, Apelido, Nome, Camisa,
Posicao, Nacionalidade, DataNasc, Email, Foto);
end else begin
Equipe.AlterarJogador (CodJogador, Apelido, Nome, Camisa, Posicao,
Nacionalidade, DataNasc, Email, Foto);
end;
Foto.Free;
Equipe.Destroy;
Except
Suporte');
end;
end;
end;
end;
function TFrmCadJogador.ValidaFormulario : Boolean;
begin
if EdtApelidoJogador.Text = '' then begin
EdtApelidoJogador.SetFocus;
ShowMessage('Nome do Jogador Invlido');
ValidaFormulario := False;
end else begin
if EdtNomeJogador.Text = '' then begin
EdtNomeJogador.Text := EdtApelidoJogador.Text;
end;
if EdtNumCamisa.Text = '' then begin
EdtNumCamisa.Text := '0';
end;
213
ValidaFormulario := True;
end;
end;
procedure TFrmCadJogador.DBGrdJogadoresDblClick(Sender: TObject);
begin
if BtnAlterarJogador.Enabled = True then begin
Self.BtnAlterarJogadorClick(Sender);
end;
end;
procedure TFrmCadJogador.BtnExcluirJogadorClick(Sender: TObject);
var
Equipe: TEquipe;
Excluiu: Boolean;
begin
try
Equipe.Materializar(TItemCombo(CmbBxEquipe.Items.Objects[CmbBxEquipe.ItemIndex]).GetOid)
;
Excluiu :=
Equipe.ExcluirJogador(ClntDtStJogador.FieldByName('CodJogador').AsInteger);
If Excluiu = False then begin
ShowMessage('O Jogador no pode ser excluido. Ele j atuou nesta temporada');
end else begin
end;
Equipe.Destroy;
Except
Suporte');
end;
end;
end;
end.
========================================================================================
====
ARQUIVO: UICadEstruturaTemporada.pas
========================================================================================
====
unit UICadEstruturaTemporada;
interface
uses
Dialogs, Borland.Vcl.StdCtrls, Borland.Vcl.Buttons, Borland.Vcl.ExtCtrls,
Borland.Vcl.Grids, Borland.Vcl.DBGrids, System.ComponentModel, FMTBcd,
Borland.Vcl.Db, Borland.Vcl.DBClient, Borland.Vcl.Provider,
Borland.Vcl.SqlExpr, UDMDados, UTemporada;
type
TFrmCadEstruturaTemporada = class(TForm)
BtnIncluirFase: TButton;
BtnAlterarFase: TButton;
BtnExcluirFase: TButton;
BtnIncluirGrupo: TButton;
BtnAlterarGrupo: TButton;
BtnExcluirGrupo: TButton;
Panel3: TPanel;
Panel4: TPanel;
Panel5: TPanel;
PnlBtnsFases: TPanel;
BtnGravarFase: TBitBtn;
BtnCancelarFase: TBitBtn;
PnlDadosFases: TPanel;
Label1: TLabel;
EdtNomeFase: TEdit;
PnlDadosGrupos: TPanel;
Label2: TLabel;
EdtNomeGrupo: TEdit;
214
PnlBtnsGrupos: TPanel;
BtnGravarGrupo: TBitBtn;
BtnCancelarGrupo: TBitBtn;
BtnFechar: TBitBtn;
SQLDtStRodadas: TSQLDataSet;
DtStPrvdrRodadas: TDataSetProvider;
ClntDtStRodadas: TClientDataSet;
DtSrcRodadas: TDataSource;
BtnAdicionarRodadas: TButton;
BtnDiminuirRodadas: TButton;
procedure BtnCancelarFaseClick(Sender: TObject);
procedure BtnCancelarGrupoClick(Sender: TObject);
procedure BtnIncluirFaseClick(Sender: TObject);
procedure BtnIncluirGrupoClick(Sender: TObject);
procedure BtnAlterarFaseClick(Sender: TObject);
procedure BtnAlterarGrupoClick(Sender: TObject);
procedure DBGrdFasesDblClick(Sender: TObject);
procedure DBGrdGruposDblClick(Sender: TObject);
procedure BtnAdicionarRodadasClick(Sender: TObject);
procedure BtnDiminuirRodadasClick(Sender: TObject);
procedure BtnGravarGrupoClick(Sender: TObject);
procedure BtnExcluirGrupoClick(Sender: TObject);
procedure BtnGravarFaseClick(Sender: TObject);
procedure BtnExcluirFaseClick(Sender: TObject);
private
conBD: TDtMdlDados;
Status: String;
NumFases, NumGrupos, NumRodadas: Integer;
procedure AtualizarRodadas;
procedure BloqueiaFormularioFases;
procedure BloqueiaFormularioGrupos;
procedure AtivaFormularioFases;
procedure AtivaFormularioGrupos;
public
procedure Mostrar(umaTemp: TTemporada);
function GetCodEstruturaTemporada : Integer;
end;
var
FrmCadEstruturaTemporada: TFrmCadEstruturaTemporada;
implementation
{$R *.nfm}
procedure TFrmCadEstruturaTemporada.BtnFecharClick(Sender: TObject);
begin
Self.Close;
end;
procedure TFrmCadEstruturaTemporada.SetBD (var umaConBD: TDtMdlDados);
begin
conBD := umaConBD;
end;
215
procedure TFrmCadEstruturaTemporada.Mostrar (umaTemp: TTemporada);

begin
ShowModal;
end;
procedure TFrmCadEstruturaTemporada.AtualizarFases;
var
SQL: String;
begin
SQLDtStFases.ParamByName('CodTemp').AsInteger := Temporada.GetCodTemporada;
ClntDtStFases.Open;
SQL := 'Select COUNT(*) from ESTRUTURATEMPORADA where CODFASE is null and
CODTEMPORADA=' + IntToStr(Temporada.GetCodTemporada);
ClntDtStDados.Open;
NumFases := ClntDtStDados.FieldByName('Count').AsInteger;
if NumFases = 0 then begin
BtnAlterarFase.Enabled := False;
BtnExcluirFase.Enabled := False;
BtnIncluirGrupo.Enabled := False;
BtnAlterarGrupo.Enabled := False;
BtnExcluirGrupo.Enabled := False;
BtnAdicionarRodadas.Enabled := False;
BtnDiminuirRodadas.Enabled := False;
end else begin
BtnAlterarFase.Enabled := True;
BtnExcluirFase.Enabled := True;
BtnIncluirGrupo.Enabled := True;
end;
end;
procedure TFrmCadEstruturaTemporada.AtualizarGrupos;
var
SQL: String;
begin
SQL := 'Select COUNT(*) from ESTRUTURATEMPORADA where CODGRUPO is null and CODFASE=' +
ClntDtStFases.FieldByName('CodEstruturaTemporada').AsString;
ClntDtStDados.Open;
NumGrupos := ClntDtStDados.FieldByName('Count').AsInteger;
if NumGrupos = 0 then begin
BtnAlterarGrupo.Enabled := False;
BtnExcluirGrupo.Enabled := False;
BtnAdicionarRodadas.Enabled := False;
end else begin
BtnAlterarGrupo.Enabled := True;
BtnExcluirGrupo.Enabled := True;
end;
end;
procedure TFrmCadEstruturaTemporada.AtualizarRodadas;
var
SQL: String;
begin
SQLDtStRodadas.ParamByName('CodGrupo').AsInteger :=
ClntDtStRodadas.Close;
ClntDtStRodadas.Open;
ClntDtStRodadas.First;
216
SQL := 'Select COUNT(*) from ESTRUTURATEMPORADA where CODGRUPO=' +

ClntDtStGrupos.FieldByName('CodEstruturaTemporada').AsString;
ClntDtStDados.Open;
NumRodadas := ClntDtStDados.FieldByName('Count').AsInteger;
BtnAdicionarRodadas.Enabled := True;
if NumRodadas = 0 then begin
end else begin
BtnDiminuirRodadas.Enabled := True;
end;
end;
procedure TFrmCadEstruturaTemporada.AtivaFormularioFases;
var
SQL: String;
begin
EdtNomeFase.Text := '';
EdtNomeFase.Enabled := True;
BtnGravarFase.Enabled := True;
BtnCancelarFase.Enabled := True;
EdtNomeFase.SetFocus;
end;
procedure TFrmCadEstruturaTemporada.BloqueiaFormularioFases;
begin
EdtNomeFase.Text := '';
EdtNomeFase.Enabled := False;
BtnGravarFase.Enabled := False;
BtnCancelarFase.Enabled := False;
end;
procedure TFrmCadEstruturaTemporada.AtivaFormularioGrupos;
begin
EdtNomeGrupo.Text := '';
EdtNomeGrupo.Enabled := True;
BtnGravarGrupo.Enabled := True;
BtnCancelarGrupo.Enabled := True;
EdtNomeGrupo.SetFocus;
end;
procedure TFrmCadEstruturaTemporada.BloqueiaFormularioGrupos;
begin
EdtNomeGrupo.Text := '';
EdtNomeGrupo.Enabled := False;
BtnGravarGrupo.Enabled := False;
BtnCancelarGrupo.Enabled := False;
end;
procedure TFrmCadEstruturaTemporada.FormDestroy(Sender: TObject);
begin
Temporada.Destroy;
end;
procedure TFrmCadEstruturaTemporada.BtnCancelarFaseClick(Sender: TObject);
begin
Self.BloqueiaFormularioFases;
end;
procedure TFrmCadEstruturaTemporada.BtnCancelarGrupoClick(Sender: TObject);
begin
Self.BloqueiaFormularioGrupos;
end;
procedure TFrmCadEstruturaTemporada.BtnIncluirFaseClick(Sender: TObject);
begin
Status := 'N';
CodEstruturaTemporada := ClntDtStFases.FieldByName('CodEstruturaTemporada').AsInteger;
Self.AtivaFormularioFases;
end;
procedure TFrmCadEstruturaTemporada.BtnIncluirGrupoClick(Sender: TObject);
begin
217
Status := 'N';
CodEstruturaTemporada :=
Self.AtivaFormularioGrupos;
end;
procedure TFrmCadEstruturaTemporada.BtnAlterarFaseClick(Sender: TObject);
begin
Status := 'A';
CodEstruturaTemporada := ClntDtStFases.FieldByName('CodEstruturaTemporada').AsInteger;
Self.AtivaFormularioFases;
EdtNomeFase.Text := ClntDtStFases.FieldByName('NomeEstruturaTemporada').AsString;
end;
procedure TFrmCadEstruturaTemporada.BtnAlterarGrupoClick(Sender: TObject);
var
SQL: String;
begin
Status := 'A';
CodEstruturaTemporada :=
Self.AtivaFormularioGrupos;
EdtNomeGrupo.Text := ClntDtStGrupos.FieldByName('NomeEstruturaTemporada').AsString;
end;
procedure TFrmCadEstruturaTemporada.DBGrdFasesCellClick(Column: TColumn);
begin
if NumFases > 0 then Self.AtualizarGrupos;
end;
procedure TFrmCadEstruturaTemporada.DBGrdGruposCellClick(Column: TColumn);
begin
if NumGrupos > 0 then Self.AtualizarRodadas;
end;
procedure TFrmCadEstruturaTemporada.DBGrdFasesDblClick(Sender: TObject);
begin
if NumFases > 0 then Self.BtnAlterarFaseClick(Sender);
end;
procedure TFrmCadEstruturaTemporada.DBGrdGruposDblClick(Sender: TObject);
begin
if NumGrupos > 0 then Self.BtnAlterarGrupoClick(Sender);
end;
procedure TFrmCadEstruturaTemporada.BtnAdicionarRodadasClick(Sender: TObject);
begin
try
if NumRodadas < 9 then begin
Temporada.IncluirRodada('0'+IntToStr(NumRodadas+1),
end else begin
Temporada.IncluirRodada(IntToStr(NumRodadas+1),
end;
Except
Suporte');
end;
end;
end;
procedure TFrmCadEstruturaTemporada.BtnDiminuirRodadasClick(
Sender: TObject);
begin
while not ClntDtStRodadas.eof do begin
ClntDtStRodadas.Next;
218
end;
try
Temporada.ExcluirEstruturaTemporada(ClntDtStRodadas.FieldByName('CodEstruturaTemporada')
.AsInteger);
Except
Suporte');
end;
end;
end;
procedure TFrmCadEstruturaTemporada.BtnGravarGrupoClick(Sender: TObject);
begin
if EdtNomeGrupo.Text = '' then begin
ShowMessage ('Nome do Grupo Invlido');
end else begin
try
Temporada.IncluirGrupo(EdtNomeGrupo.Text,
ClntDtStFases.FieldByName('codEstruturaTemporada').AsInteger);
end else begin
Temporada.AlterarGrupo(codEstruturaTemporada, EdtNomeGrupo.Text);
end;
Except
Suporte');
end;
end;
end;
end;
procedure TFrmCadEstruturaTemporada.BtnExcluirGrupoClick(Sender: TObject);
var
Excluiu: Boolean;
begin
try
Excluiu :=
Temporada.ExcluirEstruturaTemporada(ClntDtStGrupos.FieldByName('codEstruturaTemporada').
AsInteger);
if Excluiu = False then begin
ShowMessage('ERRO: Existem Rodadas Cadastradas Neste Grupo');
end else begin
end;
Except
Suporte');
end;
end;
end;
procedure TFrmCadEstruturaTemporada.BtnGravarFaseClick(Sender: TObject);
begin
if EdtNomeFase.Text = '' then begin
ShowMessage ('Nome da Fase Invlido');
end else begin
try
Temporada.IncluirFase(EdtNomeFase.Text);
end else begin
Temporada.AlterarFase(CodEstruturaTemporada, EdtNomeFase.Text);
end;
Except
Suporte');
end;
219
end;
end;
end;
procedure TFrmCadEstruturaTemporada.BtnExcluirFaseClick(Sender: TObject);
var
Excluiu: Boolean;
begin
try
Excluiu :=
Temporada.ExcluirEstruturaTemporada(ClntDtStFases.FieldByName('codEstruturaTemporada').A
sInteger);
if Excluiu = False then begin
ShowMessage('ERRO: Existem Grupos Cadastrados nesta Fase');
end else begin
end;
Except
Suporte');
end;
end;
end;
function TFrmCadEstruturaTemporada.GetCodEstruturaTemporada : Integer;
begin
GetCodEstruturaTemporada := CodEstruturaTemporada;
end;
end.
========================================================================================
====
ARQUIVO: UICadEstadio.pas
========================================================================================
====
unit UICadEstadio;
interface
uses
Dialogs, FMTBcd, Borland.Vcl.Provider, Borland.Vcl.SqlExpr,
Borland.Vcl.Grids, Borland.Vcl.DBGrids, Borland.Vcl.Buttons,
Borland.Vcl.StdCtrls, Borland.Vcl.ExtCtrls, System.ComponentModel, UDMDados,
UEstadio;
type
TFrmCadEstadio = class(TForm)
ImgBranco: TImage;
Label1: TLabel;
Label2: TLabel;
Label3: TLabel;
Label4: TLabel;
EdtNomeEstadio: TEdit;
EdtCidadeEstadio: TEdit;
PnlBtns: TPanel;
BtnGravar: TBitBtn;
DBGrdEstadios: TDBGrid;
Panel3: TPanel;
ClntDtStEstadio: TClientDataSet;
DtSrcEstadio: TDataSource;
SQLDtStEstadio: TSQLDataSet;
DtStPrvdrEstadio: TDataSetProvider;
EdtNomeOficialEstadio: TEdit;
Label5: TLabel;
EdtPaisEstadio: TEdit;
Label6: TLabel;
EdtCapacidadeEstadio: TEdit;
Panel15: TPanel;
220
ImgEstadio: TImage;
ClntDtStEstadioCODESTADIO: TIntegerField;
ClntDtStEstadioNOMEESTADIO: TStringField;
ClntDtStEstadioNOMECOMPLETOESTADIO: TStringField;
ClntDtStEstadioCAPACIDADEESTADIO: TIntegerField;
ClntDtStEstadioCIDADEESTADIO: TStringField;
ClntDtStEstadioFOTO: TBlobField;
ClntDtStEstadioPAIS: TStringField;
BtnFechar: TBitBtn;
BtnIncluirEstadio: TBitBtn;
BtnAlterarEstadio: TBitBtn;
BtnExcluirEstadio: TBitBtn;
procedure EdtCapacidadeEstadioKeyPress(Sender: TObject; var Key: Char);
procedure BtnAlterarEstadioClick(Sender: TObject);
procedure DBGrdEstadiosDblClick(Sender: TObject);
procedure FormClose(Sender: TObject; var Action: TCloseAction);
private
conBD: TDtMdlDados;
Status: String;
public
procedure Mostrar;
end;
var
implementation
{$R *.nfm}
procedure TFrmCadEstadio.SetBD (var umaConBD: TDtMdlDados);
begin
conBD := umaConBD;
end;
procedure TFrmCadEstadio.Mostrar;
begin
ClntDtStEstadio.Close;
ClntDtStEstadio.Open;
Self.ShowModal;
end;
procedure TFrmCadEstadio.BtnCarregarImgClick(Sender: TObject);
var
FileName : String;
begin
ImgEstadio.Picture.LoadFromFile(FileName);
end;
end;
procedure TFrmCadEstadio.BtnFecharClick(Sender: TObject);
begin
Self.Close;
end;
procedure TFrmCadEstadio.EdtCapacidadeEstadioKeyPress(Sender: TObject; var Key: Char);
begin
Key := #0;
Beep;
end;
end;
procedure TFrmCadEstadio.BtnIncluirEstadioClick(Sender: TObject);
begin
Self.BtnCancelarClick(Sender);
Status := 'N';
221
EdtNomeEstadio.Enabled := True;
EdtNomeOficialEstadio.Enabled := True;
EdtCidadeEstadio.Enabled := True;
EdtPaisEstadio.Enabled := True;
EdtCapacidadeEstadio.Enabled := True;
EdtNomeEstadio.SetFocus;
end;
procedure TFrmCadEstadio.BtnAlterarEstadioClick(Sender: TObject);
begin
Status := 'A';
CodEstadio := ClntDtStEstadio.FieldByName('CodEstadio').AsInteger;
EdtNomeEstadio.Enabled := True;
EdtNomeOficialEstadio.Enabled := True;
EdtCidadeEstadio.Enabled := True;
EdtPaisEstadio.Enabled := True;
EdtCapacidadeEstadio.Enabled := True;
EdtNomeEstadio.Text := ClntDtStEstadio.FieldByName('NomeEstadio').AsString;
EdtNomeOficialEstadio.Text :=
ClntDtStEstadio.FieldByName('NomeCompletoEstadio').AsString;
EdtCidadeEstadio.Text := ClntDtStEstadio.FieldByName('CidadeEstadio').AsString;
EdtPaisEstadio.Text := ClntDtStEstadio.FieldByName('Pais').AsString;
EdtCapacidadeEstadio.Text :=
ClntDtStEstadio.FieldByName('CapacidadeEstadio').AsString;
ImgEstadio.Picture.Bitmap.LoadFromStream(ClntDtStEstadio.CreateBlobStream(ClntDtStEstadi
o.FieldByName('Foto'),bmRead));
EdtNomeEstadio.SetFocus;
end;
procedure TFrmCadEstadio.DBGrdEstadiosDblClick(Sender: TObject);
begin
Self.BtnAlterarEstadioClick(Sender);
end;
procedure TFrmCadEstadio.BtnCancelarClick(Sender: TObject);
begin
EdtNomeEstadio.Text := '';
EdtNomeOficialEstadio.Text := '';
EdtCidadeEstadio.Text := '';
EdtPaisEstadio.Text := '';
EdtCapacidadeEstadio.Text := '';
ImgEstadio.Picture := ImgBranco.Picture;
EdtNomeEstadio.Enabled := False;
EdtNomeOficialEstadio.Enabled := False;
EdtCidadeEstadio.Enabled := False;
EdtPaisEstadio.Enabled := False;
EdtCapacidadeEstadio.Enabled := False;
end;
procedure TFrmCadEstadio.BtnGravarClick(Sender: TObject);
var
Estadio: TEstadio;
NomeEstadio, NomeCompletoEstadio, CidadeEstadio, PaisEstadio: String;
CapacidadeEstadio: Integer;
Imagem : TMemoryStream;
begin
NomeEstadio := EdtNomeEstadio.Text;
NomeCompletoEstadio := EdtNomeOficialEstadio.Text;
if NomeCompletoEstadio = '' then begin
NomeCompletoEstadio := NomeEstadio;
end;
CidadeEstadio := EdtCidadeEstadio.Text;
PaisEstadio := EdtPaisEstadio.Text;
if EdtCapacidadeEstadio.Text = '' then begin
CapacidadeEstadio := 0;
end else begin
222
CapacidadeEstadio := StrToInt(EdtCapacidadeEstadio.Text);
end;
Imagem := TMemoryStream.Create;
ImgEstadio.Picture.Graphic.SaveToStream(Imagem);
if (NomeEstadio = '') then begin
ShowMessage ('ERRO: Nome do Estdio Invlido');
end else begin
try
Estadio.NovoEstadio(NomeEstadio, NomeCompletoEstadio, CidadeEstadio,
PaisEstadio, CapacidadeEstadio, Imagem);
end else begin
Estadio.AlterarEstadio(NomeEstadio, NomeCompletoEstadio, CidadeEstadio,
PaisEstadio, CapacidadeEstadio, Imagem);
end;
ClntDtStEstadio.Close;
ClntDtStEstadio.Open;
Estadio.Destroy;
Imagem.Free;
Except
Suporte');
end;
end;
end;
end;
procedure TFrmCadEstadio.FormClose(Sender: TObject; var Action: TCloseAction);
begin
ImgEstadio.Destroy;
end;
end.
========================================================================================
====
ARQUIVO: UICadEquipeCompeteTemporada.pas
========================================================================================
====
unit UICadEquipeCompeteTemporada;
interface
uses
Dialogs, FMTBcd, Borland.Vcl.StdCtrls, Borland.Vcl.Provider,
Borland.Vcl.SqlExpr, Borland.Vcl.Db, Borland.Vcl.DBClient,
Borland.Vcl.Buttons, Borland.Vcl.ExtCtrls, System.ComponentModel,
Borland.Vcl.Grids, Borland.Vcl.DBGrids, UDMDados, UTemporada, UEquipe,
UICadEquipe;
type
TFrmCadEquipeCompeteTemporada = class(TForm)
Panel3: TPanel;
DBGrid1: TDBGrid;
Panel1: TPanel;
BtnIncluirNaDisputa: TButton;
BtnExcluirDaDisputa: TButton;
PnlNomeTemporada: TPanel;
BtnFechar: TBitBtn;
ClntDtStEquipe: TClientDataSet;
ClntDtStEquipeCODEQUIPE: TIntegerField;
ClntDtStEquipeNOMEEQUIPE: TStringField;
ClntDtStEquipeNOMECOMPLETOEQUIPE: TStringField;
ClntDtStEquipeDATAFUNDACAO: TDateField;
ClntDtStEquipeCIDADE: TStringField;
ClntDtStEquipePAIS: TStringField;
ClntDtStEquipeTIPOEQUIPE: TIntegerField;
ClntDtStEquipeCODESTADIO: TIntegerField;
ClntDtStEquipeESCUDO: TBlobField;
DtSrcEquipe: TDataSource;
SQLDtStEquipe: TSQLDataSet;
DtStPrvdrEquipe: TDataSetProvider;
223
BtnCadEquipe: TButton;
Label5: TLabel;
PnlNumEquipes: TPanel;
BtnBuscar: TBitBtn;
EdtBusca: TEdit;
Label9: TLabel;
procedure BtnIncluirNaDisputaClick(Sender: TObject);
procedure BtnExcluirDaDisputaClick(Sender: TObject);
procedure DBGrid1DblClick(Sender: TObject);
procedure BtnCadEquipeClick(Sender: TObject);
procedure BtnBuscarClick(Sender: TObject);
procedure EdtBuscaKeyDown(Sender: TObject; var Key: Word;
private
conBD: TDtMdlDados;
public
end;
var
implementation
{$R *.nfm}
procedure TFrmCadEquipeCompeteTemporada.SetBD (var umaConBD: TDtMdlDados);
begin
conBD := umaConBD;
end;
procedure TFrmCadEquipeCompeteTemporada.Mostrar (umaTemp: TTemporada);
begin
PnlNomeTemporada.Caption := Temporada.GetNomeTemporada;
ShowModal;
end;
procedure TFrmCadEquipeCompeteTemporada.AtualizaInterface;
var
SQL: String;
begin
SQLDtStEquipe.ParamByName('CodTemp').asInteger := Temporada.GetCodTemporada;
ClntDtStEquipe.Close;
ClntDtStEquipe.Open;
SQLDtStEquipeDisputaTemp.ParamByName('CodTemp').asInteger :=
ClntDtStEquipeDisputaTemp.Close;
ClntDtStEquipeDisputaTemp.Open;
224
SQL := 'Select Count(*) FROM EQUIPECOMPETETEMPORADA ECT, EQUIPE E where ';

SQL := SQL + 'CODTEMPORADA=' + IntToStr(Temporada.GetCodTemporada);
SQL := SQL + ' and ECT.CODEQUIPE=E.CODEQUIPE';
ClntDtStDados.Open;
PnlNumEquipes.Text := ClntDtStDados.FieldByName('COUNT').AsString;
if ClntDtStDados.FieldByName('COUNT').AsInteger > 0 then begin
BtnExcluirDaDisputa.Enabled := True;
end else begin
BtnExcluirDaDisputa.Enabled := False;
end;
SQL := 'Select COUNT(*) From EQUIPE Where CodEquipe not in (Select Codequipe FROM ';
SQL := SQL + 'EQUIPECOMPETETEMPORADA where CODTEMPORADA=' +
IntToStr(Temporada.GetCodTemporada) + ') ';
ClntDtStDados.Open;
if ClntDtStDados.FieldByName('COUNT').AsInteger > 0 then begin
BtnIncluirNaDisputa.Enabled := True;
end else begin
BtnIncluirNaDisputa.Enabled := False;
end;
end;
procedure TFrmCadEquipeCompeteTemporada.FormDestroy(Sender: TObject);

begin
Temporada.Destroy;
end;
procedure TFrmCadEquipeCompeteTemporada.BtnFecharClick(Sender: TObject);
begin
Self.Close;
end;
procedure TFrmCadEquipeCompeteTemporada.BtnIncluirNaDisputaClick(
Sender: TObject);
var
Equipe: TEquipe;
begin
try
Equipe.Materializar(ClntDtStEquipe.FieldByName('CodEquipe').AsInteger);
Temporada.IncluirEquipeNaDisputa(Equipe);
Equipe.Destroy;
Except
Suporte');
end;
end;
end;
procedure TFrmCadEquipeCompeteTemporada.DBGrdEquipeDblClick(
Sender: TObject);
begin
if BtnIncluirNaDisputa.Enabled = True then begin
Self.BtnIncluirNaDisputaClick(Sender);
end;
end;
procedure TFrmCadEquipeCompeteTemporada.BtnExcluirDaDisputaClick(
Sender: TObject);
var
Equipe: TEquipe;
begin
try
Equipe.Materializar(ClntDtStEquipeDisputaTemp.FieldByName('CodEquipe').AsInteger);
if Temporada.ExcluirEquipeDaDisputa(Equipe) = False then begin;
ShowMessage('ERRO: Esta equipe j possui atuaes nesta temporada');
end else begin
Equipe.Destroy;
end;
225
Except
Suporte');
end;
end;
end;
procedure TFrmCadEquipeCompeteTemporada.DBGrid1DblClick(Sender: TObject);
begin
if BtnExcluirDaDisputa.Enabled = True then begin
Self.BtnExcluirDaDisputaClick(Sender);
end;
end;
procedure TFrmCadEquipeCompeteTemporada.BtnCadEquipeClick(Sender: TObject);
var
begin
FrmCadEquipe := TFrmCadEquipe.Create(nil); FrmCadEquipe.SetBD(ConBD);
FrmCadEquipe.Mostrar;
FrmCadEquipe.Destroy;
end;
procedure TFrmCadEquipeCompeteTemporada.BtnBuscarClick(Sender: TObject);
var
SQL: String;
begin
SQL := 'Select * from EQUIPE where CodEquipe not in (Select Codequipe FROM
EQUIPECOMPETETEMPORADA where CODTEMPORADA=:CodTemp) ';
if ((EdtBusca.Text = '') or (EdtBusca.Text = '*')) then begin
end else begin
SQL := SQL + 'and Upper(nomeEquipe) like ''%' + Uppercase(EdtBusca.Text) + '%'' ';
SQL := SQL + 'or Upper(Pais) like ''%' + Uppercase(EdtBusca.Text) + '%'' ';
end;
SQLDtStEquipe.CommandText := SQL;
SQLDtStEquipe.ParamByName('CodTemp').asInteger := Temporada.GetCodTemporada;
with ClntDtStEquipe do begin
Close;
Open;
First;
end;
end;
procedure TFrmCadEquipeCompeteTemporada.EdtBuscaKeyDown(Sender: TObject; var Key: Word;
begin
Self.BtnBuscarClick(Sender);
end;
end;
end.
========================================================================================
====
ARQUIVO: UICadEquipe.pas
========================================================================================
====
unit UICadEquipe;
interface
uses
Dialogs, System.ComponentModel, Borland.Vcl.Grids, Borland.Vcl.DBGrids,
FMTBcd, Borland.Vcl.ComCtrls, Borland.Vcl.Provider, Borland.Vcl.SqlExpr,
Borland.Vcl.Buttons, Borland.Vcl.StdCtrls, Borland.Vcl.ExtCtrls, UItemCombo,
UDMDados, UEquipe, UICadEstadio, UMeuUtils;
type
TFrmCadEquipe = class(TForm)
ImgBranco: TImage;
226
Label1: TLabel;
Label2: TLabel;
Label3: TLabel;
Label4: TLabel;
EdtNomeCompletoEquipe: TEdit;
EdtPaisEquipe: TEdit;
CmbBxTipoEquipe: TComboBox;
Panel7: TPanel;
ImgEquipe: TImage;
PnlBtns: TPanel;
BtnGravar: TBitBtn;
Panel3: TPanel;
ClntDtStEquipe: TClientDataSet;
DtSrcEquipe: TDataSource;
SQLDtStEquipe: TSQLDataSet;
DtStPrvdrEquipe: TDataSetProvider;
Label5: TLabel;
EdtNomeEquipe: TEdit;
DtDataFundacao: TDateTimePicker;
Label6: TLabel;
Label7: TLabel;
EdtCidadeEquipe: TEdit;
Label8: TLabel;
CmbBxEstadioEquipe: TComboBox;
BtnIncluirEstadio: TButton;
ClntDtStEstadio: TClientDataSet;
DtSrcEstadio: TDataSource;
SQLDtStEstadio: TSQLDataSet;
DtStPrvdrEstadio: TDataSetProvider;
ClntDtStEquipeCODEQUIPE: TIntegerField;
ClntDtStEquipeNOMEEQUIPE: TStringField;
ClntDtStEquipeNOMECOMPLETOEQUIPE: TStringField;
ClntDtStEquipeDATAFUNDACAO: TDateField;
ClntDtStEquipeCIDADE: TStringField;
ClntDtStEquipePAIS: TStringField;
ClntDtStEquipeTIPOEQUIPE: TIntegerField;
ClntDtStEquipeCODESTADIO: TIntegerField;
ClntDtStEquipeESCUDO: TBlobField;
ClntDtStEstadioCODESTADIO: TIntegerField;
ClntDtStEstadioNOMEESTADIO: TStringField;
ClntDtStEstadioNOMECOMPLETOESTADIO: TStringField;
ClntDtStEstadioCAPACIDADEESTADIO: TIntegerField;
ClntDtStEstadioCIDADEESTADIO: TStringField;
ClntDtStEstadioFOTO: TBlobField;
ClntDtStEstadioPAIS: TStringField;
PnlIdade: TPanel;
BtnFechar: TBitBtn;
EdtBusca: TEdit;
BtnBuscar: TBitBtn;
Label9: TLabel;
BtnIncluirEquipe: TBitBtn;
BtnAlterarEquipe: TBitBtn;
BtnExcluirEquipe: TBitBtn;
procedure BtnIncluirEquipeClick(Sender: TObject);
procedure BtnAlterarEquipeClick(Sender: TObject);
procedure DtDataFundacaoChange(Sender: TObject);
procedure BtnBuscarClick(Sender: TObject);
procedure EdtBuscaKeyDown(Sender: TObject; var Key: Word;
private
conBD: TDtMdlDados;
Status: String;
CodEquipe: Integer;
227
public
procedure Mostrar;
procedure CarregarCmbBxEstadioEquipe;
procedure LimparCmbBxEstadioEquipe;
end;
var
implementation
{$R *.nfm}
procedure TFrmCadEquipe.SetBD (var umaConBD: TDtMdlDados);
begin
conBD := umaConBD;
end;
procedure TFrmCadEquipe.BtnFecharClick(Sender: TObject);
begin
Self.Close;
end;
procedure TFrmCadEquipe.LimparCmbBxEstadioEquipe;
var
i: Integer;
begin
for i:=1 to CmbBxEstadioEquipe.Items.Count-1 do begin
TItemCombo(CmbBxEstadioEquipe.Items.Objects[i]).Destroy;
end;
CmbBxEstadioEquipe.Clear;
end;
procedure TFrmCadEquipe.CarregarCmbBxEstadioEquipe;
var
begin
CmbBxEstadioEquipe.Items.AddObject('', ItemCombo);
with ClntDtStEstadio do begin
Close;
Open;
First;
ItemCombo.SetOid(FieldByName('CodEstadio').AsInteger);
CmbBxEstadioEquipe.Items.AddObject(FieldByName('NomeEstadio').asString + ', ' +
FieldByName('CidadeEstadio').asString, ItemCombo);
Next;
end;
CmbBxEstadioEquipe.ItemIndex := 0;
end;
ItemCombo.Free;
end;
procedure TFrmCadEquipe.BtnIncluirEquipeClick(Sender: TObject);
var
begin
Status := 'N';
EdtNomeEquipe.Enabled := True;
EdtNomeCompletoEquipe.Enabled := True;
DtDataFundacao.Enabled := True;
Self.DtDataFundacaoChange(nil);
EdtCidadeEquipe.Enabled := True;
EdtPaisEquipe.Enabled := True;
CmbBxTipoEquipe.Enabled := True;
Self.CarregarCmbBxEstadioEquipe;
CmbBxEstadioEquipe.Enabled := True;
BtnIncluirEstadio.Enabled := True;
228
EdtNomeEquipe.SetFocus;
end;
procedure TFrmCadEquipe.Mostrar;
begin
ShowModal;
end;
procedure TFrmCadEquipe.FormDestroy(Sender: TObject);
begin
MeusUtils.Free;
ImgEquipe.Destroy;
end;
procedure TFrmCadEquipe.BtnIncluirEstadioClick(Sender: TObject);
var
i: Integer;
achou: boolean;
begin
achou := false;
while ((i < CmbBxEstadioEquipe.Items.Count) and (not achou)) do begin
if TItemCombo(CmbBxEstadioEquipe.Items.Objects[i]).GetOid =
ClntDtStEquipe.FieldByName('CodEstadio').AsInteger then begin
CmbBxEstadioEquipe.ItemIndex := i;
achou := true;
end;
i := i + 1;
end;
end;
procedure TFrmCadEquipe.BtnAlterarEquipeClick(Sender: TObject);
var
i: Integer;
achou: boolean;
begin
Status := 'A';
CodEquipe := ClntDtStEquipe.FieldByName('CodEquipe').AsInteger;
EdtNomeEquipe.Enabled := True;
EdtNomeCompletoEquipe.Enabled := True;
DtDataFundacao.Enabled := True;
EdtCidadeEquipe.Enabled := True;
EdtPaisEquipe.Enabled := True;
CmbBxTipoEquipe.Enabled := True;
CmbBxEstadioEquipe.Enabled := True;
BtnIncluirEstadio.Enabled := True;
ImgEquipe.Picture := ImgBranco.Picture;
EdtNomeEquipe.Text := ClntDtStEquipe.FieldByName('NomeEquipe').AsString;
EdtNomeCompletoEquipe.Text :=
ClntDtStEquipe.FieldByName('NomeCompletoEquipe').AsString;
DtDataFundacao.DateTime := ClntDtStEquipe.FieldByName('DataFundacao').AsDateTime;
Self.DtDataFundacaoChange(nil);
EdtCidadeEquipe.Text := ClntDtStEquipe.FieldByName('Cidade').AsString;
EdtPaisEquipe.Text := ClntDtStEquipe.FieldByName('Pais').AsString;
achou := false;
while ((i < CmbBxEstadioEquipe.Items.Count) and (not achou)) do begin
if TItemCombo(CmbBxEstadioEquipe.Items.Objects[i]).GetOid =
ClntDtStEquipe.FieldByName('CodEstadio').AsInteger then begin
CmbBxEstadioEquipe.ItemIndex := i;
achou := true;
229
end;
i := i + 1;
end;
case ClntDtStEquipe.FieldByName('TipoEquipe').AsInteger of
1: CmbBxTipoEquipe.ItemIndex := 0;
2: CmbBxTipoEquipe.ItemIndex := 1;
end;
ImgEquipe.Picture.Bitmap.LoadFromStream(ClntDtStEquipe.CreateBlobStream(ClntDtStEquipe.F
ieldByName('Escudo'),bmRead));
EdtNomeEquipe.SetFocus;
end;
procedure TFrmCadEquipe.BtnCancelarClick(Sender: TObject);
begin
EdtNomeEquipe.Text := '';
EdtNomeCompletoEquipe.Text := '';
EdtCidadeEquipe.Text := '';
EdtPaisEquipe.Text := '';
PnlIdade.Caption := '';
ImgEquipe.Picture := ImgBranco.Picture;
EdtNomeEquipe.Enabled := False;
EdtNomeCompletoEquipe.Enabled := False;
DtDataFundacao.Enabled := False;
EdtCidadeEquipe.Enabled := False;
EdtPaisEquipe.Enabled := False;
CmbBxTipoEquipe.Enabled := False;
CmbBxEstadioEquipe.Enabled := False;
BtnIncluirEstadio.Enabled := False;
end;
procedure TFrmCadEquipe.BtnCarregarImgClick(Sender: TObject);
var
FileName: String;
begin
ImgEquipe.Picture.LoadFromFile(FileName);
end;
end;
procedure TFrmCadEquipe.BtnGravarClick(Sender: TObject);
var
Equipe: TEquipe;
Nome, NomeCompleto, Cidade, Pais: String;
Tipo, CodEstadio: Integer;
DataFundacao: TDateTime;
Imagem : TMemoryStream;
begin
Nome := EdtNomeEquipe.Text;
NomeCompleto := EdtNomeCompletoEquipe.Text;
if NomeCompleto = '' then begin
NomeCompleto := Nome;
end;
Cidade := EdtCidadeEquipe.Text;
Pais := EdtPaisEquipe.Text;
Tipo := CmbBxTipoEquipe.ItemIndex + 1;
DataFundacao := DtDataFundacao.DateTime;
CodEstadio :=
TItemCombo(CmbBxEstadioEquipe.Items.Objects[CmbBxEstadioEquipe.ItemIndex]).GetOid;
Imagem := TMemoryStream.Create;
ImgEquipe.Picture.Graphic.SaveToStream(Imagem);
if ((Nome = '') or (Pais='')) then begin
ShowMessage ('ERRO: Nome da Equipe ou Pas Invlido');
end else begin
try
Equipe.NovaEquipe(Nome, NomeCompleto, Cidade,Pais, DataFundacao, Tipo,
CodEstadio, Imagem);
end else begin
Equipe.Materializar (CodEquipe);
230
Equipe.AlterarEquipe(Nome, NomeCompleto, Cidade,Pais, DataFundacao, Tipo,

CodEstadio, Imagem);
end;
Equipe.Destroy;
Imagem.Free;
Except
Suporte');
end;
end;
end;
end;
procedure TFrmCadEquipe.DBGrdEquipeDblClick(Sender: TObject);
begin
Self.BtnAlterarEquipeClick(Sender);
end;
procedure TFrmCadEquipe.DtDataFundacaoChange(Sender: TObject);
begin
PnlIdade.Caption := IntToStr(MeusUtils.CalcAnos (DtDataFundacao.DateTime)) + ' ANOS';
end;
procedure TFrmCadEquipe.BtnBuscarClick(Sender: TObject);
var
SQL: String;
begin
SQL := 'Select * from EQUIPE ';
if ((EdtBusca.Text = '') or (EdtBusca.Text = '*')) then begin
end else begin
SQL := SQL + 'where Upper(nomeEquipe) like ''%' + Uppercase(EdtBusca.Text) + '%'' ';
SQL := SQL + 'or Upper(Pais) like ''%' + Uppercase(EdtBusca.Text) + '%'' ';
end;
SQLDtStEquipe.CommandText := SQL;
with ClntDtStEquipe do begin
Close;
Open;
First;
end;
end;
procedure TFrmCadEquipe.EdtBuscaKeyDown(Sender: TObject; var Key: Word; Shift:
TShiftState);
begin
Self.BtnBuscarClick(Sender);
end;
end;
end.
========================================================================================
====
ARQUIVO: UClassificacao.pas
========================================================================================
====
unit UClassificacao;
interface
Uses
UDMDados, UEquipe, SysUtils, UMeuUtils, UDMClasses;
Type
TClassificacao = Class
protected
BD: TDtMdlClasses;
conBD: TDtMdlDados;
CodClassificacao: Integer;
231
DataJogo: TDateTime;
Equipe: TEquipe;
Pontos: Integer;
Jogos: Integer;
Vitoria: Integer;
Empate: Integer;
Derrota: Integer;
VitoriaProrrogacao: Integer;
VitoriaPenaltis: Integer;
DerrotaProrrogacao: Integer;
DerrotaPenaltis: Integer;
EmpateProrrogacao: Integer;
GolsPro: Integer;
GolsContra: Integer;
Publico: Integer;
Local: String; // C-Casa; F-Fora; T-Tribunal
Realizado: Integer; // 0-Falso; 1-Verdade
public
function GetCodClassificacao: Integer;
procedure NovaClassificacao (CodEstTemp: Integer; umaDataHoraJogo: TDateTime;
var umaEquipe : TEquipe; umRealizado, osGolsPro, osGolsContra,
umProrrogacao, osGolsProProrrog, osGolsContraProrrog, umPenaltis,
osGolsProPen, osGolsContraPen, umPublico: Integer; umLocal:
String;
procedure AlterarClassificacao (CodEstTemp: Integer; umaDataHoraJogo: TDateTime;
String;
procedure ExcluirClassificacao;
procedure CalcularClassificacao (CodEstTemp: Integer; umaDataHoraJogo: TDateTime;
String;
PtsVitPen,
PtsDerPen: Integer);
procedure NovaClassificacaoPunicao(CodEstTemp: Integer; umaData: TDateTime; var
umaEquipe : TEquipe; osPontos: Integer);
procedure AlterarClassificacaoPunicao(CodEstTemp: Integer; umaData: TDateTime; var
umaEquipe : TEquipe; osPontos: Integer);
end;
implementation
constructor TClassificacao.Create;
begin
inherited;
end;
procedure TClassificacao.SetBD (var umaConBD: TDtMdlDados);
begin
conBD := umaConBD;
end;
procedure TClassificacao.Materializar (Cod: Integer);
begin
BD.SQLDtStDados.CommandText := 'SELECT * FROM CLASSIFICACAO WHERE CODCLASSIFICACAO = '
+ IntToStr(Cod);
Close;
Open;
First;
CodClassificacao := FieldByname('CodClassificacao').asInteger;
232
CodEstruturaTemporada := FieldByname('CodEstruturaTemporada').asInteger;
DataJogo := FieldByname('DataJogo').asDateTime;
Equipe := TEquipe.Create; Equipe.SetBD(conBD);
Equipe.Materializar (FieldByname('CodEquipe').asInteger);
Pontos := FieldByname('Pontos').asInteger;
Jogos := FieldByname('Jogos').asInteger;
Vitoria := FieldByname('Vitoria').asInteger;
Empate := FieldByname('Empate').asInteger;
Derrota := FieldByname('Derrota').asInteger;
VitoriaProrrogacao := FieldByname('VitoriaProrrogacao').asInteger;
VitoriaPenaltis := FieldByname('VitoriaPenaltis').asInteger;
DerrotaProrrogacao := FieldByname('DerrotaProrrogacao').asInteger;
DerrotaPenaltis := FieldByname('DerrotaPenaltis').asInteger;
EmpateProrrogacao := FieldByname('EmpateProrrogacao').asInteger;
GolsPro := FieldByname('GolsPro').asInteger;
GolsContra := FieldByname('GolsContra').asInteger;
Publico := FieldByname('Publico').asInteger;
Local := FieldByname('Local').asString;
Realizado := FieldByname('Realizado').asInteger;
end;
end;
function TClassificacao.GetCodClassificacao: Integer;
begin
GetCodClassificacao := CodClassificacao;
end;
procedure TClassificacao.NovaClassificacao (CodEstTemp: Integer; umaDataHoraJogo:
TDateTime;
String;
PtsVitPen,
var
SQL: String;
begin
Close;
Open;
First;
CodClassificacao := FieldByName('OID').asInteger;
end;
Self.CalcularClassificacao (CodEstTemp, umaDataHoraJogo, umaEquipe, umRealizado,
osGolsPro, osGolsContra,
osGolsProPen,
osGolsContraPen, umPublico, umLocal, PtsVit, PtsEmp,
PtsVitProrrog, PtsEmpProrrog,
PtsDerProrrog, PtsVitPen, PtsDerPen);
SQL := 'INSERT INTO CLASSIFICACAO (CodClassificacao, CodEstruturaTemporada, DataJogo,
CodEquipe, ';
SQL := SQL + 'Pontos, Jogos, Vitoria, Empate, Derrota, VitoriaProrrogacao,
VitoriaPenaltis, DerrotaProrrogacao, ';
SQL := SQL + 'DerrotaPenaltis, EmpateProrrogacao, GolsPro, GolsContra, Publico, Local,
Realizado) VALUES (';
SQL := SQL + IntToStr(CodClassificacao) + ', ';
SQL := SQL + '''' + MeusUtils.DataParaBD (DataJogo) + ''', ';
SQL := SQL + IntToStr(Jogos) + ', ';
SQL := SQL + IntToStr(Vitoria) + ', ';
SQL := SQL + IntToStr(Empate) + ', ';
SQL := SQL + IntToStr(Derrota) + ', ';
SQL := SQL + IntToStr(VitoriaProrrogacao) + ', ';
SQL := SQL + IntToStr(VitoriaPenaltis) + ', ';
SQL := SQL + IntToStr(DerrotaProrrogacao) + ', ';
SQL := SQL + IntToStr(DerrotaPenaltis) + ', ';
SQL := SQL + IntToStr(EmpateProrrogacao) + ', ';
SQL := SQL + IntToStr(GolsPro) + ', ';
SQL := SQL + IntToStr(GolsContra) + ', ';
233

SQL := SQL + '''' + Local + ''', ';
SQL := SQL + IntToStr(Realizado) + ');';
end;
procedure TClassificacao.NovaClassificacaoPunicao(CodEstTemp: Integer; umaData:
TDateTime; var umaEquipe : TEquipe; osPontos: Integer);
var
SQL: String;
begin
CodEstruturaTemporada := CodEstTemp;
DataJogo := umaData;
GolsPro := 0;
GolsContra := 0;
Publico := 0;
Local := 'T';
Pontos := osPontos;
Jogos := 0;
Vitoria := 0;
Empate := 0;
Derrota := 0;
VitoriaProrrogacao := 0;
VitoriaPenaltis := 0;
DerrotaProrrogacao := 0;
DerrotaPenaltis := 0;
EmpateProrrogacao := 0;
Realizado := 1;
Close;
Open;
First;
CodClassificacao := FieldByName('OID').asInteger;
end;
SQL := 'INSERT INTO CLASSIFICACAO (CodClassificacao, CodEstruturaTemporada, DataJogo,
CodEquipe, ';
SQL := SQL + 'Pontos, Jogos, Vitoria, Empate, Derrota, VitoriaProrrogacao,
VitoriaPenaltis, DerrotaProrrogacao, ';
SQL := SQL + 'DerrotaPenaltis, EmpateProrrogacao, GolsPro, GolsContra, Publico, Local,
Realizado) VALUES (';
SQL := SQL + IntToStr(CodClassificacao) + ', ';
SQL := SQL + '''' + MeusUtils.DataParaBD (DataJogo) + ''', ';
SQL := SQL + IntToStr(Jogos) + ', ';
SQL := SQL + IntToStr(Vitoria) + ', ';
SQL := SQL + IntToStr(Empate) + ', ';
SQL := SQL + IntToStr(Derrota) + ', ';
SQL := SQL + IntToStr(VitoriaProrrogacao) + ', ';
SQL := SQL + IntToStr(VitoriaPenaltis) + ', ';
SQL := SQL + IntToStr(DerrotaProrrogacao) + ', ';
SQL := SQL + IntToStr(DerrotaPenaltis) + ', ';
SQL := SQL + IntToStr(EmpateProrrogacao) + ', ';
SQL := SQL + IntToStr(GolsPro) + ', ';
SQL := SQL + IntToStr(GolsContra) + ', ';
SQL := SQL + '''' + Local + ''', ';
SQL := SQL + IntToStr(Realizado) + ');';
end;
procedure TClassificacao.AlterarClassificacao (CodEstTemp: Integer; umaDataHoraJogo:
TDateTime;
String;
PtsVitPen,
234
var
SQL: String;
begin
Self.CalcularClassificacao (CodEstTemp, umaDataHoraJogo, umaEquipe, umRealizado,
osGolsPro, osGolsContra,
osGolsProPen,
osGolsContraPen, umPublico, umLocal, PtsVit, PtsEmp,
PtsVitProrrog, PtsEmpProrrog,
PtsDerProrrog, PtsVitPen, PtsDerPen);
SQL := 'UPDATE CLASSIFICACAO SET ';
SQL := SQL + 'DataJogo = ''' + MeusUtils.DataParaBD (DataJogo) + ''', ';
SQL := SQL + 'CodEquipe = ' + IntToStr(Equipe.GetCodEquipe) + ', ';
SQL := SQL + 'Pontos = ' + IntToStr(Pontos) + ', ';
SQL := SQL + 'Jogos = ' + IntToStr(Jogos) + ', ';
SQL := SQL + 'Vitoria = ' + IntToStr(Vitoria) + ', ';
SQL := SQL + 'Empate = ' + IntToStr(Empate) + ', ';
SQL := SQL + 'Derrota = ' + IntToStr(Derrota) + ', ';
SQL := SQL + 'VitoriaProrrogacao = ' + IntToStr(VitoriaProrrogacao) + ', ';
SQL := SQL + 'VitoriaPenaltis = ' + IntToStr(VitoriaPenaltis) + ', ';
SQL := SQL + 'DerrotaProrrogacao = ' + IntToStr(DerrotaProrrogacao) + ', ';
SQL := SQL + 'DerrotaPenaltis = ' + IntToStr(DerrotaPenaltis) + ', ';
SQL := SQL + 'EmpateProrrogacao = ' + IntToStr(EmpateProrrogacao) + ', ';
SQL := SQL + 'GolsPro = ' + IntToStr(GolsPro) + ', ';
SQL := SQL + 'GolsContra = ' + IntToStr(GolsContra) + ', ';
SQL := SQL + 'Publico = ' + IntToStr(Publico) + ', ';
SQL := SQL + 'Local = ''' + Local + ''', ';
SQL := SQL + 'Realizado = ' + IntToStr(Realizado) + ' ';
SQL := SQL + 'WHERE CODCLASSIFICACAO = ' + IntToStr(CodClassificacao);
end;
procedure TClassificacao.AlterarClassificacaoPunicao(CodEstTemp: Integer; umaData:
TDateTime; var umaEquipe : TEquipe; osPontos: Integer);
var
SQL: String;
begin
DataJogo := umaData;
Pontos := osPontos;
SQL := 'UPDATE CLASSIFICACAO SET ';
SQL := SQL + 'DataJogo = ''' + MeusUtils.DataParaBD (DataJogo) + ''', ';
SQL := SQL + 'CodEquipe = ' + IntToStr(Equipe.GetCodEquipe) + ', ';
SQL := SQL + 'Pontos = ' + IntToStr(Pontos) + ' ';
SQL := SQL + 'WHERE CODCLASSIFICACAO = ' + IntToStr(CodClassificacao);
end;
procedure TClassificacao.ExcluirClassificacao;
var
SQL: String;
begin
SQL := 'Delete from CLASSIFICACAO where CODCLASSIFICACAO=' +
IntToStr(CodClassificacao);
end;
procedure TClassificacao.CalcularClassificacao (CodEstTemp: Integer; umaDataHoraJogo:
TDateTime;
String;
PtsVitPen,
begin
DataJogo := umaDataHoraJogo;
GolsPro := osGolsPro;
235
GolsContra := osGolsContra;
Publico := umPublico;
Local := umLocal;
Realizado := umRealizado;
Pontos := 0;
Jogos := 0;
Vitoria := 0;
Empate := 0;
Derrota := 0;
if Realizado = 1 then begin // Se o jogo foi realizado
Jogos := 1;
if umProrrogacao = 1 then begin
if umPenaltis = 1 then begin
if osGolsProPen > osGolsContraPen then begin // Se ganhou nos penaltis
Pontos := PtsVitPen;
end else begin
// Se perdeu nos penaltis
Pontos := PtsDerPen;
end;
end else begin
// Se jogo foi pra prorrogacao e no
aos penaltis
if osGolsProProrrog > osGolsContraProrrog then begin // Se ganhou na prorrogacao
Pontos := PtsVitProrrog;
end else begin
if osGolsProProrrog = osGolsContraProrrog then begin // Se empatou na
prorrogacao
Pontos := PtsEmpProrrog;
end else begin
// Se perdeu na prorrogacao
Pontos := PtsDerProrrog;
end;
end;
end;
end else begin
if osGolsPro > osGolsContra then begin
Pontos := PtsVit;
Vitoria := 1;
end else begin
if osGolsPro = osGolsContra then begin
Pontos := PtsEmp;
Empate := 1;
end else begin
Pontos := 0;
Derrota := 1;
end;
end;
end;
end;
end;
destructor TClassificacao.Destroy;
begin
BD.Destroy;
MeusUtils.Free;
Equipe.Destroy;
end;
end.
========================================================================================
====
ARQUIVO: UCampeonato.pas
========================================================================================
====
unit UCampeonato;
interface
Uses
236

Borland.Vcl.Db, UDMClasses;
type
TCampeonato = class
protected
conBD: TDtMdlDados;
BD: TDtMdlClasses;
CodCampeonato: Integer;
Nome: String;
Tipo: Integer; //1:Nacional; 2:Intercontinental; 3:Selees; 4:Demais
Pais: String;
public
procedure AlterarCampeonato(umNome: &String; umTipo: Integer; umPais: String;
Escudo: TMemoryStream);
procedure Materializar(umCod: Integer);
procedure NovoCampeonato(umNome: &String; umTipo: Integer; umPais: String;
function GetCodCampeonato: Integer;
function GetNomeCampeonato: String;
end;
implementation
constructor TCampeonato.Create;
begin
inherited;
end;
procedure TCampeonato.SetBD (var umaConBD: TDtMdlDados);
begin
conBD := umaConBD;
BD.SetConexaoBD (conBD);
end;
procedure TCampeonato.Materializar(umCod: Integer);
begin
BD.SQLDtStDados.CommandText := 'SELECT * FROM CAMPEONATO WHERE CODCAMPEONATO = ' +
IntToStr(umCod);
Close;
Open;
First;
CodCampeonato := FieldByName('CodCampeonato').asInteger;
Nome := FieldByName('Nome').asString;
Tipo := FieldByName('Tipo').asInteger;
Pais := FieldByName('Pais').asString;
end;
end;
procedure TCampeonato.NovoCampeonato(umNome: String; umTipo: Integer; umPais: String;
var
SQL: String;
begin
Nome := umNome;
Tipo := umTipo;
Pais := umPais;
Close;
Open;
First;
CodCampeonato := FieldByName('OID').asInteger;
end;
SQL := 'Insert into CAMPEONATO (CODCAMPEONATO, NOME, TIPO, PAIS, ESCUDO) values (';
SQL := SQL + IntToStr(CodCampeonato) + ', ';
237
SQL := SQL + '''' + Nome + ''', ';

SQL := SQL + IntToStr(Tipo) + ', ';
SQL := SQL + '''' + Pais + ''', ';
SQL := SQL + ':Escudo)';
BD.SQLDtStDados.ParamByName('Escudo').LoadFromStream(Escudo,ftBlob);
end;
procedure TCampeonato.AlterarCampeonato(umNome: String; umTipo: Integer; umPais: String;
var
SQL: String;
begin
Nome := umNome;
Tipo := umTipo;
Pais := umPais;
SQL := 'Update CAMPEONATO set ';
SQL := SQL + 'NOME=''' + Nome + ''', ';
SQL := SQL + 'TIPO=' + IntToStr(Tipo) + ', ';
SQL := SQL + 'PAIS=''' + Pais + ''', ';
SQL := SQL + 'ESCUDO=:Escudo where CODCAMPEONATO=' + IntToStr(CodCampeonato);
BD.SQLDtStDados.ParamByName('Escudo').LoadFromStream(Escudo,ftBlob);
end;
function TCampeonato.GetCodCampeonato: Integer;
begin
GetCodCampeonato := CodCampeonato;
end;
function TCampeonato.GetNomeCampeonato: String;
begin
GetNomeCampeonato := Nome;
end;
destructor TCampeonato.Destroy;
begin
BD.Destroy;
MeusUtils.Free;
end;
end.
========================================================================================
====
ARQUIVO: UArbitro.pas
========================================================================================
====
unit UArbitro;
interface
Uses
UDMDados, SysUtils, UMeuUtils, UDMClasses,
Borland.Vcl.Classes, Borland.Vcl.DBXpress, Borland.Vcl.Db;
type
TArbitro = class
protected
conBD: TDtMdlDados;
BD: TDtMdlClasses;
CodArbitro: Integer;
NomeArbitro: String;
DataNascimento: TDateTime;
public
function GetCodArbitro : Integer;
Destructor Destroy; override;
procedure AlterarArbitro(umNome: String; umaData: TDateTime; Foto: TMemoryStream);
procedure NovoArbitro(umaTemp: Integer; umNome: String; umaData: TDateTime; Foto:
TMemoryStream);
238
end;
implementation
constructor TArbitro.Create;
begin
inherited;
end;
procedure TArbitro.SetBD (var umaConBD: TDtMdlDados);
begin
conBD := umaConBD;
end;
procedure TArbitro.Materializar (Cod: Integer);
begin
BD.SQLDtStDados.CommandText := 'SELECT * FROM ARBITRO WHERE CODARBITRO = ' +
IntToStr(Cod);
Close;
Open;
First;
CodArbitro := FieldByName('CodArbitro').asInteger;
CodTemporada := FieldByName('CodTemporada').asInteger;
NomeArbitro := FieldByName('NomeArbitro').asString;
DataNascimento := FieldByName('DataNascimento').asDateTime;
end;
end;
procedure TArbitro.NovoArbitro(umaTemp: Integer; umNome: String; umaData: TDateTime;
var
SQL: String;
begin
CodTemporada := umaTemp;
NomeArbitro := umNome;
Close;
Open;
First;
CodArbitro := FieldByName('OID').asInteger;
end;
SQL := 'Insert into ARBITRO (CODARBITRO, CODTEMPORADA, NOMEARBITRO, DATANASCIMENTO,
FOTO) values (';
SQL := SQL + IntToStr(CodArbitro) + ', ';
SQL := SQL + '''' + NomeArbitro + ''', ';
SQL := SQL + '''' + MeusUtils.DataParaBD (DataNascimento) + ''', ';
SQL := SQL + ':Foto)';
end;
procedure TArbitro.AlterarArbitro(umNome: String; umaData: TDateTime; Foto:
TMemoryStream);
var
SQL: String;
begin
NomeArbitro := umNome;
SQL := 'Update ARBITRO set ';
SQL := SQL + 'NOMEARBITRO=''' + NomeArbitro + ''', ';
SQL := SQL + 'DATANASCIMENTO=''' + MeusUtils.DataParaBD (DataNascimento) + ''', ';
SQL := SQL + 'FOTO=:Foto where CODARBITRO=' + IntToStr(CodArbitro);
end;
239
function TArbitro.GetCodArbitro : Integer;

begin
GetCodArbitro := CodArbitro;
end;
destructor TArbitro.Destroy;
begin
BD.Destroy;
MeusUtils.Free;
end;
end.
240
Anexo 4
Artigo
Fernando Peron
peron@inf.ufsc.br
Resumo
1.2 Objetivo Especfico
Este
artigo
apresenta
o
desenvolvimento de um sistema de
informao para campeonatos de
futebol.
O artigo faz uma breve
contextualizao ao leitor para o
entendimento do problema e apresenta,
uma
abordagem
para
o
desenvolvimento de software orientado
a objetos.
O artigo visa destacar a
aplicao prtica do curso de Sistemas
de Informao.
Fazer a anlise e projeto de um sistema,

utilizando uma metodologia que auxilie
a compreender o escopo do problema.
Fazer a anlise e projeto do sistema
utilizando UML e implementao
utilizando linguagem orientada a
objetos Delphi na verso 8 em conjunto
ao Banco de Dados Interbase verso
7.1.
1. Introduo
Antes deste artigo propriamente

entrar na parte de anlise e projeto do
software, feito neste tpico uma breve
contextualizao dos campeonatos de
futebol para se entender a ferramenta
que se deseja obter.
O futebol conhecido como um
esporte com regras conservadoras. Ao
mesmo tempo, para tornar o futebol
mais atraente para o pblico, as
frmulas de disputa dos campeonatos de
futebol so bastante diversificadas.
As frmulas de disputas,
tambm conhecidas como regulamento
da competio, o mecanismo que
organiza a maneira de como ser
disputada a competio. Na frmula de
disputa de uma competio definido
de que forma ser conhecido o campeo
da disputa, a ordem de classificao, os
times que sero rebaixados, etc.
1.1 Objetivo Geral

O desenvolvimento de um
programa de computadores, exercitando
na prtica os conhecimentos adquiridos
durante o curso de Sistema de
Informao. Para isso, o problema
selecionado como tema para o software
uma aplicao capaz de fazer o
gerenciamento completo de um
campeonato de futebol, desde controle
de tabela de jogos e resultados at a
gerao automtica de relatrios,
estatsticas e grficos que permitam ao
usurio entender melhor este tipo de
competio.
2. Organizao dos
Campeonatos e as Regras
241
O sistema deve ter grande

flexibilidade para aceitar que as
diferentes competies de futebol
possam ser controladas.
Para todo jogo de futebol
realizado existe um documento oficial
intitulado Smula que possui o
resumo dos acontecimentos do jogo. A
smula preenchida pelos rbitros da
partida.
O software tem o objetivo fazer
um resumo desta smula da partida,
podendo
at
mesmo,
incluir
informaes que no constam na
smula oficial, com a finalidade de
gerar uma variedade maior de
estatsticas do campeonato.
3. Estado da Arte
Trs ferramentas com objetivos
semelhantes aplicao objeto deste
trabalho foram pesquisadas. Foram
feitas observaes dos pontos positivos
e negativos de cada uma das
ferramentas. O aproveitamento das boas
solues e a precauo com as
franquezas das ferramentas existentes
colaboraram para o desenvolvimento de
um software completo e eficiente. Este
estudo tambm tem a finalidade de
estabelecer
um
parmetro
de
qualificao do resultado deste trabalho.
O software LeaguePad um
software
extremamente
flexvel.
Atravs dele possvel gerenciar
qualquer tipo de competio de futebol.
O software tambm se adapta as
necessidades do usurio. Para os
usurios que querem obter grandes
quantidades de informaes, o software
atende a quase tudo que se possa
imaginar. Por outro lado, caso o usurio
queira apenas ter a tabela de jogos, os
resultados e a classificao atualizada
automaticamente, este software se
adapta perfeitamente.
O ponto fraco deste software o
fato de ele tratar cada temporada de um
campeonato de forma independente.
Isso quer dizer que no possvel fazer

uma anlise entre duas temporadas de
um campeonato de um determinado
pas. O mesmo problema ocorre com as
equipes. Elas so tratadas de forma
independente
dentro
de
cada
campeonato. Assim, se uma equipe A
disputa dois campeonatos cadastrados
no sistema. O sistema interpreta com
duas equipes distintas, no sendo
possvel gerar estatsticas da equipe A
nestes dois campeonatos que disputou.
O Football League Tracker
outro bom software que se prope a
fazer o controle de campeonatos de
futebol. Este programa tambm
bastante completo. Abrange quase todas
as estatsticas que o jogo de futebol
pode gerar. possvel controlar alm da
tabela de classificao, dados a respeito
dos jogadores, como, por exemplo, lista
de artilheiros e jogadores que marcaram
gols contra. Tambm possvel acessar
uma tabela de informaes sobre as
arbitragens do campeonato.
O programa deixa a desejar em
sua interface de difcil compreenso.
Algumas
tabelas
possuem
seus
cabealhos com as palavras pela
metade, no sendo possvel saber que
dado est inserido na coluna da tabela.
O procedimento para inserir os jogos e
placares, alm das estatsticas tambm
no simples. Requer bastante trabalho
do
usurio
para
aprender
e
posteriormente usar. Existe tambm
uma grande quantidade de menus em
algumas interfaces.
O Gerenciador de Campeonato
Verso 1.0 um software mais simples
que o LeaguePad e o LTracker. Suas
funcionalidades basicamente servem
para o acompanhamento da tabela de
jogos e seus respectivos resultados e a
gerao automtica da tabela de
classificao a partir dos placares
inseridos nos jogos.
4. Fundamentos Tericos
242
A Programao Orientada a
Objetos uma extenso natural da
programao estruturada. Sua essncia
a reutilizao de cdigo. Uma vez que
voc cria um objeto para uma aplicao,
este objeto poder (e dever) ser
utilizado em novas aplicaes [SIL 00].
O objetivo especfico de
construir
um
programa
para
computadores utilizando os conceitos
de programao orientada a objetos.
Porm, a construo de um bom
programa orientado a objetos vai alm
de saber o dominar uma linguagem
orientada a objetos, como por exemplo,
Java ou Delphi. Este apenas o
primeiro passo para construo.
fundamental para obteno do sucesso
do trabalho uma boa anlise e um bom
projeto.
A metodologia de anlise e
projeto utilizada neste trabalho
proposta pelo livro de Craig Larman:
Utilizando UML e Padres. Este livro
apresenta um exemplo de processo de
desenvolvimento, o qual descreve uma
possvel ordem de atividades e um ciclo
de vida de desenvolvimento. Contudo,
ele no prescreve um processo ou
metodologia definitiva; ele fornece um
exemplo de passos comuns.
UML tem o poder de
transformar idias em modelos reais.
uma linguagem destina estruturao de
projetos. Um dos principais objetivos da
UML tornar todo o processo de
desenvolvimento
totalmente
transparente e organizado [SOA 01].
Em um nvel alto, os principais
passos at a entregar uma aplicao
incluem os seguintes:
1. Planejar e Elaborar Planejamento,
definio de requisitos, construo de
prottipos e assim por diante.
2. Construir A construo do sistema.
3. Instalar A implantao do sistema
para uso.
Um
processo
de
desenvolvimento de software um
mtodo para organizar as atividades
relacionadas com a criao, entrega e

manuteno de sistemas de software
[LAR 00].
5. O Sistema de
Gerenciamento de
Campeonatos de Futebol
A proposta deste trabalho a
criao de um programa de computador
para fazer o controle de campeonatos de
futebol.
Um bom sistema de controle de
campeonatos deve ser capaz de
gerenciar vrios campeonatos de
futebol. Dentro de cada campeonato,
deve ser possvel incluir as equipes que
disputam a competio e os jogadores
inscritos por estas equipes. Tambm
fazem parte de um campeonato, os
rbitros que apitam um jogo e o sistema
tambm deve abranger este fato.
Um sistema robusto para
controle
de
campeonatos,
deve
principalmente ser capaz de aceitar o
gerenciamento dos mais diferentes tipos
de competies de futebol. Cada tipo de
competio tem suas frmulas de
disputa. Uma Copa do Mundo,
exemplo, numa primeira fase as equipes
so divididas em grupos. As equipes
melhores colocadas avanam para fase
seguinte, onde novamente se organizam
em grupos e assim sucessivamente at
chegar a grande final. J num
campeonato nacional disputado em um
pas da Europa, como por exemplo, o
Campeonato Ingls de Futebol, possui
uma frmula de disputa diferente da
frmula de disputa da Copa do Mundo.
No Campeonato Ingls, as equipes
jogam todas entre si em uma nica fase
em um nico grupo. A que somar mais
pontos a grande campe.
Tambm a de se esperar de um
bom software de Controle de
Campeonatos a possibilidade de
gerenciar os jogos dentro
da
competio, incluindo a escalao das
243
equipes e juizes. Alm do simples

placar do jogo, deve ser possvel inserir
no sistema as diversas estatsticas
inerentes a uma partida de futebol. Em
contrapartida, desejvel que este
sistema nos mostre de forma
automtica, uma porca de relatrios
estatsticos que nos ajudem a
compreender a competio.
O sistema deve ser capaz de
suportar o controle de diversos
campeonatos. Os campeonatos so
disputados em sua grande maioria
anualmente. Cada edio de um
campeonato recebe o nome de
Temporada. Assim, um campeonato
deve ser cadastrado uma nica vez. Esta
distino
entre
Campeonato
e
Temporada permitir ao sistema gerar
informaes de um Campeonato ao
longo das suas edies. Com isso, o
conceito de campeonato no sistema
bastante simples, entretanto o conceito
de Temporada muito mais complexo,
pois na temporada que efetivamente
registradas as tabelas de jogos e
implicaes.
Outros
dois
importantes
conceitos que o sistema administrar de
forma nica so as Equipes e os
Estdios. Assim como os campeonatos,
uma Equipe e um Estdio sero
cadastrados uma nica vez. Desta forma
ser possvel gerar todas as informaes
referentes a uma Equipe ao longo das
diferentes competies que disputou.
diminui a complexidade do problema. O

desenvolvimento foi feito em partes. Os
casos de uso so classificados de acordo
com a relevncia para o sistema. Isso
deu segurana ao desenvolvimento, pois
os resultados vo aparecendo j nos
primeiros ciclos de desenvolvimento e,
em momento algum, se cria dvidas
quanto ao andamento do projeto.
7. Referncias
Bibliogrficas
[LAR 00] Larman, Craig. Utilizando
UML e Padres Uma Introduo
Anlise e ao Projeto Orientado a
Objetos. Editora Bookman. 2000.
[SOA 01] Soares, Walace. Crie um
Site B2C com PHP 4 e MySQL.
Editora rica. 2001.
[SIL 00] Silva, Ivan Jos de Mecenas
Silva. Delphi 5 Objetos e Herana.
Book Express. 2000.
6. Concluses
O presente trabalho apresentou
os detalhes que envolvem a disputa de
um campeonato de futebol para servir
de base para o desenvolvimento do
software.
A metodologia auxilia o
desenvolvedor na transio das etapas
do desenvolvimento e os resultados a
serem obtidos em cada etapa. Foi til
para delimitar com exatido o problema
a ser resolvido. A fase de anlise
244

Relatorio Final Completo

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Relatorio Final Completo

Enviado por

Direitos autorais:

Formatos disponíveis

UFSC - UNIVERSIDADE FEDERAL DE SANTA CATARINA

Trabalho de concluso de curso apresentado como parte dos requisitos para

Contextualizao do Problema ............................................................................................. 10

2 ORGANIZAO DOS CAMPEONATOS DE FUTEBOL E REGRAS......... 12

Campeonatos e Frmulas de Disputa ................................................................................... 12

Tabela de Classificao e Critrios de Desempate ............................................................... 13

Smula da partida de futebol ............................................................................................... 14

Tribunal Desportivo ............................................................................................................. 14

3 ESTADO DA ARTE ..................................................................................... 16

Software LeaguePad ............................................................................................................. 16

Football League Tracker (LTracker) - Verso 5.6............................................................... 20

Gerenciador de Campeonato V1.0 - Trilikix........................................................................ 23

Passos para o Desenvolvimento do Programa ...................................................................... 27

A Fase Planejar e Elaborar .................................................................................................. 28

Fase Analisar ........................................................................................................................ 30

Fase Instalar ......................................................................................................................... 31

Programa de Controle de Campeonatos de Futebol ............................................................ 33

Definio dos usurios do Sistema........................................................................................ 34

Definindo as reas do Sistema e os Casos de Uso ................................................................ 35

Manuteno de Estdios ....................................................................................................... 39

Manuteno de rbitros .................................................................................................. 50

Manuteno da Estrutura do Campeonato ..................................................................... 51

Administrao de Jogos ................................................................................................... 58

Manuteno da Tabela de Jogos ...................................................................................... 60

Manuteno da Escalao do Jogo................................................................................... 62

Manuteno de Eventos do Jogo...................................................................................... 65

O Modelo Conceitual ............................................................................................................ 68

Diagramas de Classes de Projeto.......................................................................................... 70

6 CONSIDERAES DO PROJETO E IMPLEMENTAO DO PROG ....... 75

A Abertura do Sistema ......................................................................................................... 75

Cadastro de Campeonato ..................................................................................................... 76

Cadastro de Temporada ....................................................................................................... 77

Cadastro de Equipe .............................................................................................................. 78

Cadastro de Estdios ............................................................................................................ 79

A Administrao de Temporada .......................................................................................... 80

Cadastro da Estrutura da Temporada ................................................................................. 81

Incluir Equipe na Disputa da Temporada............................................................................ 82

Punies do Tribunal ............................................................................................................ 84

Administrao da Tabela de Jogos....................................................................................... 85

Definir Escalao de um Jogo............................................................................................... 89

Definir Lances da Partida..................................................................................................... 91

Campanha por Equipe.......................................................................................................... 93

7 CONCLUSES E TRABALHOS FUTUROS ............................................... 95

Figura 3.2. LeguePad: Tabela de Jogos.....................................................................

Figura 3.3. LeguePad: Tabela de Classificao.........................................................

Figura 3.4. LeguePad: Baixar base de dados de um campeonato..............................

Figura 3.5. LTracker: Interface inicial do sistema.....................................................

Figura 3.6. LTracker: Tabela de classificao...........................................................

Figura 3.7. LTracker: Grfico de desempenho da equipe no campeonato................

Figura 3.8. LTracker: Tabela de jogos.......................................................................

Figura 3.9. Trilikix: Tabela de jogos..........................................................................

Figura 3.10. Trilikix: Tabela de classificao............................................................

Figura 5.1. Usurios do Sistema................................................................................

Figura 5.2. Pacote da rea do usurio........................................................................

Figura 5.3. Diagrama de caso de uso para Manuteno de Campeonatos.................

Figura 5.4. Diagrama de caso de uso para Manuteno de Equipes..........................

Figura 5.5. Diagrama de caso de uso para Manuteno de Estdios.........................

Figura 5.6. Pacote da rea do usurio com casos de usos definidos..........................

Figura 5.7. Diagrama de caso de uso para Manuteno de Temporadas...................

Figura 5.8. Diagrama de caso de uso para Equipes Participantes..............................

Figura 5.9. Diagrama de caso de uso para Manuteno de Jogadores.......................

Figura 5.10. Diagrama de caso de uso para Manuteno de rbitros.......................

Figura 5.11. Diagrama de caso de uso para Manuteno da Est. Temporada...........

Figura 5.12. Diagrama de caso de uso para Punies................................................