void vessel_selected(ConfigNode node, CraftBrowserDialog.LoadType t)
{
vessel_selector = null;
//load vessel config
var construct = new ShipConstruct();
if (!construct.LoadShip(node))
{
var shipName = node.GetValue("ship");
Utils.Error($"Unable to load ShipConstruct '{shipName}'. " +
"This usually means that some parts are missing " +
"or some modules failed to initialize.");
Utils.Message("Unable to load {0}", shipName);
return;
}
//check if it's possible to launch such vessel
bool cant_launch = false;
var preFlightCheck = new PreFlightCheck(new Callback(() => cant_launch = false), new Callback(() => cant_launch = true));
preFlightCheck.AddTest(new PreFlightTests.ExperimentalPartsAvailable(construct));
preFlightCheck.RunTests();
//cleanup loaded parts and try to store construct
if (cant_launch)
{
construct.Unload();
}
else
{
StartCoroutine(delayed_process_construct(construct));
}
}
public void OnEditorLoad(ShipConstruct ship, CraftBrowserDialog.LoadType type)
{
if (type == CraftBrowserDialog.LoadType.Normal)
{
ResetAndRebuild(forbidAdding: true);
}
}
void onEditorLoad(ShipConstruct ct, CraftBrowserDialog.LoadType loadType)
{
Log.Info("onEditorLoad 1");
if (!registeredMods.Contains("StageRecovery"))
{
return;
}
// if (loadType == CraftBrowserDialog.LoadType.Normal)
if (ct != null && ct.Parts.Count() > 0)
{
Log.Info("onEditorLoad 2");
Part root = ct.Parts[0];
Log.Info("onEditorLoad 3");
if (!idUtil.IsDecoupler(root))
{
Log.Info("onEditorLoad 4");
idUtil.UpdateChildren(root, root.FindModuleImplementing <ControllingRecoveryModule>().RecoveryOwner, true);
}
else
{
Log.Info("onEditorLoad 5");
idUtil.UpdateChildren(root, root.FindModuleImplementing <RecoveryIDModule>().RecoveryOwner, true);
}
}
}
private void craftSelectComplete(string filename,
CraftBrowserDialog.LoadType lt)
{
control.LoadCraft(filename, flagURL);
control.craftType = craftlist.craftType;
craftlist = null;
}
/// <summary>
/// Here when a ship loads in the editor.
/// </summary>
/// <param name="ship"></param>
/// <param name="loadType"></param>
private void OnEditorLoad(ShipConstruct ship, CraftBrowserDialog.LoadType loadType)
{
// Order of operations:
// 1. This method (OnEditorLoad) gets called.
// 2. PartModules' OnStart method gets called (e.g. for ModuleRoboticSlave)
Logging.Log("Loaded vessel in editor: " + ship.shipName);
ModuleRoboticSlave.RefreshFromRoot(ship.parts[0]);
}
private void OnLoad(ShipConstruct data0, CraftBrowserDialog.LoadType data1)
{
if (data1 == CraftBrowserDialog.LoadType.Normal)
{
ShipConcerns.Clear();
SectionConcerns.Clear();
}
}
protected void OnEditorLoad(ShipConstruct ship, CraftBrowserDialog.LoadType loadType)
{
if (loadType == CraftBrowserDialog.LoadType.Normal)
{
// Loading a new ship design replaces the root part, and the new
// root hasn't been cleaned even if the old one had been.
manifestNeedsCleaning = true;
}
}
private void OnSelected(string fullPath, CraftBrowserDialog.LoadType loadType)
{
Log.Info("OnSelected, fullPath: " + fullPath);
craftBrowser = null;
openingCraftBrowser = false;
StartCoroutine(SpawnCraftRoutine(fullPath));
choosingPosition = true;
}
protected override void VesselSelected(string filePath, CraftBrowserDialog.LoadType loadType)
{
if (filePath == _selectedCraftFilePath)
{
return;
}
// Clear out previously selected vessel
_cachedCostData = null;
_cachedResources = null;
_window.ShipSelected(null);
_selectedCraftFilePath = filePath;
_craftConfigNode = ConfigNode.Load(filePath);
if (_craftConfigNode == null || _craftConfigNode.CountNodes < 1)
{
_window.ShowAlert(_invalidVesselErrorText);
return;
}
var error = string.Empty;
if (!ShipConstruction.AllPartsFound(_craftConfigNode, ref error))
{
Debug.LogError($"[KONSTRUCTION] Failed to load vessel at {_selectedCraftFilePath}");
Debug.LogError($"[KONSTRUCTION] {error}");
_window.ShowAlert(_unavailablePartsErrorText);
return;
}
var protoVessel = CreateProtoVessel();
if (protoVessel == null)
{
_window.ShowAlert(_invalidVesselErrorText);
return;
}
else if (_hasLaunchClamp)
{
_window.ShowAlert(_launchClampErrorText);
return;
}
_cachedProtoVessel = protoVessel;
var partResources = GetResourceCosts();
var konstructorMetadata = new KonstructorMetadata(partResources);
var shipName = Localizer.Format(_craftConfigNode.GetValue("ship"));
var shipMetadata = new ShipMetadata(
shipName,
$"{_dryMassText}: {_cachedDryMass:N1} t",
$"{_dryCostText}: {_cachedFundsCost:N0}",
konstructorMetadata,
_cachedThumbnail);
_window.ShipSelected(shipMetadata);
}
private void EditorLoad(ShipConstruct data0, CraftBrowserDialog.LoadType data1)
{
switch (data1)
{
case CraftBrowserDialog.LoadType.Merge:
RenameSections(data0);
break;
}
}
private void OnSelected(string fullPath, CraftBrowserDialog.LoadType loadType)
{
craftBrowser = null;
openingCraftBrowser = false;
if (VesselMoverToolbar.addCrewMembers && VesselMoverToolbar.selectCrewMembers)
{
FullPath = fullPath;
IsSelectingCrew = true;
return;
}
StartCoroutine(SpawnCraftRoutine(fullPath));
choosingPosition = true;
}
/// <summary>
/// Here when a ship is loaded in the editor.
/// </summary>
/// <param name="construct"></param>
/// <param name="loadType"></param>
private void OnShipLoaded(ShipConstruct construct, CraftBrowserDialog.LoadType loadType)
{
try
{
CurrentEditorScreen = EditorScreen.Parts;
HasBeenSorted = false;
sortAttempts = 0;
}
catch (Exception e)
{
print("AlphabeticalKerbals: There was an error in OnShipLoaded");
}
}
/// <summary>
/// Here when a ship is loaded in the editor.
/// </summary>
/// <param name="construct"></param>
/// <param name="loadType"></param>
private void OnShipLoaded(ShipConstruct construct, CraftBrowserDialog.LoadType loadType)
{
try
{
Logging.Log("Ship loaded, " + construct.Count + " parts. ");
LogPreferredAssignments(construct);
AssignmentLogic.AssignKerbals(construct);
LogVesselManifest();
}
catch (Exception e)
{
Logging.Exception(e);
}
}
private void onEditorLoad(ShipConstruct data0, CraftBrowserDialog.LoadType data1)
{
if (HighLogic.LoadedSceneIsEditor)
{
List <Part> .Enumerator _part = EditorLogic.fetch.ship.Parts.GetEnumerator();
while (_part.MoveNext())
{
if (_part.Current.Modules.Contains <KerbalEVA>())
{
//EditorLogic.DeletePart(_part.Current);
}
}
_part.Dispose();
}
}
private void onEditorLoad(ShipConstruct ship, CraftBrowserDialog.LoadType loadType)
{
Debug.LogFormat("[TankWindow] onEditorLoad: {0}", loadType);
for (int i = 0, c = ship.parts.Count; i < c; ++i)
{
Part part = ship.parts[i];
for (int j = 0, d = part.Modules.Count; j < d; ++j)
{
PartModule module = part.Modules[j];
if (module is ModuleFuelTanks)
{
(module as ModuleFuelTanks).UpdateUsedBy();
}
}
}
}
private void craftSelectOkay(string filename,
CraftBrowserDialog.LoadType lt)
{
ConfigNode craftNode = ConfigNode.Load(filename);
//bool lockedParts = false;
ShipConstruct ship = new ShipConstruct();
//ProtoVessel cringle = new ProtoVessel (craftNode);
//foreach (ProtoPartSnapshot ppart in cringle.protoPartSnapshots) {
// Debug.Log (ppart.partName);
//}
if (!ship.LoadShip(craftNode))
{
return;
}
//GameObject ro = ship.parts[0].localRoot.gameObject;
//Vessel craftVessel = ro.AddComponent<Vessel>();
//craftVessel.Initialize (true);
//craftVessel.Die ();
//craft = craftVessel;
//if (!ship.shipPartsUnlocked) {
// lockedParts = true;
//}
//GameObject ro = ship.parts[0].localRoot.gameObject;
//craft = ro.AddComponent<Vessel>();
//craft.Initialize (true);
// if (ExSettings.B9Wings_Present) {
// if (!InitializeB9Wings (craftVessel)
// && ExSettings.FAR_Present) {
// InitializeFARSurfaces (craftVessel);
// }
// } else if (ExSettings.FAR_Present) {
// InitializeFARSurfaces (craftVessel);
// }
//foreach (Part p in craftVessel.parts) {
// resources.addPart (p);
//}
//craftVessel.Die ();
}
private void OnShipLoad(ShipConstruct ship, CraftBrowserDialog.LoadType loadType)
{
this.GetVesselResources();
}
void OnShipLoad(ShipConstruct ship, CraftBrowserDialog.LoadType load_type)
{
init_engines = load_type == CraftBrowserDialog.LoadType.Normal;
}
/// <summary>
/// Here when a ship loads in the editor.
/// </summary>
/// <param name="ship"></param>
/// <param name="loadType"></param>
private void OnEditorLoad(ShipConstruct ship, CraftBrowserDialog.LoadType loadType)
{
ModuleSimpleFuelSwitch.OnShipLoaded(ship);
}
private void OnEditorLoad(ShipConstruct ship, CraftBrowserDialog.LoadType loadType)
{
HideAllWindows();
}
private void OnShipLoad(ShipConstruct ship, CraftBrowserDialog.LoadType loadType)
{
//Debug.Log("FillItUp.OnShipLoad");
RebuildModel();
}
private void onEditorLoad(ShipConstruct shiploaded, CraftBrowserDialog.LoadType loadType) => ReloadVessel();
private void ResetEditorEvent(ShipConstruct construct, CraftBrowserDialog.LoadType type)
{
ResetEditor();
}
protected abstract void VesselSelected(string filePath, CraftBrowserDialog.LoadType loadType);
private void OnEditorLoad(ShipConstruct vesselConstruct, CraftBrowserDialog.LoadType loadType)
{
BuildBalancerList(vesselConstruct.Parts);
editorPartCount = vesselConstruct.parts.Count;
}
private void craftSelectComplete(string filename,
CraftBrowserDialog.LoadType lt)
{
craftlist = null;
control.LoadCraft(filename, control.builder.part.flagURL);
}
private void OnEditorLoad(ShipConstruct sc, CraftBrowserDialog.LoadType lt)
{
//Debug.Log("FillItUp.OnEditorLoad");
RebuildModel();
}
void OnShipLoad(ShipConstruct ship, CraftBrowserDialog.LoadType load_type)
{
update = true;
}
private void onEditorLoad(ShipConstruct ship, CraftBrowserDialog.LoadType loadType)
{
Debug.LogFormat("ELShipInfo.onEditorLoad: {0} {1}", ship, loadType);
RebuildList();
}
