Fiquei me perguntando como são feitas colisões em alguns jogos simples de corrida de carros em 3D (especialmente em jogos como Outrun 2 / Motoracer).
Nos jogos clássicos de corrida de carros com ambiente complexo (mundo aberto), acho que isso é feito com uma caixa básica (para o carro) para colisão de avião (para pista, construções e outras coisas). A coisa toda seria otimizada usando algumas caixas delimitadoras (é assim que a colisão é feita em muitos jogos).
Em um jogo como Outrun 2 / Motoracer, a jogabilidade é tão simples que os desenvolvedores talvez não precisem disso e tudo poderia ter sido muito simplificado. Para quem nunca toca, aqui está o que é tão específico:
- O carro / bicicleta está sempre colado na estrada.
- A estrada é sempre do mesmo tamanho e tem uma forma muito simples.
- As únicas possibilidades são seguir essa estrada, não é possível sair da estrada ou entrar em colisão com outra coisa (exceto outros carros / motos, mas não nos importamos).
- Quando você colide com a estrada, uma colisão de arcada muito básica é feita (o carro é simplesmente empurrado para longe dela)
Aqui está como eu acho que a colisão (poderia) ter sido feita:
A pista inteira poderia ser considerada como uma curva gigante em 3D. A partir dessa curva, os polígonos da estrada podem ser gerados (usando os vetores frontal, esquerdo e superior gerados a partir da curva). Outros elementos (como casas, árvores, ...) também podem ser colocados e alinhados usando esse método.
Em seguida, para lidar com as colisões (e desenhar carro):
1) Encontre a posição mais próxima na curva 3d da posição 3d atual do carro. Em outras palavras, transforme a posição do carro 3d na posição da curva mais bege. Cada posição 3d na estrada pode ser considerada um deslocamento ao longo da curva 3d ( t
) + deslocamento lateral ( d
). Verifique a imagem abaixo se ela não estiver clara (este é um exemplo 2d, mas isso se aplica a 3d facilmente).
quando t = 0 carro estiver no início da seção da pista, quando t = 1 carro estiver no final. quando d = -1 ou 1 carro está na fronteira da pista, quando d = 0 carro está no meio da estrada
2) alinhe o carro à estrada usando t
e d
(muito simples: para qualquer valor t
e d
eu posso obter uma posição 3d + vetores para cima / frente / esquerda). o carro agora está colado na estrada
3) verifique o deslocamento lateral d
do carro. se o valor for muito grande (d > 1)
ou se o (d < -1)
carro estiver baixo , estiver fora da pista. basta prendê-lo para colocar o carro no lugar correto.
Isso também torna o abate em 3D muito simples, basta desenhar a pista da t
posição atual do carro para t + some_big_enough_value_to_avoid_visible_clipping
.
Ou talvez eu esteja completamente errado: teria sido muito mais rápido e mais simples verificar a colisão do carro (uma caixa delimitadora) e um conjunto muito simplificado de polígonos que representam a pista (sem os prédios e outros). O mundo 3d (e o modelo de colisão resultante) teria sido simplesmente gerado antes, usando alguma ferramenta de terceiros (sem mais curvas 3d ao executar o jogo, apenas um monte de polígonos).
fonte
No meu piloto OpenGL, eu comecei usando dois círculos para definir as bordas da pista, mas parecia um incômodo demais. Eu apenas uso glReadPixel para ler a cor do pixel. Se o carro do jogador estiver sobre um pixel verde (colorido na grama), o movimento será ainda mais limitado. Há muito pouco efeito no desempenho.
fonte