fishnet installed

Assets/FishNet/Runtime/Generated/Component/TakeOwnership/PredictedOwner.cs

@@ -0,0 +1,121 @@
+using FishNet.Connection;
+using FishNet.Managing;
+using FishNet.Managing.Logging;
+using FishNet.Managing.Server;
+using FishNet.Object;
+using FishNet.Object.Synchronizing;
+using UnityEngine;
+
+namespace FishNet.Component.Ownership
+{
+    /// <summary>
+    /// Adding this component allows any client to take ownership of the object and begin modifying it immediately.
+    /// </summary>
+    public class PredictedOwner : NetworkBehaviour
+    {
+        #region Public.
+        /// <summary>
+        /// True if the local client used TakeOwnership and is awaiting an ownership change.
+        /// </summary>
+        public bool TakingOwnership { get; private set; }
+        /// <summary>
+        /// Owner on client prior to taking ownership. This can be used to reverse a failed ownership attempt.
+        /// </summary>
+        public NetworkConnection PreviousOwner { get; private set; } = NetworkManager.EmptyConnection;
+        #endregion
+
+        #region Serialized.
+        /// <summary>
+        /// True if to enable this component.
+        /// </summary>
+        [Tooltip("True if to enable this component.")]
+        [SyncVar(SendRate = 0f)]
+        [SerializeField]
+        private bool _allowTakeOwnership = true;
+        /// <summary>
+        /// Sets the next value for AllowTakeOwnership and synchronizes it.
+        /// Only the server may use this method.
+        /// </summary>
+        /// <param name="value">Next value to use.</param>
+        [Server]
+        public void SetAllowTakeOwnership(bool value) => _allowTakeOwnership = value;
+        #endregion
+
+        /// <summary>
+        /// Called on the client after gaining or losing ownership.
+        /// </summary>
+        /// <param name="prevOwner">Previous owner of this object.</param>
+        public override void OnOwnershipClient(NetworkConnection prevOwner)
+        {
+            base.OnOwnershipClient(prevOwner);
+            /* Unset taken ownership either way.
+            * If the new owner it won't be used,
+            * if no longer owner then another client
+            * took it. */
+            TakingOwnership = false;
+            PreviousOwner = base.Owner;
+        }
+
+        /// <summary>
+        /// Takes ownership of this object to the local client and allows immediate control.
+        /// </summary>
+        [Client]
+        public virtual void TakeOwnership()
+        {
+            if (!_allowTakeOwnership)
+                return;
+            //Already owner.
+            if (base.IsOwner)
+                return;
+
+            NetworkConnection c = base.ClientManager.Connection;
+            TakingOwnership = true;
+            //If not server go through the server.
+            if (!base.IsServer)
+            {
+                base.NetworkObject.SetLocalOwnership(c);
+                ServerTakeOwnership();
+            }
+            //Otherwise take directly without rpcs.
+            else
+            {
+                OnTakeOwnership(c);
+            }
+        }
+
+
+        /// <summary>
+        /// Takes ownership of this object.
+        /// </summary>
+        [ServerRpc(RequireOwnership = false)]
+        private void ServerTakeOwnership(NetworkConnection caller = null)
+        {
+            OnTakeOwnership(caller);
+        }
+
+        /// <summary>
+        /// Called on the server when a client tries to take ownership of this object.
+        /// </summary>
+        /// <param name="caller">Connection trying to take ownership.</param>
+        [Server]
+        protected virtual void OnTakeOwnership(NetworkConnection caller)
+        {
+            //Client somehow disconnected between here and there.
+            if (!caller.IsActive)
+                return;
+            //Feature is not enabled.
+            if (!_allowTakeOwnership)
+                return;
+            //Already owner.
+            if (caller == base.Owner)
+                return;
+
+            base.GiveOwnership(caller);
+            /* No need to send a response back because an ownershipchange will handle changes.
+             * Although if you were to override with this your own behavior
+             * you could send responses for approved/denied. */
+        }
+
+    }
+
+}

Assets/FishNet/Runtime/Generated/Component/TakeOwnership/PredictedOwner.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 03002f7d324007e41b10a9dc87ed3c38
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: bf9191e2e07d29749bca3a1ae44e4bc8, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FishNet/Runtime/Generated/Component/TakeOwnership/PredictedSpawn.cs

@@ -0,0 +1,96 @@
+using FishNet.Connection;
+using FishNet.Object;
+using UnityEngine;
+
+namespace FishNet.Component.Ownership
+{
+    /// <summary>
+    /// Adding this component allows any client to use predictive spawning on this prefab.
+    /// </summary>
+    public class PredictedSpawn : NetworkBehaviour
+    {
+        #region Serialized.
+        /// <summary>
+        /// True to allow clients to predicted spawn this object.
+        /// </summary>
+        public bool GetAllowSpawning() => _allowSpawning;
+        /// <summary>
+        /// Sets to allow predicted spawning. This must be set on client and server.
+        /// </summary>
+        /// <param name="value">New value.</param>
+        public void SetAllowSpawning(bool value) => _allowSpawning = value;
+        [Tooltip("True to allow clients to predicted spawn this object.")]
+        [SerializeField]
+        private bool _allowSpawning = true;
+        /// <summary>
+        /// True to allow clients to predicted despawn this object.
+        /// </summary>
+        public bool GetAllowDespawning() => _allowDespawning;
+        /// <summary>
+        /// Sets to allow predicted despawning. This must be set on client and server.
+        /// </summary>
+        /// <param name="value">New value.</param>
+        public void SetAllowDespawning(bool value) => _allowDespawning = value;
+        [Tooltip("True to allow clients to predicted despawn this object.")]
+        [SerializeField]
+        private bool _allowDespawning = true;
+        /// <summary>
+        /// 
+        /// </summary>
+        [Tooltip("True to allow clients to predicted set syncTypes prior to spawning the item. Set values will be applied on the server and sent to other clients.")]
+        [SerializeField]
+        private bool _allowSyncTypes = true;
+        /// <summary>
+        /// True to allow clients to predicted set syncTypes prior to spawning the item. Set values will be applied on the server and sent to other clients.
+        /// </summary>
+        public bool GetAllowSyncTypes() => _allowSyncTypes;
+        /// <summary>
+        /// Sets to allow syncTypes. This must be set on client and server.
+        /// </summary>
+        /// <param name="value">New value.</param>
+        public void SetAllowSyncTypes(bool value) => _allowSyncTypes = value;
+        #endregion
+
+        /// <summary>
+        /// Called on the client when trying to predicted spawn this object.
+        /// </summary>
+        /// <param name="owner">Owner specified to spawn with.</param>
+        /// <returns>True if able to spawn.</returns>
+        public virtual bool OnTrySpawnClient(NetworkConnection owner = null)
+        {
+            return GetAllowSpawning();
+        }
+        /// <summary>
+        /// Called on the server when a client tries to predicted spawn this object.
+        /// </summary>
+        /// <param name="spawner">Connection trying to predicted spawn this object.</param>
+        /// <param name="owner">Owner specified to spawn with.</param>
+        /// <returns>True if able to spawn.</returns>
+        public virtual bool OnTrySpawnServer(NetworkConnection spawner, NetworkConnection owner = null)
+        {
+            return GetAllowSpawning();
+        }
+
+        /// <summary>
+        /// Called on the client when trying to predicted spawn this object.
+        /// </summary>
+        /// <returns>True if able to despawn.</returns>
+        public virtual bool OnTryDespawnClient()
+        {
+            return GetAllowDespawning();
+        }
+        /// <summary>
+        /// Called on the server when a client tries to predicted despawn this object.
+        /// </summary>
+        /// <param name="despawner">Connection trying to predicted despawn this object.</param>
+        /// <returns>True if able to despawn.</returns>
+        public virtual bool OnTryDepawnServer(NetworkConnection despawner)
+        {
+            return GetAllowDespawning();
+        }
+
+
+
+    }
+
+}

Assets/FishNet/Runtime/Generated/Component/TakeOwnership/PredictedSpawn.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e2b597e1828355a4d994a69cbb11ef85
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: bf9191e2e07d29749bca3a1ae44e4bc8, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: