Video Transcript
Olá pessoal, bem-vindo a mais uma aula de Sdl. Nesta aula vou te ensinar a escrever texto na tela do jogo.
Eu gostaria de fazer o seguinte, vamos colocar na tela do jogo um texto que diz qual é o objetivo do jogo.
Nesse caso vamos colocar na tela o texto objetivo, dois pontos. Atravessar o labirinto e encontrar a saída.
Para poder fazer isso, vou usar uma biblioteca adicional do Sdl que nos permitirá carregar fontes ttf, true type.
Vamos começar. Como o sistema Ubuntu, vou ter que instalar os headers dessa biblioteca.
Então, vou te mostrar aqui no terminal. Eu vou falar suru apt, espaço, install.
E o nome do pacote vai ser live sl2, trasso ttf, trasso dv.
Note que de novos pacotes serão instalados.
Depois de instalar esse pacote pelo apt, vou verificar se realmente tem os arquivos de header de c na pasta barra.
Vou dar um ls no barra usr, barra include, barra sdl2 e vou dar um pipe por grep, pela palavra chave ttf.
E eu encontrei o arquivo sdl underscore ttf.h que é o que a gente vai incluir para poder ter acesso às funções de escrever um texto na tela.
Para poder escrever o texto, precisamos de uma arquiva de fonte.
Como eu uso o sistema Ubuntu, uma distribuição de Linux, tem uma pasta que contém várias fontes que eu posso escolher uma das fontes.
Você tem que achar uma fonte para carregar no programa.
No caso do Ubuntu, tem a pasta de fontes.
Vou pegar o caminho dessa pasta.
No meu caso, o Ubuntu barra usr, barra share, barra fontes.
Tem vários tipos, estou interessado em true type, true type, barra true type.
Tem várias fontes, vou usar openSuns, openSuns e tem vários arquivos.ttf que posso escolher.
Vou escolher o openSuns, traço regular, ttf, quando eu carregar a fonte.
Antes de tudo, precisamos carregar a nova biblioteca no código do jogo.
Da mesma maneira que fizemos, se você for no arquivo jogo.cpp, chamamos a função sdlinit.
Da mesma maneira que vamos fazer o init do ttf.
Eu tenho um referência no website deles.
Se for no website levesdl.org e você fazer um busco ou um buscador,
você pode bater na página, barra project, barra docs, sdlttf,
que tem a documentação do sdli underscore ttf, que é essa biblioteca que acabamos de instalar para poder escrever na tela.
Se você escolhe o formato, o que importa é tipo, funções, init para iniciar e quit.
Você clica aqui, deixa aumentar o texto para você ver melhor.
Ele dá um exemplo de como iniciar e se colocar no quit e como fechar, encerrar no final do programa.
Vamos fazer o seguinte, no caso do init é bem simples.
Se você olhar no documentação, é só chamar init, o valor de torna init, que se for valor não zero,
vai ser erro e, nesse caso, ele imprime na tela a mensagem que é obtida pela chamada de ttf underscore getError.
Vamos ao nosso código.
Como a gente sabe, a função principal, se você lembra main.cpp, cria uma instância de jogo,
chama a função iniciar do objeto jogo, que é essa função de iniciar se a gente olhar no arquivo jogo.cpp.
Na definição da função, chama sdli init.
Depois de chamar sdli init, vamos criar aqui uma nova linha.
Vamos chamar o ttf init.
E esse ttf init retorna valor zero se teve êxito, não teve nenhum problema.
E valor não zero se houve um problema.
Então, se não for zero, da mesma maneira que a gente fez anteriormente,
se chamar ttf init não for zero, vai ter um erro, a gente pode logar sdli log.
Não deu certo iniciar o sdli ttf, dois pontos, espaço por cento s para string.
E como segundo argumento, ttf getError, note que é a mesma padrão.
No caso do sdli init, a gente usa o erro que vem do sdli próprio.
Nesse caso, o erro seria da biblioteca ttf.
Então, a gente usa o prefixo ttf getError como nome da função, chama isso.
E pode fazer saída ou qualquer coisa, como a gente não lida com isso,
vou só botar, sei lá, pret exit 1, se você não se portar, ou 2 para diferenciar do erro.
Você que sabe aí, tá?
Como a gente acabou de usar ttf init, essa função precisa vir de algum lugar.
Da onde é que vem essa função?
Bem, daquela... aquele header que a gente viu aqui, olha aqui no terminal, se lembra?
Na parte do sr, barra include, barra sdli2, tem esse arquivo sdli ttf.h, que é o header,
que a gente vai incluir aqui para poder ter acesso a essa função.
Então, lá em cima vai sonar nova linha 6, include, espaço, abre aspas duplas, sdli...
Ah, nesse caso, você pode usar, em vez de aspa duplas, o menor que, maior que sdli2, barra sdli underscore ttf.h.
Da mesma maneira que a gente fez aqui no jogo .h, dessa maneira aqui.
E o que é que significa essa menor que, maior que? Significa que ele vai olhar o caminho,
barra, o sr, barra include, e como a gente tem a pasta sdli2, é essa aqui,
barra, o nome do arquivo que é essa aqui.
Então, na verdade, isso seria include do barra, o sr, barra include, barra sdli2, barra sdli ttf.h.
Então, o menor que e maior que nos permite não ter que escrever barra, o sr, barra include nesse caso,
que ele já procura lá.
Bem, legal, isso é no início do jogo.
Agora, quando você desligar, se lembra que você volta ao arquivo main.cpp,
no finalzinho lá, antes do return zero, lenha 16, tem o jogo chamado da função jogo.desligar.
Essa definição da função que está dentro do arquivo jogo.cpp,
apenas chama o sdli quit no final, mas antes de chamar o sdli quit, vamos chamar ttf underscore quit.
Tá bom?
Note que é antes do sdli, porque segue a ordem de alocamento, né?
Quando for iniciar primeiro o sdli, depois o ttf init.
Quando for desligar, primeiro foi aquele que foi o último, nesse caso o ttf init, seguido dos anteriores,
sdli init no final sempre.
Então, eu reverso quando for desligar o da ordem.
Vamos salvar o arquivo e eu vou compilar para ver se não houve nenhum problema.
Então, fala make.
O problema aqui é do linkamento, né?
WBoteca, note que no comando de make tem essa opção de barra lsdl2,
se a gente vai precisar de barra l para sdl2 ttf.
Então, eu vou para o arquivo makefile e na linha 2, depois de barra lsdl2,
vou dar espaço, barra lsdl2, eu acho que é underscore ttf.
É, correto.
Eu sei porque ficou cortado o texto ali.
Ah, deixa eu aumentar aqui.
Pronto.
Vou salvar o arquivo, tentar novamente.
.barrabuild, barra labirinto.
O jogo ainda funciona sem problemas.
Então, o ttf, essa biblioteca sdl2, certo?
Foi iniciada, iniciada corretamente no jogo,
quando a gente fechar também vai ser desligada corretamente.
Muito bem.
Agora é hora de a gente primeiro carregar a fonte.
Da mesma maneira que a gente carrega imagens e outras coisas,
recurso de um jogo, a gente carrega as fontes.
Nesse caso, onde é que eu vou pôr?
Vamos ver aqui.
O jogo, eu posso definir a variável para armazenar referência para a fonte,
na classe de jogo.
Isso é uma das opções.
Claro que você pode começar a escrever em qualquer lugar
e depois você aprende qual é o melhor local para pôr,
mas vou colocar lá.
Então, a classe de jogo vai ter uma variável chamada fonte,
se eu adicionar aqui.
No final, nova linha 19,
como um membro privado, atributo privado por padrão.
Eu vou falar ttf fonte, ponteiro, fonte.
Então, o que é que é esse aqui?
O nome da variável é fonte, f-o-n-t.
O tipo vai ser ttf underscore fonte, ponteiro, acho que é isso.
Isso vem lá do sdl underscore ttf.h.
Como eu uso linha 4 aqui,
eu vou pegar do jogo.cpp que eu tinha escrito
e eu posso recortar.
Em vez de pôr no cpp, vou pôr no .h.
Dessa maneira, vai saber da linha 20 aqui.
No cpp vai incluir o jogo e também inclui o sdlt ttf.
Vamos lá de volta para o jogo.cpp,
quando você iniciar,
ele iniciou o sdl,
iniciou o ttf.
Deixa eu voltar aqui no membro do cpp,
então iniciar,
criar a janela, configurar a cor jogador.
Eu posso fazer uma função para carregar as fonte,
se quiser, embora que só tenha um agora,
ou você poderia já colocar no iniciar,
e vamos fazer uma função mesmo.
Então,
se você quiser fazer de um maneira diferente,
sinta-se à vontade.
Depois de iniciar, eu vou falar de jogo,
vou carregar fontes,
eu vou criar essa função, carregar fontes,
na classe jogo, então o jogo.h,
como membro público, uma função,
nova linha aqui 24,
vou carregar fontes.
Claro que só tenho um agora, mas poderia ser vários.
Vamos declarar,
declaramos aqui na linha 24,
vamos definir no arquivo.cpp,
depois da definição de iniciar,
vou falar void,
jogo dos pontos,
carregar fontes,
abre chaves,
então para carregar a fonte,
chamamos de fonte,
tf underscore open font,
o primeiro argumento é o caminho para fonte,
lembra que no meu caso,
o caminho seria o sr,
barra share, barra fontes,
barra drewtype, barra open sons,
barra o nome do arquivo,
então vou colar aqui,
barra,
regla,
pronto, então o segundo argumento,
leve que a v de linha,
o segundo argumento é o tamanho que você quer que essa fonte,
seja, pareça,
eu vou escolher 24, certo?
Se você quiser ter mais informações sobre essa função,
recomendo checar aquele site que eu te mostrei,
de referência,
volta aqui para o topo, funções,
aí você pode procurar open fontes,
na sessão 3.2 dessa versão,
2.0.7 do SLLTTF,
Open font, ele diz aqui,
primeiro argumento, o caminho para o arquivo,
o segundo é o tamanho,
point size,
a carregar as fontes,
baseado em 72dpi,
basicamente se traduz para a altura de pixel,
ele mostra aqui o exemplo de carregar,
como a gente fez.
Pronto, então,
vamos definir a variável fonte que tínhamos declarado lá no jogo.h,
se lembra que o tipo é,
TTF fonte asterisco,
ponteiro para TTF fonte.
É só isso mesmo,
pode ser que haja um erro de carregamento do arquivo,
vamos ver a documentação.
Então, de acordo com a documentação aqui,
ele checa o erro só no f aqui,
talvez, ah, está aqui,
então ele retorna no,
se tiver erro,
então, ele checa, se não for no,
se não existia fonte,
se for no, no que se torna verdadeiro,
ele imprimiu erro.
Então, você pode fazer isso também,
eu deixo a,
gerenciamento, já estão de erros como,
exercício aí para você,
de como você quer organizar os seus erros,
é só fazer o básico aqui mesmo,
vou talvez fechar o programa,
porque se não tiver fonte,
não vai dar certo para ter o jogo.
Então, se não tiver f,
exclamação, fonte,
vamos fazer aquele mesmo lance,
vou dar sdlog,
erro ao carregar a fonte,
2 pontos por cento s,
ttf underscore,
get error,
40 z's,
vou dar o exit, sei lá, 3.
Vamos testar isso,
make,
não houve problema, mas se eu tivesse
removido exclamação,
o que que aconteceria?
make,
então ele fala, se não tivesse isso,
eu carguei a fonte,
é claro que não tem erro,
por isso que não apareceu nada depois de fonte,
mas seria uma mensagem.
Eu estou usando log aqui,
mas realmente não é um info,
seria mais erro,
se você quiser pescar mais sobre
como logar as coisas
de maneira apropriada,
é um bom exercício,
eu não vou fazer isso para
tirar o foco das nossas aulas,
vou reverter o que tinha feito
para testar,
não esqueço da exclamação.
Muito bem, então iniciamos
o ttf,
carregamos a fonte,
agora a gente pode
renderizar o texto,
então vamos aqui,
onde está a parte do
game loop,
vamos carregar a mapa,
imprimir a mapa,
rodar,
então no rodar,
a gente teria que
ter uma superfície
que tem o texto
e colocar a superfície
sobre a janela,
a superfície da janela.
Isso seria no game loop,
antes disso a gente precisaria
dar superfície do texto,
nesse caso
será um texto estático,
então não precisa
colocar essa superfície
dentro do loop,
pode ser fora, porque só vai cargar
gerar essa superfície uma vez
como o texto está estático,
e não vai mudar, não é dinâmico,
então para ter superfície
a gente vai precisar da fonte,
e a cor da fonte,
e um texto,
então vamos aqui,
rodar,
carregar, carregar fontes,
figurar a cor de jogador,
nesse caso seria
figurar a superfície do mapa de jogo,
vou olhar aqui no rodar,
então no rodar,
enquanto não sair,
pega os eventos,
delete o mapa do jogo,
dá o free rack da posição de jogador,
sobre isso eu poderia colocar
o texto,
né,
e o texto,
e o texto,
o texto,
aqui seria o
sdl,
delete surface,
dá superfície de texto,
ah, o que eu chamei
dessas variáveis, só estou pensando
no nome da variável,
Windows surface, o que eu chamei
as superfícies, mapa de jogo,
ok,
volta lá,
então o que que apareceria no game blooper
que seria o glit surface da mensagem,
né, pode ser,
a superfície
da mensagem
de objetivo,
não sei como
nomear, mas ok,
vai de si mesmo,
então
o glit surface é de,
o primeiro argumento é de,
o segundo é o clip,
não vai ter nenhum clip,
não, o terceiro seria
destino,
que seria
superfície da janela, Windows surface,
e o clip do destino, nenhum,
então vai ser não,
vou te ouvir,
ah,
na verdade
seria,
não é não,
porque você não vai colocar na
superfície inteira,
essa é uma parte da superfície da tela,
então a gente vai ter que ter alguma coisa aqui,
né,
destino,
destino
destino da mensagem abiativa,
seria o
ponto,
nesse caso seria o
SDL erect,
destino da mensagem abiativa,
a gente vai para a definir já, já,
de certo, então seria o
endereço,
então a percent
o ecomessão,
então,
claro que a gente vai precisar
desses negócios, então seria o seguinte,
a mensagem apareceria na tela,
constantemente,
mas obviamente,
ah, tenho que recompilar,
tá aqui o jogo,
se a mensagem aparecer aqui,
depois de
desenhar
o mapa, né,
e desenhar o jogador, que se
move,
claro, se a mensagem ficar sempre na
tela, vai ficar no meu
do jogo,
então a gente vai precisar de um mecanismo
para poder parar de
mostrar essa mensagem, né,
a gente pode usar um
timer, né, que, por exemplo,
mostra mensagem
nos primeiros
X,
segundos do jogo,
depois disso, a mensagem
desaparece,
claro que tem outras maneiras, você pode
ter que apertar a tecla,
e tal, e tal, mas para a gente
focar só em aprender
a escrever texto, eu vou
fazer de maneira mais simples, que é
vermelho, vou escrever
depois de um tempo,
tá bom?
então, esse é o objetivo,
certo?
então, vou escrever as corras
tudo aqui, mas a gente vai movimentar
e colocar em outros locais,
então, para poder ter
essa,
esse bleeding da superfície,
vai criar a mensagem de objetivo
para
a tela
janela, em um certo
local da
superfície inteira,
né, a gente vai definir
coordenadas aqui, e o tamanho
já, já, precisa
obviamente da SDL
surface, ponteiro
superfície
da mensagem de objetivo, e essa superfície
será gerada
pela função do
TTF, certo?
então, eu vou chamar a função
TTF underscore render
text underscore solid
primeiro argumento é a
fonte,
TTF fonte, ponteiro
o segundo é
a mensagem, então, colocar o objetivo
dois pontos
atravessar
o labirinto
e encontrar a saída
aí, o terceiro argumento é a cor,
cor
da fonte
agora, eu vou criar a variável da cor da fonte
SDL color
é o tipo
cor da fonte
igual, eu vou usar um
iniciar this track
aqui, eu posso
escolher a cor aí
qualquer, sei lá, vou colocar
vermelho, tá, só pra
aí você pode escolher qualquer cor aí
então, a primeira é red
que é vermelho, 255
é
a segunda é
RGB, red, green, blue
0, verde
0, azul
então, vai ser vermelho
então, eu passo essa variável aqui
ok, ok
ah, como eu
criei
uma superfície
aqui
eu preciso
né
de alocar né
com
SDL free surface
depois de usar, eu usei
até a bleach, depois do bleach
SDL free surface
superfície
da mensagem de objetivo
claro que eu estou fazendo tudo no game loop, mas a gente pode
movimentar isso pra
tornar mais eficiente
só pra ver se funciona
a medida
então, vamos ver o que é que precisa mais aqui
esqueci das coordenadas do destino
mensagem né
vamos estar no
vamos
experimentar, vou colocar qual que é valor
aqui
vamos ver
100, 100, 300
vamos ver o que acontece quando eu mudo esses valores
quatro valores, tá
no meu terminal
vou recompilar
não teve nenhum erro
então, apareceu uma mensagem aqui
objetivo é
atravessar o labirinto, encontrar a saída
tal e tal
então, o que acontece
nesse rack
eu colocar zero aqui nesse primeiro
vamos ver
ok, então zero é o valor x
se você colocar no começo
aqui
eu acho que o segundo vai ser o y
que foi 100
se eu colocar zero
vai lá pro topo, certo?
que você começa do topo, o x
mic
build
então, corretamente eu estou
se eu quiser colocar um 16, 16
pra colocar um espacinho
pode ser
16, 16 é isso
ficou demais, vou colocar 8
8x, 8y
está bem melhor
pronto
essa parte 300, eu acho que é o tamanho
o tamanho, a largura e a altura
por exemplo, se eu colocar
32 de largura
o que acontece
parece que não acontece nada
bem, eu sei que a largura e a altura
vai ser
a gente não sabe, vai depender
da superfície
da mensagem de objeto
de objetivo
o que a gente poderia
pegar essa surface
que o valor de largura e altura
mas
eu deixei pra você
ver aqui, sabe usar
se eu ver aqui
se eu ver as propriedades do surface
vamos lá no wiki
se dela surface
vou colocar
busca
h-i-d-o
ok
só dar um
um print aqui pra ver
debugar
std
c-out
w2p
minuq minuq
a superfície da mensagem de objetivo
vamos ver
não sei se é o traço
maior que aqui nesse caso
que é ponteiro, vamos ver
vamos ver aqui
é ponteiro
eu defini com ponteiro, tem que usar
o traço
maior que
pra acessar o valor
de estruturar
propriedade
então note aqui que ele diz que é
576
de largura e 383 de altura
certo
vamos usar esses valores aqui
vai cortar
aqui
e aqui
vamos tirar
std-out
vou colocar em nova linha
você vê melhor
esquecido
então std-l erect
x é 8
largura
que é o wf
vem da superfície mensagem de objetivo
e altura
o h
vem da superfície mensagem de objetivo
só fazer da somloneira
vai ser mais correto
note que o
o i com
o assento
desse carácter
talvez devido
a codificação
então teria que usar
unicode
tem que ver na argumentação como habilitar isso
deixa aí como exercício
tá
você quiser pesquisar
obviamente
posso tirar o i pra consertar
pra não ficar com aquele a
mas aí você perderia o assento
deixa aí
seria legal
criar um acorde
fundo
para esse objetivo
seria legal
deixa eu começar
você pode criar um separado
talvez eu não sei se tem função
que coloca fundo
no trecho
acho que não
só no ttf biblioteca
acho que não tem
mas uma maneira
seria você criar um
rack
e você desenhar
primeiro aquele rack
e segundo você desenha
o texto sobre
o rack
da mesma maneira que você fez
o fill rack para os azulejos
se lembra
se olhar aqui em algum lugar
o sdl fill rack
a mesma coisa
só fazer o fill rack e você usa
a largura
do superfícimento
do objetivo e altura
talvez adicione uns pontos
a mais para ele poder ter
um padding
um espaço entre o texto e a borda
e essas coisas
é um bom exercício que eu deixo pra você fazer aí
bem legal
agora vamos fazer esse mensagem
depois de certos segundos
para poder fazer isso eu tenho que
gravar o tempo
o tempo inicial
e o tempo que se passou
eu posso ir aqui
é claro que se você tivesse
uma classe de timer
para você gravar o tempo
é muito legal
mas como eu não tenho, vou deixar aqui
a variável de fora
vou usar a função getTix
vou te mostrar do sdl
cadê
se eu for aqui
sdl getTix
não sei se está
tem aqui, bateu na url
então essa função sdl underscore
getTix
pega o número de mili segundos
desde a inicia
iniciamento
da sdl
se lembra sdl init
ele diz quantos mili segundos se passaram
vou usar isso como referência
para
gravar o tempo
está aqui, mostra um exemplo bem legal
o sdl getTix
que gravou e depois de um certo tempo
vamos lá
vamos falar qual tipo aqui
vou voltar lá
o tipo é
uint32
vamos voltar o código
uint32
tempo inicial
sdl underscore
getTix, parênteses
ele vai te dar o tempo inicial
por exemplo, 2,3,4
que é mili segundos
nesse caso seria 1,2,3,4 segundos
ms
vamos ver
o que está a gente esperar
10 segundos
antes de esconder a mensagem
na parte da mensagem
faria o seguinte
se
o tempo inicial
é o que já passou
esse tempo
tem que pegar o tempo
tem que fazer o sdl getTix
de novo
ele te daria o tempo
futuro
e você pega o tempo
que é o atual, menos o tempo
passado que é o tempo inicial
e se esse valor for maior
ou igual a um certo número
é o que já passou
maior
então
se o sdl getTix
deixa eu colocar aqui o int
tt2
tempo agora
sdl getTix
se o tempo agora
é claro que vai ser um valor maior
menos o tempo inicial
que vai dar a diferença
o tempo que passou, em mili segundos
se esse for
certo
maior que 10 mil
que é dividido por mil
é 10 segundos
então a gente vai fazer
a mensagem aparecer
então
eu tenho que ter uma bull
para mostrar a mensagem
por isso é uma boa
bull
mostrar
mensagem de objetivo
true, inicialmente
se o tempo agora é menos que o tempo inicial
por exemplo
se o tempo agora for
sei lá
11
2, 3, 4
ou 2, 3, 5
para ficar maior aqui
menos aquele
seria maior que 10 mil sim
seria
10 mil e um
nesse caso
você vai mostrar a mensagem
vertigo, false, não mostre mais
aqui
esse caso seria só para controlar
os tempos
os timers
que eu separei desse aqui
da desenho
você vai fazer aqui
pegar essa parte daqui
colocar dentro de lá
enquanto estiver menor que eu igual
você mostra
se não
claro que é outra maneira de fazer
mas
normalmente você teria um sistema de timers
e você poderia
criar uma lista de timers
alguma coisa assim
e dessa lista você poderia
verificar se o tempo já passou
para um certo
elemento do jogo
nesse caso o elemento seria a parte
da mensagem de objetivo
essa textura e tal
então eu vou separar aqui
se mostrar
mensagem de objetivo
eu mostro
obviamente a gente teria não só uma coisa
teria várias
elementos do jogo
que a gente queria mostrar
nesse caso a gente poderia converter
essas
construções para algo genérico
para ter uma lista de elementos
ou coisas para você poder
checar os timers
e se o timer já estiver mostrando
você mostra cada objeto
de jogo, nesse caso a mensagem
como a gente só tem um aqui
eu vou deixar
essa maneira simples, mas claro que a gente
poderia introduzir um
sistema de gestão de
objetos de jogo, de timers
e tal e tal e tal
vamos esperar 10 segundos
para ver se realmente
funciona
desapareceu depois das segundos
não existe mais
claro que eu não parei o jogo
com essa mensagem
você poderia adicionar isso também
para o jogo, esperar 10 segundos
aí começa
você pode adicionar a mensagem
de jogo, começa
a jogo, start
uma coisa assim
essas coisas aí
e tal e tal
tá certo, vamos
terminar com a refatorização
para deixar isso menos
pesado aqui
você poderia pegar essa coisa
fonte
como reorganizar isso né
eu não quero ficar criando superfície
todo o tempo, então vou pegar essa
parte aqui e colocar para fora
do loop
são confundindo aqui
o hotkey
para mover
de fora do isle
colocar a fonte
só para ter uma vez
superfície mensagem só para ter uma vez
como eu sempre vou
ter que dar o Blitz
eu não posso
dar o free surface
eu vou colocar esse free surface
depois do loop, terminar
para fora, mais no lado
depois
outra coisa
o rack
nesse caso
o rack sempre, esse valor é constante
o W
do mensagem de objetivo sim
o H do superfície mensagem de objetivo sim
nesse caso
você poderia obviamente fazer
uma animação, seria legal
você fazer esse experimento
colocar mensagem
para ficar mudando de posição
na tela enquanto você espera
seria uma coisa interessante
fazer como exercício
então vou colocar esse para fora
também, mais antes do loop
destino
outra mensagem
e objetivo
o tempo agora sempre
ter que pegar ali, não pode tirar
sempre é dinâmico
deixa estar assim, eu não fiz nenhuma besteira
agora não vai precisar
mais ficar
redefinir nas coisas, cada vez no loop
então fica mais eficiente
e você só vai dar a limpeza
para as pesquisas, depois que o loop do game
terminar
muito bem
então
claro que eu tirei para fora e tal
a gente poderia fazer mais coisas aqui
nesse caso, talvez
colocar
esses valores
como parte de
atributos da classe
uma opção
essa é a superfície também
para a gente limpar
a função de rodar
porque não deve ter
muita coisa dentro
poderia fazer isso
o que mais
como a gente não tem um sistema
estabelecido de
objetos de jogo e tal
seria legal ter
tipo assim
a gente não
tem só uma mensagem
mas pode ter vários tipos
obviamente um jogo vai ter
mensagens dinâmicas
vamos poder
a gente já ter uma maneira de
criar um sistema
vou deixar assim, você quiser
mudar e fazer um excesso
por enquanto vou deixar assim
depois eu posso pensar
repartorizar
para você nessa aula
nesse curso
tá bom então
vamos revisar tudo que a gente fez até agora
a gente mostrou essa mensagem na tela
com os W.tech, SDL
e 2.ttf
como eu uso o Ubuntu, eu instalei com o sudo apt
install
se você se lembra lá
eu comecei
vou mostrar o nome da W.tech
aqui
leve sdl2
tras ttf, tras sudeve
com isso a gente
tem um arquivo
barro sr
barro include
barro sdl2
barro sdl.ttf
.h
podemos dar um include dele aqui
para poder usar
seus
seu código
nesse caso
criamos uma variável ttf
fonte.t para
amazenar a fonte carregada
criamos a função de carregar fonte
lá no jogo
iniciar a gente sempre tem que dar o ttf init
de verifico por eles
ttf get error
vou te dar um mensagem de erro
ttf init retorna 0
se não houver nem o eu
valor diferente 0
se houver
não se esqueça de dar o ttf quit
antes do sdl quit na função de
de ligar
quando a gente carrega as fontes
a gente usa ttf open fonte
caminho da fonte
e o tamanho 24
no meu caso
retorna no
se não
é certo
a gente checa aqui e pega ttf get error
mensagem de erro
lá no game loop a gente criou
uma cor para a fonte
criamos o superfície com o texto
que a gente chama ttf
render tag solid
primeiro argumento a fonte
segundo é a mensagem
a texta
terceiro é a cor da fonte
que é o sdl color
criamos um rack para poder fazer o
glitch depois no game loop
da superfície da mensagem de
objetivo para o destino que é o
windows surface
usando o endereço de
o sdl rack destino da mensagem de
objetivo
que vai colocar em x8
largura
que é da superfície mensagem de
objetivo e altura também
para poder fazer a mensagem desaparecer
depois de 10 segundos
nós gravamos o tempo inicial
com um certo tempo inicial
com sdl get checks
coloca na variável
o valor é de tipo you int
32
no game loop a gente sempre está
verificando o tempo
passar
10 segundos
no caso o tempo agora que a gente
pega na hora do loop
menos o tempo inicial que foi gravado
inicialmente no início do
programa
quando a gente gravou aqui em cima
antes do while
se for mais que 10
isso é 10 segundos que passaram
nesse caso é 10 milis segundos
que se você dividir por 1.000
você pega o número de
segundos que é 10
usamos as flags aqui
eu separei a flag e o
texto para a gente
no futuro se tiver
estabelecido um sistema funcionar
melhor
mais organizado
se a flag
for ativa
você mostra mensagem, se não
nesse caso depois de 10 segundos é
falso então não vai mais fazer o blitz
não se esqueça de dar o sdl
free surface depois de
não precisar mais da
superfície da mensagem de objetivo
nesse caso é depois do
game loop aqui
não se esqueça
mais mais não vai
não tem garbage collection
coleção de lixo
então não vai
se responsabilizar
pelas alocações de memória que você
faz nesse caso a alocação para
uma superfície
vamos ter que fazer
o free surface
então vai ter memory leak
então é isso pessoal
com isso a gente chegou ao fim dessa aula
eu espero que você tenha gostado
e
eu te peço para você
se inscrever
curtir, gostar
da aula do vídeo
deixe comentários
muito obrigado
para assistir e até a próxima
tchau