I am working on a new 3d game based on a 2D tiled map. After developing the most basic features (procedural map generation, and player movement) i want to make it work in multiplayer.
I have read the whole HLAPI documentation and I have done twice the HLAPI tutorial, but my current architecture seems pretty different to the architecture shown in the mentioned tutorial.
This is how the game works without multiplayer:
Pregame Scene objects:
- An empty object with an script called "GlobalController", this will be alive through all scenes taking care of scene management and as global data storage.
- Another empty with an script called "PregameUIController", this will take care about the user interaction with the pregame scene.
- A Canvas an other irrelevant objects.
Pregame scene main flow:
- The global controller load from files the game definitions (types of tiles, types of biomes, types of entities)
- The player select the size and seed of the planet and click play
- The global controller creates a new planet(c# class, not monobehaviour, only for data storage) prepared for creation
- The global controller changes the scene to planet creation scene
Planet creation Scene objects: - Planet creation controller, taking care of planet creation and displaying the user the current state of the planet creation.
Planet creation main flow: - Planet creation controller (PCC from now) get the reference to the planet from the global controller - PCC creates the planet terrain and entities while telling the state of the process to the player - PCC sets the starting position of the planet based on a complex algorithm - PCC tells Global controller to start playing the planet - Global controller creates a new Player (c# class, not monobehaviour, only for data storage) as activePlayer, which will contain the starting position of the player - The global controller changes the scene to playing scene - A Canvas an other irrelevant objects.
Playing scene objects:
- Render controller, taking care of what is showed on the player screen
- InputController, taking care of the player inputs
- PlayerController, taking care of the player prefab and his different behaviours
- A Canvas an other irrelevant objects.
Playing scene main flow:
- Render controller and player controller gets the planet and players references from global controller
- Render controller render the nearest chunks to the player
- Player controller instantiate the player prefab
- Input controller manages the input to ask playerController move the player
- Moving the player consists in:
- player controller verify the destination is a valid destination
- playercontroller asks playerObject (monobehaviour attached to the playerPrefab) to move
- when movement ends, playerObject modify the player position
This is what i try to achieve
Pregame scene:
- The user decide if play as host or client
- If client go to planet creation scene
- If host set seed, size and other parameters and then go to planet creation
Planet creation scene:
- If host, procede normally (lets create the planet while notifying the player, then create the player, finally go to main scene)
- If client:
- Get the planet data from server
- Global controller creates a new Player as activePlayer, which will contain the starting position of the player. (Same as before)
Playing scene:
- Both players can move and see the other movements in the same map (which currently is not being modified)
- Player controller can verify if a player can move to the next tile (local verification)
- When PlayerPrefab starts moving, the server is notified, if it is an illegal movement server notifies back and movemet is aborted.
The problems:
- Making the planet only to be generated (complex perlin algorithm) on the server.
- Sharing the planet info (custom class that contains more custom classes) with the client when he connects?
- Making the controllers (Global controller, Network controller, ...) extend from NetworkBehaviour and assign them a NetworkIdentity then, as said in the documentation, them will be deactivated till the scene is loaded preventing to sync the data of the controllers from server to client.
- Avoiding the playerPrefab to spawn while I still have not the need info to spawn it (even I am not in the playing scene).
THE QUESTIONS:
- Do I need to refactor the whole game to change how things communicate with each others? If you think I can stick to this architecture, can you give me some guidelines to make this work.
