sevenx_engine 0.2.11

# 🎨 Guia de Assets - SevenX Engine


## 📋 Como Usar Seus Próprios Assets


A SevenX Engine permite que você use qualquer asset (imagens, sons, etc.) no seu jogo!

## 🖼️ Sprites e Imagens


### Formatos Suportados

- PNG (recomendado - suporta transparência)
- JPEG
- BMP
- GIF
- TIFF
- WebP

### Estrutura Recomendada


```
meu_jogo/
├── assets/
│   ├── sprites/
│   │   ├── player/
│   │   │   ├── idle.png
│   │   │   ├── walk.png
│   │   │   └── attack.png
│   │   ├── enemies/
│   │   │   ├── goblin.png
│   │   │   └── skeleton.png
│   │   └── items/
│   │       ├── coin.png
│   │       └── potion.png
│   ├── tilesets/
│   │   ├── ground.png
│   │   └── walls.png
│   ├── sounds/
│   │   ├── jump.wav
│   │   └── coin.wav
│   └── music/
│       └── theme.ogg
```

## 📖 Exemplos de Uso


### 1. Carregando um Sprite Simples


```rust
use sevenx_engine::sprite::SpriteSheet;

// Carrega uma imagem de 32x32 pixels
let sprite = SpriteSheet::load("assets/sprites/player/idle.png", 32, 32)
    .expect("Falha ao carregar sprite");
```

### 2. Sprite Sheet com Múltiplas Frames


```rust
// Sprite sheet com frames de 64x64
// A imagem pode ter várias frames lado a lado
let sprite_sheet = SpriteSheet::load("assets/sprites/player/walk.png", 64, 64)?;

// Se sua imagem tem 4 frames horizontais de 64x64:
// [Frame1][Frame2][Frame3][Frame4]
// A imagem total seria 256x64 pixels
```

### 3. Usando Sprite Placeholder (Sem Assets)


```rust
// Cria um sprite colorido automaticamente (útil para protótipos)
let placeholder = SpriteSheet::create_placeholder();
```

### 4. Carregando Assets do Jogador


```rust
use sevenx_engine::*;

fn setup_player(world: &mut World) {
    let mut player = GameObject::new(100.0, 100.0, ObjectType::Player);

    // Carrega diferentes sprites para diferentes ações
    if let Ok(idle_sprite) = SpriteSheet::load("assets/player/idle.png", 32, 32) {
        player.sheets.insert(PlayerAction::Idle, idle_sprite);
    } else {
        // Fallback para placeholder se o arquivo não existir
        player.sheets.insert(PlayerAction::Idle, SpriteSheet::create_placeholder());
    }

    if let Ok(walk_sprite) = SpriteSheet::load("assets/player/walk.png", 32, 32) {
        player.sheets.insert(PlayerAction::Walk, walk_sprite);
    } else {
        player.sheets.insert(PlayerAction::Walk, SpriteSheet::create_placeholder());
    }

    world.add_object(player);
}
```

### 5. Resource Manager (Recomendado)


```rust
use sevenx_engine::ResourceManager;

struct Game {
    resources: ResourceManager,
}

impl Game {
    fn load_assets(&mut self) {
        // Carrega e cacheia sprites
        self.resources.load_sprite_sheet(
            "player_idle",
            "assets/player/idle.png",
            32,
            32
        ).ok();

        self.resources.load_sprite_sheet(
            "player_walk",
            "assets/player/walk.png",
            32,
            32
        ).ok();

        self.resources.load_sprite_sheet(
            "enemy",
            "assets/enemies/goblin.png",
            48,
            48
        ).ok();
    }

    fn create_player(&self) -> GameObject {
        let mut player = GameObject::new(100.0, 100.0, ObjectType::Player);

        // Usa sprites do cache
        if let Some(idle) = self.resources.get_sprite_sheet("player_idle") {
            player.sheets.insert(PlayerAction::Idle, idle.clone());
        }

        if let Some(walk) = self.resources.get_sprite_sheet("player_walk") {
            player.sheets.insert(PlayerAction::Walk, walk.clone());
        }

        player
    }
}
```

## 🎨 Criando Sprite Sheets


### Formato de Sprite Sheet


Uma sprite sheet é uma imagem que contém múltiplas frames:

```
Exemplo: walk.png (192x32 pixels)
┌────────┬────────┬────────┬────────┬────────┬────────┐
│ Frame1 │ Frame2 │ Frame3 │ Frame4 │ Frame5 │ Frame6 │
│  32x32 │  32x32 │  32x32 │  32x32 │  32x32 │  32x32 │
└────────┴────────┴────────┴────────┴────────┴────────┘
```

### Ferramentas Recomendadas


- **Aseprite** - Editor de pixel art (pago)
- **Piskel** - Editor online gratuito
- **GIMP** - Editor gratuito
- **Photoshop** - Editor profissional

### Dicas para Sprite Sheets


1. **Tamanho consistente**: Todas as frames devem ter o mesmo tamanho
2. **Transparência**: Use PNG com canal alpha
3. **Organização**: Frames da esquerda para direita
4. **Múltiplas linhas**: Você pode ter várias linhas (ex: linha 0 = andar para baixo, linha 1 = andar para cima)

## 🎵 Áudio (Preparação para Futuro)


```rust
use sevenx_engine::AudioSystem;

let mut audio = AudioSystem::new();

// Carrega sons
audio.load_sound("jump", "assets/sounds/jump.wav").ok();
audio.load_sound("coin", "assets/sounds/coin.wav").ok();

// Toca efeitos
audio.play_sfx("jump");
audio.play_sfx("coin");

// Música de fundo
audio.play_music("theme", true); // true = loop
```

## 🗺️ Tilesets


```rust
use sevenx_engine::Tilemap;

let mut tilemap = Tilemap::new(20, 15, 32, 32);

// Carrega tileset
tilemap.load_tileset("assets/tilesets/ground.png").ok();

// Define tiles
tilemap.set_tile(0, 0, Some(Tile::new(0))); // Tile ID 0
tilemap.set_tile(1, 0, Some(Tile::new(1))); // Tile ID 1
```

## 📦 Assets Gratuitos


### Onde Encontrar Assets Gratuitos


1. **OpenGameArt.org** - https://opengameart.org/
2. **Itch.io** - https://itch.io/game-assets/free
3. **Kenney.nl** - https://kenney.nl/assets (excelente!)
4. **CraftPix** - https://craftpix.net/freebies/

### Licenças Comuns


- **CC0** - Domínio público, use como quiser
- **CC-BY** - Dê crédito ao autor
- **MIT** - Use livremente, mantenha a licença

## 🚀 Exemplo Completo


```rust
use sevenx_engine::*;

struct MeuJogo {
    resources: ResourceManager,
}

impl GameState for MeuJogo {
    fn new() -> Self {
        let mut game = MeuJogo {
            resources: ResourceManager::new(),
        };
        
        game.load_all_assets();
        game
    }

    fn update(&mut self, dt: f32, input: &InputHandler, world: &mut World) {
        // Cria mundo na primeira vez
        if world.game_objects.is_empty() {
            self.setup_world(world);
        }

        // Sua lógica aqui
    }

    fn draw(&mut self, _world: &World, _pixels: &mut [u8]) {}
}

impl MeuJogo {
    fn load_all_assets(&mut self) {
        println!("📦 Carregando assets...");

        // Tenta carregar, mas não falha se não existir
        self.resources.load_sprite_sheet(
            "player",
            "assets/player.png",
            32,
            32
        ).ok();

        println!("✅ Assets carregados!");
    }

    fn setup_world(&self, world: &mut World) {
        let mut player = GameObject::new(100.0, 100.0, ObjectType::Player);

        // Usa asset se disponível, senão usa placeholder
        if let Some(sprite) = self.resources.get_sprite_sheet("player") {
            player.sheets.insert(PlayerAction::Idle, sprite.clone());
        } else {
            player.sheets.insert(PlayerAction::Idle, SpriteSheet::create_placeholder());
        }

        world.add_object(player);
    }
}

fn main() {
    Engine::new().run::<MeuJogo>();
}
```

## 💡 Dicas


1. **Comece com placeholders**: Desenvolva a lógica primeiro, adicione arte depois
2. **Use ResourceManager**: Evita carregar o mesmo asset múltiplas vezes
3. **Trate erros**: Sempre tenha um fallback se o asset não carregar
4. **Organize bem**: Mantenha uma estrutura de pastas clara
5. **Otimize**: Use PNG com compressão para reduzir tamanho

## 🎯 Próximos Passos


1. Crie sua pasta `assets/`
2. Adicione seus sprites
3. Carregue-os no seu jogo
4. Divirta-se criando!