Tutorial: Criando Game Servers

Aprenda a criar e configurar game servers para a plataforma

📋 Índice

🎯 1. Visão Geral

Sobre Este Tutorial

Este tutorial usa Counter-Strike 1.6 como exemplo prático, mas todos os conceitos e estruturas podem ser adaptados para qualquer tipo de game server (Minecraft, Unreal Tournament, Half-Life, etc.).

Os exemplos de código, configurações e scripts são específicos do Counter-Strike, mas a metodologia é universal.

Este tutorial ensina como criar game servers personalizados para a plataforma Game Server Manager. Você aprenderá a:

  • ✅ Criar a estrutura de arquivos necessária
  • ✅ Configurar o arquivo de metadados
  • ✅ Criar templates de configuração
  • ✅ Implementar scripts de controle
  • ✅ Adicionar banners personalizados
  • ✅ Empacotar tudo em um arquivo ZIP
  • ✅ Instalar na plataforma

📝 Pré-requisitos

  • Conhecimento básico de JSON
  • Conhecimento básico de HTML/CSS
  • Conhecimento básico de JavaScript
  • Editor de texto (VS Code, Sublime Text, etc.)
  • Conhecimento do jogo específico que você quer criar servidor

⚠️ Importante

Embora os exemplos sejam de Counter-Strike, você deve adaptar:

  • Executáveis: Use os binários do seu jogo específico
  • Configurações: Adapte comandos e parâmetros para seu jogo
  • Scripts: Modifique caminhos e comandos conforme necessário
  • Templates: Crie interfaces específicas para seu jogo

📁 2. Estrutura de Arquivos

Todo game server deve seguir uma estrutura específica de arquivos. Aqui está a estrutura completa:

meu-game-server/
├── config.json                      # Metadados do servidor
├── config_template.html             # Template de configuração
├── config_schema.json               # Schema de validação JSON
├── config_script.js                 # Script JavaScript para interatividade
├── config_files_template.json       # Templates de arquivos do servidor
├── config_custom_content.json       # Configuração de conteúdo customizado
├── start.sh                         # Script de inicialização
├── stop.sh                          # Script de parada
├── restart.sh                       # Script de reinicialização
├── health_check.sh                  # Script de verificação de saúde
├── banner.jpg                       # Banner do servidor (opcional)
├── file_templates/                  # Pasta com templates de arquivos
│   ├── server.cfg                   # Configuração principal
│   ├── mapcycle.txt                 # Lista de mapas
│   ├── motd.txt                     # Mensagem do dia
│   ├── banned.cfg                   # Lista de banidos
│   └── ...                          # Outros arquivos de configuração
└── server_files/                    # Pasta com arquivos do servidor
    ├── executables/                 # Executáveis do jogo
    ├── configs/                     # Configurações padrão
    ├── maps/                        # Mapas do jogo
    ├── models/                      # Modelos 3D
    ├── sounds/                      # Arquivos de áudio
    └── ...                          # Outros arquivos do servidor

📋 Arquivos Obrigatórios vs Opcionais:

  • Obrigatórios: config.json, config_template.html, start.sh, stop.sh, restart.sh, health_check.sh
  • Opcionais: config_schema.json, config_script.js, config_files_template.json, config_custom_content.json, banner.jpg
  • Pastas: file_templates/ e server_files/ são opcionais mas recomendadas

⚠️ Importante

Todos os arquivos principais devem estar na raiz do ZIP. As pastas file_templates/ e server_files/ podem conter subarquivos.

⚙️ 3. Arquivo config.json

O arquivo config.json contém os metadados do seu game server:

{
    "handle": "meu-game-server",
    "server_name": "Meu Game Server",
    "server_description": "Descrição do meu servidor de jogo",
    "banner_image": "banner.jpg",
    "is_active": true
}

📋 Campos Obrigatórios:

  • handle: Identificador único (sem espaços, apenas letras, números e hífens)
  • server_name: Nome exibido do servidor
  • server_description: Descrição detalhada do servidor
  • banner_image: Nome do arquivo do banner (opcional)
  • is_active: Se o servidor está ativo (true/false)

📋 4. Arquivo config_schema.json

O arquivo config_schema.json define a validação e estrutura dos dados de configuração:

{
    "type": "object",
    "properties": {
        "ServerName": {
            "type": "string",
            "minLength": 1,
            "maxLength": 100,
            "description": "Nome do servidor que aparecerá na lista"
        },
        "ServerPort": {
            "type": "integer",
            "minimum": 1024,
            "maximum": 65535,
            "description": "Porta do servidor para conexões"
        },
        "MaxPlayers": {
            "type": "integer",
            "minimum": 1,
            "maximum": 32,
            "description": "Número máximo de jogadores"
        },
        "MapName": {
            "type": "string",
            "enum": ["de_dust2", "de_inferno", "cs_office"],
            "description": "Mapa inicial do servidor"
        },
        "FriendlyFire": {
            "type": "boolean",
            "description": "Permitir fogo amigo"
        }
    },
    "required": ["ServerName", "ServerPort", "MaxPlayers"]
}

📋 Tipos de Validação Suportados:

  • string: Texto com minLength/maxLength
  • integer: Números inteiros com minimum/maximum
  • boolean: true/false
  • enum: Lista de valores permitidos
  • required: Campos obrigatórios

💡 Dicas para Schema:

  • Use descrições claras para cada campo
  • Defina limites realistas (ex: portas 1024-65535)
  • Enum é útil para mapas, modos de jogo, etc.
  • Required deve incluir apenas campos essenciais

⚡ 5. Arquivo config_script.js

O arquivo config_script.js adiciona interatividade ao template de configuração:

// Exemplo de script de configuração
class ServerConfig {
    constructor() {
        this.setupEventListeners();
    }

    setupEventListeners() {
        // Mudança de mapa
        const mapSelect = document.getElementById('MapName');
        if (mapSelect) {
            mapSelect.addEventListener('change', () => {
                this.onMapChange();
            });
        }

        // Mudança de jogadores
        const maxPlayersInput = document.getElementById('MaxPlayers');
        if (maxPlayersInput) {
            maxPlayersInput.addEventListener('change', () => {
                this.onMaxPlayersChange();
            });
        }
    }

    onMapChange() {
        const selectedMap = document.getElementById('MapName').value;
        console.log('Mapa selecionado:', selectedMap);
        
        // Ajustar configurações baseadas no mapa
        this.updateMapSpecificSettings(selectedMap);
    }

    onMaxPlayersChange() {
        const maxPlayers = parseInt(document.getElementById('MaxPlayers').value);
        
        // Ajustar bot quota se necessário
        const botQuota = document.getElementById('BotQuota');
        if (botQuota && botQuota.value > maxPlayers) {
            botQuota.value = Math.max(0, maxPlayers - 1);
            this.showNotification('Número de bots ajustado', 'warning');
        }
    }

    showNotification(message, type = 'info') {
        // Criar notificação visual
        const notification = document.createElement('div');
        notification.className = `alert alert-${type}`;
        notification.textContent = message;
        document.body.appendChild(notification);
        
        setTimeout(() => notification.remove(), 5000);
    }
}

// Inicializar quando a página carregar
document.addEventListener('DOMContentLoaded', () => {
    new ServerConfig();
});

💡 Funcionalidades Úteis:

  • Validação em tempo real: Verificar valores conforme o usuário digita
  • Ajustes automáticos: Modificar campos relacionados automaticamente
  • Notificações: Alertar sobre configurações problemáticas
  • Dependências: Habilitar/desabilitar campos baseados em outros

🎨 6. Template de Configuração

O arquivo config_template.html define a interface de configuração do servidor:

<!DOCTYPE html>
<html>
<head>
    <title>Configuração - </title>
    <style>
        .config-container { max-width: 800px; margin: 0 auto; padding: 20px; }
        .form-group { margin-bottom: 15px; }
        .form-group label { display: block; margin-bottom: 5px; font-weight: bold; }
        .form-group input, .form-group select { width: 100%; padding: 8px; }
    </style>
</head>
<body>
    <div class="config-container">
        <h1></h1>
        <p></p>
        
        <form id="configForm">
            <div class="form-group">
                <label for="maxPlayers">Máximo de Jogadores:</label>
                <input type="number" id="maxPlayers" name="maxPlayers" value="16" min="1" max="64">
            </div>
            
            <div class="form-group">
                <label for="mapName">Mapa Padrão:</label>
                <select id="mapName" name="mapName">
                    <option value="de_dust2">de_dust2</option>
                    <option value="de_inferno">de_inferno</option>
                    <option value="de_mirage">de_mirage</option>
                </select>
            </div>
            
            <div class="form-group">
                <label for="gameMode">Modo de Jogo:</label>
                <select id="gameMode" name="gameMode">
                    <option value="classic">Clássico</option>
                    <option value="gungame">Gun Game</option>
                    <option value="deathmatch">Deathmatch</option>
                </select>
            </div>
        </form>
    </div>
</body>
</html>

💡 Dicas para Templates:

  • Use e para exibir informações dinâmicas
  • Mantenha o design responsivo
  • Use IDs únicos para os campos de formulário
  • Inclua validação básica nos campos
  • Organize campos em seções lógicas
  • Use Bootstrap ou CSS moderno para estilização

📄 7. Pasta file_templates/

A pasta file_templates/ contém templates de arquivos de configuração que serão processados dinamicamente:

file_templates/
├── server.cfg           # Configuração principal do servidor
├── mapcycle.txt         # Lista de mapas para rotação
├── motd.txt             # Mensagem do dia
├── banned.cfg           # Lista de jogadores banidos
├── listip.cfg           # Lista de IPs banidos
├── listid.cfg           # Lista de Steam IDs banidos
└── amxx.cfg             # Configuração do AMX Mod X

Exemplo: server.cfg

// Configuração do servidor Counter-Strike
hostname ""
sv_password ""
rcon_password ""
sv_lan 0
sv_region 
maxplayers 
mp_timelimit 
mp_fraglimit 
mp_friendlyfire 
mp_autoteambalance 
mp_allowspectators 
mp_roundtime 
mp_freezetime 
mp_buytime 
mp_c4timer 
mp_startmoney 
mp_maxmoney 
mp_killreward 
mp_tkpenalty 
bot_quota 
bot_difficulty 
log on
sv_logbans 1
sv_logecho 1

💡 Variáveis de Template:

  • : Nome do servidor
  • : Máximo de jogadores
  • : Tempo limite da partida
  • : Fogo amigo (0/1)
  • : Balanceamento automático (0/1)
  • E muitas outras...

⚠️ Importante sobre Templates:

  • Use variáveis entre chaves duplas:
  • Valores booleanos devem ser 0 ou 1
  • Mantenha comentários explicativos
  • Teste os templates com dados reais

🎮 8. Pasta server_files/

A pasta server_files/ contém todos os arquivos necessários para executar o servidor:

server_files/
├── executables/         # Executáveis do servidor
│   ├── hlds_linux      # Servidor Linux
│   ├── hlds.exe         # Servidor Windows
│   └── steamclient.so   # Cliente Steam
├── configs/            # Configurações padrão
│   ├── server.cfg      # Config padrão
│   └── mapcycle.txt    # Lista de mapas padrão
├── maps/               # Mapas do jogo (.bsp)
│   ├── de_dust2.bsp
│   ├── de_inferno.bsp
│   └── cs_office.bsp
├── models/             # Modelos 3D
├── sounds/             # Arquivos de áudio
├── sprites/            # Sprites da interface
├── logs/               # Arquivos de log
└── addons/             # Plugins e mods
    ├── metamod/
    └── amxmodx/

💡 Estrutura Recomendada:

  • executables/: Todos os binários do servidor
  • configs/: Arquivos de configuração padrão
  • maps/: Mapas do jogo (.bsp)
  • models/: Modelos 3D de jogadores/armas
  • sounds/: Efeitos sonoros e música
  • addons/: Plugins como Metamod e AMX Mod X

⚠️ Considerações Importantes:

  • Inclua apenas arquivos essenciais para reduzir o tamanho
  • Verifique licenças dos arquivos incluídos
  • Teste se todos os executáveis funcionam
  • Mantenha estrutura de pastas consistente

🎨 9. Arquivo config_custom_content.json

O arquivo config_custom_content.json define categorias de conteúdo customizado que usuários podem fazer upload:

[
    {
        "name": "Maps",
        "handle": "maps",
        "server_path": "cstrike/maps",
        "description": "Mapas customizados (.bsp) para Counter-Strike",
        "is_active": true
    },
    {
        "name": "Models",
        "handle": "models",
        "server_path": "cstrike/models",
        "description": "Modelos 3D customizados para Counter-Strike",
        "is_active": true
    },
    {
        "name": "Sounds",
        "handle": "sounds",
        "server_path": "cstrike/sound",
        "description": "Arquivos de áudio customizados",
        "is_active": true
    },
    {
        "name": "Plugins",
        "handle": "plugins",
        "server_path": "cstrike/addons/metamod/plugins",
        "description": "Plugins do Metamod",
        "is_active": true
    }
]

📋 Campos de Custom Content:

  • name: Nome exibido da categoria
  • handle: Identificador único (sem espaços)
  • server_path: Caminho no servidor onde os arquivos serão colocados
  • description: Descrição da categoria
  • is_active: Se a categoria está ativa

💡 Exemplos de Categorias Úteis:

  • Maps: Para mapas customizados (.bsp)
  • Models: Para modelos 3D (.mdl)
  • Sounds: Para efeitos sonoros (.wav)
  • Sprites: Para sprites da interface (.spr)
  • Configs: Para arquivos de configuração
  • Plugins: Para plugins e mods

📋 9.5. Arquivo config_files_template.json

O arquivo config_files_template.json define quais arquivos de template estão disponíveis para edição:

[
    {
        "name": "server.cfg",
        "description": "Arquivo de configuração principal do servidor Counter-Strike",
        "server_path": "cstrike/server.cfg",
        "is_active": true
    },
    {
        "name": "mapcycle.txt",
        "description": "Lista de mapas para rotação automática",
        "server_path": "cstrike/mapcycle.txt",
        "is_active": true
    },
    {
        "name": "motd.txt",
        "description": "Mensagem do dia exibida aos jogadores",
        "server_path": "cstrike/motd.txt",
        "is_active": true
    },
    {
        "name": "banned.cfg",
        "description": "Lista de jogadores banidos",
        "server_path": "cstrike/banned.cfg",
        "is_active": true
    }
]

📋 Campos de File Template:

  • name: Nome exibido do arquivo
  • description: Descrição do que o arquivo faz
  • server_path: Caminho onde o arquivo será criado no servidor
  • is_active: Se o template está ativo

💡 Dicas para File Templates:

  • Inclua apenas arquivos que usuários podem editar
  • Use descrições claras sobre a função de cada arquivo
  • Mantenha server_path consistente com a estrutura do jogo
  • Desative templates que não são necessários

🔧 10. Scripts de Controle

Cada game server precisa de scripts para controle básico:

start.sh

#!/bin/bash
# Script de inicialização do servidor

# Configurações
SERVER_DIR="/path/to/server"
EXECUTABLE="./server_executable"
CONFIG_FILE="server.cfg"
PORT=${PORT:-7777}

# Verificar se o servidor já está rodando
if pgrep -f "$EXECUTABLE" > /dev/null; then
    echo "Servidor já está rodando!"
    exit 1
fi

# Navegar para o diretório do servidor
cd "$SERVER_DIR" || exit 1

# Iniciar o servidor
echo "Iniciando servidor na porta $PORT..."
$EXECUTABLE +port $PORT +exec $CONFIG_FILE &

# Salvar PID
echo $! > server.pid
echo "Servidor iniciado com PID: $!"

stop.sh

#!/bin/bash
# Script de parada do servidor

SERVER_DIR="/path/to/server"
PID_FILE="server.pid"

# Navegar para o diretório do servidor
cd "$SERVER_DIR" || exit 1

# Verificar se existe arquivo PID
if [ -f "$PID_FILE" ]; then
    PID=$(cat "$PID_FILE")
    
    # Verificar se o processo ainda existe
    if kill -0 "$PID" 2>/dev/null; then
        echo "Parando servidor (PID: $PID)..."
        kill "$PID"
        
        # Aguardar parada
        sleep 2
        
        # Forçar parada se necessário
        if kill -0 "$PID" 2>/dev/null; then
            echo "Forçando parada..."
            kill -9 "$PID"
        fi
        
        echo "Servidor parado."
    else
        echo "Servidor não está rodando."
    fi
    
    # Remover arquivo PID
    rm -f "$PID_FILE"
else
    echo "Arquivo PID não encontrado."
fi

restart.sh

#!/bin/bash
# Script de reinicialização do servidor

echo "Reiniciando servidor..."

# Parar o servidor
./stop.sh

# Aguardar um pouco
sleep 2

# Iniciar novamente
./start.sh

echo "Reinicialização concluída."

health_check.sh

#!/bin/bash
# Script de verificação de saúde do servidor

SERVER_DIR="/path/to/server"
PID_FILE="server.pid"
PORT=${PORT:-7777}

# Navegar para o diretório do servidor
cd "$SERVER_DIR" || exit 1

# Verificar se o processo está rodando
if [ -f "$PID_FILE" ]; then
    PID=$(cat "$PID_FILE")
    
    if kill -0 "$PID" 2>/dev/null; then
        # Verificar se a porta está respondendo
        if netstat -ln | grep ":$PORT " > /dev/null; then
            echo "Servidor está funcionando corretamente"
            exit 0
        else
            echo "Servidor está rodando mas a porta não está respondendo"
            exit 1
        fi
    else
        echo "Servidor não está rodando"
        exit 1
    fi
else
    echo "Arquivo PID não encontrado"
    exit 1
fi

⚠️ Importante sobre Scripts:

  • Todos os scripts devem ter permissão de execução
  • Use caminhos absolutos quando possível
  • Implemente tratamento de erros
  • Salve o PID do processo para controle

📦 12. Criando o ZIP

Após criar todos os arquivos, empacote-os em um arquivo ZIP:

1

Organize os Arquivos

Certifique-se de que todos os arquivos estão na mesma pasta:

  • config.json
  • config_template.html
  • start.sh
  • stop.sh
  • restart.sh
  • health_check.sh
  • banner.jpg (se aplicável)
2

Crie o ZIP

Selecione todos os arquivos e crie um arquivo ZIP:

# No Linux/Mac
zip -r meu-game-server.zip *

# No Windows
# Selecione os arquivos, clique com botão direito
# Escolha "Enviar para" → "Pasta compactada"
3

Verifique o Conteúdo

Abra o ZIP e confirme que todos os arquivos estão na raiz:

meu-game-server.zip
├── config.json
├── config_template.html
├── start.sh
├── stop.sh
├── restart.sh
├── health_check.sh
└── banner.jpg

⚠️ Erros Comuns:

  • ❌ Arquivos dentro de subpastas
  • ❌ Nomes de arquivo com espaços
  • ❌ Arquivos corrompidos
  • ❌ Scripts sem permissão de execução

🚀 13. Instalação

Para instalar seu game server na plataforma:

1

Acesse a Plataforma

Faça login na plataforma Game Server Manager

2

Vá para Game Servers

Navegue até a seção "Game Servers"

3

Clique em "Instalar"

Clique no botão "Instalar" ou "Upload ZIP"

4

Selecione o Arquivo

Escolha o arquivo ZIP do seu game server

5

Aguarde a Instalação

A plataforma processará e instalará o servidor

6

Verifique a Instalação

Confirme que o servidor aparece na lista

📚 14. Exemplos Práticos

Exemplo de Referência

Os exemplos abaixo são específicos do Counter-Strike 1.6 e servem apenas como referência. Adapte os conceitos para o seu jogo específico.

Aqui estão alguns exemplos de game servers que você pode usar como referência:

🎯 Counter-Strike 1.6 - Exemplo Completo (Referência)

Handle: counter-strike

Descrição: Servidor clássico de Counter-Strike 1.6

Nota: Este é apenas um exemplo - adapte para seu jogo!

📁 Arquivos Principais:

  • config.json: Metadados do servidor
  • config_template.html: Interface de configuração completa
  • config_schema.json: Validação de 25+ campos
  • config_script.js: Interatividade avançada
  • banner.jpg: Banner promocional do CS

📄 Templates de Arquivos:

  • server.cfg: Configuração principal com 50+ comandos
  • mapcycle.txt: Lista de mapas para rotação
  • motd.txt: Mensagem do dia personalizada
  • banned.cfg: Sistema de banimentos
  • amxx.cfg: Configuração do AMX Mod X

🎮 Arquivos do Servidor:

  • hlds_linux: Executável do servidor
  • steamclient.so: Cliente Steam
  • maps/: 15+ mapas clássicos (.bsp)
  • models/: Modelos de jogadores e armas
  • sounds/: Efeitos sonoros do jogo

🎨 Conteúdo Customizado:

  • Maps: Upload de mapas customizados
  • Models: Modelos 3D personalizados
  • Sounds: Efeitos sonoros customizados
  • Plugins: Plugins do Metamod/AMX Mod X

🏆 Unreal Tournament 4 - Exemplo de Adaptação

Handle: ut4server

Descrição: Servidor de Unreal Tournament 4

Adaptações necessárias:

  • Executável: UnrealTournamentServer.exe (ao invés de hlds_linux)
  • Configuração: Game.ini e Engine.ini (ao invés de server.cfg)
  • Scripts: Comandos específicos do UT4
  • Porta padrão: 7777 (ao invés de 27015)
  • Mapas: Arquivos .umap (ao invés de .bsp)

🧱 Minecraft - Exemplo de Adaptação

Handle: minecraft-server

Descrição: Servidor de Minecraft

Adaptações necessárias:

  • Executável: java -jar minecraft_server.jar
  • Configuração: server.properties (ao invés de server.cfg)
  • Scripts: Comandos Java específicos
  • Porta padrão: 25565
  • Arquivos: world/, plugins/, mods/

💡 Dicas para Adaptação:

  • Estude a documentação do seu jogo específico
  • Adapte os scripts para os executáveis e comandos corretos
  • Modifique os templates para as configurações do seu jogo
  • Teste extensivamente antes de publicar
  • Use exemplos funcionais como base, mas personalize

🔧 15. Solução de Problemas

❌ Problemas Comuns e Soluções:

Erro: "Arquivo config.json não encontrado"

Solução: Verifique se o arquivo está na raiz do ZIP e tem o nome correto.

Erro: "Script não tem permissão de execução"

Solução: Execute chmod +x *.sh antes de criar o ZIP.

Erro: "Handle já existe"

Solução: Altere o campo "handle" no config.json para um valor único.

Erro: "Banner não encontrado"

Solução: Verifique se o nome do arquivo no config.json corresponde ao arquivo real.

Servidor não inicia

Solução: Verifique os caminhos nos scripts e se os executáveis existem.

Template não carrega

Solução: Verifique a sintaxe HTML e se todas as tags estão fechadas.

Erro: "Schema de validação inválido"

Solução: Verifique se o JSON do config_schema.json está válido e se os tipos estão corretos.

Erro: "Script JavaScript não funciona"

Solução: Verifique se os IDs dos elementos no HTML correspondem aos do JavaScript.

Erro: "Arquivos de template não encontrados"

Solução: Verifique se a pasta file_templates/ existe e contém os arquivos listados no config_files_template.json.

Erro: "Conteúdo customizado não aparece"

Solução: Verifique se o config_custom_content.json está válido e se os caminhos server_path estão corretos.

Servidor não encontra executáveis

Solução: Verifique se os executáveis estão na pasta server_files/ e têm permissão de execução.

Variáveis de template não são substituídas

Solução: Use a sintaxe correta e verifique se os nomes correspondem ao schema.

🆘 Precisa de Ajuda?

Se você ainda está com problemas:

  • Verifique os logs da plataforma
  • Teste os scripts manualmente
  • Compare com exemplos funcionais
  • Consulte a documentação do jogo específico