feat: AttachableBehaviour and ComponentController

Examples/CharacterControllerMovingBodies/Readme.md

@@ -1,11 +1,11 @@
 # Netcode for GameObjects Smooth Transform Space Transitions
 ## Non-Rigidbody CharacterController Parenting with Moving Bodies
 ![image](https://github.com/user-attachments/assets/096953ca-5d7d-40d5-916b-72212575d258)
-This example provides you with the fundamental building blocks for smooth synchronized transitions between two non-rigidbody based objects. This includes transitioning from world to local, local to world, and local to local transform spaces. 
+This example provides you with the fundamental building blocks for smooth synchronized transitions between two non-rigidbody based objects. This includes transitioning from world to local, local to world, and local to local transform spaces.
 
 ### The `CharacterController`
 ![image](https://github.com/user-attachments/assets/13c627bd-920d-40c8-8947-69aa37b44ebf)
-The `CharacterController` component is assigned to the `PlayerNoRigidbody` player prefab. It includes a `MoverScriptNoRigidbody` that handles all of the player's motion and includes some additional "non-rigidbody to non-rigidbody" collision handling logic that is applied when a player bumps into a rotation and/or moving body. The player prefab includes a child "PlayerBallPrime" that rotates around the player in local space (nested `NetworkTransform`), and the "PlayerBallPrime" has 3 children ("PlayerBallChild1-3") that each rotates around a different axis of the "PlayerBallPrime". While the end resulting effect is kind of cool looking, they provide a point of reference as to whether there is any deviation of each child's given axial path relative to each parent level. Additionally, it shows how tick synchronized nested `NetworkTransform` components keep synchronized with their parent and how that persists when the parent is parented or has its parent removed.
+The `CharacterController` component is assigned to the `PlayerNoRigidbody` player prefab. It includes a `MoverScriptNoRigidbody` that handles all of the player's motion and includes some additional "non-rigidbody to non-rigidbody" collision handling logic that is applied when a player bumps into a rotation and/or moving body. The player prefab includes a child "PlayerBallPrime" that rotates around the player in local space (nested NetworkTransform), and the "PlayerBallPrime" has 3 children ("PlayerBallChild1-3") that each rotates around a different axis of the "PlayerBallPrime". While the end resulting effect is kind of cool looking, they provide a point of reference as to whether there is any deviation of each child's given axial path relative to each parent level. Additionally, it shows how tick synchronized nested NetworkTransform components keep synchronized with their parent and how that persists when the parent is parented or has its parent removed.
 
 ### Rotating Bodies
 #### StationaryBodyA&B

Examples/OverridingScenesAndPrefabs/Readme.md

@@ -5,10 +5,10 @@ _Supports using the client-server and distributed authority network topologies._
 
 This example, based on the [Netcode for GameObjects Smooth Transform Space Transitions](https://github.com/Unity-Technologies/com.unity.netcode.gameobjects/tree/example/server-client-unique-scenes-and-prefabs/Examples/CharacterControllerMovingBodies), provides and overview of how to use:
 - [`NetworkPrefabHandler`](https://docs.unity3d.com/Packages/[email protected]/api/Unity.Netcode.NetworkPrefabHandler.html) as a way to dynamically control overriding network prefabs and how they are instantiated.
-  - For this example, the prefab handler is overriding the player prefab. 
+  - For this example, the prefab handler is overriding the player prefab.
     - *You will only see the end result of this portion of the example by running a server instance (i.e. not host) as that will create instances of the ServerPlayer network prefab instead of the ClientPlayer network prefab.*
-- [`NetworkSceneManager.SetClientSynchronizationMode`](https://docs.unity3d.com/Packages/[email protected]/api/Unity.Netcode.NetworkSceneManager.html#Unity_Netcode_NetworkSceneManager_SetClientSynchronizationMode_UnityEngine_SceneManagement_LoadSceneMode_) to change the default client synchronization mode (SingleMode) to an additive client synchronization mode. 
-  - Additive client synchronization mode will prevent already existing preloaded scenes from being unloaded and will use them, as opposed to reloading the same scene, during a client's initial synchronization. 
+- [`NetworkSceneManager.SetClientSynchronizationMode`](https://docs.unity3d.com/Packages/[email protected]/api/Unity.Netcode.NetworkSceneManager.html#Unity_Netcode_NetworkSceneManager_SetClientSynchronizationMode_UnityEngine_SceneManagement_LoadSceneMode_) to change the default client synchronization mode (SingleMode) to an additive client synchronization mode.
+  - Additive client synchronization mode will prevent already existing preloaded scenes from being unloaded and will use them, as opposed to reloading the same scene, during a client's initial synchronization.
     - *This is a server-side only setting that gets sent to the clients during the initial synchronization process.*
 - [`NetworkSceneManager.VerifySceneBeforeLoading`](https://docs.unity3d.com/Packages/[email protected]/api/Unity.Netcode.NetworkSceneManager.html#Unity_Netcode_NetworkSceneManager_VerifySceneBeforeLoading) in order to control what scenes the server will include when sending the synchronization message to newly connecting clients.
 
@@ -19,14 +19,14 @@ This example uses unity services. Upon loading the project for the first time, y
 ## Terminology
 
 ### Shared Scenes
-These are scenes that will be synchronized between a server or session owner and used when a client runs through the initial synchronization process. 
-- You can populate these scenes with in-scene placed or dynamically spawned NetworkObjects. 
+These are scenes that will be synchronized between a server or session owner and used when a client runs through the initial synchronization process.
+- You can populate these scenes with in-scene placed or dynamically spawned NetworkObjects.
 - These scenes **must be** within the scenes in build list.
 
 ### Local Scenes
-These are scenes that are always only local to the application instances (server or client) and will not be synchronized. 
-- You should not populate these scenes with NetworkObjects. 
-  -However, this example includes one of several ways you can associate a `MonoBehaviour` with a `NetworkBehaviour`. 
+These are scenes that are always only local to the application instances (server or client) and will not be synchronized.
+- You should not populate these scenes with NetworkObjects.
+  -However, this example includes one of several ways you can associate a `MonoBehaviour` with a NetworkBehaviour.
 - These scenes can be dynamically created, included in the scenes in build list, or be an addressable loaded at some point prior to connecting or while connected to a session.
 
 ## Client Synchronization and Scene Validation
@@ -54,16 +54,16 @@ The first scene loaded. Contains a `NetworkManagerBootstrapper` in-scene placed
 #### NetworkManager Bootstrapper (component)
 ![image](Images/NetworkManagerBootstrapperProperties.png)
 
-Handles the pre-network session menu interface along with connect and disconnect events. Since it is derived from `NetworkManager`, it also defines the network session configuration (i.e. `NetworkConfig`). The `NetworkManagerBootstrapper` in-scene placed `GameObject` gets loaded into the DDOL scene automatically and will persist throughout the application life time. This derived class requires the `SceneBootstrapLoader` component.
+Handles the pre-network session menu interface along with connect and disconnect events. Since it is derived from NetworkManager, it also defines the network session configuration (i.e. `NetworkConfig`). The `NetworkManagerBootstrapper` in-scene placed `GameObject` gets loaded into the DDOL scene automatically and will persist throughout the application life time. This derived class requires the `SceneBootstrapLoader` component.
 
 #### Scene Bootstrap Loader (component)
 ![image](Images/SceneBootstrapLoader.png)
 
-This component handles preloading scenes for both the client(s) and server. Upon being started, the `NetworkManagerBootstrapper` component will invoke `SceneBootstrapLoader.LoadMainMenu` method that kicks off the scene preloading process. 
+This component handles preloading scenes for both the client(s) and server. Upon being started, the `NetworkManagerBootstrapper` component will invoke `SceneBootstrapLoader.LoadMainMenu` method that kicks off the scene preloading process.
 - **Default Active Scene Asset:** There is always an active scene. For this example, the default active scene is the same on both the client and server relative properties. *The active scene is always (and should always) be a "shared scene".*
   - This could represent a lobby or network session main menu (i.e. create or join session).
   - Both the client and the server preload this scene prior to starting a network session.
-- **Local Scene Assets:** There could be times where you want to load scenes specific to the `NetworkManager` instance type (i.e. client, host, or server).
+- **Local Scene Assets:** There could be times where you want to load scenes specific to the NetworkManager instance type (i.e. client, host, or server).
   - These scenes are not synchronized by a server (client-server) or session owner (distributed authority).
   - Having different locally loaded scenes is typically more common in a client-server network topology.
   - In a distributed authority network topology, it is more common to keep all scenes synchronized but you might want to load non-synchronized scenes (i.e. menu interface for settings etc).
@@ -72,11 +72,11 @@ This component handles preloading scenes for both the client(s) and server. Upon
     - If the server synchronizes any scenes from the share scene assets with a client that already has those scene loaded, then those locally loaded scenes on the client side will be used during synchronization.
     - Depending upon how many scenes you want to synchronize and/or how large one or more scenes are, preloading scenes can reduce synchronization time for clients.
 The `NetworkManagerBootstrapper` uses the `SceneBootstrapLoader` component to start the creation or joining of a network session. The logical flow looks like:
-- `NetworkManagerBootstrapper` invokes `SceneBootstrapLoader.StartSession` when you click one of the (very simple) main menu buttons and passes in the mode/type of `NetworkManager` to start.
-- Based on the `NetworkManager` type being started, the `SceneBootstrapLoader` will then:
+- `NetworkManagerBootstrapper` invokes `SceneBootstrapLoader.StartSession` when you click one of the (very simple) main menu buttons and passes in the mode/type of NetworkManager to start.
+- Based on the NetworkManager type being started, the `SceneBootstrapLoader` will then:
  - Load the default active scene using the `UnityEngine.SceneManagement.SceneManager`.
  - Load the local scenes using the `UnityEngine.SceneManagement.SceneManager`.
- - Then it will create or join a network session by either starting the `NetworkManager` or connecting to the sesssion via multiplayer services.
+ - Then it will create or join a network session by either starting the NetworkManager or connecting to the sesssion via multiplayer services.
  - _Server or Session Owner only:_
    - If any, load the shared (i.e. synchronized) scene assets using the `NetworkSceneManager`
 
@@ -87,7 +87,7 @@ This `MonoBehaviour` component implements the `INetworkPrefabInstanceHandler` in
 - Network Prefab: This is the network prefab that you want to override. In this example, it is what is used to spawn a server-side player prefab and is what is defined within the `NetworkManagerBootstrapper` component.
 - Network Prefab Override: This is what is used to spawn a player prefab on the client-side.
 
-At runtime the local `NetworkManager` instance is a client/host or server and will spawn either the ClientPlayer or ServerPlayer prefab. The `NetworkPrefabOverrideHandler` does not need to be a `NetworkBehaviour` and sometimes (especially for overriding the player prefab) it is better to register prefab handlers prior to starting the `NetworkManager`.
+At runtime the local NetworkManager instance is a client/host or server and will spawn either the ClientPlayer or ServerPlayer prefab. The `NetworkPrefabOverrideHandler` does not need to be a NetworkBehaviour and sometimes (especially for overriding the player prefab) it is better to register prefab handlers prior to starting the NetworkManager.
 
 ## Input Controls
 The following is a list of the input controls used in this project: