sevenx_engine 0.2.4

Engine de jogos 2D completa com física, áudio, partículas, tilemap, UI e eventos.
Documentation

SevenX Engine

Uma engine de jogos 2D moderna e minimalista, baseada em pixels, feita em Rust. Ideal para aprendizado, prototipagem rápida e desenvolvimento de jogos 2D.

✨ Funcionalidades (v0.2.4) 🎉

Core

  • 🎮 Sistema de Componentes: Arquitetura flexível baseada em componentes (Transform, Physics, Collider)
  • 🎨 Renderização 2D: Controle de baixo nível do buffer de pixels com suporte a transparência
  • 📷 Sistema de Câmera: Viewport com zoom, scroll e seguimento suave de alvos
  • 🎯 Sistema de Layers: Z-index para controle de profundidade de renderização

Física e Colisão

  • ⚡ Sistema de Física: Velocidade, aceleração, gravidade e arrasto configuráveis
  • 💥 Detecção de Colisão: AABB (Axis-Aligned Bounding Box) com suporte a triggers
  • 🌍 Gravidade Global: Configurável por mundo

Sprites e Animação

  • 🖼️ Sprite Sheets: Carregamento e gerenciamento de sprite sheets
  • 🎬 Sistema de Animação: Animações baseadas em frames com múltiplas ações e direções
  • 💾 Resource Manager: Cache de texturas para melhor performance

Áudio 🔊 NOVO

  • 🎵 Sistema de Áudio: Reprodução de música e efeitos sonoros
  • 🔉 Controle de Volume: Volume independente para música e SFX
  • 💿 Cache de Sons: Gerenciamento eficiente de recursos de áudio

Tilemap e Níveis 🗺️ NOVO

  • 🧱 Sistema de Tilemap: Renderização de níveis baseados em grid
  • 🚧 Tiles Sólidos: Colisão com tiles para plataformas
  • 💾 Serialização: Salvar/carregar níveis em JSON ou TOML
  • 🎨 Editor de Níveis: Ferramentas para criar níveis

Partículas ✨ NOVO

  • 💥 Sistema de Partículas: Explosões, fumaça, brilhos e efeitos customizados
  • 🎆 Emissores: Burst (explosão) e stream (contínuo)
  • 🌈 Alpha Blending: Transparência suave
  • ⚙️ Configurações: Presets prontos e customizáveis

UI 🖼️ NOVO

  • 🔘 Botões: Botões interativos com hover
  • 📝 Texto: Renderização de texto bitmap 8x8
  • 🎨 Primitivas: Retângulos, bordas e formas básicas

Eventos 📡 NOVO

  • 🎯 Sistema de Eventos: Eventos customizáveis com callbacks
  • 📬 Fila de Eventos: Processamento assíncrono
  • 🎮 Eventos Pré-definidos: PlayerDied, CoinCollected, LevelComplete, etc.

Input e Configuração

  • ⌨️ Input Handling: Sistema de captura de eventos de teclado
  • 🎮 Suporte a Gamepad: Botões e eixos analógicos com deadzone NOVO
  • ⚙️ Engine Config: Configuração customizável de janela, gravidade e cores

🚀 Instalação

Adicione ao seu Cargo.toml:

[dependencies]
sevenx_engine = "0.2.4"

📖 Exemplo Básico

use sevenx_engine::{
    game_object::{Direction, ObjectType, PlayerAction},
    input::InputHandler,
    world::World,
    Engine, EngineConfig, GameState, KeyCode,
};

struct MyGame;

impl GameState for MyGame {
    fn new() -> Self {
        MyGame
    }

    fn update(&mut self, dt: f32, input: &InputHandler, world: &mut World) {
        // Sua lógica de jogo aqui
        if let Some(player) = world.game_objects.iter_mut()
            .find(|obj| obj.object_type == ObjectType::Player)
        {
            let speed = 200.0;
            
            if input.is_key_pressed(KeyCode::ArrowRight) {
                player.transform.translate(speed * dt, 0.0);
                player.current_action = PlayerAction::Walk;
                player.facing_direction = Direction::Right;
            }
        }
    }

    fn draw(&mut self, _world: &World, _pixels: &mut [u8]) {
        // Renderização automática pelo Renderer
    }
}

fn main() {
    let config = EngineConfig::new()
        .with_title("Meu Jogo")
        .with_size(800, 600)
        .with_gravity(980.0);

    Engine::with_config(config).run::<MyGame>();
}

🎯 Exemplos Avançados

Física e Gravidade

use sevenx_engine::{Physics, Collider, GameObject};

// Cria um objeto com física
let mut player = GameObject::new(100.0, 100.0, ObjectType::Player)
    .with_physics(Physics::new()
        .with_gravity(1.0)      // Afetado pela gravidade
        .with_drag(0.1))        // Resistência do ar
    .with_collider(Collider::new(32.0, 32.0))
    .with_z_index(10);

Sistema de Câmera

// Seguir o jogador suavemente
if let Some(player) = world.game_objects.iter()
    .find(|obj| obj.object_type == ObjectType::Player)
{
    let (px, py) = player.transform.position;
    engine.get_camera_mut().follow(px, py, 5.0, dt);
}

// Zoom
engine.get_camera_mut().set_zoom(2.0);

Resource Manager

use sevenx_engine::ResourceManager;

let mut resources = ResourceManager::new();

// Carrega e cacheia sprites
resources.load_sprite_sheet("player_idle", "assets/idle.png", 32, 32)?;
resources.load_sprite_sheet("player_walk", "assets/walk.png", 32, 32)?;

// Reutiliza sprites do cache
if let Some(sprite) = resources.get_sprite_sheet("player_idle") {
    // Usa o sprite
}

🏗️ Arquitetura

A SevenX Engine usa uma arquitetura baseada em componentes:

GameObject
├── Transform (posição, rotação, escala)
├── Physics (opcional - velocidade, aceleração)
├── Collider (opcional - detecção de colisão)
├── Sprites (sprite sheets por ação)
└── Animations (animações por direção)

📚 Módulos

  • animation - Sistema de animação de sprites
  • camera - Controle de viewport e câmera
  • collision - Detecção de colisão AABB
  • config - Configuração da engine
  • game_object - Entidades do jogo
  • game_state - Trait para estados de jogo
  • input - Gerenciamento de input
  • physics - Sistema de física 2D
  • renderer - Renderização de pixels
  • resource_manager - Cache de recursos
  • sprite - Sprite sheets
  • transform - Transformações espaciais
  • world - Gerenciamento de objetos

🎮 Exemplos Incluídos

Execute os exemplos com:

cargo run --example jogo_teste       # Exemplo básico
cargo run --example physics_demo     # Demo de física
cargo run --example tilemap_demo     # Demo de tilemap
cargo run --example particles_demo   # Demo de partículas
cargo run --example events_demo      # Demo de eventos
cargo run --example complete_game    # Jogo completo
cargo run --example level_editor     # Editor de níveis

🛣️ Roadmap

  • Sistema de áudio (música e efeitos sonoros) ✅ v0.2.1
  • Carregamento de níveis via arquivos (JSON/TOML) ✅ v0.2.1
  • Sistema de partículas ✅ v0.2.1
  • Tilemap e tile editor ✅ v0.2.1
  • Sistema de UI básico ✅ v0.2.1
  • Suporte a gamepad ✅ v0.2.1
  • Sistema de eventos customizáveis ✅ v0.2.1
  • Melhor suporte a rotação de sprites ✅ v0.2.3
  • Sistema de diálogos ✅ v0.2.3
  • Save/Load de progresso do jogo ✅ v0.2.3
  • Integração com bibliotecas de áudio reais (rodio) ✅ v0.2.3
  • Sistema de networking multiplayer
  • Shaders customizáveis
  • Sistema de conquistas/achievements
  • Suporte a controllers adicionais

🤝 Contribuindo

Contribuições são bem-vindas! Sinta-se à vontade para abrir issues ou pull requests.

📄 Licença

Este projeto é licenciado sob os termos da licença MIT ou Apache 2.0, à sua escolha.