Conectar por IP na Rede Local: Multiplayer no Godot

Se voce quer conectar jogadores por IP na rede local no Godot, a boa noticia e que o motor ja traz tudo pronto. Nao precisa de servico externo, nem de conta em plataforma, nem de biblioteca de terceiros. Com a classe ENetMultiplayerPeer uma maquina vira servidor (o host), as outras viram clientes, e todas conversam pelo endereco IP dentro do mesmo Wi-Fi ou do mesmo cabo. Este guia mostra o caminho completo: criar o servidor, conectar o cliente, descobrir o IP certo, lidar com porta e firewall, e entender por que comecar na LAN economiza muita dor de cabeça antes de pensar em servidor na nuvem.

A ideia central do multiplayer no Godot e simples: existe um MultiplayerPeer que representa a sua ponta da conexao. O servidor cria um peer em modo servidor, o cliente cria um peer em modo cliente apontando para o IP do servidor, e os dois atribuem esse peer ao multiplayer.multiplayer_peer. A partir dai o Godot cuida do transporte de pacotes. O que voce envia por cima disso (posicao de personagem, placar, chat) e assunto de RPC ou de nos sincronizados, mas nada acontece enquanto a conexao por IP nao estiver de pe.

Criando o servidor (o host)

O host e a maquina que abre a porta e fica esperando conexoes. No Godot 4 isso cabe em poucas linhas. Voce instancia um ENetMultiplayerPeer, chama create_server passando a porta e o numero maximo de jogadores, e entrega esse peer ao sistema de multiplayer.

extends Node

const PORTA: int = 8910
const MAX_JOGADORES: int = 4

func criar_servidor() -> void:
    var peer: ENetMultiplayerPeer = ENetMultiplayerPeer.new()
    var erro: int = peer.create_server(PORTA, MAX_JOGADORES)
    if erro != OK:
        push_error("Nao consegui abrir o servidor na porta %d" % PORTA)
        return
    multiplayer.multiplayer_peer = peer
    print("Servidor no ar. Esperando jogadores na porta %d." % PORTA)

Repare em dois detalhes que iniciantes costumam pular. Primeiro, create_server devolve um codigo de erro: se a porta ja estiver ocupada por outro programa (ou por uma instancia antiga do seu jogo que nao fechou direito), ele retorna algo diferente de OK e voce precisa tratar isso em vez de seguir como se tudo estivesse bem. Segundo, so depois de atribuir o peer a multiplayer.multiplayer_peer e que o Godot passa a funcionar em modo rede. Enquanto essa linha nao roda, voce tem um objeto solto que nao faz nada.

Vale conectar os sinais do servidor para saber quem entra e quem sai. O multiplayer emite peer_connected e peer_disconnected com o ID do jogador, e isso e util para spawnar personagens ou limpar o estado de quem caiu.

func _ready() -> void:
    multiplayer.peer_connected.connect(_ao_entrar)
    multiplayer.peer_disconnected.connect(_ao_sair)

func _ao_entrar(id: int) -> void:
    print("Jogador %d conectou." % id)

func _ao_sair(id: int) -> void:
    print("Jogador %d saiu." % id)

Conectando o cliente por IP

O cliente faz o caminho inverso: ele nao abre porta, ele procura o servidor em um endereco. A chamada e create_client, que recebe o IP do host e a mesma porta que o servidor abriu. A porta precisa bater exatamente, senao o cliente tenta falar numa porta onde ninguem esta ouvindo.

func conectar_cliente(ip: String) -> void:
    var peer: ENetMultiplayerPeer = ENetMultiplayerPeer.new()
    var erro: int = peer.create_client(ip, PORTA)
    if erro != OK:
        push_error("Nao consegui iniciar a conexao com %s" % ip)
        return
    multiplayer.multiplayer_peer = peer
    print("Tentando conectar em %s:%d..." % [ip, PORTA])

Um ponto importante: create_client retornar OK nao significa que voce ja esta conectado. Significa apenas que a tentativa comecou. A confirmacao vem por sinal. O Godot emite connected_to_server quando o aperto de mao termina, e connection_failed quando o servidor nao responde (IP errado, porta errada, firewall bloqueando ou host offline). Sempre trate os dois.

func _ready() -> void:
    multiplayer.connected_to_server.connect(_conectou)
    multiplayer.connection_failed.connect(_falhou)
    multiplayer.server_disconnected.connect(_servidor_caiu)

func _conectou() -> void:
    print("Conectado ao servidor com sucesso.")

func _falhou() -> void:
    push_warning("Falha ao conectar. Confira IP, porta e firewall.")
    multiplayer.multiplayer_peer = null

func _servidor_caiu() -> void:
    push_warning("O servidor encerrou a conexao.")
    multiplayer.multiplayer_peer = null

Esse connection_failed e o seu melhor amigo na depuracao. Se ele dispara rapido, quase sempre e IP ou porta trocados. Se demora e so entao falha, costuma ser firewall ou host que nem subiu.

Descobrindo o IP local da maquina

Para o cliente conectar, ele precisa saber o IP do host na rede local. Esse endereco nao e fixo e muda de rede para rede, entao nao adianta chutar. No Windows, abra o terminal e rode ipconfig; procure a linha "Endereco IPv4" do adaptador que esta realmente em uso (Wi-Fi ou Ethernet). No Linux ou macOS use ip addr ou ifconfig. O numero costuma comecar com 192.168., com 10. ou na faixa de 172.16. a 172.31., porque essas sao as faixas reservadas para redes privadas.

Voce tambem pode mostrar os enderecos de dentro do proprio jogo, o que ajuda o host a ler o IP para um amigo sem sair do Godot.

func mostrar_ips_locais() -> void:
    var enderecos: PackedStringArray = IP.get_local_addresses()
    for endereco: String in enderecos:
        print("Endereco disponivel: %s" % endereco)

Esse metodo lista todos os enderecos da maquina, inclusive o 127.0.0.1 (localhost) e eventuais adaptadores virtuais. O host olha a lista, identifica o IP da faixa privada e passa esse valor para quem vai entrar. Para testar sem duas maquinas, rode duas instancias do projeto e conecte o cliente em 127.0.0.1: tudo roda na mesma maquina e e otimo para validar a logica antes de envolver a rede de verdade.

Porta e firewall: onde a conexao trava na pratica

A porta e um numero que identifica qual programa recebe os pacotes numa maquina. Escolha uma porta livre acima de 1024 (abaixo disso o sistema reserva para servicos conhecidos) e use o mesmo valor no servidor e no cliente. Valores como 8910, 7777 ou 9999 aparecem muito em exemplos justamente porque dificilmente colidem com outra coisa.

O obstaculo mais comum na primeira vez e o firewall do sistema operacional. Quando o host roda o jogo e abre a porta, o Windows normalmente mostra um aviso perguntando se quer permitir o acesso a rede. Marque a opcao de rede privada e autorize. Se voce dispensou esse aviso sem querer, o cliente vai bater em connection_failed eternamente mesmo com IP e porta corretos, porque o firewall esta descartando os pacotes antes de chegarem ao jogo. Nesse caso, libere o executavel do seu jogo nas regras de firewall manualmente. Antivirus de terceiros as vezes tambem bloqueiam, entao vale checar.

Uma dica de ouro para a depuracao: teste em camadas. Primeiro 127.0.0.1 na mesma maquina (elimina rede e firewall da equacao). Depois duas maquinas na mesma rede com o IP local. So quando esses dois funcionam e que faz sentido pensar em internet.

IP local contra IP publico: por que a LAN vem primeiro

Aqui mora a confusao que mais trava iniciante. O IP local (aquele 192.168.x.x) so existe dentro da sua rede. Ele e invisivel para a internet. Se voce mandar esse endereco para um amigo em outra cidade, nao vai funcionar de jeito nenhum, porque o roteador dele nao tem como rotear ate a sua rede interna.

Para jogar pela internet voce precisa do IP publico, que e o endereco unico que o seu roteador expoe para o mundo. E ai entra a complicacao: o roteador nao sabe, por padrao, para qual maquina interna mandar os pacotes que chegam numa porta. Voce precisa configurar o port forwarding, dizendo ao roteador "pacotes que chegarem na porta 8910 devem ir para a maquina 192.168.x.x". Isso varia de roteador para roteador, exige acesso de administrador e pode esbarrar em CGNAT, uma configuracao comum de operadora que simplesmente nao da IP publico direto para voce. Por isso tanta gente desiste nessa etapa.

Comecar pela rede local nao e preguica, e metodo. Na LAN voce elimina de uma vez o port forwarding, o CGNAT e a latencia da internet. Se o seu jogo nao sincroniza bem dentro de casa, ele nao vai magicamente funcionar pela internet. A LAN e o ambiente onde voce prova que a logica de servidor e cliente esta correta. Depois que isso roda liso, voce decide o proximo passo com calma: abrir porta para jogar com amigos ou colocar um servidor dedicado no ar, lembrando que isso tem custo de servidor de jogo online que vale planejar antes.

O que vem depois da conexao

Conectar por IP e a fundacao, nao o predio inteiro. Com o peer de pe e os sinais tratados, o proximo passo e mandar informacao util entre as maquinas. No Godot isso se faz com RPC (chamadas de funcao remota) e com nos de sincronizacao. Se voce quer entender a parte de trocar chamadas entre servidor e cliente, veja o guia de multiplayer no Godot com RPC, que cobre o anotador @rpc e como o estado trafega. E se prefere um passo a passo montando uma cena jogavel do zero, o tutorial de multiplayer no Godot junta tudo em um projeto completo.

Para fechar, um resumo mental do fluxo: o host chama create_server(porta) e atribui o peer; o cliente descobre o IP local do host, chama create_client(ip, porta) com a mesma porta e espera o sinal connected_to_server; se travar, suspeite de IP, porta e firewall, nessa ordem. Domine isso na rede local e voce ja tem a base sobre a qual qualquer jogo online de verdade e construido. A internet e so o mesmo conceito com mais etapas de configuracao no caminho, e agora voce sabe exatamente onde elas entram.