# 🌐 Sistema de Multiplayer - SevenX Engine
Sistema completo de multiplayer com sincronização, predição e suporte 2D/3D.
## 🚀 Início Rápido
### 1. Adicione ao Cargo.toml
```toml
[dependencies]
sevenx_engine = { version = "0.2.7", features = ["multiplayer"] }
```
### 2. Crie um Host
```rust
use sevenx_engine::*;
let mut network = NetworkManager::create_host("player1", "Meu Nome");
```
### 3. Atualize a Posição
```rust
// A cada frame
network.update_player_position(x, y, z);
network.tick(dt);
```
### 4. Renderize Outros Jogadores
```rust
for player in network.get_all_players() {
let (x, y, z) = player.position;
// Desenhe o jogador em (x, y, z)
}
```
## 🎮 Exemplo Completo 2D
```rust
use sevenx_engine::*;
struct MultiplayerGame {
network: NetworkManager,
pos: (f32, f32),
}
impl GameState for MultiplayerGame {
fn new() -> Self {
Self {
network: NetworkManager::create_host("player1", "Host"),
pos: (400.0, 300.0),
}
}
fn update(&mut self, dt: f32, input: &InputHandler, _world: &mut World) {
// Movimento
if input.is_key_down(KeyCode::KeyW) { self.pos.1 -= 200.0 * dt; }
if input.is_key_down(KeyCode::KeyS) { self.pos.1 += 200.0 * dt; }
if input.is_key_down(KeyCode::KeyA) { self.pos.0 -= 200.0 * dt; }
if input.is_key_down(KeyCode::KeyD) { self.pos.0 += 200.0 * dt; }
// Sincroniza
self.network.update_player_position(self.pos.0, self.pos.1, 0.0);
self.network.tick(dt);
}
fn draw(&mut self, _world: &World, frame_buffer: &mut [u8]) {
// Desenha todos os jogadores
for player in self.network.get_all_players() {
// Desenhe círculo em player.position
}
}
}
fn main() {
Engine::new().run::<MultiplayerGame>();
}
```
## 🎯 Exemplo FPS 3D
```rust
use sevenx_engine::*;
struct FPSGame {
network: NetworkManager,
camera: Camera3D,
}
impl GameState for FPSGame {
fn new() -> Self {
Self {
network: NetworkManager::create_host("player1", "Host"),
camera: Camera3D::new(800, 600),
}
}
fn update(&mut self, dt: f32, input: &InputHandler, _world: &mut World) {
// Movimento FPS
let forward = Vec3::new(
self.camera.yaw.sin(),
0.0,
self.camera.yaw.cos()
);
if input.is_key_down(KeyCode::KeyW) {
self.camera.position = self.camera.position + forward * 5.0 * dt;
}
// Mouse
let (dx, dy) = input.get_mouse_delta();
self.camera.yaw += dx as f32 * 0.002;
self.camera.pitch -= dy as f32 * 0.002;
// Sincroniza
self.network.update_player_position(
self.camera.position.x,
self.camera.position.y,
self.camera.position.z
);
self.network.update_player_rotation(
self.camera.pitch,
self.camera.yaw,
0.0
);
// Atirar
if input.is_mouse_button_pressed(MouseBtn::Left) {
let dir = Vec3::new(
self.camera.yaw.sin() * self.camera.pitch.cos(),
-self.camera.pitch.sin(),
self.camera.yaw.cos() * self.camera.pitch.cos()
);
self.network.send_shoot(
(self.camera.position.x, self.camera.position.y, self.camera.position.z),
(dir.x, dir.y, dir.z)
);
}
self.network.tick(dt);
}
fn draw(&mut self, _world: &World, frame_buffer: &mut [u8]) {
// Renderiza outros jogadores
for player in self.network.get_all_players() {
if player.id == self.network.player_id {
continue; // Não renderiza próprio jogador
}
// Crie mesh do jogador e renderize
}
}
}
```
## 🏠 Sistema de Lobby
```rust
// Configurar lobby
let lobby = LobbyInfo {
name: "Meu Lobby".to_string(),
max_players: 8,
is_public: true,
game_mode: "Deathmatch".to_string(),
map: "arena_01".to_string(),
password: None,
};
network.update_lobby(lobby);
// Sistema de ready
network.set_ready(true);
if network.all_players_ready() {
println!("Todos prontos! Iniciando...");
}
// Times
network.change_team("Red");
let red_team = network.get_team_players("Red");
```
## 💬 Chat
```rust
// Chat global
network.send_chat("Olá a todos!", ChatChannel::Global);
// Chat de time
network.send_chat("Vamos atacar!", ChatChannel::Team);
// Whisper (privado)
network.send_chat("Mensagem secreta", ChatChannel::Whisper("player2".to_string()));
```
## 🎮 Ações
```rust
// Ação genérica
network.send_player_action("jump", vec![]);
// Tiro (FPS)
network.send_shoot(origin, direction);
// Interação
network.send_interact("target_player_id");
```
## 📊 Estatísticas
```rust
println!("Jogadores: {}", network.player_count());
println!("Packets enviados: {}", network.stats.packets_sent);
println!("Packets recebidos: {}", network.stats.packets_received);
println!("Ping médio: {}ms", network.stats.average_ping);
```
## ⚙️ Configuração
```rust
// Taxa de sincronização (Hz)
network.set_sync_rate(30); // 30 atualizações por segundo
// Predição (recomendado)
network.set_prediction(true);
```
## 🌐 Servidor Dedicado
```rust
#[cfg(feature = "multiplayer")]
use sevenx_engine::NetworkServer;
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let addr = "0.0.0.0:8080".parse()?;
let mut server = NetworkServer::new(addr).await?;
println!("Servidor iniciado em: {}", addr);
loop {
server.accept().await?;
// Broadcast de estado
let msg = NetworkMessage::GameState {
tick: 0,
data: vec![],
};
server.broadcast(msg).await;
tokio::time::sleep(tokio::time::Duration::from_millis(33)).await;
}
}
```
## 🚀 Executar Exemplos
```bash
# Multiplayer 2D
cargo run --example multiplayer_demo
# FPS Multiplayer 3D
cargo run --example fps_multiplayer
# Servidor dedicado
cargo run --example dedicated_server --features multiplayer
```
## 📚 Documentação Completa
Veja [MULTIPLAYER_GUIDE.md](MULTIPLAYER_GUIDE.md) para documentação completa.
## 🎯 Features
- ✅ Sincronização automática de posição
- ✅ Interpolação suave
- ✅ Predição do cliente
- ✅ Sistema de lobby
- ✅ Times
- ✅ Chat (global, time, whisper)
- ✅ Estatísticas de rede
- ✅ Suporte 2D e 3D
- ✅ Networking real (QUIC)
- ✅ Servidor dedicado
## 💡 Dicas
1. **Sempre chame `tick()`** a cada frame
2. **Use predição** para movimento suave
3. **Configure taxa de sincronização** (20-30 Hz é suficiente)
4. **Valide ações no servidor** se você é o host
5. **Monitore ping** para detectar lag
## 🐛 Problemas Comuns
### Jogadores não aparecem
```rust
// Certifique-se de chamar tick()
network.tick(dt);
```
### Movimento travado
```rust
// Habilite predição
network.set_prediction(true);
// Envie velocidade
network.update_player_velocity(vx, vy, vz);
```
### Lag alto
```rust
// Aumente taxa de sincronização
network.set_sync_rate(60);
// Verifique ping
for player in network.get_all_players() {
println!("{}: {}ms", player.name, player.ping);
}
```
---
**Divirta-se criando jogos multiplayer! 🎮🌐**