Como usar nós RayCast2D para detecção de linha de visão em Godot

A detecção de linha de visão adiciona uma camada de complexidade ao seu jogo com um mecanismo que permite que personagens ou objetos percebam o que está ao seu redor. Você pode usar esse recurso para comportamento de IA inimiga, mecânica de visibilidade do jogador, jogabilidade furtiva e muito mais.

No Godot, o nó RayCast2D oferece uma maneira simples e eficiente de obter detecção de linha de visão.

Configurando o jogo Godot

Antes de mergulhar nos nós RayCast2D, configure um ambiente de jogo 2D básico no Godot 4. Crie um jogador personagem que pode se mover usando entradas do teclado e interagir com plataformas.

Primeiro, crie uma cena para o personagem do jogador. Adicione um PersonagemBody2D nó como a raiz da cena. Dentro de PersonagemBody2D, adicione um ColisãoForma2D com formato retangular e Sprite2D para a representação visual do personagem.

O código usado neste artigo está disponível neste Repositório GitHub e é gratuito para você usar sob a licença do MIT.

Aqui está o código GDScript para a movimentação do jogador:

extends CharacterBody2D
var speed = 300
func _physics_process(delta):
 var input_dir = Vector2.ZERO
if Input.is_action_pressed("ui_left"):
 input_dir.x -= 1
if Input.is_action_pressed("ui_right"):
 input_dir.x += 1
if Input.is_action_pressed("ui_up"):
 input_dir.y -= 1
if Input.is_action_pressed("ui_down"):
 input_dir.y += 1
 velocity = input_dir.normalized() * speed
 move_and_collide(velocity * delta)

Agora, crie algumas plataformas para o jogador interagir. Você pode usar Corpo Estático2D nós com formas de colisão apropriadas para representar as plataformas. Organize-os na cena para criar um ambiente de plataforma.

Configurando RayCast2D

Para criar detecção de linha de visão, use o RayCast2D nó. Veja como você pode adicionar um RayCast2D nó usando GDScript:

var raycast: RayCast2D
func _ready():
 raycast = RayCast2D.new()
 add_child(raycast)

Certifique-se de anexar este script ao PersonagemBody2D nó. Este trecho de código cria um novo RayCast2D nó e o anexa como um filho ao personagem do jogador.

Fornecendo feedback visual sobre interação na linha de visão

Agora você pode imprimir uma mensagem sempre que a linha de visão do jogador cruzar com uma plataforma. Lance um raio da posição do jogador na direção do movimento. Se o raio colidir com um objeto, significa que o jogador tem linha de visão para uma plataforma.

Adicione o seguinte código ao mesmo script:

func _physics_process(delta):
#... (previous movement code)
 raycast.target_position = Vector2(100, 0)
if raycast.is_colliding():
 print("Collided with platform!")

Aqui está o resultado:

Expandindo a funcionalidade do RayCast2D

Existem muitos recursos avançados que você pode usar para melhorar significativamente a interatividade e a complexidade do seu jogo.

get_collider()

Usando o get_collider() método, você pode acessar o primeiro objeto interceptado pelo raio. O método retorna nulo se nenhum objeto estiver no caminho do raio. Isso é particularmente útil para identificar o objeto específico para o qual seu jogador tem linha de visão.

if raycast.is_colliding():
 var collided_object = raycast.get_collider()
if collided_object:
 print("You can see:", collided_object.name)

get_collider_rid()

O get_collider_rid() O método pode informar o ID do recurso (RID) do primeiro objeto interceptado:

if raycast.is_colliding():
 var collider_rid = raycast.get_collider_rid()
if !collider_rid.is_valid():
 print("No valid object RID")
else:
 print("Object RID:", collider_rid)

get_collider_shape()

O get_collider_shape() A função retorna o ID da forma do primeiro objeto interceptado ou 0 se nenhuma colisão ocorrer.

if raycast.is_colliding():
 var collider_shape = raycast.get_collider_shape()
if collider_shape == 0:
 print("No valid shape ID")
else:
 print("Shape ID:", collider_shape)

get_collision_normal()

Para entender melhor a interação, get_collision_normal() fornece a normal da forma no ponto de colisão. Nos casos em que o raio começa dentro da forma e hit_from_inside for verdade, o normal retornado será Vetor2(0, 0).

if raycast.is_colliding():
 var collision_normal = raycast.get_collision_normal()
 print("Collision Normal:", collision_normal)

get_collision_point()

Quando o raio intercepta um objeto, get_collision_point() retorna o ponto exato de colisão em coordenadas globais.

if raycast.is_colliding():
 var collision_point = raycast.get_collision_point()
 print("Collision Point:", collision_point)

Usando esses recursos avançados do RayCast2D nó, você pode obter insights críticos sobre as interações entre o raio e os objetos em colisão.

Esses métodos permitem que você colete informações essenciais que podem impactar significativamente a mecânica de jogo, as interações de objetos e o feedback do jogador.

Incluindo recursos adicionais

Além da funcionalidade básica de detecção de linha de visão, você pode aprimorar ainda mais a dinâmica do seu jogo implementando alguns recursos avançados.

Gatilhos de eventos

Em vez de apenas imprimir uma mensagem, você pode acionar eventos específicos no jogo. Por exemplo, revelar caminhos ocultos, ativar mecanismos ou alertar inimigos sobre a presença do jogador pode adicionar profundidade ao seu jogo.

Tratamento Dinâmico de Obstruções

Considere cenários onde os obstáculos podem obstruir a linha de visão. A implementação da detecção dinâmica de obstrução garante que a linha de visão seja atualizada em tempo real à medida que os objetos entram e saem da visão do jogador.

Indicadores visuais personalizados

Em vez de depender apenas de texto, você pode criar indicadores visuais personalizados para destacar a presença de interações na linha de visão. Isso pode envolver mudar a cor do jogador ou objeto sprite, exibir um ícone ou animando elementos relevantes.

Mecânica da Névoa de Guerra

Para jogos focados em estratégia ou exploração, você pode introduzir a mecânica da névoa de guerra. Isto restringe a visão do jogador até que este estabeleça uma linha de visão, revelando gradualmente o mundo do jogo e incentivando a tomada de decisões estratégicas.

Melhores práticas para detecção de linha de visão

Otimizar a detecção da linha de visão é crucial para manter uma experiência de jogo tranquila. Aqui estão algumas práticas recomendadas a serem lembradas.

Frequência de Raycast

Evite realizar raycasts em cada quadro, se não for necessário. Considere verificar a linha de visão apenas quando a posição do jogador ou o ambiente mudar significativamente. Isso ajuda a reduzir cálculos desnecessários.

Comprimento do raio

Equilibre o comprimento do seu raycast. Raios extremamente longos podem afetar o desempenho, então escolha um comprimento que cubra a área necessária enquanto mantém a carga computacional sob controle.

Camadas de colisão

Use camadas de colisão e máscaras para ajustar quais objetos a detecção de linha de visão considera. Isso evita raycasts desnecessários para objetos irrelevantes.

Resultados de cache

Se você estiver executando a mesma detecção de linha de visão para vários objetos ou quadros, considere armazenar os resultados em cache para evitar cálculos redundantes.

Integração em nível de plataforma

Alinhe sua mecânica de detecção de linha de visão com o design de níveis de seu jogo de plataforma. Considere a verticalidade do ambiente, as diferentes alturas da plataforma e possíveis obstáculos que possam obstruir a linha de visão.

Certifique-se de que seu sistema de detecção acomoda essas nuances para criar uma experiência de jogador perfeita e intuitiva.

Tornando os jogos Godot mais envolventes com detecção de linha de visão

A detecção de linha de visão adiciona profundidade e realismo ao seu mundo de jogo. Os jogadores podem criar estratégias, ocultar ou abordar os desafios de maneira diferente com base em sua linha de visão. Essa mecânica pode transformar um jogo de plataforma simples em uma experiência mais envolvente, tornando a jogabilidade mais envolvente e memorável.