6 files changed, 85 insertions(+), 8 deletions(-)

M crates/unified/src/client/mod.rs
M crates/unified/src/client/starguide/init.rs
M crates/unified/src/client/starguide/mod.rs
A crates/unified/src/client/starguide/orbit.rs
M crates/unified/src/client/zoom.rs
M crates/unified/src/ecs.rs

@@ 2,6 2,7 @@ use crate::client::key_input::key_input_plugin;
 use crate::client::parts::parts_plugin;
 use crate::client::planet::indicators::indicators_plugin;
 use crate::client::starfield::starfield_plugin;
+use crate::client::starguide::orbit::starguide_orbit_plugin;
 use crate::client::ui::ui_plugin;
 use crate::client::zoom::zoom_plugin;
 use crate::client::starguide::init::starguide_init_plugin;


@@ 58,6 59,7 @@ impl Plugin for ClientPlugin {
             .add_plugins(client_attachment_plugin)
             .add_plugins(starguide_init_plugin)
             .add_plugins(starguide_input_plugin)
+            .add_plugins(starguide_orbit_plugin)
             .insert_state(GameplayState::Main)
             .insert_resource(DebugPickingMode::Disabled);
 

@@ 1,10 1,11 @@
 use bevy::anti_alias::fxaa::Fxaa;
+use bevy::asset::RenderAssetUsages;
 use bevy::core_pipeline::tonemapping::DebandDither;
 use bevy::post_process::bloom::Bloom;
+use bevy::render::render_resource::{Extent3d, TextureDimension, TextureFormat};
+use bevy::window::PrimaryWindow;
 use crate::prelude::*;
-use crate::ecs::{Me, Part, STARGUIDE_LAYER, StarguideCamera, StarguideMe};
-use crate::config::planet::SpecialSpriteProperties;
-use crate::config::planet::Planet;
+use crate::ecs::{Me, ORBIT_LAYER, OrbitCamera, Part, STARGUIDE_LAYER, StarguideCamera, StarguideMe, StarguideOrbit, StarguideOrbitImage};
 
 pub fn starguide_init_plugin(app: &mut App) {
     app


@@ 13,17 14,45 @@ pub fn starguide_init_plugin(app: &mut App) {
         .add_systems(Update, player_position_update);
 }
 
-pub fn init_starguide(mut commands: Commands) {
+pub fn init_starguide(
+    mut images: ResMut<Assets<Image>>,
+    window: Single<&Window, With<PrimaryWindow>>,
+    mut commands: Commands,
+) {
+    commands.spawn((Camera2d::default(), Camera {
+        is_active: false,
+        clear_color: ClearColorConfig::Custom(Color::linear_rgba(0.0, 0.0, 0.0, 1.0)),
+        order: 0,
+        ..default()
+    }))
+    .insert(ORBIT_LAYER)
+    .insert(OrbitCamera);
+
     commands.spawn((Camera2d::default(), Camera {
         is_active: false,
-        clear_color: ClearColorConfig::Custom(Color::linear_rgba(0.0, 0.0, 0.0, 0.0)),
+        clear_color: ClearColorConfig::None,
+        order: 1,
         ..default()
     }))
-    .insert(Bloom::default())
+    //.insert(Bloom::default())
     .insert(DebandDither::Enabled)
     .insert(Fxaa::default())
     .insert(STARGUIDE_LAYER)
     .insert(StarguideCamera);
+
+    /*let image = Image::new_fill(
+        Extent3d {
+            width: window.width() as u32,
+            height: window.height() as u32,
+            depth_or_array_layers: 1,
+        }, TextureDimension::D2,
+        &(Color::WHITE.to_srgba().to_u8_array()),
+        TextureFormat::Rgba8UnormSrgb,
+        RenderAssetUsages::MAIN_WORLD | RenderAssetUsages::RENDER_WORLD,
+    );
+    let handle = images.add(image);
+    commands.spawn((Sprite::from_image(handle.clone()), ORBIT_LAYER, StarguideOrbit));
+    commands.insert_resource(StarguideOrbitImage(handle));*/
 }
 
 pub fn player_init(


@@ 42,7 71,7 @@ pub fn player_init(
 
 fn player_position_update(
     me: Single<&Transform, (Changed<Transform>, With<Me>)>,
-    mut starguide_me: Single<&mut Transform, (With<StarguideMe>, Without<Me>)>,
+    mut starguide_me: Single<&mut Transform, (With<StarguideMe>, Without<StarguideOrbit>, Without<Me>)>,
 ) {
     starguide_me.translation = me.translation;
     starguide_me.rotation = me.rotation;

@@ 1,2 1,3 @@
 pub mod init;
 pub mod input;
+pub mod orbit;

@@ 0,0 1,19 @@
+use crate::{ecs::StarguideOrbitImage, prelude::*};
+
+pub fn starguide_orbit_plugin(app: &mut App) {
+    //app.add_systems(Update, update_orbits);
+}
+
+fn update_orbits(
+    orbit_image: Res<StarguideOrbitImage>,
+    mut images: ResMut<Assets<Image>>,
+) {
+    let Some(image) = images.get_mut(&orbit_image.0) else {
+        error!("Orbit prediction image not found");
+        return
+    };
+
+    for i in 0..100 {
+        image.set_color_at(i, 100, Color::linear_rgb(1.0, 0.0, 0.0)).unwrap();
+    }
+}

@@ 4,7 4,7 @@ use bevy::{
 };
 
 use crate::{
-    client::starfield::{BACK_STARFIELD_SIZE, FRONT_STARFIELD_SIZE, MID_STARFIELD_SIZE, StarfieldSize}, ecs::{MainCamera, Me, StarfieldBack, StarfieldFront, StarfieldMid}
+    client::starfield::{BACK_STARFIELD_SIZE, FRONT_STARFIELD_SIZE, MID_STARFIELD_SIZE, StarfieldSize}, ecs::{MainCamera, Me, OrbitCamera, StarfieldBack, StarfieldFront, StarfieldMid, StarguideOrbit}
 };
 use crate::ecs::{StarguideCamera, GameplayState};
 


@@ 52,10 52,23 @@ fn on_scroll(
             Without<StarfieldBack>,
         ),
     >,
+    mut orbit_camera: Single<
+        &mut Camera,
+        (
+            With<OrbitCamera>,
+            Without<StarguideCamera>,
+            Without<MainCamera>,
+            Without<Me>,
+            Without<StarfieldFront>,
+            Without<StarfieldMid>,
+            Without<StarfieldBack>,
+        ),
+    >,
     mut camera: Single<
         (&mut Camera, &mut Transform),
         (
             With<MainCamera>,
+            Without<OrbitCamera>,
             Without<StarguideCamera>,
             Without<Me>,
             Without<StarfieldFront>,


@@ 89,9 102,11 @@ fn on_scroll(
                     camera.1.scale *= 1.03;
                     starguide_camera.1.scale *= 1.03;
                 }
+
                 if camera.1.scale.z > 20.0 && matches!(gameplay_state.get(), GameplayState::Main) {
                     camera.0.is_active = false;
                     starguide_camera.0.is_active = true;
+                    orbit_camera.is_active = true;
 
                     starguide_camera.1.translation = player.translation;
                     gameplay_next_state.set(GameplayState::Starguide);


@@ 106,6 121,8 @@ fn on_scroll(
                     camera.0.is_active = true;
                     gameplay_next_state.set(GameplayState::Main);
                     starguide_camera.0.is_active = false;
+                    orbit_camera.is_active = false;
+
                     if matches!(*visibility_back, Visibility::Hidden) {
                         if let Some(size_back) = size_back {
                             starfield_back.image_mode = SpriteImageMode::Tiled {

@@ 20,11 20,14 @@ pub enum GameplayState {
 pub const MAIN_LAYER: RenderLayers = RenderLayers::layer(0);
 pub const STARGUIDE_LAYER: RenderLayers = RenderLayers::layer(1);
 pub static MAIN_STAR_LAYERS: LazyLock<RenderLayers> = LazyLock::new(|| RenderLayers::from_layers(&[0, 1]));
+pub const ORBIT_LAYER: RenderLayers = RenderLayers::layer(2);
 
 #[derive(Component)]
 pub struct MainCamera;
 #[derive(Component)]
 pub struct StarguideCamera;
+#[derive(Component)]
+pub struct OrbitCamera;
 
 #[derive(Component)]
 pub struct StarfieldFront;


@@ 92,6 95,12 @@ pub struct Me;
 #[derive(Component)]
 pub struct StarguideMe;
 
+#[derive(Resource)]
+pub struct StarguideOrbitImage(pub Handle<Image>);
+
+#[derive(Component)]
+pub struct StarguideOrbit;
+
 #[derive(Message, Serialize, Deserialize, Debug, MapEntities)]
 pub struct Hi {
     #[entities]