Pfthb

We are building a real time strategy game on Unity and trying to destroy gameobjects on the server and the clients via network.
Currently a player can always destroy his own objects and the server can destroy all objects. But when a client tries to destroy objects of the server (or other clients) it only gets destroyed on this client. (As the client neither hasAuthority nor the object isLocalPlayer)

We tried different approaches:

1. Using Destroy(gameObject)

This will obviously not work as it gets only destroyed locally.

2. Using NetworkServer.Destroy(gameObject)

This fails as we don't have the authority.

3. Using a command to destroy the object

The moment we try to call a command on the server in which we destroy the object fails as well. Due to the authority check:

Trying to send command for object without authority.

4. First assigning the authority

We tried to assign the authority via
GetComponent<NetworkIdentity>().AssignClientAuthority(connectionToClient);
but get the Error Message:

AssignClientAuthority can only be call on the server for spawned objects.

Trying to do this in a Command will fail due to Point 3.

Are there other possibilities to destroy gameObjects?
What is the way to go for destroying the gameObjects?

Edit: We spawned most of the objects during runtime (in a Command) via NetworkServer.SpawnWithClientAuthority or NetworkServer.Spawn

Despite the fact UNet is going to end soon (as already mentioned by Draco18s) so far I would have done this:

1. Add a NetworkIdentity to the GameObject you want to be able to destroy/identify over the network.




2. If it is a prefab you spawn make sure it is added to the spawnable prefabs in the NetworkManager



3. 
   

   Since the local player object always has the authority over itself and components attached to it add the [Command] call to a component on the local player object (not on the target GameObjects) and use NetworkServer.Destroy e.g. something like

   
   
   
   
   

   public class NetworkObjectDestroyer : NetworkBehaviour
   
    // Called by the Player
    [Client]
    public void TellServerToDestroyObject(GameObject obj)
    
    CmdDestroyObject(obj);
    
   
    // Executed only on the server
    [Command]
    private void CmdDestroyObject(GameObject obj)
    
    // It is very unlikely but due to the network delay
    // possisble that the other player also tries to
    // destroy exactly the same object beofre the server
    // can tell him that this object was already destroyed.
    // So in that case just do nothing.
    if(!obj) return;
   
    NetworkServer.Destroy(obj);
    
   
   

   
   
   

   Hint: You also could add this for easier access since you are sure that you only need access to exactly one of those components (namely the one of your local player):

   
   
   

   public static NetworkObjectDestroyer Instance;
   
   private void Awake()
   
    // skip if not the local player
    if(!isLocalPlayer) return;
   
    // set the static instance
    Instance = this;
   
   

   
   


4. 
   

   Than later somewhere in your other script that needs to execute the destroy you do something like

   
   
   

   // that you would have to get somewhere if not anyway 
   // calling from a component of the local player object
   GameObject playerObject;
   
   // wherever you get your target object from
   GameObject targetObject;
   
   playerObject.GetComponent<NetworkObjectDestroyer>().TellServerToDestroyObject(targetObject);
   

   
   
   

   It is easier if you added the static Instance before. Than you can simply use

   
   
   

   NetworkObjectDestroyer.Instance.TellServerToDestroyObject(targetObject);
   

   
   
   

   without having to get the references first.

   
   

How about using (1) and set up each client to have authority over their own game objects? Then all you need to ensure is to have each client be notified by the server on particular events.

Here is a more open-ended question regarding multiplayer that describes how it would work manually. by having the clients listen to server messages/RPCs.

straight from the unity docs:

Local authority
Local authority (sometimes referred to as client authority) means the local client has authoritative control over a particular networked GameObject. This is in contrast to the default state which is that the server has authoritative control over networked GameObjects.

In addition to isLocalPlayer****, you can choose to make the player GameObjects have “local authority”. This means that the player GameObject on its owner’s client is responsible for (or has authority over) itself. This is particularly useful for controlling movement; it means that each client has authority over how their own player GameObject is being controlled.

To enable local player authority on a GameObject, tick the Network Identity component
’s Local Player Authority checkbox. The Network Transform component uses this “authority” setting, and sends movement information from the client to the other clients if this is set.

See Scripting API Reference documentation on NetworkIdentity
and localPlayerAuthority for information on implementing local player authority via script.

see here

you just need to set up a few things and youll be good to go!