Netty Fluent TCP Game Server

Uma aplicação Java que funciona como uma fluent API para um servidor TCP usando Netty, especialmente projetado para jogos online. O servidor suporta criptografia AES-256 e processamento separado de pacotes através de handlers modulares.

🚀 Características

• Fluent API: Interface intuitiva e fácil de usar para configuração do servidor
• Criptografia AES-256: Protege a comunicação entre cliente e servidor
• Processamento Modular: Handlers separados para diferentes tipos de pacotes
• Suporte Completo a Jogos: Pacotes específicos para autenticação, movimento de jogadores, chat, etc.
• Alta Performance: Baseado no framework Netty para máxima eficiência
• Configuração Flexível: Threads, timeouts, logging e criptografia configuráveis

📦 Estrutura do Projeto

src/main/java/com/gameserver/
├── GameServer.java                    # Classe principal com fluent API
├── GameServerApplication.java         # Aplicação de exemplo
├── packet/
│   ├── GamePacket.java               # Classe de pacote com serialização JSON
│   └── PacketType.java               # Enum com tipos de pacotes
├── crypto/
│   └── PacketCrypto.java             # Sistema de criptografia AES-256
├── handler/
│   ├── PacketHandler.java            # Interface para handlers
│   ├── PacketHandlerRegistry.java    # Registro de handlers
│   └── impl/
│       ├── AuthenticationHandler.java # Handler de autenticação
│       └── PlayerHandler.java        # Handler de jogadores
├── codec/
│   ├── GamePacketDecoder.java        # Decoder Netty
│   └── GamePacketEncoder.java        # Encoder Netty
├── netty/
│   └── GameServerHandler.java        # Handler principal do Netty
└── client/
    └── GameClient.java               # Cliente de exemplo

🛠️ Instalação e Execução

Pré-requisitos

• Java 11 ou superior
• Maven 3.6 ou superior

Compilar o Projeto

mvn clean compile

Executar o Servidor

mvn exec:java -Dexec.mainClass="com.gameserver.GameServerApplication"

Executar o Cliente de Teste

mvn exec:java -Dexec.mainClass="com.gameserver.client.GameClient"

Gerar JAR Executável

mvn package
java -jar target/netty-fluent-tcp-server-1.0.0.jar

💻 Uso da Fluent API

Exemplo Básico

GameServer server = GameServer.create()
    .port(8080)                    // Define a porta
    .encryption(true)              // Habilita criptografia
    .withDefaultHandlers()         // Usa handlers padrão
    .start();                      // Inicia o servidor

// Aguarda encerramento
server.awaitTermination();

Configuração Avançada

GameServer server = GameServer.create()
    .port(9090)
    .encryption(true)
    .encryptionKey("sua-chave-base64-aqui")  // Chave específica
    .bossThreads(2)                          // 2 threads para aceitar conexões
    .workerThreads(8)                        // 8 threads para I/O
    .logging(true)                           // Logging do Netty
    .idleTimeout(600)                        // Timeout de 10 minutos
    .withDefaultHandlers()
    .registerHandler(new CustomHandler())    // Handler customizado
    .start();

📡 Tipos de Pacotes Suportados

Conexão e Autenticação

• CONNECT - Conexão inicial
• DISCONNECT - Desconexão
• AUTHENTICATION - Autenticação do usuário
• AUTHENTICATION_RESPONSE - Resposta de autenticação
• HEARTBEAT - Manutenção da conexão

Jogador

• PLAYER_JOIN - Jogador entra na sala
• PLAYER_LEAVE - Jogador sai da sala
• PLAYER_MOVE - Movimento do jogador
• PLAYER_UPDATE - Atualização do jogador
• PLAYER_ACTION - Ação do jogador
• PLAYER_CHAT - Chat do jogador

Jogo

• GAME_START - Início do jogo
• GAME_END - Fim do jogo
• GAME_STATE - Estado do jogo
• GAME_UPDATE - Atualização do jogo
• GAME_EVENT - Evento do jogo

Sistema

• ERROR - Erro
• SUCCESS - Sucesso
• NOTIFICATION - Notificação
• BROADCAST - Transmissão

🔒 Criptografia

O servidor usa criptografia AES-256-CBC para proteger a comunicação:

// Servidor com criptografia habilitada (chave gerada automaticamente)
GameServer server = GameServer.create()
    .encryption(true)
    .start();

// Usar chave específica
GameServer server = GameServer.create()
    .encryptionKey("sua-chave-base64")
    .start();

// Desabilitar criptografia
GameServer server = GameServer.create()
    .encryption(false)
    .start();

🎯 Criando Handlers Customizados

public class CustomHandler implements PacketHandler {
    @Override
    public boolean canHandle(GamePacket packet) {
        return packet.getType() == PacketType.CUSTOM;
    }
    
    @Override
    public void handle(ChannelHandlerContext ctx, GamePacket packet) {
        String customData = packet.getDataAsString("customData");
        
        // Processa o pacote customizado
        GamePacket response = new GamePacket(PacketType.SUCCESS)
            .withPlayerId(packet.getPlayerId())
            .withData("processed", true)
            .withData("originalData", customData);
        
        ctx.writeAndFlush(response);
    }
    
    @Override
    public int getPriority() {
        return 100; // Prioridade (menor = maior prioridade)
    }
    
    @Override
    public String getHandlerName() {
        return "CustomHandler";
    }
}

// Registrar o handler
server.registerHandler(new CustomHandler());

📝 Criando e Enviando Pacotes

No Cliente

// Pacote de autenticação
GamePacket authPacket = new GamePacket(PacketType.AUTHENTICATION)
    .withPlayerId("player123")
    .withData("username", "jogador1")
    .withData("password", "123456");

client.sendPacket(authPacket);

// Pacote de movimento
GamePacket movePacket = new GamePacket(PacketType.PLAYER_MOVE)
    .withPlayerId("player123")
    .withData("x", 100.5)
    .withData("y", 200.0)
    .withData("z", 50.25)
    .withData("roomId", "sala001");

client.sendPacket(movePacket);

No Servidor (Handler)

// Criar resposta
GamePacket response = new GamePacket(PacketType.SUCCESS)
    .withPlayerId(originalPacket.getPlayerId())
    .withData("success", true)
    .withData("message", "Operação realizada com sucesso");

ctx.writeAndFlush(response);

🔧 Configuração

Parâmetros do Servidor

Parâmetro	Padrão	Descrição
port	8080	Porta do servidor
encryption	true	Habilita/desabilita criptografia
encryptionKey	null	Chave de criptografia personalizada
bossThreads	1	Threads para aceitar conexões
workerThreads	0 (auto)	Threads para processamento I/O
logging	true	Logging do Netty
idleTimeout	300	Timeout de inatividade (segundos)

Logging

O projeto usa Logback. Configure os níveis de log em src/main/resources/logback.xml:

<!-- Log da aplicação -->
<logger name="com.gameserver" level="DEBUG"/>

<!-- Log do Netty -->
<logger name="io.netty" level="INFO"/>

🧪 Teste

Executar o Servidor

mvn exec:java -Dexec.mainClass="com.gameserver.GameServerApplication"

Executar o Cliente

mvn exec:java -Dexec.mainClass="com.gameserver.client.GameClient"

Comandos do Cliente de Teste

1. Connect - Conecta ao servidor
2. Authenticate - Autentica com credenciais
3. Join Room - Entra em uma sala
4. Move Player - Move o jogador
5. Send Chat - Envia mensagem de chat
6. Start Game - Inicia um jogo
7. Heartbeat - Envia heartbeat
8. Custom Packet - Envia pacote customizado

🎮 Integração com Go Lang

Este servidor Java foi projetado para trabalhar com clientes Go. O formato de pacotes JSON e o sistema de criptografia AES-256 são compatíveis com implementações Go.

Exemplo de Cliente Go

type GamePacket struct {
    Type      string                 `json:"type"`
    PlayerId  string                 `json:"playerId"`
    Data      map[string]interface{} `json:"data"`
    Timestamp int64                  `json:"timestamp"`
}

// Enviar pacote de autenticação
packet := GamePacket{
    Type:     "AUTHENTICATION",
    PlayerId: "player123",
    Data: map[string]interface{}{
        "username": "jogador1",
        "password": "123456",
    },
    Timestamp: time.Now().UnixMilli(),
}

📚 Dependências

• Netty 4.1.122.Final - Framework de rede
• Jackson 2.16.1 - Serialização JSON
• SLF4J + Logback - Sistema de logging
• JUnit 5 - Testes (opcional)

🤝 Contribuição

1. Fork o projeto
2. Crie uma branch para sua feature (git checkout -b feature/nova-feature)
3. Commit suas mudanças (git commit -am 'Adiciona nova feature')
4. Push para a branch (git push origin feature/nova-feature)
5. Abra um Pull Request

📄 Licença

Este projeto está licenciado sob a Apache License 2.0 - veja o arquivo LICENSE para detalhes.

🔍 Troubleshooting

Problemas Comuns

1. Porta já em uso: Mude a porta usando .port(outra_porta)
2. Problemas de criptografia: Verifique se cliente e servidor usam a mesma chave
3. Timeout de conexão: Ajuste o idleTimeout conforme necessário
4. Performance: Ajuste bossThreads e workerThreads para seu hardware

Logs Úteis

# Ver logs em tempo real
tail -f logs/gameserver.log

# Filtrar logs por nível
grep "ERROR" logs/gameserver.log

---