Aula 05
Azulejos de Entrada e Saída do Labirinto com um Novo Formato do Mapa de Jogo
Summary
# Resumo da Aula de SDL - Desenvolvimento do Jogo Labyrinth
## Objetivos da Aula
- Pintar a entrada e a saída do Labyrinth.
## Detalhes do Mapa
1. **Entrada**:
- Localização: Segunda linha, primeira coluna (coordenadas `1,0`).
- Cor: Verde.
2. **Saída**:
- Localização: Quinta linha, última coluna (coordenadas `4,19`).
- Cor: Vermelho.
3. **Ajustes no Mapa**:
- O mapa inicial não possui caminhos para a saída, então é necessário modificar os muros.
- Criar um caminho a partir da entrada até a saída.
## Carregamento do Mapa
- Adiciona entradas e saídas como variáveis no arquivo do mapa (`mapa_do_jogo.txt`).
- As entradas são representadas pelas coordenadas no formato `x_entrada, y_entrada, x_saida, y_saida`.
## Implementação
1. **Definição das Coordenadas**:
- Coordenadas são ajustadas para alinhar com o array de 0 a n.
- Coordenadas são convertidas multiplicando pelo tamanho da azulejo (32 pixels).
2. **Mudanças no Código**:
- O código para carregar o mapa agora inclui a leitura das coordenadas de entrada e saída.
- Variáveis são inicializadas com os valores corretos.
3. **Funções de Pintura**:
- Funções criadas para pintar a entrada e a saída no mapa.
- Chamadas para pintar a superfície do mapa após a carga.
## Problemas e Soluções
- **Bug no Movimento**:
- Um bug foi encontrado ao tentar mover o jogador para cima (influenciado por um erro de lógica).
- O ajuste foi feito de subtrair a posição `y` corretamente ao mover para cima.
- **Pintura da Entrada e Saída**:
- A posição do jogador é agora carregada corretamente utilizando a entrada.
- As funções de pintura são chamadas no loop principal após o carregamento do mapa.
## Conclusão
- A aula chegou ao fim com a entrada e saída pintadas corretamente no mapa e a implementação do código revisitada e aprimorada.
- A próxima aula será sobre a continuidade do desenvolvimento do Labyrinth.
Muito obrigado por assistir e até a próxima!
Video Transcript
Olá pessoal estamos de volta mais uma aula de Sdl vamos continuar o desenvolvimento
do nosso jogo do Labyrinth.
O objetivo desta aula será pintar a entrada e a saída do Labyrinth.
Olha aqui nessa imagem. Então eu vou pintar a entrada por exemplo aqui eu quero que a entrada
seja na segunda linha primeira coluna então eu vou pintar de verde esse azul lejo aqui o
jogador irá iniciar na posição desse azul lejo verde que é indica a entrada do labirinto.
Então eu quero também fazer a saída para poder fazer a saída eu vou pintar de vermelho e eu vou
colocar na quinta linha certo deixa eu contar aqui 1 2 3 4 5 aproximadamente aqui mas vai ser lá
a última coluna tá na coluna 20 tá isso vai ser a saída. Claro que agora o mapa não tem
meios de ir até lá e eu vou modificar o mapa para poder abrir as o caminho né por exemplo
eu acho que o muro é por branca né então eu tenho que fazer um caminho por exemplo eu quero
deixar eu trancar essa aqui tá vamos trancar ela vai para cima para a direita para baixo para
direita vamos dizer que ele vai para cima para direita para baixo bem aqui eu acho que eu vou abrir
essas partes aqui também.
E aí vai ser o chão né eu queria abrir essa parte aqui tá e poder andar.
Aí vai pular e a gente pode fazer outro aqui também vai ser rápido aí você faz da maneira que
você só precisa chegar aqui no vermelho então posso fazer sim.
E fazer talvez.
E.
E assim por diante né você pode fazer sua própria mapa aí.
E.
Aqui.
Vou deixar passar por aqui.
Então vamos começar.
Primeiro fazendo esse mapa bem rapidinho voltando lá no arquivo mapa do jogo.txt eu quero bloquear a terceira
linha primeira coluna tá então linha um linha dois liga três.
Em vez de zero com um para dizer que é o muro tá.
Aí a gente vai para cima.
Abaixo abaixo para a direita para direita direita lá por cima aqui nos zeros aí chega aqui.
Estamos na queremos abrir a quarta linha né então a quarta linha essa aqui em vez de um um vai ser zero zero zero.
Tá dessa aqui que é meio difícil de visualizar mas continuando também quero abrir do lado.
Zero vai para baixo vai para direita e para direita para direita também em vez de um um vai ser.
Zero zero tá.
E.
E cá vai duas para baixo e uma para direita e outra para direita vamos abrir também.
E finalmente vai ter o caminho aqui e vai ser vamos ver aqui na.
Quinta linha então na quinta aqui vamos abrir esses dois aqui.
E a saída vai ser na quinta linha na última coluna então vamos fazer um negócio aí para poder indicar
qual é a entrada e qual é a saída.
Então vamos lá para a gente poder saber onde é que é a entrada e a saída a gente tem que indicar no mapa.
Bem como cada azulejo indica o tipo de tipo de azulejo que é você poderia
tecnicamente dizer que o azulejo de outro número que não seja zero nenhum por exemplo número dois
seria a entrada número três seria a saída pode fazer dessa maneira mas eu não vou fazer
essa maneira porque eu quero de copular essa.
Eu não quero acoplar a entrada posição de entrada posição saída com o azulejo porque.
Por exemplo se esses azulejos fossem algo mais apresentativo como se fosse uma grama.
Quando fosse a terra né.
Então teria grama e seria o azulejo e se eu modificasse essa grama para ser a entrada a grama desapareceria
então a gente precisa ter ainda o azulejo que é a grama e faz parte do mapa e em cima disso
que a gente põe um invisível né uma coisa invisível que agora não tá invisível porque
eu tô indicando com a cor verde mas poderia ser invisível e a gente quer que essas coisas
aquela entrada seja separada dos azulejos do mapa tá então por isso que eu vou aqui fazer o seguinte
na primeira linha do arquivo do mapa do jogo eu vou determinar onde é que é a entrada e
onde é que é coordenada da saída tá então vou levar quatro valores a coordenada x de entrada
coordenada y de entrada e a coordenada x de saída e coordenada y de saída então vamos separar
esses valores por um espaço tá então nesse caso aqui o verde seria na linha né vamos começar
com a linha a linha vai de cima para baixo então temos a linha 1 e a linha 2 né que é o verde bem
você poderia contar de 1 2 3 ou você pode contar começando do 0 você contar começando do 0 fica
mais fácil na hora de fazer os cálculos na na porque a gente tá usando a race lembra para fazer
fazer na os azulejos o um array de duas dimensões né então você pode aqui vamos começar do 0
contar do 0 então a primeira linha a gente vai representar pelo número 0 a segunda linha pelo
número 1 e assim por diante então para poder pôr a linha aqui vou a segunda linha será número 1
indica o índice agora para a coluna será a primeira coluna né primeira coluna começa do 0
conta do 0 e não está 0 então temos aqui a coordenada de entrada né do abrindo que é
esse ponto verde que eu marquei aqui na no colo apente então vai ser segunda linha primeira coluna
isto é um 0 agora vamos fazer a mesma coisa para sair bem para sair qual é a linha vamos ver
tem um linha 0 linha 1 linha 2 linha 3 linha 4 né que a quinta é sempre 5 menos 1 4 né então
então um pouco 4 agora para poder pôr a coluna eu posso contar um por um mas eu sei que a tela do
jogo tem dimensão de largura de 640 como cada caso leite tem tamanho de 32 pixels eu divido 640
e 32 isso dá o que então 32 vezes 10 é 320 né então vezes 20 é 640 então temos 20 azulejos
da esquerda para a direita na última coluna será o azulejo né da coluna da da vigésima né a 20 coluna 20
mas como a gente conta do 0 a gente tem que subtrair um então na verdade a coordenada aqui vai ser 19
tá então com isso a gente vai pegar e ler isso lá no nosso arquivo main.op s na hora de ler o mapa
e lá bem vamos ler a coordenada de entrada e saída então vamos lá vamos no arquivo main.cpp na hora
de carregar o mapa você tem na linha c82 tem a chamada aqui para carregar o mapa uma arreia aqui
vamos lá nessa função então damos aqui na função de carregar o mapa temos um objeto de
e fstream que abre com um arquivo mapa do jogo outro teste este o arquivo estiver aberto vamos fazer
alguma coisa né essa parte que é para ler os azulejos antes de ler as azulejos ele precisa ler a linha de
entrada e saída do labirinto então vamos fazer o seguinte vamos fazer um variável e a gente aqui
essa variável vai ser vamos a gente tem que armazenar qual vai ser a linha da entrada e a coluna da
entrada então vamos fazer a linha da entrada e fazer outro variável a coluna da entrada
agora eu vou pegar o mapa do jogo que é um objeto de fstream vou mandar lá ele ler para a linha da
entrada que é o primeiro número né aí depois eu mandar para coluna da entrada
tá certo a pai mesmo compra saída né vou fazer um variável a linha da saída se quiser pôr
a linha tanto faz só fazendo aqui você vê como dá no mesmo uma declaração de variável a pega o
e fstream mapa do jogo e põe lá para o próximo valor e para variável linha da saída próximo valor
se atribuído a variável coluna da entrada tá e como tem quatro atribuições através do operador
aqui que tá já uma função do e fstream pertença ao e fstream
é a gente vai ter esses valores aqui do mapa do jogo carregado na memória tá agora vamos ver
e ele pega os lejos e a variável as lejos que é um array de duas dimensões é na verdade modificada né
e aí a gente precisa arranjar uma maneira de na hora de pintar o mapa né também pintar a entrada e
pintar a saída vem vamos fazer isso com essas variáveis aqui são locais né a gente precisa de uma
forma para mandar para disponibilizar esse valor fora dessa função de carregar mapa eu carregar mapa
ele não vai ser responsável a pintura então a gente lá da hora da pintura precisa ter acesso a esses valores
e fazer isso vamos ver que a gente deixa eu voltar aqui na chamada imprimir é só para debug né não é a pintura
é criar superfície do mapa do jogo a longa da uma função essa função cria uma superfície sdl e surface
e pintos quadradinhos né os azulejos aqui e tal e tal
e pode andar o azul e então quero pintar sobre o que o que já tem né eu não quero a
minha cabeça que eu não quero modificar a lógica de pintar os quadradinhos eu não quero a como é que se
fala combinar essa lógica com a lógica de entrada e da saída porque eu quero manter separados como já
eu não quero tirar a grama só para pôr o invisível que é apresentado pelo verde aqui da entrada e pelo vermelho
da saída né porque fosse um jogo com gráfico né mais normal né sem ser só esses quadradinhos você
não precisava pintar as coisas né normalmente não precisa né então vamos dar um olhado
vamos fazer o seguinte depois de criar superfície do mapa do jogo né ele vai pintar todos os
quadradinhos a gente vai pintar sobre a sua superfície o azulejo de entrada e o azul de saída então vamos
fazer o seguinte não se esqueça o lado a gente tem que lidar com aquele problema da carregamento
do das coordenadas tá então com o ensinamento mas não se esquece depois de criar superfície do mapa do
colinha 191 vamos fazer uma função para poder pintar saída saída tá eu também quero fazer uma
função para pintar a entrada deixa fazer entrar primeiro
a entrada
está saída
então precisa da coordenada né a posição então aqui eu preciso
pintar a entrada onde eu preciso da superfície para pintar então eu vou criar o fone já já tá
certo essa função vai levar com o margamento que a gente precisa de uma superfície para poder pintar
e precisa da coordenada de entrada então vai ser um sdl surface ponteiro que vai ser o mapa
do jogo eu escrevi mapa de jogo que
eu escrevi mapa de jogo né e vai ser eu tenho que declarar na verdade a função eu vou tirar esse tipo
já já só e precisa também do de uma posição né eu vou chamar de sdl e rec a posição de
entrada tá então deixa eu copiar essa nature de função e vou tirar os tipos então quero
chamar essa função dessa maneira aqui tá vamos lá em cima e fazer a função antes do meio
eu vou criar
o colar adicionar os
as chaves a pintar a entrada vai ser retornando nada vou e tá bom
então a gente vai fazer o seguinte a gente vai dar o sdl e o rec para poder pintar um retango
a primeira tem que dar qual é a superfície né vai ser mapa de jogo a segunda argumento será o
retango né o endereço né o retango vai ser posição entrada mas na verdade o endereço o terceiro
argumento vai ser o e o int né 32 da cor eu vou dizer por essa variável com o que eu vou fazer
anteriormente o índice 32 cor a gente vai obter essa cor do sdl e map rgb tá para poder mapear
primeiro argumento vai ser a formato da superfície então mapa de jogo é superfície e pega o formato
a segunda vai ser quanto de vermelho né rgb então separado vírgula então quero fazer a cor ser verde
nesse caso então deixa eu dar 128 255 128 então vermelho 128 verde né green 255
e o azul nauc a azul 128 tá e isso vai mapear para um inteiro né sem sinal de 32 bits e a gente passa com
uma argumenta que terceiro argumento pro ferro rec agora a gente precisa da posição de entrada
vamos voltar né backtrack aqui pra onde a gente chama a produção de entrada agora posição de
entrada eu tenho que arranjar o maneiro de ir lá da função do criar superfície
a pade jogo ou na verdade o carga mapa de um cargar mapa que vão ver e eu tivesse e a gente fazer um
rack e posição entrada e pega o rack e passa referência aqui será que isso vai funcionar
vamos segundo argumento cargar mapa vamos ver vamos lá de volta por cargar mapa
a d na segunda argumento o parâmetro vai ser sdl e rec referência tá uso 1%
e como dizer posição entrada
e com isso eu posso pegar a posição entrada e setar aqui embaixo como eu peguei a linha da entrada
quando a entrada eu li esses valores eu posso dizer que a posição de entrada x vai ser linha da entrada
alguma coisa que eu vou dizer já já posição entrada y é coluna da entrada vezes alguma coisa
então como é uma referência pro sdl e rec ele vai ser modificado tá quando sair da função o valor
que foi passado será modificado é mutado né devido a referência que eu adicionei e não tiver
referência o valor seria passado por valor né by value e seria uma cópia
nesse caso agora que na hora de setar a posição de entrar x e eu tenho que setar na na verdade na
coordenada do x e no sdl né porque embora que tenha 20 a 20 colunas esquerda pra direita e 15 né
480 dividido por 32 né da 10 15 15 e ir para baixo a coordenada na verdade é diferente porque cada
cada a zo lejo tem 32 pixels né então eu tenho que pegar essa linha da entrada e multiplicar pelo
32 a na verdade 32 é só variável que global que eu tenho tamanho da zo lejo então vou usar ela aqui
a linha 5 e o que vai para coluna da entrada tem que multiplicar pelo tamanho do azul e por exemplo
se a linha nesse caso aqui a posição da entrada o que a linha vai ser 0 1 vai ser 1 né então a linha 1
vezes 32 vai bater onde vai bater aqui logo no começo da da segunda linha que tá correto né da
posição x agora o pôs
agora a posição y né
opa acho que eu fiz uma coisa errada aqui aí eu e o que são problemas muito comum a gente muda a gente
troca né as posições vamos fazer isso aqui pensar aqui a posição x é vai de da onde x vai da
esquerda para a direita né
esquerda para a direita as colunas então não é linha eu vou ter errado aqui então isso aqui tem que ser na verdade
coluna
que eu quis dizer então para a posição x vai ser a coluna entrar nesse caso vai ser a coluna que a coluna 0
é
vezes 32 vai dar 0 né então tá correto ele vai vai ficar na primeira aqui né logo no começo
então olha aqui na coluna pente
então se fosse a simulina coluna ele iria ser o que 1 vezes 32 que dá 32 então ele ia pular e
começava aqui né olha aqui na minha seta do colo pente
na mesma maneira para o para o ípice nesse caso aqui o ípice seria na segunda linha que é apresentado
pelo índice 0 1 1 em segundo vezes 32 dá 32 então tá correto então começa logo aqui
onde eu pintei de vez né na verdade na parte sim você né
então da mesma maneira a gente vai fazer para a adição no terceiro argumento sdm erect a referência posição de saída
aí você pode fazer a mesma coisa depois de fazer a leitura da variável chama a posição saída ponto x igual a
a coluna
a das pô
minha variável tá errado né coluna da saída que o nome da variável tem que ser coluna da saída vou ter eu escrevi errar
então linha 19 linha da saída linha 20 tem que ser coluna da saída não é da entrada e muda também o e-m-t-1 aqui no final
o mais que mais que coluna da saída então posição da saída ponto x igual coluna da saída
vezes o tamanho do azulejo posição saída ponto y é a linha da saída vezes o tamanho do azulejo agora vamos voltar para a
chamada do carrega mapa na linha 198 e adicionar o terceiro argumento aqui o endereço e uma variável a gente pode criar
se dela e reac posição saída aí eu digo aqui como terceiro argumento linha 199 agora carrega mapa
terceiro argumento posição saída e manda o endereço
o panava da né e neres que eu passei uma referência desculpa como passei referência eu não preciso o endereço e
que eu vou mandar assim mesmo a carrega mapa tem referência referência tal e tal e tal
e a gente só vai precisar do empercent na hora de pintar né na hora que vou pintar a entrada na linhas 202 você
passa o empercent aqui com segundo no segundo argumento ele poder pegar o endereço né na hora de
pintar o empercent aqui
ah eu tava errado desculpa já tá aqui
linha 164 já tem 1% então eu não passei nenhum ponteiro como parendo desculpa
remover-se 1% então tá assim mesmo vai ser passado por a cópia sem problema a gente não precisa preocupar
a na pintar saída você faz a mesma coisa passa o mapa de jogo e a posição nas escadas e saída
você pode até copiar o mesmo código né então falar a pintar saída leva como argumento sdl
surface asterisco mapa de jogo vírgula sdl e rec posição saída nesse caso essa função leva com
nada como retom então é void
a gente primeiro tem que fazer a col sdl map rgb para poder mapear da formato da superfície mapa de jogo
a traço mais que format né então você passa o rgb separado por vírgula os próximos argumentos
como eu quero que seja com vermelho a votar mais vermelho então 255 128 128 a
vila vamos botar dentro variável como essa função retorna o inch 32 eu fazer o tipo o inch 32 foi igual
com isso sdl e o rec para o mapa de jogo superfície o endereço do sdl e rec posição saída nesse caso
e finalmente a cor que é o format é o peccionado de code e o inch 32 a vão com isso
voltar lá na chamada e tal e tal vamos ver se funcionou esse negócio vou salvar o meu arquivo vou
aqui no meu terminal deixa eu matar esse jogo eu vou recompilar e rodar de novo a noite que apareceu um
problema aqui na linha 21 vamos lá para a linha 21 mapa de jogo não foi declarado 21 que eu fiz de errado
a
o nome da variável tá errado né mapa do jogo né por isso que eu tava meio confuso teriamente mapa de jogo
esses detalhes que eu escrevi e então vamos ver aqui primeiro não confio que a gente fez na primeira vez
naquele mapa como se realmente a gente fez o mapa corretamente então eu fechei aqui né a terceira
linha primeira coluna fechado certo vai para o cima e vai para direito para cima para direito para baixo
certo então abre aqui nesse canto aqui abriu abriu vai para baixo abre também vai para baixo vai para baixo
abriu para cima vai para cima vai para direita abriu vai para direita agora aconteceu um escolar muito doido
aqui que não não imprimiu a entrada mas imprimiu a saída com esse bem ele aqui na coluna né e para baixo
vamos ver o que aconteceu eu acho que foi o negócio aí que eu esqueci de setar primeiramente eu esqueci de setar
né as dimensões de largura e altura do cada retango de entrar e sair então não corre de isso né
vamos voltar aqui na hora que a posição entrar aqui foi feito né nesse posição entrar a posição sair
você pode pode iniciar aqui com x y w h ou você pode já setar aqui dessa maneira da pende você tá e vou
fazer o iniciamento na botada é posição de entrar a x vai ser 0 y vai ser 0 a width né que agora vai ser o tamanho do
azul leite né e a altura também vai ser o tamanho da azul leite então x y w h mesmo como fazer por outro tá
e eu copiar e colar isso a posição saída aí então agora temos a iniciação né das variadas
posição entrar posição saída para ter valor x y 00 respectivamente e o largura e a altura vai ser ambas 32 que é o
azul leite vamos ver agora se cogeu alguma coisa vou fechar aqui vai compilar e iniciar agora você viu que o negócio
funcionou de completamente né a entrada foi pintar na segunda linha primeira coluna a saída foi invitada lá na última
coluna na quinta linha né que é o índice 4 a menores que jogador não começou no azul leite da entrada
e aí é um problema tá que a gente tem que coger então vamos lá vamos lá para a parte da onde você seta o
posição inicial de jogador tá onde é que tá isso você vê que a posição do jogador tá setado na linha 195
e o jogador 00 né x y a gente tem que mudar isso para poder ser da posição entrada verdade mas a gente só pega a
posição entrada depois que carregar o mapa né então a gente vai ter que mover essa parte aqui do jogador para lá e para baixo
e carregar o mapa e tá bom então posso pegar e recortar a linha 195 a depois da carregar o mapa a gente vai ter
posição de entrada então posso dizer que sdl e rack posição jogador vai ser igual que a pro x eu posso dizer
posição entrada ponto x a pro irso posso dizer posição entrada ponto irso tá a gente quebra a linha se você quiser que é
melhor de ver essa maneira que e aí e aí e um bêbito agora começou né então o jogador realmente começou lá
o que a gente vai ver tá e aí tá correto isso e agora parece que a gente tem um problema aqui de movimento tá em
sei por que porque será a gente vai ter que confirmar isso é problema da tô tentando ir prazinho para baixo não tá
Então, vamos ver aqui.
Então, provavelmente é o problema da pintura lá no loop do jogo.
Eu noto que eu pintei, entrar e sair, fora do while, da linha 216.
Você notar que o jogo na verdade o loop fica pintando a tela constantemente.
Então, a gente na verdade precisa pintar e entrar e sair de novo, cada vez,
a cada interação da sua pintura.
Então, vou ter que tirar essa parte aqui da entrada e saída e pôr dentro loop.
Porque você vê, vamos ver no loop que ele dá com eventos,
depois de processar a entrada do jogador, ele faz o quê?
Vamos ver. Na verdade, pode ser que eu estava errado, né? Desculpa, vamos ver.
Eu acho que, como eu pintei para a superfície do mapa do jogo,
a superfície já vem com os quadradinhos e a entrada e saída já pintadas.
O que está acontecendo aqui? É que cada interação, ele está pintando esse mapa que já foi criado com a entrada e saída.
Acho que esse não é o problema. Deixa eu ver aqui o que acontece.
Eu comentar pintar e entrar e sair. Talvez eu tenha feito algo errado aqui.
Então, problema não foi na pintar e entrar nem sair.
O dia que será que foi esse problema? Será que foi na hora de carregar o mapa?
Vamos ver. Eu fiz aqui, certo?
A dia, na hora de carregar o mapa, a posição entrar e a posição sair.
Se eu não fizesse essa parte aqui da linha entrar e sair, né?
Vou aumentar e remover a primeira linha do mapa do jogo para voltar como era antes.
Eu já me resolvi o problema.
Então, eu posso mover. Então, alguma coisa aconteceu lá naquela parte.
Vamos ver, debugar isso.
Eu vou retornar para reverter no 0, 4, 19.
No meio.cpp deixo reverter isso. Linha da entrada coluna da entrada.
Mapa do jogo que está aberto. Na primeira, primeiro número, 1.
Deixa eu botar aqui para baixo e dividir para baixo.
Você vê que ele vai pegar a mapa do jogo por dia da entrada.
Esse primeiro valor que é 1, coluna da entrada, valor que é 0.
Pega a posição de entrar x, como a entrada que é 1. Desculpa, que é 0.
Vê se estão mandados o leite, 32, né? 0. Correto.
A posição de entrar também é correta.
Nós sabemos que está correta porque ele pintou na tela, né?
Você lembra? Ele pintou realmente no local certo, né? Eu acho que isso está correto.
Linha do site, como o site, a mapa do jogo, tal, tal, tal.
Também está correto. Eu não sei porque o negócio não.
Estou no direito.
Ah, que será que foi? Será que é?
Vamos ver.
Ele pintou o mapa, né? Todos foram certados corretamente.
Você sabe que eu debugou o mapa?
0, 0. A gente começa do 0.
Tá bom.
Por que será que não está usando direito? Eu não consigo meu movimento metal.
Você vê que a peste para cima não vai.
Se eu tivesse começado em outro, se eu botar a posição 0, 0, o que o mapa do jogo acontece.
Agora vai, né? Será que eu descobri um bug?
Oh, não, oh, não, oh, não.
Então, deixa eu pegar o mapa aqui e pintar novamente.
Vamos voltar para a parte que a gente comentou de pintar a entrada e a saída.
A gente não vai fechar.
Então, a entrada agora é no 0, 0, né? Então, funcionou.
Oh, achei um bug, né? Ah.
Então, a gente achou um bug na verdade de mover para cima.
Oh, não, não, tem um bug.
Então, foi bom isso que a gente achou esse bug, né?
A gente fez algo, mas a gente...
É aquele velho bug, né? Que sempre acontece de algo estar errado por um, né?
Sempre dar esse bug. É muito comum de você estar usando cooperações.
E o problema é sempre porque você fara por um.
Só por uma unidade, né?
Nesse caso, quando você vai para cima, ele está pensando que eu já cheguei no final da tela, na barreira da tela, na vertical lá no topo.
Então, esse é o bug que a gente tem aqui. Então, vamos resolver.
Na hora de pegar o entrada de jogador, processar a entrada do jogador,
função aqui, eu tenho que ver o bug lá de ir para cima, que é o elseif sdlkup.
Então, o que aconteceu é que eu estou tentando ir para cima, a posição de jogador vai ser o quê?
Nesse caso, o que é a posição? O quê?
32, né? Então, 32 menos 32 é 0.
É 0 maior ou igual a 0? Sim, verdadeiro.
Nova posição y. Olha aqui, olha aqui.
Esse aqui deve ser menos, né? Não?
Porque o de baixo aqui, adiciona 32, ao de cima é que você subtrae.
Então, linha 153 estava errado. A gente acha que é um bug.
Linha 153, ver se é demais, igual vai ser menos ou igual.
Porque você está indo para cima e para cima subtrae do y.
O que é o y? Não é adição.
Então, resolvi o bug aqui.
Agora vai para cima, agora posso reverter o meu valor da coordenada inicial do...
da linha, né? Que é o y.
Aí, agora funciona. Eu estou testando aqui, ver se não tem bug indo para a esquerda.
Agora vamos lá para a saída.
Porque ele também estava certo, indo para cima está certo, indo para baixo também está certo.
Não, isso foi só aquele.
Então conseguimos pintar a entrada e a saída. Legal.
Então, chegamos ao fim dessa aula.
É visual no que a gente fez. A gente modificou o formato do mapa, do jogo, esse arquivo de texto plano.
Para a primeira linha, adicar a coordenada da entrada e saída do labirinto.
Nesses casos são quatro valores, né? O x e y da entrada e o x e y da saída.
Aí, na hora de carregar o mapa, você pega e sete a sdli rack para a posição entrada e posição saída, né?
Antes de lidar com todos os azulejos.
Sete.
Depois disso você sete a posição do jogador com a posição de entrada x e y.
Ele pode começar lá em cima do azulejo de entrada, que é representado pela cor verde.
Finalmente, criamos as funções de pintar, entrar e sair da zona superfície do mapa.
Só preciso fazer isso uma vez, não precisa poder ter look.
Porque o mapa sempre é redesenhado com essa superfície. Já pronta.
Tá bom então, por essa aula é só. Muito obrigado por assistir. Até a próxima. Tchau.
Nenhum comentário ainda (loading...)
Nenhum comentário ainda (loading...)
Gostou da aula? 😆👍
Apoie nosso trabalho com uma doação: