17 files changed, 47 insertions(+), 75 deletions(-)

M crates/unified/src/attachment.rs
M crates/unified/src/client/key_input.rs
M crates/unified/src/client/mod.rs
M crates/unified/src/client/particles/mod.rs
M crates/unified/src/client/parts.rs
M crates/unified/src/client/planet/incoming_planets.rs
M crates/unified/src/client/planet/indicators.rs
M crates/unified/src/client_plugins.rs
M crates/unified/src/config/part.rs
M crates/unified/src/main.rs
M crates/unified/src/particle_editor/mod.rs
M crates/unified/src/particles.rs
M crates/unified/src/server/earth_parts.rs
M crates/unified/src/server/gravity.rs
M crates/unified/src/server/part.rs
M crates/unified/src/server/player.rs
M crates/unified/src/server_plugins.rs

@@ 1,18 1,16 @@
-use bevy::asset::processor::ErasedProcessor;
 use bevy::ecs::entity::MapEntities;
 use bevy::prelude::*;
 use serde::{Deserialize, Serialize};
-use std::ops::Deref;
 
 #[derive(Component, Serialize, Deserialize)]
 /// The primary component for a ship structure
 pub struct Ship;
 
-#[derive(Component, Serialize, Deserialize)]
+#[derive(Component, Serialize, Deserialize, MapEntities)]
 #[relationship_target(relationship = PartInShip, linked_spawn)]
 pub struct Parts(#[entities] Vec<Entity>);
 
-#[derive(Component, Serialize, Deserialize)]
+#[derive(Component, Serialize, Deserialize, MapEntities)]
 #[relationship(relationship_target = Parts)]
 pub struct PartInShip(#[entities] Entity);
 


@@ 22,29 20,29 @@ pub struct Joint {
     pub id: JointId,
     pub transform: Transform,
 }
-#[derive(Component, Serialize, Deserialize)]
+#[derive(Component, Serialize, Deserialize, MapEntities)]
 pub struct Peer(#[entities] Entity);
 
-#[derive(Component, Serialize, Deserialize)]
+#[derive(Component, Serialize, Deserialize, MapEntities)]
 #[relationship(relationship_target = Joints)]
 pub struct JointOf(#[entities] pub Entity);
-#[derive(Component, Serialize, Deserialize)]
+#[derive(Component, Serialize, Deserialize, MapEntities)]
 #[relationship_target(relationship = JointOf)]
 pub struct Joints(#[entities] Vec<Entity>);
-#[derive(Component, Serialize, Deserialize)]
+#[derive(Component, Serialize, Deserialize, MapEntities)]
 #[relationship(relationship_target = JointSnaps)]
 pub struct JointSnapOf(#[entities] pub Entity);
-#[derive(Component, Serialize, Deserialize)]
+#[derive(Component, Serialize, Deserialize, MapEntities)]
 #[relationship_target(relationship = JointSnapOf)]
 pub struct JointSnaps(#[entities] Vec<Entity>);
 
 #[derive(Serialize, Deserialize)]
 pub struct JointId(pub String);
 impl JointId {
-    pub fn from_part_and_joint_id(part: String, joint: String) -> Self {
+    #[must_use] pub fn from_part_and_joint_id(part: String, joint: String) -> Self {
         Self(format!("{part}:{joint}"))
     }
 }
 
-#[derive(Serialize, Deserialize, Component)]
+#[derive(Serialize, Deserialize, Component, MapEntities)]
 pub struct JointSnapFor(#[entities] pub Entity);

@@ 1,13 1,11 @@
 use crate::attachment::{Joint, JointSnapFor};
-use crate::ecs::{Part, ThrustEvent};
+use crate::ecs::ThrustEvent;
 use bevy::color::palettes::css::{FUCHSIA, GREEN};
 use bevy::dev_tools::picking_debug::DebugPickingMode;
-use bevy::gizmos::AppGizmoBuilder;
-use bevy::log::{debug, info};
 use bevy::math::Vec3Swizzles;
 use bevy::prelude::{
-    ChildOf, GizmoConfigGroup, Gizmos, GlobalTransform, IntoScheduleConfigs, Query, Reflect,
-    ResMut, Resource, Transform, With,
+    Gizmos, GlobalTransform, Query,
+    ResMut, Resource, With,
 };
 use bevy::{
     app::{App, Update},


@@ 73,7 71,7 @@ fn draw_attachment_debug(
     joints: Query<&GlobalTransform, With<Joint>>,
     snaps: Query<&GlobalTransform, With<JointSnapFor>>,
     mut gizmos: Gizmos,
-    mut state: ResMut<AttachmentDebugRes>,
+    state: ResMut<AttachmentDebugRes>,
 ) {
     if !state.0 {
         return;

@@ 23,8 23,6 @@ use bevy::core_pipeline::tonemapping::DebandDither;
 use bevy::dev_tools::picking_debug::DebugPickingMode;
 use bevy::prelude::*;
 use bevy::window::PrimaryWindow;
-use bevy_egui::EguiPlugin;
-use bevy_replicon::shared::server_entity_map::ServerEntityMap;
 use planet::incoming_planets::incoming_planets_plugin;
 
 pub struct ClientPlugin {


@@ 65,7 63,6 @@ pub struct Me;
 fn find_me(
     mut commands: Commands,
     q_clients: Query<(Entity, &Player, &Part), Added<Player>>,
-    entity_map: Res<ServerEntityMap>,
     asset_server: Res<AssetServer>,
 ) {
     for (entity, player, part) in q_clients.iter() {

@@ 3,5 3,5 @@ use bevy::app::{App, Plugin};
 pub struct ParticlePlugin;
 
 impl Plugin for ParticlePlugin {
-    fn build(&self, app: &mut App) {}
+    fn build(&self, _app: &mut App) {}
 }

@@ 3,7 3,6 @@ use crate::ecs::{CursorWorldCoordinates, DragRequestEvent, Part};
 use bevy::prelude::*;
 use bevy_rapier2d::dynamics::MassProperties;
 use bevy_rapier2d::prelude::{AdditionalMassProperties, ReadMassProperties, RigidBody};
-use std::fmt::Debug;
 
 pub fn parts_plugin(app: &mut App) {
     app.insert_resource(DragResource(None));


@@ 70,8 69,8 @@ fn on_part_click(
 ) {
     if ev.button != PointerButton::Primary {
         return;
-    };
-    let Ok(sprite) = sprites.get(ev.target()) else {
+    }
+    let Ok(_) = sprites.get(ev.target()) else {
         return;
     };
     drag.0 = Some(ev.target());


@@ 85,7 84,7 @@ fn on_part_release(
 ) {
     if ev.button != PointerButton::Primary {
         return;
-    };
+    }
 
     if let Some(e) = drag.0
         && let Some(c) = cursor.0

@@ 10,8 10,6 @@ fn handle_incoming_planets(
     mut commands: Commands,
     new_planets: Query<(Entity, &Planet), Added<Planet>>,
     asset_server: Res<AssetServer>,
-    meshes: ResMut<Assets<Mesh>>,
-    materials: ResMut<Assets<ColorMaterial>>,
 ) {
     for (new_entity, new_planet) in new_planets.iter() {
         let mut sprite = Sprite::from_image(asset_server.load(&new_planet.sprite));


@@ 34,8 32,6 @@ fn handle_updated_planets(
     mut commands: Commands,
     updated_planets: Query<(Entity, &Planet), Changed<Planet>>,
     asset_server: Res<AssetServer>,
-    meshes: ResMut<Assets<Mesh>>,
-    materials: ResMut<Assets<ColorMaterial>>,
 ) {
     for (updated_entity, updated_planet) in updated_planets.iter() {
         let mut sprite = Sprite::from_image(asset_server.load(&updated_planet.sprite));

@@ 10,7 10,7 @@ pub fn indicators_plugin(app: &mut App) {
 }
 
 #[derive(Component)]
-struct PlanetIndicator(String);
+struct PlanetIndicator;
 #[derive(Component)]
 struct HasIndicator(Entity);
 


@@ 32,7 32,7 @@ fn add_indicators(
         let indicator = commands
             .spawn((
                 ChildOf(me),
-                PlanetIndicator(planet_data.name.clone()),
+                PlanetIndicator,
                 sprite,
                 Transform::from_xyz(0.0, 0.0, 0.0),
             ))

@@ 6,7 6,6 @@ use bevy::app::{PluginGroup, PluginGroupBuilder};
 use bevy::dev_tools::picking_debug::DebugPickingPlugin;
 use bevy::log::LogPlugin;
 use bevy::prelude::MeshPickingPlugin;
-use bevy::sprite::prelude::SpritePickingPlugin;
 use bevy_rapier2d::prelude::RapierDebugRenderPlugin;
 use bevy_replicon::RepliconPlugins;
 

@@ 1,6 1,6 @@
 use bevy::asset::Asset;
 use bevy::math::{Quat, Vec3};
-use bevy::prelude::{Component, Transform, TypePath};
+use bevy::prelude::{Transform, TypePath};
 use serde::{Deserialize, Serialize};
 
 #[derive(Deserialize, TypePath, Serialize, Clone, Debug, PartialEq, Asset)]

@@ 1,4 1,4 @@
-use bevy::log::{Level, tracing_subscriber};
+use bevy::log::tracing_subscriber;
 use bevy::prelude::*;
 use clap::Parser;
 use starkingdoms::client_plugins::ClientPluginGroup;

@@ 6,7 6,6 @@ use bevy::prelude::*;
 use bevy_egui::{EguiContexts, EguiPlugin, EguiPrimaryContextPass, egui};
 use bevy_rapier2d::plugin::{NoUserData, RapierPhysicsPlugin};
 use ordered_float::OrderedFloat;
-use ron::ser::PrettyConfig;
 use std::collections::BTreeMap;
 
 mod ecs;


@@ 32,7 31,7 @@ pub fn particle_editor_plugin(app: &mut App) {
         scale_curve: LifetimeCurve::new(&[(0.0f32, 5.0), (2.0, 0.0)])
             .0
             .iter()
-            .map(|u| (u.0.clone(), u.1.clone()))
+            .map(|u| (*u.0, *u.1))
             .collect::<Vec<_>>(),
         color_curve: vec![(OrderedFloat(0.0f32), [255, 0, 0, 255])],
     });


@@ 167,8 166,7 @@ fn editor_ui(
                     let new_v = (
                         OrderedFloat(editor_resource.add_scale_t),
                         editor_resource.add_scale_v,
-                    )
-                        .clone();
+                    );
                     editor_resource.scale_curve.push(new_v);
                 }
                 ui.end_row();


@@ 216,8 214,7 @@ fn editor_ui(
                     let new_v = (
                         OrderedFloat(editor_resource.add_color_t),
                         editor_resource.add_color_v,
-                    )
-                        .clone();
+                    );
                     editor_resource.color_curve.push(new_v);
                 }
                 ui.end_row();


@@ 228,10 225,10 @@ fn editor_ui(
                         (
                             *u,
                             Color::Srgba(Srgba::new(
-                                v[0] as f32 / 256.0,
-                                v[1] as f32 / 256.0,
-                                v[2] as f32 / 256.0,
-                                v[3] as f32 / 256.0,
+                                f32::from(v[0]) / 256.0,
+                                f32::from(v[1]) / 256.0,
+                                f32::from(v[2]) / 256.0,
+                                f32::from(v[3]) / 256.0,
                             )),
                         )
                     })));


@@ 250,10 247,10 @@ fn editor_ui(
                             (
                                 *u,
                                 Color::Srgba(Srgba::new(
-                                    v[0] as f32 / 256.0,
-                                    v[1] as f32 / 256.0,
-                                    v[2] as f32 / 256.0,
-                                    v[3] as f32 / 256.0,
+                                    f32::from(v[0]) / 256.0,
+                                    f32::from(v[1]) / 256.0,
+                                    f32::from(v[2]) / 256.0,
+                                    f32::from(v[3]) / 256.0,
                                 )),
                             )
                         })));


@@ 269,14 266,14 @@ fn editor_ui(
                                 .scale
                                 .0
                                 .iter()
-                                .map(|u| (u.0.clone(), u.1.clone()))
+                                .map(|u| (*u.0, *u.1))
                                 .collect::<Vec<_>>();
                             editor_resource.color_curve = effect
                                 .color
                                 .0
                                 .iter()
                                 .map(|u| {
-                                    (u.0.clone(), {
+                                    (*u.0, {
                                         let mut r = [0u8; 4];
                                         let srgba: Srgba = (*u.1).into();
                                         r[0] = (srgba.red * 256.0).floor() as u8;


@@ 291,7 288,7 @@ fn editor_ui(
                         Err(e) => {
                             editor_resource.status = e.to_string();
                         }
-                    };
+                    }
                 }
             });
             ui.text_edit_multiline(&mut editor_resource.ser_field);

@@ 1,7 1,7 @@
 use bevy::color::{Color, LinearRgba};
 use bevy::math::Vec2;
 use bevy::prelude::Component;
-use ordered_float::{FloatCore, OrderedFloat};
+use ordered_float::OrderedFloat;
 use rand::Rng;
 use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;


@@ 42,13 42,13 @@ impl<P: Lerp + Copy> LifetimeCurve<P> {
         P: 'a,
     {
         Self(BTreeMap::from_iter(
-            points.into_iter().map(|u| (OrderedFloat(u.0), u.1.clone())),
+            points.into_iter().map(|u| (OrderedFloat(u.0), u.1)),
         ))
     }
 
     /// Sample for the value at T. Returns None if the curve has no points, or if T is outside
     /// the domain of the points specified.
-    pub fn sample(&self, at: f32) -> Option<P> {
+    #[must_use] pub fn sample(&self, at: f32) -> Option<P> {
         if self.0.is_empty() {
             return None;
         }


@@ 82,7 82,7 @@ impl<P: Lerp + Copy> LifetimeCurve<P> {
 
     /// Given an input time value, use the ends of the spline's time to clamp
     /// the input value.
-    pub fn clamp_time(&self, time: f32) -> Option<f32> {
+    #[must_use] pub fn clamp_time(&self, time: f32) -> Option<f32> {
         let Some(first) = self.0.iter().nth(0) else {
             return None;
         };


@@ 128,7 128,7 @@ pub struct RandUsize {
 }
 impl RandUsize {
     pub fn sample(&self, rng: &mut impl Rng) -> usize {
-        let lower_bound = self.value.checked_sub(self.randomness).unwrap_or(0);
+        let lower_bound = self.value.saturating_sub(self.randomness);
         rng.random_range(lower_bound..self.value + self.randomness)
     }
 }

@@ 1,15 1,10 @@
 use crate::config::planet::Planet;
-use crate::ecs::{Part, PartBundle};
 use crate::server::part::SpawnPartRequest;
 use crate::server::world_config::WorldConfigResource;
 use bevy::app::App;
-use bevy::math::Vec2;
 use bevy::prelude::*;
 use bevy::prelude::{Commands, Query, Res, Transform};
 use bevy::time::Time;
-use bevy_rapier2d::dynamics::{AdditionalMassProperties, MassProperties};
-use bevy_rapier2d::geometry::Collider;
-use bevy_replicon::prelude::Replicated;
 
 #[derive(Resource, Default)]
 struct PartTimerRes {


@@ 21,7 16,7 @@ pub fn spawn_parts_plugin(app: &mut App) {
         .add_systems(Update, spawn_parts_on_earth);
 }
 
-pub fn spawn_parts_on_earth(
+fn spawn_parts_on_earth(
     mut commands: Commands,
     world_config: Res<WorldConfigResource>,
     planets: Query<(&Transform, &Planet)>,

@@ 10,7 10,7 @@ pub fn newtonian_gravity_plugin(app: &mut App) {
 }
 
 fn update_gravity(
-    mut part_query: Query<(&Transform, &ReadMassProperties, &mut ExternalForce), (With<Part>)>,
+    mut part_query: Query<(&Transform, &ReadMassProperties, &mut ExternalForce), With<Part>>,
     planet_query: Query<(&Transform, &ReadMassProperties), With<Planet>>,
     world_config: Res<WorldConfigResource>,
 ) {

@@ 2,7 2,7 @@ use crate::config::world::PartConfig;
 use bevy::prelude::Component;
 use bevy::prelude::*;
 
-pub fn part_management_plugin(app: &mut App) {}
+pub fn part_management_plugin(_app: &mut App) {}
 
 #[derive(Component)]
 pub struct SpawnPartRequest(pub Handle<PartConfig>);

@@ 2,16 2,14 @@ use std::f32::consts::PI;
 
 use crate::config::planet::Planet;
 use crate::ecs::{
-    DragRequestEvent, Part, PartBundle, Particles, Player, PlayerThrust, ThrustEvent,
+    DragRequestEvent, Part, Player, PlayerThrust, ThrustEvent,
 };
 use crate::server::part::SpawnPartRequest;
 use crate::server::world_config::WorldConfigResource;
 use crate::server::{ConnectedGameEntity, ConnectedNetworkEntity};
 use bevy::prelude::*;
-use bevy_rapier2d::prelude::{
-    AdditionalMassProperties, Collider, ExternalForce, ExternalImpulse, MassProperties,
-};
-use bevy_replicon::prelude::{FromClient, Replicated};
+use bevy_rapier2d::prelude::ExternalForce;
+use bevy_replicon::prelude::FromClient;
 
 pub fn player_management_plugin(app: &mut App) {
     app.add_systems(Update, (handle_new_players, player_thrust, dragging));


@@ 34,8 32,6 @@ fn handle_new_players(
     world_config: Res<WorldConfigResource>,
     planets: Query<(&Transform, &Planet)>,
     asset_server: Res<AssetServer>,
-    gt: Query<&GlobalTransform>,
-    child_of: Query<&ChildOf>,
 ) {
     let Some(wc) = &world_config.config else {
         return;

@@ 4,15 4,12 @@ use crate::config::world::GlobalWorldConfig;
 use aeronet_replicon::server::AeronetRepliconServerPlugin;
 use aeronet_websocket::server::WebSocketServerPlugin;
 use bevy::app::{
-    App, PluginGroup, PluginGroupBuilder, ScheduleRunnerPlugin, Startup, TaskPoolPlugin,
+    PluginGroup, PluginGroupBuilder, ScheduleRunnerPlugin, TaskPoolPlugin,
 };
 use bevy::asset::AssetPlugin;
 use bevy::diagnostic::FrameCountPlugin;
-use bevy::math::Vec2;
-use bevy::prelude::Query;
 use bevy::time::TimePlugin;
 use bevy_common_assets::toml::TomlAssetPlugin;
-use bevy_rapier2d::plugin::{NoUserData, RapierConfiguration, RapierPhysicsPlugin};
 use bevy_replicon::RepliconPlugins;
 use std::net::SocketAddr;
 use std::time::Duration;