Netcode. Is optimizing input as bitmasks worth it?

Is it worth it to implement the input as bitmasks? The scenario is a lot of players (100 + if possible) and each player controlling multiple space vehicles. (players themselves and client-side AI vehicles) The control is not predictive. The physics sim results or transforms are sent back to players.

Code (CSharp):

1.  
2. public struct VehicleMovementControl : ICommandData
3. {
4.     public uint Tick { get; set; }
5.     public DirectionMask Translation;
6.     public DirectionMask Rotation;
7. }
8.  
9. [System.Serializable]
10. public struct DirectionMask
11. {
12.     public const byte XPosMask = 1;
13.     public const byte XNegMask = 2;
14.     public const byte YPosMask = 4;
15.     public const byte YNegMask = 8;
16.     public const byte ZPosMask = 16;
17.     public const byte ZNegMask = 32;
18.  
19.     public bool XPos => (XPosMask & Value) == XPosMask;
20.     public bool XNeg => (XNegMask & Value) == XNegMask;
21.     public bool YPos => (YPosMask & Value) == YPosMask;
22.     public bool YNeg => (YNegMask & Value) == YNegMask;
23.     public bool ZPos => (ZPosMask & Value) == ZPosMask;
24.     public bool ZNeg => (ZNegMask & Value) == ZNegMask;
25.  
26.     public byte Value;
27. }
28.  

Also, is it safe/reliable? As I'm reading up on this it seems very reliable for currently existing hardware.

Or maybe Netcode would compress bools into a bitmask on its own?

 

Actually the generated serialization code is converting my bytes into uints... even though it is perfectly capable to write bytes... That is so strange. Are uints better optimized or sth?

Code (CSharp):

1.  
2.         public void Serialize(ref DataStreamWriter writer, in VehicleMovementControl data)
3.         {
4.             writer.WriteUInt(data.translation.value);
5.         }
6.  
7.         public void Deserialize(ref DataStreamReader reader, ref VehicleMovementControl data)
8.         {
9.             data.translation.value = (byte) reader.ReadUInt();
10.         }

 

Well for starters you have a single multi value flag. So you just need a single byte not a bit mask. Bit masks are something different.

Netcode I'm sure uses variable length integer encoding, which encodes integers using the least amount of bytes necessary. So integers <= 127 for instance are already being sent as a single byte. That's just happening at a lower level in their code somewhere.

So just use an int/uint/enum and get rid of all that byte stuff, it's not adding any value.

And optimizing what the client sends the server is almost inconsequential. Client is sending data for 1 player. Server is sending data for 100 players to every client. You focus on optimizing what the server sends.

 

Do you have anything to back this claim up? Or do you just assume that they use variable length int encoding "somewhere"?
I am also trying to pack player IDs into a single byte for network traffic, as it would only take up 1 byte. but the auto generated serializer turns it into a uint anyway.