Como utilizar nós RayCast2D para deteção de linha de visão no Godot

A deteção de linha de visão acrescenta uma camada de complexidade ao seu jogo com um mecanismo que permite que as personagens ou objectos percebam o que os rodeia. Podes utilizar esta funcionalidade para o comportamento da IA inimiga, a mecânica de visibilidade do jogador, a jogabilidade furtiva e muito mais.

No Godot, a implementação da deteção de linha de visão através da utilização do nó RayCast2D é simplificada e engenhosa.

Configurando o jogo Godot

Para começar a trabalhar com os nós RayCast2D no Godot, primeiro é necessário estabelecer um ambiente de jogo bidimensional fundamental. Isto inclui a criação de uma personagem capaz de se mover através da utilização do teclado, bem como a capacidade de a personagem interagir com várias plataformas dentro do mundo do jogo.

Para começar a desenhar a personagem do jogador em Unity, segue estes passos:1. Cria uma Scene vazia clicando com o botão direito do rato na janela Project e seleccionando “Scene”. Dá-lhe um nome como “PlayerCharacter” ou semelhante.2. Arrasta um novo GameObject para o painel Hierarchy dentro desta Scene recém-criada. Com o GameObject raiz selecionado, vá ao painel Inspetor e clique no botão “Add Component” (Adicionar componente) na parte inferior. Na lista de componentes disponíveis, escolhe “CharacterController2D” e clica em “Add”. Este componente é necessário para qualquer movimento de personagem 2D no Unity.4. Em seguida, arraste outro GameObject para o painel Hierarchy a partir do painel Assets. Desta vez, seleccione o pre

O código que o acompanha pode ser acedido através de um repositório GitHub, que serve como uma plataforma de código aberto para os programadores partilharem o seu trabalho com outros. Este conjunto específico de códigos está licenciado ao abrigo dos termos da Licença MIT, concedendo assim aos utilizadores permissão para o utilizarem sem custos.

O código GDScript fornecido refere-se ao Movimento do Jogador, conforme indicado pelo seu título. Contém uma função denominada “move” que parece ser responsável por tratar do movimento da personagem com base na entrada do utilizador e noutros factores, como saltar e trepar. O código também utiliza variáveis, incluindo velocidade horizontal e vertical, aceleração, gravidade e muito mais.

 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)

Para facilitar a interação entre o jogador e o mundo do jogo, é necessário desenvolver uma série de plataformas interactivas no cenário. Estas podem ser construídas utilizando componentes StaticBody2D, que oferecem várias opções para definir a forma do objeto. Ao organizar estes elementos cuidadosamente, podemos criar eficazmente uma experiência de plataformas imersiva para o utilizador.

Configurar o RayCast2D

Para incorporar a deteção de linha de visão no seu projeto utilizando Unity3D e GDScript, siga estes passos para integrar o nó Raycast2D do Godot Engine:

 var raycast: RayCast2D

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

Assegure-se de que afixa este script ao nó

Fornecer feedback visual sobre a interação com a linha de visão

Pode agora gerar uma notificação quando o eixo visual do jogador intersecta uma superfície, lançando um feixe de luz a partir da sua localização atual e apontando-o para a trajetória pretendida. Se este raio atingir uma entidade, isso implica que o jogador é capaz de perceber a plataforma dentro do seu campo de visão.

Incorporar o código acima mencionado no guião existente da seguinte forma:

 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:

Expandir a Funcionalidade do RayCast2D

A utilização de uma pletora de funcionalidades inovadoras é fundamental para elevar o nível de interação e complexidade de um jogo a um nível excecional.

get_collider()

A utilização da função get_collider() permite recuperar a entidade inicial encontrada pelo raio. Se nenhum objeto se encontrar na trajetória do raio, este método devolverá null, o que fornece informações valiosas sobre a ausência de um obstáculo na linha de visão do jogador.

 if raycast.is_colliding():
    var collided_object = raycast.get_collider()

    if collided_object:
        print("You can see:", collided_object.name) 

get_collider_rid()

A função get_collider_rid() permite recuperar o ID do recurso (RID) correspondente ao primeiro objeto colidido num sistema de deteção de colisões, fornecendo informações valiosas para determinar que objectos entraram em contacto durante o jogo ou outras aplicações interactivas.

 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()

A função get_collider_shape() recupera o identificador único associado à forma geométrica do objeto inicial sobreposto, ou zero (0) no caso de não ocorrer uma colisão.

 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 compreender melhor a interação, a utilização da função get_collision_normal() fornece o vetor normal do objeto no ponto de colisão. Quando o raio tem origem no interior da forma e a condição hit_from_inside é satisfeita, a normal devolvida por esta função será representada como uma instância Vector2 com um valor x de zero e um valor y de zero.

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

get_collision_point()

Ao encontrar um objeto com o qual colide, a função get\_collision\_point() determina com precisão o ponto em que a colisão ocorre num sistema de coordenadas definido globalmente.

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

Aproveitando as intrincadas funcionalidades do módulo RayCast2D, é possível adquirir uma compreensão inestimável sobre a interação entre o feixe projetado e as entidades obstrutivas na cena.

A utilização destas técnicas permite a aquisição de dados cruciais que têm o potencial de influenciar grandemente a mecânica do jogo, a interatividade dos objectos e a experiência do utilizador.

Inclusão de funcionalidades adicionais

Para além das capacidades fundamentais de deteção da linha de visão, é possível melhorar os elementos dinâmicos de um jogo através da incorporação de funcionalidades mais avançadas.

Accionadores de eventos

Em vez de simplesmente mostrar uma notificação, é possível iniciar determinadas ocorrências do jogo. Por exemplo, revelar rotas ocultas, ativar máquinas ou notificar os adversários do paradeiro do jogador pode melhorar a experiência de jogo.

Tratamento dinâmico de obstáculos

Para ter em conta as potenciais interferências com a linha de visão, é essencial incorporar um mecanismo para detetar dinamicamente quaisquer obstáculos que possam impedir a receção visual. Deste modo, a linha de visão poderá ajustar-se em tempo real à medida que os objectos entram ou saem do campo de visão do utilizador.

Indicadores visuais personalizados

Para aumentar as indicações textuais tradicionais, é possível desenvolver sinais visuais personalizados que realcem as ligações de linha de visão entre jogadores e objectos. Tais melhorias podem incluir a alteração da tonalidade do sprite de uma personagem ou item, a exibição de uma representação simbólica ou a ativação de componentes animados pertinentes a estas relações.

Mecânicas de Névoa de Guerra

Para melhorar a experiência em jogos de estratégia, recomenda-se a implementação de mecânicas de Névoa de Guerra. Estas mecânicas limitam a visibilidade do jogador até que seja estabelecida uma linha de visão, revelando assim progressivamente o mundo do jogo e promovendo escolhas estratégicas ponderadas.

Melhores práticas para a deteção da linha de visão

A otimização da deteção da linha de visão (LOS) é essencial para garantir uma jogabilidade perfeita, uma vez que ajuda a evitar obstruções e a garantir que os jogadores conseguem ver aquilo com que precisam de interagir ou navegar eficazmente. Seguir estas boas práticas vai ajudá-lo a atingir este objetivo:

Frequência de Raycast

Evite executar raycasts constantemente em cada iteração, a menos que seja absolutamente necessário. Em vez disso, considere examinar a visibilidade apenas quando a localização do jogador ou o cenário sofrerem alterações consideráveis. Ao fazê-lo, pode minimizar os cálculos desnecessários e otimizar o desempenho.

Comprimento do raio

Assegure um desempenho ótimo ajustando a duração do seu raycast para cobrir apenas a região necessária sem causar um cálculo excessivo. Raios excessivamente longos podem afetar negativamente a eficiência, pelo que é importante encontrar um equilíbrio entre a cobertura e a carga computacional.

Collision Layers (Camadas de colisão)

Utilize camadas e máscaras de colisão para refinar o âmbito dos objectos a considerar para a deteção da linha de visão, evitando assim raycasts estranhos dirigidos a entidades insignificantes.

Armazenamento em cache dos resultados

Ao efetuar várias instâncias de análise da linha de vista em vários objectos ou em fotogramas sucessivos, é aconselhável armazenar o resultado numa cache para evitar cálculos desnecessários.

Integração de níveis de plataformas

Assegure-se de que o sistema de deteção da linha de visão do jogo é coerente com o design do nível de plataformas, tendo em conta factores como a verticalidade do ambiente, as diferentes elevações das plataformas e quaisquer possíveis impedimentos à acuidade visual no ambiente.

Assegure-se de que o seu sistema de deteção é capaz de ter em conta as subtis complexidades presentes na jogabilidade, de modo a facilitar uma experiência coesa e de fácil utilização para os jogadores.

Tornar os jogos Godot mais envolventes com a deteção de linha de visão

A deteção de linha de visão aumenta a profundidade e a realidade do ambiente de jogo, permitindo que os jogadores planeiem, se escondam ou enfrentem obstáculos de várias formas, dependendo da sua perspetiva visual. Ao incorporar este elemento, os programadores podem transformar um jogo de plataformas vulgar numa experiência mais cativante e envolvente que aumenta o envolvimento dos jogadores e cria memórias duradouras.