cleanup 3d stuff

server/src/main.rs

@@ -80,13 +80,11 @@ fn main() {
 fn server_update_system(
     mut server_events: EventReader<ServerEvent>,
     mut commands: Commands,
-    mut meshes: ResMut<Assets<Mesh>>,
-    mut materials: ResMut<Assets<StandardMaterial>>,
     mut lobby: ResMut<ServerLobby>,
     mut server: ResMut<RenetServer>,
     mut visualizer: ResMut<RenetServerVisualizer<200>>,
     mut client_ticks: ResMut<ClientTicks>,
-    players: Query<(Entity, &Player, &Transform)>,
+    players: Query<(Entity, &Player)>,
 ) {
     for event in server_events.iter() {
         match event {
@@ -96,19 +94,16 @@ fn server_update_system(
                 visualizer.add_client(*id);
 
                 // Initialize other players for this new client
-                for (entity, player, transform) in players.iter() {
-                    let translation: [f32; 3] = transform.translation.into();
+                for (entity, player) in players.iter() {
                     let message = bincode::serialize(&ServerMessages::PlayerCreate {
                         id: player.id,
                         entity,
-                        translation,
                     })
                     .unwrap();
                     server.send_message(*id, ServerChannel::ServerMessages.id(), message);
                 }
 
                 // Spawn new player
-                let transform = Transform::from_xyz(0., 0.51, 0.);
                 let player_entity = commands
                     .spawn_bundle(SpriteBundle {
                         sprite: Sprite {
@@ -125,17 +120,15 @@ fn server_update_system(
                     .insert(Velocity::default())
                     .insert(Player {
                         id: *id,
-                        location: Vec2::new(10., 10.),
+                        position: Vec2::new(10., 10.),
                     })
                     .id();
 
                 lobby.players.insert(*id, player_entity);
 
-                let translation: [f32; 3] = transform.translation.into();
                 let message = bincode::serialize(&ServerMessages::PlayerCreate {
                     id: *id,
                     entity: player_entity,
-                    translation,
                 })
                 .unwrap();
 
@@ -164,23 +157,23 @@ fn server_update_system(
             let command: PlayerCommand = bincode::deserialize(&message).unwrap();
 
             match command {
-                PlayerCommand::BasicAttack { mut cast_at } => {
+                PlayerCommand::BasicAttack { mut fired_at } => {
                     println!(
                         "Received basic attack from client {}: {:?}",
-                        client_id, cast_at
+                        client_id, fired_at
                     );
 
                     if let Some(player_entity) = lobby.players.get(&client_id) {
-                        if let Ok((_, _, player_transform)) = players.get(*player_entity) {
-                            cast_at[1] = player_transform.translation[1];
+                        if let Ok((_, player)) = players.get(*player_entity) {
+                            fired_at = player.position;
 
                             let projectile_entity =
-                                spawn_projectile(&mut commands, cast_at, cast_at);
+                                spawn_projectile(&mut commands, fired_at, fired_at);
 
                             let message = ServerMessages::SpawnProjectile {
                                 entity: projectile_entity,
-                                location: cast_at,
-                                direction: cast_at,
+                                position: fired_at,
+                                direction: fired_at,
                             };
 
                             let message = bincode::serialize(&message).unwrap();
@@ -255,10 +248,9 @@ fn move_players_system(mut query: Query<(&mut Velocity, &PlayerInput)>) {
     for (mut velocity, input) in query.iter_mut() {
         let x = (input.right as i8 - input.left as i8) as f32;
         let y = (input.down as i8 - input.up as i8) as f32;
-        let direction = Vec2::new(x, y).normalize_or_zero();
 
-        velocity.linvel.x = direction.x * PLAYER_MOVE_SPEED;
-        velocity.linvel.y = direction.y * PLAYER_MOVE_SPEED;
+        velocity.linvel.x = x * PLAYER_MOVE_SPEED;
+        velocity.linvel.y = y * PLAYER_MOVE_SPEED;
     }
 }