C# MessageWriter.GetMessageBytes方法代码示例

 public static void SendScenarioModules(ClientObject client)
 {
     int numberOfScenarioModules = Directory.GetFiles(Path.Combine(Server.universeDirectory, "Scenarios", client.playerName)).Length;
     int currentScenarioModule = 0;
     string[] scenarioNames = new string[numberOfScenarioModules];
     byte[][] scenarioDataArray = new byte[numberOfScenarioModules][];
     foreach (string file in Directory.GetFiles(Path.Combine(Server.universeDirectory, "Scenarios", client.playerName)))
     {
         //Remove the .txt part for the name
         scenarioNames[currentScenarioModule] = Path.GetFileNameWithoutExtension(file);
         scenarioDataArray[currentScenarioModule] = File.ReadAllBytes(file);
         currentScenarioModule++;
     }
     ServerMessage newMessage = new ServerMessage();
     newMessage.type = ServerMessageType.SCENARIO_DATA;
     using (MessageWriter mw = new MessageWriter())
     {
         mw.Write<string[]>(scenarioNames);
         foreach (byte[] scenarioData in scenarioDataArray)
         {
             if (client.compressionEnabled)
             {
                 mw.Write<byte[]>(Compression.CompressIfNeeded(scenarioData));
             }
             else
             {
                 mw.Write<byte[]>(Compression.AddCompressionHeader(scenarioData, false));
             }
         }
         newMessage.data = mw.GetMessageBytes();
     }
     ClientHandler.SendToClient(client, newMessage, true);
 }

 public static void SendAllPlayerColors(ClientObject client)
 {
     Dictionary<string,float[]> sendColors = new Dictionary<string, float[]>();
     foreach (ClientObject otherClient in ClientHandler.GetClients())
     {
         if (otherClient.authenticated && otherClient.playerColor != null)
         {
             if (otherClient != client)
             {
                 sendColors[otherClient.playerName] = otherClient.playerColor;
             }
         }
     }
     ServerMessage newMessage = new ServerMessage();
     newMessage.type = ServerMessageType.PLAYER_COLOR;
     using (MessageWriter mw = new MessageWriter())
     {
         mw.Write<int>((int)PlayerColorMessageType.LIST);
         mw.Write<int>(sendColors.Count);
         foreach (KeyValuePair<string, float[]> kvp in sendColors)
         {
             mw.Write<string>(kvp.Key);
             mw.Write<float[]>(kvp.Value);
         }
         newMessage.data = mw.GetMessageBytes();
     }
     ClientHandler.SendToClient(client, newMessage, true);
 }

 public void Load()
 {
     if (savedVessel != null && savedSubspace != null)
     {
         if ((UnityEngine.Time.realtimeSinceStartup - lastLoadTime) > 5f)
         {
             lastLoadTime = UnityEngine.Time.realtimeSinceStartup;
             TimeSyncer.fetch.UnlockSubspace();
             long serverClock = TimeSyncer.fetch.GetServerClock();
             int newSubspace = TimeSyncer.fetch.LockNewSubspace(serverClock, savedSubspace.planetTime, savedSubspace.subspaceSpeed);
             using (MessageWriter mw = new MessageWriter())
             {
                 mw.Write<int>((int)WarpMessageType.NEW_SUBSPACE);
                 mw.Write<string>(Settings.fetch.playerName);
                 mw.Write<int>(newSubspace);
                 mw.Write<long>(serverClock);
                 mw.Write<double>(savedSubspace.planetTime);
                 mw.Write<float>(savedSubspace.subspaceSpeed);
                 NetworkWorker.fetch.SendWarpMessage(mw.GetMessageBytes());
             }
             TimeSyncer.fetch.LockSubspace(newSubspace);
             VesselWorker.fetch.LoadVessel(savedVessel);
             ScreenMessages.PostScreenMessage("Quickloaded!", 3f, ScreenMessageStyle.UPPER_CENTER);
         }
     }
     else
     {
         ScreenMessages.PostScreenMessage("No current quicksave to load from!", 3f, ScreenMessageStyle.UPPER_CENTER);
     }
 }

 public static void RunNukeKSC(string commandText)
 {
     lock (Server.universeSizeLock)
     {
         string[] vesselList = Directory.GetFiles(Path.Combine(Server.universeDirectory, "Vessels"));
         int numberOfRemovals = 0;
         foreach (string vesselFile in vesselList)
         {
             string vesselID = Path.GetFileNameWithoutExtension(vesselFile);
             bool landedAtKSC = false;
             bool landedAtRunway = false;
             using (StreamReader sr = new StreamReader(vesselFile))
             {
                 string currentLine = sr.ReadLine();
                 while (currentLine != null && !landedAtKSC && !landedAtRunway)
                 {
                     string trimmedLine = currentLine.Trim();
                     if (trimmedLine.StartsWith("landedAt = "))
                     {
                         string landedAt = trimmedLine.Substring(trimmedLine.IndexOf("=") + 2);
                         if (landedAt == "KSC")
                         {
                             landedAtKSC = true;
                         }
                         if (landedAt == "Runway")
                         {
                             landedAtRunway = true;
                         }
                     }
                     currentLine = sr.ReadLine();
                 }
             }
             if (landedAtKSC | landedAtRunway)
             {
                 DarkLog.Normal("Removing vessel: " + vesselID);
                 //Delete it from the universe
                 if (File.Exists(vesselFile))
                 {
                     File.Delete(vesselFile);
                 }
                 //Send a vessel remove message
                 ServerMessage newMessage = new ServerMessage();
                 newMessage.type = ServerMessageType.VESSEL_REMOVE;
                 using (MessageWriter mw = new MessageWriter())
                 {
                     //Send it with a delete time of 0 so it shows up for all players.
                     mw.Write<int>(0);
                     mw.Write<double>(0);
                     mw.Write<string>(vesselID);
                     mw.Write<bool>(false);
                     newMessage.data = mw.GetMessageBytes();
                 }
                 ClientHandler.SendToAll(null, newMessage, false);
                 numberOfRemovals++;
             }
         }
         DarkLog.Normal("Nuked " + numberOfRemovals + " vessels around the KSC");
     }
 }

 public static void SendConnectionEnd(ClientObject client, string reason)
 {
     ServerMessage newMessage = new ServerMessage();
     newMessage.type = ServerMessageType.CONNECTION_END;
     using (MessageWriter mw = new MessageWriter())
     {
         mw.Write<string>(reason);
         newMessage.data = mw.GetMessageBytes();
     }
     ClientHandler.SendToClient(client, newMessage, true);
 }

 public static void SendConsoleMessageToClient(ClientObject client, string message)
 {
     ServerMessage newMessage = new ServerMessage();
     newMessage.type = ServerMessageType.CHAT_MESSAGE;
     using (MessageWriter mw = new MessageWriter())
     {
         mw.Write<int>((int)ChatMessageType.CONSOLE_MESSAGE);
         mw.Write<string>(message);
         newMessage.data = mw.GetMessageBytes();
     }
     ClientHandler.SendToClient(client, newMessage, false);
 }

 public static void SendAllAdmins(ClientObject client)
 {
     ServerMessage newMessage = new ServerMessage();
     newMessage.type = ServerMessageType.ADMIN_SYSTEM;
     using (MessageWriter mw = new MessageWriter())
     {
         mw.Write((int)AdminMessageType.LIST);
         mw.Write<string[]>(DarkMultiPlayerServer.AdminSystem.fetch.GetAdmins());
         newMessage.data = mw.GetMessageBytes();
     }
     ClientHandler.SendToClient(client, newMessage, true);
 }

 public static void SendHandshakeChallange(ClientObject client)
 {
     client.challange = new byte[1024];
     Random rand = new Random();
     rand.NextBytes(client.challange);
     ServerMessage newMessage = new ServerMessage();
     newMessage.type = ServerMessageType.HANDSHAKE_CHALLANGE;
     using (MessageWriter mw = new MessageWriter())
     {
         mw.Write<byte[]>(client.challange);
         newMessage.data = mw.GetMessageBytes();
     }
     ClientHandler.SendToClient(client, newMessage, true);
 }

 public static void SendChatMessageToClient(ClientObject client, string messageText)
 {
     ServerMessage newMessage = new ServerMessage();
     newMessage.type = ServerMessageType.CHAT_MESSAGE;
     using (MessageWriter mw = new MessageWriter())
     {
         mw.Write<int>((int)ChatMessageType.PRIVATE_MESSAGE);
         mw.Write<string>(Settings.settingsStore.consoleIdentifier);
         mw.Write<string>(client.playerName);
         mw.Write(messageText);
         newMessage.data = mw.GetMessageBytes();
     }
     ClientHandler.SendToClient(client, newMessage, true);
 }

 public void AcquireLock(string lockName, bool force)
 {
     lock (lockObject)
     {
         using (MessageWriter mw = new MessageWriter())
         {
             mw.Write<int>((int)LockMessageType.ACQUIRE);
             mw.Write<string>(Settings.fetch.playerName);
             mw.Write<string>(lockName);
             mw.Write<bool>(force);
             NetworkWorker.fetch.SendLockSystemMessage(mw.GetMessageBytes());
         }
     }
 }

 private static void SendKerbal(ClientObject client, string kerbalName, byte[] kerbalData)
 {
     ServerMessage newMessage = new ServerMessage();
     newMessage.type = ServerMessageType.KERBAL_REPLY;
     using (MessageWriter mw = new MessageWriter())
     {
         //Send the vessel with a send time of 0 so it instantly loads on the client.
         mw.Write<double>(0);
         mw.Write<string>(kerbalName);
         mw.Write<byte[]>(kerbalData);
         newMessage.data = mw.GetMessageBytes();
     }
     ClientHandler.SendToClient(client, newMessage, false);
 }

 public static void SendChatMessageToChannel(string channel, string messageText)
 {
     ServerMessage newMessage = new ServerMessage();
     newMessage.type = ServerMessageType.CHAT_MESSAGE;
     using (MessageWriter mw = new MessageWriter())
     {
         mw.Write<int>((int)ChatMessageType.CHANNEL_MESSAGE);
         mw.Write<string>(Settings.settingsStore.consoleIdentifier);
         // Channel
         mw.Write<string>(channel);
         mw.Write(messageText);
         newMessage.data = mw.GetMessageBytes();
     }
     ClientHandler.SendToAll(null, newMessage, true);
 }

        private static void SendMotdReply(ClientObject client)
        {
            ServerMessage newMessage = new ServerMessage();
            newMessage.type = ServerMessageType.MOTD_REPLY;

            string newMotd = Settings.settingsStore.serverMotd;
            newMotd = newMotd.Replace("%name%", client.playerName);
            newMotd = newMotd.Replace(@"\n", Environment.NewLine);

            using (MessageWriter mw = new MessageWriter())
            {
                mw.Write<string>(newMotd);
                newMessage.data = mw.GetMessageBytes();
            }
            ClientHandler.SendToClient(client, newMessage, true);
        }

 public void ReleaseLock(string lockName)
 {
     lock (lockObject)
     {
         using (MessageWriter mw = new MessageWriter())
         {
             mw.Write<int>((int)LockMessageType.RELEASE);
             mw.Write<string>(Settings.fetch.playerName);
             mw.Write<string>(lockName);
             NetworkWorker.fetch.SendLockSystemMessage(mw.GetMessageBytes());
         }
         if (LockIsOurs(lockName))
         {
             serverLocks.Remove(lockName);
         }
     }
 }

 private void SendCKANFileToClient(ClientObject client)
 {
     using (MessageWriter mw = new MessageWriter())
     {
         mw.Write<int>(CKAN_PROTOCOL_VERSION);
         if (!File.Exists(ckanFile))
         {
             mw.Write<bool>(false);
             byte[] sendData = mw.GetMessageBytes();
             DMPModInterface.SendDMPModMessageToClient(client, "DMPCkanPlugin", sendData, false);
             return;
         }
         mw.Write<bool>(true);
         mw.Write<string>(File.ReadAllText(ckanFile));
     }
     DarkLog.Debug("Sent CKAN file to " + client.playerName);
 }