public override void HandleMessage(ClientStructure client, IClientMessageBase message)
{
var data = message.Data as HandshakeBaseMsgData;
switch (data?.HandshakeMessageType)
{
case HandshakeMessageType.Request:
SetAndSendHandshakeChallangeMessage(client);
break;
case HandshakeMessageType.Response:
try
{
HandshakeHandler.HandleHandshakeResponse(client, (HandshakeResponseMsgData)data);
}
catch (Exception e)
{
LunaLog.Debug($"Error in HANDSHAKE_REQUEST from {((HandshakeResponseMsgData)data).PlayerName}: {e}");
HandshakeSystemSender.SendHandshakeReply(client, HandshakeReply.MalformedHandshake, "Malformed handshake");
}
break;
default:
throw new NotImplementedException("Handshake type not implemented");
}
//We don't use this message so we can recycle it
message.Recycle();
}
public static void HandleMessage(ClientStructure client, IClientMessageBase message)
{
var data = message.Data as KerbalBaseMsgData;
switch (data?.KerbalMessageType)
{
case KerbalMessageType.Request:
KerbalSystem.HandleKerbalsRequest(client);
//We don't use this message anymore so we can recycle it
message.Recycle();
break;
case KerbalMessageType.Proto:
KerbalSystem.HandleKerbalProto(client, (KerbalProtoMsgData)data);
break;
case KerbalMessageType.Remove:
KerbalSystem.HandleKerbalRemove(client, (KerbalRemoveMsgData)data);
break;
default:
throw new NotImplementedException("Kerbal type not implemented");
}
}
public override void HandleMessage(ClientStructure client, IClientMessageBase message)
{
var data = (CraftLibraryBaseMsgData)message.Data;
if (data.PlayerName != client.PlayerName)
{
return;
}
switch (data.CraftMessageType)
{
case CraftMessageType.UploadFile:
CraftLibraryHandler.HandleUploadFileMessage(client, (CraftLibraryUploadMsgData)data);
break;
case CraftMessageType.RequestFile:
CraftLibraryHandler.HandleRequestFileMessage(client, (CraftLibraryRequestMsgData)data);
break;
case CraftMessageType.DeleteFile:
CraftLibraryHandler.HandleDeleteFileMessage(client, (CraftLibraryDeleteMsgData)data);
break;
case CraftMessageType.ListRequest:
//We don't use this message anymore so we can recycle it
message.Recycle();
CraftLibrarySystem.SendCraftList(client);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public override void HandleMessage(ClientStructure client, IClientMessageBase message)
{
var data = (LockBaseMsgData)message.Data;
switch (data.LockMessageType)
{
case LockMessageType.ListRequest:
LockSystemSender.SendAllLocks(client);
//We don't use this message anymore so we can recycle it
message.Recycle();
break;
case LockMessageType.Acquire:
var acquireData = (LockAcquireMsgData)data;
if (acquireData.Lock.PlayerName == client.PlayerName)
{
LockSystemSender.SendLockAcquireMessage(client, acquireData.Lock, acquireData.Force);
}
break;
case LockMessageType.Release:
var releaseData = (LockReleaseMsgData)data;
if (releaseData.Lock.PlayerName == client.PlayerName)
{
LockSystemSender.ReleaseAndSendLockReleaseMessage(client, releaseData.Lock);
}
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public override void HandleMessage(ClientStructure client, IClientMessageBase message)
{
var data = (QuicksaveBaseMsgData)message.Data;
switch (data.MessageType)
{
case QuicksaveMessageType.ListRequest:
QuicksaveSystem.SendQuicksaveList(client, (QuicksaveListRequestMsgData)data);
break;
case QuicksaveMessageType.LoadRequest:
QuicksaveSystem.LoadQuicksave(client, (QuicksaveLoadRequestMsgData)data);
break;
case QuicksaveMessageType.SaveRequest:
QuicksaveSystem.SaveQuicksave(client, (QuicksaveSaveRequestMsgData)data);
break;
case QuicksaveMessageType.RemoveRequest:
QuicksaveSystem.RemoveQuicksave(client, (QuicksaveRemoveRequestMsgData)data);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
//Fire OnMessageReceived
public static void FireOnMessageReceived(ClientStructure client, IClientMessageBase message)
{
var handledByAny = false;
lock (ListLock)
{
foreach (var plugin in LoadedPlugins)
{
try
{
plugin.OnMessageReceived(client, message);
//prevent plugins from unhandling other plugin's Handled requests
if (message.Handled)
{
handledByAny = true;
}
}
catch (Exception e)
{
var type = plugin.GetType();
LunaLog.Debug($"Error thrown in OnMessageReceived event for {type.FullName} ({type.Assembly.FullName}), Exception: {e}");
}
message.Handled = handledByAny;
}
}
}
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;
}
}
public override void HandleMessage(ClientStructure client, IClientMessageBase message)
{
var data = (ScreenshotBaseMsgData)message.Data;
switch (data.ScreenshotMessageType)
{
case ScreenshotMessageType.FoldersRequest:
ScreenshotSystem.SendScreenshotFolders(client);
break;
case ScreenshotMessageType.ListRequest:
ScreenshotSystem.SendScreenshotList(client, (ScreenshotListRequestMsgData)data);
break;
case ScreenshotMessageType.ScreenshotData:
ScreenshotSystem.SaveScreenshot(client, (ScreenshotDataMsgData)data);
break;
case ScreenshotMessageType.DownloadRequest:
ScreenshotSystem.SendScreenshot(client, (ScreenshotDownloadRequestMsgData)data);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
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;
}
}
public static void HandleMessage(ClientStructure client, IClientMessageBase message)
{
var data = (CraftLibraryBaseMsgData)message.Data;
switch (data.CraftMessageType)
{
case CraftMessageType.FoldersRequest:
CraftLibrarySystem.SendCraftFolders(client);
break;
case CraftMessageType.ListRequest:
CraftLibrarySystem.SendCraftList(client, (CraftLibraryListRequestMsgData)data);
break;
case CraftMessageType.DownloadRequest:
CraftLibrarySystem.SendCraft(client, (CraftLibraryDownloadRequestMsgData)data);
break;
case CraftMessageType.DeleteRequest:
CraftLibrarySystem.DeleteCraft(client, (CraftLibraryDeleteRequestMsgData)data);
break;
case CraftMessageType.CraftData:
CraftLibrarySystem.SaveCraft(client, (CraftLibraryDataMsgData)data);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public override void HandleMessage(ClientStructure client, IClientMessageBase message)
{
var messageData = message.Data as VesselBaseMsgData;
switch (messageData?.VesselMessageType)
{
case VesselMessageType.Sync:
HandleVesselsSync(client, messageData);
message.Recycle();
break;
case VesselMessageType.Proto:
HandleVesselProto(client, messageData);
break;
case VesselMessageType.Dock:
HandleVesselDock(client, messageData);
break;
case VesselMessageType.Remove:
HandleVesselRemove(client, messageData);
break;
case VesselMessageType.Position:
VesselRelaySystem.HandleVesselMessage(client, messageData);
if (!GeneralSettings.SettingsStore.ShowVesselsInThePast || client.Subspace == WarpContext.LatestSubspace)
{
VesselDataUpdater.WritePositionDataToFile(messageData);
}
break;
case VesselMessageType.Flightstate:
VesselRelaySystem.HandleVesselMessage(client, messageData);
break;
case VesselMessageType.Update:
VesselDataUpdater.WriteUpdateDataToFile(messageData);
MessageQueuer.RelayMessage <VesselSrvMsg>(client, messageData);
break;
case VesselMessageType.Resource:
VesselDataUpdater.WriteResourceDataToFile(messageData);
MessageQueuer.RelayMessage <VesselSrvMsg>(client, messageData);
break;
case VesselMessageType.PartSync:
VesselDataUpdater.WriteModuleDataToFile(messageData);
MessageQueuer.RelayMessage <VesselSrvMsg>(client, messageData);
break;
case VesselMessageType.Fairing:
VesselDataUpdater.WriteFairingDataToFile(messageData);
MessageQueuer.RelayMessage <VesselSrvMsg>(client, messageData);
break;
default:
throw new NotImplementedException("Vessel message type not implemented");
}
}
public override void OnMessageReceived(ClientStructure client, IClientMessageBase messageData)
{
ChatMsgData chatMsgData = messageData.Data as ChatMsgData;
if (chatMsgData != null)
{
connector.SendToDiscord("[" + chatMsgData.From + "] " + chatMsgData.Text);
}
}
public override void HandleMessage(ClientStructure client, IClientMessageBase message)
{
var data = (ModMsgData)message.Data;
if (data.Relay)
{
MessageQueuer.RelayMessage <ModSrvMsg>(client, data);
}
LmpModInterface.OnModMessageReceived(client, data.ModName, data.Data, data.NumBytes);
}
public static void HandleMessage(ClientStructure client, IClientMessageBase message)
{
var messageData = (AdminBaseMsgData)message.Data;
if (!string.IsNullOrEmpty(GeneralSettings.SettingsStore.AdminPassword) && GeneralSettings.SettingsStore.AdminPassword == messageData.AdminPassword)
{
var msgData = ServerContext.ServerMessageFactory.CreateNewMessageData <AdminReplyMsgData>();
switch (messageData.AdminMessageType)
{
case AdminMessageType.Ban:
var banMsg = (AdminBanMsgData)message.Data;
LunaLog.Debug($"{client.PlayerName}: Requested a ban against {banMsg.PlayerName}. Reason: {banMsg.Reason}");
msgData.Response = CommandHandler.Commands["ban"].Func($"{banMsg.PlayerName} {banMsg.Reason}") ? AdminResponse.Ok : AdminResponse.Error;
break;
case AdminMessageType.Kick:
var kickMsg = (AdminKickMsgData)message.Data;
LunaLog.Debug($"{client.PlayerName}: Requested a kick against {kickMsg.PlayerName}. Reason: {kickMsg.Reason}");
msgData.Response = CommandHandler.Commands["kick"].Func($"{kickMsg.PlayerName} {kickMsg.Reason}") ? AdminResponse.Ok : AdminResponse.Error;
break;
case AdminMessageType.Dekessler:
LunaLog.Debug($"{client.PlayerName}: Requested a dekessler");
CommandHandler.Commands["dekessler"].Func(null);
msgData.Response = AdminResponse.Ok;
break;
case AdminMessageType.Nuke:
LunaLog.Debug($"{client.PlayerName}: Requested a nuke");
CommandHandler.Commands["nukeksc"].Func(null);
msgData.Response = AdminResponse.Ok;
break;
case AdminMessageType.RestartServer:
LunaLog.Debug($"{client.PlayerName}: Requested a server restart");
CommandHandler.Commands["restartserver"].Func(null);
msgData.Response = AdminResponse.Ok;
break;
default:
throw new ArgumentOutOfRangeException();
}
MessageQueuer.SendToClient <AdminSrvMsg>(client, msgData);
}
else
{
LunaLog.Warning($"{client.PlayerName}: Tried to run an admin command with an invalid password");
var msgData = ServerContext.ServerMessageFactory.CreateNewMessageData <AdminReplyMsgData>();
msgData.Response = AdminResponse.InvalidPassword;
MessageQueuer.SendToClient <AdminSrvMsg>(client, msgData);
}
}
public override void HandleMessage(ClientStructure client, IClientMessageBase message)
{
var data = (ShareProgressBaseMsgData)message.Data;
switch (data.ShareProgressMessageType)
{
case ShareProgressMessageType.FundsUpdate:
ShareFundsSystem.FundsReceived(client, (ShareProgressFundsMsgData)data);
break;
case ShareProgressMessageType.ScienceUpdate:
ShareScienceSystem.ScienceReceived(client, (ShareProgressScienceMsgData)data);
break;
case ShareProgressMessageType.ScienceSubjectUpdate:
ShareScienceSubjectSystem.ScienceSubjectReceived(client, (ShareProgressScienceSubjectMsgData)data);
break;
case ShareProgressMessageType.ReputationUpdate:
ShareReputationSystem.ReputationReceived(client, (ShareProgressReputationMsgData)data);
break;
case ShareProgressMessageType.TechnologyUpdate:
ShareTechnologySystem.TechnologyReceived(client, (ShareProgressTechnologyMsgData)data);
break;
case ShareProgressMessageType.ContractsUpdate:
ShareContractsSystem.ContractsReceived(client, (ShareProgressContractsMsgData)data);
break;
case ShareProgressMessageType.AchievementsUpdate:
ShareAchievementsSystem.AchievementsReceived(client, (ShareProgressAchievementsMsgData)data);
break;
case ShareProgressMessageType.StrategyUpdate:
ShareStrategySystem.StrategyReceived(client, (ShareProgressStrategyMsgData)data);
break;
case ShareProgressMessageType.FacilityUpgrade:
ShareUpgradeableFacilitiesSystem.UpgradeReceived(client, (ShareProgressFacilityUpgradeMsgData)data);
break;
case ShareProgressMessageType.PartPurchase:
SharePartPurchaseSystem.PurchaseReceived(client, (ShareProgressPartPurchaseMsgData)data);
break;
case ShareProgressMessageType.ExperimentalPart:
ShareExperimentalPartSystem.ExperimentalPartReceived(client, (ShareProgressExperimentalPartMsgData)data);
break;
}
}
public override void HandleMessage(ClientStructure client, IClientMessageBase message)
{
var data = message.Data as HandshakeBaseMsgData;
switch (data?.HandshakeMessageType)
{
case HandshakeMessageType.Request:
HandshakeHandler.HandleHandshakeRequest(client, (HandshakeRequestMsgData)data);
break;
default:
throw new NotImplementedException("Handshake type not implemented");
}
message.Recycle();
}
public override void HandleMessage(ClientStructure client, IClientMessageBase message)
{
var data = (AdminBaseMsgData)message.Data;
switch (data.AdminMessageType)
{
case AdminMessageType.ListRequest:
AdminSystemSender.SendAdminList(client);
//We don't use this message anymore so we can recycle it
message.Recycle();
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public static void HandleMessage(ClientStructure client, IClientMessageBase message)
{
var data = (FlagBaseMsgData)message.Data;
switch (data.FlagMessageType)
{
case FlagMessageType.ListRequest:
FlagSystem.HandleFlagListRequestMessage(client);
//We don't use this message anymore so we can recycle it
message.Recycle();
break;
case FlagMessageType.FlagData:
FlagSystem.HandleFlagDataMessage(client, (FlagDataMsgData)data);
break;
}
}
public override void HandleMessage(ClientStructure client, IClientMessageBase message)
{
var messageData = message.Data as ScenarioBaseMsgData;
switch (messageData?.ScenarioMessageType)
{
case ScenarioMessageType.Request:
ScenarioSystem.SendScenarioModules(client);
break;
case ScenarioMessageType.Data:
ScenarioSystem.ParseReceivedScenarioData(client, messageData);
break;
}
//We don't use this message anymore so we can recycle it
message.Recycle();
}
public override void HandleMessage(ClientStructure client, IClientMessageBase message)
{
//We don't use this message anymore so we can recycle it
message.Recycle();
var newMotd = GeneralSettings.SettingsStore.ServerMotd;
if (newMotd.Length > 255)
{
newMotd = newMotd.Substring(0, 255); //We don't wanna send a huuuge message!
}
newMotd = newMotd.Replace("%Name%", client.PlayerName).Replace(@"\n", Environment.NewLine);
var msgData = ServerContext.ServerMessageFactory.CreateNewMessageData <MotdReplyMsgData>();
msgData.MessageOfTheDay = newMotd;
MessageQueuer.SendToClient <MotdSrvMsg>(client, msgData);
}
public static void HandleMessage(ClientStructure client, IClientMessageBase message)
{
var messageData = (ChatMsgData)message.Data;
if (messageData.From != client.PlayerName)
{
return;
}
if (messageData.Relay)
{
MessageQueuer.SendToAllClients <ChatSrvMsg>(messageData);
LunaLog.ChatMessage($"{messageData.From}: {messageData.Text}");
}
else //Is a PM to server msg
{
LunaLog.Warning($"{messageData.From}: {messageData.Text}");
}
}
public override void HandleMessage(ClientStructure client, IClientMessageBase message)
{
var data = (ChatBaseMsgData)message.Data;
if (data.From != client.PlayerName)
{
return;
}
switch (data.ChatMessageType)
{
case ChatMessageType.ListRequest:
ChatSystem.SendPlayerChatChannels(client);
//We don't use this message anymore so we can recycle it
message.Recycle();
break;
case ChatMessageType.Join:
ChatSystemReceiver.HandleJoinMessage(client, (ChatJoinMsgData)data);
break;
case ChatMessageType.Leave:
ChatSystemReceiver.HandleLeaveMessage(client, (ChatLeaveMsgData)data);
break;
case ChatMessageType.ChannelMessage:
ChatSystemReceiver.HandleChannelMessage(client, (ChatChannelMsgData)data);
break;
case ChatMessageType.PrivateMessage:
ChatSystemReceiver.HandlePrivateMessage(client, (ChatPrivateMsgData)data);
break;
case ChatMessageType.ConsoleMessage:
ChatSystemReceiver.HandleConsoleMessage(client, (ChatConsoleMsgData)data);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public override void HandleMessage(ClientStructure client, IClientMessageBase message)
{
var data = (FacilityBaseMsgData)message.Data;
switch (data.FacilityMessageType)
{
case FacilityMessageType.Upgrade:
var upgradeMsg = (FacilityUpgradeMsgData)message.Data;
LunaLog.Normal($"{client.PlayerName} UPGRADED facility {upgradeMsg.ObjectId} to level: {upgradeMsg.Level}");
break;
case FacilityMessageType.Repair:
LunaLog.Normal($"{client.PlayerName} REPAIRED facility {data.ObjectId}");
break;
case FacilityMessageType.Collapse:
LunaLog.Normal($"{client.PlayerName} DESTROYED facility {data.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, message.Data);
}
public override void HandleMessage(ClientStructure client, IClientMessageBase message)
{
var data = (FacilityBaseMsgData)message.Data;
switch (data.FacilityMessageType)
{
case FacilityMessageType.Repair:
LunaLog.Normal($"{client.PlayerName} REPAIRED facility {data.ObjectId}");
ScenarioDataUpdater.WriteRepairedDestroyedDataToFile(data.ObjectId, true);
break;
case FacilityMessageType.Collapse:
LunaLog.Normal($"{client.PlayerName} DESTROYED facility {data.ObjectId}");
ScenarioDataUpdater.WriteRepairedDestroyedDataToFile(data.ObjectId, false);
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, message.Data);
}
public override void HandleMessage(ClientStructure client, IClientMessageBase message)
{
var messageData = message.Data as WarpBaseMsgData;
switch (messageData?.WarpMessageType)
{
case WarpMessageType.NewSubspace:
WarpReceiver.HandleNewSubspace(client, (WarpNewSubspaceMsgData)messageData);
break;
case WarpMessageType.ChangeSubspace:
WarpReceiver.HandleChangeSubspace(client, (WarpChangeSubspaceMsgData)messageData);
break;
case WarpMessageType.SubspacesRequest:
WarpSystemSender.SendAllSubspaces(client);
//We don't use this message anymore so we can recycle it
message.Recycle();
break;
default:
throw new NotImplementedException("Warp Type not implemented");
}
}
public abstract void HandleMessage(ClientStructure client, IClientMessageBase message);
public override void HandleMessage(ClientStructure client, IClientMessageBase message)
{
//We don't use this message anymore so we can recycle it
message.Recycle();
var msgData = ServerContext.ServerMessageFactory.CreateNewMessageData <SettingsReplyMsgData>();
msgData.WarpMode = WarpSettings.SettingsStore.WarpMode;
msgData.GameMode = GeneralSettings.SettingsStore.GameMode;
msgData.TerrainQuality = GeneralSettings.SettingsStore.TerrainQuality;
msgData.AllowCheats = GeneralSettings.SettingsStore.Cheats;
msgData.AllowAdmin = !string.IsNullOrEmpty(GeneralSettings.SettingsStore.AdminPassword);
msgData.AllowSackKerbals = GeneralSettings.SettingsStore.AllowSackKerbals;
msgData.AllowQuicksaves = GeneralSettings.SettingsStore.AllowQuicksaves;
msgData.MaxNumberOfAsteroids = GeneralSettings.SettingsStore.NumberOfAsteroids;
msgData.ConsoleIdentifier = GeneralSettings.SettingsStore.ConsoleIdentifier;
msgData.GameDifficulty = GeneralSettings.SettingsStore.GameDifficulty;
msgData.SafetyBubbleDistance = GeneralSettings.SettingsStore.SafetyBubbleDistance;
msgData.MaxVesselParts = GeneralSettings.SettingsStore.MaxVesselParts;
msgData.VesselUpdatesMsInterval = IntervalSettings.SettingsStore.VesselUpdatesMsInterval;
msgData.SecondaryVesselUpdatesMsInterval = IntervalSettings.SettingsStore.SecondaryVesselUpdatesMsInterval;
msgData.MinScreenshotIntervalMs = ScreenshotSettings.SettingsStore.MinScreenshotIntervalMs;
msgData.MaxScreenshotWidth = ScreenshotSettings.SettingsStore.MaxScreenshotWidth;
msgData.MaxScreenshotHeight = ScreenshotSettings.SettingsStore.MaxScreenshotHeight;
msgData.MinCraftLibraryRequestIntervalMs = CraftSettings.SettingsStore.MinCraftLibraryRequestIntervalMs;
msgData.PrintMotdInChat = GeneralSettings.SettingsStore.PrintMotdInChat;
if (GeneralSettings.SettingsStore.GameDifficulty == GameDifficulty.Custom && GameplaySettings.SettingsStore != null)
{
msgData.EnableCommNet = GameplaySettings.SettingsStore.CommNetwork;
msgData.RespawnTimer = GameplaySettings.SettingsStore.RespawnTime;
msgData.AllowOtherLaunchSites = GameplaySettings.SettingsStore.AllowOtherLaunchSites;
msgData.AllowStockVessels = GameplaySettings.SettingsStore.AllowStockVessels;
msgData.AutoHireCrews = GameplaySettings.SettingsStore.AutoHireCrews;
msgData.BypassEntryPurchaseAfterResearch = GameplaySettings.SettingsStore.BypassEntryPurchaseAfterResearch;
msgData.IndestructibleFacilities = GameplaySettings.SettingsStore.IndestructibleFacilities;
msgData.MissingCrewsRespawn = GameplaySettings.SettingsStore.MissingCrewsRespawn;
msgData.ReentryHeatScale = GameplaySettings.SettingsStore.ReentryHeatScale;
msgData.ResourceAbundance = GameplaySettings.SettingsStore.ResourceAbundance;
msgData.FundsGainMultiplier = GameplaySettings.SettingsStore.FundsGainMultiplier;
msgData.CanRevert = GameplaySettings.SettingsStore.CanRevert;
msgData.RepLossDeclined = GameplaySettings.SettingsStore.RepLossDeclined;
msgData.FundsLossMultiplier = GameplaySettings.SettingsStore.FundsLossMultiplier;
msgData.RepGainMultiplier = GameplaySettings.SettingsStore.RepGainMultiplier;
msgData.RepLossMultiplier = GameplaySettings.SettingsStore.RepLossMultiplier;
msgData.ScienceGainMultiplier = GameplaySettings.SettingsStore.ScienceGainMultiplier;
msgData.StartingFunds = GameplaySettings.SettingsStore.StartingFunds;
msgData.StartingReputation = GameplaySettings.SettingsStore.StartingReputation;
msgData.StartingScience = GameplaySettings.SettingsStore.StartingScience;
//Advanced
msgData.ActionGroupsAlways = GameplaySettings.SettingsStore.ActionGroupsAlways;
msgData.GKerbalLimits = GameplaySettings.SettingsStore.GKerbalLimits;
msgData.GPartLimits = GameplaySettings.SettingsStore.GPartLimits;
msgData.KerbalGToleranceMult = GameplaySettings.SettingsStore.KerbalGToleranceMult;
msgData.PressurePartLimits = GameplaySettings.SettingsStore.PressurePartLimits;
msgData.EnableKerbalExperience = GameplaySettings.SettingsStore.KerbalExp;
msgData.ImmediateLevelUp = GameplaySettings.SettingsStore.ImmediateLevelUp;
msgData.AllowNegativeCurrency = GameplaySettings.SettingsStore.AllowNegativeCurrency;
msgData.ResourceTransferObeyCrossfeed = GameplaySettings.SettingsStore.ObeyCrossfeedRules;
msgData.BuildingImpactDamageMult = GameplaySettings.SettingsStore.BuildingDamageMultiplier;
msgData.PartUpgradesInCareerAndSandbox = GameplaySettings.SettingsStore.PartUpgrades;
//Commnet
msgData.RequireSignalForControl = GameplaySettings.SettingsStore.RequireSignalForControl;
msgData.DsnModifier = GameplaySettings.SettingsStore.DsnModifier;
msgData.RangeModifier = GameplaySettings.SettingsStore.RangeModifier;
msgData.OcclusionMultiplierVac = GameplaySettings.SettingsStore.OcclusionModifierVac;
msgData.OcclusionMultiplierAtm = GameplaySettings.SettingsStore.OcclusionModifierAtm;
msgData.EnableGroundStations = GameplaySettings.SettingsStore.ExtraGroundstations;
msgData.PlasmaBlackout = GameplaySettings.SettingsStore.ReentryBlackout;
}
MessageQueuer.SendToClient <SetingsSrvMsg>(client, msgData);
}
public virtual void OnMessageReceived(ClientStructure client, IClientMessageBase messageData)
{
}
public void OnMessageReceived(ClientStructure client, IClientMessageBase messageData)
{
LuaScriptManger.CallHandler("OnMessageReceived", client, messageData);
}
