Esta página ainda não foi traduzida: mostrando a versão em inglês.
Game servers em C#
Um game server em C# executa as suas regras no PlayServ: cada Room faz o tick, o seu código avança a simulação e o SDK envia snapshots aos Players. O PlayServ verifica cada Player e distribui as vagas; o seu servidor decide o que um Player pode fazer e o que acontece. É um processo .NET construído sobre o SDK C# do PlayServ, e o deploy é feito como o de uma cloud function.
| Seu | Do PlayServ |
|---|---|
| As regras: o que um Player pode fazer, o que isso muda, quem vence | Quem é o Player: toda conexão chega com um Player verificado |
| O relógio e a simulação | As vagas: capacidade, tempo de vida, timeout de inatividade, número máximo de Rooms, a partir das Room settings |
| O que os Players enviam e o que você devolve | Encontrar Rooms: listar, hospedar, entrar e o ticket que deixa um Player entrar |
Primeiros passos
Crie o projeto
playserv init sky-arena --kind game_serverO projeto é um servidor de eco que já pode ir para deploy como está. Substitua a classe do servidor pelas suas Rooms, como mostrado abaixo.
Faça o deploy
playserv functions deploy --slug sky-arena --kind game_server --src .O slug é único em toda a sua organização, não só no seu Project.
Defina as Room settings
playserv rooms config set sky-arena --capacity 8 --reservation-ttl 10 --lifetime 1800 --idle-timeout 120 --max-rooms 50Ou em Servers → Room settings. Enquanto elas não existirem, os Players não conseguem hospedar, listar nem entrar nas Rooms desse servidor.
A classe do servidor
Uma classe por projeto, derivada de PlatformGameServer, com um construtor público sem parâmetros. Program.cs a inicia: await PlatformHost.RunAsync<ArenaServer>(args);
| Hook | Quando |
|---|---|
OnStartupAsync · OnShutdownAsync | O processo inicia, ou recebe o pedido para parar. |
OnPlayerConnected(session) | Um Player passou pelo handshake. session.Id é o Player verificado, e session.AdmittedRoomName, a Room para a qual o ticket dele vale. |
OnPlayerMessage(session, bytes) | Uma mensagem desse Player. |
OnPlayerDisconnected(session, reason) | A conexão fechou, ou o período de tolerância de reconexão acabou. |
OnPlayerReconnected(session) | O Player voltou dentro de ReconnectGrace, 30 segundos por padrão. |
OnTicketOfferAsync(room, playerId, params, ct) | O PlayServ pergunta se este Player pode entrar nesta Room, antes de emitir o ticket. Retorne false para recusar, por exemplo em uma Room privada. |
Envie a um Player com session.SendTextAsync, SendBinaryAsync ou TrySendText. Cada Player tem uma fila de 64 mensagens; um Player lento demais para acompanhar é desconectado, em vez de travar a Room.
Rooms
using PlayServ.Sdk;
using PlayServ.Sdk.Rooms;
public sealed class Pilot : RoomPlayer { public int Score; }
public sealed record ArenaConfig(int RoundSeconds);
public sealed class ArenaRoom : Room<Pilot, ArenaConfig>
{
public ArenaRoom(string name) : base(name, new ArenaConfig(300), capacity: 8) { }
protected override float SimStepSeconds => 0.1f; // 10 steps per second
protected override void OnSimStep(float dt)
{
// move ships, resolve hits, end the round
}
}
Um RoomHost é dono das Rooms do servidor: new RoomHost<ArenaRoom, Pilot, ArenaConfig>(name => new ArenaRoom(name), tickHz: 10). Ele cria uma Room quando um Player hospeda uma, faz o tick de todas as Rooms, aplica as Room settings, envia o heartbeat de cada Room ao PlayServ a cada 5 segundos, aproximadamente, e descarta as Rooms que o PlayServ fecha. Abra uma Room você mesmo com GetOrCreate(name); encontre uma com Find(name).
Membro de Room | O que faz |
|---|---|
AddPlayer · RemovePlayer · GetPlayer · Players · IsFull | A lista de participantes. AddPlayer retorna false quando a Room está cheia. |
Lock | Tudo o que lê ou altera o estado da Room roda sob ele. O SDK o adquire a cada tick; adquira-o você mesmo a cada comando. |
OnPlayerJoined · OnPlayerLeft · OnIdle | Hooks da lista de participantes. OnIdle dispara sempre que a Room é descartada: timeout de inatividade, fim do tempo de vida ou um Delete room de um operador. |
SetState · SetAttributes | O que os Players veem e usam como filtro ao listar Rooms. |
MarkActive(player) | Registra atividade, para o timeout de inatividade. |
DeclareConnect(new RoomConnect(host, port, transport), region) | Onde os Players conectam e onde a Room roda. |
A capacidade no construtor serve só para execuções locais: a capacidade das Room settings a substitui.
A simulação
OnSimStep(dt) é a sua simulação de passo fixo. O host a chama sob o lock da Room, a cada SimStepSeconds (1/30 por padrão), e, depois de um travamento, recupera o atraso com no máximo MaxCatchUpSteps passos por tick (6 por padrão).
Divida uma simulação grande em sistemas: AddSystem(ISimSystem) e AddPlayerSystem(IPlayerSimSystem), cada um em uma fase: Input, AI, Movement, Collision, Combat, Spawn, Scoring, Cleanup. O OnSimStep padrão os executa nessa ordem.
Não sobrescreva OnTick
O tick da Room avança a simulação, mantém o período de tolerância de reconexão e envia os snapshots. Sobrescrever OnTick sem chamar base.OnTick desliga as três coisas. Coloque a sua lógica em OnSimStep.
DeclareReconnect(lingerSeconds, removeOnExpiry, onExpire) remove todo Player sem atividade registrada com MarkActive há lingerSeconds, conectado ou não. Assim, um Player que caiu mantém a vaga durante esse tempo. onExpire roda primeiro; com removeOnExpiry, ligado por padrão, o Player é removido em seguida e OnPlayerLeft roda. Recalcule ali o host da Room, os times ou a ordem dos turnos. Chame MarkActive em todo comando que um Player enviar, senão Players ativos também são removidos.
Snapshots
Os Players veem a Room por meio dos snapshots que você monta; o SDK decide quando enviá-los. Declare o plano uma vez, no construtor da Room:
DeclareSnapshot<ArenaSnapshot>(plan =>
{
plan.Cadence = SnapshotCadence.EveryN(20); // every 20 ticks
plan.Deliver = snapshot => Broadcast(snapshot);
plan.Assemble(_ => BuildSnapshot());
});
| Configuração do plano | O que faz |
|---|---|
Assemble(...) | Monta o snapshot depois de um tick, sob o lock. Obrigatório. |
Deliver | Envia o snapshot aos Players da Room. |
Cadence | SnapshotCadence.EveryTick ou EveryN(n) ticks. |
ForcePublishOnEvent | Ligado por padrão: um Events.Emit(...) vindo de qualquer mudança envia um snapshot no tick seguinte, sem esperar a cadência. |
AdaptiveCadence | Envia com mais ou menos frequência entre MinHz (1) e MaxHz (15), dentro de um orçamento. |
Defina Deliver para enviar os snapshots às conexões dos seus Players. Uma cadência baixa com Events.Emit a cada mudança faz um jogo por turnos parecer instantâneo.
Comandos dos Players
O que os Players enviam em OnPlayerMessage é você quem define: uma pequena mensagem JSON com um ID de requisição permite responder a cada comando. Trate cada um sob o lock da Room e responda com um código de erro curto em vez de lançar uma exceção.
Confie na sessão, não na mensagem
Pegue o Player de session.Id, nunca de um ID que veio na mensagem. Confira cada comando com as suas regras: a fase certa, o Player certo, dentro dos limites.
Um servidor também pode expor métodos que os Players chamam com PlayServRpc.InvokeAsync.
Dados
Um servidor com deploy feito lê e grava os seus dados sem key: Platform.Table<T>(), Platform.Records e Platform.Singleton. Salve o resultado de uma partida uma vez por partida, atualize o perfil de um Player pela chave natural dele e releia configurações ao vivo, como um singleton, com um timer.
Nunca espere por uma chamada de dados dentro de OnSimStep ou sob o lock da Room: execute-a fora do tick. DeclareDataMirror e DeclarePersistedCounter mantêm as linhas dos Players em sincronia com a Room por você.
Onde os Players conectam
Os Players chegam à Room por RoomConnect: em um pool de máquinas ou nas suas próprias máquinas, chame DeclareConnect com o endereço público e a porta. Um Player conecta com CreateRoomSession ou CreateGameConnection, que enviam o ticket; o SDK o confere antes de OnPlayerConnected, e um ticket inválido ou expirado fecha a conexão.
Limites
| Item | Limite |
|---|---|
| Mensagem de um Player | 1 MB |
| Handshake | A primeira mensagem, até 4 KB, em até 10 segundos |
| Fila por Player | 64 mensagens |
tickHz | 1–240 |
| Recuperação de atraso | 6 passos por tick |
| Rooms e vagas | Definidos pelas Room settings |
Próximos passos
- Hospedagem de game servers — os dois tipos de servidor e os Unity Dedicated Servers
- Deploy com a CLI — deploy, tags e declaração de servidores
- Conectar-se a um jogo — como os Players chegam à sua Room
Atualizado em 22 de out. de 2026