Many things

cosmos_client/assets/cosmos/lang/blocks/en_us.lang

@@ -8,7 +8,7 @@ cosmos:redwood_log=Redwood Log
 cosmos:redwood_leaf=Redwood Leaf
 cosmos:ship_core=Ship Core
 cosmos:energy_cell=Energy Cell
-cosmos:reactor=Reactor
+cosmos:passive_generator=Passive Generator
 cosmos:thruster=Thruster
 cosmos:light=Light
 cosmos:glass=Glass

cosmos_client/assets/cosmos/lang/items/en_us.lang

@@ -1,2 +1,2 @@
-cosmos:test_crystal=Test Crystal
+cosmos:photonium_crystal=Test Crystal
 cosmos:iron_bar=Iron Bar

cosmos_client/src/asset/materials/material_types/animated_material.rs

@@ -239,8 +239,7 @@ pub(super) fn register(app: &mut App) {
         (
             respond_to_remove_materails_event.in_set(MaterialsSystemSet::ProcessRemoveMaterialsEvents),
             respond_to_add_materials_event.in_set(MaterialsSystemSet::ProcessAddMaterialsEvents),
-        )
-            .run_if(in_state(GameState::Playing)),
+        ),
     )
     .add_systems(
         Update,

cosmos_client/src/asset/materials/material_types/lod_material.rs

@@ -128,8 +128,7 @@ pub(super) fn register(app: &mut App) {
         (
             respond_to_remove_materails_event.in_set(MaterialsSystemSet::ProcessRemoveMaterialsEvents),
             respond_to_add_materials_event.in_set(MaterialsSystemSet::ProcessAddMaterialsEvents),
-        )
-            .run_if(in_state(GameState::Playing)),
+        ),
     )
     .add_systems(
         Update,

cosmos_client/src/asset/materials/material_types/main_material.rs

@@ -128,8 +128,7 @@ pub(super) fn register(app: &mut App) {
         (
             respond_to_remove_materails_event.in_set(MaterialsSystemSet::ProcessRemoveMaterialsEvents),
             respond_to_add_materials_event.in_set(MaterialsSystemSet::ProcessAddMaterialsEvents),
-        )
-            .run_if(in_state(GameState::Playing)),
+        ),
     )
     .add_systems(
         Update,

cosmos_client/src/asset/materials/mod.rs

@@ -343,6 +343,7 @@ pub(super) fn register(app: &mut App) {
             MaterialsSystemSet::ProcessAddMaterialsEvents,
         )
             .in_set(AssetsSet::AssetsReady)
+            .run_if(in_state(GameState::Playing).or(in_state(GameState::LoadingWorld)))
             .chain(),
     );
 

cosmos_client/src/crafting/blocks/basic_fabricator/ui.rs

@@ -41,6 +41,7 @@ use crate::{
     ui::{
         components::{
             button::{register_button, Button, ButtonEvent, ButtonStyles},
+            scollable_container::ScrollBox,
             window::GuiWindow,
         },
         font::DefaultFont,
@@ -149,93 +150,96 @@ fn populate_menu(
         let mut slot_ents = vec![];
 
         ecmds.with_children(|p| {
-            p.spawn((Node {
-                flex_grow: 1.0,
-                flex_direction: FlexDirection::Column,
-                ..Default::default()
-            },))
-                .with_children(|p| {
-                    for recipe in crafting_recipes.iter() {
+            p.spawn((
+                ScrollBox::default(),
+                Node {
+                    flex_grow: 1.0,
+                    flex_direction: FlexDirection::Column,
+                    ..Default::default()
+                },
+            ))
+            .with_children(|p| {
+                for recipe in crafting_recipes.iter() {
+                    p.spawn((
+                        Node {
+                            height: Val::Px(100.0),
+                            width: Val::Percent(100.0),
+                            justify_content: JustifyContent::SpaceBetween,
+                            ..Default::default()
+                        },
+                        Button::<SelectItemEvent>::default(),
+                        Recipe(recipe.clone()),
+                    ))
+                    .with_children(|p| {
                         p.spawn((
                             Node {
-                                height: Val::Px(100.0),
-                                width: Val::Percent(100.0),
-                                justify_content: JustifyContent::SpaceBetween,
+                                width: Val::Px(64.0),
+                                height: Val::Px(64.0),
+                                margin: UiRect::all(Val::Auto),
+                                ..Default::default()
+                            },
+                            RenderItem {
+                                item_id: recipe.output.item,
+                            },
+                        ));
+
+                        let item = items.from_numeric_id(recipe.output.item);
+                        let name = lang.get_name_from_id(item.unlocalized_name()).unwrap_or(item.unlocalized_name());
+
+                        p.spawn((
+                            Name::new("Item name + inputs display"),
+                            Node {
+                                width: Val::Percent(80.0),
+                                flex_direction: FlexDirection::Column,
+                                justify_content: JustifyContent::SpaceEvenly,
                                 ..Default::default()
                             },
-                            Button::<SelectItemEvent>::default(),
-                            Recipe(recipe.clone()),
                         ))
                         .with_children(|p| {
                             p.spawn((
                                 Node {
-                                    width: Val::Px(64.0),
-                                    height: Val::Px(64.0),
-                                    margin: UiRect::all(Val::Auto),
+                                    width: Val::Percent(100.0),
+                                    // margin: UiRect::vertical(Val::Auto),
                                     ..Default::default()
                                 },
-                                RenderItem {
-                                    item_id: recipe.output.item,
-                                },
+                                Text::new(format!("{}x {}", recipe.output.quantity, name)),
+                                text_style.clone(),
                             ));
 
-                            let item = items.from_numeric_id(recipe.output.item);
-                            let name = lang.get_name_from_id(item.unlocalized_name()).unwrap_or(item.unlocalized_name());
-
-                            p.spawn((
-                                Name::new("Item name + inputs display"),
-                                Node {
-                                    width: Val::Percent(80.0),
-                                    flex_direction: FlexDirection::Column,
-                                    justify_content: JustifyContent::SpaceEvenly,
-                                    ..Default::default()
-                                },
-                            ))
+                            p.spawn(Node {
+                                flex_direction: FlexDirection::Row,
+                                width: Val::Percent(100.0),
+                                ..Default::default()
+                            })
                             .with_children(|p| {
-                                p.spawn((
-                                    Node {
-                                        width: Val::Percent(100.0),
-                                        // margin: UiRect::vertical(Val::Auto),
-                                        ..Default::default()
-                                    },
-                                    Text::new(format!("{}x {}", recipe.output.quantity, name)),
-                                    text_style.clone(),
-                                ));
-
-                                p.spawn(Node {
-                                    flex_direction: FlexDirection::Row,
-                                    width: Val::Percent(100.0),
-                                    ..Default::default()
-                                })
-                                .with_children(|p| {
-                                    for item in recipe.inputs.iter() {
-                                        let RecipeItem::Item(item_id) = item.item;
-
+                                for item in recipe.inputs.iter() {
+                                    let RecipeItem::Item(item_id) = item.item;
+
+                                    p.spawn((
+                                        Node {
+                                            width: Val::Px(64.0),
+                                            height: Val::Px(64.0),
+                                            flex_direction: FlexDirection::Column,
+                                            align_items: AlignItems::End,
+                                            justify_content: JustifyContent::End,
+                                            ..Default::default()
+                                        },
+                                        RenderItem { item_id },
+                                    ))
+                                    .with_children(|p| {
                                         p.spawn((
-                                            Node {
-                                                width: Val::Px(64.0),
-                                                height: Val::Px(64.0),
-                                                flex_direction: FlexDirection::Column,
-                                                align_items: AlignItems::End,
-                                                justify_content: JustifyContent::End,
-                                                ..Default::default()
-                                            },
-                                            RenderItem { item_id },
-                                        ))
-                                        .with_children(|p| {
-                                            p.spawn((
-                                                Name::new("Item recipe qty"),
-                                                TextNeedsTopRoot,
-                                                Text::new(format!("{}", item.quantity)),
-                                                text_style.clone(),
-                                            ));
-                                        });
-                                    }
-                                });
+                                            Name::new("Item recipe qty"),
+                                            TextNeedsTopRoot,
+                                            Text::new(format!("{}", item.quantity)),
+                                            text_style.clone(),
+                                        ));
+                                    });
+                                }
                             });
                         });
-                    }
-                });
+                    });
+                }
+            });
 
             p.spawn((
                 Name::new("Footer"),

cosmos_client/src/entities/player/mod.rs

@@ -1,11 +1,48 @@
 //! Contains systems and components for the player
 
-use bevy::prelude::App;
+use bevy::{color::palettes::css, prelude::*};
+use bevy_rapier3d::prelude::{ActiveEvents, CoefficientCombineRule, Collider, Friction, LockedAxes, ReadMassProperties, RigidBody};
+use cosmos_core::{entities::player::Player, netty::system_sets::NetworkingSystemsSet, persistence::LoadingDistance, state::GameState};
 
 pub mod player_movement;
 pub mod render_distance;
 
+fn on_add_player(
+    mut commands: Commands,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+    mut meshes: ResMut<Assets<Mesh>>,
+    q_player: Query<(Entity, &Player), Added<Player>>,
+) {
+    for (ent, player) in q_player.iter() {
+        commands.entity(ent).insert((
+            Mesh3d(meshes.add(Capsule3d::default())),
+            MeshMaterial3d(materials.add(StandardMaterial {
+                base_color: css::GREEN.into(),
+                ..Default::default()
+            })),
+            Collider::capsule_y(0.65, 0.25),
+            LockedAxes::ROTATION_LOCKED,
+            Name::new(format!("Player ({})", player.name())),
+            RigidBody::Dynamic,
+            Friction {
+                coefficient: 0.0,
+                combine_rule: CoefficientCombineRule::Min,
+            },
+            LoadingDistance::new(1, 2),
+            ReadMassProperties::default(),
+            ActiveEvents::COLLISION_EVENTS,
+        ));
+    }
+}
+
 pub(super) fn register(app: &mut App) {
+    app.add_systems(
+        Update,
+        on_add_player
+            .in_set(NetworkingSystemsSet::Between)
+            .run_if(in_state(GameState::Playing).or(in_state(GameState::LoadingWorld))),
+    );
+
     render_distance::register(app);
     player_movement::register(app);
 }

cosmos_client/src/entities/player/render_distance.rs

@@ -1,6 +1,6 @@
 //! Represents how far the player can see entities
 
-use bevy::prelude::{in_state, App, Changed, IntoSystemConfigs, Query, ResMut, Update, With};
+use bevy::prelude::{in_state, App, Changed, Condition, IntoSystemConfigs, Query, ResMut, Update, With};
 use bevy_renet2::renet2::RenetClient;
 use cosmos_core::{
     entities::player::render_distance::RenderDistance,
@@ -20,5 +20,8 @@ fn send_render_distance(query: Query<&RenderDistance, (With<LocalPlayer>, Change
 }
 
 pub(super) fn register(app: &mut App) {
-    app.add_systems(Update, send_render_distance.run_if(in_state(GameState::Playing)));
+    app.add_systems(
+        Update,
+        send_render_distance.run_if(in_state(GameState::Playing).or(in_state(GameState::LoadingWorld))),
+    );
 }

cosmos_client/src/inventory/mod.rs

@@ -953,22 +953,47 @@ enum InventorySet {
     MoveWindows,
 }
 
+fn rec_make_render_middle_camera(
+    ent: Entity,
+    q_mid_cam: &Query<Entity, With<UiTopRoot>>,
+    q_children: &Query<&Children>,
+    q_target_cam: &mut Query<(Entity, &mut TargetCamera), (Changed<TargetCamera>, With<TextNeedsTopRoot>)>,
+    commands: &mut Commands,
+) {
+    let middle_camera_entity = q_mid_cam.single();
+
+    if let Ok((_, mut target_camera)) = q_target_cam.get_mut(ent) {
+        if target_camera.0 != middle_camera_entity {
+            target_camera.0 = middle_camera_entity;
+        }
+        if let Ok(children) = q_children.get(ent) {
+            for c in children.iter() {
+                rec_make_render_middle_camera(*c, q_mid_cam, q_children, q_target_cam, commands);
+            }
+        }
+    } else {
+        commands.entity(ent).insert(TargetCamera(middle_camera_entity));
+        if let Ok(children) = q_children.get(ent) {
+            for c in children.iter() {
+                rec_make_render_middle_camera(*c, q_mid_cam, q_children, q_target_cam, commands);
+            }
+        }
+    }
+}
+
 fn make_render_middle_camera(
     q_mid_cam: Query<Entity, With<UiTopRoot>>,
-    mut q_target_cam: Query<&mut TargetCamera, (Changed<TargetCamera>, With<TextNeedsTopRoot>)>,
+    q_children: Query<&Children>,
+    mut q_target_cam: Query<(Entity, &mut TargetCamera), (Changed<TargetCamera>, With<TextNeedsTopRoot>)>,
     q_needs_target_cam: Query<Entity, (Without<TargetCamera>, With<TextNeedsTopRoot>)>,
     mut commands: Commands,
 ) {
-    for mut target_camera in q_target_cam.iter_mut() {
-        let middle_camera_entity = q_mid_cam.single();
-        if target_camera.0 != middle_camera_entity {
-            target_camera.0 = middle_camera_entity;
-        }
+    for ent in q_target_cam.iter().map(|x| x.0).collect::<Vec<Entity>>() {
+        rec_make_render_middle_camera(ent, &q_mid_cam, &q_children, &mut q_target_cam, &mut commands);
     }
 
     for ent in q_needs_target_cam.iter() {
-        let middle_camera_entity = q_mid_cam.single();
-        commands.entity(ent).insert(TargetCamera(middle_camera_entity));
+        rec_make_render_middle_camera(ent, &q_mid_cam, &q_children, &mut q_target_cam, &mut commands);
     }
 }
 

cosmos_client/src/loading/mod.rs

@@ -1,6 +1,9 @@
 //! Responsible for unloading far entities
 
-use bevy::prelude::{App, Commands, Entity, IntoSystemConfigs, Parent, Query, Update, With, Without};
+use bevy::{
+    log::info,
+    prelude::{App, Commands, Entity, IntoSystemConfigs, Parent, Query, Update, With, Without},
+};
 use cosmos_core::{
     ecs::NeedsDespawned,
     entities::player::Player,
@@ -19,6 +22,7 @@ fn unload_far_entities(
             let ul_distance = unload_distance.unload_distance() as SectorUnit;
 
             if (loc.sector() - my_loc.sector()).abs().max_element() > ul_distance {
+                info!("Unloading {ent:?} - it's too far.");
                 commands.entity(ent).insert(NeedsDespawned);
             }
         }

cosmos_client/src/main.rs

@@ -155,8 +155,7 @@ fn main() {
         ))
         // .add_plugins(RapierDebugRenderPlugin::default())
         .add_systems(OnEnter(GameState::Connecting), connect::establish_connection)
-        .add_systems(Update, connect::wait_for_connection.run_if(in_state(GameState::Connecting)))
-        .add_systems(Update, connect::wait_for_done_loading.run_if(in_state(GameState::LoadingWorld)));
+        .add_systems(Update, connect::wait_for_connection.run_if(in_state(GameState::Connecting)));
 
     input::register(&mut app);
     window::register(&mut app);