static public byte[] Serialize(MultiplayerAction action)
 {
     byte[] data = new byte[1 + action.extraData.Length];
     data[0] = (byte)action.action;
     Array.ConstrainedCopy(action.extraData, 0, data, 1, action.extraData.Length);
     return(data);
 }
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--;
                    }
                }
            }
        }
Beispiel #3
0
 public void SendToEveryone(MultiplayerAction action, int idClientToIgnore)
 {
     foreach (MultiplayerClient client in clients)
     {
         if (client.id != idClientToIgnore && client.id >= 0)
         {
             client.AddAction(action);
         }
     }
 }
        static public MultiplayerAction Deserialize(byte[] data)
        {
            MultiplayerAction.Action action = (MultiplayerAction.Action)data[0];
            byte[] extraData = new byte[data.Length - 1];
            Array.ConstrainedCopy(data, 1, extraData, 0, extraData.Length);

            MultiplayerAction ma = new MultiplayerAction(action, extraData);

            return(ma);
        }
Beispiel #5
0
 public void SendToOne(MultiplayerAction action, int idClient)
 {
     foreach (MultiplayerClient client in clients)
     {
         if (client.id == idClient)
         {
             client.AddAction(action);
             break;
         }
     }
 }
Beispiel #6
0
 public void AddAction(MultiplayerAction action)
 {
     actionsQueue.Add(action);
 }