I managed to recreate this problem with simplified setup:

Shared data types:

using System.Collections.Generic;
using MessagePack;

namespace MessagePackTestShared
{

public enum NetworkMessageType : byte
{
    Unknown,
    LoginRequest = 1,
    LoginResponseFailure,
    LoginResponseSuccess,
}


[MessagePackObject]
public class NetworkMessageBase
{
    [Key(0)] public readonly NetworkMessageType NetworkMessageType;

    public NetworkMessageBase(NetworkMessageType networkMessageType)
    {
        NetworkMessageType = networkMessageType;
    }
}


[MessagePackObject]
public class LoginRequest : NetworkMessageBase
{
    [Key(1)] public readonly string LoginData;

    public LoginRequest(string loginData) : base(NetworkMessageType.LoginRequest)
    {
        LoginData = loginData;
    }

    public LoginRequest(NetworkMessageType networkMessageType, string loginData) : base(networkMessageType)
    {
        LoginData = loginData;
    }
}


[MessagePackObject]
public class LoginResponseFailure : NetworkMessageBase
{
    [Key(1)] public readonly string ErrorMessage;

    public LoginResponseFailure(string errorMessage) : base(NetworkMessageType.LoginResponseFailure)
    {
        ErrorMessage = errorMessage;
    }

    public LoginResponseFailure(NetworkMessageType networkMessageType, string errorMessage) : base(networkMessageType)
    {
        ErrorMessage = errorMessage;
    }
}


[MessagePackObject]
public class LoginResponseSuccess : NetworkMessageBase
{
    [Key(1)] public readonly PlayerDataPublic PlayerDataPublic;

    public LoginResponseSuccess(PlayerDataPublic playerDataPublic) : base(NetworkMessageType.LoginResponseSuccess)
    {
        PlayerDataPublic = playerDataPublic;
    }

    public LoginResponseSuccess(NetworkMessageType networkMessageType, PlayerDataPublic playerDataPublic) : base(networkMessageType)
    {
        PlayerDataPublic = playerDataPublic;
    }
}


[MessagePackObject]
public class PlayerDataPublic
{
    [Key(0)] public long Id;
    [Key(1)] public uint Money;
    [Key(2)] public byte FigureId;
    [Key(3)] public List<byte> OwnedFigures;
}

}

Server implementation (.NET 8)

using MessagePack;
using MessagePackTestShared;

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();
app.MapGet("/message", MessageEndpoint);
app.Run();
return;

async Task<IResult> MessageEndpoint(HttpRequest request)
{
    var messageBytes = new byte[request.ContentLength.Value];
    await request.Body.ReadExactlyAsync(messageBytes);
    var messageBase = MessagePackSerializer.Deserialize<NetworkMessageBase>(messageBytes);
    return messageBase.NetworkMessageType switch
    {
        NetworkMessageType.LoginRequest => OnLoginRequest(MessagePackSerializer.Deserialize<LoginRequest>(messageBytes))
    };
}

IResult OnLoginRequest(LoginRequest message)
{
    LogMessage(message);
    return string.IsNullOrEmpty(message.LoginData) ? LoginResponseFailure() : LoginResponseSuccess();
}

IResult LoginResponseFailure()
{
    var loginResponseFailure = new LoginResponseFailure("Something went wrong, oops!");
    return SerializeMessage(loginResponseFailure);
}

IResult LoginResponseSuccess()
{
    var playerData = new PlayerDataPublic
    {
        Id = 123,
        Money = 321,
        FigureId = 1,
        OwnedFigures = [1, 2, 3]
    };

    var loginResponseSuccess = new LoginResponseSuccess(playerData);
    return SerializeMessage(loginResponseSuccess);
}

IResult SerializeMessage<T>(T message) where T : NetworkMessageBase
{
    LogMessage(message);
    var messageSerialized = MessagePackSerializer.Serialize(message);
    return Results.Bytes(messageSerialized);
}

static void LogMessage<T>(T message) where T : NetworkMessageBase
{
    Console.WriteLine($"{message.NetworkMessageType} - {MessagePackSerializer.SerializeToJson(message)}");
}

Client implementation (Unity 6000.0.34f1)

using System;
using Cysharp.Threading.Tasks;
using MessagePack;
using MessagePackTestShared;
using UnityEngine;
using UnityEngine.Networking;

public class Main : MonoBehaviour
{
    const string _url = "http://localhost:5261/message";

    private async UniTaskVoid Start()
    {
        var loginData = "";
        var loginRequest = new LoginRequest(loginData);
        var serverMessage = await SendMessage(loginRequest);
        OnMessageReceived(serverMessage);
    }

    private static async UniTask<byte[]> SendMessage<T>(T message) where T : NetworkMessageBase
    {
        LogMessage(message);
        var messageSerialized = MessagePackSerializer.Serialize(message);
        var request = new UnityWebRequest(_url, "GET");
        request.downloadHandler = new DownloadHandlerBuffer();
        request.uploadHandler = new UploadHandlerRaw(messageSerialized);
        await request.SendWebRequest();
        return request.downloadHandler.data;
    }

    private void OnMessageReceived(byte[] messageBytes)
    {
        var messageBase = MessagePackSerializer.Deserialize<NetworkMessageBase>(messageBytes);
        switch (messageBase.NetworkMessageType)
        {
            case NetworkMessageType.LoginResponseFailure: OnLoginResponseFailure(MessagePackSerializer.Deserialize<LoginResponseFailure>(messageBytes)).Forget(); break;
            case NetworkMessageType.LoginResponseSuccess: OnLoginResponseSuccess(MessagePackSerializer.Deserialize<LoginResponseSuccess>(messageBytes)).Forget(); break;
        }
    }

    private async UniTaskVoid OnLoginResponseFailure(LoginResponseFailure message)
    {
        LogMessage(message);

        var loginData = Guid.NewGuid().ToString();
        var loginRequest = new LoginRequest(loginData);
        var serverMessage = await SendMessage(loginRequest);
        OnMessageReceived(serverMessage);
    }

    private async UniTaskVoid OnLoginResponseSuccess(LoginResponseSuccess message)
    {
        LogMessage(message);
    }

    private static void LogMessage<T>(T message) where T : NetworkMessageBase
    {
        Debug.Log($"{message.NetworkMessageType} - {MessagePackSerializer.SerializeToJson(message)}");
    }
}

In result I get these logs:

Server

LoginRequest - [1,""]
LoginResponseFailure - [2,"Something went wrong, oops!"]
LoginRequest - [1,"3d4f36d9-9ec5-4560-a3ed-6f8394431dd3"]
LoginResponseSuccess - [3,[123,321,1,"AQID"]]

Client (Error message is the same as in my previous post)

LoginRequest - [1,""]
LoginResponseFailure - [2,"Something went wrong, oops!"]
LoginRequest - [1,"3d4f36d9-9ec5-4560-a3ed-6f8394431dd3"]
MessagePackSerializationException: Unexpected msgpack code 196 (bin 8) encountered.

My intuiton tells me that problem is in List<byte> PlayerDataPublic.OwnedFigures. Server serializes it as string and client gets confused.

Uh oh!

How to use it on unity6 webgl? #2099

Description

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions