void OnConnect(NetworkConnection c)
    {
        // Set all player values when connecting
        NewClientMsg msg = new NewClientMsg();

        msg.player.id                   = c.InternalId.ToString();
        msg.player.position             = new Vector3(0, 0, 0);
        msg.player.rotation.eulerAngles = new Vector3(0, 0, 0);
        msg.player.color.r              = Random.Range(0.0f, 1.0f);
        msg.player.color.g              = Random.Range(0.0f, 1.0f);
        msg.player.color.b              = Random.Range(0.0f, 1.0f);
        msg.player.lastBeat             = DateTime.Now;

        PlayerListMsg list = new PlayerListMsg(players);

        foreach (NetworkConnection connection in m_Connections)
        {
            SendToClient(JsonUtility.ToJson(msg), connection);
        }

        msg.cmd = Commands.MY_ID;
        SendToClient(JsonUtility.ToJson(msg), c);
        SendToClient(JsonUtility.ToJson(list), c);
        players.Add(msg.player);
        m_Connections.Add(c);
        Debug.Log("Accepted a connection");
    }
    void OnConnect(NetworkConnection c)
    {
        // Example to send a handshake message:
        NewClientMsg newClientMsg = new NewClientMsg();

        newClientMsg.player.id = c.InternalId.ToString();

        //position arrangement
        newClientMsg.player.cubePos = new Vector3(playerList.Count * 2.0f - 6.0f, 0.0f, 0.0f);

        foreach (NetworkConnection connection in m_Connections)
        {
            SendToClient(JsonUtility.ToJson(newClientMsg), connection);
        }

        PlayerListMsg list = new PlayerListMsg(playerList);

        SendToClient(JsonUtility.ToJson(list), c);

        newClientMsg.cmd = Commands.PLAYER_ID;
        SendToClient(JsonUtility.ToJson(newClientMsg), c);
        playerList.Add(newClientMsg.player);

        m_Connections.Add(c);
        Debug.Log("Server msg: Accepted a connection");
    }
    void OnData(DataStreamReader stream)
    {
        NativeArray <byte> bytes = new NativeArray <byte>(stream.Length, Allocator.Temp);

        stream.ReadBytes(bytes);
        string        recMsg = Encoding.ASCII.GetString(bytes.ToArray());
        NetworkHeader header = JsonUtility.FromJson <NetworkHeader>(recMsg);

        switch (header.cmd)
        {
        case Commands.PLAYER_CONNECT:
            PlayerConnectMsg pcMsg = JsonUtility.FromJson <PlayerConnectMsg>(recMsg);
            SpawnPlayers(pcMsg.newPlayer.id, pcMsg.newPlayer.cubeColor);
            Debug.Log("New Player joined");
            break;

        case Commands.INVERT_BALL:

            GameObject.FindGameObjectWithTag("Ball").GetComponent <Ball>().invert = -1;
            break;

        case Commands.PLAYER_UPDATE:
            PlayerUpdateMsg puMsg = JsonUtility.FromJson <PlayerUpdateMsg>(recMsg);
            UpdatePlayers(puMsg.players);

            break;

        case Commands.OWNED_ID:
            OwnIDMsg idMsg = JsonUtility.FromJson <OwnIDMsg>(recMsg);
            playerID = idMsg.ownedPlayer.id;
            Debug.Log("Own id received! id: " + playerID);
            break;

        case Commands.PLAYER_DROPPED:
            PlayerDropMsg dropMsg = JsonUtility.FromJson <PlayerDropMsg>(recMsg);
            foreach (NetworkObjects.NetworkPlayer p in dropMsg.droppedPlayers)
            {
                DestroyPlayers(p.id);
            }
            break;

        case Commands.PLAYER_LIST:
            PlayerListMsg plMsg = JsonUtility.FromJson <PlayerListMsg>(recMsg);
            foreach (var it in plMsg.players)
            {
                SpawnPlayers(it.id, it.cubeColor);
                Debug.Log("Spawn player with id: " + it.id);
            }
            break;

        default:
            Debug.Log("Unrecognized message received!");
            break;
        }
    }
    void OnData(DataStreamReader stream)
    {
        NativeArray <byte> bytes = new NativeArray <byte>(stream.Length, Allocator.Temp);

        stream.ReadBytes(bytes);
        string        recMsg = Encoding.ASCII.GetString(bytes.ToArray());
        NetworkHeader header = JsonUtility.FromJson <NetworkHeader>(recMsg);

        switch (header.cmd)
        {
        case Commands.NEW_CLIENT:
            NewClientMsg ncMsg1 = JsonUtility.FromJson <NewClientMsg>(recMsg);
            SpawnPlayer(ncMsg1.player);
            Debug.Log("Client Msg: New Client message received!");
            break;

        case Commands.CLIENT_DROP:
            DropPlayerMsg dpMsg = JsonUtility.FromJson <DropPlayerMsg>(recMsg);
            RemovePlayers(dpMsg.players);
            Debug.Log("Client Msg: Client drop message received!");
            break;

        case Commands.CLIENT_LIST:
            PlayerListMsg nplMsg = JsonUtility.FromJson <PlayerListMsg>(recMsg);
            for (int i = 0; i < nplMsg.players.Length; i++)
            {
                SpawnPlayer(nplMsg.players[i]);
            }
            Debug.Log("Client Msg: Client list message received!");
            break;

        case Commands.PLAYER_UPDATE:
            PlayerUpdateMsg puMsg = JsonUtility.FromJson <PlayerUpdateMsg>(recMsg);
            PlayerUpdate(puMsg.updatedPlayers);
            break;

        case Commands.SERVER_UPDATE:
            ServerUpdateMsg suMsg = JsonUtility.FromJson <ServerUpdateMsg>(recMsg);
            Debug.Log("Client Msg: Server update message received!");
            break;

        case Commands.PLAYER_ID:
            NewClientMsg ncMsg2 = JsonUtility.FromJson <NewClientMsg>(recMsg);
            playerID = ncMsg2.player.id;
            SpawnPlayer(ncMsg2.player);
            break;

        default:
            Debug.Log("Client Msg: Unrecognized message received!");
            break;
        }
    }
    void OnData(DataStreamReader stream)
    {
        NativeArray <byte> bytes = new NativeArray <byte>(stream.Length, Allocator.Temp);

        stream.ReadBytes(bytes);
        string        recMsg = Encoding.ASCII.GetString(bytes.ToArray());
        NetworkHeader header = JsonUtility.FromJson <NetworkHeader>(recMsg);

        switch (header.cmd)
        {
        case Commands.NEW_CLIENT:
            NewClientMsg newClientMsg = JsonUtility.FromJson <NewClientMsg>(recMsg);
            SpawnPlayer(newClientMsg.player);
            Debug.Log("New client");
            break;

        case Commands.PLAYER_UPDATE:
            PlayerUpdateMsg puMsg = JsonUtility.FromJson <PlayerUpdateMsg>(recMsg);
            UpdatePlayer(puMsg.updatedPlayers);
            //Debug.Log("Player updated");
            break;

        case Commands.SERVER_UPDATE:
            ServerUpdateMsg suMsg = JsonUtility.FromJson <ServerUpdateMsg>(recMsg);
            Debug.Log("Server update message received!");
            break;

        case Commands.LIST_CLIENT:
            PlayerListMsg nplMsg = JsonUtility.FromJson <PlayerListMsg>(recMsg);
            SpawnPlayers(nplMsg.players);
            Debug.Log("List_Client");
            break;

        case Commands.MY_ID:
            NewClientMsg ncMsg = JsonUtility.FromJson <NewClientMsg>(recMsg);
            clientId = ncMsg.player.id;
            SpawnPlayer(ncMsg.player);
            break;

        case Commands.DROP_CLIENT:
            DropPlayerMsg dpMsg = JsonUtility.FromJson <DropPlayerMsg>(recMsg);
            DestroyPlayers(dpMsg.players);
            Debug.Log("Drop players");
            break;

        default:
            Debug.Log("Unrecognized message received!");
            break;
        }
    }
    void Start()
    {
        m_Driver = NetworkDriver.Create();
        var endpoint = NetworkEndPoint.AnyIpv4;

        endpoint.Port = serverPort;
        if (m_Driver.Bind(endpoint) != 0)
        {
            Debug.Log("Failed to bind to port " + serverPort);
        }
        else
        {
            m_Driver.Listen();
        }

        m_Connections = new NativeList <NetworkConnection>(16, Allocator.Persistent);

        plMsg       = new PlayerListMsg();
        msgInterval = new List <float>();

        InvokeRepeating("SendPosition", 1, 0.033f);
    }