Multiplayer Game Byte Array Serialization With Go And C# Tool

Question

it's a tool I developed to make byte arrays meaningful in multiplayer games.

A tool that prepares the encode and decode codes for go and c#.

example input(example.customExtension)

type UnitNetworkDto{
 int16 ViewId;
 float X;
 float Z;
 int Health;
 int8 TeamType;
 int16 TargetViewId;
 Vector3Qoo Position;
}

type Vector3Qoo
 { float X;float Y;float Z;} 

go output

package typed

var (
  Vector3Qoo_BYTE_COUNT     = 12
  UnitNetworkDto_BYTE_COUNT = 29
)

type Vector3Qoo struct {
  X float32
  Y float32
  Z float32
}

func (v *Vector3Qoo) Encode() []byte {
  res := Float32ToBytes(v.X)
  res = append(res, Float32ToBytes(v.Y)...)
  res = append(res, Float32ToBytes(v.Z)...)
  return res
}

func Vector3QooDecode(input []byte) Vector3Qoo {
  res := Vector3Qoo{}
  res.X = Float32FromBytes(input[0:4])
  res.Y = Float32FromBytes(input[4:8])
  res.Z = Float32FromBytes(input[8:12])
  return res
}

type UnitNetworkDto struct {
  ViewId       int16
  X            float32
  Z            float32
  Health       int32
  TeamType     int8
  TargetViewId int16
  Position     Vector3Qoo
}

func (u *UnitNetworkDto) Encode() []byte {
  res := Int16ToBytes(u.ViewId)
  res = append(res, Float32ToBytes(u.X)...)
  res = append(res, Float32ToBytes(u.Z)...)
  res = append(res, Int32ToBytes(u.Health)...)
  res = append(res, Int8ToBytes(u.TeamType)...)
  res = append(res, Int16ToBytes(u.TargetViewId)...)
  res = append(res, u.Position.Encode()...)
  return res
}

func UnitNetworkDtoDecode(input []byte) UnitNetworkDto {
  res := UnitNetworkDto{}
  res.ViewId = Int16FromBytes(input[0:2])
  res.X = Float32FromBytes(input[2:6])
  res.Z = Float32FromBytes(input[6:10])
  res.Health = Int32FromBytes(input[10:14])
  res.TeamType = Int8FromBytes(input[14:15])
  res.TargetViewId = Int16FromBytes(input[15:17])
  res.Position = Vector3QooDecode(input[17:29])
  return res
}

c# output

namespace Typed
{
  public static class CSharpTypedFileHelper{
    public static int Vector3Qoo_BYTE_COUNT = 12;
    public static int UnitNetworkDto_BYTE_COUNT = 29;
  }

  public class Vector3Qoo{
    public float X { get; set; }
    public float Y { get; set; }
    public float Z { get; set; }
    public Vector3Qoo(byte[] input){
      this.X = QooUtils.FloatFromBytes(input.SubArray(0,4));
      this.Y = QooUtils.FloatFromBytes(input.SubArray(4,4));
      this.Z = QooUtils.FloatFromBytes(input.SubArray(8,4));
    }

    public Vector3Qoo(float q_X,float q_Y,float q_Z){
      X = q_X;
      Y = q_Y;
      Z = q_Z;
    }

    public byte[] Encode(){
      byte[] res = QooUtils.FloatToBytes(X);
      res = QooUtils.Combine(res,QooUtils.FloatToBytes(Y));
      res = QooUtils.Combine(res,QooUtils.FloatToBytes(Z));
      return res;
    }
 }

 public class UnitNetworkDto{
   public int ViewId { get; set; }
   public float X { get; set; }
   public float Z { get; set; }
   public int Health { get; set; }
   public int TeamType { get; set; }
   public int TargetViewId { get; set; }
   public Vector3Qoo Position { get; set; }
   
   public UnitNetworkDto(byte[] input){
     this.ViewId = QooUtils.Int16FromBytes(input.SubArray(0,2));
     this.X = QooUtils.FloatFromBytes(input.SubArray(2,4));
     this.Z = QooUtils.FloatFromBytes(input.SubArray(6,4));
     this.Health = QooUtils.Int32FromBytes(input.SubArray(10,4));
     this.TeamType = QooUtils.Int8FromBytes(input.SubArray(14,1));
     this.TargetViewId = QooUtils.Int16FromBytes(input.SubArray(15,2));
     this.Position = new Vector3Qoo(input.SubArray(17,12));
   }

   public UnitNetworkDto(int q_ViewId,float q_X,float q_Z,int q_Health,int 
     q_TeamType,int q_TargetViewId,Vector3Qoo q_Position){
     ViewId = q_ViewId;
     X = q_X;
     Z = q_Z;
     Health = q_Health;
     TeamType = q_TeamType;
     TargetViewId = q_TargetViewId;
     Position = q_Position;
   }

   public byte[] Encode(){
     byte[] res = QooUtils.Int16ToBytes(ViewId);
     res = QooUtils.Combine(res,QooUtils.FloatToBytes(X));
     res = QooUtils.Combine(res,QooUtils.FloatToBytes(Z));
     res = QooUtils.Combine(res,QooUtils.Int32ToBytes(Health));
     res = QooUtils.Combine(res,QooUtils.Int8ToBytes(TeamType));
     res = QooUtils.Combine(res,QooUtils.Int16ToBytes(TargetViewId));
     res = QooUtils.Combine(res,Position.Encode());
     return res;
   }
 }

}

I wrote this system with go. It converts the type file I gave (example.customExtension) to c# and go.

I'm new to multiplayer development, so I'm not sure if there's any cost on the server side to transfer and translate in this way. I'm wondering if creating and using a tool in this way is a method used among multiplayer game developers, your comments and suggestions. Evaluate the outputs I want from you

also the Int8FromBytes function might sound a bit silly :)