pastemyst

Weapon Spawning issues over network

(at edit #0)

present

Player Combat Controller

C#copy raw

```cs

// Error is explained on line 154

using System;
using System.Collections.Generic;
using JebScripts.Game.Combat;
using JebScripts.Game.Input;
using Unity.Netcode;
using UnityEngine;

namespace JebScripts.Game.Player
{
    public class PlayerCombatController : NetworkBehaviour
    {
        [Header("Input")]
        [SerializeField] InputReader inputReader;

[Header("Gun")] 
        [SerializeField] private GunController[] startingGuns;
        [SerializeField] private Transform gunTransform;
        
        // Weapon Inventory
        
        private GunController activeGunController;
        [SerializeField] private int maxWeapons = 2;
        private NetworkVariable<int> activeWeaponsSlot = new NetworkVariable<int>();
        private List<GunController> ownedGuns = new();
        
        public Action<GunController> onWeaponSlotChanged;
        
        // Load Functions
        
        public override void OnNetworkSpawn()
        {
             SetupGunControls();
            
            if (!IsOwner)
                return;
           
            inputReader.OnFireEvent += OnFire;
            inputReader.OnFireCanceledEvent += OnFireCanceled;
            inputReader.OnReloadEvent += OnReload;
            inputReader.OnAimEvent += OnAim;
            inputReader.OnDirectChangeWeaponSlot += RequestActiveWeaponSlotChange;
        }
        
        public override void OnNetworkDespawn()
        {
            activeWeaponsSlot.OnValueChanged -= WeaponSlotChanged;
            
            if (!IsOwner)
                return;
            inputReader.OnFireEvent -= OnFire;
            inputReader.OnFireCanceledEvent -= OnFireCanceled;
            inputReader.OnReloadEvent -= OnReload;
            inputReader.OnAimEvent -= OnAim;
            inputReader.OnDirectChangeWeaponSlot -= RequestActiveWeaponSlotChange;
        }

private void SetupGunControls()
        {
            activeWeaponsSlot.OnValueChanged += WeaponSlotChanged;
            if (IsServer)
            {
                foreach (GunController weapon in startingGuns)
                {
                    AddGunToInventory(weapon, false);
                }

RequestActiveWeaponSlotChange(0);
            }
            
            if(IsClient)
                WeaponSlotChanged(-1, activeWeaponsSlot.Value);
        }
        
        // Firing
        private void OnFire()
        {
            activeGunController.StartShooting();
        }
        
        private void OnFireCanceled()
        {
            activeGunController.StopShooting();
        }
        
        // Aiming
        private void OnAim(Vector2 value)
        {
            if (Camera.main == null) 
                return;
            Vector2 worldTarget = Camera.main.ScreenToWorldPoint(value);
            Vector2 aimDirection = worldTarget - (Vector2)gunTransform.position;
            float angle = Mathf.Atan2(aimDirection.y, aimDirection.x) * Mathf.Rad2Deg;
            gunTransform.rotation = Quaternion.Euler(0, 0, angle);
            
            gunTransform.localScale = aimDirection.x < 0 ? new Vector3(1, -1, 1) :
                new Vector3(1, 1, 1);
        }

// Reloading
        private void OnReload()
        {
            activeGunController.Reload();
        }

// Weapon Changing
        
        private void RequestActiveWeaponSlotChange(int newSlot)
        {
            if (IsServer)
            {
                activeWeaponsSlot.Value = Mathf.Clamp(newSlot, 0, ownedGuns.Count - 1);;
            }
            else
            {
                RequestActiveWeaponSlotChangeServerRPC(newSlot);
            }
        }
        
        [ServerRpc]
        private void RequestActiveWeaponSlotChangeServerRPC(int slot)
        {
            ApplyActiveWeaponSlotChange(slot);
        }

private void ApplyActiveWeaponSlotChange(int slot)
        {
            if (ownedGuns == null || ownedGuns.Count == 0 || slot == activeWeaponsSlot.Value) 
                return;

activeWeaponsSlot.Value = Mathf.Clamp(slot, 0, ownedGuns.Count - 1);
        }
        
        private void WeaponSlotChanged(int previousvalue, int newvalue)
        {
            if (previousvalue >= 0 && previousvalue < ownedGuns.Count)
            {
                GunController previousGun = ownedGuns[previousvalue];
                if (previousGun)
                    previousGun.ShowVisuals(false);
            }
            
            if (newvalue < 0 || newvalue >= ownedGuns.Count) 
                return;
            GunController nextGun = ownedGuns[newvalue];
            
            if (!nextGun) 
                return;
            
            nextGun.ShowVisuals(true);
            activeGunController = nextGun;
        }
        
        // Adding Guns
        
        // This Is Where I am having issues with the my code,  im trying to spawn in a gun prefab which has a network behaviour on it (Gun Controller) but all that happens is it spawns the gun into the scene.  No parenting so doesnt attatch to the intedned socket(trasnform) so doesnt follow the player.  On the server the player can still fire and switch the gun that is active like in the functions above but on any late joining they cant fire their weapons, However they can change their active gun but it only shows on the server client.
        
        // Spawn Guns in and store them in each players inventory
        // allow each player to control their gun
        // Should attatch to socket on each players prefab at runtime
        // switching between active guns should show on everyones version
        
        private void AddGunToInventory(GunController newGun, bool equip = true)
        { 
            if (!IsServer) return;

int targetIndex = ownedGuns.Count < maxWeapons ? ownedGuns.Count : activeWeaponsSlot.Value;
            if (targetIndex < ownedGuns.Count && ownedGuns[targetIndex] != null)
            {
                ownedGuns[targetIndex].NetworkObject.Despawn();
                Destroy(ownedGuns[targetIndex].gameObject);
                ownedGuns[targetIndex] = null;
            }

GunController gun = Instantiate(newGun, transform);
            NetworkObject networkObj = gun.GetComponent<NetworkObject>();

networkObj.Spawn();
            
            if (targetIndex < ownedGuns.Count)
                ownedGuns[targetIndex] = gun;
            else
                ownedGuns.Add(gun);
            
            //newGunVisual.transform.localPosition = Vector3.zero;
            //newGunVisual.transform.localRotation = Quaternion.identity;
            
            gun.ShowVisuals(equip);
            
            if (equip)
                RequestActiveWeaponSlotChange(targetIndex);
        }
    }
}
```

Gun Controller

C#copy raw

```cs
using Unity.Netcode;
using UnityEngine;

namespace JebScripts.Game.Combat
{
    public class GunController : NetworkBehaviour
    {
        [Header("Basic Information")]
        public string gunName;
        
        [Header("Firing Information")]
        [Tooltip("Time between shots (seconds)")]
        [SerializeField] private float fireRate;
        [SerializeField] private float bulletSpeed;
        [SerializeField] private int maxMagAmmo;
        [SerializeField] private int maxReserveAmmo;
        [SerializeField] private FireType fireType;

[Header("Projectiles")]
        [SerializeField] private GameObject serverBulletPrefab;
        [SerializeField] private GameObject clientBulletPrefab;
        
        [Header("Muzzle")]
        [SerializeField] private Transform muzzle;
        private Vector3 MuzzlePosition => muzzle.position;
        private Vector3 MuzzleDirection => muzzle.up;
        
        [Header("Visuals")]
        [SerializeField] private Transform visualTransform;
        
        public bool bIsFiring = false;
        private float currentFireDelay = 0f;
        
        private NetworkVariable<int> currentMagAmmo = new NetworkVariable<int>();
        private NetworkVariable<int> currentReserveAmmo = new NetworkVariable<int>();

public override void OnNetworkSpawn()
        {
            if (IsServer)
            {
                RequestFillAmmo();
            }
            
            currentMagAmmo.OnValueChanged += CurrentMagAmmoChanged;
            currentReserveAmmo.OnValueChanged += CurrentReserveAmmoChanged;
        }
        
        public override void OnNetworkDespawn()
        {
            currentMagAmmo.OnValueChanged -= CurrentMagAmmoChanged;
            currentReserveAmmo.OnValueChanged -= CurrentReserveAmmoChanged;
        }

private void CurrentReserveAmmoChanged(int previousvalue, int newvalue)
        {
            Debug.Log($"Reserve Ammo Ammo {newvalue}");
        }

private void CurrentMagAmmoChanged(int previousvalue, int newvalue)
        {
            Debug.Log($"Mag Ammo {newvalue}");
        }

// Tick Functions
        private void Update()
        {
            if (!IsOwner)
                return;

if (currentFireDelay > 0f)
                currentFireDelay -= Time.deltaTime;
            
            fireType?.UpdateFiring(this);
        }

// Shooting
        public void StartShooting()
        {
            fireType?.StartFiring(this);
        }
        
        public void StopShooting()
        {
            fireType?.StopFiring(this);
        }

public bool CanFire()
        {
            return currentFireDelay <= 0f && currentMagAmmo.Value > 0;
        }
        
        public void ResetFireDelay()
        {
            currentFireDelay = fireRate;
        }
        
        public void FireProjectile()
        {
            if (!IsOwner) 
                return;

Vector3 pos = MuzzlePosition;
            Vector3 direction = MuzzleDirection;
            
            SpawnProjectileServerRPC(pos, direction);
            SpawnDummyProjectile(pos, direction);
        }

private void SpawnDummyProjectile(Vector3 position, Vector3 direction)
        {
            GameObject projectileInstance = Instantiate(
                clientBulletPrefab,
                position,
                Quaternion.identity);
            
            projectileInstance.transform.up = direction;

if (!projectileInstance.TryGetComponent<ProjectilePropulsion>(out ProjectilePropulsion propulsion)) 
                return;
            float speed = bulletSpeed;
            propulsion.AddPropulsion(speed);
        }

[ServerRpc]
        private void SpawnProjectileServerRPC(Vector3 position, Vector3 direction)
        {
            ReduceAmmo(1);
            
            GameObject projectileInstance = Instantiate(
                serverBulletPrefab,
                position,
                Quaternion.identity);
            
            projectileInstance.transform.up = direction;

if (projectileInstance.TryGetComponent<ProjectilePropulsion>(out ProjectilePropulsion propulsion))
            {
                float speed = bulletSpeed;
                propulsion.AddPropulsion(speed);
            }
            
            SpawnDummyProjectileClientRPC(position, direction);
        }
        
        [ClientRpc]
        private void SpawnDummyProjectileClientRPC(Vector3 position, Vector3 direction)
        {
            if(IsOwner)
                return;
            
            SpawnDummyProjectile(position, direction);
        }
        
        // Ammo
        public void Reload()
        {
            RequestReloadMag();
        }

public void RequestFillAmmo()
        {
            if (IsServer)
            {
                FillAmmo();
                return;
            }
            FillAmmoServerRPC();
        }

[ServerRpc]
        private void FillAmmoServerRPC()
        {
            FillAmmo();
        }

private void FillAmmo()
        {
            currentMagAmmo.Value = maxMagAmmo;
            currentReserveAmmo.Value = maxReserveAmmo;
        }

private void RequestReloadMag()
        {
            if (IsServer)
            {
                ReloadMag();
                return;
            }
            ReloadMagServerRPC();
        }

[ServerRpc]
        private void ReloadMagServerRPC()
        {
            ReloadMag();
        }

private void ReloadMag()
        {
            int bulletsNeeded = maxMagAmmo - currentMagAmmo.Value;
            if (bulletsNeeded <= 0)
                return;
            
            int bulletsAvailable = Mathf.Min(bulletsNeeded, currentReserveAmmo.Value);
            if (bulletsAvailable <= 0)
                return;
            
            currentReserveAmmo.Value -= bulletsAvailable;
            currentMagAmmo.Value += bulletsAvailable;
        }
        
        private void ReduceAmmo(int ammo)
        {
            // Only Called on server
            currentMagAmmo.Value = Mathf.Clamp(
                currentMagAmmo.Value - 1,
                0,
                maxMagAmmo
            );
        }
        
        // Visuals

public void ShowVisuals(bool show)
        {
            visualTransform.gameObject.SetActive(show);
        }
    }
}

```

created at:

stats: 432 lines, 953 words, 13.27kb