8 files changed, 99 insertions(+), 29 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/common/src/packet.rs
M crates/server/src/player/client_login.rs
M crates/server/src/player/packet.rs

@@ 25,6 25,14 @@ pub struct OtherPlayerBundle {
     pub username: PlayerUsername,
 }
 
+#[derive(Bundle)]
+pub struct PlanetBundle {
+    pub transform: Transform,
+    pub texture: Texture,
+    pub server_id: ServerId,
+    pub planet: Planet,
+}
+
 #[derive(ScheduleLabel, Hash, Clone, Debug, Eq, PartialEq)]
 pub enum Schedule {
     Startup,

@@ 10,6 10,7 @@ use crate::systems::create_hearty;
 use bevy_ecs::schedule::Schedule;
 use bevy_ecs::{event::Events, world::World};
 use components::{Camera, Chat, RecvPacket, SendPacket};
+use networking::handlers::{handle_planet_positions, handle_spawn_planet};
 use platform::assets::Assets;
 use platform::websocket::Ws;
 use rendering::assets::AssetLoader;


@@ 79,6 80,8 @@ pub fn start() {
     update_schedule.add_systems(handle_spawn_player);
     update_schedule.add_systems(handle_spawn_part);
     update_schedule.add_systems(handle_part_positions);
+    update_schedule.add_systems(handle_spawn_planet);
+    update_schedule.add_systems(handle_planet_positions);
     update_schedule.add_systems(handle_energy_update);
     update_schedule.add_systems(handle_crafting_ui);
     update_schedule.add_systems(handle_message);

@@ 1,17 1,15 @@
 use crate::components::{
-    Camera, Chat, Menu, OtherPlayerBundle, Part, PartBundle, Player, PlayerResources,
-    PlayerUsername, ServerId, Texture, Transform,
+    Camera, Chat, Menu, OtherPlayerBundle, Part, PartBundle, Planet, PlanetBundle, 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, PlayerLeavePacket, PlayerListPacket,
-    SpawnPartPacket, SpawnPlayerPacket,
+    DespawnPartPacket, EnergyUpdatePacket, LoginResponsePacket, MessagePacket, OpenCraftingUiPacket, PartPositionsPacket, PlanetPositionsPacket, PlayerLeavePacket, PlayerListPacket, SpawnPartPacket, SpawnPlanetPacket, SpawnPlayerPacket
 };
 use starkingdoms_common::PartType;
 
+use super::{part_texture_name, planet_texture_name};
+
 pub fn handle_login_response(
     mut reader: EventReader<LoginResponsePacket>,
     player: Query<Entity, With<Player>>,


@@ 96,7 94,7 @@ pub fn handle_spawn_part(mut reader: EventReader<SpawnPartPacket>, mut commands:
                 scale: Scale3::new(25.0, 25.0, 1.0),
             },
             texture: Texture {
-                name: texture_name(part.part_type, part.flags.attached),
+                name: part_texture_name(part.part_type, part.flags.attached),
             },
             server_id: ServerId(*server_id),
             part: Part(part.flags.attached),


@@ 119,10 117,10 @@ pub fn handle_part_positions(
                     transform.rotation = Rotation2::new(part.transform.rot);
 
                     if part.flags.attached && !bevy_part.0 {
-                        texture.name = texture_name(part.part_type, part.flags.attached);
+                        texture.name = part_texture_name(part.part_type, part.flags.attached);
                         bevy_part.0 = true;
                     } else if !part.flags.attached && bevy_part.0 {
-                        texture.name = texture_name(part.part_type, part.flags.attached);
+                        texture.name = part_texture_name(part.part_type, part.flags.attached);
                         bevy_part.0 = false;
                     }
                 }


@@ 139,6 137,31 @@ pub fn handle_part_positions(
     }
 }
 
+pub fn handle_spawn_planet(
+    mut reader: EventReader<SpawnPlanetPacket>,
+    mut commands: Commands,
+) {
+    for SpawnPlanetPacket { id, planet, radius } in reader.read() {
+        commands.spawn(PlanetBundle {
+            transform: Transform {
+                translation: Translation3::new(planet.transform.x, planet.transform.y, 0.0),
+                rotation: Rotation2::new(0.0),
+                scale: Scale3::new(*radius, *radius, 1.0),
+            },
+            texture: Texture { name: planet_texture_name(planet.planet_type) },
+            server_id: ServerId(*id),
+            planet: Planet,
+        });
+    }
+}
+pub fn handle_planet_positions(
+    mut reader: EventReader<PlanetPositionsPacket>
+) {
+    for PlanetPositionsPacket { planets } in reader.read() {
+        // TODO: do something
+    }
+}
+
 pub fn handle_energy_update(
     mut reader: EventReader<EnergyUpdatePacket>,
     mut player_res: ResMut<PlayerResources>,

@@ 5,12 5,12 @@ use starkingdoms_common::packet::Packet::{
     DespawnPart, EnergyUpdate, LoginResponse, Message, OpenCraftingUi, PartPositions,
     PlanetPositions, PlayerLeave, PlayerList, SpawnPart, SpawnPlayer,
 };
-use starkingdoms_common::PartType;
+use starkingdoms_common::{PartType, PlanetType};
 
 pub mod handlers;
 pub mod websocket;
 
-fn texture_name(part_type: PartType, attached: bool) -> String {
+fn part_texture_name(part_type: PartType, attached: bool) -> String {
     use PartType::*;
     if attached {
         match part_type {


@@ 35,6 35,34 @@ fn texture_name(part_type: PartType, attached: bool) -> String {
     }
 }
 
+fn planet_texture_name(planet_type: PlanetType) -> String {
+    match planet_type {
+        /*PlanetType::Sun => "sun.svg",
+        PlanetType::Mercury => "mercury.svg",
+        PlanetType::Venus => "venus.svg",
+        PlanetType::Earth => "earth.svg",
+        PlanetType::Moon => "moon.svg",
+        PlanetType::Mars => "mars.svg",
+        PlanetType::Jupiter => "jupiter.svg",
+        PlanetType::Saturn => "saturn.svg",
+        PlanetType::Uranus => "uranus.svg",
+        PlanetType::Neptune => "neptune.svg",
+        PlanetType::Pluto => "pluto.svg",*/
+        PlanetType::Sun => "sun.svg",
+        PlanetType::Mercury => "moon.svg",
+        PlanetType::Venus => "venus.svg",
+        PlanetType::Earth => "earth.svg",
+        PlanetType::Moon => "moon.svg",
+        PlanetType::Mars => "mars.svg",
+        PlanetType::Jupiter => "jupiter.svg",
+        PlanetType::Saturn => "sun.svg",
+        PlanetType::Uranus => "venus.svg",
+        PlanetType::Neptune => "mars.svg",
+        PlanetType::Pluto => "earth.svg",
+    }
+    .to_string()
+}
+
 pub fn send_event<T: Event>(e: T, world: &mut World) {
     let mut events = world.resource_mut::<Events<T>>();
     events.send(e);


@@ 52,6 80,7 @@ pub fn send_packet_event(packet: Packet, world: &mut World) {
         SpawnPlayer(e) => send_event(e, world),
         PlayerList(e) => send_event(e, world),
         PlanetPositions(e) => send_event(e, world),
+        Packet::SpawnPlanet(e) => send_event(e, world),
         PartPositions(e) => send_event(e, world),
         SpawnPart(e) => send_event(e, world),
         DespawnPart(e) => send_event(e, world),

@@ 6,6 6,7 @@ use bevy_ecs::entity::Entity;
 use bevy_ecs::event::Events;
 use bevy_ecs::query::With;
 use bevy_ecs::world::World;
+use glow::HasContext;
 #[cfg(not(target_arch = "wasm32"))]
 use glutin::surface::{GlSurface, Surface, SwapInterval, WindowSurface};
 #[cfg(not(target_arch = "wasm32"))]


@@ 275,13 276,13 @@ impl ApplicationHandler for App {
                 let mut camera = self.world.get_resource_mut::<Camera>().unwrap();
                 camera.width = size.width;
                 camera.height = size.height;
-                /*
+
                 unsafe {
                     self.gl
                         .as_ref()
                         .unwrap()
                         .viewport(0, 0, size.width as i32, size.height as i32);
-                }*/
+                }
             }
             WindowEvent::MouseWheel { delta, .. } => {
                 let mut camera = self.world.get_resource_mut::<Camera>().unwrap();


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

@@ 39,7 39,6 @@ macro_rules! proto_transform {
 pub struct Planet {
     pub planet_type: PlanetType,
     pub transform: ProtoTransform,
-    pub radius: f32,
 }
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
 pub struct Part {


@@ 144,6 143,14 @@ pub struct PlanetPositionsPacket {
 
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
 #[cfg_attr(feature = "bevy", derive(::bevy_ecs::event::Event))]
+pub struct SpawnPlanetPacket {
+    pub id: u32,
+    pub planet: Planet,
+    pub radius: f32,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
+#[cfg_attr(feature = "bevy", derive(::bevy_ecs::event::Event))]
 pub struct PartPositionsPacket {
     pub parts: Vec<(u32, Part)>,
 }


@@ 216,6 223,7 @@ pub enum Packet {
     SpawnPlayer(SpawnPlayerPacket),
     PlayerList(PlayerListPacket),
     PlanetPositions(PlanetPositionsPacket),
+    SpawnPlanet(SpawnPlanetPacket),
     PartPositions(PartPositionsPacket),
     SpawnPart(SpawnPartPacket),
     DespawnPart(DespawnPartPacket),


@@ 238,6 246,7 @@ pub fn register_packet_events(world: &mut bevy_ecs::prelude::World) {
     bevy_ecs::event::EventRegistry::register_event::<LoginResponsePacket>(world);
     bevy_ecs::event::EventRegistry::register_event::<PlayerListPacket>(world);
     bevy_ecs::event::EventRegistry::register_event::<PlanetPositionsPacket>(world);
+    bevy_ecs::event::EventRegistry::register_event::<SpawnPlanetPacket>(world);
     bevy_ecs::event::EventRegistry::register_event::<PartPositionsPacket>(world);
     bevy_ecs::event::EventRegistry::register_event::<SpawnPartPacket>(world);
     bevy_ecs::event::EventRegistry::register_event::<DespawnPartPacket>(world);

@@ 18,8 18,7 @@ use jwt::VerifyWithKey;
 use rand::Rng;
 use sha2::Sha256;
 use starkingdoms_common::packet::{
-    LoginResponsePacket, MessagePacket, PlanetPositionsPacket, PlayerListPacket, SpawnPartPacket,
-    SpawnPlayerPacket,
+    LoginResponsePacket, MessagePacket, PlanetPositionsPacket, PlayerListPacket, SpawnPartPacket, SpawnPlanetPacket, SpawnPlayerPacket
 };
 use starkingdoms_common::{
     packet::{MessageType, Packet, Part, Planet, ProtoPartFlags},


@@ 249,25 248,24 @@ pub fn packet_stream(
         message: packet.into_message(),
     });
     // tell this player the planets
-    let mut planets = Vec::new();
+    //let mut planets = Vec::new();
     for (entity, planet_type, transform) in planet_query.iter() {
         let translation = transform.translation;
-        planets.push((
-            entity.index(),
-            Planet {
+        let packet = Packet::SpawnPlanet(SpawnPlanetPacket {
+            id: entity.index(),
+            planet: Planet {
                 planet_type: planet_type.0,
                 transform: proto_transform!(Transform::from_translation(
                     translation * CLIENT_SCALE
                 )),
-                radius: planet!(*planet_type).size * CLIENT_SCALE,
             },
-        ));
+            radius: planet!(*planet_type).size * CLIENT_SCALE,
+        });
+        event_queue.push(WsEvent::Send {
+            to: *from,
+            message: packet.into_message(),
+        });
     }
-    let packet = Packet::PlanetPositions(PlanetPositionsPacket { planets });
-    event_queue.push(WsEvent::Send {
-        to: *from,
-        message: packet.into_message(),
-    });
 
     // tell the player already existing users
     let mut players = Vec::new();

@@ 71,7 71,6 @@ pub fn on_position_change(
                 transform: proto_transform!(Transform::from_translation(
                     transform.translation * CLIENT_SCALE
                 )),
-                radius: planet!(*planet_type).size * CLIENT_SCALE,
             },
         ));
     }