Singleton Network Manager
As part of my Futuregames studies, I made a singleton manager system to handle Unity's netcode for gameobjects API. This solution allows me to only use one network object component!
The structure is that of one server script and a player-sync-manager script, both being on the same game object with the network object component and the network manager component.
Both has a dictionary list of player Clients scripts, the server handling the server copy one, while the player-sync-manager handles the client side. Server also stores my enums and structs.
Each player client stores a ulong client id, which I use in the player-sync-manager to target each instance of a specific player and sync them together.
Player actions script handles the movement and the battle manager handles the game state and sends game related calls to the server.
I’m also starting the game in a bootstrap scene with the Network object, so that the initial awake methods can go of before the scene switches to the play scene.
The game environment is a simple smack the ball to each other.
My Scripts
Server:
The server script stores two blackboard struct types. One for player clients and one for the ball object. The server handles the syncing of the game state, while the player sync manager handles the client syncing.
Player Sync Manager:
The player sync manager specifically handles client syncing. It still communicates to the server whenever a client/host joins. The sync functions gets called from the player client script.
Player Client:
Player client stores it's sync values and calls to the player sync manager to with those stored values, so that the sync manager can update all instances of the client.
It sends the calls in FixedUpdate.
Battle Manager:
Battle manager mostly handles the ball gameobject.
Player Actions:
Handles player movement and it uses the new input system. It also calls the player arm (Player Damage Dealer) rotation and scale function.
I'm also squishing the player to make it slime like, whenever it moves.
Player Damage Dealer:
Handles arm rotation, scale and collision events with the ball gameobject.
Ball:
The ball gameobject. It is the server which actually kicks the ball. The ball simply calls to the server whenever it gets hit and the server calls the kickball function as a rpc to all ball instances.