Transcrições
1. Visão geral: Olá, pessoal,
bem-vindos ao meu curso, onde criaremos do zero um
convidado completo do mundo, também conhecido como jogo
e em Java, usando as tecnologias Springbood, MySQL e Java Swing onde criaremos do
zero um
convidado completo do mundo,
também conhecido como jogo
e em Java,
usando as tecnologias Springbood, MySQL e Java Swing. Nas seções a seguir, você poderá interagir com vários aspectos da
construção do jogo, como definir o ecossistema, trabalhar com a estrutura
Springboard, uma das estruturas mais
populares do
mercado, e também conseguirá criar
o aplicativo de forma modular,
de forma cada recurso seja separado em um Definiremos vários
componentes como parte deste jogo, mas não se preocupe,
pois mostrarei exatamente como fazer com que eles
interajam entre si. Por último, mas não menos importante, como é um simulador de carrasco, precisaremos armazenar
em algum lugar as palavras Para isso, adicionaremos os dados no banco de dados elecional
Moser Então, vamos começar.
2. Primeiros passos: A primeira etapa do nosso processo de
desenvolvimento é criar um aplicativo Spring
Boot. Então eu comecei
aquele Spring Dot IO, e aqui, você vê que tem várias opções
que você pode escolher. O tipo do projeto, a versão do
spring boot, a linguagem Java e agora
os metadados do projeto Podemos criar um grupo específico, e vamos
chamá-lo de Hangman Para o artefato,
vamos chamá-lo de jogo. O mesmo vale para o nome
na descrição. Podemos chamá-lo de simulador de
jogo Hangman. Para o nome do pacote, podemos usar o jogo C and Man, o frasco de embalagem e,
para a versão Ja, escolhemos a versão 11. Também temos a capacidade de
adicionar dependências específicas. Mas, por enquanto, não devemos
seguir nessa direção, pois essas dependências
serão adicionadas manualmente em um
momento posterior do curso Podemos ir gerar
o projeto. Vamos abrir essa pasta. Na verdade, vamos extrair o
zip em uma pasta específica. E vamos cortar essa pasta
abaixo dos projetos aqui. Obviamente, você pode escolher o local de sua preferência. Agora, temos a
opção de importar esse projeto Maven para o nosso ID E a próxima etapa
será criar os pacotes correspondentes que usaremos como parte
deste curso. Então essa é a
estrutura básica dos pacotes. Então, vamos chamar esse pacote de guy and frame a partir da interface
gráfica do usuário. Um novo pacote chamado Coman Game Guy and Listeners onde armazenaremos nossos ouvintes
correspondentes Outro pacote para menu. Estou configurando um novo pacote
agora para os painéis que serão adicionados ao
quadro principal do aplicativo. Estou tentando aqui estruturar
o máximo possível esse projeto em seções
diferentes. Vamos criar um
pacote chamado model. Um repositório número 14
onde armazenaremos nosso repositório
correspondente do Spring Data GPA Um para serviço,
onde manteremos nosso principal
serviço de lógica de negócios para o serviço IMPL. Sob o serviço, teremos uma interface sob o IMPL. Teremos a implementação
correspondente. E um último pacote para t. Aqui ao lado da dependência inicial do
Springboard Temos a opção de adicionar
uma nova dependência aqui. Vamos configurar o ID do grupo para a inicialização do O spring framework. O ID do artefato
será boot starter web. Desde então, eu realmente quero que a instância don't get seja
executada nos bastidores. O aplicativo estará
instalado e funcionando sem nenhuma interação
do usuário. Vamos começar o aplicativo agora. Escolheremos o aplicativo Spring Boot, e o
aplicativo spring boot
começará a usar uma instância
tomcat incorporada, e temos a
opção de verificar isso Vamos ao nosso navegador e
digitar o host local A oito, e veremos uma página de erro
padrão.
3. Vamos começar de forma simples: Agora, como temos
a estrutura principal do aplicativo definida em
termos de pacotes, devemos começar a criar
nossos componentes reais. O primeiro passo é navegar pelos painéis
ocultos do Man Game Guy
e criar uma classe simples Vamos chamá-lo de painel vazio. A primeira coisa é
anotar essa classe com o estereótipo do componente
para que ela seja registrada na mola como um componente simples e possa ser injetada Essa classe, na verdade,
estenderá o painel. Isso é útil para
criarmos o painel real como um componente
separado. O. Agora, vamos adicionar um construtor
simples E temos a referência
ao painel J usando a palavra-chave di e queremos definir o tamanho preferido para uma dimensão específica,
500 por 100. Vamos também definir a cor
de
fundo do painel para preto. E podemos configurar um
layout simples para nosso painel. E vamos usar
um layout de ganância. Dois e um. Vou interromper a
execução inicial do aplicativo. Agora, como temos esse painel
simples instalado, podemos acessar o quadro do cara do
jogo Changan e criar o quadro real do nosso aplicativo que
manterá todos os painéis Podemos clicar no padrão
finalizado. Também para nossa moldura de carrasco, devemos
anotá-la com um componente para que ela seja
coletada até Essa classe
estenderá o quadro J. J frame é uma classe
do pacote Java swing. E temos a opção de conectar
automaticamente o painel vazio. Mais uma vez, como o
painel vazio é um componente, podemos injetá-lo diretamente aqui E também criaremos um
painel chamado painel principal. Vamos também adicionar um comentário. Uma vez que esse painel principal manterá todos os nossos painéis importados que serão adicionados
ao quadro principal. Imagine que importaremos
todos os nossos painéis criados, adicionaremos, adicionaremos ao painel principal, e esse painel principal será adicionado diretamente ao quadro J. Também configuramos um construtor
simples. E vamos criar um método
chamado create Min guy, e precisaremos
anotá-lo com
post build para que esse método seja invocado
automaticamente Importamos o pacote
de
notação Java para usar corretamente a notação
pós-construção Agora vamos definir algumas propriedades
específicas para nosso quadro J principal. Precisamos definir os
limites para 170100500. Não permitiremos que o usuário redimensione esse quadro j
como opção A próxima etapa será adicionar um
ouvinte de janela específico a esse quadro J. Precisaremos instanciar
o adaptador do Windows. Remova esses comentários. E precisaremos implementar o método correspondente
chamado fechamento da janela. Como parâmetro, isso
receberá o evento da janela. Quando o usuário clica
no botão x
para fechar essa janela, na verdade
nos livramos
do aplicativo,
saímos do aplicativo e
liberamos todos os recursos. Agora, precisamos instanciar
o painel principal. E sob o painel principal, precisamos definir o layout. E para esse caso, usaremos o layout da borda. Agora podemos adicionar
o painel vazio sob o painel principal usando
a opção de layout de
borda so. Portanto, esse painel vazio
será adicionado na parte inferior. E também adicionaremos o painel
principal ao quadro J,
o quadro J principal e definiremos o quadro J como visível para
o usuário correspondente. Agora, vamos iniciar
o aplicativo. Vamos salvar o painel vazio e você verá que recebemos um erro. O Spring não funciona bem com os componentes
correspondentes do swing, e você vê o erro aqui
relacionado ao headless Para corrigir isso, precisamos navegar até o principal método
correspondente do nosso aplicativo
de jogo, e eu removi a declaração
inicial, e precisaremos usar o construtor de aplicativos
spring. Vou criar um novo objeto para o construtor de
aplicativos spring. Como exemplo,
receberemos a classe dot do
aplicativo de jogo. Precisamos definir o headless
do construtor como falso e executar esse construtor E agora estamos prontos para iniciar o aplicativo, pois a opção sem cabeça
foi configurada para cair E você vê aqui neles, configuramos o painel vazio e também temos
a opção de fechar o quadro J.
4. Como se divertir com imagens: Agora, antes de começar a construir o próximo painel sem lista,
o painel de imagens. Precisamos de algumas imagens
para brincar. Eu configurei para você duas imagens, 14 smile e 14 set. A primeira coisa a observar
é que precisamos
criar uma pasta sob os recursos principais de
origem, e vamos chamá-la de imagens. Não se preocupe Fornecerei a você
as imagens do set e do Smile para trabalhar
neste projeto com elas. Dito isso. Vamos criar
o próximo painel em nossa lista. Eu configurei uma classe
chamada painel de imagens. Essa classe também precisará ser
anotada com o
componente para que
seja captada pelo contêiner de
mola
e, da mesma forma que no painel, precisamos estender o painel G. Como remover esses comentários. Precisamos configurar uma
lista de rótulos G. Vamos chamá-la de lista de imagens. Isso será usado
para armazenar nossas imagens. Agora, criaremos um construtor
simples chamado painel de imagem, é claro, e o método que
será anotado com uma construção de postagem
para que seja invocado automaticamente até o spring
para configurar todas as propriedades
do A primeira coisa
será instanciar a lista de imagens como uma lista E também defina o tamanho
referido como 100100 como um
objeto de dimensão para nosso painel G. Vamos corrigir isso,
pois não se chama imagens, na verdade
é a lista de imagens. Ok. Vamos definir uma
cor de fundo específica para o painel como branco. E também definiremos um layout
específico como layout grade com cinco
linhas e uma coluna. Vamos montar um espaço aqui. Agora, eu gostaria de fazer quatro voltas começando
de
0 a 4, inclusive Então, menos de cinco e
criaremos uma etiqueta. Imagine que precisamos
armazenar cinco imagens. Criamos alguns
objetos simples para nosso rótulo J. Vamos também acessar o jogo
C hangman teal e criar um ajudante simples Já que eu gostaria de
armazenar algumas referências a imagens sorridentes e
tristes nesta classe auxiliar Então eu anotei essa
classe com o componente. Vamos configurar alguns ícones de imagem
simples. Este será um
ícone de imagem que terá uma referência à imagem do sorriso. Precisamos criar um ícone de imagem. E usaremos a ajuda para
obter o carregador de classes. Obtenha recursos. E se você se lembra, configuramos a imagem abaixo
das imagens, Smile JPG. Também vamos fazer algo
semelhante com a imagem de satélite. novo ícone de imagem,
o mesmo processo, ajuda a obter o carregador de classes e
obter imagens de recursos Agora defina esse PNG. Portanto, temos acesso a essas
duas imagens. Agora vamos para
o painel de imagens, e aqui, como um parâmetro
para o construtor do rótulo J. Na verdade, podemos usar
a referência à imagem
do sorriso auxiliar,
pois, por padrão, nossas
imagens terão o tipo correspondente definido
para elas e obterão a imagem Mas você vê que
recebemos um erro, então precisamos, de alguma forma,
transformar essa referência um formato específico
que o nível
G possa realmente
usar corretamente. Para fazer isso, vamos
criar um método simples. Então dois. Que retornaremos
no ícone da imagem. Vamos chamar de escala o fato recebermos a
fonte da imagem como referência. Basicamente, a partir dessa
fonte de imagem, ela retornará no ícone da imagem. Definiremos a largura e a
altura de duas propriedades 250, outra variável para o tipo,
e o tipo será o tipo de idade do
baiacu em RGB Ah, agora vamos criar uma imagem em buffer chamada
DST a partir do destino Nova imagem de buffer que
recebemos com 50 de altura 50 no
tipo como tipo em GB Precisaremos usar
os gráficos e com base no destino da
imagem armazenada em buffer invocaremos o método create Agora poderemos desenhar
uma imagem dos gráficos para
o objeto e ela
será a fonte zero,
zero, a largura, a
altura e isso. E também precisaremos invocar o método dispose nos gráficos
do objeto Como etapa final, podemos retornar o ícone da imagem desse método. Aqui, precisamos apenas
usar o método de escala
e você verá que o problema foi corrigido
e que o rótulo
realmente apontará para um
ícone de imagem para a imagem do sorriso. Também precisamos adicionar o
rótulo da imagem à lista de imagens. Para código de meta bits. Vamos voltar à moldura
do ajudante. Uma vez que já temos esse painel de
imagens instalado. Vamos injetá-lo usando
o cabo automático. Painel de imagem privada. Semelhante ao painel vazio, pode adicioná-lo ao painel principal. Este painel principal
adiciona um painel de imagens e usaremos o
layout da borda como para o leste. Então, isso será armazenado na parte
direita da tela. Vamos iniciar o aplicativo. E você pode ver que o painel de
imagens foi configurado. Vamos fechar isso, por exemplo. Vamos mover esse console para
a parte inferior da tela.
5. Eventos de usuário: Antes de prosseguir e começar a implementar o terceiro
painel da lista, precisaremos configurar algumas classes de componentes
específicas como parte do nosso processo de
desenvolvimento. Então, eu quero o pacote de jogos C
Hangman. Vamos criar uma classe
chamada sp Context. Clique em Concluir. Precisaremos
anotar essa classe
com um estereótipo de componente Vamos também adicionar um comentário
descritivo, como esse componente que
será usado para automatizar
o
contexto do aplicativo Spring dentro da classe não correspondente Você verá posteriormente
neste curso como essa
classe será usada. contexto Spring
precisa implementar o aplicativo com reconhecimento do contexto. Também usaremos a denotação
automática de palavras. Vamos adicionar uma variável como variável estática do tipo contexto de
aplicativo e vamos chamá-la de contexto de
aplicativo. Certifique-se de importá-lo
do pacote
correspondente da estrutura. E também precisaremos substituir o método de
contexto do aplicativo definido pois implementamos o
aplicativo sensível ao contexto Esse método recebe o parâmetro de contexto do
aplicativo e o tipo de exeção Bins Eu importei a exceção Bins. Agora, usaremos o contexto
spring, esse
contexto do aplicativo para ser igual
ao contexto do aplicativo recebido como parâmetro no método set
application context. Também vamos retornar o contexto do
aplicativo usando um método estático. Aqui, estamos retornando
apenas o contexto do aplicativo. Vamos seguir em frente e trabalhar
nos ouvintes que serão
usados em nosso aplicativo Teremos um ouvinte de mouse
e também um ouvinte de botão. Então, vamos abordar ouvintes do
Hangman Game Guy
e criar nosso ouvinte de mouse que responderá
aos eventos do mouse para nossos botões que serão
criados em Essa classe de ouvinte de mouse precisa estender
o adaptador do mouse Eu configurei um
construtor vazio simples para nossa classe. Vamos adicionar um comentário para
o método que configuramos, lidar com o caso em que o mouse
insere um padrão específico. O método precisa ser
chamado mouse enter do tipo void e recebe um evento de
mouse como parâmetro Precisaremos obter a
parte inferior que selecionamos. Na verdade, o botão que
acionou esse evento do mouse. Quando entramos no
botão com o mouse, esse evento será gerado
automaticamente. Se o botão estiver ativado, passamos o mouse sobre ele para
basicamente passar o mouse sobre o botão Precisamos definir a
cor de fundo como efeito. E vamos configurá-lo
para branco para que o usuário saiba em qual
botão ele passou o mouse Agora vamos adicionar um novo
método que
tratará do caso em que o
mouse sair do botão Precisamos chamá-lo de mouse
saído do tipo void, igual ao mouse centralizado, recebe um
evento E precisamos verificar se
o botão escolhido está ativado para definir uma cor de fundo
específica para esse botão também. Definimos a cor de fundo. Vamos criar uma nova classe
chamada button listener. Essa classe de ouvinte de botões precisa implementar o ouvinte de ação Vamos também adicionar um método que
precisa ser implementado, ação executada que
recebe um evento de ação E. Precisamos obter o
botão atual em que clicamos Usando o mesmo
processo. Obtenha a fonte. Simularemos o fato de que não
queremos que o botão
seja selecionado novamente, então o desativamos e também definimos a cor de
fundo como verde Também precisaremos obter
a letra correspondente do botão pois cada botão
terá uma letra. Faremos isso usando o
gráfico get text to zero. Na verdade, isso nos dará a primeira e única letra
existente para esse botão que é
adicionada a esse botão. Agora, se você se lembrar do contexto do
aplicativo, a classe de contexto spring será usada aqui para o contexto do
aplicativo. E em um ponto
posterior deste capítulo, você verá, depois de configurarmos
todos os botões, como poderemos usar esse contexto de aplicativo
em nosso módulo.
6. Construindo a cena: Agora, estamos prontos para criar
nosso terceiro painel na lista. Então, vamos navegar até os painéis Guy do jogo C
hangman, pacote
correspondente, e
criar uma classe de painel de letras Devemos seguir uma abordagem
semelhante para anotar essa classe com o estereótipo do componente para que ela seja Essa classe precisará estender
o componente de giro do painel G. Agora, precisaremos criar
um mapa específico que
manterá os pares de valores-chave da letra e do botão
correspondente. Uma vez que tentaremos simular todo
o teclado do nosso computador desktop ou computador, depende do caso do usuário Estou criando um
mapa simples com a chave sendo uma string e o valor sendo o botão
correspondente, e vamos chamá-lo de mapa de letras. Agora, para o construtor de
patentes de cartas, definiremos um layout simples
de um layout de grade onde usaremos uma estrutura de layout de
grade livre e zero correspondente Estabeleceremos o método de criação de painel que é anotado
com a construção post Para que esse método seja invocado
automaticamente primavera, começaremos a
definir a lista
de correspondentes em nosso teclado A primeira lista conterá todas as letras de
Q a P, inclusive. Estou adicionando aqui todas
as letras
do Q ao p no nosso teclado. Vamos usar uma
abordagem semelhante para a segunda e
configuraremos letras de a L. Lembremos
que todas as letras são. J, K e também L. Vamos definir a
última linha de z a M. É uma lista V B e a letra final M. Definimos listas livres de
cordas que acompanharão as linhas
do nosso teclado
e incluirão todas as letras Agora, devemos adicionar um comentário descritivo, como para cada letra na lista Precisamos criar um botão
correspondente. Agora, eu gostaria de configurar
um método que criará um painel J para lista de letras que
serão definidas como parâmetro. Receberemos cada uma
das três cartas e
com base nessas cartas. Criaremos um painel
correspondente, e esse painel
terá um conjunto de botões que
corresponderão a essas letras. Estou criando aqui
um painel de cartas. Isso funcionará como um painel
intermediário. Queremos criar
um ouvinte de botão, instância
correspondente, instância
correspondente, e também vamos adicionar
um ouvinte de mouse Novo ouvinte de mouse. Agora, para cada
letra da lista. Queremos criar um botão e os dados correspondentes
devem ser mapeados para ele Vamos fazer uma iteração
na lista de letras que é recebida como parâmetro
desse método E para cada letra,
tentaremos criar um botão que
recebemos como parâmetro para
o construtor da letra Queremos criar algumas
propriedades para esse padrão, como definir o tamanho preferido e também definir a cor de
fundo. 100. Agora devemos adicionar
o ouvinte de ação, como esse botão, que
responderá a eventos específicos, e também o ouvinte do mouse,
para que esse botão possa responder aos
eventos do mouse no centro do mouse e na saída do mouse Vamos também adicionar uma
fonte específica a esse botão. Criamos aqui uma variável. Vamos chamá-lo de fonte. Eu e nós vamos
instanciar uma nova fonte. Mas não devemos
esquecer o tipo, então essa é a fonte do nome da
variável
e, para a fonte,
usaremos negrito e 26. Vamos usar a
classe auxiliar para isso,
essa é uma
variável constante, fonte auxiliar Definimos a fonte do nosso botão. E agora, o botão de letras. Na verdade, vamos adicionar um
botão de letra ao painel de letras e também precisamos
adicioná-lo ao mapa de letras, a letra será
a chave
e o botão da letra
será o valor correspondente, e o botão da letra
será o valor correspondente modo que manteremos todos
os botões em um só lugar, ou
seja, o mapa de letras. Como criamos esse painel
intermediário, precisamos retorná-lo e,
no método create panel, precisamos invocar o painel create letter para
cada uma das nossas três listas Vamos criar uma variável
chamada painel QP para que
retornemos um painel de botões
da lista QP. mesmo para a segunda
lista de A a L. E também para a terceira lista. Um dois. Temos três
painéis definidos. E adicionaremos esses três painéis
intermediários ao painel
da letra principal s
usando essa palavra-chave, já que ela faz referência
ao painel principal Vamos remover os espaços. E agora temos o painel da
letra s no lugar. Mas também queremos ter os métodos setter e
getter para nosso mapa de letras que
manterão uma referência a todos os nossos botões que foram
adicionados ao painel de letras Esse é o método get. Vamos também adicionar o método set. Vamos fazer isso manualmente, já que o Spring Tool Suit ID
pode fazer isso automaticamente, mas podemos
anotar isso sozinhos. Então, esse mapa de letras
é igual ao mapa de letras. E vamos até a moldura
do carrasco. Vamos injetar o painel da letra s. M. Usaremos a notação Auto
Ward Painel de letras privadas,
painel de letras como variável. E aqui, precisamos
adicionar o painel de letras
ao painel principal Mas desta vez, usaremos o layout da
borda nesse centro. Então, adicionaremos
esse painel no
centro da nossa tela Vamos iniciar o aplicativo. E você pode ver o
painel no lugar. Além disso, o
ouvinte do mouse está instalado. Você vê que quando
eu tenho um botão, a cor muda. Além disso, o
ouvinte de ação está pronto. Quando eu clico no botão, o botão é alterado para verde.
7. Adivinha a palavra: Neste vídeo, criaremos nosso quarto painel a partir da
nossa lista de painéis. Vamos navegar até nosso
pacote de painéis e criar uma nova classe. Isso será chamado de painel de palavras. Anotaremos essa classe com um estereótipo de componente spring e também precisaremos estender a Vamos também adicionar um ID de versão
serial padrão. Precisaremos
configurar uma nova variável
que será uma lista do botão G
e a chamaremos de lista de palavras
geradas para
que cada letra de
nossa palavra gerada seja que cada letra de nossa palavra gerada mapeada para um botão específico que
será adicionado a essa lista, uma nova variável chamada palavra
gerada que manterá nossa palavra gerada
correspondente e o número de tentativas que o usuário tentou
adivinhar o mundo. Nessa classe de painel J, precisaremos de uma referência
ao painel da letra s, então vamos injetá-lo Também é outra referência
ao painel de imagens. Então, injete os dois
usando a notação automática. Eu criei um
construtor simples e, aqui, definiremos propriedades específicas
do painel Eu adicionei o layout do conjunto
como um layout de fluxo simples. O tamanho preferido
para nosso painel. Precisaremos definir a cor
de fundo para preto. Agora vamos anotar
um novo método com uma construção post para que
ele seja
invocado automaticamente pela primavera que
esse método criará no esse método criará Até agora, precisaremos
instanciar a palavra gerada
com uma palavra padrão, já que não temos nada
que gere automaticamente de forma
aleatória Então, vamos usar algo
simples neste estágio. Então, a
palavra gerada será jogo. Vamos também exemplificar a lista de palavras gerada
como uma nova lista R A, e o número de
tentativas deve ser zero, já que acabamos de começar o jogo. Agora, como temos
uma palavra no lugar, mesmo que seja a palavra
padrão do jogo, precisamos obter a primeira
e a última letra dela. Então, essas serão variáveis
específicas do gráfico. Para a primeira letra da palavra, vamos extraí-la do gráfico de palavras
gerado de zero. Para a última letra da palavra, obteremos o tamanho da palavra
gerado pelo gráfico de palavras
gerado menos um Agora temos a primeira
e a última letra da palavra. E precisaremos repetir
a palavra gerada e criar um botão para cada letra no mundo
gerado padrão final, mais a chamada LB, é instanciado
para um novo padrão
e, por padrão, usaremos esse sinal para simular
que a letra não é
mostrada Definiremos o tamanho
preferido do botão e também a fonte
correspondente do botão. Além disso, vamos definir a cor de
fundo como branca e não ativá-la. Ele deve ser desativado por
padrão para que não
responda a nenhum evento de clique ou
evento de mouse. Adicionaremos esse botão
à lista de palavras gerada e também ao painel
correspondente. Agora, já que temos a
primeira e a última letra extraída da palavra
gerada Também precisamos
mostrá-los na
interface gráfica do usuário. Como você sabe, estamos
fazendo uma simulação de carrasco, e as primeiras e
últimas letras
do mundo do mundo devem
ser expostas ao usuário Então eu exponho a primeira letra. Além disso, vamos expor a última letra ao usuário
usando o método set text Agora precisamos iterar sobre palavra
gerada
usando um loop de quatro Pois eu chamo de zero, diminuí e gerei o
comprimento da palavra menos um mais E precisamos obter cada
letra da palavra. Vamos também adicionar um comentário aqui. E o que estamos
tentando fazer aqui é expor
a
letra atual ao usuário,
se a letra atual
corresponder à primeira letra da palavra gerada ou à última letra
da palavra gerada Portanto, se a letra atual for
igual à primeira letra
ou a letra atual for igual
à Precisamos obter a lista de palavras
gerada, a
referência do botão correspondente e definir o texto para a letra atual. Está bem? E agora precisamos
desativar as letras que são inicialmente expostas
na palavra que geramos. Dessa forma, precisamos desativar a primeira e
a última letra
do painel de letras, pois elas
já estão expostas
ao usuário e o usuário não
deve
poder clicar nelas. Vamos ao painel de letras. T e crie o método aqui. Vamos chamá-la de letras
padrão desativadas. Esta carta deve receber
a primeira letra em palavra e também a
última letra em palavra. Vamos criar algumas sequências de caracteres
com base nos dois gráficos que recebemos como parâmetros para a primeira letra e
um para a última letra Está bem? E agora, devemos
desativar a primeira letra. Precisamos obter uma referência à primeira letra no botão Word. Para isso, se você se lembra, temos o mapa de letras que tem referências a
todos os nossos botões e obteremos o botão
correspondente usando a primeira letra maiúscula
. Com base na tecla do mapa de letras, poderemos extrair o valor correspondente do botão
J
e, basicamente, precisamos
desabilitar esse botão. E também defina a cor de
fundo para verde, simule-a de
uma forma para o usuário Uma abordagem semelhante
deve ser seguida para a última letra que recebemos como parâmetro
para esse método. Então, criaremos a última
letra no botão da ala. E do mapa de letras, obteremos a última letra. Essa é a letra maiúscula. Vamos consertar isso. o valor do botão J correspondente e precisamos
desativá-lo e também definir a cor de
fundo como verde. Vamos fazer isso. Defina o
fundo verde, e é basicamente isso. Vamos voltar ao
painel de palavras e invocar esse método. Temos a referência de
extensão de letras que injetamos anteriormente
neste componente Vamos chamar o painel de
desativação de letras usando a primeira letra da
palavra e a última letra da palavra Agora somos o painel que
criamos a partir desse método. Na próxima etapa, precisamos de um
método para verificar se letra
selecionada está presente
na palavra gerada. Por exemplo, quando selecionamos uma letra
no painel da letra s, precisamos verificar se ela está presente na palavra
gerada ou não. Com base nisso,
faremos alguma coisa. Então, vamos configurar um valor de bleen
na letra encontrada por padrão ser falsa e iterar
sobre a palavra gerada Precisamos obter a letra
atual da
palavra gerada Garrat de I. E precisamos verificar se
a letra atual corresponde
à letra que selecionamos E nesse caso, invocaremos a
lista de palavras gerada que obtém o
valor da letra da string de texto definido Então, vamos expor a letra
selecionada pois ela é encontrada
na palavra gerada Assim, a letra selecionada
será exposta ao usuário, simulando o fato de que ele
conseguiu encontrar a carta E como o usuário
conseguiu encontrar a letra, talvez você tenha achado que a
palavra inteira foi encontrada. Portanto, se a carta foi encontrada, no entanto, não devemos
esquecer de alterar o. Então, se a letra foi encontrada, também
precisaremos de um método check complete word para ver se todas as letras
da palavra gerada eram f. Vamos implementar isso
completo, um método simples. Então, vamos fazer com que o
comentário verifique se todas as letras da
palavra foram encontradas. Portanto, esse é um método privado, verifique a palavra completa
e precisaremos dos mecanismos para
descobrir se todas
as letras da
palavra foram encontradas. E para fazer isso, se tivermos pelo menos um desses símbolos
que
simula que a letra não é
mostrada ao usuário, significa que a palavra não
está completa Então, vamos fazer uma pesquisa
sobre quantas letras com esse símbolo ainda temos
na palavra gerada. Então, o número de letras encontradas, vamos extrair da lista de palavras
gerada. Faremos um filtro
e, para cada botão, verificaremos se o texto do botão é igual ao
símbolo considerado E se o número de letras
encontrado for maior que zero, isso significa que a palavra não
está completa. Mas, na verdade, vamos
mudar essa variável para o número de letras não encontradas, já que é mais descritiva E se todas as
letras forem encontradas, retornaremos verdadeiras. Então, voltando a esta afirmação, se as letras forem
encontradas e a palavra completa, precisaremos invocar o painel de letras e
obter o mapa de letras Para cada letra
no mapa de letras, lembre-se de que as teclas são cadeias de caracteres e os valores
são padrões G. Para cada botão, o
desativará para que o usuário não
possa mais
clicar em nenhum botão
no painel. Além disso, devemos mostrar uma mensagem pop-up usando o pino de opção G, mostrar o diálogo da
mensagem. E vamos informar ao
usuário que ele conseguiu encontrar a palavra nesse caso
e vamos parabenizar E vamos continuar com o
caso S, se a letra for encontrada. Isso não é verdade. O usuário não conseguiu
identificar uma carta. Precisamos simular isso na interface gráfica
do usuário. Se você se lembra da
lista de imagens, precisamos atualizar uma
referência de imagem de smile para set. Faremos isso usando
o painel de imagens. E no painel de imagens, precisamos de uma referência
à lista de imagens. Portanto, precisamos criar o método getter para isso no
painel de imagens Ter uma referência mais
uma vez
às cinco imagens usadas para simular cinco tentativas
possíveis para o usuário
adivinhar a palavra inteira Isso retornará
a lista de imagens. Vamos também adicionar um
método setter para isso. Defina a lista de imagens, para que
recebamos uma etiqueta OJ da lista, e essa lista de imagens seja
igual à lista de imagens. Então, voltando ao painel de palavras, temos acesso agora
à lista de imagens. E obteremos a tentativa
atual. Lembre-se de que o
número de tentativas é zero quando iniciamos o jogo
e definiremos o ícone. Bem, na verdade, mude
o ícone de uma imagem de sorriso padrão
para uma imagem triste. Também aumentaremos o
número de tentativas. E como aumentamos
o número de tentativas, também
devemos verificar se
atingimos o máximo
permitido de tentativas. Nesse caso, o número
máximo de tentativas é igual ao painel de imagens,
obtenha
o tamanho da lista de imagens. No nosso caso, cinco. Então, nesse caso, repetiremos as letras
do painel de letras s, usando a mesma abordagem
descrita anteriormente, e desativaremos todos os
botões
para repetiremos as letras
do painel de letras s,
usando a mesma abordagem
descrita anteriormente,
e desativaremos todos os
botões
para permitir que o usuário
clique em qualquer botão à esquerda, e também informaremos ao usuário que ele não conseguiu encontrar
a palavra O que significa que ele perdeu o jogo. A palavra foi gerada. Até agora tudo bem. Isso parece bom. Se você se lembra, configuramos
aqui um método de carta de cheque, mas na verdade não o chamamos. Mas temos um ouvinte de ação
para cada um dos nossos botões
e, agora, sob o ouvinte de
botões, precisamos invocar esse método de carta de
verificação usando a classe de contexto que
definimos anteriormente Portanto, precisamos obter a
instância do painel de palavras, pois você vê que o ouvinte de
botões não é um componente de primavera
e o painel de palavras, é um componente de primavera e, usando
a classe de contexto de primavera, poderemos
invocar adequadamente o método a partir
do painel de palavras usando
esse ouvinte de botão Então você vê o painel de palavras, cheque a letra da carta. Portanto, agora também poderemos
invocar os compartimentos correspondentes da mola de um componente que
não está associado ao contêiner da
mola A última etapa será
conectar automaticamente o painel de palavras sob a moldura manual e adicioná-lo ao painel
principal na seção norte Vamos fazer isso. Vamos também
iniciar o aplicativo agora. Salvamos o painel de palavras. E você vê que, por padrão, temos todos os painéis no lugar
e essa palavra padrão do jogo. Você vê que as tentativas foram feitas
a partir de uma imagem de sorriso, a
imagem estava
no painel de imagens. Ah.
8. Tentar novamente?: Já temos o jogo pronto, mas parece que
não temos
a opção de regenerá-lo depois de terminá-lo com
sucesso ou fracasso Então, vamos trabalhar nisso. Precisamos trabalhar nos painéis
e, para o painel vazio, não
precisamos fazer nada pois é apenas um painel vazio. Mas
a partir do painel de imagens, precisamos criar uma forma de
regenerar os componentes
na tela Então, vamos configurar um método simples,
um método público de limpeza de vazios E nesse método, primeiro
removeremos
todos os componentes do painel
de imagens
e também invocaremos novamente o método de
criação de painel, e também invocaremos novamente o método de
criação de painel que basicamente criará todos os componentes e
os adicionará ao Vamos seguir a mesma coisa
para o painel de letras. Public void cancele essa remoção e vamos invocar novamente o método de
criação de painel, e a mesma coisa
para o vazio público está claro, essa remoção e esse ótimo painel Então, agora precisamos de
uma maneira de realmente
chamar todos esses três métodos
do painel de imagens, painel letras e painel de palavras. Vamos ver o quadro hangman
e, na parte inferior, criaremos um método privado de painéis
vazios e transparentes.
Se você se lembrar, o quadro handman tem referências a
todos os nossos painéis, e invocaremos o método
clear para painel, painel de
palavras e painel de imagens E também precisaremos do método que
será chamado de novo jogo. Sob esse método, primeiro
descartaremos o quadro j atual Precisaremos obter as
coordenadas x e y da posição
atual do quadro j e também precisaremos
invocar o
método clear panels para limpar
e regenerar os J. Depois de fazer isso, definiremos a localização do
nosso quadro J e o configuraremos novamente para ficar visível para o usuário, com todos os painéis sendo regenerados
de maneira correta Agora, precisamos de alguma forma invocar esse
novo método de jogo hanman frame, e entraremos
no painel de palavras e teremos como
exemplo o quadro handman Este é um componente,
então ele pode ser injetado. Portanto, temos dois locais onde podemos gerar
esse novo jogo. No caso de o usuário ter encontrado a palavra e também no caso de
o usuário não
conseguir encontrar a palavra. Agora, tudo deve estar no
lugar certo e temos a opção regenerar os componentes basicamente para reiniciar o jogo Você vê que o jogo foi reiniciado automaticamente
e todos os painéis foram regenerados com sucesso
9. Como salvar as palavras: Neste vídeo,
eu gostaria de
implementar um mecanismo
que nos permitirá extrair palavras aleatórias
de um banco de dados em vez de usar sempre a
palavra padrão do jogo. Então, como primeira etapa, precisamos usar o POM dot XML. E aqui, precisamos adicionar algumas dependências específicas.
A primeira dependência terá a estrutura de ID de grupo
pork spring Isso posto. Para o ID do artefato, então inicie o GPA, e agora
a segunda dependência, teremos o ID do grupo Para o ID do artefato, precisamos configurar o conector M
squeal Java Como temos essa
dependência estabelecida,
precisaremos usar o pacote de modelo de jogo como Hangman e criar uma classe simples, e vamos chamá-la Essa classe atuará como uma entidade do GPA e nos
permitirá interagir
com o banco de dados Então, vamos declarar isso
com a entidade. Certifique-se de usar o pacote de entidades Java
Persistence. Vamos também adicionar o
nome da tabela como sendo as palavras. Agora precisaremos configurar uma variável específica
que atuará como chave primária para
nossa tabela de palavras. Então, nós o anotamos com o
ID e o valor gerado. Usaremos o tipo de geração
str como identidade. Então, vamos fazer isso. Agora, vamos adicionar uma variável privada de ID longa. Eu também gostaria de
configurar um valor de string privado. Mas primeiro, com a
coluna n 16 e ie. Agora adicionaremos o construtor
público,
um construtor padrão, que
é necessário para entidades do GPA Vamos usar o ID para
gerar os getters e
setters para nosso campo de valor A próxima etapa é criar um repositório de
palavras correspondente Portanto, isso está relacionado ao
nosso GPA de dados de primavera. Isso precisa ser anotado com o estereótipo do repositório E, claro, ele deve
estender o repositório JPA. E como parâmetros, precisamos configurar
a classe do modelo e o tipo da
chave primária em nosso caso long. Para a classe modelo,
de, a palavra classe. A próxima etapa será
criar um serviço para nossa interação com a lógica de negócios
e nossa entidade GPA Então, vamos chamar esse
serviço de palavras de serviço e configurá-lo no pacote de serviços de jogos C
Han Man. Vamos transformá-la em uma interface e definiremos dois métodos. Nele, armazenará
uma lista de palavras no banco de dados quando o aplicativo for
executado pela primeira vez. Outro método é extrair a palavra aleatória do banco de dados Precisaremos de uma implementação de
classe concreta para realmente implementar
esses métodos. Eu criei o serviço MPL do Word e anotei com E essa classe implementa
a palavra interface de serviço. Também vamos adicionar métodos
não implementados até agora. E vamos também injetar
o repositório de palavras. Para a lista de palavras, eu já preparei
para você uma lista de uma palavra que será
armazenada no banco de dados. Então você só pode copiar e colar isso sem anotá-los. Veja, há muitas palavras com
as quais você pode brincar. E precisamos do mecanismo para realmente armazenar essa
lista de palavras. No método de banco de dados seguro, primeiro
verificaremos se o
método de contagem de repositórios de palavras retorna zero Isso significa que não temos nenhuma palavra armazenada
até o momento no banco de dados. Vamos dividir a lista de palavras
em uma matriz separada por co. E vamos iterar sobre essa matriz de palavras E salve cada palavra no banco de dados usando
o método de salvamento do
repositório de palavras Para isso, vamos criar um construtor simples que receba o valor como parâmetro Esse valor é igual a valor e
isso deve resolver nosso problema. Armazenaremos diretamente uma palavra no banco de dados
relacional Muscular Vamos agora para o método de
obtenção de palavras aleatórias. Para isso, vamos
ao repositório e
configuramos um método específico Isso retornará uma palavra, e vamos chamá-la de
encontrar uma palavra aleatória, e usaremos a
notação específica e selecionaremos Vamos chamar nosso banco de dados de carrasco, já que o jogo é carrasco, e invocar as
palavras do andman ordenadas por rand,
limite um, e a consulta nativa
deve ser Isso extrairá
uma palavra aleatória do nosso banco de dados andman que
configuraremos posteriormente e
da palavra sable
que configuramos anteriormente na classe de modelo
correspondente à palavra Então, voltando ao serviço de
palavras MPL, vamos usar o método
recém-criado do repositório
de palavras Então, repositório do Word,
encontre uma palavra aleatória e vamos recuperar
o valor da string usando o método get value Agora, como temos esses
dois métodos implementados, precisaremos de uma maneira de
realmente invocá-los. Para o primeiro método,
vamos até o aplicativo do jogo
e, aqui, quando o
aplicativo será iniciado. Primeiro, injetaremos serviço correspondente usando
a anotação automática de fiação Obviamente, usando o método
post construct, Spring invocará automaticamente esse método e, nesse estágio, vamos salvar na chamada DV a
partir da palavra serviço Dessa forma, todas as palavras
serão armazenadas no banco de dados. Agora, precisamos da maneira invocar esse método de obtenção de palavras
aleatórias E se você se lembra
no painel de palavras, consideramos por padrão que
o jogo é a palavra gerada, e precisamos mudar isso. Vamos conectar automaticamente a instância de serviço de
palavras. E em vez de usar o texto do
jogo aqui, vamos usar o método de serviço de palavras, obter palavras aleatórias. Então, toda vez
que gerarmos esse painel, uma nova palavra será extraída do banco
de Agora, uma etapa importante é
definir propriedades específicas em nosso arquivo de
propriedades do aplicativo para
que o spring possa se comunicar com
o banco de dados mSw Então, definiremos o nome da classe do driver da
fonte de dados spring como o nome da classe que corresponde
à instância Muscular. Precisamos definir o URL dos dados
da primavera. Esse URL corresponde à
instância Muscular que configuramos localmente e se conecta a um banco de dados
hangman que
criamos . Para o nome de usuário da fonte de
dados spring, temos o nome de usuário da
instância Mice definido como root e a
senha definida como senha Obviamente, isso
depende da sua instância do Mcal. Mostraremos os SQLs
gerados nos registros
e usaremos a atualização
automática do DDL em termos de possíveis alterações
que farão com que a classe
do modelo de palavras
seja
armazenada automaticamente na instância correspondente Agora vamos definir o dialeto mSQEL. Dialeto Org Hibernate. Vamos começar o arquivo, MQ é igual a 57 dialeto Agora, fui para minha instância do
Miquel e tudo que você precisa fazer é criar um banco de dados simples
chamado Hand Man apenas uma vez Vamos iniciar o aplicativo. Ou vamos dar uma olhada nos registros. Você vê que todas as palavras
estão sendo inseridas. Esse processo acontece
apenas uma vez, e você vê que já temos uma palavra aleatória extraída do banco
de dados na interface
gráfica do usuário Também podemos revisar o fato que todas as palavras
foram
inseridas no banco de dados usando uma
contagem da tabela de palavras. E você vê uma palavra. E agora o jogo funciona
muito mais facilmente em termos de ser capaz de
gerar palavras aleatórias a
cada vez Você vê palavras longas, palavras
curtas e assim por diante.
10. Como adicionar um menu: Neste vídeo,
gostaria de adicionar a opção fornecer um menu para nossa interface
gráfica de usuário. Vamos fechar a
instância atual do aplicativo
e, no menu Cohen
Man game Guy Vamos criar uma
classe simples chamada menu. Esta classe será e com o componente
estereótipo de primavera Deve estender a barra de menu J. Esse é um componente de
um pacote Javac swing. Agora, preciso
conectar automaticamente a estrutura do Hanman. Componente principal. Vamos consertar isso e remover os cometas. Ou crie um construtor
para nossa classe de menu. Depois disso, configuraremos o método
create menu.
Em nosso construtor, vamos chamar esse método
create menu Sob esse método recém-criado, primeiro
definiremos o menu G
chamado menu Opções e armazenaremos as cadeias de
opções Cadeia de opções ao lado dela. Agora vamos criar alguns itens de menu
simples que serão adicionados
ao menu de opções. Para a opção 1. Teremos a possibilidade de gerar
a palavra
e, para a segunda opção, teremos o caso de uso
para sair do aplicativo. Essa é uma forma alternativa de
pressionar o padrão x. Agora, gostaria de adicionar também principais ouvintes aos nossos itens de menu Controle mais n para
a nova opção de jogo e Controle mais E
para a opção de saída. Vamos fazer isso. Opção 1, precisamos invocar
o acelerador definido E como parâmetro, precisamos
definir o pressionamento de tecla e obter a tecla tecla e a tecla de evento de tecla
e n, e precisamos adicionar o
evento de ação como máscara de controle Semelhante à opção
dois do nosso menu. Defina o acelerador,
ainda usaremos o pressionamento de tecla e agora usaremos o evento chave com o
E e o evento de ação, mesma coisa, máscara de controle Precisamos implementar a lógica
de negócios para nossas opções. Adicionaremos ouvintes de ação
para ambos. Então, para a opção 1
ou gerar mundo, precisaremos implementar
o
método action perform e receber
um evento de ação E. E aqui, usamos
a instância
do jogo Hand maan e
invocamos o novo jogo Para a opção dois,
adicionaremos um ouvinte de ação. Mesma assinatura de método,
ação executada, evento de
ação E como parâmetro
e, desta vez,
excederemos a aplicação. Agora, precisamos adicionar
a opção um e a opção
dois ao menu de opções. E adicione esse menu de opções
ao componente principal do menu j
que essa classe estende. Para
usar corretamente esse menu, precisaremos injetá-lo
sob a moldura masculina Vamos fazer isso. Precisaremos primeiro usar
a notação
automática com fio, o menu de menu
privado, já que nossa
classe é chamada dessa forma E aqui, invocaremos
essa barra de menu set J
e, para o parâmetro,
usaremos o menu Agora vamos iniciar
o aplicativo. E você pode ver que
os menus de opções apresentam duas opções
diferentes, gerar palavra e sair, eu pressionei o botão gerar palavra. Uma nova palavra foi gerada e você também tem a
opção de usar pressionamentos de teclas Vamos usá-los para
a opção de saída.