Merge pull request #237 from AnthonyTornetta/233-make-asteroids-good

233 make asteroids good

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

@@ -64,4 +64,7 @@ cosmos:reactor_controller=Reactor Controller
 cosmos:reactor_casing=Reactor Casing
 cosmos:reactor_window=Reactor Window
 cosmos:reactor_cell=Reactor Power Cell
-cosmos:fan=Fan
+cosmos:fan=Fan
+cosmos:storage=Storage
+cosmos:station_core=Station Core
+cosmos:test_ore=Test Ore

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

@@ -0,0 +1 @@
+cosmos:test_crystal=Test Crystal

cosmos_client/src/netty/gameplay/receiver.rs

@@ -422,11 +422,22 @@ pub(crate) fn client_sync_players(
 
                 entity_cmds.insert((structure, BiosphereMarker::new(biosphere)));
             }
+            ServerReliableMessages::NumberOfChunks {
+                entity: server_entity,
+                chunks_needed,
+            } => {
+                let Some(entity) = network_mapping.client_from_server(&server_entity) else {
+                    continue;
+                };
+
+                if let Some(mut ecmds) = commands.get_entity(entity) {
+                    ecmds.insert(chunks_needed);
+                }
+            }
             ServerReliableMessages::Ship {
                 entity: server_entity,
                 body,
                 dimensions,
-                chunks_needed,
             } => {
                 let Some(entity) = network_mapping.client_from_server(&server_entity) else {
                     continue;
@@ -451,7 +462,7 @@ pub(crate) fn client_sync_players(
                 let builder = ClientShipBuilder::default();
                 builder.insert_ship(&mut entity_cmds, location, body.create_velocity(), &mut structure);
 
-                entity_cmds.insert((structure, chunks_needed));
+                entity_cmds.insert((structure /*chunks_needed*/,));
 
                 client.send_message(
                     NettyChannelClient::Reliable,
@@ -464,7 +475,6 @@ pub(crate) fn client_sync_players(
                 entity: server_entity,
                 body,
                 dimensions,
-                chunks_needed,
             } => {
                 let Some(entity) = network_mapping.client_from_server(&server_entity) else {
                     continue;
@@ -489,7 +499,7 @@ pub(crate) fn client_sync_players(
                 let builder = ClientStationBuilder::default();
                 builder.insert_station(&mut entity_cmds, location, &mut structure);
 
-                entity_cmds.insert((structure, chunks_needed));
+                entity_cmds.insert((structure /*chunks_needed*/,));
             }
             ServerReliableMessages::ChunkData {
                 structure_entity: server_structure_entity,

cosmos_client/src/structure/asteroid/client_asteroid_builder.rs

@@ -38,8 +38,8 @@ impl Default for ClientAsteroidBuilder {
 }
 
 impl TAsteroidBuilder for ClientAsteroidBuilder {
-    fn insert_asteroid(&self, entity: &mut EntityCommands, location: Location, structure: &mut Structure) {
-        self.builder.insert_asteroid(entity, location, structure);
+    fn insert_asteroid(&self, entity: &mut EntityCommands, location: Location, structure: &mut Structure, temperature: f32) {
+        self.builder.insert_asteroid(entity, location, structure, temperature);
     }
 }
 

cosmos_client/src/structure/asteroid/sync.rs

@@ -30,6 +30,7 @@ fn receive_asteroids(
                 entity: server_entity,
                 body,
                 dimensions,
+                temperature,
             } => {
                 let Some(entity) = network_mapping.client_from_server(&server_entity) else {
                     continue;
@@ -54,7 +55,7 @@ fn receive_asteroids(
 
                 let builder = ClientAsteroidBuilder::default();
 
-                builder.insert_asteroid(&mut entity_cmds, location, &mut structure);
+                builder.insert_asteroid(&mut entity_cmds, location, &mut structure, temperature);
 
                 entity_cmds.insert(structure);
             }

cosmos_client/src/ui/ship_flight/mod.rs

@@ -5,6 +5,7 @@ use cosmos_core::{
     entities::player::Player,
     physics::location::Location,
     structure::{
+        asteroid::Asteroid,
         planet::Planet,
         ship::{pilot::Pilot, Ship},
         station::Station,
@@ -233,6 +234,7 @@ fn add_indicators(
 fn added(
     ship_query: Query<Entity, Added<Ship>>,
     station_query: Query<Entity, Added<Station>>,
+    asteroid_query: Query<Entity, Added<Asteroid>>,
     planet_query: Query<Entity, Added<Planet>>,
     player_query: Query<Entity, (Added<Player>, Without<LocalPlayer>)>,
     mut commands: Commands,
@@ -258,6 +260,13 @@ fn added(
             offset: Vec3::ZERO,
         });
     });
+    asteroid_query.for_each(|ent| {
+        commands.entity(ent).insert(IndicatorSettings {
+            color: Color::hex("6159427F").unwrap(),
+            max_distance: 20_000.0,
+            offset: Vec3::ZERO,
+        });
+    });
     player_query.for_each(|ent| {
         commands.entity(ent).insert(IndicatorSettings {
             color: Color::hex("FFFFFF7F").unwrap(),

cosmos_core/src/block/blocks.rs

@@ -257,6 +257,12 @@ fn add_cosmos_blocks(
             .create(),
     );
 
+    blocks.register(
+        BlockBuilder::new("cosmos:test_ore", 10.0, 50.0)
+            .add_property(BlockProperty::Full)
+            .create(),
+    );
+
     loading.finish_loading(id, &mut end_writer);
 }
 

cosmos_core/src/item/items.rs

@@ -1,23 +1,26 @@
 //! Loads all the items for cosmos & adds the item registry.
 
-// use crate::loader::{AddLoadingEvent, DoneLoadingEvent, LoadingManager};
-use crate::registry;
-use bevy::prelude::App;
+use crate::loader::{AddLoadingEvent, DoneLoadingEvent, LoadingManager};
+use crate::registry::{self, Registry};
+use bevy::prelude::*;
 
-use super::Item;
+use super::{Item, DEFAULT_MAX_STACK_SIZE};
 
-// pub fn add_cosmos_items(
-//     mut items: ResMut<Registry<Item>>,
-//     mut loading: ResMut<LoadingManager>,
-//     mut end_writer: EventWriter<DoneLoadingEvent>,
-//     mut start_writer: EventWriter<AddLoadingEvent>,
-// ) {
-//     let id = loading.register_loader(&mut start_writer);
-//     loading.finish_loading(id, &mut end_writer);
-// }
+fn add_cosmos_items(
+    mut items: ResMut<Registry<Item>>,
+    mut loading: ResMut<LoadingManager>,
+    mut end_writer: EventWriter<DoneLoadingEvent>,
+    mut start_writer: EventWriter<AddLoadingEvent>,
+) {
+    let id = loading.register_loader(&mut start_writer);
 
-pub(super) fn register(app: &mut App) {
+    items.register(Item::new("cosmos:test_crystal", DEFAULT_MAX_STACK_SIZE));
+
+    loading.finish_loading(id, &mut end_writer);
+}
+
+pub(super) fn register<T: States>(app: &mut App, loading_state: T) {
     registry::create_registry::<Item>(app);
 
-    // app.add_system_set(SystemSet::on_enter(loading_state).with_system(add_cosmos_items));
+    app.add_systems(OnEnter(loading_state), add_cosmos_items);
 }

cosmos_core/src/item/mod.rs

@@ -2,7 +2,7 @@
 
 pub mod items;
 
-use bevy::prelude::App;
+use bevy::{ecs::schedule::States, prelude::App};
 
 use crate::registry::identifiable::Identifiable;
 
@@ -35,9 +35,9 @@ pub const DEFAULT_MAX_STACK_SIZE: u16 = 999;
 
 impl Item {
     /// Creates an item
-    pub fn new(unlocalized_name: String, max_stack_size: u16) -> Self {
+    pub fn new(unlocalized_name: impl Into<String>, max_stack_size: u16) -> Self {
         Self {
-            unlocalized_name,
+            unlocalized_name: unlocalized_name.into(),
             numeric_id: 0, // this will get set when this item is registered
             max_stack_size,
         }
@@ -49,6 +49,6 @@ impl Item {
     }
 }
 
-pub(super) fn register(app: &mut App) {
-    items::register(app);
+pub(super) fn register<T: States>(app: &mut App, loading_state: T) {
+    items::register(app, loading_state);
 }

cosmos_core/src/netty/server_reliable_messages.rs

@@ -116,6 +116,13 @@ pub enum ServerReliableMessages {
         /// Planet's location
         location: Location,
     },
+    /// This is sent whenever `SendAllChunks` is requested - it is used to specify how much chunks you should expect before marking the structure as loaded
+    NumberOfChunks {
+        /// The fixed structure's server entity.
+        entity: Entity,
+        /// The number of chunks that need to be loaded from the server.
+        chunks_needed: ChunksNeedLoaded,
+    },
     /// A ship should be created on the client-side.
     /// This does NOT mean the ship was just created by the sever, just that one should be created on the client.
     Ship {
@@ -125,8 +132,6 @@ pub enum ServerReliableMessages {
         body: NettyRigidBody,
         /// The width to be passed into the structure's constructor.
         dimensions: ChunkCoordinate,
-        /// The number of chunks that need to be loaded from the server.
-        chunks_needed: ChunksNeedLoaded,
     },
     /// A station should be created on the client-side.
     /// This does NOT mean the station was just created by the sever, just that one should be created on the client.
@@ -137,8 +142,6 @@ pub enum ServerReliableMessages {
         body: NettyRigidBody,
         /// The width to be passed into the structure's constructor.
         dimensions: ChunkCoordinate,
-        /// The number of chunks that need to be loaded from the server.
-        chunks_needed: ChunksNeedLoaded,
     },
     /// Represents the server's message of the day.
     MOTD {

cosmos_core/src/plugin/cosmos_core_plugin.rs

@@ -77,7 +77,7 @@ impl<T: States + Clone + Copy> Plugin for CosmosCorePlugin<T> {
             self.post_loading_state,
             self.playing_state,
         );
-        item::register(app);
+        item::register(app, self.loading_state);
         blockitems::register(app, self.post_loading_state);
         physics::register(app, self.post_loading_state);
         events::register(app, self.playing_state);

cosmos_core/src/structure/asteroid/asteroid_builder.rs

@@ -14,7 +14,7 @@ use super::*;
 /// Implement this to add a custom way to build asteroids
 pub trait TAsteroidBuilder {
     /// Adds everything to the entity needed to have an asteroid
-    fn insert_asteroid(&self, entity: &mut EntityCommands, location: Location, structure: &mut Structure);
+    fn insert_asteroid(&self, entity: &mut EntityCommands, location: Location, structure: &mut Structure, temperature: f32);
 }
 
 /// Default way to build an asteroid
@@ -30,12 +30,12 @@ impl<T: TStructureBuilder> AsteroidBuilder<T> {
 }
 
 impl<T: TStructureBuilder> TAsteroidBuilder for AsteroidBuilder<T> {
-    fn insert_asteroid(&self, entity: &mut EntityCommands, location: Location, structure: &mut Structure) {
+    fn insert_asteroid(&self, entity: &mut EntityCommands, location: Location, structure: &mut Structure, temperature: f32) {
         self.structure_builder
             .insert_structure(entity, location, Velocity::default(), structure);
 
         entity.insert((
-            Asteroid,
+            Asteroid::new(temperature),
             Name::new("Asteroid"),
             RigidBody::Fixed,
             LoadingDistance::new(ASTEROID_LOAD_RADIUS, ASTEROID_UNLOAD_RADIUS),

cosmos_core/src/structure/asteroid/asteroid_netty.rs

@@ -18,5 +18,7 @@ pub enum AsteroidServerMessages {
         body: NettyRigidBody,
         /// The width to be passed into the structure's constructor
         dimensions: ChunkCoordinate,
+        /// The asteroid's temperature
+        temperature: f32,
     },
 }

cosmos_core/src/structure/asteroid/mod.rs

@@ -7,10 +7,24 @@ pub mod asteroid_netty;
 pub mod loading;
 
 /// How far away an asteroid should be loaded
-pub const ASTEROID_LOAD_RADIUS: u32 = 5;
+pub const ASTEROID_LOAD_RADIUS: u32 = 2;
 /// How far away an asteroid should be unloaded
-pub const ASTEROID_UNLOAD_RADIUS: u32 = 6;
+pub const ASTEROID_UNLOAD_RADIUS: u32 = 3;
 
-#[derive(Debug, Component, Default, Reflect)]
+#[derive(Debug, Component, Reflect)]
 /// A small structure that is non-controllable
-pub struct Asteroid;
+pub struct Asteroid {
+    temperature: f32,
+}
+
+impl Asteroid {
+    /// Creates a new asteroid with this temperature
+    pub fn new(temperature: f32) -> Self {
+        Self { temperature }
+    }
+
+    /// Gets the asteroid's temperature
+    pub fn temperature(&self) -> f32 {
+        self.temperature
+    }
+}

cosmos_core/src/structure/full_structure.rs

@@ -162,6 +162,11 @@ impl FullStructure {
         self.loaded = true;
     }
 
+    /// Returns true if the `set_loaded` member function has been called.
+    pub fn is_loaded(&self) -> bool {
+        self.loaded
+    }
+
     /// Returns the chunk's state
     pub fn get_chunk_state(&self, coords: ChunkCoordinate) -> ChunkState {
         if !self.is_within_chunks(coords) {

cosmos_core/src/structure/mod.rs

@@ -7,7 +7,6 @@ use std::ops::DerefMut;
 use std::sync::{Arc, Mutex};
 
 use bevy::app::Update;
-use bevy::log::info;
 use bevy::prelude::{App, Event, IntoSystemConfigs, Name, PreUpdate, VisibilityBundle};
 use bevy::reflect::Reflect;
 use bevy::transform::TransformBundle;
@@ -650,7 +649,6 @@ fn add_chunks_system(
         };
 
         if !chunk.is_empty() && structure.chunk_entity(chunk_coordinate).is_none() {
-            info!("Spawning chunk entity!");
             spawn_chunk_entity(
                 &mut commands,
                 &mut structure,