Sharing ownership between two players

[Maclay74]

This is a follow up question after #2512, where @NoelStephensUnity helped me a lot with making a solid and smooth movement of an object by a player.

But since multiplayer games are about cooperation, carrying stuff together is one of the essentials features in our game.
I'd like to make it that when one player tries to carry a large thing, it struggles, whereas two can do it easier.

The problem is, they both should be able to move the object they are carrying. And they are client-side authoritative.
So I can't just change the ownership of the object, because another player is going to have a delay.

The only idea I have is to let them simulate locally object's state, ignoring the correct one from the server. And once they drop the object, it switched back to updates from the server. I think this should work, at least, I can't tell why not.

But I think I don't understand the solution @NoelStephensUnity provided me with to 100%. I see that it disables server updates and lets client simulate rigidbody, but it also handles the jitter problem by making sure that the authority is completely switched, and I just don't understand how I can make it more generic, so I could just toggle it when I need it.

Do you think it's going to work or I am completely wrong about the approach? Maybe it can be achieved easily?
If so, could you please you elaborate on your solution? As I said, I'd like to make it generic.

Thanks a lot!

[NoelStephensUnity]

@Maclay74
Wooo...this is indeed a challenging problem to solve... challenge accepted! 😸

I need a little time to noodle on this one, but we must always remind ourselves that video games aren't always about replicating real world scenarios perfectly...but creating the perception of a replicated "real world" scenario. Historically, game developers have used a "smoke and mirrors" approach...

So, let's think about a solution that isn't a 1:1 logical one...but will yield the same "perceived" result.

Off of the top of my head I am thinking along the lines of:

The goals (as I understand them):

• When more than one player wants to "lift an object" (or help) you want the perception that both user's input are impacting the over-all motion of the object.
• You want each player helping to lift the object have the perception that their input (motion) is impacting the over-all final "motion vector".
• You want this to feel seamless to the players just like they experience when lifting an object that is small enough for one player to carry.

The (initial) solution:

• This will require a "special" movement model where all players helping to carry the object become owned by the server
• Each user's input will be redirected to the server at regular intervals as "input force vectors".
  • This is so each player's input is processed at the same time (or within a very small variant period)
  • The server combines the force vectors into a final over-all force vector
    • Force can be "simulated" by getting the magnitude of the vector and making that a % of the total maximum velocity that the combined players will have on the object. Then take the calculated velocity and multiply that times the normal of the over-all force vector. So, you could still use the player's velocity vector and just consider that the "force".
• When a single player is picking up the object, you can still use the approach I provided but the object could apply a certain "drag" and/or you could have a minimum number of players required to "freely move" the object...with only 1 player for a 4 player required object might apply a penalty to the player's over-all maximum velocity.
• When more than one player has picked up the object, you will want to:
  • Detect this state on the server-side and change the ownership from the current player holding the object to the server
  • Change ownership of each player "helping move" the object while also notifying and/or changing the state of the player (i.e. a NetworkVariable is a nice place to handle changes in state)
  • Each player/client will detect the change in state and as opposed to applying motion directly to the player, they will send "force vector" updates via a NetworkVariable (i.e. to assure all players helping are applying their force vector at the same time)
    • When the server gains ownership, it will basically do the same thing a single player does when picking up an object...but in reverse...meaning the server will parent the players under the object being picked up with each player's current local space relative position when they helped to "pickup/move" the object stays the same while the players are helping move the object
      • This will move all players with the object being carried by multiple players, so when the server applies the final total players' force vector in motion to the object the players will still appear to move.
• When a player stops helping to move an object, the server changes ownership of the player object back to the player and the player's normal motion type/input is resumed.

This is a first pass brain storm of what I would attempt first to accomplish what you are trying to do... it does require having different "player motion types"...but trying it the "logical path way" where you try to perfectly synchronize multiple clients will never "look or feel" right due to the differences in latencies and such... making a new type of "motion" where players are not really moving their player object...but really just contributing to the object's over-all movement and direction...where the server is synchronizing the motion and the clients are just interpolating the motion...will yield a smoother more seemingly "synchronized" experience for the players.

Let me know if this approach makes sense... I might even try slapping and example of this together if I can find some free time...it is a cool concept indeed!
👍

p.s. The above description does have some areas that need some additional thought... like how players send their input. My initial thought is you would have player objects that have no render mesh but are NetworkObjects and do have the player input components (would need to be like a NetworkBehaviour)...we could call this the PlayerNetworkController. The player's visuals would be an additional spawned NetworkObject that the server changes ownership to the player in question and parents this under the PlayerNetworkController. Where the PlayerNetworkController is really what is moving around. You would also need to change each client's camera (when helping move an object) to focus on the object itself and not the player. So, initially the PlayerNetworkController moves the "player's object"...when helping to move and object the "player object" is what the server takes ownership of and the PlayerNetworkController can "follow" the object being moved while also updating a "player force vector" NetworkVariable that is part of the PlayerNetworkController's PlayerInput component...the server would subscribe to updates to this NetworkVariable when the player is helping to move an object and the client/player would only update this if it is helping move the object...so each "visual player object" would be parented under the bigger object the players are helping to move...on the clients' side it would be parented under the object being moved...and the server would move the object based on the players' over-all average "motion vector"....which on the clients' side since the object being moved would be interpolating and since all "visual player objects" are basically parented under the object being moved all clients should have smooth motion along with the object being moved.

[Maclay74]

Hey! Thanks for the reply!

Of course, your solution does make a lot of sense.
But as for the movement part of the task, I don't think I need precise physical movement and I was going to implement it in a way that two players can move the object only when they both apply force to the same direction. I was thinking about dot product of their desired movement vectors with some threshold. And when the vector is different, they would rotate around, using other player as a pivot. Something like that:

I just think that this "mechanic" approach is more robust and easy to tweak.

So, essentially, I can implement your solution by a NetworkList of carriers, then calculate movement, apply it to the object that parents all the players.

The only question I have is about input lag - currently my players are client-authoritative and changing movement authority to the server would be noticeable, right?

By the way, what do you think about my idea with simulating the carrying object independently on each carrying player?

Thanks a lot for your help!

[NoelStephensUnity]

@Maclay74
Sorry for the very delayed response. We are running through all support and feature related items to determine what we will be adding as documentation and example and/or new feature support.

Your idea seems clever...the issue I see here (not with your idea) is that we lack any guidance on how one might achieve the best results for this kind of mechanic.