eduardoforca / jogodopinguim Goto Github PK

Alien é um objeto controlado pelo mouse. Ele executa uma sequência de ações, uma a uma, contidas numa fila. Quando um dos botões do mouse é pressionado em determinado ponto da tela, o Alien cria uma ação e a enfileira.

Bullet é um projétil que segue em linha reta após sua criação. Ele recebe vários parâmetros que a entidade atiradora determina, incluindo uma direção (angle), um módulo de velocidade (speed), o dano que ela vai causar, um caminho para seu Sprite, e uma distância máxima a ser percorrida antes que
o projétil “expire” (para que ele não ande pelo mundo infinitamente).

Alterações para comportar TileSet e TileMap no jogo.

• Construtores com inicialização em valores dados e/ou em zero
• Soma/subtração de vetores
• Multiplicação de vetor por escalar
• Magnitude
• Cálculo do vetor normalizado

Um vetor normalizado é um vetor unitário (de magnitude 1) com a mesma direção do vetor original
Matematicamente, podemos demonstrar que, ao dividir os componentes de um vetor pela magnitude dele, obteremos um vetor unitário.

• Distância entre um ponto e outro

Equivalente à magnitude da diferença entre dois vetores

• Inclinação de um vetor em relação ao eixo x

Atente para a diferença entre atan() e atan2()

• Inclinação da reta dada por dois pontos

A diferença entre dois vetores tem a mesma inclinação da reta - note que a ordem na subtração importa!

• Rotação em um determinado ângulo

O algoritmo para tal é baseado em matrizes de rotação:
x’ = x * cosθ - y * sinθ
y’ = y * cosθ + x * sinθ
Note que, para um eixo y positivo para baixo, um ângulo positivo resulta numa rotação no sentido horário.

• Soma de Rect com Vec2
• Obter coordenadas do centro de um retângulo
• Distância entre o centro de dois Rects
• Saber se um ponto está dentro de um Rect
• Sobrecarga de operadores de atribuição, soma, subtração

Independente da perspectiva - primeira pessoa, terceira pessoa, topdown - jogos tentam criar a ilusão de que há um observador na cena, e que vemos o jogo pelos olhos dele.

State é a responsável pela lógica específica do seu jogo. Game conhece
apenas a manipulação do estado do jogo de maneira genérica, e vai chamar
as funções de State sem saber, necessariamente, como ele se comporta.

A classe Sprite encapsula o carregamento e uso de SDL_Textures, o
tipo da SDL que contém uma imagem carregada do disco pronta para ser
renderizada num SDL_Renderer.

Isso ocorre devido ao fato do pinguim ser deletado antes do som terminar de tocar. Solução ainda não encontrada.

É essencial, por mais simples que seja, que uma simulação de física consiga dizer quanto tempo passou desde a última atualização

A classe Game implementa as funções básicas da nossa engine,
incluindo o main game loop, e a inicialização dos subsistemas (no caso, SDL,
SDL_image e SDL_mixer) que precisaremos para outras classes funcionarem.

Nem todo objeto do nosso jogo pode ter seu movimento controlado: Alguns são guiados por AI e tomam decisões em um contexto, e outros seguem regras simples indefinidamente, definidas no seu Update. Minion é o segundo caso, orbitando um GameObject dado até ser deletado.

Sound é quase a mesma classe de Music, mesmo na implementação. As diferenças estão nas funções da Mixer usadas, e no fato de que, diferente das músicas, existem vários canais diferentes para reproduzir sons.

TileMap simula uma matriz tridimensional, representando nosso mapa e suas diversas camadas. Essa matriz contém, em cada posição, um índice de tile no TileSet.

Fizemos um objeto que gira em torno de outro, Minion, mas algo ainda mais interessante é podermos girar objetos em torno de si mesmos. Além disso, é comum querermos manipular a escala de objetos in-game, sem alterar seu sprite. Nossa engine não faz nada disso: vamos implementar!

Vec2 expressa um vetor no R2, que pode tanto representar uma posição no espaço como uma
grandeza. Rect expressa uma posição (canto superior esquerdo do retângulo) e dimensões.

Face é um “inimigo” com uma determinada quantidade de HP.

Os penguins farão um objeto composto por um par de pinguins: Um é o pinguim de baixo, que desliza sobre o gelo (PenguinBody), e o outro é pinguim controlando o canhão montado em cima
(PenguinCannon).

Utlizar Classe Component para fazer a Engine orientada a componentes ao invés de herança.

• Criar Classe Component

• Transformar Sprite em Component

Uma classe de tileset é responsável por armazenar os tiles utilizados na renderização do TileMap. Internamente, os tiles fazem parte de um grande Sprite (img/tileset.png). Quando queremos renderizar um deles, recortamos usando o clip do Sprite.

Nos construtores dos componentes que criaremos nesse trabalho nós iremos setar tudo relacionado ao próprio GameObject. Entretanto, haverão entidades que necessitarão da existência de outros GameObjects (e manter referências a elas). A criação deles não será em seus construtores, mas sim numa nova etapa de execução ao loop do jogo, o Start. E para se manter a referência de forma segura, teremos que deixar unique_ptr para trás e mudarmos para shared_ptr em alguns lugares.

Ao invés de usar uma função como a State::Input, é preferível que haja uma parte na sua engine que leia o estado do input do jogo a cada frame, e que possa ser consultado por interessados.

Para administrar os objetos instanciados no jogo, vamos manter umarray de ponteiros para GOs.

Se você mover a câmera para além do tilemap, pode-se observar um efeito indesejado. A imagem fica repetida sobre um pedaço de si mesma. Isso acontece porquê não estamos limpando o render anterior, na verdade estamos sempre renderizando por cima do frame anterior.

GameObject é um agrupador de lógicas que estarão implementadas em seus componentes.

TileSet tem um mecanismo de reuso de Sprites próprio, mas ainda temos o problema, vindo do trabalho passado, de Faces estarem realocando o mesmo sprite dezenas de vezes na memória. Precisamos de um mecanismo que mantenha registradas SDL_Textures que já estão alocadas, e permita que vários objetos as compartilhem.