/// <summary>
/// This method relay the vessel update to players in other planets
/// </summary>
public static void RelayToFarPlayers()
{
while (ServerContext.ServerRunning)
{
try
{
if (IncomingFarUpdates.TryDequeue(out var vesselUpdate) && VesselsDictionary.ContainsKey(vesselUpdate.Key))
{
var farClients = VesselsDictionary.Where(v => !Equals(v.Key, vesselUpdate.Key) && v.Value != null &&
v.Value.BodyName != vesselUpdate.Value.BodyName)
.Select(v => v.Key);
foreach (var farClient in farClients.Where(c => ServerContext.Clients.ContainsKey(c.Endpoint)))
{
MessageQueuer.RelayMessage <VesselSrvMsg>(farClient, vesselUpdate.Value);
}
}
}
catch (Exception e)
{
LunaLog.Error($"Error in RelayToFarPlayers method! Details: {e}");
}
Thread.Sleep(GeneralSettings.SettingsStore.FarDistanceUpdateIntervalMs);
}
}
public static void HandleFlagListRequestMessage(ClientStructure client)
{
var flagList = new Dictionary <string, FlagInfo>();
var serverFlags = FileHandler.GetFilesInPath(FlagPath, SearchOption.AllDirectories);
foreach (var serverFlag in serverFlags)
{
var flagName = Path.GetFileNameWithoutExtension(serverFlag)?.Replace('$', '/');
//2 playes have the same flag name so in this case we only send the first one
if (string.IsNullOrEmpty(flagName) || flagList.ContainsKey(flagName))
{
continue;
}
var flagOwner = Path.GetDirectoryName(serverFlag);
if (flagOwner == null)
{
continue;
}
flagList.Add(flagName, new FlagInfo
{
Owner = flagOwner,
FlagData = File.ReadAllBytes(serverFlag),
FlagName = flagName
});
}
var msgData = ServerContext.ServerMessageFactory.CreateNewMessageData <FlagListResponseMsgData>();
msgData.FlagFiles = flagList.Values.ToArray();
msgData.FlagCount = msgData.FlagFiles.Length;
MessageQueuer.SendToClient <FlagSrvMsg>(client, msgData);
}
private static void HandleVesselDock(ClientStructure client, VesselBaseMsgData message)
{
var msgData = (VesselDockMsgData)message;
LunaLog.Debug($"Docking message received! Dominant vessel: {msgData.DominantVesselId}");
if (VesselContext.RemovedVessels.Contains(msgData.WeakVesselId))
{
return;
}
if (VesselStoreSystem.VesselExists(msgData.DominantVesselId))
{
LunaLog.Debug($"Saving DOCKED vessel {msgData.DominantVesselId} from {client.PlayerName}. Bytes: {msgData.NumBytes}");
}
VesselDataUpdater.RawConfigNodeInsertOrUpdate(msgData.DominantVesselId, Encoding.UTF8.GetString(msgData.FinalVesselData, 0, msgData.NumBytes));
//Now remove the weak vessel but DO NOT add to the removed vessels as they might undock!!!
LunaLog.Debug($"Removing weak docked vessel {msgData.WeakVesselId}");
VesselStoreSystem.RemoveVessel(msgData.WeakVesselId);
MessageQueuer.RelayMessage <VesselSrvMsg>(client, msgData);
//Tell all clients to remove the weak vessel
var removeMsgData = ServerContext.ServerMessageFactory.CreateNewMessageData <VesselRemoveMsgData>();
removeMsgData.VesselId = msgData.WeakVesselId;
MessageQueuer.SendToAllClients <VesselSrvMsg>(removeMsgData);
}
public static void HandleMessage(ClientStructure client, IClientMessageBase message)
{
var data = (GroupBaseMsgData)message.Data;
switch (data.GroupMessageType)
{
case GroupMessageType.ListRequest:
var msgData = ServerContext.ServerMessageFactory.CreateNewMessageData <GroupListResponseMsgData>();
msgData.Groups = GroupSystem.Groups.Values.ToArray();
msgData.GroupsCount = msgData.Groups.Length;
MessageQueuer.SendToClient <GroupSrvMsg>(client, msgData);
//We don't use this message anymore so we can recycle it
message.Recycle();
break;
case GroupMessageType.CreateGroup:
GroupSystem.CreateGroup(client.PlayerName, ((GroupCreateMsgData)data).GroupName);
break;
case GroupMessageType.RemoveGroup:
GroupSystem.RemoveGroup(client.PlayerName, ((GroupRemoveMsgData)data).GroupName);
break;
case GroupMessageType.GroupUpdate:
GroupSystem.UpdateGroup(client.PlayerName, ((GroupUpdateMsgData)data).Group);
break;
}
}
public override void HandleMessage(ClientStructure client, IClientMessageBase message)
{
var messageData = message.Data as PlayerColorBaseMsgData;
switch (messageData?.PlayerColorMessageType)
{
case PlayerColorMessageType.Request:
SendAllPlayerColors(client);
//We don't use this message anymore so we can recycle it
message.Recycle();
break;
case PlayerColorMessageType.Set:
var data = (PlayerColorSetMsgData)messageData;
if (data.PlayerColor.PlayerName != client.PlayerName)
{
return;
}
Array.Copy(data.PlayerColor.Color, client.PlayerColor, data.PlayerColor.Color.Length);
MessageQueuer.RelayMessage <PlayerColorSrvMsg>(client, data);
break;
}
}
private static void HandleVesselDock(ClientStructure client, VesselBaseMsgData message)
{
var msgData = (VesselDockMsgData)message;
LunaLog.Debug($"Docking message received! Dominant vessel: {msgData.DominantVesselId}");
if (VesselContext.RemovedVessels.Contains(msgData.WeakVesselId))
{
return;
}
var path = Path.Combine(ServerContext.UniverseDirectory, "Vessels", $"{msgData.DominantVesselId}.txt");
if (!File.Exists(path))
{
LunaLog.Debug($"Saving vessel {msgData.DominantVesselId} from {client.PlayerName}");
}
FileHandler.WriteToFile(path, msgData.FinalVesselData, msgData.NumBytes);
//Now remove the weak vessel
LunaLog.Debug($"Removing weak docked vessel {msgData.WeakVesselId}");
Universe.RemoveFromUniverse(Path.Combine(ServerContext.UniverseDirectory, "Vessels",
$"{msgData.WeakVesselId}.txt"));
VesselContext.RemovedVessels.Add(msgData.WeakVesselId);
MessageQueuer.RelayMessage <VesselSrvMsg>(client, msgData);
//Tell all clients to remove the weak vessel
var removeMsgData = ServerContext.ServerMessageFactory.CreateNewMessageData <VesselRemoveMsgData>();
removeMsgData.VesselId = msgData.WeakVesselId;
MessageQueuer.SendToAllClients <VesselSrvMsg>(removeMsgData);
}
private static void HandleVesselProto(ClientStructure client, VesselBaseMsgData message)
{
var msgData = (VesselProtoMsgData)message;
if (VesselContext.RemovedVessels.Contains(msgData.Vessel.VesselId))
{
return;
}
if (msgData.Vessel.NumBytes == 0)
{
LunaLog.Warning($"Received a vessel with 0 bytes ({msgData.Vessel.VesselId}) from {client.PlayerName}.");
return;
}
var path = Path.Combine(ServerContext.UniverseDirectory, "Vessels", $"{msgData.Vessel.VesselId}.txt");
if (!File.Exists(path))
{
LunaLog.Debug($"Saving vessel {msgData.Vessel.VesselId} from {client.PlayerName}. Bytes: {msgData.Vessel.NumBytes}");
}
FileHandler.WriteToFile(path, msgData.Vessel.Data, msgData.Vessel.NumBytes);
MessageQueuer.RelayMessage <VesselSrvMsg>(client, msgData);
}
/// <summary>
/// Sends the crafts in a folder
/// </summary>
public static void SendCraftList(ClientStructure client, CraftLibraryListRequestMsgData data)
{
var crafts = new List <CraftBasicInfo>();
var playerFolder = Path.Combine(CraftPath, data.FolderName);
foreach (var craftType in Enum.GetNames(typeof(CraftType)))
{
var craftTypeFolder = Path.Combine(playerFolder, craftType);
if (Directory.Exists(craftTypeFolder))
{
foreach (var file in Directory.GetFiles(craftTypeFolder))
{
var craftName = Path.GetFileNameWithoutExtension(file);
crafts.Add(new CraftBasicInfo
{
CraftName = craftName,
CraftType = (CraftType)Enum.Parse(typeof(CraftType), craftType),
FolderName = data.FolderName
});
}
}
}
var msgData = ServerContext.ServerMessageFactory.CreateNewMessageData <CraftLibraryListReplyMsgData>();
msgData.FolderName = data.FolderName;
msgData.PlayerCrafts = crafts.ToArray();
msgData.PlayerCraftsCount = crafts.Count;
MessageQueuer.SendToClient <CraftLibrarySrvMsg>(client, msgData);
if (msgData.PlayerCraftsCount > 0)
{
LunaLog.Debug($"Sending {msgData.PlayerCraftsCount} ({data.FolderName}) crafts to: {client.PlayerName}");
}
}
/// <summary>
/// Sends the requested craft
/// </summary>
public static void SendCraft(ClientStructure client, CraftLibraryDownloadRequestMsgData data)
{
var lastTime = LastRequest.GetOrAdd(client.PlayerName, DateTime.MinValue);
if (DateTime.Now - lastTime > TimeSpan.FromMilliseconds(CraftSettings.SettingsStore.MinCraftLibraryRequestIntervalMs))
{
LastRequest.AddOrUpdate(client.PlayerName, DateTime.Now, (key, existingVal) => DateTime.Now);
var file = Path.Combine(CraftPath, data.CraftRequested.FolderName, data.CraftRequested.CraftType.ToString(),
$"{data.CraftRequested.CraftName}.craft");
if (FileHandler.FileExists(file))
{
var msgData = ServerContext.ServerMessageFactory.CreateNewMessageData <CraftLibraryDataMsgData>();
msgData.Craft.CraftType = data.CraftRequested.CraftType;
msgData.Craft.Data = FileHandler.ReadFile(file);
msgData.Craft.NumBytes = msgData.Craft.Data.Length;
msgData.Craft.FolderName = data.CraftRequested.FolderName;
msgData.Craft.CraftName = data.CraftRequested.CraftName;
LunaLog.Debug($"Sending craft ({ByteSize.FromBytes(msgData.Craft.NumBytes).KiloBytes}{ByteSize.KiloByteSymbol}): {data.CraftRequested.CraftName} to: {client.PlayerName}.");
MessageQueuer.SendToClient <CraftLibrarySrvMsg>(client, msgData);
}
}
else
{
LunaLog.Warning($"{client.PlayerName} is requesting crafts too fast!");
}
}
private static void RunDekessler()
{
var vesselList = FileHandler.GetFilesInPath(Path.Combine(ServerContext.UniverseDirectory, "Vessels"));
var removalCount = 0;
foreach (var vesselFilePath in vesselList)
{
var vesselId = Path.GetFileNameWithoutExtension(vesselFilePath);
if (!File.Exists(vesselFilePath)) continue;
var vesselIsDebris = FileHandler.ReadFileLines(vesselFilePath).Select(l=> l.ToLower())
.Any(l => l.Contains("type = ") && l.Contains("debris"));
if (vesselId != null && vesselIsDebris)
{
LunaLog.Normal($"Removing debris vessel: {vesselId}");
//Delete it from the universe
Universe.RemoveFromUniverse(vesselFilePath);
//Send a vessel remove message
var msgData = ServerContext.ServerMessageFactory.CreateNewMessageData<VesselRemoveMsgData>();
msgData.VesselId = Guid.Parse(vesselId);
MessageQueuer.SendToAllClients<VesselSrvMsg>(msgData);
removalCount++;
}
}
if (removalCount > 0)
LunaLog.Normal($"Removed {removalCount} debris");
}
public override void HandleMessage(ClientStructure client, IMessageData messageData)
{
var message = messageData as KerbalBaseMsgData;
switch (message?.KerbalMessageType)
{
case KerbalMessageType.Request:
var kerbalFiles = FileHandler.GetFilesInPath(Path.Combine(ServerContext.UniverseDirectory, "Kerbals"));
var kerbalsData = kerbalFiles.Select(k => new KeyValuePair<string, byte[]>(Path.GetFileNameWithoutExtension(k),
FileHandler.ReadFile(k)));
LunaLog.Debug($"Sending {client.PlayerName} {kerbalFiles.Length} kerbals...");
var newMessageData = new KerbalReplyMsgData
{
KerbalsData = kerbalsData.ToArray()
};
MessageQueuer.SendToClient<KerbalSrvMsg>(client, newMessageData);
break;
case KerbalMessageType.Proto:
var data = (KerbalProtoMsgData)message;
LunaLog.Debug($"Saving kerbal {data.KerbalName} from {client.PlayerName}");
var path = Path.Combine(ServerContext.UniverseDirectory, "Kerbals", $"{data.KerbalName}.txt");
FileHandler.WriteToFile(path, data.KerbalData);
MessageQueuer.RelayMessage<KerbalSrvMsg>(client, data);
break;
default:
throw new NotImplementedException("Kerbal type not implemented");
}
}
public override void HandleMessage(ClientStructure client, IMessageData messageData)
{
var baseMsg = (FacilityBaseMsgData)messageData;
switch (baseMsg.FacilityMessageType)
{
case FacilityMessageType.Upgrade:
var upgradeMsg = (FacilityUpgradeMsgData)messageData;
LunaLog.Normal($"{client.PlayerName} UPGRADED facility {upgradeMsg.ObjectId} to level: {upgradeMsg.Level}");
break;
case FacilityMessageType.Repair:
LunaLog.Normal($"{client.PlayerName} REPAIRED facility {baseMsg.ObjectId}");
break;
case FacilityMessageType.Collapse:
LunaLog.Normal($"{client.PlayerName} DESTROYED facility {baseMsg.ObjectId}");
break;
default:
throw new ArgumentOutOfRangeException();
}
//We don't do anything on the server side with this messages so just relay them.
MessageQueuer.RelayMessage <FacilitySrvMsg>(client, messageData);
}
private static void RunNuke()
{
var vesselList = FileHandler.GetFilesInPath(Path.Combine(ServerContext.UniverseDirectory, "Vessels"));
var removalCount = 0;
foreach (var vesselFilePath in vesselList)
{
var vesselId = Path.GetFileNameWithoutExtension(vesselFilePath);
var landed = FileHandler.ReadFileLines(vesselFilePath).Select(l => l.ToLower())
.Any(l => l.Contains("landed at = ") && (l.Contains("ksc") || l.Contains("runway")));
if (vesselId != null && landed)
{
LunaLog.Normal($"Removing vessel {vesselId} from KSC");
//Delete it from the universe
Universe.RemoveFromUniverse(vesselFilePath);
//Send a vessel remove message
//Send it with a delete time of 0 so it shows up for all Players.
MessageQueuer.SendToAllClients <VesselSrvMsg>(new VesselRemoveMsgData
{
VesselId = Guid.Parse(vesselId)
});
removalCount++;
}
}
if (removalCount > 0)
{
LunaLog.Normal($"Nuked {removalCount} vessels around the KSC");
}
}
/// <summary>
/// This method relays a message to the other clients in the same subspace and in case there are other players
/// in older subspaces it stores it for further processing
/// </summary>
public static void HandleVesselMessage(ClientStructure client, VesselBaseMsgData msg)
{
if (client.Subspace == -1)
{
return;
}
MessageQueuer.RelayMessageToSubspace <VesselSrvMsg>(client, msg);
if (GeneralSettings.SettingsStore.ShowVesselsInThePast)
{
foreach (var subspace in WarpSystem.GetFutureSubspaces(client.Subspace))
{
MessageQueuer.RelayMessageToSubspace <VesselSrvMsg>(client, msg, subspace);
}
}
//The client is running in the future so here we adjust the real sent time of the message
msg.SentTime += WarpSystem.GetSubspaceTimeDifference(client.Subspace);
foreach (var subspace in WarpSystem.GetPastSubspaces(client.Subspace))
{
if (!OldVesselMessages.ContainsKey(client.Subspace))
{
OldVesselMessages.TryAdd(subspace, new ConcurrentQueue <VesselBaseMsgData>());
}
OldVesselMessages[subspace].Enqueue(msg);
}
}
public static void LoadQuicksave(ClientStructure client, QuicksaveLoadRequestMsgData data)
{
Task.Run(() =>
{
var quicksaveFile = GetQuicksaveFile(data.QuicksaveInfo.Name, data.QuicksaveInfo.VesselId);
if (!File.Exists(quicksaveFile))
{
LunaLog.Warning($"Could not find quicksave {quicksaveFile}");
return;
}
var vesselData = File.ReadAllText(quicksaveFile);
var msgData = ServerContext.ServerMessageFactory.CreateNewMessageData <QuicksaveLoadReplyMsgData>();
msgData.QuicksaveInfo = new QuicksaveInfo
{
Name = data.QuicksaveInfo.Name,
Date = data.QuicksaveInfo.Date,
VesselId = data.QuicksaveInfo.VesselId,
Data = Encoding.UTF8.GetBytes(vesselData),
NumBytes = vesselData.Length
};
MessageQueuer.SendToClient <QuicksaveSrvMsg>(client, msgData);
RemoveOldQuicksaves();
});
}
public void HandleUploadFileMessage(ClientStructure client, CraftLibraryUploadMsgData message)
{
var playerPath = Path.Combine(Path.Combine(ServerContext.UniverseDirectory, "Crafts"),
message.PlayerName);
if (!FileHandler.FolderExists(playerPath))
{
FileHandler.FolderCreate(playerPath);
}
var typePath = Path.Combine(playerPath, message.UploadType.ToString());
if (!FileHandler.FolderExists(typePath))
{
FileHandler.FolderCreate(typePath);
}
var craftFile = Path.Combine(typePath, $"{message.UploadName}.craft");
FileHandler.WriteToFile(craftFile, message.CraftData);
LunaLog.Debug($"Saving {message.UploadName}, Type: {message.UploadType} from {message.PlayerName}");
var newMessageData = new CraftLibraryAddMsgData
{
PlayerName = message.PlayerName,
UploadName = message.UploadName,
UploadType = message.UploadType
};
MessageQueuer.RelayMessage <CraftLibrarySrvMsg>(client, newMessageData);
}
public static void Shutdown(string reason)
{
MessageQueuer.SendConnectionEndToAll(reason);
Thread.Sleep(250);
ServerStarting = false;
ServerRunning = false;
}
private static void HandleVesselsRequest(ClientStructure client)
{
var sendVesselCount = 0;
var vesselList = new List <VesselInfo>();
foreach (var file in FileHandler.GetFilesInPath(Path.Combine(ServerContext.UniverseDirectory, "Vessels")))
{
var vesselData = FileHandler.ReadFile(file);
if (Guid.TryParse(Path.GetFileNameWithoutExtension(file), out var vesselId))
{
sendVesselCount++;
vesselList.Add(new VesselInfo
{
Data = vesselData,
NumBytes = vesselData.Length,
VesselId = vesselId
});
}
}
var msgData = ServerContext.ServerMessageFactory.CreateNewMessageData <VesselsReplyMsgData>();
msgData.VesselsData = vesselList.ToArray();
msgData.VesselsCount = vesselList.Count;
MessageQueuer.SendToClient <VesselSrvMsg>(client, msgData);
LunaLog.Debug($"Sending {client.PlayerName} {sendVesselCount} vessels");
}
private static void HandleVesselsSync(ClientStructure client, VesselBaseMsgData message)
{
var msgData = (VesselSyncMsgData)message;
var vesselsToSend = GetCurrentVesselIds().Except(msgData.VesselIds).ToArray();
foreach (var vesselId in vesselsToSend)
{
var vesselData = FileHandler.ReadFile(Path.Combine(ServerContext.UniverseDirectory, "Vessels", $"{vesselId}.txt"));
if (vesselData.Length > 0)
{
var protoMsg = ServerContext.ServerMessageFactory.CreateNewMessageData <VesselProtoMsgData>();
protoMsg.Vessel.Data = vesselData;
protoMsg.Vessel.NumBytes = vesselData.Length;
protoMsg.Vessel.VesselId = vesselId;
MessageQueuer.SendToClient <VesselSrvMsg>(client, protoMsg);
}
}
if (vesselsToSend.Length > 0)
{
LunaLog.Debug($"Sending {client.PlayerName} {vesselsToSend.Length} vessels");
}
}
public static void SendAllSubspaces(ClientStructure client)
{
LunaLog.Debug($"Sending {client.PlayerName} {WarpContext.Subspaces.Count} possible subspaces");
var msgData = ServerContext.ServerMessageFactory.CreateNewMessageData <WarpSubspacesReplyMsgData>();
var subspaces = WarpContext.Subspaces.ToArray().Select(s =>
{
var players = ClientRetriever.GetAuthenticatedClients()
.Where(c => !Equals(c, client) && c.Subspace == s.Key)
.Select(c => c.PlayerName)
.ToArray();
return(new SubspaceInfo
{
PlayerCount = players.Length,
Players = players,
SubspaceKey = s.Key,
SubspaceTime = s.Value.Time
});
}).ToArray();
msgData.Subspaces = subspaces;
msgData.SubspaceCount = subspaces.Length;
MessageQueuer.SendToClient <WarpSrvMsg>(client, msgData);
}
public static void UpdateGroup(string clientPlayerName, Group group)
{
if (Groups.TryGetValue(group.Name, out var existingGroup))
{
if (existingGroup.Owner == clientPlayerName)
{
//We are the owner of the group so we can do whatever we want
if (Groups.TryUpdate(group.Name, group, existingGroup))
{
var msgData = ServerContext.ServerMessageFactory.CreateNewMessageData <GroupUpdateMsgData>();
msgData.Group = group;
MessageQueuer.SendToAllClients <GroupSrvMsg>(msgData);
Task.Run(() => SaveGroups());
}
}
else
{
//We are not the owner of the group so the only thing we can do is to add ourself to the "invited" hashset
if (group.Owner == existingGroup.Owner && Common.ScrambledEquals(group.Members, existingGroup.Members))
{
var invited = group.Invited.Except(existingGroup.Invited).ToArray();
if (invited.Length == 1 && invited[0] == clientPlayerName && Groups.TryUpdate(group.Name, group, existingGroup))
{
var msgData = ServerContext.ServerMessageFactory.CreateNewMessageData <GroupUpdateMsgData>();
msgData.Group = group;
MessageQueuer.SendToAllClients <GroupSrvMsg>(msgData);
Task.Run(() => SaveGroups());
}
}
}
}
}
private static void HandleVesselsRequest(ClientStructure client, IMessageData messageData)
{
var sendVesselCount = 0;
var cachedVesselCount = 0;
var clientRequested = (messageData as VesselsRequestMsgData)?.RequestList ?? new string[0];
var vesselList = new List <KeyValuePair <string, byte[]> >();
foreach (var file in FileHandler.GetFilesInPath(Path.Combine(ServerContext.UniverseDirectory, "Vessels")))
{
var vesselId = Path.GetFileNameWithoutExtension(file);
var vesselData = FileHandler.ReadFile(file);
var vesselObject = Common.CalculateSha256Hash(vesselData);
if (clientRequested.Contains(vesselObject))
{
sendVesselCount++;
vesselList.Add(new KeyValuePair <string, byte[]>(vesselId, vesselData));
}
else
{
cachedVesselCount++;
}
}
MessageQueuer.SendToClient <VesselSrvMsg>(client, new VesselsReplyMsgData {
VesselsData = vesselList.ToArray()
});
LunaLog.Debug($"Sending {client.PlayerName} {sendVesselCount} vessels, cached: {cachedVesselCount}...");
}
private static void RunNuke()
{
var vesselList = FileHandler.GetFilesInPath(Path.Combine(ServerContext.UniverseDirectory, "Vessels"));
var removalCount = 0;
foreach (var vesselFilePath in vesselList)
{
var vesselId = Path.GetFileNameWithoutExtension(vesselFilePath);
var landed = FileHandler.ReadFileLines(vesselFilePath).Select(l => l.ToLower())
.Any(l => l.Contains("landedat = ") && (l.Contains("ksc") || l.Contains("runway")));
if (vesselId != null && landed && !LockSystem.LockQuery.ControlLockExists(new Guid(vesselId)))
{
LunaLog.Normal($"Removing vessel {vesselId} from KSC");
//Delete it from the universe
Universe.RemoveFromUniverse(vesselFilePath);
//Send a vessel remove message
var msgData = ServerContext.ServerMessageFactory.CreateNewMessageData <VesselRemoveMsgData>();
msgData.VesselId = Guid.Parse(vesselId);
MessageQueuer.SendToAllClients <VesselSrvMsg>(msgData);
removalCount++;
}
}
if (removalCount > 0)
{
LunaLog.Normal($"Nuked {removalCount} vessels around the KSC");
}
}
/// <summary>
/// This method relay the update to players in the same planet but farther than 25km
/// </summary>
public static void RelayToMediumDistancePlayers()
{
while (ServerContext.ServerRunning)
{
try
{
KeyValuePair <ClientStructure, VesselPositionMsgData> vesselUpdate;
if (IncomingMediumUpdates.TryDequeue(out vesselUpdate) && VesselsDictionary.ContainsKey(vesselUpdate.Key))
{
IncomingFarUpdates.Enqueue(vesselUpdate);
var mediumDistanceClients = VesselsDictionary.Where(
v => !Equals(v.Key, vesselUpdate.Key) && v.Value != null &&
v.Value.BodyName == vesselUpdate.Value.BodyName &&
CalculateDistance(v.Value, vesselUpdate.Value) >
GeneralSettings.SettingsStore.CloseDistanceInMeters)
.Select(v => v.Key);
foreach (
var mediumDistanceClient in
mediumDistanceClients.Where(c => ServerContext.Clients.ContainsKey(c.Endpoint)))
{
MessageQueuer.RelayMessage <VesselSrvMsg>(mediumDistanceClient, vesselUpdate.Value);
}
}
}
catch (Exception e)
{
LunaLog.Error($"Error in RelayToMediumDistancePlayers method! Details: {e}");
}
Thread.Sleep(GeneralSettings.SettingsStore.MediumDistanceUpdateIntervalMs);
}
}
public static void HandleMessage(ClientStructure client, IClientMessageBase message)
{
var messageData = message.Data as PlayerStatusBaseMsgData;
switch (messageData?.PlayerStatusMessageType)
{
case PlayerStatusMessageType.Request:
SendOtherPlayerStatusesToNewPlayer(client);
//We don't use this message anymore so we can recycle it
message.Recycle();
break;
case PlayerStatusMessageType.Set:
var data = (PlayerStatusSetMsgData)messageData;
if (data.PlayerStatus.PlayerName != client.PlayerName)
{
return;
}
client.PlayerStatus.VesselText = data.PlayerStatus.VesselText;
client.PlayerStatus.StatusText = data.PlayerStatus.StatusText;
MessageQueuer.RelayMessage <PlayerStatusSrvMsg>(client, data);
break;
}
}
private static void RunNuke()
{
uint removalCount = 0;
var vesselList = VesselStoreSystem.CurrentVessels.ToArray();
foreach (var vesselKeyVal in vesselList)
{
if (vesselKeyVal.Value.Fields.GetSingle("landed").Value.ToLower() == "true" &&
vesselKeyVal.Value.Fields.GetSingle("landedAt").Value.ToLower().Contains("ksc") ||
vesselKeyVal.Value.Fields.GetSingle("landedAt").Value.ToLower().Contains("runway") ||
vesselKeyVal.Value.Fields.GetSingle("landedAt").Value.ToLower().Contains("launchpad"))
{
LunaLog.Normal($"Removing vessel: {vesselKeyVal.Key} from KSC");
VesselStoreSystem.RemoveVessel(vesselKeyVal.Key);
//Send a vessel remove message
var msgData = ServerContext.ServerMessageFactory.CreateNewMessageData <VesselRemoveMsgData>();
msgData.VesselId = vesselKeyVal.Key;
MessageQueuer.SendToAllClients <VesselSrvMsg>(msgData);
removalCount++;
}
}
if (removalCount > 0)
{
LunaLog.Normal($"Nuked {removalCount} vessels around the KSC");
}
}
private static void RunDekessler()
{
var removalCount = 0;
var vesselList = VesselStoreSystem.CurrentVesselsInXmlFormat.ToArray();
foreach (var vesselKeyVal in vesselList)
{
if (IsVesselDebris(vesselKeyVal.Key, vesselKeyVal.Value))
{
LunaLog.Normal($"Removing debris vessel: {vesselKeyVal.Key}");
VesselStoreSystem.RemoveVessel(vesselKeyVal.Key);
//Send a vessel remove message
var msgData = ServerContext.ServerMessageFactory.CreateNewMessageData <VesselRemoveMsgData>();
msgData.VesselId = vesselKeyVal.Key;
MessageQueuer.SendToAllClients <VesselSrvMsg>(msgData);
removalCount++;
}
}
if (removalCount > 0)
{
LunaLog.Normal($"Removed {removalCount} debris");
}
}
public override void Execute(string commandArgs)
{
string playerName;
string reason;
CommandSystemHelperMethods.SplitCommand(commandArgs, out playerName, out reason);
reason = string.IsNullOrEmpty(reason) ? "No reason specified" : reason;
if (!string.IsNullOrEmpty(playerName))
{
var player = ClientRetriever.GetClientByName(playerName);
if (player != null)
{
MessageQueuer.SendConnectionEnd(player, $"You were banned from the server: {reason}");
}
Add(playerName);
LunaLog.Normal($"Player '{playerName}' was banned from the server: {reason}");
}
else
{
LunaLog.Normal($"Player: {playerName} not found");
}
}
private static void HandleVesselsSync(ClientStructure client, VesselBaseMsgData message)
{
var msgData = (VesselSyncMsgData)message;
var allVessels = VesselStoreSystem.CurrentVesselsInXmlFormat.Keys.ToList();
for (var i = 0; i < msgData.VesselsCount; i++)
{
allVessels.Remove(msgData.VesselIds[i]);
}
var vesselsToSend = allVessels;
foreach (var vesselId in vesselsToSend)
{
var vesselData = VesselStoreSystem.GetVesselInConfigNodeFormat(vesselId);
if (vesselData.Length > 0)
{
var protoMsg = ServerContext.ServerMessageFactory.CreateNewMessageData <VesselProtoMsgData>();
protoMsg.Vessel.Data = Encoding.UTF8.GetBytes(vesselData);
protoMsg.Vessel.NumBytes = vesselData.Length;
protoMsg.Vessel.VesselId = vesselId;
MessageQueuer.SendToClient <VesselSrvMsg>(client, protoMsg);
}
}
if (allVessels.Count > 0)
{
LunaLog.Debug($"Sending {client.PlayerName} {vesselsToSend.Count} vessels");
}
}
public static void RunDekessler(string commandText)
{
var vesselList = FileHandler.GetFilesInPath(Path.Combine(ServerContext.UniverseDirectory, "Vessels"));
var removalCount = 0;
foreach (var vesselFilePath in vesselList)
{
var vesselIsDebris = FileHandler.ReadFileLines(vesselFilePath)
.Any(l => l.Contains("Type = ") && l.Contains("Debris"));
if (vesselIsDebris)
{
var vesselId = Path.GetFileNameWithoutExtension(vesselFilePath);
LunaLog.Normal("Removing vessel: " + vesselId);
//Delete it from the universe
Universe.RemoveFromUniverse(vesselFilePath);
//Send a vessel remove message
//Send it with a delete time of 0 so it shows up for all Players.
MessageQueuer.SendToAllClients <VesselSrvMsg>(new VesselRemoveMsgData
{
PlanetTime = 0,
VesselId = Guid.Parse(vesselId)
});
removalCount++;
LunaLog.Debug("Removed debris vessel " + vesselId);
}
}
LunaLog.Normal("Removed " + removalCount + " debris");
}
