private static bool CheckFile(IEnumerable <string> gameFileRelativePaths, ModItem item, bool required)
{
if (item.ModFilename.EndsWith("dll"))
{
var fileExists = SystemsContainer.Get <ModSystem>().DllList.ContainsKey(item.ModFilename);
if (!fileExists && required)
{
Sb.AppendLine($"Required file {item.ModFilename} is missing!");
return(false);
}
if (fileExists && !string.IsNullOrEmpty(item.Sha) && SystemsContainer.Get <ModSystem>().DllList[item.ModFilename] != item.Sha)
{
Sb.AppendLine($"Required file {item.ModFilename} does not match hash {item.Sha}!");
return(false);
}
}
else
{
var filePath = gameFileRelativePaths.FirstOrDefault(f => f.Equals(item.ModFilename, StringComparison.OrdinalIgnoreCase));
if (string.IsNullOrEmpty(filePath) && required) //Only show error if the file is required
{
Sb.AppendLine($"Required file {item.ModFilename} is missing!");
return(false);
}
if (!string.IsNullOrEmpty(filePath) && !string.IsNullOrEmpty(item.Sha))
{
var fullFilePath = CommonUtil.CombinePaths(Client.KspPath, "GameData", filePath);
if (Common.CalculateSha256Hash(fullFilePath) != item.Sha)
{
Sb.AppendLine($"File {item.ModFilename} does not match hash {item.Sha}!");
return(false);
}
}
}
return(true);
}
public void HandleMessage(IServerMessageBase msg)
{
if (!(msg.Data is CraftLibraryBaseMsgData msgData))
{
return;
}
switch (msgData.CraftMessageType)
{
case CraftMessageType.ListReply:
{
var data = (CraftLibraryListReplyMsgData)msgData;
for (var i = 0; i < data.PlayerCraftsCount; i++)
{
if (data.PlayerCrafts[i].Crafts.VabExists)
{
for (var j = 0; j < data.PlayerCrafts[i].Crafts.VabCraftCount; j++)
{
System.QueueCraftAdd(new CraftChangeEntry
{
PlayerName = data.PlayerCrafts[i].PlayerName,
CraftType = CraftType.Vab,
CraftName = data.PlayerCrafts[i].Crafts.VabCraftNames[j]
});
}
}
if (data.PlayerCrafts[i].Crafts.SphExists)
{
for (var j = 0; j < data.PlayerCrafts[i].Crafts.SphCraftCount; j++)
{
System.QueueCraftAdd(new CraftChangeEntry
{
PlayerName = data.PlayerCrafts[i].PlayerName,
CraftType = CraftType.Sph,
CraftName = data.PlayerCrafts[i].Crafts.SphCraftNames[j]
});
}
}
if (data.PlayerCrafts[i].Crafts.SubassemblyExists)
{
for (var j = 0; j < data.PlayerCrafts[i].Crafts.SubassemblyCraftCount; j++)
{
System.QueueCraftAdd(new CraftChangeEntry
{
PlayerName = data.PlayerCrafts[i].PlayerName,
CraftType = CraftType.Subassembly,
CraftName = data.PlayerCrafts[i].Crafts.SubassemblyCraftNames[j]
});
}
}
}
MainSystem.NetworkState = ClientState.CraftlibrarySynced;
}
break;
case CraftMessageType.AddFile:
{
var data = (CraftLibraryAddMsgData)msgData;
var cce = new CraftChangeEntry
{
PlayerName = data.PlayerName,
CraftType = data.UploadType,
CraftName = data.UploadName
};
System.QueueCraftAdd(cce);
SystemsContainer.Get <ChatSystem>().Queuer.QueueChannelMessage(SettingsSystem.ServerSettings.ConsoleIdentifier, "",
$"{cce.PlayerName} shared {cce.CraftName} ({cce.CraftType})");
}
break;
case CraftMessageType.DeleteFile:
{
var data = (CraftLibraryDeleteMsgData)msgData;
var cce = new CraftChangeEntry
{
PlayerName = data.PlayerName,
CraftType = data.CraftType,
CraftName = data.CraftName
};
System.QueueCraftDelete(cce);
}
break;
case CraftMessageType.RespondFile:
{
var data = (CraftLibraryRespondMsgData)msgData;
var craftData = Common.TrimArray(data.CraftData, data.NumBytes);
var cre = new CraftResponseEntry
{
PlayerName = data.PlayerName,
CraftType = data.RequestedType,
CraftName = data.RequestedName,
CraftData = craftData
};
System.QueueCraftResponse(cre);
}
break;
}
}
public double GetCurrentError() => Synced?Planetarium.GetUniversalTime() - SystemsContainer.Get <WarpSystem>().GetCurrentSubspaceTime() : 0;
public void HandleMessage(IMessageData messageData)
{
var msgData = messageData as SettingsReplyMsgData;
if (msgData == null)
{
return;
}
SettingsSystem.ServerSettings.WarpMode = msgData.WarpMode;
SettingsSystem.ServerSettings.GameMode = msgData.GameMode;
SettingsSystem.ServerSettings.AllowCheats = msgData.AllowCheats;
SettingsSystem.ServerSettings.MaxNumberOfAsteroids = msgData.MaxNumberOfAsteroids;
SettingsSystem.ServerSettings.ConsoleIdentifier = msgData.ConsoleIdentifier;
SettingsSystem.ServerSettings.SafetyBubbleDistance = msgData.SafetyBubbleDistance;
SettingsSystem.ServerSettings.VesselUpdatesSendMsInterval = msgData.VesselUpdatesSendMsInterval;
SettingsSystem.ServerSettings.SecondaryVesselUpdatesSendMsInterval = msgData.SecondaryVesselUpdatesSendMsInterval;
SettingsSystem.ServerSettings.DropControlOnVesselSwitching = msgData.DropControlOnVesselSwitching;
SettingsSystem.ServerSettings.DropControlOnExitFlight = msgData.DropControlOnExitFlight;
SettingsSystem.ServerSettings.SendScenarioDataMsInterval = msgData.SendScenarioDataMsInterval;
SettingsSystem.ServerSettings.VesselKillCheckMsInterval = msgData.VesselKillCheckMsInterval;
SettingsSystem.ServerSettings.StrandedVesselsCheckMsInterval = msgData.StrandedVesselsCheckMsInterval;
SettingsSystem.ServerSettings.VesselDefinitionSendMsInterval = msgData.VesselDefinitionSendMsInterval;
SettingsSystem.ServerSettings.VesselDefinitionSendFarMsInterval = msgData.VesselDefinitionSendFarMsInterval;
SettingsSystem.ServerSettings.AbandonedVesselsUpdateMsInterval = msgData.AbandonedVesselsUpdateMsInterval;
SettingsSystem.ServerSettings.ShowVesselsInThePast = msgData.ShowVesselsInThePast;
SettingsSystem.ServerSettings.ClockSetMsInterval = msgData.ClockSetMsInterval;
SettingsSystem.ServerSettings.WarpMaster = msgData.WarpMaster;
SettingsSystem.ServerSettings.DropControlOnExit = msgData.DropControlOnExit;
SettingsSystem.ServerSettings.GameDifficulty = msgData.GameDifficulty;
if (SettingsSystem.ServerSettings.GameDifficulty != GameDifficulty.Custom)
{
SettingsSystem.ServerSettings.ServerParameters =
GameParameters.GetDefaultParameters(
SystemsContainer.Get <MainSystem>().ConvertGameMode(SettingsSystem.ServerSettings.GameMode),
(GameParameters.Preset)SettingsSystem.ServerSettings.GameDifficulty);
}
else
{
SettingsSystem.ServerSettings.ServerParameters = new GameParameters
{
Difficulty =
{
AllowStockVessels = msgData.AllowStockVessels,
AutoHireCrews = msgData.AutoHireCrews,
BypassEntryPurchaseAfterResearch = msgData.BypassEntryPurchaseAfterResearch,
IndestructibleFacilities = msgData.IndestructibleFacilities,
MissingCrewsRespawn = msgData.MissingCrewsRespawn,
ReentryHeatScale = msgData.ReentryHeatScale,
ResourceAbundance = msgData.ResourceAbundance,
RespawnTimer = msgData.RespawnTimer,
EnableCommNet = msgData.EnableCommNet
},
Career =
{
FundsGainMultiplier = msgData.FundsGainMultiplier,
FundsLossMultiplier = msgData.FundsLossMultiplier,
RepGainMultiplier = msgData.RepGainMultiplier,
RepLossMultiplier = msgData.RepLossMultiplier,
RepLossDeclined = msgData.RepLossDeclined,
ScienceGainMultiplier = msgData.ScienceGainMultiplier,
StartingFunds = msgData.StartingFunds,
StartingReputation = msgData.StartingReputation,
StartingScience = msgData.StartingScience
},
Flight =
{
CanQuickLoad = msgData.CanQuickLoad,
CanRestart = msgData.CanQuickLoad,
CanLeaveToEditor = msgData.CanQuickLoad
}
};
SettingsSystem.ServerSettings.ServerAdvancedParameters = new GameParameters.AdvancedParams
{
ActionGroupsAlways = msgData.ActionGroupsAlways,
GKerbalLimits = msgData.GKerbalLimits,
GPartLimits = msgData.GPartLimits,
KerbalGToleranceMult = msgData.KerbalGToleranceMult,
PressurePartLimits = msgData.PressurePartLimits,
AllowNegativeCurrency = msgData.AllowNegativeCurrency,
EnableKerbalExperience = msgData.EnableKerbalExperience,
ImmediateLevelUp = msgData.ImmediateLevelUp,
ResourceTransferObeyCrossfeed = msgData.ResourceTransferObeyCrossfeed,
BuildingImpactDamageMult = msgData.BuildingImpactDamageMult,
PartUpgradesInCareer = msgData.PartUpgradesInCareerAndSandbox,
PartUpgradesInSandbox = msgData.PartUpgradesInCareerAndSandbox
};
SettingsSystem.ServerSettings.ServerCommNetParameters = new CommNetParams
{
requireSignalForControl = msgData.RequireSignalForControl,
DSNModifier = msgData.DsnModifier,
rangeModifier = msgData.RangeModifier,
occlusionMultiplierVac = msgData.OcclusionMultiplierVac,
occlusionMultiplierAtm = msgData.OcclusionMultiplierAtm,
enableGroundStations = msgData.EnableGroundStations,
plasmaBlackout = msgData.PlasmaBlackout
};
}
SystemsContainer.Get <MainSystem>().NetworkState = ClientState.SettingsSynced;
}
public override void Update()
{
Status = SystemsContainer.Get <MainSystem>().Status;
SelectedSafe = Selected;
AddingServerSafe = AddingServer;
}
public void HandleMessage(IMessageData messageData)
{
var msgData = messageData as WarpBaseMsgData;
if (msgData == null)
{
return;
}
switch (msgData.WarpMessageType)
{
case WarpMessageType.SubspacesReply:
{
var data = (WarpSubspacesReplyMsgData)messageData;
for (var i = 0; i < data.SubspaceKey.Length; i++)
{
AddSubspace(data.SubspaceKey[i], data.SubspaceTime[i]);
}
foreach (var ps in data.Players)
{
if (System.ClientSubspaceList.ContainsKey(ps.Value))
{
System.ClientSubspaceList[ps.Value] = ps.Key;
}
else
{
System.ClientSubspaceList.TryAdd(ps.Value, ps.Key);
}
}
AddSubspace(-1, 0); //Add warping subspace
SystemsContainer.Get <MainSystem>().NetworkState = ClientState.WarpsubspacesSynced;
}
break;
case WarpMessageType.NewSubspace:
{
var data = (WarpNewSubspaceMsgData)messageData;
AddSubspace(data.SubspaceKey, data.ServerTimeDifference);
if (data.PlayerCreator == SettingsSystem.CurrentSettings.PlayerName)
{
//It's our subspace that we just created so set it as ours
System.WaitingSubspaceIdFromServer = false;
System.SkipSubspaceProcess = true;
System.CurrentSubspace = data.SubspaceKey;
}
}
break;
case WarpMessageType.ChangeSubspace:
{
var data = (WarpChangeSubspaceMsgData)messageData;
System.ClientSubspaceList[data.PlayerName] = data.Subspace;
}
break;
default:
{
LunaLog.LogError($"[LMP]: Unhandled WARP_MESSAGE type: {((WarpBaseMsgData)messageData).WarpMessageType}");
break;
}
}
}
public void DrawContent(int windowId)
{
if (!LoadEventHandled)
{
LoadEventHandled = true;
TempColor = SettingsSystem.CurrentSettings.PlayerColor;
NewCacheSize = SettingsSystem.CurrentSettings.CacheSize.ToString();
}
//Player color
GUILayout.BeginVertical();
GUI.DragWindow(MoveRect);
GUILayout.BeginHorizontal();
GUILayout.Label("Player Name color: ");
GUILayout.Label(SettingsSystem.CurrentSettings.PlayerName, TempColorLabelStyle);
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label("R: ");
TempColor.r = GUILayout.HorizontalScrollbar(TempColor.r, 0, 0, 1);
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label("G: ");
TempColor.g = GUILayout.HorizontalScrollbar(TempColor.g, 0, 0, 1);
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label("B: ");
TempColor.b = GUILayout.HorizontalScrollbar(TempColor.b, 0, 0, 1);
GUILayout.EndHorizontal();
TempColorLabelStyle.active.textColor = TempColor;
TempColorLabelStyle.normal.textColor = TempColor;
GUILayout.BeginHorizontal();
if (GUILayout.Button("Random", ButtonStyle))
{
TempColor = PlayerColorSystem.GenerateRandomColor();
}
if (GUILayout.Button("Set", ButtonStyle))
{
WindowsContainer.Get <StatusWindow>().ColorEventHandled = false;
SettingsSystem.CurrentSettings.PlayerColor = TempColor;
SettingsSystem.SaveSettings();
if (MainSystem.NetworkState == ClientState.Running)
{
SystemsContainer.Get <PlayerColorSystem>().MessageSender.SendPlayerColorToServer();
}
}
GUILayout.EndHorizontal();
GUILayout.Space(10);
//Cache
var enableCache = GUILayout.Toggle(SettingsSystem.CurrentSettings.EnableCache, "Enable cache", ButtonStyle);
if (enableCache != SettingsSystem.CurrentSettings.EnableCache)
{
if (!enableCache)
{
UniverseSyncCache.DeleteCache(); //Remove all cache when deactivating it
}
SettingsSystem.CurrentSettings.EnableCache = enableCache;
SettingsSystem.SaveSettings();
}
if (SettingsSystem.CurrentSettings.EnableCache)
{
GUILayout.Label("Cache size");
GUILayout.Label($"Current size: {Math.Round(UniverseSyncCache.CurrentCacheSize / (float)(1024 * 1024), 3)} MB.");
GUILayout.Label($"Max size: {SettingsSystem.CurrentSettings.CacheSize} MB.");
NewCacheSize = GUILayout.TextArea(NewCacheSize);
GUILayout.BeginHorizontal();
if (GUILayout.Button("Set", ButtonStyle))
{
if (int.TryParse(NewCacheSize, out var tempCacheSize))
{
if (tempCacheSize < 1)
{
tempCacheSize = 1;
NewCacheSize = tempCacheSize.ToString();
}
if (tempCacheSize > 1000)
{
tempCacheSize = 1000;
NewCacheSize = tempCacheSize.ToString();
}
SettingsSystem.CurrentSettings.CacheSize = tempCacheSize;
SettingsSystem.SaveSettings();
}
else
{
NewCacheSize = SettingsSystem.CurrentSettings.CacheSize.ToString();
}
}
if (GUILayout.Button("Expire cache"))
{
UniverseSyncCache.ExpireCache();
}
if (GUILayout.Button("Delete cache"))
{
UniverseSyncCache.DeleteCache();
}
GUILayout.EndHorizontal();
}
//Key bindings
GUILayout.Space(10);
var chatDescription = $"Set chat key (current: {SettingsSystem.CurrentSettings.ChatKey})";
if (SettingChat)
{
chatDescription = "Setting chat key (click to cancel)...";
if (Event.current.isKey)
{
if (Event.current.keyCode != KeyCode.Escape)
{
SettingsSystem.CurrentSettings.ChatKey = Event.current.keyCode;
SettingsSystem.SaveSettings();
SettingChat = false;
}
else
{
SettingChat = false;
}
}
}
if (GUILayout.Button(chatDescription))
{
SettingChat = !SettingChat;
}
GUILayout.Space(10);
GUILayout.Label("Generate a server LMPModControl:");
if (GUILayout.Button("Generate blacklist LMPModControl.txt"))
{
SystemsContainer.Get <ModSystem>().GenerateModControlFile(false);
}
if (GUILayout.Button("Generate whitelist LMPModControl.txt"))
{
SystemsContainer.Get <ModSystem>().GenerateModControlFile(true);
}
WindowsContainer.Get <UniverseConverterWindow>().Display = GUILayout.Toggle(WindowsContainer.Get <UniverseConverterWindow>().Display, "Generate Universe from saved game", ButtonStyle);
if (GUILayout.Button("Reset disclaimer"))
{
SettingsSystem.CurrentSettings.DisclaimerAccepted = false;
SettingsSystem.SaveSettings();
}
var settingCompression = GUILayout.Toggle(SettingsSystem.CurrentSettings.CompressionEnabled, "Enable compression", ButtonStyle);
if (settingCompression != SettingsSystem.CurrentSettings.CompressionEnabled)
{
SettingsSystem.CurrentSettings.CompressionEnabled = settingCompression;
SettingsSystem.SaveSettings();
}
var settingInterpolation = GUILayout.Toggle(SettingsSystem.CurrentSettings.InterpolationEnabled, "Enable interpolation", ButtonStyle);
if (settingInterpolation != SettingsSystem.CurrentSettings.InterpolationEnabled)
{
SettingsSystem.CurrentSettings.InterpolationEnabled = settingInterpolation;
SettingsSystem.SaveSettings();
}
var positionFudge = GUILayout.Toggle(SettingsSystem.CurrentSettings.PositionFudgeEnable, "Enable position fudge", ButtonStyle);
if (positionFudge != SettingsSystem.CurrentSettings.PositionFudgeEnable)
{
SettingsSystem.CurrentSettings.PositionFudgeEnable = positionFudge;
SettingsSystem.SaveSettings();
}
var altPositionSystem = GUILayout.Toggle(SettingsSystem.CurrentSettings.UseAlternativePositionSystem, "Use alterative position system", ButtonStyle);
if (altPositionSystem != SettingsSystem.CurrentSettings.UseAlternativePositionSystem)
{
SettingsSystem.CurrentSettings.UseAlternativePositionSystem = altPositionSystem;
SettingsSystem.SaveSettings();
}
var packOtherVessels = GUILayout.Toggle(SettingsSystem.CurrentSettings.PackOtherControlledVessels, "Pack other vessels", ButtonStyle);
if (packOtherVessels != SettingsSystem.CurrentSettings.PackOtherControlledVessels)
{
SettingsSystem.CurrentSettings.PackOtherControlledVessels = packOtherVessels;
SettingsSystem.SaveSettings();
}
GUILayout.BeginHorizontal();
GUILayout.Label("Toolbar:", SmallOption);
if (GUILayout.Button(ToolbarMode, ButtonStyle))
{
var newSetting = (int)SettingsSystem.CurrentSettings.ToolbarType + 1;
//Overflow to 0
if (!Enum.IsDefined(typeof(LmpToolbarType), newSetting))
{
newSetting = 0;
}
SettingsSystem.CurrentSettings.ToolbarType = (LmpToolbarType)newSetting;
SettingsSystem.SaveSettings();
UpdateToolbarString();
SystemsContainer.Get <ToolbarSystem>().ToolbarChanged();
}
GUILayout.EndHorizontal();
#if DEBUG
if (GUILayout.Button("Check Common.dll stock parts"))
{
SystemsContainer.Get <ModSystem>().CheckCommonStockParts();
}
#endif
GUILayout.FlexibleSpace();
if (GUILayout.Button("Close", ButtonStyle))
{
Display = false;
}
GUILayout.EndVertical();
}
public void OnApplicationQuit()
{
SystemsContainer.Get <MainSystem>().OnExit();
}
public void StopSpectating()
{
InputLockManager.RemoveControlLock(SpectateLock);
SystemsContainer.Get <LockSystem>().ReleaseSpectatorLock();
VesselCommon.IsSpectating = false;
}
public void DrawContent(int windowId)
{
if (!LoadEventHandled)
{
LoadEventHandled = true;
TempColor = SettingsSystem.CurrentSettings.PlayerColor;
}
//Player color
GUILayout.BeginVertical();
GUI.DragWindow(MoveRect);
GUILayout.BeginHorizontal();
GUILayout.Label("Player Name color: ");
GUILayout.Label(SettingsSystem.CurrentSettings.PlayerName, TempColorLabelStyle);
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label("R: ", SmallOption);
TempColor.r = GUILayout.HorizontalScrollbar(TempColor.r, 0, 0, 1);
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label("G: ", SmallOption);
TempColor.g = GUILayout.HorizontalScrollbar(TempColor.g, 0, 0, 1);
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label("B: ", SmallOption);
TempColor.b = GUILayout.HorizontalScrollbar(TempColor.b, 0, 0, 1);
GUILayout.EndHorizontal();
TempColorLabelStyle.active.textColor = TempColor;
TempColorLabelStyle.normal.textColor = TempColor;
GUILayout.BeginHorizontal();
if (GUILayout.Button("Random", ButtonStyle))
{
TempColor = PlayerColorSystem.GenerateRandomColor();
}
if (GUILayout.Button("Set", ButtonStyle))
{
WindowsContainer.Get <StatusWindow>().ColorEventHandled = false;
SettingsSystem.CurrentSettings.PlayerColor = TempColor;
SettingsSystem.SaveSettings();
if (MainSystem.NetworkState == ClientState.Running)
{
SystemsContainer.Get <PlayerColorSystem>().MessageSender.SendPlayerColorToServer();
}
}
GUILayout.EndHorizontal();
GUILayout.Space(10);
//Key bindings
var chatDescription = $"Set chat key (current: {SettingsSystem.CurrentSettings.ChatKey})";
if (SettingChat)
{
chatDescription = "Setting chat key (click to cancel)...";
if (Event.current.isKey)
{
if (Event.current.keyCode != KeyCode.Escape)
{
SettingsSystem.CurrentSettings.ChatKey = Event.current.keyCode;
SettingsSystem.SaveSettings();
SettingChat = false;
}
else
{
SettingChat = false;
}
}
}
if (GUILayout.Button(chatDescription))
{
SettingChat = !SettingChat;
}
if (GUILayout.Button("Reset disclaimer"))
{
SettingsSystem.CurrentSettings.DisclaimerAccepted = false;
SettingsSystem.SaveSettings();
}
var settingInterpolation = GUILayout.Toggle(SettingsSystem.CurrentSettings.InterpolationEnabled, "Enable interpolation", ButtonStyle);
if (settingInterpolation != SettingsSystem.CurrentSettings.InterpolationEnabled)
{
SettingsSystem.CurrentSettings.InterpolationEnabled = settingInterpolation;
SettingsSystem.SaveSettings();
}
var closeBtnInConnectionWindow = GUILayout.Toggle(SettingsSystem.CurrentSettings.CloseBtnInConnectionWindow, "Show \"Close\" button in connection window", ButtonStyle);
if (closeBtnInConnectionWindow != SettingsSystem.CurrentSettings.CloseBtnInConnectionWindow)
{
SettingsSystem.CurrentSettings.CloseBtnInConnectionWindow = closeBtnInConnectionWindow;
SettingsSystem.SaveSettings();
}
GUILayout.Space(10);
GUILayout.BeginVertical();
GUILayout.Label("Positioning system:");
var positionSetting = GUILayout.SelectionGrid(SettingsSystem.CurrentSettings.PositionSystem, new[] { "Dark", "Dagger", "Mixed" }, 3, "toggle");
if (positionSetting != SettingsSystem.CurrentSettings.PositionSystem)
{
SettingsSystem.CurrentSettings.PositionSystem = positionSetting;
SettingsSystem.SaveSettings();
}
GUILayout.EndVertical();
GUILayout.Space(10);
GUILayout.Label("Generate a server LMPModControl:");
if (GUILayout.Button("Generate blacklist LMPModControl.txt"))
{
SystemsContainer.Get <ModSystem>().GenerateModControlFile(false);
}
if (GUILayout.Button("Generate whitelist LMPModControl.txt"))
{
SystemsContainer.Get <ModSystem>().GenerateModControlFile(true);
}
WindowsContainer.Get <UniverseConverterWindow>().Display = GUILayout.Toggle(WindowsContainer.Get <UniverseConverterWindow>().Display, "Generate Universe from saved game", ButtonStyle);
GUILayout.Space(10);
GUILayout.BeginHorizontal();
GUILayout.Label("Toolbar:", SmallOption);
if (GUILayout.Button(ToolbarMode, ButtonStyle))
{
var newSetting = (int)SettingsSystem.CurrentSettings.ToolbarType + 1;
//Overflow to 0
if (!Enum.IsDefined(typeof(LmpToolbarType), newSetting))
{
newSetting = 0;
}
SettingsSystem.CurrentSettings.ToolbarType = (LmpToolbarType)newSetting;
SettingsSystem.SaveSettings();
UpdateToolbarString();
SystemsContainer.Get <ToolbarSystem>().ToolbarChanged();
}
GUILayout.EndHorizontal();
#if DEBUG
DrawAdvancedDebugOptions();
#endif
GUILayout.FlexibleSpace();
if (GUILayout.Button("Close", ButtonStyle))
{
Display = false;
}
GUILayout.EndVertical();
}
private void DrawAdvancedDebugOptions()
{
if (GUILayout.Button("Check Common.dll stock parts"))
{
SystemsContainer.Get <ModSystem>().CheckCommonStockParts();
}
GUILayout.Space(10);
ShowAdvancedNetworkFields = GUILayout.Toggle(ShowAdvancedNetworkFields, "Advanced network fields", ButtonStyle);
if (ShowAdvancedNetworkFields)
{
if (MainSystem.NetworkState > ClientState.Disconnected)
{
GUILayout.Label("Cannot change values while connected");
}
GUILayout.Label($"MTU: {NetworkMain.Config.MaximumTransmissionUnit}");
//if (MainSystem.NetworkState <= ClientState.Disconnected)
// NetworkMain.Config.MaximumTransmissionUnit = (int)GUILayout.HorizontalScrollbar(NetworkMain.Config.MaximumTransmissionUnit, 0, 0, 10000);
GUILayout.Label(InfiniteTimeout
? "Timeout: Infinite"
: $"Timeout: {NetworkMain.Config.ConnectionTimeout}s. Minimum: {NetworkMain.Config.PingInterval}s");
GUILayout.BeginHorizontal();
if (MainSystem.NetworkState <= ClientState.Disconnected)
{
InfiniteTimeout = GUILayout.Toggle(InfiniteTimeout, "Infinite", "toggle");
if (!InfiniteTimeout)
{
if (NetworkMain.Config.ConnectionTimeout >= float.MaxValue - 1)
{
NetworkMain.Config.ConnectionTimeout = 15;
}
var value = GUILayout.TextArea(NetworkMain.Config.ConnectionTimeout.ToString(CultureInfo.InvariantCulture), 32, TextAreaStyle);
if (float.TryParse(value, out var parsedResult))
{
if (parsedResult >= NetworkMain.Config.PingInterval)
{
NetworkMain.Config.ConnectionTimeout = parsedResult;
}
}
}
else
{
NetworkMain.Config.ConnectionTimeout = float.MaxValue;
}
}
GUILayout.EndHorizontal();
}
ShowBadNetworkSimulationFields = GUILayout.Toggle(ShowBadNetworkSimulationFields, "Bad network simulation", ButtonStyle);
if (ShowBadNetworkSimulationFields)
{
GUILayout.Label($"NTP time offset: {LunaTime.SimulatedMsTimeOffset:F1}ms");
LunaTime.SimulatedMsTimeOffset = (float)Math.Round(GUILayout.HorizontalScrollbar(LunaTime.SimulatedMsTimeOffset, 0, -2500, 2500), 3);
if (MainSystem.NetworkState > ClientState.Disconnected)
{
GUILayout.Label("Cannot change values while connected");
}
GUILayout.Label($"Packet loss: {NetworkMain.Config.SimulatedLoss * 100:F1}%");
if (MainSystem.NetworkState <= ClientState.Disconnected)
{
NetworkMain.Config.SimulatedLoss = (float)Math.Round(GUILayout.HorizontalScrollbar(NetworkMain.Config.SimulatedLoss, 0, 0, 1), 3);
}
GUILayout.Label($"Packet duplication: {NetworkMain.Config.SimulatedDuplicatesChance * 100:F1}%");
if (MainSystem.NetworkState <= ClientState.Disconnected)
{
NetworkMain.Config.SimulatedDuplicatesChance = (float)Math.Round(GUILayout.HorizontalScrollbar(NetworkMain.Config.SimulatedDuplicatesChance, 0, 0, 1), 3);
}
GUILayout.Label($"Max random latency: {NetworkMain.Config.SimulatedRandomLatency * 1000:F1} ms");
if (MainSystem.NetworkState <= ClientState.Disconnected)
{
NetworkMain.Config.SimulatedRandomLatency = (float)Math.Round(GUILayout.HorizontalScrollbar(NetworkMain.Config.SimulatedRandomLatency, 0, 0, 3), 4);
}
GUILayout.Label($"Min latency: {NetworkMain.Config.SimulatedMinimumLatency * 1000:F1} ms");
if (MainSystem.NetworkState <= ClientState.Disconnected)
{
NetworkMain.Config.SimulatedMinimumLatency = (float)Math.Round(GUILayout.HorizontalScrollbar(NetworkMain.Config.SimulatedMinimumLatency, 0, 0, 3), 4);
}
}
}
private void PrintSystemButtons()
{
//Asteroid = GUILayout.Toggle(Asteroid, "Asteroid system", ButtonStyle);
//if (Asteroid)
//{
// //This system should never be toggled
// //SystemContainer.Get<AsteroidSystem>().Enabled = GUILayout.Toggle(SystemContainer.Get<AsteroidSystem>().Enabled, "ON/OFF", ButtonStyle);
//}
CraftLibrary = GUILayout.Toggle(CraftLibrary, "Craft library system", ButtonStyle);
if (CraftLibrary)
{
SystemsContainer.Get <CraftLibrarySystem>().Enabled = GUILayout.Toggle(SystemsContainer.Get <CraftLibrarySystem>().Enabled, "ON/OFF", ButtonStyle);
}
Facility = GUILayout.Toggle(Facility, "Facility system", ButtonStyle);
if (Facility)
{
SystemsContainer.Get <FacilitySystem>().Enabled = GUILayout.Toggle(SystemsContainer.Get <FacilitySystem>().Enabled, "ON/OFF", ButtonStyle);
}
Flag = GUILayout.Toggle(Flag, "Flag system", ButtonStyle);
if (Flag)
{
SystemsContainer.Get <FlagSystem>().Enabled = GUILayout.Toggle(SystemsContainer.Get <FlagSystem>().Enabled, "ON/OFF", ButtonStyle);
}
GameScene = GUILayout.Toggle(GameScene, "GameScene system", ButtonStyle);
if (GameScene)
{
SystemsContainer.Get <GameSceneSystem>().Enabled = GUILayout.Toggle(SystemsContainer.Get <GameSceneSystem>().Enabled, "ON/OFF", ButtonStyle);
}
Group = GUILayout.Toggle(Group, "Group system", ButtonStyle);
if (Group)
{
SystemsContainer.Get <GroupSystem>().Enabled = GUILayout.Toggle(SystemsContainer.Get <GroupSystem>().Enabled, "ON/OFF", ButtonStyle);
}
Kerbal = GUILayout.Toggle(Kerbal, "Kerbal system", ButtonStyle);
if (Kerbal)
{
SystemsContainer.Get <KerbalSystem>().Enabled = GUILayout.Toggle(SystemsContainer.Get <KerbalSystem>().Enabled, "ON/OFF", ButtonStyle);
}
Lock = GUILayout.Toggle(Lock, "Lock system", ButtonStyle);
if (Lock)
{
SystemsContainer.Get <LockSystem>().Enabled = GUILayout.Toggle(SystemsContainer.Get <LockSystem>().Enabled, "ON/OFF", ButtonStyle);
}
ModS = GUILayout.Toggle(ModS, "Mod system", ButtonStyle);
if (ModS)
{
SystemsContainer.Get <ModSystem>().Enabled = GUILayout.Toggle(SystemsContainer.Get <ModSystem>().Enabled, "ON/OFF", ButtonStyle);
}
//ModApi = GUILayout.Toggle(ModApi, "Mod api system", ButtonStyle);
//if (ModApi)
//{
// //This system cannot be toggled
// //SystemContainer.Get<ModApiSystem>().Enabled = GUILayout.Toggle(SystemContainer.Get<ModApiSystem>().Enabled, "ON/OFF", ButtonStyle);
//}
PlayerColor = GUILayout.Toggle(PlayerColor, "Player color system", ButtonStyle);
if (PlayerColor)
{
SystemsContainer.Get <PlayerColorSystem>().Enabled = GUILayout.Toggle(SystemsContainer.Get <PlayerColorSystem>().Enabled, "ON/OFF", ButtonStyle);
}
PlayerConnection = GUILayout.Toggle(PlayerConnection, "Player connection system", ButtonStyle);
if (PlayerConnection)
{
SystemsContainer.Get <PlayerConnectionSystem>().Enabled = GUILayout.Toggle(SystemsContainer.Get <PlayerConnectionSystem>().Enabled, "ON/OFF", ButtonStyle);
}
Scenario = GUILayout.Toggle(Scenario, "Scenario system", ButtonStyle);
if (Scenario)
{
//This system should never be toggled
SystemsContainer.Get <ScenarioSystem>().Enabled = GUILayout.Toggle(SystemsContainer.Get <ScenarioSystem>().Enabled, "ON/OFF", ButtonStyle);
}
TimeSyncer = GUILayout.Toggle(TimeSyncer, "Time sync system", ButtonStyle);
if (TimeSyncer)
{
SystemsContainer.Get <TimeSyncerSystem>().Enabled = GUILayout.Toggle(SystemsContainer.Get <TimeSyncerSystem>().Enabled, "ON/OFF", ButtonStyle);
}
Toolbar = GUILayout.Toggle(Toolbar, "Toolbar system", ButtonStyle);
if (Toolbar)
{
SystemsContainer.Get <ToolbarSystem>().Enabled = GUILayout.Toggle(SystemsContainer.Get <ToolbarSystem>().Enabled, "ON/OFF", ButtonStyle);
}
VesselDock = GUILayout.Toggle(VesselDock, "Vessel dock", ButtonStyle);
if (VesselDock)
{
SystemsContainer.Get <VesselDockSystem>().Enabled = GUILayout.Toggle(SystemsContainer.Get <VesselDockSystem>().Enabled, "ON/OFF", ButtonStyle);
}
VesselFlightState = GUILayout.Toggle(VesselFlightState, "Vessel flightstate", ButtonStyle);
if (VesselFlightState)
{
SystemsContainer.Get <VesselFlightStateSystem>().Enabled = GUILayout.Toggle(SystemsContainer.Get <VesselFlightStateSystem>().Enabled, "ON/OFF", ButtonStyle);
}
VesselImmortal = GUILayout.Toggle(VesselImmortal, "Vessel immortal", ButtonStyle);
if (VesselImmortal)
{
SystemsContainer.Get <VesselImmortalSystem>().Enabled = GUILayout.Toggle(SystemsContainer.Get <VesselImmortalSystem>().Enabled, "ON/OFF", ButtonStyle);
}
VesselLock = GUILayout.Toggle(VesselLock, "Vessel lock", ButtonStyle);
if (VesselLock)
{
SystemsContainer.Get <VesselLockSystem>().Enabled = GUILayout.Toggle(SystemsContainer.Get <VesselLockSystem>().Enabled, "ON/OFF", ButtonStyle);
}
VesselPosition = GUILayout.Toggle(VesselPosition, "Vessel position", ButtonStyle);
if (VesselPosition)
{
SystemsContainer.Get <VesselPositionSystem>().Enabled = GUILayout.Toggle(SystemsContainer.Get <VesselPositionSystem>().Enabled, "ON/OFF", ButtonStyle);
}
VesselUpdate = GUILayout.Toggle(VesselUpdate, "Vessel update", ButtonStyle);
if (VesselUpdate)
{
SystemsContainer.Get <VesselUpdateSystem>().Enabled = GUILayout.Toggle(SystemsContainer.Get <VesselUpdateSystem>().Enabled, "ON/OFF", ButtonStyle);
}
VesselResource = GUILayout.Toggle(VesselResource, "Vessel resources", ButtonStyle);
if (VesselResource)
{
SystemsContainer.Get <VesselResourceSystem>().Enabled = GUILayout.Toggle(SystemsContainer.Get <VesselResourceSystem>().Enabled, "ON/OFF", ButtonStyle);
}
VesselProto = GUILayout.Toggle(VesselProto, "Vessel proto", ButtonStyle);
if (VesselProto)
{
SystemsContainer.Get <VesselProtoSystem>().Enabled = GUILayout.Toggle(SystemsContainer.Get <VesselProtoSystem>().Enabled, "ON/OFF", ButtonStyle);
}
VesselRange = GUILayout.Toggle(VesselRange, "Vessel range", ButtonStyle);
if (VesselRange)
{
SystemsContainer.Get <VesselRangeSystem>().Enabled = GUILayout.Toggle(SystemsContainer.Get <VesselRangeSystem>().Enabled, "ON/OFF", ButtonStyle);
}
VesselPrecalc = GUILayout.Toggle(VesselPrecalc, "Vessel precalc", ButtonStyle);
if (VesselPrecalc)
{
SystemsContainer.Get <VesselPrecalcSystem>().Enabled = GUILayout.Toggle(SystemsContainer.Get <VesselPrecalcSystem>().Enabled, "ON/OFF", ButtonStyle);
}
VesselState = GUILayout.Toggle(VesselState, "Vessel state", ButtonStyle);
if (VesselState)
{
SystemsContainer.Get <VesselStateSystem>().Enabled = GUILayout.Toggle(SystemsContainer.Get <VesselStateSystem>().Enabled, "ON/OFF", ButtonStyle);
}
VesselRemove = GUILayout.Toggle(VesselRemove, "Vessel remove", ButtonStyle);
if (VesselRemove)
{
SystemsContainer.Get <VesselRemoveSystem>().Enabled = GUILayout.Toggle(SystemsContainer.Get <VesselRemoveSystem>().Enabled, "ON/OFF", ButtonStyle);
}
VesselSwitcher = GUILayout.Toggle(VesselSwitcher, "Vessel switcher", ButtonStyle);
if (VesselSwitcher)
{
SystemsContainer.Get <VesselSwitcherSystem>().Enabled = GUILayout.Toggle(SystemsContainer.Get <VesselSwitcherSystem>().Enabled, "ON/OFF", ButtonStyle);
}
Warp = GUILayout.Toggle(Warp, "Warp system", ButtonStyle);
if (Warp)
{
//This system should never be toggled
SystemsContainer.Get <WarpSystem>().Enabled = GUILayout.Toggle(SystemsContainer.Get <WarpSystem>().Enabled, "ON/OFF", ButtonStyle);
}
}
private static void HandleButtonClick() => SystemsContainer.Get <MainSystem>().ToolbarShowGui = !SystemsContainer.Get <MainSystem>().ToolbarShowGui;
private void HandleWindowEvents()
{
if (!WindowsContainer.Get <StatusWindow>().DisconnectEventHandled)
{
WindowsContainer.Get <StatusWindow>().DisconnectEventHandled = true;
ForceQuit = true;
NetworkConnection.Disconnect("Quit");
SystemsContainer.Get <ScenarioSystem>().SendScenarioModules(); // Send scenario modules before disconnecting
}
if (!ConnectionWindow.RenameEventHandled)
{
SystemsContainer.Get <StatusSystem>().MyPlayerStatus.PlayerName = SettingsSystem.CurrentSettings.PlayerName;
ConnectionWindow.RenameEventHandled = true;
SettingsSystem.SaveSettings();
}
if (!ConnectionWindow.AddEventHandled)
{
SettingsSystem.CurrentSettings.Servers.Add(ConnectionWindow.AddEntry);
ConnectionWindow.AddEntry = null;
ConnectionWindow.AddingServer = false;
ConnectionWindow.AddEventHandled = true;
SettingsSystem.SaveSettings();
}
if (!ConnectionWindow.EditEventHandled)
{
SettingsSystem.CurrentSettings.Servers[ConnectionWindow.Selected].Name = ConnectionWindow.EditEntry.Name;
SettingsSystem.CurrentSettings.Servers[ConnectionWindow.Selected].Address = ConnectionWindow.EditEntry.Address;
SettingsSystem.CurrentSettings.Servers[ConnectionWindow.Selected].Port = ConnectionWindow.EditEntry.Port;
ConnectionWindow.EditEntry = null;
ConnectionWindow.AddingServer = false;
ConnectionWindow.EditEventHandled = true;
SettingsSystem.SaveSettings();
}
if (!ConnectionWindow.RemoveEventHandled)
{
SettingsSystem.CurrentSettings.Servers.RemoveAt(ConnectionWindow.Selected);
ConnectionWindow.Selected = -1;
ConnectionWindow.RemoveEventHandled = true;
SettingsSystem.SaveSettings();
}
if (!ConnectionWindow.ConnectEventHandled)
{
ConnectionWindow.ConnectEventHandled = true;
NetworkConnection.ConnectToServer(
SettingsSystem.CurrentSettings.Servers[ConnectionWindow.Selected].Address,
SettingsSystem.CurrentSettings.Servers[ConnectionWindow.Selected].Port);
}
if (CommandLineServer != null && HighLogic.LoadedScene == GameScenes.MAINMENU &&
Time.timeSinceLevelLoad > 1f)
{
NetworkConnection.ConnectToServer(CommandLineServer.Address, CommandLineServer.Port);
CommandLineServer = null;
}
if (!ConnectionWindow.DisconnectEventHandled)
{
ConnectionWindow.DisconnectEventHandled = true;
GameRunning = false;
FireReset = true;
NetworkConnection.Disconnect(NetworkState <= ClientState.Starting
? "Cancelled connection to server"
: "Quit");
}
}
public void MainSystemUpdate()
{
LunaLog.ProcessLogMessages();
var startClock = ProfilerData.LmpReferenceTime.ElapsedTicks;
if (!Enabled)
{
return;
}
try
{
if (HighLogic.LoadedScene == GameScenes.MAINMENU)
{
if (!SystemsContainer.Get <ModSystem>().DllListBuilt)
{
SystemsContainer.Get <ModSystem>().DllListBuilt = true;
SystemsContainer.Get <ModSystem>().BuildDllFileList();
}
if (!LmpSaveChecked)
{
LmpSaveChecked = true;
SetupBlankGameIfNeeded();
}
}
HandleWindowEvents();
SystemsHandler.Update();
WindowsHandler.Update();
//Force quit
if (ForceQuit)
{
ForceQuit = false;
GameRunning = false;
FireReset = true;
StopGame();
}
if (DisplayDisconnectMessage)
{
ShowDisconnectMessage();
}
//Normal quit
if (GameRunning)
{
if (HighLogic.LoadedScene == GameScenes.MAINMENU)
{
GameRunning = false;
FireReset = true;
SystemsContainer.Get <ToolbarSystem>().Enabled = false; //Always disable toolbar in main menu
NetworkConnection.Disconnect("Quit to main menu");
}
if (HighLogic.CurrentGame.flagURL != SettingsSystem.CurrentSettings.SelectedFlag)
{
LunaLog.Log("[LMP]: Saving Selected flag");
SettingsSystem.CurrentSettings.SelectedFlag = HighLogic.CurrentGame.flagURL;
SettingsSystem.SaveSettings();
SystemsContainer.Get <FlagSystem>().FlagChangeEvent = true;
}
// save every GeeASL from each body in FlightGlobals
if (HighLogic.LoadedScene == GameScenes.FLIGHT && BodiesGees.Count == 0)
{
foreach (var body in FlightGlobals.Bodies)
{
BodiesGees.Add(body, body.GeeASL);
}
}
//handle use of cheats
if (!SettingsSystem.ServerSettings.AllowCheats)
{
CheatOptions.InfinitePropellant = false;
CheatOptions.NoCrashDamage = false;
foreach (var gravityEntry in BodiesGees)
{
gravityEntry.Key.GeeASL = gravityEntry.Value;
}
}
if (HighLogic.LoadedScene == GameScenes.FLIGHT && FlightGlobals.ready)
{
HighLogic.CurrentGame.Parameters.Flight.CanLeaveToSpaceCenter = PauseMenu.canSaveAndExit == ClearToSaveStatus.CLEAR;
}
else
{
HighLogic.CurrentGame.Parameters.Flight.CanLeaveToSpaceCenter = true;
}
}
if (FireReset)
{
FireReset = false;
SystemsHandler.KillAllSystems();
}
if (StartGame)
{
StartGame = false;
StartGameNow();
}
}
catch (Exception e)
{
HandleException(e, "Main system- update");
}
LunaProfiler.UpdateData.ReportTime(startClock);
}
/// <summary>
/// Called when a vessel is initiated.
/// </summary>
public void VesselCreate(Vessel data)
{
//No need to check the unloaded update locks as vessels when unloaded don't have parts!
if (!VesselCommon.IsSpectating && data.id != VesselProtoSystem.CurrentlyUpdatingVesselId && !SystemsContainer.Get <VesselRemoveSystem>().VesselWillBeKilled(data.id))
{
//We are modifying a vessel that LMP is not handling
if (VesselsProtoStore.AllPlayerVessels.ContainsKey(data.id))
{
//The vessel even exists on the store so probably it's a vessel that has lost a part or smth like that...
if (LockSystem.LockQuery.UpdateLockBelongsToPlayer(data.id, SettingsSystem.CurrentSettings.PlayerName))
{
//We own the update lock of that vessel that suffered a modification so just leave it here
//The main system has a routine that will check changes and send the new definition
LunaLog.Log($"SKIPPING detected change in vesselId {data.id} name {data.vesselName} (we own update lock)");
}
else
{
LunaLog.Log($"REVERTING change in NEW vesselId {data.id} name {data.vesselName} (DON'T own UnloadedUpdate lock)");
VesselsProtoStore.AllPlayerVessels[data.id].VesselHasUpdate = true;
}
}
else
{
//The vessel is NEW as it's not in the store. It might be a debris...
var rootPartOrFirstPart = data.rootPart ?? data.parts.FirstOrDefault();
if (rootPartOrFirstPart != null)
{
var originalVessel = VesselsProtoStore.GetVesselByPartId(rootPartOrFirstPart.flightID);
if (originalVessel == null)
{
//We didn't find an original vessel so it's probably a totally new vessel that was spawned...
return;
}
//The vessel even exists on the store so probably it's a vessel that has lost a part or smth like that...
if (LockSystem.LockQuery.UpdateLockBelongsToPlayer(originalVessel.id, SettingsSystem.CurrentSettings.PlayerName))
{
LunaLog.Log($"SENDING NEW vesselId {data.id} name {data.vesselName} (Original vessel UPD lock is ours)");
//We own the update lock of that vessel that originated that part so let's get that updat lock and send the definition
SystemsContainer.Get <LockSystem>().AcquireUpdateLock(data.id, true);
//Now send this debris and force it!
System.MessageSender.SendVesselMessage(data, true);
//Add it also to our store
VesselsProtoStore.AddVesselToDictionary(FlightGlobals.ActiveVessel);
}
else
{
LunaLog.Log($"REVERTING NEW vesselId {data.id} name {data.vesselName} (UPD lock is NOT ours)");
SystemsContainer.Get <VesselRemoveSystem>().AddToKillList(data.id);
}
}
}
}
}
public void Start()
{
SystemsContainer.Get <MainSystem>().Start();
}
/// <summary>
/// Check if a vessel is yours or not
/// </summary>
/// <returns></returns>
private static bool VesselControlLockIsOurs(ProtoVessel vessel)
{
return(!SystemsContainer.Get <LockSystem>().LockExists($"control-{vessel.vesselID}") || SystemsContainer.Get <LockSystem>().LockIsOurs($"control-{vessel.vesselID}"));
}
public void OnDestroy()
{
SystemsContainer.Get <MainSystem>().OnExit();
}
public void DrawContent(int windowId)
{
var pressedEnter = Event.current.type == EventType.KeyDown && !Event.current.shift &&
Event.current.character == '\n';
GUILayout.BeginVertical();
GUI.DragWindow(MoveRect);
GUILayout.BeginHorizontal();
DrawRooms();
GUILayout.FlexibleSpace();
if (System.SelectedChannel != null && System.SelectedChannel != SettingsSystem.ServerSettings.ConsoleIdentifier ||
System.SelectedPmChannel != null)
{
if (GUILayout.Button("Leave", ButtonStyle))
{
System.LeaveEventHandled = false;
}
}
DrawConsole();
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
ChatScrollPos = GUILayout.BeginScrollView(ChatScrollPos, ScrollStyle);
if (System.SelectedChannel == null && System.SelectedPmChannel == null)
{
if (!System.ChannelMessages.ContainsKey(""))
{
System.ChannelMessages.Add("", new List <string>());
}
foreach (var channelMessage in System.ChannelMessages[""])
{
GUILayout.Label(channelMessage, LabelStyle);
}
}
if (System.SelectedChannel != null && System.SelectedChannel != SettingsSystem.ServerSettings.ConsoleIdentifier)
{
if (!System.ChannelMessages.ContainsKey(System.SelectedChannel))
{
System.ChannelMessages.Add(System.SelectedChannel, new List <string>());
}
foreach (var channelMessage in System.ChannelMessages[System.SelectedChannel])
{
GUILayout.Label(channelMessage, LabelStyle);
}
}
if (System.SelectedChannel == SettingsSystem.ServerSettings.ConsoleIdentifier)
{
foreach (var consoleMessage in System.ConsoleMessages)
{
GUILayout.Label(consoleMessage, LabelStyle);
}
}
if (System.SelectedPmChannel != null)
{
if (!System.PrivateMessages.ContainsKey(System.SelectedPmChannel))
{
System.PrivateMessages.Add(System.SelectedPmChannel, new List <string>());
}
foreach (var privateMessage in System.PrivateMessages[System.SelectedPmChannel])
{
GUILayout.Label(privateMessage, LabelStyle);
}
}
GUILayout.EndScrollView();
PlayerScrollPos = GUILayout.BeginScrollView(PlayerScrollPos, ScrollStyle, SmallSizeOption);
GUILayout.BeginVertical();
GUILayout.Label(SettingsSystem.CurrentSettings.PlayerName, LabelStyle);
if (System.SelectedPmChannel != null)
{
GUILayout.Label(System.SelectedPmChannel, LabelStyle);
}
else
{
if (System.SelectedChannel == null)
{
foreach (var player in SystemsContainer.Get <StatusSystem>().PlayerStatusList.Values)
{
if (System.JoinedPmChannels.Contains(player.PlayerName))
{
GUI.enabled = false;
}
if (GUILayout.Button(player.PlayerName, LabelStyle))
{
if (!System.JoinedPmChannels.Contains(player.PlayerName))
{
System.JoinedPmChannels.Add(player.PlayerName);
}
}
GUI.enabled = true;
}
}
else
{
foreach (var playerEntry in System.PlayerChannels)
{
if (playerEntry.Key != SettingsSystem.CurrentSettings.PlayerName &&
playerEntry.Value.Contains(System.SelectedChannel))
{
if (System.JoinedPmChannels.Contains(playerEntry.Key))
{
GUI.enabled = false;
}
if (GUILayout.Button(playerEntry.Key, LabelStyle))
{
if (!System.JoinedPmChannels.Contains(playerEntry.Key))
{
System.JoinedPmChannels.Add(playerEntry.Key);
}
}
GUI.enabled = true;
}
}
}
}
GUILayout.EndVertical();
GUILayout.EndScrollView();
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUI.SetNextControlName("ChatBase.SendTextArea");
var tempSendText = GUILayout.TextArea(System.SendText, TextAreaStyle);
//When a control is inserted or removed from the GUI, Unity's focusing starts tripping balls. This is a horrible workaround for unity that shouldn't exist...
var newTextId = GUIUtility.GetControlID(FocusType.Keyboard);
if (PreviousTextId != newTextId)
{
PreviousTextId = newTextId;
if (System.ChatLocked)
{
System.SelectTextBox = true;
}
}
//Don't add the newline to the messages, queue a send
if (!IgnoreChatInput)
{
if (pressedEnter)
{
System.SendEventHandled = false;
}
else
{
System.SendText = tempSendText;
}
}
if (System.SendText == "")
{
GUI.enabled = false;
}
if (GUILayout.Button("Send", ButtonStyle, SmallSizeOption))
{
System.SendEventHandled = false;
}
GUI.enabled = true;
GUILayout.EndHorizontal();
GUILayout.EndVertical();
if (!System.SelectTextBox)
{
if (GUI.GetNameOfFocusedControl() == "ChatBase.SendTextArea" && !System.ChatLocked)
{
System.ChatLocked = true;
InputLockManager.SetControlLock(LmpGuiUtil.BlockAllControls, System.LmpChatLock);
}
if (GUI.GetNameOfFocusedControl() != "ChatBase.SendTextArea" && System.ChatLocked)
{
System.ChatLocked = false;
InputLockManager.RemoveControlLock(System.LmpChatLock);
}
}
else
{
System.SelectTextBox = false;
GUI.FocusControl("ChatBase.SendTextArea");
}
}
public void DrawContent(int windowId)
{
GUILayout.BeginVertical();
GUI.DragWindow(MoveRect);
#region Horizontal toolbar
GUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
var chatButtonStyle = ButtonStyle;
if (SystemsContainer.Get <ChatSystem>().ChatButtonHighlighted)
{
chatButtonStyle = HighlightStyle;
}
if (!SettingsSystem.ServerSettings.DropControlOnVesselSwitching)
{
if (GUILayout.Button(new GUIContent(StatusTexts.DropCtrlBtnTxt, StatusTexts.DropCtrlBtnTooltip), ButtonStyle))
{
SystemsContainer.Get <VesselLockSystem>().DropAllOtherVesselControlLocks();
}
}
WindowsContainer.Get <ChatWindow>().Display = GUILayout.Toggle(WindowsContainer.Get <ChatWindow>().Display, StatusTexts.ChatBtnTxt, chatButtonStyle);
WindowsContainer.Get <CraftLibraryWindow>().Display = GUILayout.Toggle(WindowsContainer.Get <CraftLibraryWindow>().Display, StatusTexts.CraftBtnTxt, ButtonStyle);
WindowsContainer.Get <DebugWindow>().Display = GUILayout.Toggle(WindowsContainer.Get <DebugWindow>().Display, StatusTexts.DebugBtnTxt, ButtonStyle);
#if DEBUG
WindowsContainer.Get <SystemsWindow>().Display = GUILayout.Toggle(WindowsContainer.Get <SystemsWindow>().Display, StatusTexts.SystemsBtnTxt, ButtonStyle);
WindowsContainer.Get <LocksWindow>().Display = GUILayout.Toggle(WindowsContainer.Get <LocksWindow>().Display, StatusTexts.LocksBtnTxt, ButtonStyle);
#endif
GUILayout.EndHorizontal();
#endregion
#region Players information
ScrollPosition = GUILayout.BeginScrollView(ScrollPosition, ScrollStyle);
//Draw other subspaces
for (var i = 0; i < SubspaceDisplay.Count; i++)
{
if (SubspaceDisplay[i].SubspaceId == -1)
{
//Draw the warping players
GUILayout.BeginHorizontal(SubspaceStyle);
GUILayout.Label(StatusTexts.WarpingLabelTxt);
GUILayout.EndHorizontal();
}
else
{
GUILayout.BeginHorizontal(SubspaceStyle);
GUILayout.Label(StatusTexts.GetTimeLabel(SubspaceDisplay[i]));
GUILayout.FlexibleSpace();
if (NotWarpingAndIsFutureSubspace(SubspaceDisplay[i].SubspaceId) && GUILayout.Button(StatusTexts.SyncBtnTxt, ButtonStyle))
{
WarpSystem.CurrentSubspace = SubspaceDisplay[i].SubspaceId;
}
GUILayout.EndHorizontal();
}
for (var j = 0; j < SubspaceDisplay[i].Players.Count; j++)
{
DrawPlayerEntry(SubspaceDisplay[i].Players[j] == SettingsSystem.CurrentSettings.PlayerName
? SystemsContainer.Get <StatusSystem>().MyPlayerStatus
: SystemsContainer.Get <StatusSystem>().GetPlayerStatus(SubspaceDisplay[i].Players[j]));
}
}
GUILayout.EndScrollView();
#endregion
GUILayout.FlexibleSpace();
#if DEBUG
GUILayout.BeginHorizontal();
DrawDebugSwitches();
GUILayout.EndHorizontal();
#endif
GUILayout.BeginHorizontal();
if (GUILayout.Button(StatusTexts.DisconnectBtnTxt, ButtonStyle))
{
DisconnectEventHandled = false;
}
WindowsContainer.Get <OptionsWindow>().Display = GUILayout.Toggle(WindowsContainer.Get <OptionsWindow>().Display, StatusTexts.OptionsBtnTxt, ButtonStyle);
GUILayout.EndHorizontal();
GUILayout.EndVertical();
}
public static string GetTimeLabel(SubspaceDisplayEntry currentEntry)
{
return($"T: +{KSPUtil.PrintTimeCompact(SystemsContainer.Get<WarpSystem>().GetSubspaceTime(currentEntry.SubspaceId), false)}");
}
/// <summary>
/// Enqueues the received message to the correct system
/// </summary>
/// <param name="msg"></param>
private static void EnqueueMessageToSystem(IServerMessageBase msg)
{
switch (msg.MessageType)
{
case ServerMessageType.Handshake:
SystemsContainer.Get <HandshakeSystem>().EnqueueMessage(msg);
break;
case ServerMessageType.Chat:
SystemsContainer.Get <ChatSystem>().EnqueueMessage(msg);
break;
case ServerMessageType.Settings:
SystemsContainer.Get <SettingsSystem>().EnqueueMessage(msg);
break;
case ServerMessageType.PlayerStatus:
SystemsContainer.Get <StatusSystem>().EnqueueMessage(msg);
break;
case ServerMessageType.PlayerColor:
SystemsContainer.Get <PlayerColorSystem>().EnqueueMessage(msg);
break;
case ServerMessageType.PlayerConnection:
SystemsContainer.Get <PlayerConnectionSystem>().EnqueueMessage(msg);
break;
case ServerMessageType.Scenario:
SystemsContainer.Get <ScenarioSystem>().EnqueueMessage(msg);
break;
case ServerMessageType.Kerbal:
SystemsContainer.Get <KerbalSystem>().EnqueueMessage(msg);
break;
case ServerMessageType.Vessel:
switch (((VesselBaseMsgData)msg.Data).VesselMessageType)
{
case VesselMessageType.Position:
SystemsContainer.Get <VesselPositionSystem>().EnqueueMessage(msg);
break;
case VesselMessageType.Flightstate:
SystemsContainer.Get <VesselFlightStateSystem>().EnqueueMessage(msg);
break;
case VesselMessageType.VesselsReply:
case VesselMessageType.Proto:
SystemsContainer.Get <VesselProtoSystem>().EnqueueMessage(msg);
break;
case VesselMessageType.Dock:
SystemsContainer.Get <VesselDockSystem>().EnqueueMessage(msg);
break;
case VesselMessageType.Remove:
SystemsContainer.Get <VesselRemoveSystem>().EnqueueMessage(msg);
break;
case VesselMessageType.Update:
SystemsContainer.Get <VesselUpdateSystem>().EnqueueMessage(msg);
break;
case VesselMessageType.Resource:
SystemsContainer.Get <VesselResourceSystem>().EnqueueMessage(msg);
break;
}
break;
case ServerMessageType.CraftLibrary:
SystemsContainer.Get <CraftLibrarySystem>().EnqueueMessage(msg);
break;
case ServerMessageType.Flag:
SystemsContainer.Get <FlagSystem>().EnqueueMessage(msg);
break;
case ServerMessageType.Motd:
SystemsContainer.Get <MotdSystem>().EnqueueMessage(msg);
break;
case ServerMessageType.Warp:
SystemsContainer.Get <WarpSystem>().EnqueueMessage(msg);
break;
case ServerMessageType.Admin:
SystemsContainer.Get <AdminSystem>().EnqueueMessage(msg);
break;
case ServerMessageType.Lock:
SystemsContainer.Get <LockSystem>().EnqueueMessage(msg);
break;
case ServerMessageType.Mod:
SystemsContainer.Get <ModApiSystem>().EnqueueMessage(msg);
break;
case ServerMessageType.Groups:
SystemsContainer.Get <GroupSystem>().EnqueueMessage(msg);
break;
case ServerMessageType.Facility:
SystemsContainer.Get <FacilitySystem>().EnqueueMessage(msg);
break;
default:
LunaLog.LogError($"[LMP]: Unhandled Message type {msg.MessageType}");
break;
}
}
/// <summary>
/// Main receiveing thread
/// </summary>
public static void ReceiveMain()
{
try
{
while (!SystemsContainer.Get <MainSystem>().Quit)
{
if (NetworkMain.ClientConnection.ReadMessage(out var msg))
{
NetworkStatistics.LastReceiveTime = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;
switch (msg.MessageType)
{
case NetIncomingMessageType.NatIntroductionSuccess:
NetworkServerList.HandleNatIntroduction(msg);
break;
case NetIncomingMessageType.ConnectionLatencyUpdated:
NetworkStatistics.PingMs =
(float)TimeSpan.FromSeconds(msg.ReadFloat()).TotalMilliseconds;
break;
case NetIncomingMessageType.UnconnectedData:
NetworkServerList.HandleServersList(msg);
break;
case NetIncomingMessageType.Data:
try
{
var deserializedMsg =
NetworkMain.SrvMsgFactory.Deserialize(msg.ReadBytes(msg.LengthBytes),
DateTime.UtcNow.Ticks);
if (deserializedMsg != null)
{
EnqueueMessageToSystem(deserializedMsg as IServerMessageBase);
}
}
catch (Exception e)
{
LunaLog.LogError($"[LMP]: Error deserializing message! {e}");
NetworkMain.HandleDisconnectException(e);
}
break;
case NetIncomingMessageType.StatusChanged:
switch ((NetConnectionStatus)msg.ReadByte())
{
case NetConnectionStatus.Disconnected:
var reason = msg.ReadString();
NetworkConnection.Disconnect(reason);
break;
}
break;
default:
LunaLog.Log($"[LMP]: LIDGREN: {msg.MessageType} -- {msg.PeekString()}");
break;
}
}
else
{
Thread.Sleep(SettingsSystem.CurrentSettings.SendReceiveMsInterval);
}
}
}
catch (Exception e)
{
LunaLog.LogError($"[LMP]: Receive message thread error: {e}");
NetworkMain.HandleDisconnectException(e);
}
}
public override void Update()
{
Display &= SystemsContainer.Get <MainSystem>().GameRunning;
SafeDisplay = Display;
}
/// <summary>
/// Release the control locks
/// </summary>
private static void ReleaseAllControlLocks()
{
SystemsContainer.Get <LockSystem>().ReleasePlayerLocks(LockType.Control);
SystemsContainer.Get <LockSystem>().ReleaseSpectatorLock();
VesselCommon.IsSpectating = false;
}
private static void CheckFiles()
{
var gameFilePaths = Directory.GetFiles(CommonUtil.CombinePaths(Client.KspPath, "GameData"), "*",
SearchOption.AllDirectories);
var gameFileRelativePaths =
gameFilePaths.Select(
filePath =>
filePath.Substring(filePath.ToLowerInvariant().IndexOf("gamedata", StringComparison.Ordinal) + 9)
.Replace('\\', '/')).ToList();
//Check Required
foreach (var requiredEntry in ParseRequired)
{
if (!requiredEntry.Key.EndsWith("dll"))
{
CheckNonDllFile(gameFileRelativePaths, requiredEntry, true);
}
else
{
CheckDllFile(requiredEntry, true);
}
}
//Check Optional
foreach (var optionalEntry in ParseOptional)
{
if (!optionalEntry.Key.EndsWith("dll"))
{
CheckNonDllFile(gameFileRelativePaths, optionalEntry, false);
}
else
{
CheckDllFile(optionalEntry, false);
}
}
if (WhiteList.Any() && !BlackList.Any()) //Check Resource whitelist
{
var autoAllowed = new List <string>
{
"lunamultiplayer/plugins/lunaclient.dll",
"lunamultiplayer/plugins/lunacommon.dll",
"lunamultiplayer/plugins/fastmember.dll",
"lunamultiplayer/plugins/lidgren.network.dll",
"lunamultiplayer/plugins/mono.data.tds.dll",
"lunamultiplayer/plugins/system.data.dll",
"lunamultiplayer/plugins/system.threading.dll",
"lunamultiplayer/plugins/system.transactions.dll"
};
//Allow LMP files, Ignore squad plugins, Check required (Required implies whitelist), Check optional (Optional implies whitelist)
//Check whitelist
foreach (var dllResource in
SystemsContainer.Get <ModSystem>().DllList.Where(
dllResource =>
!autoAllowed.Contains(dllResource.Key) && !dllResource.Key.StartsWith("squad/plugins") &&
!ParseRequired.ContainsKey(dllResource.Key) && !ParseOptional.ContainsKey(dllResource.Key) &&
!WhiteList.ContainsKey(dllResource.Key)))
{
ModCheckOk = false;
LunaLog.Log($"[LMP]: Non-whitelisted resource {dllResource.Key} exists on client!");
StringBuilder.AppendLine($"Non-whitelisted resource {dllResource.Key} exists on client!");
}
}
if (!WhiteList.Any() && BlackList.Any()) //Check Resource blacklist
{
foreach (var blacklistEntry in
BlackList.Keys.Where(blacklistEntry => SystemsContainer.Get <ModSystem>().DllList.ContainsKey(blacklistEntry)))
{
ModCheckOk = false;
LunaLog.Log($"[LMP]: Banned resource {blacklistEntry} exists on client!");
StringBuilder.AppendLine($"Banned resource {blacklistEntry} exists on client!");
}
}
}
/// <summary>
/// Release the asteroid spawn lock
/// </summary>
private static void ReleaseAsteroidLock()
{
SystemsContainer.Get <LockSystem>().ReleasePlayerLocks(LockType.Asteroid);
}
private static void NetworkUpdate()
{
switch (SystemsContainer.Get <MainSystem>().NetworkState)
{
case ClientState.Disconnected:
case ClientState.Connecting:
//Kill all systems while disconnected/connecting
SystemsHandler.KillAllSystems();
return;
case ClientState.Connected:
SystemsContainer.Get <HandshakeSystem>().Enabled = true;
break;
case ClientState.Handshaking:
SystemsContainer.Get <MainSystem>().Status = "Connection successful, handshaking";
break;
case ClientState.Authenticated:
SystemsContainer.Get <PlayerConnectionSystem>().Enabled = true;
SystemsContainer.Get <StatusSystem>().Enabled = true;
SystemsContainer.Get <StatusSystem>().MessageSender.SendPlayerStatus(SystemsContainer.Get <StatusSystem>().MyPlayerStatus);
SystemsContainer.Get <MainSystem>().NetworkState = ClientState.TimeSyncing;
break;
case ClientState.TimeSyncing:
SystemsContainer.Get <MainSystem>().Status = "Handshaking successful, syncing server clock";
SystemsContainer.Get <TimeSyncerSystem>().Enabled = true;
if (SystemsContainer.Get <TimeSyncerSystem>().Synced)
{
SystemsContainer.Get <MainSystem>().NetworkState = ClientState.TimeSynced;
}
else
{
SystemsContainer.Get <TimeSyncerSystem>().MessageSender.SendTimeSyncRequest();
}
break;
case ClientState.TimeSynced:
LunaLog.Log("[LMP]: Time Synced!");
SystemsContainer.Get <KerbalSystem>().Enabled = true;
NetworkSimpleMessageSender.SendKerbalsRequest();
SystemsContainer.Get <MainSystem>().NetworkState = ClientState.SyncingKerbals;
break;
case ClientState.SyncingKerbals:
SystemsContainer.Get <MainSystem>().Status = "Syncing kerbals";
break;
case ClientState.KerbalsSynced:
SystemsContainer.Get <MainSystem>().Status = "Kerbals synced";
SystemsContainer.Get <SettingsSystem>().Enabled = true;
NetworkSimpleMessageSender.SendSettingsRequest();
SystemsContainer.Get <MainSystem>().NetworkState = ClientState.SyncingSettings;
break;
case ClientState.SyncingSettings:
SystemsContainer.Get <MainSystem>().Status = "Syncing settings";
break;
case ClientState.SettingsSynced:
SystemsContainer.Get <MainSystem>().Status = "Settings synced";
SystemsContainer.Get <WarpSystem>().Enabled = true;
NetworkSimpleMessageSender.SendWarpSubspacesRequest();
SystemsContainer.Get <MainSystem>().NetworkState = ClientState.SyncingWarpsubspaces;
break;
case ClientState.SyncingWarpsubspaces:
SystemsContainer.Get <MainSystem>().Status = "Syncing warp subspaces";
break;
case ClientState.WarpsubspacesSynced:
SystemsContainer.Get <MainSystem>().Status = "Warp subspaces synced";
SystemsContainer.Get <PlayerColorSystem>().Enabled = true;
NetworkSimpleMessageSender.SendColorsRequest();
SystemsContainer.Get <MainSystem>().NetworkState = ClientState.SyncingColors;
break;
case ClientState.SyncingColors:
SystemsContainer.Get <MainSystem>().Status = "Syncing player colors";
break;
case ClientState.ColorsSynced:
SystemsContainer.Get <MainSystem>().Status = "Player colors synced";
NetworkSimpleMessageSender.SendPlayersRequest();
SystemsContainer.Get <MainSystem>().NetworkState = ClientState.SyncingPlayers;
break;
case ClientState.SyncingPlayers:
SystemsContainer.Get <MainSystem>().Status = "Syncing players";
break;
case ClientState.PlayersSynced:
SystemsContainer.Get <MainSystem>().Status = "Players synced";
SystemsContainer.Get <ScenarioSystem>().Enabled = true;
NetworkSimpleMessageSender.SendScenariosRequest();
SystemsContainer.Get <MainSystem>().NetworkState = ClientState.SyncingScenarios;
break;
case ClientState.SyncingScenarios:
SystemsContainer.Get <MainSystem>().Status = "Syncing scenarios";
break;
case ClientState.ScneariosSynced:
SystemsContainer.Get <MainSystem>().Status = "Scenarios synced";
SystemsContainer.Get <CraftLibrarySystem>().Enabled = true;
NetworkSimpleMessageSender.SendCraftLibraryRequest();
SystemsContainer.Get <MainSystem>().NetworkState = ClientState.SyncingCraftlibrary;
break;
case ClientState.SyncingCraftlibrary:
SystemsContainer.Get <MainSystem>().Status = "Syncing craft library";
break;
case ClientState.CraftlibrarySynced:
SystemsContainer.Get <MainSystem>().Status = "Craft library synced";
SystemsContainer.Get <ChatSystem>().Enabled = true;
NetworkSimpleMessageSender.SendChatRequest();
SystemsContainer.Get <MainSystem>().NetworkState = ClientState.SyncingChat;
break;
case ClientState.SyncingChat:
SystemsContainer.Get <MainSystem>().Status = "Syncing chat";
break;
case ClientState.ChatSynced:
SystemsContainer.Get <MainSystem>().Status = "Chat synced";
SystemsContainer.Get <LockSystem>().Enabled = true;
NetworkSimpleMessageSender.SendLocksRequest();
SystemsContainer.Get <MainSystem>().NetworkState = ClientState.SyncingLocks;
break;
case ClientState.SyncingLocks:
SystemsContainer.Get <MainSystem>().Status = "Syncing locks";
break;
case ClientState.LocksSynced:
SystemsContainer.Get <MainSystem>().Status = "Locks synced";
SystemsContainer.Get <AdminSystem>().Enabled = true;
NetworkSimpleMessageSender.SendAdminsRequest();
SystemsContainer.Get <MainSystem>().NetworkState = ClientState.SyncingAdmins;
break;
case ClientState.SyncingAdmins:
SystemsContainer.Get <MainSystem>().Status = "Syncing admins";
break;
case ClientState.AdminsSynced:
SystemsContainer.Get <MainSystem>().Status = "Admins synced";
SystemsContainer.Get <VesselLockSystem>().Enabled = true;
SystemsContainer.Get <VesselPositionSystem>().Enabled = true;
SystemsContainer.Get <VesselPositionAltSystem>().Enabled = true;
SystemsContainer.Get <VesselFlightStateSystem>().Enabled = true;
SystemsContainer.Get <VesselUpdateSystem>().Enabled = true;
SystemsContainer.Get <VesselChangeSystem>().Enabled = true;
SystemsContainer.Get <VesselProtoSystem>().Enabled = true;
SystemsContainer.Get <VesselRemoveSystem>().Enabled = true;
SystemsContainer.Get <VesselImmortalSystem>().Enabled = true;
SystemsContainer.Get <VesselDockSystem>().Enabled = true;
SystemsContainer.Get <VesselRangeSystem>().Enabled = true;
NetworkSimpleMessageSender.SendVesselListRequest();
SystemsContainer.Get <MainSystem>().NetworkState = ClientState.SyncingVessels;
break;
case ClientState.SyncingVessels:
SystemsContainer.Get <MainSystem>().Status = "Syncing vessels";
break;
case ClientState.VesselsSynced:
LunaLog.Log("[LMP]: Vessels Synced!");
SystemsContainer.Get <MainSystem>().Status = "Syncing universe time";
SystemsContainer.Get <MainSystem>().NetworkState = ClientState.TimeLocking;
SystemsContainer.Get <FlagSystem>().Enabled = true;
SystemsContainer.Get <KerbalReassignerSystem>().Enabled = true;
SystemsContainer.Get <FlagSystem>().SendFlagList();
SystemsContainer.Get <PlayerColorSystem>().MessageSender.SendPlayerColorToServer();
break;
case ClientState.TimeLocking:
if (SystemsContainer.Get <TimeSyncerSystem>().Synced)
{
LunaLog.Log("[LMP]: Time Locked!");
SystemsContainer.Get <MainSystem>().Status = "Starting game";
SystemsContainer.Get <MainSystem>().NetworkState = ClientState.TimeLocked;
SystemsContainer.Get <MainSystem>().StartGame = true;
}
break;
case ClientState.TimeLocked:
SystemsContainer.Get <MainSystem>().NetworkState = ClientState.Starting;
break;
case ClientState.Starting:
LunaLog.Log("[LMP]: All systems up and running! Poyekhali!!");
if (HighLogic.LoadedScene == GameScenes.SPACECENTER)
{
SystemsContainer.Get <MainSystem>().Status = "Running";
SystemsContainer.Get <MotdSystem>().Enabled = true;
SystemsContainer.Get <MainSystem>().DisplayDisconnectMessage = false;
SystemsContainer.Get <MainSystem>().NetworkState = ClientState.Running;
SystemsContainer.Get <AsteroidSystem>().Enabled = true;
SystemsContainer.Get <ToolbarSystem>().Enabled = true;
NetworkSimpleMessageSender.SendMotdRequest();
}
break;
case ClientState.Running:
SystemsContainer.Get <MainSystem>().GameRunning = true;
break;
default:
throw new ArgumentOutOfRangeException();
}
if (SystemsContainer.Get <MotdSystem>().DisplayMotd&& HighLogic.LoadedScene != GameScenes.LOADING)
{
SystemsContainer.Get <MotdSystem>().DisplayMotd = false;
SystemsContainer.Get <ScenarioSystem>().UpgradeTheAstronautComplexSoTheGameDoesntBugOut();
ScreenMessages.PostScreenMessage(SystemsContainer.Get <MotdSystem>().ServerMotd, 10f, ScreenMessageStyle.UPPER_CENTER);
//Control locks will bug out the space centre sceen, so remove them before starting.
NetworkMain.DeleteAllTheControlLocksSoTheSpaceCentreBugGoesAway();
}
}
public void DrawContent(int windowId)
{
GUILayout.BeginVertical();
GUI.DragWindow(MoveRect);
GUILayout.Space(20);
GUILayout.BeginHorizontal();
GUILayout.Label("Player Name:", LabelOptions);
var oldPlayerName = SettingsSystem.CurrentSettings.PlayerName;
SettingsSystem.CurrentSettings.PlayerName = GUILayout.TextArea(SettingsSystem.CurrentSettings.PlayerName, 32, TextAreaStyle); // Max 32 characters
if (oldPlayerName != SettingsSystem.CurrentSettings.PlayerName)
{
SettingsSystem.CurrentSettings.PlayerName = SettingsSystem.CurrentSettings.PlayerName.Replace("\n", "");
RenameEventHandled = false;
}
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
//Draw add button
var addMode = SelectedSafe == -1 ? "Add" : "Edit";
var buttonAddMode = addMode;
if (AddingServer)
{
buttonAddMode = "Cancel";
}
AddingServer = GUILayout.Toggle(AddingServer, buttonAddMode, ButtonStyle);
if (AddingServer && !AddingServerSafe && Selected != -1)
{
//Load the existing server settings
ServerName = SettingsSystem.CurrentSettings.Servers[Selected].Name;
ServerAddress = SettingsSystem.CurrentSettings.Servers[Selected].Address;
ServerPort = SettingsSystem.CurrentSettings.Servers[Selected].Port.ToString();
}
//Draw connect button
if (SystemsContainer.Get <MainSystem>().NetworkState == ClientState.Disconnected)
{
GUI.enabled = SelectedSafe != -1;
if (GUILayout.Button("Connect", ButtonStyle))
{
ConnectEventHandled = false;
}
}
else
{
if (GUILayout.Button("Disconnect", ButtonStyle))
{
DisconnectEventHandled = false;
}
}
//Draw remove button
if (GUILayout.Button("Remove", ButtonStyle))
{
if (RemoveEventHandled)
{
RemoveEventHandled = false;
}
}
GUI.enabled = true;
WindowsContainer.Get <OptionsWindow>().Display = GUILayout.Toggle(WindowsContainer.Get <OptionsWindow>().Display, "Options", ButtonStyle);
if (GUILayout.Button("Servers", ButtonStyle))
{
WindowsContainer.Get <ServerListWindow>().Display = true;
}
if (GUILayout.Button("Close", ButtonStyle))
{
Closed = true;
}
GUILayout.EndHorizontal();
if (AddingServerSafe)
{
GUILayout.BeginHorizontal();
GUILayout.Label("Name:", LabelOptions);
ServerName = GUILayout.TextArea(ServerName, TextAreaStyle);
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label("Address:", LabelOptions);
ServerAddress = GUILayout.TextArea(ServerAddress, TextAreaStyle).Trim();
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label("Port:", LabelOptions);
ServerPort = GUILayout.TextArea(ServerPort, TextAreaStyle).Trim();
GUILayout.EndHorizontal();
if (GUILayout.Button($"{addMode} server", ButtonStyle))
{
if (AddEventHandled)
{
if (Selected == -1)
{
AddEntry = new ServerEntry
{
Name = ServerName,
Address = ServerAddress,
Port = 6702
};
int.TryParse(ServerPort, out AddEntry.Port);
AddEventHandled = false;
}
else
{
EditEntry = new ServerEntry
{
Name = ServerName,
Address = ServerAddress,
Port = 6702
};
int.TryParse(ServerPort, out EditEntry.Port);
EditEventHandled = false;
}
}
}
}
GUILayout.Label("Custom servers:");
if (SettingsSystem.CurrentSettings.Servers.Count == 0)
{
GUILayout.Label("(None - Add a server first)");
}
ScrollPos = GUILayout.BeginScrollView(ScrollPos, GUILayout.Width(WindowWidth - 5),
GUILayout.Height(WindowHeight - 100));
for (var serverPos = 0; serverPos < SettingsSystem.CurrentSettings.Servers.Count; serverPos++)
{
var thisSelected = GUILayout.Toggle(serverPos == SelectedSafe,
SettingsSystem.CurrentSettings.Servers[serverPos].Name, ButtonStyle);
if (Selected == SelectedSafe)
{
if (thisSelected)
{
if (Selected != serverPos)
{
Selected = serverPos;
AddingServer = false;
}
}
else if (Selected == serverPos)
{
Selected = -1;
AddingServer = false;
}
}
}
GUILayout.EndScrollView();
//Draw Status Message
GUILayout.Label(Status, StatusStyle);
GUILayout.EndVertical();
}
