public void HandleMessage(IServerMessageBase msg)
{
if (!(msg.Data is FacilityBaseMsgData msgData))
{
return;
}
var destructibleFacility = Object.FindObjectsOfType <DestructibleBuilding>().FirstOrDefault(o => o.id == msgData.ObjectId);
if (destructibleFacility != null)
{
switch (msgData.FacilityMessageType)
{
case FacilityMessageType.Repair:
System.DestroyedFacilities.Remove(destructibleFacility.id);
System.RepairFacilityWithoutSendingMessage(destructibleFacility);
break;
case FacilityMessageType.Collapse:
System.DestroyedFacilities.Add(destructibleFacility.id);
System.CollapseFacilityWithoutSendingMessage(destructibleFacility);
break;
}
}
}
public void HandleMessage(IServerMessageBase msg)
{
if (!(msg.Data is KerbalBaseMsgData msgData))
{
return;
}
switch (msgData.KerbalMessageType)
{
case KerbalMessageType.Remove:
System.KerbalsToRemove.Enqueue(((KerbalRemoveMsgData)msgData).KerbalName);
break;
case KerbalMessageType.Reply:
HandleKerbalReply(msgData as KerbalReplyMsgData);
break;
case KerbalMessageType.Proto:
HandleKerbalProto(msgData as KerbalProtoMsgData);
break;
default:
LunaLog.LogError("[LMP]: Invalid Kerbal message type");
break;
}
}
public void HandleMessage(IServerMessageBase msg)
{
if (!(msg.Data is VesselEvaMsgData msgData) || !System.EvaSystemReady)
{
return;
}
//We received a msg for our own controlled vessel so ignore it
if (LockSystem.LockQuery.ControlLockBelongsToPlayer(msgData.VesselId, SettingsSystem.CurrentSettings.PlayerName))
{
return;
}
//Vessel might exist in the store but not in game (if the vessel is in safety bubble for example)
VesselsProtoStore.UpdateVesselProtoEvaFsm(msgData);
var vessel = FlightGlobals.FindVessel(msgData.VesselId);
if (vessel == null || !vessel.isEVA)
{
return;
}
try
{
System.RunEvent(vessel, msgData.NewState, msgData.EventToRun);
}
catch (Exception)
{
//Ignore the eva animation errors
}
}
public void HandleMessage(IServerMessageBase msg)
{
if (!(msg.Data is VesselUpdateMsgData msgData) || !System.UpdateSystemReady)
{
return;
}
//We received a msg for our own controlled/updated vessel so ignore it
if (!VesselCommon.DoVesselChecks(msgData.VesselId))
{
return;
}
//Vessel might exist in the store but not in game (if the vessel is in safety bubble for example)
VesselsProtoStore.UpdateVesselProtoValues(msgData);
var vessel = FlightGlobals.FindVessel(msgData.VesselId);
if (vessel == null)
{
return;
}
UpdateVesselFields(vessel, msgData);
UpdateActionGroups(vessel, msgData);
UpdateProtoVesselValues(vessel.protoVessel, msgData);
}
public static VesselPositionUpdate CreateFromMessage(IServerMessageBase msg)
{
if (!(msg.Data is VesselPositionMsgData msgData))
{
return(null);
}
var upd = new VesselPositionUpdate
{
VesselId = msgData.VesselId,
BodyIndex = msgData.BodyIndex,
HeightFromTerrain = msgData.HeightFromTerrain,
TimeStamp = msgData.TimeStamp
};
Array.Copy(msgData.SrfRelRotation, upd.SrfRelRotation, 4);
Array.Copy(msgData.TransformPosition, upd.TransformPosition, 3);
Array.Copy(msgData.Velocity, upd.Velocity, 3);
Array.Copy(msgData.LatLonAlt, upd.LatLonAlt, 3);
Array.Copy(msgData.Com, upd.Com, 3);
Array.Copy(msgData.NormalVector, upd.NormalVector, 3);
Array.Copy(msgData.Orbit, upd.Orbit, 8);
return(upd);
}
public void SendMessageToClient(ClientStructure client, IServerMessageBase message)
{
if (message.MessageType == ServerMessageType.SyncTime)
{
SyncTimeSystem.RewriteMessage(client, message);
}
message.Data.SentTime = DateTime.UtcNow.Ticks;
var messageBytes = message.Serialize(GeneralSettings.SettingsStore.CompressionEnabled);
if (messageBytes == null)
{
LunaLog.Error("Error serializing message!");
return;
}
client.LastSendTime = ServerContext.ServerClock.ElapsedMilliseconds;
client.BytesSent += messageBytes.Length;
var outmsg = Server.CreateMessage(messageBytes.Length);
outmsg.Write(messageBytes);
Server.SendMessage(outmsg, client.Connection, message.NetDeliveryMethod, message.Channel);
Server.FlushSendQueue(); //Manually force to send the msg
}
public void HandleMessage(IServerMessageBase msg)
{
if (!(msg.Data is AdminBaseMsgData msgData))
{
return;
}
switch (msgData.AdminMessageType)
{
case AdminMessageType.ListReply:
{
var data = (AdminListReplyMsgData)msgData;
for (var i = 0; i < data.AdminsNum; i++)
{
System.RegisterServerAdmin(data.Admins[i]);
}
MainSystem.NetworkState = ClientState.AdminsSynced;
}
break;
case AdminMessageType.Add:
{
var data = (AdminAddMsgData)msgData;
System.RegisterServerAdmin(data.PlayerName);
}
break;
case AdminMessageType.Remove:
{
var data = (AdminRemoveMsgData)msgData;
System.UnregisterServerAdmin(data.PlayerName);
}
break;
}
}
public void HandleMessage(IServerMessageBase msg)
{
if (!(msg.Data is VesselFairingMsgData msgData) || !System.FairingSystemReady)
{
return;
}
//Vessel might exist in the store but not in game (if the vessel is in safety bubble for example)
VesselsProtoStore.UpdateVesselProtoPartFairing(msgData);
var vessel = FlightGlobals.FindVessel(msgData.VesselId);
if (vessel == null)
{
return;
}
var part = VesselCommon.FindProtoPartInProtovessel(vessel.protoVessel, msgData.PartFlightId);
if (part != null)
{
var module = VesselCommon.FindProtoPartModuleInProtoPart(part, "ModuleProceduralFairing");
module?.moduleValues.SetValue("fsm", "st_flight_deployed");
module?.moduleValues.RemoveNodesStartWith("XSECTION");
(module?.moduleRef as ModuleProceduralFairing)?.DeployFairing();
}
}
public void HandleMessage(IServerMessageBase msg)
{
if (!(msg.Data is ScenarioBaseMsgData msgData))
{
return;
}
if (msgData.ScenarioMessageType == ScenarioMessageType.Data)
{
var data = (ScenarioDataMsgData)msgData;
for (var i = 0; i < data.ScenarioCount; i++)
{
var scenarioNode = ConfigNodeSerializer.Deserialize(data.ScenariosData[i].Data, data.ScenariosData[i].NumBytes);
if (scenarioNode != null)
{
var entry = new ScenarioEntry
{
ScenarioName = data.ScenariosData[i].Module,
ScenarioNode = scenarioNode
};
System.ScenarioQueue.Enqueue(entry);
}
else
{
LunaLog.LogError($"[LMP]: Scenario data has been lost for {data.ScenariosData[i].Module}");
ScreenMessages.PostScreenMessage($"Scenario data has been lost for {data.ScenariosData[i].Module}", 5f, ScreenMessageStyle.UPPER_CENTER);
}
}
MainSystem.NetworkState = ClientState.ScenariosSynced;
}
}
public void HandleMessage(IServerMessageBase msg)
{
if (!(msg.Data is FlagBaseMsgData msgData))
{
return;
}
switch (msgData.FlagMessageType)
{
case FlagMessageType.ListResponse:
{
var data = (FlagListResponseMsgData)msgData;
for (var i = 0; i < data.FlagCount; i++)
{
var extendedFlagInfo = new ExtendedFlagInfo(data.FlagFiles[i]);
System.ServerFlags.TryAdd(extendedFlagInfo.FlagName, extendedFlagInfo);
}
MainSystem.NetworkState = ClientState.FlagsSynced;
}
break;
case FlagMessageType.FlagData:
{
var data = (FlagDataMsgData)msgData;
var extendedFlagInfo = new ExtendedFlagInfo(data.Flag);
System.ServerFlags.AddOrUpdate(extendedFlagInfo.FlagName, extendedFlagInfo, (key, existingVal) => extendedFlagInfo);
}
break;
}
}
public static VesselPositionUpdate UpdateFromMessage(IServerMessageBase msg, VesselPositionUpdate update)
{
if (!(msg.Data is VesselPositionMsgData msgData))
{
return(null);
}
update.VesselId = msgData.VesselId;
update.BodyIndex = msgData.BodyIndex;
update.HeightFromTerrain = msgData.HeightFromTerrain;
update.SentTimeStamp = msgData.TimeStamp;
update.ReceiveTimeStamp = msgData.ReceiveTime;
update.GameTimeStamp = msgData.GameTime;
Array.Copy(msgData.SrfRelRotation, update.SrfRelRotation, 4);
Array.Copy(msgData.TransformPosition, update.TransformPosition, 3);
Array.Copy(msgData.Velocity, update.Velocity, 3);
Array.Copy(msgData.OrbitPos, update.OrbitPos, 3);
Array.Copy(msgData.OrbitVel, update.OrbitVel, 3);
Array.Copy(msgData.LatLonAlt, update.LatLonAlt, 3);
Array.Copy(msgData.NormalVector, update.NormalVector, 3);
Array.Copy(msgData.Orbit, update.Orbit, 8);
return(update);
}
public void HandleMessage(IServerMessageBase msg)
{
if (!(msg.Data is ModMsgData msgData))
{
return;
}
var modName = msgData.ModName;
//Clone it as after that the mesage will be recycled
//TODO: can this be improved to avoid garbage?
var modData = Common.TrimArray(msgData.Data, msgData.NumBytes);
lock (System.EventLock)
{
if (System.UpdateQueue.ContainsKey(modName))
{
System.UpdateQueue[modName].Enqueue(modData);
}
if (System.FixedUpdateQueue.ContainsKey(modName))
{
System.FixedUpdateQueue[modName].Enqueue(modData);
}
if (System.RegisteredRawMods.ContainsKey(modName))
{
System.RegisteredRawMods[modName](modData);
}
}
}
public void HandleMessage(IServerMessageBase msg)
{
if (!(msg.Data is VesselPositionMsgData msgData))
{
return;
}
var vesselId = msgData.VesselId;
if (!VesselCommon.DoVesselChecks(vesselId))
{
return;
}
if (!VesselPositionSystem.CurrentVesselUpdate.ContainsKey(vesselId))
{
VesselPositionSystem.CurrentVesselUpdate.TryAdd(vesselId, new VesselPositionUpdate(msgData));
VesselPositionSystem.TargetVesselUpdateQueue.TryAdd(vesselId, new PositionUpdateQueue());
}
else
{
VesselPositionSystem.TargetVesselUpdateQueue.TryGetValue(vesselId, out var queue);
queue?.Enqueue(msgData);
}
}
public void HandleMessage(IServerMessageBase msg)
{
if (!(msg.Data is VesselDecoupleMsgData msgData))
{
return;
}
//We received a msg for our own controlled/updated vessel so ignore it
if (!VesselCommon.DoVesselChecks(msgData.VesselId))
{
return;
}
if (!System.VesselDecouples.ContainsKey(msgData.VesselId))
{
System.VesselDecouples.TryAdd(msgData.VesselId, new VesselDecoupleQueue());
}
if (System.VesselDecouples.TryGetValue(msgData.VesselId, out var queue))
{
if (queue.TryPeek(out var value) && value.GameTime > msgData.GameTime)
{
//A user reverted, so clear his message queue and start from scratch
queue.Clear();
}
queue.Enqueue(msgData);
}
}
public void HandleMessage(IServerMessageBase msg)
{
if (!(msg.Data is VesselPositionMsgData msgData))
{
return;
}
var vesselId = msgData.VesselId;
if (!VesselCommon.DoVesselChecks(vesselId))
{
return;
}
if (VesselPositionSystem.CurrentVesselUpdate.TryGetValue(vesselId, out var currentUpdate) && currentUpdate.GameTimeStamp > msgData.GameTime)
{
//A user reverted, so clear it and start from scratch
System.RemoveVessel(vesselId);
}
if (!VesselPositionSystem.CurrentVesselUpdate.ContainsKey(vesselId))
{
VesselPositionSystem.CurrentVesselUpdate.TryAdd(vesselId, new VesselPositionUpdate(msgData));
VesselPositionSystem.TargetVesselUpdateQueue.TryAdd(vesselId, new PositionUpdateQueue());
}
else
{
VesselPositionSystem.TargetVesselUpdateQueue.TryGetValue(vesselId, out var queue);
queue?.Enqueue(msgData);
}
}
private static void SendToClient(ClientStructure client, IServerMessageBase msg)
{
if (msg.Data == null)
{
return;
}
client.SendMessageQueue.Enqueue(msg);
}
public void HandleMessage(IServerMessageBase msg)
{
if (!(msg.Data is ChatMsgData msgData))
{
return;
}
System.NewChatMessages.Enqueue(new Tuple <string, string>(msgData.From, msgData.Text));
}
private static void SendToClient(ClientStructure client, IServerMessageBase msg)
{
if (msg?.Data == null)
{
return;
}
LidgrenServer.SendMessageToClient(client, msg);
}
public void HandleMessage(IServerMessageBase msg)
{
if (!(msg.Data is VesselDockMsgData msgData))
{
return;
}
LunaLog.Log("Docking message received!");
//Add the new vessel data to the store
VesselsProtoStore.HandleVesselProtoData(msgData.FinalVesselData, msgData.NumBytes, msgData.DominantVesselId);
if (FlightGlobals.ActiveVessel?.id == msgData.WeakVesselId)
{
LunaLog.Log($"Docking NOT detected. We DON'T OWN the dominant vessel. Switching to {msgData.DominantVesselId}");
SystemsContainer.Get <VesselRemoveSystem>().AddToKillList(FlightGlobals.ActiveVessel.id);
SystemsContainer.Get <VesselSwitcherSystem>().SwitchToVessel(msgData.DominantVesselId);
WarpSystem.WarpIfSubspaceIsMoreAdvanced(msgData.SubspaceId);
}
if (FlightGlobals.ActiveVessel?.id == msgData.DominantVesselId && !VesselCommon.IsSpectating)
{
var newProto = VesselSerializer.DeserializeVessel(msgData.FinalVesselData, msgData.NumBytes);
/* This is a strange case were we didn't detect the docking on time and the weak vessel send the new definition...
* Usually it happens when a vessel in a future subspace docks with a vessel in the past and the vessel in the past is the dominant vessel
* The reason why is bad is because the ModuleDockingNode sent by the WEAK vessel will tell us that we are
* NOT the dominant (because we received the vesselproto from the WEAK vessel) so we won't be able to undock properly...
* This will be fixed if we go to the space center and reload again the vessel...
*/
LunaLog.Log("Docking NOT detected. We OWN the dominant vessel");
if (FlightGlobals.FindVessel(msgData.WeakVesselId) != null)
{
LunaLog.Log($"Weak vessel {msgData.WeakVesselId} still exists in our game. Removing it now");
SystemsContainer.Get <VesselRemoveSystem>().AddToKillList(msgData.WeakVesselId);
SystemsContainer.Get <VesselRemoveSystem>().KillVessel(msgData.WeakVesselId);
}
/* We own the dominant vessel and dind't detected the docking event so we need to reload our OWN vessel
* so if we send our own protovessel later, we send the updated definition
*/
LunaLog.Log($"Creating the missing parts in our own vessel. Current: {FlightGlobals.ActiveVessel.parts.Count} Expected: {newProto.protoPartSnapshots.Count}");
//ProtoToVesselRefresh.CreateMissingPartsInCurrentProtoVessel(FlightGlobals.ActiveVessel, newProto);
VesselLoader.ReloadVessel(newProto);
LunaLog.Log("Force sending the new proto vessel");
SystemsContainer.Get <VesselProtoSystem>().MessageSender.SendVesselMessage(FlightGlobals.ActiveVessel, true);
WarpSystem.WarpIfSubspaceIsMoreAdvanced(msgData.SubspaceId);
return;
}
//Some other 2 players docked so just remove the weak vessel.
SystemsContainer.Get <VesselRemoveSystem>().AddToKillList(msgData.WeakVesselId);
}
public void HandleMessage(IServerMessageBase msg)
{
if (!(msg.Data is ChatMsgData msgData))
{
return;
}
sb.Length = 0;
sb.Append(msgData.From).Append(": ").Append(msgData.Text);
System.NewChatMessages.Enqueue(new Tuple <string, string, string>(msgData.From, msgData.Text, sb.ToString()));
}
public void HandleMessage(IServerMessageBase msg)
{
if (!(msg.Data is ModMsgData msgData))
{
return;
}
var modData = Common.TrimArray(msgData.Data, msgData.NumBytes);
ModApiEvent.onModMessageReceived.Fire(msgData.ModName, modData);
}
//Write the send times down in SYNC_TIME_REPLY packets
public static void RewriteMessage(ClientStructure client, IServerMessageBase message)
{
try
{
((SyncTimeReplyMsgData)message.Data).ServerSendTime = DateTime.UtcNow.Ticks;
}
catch (Exception e)
{
LunaLog.Debug("Error rewriting SYNC_TIME packet, Exception " + e);
}
}
public virtual void EnqueueMessage(IServerMessageBase msg)
{
if (ProcessMessagesInUnityThread)
{
MessageHandler.IncomingMessages.Enqueue(msg);
}
else
{
TaskFactory.StartNew(() => HandleMessage(msg));
}
}
private void HandleMessage(IServerMessageBase msg)
{
try
{
MessageHandler.HandleMessage(msg);
}
catch (Exception e)
{
LunaLog.LogError($"[LMP]: Error handling Message type {msg.Data.GetType()}, exception: {e}");
NetworkConnection.Disconnect($"Error handling {msg.Data.GetType()} Message");
}
}
public void HandleMessage(IServerMessageBase msg)
{
if (!(msg.Data is MotdReplyMsgData msgData))
{
return;
}
if (!string.IsNullOrEmpty(msgData.MessageOfTheDay))
{
LunaScreenMsg.PostScreenMessage(msgData.MessageOfTheDay, 30f, ScreenMessageStyle.UPPER_CENTER);
}
}
public void HandleMessage(IServerMessageBase msg)
{
if (!(msg.Data is VesselFlightStateMsgData msgData))
{
return;
}
if (System.FlightStatesDictionary.TryGetValue(msgData.VesselId, out var existingFlightState))
{
existingFlightState.SetTarget(msgData);
}
}
public void HandleMessage(IServerMessageBase msg)
{
if (!(msg.Data is VesselPositionMsgData msgData))
{
return;
}
var vesselId = msgData.VesselId;
//Ignore vessel updates for our own controlled vessel
if (LockSystem.LockQuery.ControlLockBelongsToPlayer(vesselId, SettingsSystem.CurrentSettings.PlayerName))
{
return;
}
//Ignore updates if vessel is in kill list
if (SystemsContainer.Get <VesselRemoveSystem>().VesselWillBeKilled(vesselId))
{
return;
}
//Vessel might exist in the store but not in game (if the vessel is in safety bubble for example)
VesselsProtoStore.UpdateVesselProtoPosition(msgData);
if (!VesselPositionSystem.CurrentVesselUpdate.TryGetValue(vesselId, out var existingPositionUpdate))
{
VesselPositionSystem.CurrentVesselUpdate.TryAdd(vesselId, MessageToPositionTransfer.CreateFromMessage(msg));
VesselPositionSystem.TargetVesselUpdate.TryAdd(vesselId, MessageToPositionTransfer.CreateFromMessage(msg));
}
else
{
//Here we check that the message timestamp is lower than the message we received. UDP is not reliable and can deliver packets not in order!
//Also we only process messages if the interpolation is finished
if (existingPositionUpdate.TimeStamp < msgData.TimeStamp &&
VesselPositionSystem.TargetVesselUpdate.TryGetValue(vesselId, out var existingTargetPositionUpdate) && existingTargetPositionUpdate.TimeStamp < msgData.TimeStamp)
{
if (SettingsSystem.CurrentSettings.InterpolationEnabled)
{
//Here we set the start position to the current VESSEL position in order to LERP correctly
existingPositionUpdate.Restart();
}
else
{
//Here we just set the interpolation as not started
existingPositionUpdate.ResetFields();
}
//Overwrite the TARGET data with the data we've received in the message
MessageToPositionTransfer.UpdateFromMessage(msg, existingTargetPositionUpdate);
}
}
}
public void HandleMessage(IServerMessageBase msg)
{
if (!(msg.Data is ScreenshotBaseMsgData msgData))
{
return;
}
switch (msgData.ScreenshotMessageType)
{
case ScreenshotMessageType.ScreenshotData:
var screenshotMsg = (ScreenshotDataMsgData)msgData;
var image = CreateImage(screenshotMsg.Screenshot.DateTaken, screenshotMsg.Screenshot.Width, screenshotMsg.Screenshot.Height,
screenshotMsg.Screenshot.Data, screenshotMsg.Screenshot.NumBytes);
if (System.DownloadedImages.TryGetValue(screenshotMsg.Screenshot.FolderName, out var folderImages))
{
folderImages.AddOrUpdate(screenshotMsg.Screenshot.DateTaken, image, (key, existingVal) => image);
}
break;
case ScreenshotMessageType.FoldersReply:
var foldersMsg = (ScreenshotFoldersReplyMsgData)msgData;
for (var i = 0; i < foldersMsg.NumFolders; i++)
{
System.DownloadedImages.TryAdd(foldersMsg.Folders[i], new ConcurrentDictionary <long, Screenshot>());
System.MiniatureImages.TryAdd(foldersMsg.Folders[i], new ConcurrentDictionary <long, Screenshot>());
}
break;
case ScreenshotMessageType.ListReply:
var listMsg = (ScreenshotListReplyMsgData)msgData;
if (System.MiniatureImages.TryGetValue(listMsg.FolderName, out var folderMiniatureImages))
{
for (var i = 0; i < listMsg.NumScreenshots; i++)
{
var miniImage = CreateImage(listMsg.Screenshots[i].DateTaken, listMsg.Screenshots[i].Width, listMsg.Screenshots[i].Height,
listMsg.Screenshots[i].Data, listMsg.Screenshots[i].NumBytes);
folderMiniatureImages.AddOrUpdate(listMsg.Screenshots[i].DateTaken, miniImage, (key, existingVal) => miniImage);
}
}
break;
case ScreenshotMessageType.Notification:
var notificationMsg = (ScreenshotNotificationMsgData)msgData;
System.FoldersWithNewContent.Add(notificationMsg.FolderName);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public void SendMessageToClient(ClientStructure client, IServerMessageBase message)
{
var outmsg = Server.CreateMessage(message.GetMessageSize());
message.Data.SentTime = LunaTime.UtcNow.Ticks;
message.Serialize(outmsg);
client.LastSendTime = ServerContext.ServerClock.ElapsedMilliseconds;
client.BytesSent += outmsg.LengthBytes;
var sendResult = Server.SendMessage(outmsg, client.Connection, message.NetDeliveryMethod, message.Channel);
Server.FlushSendQueue(); //Manually force to send the msg
}
public void HandleMessage(IServerMessageBase msg)
{
if (!(msg.Data is MotdReplyMsgData msgData))
{
return;
}
if (!string.IsNullOrEmpty(msgData.MessageOfTheDay))
{
System.DisplayMotd = true;
System.ServerMotd = msgData.MessageOfTheDay;
ChatSystem.Singleton.Queuer.QueueChannelMessage(SettingsSystem.ServerSettings.ConsoleIdentifier, "", msgData.MessageOfTheDay);
}
}
