void OnData(DataStreamReader stream, int i)
    {
        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_CONNECTED:
            ConnectionApprovedMsg cpMsg = JsonUtility.FromJson <ConnectionApprovedMsg>(recMsg);
            Debug.Log("Handshake message received!");

            break;

        case Commands.PLAYER_UPDATE:
            PlayerUpdateMsg puMsg = JsonUtility.FromJson <PlayerUpdateMsg>(recMsg);
            //Debug.Log("Player update message received!");
            playerData = puMsg;
            Debug.Log("Player ID: " + playerData.player.id + " Player Position: " + playerData.player.cubPos);
            //Debug.Log("Time As of Now: " + DateTime.Now);
            playerData.player.pulse = DateTime.Now;
            for (i = 0; i < ConnectedList.GameState.Count; i++)
            {
                if (playerData.player.id == ConnectedList.GameState[i].id)
                {
                    ConnectedList.GameState.Insert(i, playerData.player);
                    ConnectedList.GameState.RemoveAt(i + 1);
                }
                Debug.Log("Transfered ID: " + ConnectedList.GameState[i].id + "Transfered Pos: " + ConnectedList.GameState[i].cubPos);
            }


            break;

        case Commands.PLAYER_DISCONNECTED:
            PlayerDisconnectMsg pdMsg = JsonUtility.FromJson <PlayerDisconnectMsg>(recMsg);
            Debug.Log("Player Disconnect update message received!, Got This: " + i);
            OnDisconnect(i);
            break;

        case Commands.GAMESTATE:
            GameStateMsg gsMsg = JsonUtility.FromJson <GameStateMsg>(recMsg);
            Debug.Log("GameState update message received!");
            break;

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

        default:
            Debug.Log("SERVER ERROR: Unrecognized message received!");
            break;
        }
    }
Beispiel #2
0
    void Disconnect()
    {
        PlayerDisconnectMsg pdMsg = new PlayerDisconnectMsg();

        SendToServer(JsonUtility.ToJson(pdMsg));

        m_Connection.Disconnect(m_Driver);
        m_Connection = default(NetworkConnection);
        Debug.Log("We got disconnected from server");
    }
Beispiel #3
0
    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.HANDSHAKE:
            HandshakeMsg hsMsg = JsonUtility.FromJson <HandshakeMsg>(recMsg);
            Debug.Log("Handshake message received!");
            break;

        case Commands.PLAYER_UPDATE:
            PlayerUpdateMsg puMsg = JsonUtility.FromJson <PlayerUpdateMsg>(recMsg);
            Debug.Log("Player update message received!");
            break;

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

        case Commands.PLAYER_LOGIN:
            PlayerLoginMsg loginMsg = JsonUtility.FromJson <PlayerLoginMsg>(recMsg);
            playerUpdateMsg.player.id = loginMsg.loginID;
            HandshakeMsg m = new HandshakeMsg();
            m.player    = playerUpdateMsg.player;
            m.player.id = loginMsg.loginID;
            SendToServer(JsonUtility.ToJson(m));
            otherPlayers.Add(m.player.id, playerController);
            Debug.Log("ID: " + loginMsg.loginID);
            break;

        case Commands.PLAYER_DISCONNECT:
            PlayerDisconnectMsg discMsg = JsonUtility.FromJson <PlayerDisconnectMsg>(recMsg);
            GameObject          player  = otherPlayers[discMsg.discID];
            otherPlayers.Remove(discMsg.discID);
            Destroy(player);
            Debug.Log("Disconnect: " + discMsg.discID);
            break;

        default:
            Debug.Log("Unrecognized message received!");
            break;
        }
    }
    void OnDisconnect(int i)
    {
        Debug.Log("Client disconnected from server, Player ID: " + i);

        // Send Most Recently Disconnected User ID to all Connected Users
        PlayerDisconnectMsg pdMsg = new PlayerDisconnectMsg();

        for (int dcID = 0; dcID < m_Connections.Length; dcID++)
        {
            if (i.ToString() != ConnectedList.GameState[dcID].id)
            {
                pdMsg.player.id = i.ToString();
                SendToClient(JsonUtility.ToJson(pdMsg), m_Connections[dcID]);
            }
        }

        ConnectedList.GameState.RemoveAt(i);
        m_Connections[i] = default(NetworkConnection);
    }
Beispiel #5
0
    void OnDisconnect(int i)
    {
        Debug.Log("Client disconnected from server");
        m_Connections[i] = default(NetworkConnection);

        PlayerDisconnectMsg pdMsg = new PlayerDisconnectMsg();

        Debug.Log("Player Disconnect ID: " + clientList[i].id);
        pdMsg.connectionID = clientList[i].id;
        for (int j = 0; j < m_Connections.Length; j++)
        {
            if (!m_Connections[j].IsCreated)
            {
                continue;
            }

            SendToClient(JsonUtility.ToJson(pdMsg), m_Connections[j]);
        }

        clientList.RemoveAt(i);
        Destroy(cubeList[i].cube);
        cubeList.RemoveAt(i);
    }
Beispiel #6
0
    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.CONNECTION_APPROVED:     // SELF
            ConnectionApprovedMsg cpMsg = JsonUtility.FromJson <ConnectionApprovedMsg>(recMsg);
            Debug.Log("Connection Approved message received!");

            foreach (NetworkObjects.NetworkPlayer player in cpMsg.player)
            {
                Debug.Log("Our Internal ID: " + player.id);
                Debug.Log("Color R: " + player.cubeColor.r + " Color G: " + player.cubeColor.g + " Color B: " + player.cubeColor.b);
                Debug.Log("Pos X: " + player.cubPos.x + " Pos Y: " + player.cubPos.y + " Pos Z: " + player.cubPos.z);

                newPlayers.Add(player.id);
                myAddress = player.id;
            }
            break;

        case Commands.PLAYER_CONNECTED:     // Everyone else
            PlayerConnectedMsg pcMsg = JsonUtility.FromJson <PlayerConnectedMsg>(recMsg);
            Debug.Log("Player Connected message received!");

            foreach (NetworkObjects.NetworkPlayer player in pcMsg.player)
            {
                //Debug.Log("Our Internal ID: " + player.id);
                //Debug.Log("Color R: " + player.cubeColor.r + " Color G: " + player.cubeColor.g + " Color B: " + player.cubeColor.b);
                //Debug.Log("Pos X: " + player.cubPos.x + " Pos Y: " + player.cubPos.y + " Pos Z: " + player.cubPos.z);

                newPlayers.Add(player.id);
            }
            break;

        case Commands.PLAYER_DISCONNECTED:
            PlayerDisconnectMsg pdMsg = JsonUtility.FromJson <PlayerDisconnectMsg>(recMsg);
            Debug.Log("Player disconnect message received! User ID: " + pdMsg.player.id);
            droppedPlayers.Add(pdMsg.player.id);
            break;

        case Commands.PLAYER_UPDATE:
            PlayerUpdateMsg puMsg = JsonUtility.FromJson <PlayerUpdateMsg>(recMsg);
            Debug.Log("Player update message received!");
            break;

        case Commands.GAMESTATE:
            GameStateMsg gsMsg = JsonUtility.FromJson <GameStateMsg>(recMsg);
            Debug.Log("Game State update message received!");
            lastestGameState = gsMsg;
            for (int i = 0; i < lastestGameState.GameState.Count; i++)
            {
                Debug.Log("Game State ID: " + lastestGameState.GameState[i].id + " RGB: " + lastestGameState.GameState[i].cubeColor + "Pos: " + lastestGameState.GameState[i].cubPos);
            }


            break;

        case Commands.SERVER_UPDATE:     // Gives The Player List Already In Server
            ServerUpdateMsg suMsg = JsonUtility.FromJson <ServerUpdateMsg>(recMsg);
            Debug.Log("Server update message received!");
            for (int i = 0; i < suMsg.players.Count; i++)
            {
                Debug.Log("PlayerList: " + suMsg.players[i].id);
            }

            initialSetofPlayers = suMsg;

            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.HANDSHAKE:
            HandshakeMsg hsMsg = JsonUtility.FromJson <HandshakeMsg>(recMsg);
            Debug.Log("Handshake message received!");
            break;

        case Commands.PLAYER_UPDATE:
            PlayerUpdateMsg puMsg = JsonUtility.FromJson <PlayerUpdateMsg>(recMsg);
            Debug.Log("Player update message received!");
            break;

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

            if (playerList.Count == 0)
            {
                playerList = suMsg.players;
                foreach (NetworkObjects.NetworkPlayer p in playerList)
                {
                    CreateCube(p);
                }
            }
            else
            {
                foreach (NetworkObjects.NetworkPlayer npServer in suMsg.players)
                {
                    int ind = GetIndex(npServer.id);

                    if (ind >= playerList.Count)
                    {
                        playerList.Add(npServer);
                        CreateCube(npServer);
                    }
                    else
                    {
                        playerList[ind] = npServer;
                        cubeList[ind].cube.transform.position = npServer.cubePos;
                    }
                }
            }
            break;

        case Commands.INITIALIZE:
            InitializeConnectionMsg icMsg = JsonUtility.FromJson <InitializeConnectionMsg>(recMsg);
            connectedID = int.Parse(icMsg.connectionID);
            Debug.Log("Initialize Connection message received!");
            Debug.Log("Connected ID of " + connectedID);
            break;

        case Commands.PLAYER_DISCONNECT:
            PlayerDisconnectMsg pdMsg = JsonUtility.FromJson <PlayerDisconnectMsg>(recMsg);
            Debug.Log("Player disconnect message received!");

            int index = GetIndex(pdMsg.connectionID);

            playerList.RemoveAt(index);
            Destroy(cubeList[index].cube);
            cubeList.RemoveAt(index);
            break;

        default:
            Debug.Log("Unrecognized message received!");
            break;
        }
    }
Beispiel #8
0
    void OnData(DataStreamReader stream, int i)
    {
        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.HANDSHAKE:
            HandshakeMsg hsMsg = JsonUtility.FromJson <HandshakeMsg>(recMsg);
            Debug.Log("Handshake message received!");
            break;

        case Commands.PLAYER_UPDATE:
            PlayerUpdateMsg puMsg = JsonUtility.FromJson <PlayerUpdateMsg>(recMsg);
            Debug.Log("Player update message received!");

            int index = 0;
            foreach (NetworkObjects.NetworkPlayer p in clientList)
            {
                if (puMsg.player.id == p.id)
                {
                    break;
                }
                index++;
            }
            clientList[index].cubePos = puMsg.player.cubePos;
            cubeList[index].cube.transform.position = puMsg.player.cubePos;
            Debug.Log("New Cube Position: " + clientList[index].cubePos);

            ServerUpdateMsg sMsg = new ServerUpdateMsg();
            sMsg.players = clientList;
            for (int j = 0; j < m_Connections.Length; j++)
            {
                if (!m_Connections[j].IsCreated)
                {
                    continue;
                }

                SendToClient(JsonUtility.ToJson(sMsg), m_Connections[j]);
            }
            break;

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

        case Commands.INITIALIZE:
            InitializeConnectionMsg icMsg = JsonUtility.FromJson <InitializeConnectionMsg>(recMsg);
            Debug.Log("Initialize Connection message received!");
            break;

        case Commands.PLAYER_DISCONNECT:
            PlayerDisconnectMsg pdMsg = new PlayerDisconnectMsg();
            Debug.Log("Player disconnect message received!");
            break;

        default:
            Debug.Log("SERVER ERROR: Unrecognized message received!");
            break;
        }
    }