Client/Server Feature Split (#63)

crates/shared/src/abilities/curver.rs

@@ -6,14 +6,11 @@ use crate::{
     physics_layers::GameLayer,
     protocol::GltfSceneRoot,
     tb_entities::EnemySpawn,
-    utils::{
-        auto_rotate::AutoRotation,
-        commands::{CommandExt, EntityCommandExt},
-        global_observer,
-    },
+    utils::{auto_rotate::AutoRotation, commands::CommandExt, global_observer},
 };
 use avian3d::prelude::*;
 use bevy::prelude::*;
+#[cfg(feature = "server")]
 use lightyear::prelude::{NetworkTarget, Replicate};
 use std::f32::consts::PI;
 
@@ -63,29 +60,30 @@ fn on_trigger_missile(
     let mut transform = Transform::from_translation(state.pos).with_rotation(rotation);
     transform.translation += transform.forward().as_vec3() * 2.0;
 
-    commands
-        .spawn((
-            Name::new("projectile-missile"),
-            CurverProjectile {
-                time: time.elapsed_secs(),
-                damage: head.damage,
-            },
-            Collider::capsule_endpoints(0.4, Vec3::new(0., 0., 2.), Vec3::new(0., 0., -2.)),
-            CollisionLayers::new(
-                LayerMask(GameLayer::Projectile.to_bits()),
-                LayerMask(state.target_layer.to_bits() | GameLayer::Level.to_bits()),
-            ),
-            Sensor,
-            CollisionEventsEnabled,
-            Visibility::default(),
-            transform,
-            children![(
-                Transform::from_rotation(Quat::from_rotation_x(PI / 2.).inverse()),
-                AutoRotation(Quat::from_rotation_x(0.4) * Quat::from_rotation_z(0.3)),
-                GltfSceneRoot::Projectile(head.projectile.clone()),
-            ),],
-        ))
-        .insert_server(Replicate::to_clients(NetworkTarget::All));
+    let mut _projectile = commands.spawn((
+        Name::new("projectile-missile"),
+        CurverProjectile {
+            time: time.elapsed_secs(),
+            damage: head.damage,
+        },
+        Collider::capsule_endpoints(0.4, Vec3::new(0., 0., 2.), Vec3::new(0., 0., -2.)),
+        CollisionLayers::new(
+            LayerMask(GameLayer::Projectile.to_bits()),
+            LayerMask(state.target_layer.to_bits() | GameLayer::Level.to_bits()),
+        ),
+        Sensor,
+        CollisionEventsEnabled,
+        Visibility::default(),
+        transform,
+        children![(
+            Transform::from_rotation(Quat::from_rotation_x(PI / 2.).inverse()),
+            AutoRotation(Quat::from_rotation_x(0.4) * Quat::from_rotation_z(0.3)),
+            GltfSceneRoot::Projectile(head.projectile.clone()),
+        ),],
+    ));
+
+    #[cfg(feature = "server")]
+    _projectile.insert(Replicate::to_clients(NetworkTarget::All));
 }
 
 fn enemy_hit(

crates/shared/src/abilities/missile.rs

@@ -6,15 +6,11 @@ use crate::{
     physics_layers::GameLayer,
     protocol::GltfSceneRoot,
     sounds::PlaySound,
-    utils::{
-        commands::{CommandExt, EntityCommandExt},
-        explosions::Explosion,
-        global_observer,
-        trail::Trail,
-    },
+    utils::{commands::CommandExt, explosions::Explosion, global_observer, trail::Trail},
 };
 use avian3d::prelude::*;
 use bevy::prelude::*;
+#[cfg(feature = "server")]
 use lightyear::prelude::{NetworkTarget, Replicate};
 use std::f32::consts::PI;
 
@@ -63,46 +59,46 @@ fn on_trigger_missile(
     let mut transform = Transform::from_translation(state.pos).with_rotation(rotation);
     transform.translation += transform.forward().as_vec3() * 2.0;
 
-    commands
-        .spawn((
-            Name::new("projectile-missile"),
-            MissileProjectile {
-                time: time.elapsed_secs(),
-                damage: head.damage,
-            },
-            Collider::capsule_endpoints(0.4, Vec3::new(0., 0., 2.), Vec3::new(0., 0., -2.)),
-            CollisionLayers::new(
-                LayerMask(GameLayer::Projectile.to_bits()),
-                LayerMask(state.target_layer.to_bits() | GameLayer::Level.to_bits()),
+    let mut _projectile = commands.spawn((
+        Name::new("projectile-missile"),
+        MissileProjectile {
+            time: time.elapsed_secs(),
+            damage: head.damage,
+        },
+        Collider::capsule_endpoints(0.4, Vec3::new(0., 0., 2.), Vec3::new(0., 0., -2.)),
+        CollisionLayers::new(
+            LayerMask(GameLayer::Projectile.to_bits()),
+            LayerMask(state.target_layer.to_bits() | GameLayer::Level.to_bits()),
+        ),
+        Sensor,
+        CollisionEventsEnabled,
+        Visibility::default(),
+        transform,
+        children![
+            (
+                Transform::from_rotation(Quat::from_rotation_x(PI / 2.).inverse()),
+                GltfSceneRoot::Projectile("missile".to_string()),
             ),
-            Sensor,
-            CollisionEventsEnabled,
-            Visibility::default(),
-            transform,
-            children![
-                (
-                    Transform::from_rotation(Quat::from_rotation_x(PI / 2.).inverse()),
-                    GltfSceneRoot::Projectile("missile".to_string()),
-                ),
-                (
-                    Trail::new(
-                        12,
-                        LinearRgba::rgb(1., 0.0, 0.),
-                        LinearRgba::rgb(0.9, 0.9, 0.)
-                    )
-                    .with_pos(transform.translation),
-                    Gizmo {
-                        handle: gizmo_assets.add(GizmoAsset::default()),
-                        line_config: GizmoLineConfig {
-                            width: 10.,
-                            ..default()
-                        },
+            (
+                Trail::new(
+                    12,
+                    LinearRgba::rgb(1., 0.0, 0.),
+                    LinearRgba::rgb(0.9, 0.9, 0.)
+                )
+                .with_pos(transform.translation),
+                Gizmo {
+                    handle: gizmo_assets.add(GizmoAsset::default()),
+                    line_config: GizmoLineConfig {
+                        width: 10.,
                         ..default()
                     },
-                )
-            ],
-        ))
-        .insert_server(Replicate::to_clients(NetworkTarget::All));
+                    ..default()
+                },
+            )
+        ],
+    ));
+    #[cfg(feature = "server")]
+    _projectile.insert(Replicate::to_clients(NetworkTarget::All));
 }
 
 fn update(mut query: Query<&mut Transform, With<MissileProjectile>>) {

crates/shared/src/abilities/mod.rs

@@ -18,7 +18,7 @@ use crate::{
     physics_layers::GameLayer,
     player::{Player, PlayerBodyMesh},
     sounds::PlaySound,
-    utils::{billboards::Billboard, commands::IsServer, sprite_3d_animation::AnimationTimer},
+    utils::{billboards::Billboard, sprite_3d_animation::AnimationTimer},
 };
 use bevy::{pbr::NotShadowCaster, prelude::*};
 use bevy_sprite3d::{Sprite3dBuilder, Sprite3dParams};
@@ -126,11 +126,10 @@ fn on_trigger_state(
     player: Query<(&ActiveHead, &ActionState<ControlState>), With<Player>>,
     headdb: Res<HeadsDatabase>,
     time: Res<Time>,
-    is_server: Option<Res<IsServer>>,
     client: Query<&Client>,
 ) {
     if let Ok(client) = client.single()
-        && (client.state == ClientState::Connected && is_server.is_none())
+        && (client.state == ClientState::Connected && cfg!(not(feature = "server")))
     {
         return;
     }

crates/shared/src/abilities/thrown.rs

@@ -7,15 +7,13 @@ use crate::{
     protocol::GltfSceneRoot,
     sounds::PlaySound,
     utils::{
-        auto_rotate::AutoRotation,
-        commands::{CommandExt, EntityCommandExt},
-        explosions::Explosion,
-        global_observer,
+        auto_rotate::AutoRotation, commands::CommandExt, explosions::Explosion, global_observer,
     },
 };
 use avian3d::prelude::*;
 use bevy::prelude::*;
 use bevy_ballistic::launch_velocity;
+#[cfg(feature = "server")]
 use lightyear::prelude::{NetworkTarget, Replicate};
 use serde::{Deserialize, Serialize};
 use std::f32::consts::PI;
@@ -62,31 +60,32 @@ fn on_trigger_thrown(
     //TODO: projectile db?
     let explosion_animation = !matches!(state.head, 8 | 16);
 
-    commands
-        .spawn((
-            Transform::from_translation(pos),
-            Name::new("projectile-thrown"),
-            ThrownProjectile {
-                impact_animation: explosion_animation,
-                damage: head.damage,
-            },
-            Collider::sphere(0.4),
-            CollisionLayers::new(
-                LayerMask(GameLayer::Projectile.to_bits()),
-                LayerMask(state.target_layer.to_bits() | GameLayer::Level.to_bits()),
-            ),
-            RigidBody::Dynamic,
-            CollisionEventsEnabled,
-            Mass(0.01),
-            LinearVelocity(vel),
-            Visibility::default(),
-            Sensor,
-        ))
-        .insert_server(Replicate::to_clients(NetworkTarget::All))
-        .with_child((
-            AutoRotation(Quat::from_rotation_x(0.4) * Quat::from_rotation_z(0.3)),
-            GltfSceneRoot::Projectile(head.projectile.clone()),
-        ));
+    let mut projectile = commands.spawn((
+        Transform::from_translation(pos),
+        Name::new("projectile-thrown"),
+        ThrownProjectile {
+            impact_animation: explosion_animation,
+            damage: head.damage,
+        },
+        Collider::sphere(0.4),
+        CollisionLayers::new(
+            LayerMask(GameLayer::Projectile.to_bits()),
+            LayerMask(state.target_layer.to_bits() | GameLayer::Level.to_bits()),
+        ),
+        RigidBody::Dynamic,
+        CollisionEventsEnabled,
+        Mass(0.01),
+        LinearVelocity(vel),
+        Visibility::default(),
+        Sensor,
+    ));
+    projectile.with_child((
+        AutoRotation(Quat::from_rotation_x(0.4) * Quat::from_rotation_z(0.3)),
+        GltfSceneRoot::Projectile(head.projectile.clone()),
+    ));
+
+    #[cfg(feature = "server")]
+    projectile.insert(Replicate::to_clients(NetworkTarget::All));
 }
 
 fn shot_collision(