16 files changed, 31 insertions(+), 45 deletions(-)

M crates/unified/src/client/crafting/ui.rs
M crates/unified/src/client/input/mod.rs
M crates/unified/src/client/parts.rs
M crates/unified/src/client/starguide/orbit.rs
M crates/unified/src/main.rs
M crates/unified/src/server/craft.rs
M crates/unified/src/server/gravity.rs
M crates/unified/src/server/heat/conduction.rs
M crates/unified/src/server/heat/radiation.rs
M crates/unified/src/server/mod.rs
M crates/unified/src/server/orbit/mod.rs
M crates/unified/src/server/planets.rs
M crates/unified/src/server/player/join.rs
M crates/unified/src/server_plugins.rs
M crates/unified/src/shared_plugins.rs
M crates/unified/src/world_config.rs

@@ 1,6 1,6 @@
 use std::collections::HashMap;
 
-use bevy::{input_focus::{AutoFocus, InputFocus}, ui::RelativeCursorPosition};
+use bevy::{input_focus::AutoFocus, ui::RelativeCursorPosition};
 
 use crate::{attachment::PartInShip, client::colors, config::recipe::RecipesConfig, ecs::{CanCraft, CraftPartRequest, CraftingUi, Drill, MainCamera, Me, Part, SingleStorage, ToggleDrillEvent, VariableStorage}, prelude::*};
 


@@ 70,7 70,7 @@ fn setup_ui(
     variable_storage: Option<&VariableStorage>,
 ) {
     let parent_pos = camera.1.world_to_viewport(camera.2, parent_transform.translation).unwrap();
-    let entity = commands.spawn((
+    let _entity = commands.spawn((
         UiTargetCamera(camera.0),
         Node {
             position_type: PositionType::Absolute,


@@ 303,7 303,7 @@ fn drill_button(
     mut text_query: Query<&mut Text>,
     drills: Query<&Drill>,
 ) {
-    for (interaction, mut previous_interaction, mut color, drill_button, mut button, children) in &mut interaction_query {
+    for (interaction, mut previous_interaction, mut color, drill_button, _button, children) in &mut interaction_query {
         match *interaction {
             Interaction::Pressed => {
                 *color = colors::SURFACE_1.into();


@@ 391,10 391,10 @@ fn close_button(
         (&Interaction, &mut PreviousInteraction, &mut BackgroundColor, &CloseButton, &mut Button),
         Changed<Interaction>,
     >,
-    mouse: Res<ButtonInput<MouseButton>>,
+    _mouse: Res<ButtonInput<MouseButton>>,
 ) {
     for (interaction, mut previous_interaction, mut color,
-        close_button, mut button) in &mut interaction_query
+        close_button, _button) in &mut interaction_query
     {
         match *interaction {
             Interaction::Pressed => {

@@ 46,7 46,7 @@ pub fn input_plugin(app: &mut App) {
 #[derive(Resource, Default)]
 pub struct CursorWorldCoordinates(pub Option<Vec2>);
 
-fn update_cursor_position(
+pub fn update_cursor_position(
     q_windows: Query<&Window, With<PrimaryWindow>>,
     q_camera: Query<(&Camera, &GlobalTransform), With<MainCamera>>,
     mut coords: ResMut<CursorWorldCoordinates>,

@@ 7,14 7,12 @@ use crate::client::colors::GREEN;
 use crate::ecs::{DragRequestEvent, Part, MAIN_LAYER};
 use crate::client::input::CursorWorldCoordinates;
 use bevy::color::palettes::css::{ORANGE, PURPLE, RED, YELLOW};
-use bevy::ui::update;
 use crate::client::ship::attachment::AttachmentDebugRes;
 use crate::prelude::*;
 
 pub fn parts_plugin(app: &mut App) {
     app.insert_resource(DragResource(None));
     app.insert_resource(SnapResource(None, None));
-    app.add_systems(PreUpdate, update_drag_ghosts);
     app.add_systems(
         Update,
         (


@@ 22,6 20,7 @@ pub fn parts_plugin(app: &mut App) {
             handle_updated_parts,
             update_part_sprites,
             handle_updated_temperature,
+            update_drag_ghosts.after(crate::client::input::update_cursor_position),
         ),
     );
     app.add_observer(on_part_release);


@@ 196,7 195,7 @@ fn on_part_release(
     drag.0 = None;
 }
 
-const F: f32 = 2.0; // frequency (Hz)
+const F: f32 = 6.0; // frequency (Hz)
 // 0.0 is undamped, 0.0-1.0 is underdamped, 1.0 is critical, and >1.0 is over
 const ZETA: f32 = 0.7; // damping
 const R: f32 = -0.6; // initial response speed


@@ 267,7 266,6 @@ fn update_drag_ghosts(
     joints: Query<(&Transform, &JointOf, Entity), Without<Peer>>,
     parts: Query<(&GlobalTransform, Option<&Me>, Option<&PartInShip>), With<Part>>,
     linvel: Query<&LinearVelocity, With<Me>>,
-    dt: Res<Time<Fixed>>,
     me: Single<Entity, With<Me>>,
     debug: Res<AttachmentDebugRes>,
     mut rsnap: ResMut<SnapResource>,


@@ 427,9 425,8 @@ fn update_drag_ghosts(
     ghost_info.last_target_pos = best_target.translation;
 
     let partvel = linvel.single().unwrap();
-    let t_dt = dt.delta_secs();
-    ghost.translation.x += partvel.x as f32 * t_dt;
-    ghost.translation.y += partvel.y as f32 * t_dt;
+    ghost.translation.x += partvel.x as f32 * time.delta_secs();
+    ghost.translation.y += partvel.y as f32 * time.delta_secs();
 
     rsnap.0 = snap;
     rsnap.1 = best_self_snap;

@@ 28,7 28,7 @@ fn update_orbits(
     for (mass, planet, transform, velocity) in planets {
         if planet.name == "Sun" { continue }
 
-        let (other_mass, _, other_transform, other_velocity) = planets.iter().find(|f_planet| f_planet.1.name == planet.orbit.clone().unwrap().orbiting).unwrap();
+        let (other_mass, _, other_transform, _other_velocity) = planets.iter().find(|f_planet| f_planet.1.name == planet.orbit.clone().unwrap().orbiting).unwrap();
         let a = other_transform.translation - transform.translation;
         let hill_sphere = a.length()*(mass.0/(3.0*(other_mass.0+mass.0))).powf(1.0/3.0);
 

@@ 84,10 84,5 @@ fn main() -> AppExit {
         .finish()
         .init();
 
-    ctrlc::set_handler(|| {
-        info!("caught ^C, ciao!");
-        std::process::exit(0);
-    }).unwrap();
-
     run(cli)
 }

@@ 11,14 11,14 @@ fn receive_crafting_request(
     part_query: Query<(&Transform, &LinearVelocity, &Part, &PartInShip)>,
     player_query: Query<(Entity, &Transform, &LinearVelocity, &Part), With<Player>>,
     parts_query: Query<&Parts>,
-    mut single_storage_query: Query<(&mut SingleStorage)>,
-    mut variable_storage_query: Query<(&mut VariableStorage)>,
+    mut single_storage_query: Query<&mut SingleStorage >,
+    mut variable_storage_query: Query<&mut VariableStorage >,
     mut commands: Commands,
     asset_server: Res<AssetServer>,
 ) {
     'request: for request in craft_part_request.read() {
         // TODO: make crafting take time
-        let (transform, vel, part, parts_list) = if let Ok((transform, vel, part, part_in_ship)) = part_query.get(request.crafting_part) {
+        let (transform, vel, _part, parts_list) = if let Ok((transform, vel, part, part_in_ship)) = part_query.get(request.crafting_part) {
             // this is a normal part
             let Ok(parts_list) = parts_query.get(part_in_ship.0) else {
                 warn!("Couldn't find parts list in part in ship");

@@ 1,4 1,3 @@
-use bevy::math::FloatPow;
 use crate::config::planet::Planet;
 use crate::ecs::Part;
 use crate::prelude::*;

@@ 5,7 5,7 @@ pub fn heat_conduction_plugin(app: &mut App) {
 }
 
 fn propagate_heat(
-    peers: Query<&Peer>
+    _peers: Query<&Peer>
 ) {
 
 }

@@ 1,4 1,4 @@
-use crate::{attachment::PartInShip, ecs::{Part, Player, Radiator, Temperature}, prelude::*};
+use crate::{ecs::{Part, Radiator, Temperature}, prelude::*};
 
 const STEFAN_BOLTZMANN: f64 = 5.670374419E-8;
 const T_ENV: f64 = 4.0; // units: Kelvin

@@ 15,9 15,6 @@ use crate::server::damping::damping_plugin;
 use crate::server::drill::drill_plugin;
 use crate::server::earth_parts::spawn_parts_plugin;
 use crate::server::gravity::newtonian_gravity_plugin;
-use crate::server::heat::conduction::heat_conduction_plugin;
-use crate::server::heat::cooling::heat_cooling_plugin;
-use crate::server::heat::radiation::heat_radiation_plugin;
 use crate::server::part::part_management_plugin;
 use crate::server::planets::planets_plugin;
 use crate::server::player::player_management_plugin;

@@ 1,14 1,10 @@
 use std::collections::HashMap;
 use std::f64::consts::PI;
-use avian2d::dynamics::solver::solver_body::SolverBodyInertia;
-use avian2d::math::{Scalar, TAU};
+use avian2d::math::TAU;
 use avian2d::prelude::{LinearVelocity, Mass};
-use bevy::log::debug;
-use bevy::math::ops::atan2;
-use bevy::prelude::{Component, Plugin, Transform};
+use bevy::prelude::{Plugin, Transform};
 use bevy::time::Time;
-use serde::{Deserialize, Serialize};
-use crate::config::planet::{Planet, PlanetSpring, PlanetSpringJoint};
+use crate::config::planet::{Planet, PlanetSpring};
 use crate::prelude::{App, Query, Res, Update, Without};
 use crate::world_config::WorldConfigResource;
 


@@ 30,7 26,7 @@ fn update_orbits(
         return;
     };
     let parent_velocities = planets.iter().map(|u| (u.0.name.clone(), u.2.clone())).collect::<HashMap<String, LinearVelocity>>();
-    for (planet, _, mut vel) in planets.iter_mut() {
+    for (planet, _, _vel) in planets.iter_mut() {
         let Some(orbit_data) = &planet.orbit else { continue; };
         // find parent
         let Some(parent) = planets_2.iter().find(|u| u.0.name == orbit_data.orbiting) else { continue; };

@@ 122,7 122,7 @@ pub fn update_planets(
                             .iter_mut()
                             .find(|(_, p, _, _)| p.name == planet.name);
 
-                        if let Some((existing, mut e_planet, mut e_transform, mut e_mass)) =
+                        if let Some((existing, mut e_planet, _e_transform, mut e_mass)) =
                             existing_planet
                         {
                             commands

@@ 1,4 1,3 @@
-use crate::attachment::PartInShip;
 use crate::config::planet::Planet;
 use crate::config::world::GlobalWorldConfig;
 use crate::ecs::{Me, Player, PlayerStorage};

@@ 7,12 7,6 @@ pub struct ServerPluginGroup;
 impl PluginGroup for ServerPluginGroup {
     fn build(self) -> PluginGroupBuilder {
         PluginGroupBuilder::start::<Self>()
-            .add_group(
-                PhysicsPlugins::default()
-                    .with_length_unit(100.0)
-                    .build()
-                    .disable::<IslandPlugin>()
-            )
             .add(crate::server::ServerPlugin)
     }
 }

@@ 14,6 14,16 @@ pub struct SharedPluginGroup;
 impl PluginGroup for SharedPluginGroup {
     fn build(self) -> PluginGroupBuilder {
         PluginGroupBuilder::start::<Self>()
+            .add(|app: &mut App| {
+                app.insert_resource(Time::from_hz(20.0));
+            })
+            .add_group(
+                PhysicsPlugins::default()
+                    .with_length_unit(100.0)
+                    .set(PhysicsInterpolationPlugin::interpolate_all())
+                    .build()
+                    .disable::<IslandPlugin>()
+            )
             .add(physics_setup_plugin)
             .add(register_everything)
             .add(world_config_plugin)

@@ 1,6 1,5 @@
 use crate::config::world::GlobalWorldConfig;
 use bevy::asset::Handle;
-use crate::config::planet::PlanetSpringJoint;
 use crate::prelude::*;
 
 pub fn world_config_plugin(app: &mut App) {