Custom Networking, Server has a server and client class

[ZaCkOX]

My custom networking (Server is a player) has a connection array holding data about clients. If someone is hosting as a server, both the Dissonance server and client classes will run. How would I move the bytes then if my network doesn't work like this. I suppose I keep a reference to the custom comms network and to the custom server, then send the bytes directly without any networking but I have to pass a CustomPeer and that peer includes an IPEndPoint and or SteamConnection (NetworkReceivedPacket needs CustomPeer for Custom Server). I have spent a lot of time reading through the custom networking tutorial, and preparing everything to make this work. However, I understand my setup and not this very well. I have been in the source code many times over. I wouldn't be surprised if I have made more than a handful of mistakes, any help would be appreciated.

#define USING_DISSONANCE

using Dissonance;
using Dissonance.Networking;
using System;
using System.Collections.Generic;
using System.Collections.Concurrent;
using System.Net;
using UnityEngine;
using static NetworkManager;
using static PublicStatics;
using static SteamworksManager;

public class CustomCommsNetwork: BaseCommsNetwork<CustomServer, CustomClient, CustomPeer, Unit, Unit> {

    #region Declares

    //Declare privates
    private CustomServer customServer = null;
    private CustomClient customClient = null;

    //Declare public properties
    public CustomServer GetCustomServer { get => customServer; }
    public CustomClient GetCustomClient { get => customClient; }

    #endregion

    #region Constructor

    public CustomCommsNetwork() { } //Do not add parameters

    #endregion

    #region Public functions

    protected override CustomServer CreateServer(Unit details) {
        customServer = new CustomServer(this, details);
        return customServer;
    }

    protected override CustomClient CreateClient(Unit details) {
        customClient = new CustomClient(this, details);
        return customClient;
    }

    #if USING_DISSONANCE

    protected override void Initialize() {

        Debug.Log("Dissonance is about to initialize.");

        base.Initialize();
    }

    protected override void Update() {
        Debug.Log("Dissonance update is running!");

        if (IsInitialized) {
            bool networkActive = NetworkIsActive();
            if (networkActive) {
                bool server = networkManager.SubSystem.IsHost;
                bool client = networkManager.SubSystem.IsHost;

                // Check what mode Dissonance is in and if
                // they're different then call the correct method
                if (Mode.IsServerEnabled() != server || Mode.IsClientEnabled() != client)
                {
                    // HLAPI is server and client, so run as a non-dedicated
                    // host (passing in the correct parameters)
                    if (server && client)
                        RunAsHost(Unit.None, Unit.None);

                    // HLAPI is just a server, so run as a dedicated host
                    else if (server)
                        RunAsDedicatedServer(Unit.None);

                    // HLAPI is just a client, so run as a client
                    else if (client)
                        RunAsClient(Unit.None);
                }
            }
            else if (Mode != NetworkMode.None)
            {
                //Network is not active, make sure Dissonance is not active
                Stop();
            }
        }
        base.Update();
        #region Functions

        bool NetworkIsActive() {
            if (networkManager.Network != null) {
                if (gameCanvas.ScreenViewState == GameCanvas.ScreenViewStates.Lobby || 
                    gameCanvas.ScreenViewState == GameCanvas.ScreenViewStates.LoadingSceneForGame ||
                    gameCanvas.ScreenViewState == GameCanvas.ScreenViewStates.UnloadingSceneForLobby ||
                    gameCanvas.ScreenViewState == GameCanvas.ScreenViewStates.GameScene ||
                    gameCanvas.ScreenViewState == GameCanvas.ScreenViewStates.UnloadingSceneForGame) {

                    //For now return true, until sure if more code is necessary here
                    return true;

                }
            }
            return false;
        }

        #endregion
    }

    #endif

    #endregion

}

public class CustomServer: BaseServer<CustomServer, CustomClient, CustomPeer> {

    #region Declares

    //Declare
    private ConcurrentQueue<Packet> packets = new ConcurrentQueue<Packet>(); //Convert to non allocating later

    #endregion

    #region Classes

    private class Packet {
        public CustomPeer customPeer;
        public ArraySegment<byte> packet;
        public Packet(CustomPeer customPeer, ArraySegment<byte> packet) {
            this.customPeer = customPeer;
            this.packet = packet;
        }
    }

    #endregion

    public CustomServer(CustomCommsNetwork network, Unit details) { }

    public void EnqueuePacket(CustomPeer customPeer, ArraySegment<byte> packet) {
        packets.Enqueue(new Packet(customPeer, packet));
    }

    public override void Connect() {
        
    }

    public override void Disconnect() {
        
    }
    
    protected override void ReadMessages() {
        int count = packets.Count;
        for (int i = 0; i < count; i++) {
            packets.LineBlockingDequeue(out Packet packet);
            NetworkReceivedPacket(packet.customPeer, packet.packet);
        }
    }

    protected override void SendReliable(CustomPeer destination, ArraySegment<byte> packet) {
        //Declare
        UDPSubSystem.Host host = networkManager.Host;
        UDPSubSystem.Connection connection = GetConnection(host, destination, out ushort slotIndex);
        byte localHeaderSize = UDPSubSystem.PUBLIC_CONSTANTS.PACKET.SIZE.OPCODE + UDPSubSystem.PUBLIC_CONSTANTS.DATA_TYPE.SIZE.USHORT + 
                               UDPSubSystem.PUBLIC_CONSTANTS.DATA_TYPE.SIZE.USHORT;
        byte[] data = new byte[localHeaderSize + packet.Count]; //Remove GC later
        byte[] opcode = OpcodesClient.GetOpcode(OpcodesClient.Opcodes.R_DissonanceMicrophone);
        byte[] slotIndexBytes = BitConverter.GetBytes(slotIndex); //Remove bitconverter later
        byte[] length = BitConverter.GetBytes((ushort)packet.Count); //Remove bitconverter later

        data[0] = opcode[0];
        data[1] = opcode[1];
        data[2] = slotIndexBytes[0];
        data[3] = slotIndexBytes[1];
        data[4] = length[0];
        data[5] = length[1];

        int count = packet.Count;
        for (int i = 0; i < count; i++) {
            data[i + localHeaderSize] = packet[i];
        }

        host.WriteData(connection, data);
    }

    //Write better later
    private UDPSubSystem.Connection GetConnection(UDPSubSystem.Host host, CustomPeer destination, out ushort slotIndex) {
        switch (networkManager.NetworkingSocket) {
            case NetworkingSockets.SteamSocket:

                for (int i = 0; i < host.connections.Length; i++) {

                    if (host.connections[i].steamConnection.Equals(destination.steamConnection)) {
                        slotIndex = (ushort)(i + 1);
                        return host.connections[i];
                    }
                }
                break;
            default: //UDPSocket

                for (int i = 0; i < host.connections.Length; i++) {
                    if (host.connections[i].ipEndPoint.Equals(destination.ipEndPoint)) {
                        slotIndex = (ushort)(i + 1);
                        return host.connections[i];
                    }
                }
                break;
        }
        //Set, should never get here
        slotIndex = 1;
        return host.connections[0];
    }

    protected override void SendUnreliable(CustomPeer destination, ArraySegment<byte> packet) {
        UDPSubSystem.Host host = networkManager.Host;
        UDPSubSystem.Connection connection = GetConnection(host, destination, out ushort slotIndex);
        byte localHeaderSize = UDPSubSystem.PUBLIC_CONSTANTS.PACKET.SIZE.OPCODE + UDPSubSystem.PUBLIC_CONSTANTS.DATA_TYPE.SIZE.USHORT + 
                               UDPSubSystem.PUBLIC_CONSTANTS.DATA_TYPE.SIZE.USHORT;
        byte[] data = new byte[localHeaderSize + packet.Count]; //Remove GC later
        byte[] opcode = OpcodesClient.GetOpcode(OpcodesClient.Opcodes.U_DissonanceMicrophone);
        byte[] slotIndexBytes = BitConverter.GetBytes(slotIndex); //Remove bitconverter later
        byte[] length = BitConverter.GetBytes((ushort)packet.Count); //Remove bitconverter later

        data[0] = opcode[0];
        data[1] = opcode[1];
        data[2] = slotIndexBytes[0];
        data[3] = slotIndexBytes[1];
        data[4] = length[0];
        data[5] = length[1];

        int count = packet.Count;
        for (int i = 0; i < count; i++) {
            data[i + localHeaderSize] = packet[i];
        }

        host.WriteData(connection, data);
    }

}

public class CustomClient : BaseClient<CustomServer, CustomClient, CustomPeer> {

    #region Declares

    private ConcurrentQueue<ArraySegment<byte>> packets = new ConcurrentQueue<ArraySegment<byte>>(); //Convert to non allocating later
    private CustomCommsNetwork customCommsNetwork = null;

    #endregion

    public CustomClient(CustomCommsNetwork network, Unit details) : base(network) { 
        customCommsNetwork = network;
    }

    public void EnqueuePacket(ArraySegment<byte> packet) {
        packets.Enqueue(packet);
    }

    public override void Connect() {
        base.Connected();
    }

    protected override void ReadMessages() {
        int count = packets.Count;
        for (int i = 0; i < count; i++) {
            packets.LineBlockingDequeue(out ArraySegment<byte> packet);
            NetworkReceivedPacket(packet);
        }
    }

    protected override void SendReliable(ArraySegment<byte> packet) {
        if (networkManager.SubSystem.IsHost) {
            customCommsNetwork.GetCustomServer.EnqueuePacket(new CustomPeer(), packet);
        } else {
            UDPSubSystem.Client client = networkManager.Client;
            byte localHeaderSize = UDPSubSystem.PUBLIC_CONSTANTS.PACKET.SIZE.OPCODE + UDPSubSystem.PUBLIC_CONSTANTS.DATA_TYPE.SIZE.USHORT;
            byte[] data = new byte[localHeaderSize + packet.Count]; //Remove GC later
            byte[] opcode = OpcodesHost.GetOpcode(OpcodesHost.Opcodes.R_DissonanceMicrophone);
            byte[] length = BitConverter.GetBytes((ushort)packet.Count); //Remove bitconverter later

            data[0] = opcode[0];
            data[1] = opcode[1];
            data[2] = length[0];
            data[3] = length[1];

            int count = packet.Count;
            for (int i = 0; i < count; i++) {
                data[i + localHeaderSize] = packet[i];
            }

            client.WriteData(client.connections[0], data);
        }
    }

    protected override void SendUnreliable(ArraySegment<byte> packet) {
        if (networkManager.SubSystem.IsHost) {
            customCommsNetwork.GetCustomServer.EnqueuePacket(new CustomPeer(), packet);
        } else {
            UDPSubSystem.Client client = networkManager.Client;
            byte localHeaderSize = UDPSubSystem.PUBLIC_CONSTANTS.PACKET.SIZE.OPCODE + UDPSubSystem.PUBLIC_CONSTANTS.DATA_TYPE.SIZE.USHORT;
            byte[] data = new byte[localHeaderSize + packet.Count]; //Remove GC later
            byte[] opcode = OpcodesHost.GetOpcode(OpcodesHost.Opcodes.U_DissonanceMicrophone);
            byte[] length = BitConverter.GetBytes((ushort)packet.Count); //Remove bitconverter later

            data[0] = opcode[0];
            data[1] = opcode[1];
            data[2] = length[0];
            data[3] = length[1];

            int count = packet.Count;
            for (int i = 0; i < count; i++) {
                data[i + localHeaderSize] = packet[i];
            }

            client.WriteData(client.connections[0], data);        
        }
    }

}

public struct CustomPeer : IEquatable<CustomPeer> {
    public IPEndPoint ipEndPoint;
    public SteamworksNetworking.Connection steamConnection;
    public CustomPeer(IPEndPoint ipEndPoint, SteamworksNetworking.Connection steamConnection) {
        this.ipEndPoint = ipEndPoint;
        this.steamConnection = steamConnection;
    }
    public bool Equals(CustomPeer other) {
        return
            Equals(ipEndPoint, other.ipEndPoint) &&
            steamConnection.connection == other.steamConnection.connection &&
            EqualityComparer<User>.Default.Equals(steamConnection.user, other.steamConnection.user);
    }

    public override bool Equals(object obj) {
        return obj is CustomPeer other && Equals(other);
    }

    public override int GetHashCode() {
        return HashCode.Combine(ipEndPoint, steamConnection.connection, steamConnection.user);
    }

    public override string ToString() {
        return $"IPEndpoint[{ipEndPoint}, Steam Connection={steamConnection.connection}, Steam User={steamConnection.user}]";
    }
}

public struct CustomServerParam {}
public struct CustomClientParam {}

[martindevans]

I'm not clear on what your question is, sorry! I'll try my best to answer.

I have to pass a CustomPeer and that peer includes an IPEndPoint and or SteamConnection (NetworkReceivedPacket needs CustomPeer for Custom Server)

CustomPeer is completely under your control, it can include anything you want. You should set it up so that when Dissonance calls Send(some_data, custom_peer) the custom_peer provides the information you need to send to that peer.

CustomPeer objects are created (by your code) when you call NetworkReceivedPacket. So this is your chance to store the information you need to be able to send back to that peer.

When I'm writing network integrations I will usually detect loopback by creating a method called something like PreprocessToServer/PreprocessToClient which exists on the CustomCommsNetwork class. That would do something like this:

PreprocessToServer(the_packet)
{
    // Caller will send the packet normally if this returns false
    if (Server == null)
        return false;
    
    // It's loopback, make sure not sure store the original packet
    var copy = MakeACopy(the_packet);
    _toServerLoopbackQueue.Enqueue(copy);
}

void Update()
{
    while (_toServerLoopbackQueue.TryDequeue(out var packet))
        NetworkReceivedPacket(packet, new CustomPeer( /* some indication that this was loopback */ );
}

SendReliable

Just a note about this. I can see you're using a UDP system. Your implementation of SendReliable must deliver packet in-order, and without any lost packets! It's possible you've got a reliability system layered over UDP, in which case that's fine.

Allocations

You're allocating a lot in this code. Voice chat sends and receives quite a lot of packets, once you have the basics working you should consider reducing this (e.g. pooling and re-using byte arrays).

[ZaCkOX]

I'm not clear on what your question is, sorry! I'll try my best to answer.

What I am trying to say is, my host doesn't have a server and client endpoint, it is a player of the game with 1 endpoint, just per client. My understanding of Dissonance is: Both the custom server and custom client will be running on this host, and each require an endpoint (CustomPeer). I believe you gave me the correct answer, use loopback. I write it when detecting if (IsHost) in the custom client.

public class CustomClient : BaseClient<CustomServer, CustomClient, CustomPeer> {

    #region Declares

    private ConcurrentQueue<ArraySegment<byte>> packets = new ConcurrentQueue<ArraySegment<byte>>(); //Convert to non allocating later
    private CustomCommsNetwork customCommsNetwork = null;

    #endregion

    public CustomClient(CustomCommsNetwork network, Unit details) : base(network) { 
        customCommsNetwork = network;
    }

    public void EnqueuePacket(ArraySegment<byte> packet) {
        packets.Enqueue(packet);
    }

    public override void Connect() {
        base.Connected();
    }

    protected override void ReadMessages() {
        int count = packets.Count;
        for (int i = 0; i < count; i++) {
            packets.LineBlockingDequeue(out ArraySegment<byte> packet);
            NetworkReceivedPacket(packet);
        }
    }

    protected override void SendReliable(ArraySegment<byte> packet) {
        if (networkManager.SubSystem.IsHost) {
+          customCommsNetwork.GetCustomServer.EnqueuePacket(new CustomPeer(), packet); //Write Loopback here
        } else {
            UDPSubSystem.Client client = networkManager.Client;
            byte localHeaderSize = UDPSubSystem.PUBLIC_CONSTANTS.PACKET.SIZE.OPCODE + UDPSubSystem.PUBLIC_CONSTANTS.DATA_TYPE.SIZE.USHORT;
            byte[] data = new byte[localHeaderSize + packet.Count]; //Remove GC later
            byte[] opcode = OpcodesHost.GetOpcode(OpcodesHost.Opcodes.R_DissonanceMicrophone);
            byte[] length = BitConverter.GetBytes((ushort)packet.Count); //Remove bitconverter later

            data[0] = opcode[0];
            data[1] = opcode[1];
            data[2] = length[0];
            data[3] = length[1];

            int count = packet.Count;
            for (int i = 0; i < count; i++) {
                data[i + localHeaderSize] = packet[i];
            }

            client.WriteData(client.connections[0], data);
        }
    }

    protected override void SendUnreliable(ArraySegment<byte> packet) {
        if (networkManager.SubSystem.IsHost) {
+          customCommsNetwork.GetCustomServer.EnqueuePacket(new CustomPeer(), packet); //Write loopback here
        } else {
            UDPSubSystem.Client client = networkManager.Client;
            byte localHeaderSize = UDPSubSystem.PUBLIC_CONSTANTS.PACKET.SIZE.OPCODE + UDPSubSystem.PUBLIC_CONSTANTS.DATA_TYPE.SIZE.USHORT;
            byte[] data = new byte[localHeaderSize + packet.Count]; //Remove GC later
            byte[] opcode = OpcodesHost.GetOpcode(OpcodesHost.Opcodes.U_DissonanceMicrophone);
            byte[] length = BitConverter.GetBytes((ushort)packet.Count); //Remove bitconverter later

            data[0] = opcode[0];
            data[1] = opcode[1];
            data[2] = length[0];
            data[3] = length[1];

            int count = packet.Count;
            for (int i = 0; i < count; i++) {
                data[i + localHeaderSize] = packet[i];
            }

            client.WriteData(client.connections[0], data);        
        }
    }

}

Just a note about this. I can see you're using a UDP system. Your implementation of SendReliable must deliver packet in-order, and without any lost packets! It's possible you've got a reliability system layered over UDP, in which case that's fine.

Yes, my network does do this. I have sequencing, in order when sending a channel of reliable, and packets that require reliable data do respond back. It does work like you would expect.

You're allocating a lot in this code. Voice chat sends and receives quite a lot of packets, once you have the basics working you should consider reducing this (e.g. pooling and re-using byte arrays).

I do understand and know. This is why I left comments there stating this will be changed out. I am just attempting to get this working first.

I also am chronically ill so this process will take me much longer than a healthy person. I will have to come back later after trying your suggestion.

[martindevans]

It looks like that change should mostly cover it. You need to make sure to drain those queues in Update and deliver the packet as well.

If you're wondering why not just deliver the packet right away, that can cause very hard to debug issues. For example:

1. Server sends a packet to the client
2. Your code immediately passes packet to client code
3. Client replies with a message, which gets passed immediately to the server
4. The very first Send call still hasn't returned. So now the server is receiving a reply to a message that it's still in the middle of sending!

Using queues in one or both directions protects against this.

[ZaCkOX]

public class CustomServer: BaseServer<CustomServer, CustomClient, CustomPeer> {

    #region Declares

    //Declare
    private ConcurrentQueue<Packet> packets = new ConcurrentQueue<Packet>(); //Convert to non allocating later
    private CustomCommsNetwork customCommsNetwork = null;

    #endregion

    #region Classes

    private class Packet {
        public CustomPeer customPeer;
        public ArraySegment<byte> packet;
        public Packet(CustomPeer customPeer, ArraySegment<byte> packet) {
            this.customPeer = customPeer;
            this.packet = packet;
        }
    }

    #endregion

    public CustomServer(CustomCommsNetwork network, Unit details) { 
        customCommsNetwork = network;
    }

    public void EnqueuePacket(CustomPeer customPeer, ArraySegment<byte> packet) {
        packets.Enqueue(new Packet(customPeer, packet));
    }

    public override void Connect() {
        //When a client connects
    }

    public override void Disconnect() {
        //When a client disconnects
    }
    
    protected override void ReadMessages() {
        int count = packets.Count;
        for (int i = 0; i < count; i++) {
            packets.LineBlockingDequeue(out Packet packet);
            NetworkReceivedPacket(packet.customPeer, packet.packet);
        }
    }

    protected override void SendReliable(CustomPeer destination, ArraySegment<byte> packet) {
        if (!destination.host) {
            SendDataToClient();
        } else {
            Loopback();
        }

        #region Functions

        void SendDataToClient() {

            UDPSubSystem.Host host = networkManager.Host;
            UDPSubSystem.Connection connection = GetConnection(host, destination, out ushort slotIndex);
            byte localHeaderSize = UDPSubSystem.PUBLIC_CONSTANTS.PACKET.SIZE.OPCODE + UDPSubSystem.PUBLIC_CONSTANTS.DATA_TYPE.SIZE.USHORT + 
                                   UDPSubSystem.PUBLIC_CONSTANTS.DATA_TYPE.SIZE.USHORT;
            byte[] data = new byte[localHeaderSize + packet.Count]; //Remove GC later
            byte[] opcode = OpcodesClient.GetOpcode(OpcodesClient.Opcodes.R_DissonanceMicrophone);
            byte[] slotIndexBytes = BitConverter.GetBytes(slotIndex); //Remove bitconverter later
            byte[] length = BitConverter.GetBytes((ushort)packet.Count); //Remove bitconverter later

            data[0] = opcode[0];
            data[1] = opcode[1];
            data[2] = slotIndexBytes[0];
            data[3] = slotIndexBytes[1];
            data[4] = length[0];
            data[5] = length[1];

            int count = packet.Count;
            for (int i = 0; i < count; i++) {
                data[i + localHeaderSize] = packet[i];
            }

            host.WriteData(connection, data);
        }

        void Loopback() {
            customCommsNetwork.GetCustomClient.EnqueuePacket(packet);
        }

        #endregion
    }

    //Write better later
    private UDPSubSystem.Connection GetConnection(UDPSubSystem.Host host, CustomPeer destination, out ushort slotIndex) {
        switch (networkManager.NetworkingSocket) {
            case NetworkingSockets.SteamSocket:

                for (int i = 0; i < host.connections.Length; i++) {

                    if (host.connections[i].steamConnection.Equals(destination.steamConnection)) {
                        slotIndex = (ushort)(i + 1);
                        return host.connections[i];
                    }
                }
                break;
            default: //UDPSocket

                for (int i = 0; i < host.connections.Length; i++) {
                    if (host.connections[i].ipEndPoint.Equals(destination.ipEndPoint)) {
                        slotIndex = (ushort)(i + 1);
                        return host.connections[i];
                    }
                }
                break;
        }
        //Set, should never get here
        slotIndex = 1;
        return host.connections[0];
    }

    protected override void SendUnreliable(CustomPeer destination, ArraySegment<byte> packet) {
        if (!destination.host) {
            SendDataToClient();
        } else {
            Loopback();
        }
        #region Functions

        void SendDataToClient() {
            UDPSubSystem.Host host = networkManager.Host;
            UDPSubSystem.Connection connection = GetConnection(host, destination, out ushort slotIndex);
            byte localHeaderSize = UDPSubSystem.PUBLIC_CONSTANTS.PACKET.SIZE.OPCODE + UDPSubSystem.PUBLIC_CONSTANTS.DATA_TYPE.SIZE.USHORT + 
                                   UDPSubSystem.PUBLIC_CONSTANTS.DATA_TYPE.SIZE.USHORT;
            byte[] data = new byte[localHeaderSize + packet.Count]; //Remove GC later
            byte[] opcode = OpcodesClient.GetOpcode(OpcodesClient.Opcodes.U_DissonanceMicrophone);
            byte[] slotIndexBytes = BitConverter.GetBytes(slotIndex); //Remove bitconverter later
            byte[] length = BitConverter.GetBytes((ushort)packet.Count); //Remove bitconverter later

            data[0] = opcode[0];
            data[1] = opcode[1];
            data[2] = slotIndexBytes[0];
            data[3] = slotIndexBytes[1];
            data[4] = length[0];
            data[5] = length[1];

            int count = packet.Count;
            for (int i = 0; i < count; i++) {
                data[i + localHeaderSize] = packet[i];
            }

            host.WriteData(connection, data);        
        }

        void Loopback() {
            customCommsNetwork.GetCustomClient.EnqueuePacket(packet);
        }

        #endregion
    }

}

public class CustomClient : BaseClient<CustomServer, CustomClient, CustomPeer> {

    #region Declares

    private ConcurrentQueue<ArraySegment<byte>> packets = new ConcurrentQueue<ArraySegment<byte>>(); //Convert to non allocating later
    private CustomCommsNetwork customCommsNetwork = null;

    #endregion

    public CustomClient(CustomCommsNetwork network, Unit details) : base(network) { 
        customCommsNetwork = network;
    }

    public void EnqueuePacket(ArraySegment<byte> packet) {
        packets.Enqueue(packet);
    }

    public override void Connect() {
        base.Connected();
    }

    protected override void ReadMessages() {
        int count = packets.Count;
        for (int i = 0; i < count; i++) {
            packets.LineBlockingDequeue(out ArraySegment<byte> packet);
            NetworkReceivedPacket(packet);
        }
    }

    protected override void SendReliable(ArraySegment<byte> packet) {
        if (networkManager.SubSystem.IsHost) {
            CustomPeer customPeer = new CustomPeer(null, null, true);
            customCommsNetwork.GetCustomServer.EnqueuePacket(customPeer, packet);
        } else {
            UDPSubSystem.Client client = networkManager.Client;
            byte localHeaderSize = UDPSubSystem.PUBLIC_CONSTANTS.PACKET.SIZE.OPCODE + UDPSubSystem.PUBLIC_CONSTANTS.DATA_TYPE.SIZE.USHORT;
            byte[] data = new byte[localHeaderSize + packet.Count]; //Remove GC later
            byte[] opcode = OpcodesHost.GetOpcode(OpcodesHost.Opcodes.R_DissonanceMicrophone);
            byte[] length = BitConverter.GetBytes((ushort)packet.Count); //Remove bitconverter later

            data[0] = opcode[0];
            data[1] = opcode[1];
            data[2] = length[0];
            data[3] = length[1];

            int count = packet.Count;
            for (int i = 0; i < count; i++) {
                data[i + localHeaderSize] = packet[i];
            }

            client.WriteData(client.connections[0], data);
        }
    }

    protected override void SendUnreliable(ArraySegment<byte> packet) {
        if (networkManager.SubSystem.IsHost) {
            CustomPeer customPeer = new CustomPeer(null, null, true);
            customCommsNetwork.GetCustomServer.EnqueuePacket(customPeer, packet);
        } else {
            UDPSubSystem.Client client = networkManager.Client;
            byte localHeaderSize = UDPSubSystem.PUBLIC_CONSTANTS.PACKET.SIZE.OPCODE + UDPSubSystem.PUBLIC_CONSTANTS.DATA_TYPE.SIZE.USHORT;
            byte[] data = new byte[localHeaderSize + packet.Count]; //Remove GC later
            byte[] opcode = OpcodesHost.GetOpcode(OpcodesHost.Opcodes.U_DissonanceMicrophone);
            byte[] length = BitConverter.GetBytes((ushort)packet.Count); //Remove bitconverter later

            data[0] = opcode[0];
            data[1] = opcode[1];
            data[2] = length[0];
            data[3] = length[1];

            int count = packet.Count;
            for (int i = 0; i < count; i++) {
                data[i + localHeaderSize] = packet[i];
            }

            client.WriteData(client.connections[0], data);        
        }
    }

}

So I added a bool host, which represents when a player is hosting, he is the host and we just pass packets without networking, this is between the initial custom server and custom client, I have no red errors. But I do get yellow warnings, "[Dissonance:Network] (07:33:48.653) CustomClient: Received a 'ClientState' packet with incorrect session ID. Expected 0, got 699432648
UnityEngine.Debug:LogWarning (object)"

And for my clients when they connect, the server gets "[Dissonance:Network] (07:34:01.549) VoiceSender`1: Attempted to send voice before assigned a client ID by the host (100 packets discarded so far)
UnityEngine.Debug:LogWarning (object)"

I believe this is because I need to work on the custom peer. I probably don't have comparisons correct? Also I'm not sure if I should just use 127.0.0.1, 0 for my IPAddress instead of a bool host, simply because I don't remember how loopback ports look when using loopback. I believe a port is assigned to clients? I want to be able to test Dissonance on just my laptop since I am very sick and lay in bed, so a host could use loopback as hosting. I might be able to just not use a bool host at all. I would have to spend more debugging and testing to make sure.

You might wonder why do any of this? Well, since my network topology is different, I want the dictionaries to match up and if the dictionaries are same then less prone to bugs. My connection array on hosting doesn't have the host ip address. It just stores the client endpoints only.

public struct CustomPeer : IEquatable<CustomPeer> {
    public IPEndPoint ipEndPoint;
    public SteamworksNetworking.Connection steamConnection;
    public bool host;
    public CustomPeer(IPEndPoint ipEndPoint, SteamworksNetworking.Connection steamConnection, bool host = false) {
        this.ipEndPoint = ipEndPoint;
        this.steamConnection = steamConnection;
        this.host = host;
    }
    public bool Equals(CustomPeer other) {
        if (!other.host) {
            return
                Equals(ipEndPoint, other.ipEndPoint) &&
                steamConnection.connection == other.steamConnection.connection &&
                EqualityComparer<User>.Default.Equals(steamConnection.user, other.steamConnection.user);        
        } else {
            return true;
        }
    }

    public override bool Equals(object obj) {
        return obj is CustomPeer other && Equals(other);
    }

    public override int GetHashCode() {
        return HashCode.Combine(ipEndPoint, steamConnection.connection, steamConnection.user);
    }

    public override string ToString() {
        return $"IPEndpoint[{ipEndPoint}, Steam Connection={steamConnection.connection}, Steam User={steamConnection.user}]";
    }
}

I don't hear any microphone, but I do see microphone usage in the basic microphone capture component.

I also have no idea if I have all the components and the settings within those components correct. I have a custom comms network, dissonance comms, voice broadcast trigger, voice receipt trigger, and basic microphone capture.

Another friend who also got Dissonance showed me his working with FishNet, and there was a gameobject with a unique ID with audio source I believe in the center of his world? If I saw that, it would probably mean I got it working I assumed.

Appreciate the help, sorry if I did something very obviously wrong and I should of noticed. Thank you in advance.

[martindevans]

[Dissonance:Network] (07:33:48.653) CustomClient: Received a 'ClientState' packet with incorrect session ID. Expected 0, got 699432648

This means that the client never received the initial handshake from the server, so it thinks it is in session=0, when the server thinks it is in session=699432648. Dissonance completely ignores packets with the wrong session ID (except for logging this message).

[Dissonance:Network] (07:34:01.549) VoiceSender`1: Attempted to send voice before assigned a client ID by the host (100 packets discarded so far)

This is basically the same - the server hasn't assigned an ID yet (probably because it was in an ignored packet) and so the client can't send voice yet.

Component setup

Looks good 👍

there was a gameobject with a unique ID with audio source I believe in the center of his world? If I saw that, it would probably mean I got it working I assumed.

This is the playback object, one is created for every speaker except yourself. Since your network system isn't initialising there are no remote players, so none have been spawned.

---

I think the bug in your loopback system is because you are storing the ArraySegment which Dissonance hands you, here:

public void EnqueuePacket(CustomPeer customPeer, ArraySegment<byte> packet) {
    packets.Enqueue(new Packet(customPeer, packet));
}

Dissonance internally re-uses the arrays (to avoid allocations), so you are not allowed to store a reference to that ArraySegment beyond the duration of that method call. You will need to copy it to your own array before queueing it.

[ZaCkOX]

Ok so I applied what you said, and a few other bug fixes. I have no errors now, and it seems to have handshakes, I see only data changed from the initial handshake? But I don't see any objects or hear anything and it does appear the microphone can be heard on both the server and client locally, just nothing happening.

Picture of host and client (Host as edtior)

Picture of host (Host as editor)

Picture of client (Client as editor), a restart of editor to show it does say "Connected" for client.

Any ideas? Maybe they don't keep sending data back and forth and I need to look into that?

[ZaCkOX]

I did debug logs for "sending packets (reliable and unreliable), and reading packets. I see the handshake, "SessionId:2144187797" on both applications, this means they can communicate, but I never see an unreliable packet being sent or read. So what am I missing here? The sending, receiving, and reading of reliable packets is working it seems. Just no sending of unreliable packets? I try speaking into the microphone and I hear nothing but I can see a component picking up my microphone in both applications. Am I supposed to create an object or something?

[martindevans]

Sorry I never replied in December, I was on my Christmas holiday and forgot to followup when I got back to work in January!

Dissonance will only send voice if it thinks it needs to - i.e. if someone is sending to a channel which someone else is listening to. Check the DissonanceComms inspector and fold out the player list, you can see a list of all the channels you're sending to and all of the Rooms other players are listening to. Voice will only be sent if those overlap (that's controlled by the broadcast/receipt triggers normally).

[ZaCkOX]

There appears to be no peers (0), but both applications show the same session ID, if you look at previous screenshots, you can see reliable debugs, for every reliable packet sent, it seems to be received and responded. I am not sure what to do. I tried reading code from a working example to understand when the prefab will be created but there was a lot to go through.


They appear connected though because both applications show a connected state. My host is a server and client, and my client is a client, both show "Connected" status.

[martindevans]

Ok that explains why no audio is flowing at least, something is going wrong in the session initialisation.

The peer should be added to the session when the ClientState message is delivered. We can see that 2 of those have been delivered, which what I'd expect for a 2 peer session.

Could you try stepping through and seeing what's happening when that packet is delivered. The flow of events here should be:

1. ClientState packet is delivered to client (Assets/Plugins/Dissonance/Core/Networking/BaseClient.cs#L295) - add a breakpoint here
2. BaseClientCollection processes it (Assets/Plugins/Dissonance/Core/Networking/BaseClientCollection.cs#L208)
3. GetOrCreateClientInfo is called (line 65), creates a new client object (line 72) and calls OnAddedClient (Assets/Plugins/Dissonance/Core/Networking/Client/SlaveClientCollection.cs#L37
4. That should add a player joined event to the event queue (Assets/Plugins/Dissonance/Core/Networking/Client/EventQueue.cs#L323)
5. Events are dispatched (_events.DispatchEvents()) at Assets/Plugins/Dissonance/Core/Networking/BaseClient.cs#L207
6. The event is raised Assets/Plugins/Dissonance/Core/Networking/Client/EventQueue.cs#L203
7. That event should be handled by Net_PlayerJoined (Assets/Plugins/Dissonance/Core/DissonanceCommsImpl.cs#L610) - add a breakpoint here

We'll see where that process is breaking as you step through that.

[ZaCkOX]

Ok so this is when I am hosting. So far, I am scratching my head because it looks like it gets added, but the value count is 0 later.

Next post I'll follow client through the same process when he joins. I would do all the checking right now but I am very sick. I'm trying to push through it. This chronic illness I have just cripples me.

[martindevans]

On the host you're running both a client and a server at the same time, that means two event queues. Maybe you saw the event added to one queue, but debugged the other queue?

If you inspect the client it should be simpler, since it's only got the one queue.

[ZaCkOX]

No matter what, id here is always 0, no matter if I am a host (server and client) or a client. Is this correct?

Also this is 0 when a client joins.

As client:

I'm on a laptop and need to print out what you said earlier, so I can follow all the lines you suggested. It is hard to navigate like this. I'm also having problems with multiplayer mode, unity 6, and sometimes the break points just not even triggering at all. I thought I saw a pattern and then the break points would trigger again when they didn't. Frustrating.