# 🎮 FPS 3D Game - Guia Completo
## 🚀 Como Jogar
```bash
cargo run --example fps_3d_game
```
---
## 🎯 Controles
### Movimento
- **W** - Andar para frente
- **S** - Andar para trás
- **A** - Andar para esquerda (strafe)
- **D** - Andar para direita (strafe)
### Câmera
- **Setas ←→** - Girar câmera (yaw)
- **Setas ↑↓** - Olhar cima/baixo (pitch)
### Ação
- **SPACE** - Atirar
---
## 🎮 Gameplay
### Objetivo
Elimine todos os inimigos vermelhos no labirinto!
### Mecânicas
**Vida (HP)**
- Barra vermelha no topo esquerdo
- Começa com 100 HP
- Game over se chegar a 0
**Munição**
- Barra amarela no topo
- Começa com 30 balas
- Cada tiro consome 1 bala
**Inimigos**
- Cubos vermelhos que se movem
- 100 HP cada
- Se aproximam do jogador
- +100 pontos ao eliminar
**Score**
- Mostrado no topo direito
- Aumenta ao eliminar inimigos
---
## 🌟 Recursos Implementados
### Renderização 3D
- ✅ Software rasterizer
- ✅ Backface culling
- ✅ Projeção perspectiva
- ✅ Transformações 3D (rotação, escala, translação)
### Mundo 3D
- ✅ Labirinto com paredes
- ✅ Chão texturizado
- ✅ Múltiplos inimigos
- ✅ Sistema de colisão
### Player
- ✅ Movimento WASD
- ✅ Rotação de câmera
- ✅ Altura da câmera (1.0 unidade)
- ✅ Colisão com paredes
### Arma
- ✅ Modelo simples de arma
- ✅ Weapon sway (balanço ao andar)
- ✅ Recoil ao atirar
- ✅ Muzzle flash (flash do tiro)
### Sistema de Combate
- ✅ Raycast para detecção de hit
- ✅ Dano aos inimigos
- ✅ Sistema de vida
- ✅ Partículas de impacto
### Partículas 3D
- ✅ Explosão ao eliminar inimigo
- ✅ Faíscas ao acertar
- ✅ Muzzle flash ao atirar
- ✅ Até 500 partículas simultâneas
### IA dos Inimigos
- ✅ Movimento em direção ao jogador
- ✅ Rotação para encarar o jogador
- ✅ Detecção de distância
- ✅ Sistema de ativação/desativação
### HUD
- ✅ Barra de vida
- ✅ Contador de munição
- ✅ Score
- ✅ Crosshair (mira)
---
## 🎨 Elementos Visuais
### Cores
- **Céu**: Gradiente azul (20-80)
- **Chão**: Verde escuro (60, 80, 60)
- **Paredes**: Cinza (100, 100, 120)
- **Inimigos**: Vermelho (200, 50, 50)
- **Arma**: Cinza escuro (80, 80, 80)
- **Muzzle Flash**: Amarelo brilhante (255, 200, 0)
### Efeitos
- Weapon sway ao andar
- Recoil ao atirar
- Partículas de explosão
- Faíscas de impacto
- Gradiente de céu
---
## 🔧 Arquitetura Técnica
### Estruturas Principais
```rust
struct FPSGame {
renderer3d: Renderer3D, // Renderizador 3D
walls: Vec<Mesh3D>, // Paredes do labirinto
floor: Mesh3D, // Chão
enemies: Vec<Enemy>, // Inimigos
player_pos: Vec3, // Posição do jogador
player_yaw: f32, // Rotação horizontal
player_pitch: f32, // Rotação vertical
particles: ParticleSystem3D, // Sistema de partículas
health: i32, // Vida
ammo: i32, // Munição
score: i32, // Pontuação
}
struct Enemy {
mesh: Mesh3D, // Modelo 3D
position: Vec3, // Posição
health: i32, // Vida
active: bool, // Ativo/Morto
}
```
### Pipeline de Renderização
1. **Limpa tela** com gradiente de céu
2. **Renderiza chão**
3. **Renderiza paredes** do labirinto
4. **Renderiza inimigos** ativos
5. **Renderiza partículas** 3D
6. **Desenha arma** (2D overlay)
7. **Desenha HUD** (vida, munição, score)
8. **Desenha crosshair** (mira)
### Sistema de Colisão
```rust
fn check_collision(&self, x: f32, z: f32) -> bool {
// 1. Verifica limites do mapa
if x < -9.0 || x > 9.0 || z < -9.0 || z > 9.0 {
return true;
}
// 2. Verifica colisão com paredes internas
// (usando bounding boxes)
...
}
```
### Sistema de Disparo
```rust
fn shoot(&mut self) {
// 1. Consome munição
self.ammo -= 1;
// 2. Aplica recoil
self.weapon_recoil = 0.1;
// 3. Raycast para detectar hit
let ray_dir = Vec3::new(
self.player_yaw.sin(),
self.player_pitch,
self.player_yaw.cos(),
);
// 4. Verifica hit em inimigos
for enemy in &mut self.enemies {
if dot_product > 0.95 { // Hit!
enemy.health -= 50;
// Partículas de impacto
}
}
}
```
---
## 🎓 Aprendizados
Este exemplo demonstra:
1. **Renderização 3D básica** com software rasterizer
2. **Sistema de câmera FPS** (first-person)
3. **Colisão 3D** simples
4. **IA básica** de inimigos
5. **Sistema de combate** com raycast
6. **Partículas 3D** para efeitos
7. **HUD** e interface
8. **Game loop** completo
---
## 🚀 Melhorias Futuras
### Fácil
- [ ] Mais tipos de inimigos
- [ ] Power-ups (vida, munição)
- [ ] Sons de tiro e explosão
- [ ] Mais níveis/labirintos
### Médio
- [ ] Texturas nas paredes
- [ ] Iluminação dinâmica
- [ ] Sombras simples
- [ ] Animações de inimigos
### Avançado
- [ ] Multiplayer local
- [ ] Diferentes armas
- [ ] Sistema de física
- [ ] Fog of war
---
## 💡 Dicas
### Performance
- O exemplo roda a ~30-60 FPS
- Reduza partículas se estiver lento
- Use wireframe para debug
### Gameplay
- Fique em movimento constante
- Use as paredes como cobertura
- Mire com cuidado (munição limitada)
- Mantenha distância dos inimigos
### Debug
- Pressione ESC para sair
- Modifique `move_speed` para velocidade
- Ajuste `mouse_sensitivity` para sensibilidade
- Mude cores no código para personalizar
---
## 🎮 Comparação com Jogos Clássicos
Este exemplo é inspirado em:
- **Wolfenstein 3D** (1992) - Raycasting FPS
- **Doom** (1993) - Software rendering
- **Quake** (1996) - True 3D
Mas simplificado para fins educacionais!
---
## 📊 Estatísticas
- **Linhas de código**: ~500
- **Vértices renderizados**: ~200-300
- **Partículas máximas**: 500
- **Inimigos**: 5
- **Tamanho do mapa**: 20x20 unidades
---
## 🆘 Troubleshooting
### Tela preta?
- Verifique se está dentro do labirinto
- Use WASD para se mover
- Tente girar a câmera com as setas
### Performance ruim?
- Reduza `ParticleSystem3D::new(200)` para menos partículas
- Desative alguns inimigos
- Use `wireframe = true` para debug
### Inimigos não aparecem?
- Eles estão espalhados pelo mapa
- Use as setas para girar e procurar
- Eles se movem em sua direção
---
## 🎉 Parabéns!
Você agora tem um FPS 3D funcional feito do zero em Rust!
**Próximos passos:**
1. Modifique o código
2. Adicione seus próprios recursos
3. Crie seu próprio jogo!
**Divirta-se criando! 🚀🎮✨**