outfly/src/main.rs

mod actor;
mod audio;
mod camera;
mod chat;
mod commands;
mod effects;
mod hud;
mod shading;
mod var;
mod world;

#[allow(dead_code)]
mod nature;

use bevy::window::{Window, WindowMode, PrimaryWindow, CursorGrabMode};
use bevy::diagnostic::FrameTimeDiagnosticsPlugin;
use bevy::prelude::*;
use bevy_embedded_assets::{EmbeddedAssetPlugin, PluginMode};
use std::env;

fn main() {
    let args: Vec<String> = env::args().collect();
    if args.len() > 1 {
        if args[1] == "--version" || args[1] == "-v" {
            let version = option_env!("CARGO_PKG_VERSION").unwrap();
            let name = option_env!("CARGO_PKG_NAME").unwrap();
            let homepage = option_env!("CARGO_PKG_HOMEPAGE").unwrap();
            println!("{name} {version}");
            println!("License: GNU GPL version 3: https://gnu.org/licenses/gpl.html");
            println!("{homepage}");
            return;
        }
    }
    if cfg!(debug_assertions) {
        App::new().add_plugins(OutFlyPlugin).run();
    } else {
        // In release builds, embed assets into the binary
        App::new().add_plugins((
            EmbeddedAssetPlugin { mode: PluginMode::ReplaceDefault },
            OutFlyPlugin,
        )).run();
    }
}

pub struct OutFlyPlugin;
impl Plugin for OutFlyPlugin {
    fn build(&self, app: &mut App) {
        app.add_systems(Startup, setup);
        app.add_systems(Update, handle_input);
        app.add_systems(Update, debug);
        app.insert_resource(var::Settings::default());
        app.insert_resource(var::GameVars::default());
        app.add_plugins((
            DefaultPlugins,//.set(ImagePlugin::default_nearest()),
            FrameTimeDiagnosticsPlugin,

            actor::ActorPlugin,
            audio::AudioPlugin,
            camera::CameraPlugin,
            chat::ChatPlugin,
            commands::CommandsPlugin,
            effects::EffectsPlugin,
            hud::HudPlugin,
            world::WorldPlugin,
        ));
    }
}

fn setup(
    mut windows: Query<&mut Window, With<PrimaryWindow>>,
) {
    for mut window in &mut windows {
        window.cursor.grab_mode = CursorGrabMode::Locked;
        window.cursor.visible = false;
        window.mode = WindowMode::BorderlessFullscreen;
        window.title = "OutFly".to_string();
    }
}

fn handle_input(
    keyboard_input: Res<ButtonInput<KeyCode>>,
    settings: Res<var::Settings>,
    mut app_exit_events: ResMut<Events<bevy::app::AppExit>>,
    mut windows: Query<&mut Window, With<PrimaryWindow>>,
) {
    if keyboard_input.pressed(settings.key_exit) {
        app_exit_events.send(bevy::app::AppExit);
    }
    if keyboard_input.just_pressed(settings.key_fullscreen) {
        for mut window in &mut windows {
            window.mode = if window.mode == WindowMode::Windowed {
                WindowMode::BorderlessFullscreen
            } else {
                WindowMode::Windowed
            }
        }
    }
}

fn debug(
    settings: Res<var::Settings>,
    keyboard_input: Res<ButtonInput<KeyCode>>,
    mut commands: Commands,
    mut materials_custom: ResMut<Assets<shading::JupitersRing>>,
    materials: Query<(Entity, &Name, &Handle<StandardMaterial>)>,
) {
    if settings.dev_mode && keyboard_input.pressed(KeyCode::KeyP) {
        for (entity, name, mat) in &materials {
            dbg!(name);
            dbg!(mat);
            let mut entity = commands.entity(entity);
            entity.remove::<Handle<StandardMaterial>>();
            let ring_radius = 229_000_000.0;
            let jupiter_radius = 71_492_000.0;
            let material = materials_custom.add(shading::JupitersRing {
                alpha_mode: AlphaMode::Blend,
                ring_radius: ring_radius,
                jupiter_radius: jupiter_radius,
            });
            entity.insert(material);
        }
    }
}