Como Fazer Jogo Multiplayer no Phaser com Node e Socket.IO

Como fazer jogo multiplayer no Phaser: servidor Node com Socket.IO ou Colyseus, servidor autoritativo, sincronizar posições e onde hospedar o jogo.
Aprender como fazer jogo multiplayer no Phaser começa por aceitar um fato simples: o Phaser não faz multiplayer. Ele é um framework de jogo em JavaScript que roda dentro do navegador de cada jogador, e cada aba é um mundo isolado. Para dois navegadores jogarem a mesma partida, alguém precisa ficar no meio repassando informação, e esse alguém é um servidor que você escreve e hospeda.
A boa notícia é que esse servidor também é JavaScript. Com Node.js e uma biblioteca de tempo real, você usa a mesma linguagem nos dois lados. Este guia mostra a arquitetura certa, um exemplo curto com Socket.IO, quando trocar para o Colyseus e o que considerar na hora de colocar o jogo no ar. Se você ainda não montou um jogo simples no Phaser, vale passar antes pelo guia de como criar um jogo com Phaser e JavaScript.
A arquitetura: Phaser no cliente, Node no servidor
Pense em duas peças separadas:
- Cliente: o jogo Phaser no navegador. Lê teclado e mouse, desenha a cena, toca som. Não decide nada importante.
- Servidor: um processo Node.js rodando numa máquina com endereço público. Guarda quem está conectado, onde cada jogador está e aplica as regras.
A comunicação entre os dois usa WebSocket, uma conexão aberta e de mão dupla entre navegador e servidor. Você raramente usa WebSocket cru: Socket.IO adiciona eventos com nome, reconexão automática e salas; Colyseus vai além e gerencia o estado do jogo por você.
Por que o servidor precisa ser autoritativo
O jeito mais tentador de começar é cada cliente mandar a própria posição e o servidor só repassar. Funciona no primeiro teste e quebra no primeiro jogador esperto. Todo código de navegador pode ser lido e alterado no console. Se o cliente diz "estou em x=900", ele pode dizer qualquer coisa: atravessar parede, teleportar, se dar vida infinita.
No modelo autoritativo, o cliente manda só a intenção ("estou segurando a seta para a direita"). O servidor aplica o movimento com as regras dele, num laço de atualização fixo (o tick), e envia para todos o estado resultante. O cliente desenha o que recebeu. Esse é o mesmo modelo usado por engines grandes; no post irmão sobre como fazer jogo multiplayer na Unreal você vê a mesma ideia implementada com replicação e RPCs prontas.
Como fazer jogo multiplayer no Phaser com Socket.IO
O exemplo abaixo é o mínimo funcional: cada jogador é um quadrado, o servidor move os quadrados a partir do input e transmite as posições 20 vezes por segundo. Primeiro o servidor, num projeto Node com socket.io instalado:
// server.js
const { Server } = require("socket.io");
const io = new Server(3000, { cors: { origin: "*" } });
const players = {};
const SPEED = 200; // pixels por segundo
const TICK_MS = 50; // 20 atualizacoes por segundo
io.on("connection", (socket) => {
players[socket.id] = { x: 100, y: 100, input: { left: false, right: false, up: false, down: false } };
socket.on("input", (input) => {
const p = players[socket.id];
if (p) p.input = input;
});
socket.on("disconnect", () => {
delete players[socket.id];
});
});
setInterval(() => {
const dt = TICK_MS / 1000;
const state = {};
for (const id in players) {
const p = players[id];
if (p.input.left) p.x -= SPEED * dt;
if (p.input.right) p.x += SPEED * dt;
if (p.input.up) p.y -= SPEED * dt;
if (p.input.down) p.y += SPEED * dt;
p.x = Math.max(0, Math.min(800, p.x));
p.y = Math.max(0, Math.min(600, p.y));
state[id] = { x: p.x, y: p.y };
}
io.emit("state", state);
}, TICK_MS);
Repare que o servidor nunca aceita uma posição vinda do cliente. Ele recebe só os botões pressionados, aplica velocidade e limites, e é dono do resultado. Em produção, restrinja o origin do CORS ao domínio do seu jogo.
Agora o cliente, uma cena Phaser usando o pacote socket.io-client:
// GameScene.js
import Phaser from "phaser";
import { io } from "socket.io-client";
export default class GameScene extends Phaser.Scene {
constructor() {
super("GameScene");
}
create() {
this.socket = io("http://localhost:3000");
this.sprites = {};
this.cursors = this.input.keyboard.createCursorKeys();
this.lastInput = "";
this.socket.on("state", (state) => {
for (const id in state) {
if (!this.sprites[id]) {
const color = id === this.socket.id ? 0x44ff44 : 0xff4444;
this.sprites[id] = this.add.rectangle(state[id].x, state[id].y, 32, 32, color);
}
this.sprites[id].setPosition(state[id].x, state[id].y);
}
for (const id in this.sprites) {
if (!state[id]) {
this.sprites[id].destroy();
delete this.sprites[id];
}
}
});
}
update() {
const input = {
left: this.cursors.left.isDown,
right: this.cursors.right.isDown,
up: this.cursors.up.isDown,
down: this.cursors.down.isDown,
};
const key = JSON.stringify(input);
if (key !== this.lastInput) {
this.socket.emit("input", input);
this.lastInput = key;
}
}
}
O cliente só envia input quando ele muda, em vez de a cada frame, o que economiza banda. Ao receber o estado, cria um retângulo para cada jogador novo, move os existentes e destrói os que saíram. Abra duas abas apontando para o jogo e você tem multiplayer funcionando.
Para testar sozinho, rode o servidor com node server.js, sirva o jogo pelo seu bundler de costume e abra o endereço em duas janelas lado a lado. Cada aba ganha um socket.id diferente, então você vê o seu quadrado verde e o da outra aba em vermelho. Mova um e confira se o outro acompanha.
Sincronizar posições sem o jogo parecer travado
Rodando local, o exemplo acima parece perfeito. Pela internet, aparecem dois problemas, e vale conhecer o nome deles para pesquisar depois:
Movimento em degraus. O servidor manda posições 20 vezes por segundo, mas a tela desenha 60 ou mais. Sem tratamento, os outros jogadores andam "pulando". A solução é interpolação: em vez de colocar o sprite direto na posição nova, você o desloca suavemente entre as duas últimas posições recebidas, mostrando os outros jogadores um pouquinho no passado.
Atraso no próprio controle. Com 100 ms de ida e volta, seu personagem só se mexe 100 ms depois de você apertar a tecla. A solução é predição no cliente: você move o seu personagem na hora, com a mesma regra do servidor, e corrige quando o estado oficial chega (reconciliação). É mais código, então só implemente quando o atraso realmente atrapalhar o seu tipo de jogo.
Para jogos de turno, cartas ou tabuleiro, nada disso é necessário: o servidor valida a jogada e manda o novo estado, e meio segundo de atraso não estraga nada. Esse é um ótimo primeiro projeto multiplayer no Phaser justamente por isso.
Quando usar Colyseus em vez de Socket.IO
No exemplo com Socket.IO, você mesmo escreveu o objeto de jogadores, o envio do estado e a remoção de quem saiu. Num jogo real ainda faltariam salas separadas por partida, limite de jogadores por sala, matchmaking e envio só do que mudou, para não mandar o estado inteiro a cada tick.
O Colyseus é um framework de servidor de jogo multiplayer para Node.js que entrega essas partes. Você define o estado com schemas tipados (por exemplo, um mapa de jogadores com x e y), escreve a lógica numa classe de sala com eventos de entrada, saída e mensagens, e o framework sincroniza automaticamente para os clientes só os campos que mudaram. Do lado do cliente, o SDK JavaScript entra na sala e avisa quando um jogador é adicionado, alterado ou removido, o que encaixa bem na lógica de criar e mover sprites do Phaser. O projeto mantém exemplos oficiais com Phaser.
Um alerta prático: a API do Colyseus mudou entre versões recentes (a forma de declarar schemas e de escutar mudanças no cliente, por exemplo). Siga a documentação da versão que você instalar, não tutoriais antigos.
Regra geral: Socket.IO para aprender e para jogos com lógica simples; Colyseus quando você começa a reescrever salas e sincronização de estado na mão.
Hospedagem: onde colocar o jogo no ar
São duas hospedagens diferentes:
- O jogo Phaser é um conjunto de arquivos estáticos (HTML, JS, imagens). Qualquer hospedagem de site estático serve, inclusive as gratuitas.
- O servidor Node precisa de um processo rodando o tempo todo e aceitando conexões WebSocket. Serve um VPS, onde você instala Node e mantém o processo vivo, ou uma plataforma de aplicações que rode Node com suporte a WebSocket. Hospedagem que só executa funções sob demanda, sem processo contínuo, não serve para esse modelo.
Três cuidados que costumam pegar quem está estreando: use HTTPS no site e WSS no servidor, porque navegador bloqueia conexão insegura vinda de página segura; escolha uma região próxima dos seus jogadores, já que servidor nos Estados Unidos acrescenta latência perceptível para quem joga do Brasil; e comece com uma máquina pequena, medindo uso de CPU e banda antes de escalar.
Se a ideia é ir além e fazer um jogo de navegador com muitos jogadores na mesma arena, o post sobre como fazer um jogo .io multiplayer trata dos desafios específicos desse formato.
Erros comuns no multiplayer com Phaser
- Confiar no cliente. Nunca aceite posição, dano ou pontuação vindos do navegador.
- Emitir a cada frame. Mandar input 60 vezes por segundo multiplica tráfego à toa. Envie quando mudar.
- Usar a física do Phaser como verdade. A física Arcade roda no cliente. Se a colisão decide o jogo, ela precisa ser calculada no servidor também.
- Esquecer a desconexão. Jogador que fecha a aba precisa sumir do estado, senão vira fantasma na tela dos outros.
- Testar só em localhost. Latência zero esconde todos os problemas de sincronização. Teste com o servidor hospedado, ou simule atraso.
Phaser é uma boa escolha para multiplayer?
Para jogos de navegador, sim, desde que você goste de montar a própria infraestrutura. O Phaser cuida da parte visual com leveza e o ecossistema Node tem ferramentas maduras para o servidor. O que você não ganha é uma camada de rede integrada à engine: replicação, RPCs e spawn sincronizado são responsabilidade sua ou do Colyseus.
Isso é ótimo para entender multiplayer a fundo, mas pode ser muita peça solta para quem quer, antes de tudo, terminar um jogo. Se o seu objetivo é aprender a fazer um jogo completo, do movimento ao multiplayer, numa engine leve e gratuita que já traz rede pronta (RPCs, sincronizadores, servidor dedicado) e ainda exporta para a web, a Godot entrega esse pacote num só lugar.
Seja qual for a ferramenta, o modelo deste post continua valendo: o servidor manda, o cliente pede e desenha, e o estado viaja pela rede no ritmo do tick.
Perguntas frequentes
O Phaser tem multiplayer nativo?
Não. O Phaser é um framework de jogo que roda no navegador do jogador, e não traz camada de rede. Para multiplayer você precisa de um servidor separado, normalmente em Node.js, e de uma biblioteca de comunicação em tempo real como Socket.IO ou um framework de servidor de jogo como o Colyseus.
Socket.IO ou Colyseus para multiplayer no Phaser?
Socket.IO é uma biblioteca de mensagens: você controla tudo, inclusive como o estado é guardado e enviado, o que é ótimo para aprender. Colyseus é um framework de servidor de jogo, com salas, matchmaking e sincronização de estado automática por schema. Para entender o conceito, comece com Socket.IO; para um projeto real com salas, o Colyseus economiza bastante código.
O que é servidor autoritativo em jogo de navegador?
É quando o servidor guarda o estado oficial do jogo e aplica as regras. O navegador só envia o input do jogador e desenha o que o servidor manda. Como qualquer pessoa pode abrir o console do navegador e alterar o JavaScript, deixar o cliente decidir posição ou dano é convite para trapaça.
Onde hospedar o servidor de um jogo multiplayer feito em Phaser?
A parte do Phaser é estática e pode ficar em qualquer hospedagem de site. O servidor Node precisa de um serviço que mantenha um processo rodando e aceite WebSocket, como um VPS ou uma plataforma de aplicações Node. Escolha uma região perto dos seus jogadores, porque a distância vira latência.


