Curso de exploração para iniciantes da biblioteca SDL, na linguagem de programação C++. A libsdl é muito usada para o desenvolvimento de jogos. Inclui escrita de um jogo de labirinto com mapa de azulejos (tiles) desenhados na tela. Usa o SDL2.

SDL - Desenvolvimento de Jogos - libsdl SDL2

Desenvolvimento de Jogos com a Biblioteca SDL libsdl – Programação em C++

```markdown
# Live Class Summary: Introduction to C++ and SDL

## Overview
In this live class, we explored programming with C++ using the SDL (Simple DirectMedia Layer) library, commonly used for game development.

## Key Points

- **Introduction to SDL:**
  - SDL is a cross-platform library supporting various systems including Windows, Mac, Linux, iOS, and Android.
  - The current version in use is SDL2.

- **Installation:**
  - For Linux, you can install SDL using package managers like `apt`.
  - For Windows and Mac users, binaries are provided on the download page.

- **Setup:**
  - After installing SDL, you need to include SDL headers in your C++ program (e.g., `#include <SDL2/SDL.h>`).

- **Initialization:**
  - SDL is initialized using `SDL_Init()` which requires specifying the subsystems needed, for example, video and audio.
  - Proper error handling was demonstrated using `SDL_GetError()` to log any issues during initialization.

- **Creating a Window:**
  - A window is created with `SDL_CreateWindow()`, which takes parameters such as title, position, dimensions, and flags.
  - Error handling for window creation was discussed.

- **Rendering:**
  - To change the background color, the program retrieves the window surface using `SDL_GetWindowSurface()`.
  - The `SDL_FillRect()` function is used to fill the window surface with a specific color.
  - The screen must be updated with `SDL_UpdateWindowSurface()` after painting.

- **Program Execution Control:**
  - `SDL_Delay()` is used to pause the execution, allowing the window to remain visible for a set duration.

- **Cleanup:**
  - It is important to release resources with `SDL_DestroyWindow()` and `SDL_Quit()` before exiting the program to prevent memory leaks.

## Conclusion
The session concluded with a recap of the SDL programming steps, emphasizing the importance of initializing, error handling, resource management, and the program's life cycle. Viewers were encouraged to like, comment, and subscribe for more content.

**Next Live Session:**
Stay tuned for the next live class to delve deeper into SDL functionalities!

Thank you for joining us at **NBK Mundo Tech**!
```

Welcome to our live.
In this live class we will explore the programming in C++, C++, or Bbioteca SDL.
Bbioteca SDL, simple direct media layer, a Bbioteca used for game development.
Let's start exploring.
Let's play with SDL to see what happens.
Don't forget to leave your like, comment and subscribe to the channel.
We are coming.
Let's wait 30 seconds to start.
Let's start.
We are on the live.
If you want to take a look at the documentation, you can support several platforms.
Windows, Mac, Linux, iOS, Android, etc.
I will use the C++ to demonstrate.
The version 2 will be the most current version of SDL.
If you go to the WIC documentation, there is an introduction page.
This page shows how to install for several systems.
In my case I am using Linux, distribution, and Ubuntu.
For this you can download the source code, compile it, or if you have a package generator,
I will use the apt.
We can use the apt and install the name of the package.
In the case of Windows and Mac, you can also choose the instructions.
But just go to the download page.
There is the binary for Windows and the DMG for Mac.
I will open my terminal.
I will use the name of the package.
If I do a search, I will use the SDL2.
This package will serve.
This is what I will use.
I have the SDL2.
I have installed the SDL2.
It will be installed in my case.
In the case of the SDL2, it will install several files.
We will import the SDL.
This SDL.h will be the file we will use in our code.
You can see the SDL2.
You can see the SDL.h.
Here is the code.
It will include several things.
I will create a new file.
I will use the name of the SDL2.h.
I will use the name of the SDL2.
This is why it knows where to search.
This is the SDL2.h.
Let me save this file.
I will use the name of the SDL2.h.
Let's see if this works.
I will use the folder of the SDL2.h.
The folder of the SDL2.h.
It compiles something.
Let's continue.
For the SDL2, we have to do the following.
First, we start the system.
The function is SDL.h.
You can pass the sub-systems as the argument you want.
The sub-system list is here.
I only want to make a video, so I will use the SDL2.h.
If you want more than one, just use the OR or logic operator.
To combine all the sub-systems you want to start.
For example, if you want video and audio, just say the video and put the logic OR and the other audio.
Let's start the SDL2.h.
Now you pass the sub-systems you want.
I will use the SDL2.h.
Now this function returns something.
This will be the error value.
If there is no error, it returns 0.
But if there is no error, it returns 0.
That's why we have to do the if statement to deal with the error.
If the return value of the SDL is not 0, it means there is a problem.
Let's do something.
I will show the error.
We can use the SDL2.h.
It didn't work.
We can use the S to substitute the variable or the value we put as the following arguments.
In this case, I want this argument to be corresponding to the S.
This will be the S to get error function.
The S to get error function is a function you can call to obtain the error.
If you make any mistake, just call the S to get error and you will be able to show the error.
The S to get error will be called.
The error message will appear here and be replaced where the S has the percentage.
After this log, I will say return 1.
We will return the main function.
The return value 0 means there was no error.
Any value that is not 0 means an error.
The return value is the error code.
In this case, the error code is 1.
It can be anything you want it to be.
So 1 means that it gave the problem to the SDL.
If you have other errors in the app, you can use other numbers.
Obviously you can use a constant here to define these constant numbers when you organize your code.
Ready, start the SDL.
Now we won't do anything yet, but before you finish the program, you have to finish the SDL
to be able to clean everything and leave everything in the conformance.
So you call the SDL and close.
Sorry, it's quit.
Let me search here in wiki, the SDL quit.
It was there in the example.
So just call the SDL quit to be able to close.
So let's compile this.
It's there G++, now there's a problem here.
It says that the SDL init, getError, log, quit were not defined.
This is because we didn't link the linker.
We have to link with the library to do this in G++, just use the option traceL.
G++ main.cpp traceLsdl2.
A huge detail that I've already had a problem with is that this linker option only has to appear after the list of the source code files.
If you put it before it won't work, it will be a problem.
So if you don't have a header, put the option traceL after the .cpp.
With this it will generate the .out.
We can run, obviously it worked fine, but it doesn't do anything.
As we didn't have an error, we know that everything worked fine.
So let's do something more cool.
So in the SDL we will first do the following.
As an objective, we will show a screen and in this screen we will paint the background color to blue.
Let's do this. First we have to make a window screen.
So we will use the SDL createWindow function.
If you look for a wiki window, it has the function here, createWindow.
And this function takes this number of parameters here.
First we stop being the title, followed by the two, to the position of the window, followed by the two, to the dimensions, the width and height of the window.
And the end is one of the flags, a flag, it's called.
Since there is nothing special, it's zero for flags.
So let's go, let's go.
We will do the following, SDL createWindow, what is the title of the world.
The second argument will be the position of the window.
There is a constant here that we can use to decentralize the window.
And this constant is SDL windowPauseCenter, I will copy that.
This constant here, we can use for x and for y.
Let me give the...
...soft.
The line break.
And now the width and height, I will give the width 140, the height 480.
Flag I will put zero, because I have nothing.
Let me break the line here to get better at seeing.
It's too long.
Now this function is called return with value here.
Or return no, if it's a problem.
Or return a pointer to SDL window, you notice here that the value returns.
So let's do this.
Point for SDL window.
Let's call this variable window.
Now let's check by mistake if the window was no.
This is not right, create the window, we will do...
It can be a log, as we did earlier.
You can use the standard CR, whatever you want.
To illustrate the CR, I will use the wire stream, just so you know how to do it.
If you don't know this, more and more.
STD, two points, two points, is the namespace.
If you want, you can use the username, namespace, STD, to have to type this,
but I can type explicitly.
If the CR didn't work, create the window.
And I will use the space and add... How do I get the error?
Remember?
SDL get error.
And I will type STD, two points, and L to type the line.
And after that I will return 2, to indicate that 2 didn't work, create the window.
This is the error.
If everything works, after creating the window,
we will do the painting and update the window.
But let's see if it works this way.
More and more again, to compile, let's run.
So it worked, nothing too much, no problems.
So let's look at the create window, the example it has.
So when we create things, normally, I don't know, more and more, STD,
we allocate, I pass on the memory.
So when we finish the program, or are doing certain things that don't need more,
we have to allocate the memory, to be able to release that memory to other resources.
The way to do this is, for the window, in this case, it will be the destroy window.
So you will do, to clean everything, destroy window,
don't forget to do this to be able to clean and release the memory.
As we didn't see anything that was happening,
it's because it creates the window and immediately releases the program.
So to see what is really happening, we will put the so-called delay,
to be able to stop the program, pause a little.
So there is this STD delay function, we can use it,
it takes an argument that is the number of milliseconds,
to be 5 seconds, it has to be 5 times 1000, 5,000.
So it will stop the program for 5 seconds and we will see the screen.
Let's go there, click there and run.
And my screen appeared on the other monitor.
So it's here, wait a minute, it's opening on the other one.
So this is the window that appears.
So the black window, nothing.
So let's learn how to change the background color of this window.
So we can use the fill rack function, let's look here.
So this STD delay was the rack we can use to paint a rectangle.
The way to do this is to have a surface, a surface.
We will use the surface of the screen.
And then we will use a color to make the color map,
you use STD-L-MAP-RGB.
To be able to get the surface of the screen, there is a GET-WINDOW-SURFACE.
This function here that returns a point of the surface and the window argument,
point to the window. So let's use that.
So after having the window, we will get the surface of the window,
get-windowsurface, pass the point to the window and from that we will get the point to the surface,
surface.
With that we have the surface of the window, we can use this to change the color,
to paint a rectangle of blue color to cover the whole window.
And we will use that fill rack function that we saw before.
So let's go.
So STD-L fill rack, but what is the surface?
It will be the window surface that I didn't give the name of the variable,
let me give it here, I'll call it window surface, window surface.
Now the second argument, let's see here.
The structure is STD-L-Rack, a rectangle representing the rectangle to be able to paint,
or NO to be able to paint the entire surface.
So NO will paint the entire surface and the color, what is the color?
We can use STD-L, map RGB, this function has to give the shape of the surface.
So window surface, we will reference the biggest sign,
format, format of the surface and now you give the RGB,
followed by, separated by the Vigol, arguments.
What is the argument for R, red, red?
I will give the red 0, what is green?
What is the blue?
It will be 255 to be able to be totally blue.
Let's see, let's see.
More, more.
So nothing happened, why?
So we painted the surface of the screen, but the screen is not updated.
So we have to update the screen.
So to be able to do this, we will have to have a function to update the screen.
Let me look here.
Let me look here.
To have this function update window surface, let's see if it works.
After painting the surface, we will update the window surface.
Pass the pointer to the window, window and let's see what it gives.
Here it is, and now it worked.
Then the window, a blue screen, and here it is the world as the title.
So let's review what we learned here.
So, SDR, a library that we can use a lot in games development.
Let's use version 2.
I'm using I don't know more, but you can use C and there are several binds to other languages, just look on the website.
And we started SDR with SDR in net, pass the subsystems that you want, subsystems.
SDR in net returns value no 0, if it is a problem.
You can use SDR and log to log something to the screen.
To get the error message, you use SDR get error.
First, we create the window, SDR create window,
Amazon variable window, which is the pointer value for SDR and window.
SDR create window returns no SDR, that's why we deal with the error here.
After creating the window, we get the surface of the window with SDR get window surface.
Get window surface returns pointer to SDR surface, surface,
to be able to paint the window with a blue rectangle covering the entire window, we can use SDR fill rack.
Get the surface that we want to paint.
I want a new one for the entire surface, but if you want only part, you can use SDR Rack.
You can paint the colors, calling the function SDR map RGB, you have to pass the surface format,
if you want to map this RGB color.
In this case, I used the window surface, reference with this larger line, the format attribute,
and you pass the RGB value, in this case, R0G0B255, because it's completely blue.
To be able to see what happened, you use the SDR update window surface,
to be able to update the surface of the screen, you pass the argument, the pointer and the window.
As this is already closing the program, nothing is happening too much, we use the SDR delay to be able to pause the execution,
for 5 seconds to see what really happened.
Whenever we set the memory, for example, we set the memory, we create a window, we have to clean things.
In this case, I called the destroy window to be able to destroy the window that was set.
There is also this window surface, normally when you create the surface, you have to use it,
call the function to release the memory that was used by the surface,
but I think the destroy window already deals with the release of the window surface,
so you don't need to explicitly release the window surface.
After that, before the program leaves, you have to call the SDR quit to be able to turn off the SDR,
the system will release the memory and so on.
Don't forget that.
Okay, so that's it for this live, in the next live, if you're old, we'll talk more about SDR.
Don't forget to give us a like, comment, subscribe to our channel,
NBKMundoTech, don't forget to subscribe and thanks for watching, see you next time.


0017-01 Live de Código - Programação em C++ com o SDL libsdl - Desenvolvimento de Jogos

Game Loop com SDL, Desenho de Retângulos e Movimento do Quadrado de Jogador

# Resumo da Live sobre SDL

## Introdução
- A live tem como foco a exploração da biblioteca SDL, amplamente utilizada no desenvolvimento de jogos.
- Demonstração será feita em C++.

## Doações e Interação
- Incentivo para se inscrever no canal, deixar comentários e likes.
- Informações sobre doações em BTC ou BCH.

## Estrutura do Programa
1. **Tela Inicial**: Primeiro, será criada uma tela azul com o título "mundo".
2. **Desenho de Retângulos**: Aprender a desenhar retângulos na tela.
3. **Entrada do Usuário**: Implementar a movimentação de um bloco (representando o jogador) usando teclas de seta.

## Game Loop
- Implementação do *Game Loop* para manter o programa em execução até o usuário decidir sair.
- Criação de uma variável `sair` que controla o loop.
- Processamento de eventos com `SDL_PollEvent` para verificar se o usuário quer encerrar o programa.

## Desenho de Retângulos
- Definição da estrutura `SDL_Rect` para desenhar retângulos.
- Execução de funções `SDL_FillRect` para preencher os retângulos e definição de cores usando `SDL_MapRGB`.

## Movimentação do Jogador
- Um retângulo representando o jogador será criado na posição (0, 0).
- Movimentações serão implementadas usando eventos de teclado (setas).
- Após cada tecla pressionada, a posição do jogador é atualizada considerando os limites da tela para evitar que ele saia.

## Condições para Movimentação
- Adição de verificações antes de mover o jogador para garantir que ele permaneça dentro da tela:
  - O jogador não pode mover para a direita se a posição somada à largura do jogador sair dos limites da tela.
  - O mesmo para as direções esquerda, cima e baixo.

## Conclusão
- Revisão do que foi feito, incluindo o *game loop*, o desenho de retângulos e a movimentação do jogador.
- Convite para se inscrever no canal, curtir a live e realizar doações.
- Abertura para dúvidas e interações da audiência.

Este resumo cobre os principais pontos abordados durante a live sobre SDL, o desenvolvimento de jogos e a movimentação do jogador na tela.

0017-02 Live de Código - Programação em C++ com o SDL libsdl - Desenvolvimento de Jogos

Carregamento de Mapa do Jogo de Arquivo de Texto Plano e Pintura dos Tijolos na Tela

# Resumo da Aula de SDL: Desenhando um Mapa de Jogo

## Introdução
Nesta aula, o objetivo é desenhar um mapa para um jogo de labirinto usando a biblioteca SDL. Começamos com um programa básico onde um quadradinho cinza pode ser movido com as setas do teclado, e adicionamos algumas cores para representar diferentes tipos de tiles.

## Estrutura do Mapa
O mapa será composto por "tiles" (tijolos) representados em uma grade, onde cada tile é um quadradinho de 32x32 pixels. Com uma tela de 640x480 pixels, o mapa terá 20 tiles na horizontal e 15 na vertical. O formato do arquivo do mapa será um simples arquivo de texto, onde:

- `0` representa um tile que o jogador pode andar.
- `1` representa um muro que o jogador não pode atravessar.

O jogador começará em um tile verde (posição inicial) e deve chegar a um tile vermelho para vencer.

## Criação do Arquivo do Mapa
Um arquivo chamado `mapa_do_jogo.txt` é criado para armazenar a estrutura do mapa. Cada linha do arquivo corresponde a uma linha de tiles na tela.

## Funções Principais
1. **Carregar o Mapa**: Esta função lê o arquivo de texto e armazena os valores em um array bidimensional.
2. **Criar Superfície do Mapa**: Esta função gera a superfície que será usada na tela, pintando os tiles de acordo com suas cores (preto para andar e branco para muro).
3. **Imprimir o Mapa**: Para debug, imprime a representação do mapa no console.

## Renderização na Tela
A função `SDL_BlitSurface` é usada para transferir a superfície do mapa para a tela do jogo, e o jogador é desenhado sobre essa superfície. O ciclo de atualização da tela garante que o mapa e a posição do jogador sejam corretamente exibidos.

## Conclusão
Na aula, aprendemos a criar um mapa básico para um jogo de labirinto. O mapeamento foi realizado através de um arquivo de texto simples, permitindo a movimentação do jogador entre tiles. Futuramente, seria interessante implementar um editor de mapas para facilitar a criação de níveis.

## Encerramento
Até a próxima aula! Não se esqueça de se inscrever no canal e deixar seu apoio.

0017-03 Carregamento de Mapa do Jogo de Arquivo de Texto Plano e Pintura dos Tijolos na Tela

Implementação da Colisão do Jogador com o Muro

# Resumo da Aula de SDL: Colisão do Jogador com o Muro

## Introdução
- O objetivo desta aula é implementar a colisão do jogador com muros em um jogo utilizando SDL (Simple DirectMedia Layer).

## Estrutura do Jogo
- O jogo utiliza um mapa em forma de matriz bidimensional onde:
  - **0** representa o chão (atravessável).
  - **1** representa o muro (não atravessável).
  
## Implementação da Colisão
1. **Função de Mapeamento**:
   - Após determinar a próxima posição do jogador, a função `mapearCoordenadaParaID` é usada para obter o ID do azulejo na nova posição.
   - A lógica de mapeamento envolve dividir as coordenadas x e y pela largura e altura dos azulejos (32 pixels).

2. **Verificação de Atravessabilidade**:
   - A função `azulejoForAtravessavel` verifica se o ID do azulejo é zero (chão) e retorna `true`. Para qualquer outro ID (incluindo 1, que é o muro), retorna `false`.

3. **Movimento do Jogador**:
   - O movimento do jogador (para cima, baixo, esquerda, e direita) é realizado com base na tecla pressionada.
   - Antes de atualizar a posição do jogador, o código verifica se a nova posição é atravessável.
   - Se for atravessável, a posição do jogador é atualizada.

## Refatoração do Código
- Para melhorar a organização, foi criada uma função chamada `processarEntradaDoJogador`.
- Variáveis globais para a largura e altura da tela, e o tamanho do azulejo foram definidas para evitar hardcoding.

## Enumerações
- Foi introduzido o `enum` para definir o tipo de azulejo de forma mais legível (chão e muro) em vez de usar apenas números.

## Conclusão
- Após implementar e testar as colisões, é possível mover o jogador somente sobre os azulejos que são atravessáveis.
- O código foi organizado e refatorado para facilitar futuras implementações.

## Mensagem Final
- Incentivo aos alunos a deixar comentários, se inscrever no canal e convidá-los para a próxima aula. 

--- 

Esse resumo sintetiza os principais pontos da aula sobre a implementação da colisão do jogador com muros em um jogo utilizando a biblioteca SDL.

E o la pessoal estamos de volta com mais uma aula de Sdl.
Vamos agora aprender como fazer a colisão do jogador com o muro.
Então vamos começar.
Temos aqui o jogo, né?
Então cada azulejo preto é atravessável.
É o chão, nós podemos andar sobre ele.
Agora, o azulejo branco não é atravessável.
O azulejo branco é o muro.
Então nós não podemos pular no muro nesse jogo.
Então ele vai ter que bloquear o jogador, né?
Nós vamos implementar a colisão para poder prevenir o jogador de pular o muro ou atravessar o muro.
Agora a gente pode porque não há colisão.
Mas gostaríamos de prevenir o jogador para somente andar sobre os azulejos pretos.
Então para poder fazer isso, se você lembra, o mapa do jogo é um arquivo de texto.
Então cada azulejo é representado pelo número inteiro.
Zero significa o chão, um significa o muro.
Nós vamos usar esse ID, né?
Esse identificador para poder determinar se a próxima posição do jogador é atravessável ou não.
Vamos criar a função mapear, coordinada para o ID do azulejo.
Isto é, se você tiver dano aqui no mapa e você querer ir para a direita, por exemplo, nesse caso, é um muro.
Então vamos pegar aquela próxima posição.
Vamos mapear essa posição x e y para o ID, né?
Que é aquele próximo azulejo.
Esse ID está dentro daquela array de duas dimensões, que armazena o mapa.
Cada elemento da array tem o ID do azulejo.
Nós vamos mapear a coordenada próxima, coordenada que seria do jogador, se ele atravessasse.
Mapa para o ID.
Vamos verificar se o ID daquele azulejo for atravessável.
Isto é o tipo for chão.
Vamos fazer um enão.
Nós vamos deixar ele passar e o muro não vai poder atravessar.
No final, vamos fazer uma repertorização do código para poder extrair toda aquela lógica da entrada do jogador, das setas.
Para uma função externa para organizar melhor o código.
Então vamos começar aqui.
Eu vou criar uma nova função.
Eu estou no arquivo main.cpp.
Antes da função main, eu vou criar outra função chamada mapA coordenada para ID do azulejo.
Essa função abre parênteses, abre chaves.
Ela vai ter com entrada a próxima posição do jogador.
Eu vou chamar isso, vai ter dentro de um sdli rect, essa estrutura.
Eu vou chamar de posição, essa variável.
E a próxima entrada será a array de duas menções do azulejo.
Lembra?
Azulejo.
Vou chamar de int azulejos.
E tem quantas linhas e quantos colunos?
Linhas será determinada pela altura da tela.
480 dividido por 32 será o quê?
10 vezes 32, 320, 320 mais 160, então 15.
E para elementos colunas, vai ser 640, que é a largura da tela, dividido por 32, que é 20.
Como eu chamo isso agora de azulejo, isso é um detalhe que eu quero falar aqui.
Eu tinha falado azulejo como se fosse tijolos, eu usei o nome tijolos, mas eu quero modificar isso.
Eu não acho que tijolos seja um termo propriado aqui, que eu tinha falado na palavra.
Eu acho que falei errado, né?
Então me desculpe, isso na verdade é azulejos, ou ladrilhos, né?
Então todas as instâncias de tijolos, eu vou substituir com a palavra azulejos.
Azulejos.
Idê do tijolo, idê do azulejo.
Tijolo, codo tijolo será codo azulejo.
E acho que tem também uma variável tamanho do tijolo, a maior do azulejo.
Tá bom?
Deixa eu só adicionar também a saída dessa função.
A saída mapear coordenada para idê do azulejo irá retornar o idê do azulejo naquela posição especificada.
Será um ipint.
Eu salva isso para ver se está funcionando o negócio aqui, depois da refatorização dos nomes de tijolos para azulejos.
Certo, então sem problemas.
Agora vamos aqui, então vamos retornar dessa função, nós vamos pegar o azulejo, né?
E temos que encontrar o elemento em uma certa posição no mapa.
Vamos supor, por exemplo, que eu estou aqui no mapa, né?
Vamos considerar a linha, a primeira.
Então eu estou aqui na segunda linha.
A posição, a segunda linha agora é y32.
Agora, se eu tivesse aqui embaixo, que quisesse, e mais para baixo, né?
Aperta essa seta para baixo.
Isso é o muro.
Qual seria aquela próxima posição daquele muro?
Seria 0, 32, 64, 96.
Y seria 96, né?
Próxima posição.
Y96 e qual é a linha, né?
O índice dessa linha.
Bem, a terceira é a quarta linha, né?
A próxima, se eu fosse para baixo.
A quarta seria índice 4 menos 1, né?
0, 1, 2, 3.
Linha 3.
Então, olha só o que acontece se você pegar essa posição 96, dividir pelo tamanho do azulejo que é 32,
você pega 3, que é o índice da linha.
Então nós vamos pegar a posição y,
dividir pelo tamanho do azulejo que é 32,
eu vou fazer uma variável aqui, 32.
Eu sei que já tem aqui na linha 94, mas você pode modificar isso depois.
Então isso vai lidar,
vai mapear corretamente nessa array, na posição y, na linha, né?
Agora nos resta fazer a coluna, né?
A posição x.
Mesma coisa, tá?
Nesse caso aqui vamos fazer outro exemplo.
Se eu tivesse aqui, né?
Na segunda linha, a terceira coluna.
Como seria?
Bem, se eu quisesse para a direita, né?
Posição próxima para a direita seria linha, seria no caso do x, né?
0, 32, 64, 96.
Olha só, no x, 96.
Qual é a coluna?
Coluna é a quarta, né?
Então 0, 1, 2, 3.
Mesma coisa, né?
Em vez de que o seu linha é coluna aqui.
Então olha só, 96 dividido por 32, 3, que é o número da coluna.
É a mesma coisa, né?
Só muda a posição que agora é que é x,
dividido pelo tamanho do azulejo que é 32.
Então tá aí.
Isso vai mapear a coordenada, coordenado do próximo coordenado, né?
Para o elemento lá na array de azulejos que contém o id para determinar se é o chão ou é o muro.
Vamos testar essa função aqui, eu vou fazer um log de debug.
Logo na hora que você mudar a posição do jogador,
eu vou fazer um debug para realmente ver se está mapeando corretamente.
Então aqui dentro da função principal,
na hora do event type sdl key down,
depois do if else, if else, if else, if.
Vou fazer um log aqui std, 2 pontos.
2 pontos, cout.
Eu vou dizer id da posição do jogador do azulejo, né?
Do azulejo, a posição do jogador.
Vai ser igual a, eu vou chamar a função mapear, coordenado para id do azulejo.
E vou passar com argumento.
Quem?
Posição do jogador, vígula.
Precisamos da...
do azulejo, né?
Nós temos essa variável aqui em cima, se você se lembra, na linha 124.
É uma array de duas dimensões.
E eu vou botar uma kebra de linha, and L.
Vamos ver se realmente está certo.
E o que é que aconteceu? Um erro aqui.
Ah, eu esqueci do namespace do and L, que é std.
Pronto, agora, se eu mover para a direita,
nós esperamos que o id seja zero.
Vamos ver a mensagem zero.
Se eu ir para baixo, o id é 1, correto.
Para a direita é zero, para a direita é 1, para a direita é 1,
para a direita é zero, para a direita é zero, zero, 1, 1.
Para cima é 1, para a esquerda é 1.
Então está corretamente tudo certo, né?
Agora que a gente já tem essa função, nós precisamos verificar
se a próxima posição vai ser um azulejo atravessável, né?
Eu devo lembrar aquilo que eu escrevi aqui, vamos fazer essa função.
O azulejo for atravessável.
Então vamos ver aqui.
Aqui em cima, vamos fazer outra função,
eu vou chamar a função azulejo for atravessável.
E eu vou passar como o parâmetro aqui vai ser o id do azulejo, tá?
Id do azulejo.
A saída vai ser um boleano, então vai ser bo, verdadeiro ou falso?
Se o id for zero, né?
Se o id do azulejo for zero, o que isso significa?
Que é o chão.
O chão você pode atravessar, então return true.
Se não for zero, né?
Else if, você pode até botar falso aqui,
que se não for zero, será qualquer outro valor, será um, dois, três, sem pudeante.
Mas é bom você fazer o else if aqui,
já antecipando que você sabe que no jogo de verdade tem vários tipos de azulejos.
Alguns são atravessáveis, outros não são.
Então por isso que eu tenho vários else if aqui, vários casos,
já vai adicionar o caso específico do azulejo C1, tá?
Nesse caso será falso.
Agora o else, né?
Ou nem pensei digitar else porque já vai bater aqui no final, então opcional.
Ah, você faz aí, eu vou retornar falso, se não conseguir verificar nenhum id reconhecido, né?
Se não reconhecer nenhum id vai ser falso.
Qualquer id que não é reconhecido não vai ser atravessável.
O id atravessável é o zero que é o do chão, o não atravessável é o do muro ou qualquer outro,
que a gente não definiu até agora.
Então se eu for aqui testar essa função aqui embaixo na hora do log, né?
Eu vou botar a sddsc out atravessável, e eu vou botar o valor aqui.
Eu vou dizer como é o nome.
Azulejo for atravessável.
Eu vou botar, na verdade eu preciso pegar o valor que foi retornado pela função,
mas a pia coordenada, então vou botar uma variável chamada de próximo azulejo, né?
Ou id do próximo azulejo, do próximo azulejo.
Será isso?
E eu vou pegar isso, colo aqui onde estava antes da função.
E se for atravessável eu vou passar o id do próximo azulejo, e vou quebrar um linha aqui, sddsc 2 pontos 2 pontos, and L.
Vamos testar isso novamente.
Eu vou andar para a direita, id da posição dos jogadores, o id desse azulejo que eu estou agora é zero, está correto.
O chão é atravessável, um, um significa true, certo? Zero é false.
Então eu vou para baixo agora.
Atravessável não, zero.
Travessável sim, para a direita não, não, zero.
Para baixo sim, para baixo não, não, não é tipo diante.
Então está corretamente implementado.
Agora vamos modificar só um pouquinho essa função para poder usar o chamado INAM.
Vamos criar esse INAM aqui, tipo de azulejo, chão, muro.
Para poder a gente notar que digitar valores numéricos inteiros, porque é difícil para o programador entender o que está acontecendo.
O que é que é zero? Sempre tem que ficar procurando tabela de mapeamento.
A zero é o chão, a um é o muro.
Então para poder ter que fazer isso nós podemos substituir esse valor com uma enumeração.
Você pode criar aqui, posso até botar aqui antes, ou lá em cima.
INAM, vou botar aqui no scopo global para poder usar em outros cantos.
Vamos falar tipo de azulejo.
Vai ser o que? Tem o chão e tem o muro.
Ele começa contando zero, então o chão é zero, o próximo muro é um.
Então na hora que você passar azulejo para o atravessado você pode checar em vez de zero aqui.
Você põe a chão em vez de muro, em vez de um, você põe muro.
E na sua verificação funcionou.
O que é que aconteceu?
Muio 91. Ah, eu acho que eu esqueci do ponto em vírgula.
Eu tinha esquecido do ponto em vírgula na linha 94.
Traveçável, então tudo certo como antes.
Você pode até modificar esse variável que o tipo pode até ser o tipo do INAM, o tipo de azulejo.
Também funciona, né?
Nesse caso, infelonciment, conversion, int, tipo de azulejo.
Você teria que converter na hora que de... Cadê?
De fazer...
Mapir a coordenada teria que converter, né?
Poderia você modificar isso para converter para tipo de azulejo.
Mas ou pode ser na chamada da função, também, cadê a chamada?
Posso converter aqui para tipo de azulejo?
Ah, deixa assim mesmo, tá?
Tá bom, assim.
Outro detalhe, se você quiser seguir a C++11, você pode botar INAM CLASS.
Dessa maneira, você pode dar uma scop aqui para ativo de azulejo, 2 pontos, 2 pontos.
Para não ter que ter essa variável, esteja um em muro independente.
Pode fazer isso também.
Ah, o que aconteceu?
INAM CLASS.
Eu acho que tem que fazer o...
O ID do azulejo tem que ser do tipo de azulejo para isso funcionar.
Eu tenho que fazer o casting aqui.
Então, seria que teria que pegar algo para estar aqui.
Aí, a chamada estaria errada também.
Não pode converter IN, tipo, para o tipo, teria que converter lá.
Enfim, eu deixo como é o exercício para você modificar a sua maneira aí.
Tá bom?
Não ser problemas.
Então, vamos continuar e fazer a implementação da colisão aqui.
Já temos o debug, depois vamos revolver isso, tá?
Deixa aí só para debugar.
Então, na hora das posições aqui, vamos checar o ID do próximo azulejo e tal e tal.
Então, vamos fazer o seguinte, vamos começar indo para direito.
Se eu for para direita, né?
E se estiver ainda na tela, vou fazer o seguinte.
Vou criar um SDL-REC para fazer a nova posição.
E vou copiar os valores de posição jogador.
Agora, pega a nova posição.
O X vai adicionar 32, que está em para direita.
Você vai pegar essa nova posição e passar para o map.a coordenada para o ID do azulejo.
Então, azulejos.
Isso vai ser o ID do próximo azulejo.
Aí você vai checar.
Se o ID do próximo azulejo for atravessável, né?
Azulejo for atravessável.
Você muda a posição.
Se tu é, você vai deixar fazer a posição jogador X, posição jogador X mais 32.
Vamos testar.
Direita, direita, direita, direita, direita, não dá.
Para baixo, para baixo, direita, direita, direita, direita, não dá.
Para cima, direita, direita, direita, direita, não vai para direita, tá?
Tá certo, então.
Mesma coisa para as outras posições.
Se você quiser pausar o vídeo, tentar fazer para o si próprio.
E a gente vai continuar na mesma padrão.
Então, vamos lá.
Para poder fazer indo para baixo, cria um SDR-RECT para a nova posição.
Copie a usuária de posição jogador, igual a posição jogador.
Agora você pega a nova posição.
Nesse caso indo para baixo é o Y, ponto Y mais 32, mais igual a 32.
Então, pega o ID do próximo azulejo.
O próximo azulejo é igual a mapear a coordenada para o ID do azulejo da nova posição e azulejos.
Se o azulejo for atravessável, o ID do próximo azulejo,
você deixa ele mudar de posição sem problemas.
Vamos testar.
Vindo para baixo, baixo, não dá.
Para baixo, baixo, não dá.
A baixo, baixo, não dá.
A baixo, não dá.
Mesma coisa para a esquerda e para o direito.
Vou copiar e colar porque é a mesma coisa.
Deixa eu ver aqui em cima.
Dentro do F, cola na nova posição, indo para a esquerda,
vai ser X menos 32, menos igual a 32.
O próximo azulejo na nova posição, azulejos for atravessável e o do próximo azulejo.
Dentro vai ser a posição X menos 32 do jogador.
Salvar.
Vamos tentar.
I para a esquerda, não vai.
A esquerda ali, não vai.
Para a esquerda ali, não vai.
Certo?
Direita, não vai, a esquerda não vai.
Para baixo, não vai.
Vamos fazer para cima, mesma coisa.
Vou copiar e colar.
Dentro do F, nova posição, posição do jogador.
Indo para cima é Y mais 32,
ID do próximo azulejo, int, mapear para o coordinado na nova posição.
Azulejo, se o azulejo for atravessável, você vai pegar a posição X
e realmente do jogador e tirar 32.
Compilar e rodar.
Vamos lá, tentar ir para cima.
Para cima não dá, para cima não dá, para cima não dá.
Então, cobrimos todas as direções.
Para a esquerda, para a direita, para baixo, para cima.
O muro agora não pode atravessar, está bloqueando a gente.
Vamos ter um código repetido, nós podemos fazer uma repatorização.
Por exemplo, sempre tem SdlE-REC,
SdlE-REC, eu posso extrair esse SdlE-REC para nova posição,
para fora,
para todos, antes do F.
Então, posso tirar para fora.
Tira aqui, linha 175, tira, já está definindo lá fora.
Linha 184 também está definindo lá fora.
Certo?
Vamos pegar extrair agora, pegar isso tudo aqui.
Dentro do key down,
eu vou fazer uma função, vou chamar de processar a entrada do jogador.
Processar a entrada do jogador, vou chamar essa função,
vamos criar lá em cima.
Processar a entrada do jogador, essa função vou colar aqui do que a gente já tinha.
Para poder funcionar, precisamos de key parameters.
Posição do jogador, né?
Jogador, isso é do tipo SdlE-REC.
Como a gente está modificando aqui na linha 115, vamos dar referência.
Vamos passar lá como referência, vou botar o 1%.
Para ele modificar o valor, quando a gente modificar nessa função,
também vai modificar lá fora.
Naquele que chama a função, o scopo vai também ser modificado.
Precisamos de o que mais? Bem, evento.
Vamos pegar o evento também, vou falar SdlE-Event.
Como a gente não modifica o evento, vou deixar assim, para passar para o valor.
A processar a entrada do jogador não retorna nada, vou falar void como valor de retorno.
Vamos ver se funciona assim.
A gente tem que modificar a chamada.
Vá na chamada da função, passa o event e passa a posição do jogador.
E... Ah, também tem que passar o quê?
Azulejos.
Então tem que passar os azulejos, vai ser uma rede duas dimensões, 15 e 20.
Vamos lá, como terceiro, o parâmetro da função para acessar a entrada do jogador.
Azulejos, o tipo vai ser int, antes int azulejos, o shet 15 com shet 20.
E agora, o que é que eu fiz? Errado.
Na função, posição do jogador não foi...
Eu botei do jogador, é posição do jogador.
E o outro vai ser erro, linha 111, pausando a constante.
Eu vou pegar esses constantes de WindowWidth, WindowHeight.
E vou botar lá no escopo global.
Vou aproveitar também pegar o tamanho do azulejo, vou botar no escopo global.
Vou lá em cima.
E vou botar aqui em cima.
Agora ele vai funcionar sem problemas.
Tá bom?
Vamos recapitular o que a gente fez.
Implementamos a colisão com o muro.
Temos o mapa do jogo com cada elemento, isso é representado nesse arquivo de texto.
E nós armazenamos isso em uma array de duas dimensões, linhas e colunas.
Cada elemento tem o inteiro, que é o id do azulejo, zero sendo o chão, um sendo o muro.
Fizemos uma função para mapear as coordenadas x e y, que o jogador iria se mover.
Mover para.
E mapeamos isso com a função mapear a coordenada para id do azulejo.
Função que pega essa próxima posição, S-T-L-E-R-E-T,
pega aquele mapa dos azulejos e mapei a posição para o id usando essa forma.
A linha será de índice e posição y dividido pelo tamanho do azulejo, que é 32.
O coluna seria a posição x dividido pelo tamanho do azulejo, que é também 32.
Notes que estão usando o azulejo depois, diferentes na horizontal e vertical, é só modificar essas variáveis aqui.
Criamos esse enam para a gente falar chão e muro, em vez de zero e um.
Fica mais legal, deixe como exercício se você quiser fazer aquela enam class, para você fazer o escopo do enam.
Para ele não ficar assim sem escopo de tipo de azulejo dos pontos.
Essa função azulejo foi atravessável, pega o id do azulejo e diz, sim ou não, esse azulejo você pode andar.
Se o id for zero, isto é chão, true, e for um, é muro, false.
Se for qualquer outro id que a gente não tem definido, ainda nesse jogo, vai ser não atravessável, false.
Finalmente, refatorizamos tudo nessa função para acessar a entrada do jogador.
Na hora que o jogador bate a tecla lá, cima, direita, para baixo, para esquerda, ele vai verificar, antes de modificar a posição,
verifica se a nova posição, a gente cria nova posição, adiciona para vai lá na nova posição e verifica se o id desse azulejo é atravessável.
Se for o caso, ele vai deixar o cara passar.
Finalmente, eu vou remover essa mensagem do bug, que é a gente verificar se a função está funcionando corretamente.
Então, com isso, por essa aula é só, pessoal, por favor, eu se apoio aí.
Se você gostou do vídeo, deixe o comentário.
Não se esqueça de escrever e até a próxima.


0017-04 Implementação da Colisão do Jogador com o Muro

Azulejos de Entrada e Saída do Labirinto com um Novo Formato do Mapa de Jogo

```markdown
# 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!
```


0017-05 Azulejos de Entrada e Saída do Labirinto com um Novo Formato do Mapa de Jogo

Aprimoramento de Código com a Criação da Classe de Jogo

```markdown
# Resumo da Aula de SDL

## Introdução
Na aula de hoje, o foco é aprimorar o código do jogo, que atualmente está muito concentrado no arquivo `main.cpp`. O objetivo é organizar a lógica em funções e classes, tornando o código mais legível e manutenível.

## Estrutura Atual
- O arquivo `main.cpp` contém a função `main`, que é o ponto de partida do programa.
- Atualmente, a função `main` é responsável por várias tarefas:
  - Inicialização do SDL
  - Criação da janela
  - Configuração do jogo (como azulejos e posição do jogador)
  - Loop do jogo
  
## Objetivos
- Extrair a lógica da função `main` em funções separadas.
- Criar uma classe chamada `Game`, que conterá a lógica do jogo.
- Manter o código inicial simples, sem criar muitas classes.

## Organização do Código
1. **Criação de Arquivos**: Será criado um novo arquivo `jogo.cpp` e um header `jogo.h` para a implementação da classe `Game`.
2. **Organização da Lógica**: A lógica do jogo será divida em funções especiais:
   - Função de inicialização do jogo
   - Função do loop do jogo
   - Função de limpeza (fechamento do programa)
   
## Implementação
- A classe `Game` será implementada com os métodos necessários.
- A primeira função a ser criada será a `iniciar` e sua implementação ocorrerá em `jogo.cpp`.
- A função `criarJanela` será responsável por criar a janela do jogo e avaliar erros usando `SDL_GetError`.

## Exemplos de Funções
- Função `iniciar()`: Inicializa os sistemas SDL.
- Função `criarJanela()`: Cria a janela e a superfície usando SDL.
- Função `desligar()`: Executa a limpeza dos recursos do SDL.

## Compilação e Erros
- A necessidade de incluir os arquivos corretamente é fundamental para evitar erros durante a compilação.
- Erros podem ser causados pela falta de declarações ou inclusão de variáveis.

## Conclusão
A aula terminou com a estrutura do código já começada a ser organizada em métodos e uma classe. Na próxima aula, será dado seguimento ao aprimoramento do código, incluindo a implementação do loop do jogo e mais funções.

```


0017-06 Aprimoramento de Código com a Criação da Classe de Jogo

Término da Implementação da Classe de Jogo

# Resumo da Aula de Programação

## Introdução
A aula se concentra em aprimorar a classe `jogo` a partir do código discutido na aula anterior. O objetivo é organizar e refatorar o código para que seja mais acessível e eficiente.

## Estrutura do Código
- **Variável Azulejos**: 
  - A variável `azulejos`, uma matriz 2D, foi transformada em um membro privado da classe `jogo` para facilitar o acesso em várias funções.
  
- **Posições de Entrada e Saída**: 
  - As variáveis relacionadas às posições de entrada e saída do jogador também foram movidas para a classe como membros privados.
  
- **Construtor**:
  - Um construtor foi adicionado para inicializar as posições de entrada e saída, além do tamanho do azulejo.

## Funções
- **Carregar Mapa**: 
  - A função `carrega-mapa` foi movida para a classe `jogo`, eliminando a necessidade de passar parâmetros que já são acessíveis dentro da classe.

- **Imprimir Mapa**: 
  - A função `imprimir-mapa` também foi convertida em um método da classe `jogo`, removendo a necessidade de parâmetros.

- **Mapa de Jogo**:
  - Uma variável chamada `mapa_de_jogo` foi criada como um membro privado da classe `jogo`.

## Game Loop
- **Rodar**: 
  - Um novo método chamado `rodar` foi adicionado para gerenciar o loop do jogo e processar a entrada do jogador.
  
- **Entrada do Jogador**:
  - A função `processar_entrada_do_jogador` foi modificada para operar com variáveis privadas e não requer mais parâmetros.

## Gerenciamento de Memória
- A discussão sobre possíveis *memory leaks* levou à implementação de liberações de memória adequadas para a superfície do mapa.

## Organização do Código
- **Includes**: 
  - Ajustes foram feitos para os headers colocados nos arquivos apropriados, e *include guards* foram adicionados para prevenir inclusões múltiplas.

## Conclusão
O código foi reformulado para melhorar a clareza e a acessibilidade, assegurando que todas as variáveis relevantes são membros privados da classe, o que simplifica a lógica do jogo. No final, o jogo foi testado e funcionou corretamente, com o jogador podendo interagir no mapa.

## Agradecimentos
A aula foi encerrada com agradecimentos aos participantes e a promessa de continuar com o aprendizado nas próximas aulas.

0017-07 Término da Implementação da Classe de Jogo

Compilação Conveniente do Jogo com o make Através do Makefile

# Resumo da Aula sobre Makefile

## Introdução
Na aula de hoje, aprendemos a criar um Makefile para facilitar o processo de compilação usando o comando `make`. O objetivo é simplificar a compilação de programas que têm múltiplos arquivos fonte e dependências.

## Compilação Sem Makefile
- A compilação manual de cada arquivo CPP usando `g++` requer listar todos os arquivos e bibliotecas, o que se torna inviável em projetos grandes.
- O comando `make` facilitará a recompilação apenas dos arquivos que mudaram, economizando tempo.

## Estrutura do Makefile
- O Makefile consiste em definir alvos, que são seguidos de pré-requisitos e comandos a serem executados.
  
### Exemplos de Comandos e Estrutura
```makefile
labirinto: main.o jogo.o
	g++ -o labirinto main.o jogo.o -lSDL2

main.o: main.cpp
	g++ -c main.cpp

jogo.o: jogo.cpp
	g++ -c jogo.cpp
```

## Benefícios do Makefile
- Apenas recompila os arquivos que foram modificados, ao invés de compilar todos os arquivos do zero, economizando tempo e recursos.

## Organização do Projeto
- Para melhor organização, o executável e arquivos de objeto foram movidos para uma pasta `build`.
- Um alvo `build` é criado para gerar a pasta, se ela não existir.

### Estrutura Final do Makefile
```makefile
build: 
	mkdir build

labirinto: build/labirinto

build/labirinto: build/main.o build/jogo.o
	g++ -o build/labirinto build/main.o build/jogo.o -lSDL2

build/main.o: main.cpp
	g++ -c main.cpp -o build/main.o

build/jogo.o: jogo.cpp
	g++ -c jogo.cpp -o build/jogo.o
```

## Copiando Arquivos Necessários
- Para que o programa funcione corretamente, foi desenvolvido um alvo para copiar o arquivo `mapa_do_jogo.txt` para a pasta `build`.

### Comando para Copiar o Mapa
```makefile
build/mapa_do_jogo: mapa_do_jogo.txt
	cp mapa_do_jogo.txt build/mapa_do_jogo.txt
```

## Considerações Finais
- Aprendemos como construir um Makefile que organiza a compilação de um projeto em C++.
- O uso de Makefile separa o código-fonte dos arquivos compilados e executáveis, tornando a estrutura do projeto mais limpa.
- Sugestões para melhorias incluem a criação de uma pasta `src` para os arquivos fonte.

Agradecemos pela participação e até a próxima aula!

Olá pessoal, estamos de volta com mais uma aula, vamos aprender a criar um makefile
para poder facilitar o comando de compilação.
Então você vê que toda hora que eu tenho que compilar aqui no meu caso eu compilo
o programa na linha de comando com o G++, que é parte do GNU Compiler Collection, GCC.
Você note que para cada arquivo CPP eu tenho que adicionar essa lista aqui, tenho que fazer os link,
o link, o linkar com a opção, né?
E finalmente ele gera o arquivo A.out.
Bem, o nosso projeto é bem curto, bem pequeno, mas ao longo do tempo quando você tem uma coisa
que realmente está na improdução, né?
O projeto normalmente é grande, muitos arquivos, muitas bibliotecas para linkar e tal e tal.
Então fica muito inconveniente toda vez que eu ter que rodar o comando e ter que listar todos os arquivos
e todas as bibliotecas para linkar.
É claro que eu estou usando, porque isso vai facilitar para mim porque eu estou usando a linha de comando.
É claro que você pode usar o build system da sua IDE e tal e tal, mas no meu caso como eu estou
deixando, eu deixo tudo simples e uso a linha de comando, eu vou usar o comando make e através do makefile
ele vai detectar se houve alguma mudança nos arquivos e vai recompilar de acordo com aquelas mudanças.
Então o benefício do makefile vai ser que a gente vai determinar como os arquivos serão gerados
e o make vai detectar também se, por exemplo, você compilou tudo de uma vez, aí você só mudou um arquivo.
Na maneira que eu estou fazendo agora, sempre eu tenho que recompilar tudo do zero, né?
Mas isso num projeto realmente grande demora para caramba.
Então o make vai detectar, opa, você só mudou esse arquivo aqui, então eu só vou recompilar esse arquivo.
Todos os outros arquivos de objetos já foram gerados e não há mudança.
Tudo que eu tenho que fazer é regenerar o arquivo principal, o programa, o executável.
Vamos lá, vamos começar aqui.
Eu vou criar um arquivo chamado makefile, primeira leita que vai usc-lo.
Agora a maneira que o makefile funciona é o seguinte, você tem que definir o alvo, tá?
Seguir de dois pontos, seguido dos pré-requisitos.
Aí de baixo você põe uma tab e o comando para poder você gerar esse alvo.
Note que não é a espécie de tab, tá?
Então o alvo vai ser o que a gente precisa, né?
Para poder fazer o nosso processo aqui de compilação.
Bem, o alvo principal é o que? É o programa, né? O programa final executável.
Então para isso eu vou dar um nome, por exemplo, eu posso chamar de labirinto.
Esse vai ser o alvo.
Mas para poder eu criar o labirinto vai fazer o quê?
Bem, tem uns pré-requisitos, né? Precisa de umas coisas.
Mas antes disso eu só vou dar o comando aqui para você ver o equivalente.
Então eu tenho o comando aqui no lado esquerdo, que é o do terminal g++, main.cpp, jogo.cpp, praço sdli2, né?
Isso vai gerar o executável, tá?
Bem, então ele depende do arquivo main e depende da existência também do arquivo jogo, tá?
Então os pré-requisitos aqui do labirinto será o quê?
Será o main e o jogo, mas não é o arquivo de código fonte, vai ser o arquivo de objeto, tá?
Então quando a gente compila alguma coisa, ele gera o arquivo .o, que é o objeto, né?
E com esse objeto a gente pega todos os objetos e linka, né?
Para poder gerar o executável.
Então para esse processo aqui do makefile funcionar direitinho a gente vai, em vez de compilar tudo de uma vez assim,
para o executável a gente vai separar em partes e vai compilar o arquivo de objeto para cada arquivo cpp, tá?
Então na verdade aqui a gente vai precisar com o pré-requisito main.o e o jogo.o, que serão os arquivos de objetos e nós iremos gerar.
Então para cada pré-requisito aqui você tem que definir outro, outra entrada de algo, né?
No caso o main.o dois pontos, esse é o alvo, corresponde a esse aqui, tá?
Então para o main.o pré-requisito é que o arquivo main.cpp exista, tá?
Então a existência do main.cpp é o pré-requisito.
Mas como é que gera o main.o?
Para poder gerar isso você tem que compilar com o g mais mais, no meu caso.
O main.cpp, mas o problema aqui é que para poder nomear dessa maneira aqui e não compilar para executar você tem que usar a opção traça c, tá?
Só para gerar o arquivo de objeto.
A mesma coisa aqui para o jogo, o jogo.o depende do que?
Do jogo.cpp existir para poder gerar o jogo.aj mais mais para c, o jogo.cpp.
Eu estou pensando aqui, não sei se ele vai gerar o arquivo de objeto já baseado no nome ou se eu tenho que especificar com a opção traço o.
Isso que eu estou pensando agora, eu vou ver, vamos ver, tá?
Então...
Deixa eu ver o negócio aqui.
Isso é esse então, vamos ver aqui.
Eu vou fechar aqui e vou salvar o makefile.
Deixa eu só ver se eu não esqueci nada, main.o, jogo.o, g mais mais.
Então eu esqueci o nome aqui do executável, eu vou botar traço o labirinto para, em vez de criar a.out, ele vai nomear labirinto que é realmente o nome do alvo, tá?
Vamos lá.
E em vez de cpp, tá certo?
Como a gente criou os arquivos de objeto, a gente vai usar o main.o e o jogo.o, tá?
Agora eu vou dar só falar make na linha de comando aqui no lado esquerdo.
Deixa eu ver se ele realmente criou.
Então, você vê que o make executou o comando g mais mais traço c, main.cpp gerou o arquivo main.o que está aqui.
Depois fez o g mais mais traço c, jogo.cpp gerou o jogo.o que está aqui.
E finalmente ele gerou o alvo principal que é o labirinto g mais mais traço o labirinto, main.o, jogo.o, traço l, sdl2.
E você não haja que apareça aqui o labirinto, o executável de cpp.barra labirinto, labirinto, ele é executa o jogo, tá?
Tá bom?
Então o que acontece aqui?
Então você define o alvo principal chamado labirinto que vai ser o nome do executável que será gerado.
Ele depende de duas coisas, depende do main.o existe e do jogo.o existe.
Bem, antes de executar esse comando aqui debaixo, ele primeiro vai ver e vai resolver essa dependência do main.o.
Então vamos lá para o alvo do main.o.o, linha 4, main.o para poder você gerar o main.o.o.
Como é que faz?
Primeiro precisa da existência dependência do arquivo main.cpp.
Então já existe?
Sim.
Então tudo certo, vamos executar o comando, ele roda os g++, traço c, main.cpp e ele gera o arquivo main.o.
Então nem precisa usar o traço o que ele automaticamente deduz o nome do arquivo de saída que é main.o, né?
É baseado no nome antes do cpp.
Então fez isso, note que é o primeiro comando aqui na linha de comando.
Depois que fizer isso ele volta lá para a lista de dependências do labirinto.
Agora vai para o jogo.o que é a segunda dependência.
Então vamos resolver essa dependência, vamos lá para a linha de alvo do jogo.o.
Então o jogo.o depende do arquivo jogo.cpp existir.
Já existe?
Sim.
Tudo certo, então vamos rodar o comando, você note que o comando roda como o segundo comando na...
Aqui no terminal.
Depois que fazer isso ele vai gerar o arquivo jogo.o.
Então as dependências do labirinto, desses alvos já estão satisfeitas, esses dois arquivos agora existem.
Então ele finalmente executa o comando g++, traço o labirinto, main.o, jogo.o, traço lsdl2.
E isso vai gerar que ele executa o chamado labirinto e vai por fim terminar o processo.
Agora quando eu tinha falado, por exemplo, se eu mudar alguma coisa no main.cpp, por exemplo,
eu vou adicionar um negócio aqui.
Olha que o que acontece se eu dar makef novo.
Você note que ele só rodou dois comandos, vez de três, né?
Isso porque ele nota que, opa, você só modificou o arquivo main.cpp.
O arquivo jogo.cpp não foi modificado, então eu vou usar aquilo que já tinha gerado antes,
para poder economizar tempo, né?
Então com isso vai ser muito tempo economizado quando você tem um projeto grande com vários arquivos.
Se eu até rodar o makef de novo, você vê que ele já fala que o labirinto já está mais atualizado.
Isso é, nem precisou compilar nada porque ele já fez a compilação, então ele detecta isso.
Detecta que já fez compilação e não há nenhuma mudança no código ponte para poder começar o processo de compilação de novo, tá?
Então eu vou reverter esse comentário.
Então está tudo certo, tudo legal, mas está muita coisa aqui, muita tralha no mesmo direitório do código ponte, né?
Então normalmente a gente separa esses arquivos compilados do próprio código ponte, né?
Então normalmente é parte chamada build, ordist, qualquer nome aí.
Então para poder fazer isso eu vou fazer o seguinte, no makefile aqui eu quero criar uma parte chamada build.
E dentro dessa pasta eu vou colocar todos os arquivos de objeto e o executável.
Então como fazer isso? Bem, deixa eu só remover os arquivos aqui para você ver o negócio.
Então vou remover todos os arquivos.o e vou remover o labirinto que é o executável e o a.out.
Então só temos o código ponte.
Tá bom?
Agora vamos ver aqui.
Então mais uma coisa que eu quero fazer.
Então o labirinto, em vez de ser na mesma pasta, eu vou botar aqui build barra, tá?
Então vai ser um arquivo que vai parecer dentro da pasta build.
Agora build não existe ainda, então eu preciso fazer uma dependência aqui chamada build, tá?
Então essa dependência do build, primeiro você adiciona o alvo aqui, build, como é que...
O que é que build depende?
Bem, o build depende na verdade nada, porque não existe ainda.
Então para poder criar o build você vai fazer o comando para criar a pasta, que é o mkdir...
dir, né? mkdir, makedir...
build.
Então quando ele bate aqui no build bar labirinto, ele vai, primeiro, resolver a dependência do build,
vai bater aqui no build, vai rodar o comando para criar a pasta.
Pronto, vai criar a pasta e já existe.
Aí ele vai para o próximo.
Bem, no próximo eu quero modificar isso, né?
Eu não quero mais no mesmo diretor, então vou botar buildbarra main.o e buildbarra jogo.o.
E para resolver essas dependências você vai lá e modifica o nome, que é o alvo mudou, né?
Mudou para buildbarra main.o e mudou buildbarra jogo.o.
Agora vamos ver aqui.
Bem, o diretório presente tem main.cpp, então tá certo.
g++, tá certo, tudo certo.
Agora eu acho que tem um detalhe aqui.
Eu não sei se ele vai criar na mesma pasta ou no build.
Eu acho que a gente vai precisar usar o traço.o.
Mas vamos ver já já.
Voltando aqui na dependência, tem um comando.
Bem, o comando vai gerar o executava agora no build barra labirinto, tá?
E o main.o e o jogo.o tá dentro do build barra main.o e buildbarra jogo.o.
Agora o negócio aqui que eu acho que não vai dar certo é o que a gente vai precisar do traço.o
aqui nas linhas 8 e 11.
Vamos ver.
Eu vou dizer a e-mail aqui no terminal.
A você note que ele já gerou o main.o e o jogo.o na mesma pasta que tá errado, né?
Então por isso que eu tinha falado antes.
Então vou remover esses caras.o e vou modificar aqui e vou adicionar o traço.o buildbarra main.o.
E no mesmo comando para poder criar o buildbarra jogo.o.
Eu vou botar traço.o, output, né?
Build barra jogo.o.
Por isso eu vou rodar a make de novo e você note que ele primeiro gerou o buildbarra main.o
depois gerou o jogo ou buildbarra jogo.o.
Finalmente ele rodou o comando para gerar o executava labirinto na pasta build.
Então tá tudo legal se eu rodar o buildbarra labirinto aqui.
Ele funciona direitinho, tá?
Ah, só um detalhe aqui que você pode ter problema.
Se eu mudar direitório para pasta build e rodar o labirinto eu acho que vai ter problema no mapa, tá?
E é, como eu tinha esperado.
O problema é porque quando eu estava na pasta terrio de cima, o mapa do jogo estava aqui, né?
Aí na hora do programa lá de rodar no jogo.cpp você note que quando ele carrega o mapa
ele carrega do pasta, mesmo pasta que o executava estar, tá?
Então esse é um problema e você vai ter.
Então para poder consertar isso você pode fazer uma maneira aqui.
Você pode copiar o arquivo mapa do jogo para a pasta build.
Que vai ser uma espécie de compilação, mas a verdade é só a cópia do arquivo.
Então o buildbarra labirinto também vai depender do mapa do jogo.txt.
E aí você adiciona aqui embaixo o alvo mapa do jogo, dois pontos para a requisição do arquivo, né?
Existir, tá?
Na verdade eu errei, desculpa, eu tenho que botar buildbarra mapa do jogo, né?
Porque isso que vai ser o gerado e esse alvo buildbarra mapa do jogo, ele vai depender do quê?
Vai depender de a existência do arquivo mapa do jogo.txt na pasta-raiz do projeto, tá?
Você vai rodar um meio que da pasta-raiz, tá certo?
Detalhe.
Para poder gerar essa arquiva é simples, é só copiar o arquivo.
Então eu vou dar cpmapadojogo.txt no para destino buildbarramapadojogo.txt.
Bem simples.
Tá? Então vamos dar um make-new e ver como é que dá.
Ah, eu estou na pasta-raiz, não tem que dar o cd.ponto para voltar para a pasta-raiz do projeto e falar a mente.
Você note que agora tem a parte do mapa do jogo dentro do mesmo executável do labirinto, né?
Então se eu cd para o build e rodar.barra labirinto, ele não vai ter mais esse problema, tá?
Mas vou te dizer um negócio, se eu cd barra barra, se eu cd 2.2.pontos e dar o build barra labirinto aqui e eu tivesse,
se eu remover o mapa do jogo aqui, a pasta-raiz também vai dar problema, né?
Porque ele sempre vai ver de que pasta você rodou o programa.
Da parte que você rodou o programa, na verdade, é que ele vai pegar o arquivo.
Por isso que esse caminho aqui relativo é meio problemático, tá?
Então deixa aí como uma péssica, para você ver se pode melhorar isso,
porque pode dar problema se você rodar de uma pasta diferente.
Tá bom?
Então deixa eu reverter aqui.
Pronto.
Pronto.
Então makefile.
Tá bom?
Então vamos avisar o que a gente fez nessa aula.
Nós aprendemos a fazer o makefile para poder usar o prédio.
Tá bom?
Então vamos avisar o que a gente fez nessa aula.
Nós aprendemos a fazer o makefile para poder usar o programa make,
para poder facilitar a compilação na linha de comando.
Make você faz a Alvos, que tem pré-requisitos,
e depois de cada pré-requisito ser resolvido, ser...
Ele executa o comando, né?
Então tem sempre Alvo, dois pontos, pré-requisitos,
e na nova linha, depois de um tab,
tem o comando para poder gerar aquele Alvo.
Nós fizemos um Alvo para poder gerar a pasta build,
um Alvo para poder gerar a pasta build.mail.o,
arquivo de objeto.
Fizemos um Alvo para gerar o arquivo build.jogo.o,
e finalmente um Alvo para gerar o arquivo build.mapa.jogo.txt.
E simplesmente copia o mapa do jogo para a pasta build,
que é a pasta executável, né?
Então tudo vai para essa pasta build para a gente poder separar
o que foi compilado, exáctável e tal do próprio código-fonte.
Normalmente, código-fonte também é posto em uma pasta separada
chamada src, por exemplo,
mas eu deixei assim mesmo na pasta raiz.
Se você quiser, pode adicionar a pasta src
para os arquivos código-fonte lá.
Se você fizer isso, você vai ter que mudar
esse makefire para poder botar src
antes de main.cpp, jg.cpp e tal, tá?
Então por essa aula só, muito obrigado por assistir e até a próxima.


0017-08 Compilação Conveniente do Jogo com o make Através do Makefile

Nesta aula aprendemos como escrever um texto na tela do jogo com a biblioteca SDL_ttf.

TTF é uma abreviação para TrueType Font.

No Ubuntu, podemos instalar a biblioteca de desenvolvimento (em outras palavras os arquivos de header de C) com o seguinte comando:

```
sudo apt install libsdl2-ttf-dev
```

Depois da instalação conferimos que o arquivo `SDL_ttf.h` está presente no diretório `/usr/include/SDL2`.

Precisaremos de um arquivo de fonte para poder desenhar um texto na tela do jogo. No caso do Ubuntu, há várias fontes TTF que podemos usar no seguinte diretório:

```
/usr/share/fonts/truetype
```

Configuramos o SDL_ttf da mesma maneira que usamos SDL_Init e SDL_Quit para carregar e descarregar a biblioteca SDL:

```
// Depois de SDL_Init()
TTF_Init()

// Antes de SDL_Quit()
TTF_Quit()
```

`TTF_Init` retorna 0 com êxito ou outro valor não-zero se der erro. A mensagem de erro pode ser obtida da chamada de `TTF_GetError()`.

Consulte a [documentação da biblioteca SDL_ttf](https://www.libsdl.org/projects/docs/SDL_ttf/SDL_ttf_8.html) para mais informações.

Adicionamos `-lSDL2_ttf` para o comando de compilação final com o g++.

Para carregar uma fonte, use `TTF_OpenFont`.

Para gerar uma superfície com o texto desejado, use `TTF_RenderText_Solid`.

Aprendemos a esconder a mensagem do objetivo do jogo depois de 10 segundos com a ajuda da função `SDL_GetTicks()`, que retorna o número de milissegundos desde o carregamento da biblioteca SDL.


Curso de exploração para iniciantes da biblioteca SDL, na linguagem de programação C++. A libsdl é muito usada para o desenvolvimento de jogos. Inclui escrita de um jogo de labirinto com mapa de azulejos (tiles) desenhados na tela. Usa o SDL2.


Como Usar SDL2 TTF Para Carregar Fonte e Escrever Texto na Tela do Jogo

# Resumo da Aula sobre SDL TTF

## Introdução
- A aula aborda como escrever texto na tela de um jogo utilizando a biblioteca SDL TTF.

## Objetivo
- Exibir uma mensagem na tela informando o objetivo do jogo: "Atravessar o labirinto e encontrar a saída."

## Instalação
- Para Ubuntu, instale os headers da biblioteca utilizando o comando:
  ```bash
  sudo apt install libsdl2-ttf-dev
  ```

## Configuração do Projeto
1. Verifique se os headers estão instalados:
   ```bash
   ls /usr/include/SDL2 | grep ttf
   ```
   - O arquivo `SDL_ttf.h` deve estar presente.

2. Escolha uma fonte TrueType (*.ttf) do diretório `/usr/share/fonts` para utilizar no jogo.

## Código
- **Inicialização da SDL TTF**:
  - Inclua a biblioteca TTF no seu código C++.
  - Inicialize a biblioteca com `TTF_Init()` e verifique se ocorreu algum erro.

- **Carregamento da Fonte**:
  - Crie uma variável para armazenar a fonte e carregue-a com:
    ```cpp
    TTF_Font* fonte = TTF_OpenFont("caminho/para/a/fonte.ttf", tamanho);
    ```
  - Verifique erros ao carregar a fonte.

- **Renderização do Texto**:
  - No loop do jogo, renderize o texto usando `TTF_RenderText_Solid`, definindo a cor da fonte.
  - Utilize `SDL_BlitSurface` para desenhar o texto na janela do jogo.

- **Gestão do Tempo**:
  - Comece um timer ao iniciar e utilize `SDL_GetTicks()` para calcular o tempo que passou.
  - Oculte o texto após 10 segundos usando uma flag para controlar a exibição.

## Considerações Finais
- O texto é gerado apenas uma vez, e a limpeza dos recursos (como a superfície de texto) deve ser feita após o loop do jogo para evitar vazamentos de memória.
- Sugestões de melhorias incluem criar um sistema de gerenciamento de mensagens dinâmicas e implementar melhores práticas de código, como separação de lógica de renderização e inicialização.

## Conclusão
- A aula termina com encorajamentos para interação com o conteúdo e sugestões para novos experimentos, como implementação de fadas de mensagens ou melhorias visuais.

---
Agradecemos por assistir e pedimos que deixem seus comentários ou feedback!

0017-09 Como Usar SDL2 TTF Para Carregar Fonte e Escrever Texto na Tela do Jogo

O desafio dessa aula é mostrar uma imagem junto à mensagem inicial do objetivo do jogo. Aprendemos a carregar imagens de formato BMP.

Baixe uma imagem qualquer (ou crie a sua própria) e mude o tamanho da imagem para caber dentro da janela do jogo. No exemplo, a imagem de um menino correndo foi usada. Como a imagem original é grande, reduzimos o tamanho para caber dentro da janela do jogo, que tem dimensões 640x480. Exportamos a imagem no GIMP para o formato BMP para a demonstração. Provavelmente não se usa esse formato na prática comum.

No código, pode-se usar a seguinte função para carregar uma imagem no formato BMP:

```
SDL_Surface* superficieDaImagemInicial = SDL_LoadBMP("correndo.bmp");
```

O argumento para `SDL_LoadBMP` é o caminho para o arquivo. O valor de retorno é um ponteiro para `SDL_Surface`.

Para mais informações sobre a função, acesse o wiki do SDL: https://wiki.libsdl.org/SDL_LoadBMP


Como Carregar e Mostrar uma Imagem BMP no Inicio do Jogo com o SDL 2

# Aula de SDL 2: Carregando e Exibindo Imagens

## Introdução
- O objetivo da aula é ensinar como carregar e exibir imagens na tela do jogo utilizando SDL 2.
- Utilizaremos o formato BMP e a biblioteca SDL_image para carregar outros formatos como JPG e PNG.

## Problema com Caracteres Especiais
- Foi mostrado um problema com a exibição de caracteres acentuados.
- A solução foi alterar a função `TTF_RenderText_Solid` para `TTF_RenderUTF8_Solid`, permitindo a correta renderização dos caracteres.

## Carregamento de Imagem
- Para iniciar, é necessário ter uma imagem que deseja exibir. Exemplo: uma imagem de corrida.
- O formato BMP foi utilizado para a demonstração, pois é suportado nativamente pela SDL.
- O BMP foi convertido de JPG para BMP, já que a SDL não suporta JPG diretamente.
- A imagem deve ser redimensionada usando um editor de imagens (como GIMP) para se adequar ao tamanho desejado.

## Código para Carregar a Imagem
- **Carregando a Imagem**:
  ```cpp
  SDL_Surface* image_surface = SDL_LoadBMP("path/to/image.bmp");
  if (!image_surface) {
      SDL_Log("Erro ao carregar a imagem: %s", SDL_GetError());
      exit(4);
  }
  ```
- A imagem é carregada e um ponteiro para `SDL_Surface` é retornado.

## Exibindo a Imagem na Tela
- A intenção é mostrar a imagem nos primeiros 10 segundos do jogo.
- A imagem deve ser centralizada na tela:
  - Para isso, foi calculado o ponto de origem usando a largura e altura da tela subtraídas pela largura e altura da imagem.
- **Exibindo a Imagem**:
  ```cpp
  SDL_BlitSurface(image_surface, NULL, screen_surface, &dest_rect);
  ```
- `dest_rect` deve ser definido para que a imagem apareça no centro da tela.

## Limpeza de Memória
- Ao final do uso da imagem, é importante liberar a memória alocada:
  ```cpp
  SDL_FreeSurface(image_surface);
  ```

## Conclusão
- A aula ensinou a carregar e exibir uma imagem BMP utilizando SDL 2, além de corrigir problemas com caracteres acentuados.
- Na próxima aula, será abordado como carregar imagens em formatos diferentes, como PNG.

## Próximos Passos
- Preparar para a próxima aula onde se discutirá o carregamento de imagens PNG.

--- 

Fique atento para não criar vazamentos de memória e sempre garantir que todos os recursos utilizados sejam liberados corretamente ao final do programa!

Olá pessoal, bem-vindo a mais uma aula de Sdli 2.
Nesta aula eu vou falar de imagens, de como você carregar uma imagem e mostrar na tela
do jogo essa imagem.
Vamos começar com o formato BNP que já vem carregamento, uma função disponível no
Sdli 2.
Vamos usar biblioteca Sdli e mg para carregar os formatos como JPG e PNG.
Vamos começar primeiro de tudo, deixa eu rodar o jogo para ver onde está.
Temos um mensagem inicial na tela com gente e tal.
Está vendo que o carácter e o ícordaceto estão funcionando, deixa eu te mostrar como
consertar isso bem rapidinho.
Se você pode mostrar onde é que você pode ver a referência.
Se você for em documentação do Sdli ttf e na sessão 3 funções e 3.4 render renderização
a gente está usando render text solid que você lembra aqui no arquivo jogo.cpp na linha
180.
Estamos usando o ttf render text solid e tem um assento, esse carácter não aparece no
codificador de lat 1.
Então a gente vai mudar para o tf8 que tem o assento.
Então para fazer isso só mudar a função, em vez de ser o ttf render text solid basta
usar o ttf render o tf8 solid.
Isso vai consertar o problema do assento não aparecer.
Vamos lá no terminal, vou recompilar e rodar o meu jogo.
Agora o assento aparece, saída, assaída.
O í de saída agora aparece com o assento em vez daquele carácter incorreto.
Vamos continuar na imagem.
Eu quero mostrar uma imagem na tela quando o jogo começa.
Por exemplo, a objetivo é atravessar o labirinto contra a saída e mostrar a imagem de uma
pessoa andando ou correndo no meio da tela.
Então primeiro de tudo você precisa ter um arquivo de uma imagem.
Encontre a imagem que você queira mostrar na tela.
No meu caso quero mostrar alguém correndo.
Por exemplo, fiz uma busca aqui, palavra-chave-run, clipe-art e achei essa imagem e gostei.
Clicando na imagem salvo, só vai imagem como.
Essa imagem está muito grande para mim.
E o formato para eu começar a te demonstrar como fazer o negócio.
O formato dessa imagem era JPD, mas como o CSDL por padrão não dá para rodar JPD, não tem função para isso.
Eu converti para BMP só para te mostrar.
A BMP tem uma função já no Sdl, que é Sdl load BMP.
Mas isso é só para demonstração.
Claro que ninguém vai usar BMP.
BMP, se você olhar o tamanho aqui, comparado BMP, o JPD, por exemplo, a imagem que eu tinha aqui trofé 1.2 megabytes do BMP
é 77.7.
Então ninguém usa BMP para usar PNG ou JPD e tal.
Esse caso aqui no jogo simples.
Está pronto.
Então para eu redimensionar a imagem usando o GIMP, programa de editor de imagens.
Eu abri a imagem, arrasto para a tela, clique em imagem, redimensionar a imagem.
Aí eu coloquei o tamanho que eu queria com as proporções aqui, só mudar eu queria a altura 240, a proporção modificou a largura automaticamente.
É de clicar redimensionar e salvo.
Aí você pode ou salvar ou pode exportar como, botei export as.
Como eu queria é só demonstrar o BMP, eu sabei como o formato aqui BMP, imagem BMP do Windows e clicar exportar.
E ele vai cargar lá o arquivo aqui correndo ponto BMP.
Vai criar esse arquivo.
Tá bom, então vamos lá usar esse load BMP aqui.
Então da mesma maneira que eu carguei aqui, eu pudei fazer da mesma maneira carguei as fontes.
Cargar fontes, carregar imagens.
Eu deveria até fazer algum sistema para armazenar imagens e tal.
Eu vou deixar com exercício se você quiser fazer esse sistema.
Só para demonstração eu vou carregar a imagem mesmo lá no game loop, que é na função rodar da classe jogo.
Então aqui no rodar, para demonstrar mesmo, demonstração, vou criar uma superfície para essa imagem.
Então vamos chamar essa IDL load BMP.
Você passa como string, né?
O caminho do arquivo nesse caso está no mesmo diretor, você vai ver que você corre no ponto BMP.
A fonte vira e vou atribuir a um variável.
Retorna um ponteiro para SdlSurface, vou chamar na superfície da imagem inicial.
De acordo com a documentação que eu tenho no navegador no lado esquerdo da tela,
o Sdl load BMP vai retornar o ponteiro para SdlSurface, ou se houver erro vai ser no.
Retorna no se houver um erro.
Então a gente vai checar se não tiver superfície da imagem inicial,
e se a exclamação da imagem inicial houver erro, vamos fazer mesmo o que a gente fez nos erros de carga.
A gente fazia o SdlLog com a GetError, Exit3.
Então vamos fazer SdlLog, eu vou carregar a imagem para o CentOS.
SdlLog GetError, nesse caso porque o erro vem do SdlLog.
Vamos dar um Exit, vou falar 4.
Vamos logar a imagem e tal e tal, vamos ver se funciona aqui.
Vou deixar isso como não, só para testar.
Então, info erro carrega a imagem, nesse caso não tem nenhum erro,
mas fez alguma coisa, saiu do programa.
Eu vou revertir essa mudança, vou continuar.
Vou lidar com o erro e tal, quando a gente carrega essa superfície,
a gente vai precisar utilizá-la no decorrer do jogo.
No início, se você só vai usar no início,
a gente poderia optimizar para não usar mais depois disso,
mas eu só vou descarregar a imagem no final quando o programa terminar mesmo.
Então vamos lá para o jogo, cadê?
Desligar, na verdade ligar, não, a gente não fez o sistema de imagens,
não tem sistema de imagens, então vamos lá no final de rodar, depois do loop.
Vou dar Sdl de surface para poder deslocar a memória que foi alocada para essa superfície.
Então a superfície da imagem inicial será livre depois do loop,
para não criar a memory leaks.
Pronto, com isso a imagem foi carregada, agora é a hora de a gente mostrar a imagem na tela.
Eu gostaria de mostrar essa imagem só nos primeiros 10 segundos do jogo,
que mostra aquela mensagem de objetivo.
Então vou usar o mesmo timer que eu tenho aqui,
da mensagem de objetivo para poder mostrar essa imagem.
Então no loop aqui, na linha 194 tem o isle dentro da função rodar.
Na parte de mostrar a mensagem de objetivo aqui,
na linha 212f, mostrar mensagem de objetivo, você dá o bleed surface para mostrar aquele texto.
Vou fazer outro bleed surface, dar o bleed surface.
Agora com a superfície da imagem inicial, a vígula, o retângulo de origem.
Nesse caso, queria clarificar aqui o bleed surface, poder não ter mais confusão.
O que significa esses argumentos?
O primeiro é a superfície que a gente quer copiar,
aí a gente vai espécie de pintar em outra sobre outra.
Agora esse source rack, retângulo de origem,
diz aqui na documentação que o retângulo de origem determina o tamanho do retângulo a ser copiado.
Então ele vai, se você tiver a imagem,
se for no, ele vai copiar a imagem toda.
Mas se você determinar o retângulo e você definir o tamanho, largura e altura,
você pode fazer um clipe daquela imagem inteira.
Então você quer copiar só uma parte da imagem, você pode definir nesse source rack.
Agora o source rack é que define o tamanho a ser copiado, não é o destino.
Acho que eu tinha confundido anteriormente aqui quando tinha feito o texto.
Na realmente não importa o quarto argumento que a gente vai ver aqui.
Então vamos pintar na Windows Surface e no quarto argumento que vai ser o
endereço do destino da mensagem, mensagem não, imagem inicial.
Agora o destino da imagem inicial, esse rack a gente vai criar aqui em cima,
vamos aqui da mesma maneira na nova linha 193, a palavra sdli rack,
destino da imagem inicial igual, agora vai ter o x e o y,
vou escrever já, e o largura e altura.
Agora largura e altura que não importa na verdade,
eu tinha confundido aqui, mas isso não importa.
O que diz na documentação aqui, no caso do quarto argumento que é o destino,
ele diz aqui somente a posição do destino é utilizada, isto é o x e o y.
A largura e altura que é width e height são ignoradas.
Então na verdade isso não importa nesse 184, 185.
Quem define esse aqui vai ser o retângulo de origem, o tamanho da imagem.
Quem define a qual parte da imagem vai ser copiada o tamanho de origem.
Agora, no caso de tamanho da imagem, por exemplo, se eu quiser se aumentar a imagem
ou diminuir a imagem, aí não dá na verdade.
Se você quiser diminuir o tamanho da imagem ou aumentar o tamanho da imagem,
aí no meu caso eu tive que usar o Gimp para poder manipular a imagem e salvar em outro tamanho.
Então a biblioteca sdli aqui, nesse caso que a gente está usando sdli no caso do DTF,
nesse caso aqui o bleed surface não vai mudar, manipular a imagem e modificar as suas dimensões
para aumentar o tamanho para ficar a imagem maior ou menor, não tem isso.
Só pode fazer o clip, que é capturar uma sub-parte, uma sub-area da imagem.
Eu estaria de clarificar isso no bleed surface. Agora vamos continuar.
Então queria mostrar essa imagem no meio da tela mesmo.
Como é que eu vou mostrar a imagem no meio da tela?
Eu vei aqui, cadê o jogo?
No meiozinho da tela vai ser como?
Então, destino a que vai determinar onde na superfície da janela,
aqui vai ser pintado. Eu quero no meio mesmo.
No meio, vamos olhar na dimensão X.
Em dimensão X, eu tenho uma variável que tem o tamanho da tela em dimensão X, que é 640,
que é o Window Height, eu sei que é 640,
então para poder colocar no meio vai ser o seguinte,
você pega o 640, divide por 2, que é 320, vai estar aqui bem no meio.
Mas a gente não pode pintar começando do 320, porque aí a imagem vai aparecer mais para o lado direito.
Então a gente tem que diminuir, reduzir pela metade da imagem.
Se você pegar metade da imagem e subtrair esse 320, você vai bater lá no local desejado.
Então, menos o, nesse caso, superfície da imagem inicial,
a traço maior que a W, que é a largura, dividido por 2.
Como a gente pode fatorar aqui, eu posso colocar 640 menos isso, dividido por 2.
E para altura é a mesma coisa, só pegar a altura.
Nesse caso eu posso usar a variável, que é Window Width,
aqui seria 480 para a altura, então 480 dividido por 2,
menos superfície da imagem inicial, traço maior que a H, que é a altura, dividido por 2.
Então posso fatorar, então vai ser o 480 menos a altura da superfície da imagem inicial,
dividido por 2, usa variável por 440, que é Window Width,
H, I, G, HT.
Há 2.0, agora vou lá para ver se eu corre de ponto de vírgula aqui no linha dos S20.
Então vamos ver no que dá isso.
Vamos compilar e rodar.
Está aí o menino correndo aparece nos primeiros 10 segundos do jogo.
Está certo? Mais uma vez aí.
Então vamos revisar aqui, pessoal.
Então...
Para poder carregar a imagem BMP, tinha uma Sdl load BMP, passo o caminho da imagem,
isso retorna o ponteiro para Sdl surface, ou não, se tiver erro,
no caso do erro, a gente checa aqui e lhe dá com o erro.
E depois disso, quando tiver imagem, superfície da imagem,
criamos um retângulo por destino da imagem inicial, que era no meio da tela.
Você pode pegar a largura da tela e dessa largura subtrai a largura da imagem
e dividir por 2 para poder centralizar a posição,
para começar a pintar que vai pegar no centro.
A mesma coisa para a altura.
A altura da tela menos a altura da imagem, isso tudo dividir por 2 para poder centralizar a posição.
E depois disso, no WIF, de mostrar mensagem de objetivo,
enquanto mostrar mensagem de objetivo,
vou ver o verdadeiro, da oblate surface de superfície da imagem inicial,
no para o source rack, destino a window surface,
o retângulo de destino, o endereço de destino da imagem inicial.
E não se esqueça, no final, quando não precisar mais da imagem,
na superfície da imagem, você dá o SDL Free Surface,
um superfície da imagem inicial para não criar nenhum liquid em memória.
Está certo pessoal?
Então, vamos fazer uma pausa aqui e depois eu vou te mostrar como rodar,
cargar imagens de outros formatos como o PNG.
Até mais!


0017-10 Como Carregar e Mostrar uma Imagem BMP no Inicio do Jogo com o SDL 2

Nesta aula aprendemos a carregar imagens de formato que não é BMP, como o JPG, PNG e TIF. Como desafio, temos que mostrar uma imagem de um troféu após o jogador pisar no azulejo de saída do labirinto.

Primeiro instale a biblioteca [SDL_image](https://www.libsdl.org/projects/SDL_image/). No caso do Ubuntu, o seguinte comando pode ser usado:

```
sudo apt install libsdl2-image-dev
```

Use o seguinte include quando tiver que usar as funções da biblioteca:

```
#include <SDL2/SDL_image.h>
```

O seguinte argumento deve ser adicionado ao comando do compilador:

```
-lSDL2_image
```

Primeiro de tudo, acione a biblioteca na função de iniciar o jogo com a função `IMG_Init`. Para mais informações, [veja a documentação](https://www.libsdl.org/projects/SDL_image//docs/SDL_image.html#SEC8).

Também deve-se fechar a biblioteca na função de desligar o jogo: use `IMG_Quit`.

Para carregar uma imagem, use `IMG_Load`. O argumento é o caminho do arquivo. O valor de retorno é um ponteiro para uma superfície: `SDL_Surface*`. Não se esqueça de liberar a memória com o `SDL_FreeSurface` toda vez que alocar memória para uma nova superfície.


Como Carregar Imagens de PNG JPG TIF para Jogo no SDL2 com o SDL Image

# Aula de Sdeli2: Implementando o Game Over

## Introdução
Na aula de hoje, aprendemos a implementar a funcionalidade de game over em um jogo utilizando a biblioteca Sdeli2. Vamos mostrar uma imagem de um troféu quando o jogo terminar.

## Estrutura do Jogo
O jogo termina quando o jogador alcança a saída do labirinto. A saída é identificada por um retângulo vermelho. A posição do jogador será comparada com a posição da saída, e ao se encontrarem, o jogo será encerrado.

## Implementação do Game Over
- Criação de uma variável booleana `acabou` que indica se o jogo terminou.
- Inicialmente, `acabou` é definida como `false`.
- No loop do jogo, após processar a entrada do jogador, verificamos se `acabou` ainda é `false`. Se a posição do jogador coincidir com a da saída, `acabou` se torna `true`.

### Função para Verificar Game Over
A função `jogo_deve_acabar()` retorna `true` se a posição do jogador for igual à posição da saída:

```cpp
bool jogo::deve_acabar() {
    return (posicao_jogador.x == posicao_saida.x && posicao_jogador.y == posicao_saida.y);
}
```

## Prevenção de Movimento Após Game Over
Quando o jogo acaba, não deve processar mais a entrada do jogador. 

```cpp
if (!acabou) {
    processar_entrada_do_jogador();
}
```

## Exibindo a Imagem de Vitória
Adicionamos a exibição de uma imagem de troféu centralizada na tela ao final do jogo.

### Carregando a Imagem
Usaremos a biblioteca `SDL_image` para carregar imagens em formato PNG. Para instalar essa biblioteca no Ubuntu, utilize:

```bash
sudo apt install libsdl2-image-dev
```

### Código para Carregar e Mostrar a Imagem
```cpp
superficie_imagem_final = IMG_Load("trofeu.png");
if (!superficie_imagem_final) {
    SDL_Log("Erro ao carregar imagem: %s", IMG_GetError());
}
```

### Centralizando a Imagem
Para centralizar a imagem, calculamos a posição com base na largura e altura da janela e da imagem:

```cpp
destino_imagem_final.x = (window_width - superficie_imagem_final->w) / 2;
destino_imagem_final.y = (window_height - superficie_imagem_final->h) / 2;
```

## Testando o Jogo
Após as implementações, ao alcançar a saída, a imagem do troféu aparecerá no centro da tela, indicando o final do jogo. A tela não permitirá mais movimentação após o término.

## Conclusão
Estamos finalizando a aula de hoje. Agradecemos a todos que assistiram. Por favor, deixem seu like e se inscrevam no canal para receber notificações de futuras aulas.

Até a próxima!

Olá pessoal, estamos de volta com mais uma aula de Sdeli2.
Vamos continuar, vamos aprender como fazer o game over e mostrar uma imagem de um formato
PMG no final do jogo.
Então o que vai ser esse game over?
O jogo acabou.
Bem, o jogo acaba quando a gente com a outra saída.
O jogo é tudo laberinto, né?
Então eu vou andar até o final, que nesse caso aqui é o retangulo quadradinho com a
cor meio que vermelha.
Quando eu entro, quando eu dar o passo e entrar na saída, eu quero terminar o jogo.
O jogo acabou.
E quando isso acontecer, você não pode mais movimentar.
E uma imagem de um troféu deve aparecer no centro da tela.
Então vamos lidar com a determinação de que o jogo acabou ou não.
Então o jogo acaba quando a posição do jogador bate com a posição da saída do laberinto.
Lembre-se de que se você for no jogo .h, um dos atributos de um objeto de jogo é a
posição saída.
Então temos a posição saída.
Também temos a posição do jogador.
Podemos comparar esse x e y desses dois e se bater, significa que o jogo acabou.
Agora para indicar que o jogo acabou ou não, eu vou criar uma variável.
Então deixa eu adicionar aqui.
Vou criar um bool.
Acabou.
E no jogo, vou fazer cpp.
Quando você iniciar no constructor, o jogo ainda não acabou.
Então vou falar acabou igual a false.
Agora quando você estiver lá no rodar e no game loop, depois de processar a entrada
do jogador, nós vamos checar se o jogo ainda não acabou e se o jogo deve acabar, nós mudamos
a cabo para true.
Então se não acabou ainda e vamos dizer que o jogo deve acabar.
Vou criar essa função de a real.
Eu disse o que é.
Acabou.
Então basicamente é o seguinte, se o jogo acabou false, o jogo ainda não acabou.
A gente vai checar se o jogo deve acabar.
Se o jogo já estiver acabado, acabou vai ser true, esse aqui vai ser false, então
esse f vai ser pular.
Só vai pintar na tela.
Agora o jogo deve acabar.
Deve eu criar essa função.
Essa função retorna bull se o jogo deve acabar.
Isto é, se a posição do jogador for a mesma posição da saída do labirinto.
Vou no jogo .h, deixo eu definir aqui como um membro público, uma função pública,
retorna um bull, o jogo deve acabar sem nenhum argumento.
Vamos definir essa função no arquivo jogo.cpp.
Pode ser que eu coloquei um lugar aqui, deixa eu criar em baixo.
Então vamos lá bull, espaço de jogo, dois pontos, dois pontos, o jogo deve acabar.
Abre parênteses sem nenhum parâmetro.
Abre chaves.
Então o jogo deve acabar se a posição do jogador x foi igual à posição da saída
x e a posição do jogador y foi igual à posição da saída y.
Obviamente nós estamos usando um mapa de azulejo, então nós esperamos que a baixa
da gente checa o x da posição do ponto acima à esquerda do retangulo, nesse caso
quadrado.
Não é movimento livre de mapa livre.
Então o jogo deve acabar se a posição do jogador x foi igual a dois sinais de igual
a dois para comparar, posição saída x e, né, 100%, posição do jogador ponto y igual
ao igual, posição saída y ponto y.
Eu posso retornar sem ter que fazer.
Se essa posição do jogador x foi igual à posição saída x e a posição do jogador
y foi igual à posição saída x, nesse caso vai ser true, então o jogo deve acabar.
Se alguma dessas condições falhar vai tornar fós, então o jogo não deve acabar ainda.
Vamos voltar aqui no processo de entrada do jogador.
Agora eu queria fazer o seguinte, queremos prevenir o jogador de se mover depois que
o jogo acabou.
Então para isso a gente não vai mais processar entrada do jogador se o jogo acabou.
Vamos ver aqui no quit.
Se for quit para sair do jogo, isso a gente pode fazer ainda, a gente só não quer processar
entrada do jogador.
Então eu vou falar se o jogo ainda não acabou eu posso processar entrada do jogador.
Então f, exclamação acabou, processar entrada do jogador.
Enquanto o jogo não acabou eu vou de processar.
Vamos ver se não tem nenhum problema.
Vou compilar e rodar o jogo.
Vou começar a andar.
A gente poderia até prevenir processar enquanto essa mensagem de objetivo aparecesse, mas
não acesse isso para você fazer.
Então quando eu bater na saída, se notes que eu não consigo mais sair, eu estou tentando
apertar na seta para a esquerda, mas ele não movimenta mais.
Então o jogo acabou.
Então aquela flag, aquela flag acabou, se torna o true e a processar entrada do jogador
não é mais chamado.
Agora bem, agora a gente pode mostrar uma imagem.
A gente sabe que quando o jogo acaba a gente deve mostrar a imagem.
Então aqui no blade surface, na sação de blade surface, depois colocar depois de tudo.
Você faz o mapa, o etângulo, quando estiver pintando, pintando, pintando, pintando,
eu quero mostrar aqui fora do if, porque não é parte do mostrar mensagem de objetivo.
Eu vou dar o blade surface da imagem de vitória.
Superfície, eu vou criar essa variável já.
Superfície da imagem, sei lá, final, vamos dizer final, vitória.
Eu quero toda imagem, não.
Não quero parte da imagem.
E vou colar na window surface, pintar na window surface e o endereço de destino da
imagem final que eu vou criar já.
Mas isso não quer que apareça sempre, né?
Se eu colocar essa maneira aqui, sempre vai aparecer no meio do jogo.
Então a gente só vai dar esse blade surface, mostrar a imagem final se o jogo acabou.
Então, se acabou, você vai dar o blade surface e mostrar essa imagem final.
Agora vamos criar essas variáveis.
Depois da imagem inicial, vou criar aqui.
Então a gente vai ter que criar superfície da imagem final e destino da imagem final.
Opa, final de final.
Bem, destino da imagem final é simples.
Fazer um sdare rack como tipo igual, abre as chaves, ponto e vírgula.
Ao destino eu quero que apareça no centro.
Então seria aquela mesma estratégia.
Pega a largura da janela, window if, subtrai a largura da superfície, nesse caso superfície
da imagem final que a gente vai criar já, já.
E pega isso tudo, coloca parentes ao redor, dividir por dois.
Agora, por y, a mesma coisa.
Abre parentes, window height, que é a altura da janela, menos a superfície.
Opa, eu esqueci de dizer superfície da imagem final traço maior que w, que é a largura
da superfície da imagem.
Então no caso da y que seria superfície da imagem final, traço maior que h, que vai
te dar a altura.
Então pega tudo isso, dividir por dois, poder centralizar.
Então não importa o w e o h dessa superfície da imagem final, a gente já sabe que não
é usado.
Inicialmente na hora de colar.
Pronto, agora superfície da imagem final.
Essa aqui que eu queria te mostrar como carregar uma imagem que não seja BNP, por exemplo,
PNG.
Então vou aqui na web, fazer uma busca, por uma imagem de um troféu.
O troféu clipart como a palavra chave.
Se eu gostei dessa primeira imagem, eu cliquei nela e eu salvei essa imagem.
Bem, a imagem é bem grande.
Deixa eu mostrar aqui.
Então troféu, PNG 1.2 megabytes.
Então vou abrir o GIMP e vou arrastar pro GIMP.
Opa, tem que criar, fechar.
Vou fechar tudo, descartar, agora fazer de novo, arrasto lá.
A imagem é bem grande, vou clicar a imagem e redimensionar.
A gente sabe que a altura da minha janela de jogo é 480, vou botar a metade de 240.
Então nesse caso seria 182 por 240.
Então tá bom essa dimensão, esse tamanho da imagem.
Então vou clicar arquivo, eu posso salvar ou poder exportar, salvar a imagem.
Ah, não dá pra salvar o que é o formato do GIMP, então tem que clicar exportar.
Vou clicar sobre escrever troféu, PNG, que ele vai exportar e subscrever.
Pronto.
Então eu redimensionei a imagem, acho que esse tamanho tá bom pro jogo, vai cabê,
vai cabê lá na tela do jogo.
Então com isso agora a gente vai partir pra carregar a imagem no formato PNG, nesse caso.
PNG.
Então a gente vai usar a seguinte, a biblioteca vai ser SDL image.
Tá bom?
Ah, então deixa eu ver aqui.
No meu caso, pra poder instalar isso, SDL image 2.0, eu posso, eu tô usando o bonto,
então deixa eu ver o bonto aqui, qual é o nome do pacote.
Eu acho que o nome vai ser Lebe, SDL 2, traço, IMG, traço deve, alguma coisa assim.
Lebe, SDL 2, IMG.
Deixa eu ver.
Eu acho que vai ser isso.
Não achou.
Ah, SDL 2.
Ah, IMG.
Oh, achei aqui.
Não é IMG, image, image, ok.
Lebe, SDL 2, traço, image, traço deve, ok.
Então deixa eu ver no terminal aqui.
Tudo, apeter, install.
Lebe, SDL 2, traço, image, traço deve.
Ah, vamos lá checar o, o SCR, eh?
Barra include LS, barra o SCR, barra include, barra, SDL 2.
Vou dar o grab, pipe grab, image, tá aqui o arquivo.h.
Ah, então, instalei, né? Biblioteca.
Deixa eu já modificar o linker, se lembra que tem um linker.
Ah, vai aparecer depois, eu depois te mostro, então vamos lá.
Ah, estou aqui na documentação no navegador, do SDL, image, você pode clicar aqui no documentation.
Lebe, SDL, port org, barra projects, barra, SDL, underscore, image.
Ah, aqui tem get insta, ele mostra como instalar e tal e tal, mas o que importa é que vai ter aquele menu lance de init,
se lembra que a gente fez, ah, iniciar.
A gente fez o init do SDL, init do 3F, também vai ter o init do SDL, image.
Então vamos ver como é que faz aqui, clicking, ah, init.
Então ele mostra aqui como é que você faz o init, no documentação, tá?
Ah, similar, né?
Img, underscore, init, aí você tem que passar flags nesse caso, ah,
que tipo de formato você gostaria de poder carregar.
Nesse caso, tem essas flags aqui, img init, opg, img init, png, img init, tif.
Então no caso, o poder é só usar img, underscore, init, underscore, png.
Mas para te mostrar como é que também cai a gljpg, você faz o seguinte, você faz um pipe, né?
Img init, png.
O que é que está acontecendo aqui?
Fazendo o war, operação de lógica, né?
De bit, né?
Lembra, 0 e 1, quando você tem, por exemplo, 0, 1, or, 0, 0, 0.
Quando você vai a sua operação, isso vai dar o quê?
Vem, você começa aí, vamos ver.
O 0 e 1, né?
O primeiro, o carácter aqui, o 0 e 1.
Ou é 0 ou 1, nesse caso na operação de bit, vai ser 1, tá?
Ou no segundo, 1 ou 1 ou 0, vai ser 1.
E no 0, 0 é 0.
0, 0 é 0, né?
Porque o or, a operação or é o seguinte, quando você tem 0 e 1 é 1.
Quando tem 1 e 0 é 1.
Quando tem 0 e 0 é 0.
Quando você tem 1 e 1 é 1, tá?
Tá bom?
Tá bom.
Se você soubesse essas coisas, acumendo você a estudar o sistema binário e operações lógicas, tá?
Nesse caso, or.
Então, se você faz o or, bitwise, aí esse cara vai retornar eles aqui.
Retorna uma bitmask com todas loaders iniciadas, ok, inundado.
Então, para ele comparar se carregou certo ou não, ele faz o and bitwise, que é o...
E compara com as flags, ok?
Então, vamos lá, pegar essas coisas, colocar dentro de uma flags.
Flag é...
Então, você vai unir com flags.
Vamos chamar a int.
Sei lá, vou usar o mesmo nome que eles usaram, inether.
Então, para poder fazer o negócio, é o seguinte, você pega o inether, faz o and bitwise com flags.
E se for diferente, vai ter eu.
O que é que é isso, né?
Vamos supor que o flag seja esse 1, 0, 0.
Tá?
Se eu pegar esse inether e fazer o and com flags, eu espero que seja a mesma coisa, se dessa é.
O que é que é o and, né?
Explicado, hein, você não sabe?
And, vai ser assim.
0 e 0, 0.
0 e 1 é 0.
1 e 0 é 0.
E só é 1 se cobrou os dois 1.
Tá?
Então, meio que o oposto do war, né?
O war só é 0 se dois for os zeros.
E o and só é 1 se os dois for um.
Tá bom, então, nesse caso, você faria, por exemplo, se fosse 1, 1, 0, 0.
Se você pegar 1, 1, 0, 0 e dar o and com flags.
Se fosse o mesmo, né?
Daria no que?
Então, vai 1 e 1 é 1, 1 e 1 é 1, 0 e 0 é 0, 0 e 0 é 0.
Então, darei no mesmo. Então, 1, 1, 0, 0 é igual a 1, 0, 0.
Se for igual, não teve erro.
Se não for igual, aí deu um erro, né?
Isso que acontece aqui.
Se você dá esse and e não for igual as flags que você determinou originalmente, então, teve erro.
Ah, então, vamos lá, vamos fazer aquele meio lance.
Sdl log, não deu certo carregar o sdli image.
Por cento s, naquilo você vai ver img get error, sabe?
Que é a função que é torna o mensagem de error do sdli image.
Eu vou dar o exit 5, sei lá.
Qualquer número aí de parentes 0.
Operações lógicas, sabe?
Esse or, assim, é diferente do duplo, certo?
Se quer, é bit por bit.
Tá?
Ahm...
Pronto, então carregou aqui.
Agora não se esqueça de descarregar lá no desligar.
Como a gente fez o init quando o jogo acabar, né?
O jogo sair, na verdade, o programa sair.
Ah, cadê o...
No função desligado o jogo.
Você vai, antes do tf quit, certo?
Antes, o que a gente fez é que no final do iniciar, então vai ter que ser no começo.
Aqui na hora de desligar.
Img underscore quit.
Ah, então você pode ver na documentação a mesma coisa.
Calvá, então descarrega, descarrega o sdli image.
Agora a gente usou img net para poder usar isso.
Você teria que fazer o include do sdli image.
Lembra o hardware que a gente pegou aqui?
Então você faz pound, include, sdli...
Ah, eu posso usar o menor que, maior que.
sdli2bar sdliandscoreimage.h
Vamos ver como é que eu fiz nos outros.
Ah, tinha que ter tf.
Certo?
Vou botar aqui em cima.
Ah, tá está.
Ele vai dar para o sdli image.
Tá está.
Ele vai dar problema de linker.
Certo, então...
Ah, esqueci de uma coisa.
Perfície.
Eu não terminei de escrever aquela superfície da imagem.
Então vou comentar por enquanto.
E na hora de dar o blitz acabou, vou comentar por enquanto.
Só para poder rodar e ver se não tem problema.
Ah, aqui também no comentar o destino da imagem final.
Por enquanto.
Agora tá, vamos ver o problema.
Referência não definida para img net.
E não é a função desligar.
Vamos jogar o linker aqui.
Vê se não for isso.
Arquivo makefile na função g++, no comando g++,
traço o e tal e tal.
Na hora do traço lsdli2,
traço lsdli2andscore.tf,
adiciona mais um espaço lsdli2,
underscore img.
Aí carrega...
Sem problemas, né?
Traço lsdli2andscore imag.
Ok.
Agora nos resta...
Usar as funções do sdli image.
Então já carreguei o sdli image,
e coloquei as funções de...
Carrega a imagem.
Vai ser parecido com sdli loadBMP.
Eu tá aqui as funções, loading.
3.2 loading.
Automatic loading.
Não tem a função específica,
e tem a função de loading.
Tem a função específica,
e tem a função de automaticamente detectar o formato.
Então eu posso usar essa.
img.sdli2andscore load.
Tá?
Tá aqui o exemplo que mostra.
Então vamos lá.
Anjogo.cpp.
Superfície da imagem final,
igual a img.sdli2andscore load.
E o caminho, nesse caso, vai ser trofel.png.vgla.
O tipo vai ser sdliandscoresurface.
Como a gente usou aqui, a gente já tinha carregado...
Já dava o include lá na linha 3.
Include-qsdli2-sdliandscoreimage.h.
Então pode usar essa função.
Se tiver problema, ele retorna no.
Então, se não tiver superfície da imagem final,
se ponou nesse caso, sdli.log,
erro ao carregar a imagem,
o cento s, não tinha a mesma coisa que eu fiz,
e sabe o que vai ser img.getEr,
em vez de sdli.getEr,
que tinha a superfície da imagem inicial.
Vou dar exit, sei lá.
Vamos dar 4 para associar a imagem, sei lá.
Mesmo eu.
Pronto, não se esqueça de dar o free surface no final,
sempre quando você aloca,
você tem que alocar sdli, free surface,
superfície da imagem final.
Vamos lá,
fez um erro de compilação, correto.
Agora vamos dar o, finalmente,
a sdli.dst na imagem final,
o bleed surface na linha 263.
Vou compilar e rodar o jogo,
vou lá mover o meu jogador até a saída.
Deixa a mensagem inicial,
antes de eu mover,
porque eu botei 10 segundos,
ainda você pode movimentar,
na mesma hora que aparecer a mensagem inicial,
se você quiser, se você come exercício,
você pode prevenir o jogador de fazer algum entrado,
de mover enquanto a mensagem e imagem inicial
estiverem na tela.
É bem similar
à mesma neca de face do acabou.
Então, tá aí, quando você move lá,
não pode mais sair, aparece troféu
no meio da tela, certo?
E note que essa imagem é de png,
é transparente, então,
o fundo do troféu aqui,
mescou mesmo com o que tinha por trás,
que é o mapa com os altos lejos.
Você pode comer exercício,
mostrar uma mensagem de vitória e tal.
Tá bom, pessoal?
Muito obrigado por assistir,
quanto com o seu apoio, por favor,
deixe seu like,
se inscreva no canal,
se quiser receber notificações,
clique naquele sininho, você sabe, né?
Então, por essa é só e até a próxima.
Até a próxima.
