A criação de jogos multiplayer é uma aventura complexa e envolvente que exige não apenas conhecimento técnico, mas também criatividade e uma compreensão profunda das dinâmicas de jogo.
Jogos como It Takes Two (site oficial) se tornaram famosos por suas mecânicas que envolvem a interação e colaboração entre dois jogadores.
Já os MMORPG ou Battle Royales juntam milhares de jogadores colaborando ou competindo ao mesmo tempo.
Neste guia expandido, vamos mergulhar no universo do desenvolvimento multiplayer no Godot (site oficial), explorando cada etapa desde a configuração inicial até a otimização de performance em tempo real.
Vamos detalhar os processos, fornecer exemplos de código e discutir as melhores práticas para garantir que seu jogo seja não apenas funcional, mas também envolvente e otimizado e, se você ficar com dúvidas, é só deixar nos comentários.
Conteúdo desde artigo
Introdução ao Multiplayer em Godot 4
O multiplayer traz uma dimensão completamente nova para jogos, transformando experiências solitárias em sociais e imprevisíveis. Com o Godot 4, você tem acesso a um motor de jogo poderoso e flexível, perfeito para criar experiências multiplayer personalizadas. Descubra mais sobre Godot 4 e suas capacidades aqui.
Entendendo a High-Level Multiplayer API
Antes de mergulhar no código, é crucial entender a High-Level Multiplayer API de Godot. Esta API é uma camada de abstração poderosa que simplifica muitos dos aspectos complexos do networking. Ao invés de lidar com os detalhes minuciosos de como os dados são enviados e recebidos através da rede, você pode se concentrar na lógica do jogo e na experiência do usuário.
A API High-Level Multiplayer oferece uma variedade de funcionalidades, como chamadas de procedimento remoto (RPCs), sincronização de estado e gerenciamento de sessões multiplayer. Com essas ferramentas, você pode implementar jogos multiplayer robustos que sincronizam os movimentos dos jogadores, estados de jogo e mais, tudo em tempo real.
Para começar a usar a API High-Level Multiplayer, você deve explorar a documentação oficial do Godot, que oferece uma visão detalhada das classes, métodos e práticas recomendadas. A documentação é projetada para ser acessível a desenvolvedores de todos os níveis e é um recurso valioso para entender como implementar recursos multiplayer eficientes e eficazes em seus jogos.
Ao dominar a High-Level Multiplayer API, você estará equipado para criar experiências multiplayer envolventes e dinâmicas, proporcionando aos jogadores interações sociais significativas e jogabilidade competitiva.
Deixa eu te contar uma coisa antes de continuarmos
Você já sonhou em transformar seu amor por videogames em mais do que apenas um hobby?
Estamos preparando uma nova SUPER-AULA ao vivo e exclusiva!!
Nessa aula exclusiva do Studio Married Games, revelaremos não apenas os fundamentos do desenvolvimento de jogos, mas também como você pode superar obstáculos técnicos e iniciar seus projetos com confiança e criatividade.
Esta é sua oportunidade de aprender com os melhores na área, ganhar insights valiosos e começar a trilhar seu caminho em direção a uma carreira dos sonhos no universo dos jogos. A paixão já está aí, agora é hora de dar poder a ela.
Não deixe escapar essa chance de fazer história no mundo dos jogos e seja avisado EM PRIMEIRA MÃO quando essa aula (e outras coisitas mas) forem acontecer!.
Inscreva-se agora e transforme essa possibilidade em realidade. Estamos te esperando!
Começando o seu multiplayer: Configure a rede
Para nos ajudar com isso, consultamos os amigos do site Medium, que escreveram esse código. Obrigado Medium. Isso é semelhante ao Godot 3.5, mas a sintaxe é um pouco diferente:
Por exemplo, agora tudo sobre multijogador está na classe global chamada “multiplayer” (MultiplayerAPI), o que significa que quando conectamos sinais, está na classe multijogador.
# GODOT 3.5
get_tree().connect("connected_to_server", self, "_connected_to_server")
# GODOT 4
multiplayer.connected_to_server.connect(self._connected_to_server)Para configuração rápida, você pode usar este código:
extends Node
const DEFAULT_PORT = 28960
const MAX_CLIENTS = 6
var server = null
var client = null
var ip_address = ""
var current_player_username = ""
var client_connected_to_server = false
var networked_object_name_index = 0 : set = networked_object_name_index_set
@onready var client_connection_timeout_timer = Timer.new()
func _ready() -> void:
multiplayer.connection_failed.connect(self._connection_failed)
multiplayer.server_disconnected.connect(self._server_disconnected)
multiplayer.connected_to_server.connect(self._connected_to_server)
add_child(client_connection_timeout_timer)
client_connection_timeout_timer.wait_time = 10
client_connection_timeout_timer.one_shot = true
client_connection_timeout_timer.connect("timeout",Callable(self,"_client_connection_timeout"))
if OS.get_name() == "Windows":
ip_address = IP.get_local_addresses()[3]
elif OS.get_name() == "Android":
ip_address = IP.get_local_addresses()[0]
else:
ip_address = IP.get_local_addresses()[3]
for ip in IP.get_local_addresses():
if ip.begins_with("192.168.") and not ip.ends_with(".1"):
ip_address = ip
func create_server() -> void:
server = ENetMultiplayerPeer.new()
server.create_server(DEFAULT_PORT, MAX_CLIENTS)
multiplayer.set_multiplayer_peer(server)
func join_server() -> void:
client = ENetMultiplayerPeer.new()
client.create_client(ip_address, DEFAULT_PORT)
multiplayer.set_multiplayer_peer(client)
client_connection_timeout_timer.start()
func reset_network_connection() -> void:
if multiplayer.has_multiplayer_peer():
if Persistent_nodes.get_child_count() > 1:
for node in Persistent_nodes.get_children():
node.queue_free()
multiplayer.multiplayer_peer = null
func _connected_to_server() -> void:
print("Successfully connected to the server")
client_connected_to_server = true
func _server_disconnected() -> void:
print("Disconnected from the server")
for child in Persistent_nodes.get_children():
if child.is_in_group("Net"):
child.queue_free()
reset_network_connection()
func _client_connection_timeout():
if client_connected_to_server == false:
print("Client has been timed out")
reset_network_connection()
func _connection_failed():
for child in Persistent_nodes.get_children():
if child.is_in_group("Net"):
child.queue_free()
reset_network_connection()
@rpc("any_peer")
func peer_networked_object_name_index_set(new_value):
networked_object_name_index = new_value
func networked_object_name_index_set(new_value):
networked_object_name_index = new_value
if get_tree().is_server():
rpc("peer_networked_object_name_index_set", networked_object_name_index)Este código você adicionará como carregamento automático e, em seguida, criará um nó com lobby e conectará os sinais e, em seguida, botão para alternar cenas.
Sincronizador multijogador
Nesta versão do Godot, adicionaram o sincronizador multiplayer, que simplifica a programação do multiplayer. Agora você precisa adicioná-lo à árvore do player e depois definir as propriedades que deseja sincronizar.
Outro novo recurso que também simplifica o processo de geração e gerenciamento de objetos em rede em jogos multijogador. Para mais detalhes, é recomendado olhar a documentação.
Antes da gente continuar, deixa eu te falar uma coisa legal…
Agora é a hora de levar sua paixão por jogos a novas alturas. E como você faz isso? Com a nossa aula online que estamos preparando para você!
Com a nossa Super-Aula ao vivo e exclusiva, no Studio Married Games, você terá acesso a um conhecimento que pode transformar sua visão de desenvolvimento de jogos em uma realidade tangível.
Desde os conceitos básicos até estratégias avançadas para superar barreiras técnicas e iniciar seus projetos, estamos aqui para guiar você por cada passo dessa jornada empolgante. Se inscreva agora e a gente avisa você quando essa aula vai rolar! Clica aí!
As vagas estão se esgotando rapidamente. Inscreva-se imediatamente para não perder essa oportunidade exclusiva de estar entre os 100 aspirantes a desenvolvedores que darão vida aos seus sonhos. A hora de agir é agora. Dê o primeiro passo para realizar seu sonho.
Chamadas RPC
Os RPCs são essenciais para implementar jogabilidade e interações em rede, e é por isso que é útil saber como usá-los corretamente. O RPC mudou a sintaxe para uma versão muito mais simples. Por exemplo, agora você não tem nenhum mestre, fantoche, controle remoto, etc., mas tem uma sintaxe muito mais simples. Sintaxe de chamadas RPC em Godot 4:
Você começará com “@” e então especificará o modo, sincronização, transfer_mode do RPC.
# mode, sync, transfer_mode (order doesn't matter)
# reliable -> tcp, unreliable -> udp (spamming), unreliable_ordered
@rpc("any_peer", "call_local", "reliable")
func totaly_sync():
print("Running locally and any_connected_client running this function")
@rpc("call_local")
func local_call():
print("calling just local function")
# You also can use different channels used mostly for optimizations
@rpc(any_peer, 1)
func my_chat_func(message):
print("RPC received on channel 1, message: " + str(message))
# Calling rpc function:
# rpc() == self.rpc
rpc("totaly_sync")
# with arguments:
rpc("my_chat_func", "Hello")Mas tenha cuidado, você não pode enviar nenhum nó porque isso pode levar a uma vulnerabilidade RCE, então você precisa contornar isso. Normalmente, declaro uma lista de itens que desejo sincronizar e depois é só enviar o índice pela rede.
@onready var items = [
preload("res://path/to/scene.tscn"),
preload("res://path/to/scene.tscn"),
]
@rpc("any_peer", "call_local", "reliable")
func sync_items(index: int) -> void:
spawn_item(items[index])Controlando o fluxo de execução
A última coisa da nossa lista é como realmente controlar o fluxo de execução. A principal forma de controlar o fluxo é:
# check whoever executing the code if its the owner of current node
mutiplayer.is_mutliplayer_authority()
# check if its the server
multiplayer.is_server()
# set the ownership of the node
NODE.set_multiplayer_authority()Ao instanciar o jogador, você precisa defini-lo como multiplayer_authority de seu nó. Isso tornará sua vida muito mais simples.
E lembre-se que ao usar a função “_ready()”, a execução desta função geralmente acontece antes de multiplayer_authority ser definido.
Criando Experiências Multiplayer Imersivas
Desenvolver um jogo multiplayer no Godot 4 é uma jornada técnica e criativa. Ao entender os sistemas de rede, sincronizar jogadores e estados do jogo corretamente, e otimizar a performance, você pode criar experiências multiplayer ricas e envolventes.
Lembre-se de que o sucesso de um jogo multiplayer depende não apenas da tecnologia, mas também da capacidade de criar um jogo divertido e envolvente que os jogadores queiram voltar várias vezes.
Não se esqueça de explorar a comunidade Godot e recursos online para obter suporte, ideias e conselhos. O fórum oficial do Godot e o Reddit são excelentes lugares para começar.
Quer fazer seu Multiplayer no Godot 4 Agora?
Viu como um desenvolvimento multiplayer no Godot 4 pode ser uma tarefa desafiadora, mas repleta de aprendizados e possibilidades? O importante é começar devagar, aprendendo os conceitos básicos e, à medida que se torna mais confortável, expandir para recursos mais avançados e otimizações.
Para aqueles realmente comprometidos em levar seus jogos multiplayer ao próximo nível, estamos oferecendo o CursoGame.Dev! Um curso avançado sobre Desenvolvimento Multiplayer no Godot 4. Aprenda em detalhes sobre o uso de diferentes recursos e técnicas de otimização com instrutores experientes e profissionais do setor.
Quer começar hoje mesmo? Clique aqui e preencha o formulário para ser um dos primeiros a garantir uma vaga no curso! Acredite, você não vai se arrepender!
Pronto para embarcar nesta aventura multiplayer com Godot 4? Com paciência, prática e paixão, você está no caminho certo para criar algo verdadeiramente especial. Boa sorte, desenvolvedor!
FAQ Rápido
O que são RPCs em Godot?
RPCs, ou Remote Procedure Calls, são chamadas de métodos entre diferentes instâncias de jogo em uma rede.
Como sincronizar movimentos dos jogadores no multiplayer do Godot?
Use RPCs para chamar métodos como move_player(player_id, position) que atualizam a posição dos jogadores em todas as instâncias.
Godot 4 suporta jogos multiplayer com alta performance?
Sim, com as ferramentas certas e otimização, Godot 4 pode suportar jogos multiplayer com alta performance.
Como otimizar a performance de rede em Godot?
Monitore o tráfego de rede, ajuste o CompressionMode e teste sob diferentes condições de rede para otimização.
Fale conosco nos comentários e diga oque achou dessa matéria e aproveite para ler mais notícias e matérias, como por exemplo, sobre Rigging de Personagens 3D, no nosso site.
