10 files changed, 128 insertions(+), 112 deletions(-)

M crates/client/src/components.rs
M crates/client/src/lib.rs
M crates/client/src/networking/handlers.rs
M crates/client/src/networking/mod.rs
M crates/client/src/rendering/mod.rs
M crates/client/src/systems.rs
M crates/common/src/packet.rs
M crates/kabel/src/codegen.rs
M crates/kabel/src/parser.rs
M crates/server/src/player/player_mouse_input.rs

@@ 1,5 1,5 @@
-use bevy_ecs::{bundle::Bundle, component::Component, event::Event, system::Resource};
 use bevy_ecs::schedule::ScheduleLabel;
+use bevy_ecs::{bundle::Bundle, component::Component, event::Event, system::Resource};
 use nalgebra::{Matrix3, Matrix4, Rotation2, Scale2, Scale3, Translation2, Translation3};
 use starkingdoms_common::packet::Packet;
 


@@ 8,7 8,7 @@ pub struct PlayerBundle {
     pub transform: Transform,
     pub texture: Texture,
     pub player: Player,
-    pub part: Part
+    pub part: Part,
 }
 
 #[derive(Bundle)]


@@ 16,24 16,24 @@ pub struct PartBundle {
     pub transform: Transform,
     pub texture: Texture,
     pub server_id: ServerId,
-    pub part: Part
+    pub part: Part,
 }
 
 #[derive(Bundle)]
 pub struct OtherPlayerBundle {
     pub part: PartBundle,
-    pub username: PlayerUsername
+    pub username: PlayerUsername,
 }
 
 #[derive(ScheduleLabel, Hash, Clone, Debug, Eq, PartialEq)]
 pub enum Schedule {
     Startup,
-    Update
+    Update,
 }
 
 #[derive(Component, Debug)]
 pub struct PlayerUsername {
-    pub username: String
+    pub username: String,
 }
 
 #[derive(Component, Debug)]

@@ 1,21 1,21 @@
 use crate::components::PlayerResources;
+use crate::components::Schedule::{Startup, Update};
+use crate::networking::handlers::{
+    handle_crafting_ui, handle_despawn_part, handle_energy_update, handle_existing_players_list,
+    handle_login_response, handle_message, handle_part_positions, handle_player_leave,
+    handle_spawn_part, handle_spawn_player,
+};
 use crate::networking::websocket::Websocket;
-use bevy_ecs::{event::Events, world::World};
-use bevy_ecs::event::EventRegistry;
-use bevy_ecs::prelude::Event;
+use crate::systems::create_hearty;
 use bevy_ecs::schedule::Schedule;
-use components::{Camera, Chat, Part, Player, RecvPacket, SendPacket, Texture, Transform};
-use nalgebra::{Rotation2, Scale3, Translation3};
+use bevy_ecs::{event::Events, world::World};
+use components::{Camera, Chat, RecvPacket, SendPacket};
 use platform::assets::Assets;
 use platform::websocket::Ws;
 use rendering::assets::AssetLoader;
 use rendering::App;
 use tracing::info;
 use winit::event_loop::{ControlFlow, EventLoop};
-use starkingdoms_common::packet::{ClientLoginPacket, DespawnPartPacket, EnergyUpdatePacket, LoginResponsePacket, MessagePacket, OpenCraftingUiPacket, PartPositionsPacket, PlanetPositionsPacket, PlayerInputPacket, PlayerLeavePacket, PlayerListPacket, PlayerMouseInputPacket, RequestSavePacket, SaveDataPacket, SaveEligibilityPacket, SendMessagePacket, SpawnPartPacket, SpawnPlayerPacket, SpecialDisconnectPacket};
-use crate::components::Schedule::{Startup, Update};
-use crate::networking::handlers::{handle_crafting_ui, handle_despawn_part, handle_energy_update, handle_existing_players_list, handle_login_response, handle_message, handle_part_positions, handle_player_leave, handle_spawn_part, handle_spawn_player};
-use crate::systems::create_hearty;
 
 #[cfg(target_arch = "wasm32")]
 #[path = "wasm/mod.rs"]


@@ 27,8 27,8 @@ pub mod platform;
 pub mod components;
 pub mod networking;
 pub mod rendering;
-pub mod ui;
 pub mod systems;
+pub mod ui;
 
 // Hi, you've found the real main function! This is called AFTER platform-specific initialization code.
 pub fn start() {


@@ 86,7 86,6 @@ pub fn start() {
     update_schedule.add_systems(handle_despawn_part);
     update_schedule.add_systems(handle_login_response);
 
-
     // add systems here
 
     world.add_schedule(startup_schedule);


@@ 100,4 99,4 @@ pub fn start() {
     event_loop
         .run_app(&mut App::new(world, send_packet_events, recv_packet_events))
         .unwrap();
-}>
\ No newline at end of file
+}

@@ 1,11 1,22 @@
+use crate::components::{
+    Camera, Chat, Menu, OtherPlayerBundle, Part, PartBundle, Player, PlayerResources,
+    PlayerUsername, ServerId, Texture, Transform,
+};
+use crate::networking::texture_name;
 use bevy_ecs::prelude::*;
 use nalgebra::{Rotation2, Scale3, Translation3};
-use starkingdoms_common::packet::{DespawnPartPacket, EnergyUpdatePacket, LoginResponsePacket, MessagePacket, OpenCraftingUiPacket, PartPositionsPacket, PlanetPositionsPacket, PlayerLeavePacket, PlayerListPacket, SpawnPartPacket, SpawnPlayerPacket};
+use starkingdoms_common::packet::{
+    DespawnPartPacket, EnergyUpdatePacket, LoginResponsePacket, MessagePacket,
+    OpenCraftingUiPacket, PartPositionsPacket, PlayerLeavePacket, PlayerListPacket,
+    SpawnPartPacket, SpawnPlayerPacket,
+};
 use starkingdoms_common::PartType;
-use crate::components::{Camera, Chat, Menu, OtherPlayerBundle, Part, PartBundle, Player, PlayerBundle, PlayerResources, PlayerUsername, ServerId, Texture, Transform};
-use crate::networking::texture_name;
 
-pub fn handle_login_response(mut reader: EventReader<LoginResponsePacket>, mut player: Query<Entity, With<Player>>, mut commands: Commands) {
+pub fn handle_login_response(
+    mut reader: EventReader<LoginResponsePacket>,
+    player: Query<Entity, With<Player>>,
+    mut commands: Commands,
+) {
     for packet in reader.read() {
         let player = player.single();
         commands.entity(player).insert(ServerId(packet.id));


@@ 14,13 25,15 @@ pub fn handle_login_response(mut reader: EventReader<LoginResponsePacket>, mut p
 
 pub fn handle_message(mut reader: EventReader<MessagePacket>, mut chat: ResMut<Chat>) {
     for message in reader.read() {
-        chat.messages.push(
-            format!("{}: {}", message.actor, message.content)
-        );
+        chat.messages
+            .push(format!("{}: {}", message.actor, message.content));
     }
 }
 
-pub fn handle_existing_players_list(mut reader: EventReader<PlayerListPacket>, mut commands: Commands) {
+pub fn handle_existing_players_list(
+    mut reader: EventReader<PlayerListPacket>,
+    mut commands: Commands,
+) {
     for packet in reader.read() {
         for (server_id, username) in &packet.players {
             commands.spawn(OtherPlayerBundle {


@@ 28,62 41,75 @@ pub fn handle_existing_players_list(mut reader: EventReader<PlayerListPacket>, m
                     transform: Transform {
                         translation: Translation3::new(0.0, 0.0, 0.0),
                         rotation: Rotation2::new(0.0),
-                        scale: Scale3::new(25.0, 25.0, 1.0)
+                        scale: Scale3::new(25.0, 25.0, 1.0),
                     },
                     texture: Texture {
-                        name: "hearty.svg".to_string()
+                        name: "hearty.svg".to_string(),
                     },
                     server_id: ServerId(*server_id),
                     part: Part(false),
                 },
                 username: PlayerUsername {
-                    username: username.clone()
-                }
+                    username: username.clone(),
+                },
             });
         }
     }
 }
 
 pub fn handle_spawn_player(mut reader: EventReader<SpawnPlayerPacket>, mut commands: Commands) {
-    for SpawnPlayerPacket { id: server_id, username } in reader.read() {
-            commands.spawn(OtherPlayerBundle {
-                part: PartBundle {
-                    transform: Transform {
-                        translation: Translation3::new(0.0, 0.0, 0.0),
-                        rotation: Rotation2::new(0.0),
-                        scale: Scale3::new(25.0, 25.0, 1.0)
-                    },
-                    texture: Texture {
-                        name: "hearty.svg".to_string()
-                    },
-                    server_id: ServerId(*server_id),
-                    part: Part(false),
-                },
-                username: PlayerUsername {
-                    username: username.clone()
-                }
-            });
-    }
-}
-
-pub fn handle_spawn_part(mut reader: EventReader<SpawnPartPacket>, mut commands: Commands) {
-    for SpawnPartPacket { id: server_id, part } in reader.read() {
-        commands.spawn(PartBundle {
+    for SpawnPlayerPacket {
+        id: server_id,
+        username,
+    } in reader.read()
+    {
+        commands.spawn(OtherPlayerBundle {
+            part: PartBundle {
                 transform: Transform {
-                    translation: Translation3::new(part.transform.x, part.transform.y, 0.0),
-                    rotation: Rotation2::new(part.transform.rot),
+                    translation: Translation3::new(0.0, 0.0, 0.0),
+                    rotation: Rotation2::new(0.0),
                     scale: Scale3::new(25.0, 25.0, 1.0),
                 },
                 texture: Texture {
-                    name: texture_name(part.part_type, part.flags.attached),
+                    name: "hearty.svg".to_string(),
                 },
                 server_id: ServerId(*server_id),
-                part: Part(part.flags.attached),
-            });
+                part: Part(false),
+            },
+            username: PlayerUsername {
+                username: username.clone(),
+            },
+        });
     }
 }
 
-pub fn handle_part_positions(mut reader: EventReader<PartPositionsPacket>, mut parts_query: Query<(Entity, &ServerId, &mut Transform, &mut Texture, &mut Part)>, mut player: Query<&ServerId, With<Player>>, mut camera: ResMut<Camera>) {
+pub fn handle_spawn_part(mut reader: EventReader<SpawnPartPacket>, mut commands: Commands) {
+    for SpawnPartPacket {
+        id: server_id,
+        part,
+    } in reader.read()
+    {
+        commands.spawn(PartBundle {
+            transform: Transform {
+                translation: Translation3::new(part.transform.x, part.transform.y, 0.0),
+                rotation: Rotation2::new(part.transform.rot),
+                scale: Scale3::new(25.0, 25.0, 1.0),
+            },
+            texture: Texture {
+                name: texture_name(part.part_type, part.flags.attached),
+            },
+            server_id: ServerId(*server_id),
+            part: Part(part.flags.attached),
+        });
+    }
+}
+
+pub fn handle_part_positions(
+    mut reader: EventReader<PartPositionsPacket>,
+    mut parts_query: Query<(Entity, &ServerId, &mut Transform, &mut Texture, &mut Part)>,
+    player: Query<&ServerId, With<Player>>,
+    mut camera: ResMut<Camera>,
+) {
     for PartPositionsPacket { parts } in reader.read() {
         for (this_id, part) in parts {
             for (_, server_id, mut transform, mut texture, mut bevy_part) in &mut parts_query {


@@ 113,26 139,35 @@ pub fn handle_part_positions(mut reader: EventReader<PartPositionsPacket>, mut p
     }
 }
 
-
-pub fn handle_energy_update(mut reader: EventReader<EnergyUpdatePacket>, mut player_res: ResMut<PlayerResources>) {
+pub fn handle_energy_update(
+    mut reader: EventReader<EnergyUpdatePacket>,
+    mut player_res: ResMut<PlayerResources>,
+) {
     for EnergyUpdatePacket { amount, max } in reader.read() {
         player_res.fuel_amount = *amount;
         player_res.fuel_max = *max;
     }
 }
 
-pub fn handle_crafting_ui(mut reader: EventReader<OpenCraftingUiPacket>, entities: Query<(Entity, &ServerId)>, mut commands: Commands) {
+pub fn handle_crafting_ui(
+    mut reader: EventReader<OpenCraftingUiPacket>,
+    entities: Query<(Entity, &ServerId)>,
+    mut commands: Commands,
+) {
     for OpenCraftingUiPacket { id } in reader.read() {
         for (entity, server_id) in &entities {
             if server_id.0 == *id {
-                commands.entity(entity)
-                    .insert(Menu);
+                commands.entity(entity).insert(Menu);
             }
         }
     }
 }
 
-pub fn handle_player_leave(mut reader: EventReader<PlayerLeavePacket>, mut part_query: Query<(Entity, &ServerId), With<Part>>, mut commands: Commands) {
+pub fn handle_player_leave(
+    mut reader: EventReader<PlayerLeavePacket>,
+    mut part_query: Query<(Entity, &ServerId), With<Part>>,
+    mut commands: Commands,
+) {
     for PlayerLeavePacket { id } in reader.read() {
         for (entity, server_id) in &mut part_query {
             if server_id.0 == *id {


@@ 142,7 177,11 @@ pub fn handle_player_leave(mut reader: EventReader<PlayerLeavePacket>, mut part_
     }
 }
 
-pub fn handle_despawn_part(mut reader: EventReader<DespawnPartPacket>, mut part_query: Query<(Entity, &ServerId), With<Part>>, mut commands: Commands) {
+pub fn handle_despawn_part(
+    mut reader: EventReader<DespawnPartPacket>,
+    mut part_query: Query<(Entity, &ServerId), With<Part>>,
+    mut commands: Commands,
+) {
     for DespawnPartPacket { id } in reader.read() {
         for (entity, server_id) in &mut part_query {
             if server_id.0 == *id {


@@ 150,4 189,4 @@ pub fn handle_despawn_part(mut reader: EventReader<DespawnPartPacket>, mut part_
             }
         }
     }
-}>
\ No newline at end of file
+}

@@ 1,26 1,14 @@
-use std::collections::HashMap;
-
-use crate::components::{
-    Camera, Chat, Menu, Part, Player, PlayerResources, RecvPacket, SendPacket, ServerId,
-    SpriteBundle, Texture, Transform,
-};
-use bevy_ecs::{
-    entity::Entity,
-    event::Events,
-    query::{QuerySingleError, With},
-    world::World,
-};
 use bevy_ecs::prelude::Event;
-use nalgebra::{Rotation2, Scale3, Translation3};
+use bevy_ecs::{event::Events, world::World};
+use starkingdoms_common::packet::Packet;
 use starkingdoms_common::packet::Packet::{
     DespawnPart, EnergyUpdate, LoginResponse, Message, OpenCraftingUi, PartPositions,
     PlanetPositions, PlayerLeave, PlayerList, SpawnPart, SpawnPlayer,
 };
-use starkingdoms_common::packet::{DespawnPartPacket, EnergyUpdatePacket, LoginResponsePacket, MessagePacket, OpenCraftingUiPacket, Packet, PartPositionsPacket, PlanetPositionsPacket, PlayerLeavePacket, PlayerListPacket, SpawnPartPacket, SpawnPlayerPacket};
-use starkingdoms_common::{PartType, PlanetType};
+use starkingdoms_common::PartType;
 
-pub mod websocket;
 pub mod handlers;
+pub mod websocket;
 
 fn texture_name(part_type: PartType, attached: bool) -> String {
     use PartType::*;

@@ 33,6 33,7 @@ use winit::{
     event_loop::ActiveEventLoop, raw_window_handle::HasWindowHandle, window::Window,
 };
 
+use crate::components::Schedule::Update;
 use crate::components::{Camera, Menu, RecvPacket, SendPacket};
 use crate::networking::send_packet_event;
 use crate::networking::websocket::Websocket;


@@ 40,7 41,6 @@ use crate::platform::websocket::Ws;
 use crate::rendering::renderer::{RenderCreateContext, Renderer};
 use crate::rendering::MaybeRenderer::{Initialized, Initializing};
 use assets::AssetLoader;
-use crate::components::Schedule::Update;
 
 pub mod assets;
 mod renderer;


@@ 403,7 403,7 @@ impl ApplicationHandler for App {
         };
         let Some(window) = &self.window else { return };
 
-        let mut ws = self
+        let ws = self
             .world
             .get_resource_mut::<Ws>()
             .expect("Failed to get Ws resource");

@@ 1,9 1,6 @@
-use bevy_ecs::bundle::Bundle;
+use crate::components::{Part, Player, PlayerBundle, Texture, Transform};
 use bevy_ecs::prelude::Commands;
 use nalgebra::{Rotation2, Scale3, Translation3};
-use crate::components::{Part, Player, PlayerBundle, Texture, Transform};
-
-
 
 pub fn create_hearty(mut commands: Commands) {
     commands.spawn(PlayerBundle {


@@ 16,6 13,6 @@ pub fn create_hearty(mut commands: Commands) {
             name: "hearty.svg".to_string(),
         },
         player: Player,
-        part: Part(false)
+        part: Part(false),
     });
-}>
\ No newline at end of file
+}

@@ 280,4 280,4 @@ impl TryFrom<&Vec<u8>> for Packet {
     fn try_from(value: &Vec<u8>) -> Result<Self, Self::Error> {
         serde_json::from_slice(value).map_err(MsgFromError::JSONError)
     }
-}>
\ No newline at end of file
+}

@@ 748,9 748,7 @@ impl Codegen {
                 }
             }
             Lit::Str(value) => {
-                self.vm.units[self.vm.unit_ptr]
-                    .pool
-                    .push(Value::Str(value));
+                self.vm.units[self.vm.unit_ptr].pool.push(Value::Str(value));
                 self.vm.units[self.vm.unit_ptr]
                     .code
                     .push(OpCode::LOAD.into());

@@ 1153,23 1153,13 @@ impl Parser {
                 }
                 Ok(lit!(Ident, ident.clone(), token))
             }
-            TokenType::Num(num) => {
-                Ok(lit!(Num, num, token))
-            }
-            TokenType::Str(string) => {
-                Ok(lit!(Str, string, token))
-            }
+            TokenType::Num(num) => Ok(lit!(Num, num, token)),
+            TokenType::Str(string) => Ok(lit!(Str, string, token)),
             TokenType::True => Ok(lit!(Bool, true, token)),
             TokenType::False => Ok(lit!(Bool, false, token)),
-            TokenType::LeftParen => {
-                self.group(token)
-            }
-            TokenType::LeftSquare => {
-                self.array(token)
-            }
-            _ => {
-                Err(unexpected_token!(self, "Unexpected token {}", token))
-            }
+            TokenType::LeftParen => self.group(token),
+            TokenType::LeftSquare => self.array(token),
+            _ => Err(unexpected_token!(self, "Unexpected token {}", token)),
         }
     }
 

@@ 189,7 189,12 @@ pub fn mouse_picking(
         let y = rel_x * angle.sin() + rel_y * angle.cos();
         let bound = [-0.5, 0.5, -0.5, 0.5]; // left, right, top, bottom
 
-        if bound[0] < x && x < bound[1] && bound[2] < y && y < bound[3] && *button == ButtonType::Right {
+        if bound[0] < x
+            && x < bound[1]
+            && bound[2] < y
+            && y < bound[3]
+            && *button == ButtonType::Right
+        {
             send_events.push(WsEvent::Send {
                 to: q_player.addr,
                 message: Packet::OpenCraftingUi(OpenCraftingUiPacket { id: entity.index() })