Beispiel #1
0
        private void SendActions()
        {
            if (currentDataToSend == null)
            {
                if (actionsQueue.Count > 0)
                {
                    List <byte> bytesToSend = new List <byte>();

                    foreach (MultiplayerAction action in actionsQueue)
                    {
                        stats.sentActions[(int)action.action]++;

                        byte[] data = MultiplayerProtocol.Serialize(action);

                        bytesToSend.Add((byte)((data.Length >> 0) & 0xFF));
                        bytesToSend.Add((byte)((data.Length >> 8) & 0xFF));
                        bytesToSend.Add((byte)((data.Length >> 16) & 0xFF));
                        bytesToSend.Add((byte)((data.Length >> 24) & 0xFF));
                        bytesToSend.AddRange(data);
                    }

                    currentDataToSend       = bytesToSend.ToArray();
                    currentDataToSendOffset = 0;

                    actionsQueue.Clear();
                }
            }

            if (currentDataToSend != null)
            {
                int bytesSent = 0;
                try
                {
                    bytesSent = tcpClient.Client.Send(currentDataToSend, currentDataToSendOffset, currentDataToSend.Length - currentDataToSendOffset, SocketFlags.None);
                }
                catch (SocketException ex)
                {
                    //Try to ignore non-serious errors
                    if (ex.SocketErrorCode != SocketError.WouldBlock &&
                        ex.SocketErrorCode != SocketError.IOPending &&
                        ex.SocketErrorCode != SocketError.NoBufferSpaceAvailable)
                    {
                        //It's a serious error.. re-throw the exception
                        throw ex;
                    }
                }

                if (bytesSent < 0)
                {
                    throw new Exception("Socket Sent Bytes < 0");
                }

                currentDataToSendOffset += bytesSent;

                if (currentDataToSendOffset == currentDataToSend.Length)
                {
                    currentDataToSend = null;
                }
            }
        }
Beispiel #2
0
        private void ReceiveActions(int limitActions)
        {
            while (tcpClient.Client.Available > 0 && limitActions > 0)
            {
                if (currentDataToReceive == null)
                {
                    if (tcpClient.Client.Available >= 4)
                    {
                        byte[] dataSizeBuffer = new byte[4];
                        tcpClient.Client.Receive(dataSizeBuffer, 0, 4, SocketFlags.None);
                        int dataSize =
                            (dataSizeBuffer[0] << 0) |
                            (dataSizeBuffer[1] << 8) |
                            (dataSizeBuffer[2] << 16) |
                            (dataSizeBuffer[3] << 24);

                        if (serverSide == true && dataSize > MAX_SERVER_SIDE_DATA_AMOUNT ||
                            serverSide == false && dataSize > MAX_CLIENT_SIDE_DATA_AMOUNT)
                        {
                            throw new Exception("Invalid amount of data to receive [" + dataSize + "]");
                        }

                        currentDataToReceive       = new byte[dataSize];
                        currentDataToReceiveOffset = 0;
                    }
                    else
                    {
                        return;
                    }
                }

                if (currentDataToReceive != null)
                {
                    int bytesRead = tcpClient.Client.Receive(currentDataToReceive, currentDataToReceiveOffset, currentDataToReceive.Length - currentDataToReceiveOffset, SocketFlags.None);
                    if (bytesRead < 0)
                    {
                        throw new Exception("Socket Read Bytes < 0");
                    }

                    currentDataToReceiveOffset += bytesRead;

                    if (currentDataToReceiveOffset == currentDataToReceive.Length)
                    {
                        MultiplayerAction action = MultiplayerProtocol.Deserialize(currentDataToReceive);

                        stats.receivedActions[(int)action.action]++;

                        clientListener.ClientActionReceived(this, action);

                        currentDataToReceive = null;

                        limitActions--;
                    }
                }
            }
        }