示例#1
0
    public void ReliableReceiveCallback(byte[] buffer, int size)
    {
        // this will be called when the endpoint extracts messages from received packets
        // buffer is byte[] and size is number of bytes in the buffer.
        // do not keep a reference to buffer as it will be pooled after this function returns
        NetworkMessage.MessageType mType = NetworkMessage.ParseMessage(buffer, size);
        Log("Messge! " + mType);
        if (mType == NetworkMessage.MessageType.FindGame)
        {
            if (ServerMain.clientWaitingToMatch == null)
            {
                ServerMain.clientWaitingToMatch = this;
            }
            else
            {
                ServerMain.clientWaitingToMatch.remoteOpponent = this;
                remoteOpponent = ServerMain.clientWaitingToMatch;

                byte[] playerOneSeed = new byte[4];
                byte[] playerTwoSeed = new byte[4];
                random.NextBytes(playerOneSeed);
                random.NextBytes(playerTwoSeed);

                byte[] playerOneData = new byte[10];
                byte[] playerTwoData = new byte[10];

                BitConverter.GetBytes(
                    (UInt16)NetworkMessage.MessageType.PlayerSeeds
                    ).CopyTo(playerOneData, 0);

                playerOneData.CopyTo(playerTwoData, 0);

                playerOneSeed.CopyTo(playerOneData, 2);
                playerOneSeed.CopyTo(playerTwoData, 6);

                playerTwoSeed.CopyTo(playerOneData, 6);
                playerTwoSeed.CopyTo(playerTwoData, 2);

                reliableEndpoint.SendMessage(playerOneData, playerOneData.Length, QosType.Reliable);
                ServerMain.clientWaitingToMatch.Send(playerTwoData, playerTwoData.Length, QosType.Reliable);
                ServerMain.clientWaitingToMatch = null;
            }
        }
        else
        {
            Log("Forwarding! " + mType);
            if (remoteOpponent == null && remoteClient != null && server != null)
            {
                server.Disconnect(remoteClient);
            }
            else
            {
                if (remoteOpponent != null)
                {
                    remoteOpponent.Send(BitConverter.GetBytes((UInt16)mType), 2, QosType.Reliable);
                }
            }
        }
    }
示例#2
0
    void HandleNetworkMessage(NetworkMessage.MessageType type, byte[] buffer, int size)
    {
        Debug.Log("[client] HandleNetworkMessage " + type);
        switch (type)
        {
        case NetworkMessage.MessageType.PlayerJoined:
            break;

        case NetworkMessage.MessageType.PlayerLeft:
            break;

        case NetworkMessage.MessageType.PlayerSeeds:
            currentState = GameState.InProgress;
            int[] seeds = NetworkMessage.ParseSeedData(buffer, size);
            Debug.Log("Seeds: " + seeds[0] + "," + seeds[1]);
            playerBoard1.Reset(seeds[0]);
            playerBoard2.Reset(seeds[1]);

            playerBoard1.PlacePiece();
            playerBoard2.PlacePiece();

            updateDisplay(playerBoard1, 0);
            updateDisplay(playerBoard2, boardHeight);
            break;

        case NetworkMessage.MessageType.InputLeft:
            playerBoard2.MoveLeft();
            updateDisplay(playerBoard2, boardHeight);
            break;

        case NetworkMessage.MessageType.InputRight:
            playerBoard2.MoveRight();
            updateDisplay(playerBoard2, boardHeight);
            break;

        case NetworkMessage.MessageType.InputRotate:
            playerBoard2.Rotate();
            updateDisplay(playerBoard2, boardHeight);
            break;

        case NetworkMessage.MessageType.InputDown:
            playerBoard2.GameTick();
            updateDisplay(playerBoard2, boardHeight);
            break;

        default:
            break;
        }
    }
示例#3
0
 public void RaiseMessageEvent(NetworkMessage.MessageType msg)
 {
     Message?.Invoke(this, new NetworkMessage(msg));
 }