sevenx_engine 0.2.11

// SevenX Engine - Android Complete Demo
// Demonstração completa de recursos Android: touch, sensores, gestos, vibração

use sevenx_engine::{
    Engine, EngineConfig, GameState,
    input::InputHandler,
    world::World,
    ui::render_text,
};

#[cfg(target_os = "android")]
use sevenx_engine::android::{
    AdvancedAndroidManager, GestureType, SwipeDirection, VibrationIntensity,
};



struct AndroidDemo {
    #[cfg(target_os = "android")]
    android: AdvancedAndroidManager,
    
    score: u32,
    time: f32,
    message: String,
}

impl GameState for AndroidDemo {
    fn new() -> Self {
        println!("🤖 SevenX Android Complete Demo");
        println!("📱 Touch, Gestos, Sensores e mais!");
        
        #[cfg(target_os = "android")]
        {
            let mut android = AdvancedAndroidManager::new();
            
            // Cria joystick virtual
            android.input.create_virtual_joystick(100.0, 450.0, 50.0);
            
            // Solicita permissões
            android.permissions.request(sevenx_engine::android::Permission::Storage);
            
            // Salva dados
            android.storage.save("high_score", "1000");
            
            Self {
                android,
                score: 0,
                time: 0.0,
                message: "Toque na tela!".to_string(),
            }
        }
        
        #[cfg(not(target_os = "android"))]
        {
            Self {
                score: 0,
                time: 0.0,
                message: "Execute no Android!".to_string(),
            }
        }
    }

    fn update(&mut self, dt: f32, _input: &InputHandler, _world: &mut World) {
        self.time += dt;
        
        #[cfg(target_os = "android")]
        {
            // Atualiza sistema Android
            self.android.update();
            
            // Processa toques
            let touches = self.android.input.get_touches();
            if !touches.is_empty() {
                self.message = format!("{} toques ativos", touches.len());
                
                // Vibra no toque
                self.android.vibration.vibrate(50);
            }
            
            // Processa gestos
            for gesture in self.android.gestures.get_gestures() {
                match gesture.gesture_type {
                    GestureType::Tap => {
                        self.score += 10;
                        self.message = "Tap detectado!".to_string();
                        self.android.vibration.vibrate_with_intensity(30, VibrationIntensity::Light);
                    }
                    GestureType::DoubleTap => {
                        self.score += 50;
                        self.message = "Double Tap!".to_string();
                        self.android.vibration.vibrate_with_intensity(50, VibrationIntensity::Medium);
                    }
                    GestureType::LongPress => {
                        self.message = "Long Press!".to_string();
                        self.android.vibration.vibrate_with_intensity(100, VibrationIntensity::Heavy);
                    }
                    GestureType::Swipe(direction) => {
                        let dir_text = match direction {
                            SwipeDirection::Up => "Cima",
                            SwipeDirection::Down => "Baixo",
                            SwipeDirection::Left => "Esquerda",
                            SwipeDirection::Right => "Direita",
                        };
                        self.message = format!("Swipe: {}", dir_text);
                        self.score += 20;
                    }
                    GestureType::Pinch(pinch_type) => {
                        self.message = format!("Pinch: {:?}", pinch_type);
                    }
                    GestureType::Rotate => {
                        self.message = "Rotação detectada!".to_string();
                    }
                }
            }
            
            // Joystick virtual
            let (axis_x, axis_y) = self.android.input.get_virtual_joystick_axis();
            if axis_x.abs() > 0.1 || axis_y.abs() > 0.1 {
                self.message = format!("Joystick: {:.2}, {:.2}", axis_x, axis_y);
            }
            
            // Acelerômetro
            let accel = self.android.input.get_accelerometer();
            if accel.x.abs() > 5.0 || accel.y.abs() > 5.0 {
                self.message = "Dispositivo sacudido!".to_string();
                self.score += 5;
            }
            
            // Bateria
            if let Some(battery) = self.android.input.get_battery() {
                if battery.level < 0.15 {
                    self.message = "⚠️ Bateria baixa!".to_string();
                }
            }
            
            // Conectividade
            if !self.android.connectivity.is_connected() {
                self.message = "❌ Sem conexão".to_string();
            }
        }
    }

    fn draw(&mut self, _world: &World, pixels: &mut [u8]) {
        // Título
        render_text(
            "SevenX Android Demo",
            250,
            20,
            [255, 255, 255, 255],
            pixels,
            800,
        );
        
        // Score
        let score_text = format!("Score: {}", self.score);
        render_text(&score_text, 20, 60, [0, 255, 0, 255], pixels, 800);
        
        // Mensagem
        render_text(&self.message, 20, 100, [255, 255, 0, 255], pixels, 800);
        
        #[cfg(target_os = "android")]
        {
            // Info de toques
            let touches = self.android.input.get_touches();
            let touch_text = format!("Toques: {}", touches.len());
            render_text(&touch_text, 20, 140, [200, 200, 255, 255], pixels, 800);
            
            // Acelerômetro
            let accel = self.android.input.get_accelerometer();
            let accel_text = format!("Accel: {:.1}, {:.1}, {:.1}", accel.x, accel.y, accel.z);
            render_text(&accel_text, 20, 180, [255, 200, 200, 255], pixels, 800);
            
            // Bateria
            if let Some(battery) = self.android.input.get_battery() {
                let battery_text = format!(
                    "Bateria: {:.0}% {}",
                    battery.level * 100.0,
                    if battery.is_charging { "⚡" } else { "" }
                );
                let battery_color = if battery.level > 0.5 {
                    [0, 255, 0, 255]
                } else if battery.level > 0.2 {
                    [255, 255, 0, 255]
                } else {
                    [255, 0, 0, 255]
                };
                render_text(&battery_text, 20, 220, battery_color, pixels, 800);
            }
            
            // FPS
            let fps = self.android.performance.get_target_fps();
            let fps_text = format!("FPS: {}", fps);
            render_text(&fps_text, 20, 260, [150, 150, 255, 255], pixels, 800);
            
            // Orientação
            let orientation = if self.android.orientation.is_landscape() {
                "Landscape"
            } else {
                "Portrait"
            };
            render_text(orientation, 20, 300, [200, 150, 255, 255], pixels, 800);
            
            // Conectividade
            let conn_text = if self.android.connectivity.is_wifi() {
                "WiFi 📶"
            } else if self.android.connectivity.is_mobile() {
                "Mobile 📱"
            } else {
                "Offline ❌"
            };
            render_text(conn_text, 20, 340, [255, 200, 100, 255], pixels, 800);
            
            // Instruções
            render_text(
                "Gestos:",
                20,
                400,
                [180, 180, 180, 255],
                pixels,
                800,
            );
            render_text(
                "• Tap: +10 pontos",
                20,
                430,
                [150, 150, 150, 255],
                pixels,
                800,
            );
            render_text(
                "• Double Tap: +50 pontos",
                20,
                460,
                [150, 150, 150, 255],
                pixels,
                800,
            );
            render_text(
                "• Swipe: +20 pontos",
                20,
                490,
                [150, 150, 150, 255],
                pixels,
                800,
            );
            render_text(
                "• Sacudir: +5 pontos",
                20,
                520,
                [150, 150, 150, 255],
                pixels,
                800,
            );
        }
        
        #[cfg(not(target_os = "android"))]
        {
            render_text(
                "Este exemplo deve ser executado no Android!",
                150,
                300,
                [255, 100, 100, 255],
                pixels,
                800,
            );
        }
    }
}

fn main() {
    println!("🚀 Iniciando SevenX Android Complete Demo");
    
    let config = EngineConfig::new()
        .with_title("SevenX Android Complete")
        .with_size(800, 600);
    
    Engine::with_config(config).run::<AndroidDemo>();
}