Como configurar um EventServer dedicado no MU Online

Em um servidor de MU Online, os eventos temporizados — Blood Castle, Devil Square, Chaos Castle, Crywolf, Kanturu, invasões de Golden Dragon e afins — são os momentos de maior concentração de jogadores e, consequentemente, de maior carga de processamento. Cada entrada de sala precisa spawnar monstros, controlar timers, validar itens de entrada, calcular ranking e distribuir recompensas, tudo isso enquanto o restante do servidor continua rodando normalmente. Quando esse trabalho todo acontece dentro do mesmo processo do GameServer, um pico em horário nobre pode gerar lag generalizado, quedas de FPS lógico e, em casos extremos, travamento do processo. É aí que entra a ideia de um EventServer dedicado: isolar a lógica de eventos em um processo separado, de forma que os picos de carga dos eventos não contaminem a experiência do jogo normal. Este tutorial explica o papel do EventServer, como separá-lo do GameServer, como configurar a ligação entre os dois e — igualmente importante — quando realmente vale a pena adotar essa arquitetura.

O que é o EventServer e qual o seu papel

O EventServer é o componente responsável por orquestrar a lógica dos eventos com hora marcada e das instâncias de evento. Na prática, ele cuida de tarefas como: agendar quando cada evento abre (por exemplo, Blood Castle a cada 2 horas), controlar as fases internas de cada sala, gerenciar o spawn e o comportamento dos monstros de evento, validar os itens de entrada (Invitation, Scroll, Feather etc.), acompanhar o progresso dos jogadores dentro da instância e, ao final, calcular quem venceu e distribuir as recompensas.

É fundamental entender que em muitos emuladores populares o EventServer não existe como binário separado — a lógica de eventos vive dentro do próprio GameServer, em módulos internos configurados por arquivos como BloodCastle.txt, DevilSquare.txt, EventItemBag.txt e similares. Nessas distribuições, "separar o EventServer" significa outra coisa (rodar um segundo GameServer só para eventos, ou usar um subserver dedicado). Já em distribuições mais parrudas — algumas linhas de Season 6+ e emuladores comerciais — existe de fato um processo EventServer.exe (ou nome equivalente) que pode ser instanciado à parte. Isso varia por emulador, e o primeiro passo é descobrir em qual dos dois mundos você está.

Por que isolar eventos do GameServer

A motivação central é de desempenho e estabilidade. Quando 300 jogadores entram simultaneamente em um Devil Square dividido em várias salas, o processo precisa alocar centenas de monstros, rodar suas rotinas de IA, checar colisões e disparar timers — tudo no mesmo loop principal que também atende movimentação, chat, trades e combate do mundo aberto. Um EventServer dedicado dá a esse trabalho o seu próprio processo (e, idealmente, seus próprios núcleos de CPU), reduzindo a interferência.

Os benefícios práticos:

O ponto sobre crash isolado é o mais subestimado: se a lógica de um evento customizado tem um bug de memória, num modelo embutido ela derruba o servidor inteiro; num modelo isolado, no pior caso cai apenas o EventServer, e os jogadores no mundo aberto seguem jogando enquanto você reinicia só aquele processo.

Pré-requisitos

Antes de começar, garanta que você tem:

• Um servidor de MU Online já funcional e estável com GameServer, DataServer, JoinServer e ConnectServer rodando. Se ainda não chegou nesse ponto, comece pelo guia base de como criar servidor de MU Online.
• Acesso administrativo à máquina (VPS ou dedicado), de preferência Windows Server, com permissão para abrir portas no firewall.
• Conhecimento de qual emulador/distribuição você usa e se ele suporta EventServer separado. Consulte a documentação do seu pack.
• Backup completo da pasta do servidor e do banco de dados antes de qualquer alteração.
• Um editor de texto que não corrompa encoding (Notepad++ ou VS Code), pois arquivos .txt/.ini de MU são sensíveis a codificação.
• SQL Server com o banco (MuOnline/MuOnline padrão) acessível via DSN ODBC 32-bit.

> Nunca faça essa migração diretamente em produção sem testar antes em ambiente de homologação. A ligação entre EventServer e GameServer envolve portas e ServerCodes que, se errados, deixam os eventos silenciosamente quebrados.

Descobrindo o modelo do seu emulador

Antes de configurar, identifique o cenário. Abra a pasta raiz do servidor e verifique a presença de binários e configs de evento:

MuServer/
├── DataServer/
├── JoinServer/
├── ConnectServer/
├── GameServer/
│   ├── GameServer.exe
│   └── Data/
│       ├── BloodCastle.txt        ← lógica embutida
│       ├── DevilSquare.txt
│       └── ChaosCastle.txt
└── EventServer/                   ← existe? (nem sempre)
    ├── EventServer.exe
    └── EventServer.ini

• Se existe uma pasta EventServer/ com binário próprio: seu emulador suporta EventServer dedicado nativamente. Você vai configurá-lo e ligá-lo ao GameServer.
• Se os eventos são só arquivos dentro de GameServer/Data/: não há EventServer separado. A estratégia equivalente é rodar um segundo GameServer dedicado a eventos (arquitetura de subserver), o que cobrimos na seção de alternativa.

Configurando o EventServer dedicado

Assumindo um emulador com EventServer.exe próprio, os passos típicos são:

1. Copie e organize a pasta. Garanta que a pasta EventServer/ está na raiz do servidor, ao lado das demais.
2. Configure a conexão com o DataServer. O EventServer precisa ler e gravar dados (recompensas, status), então ele aponta para o mesmo DataServer do GameServer. Exemplo comum de EventServer.ini (os nomes de chave variam por emulador):

[EventServer]
Port=55910                 ; porta do próprio EventServer (interna)
ServerName=EventServer

[DataServer]
DataServerIP=127.0.0.1
DataServerPort=55557       ; mesmo DataServer usado pelo GameServer

[Link]
GameServerIP=127.0.0.1
GameServerPort=55901       ; GameServer que este EventServer atende

[Database]
DSN=MuOnline               ; mesmo banco de todos os processos

1. Ajuste os arquivos de definição de evento. Dependendo da distribuição, os arquivos como BloodCastle.txt, DevilSquare.txt, ChaosCastle.txt, Crywolf.txt passam a ser lidos pelo EventServer em vez do GameServer. Confirme na documentação qual pasta Data/ ele consome.
2. Defina os horários dos eventos. Ainda que a lógica rode no EventServer, os horários costumam ser configurados em um agendador (por exemplo, EventTimer.txt ou Schedule.txt). Um exemplo genérico:

; Formato comum: Evento  Hora  Minuto  Ativo
; (varia por emulador — sempre confira o cabeçalho do arquivo)
BloodCastle   00 00 1
BloodCastle   02 00 1
DevilSquare   01 00 1
ChaosCastle   03 00 1
Crywolf       20 00 1

Ligando o EventServer ao GameServer

Essa é a etapa mais delicada. O GameServer precisa saber para onde encaminhar os pedidos de evento, e o EventServer precisa aceitar as conexões vindas do(s) GameServer(s). A comunicação é feita por sockets TCP em portas locais.

1. No GameServer, aponte o endereço do EventServer. Em muitas distros existe um bloco assim no GameServer.ini:

[EventServer]
EnableExternalEventServer=1   ; usa EventServer separado em vez do embutido
EventServerIP=127.0.0.1
EventServerPort=55910         ; deve bater com a porta do EventServer.ini

1. Garanta que o ServerCode bate. Se você tem multi-server, cada GameServer tem um ServerCode. O EventServer precisa reconhecer esses códigos para direcionar as recompensas ao servidor certo.
2. Respeite a ordem de inicialização. A sequência correta evita que um processo suba antes da sua dependência:

1. DataServer      (acesso ao banco)
2. EventServer     (precisa do DataServer no ar)
3. JoinServer
4. GameServer      (conecta ao EventServer já ativo)
5. ConnectServer

1. Abra as portas internas apenas localmente. As portas de EventServer, DataServer e JoinServer são de comunicação interna e não devem ser expostas à internet:

# Porta do EventServer — uso interno; NÃO abrir para a internet.
# Se GameServer e EventServer estão em máquinas diferentes,
# libere a porta APENAS para o IP do GameServer:
netsh advfirewall firewall add rule name="MU EventServer" dir=in action=allow protocol=TCP localport=55910 remoteip=127.0.0.1

EventServer em máquina separada (arquitetura distribuída)

Para servidores realmente grandes, o EventServer pode viver em outra VPS. Nesse caso, além de trocar 127.0.0.1 pelos IPs reais, você precisa liberar a porta do EventServer apenas para o IP do GameServer (e vice-versa nas respostas), e garantir baixa latência entre as máquinas — de preferência no mesmo datacenter. Latência alta entre GameServer e EventServer se traduz em atraso na entrada de salas e na entrega de recompensas, o que é péssima experiência para o jogador.

Alternativa: GameServer dedicado a eventos

Se seu emulador não tem EventServer separado, a solução equivalente é rodar um segundo GameServer exclusivo para eventos, compartilhando o mesmo banco. Os jogadores são teleportados para esse "servidor de eventos" ao entrar em Blood Castle/Devil Square, e voltam ao servidor principal ao sair. Isso exige portas distintas por GameServer, ServerCodes únicos e configuração no ConnectServer/ServerList. É mais trabalhoso, mas atinge o mesmo objetivo de isolamento de carga.

Quando usar (e quando não usar)

Adote EventServer dedicado quando: seu servidor passa de algumas centenas de jogadores simultâneos; você observa picos de CPU claramente correlacionados com horários de evento; você roda eventos customizados pesados; ou você já opera multi-server e quer centralizar a lógica de eventos. Evite essa complexidade se seu servidor é pequeno ou recém-lançado — nesse estágio, o EventServer embutido é mais simples de manter e o gargalo real quase sempre está em outro lugar (banco, rede, ou configuração de rates).

Erros comuns e soluções

Checklist de lançamento

• Backup completo do servidor e do banco antes de iniciar
• Confirmado se o emulador suporta EventServer dedicado ou exige GameServer de eventos
• EventServer.ini apontando para o DataServer e DSN corretos
• Porta do EventServer definida e batendo nos dois lados (EventServer e GameServer)
• GameServer.ini com EventServer externo habilitado e IP:porta corretos
• ServerCodes alinhados em todos os processos (se multi-server)
• Ordem de inicialização configurada (DataServer → EventServer → JoinServer → GameServer → ConnectServer)
• Portas internas bloqueadas para a internet (apenas 127.0.0.1 ou IP do GameServer)
• Horários de todos os eventos testados um a um em homologação
• Recompensas chegando ao personagem correto após vencer o evento
• Teste de crash: derrubar o EventServer e confirmar que o mundo aberto segue online
• Monitoramento de CPU comparando antes/depois da separação

Com o EventServer isolado e corretamente ligado ao GameServer, você ganha um servidor mais resiliente em horário de pico: eventos pesados deixam de arrastar a jogabilidade geral, e uma falha em um evento customizado não significa mais derrubar todo mundo. Suba a mudança primeiro em homologação, valide evento por evento, e só então promova para produção.

Perguntas frequentes