public static Services.VesselType ToVesselType(this VesselType type)
{
switch (type)
{
case VesselType.Base:
return(Services.VesselType.Base);
case VesselType.Debris:
return(Services.VesselType.Debris);
case VesselType.Lander:
return(Services.VesselType.Lander);
case VesselType.Plane:
return(Services.VesselType.Plane);
case VesselType.Probe:
return(Services.VesselType.Probe);
case VesselType.Relay:
return(Services.VesselType.Relay);
case VesselType.Rover:
return(Services.VesselType.Rover);
case VesselType.Ship:
return(Services.VesselType.Ship);
case VesselType.Station:
return(Services.VesselType.Station);
default:
throw new ArgumentOutOfRangeException(nameof(type));
}
}
public static void DrawOrbitIcon(Rect target, VesselType type)
{
if (iconsMap != null)
{
GUI.DrawTextureWithTexCoords(target, iconsMap, OrbitIconLocation[type]);
}
}
bool Filter_match(VesselType vesselType, string vesselGroup)
{
if (filter_types.Contains(vesselType))
{
return(false);
}
if (filter.Length <= 0 || filter == filter_placeholder)
{
return(true);
}
List <string> filterTags = Lib.Tokenize(filter.ToLower(), ' ');
List <string> vesselTags = Lib.Tokenize(vesselGroup.ToLower(), ' ');
foreach (string tag in filterTags)
{
foreach (string vesselTag in vesselTags)
{
if (vesselTag.StartsWith(tag, StringComparison.CurrentCulture))
{
return(true);
}
}
}
return(false);
}
public static String GetVesselTypeString(VesselType vesselType)
{
switch (vesselType)
{
case VesselType.Debris:
return "Debris";
case VesselType.SpaceObject:
return "SpaceObject";
case VesselType.Unknown:
return "Unknown";
case VesselType.Probe:
return "Probe";
case VesselType.Rover:
return "Rover";
case VesselType.Lander:
return "Lander";
case VesselType.Ship:
return "Ship";
case VesselType.Station:
return "Station";
case VesselType.Base:
return "Base";
case VesselType.EVA:
return "EVA";
case VesselType.Flag:
return "Flag";
}
return "Undefined";
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Type_Vessel")] VesselType vesselType)
{
if (id != vesselType.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(vesselType);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!VesselTypeExists(vesselType.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(vesselType));
}
private void DrawIcon(float xPos, float yPos, VesselType vt, Color iconColor, MapIcons.OtherIcon icon = MapIcons.OtherIcon.None)
{
var position = new Rect(xPos - iconPixelSize * 0.5f, yPos - iconPixelSize * 0.5f,
iconPixelSize, iconPixelSize);
//Rect shadow = position;
//shadow.x += iconShadowShift.x;
//shadow.y += iconShadowShift.y;
//MapView.OrbitIconsMaterial.color = iconColorShadowValue;
//Graphics.DrawTexture(shadow, MapView.OrbitIconsMap, MapIcons.VesselTypeIcon(vt, icon), 0, 0, 0, 0, MapView.OrbitIconsMaterial);
// the old icon material wasn't working, so just use this one
// but I don't fully understand the color/blend system
// a = 1.0 is far too faint; 4.0 looks pretty good
MapView.OrbitIconsMaterial.color = new Color(iconColor.r, iconColor.g, iconColor.b, 4.0f);
Graphics.DrawTexture(position, MapView.OrbitIconsMap, MapIcons.VesselTypeIcon(vt, icon), 0, 0, 0, 0, MapView.OrbitIconsMaterial);
// if the icon texture ever changes, you can use this code to dump it out for inspection
#if false
var filepath = "orbiticonsmap.png";
if (!System.IO.File.Exists(filepath))
{
var textureCopy = duplicateTexture(MapView.OrbitIconsMap);
var textureBytes = textureCopy.EncodeToPNG();
System.IO.File.WriteAllBytes(filepath, textureBytes);
}
#endif
}
private void DrawTargetTypes()
{
bool displaying = false;
GUILayout.Label("RENDEZVOUS DISPLAY", fe.headingStyle);
GUILayout.BeginHorizontal(fe.areaStyle);
GUILayout.BeginVertical();
List <VesselType> vesselTypes = new List <VesselType>();
foreach (Vessel vessel in FlightGlobals.Vessels)
{
if (!vesselTypes.Contains(vessel.vesselType) && vessel.vesselType != VesselType.Unknown && vessel != fe.vessel && vessel.mainBody == fe.vessel.mainBody)
{
displaying = true;
vesselTypes.Add(vessel.vesselType);
if (GUILayout.Button(vessel.vesselType.ToString(), fe.buttonStyle))
{
typeOfTarget = TargetType.Vessel;
typeOfVessel = vessel.vesselType;
fe.settings.Changed = true;
}
}
}
if (GUILayout.Button("Celestial Body", fe.buttonStyle) || !displaying)
{
typeOfTarget = TargetType.Celestial;
fe.settings.Changed = true;
}
GUILayout.EndVertical();
GUILayout.EndHorizontal();
}
public WaldoAttackVesselData(WaldoAttackVesselData vd)
{
name = vd.name;
id = vd.id;
craftURL = vd.craftURL;
craftPart = vd.craftPart;
flagURL = vd.flagURL;
vesselType = vd.vesselType;
body = vd.body;
orbit = vd.orbit;
latitude = vd.latitude;
longitude = vd.longitude;
altitude = vd.altitude;
height = vd.height;
orbiting = vd.orbiting;
owned = vd.owned;
pqsCity = vd.pqsCity;
pqsOffset = vd.pqsOffset;
heading = vd.heading;
pitch = vd.pitch;
roll = vd.roll;
foreach (CrewData cd in vd.crew)
{
crew.Add(new CrewData(cd));
}
}
public VesselData(VesselData vd)
{
name = vd.name;
id = vd.id;
craftURL = vd.craftURL;
craftPart = vd.craftPart;
flagURL = vd.flagURL;
vesselType = vd.vesselType;
body = vd.body;
orbit = vd.orbit;
latitude = vd.latitude;
longitude = vd.longitude;
altitude = vd.altitude;
height = vd.height;
orbiting = vd.orbiting;
owned = vd.owned;
pqsCity = vd.pqsCity;
pqsOffset = vd.pqsOffset;
heading = vd.heading;
pitch = vd.pitch;
roll = vd.roll;
foreach (CrewData cd in vd.crew)
{
crew.Add(new CrewData(cd));
}
}
private void DrawVessels()
{
bool displaying = false;
GUILayout.Label("RENDEZVOUS DISPLAY", fe.headingStyle);
GUILayout.BeginHorizontal(fe.areaStyle);
GUILayout.BeginVertical();
foreach (Vessel vessel in FlightGlobals.Vessels)
{
if (vessel.vesselType == typeOfVessel && vessel != fe.vessel)
{
if (vessel.mainBody == fe.vessel.mainBody)
{
displaying = true;
if (GUILayout.Button(vessel.vesselName, fe.buttonStyle))
{
targetObject = vessel;
fe.settings.Changed = true;
}
}
}
}
GUILayout.EndVertical();
GUILayout.EndHorizontal();
if (GUILayout.Button("Back to Target Type", fe.buttonStyle) || !displaying)
{
targetObject = null;
typeOfTarget = TargetType.None;
typeOfVessel = VesselType.Unknown;
fe.settings.Changed = true;
}
}
public Tracking_Group(string title, bool isOpen, bool instant, List <TrackingStationWidget> vessels, List <Tracking_MoonGroup> subGroups, CelestialBody body, VesselType type, Tracking_Mode mode)
{
_title = title;
_isOpen = isOpen;
_instant = instant;
_mode = mode;
_body = body;
_type = type;
int _subVesselCount = 0;
if (subGroups != null && subGroups.Count > 0)
{
for (int i = subGroups.Count - 1; i >= 0; i--)
{
_subVesselCount += subGroups[i].Vessels.Count;
}
}
AddHeader(vessels.Count, _subVesselCount);
AddSubGroups(subGroups);
AddVessels(vessels);
}
bool Filter_match(VesselType vesselType, string vesselGroup)
{
if (filter_types.Contains(vesselType))
{
return(false);
}
if (filter.Length <= 0 || filter == filter_placeholder)
{
return(true);
}
List <string> filterTags = filter.ToLower().Split(new[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries).Select(p => p.Trim()).ToList();
List <string> vesselTags = vesselGroup.ToLower().Split(new[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries).Select(p => p.Trim()).ToList();
foreach (string tag in filterTags)
{
foreach (string vesselTag in vesselTags)
{
if (vesselTag.StartsWith(tag, StringComparison.CurrentCulture))
{
return(true);
}
}
}
return(false);
}
IEnumerator RespawnEntity(string id, VesselType vesselType, EntityType entityType, TeamColor teamColor, float time)
{
float timer = time;
while (timer > 0)
{
timer -= Time.deltaTime;
yield return(null);
}
//TODO : Refactor the statements below
//Spawn entity
//Replace with while that iterates until it finds a position after 10sec stop enumerator
SpawnArea spawnArea = spawnAreas.Where(x => x.isOccupied == false).First();
Transform spawnLocation = spawnArea.location;
if (spawnArea.isOccupied)
{
yield return(null);
}
GameSettings gameSettings = GameManager.Instance.gameSettings;
GameObject prefab = gameSettings.vesselObjects.Where(x => x.entityType == entityType && x.vesselType == vesselType).First().objectPrefab;
SpawnEntity(id, prefab, spawnLocation, teamColor);
spawnArea.isOccupied = true;
StartCoroutine(WaitUntilClear(spawnArea));
}
/// <summary>
///
/// </summary>
private void UpdateVesselInfo()
{
IsVesselCommandable = vessel.IsVesselSituationValid();
if (VesselName != vessel.vesselName)
{
VesselName = vessel.vesselName;
}
if (currentVesselType != vessel.vesselType)
{
currentVesselType = vessel.vesselType;
VesselIcon = GetVesselIcon(vessel.vesselType);
}
if (vessel.loaded)
{
IsActiveVessel = vessel.isActiveVessel;
if (VesselAutopilotActive != vessel.Autopilot.Enabled)
{
VesselAutopilotActive = vessel.Autopilot.Enabled;
}
if (VesselAutopilotMode != vessel.Autopilot.Mode.ToPTIEnum())
{
VesselAutopilotMode = vessel.Autopilot.Mode.ToPTIEnum();
}
}
}
public static bool isVesselTypeEnabled(VesselType type)
{
var enabled = false;
filteredTypes.TryGetValue(type, out enabled);
return(enabled);
}
Texture2D GetVesselTypeIcon(VesselType type, bool disabled = false)
{
switch (type)
{
case VesselType.Base: return(disabled ? Icons.base_black : Icons.base_white);
case VesselType.EVA: return(disabled ? Icons.eva_black : Icons.eva_white);
case VesselType.Lander: return(disabled ? Icons.lander_black : Icons.lander_white);
case VesselType.Plane: return(disabled ? Icons.plane_black : Icons.plane_white);
case VesselType.Probe: return(disabled ? Icons.probe_black : Icons.probe_white);
case VesselType.Relay: return(disabled ? Icons.relay_black : Icons.relay_white);
case VesselType.Rover: return(disabled ? Icons.rover_black : Icons.rover_white);
case VesselType.Ship: return(disabled ? Icons.ship_black : Icons.ship_white);
case VesselType.Station: return(disabled ? Icons.station_black : Icons.station_white);
#if !KSP170 && !KSP16 && !KSP15 && !KSP14
case VesselType.DeployedScienceController: return(disabled ? Icons.controller_black : Icons.controller_white);
#endif
default: return(Icons.empty); // this really shouldn't happen.
}
}
// must be unique for Unity to not mash two nametag windows togehter.
public void Invoke(PersistentDynamicPodNames module, string oldVesselName, VesselType oldVesselType, int oldPriority)
{
attachedModule = module;
workingvesselname = oldVesselName;
workingvesseltype = oldVesselType;
workingpriority = oldPriority;
workingprioritystring = workingpriority.ToString();
myWindowId = GetInstanceID(); // Use the Id of this MonoBehaviour to guarantee unique window ID.
Vector3 screenPos = GetViewportPosFor(attachedModule.part.transform.position);
// screenPos is in coords from 0 to 1, 0 to 1, not screen pixel coords.
// Transform it to pixel coords:
float xPixelPoint = screenPos.x * UnityEngine.Screen.width;
float yPixelPoint = (1 - screenPos.y) * UnityEngine.Screen.height;
const float WINDOW_WIDTH = 400;
const float WINDOW_HEIGHT = 200;
// windowRect = new Rect(xPixelWindow, yPixelPoint, windowWidth, 130);
windowRect = new Rect(xPixelPoint - WINDOW_WIDTH / 2, yPixelPoint, WINDOW_WIDTH, WINDOW_HEIGHT);
SetEnabled(true);
if (HighLogic.LoadedSceneIsEditor)
{
attachedModule.part.SetHighlight(false, false);
}
}
public void TypingDone(string newVesselName, VesselType newVesselType, int newPriority)
{
storedVesselName = newVesselName;
vesselType = newVesselType;
priority = newPriority;
TypingCancel();
}
private PointF[] getVesselPath(VesselType type, float size, float x, float y)
{
List <PointF> points = new List <PointF>();
float offsetX = x - (size / 2f);
float offsetY = y - (size / 2f);
switch (type)
{
case VesselType.Probe:
// TODO: DRAW SATTELLITE HERE
//break;
case VesselType.Ship:
default:
// TODO: DRAW SHIP HERE
points.Add(new PointF((0.2f * size) + offsetX, 0 + offsetY));
points.Add(new PointF((0.8f * size) + offsetX, 0 + offsetY));
points.Add(new PointF((1 * size) + offsetX, (1 * size) + offsetY));
points.Add(new PointF((0 * size) + offsetX, (1 * size) + offsetY));
break;
}
return(points.ToArray());
}
public static KRPC.SpaceCenter.Services.VesselType ToVesselType(this VesselType type)
{
switch (type)
{
case VesselType.Ship:
return(KRPC.SpaceCenter.Services.VesselType.Ship);
case VesselType.Station:
return(KRPC.SpaceCenter.Services.VesselType.Station);
case VesselType.Lander:
return(KRPC.SpaceCenter.Services.VesselType.Lander);
case VesselType.Probe:
return(KRPC.SpaceCenter.Services.VesselType.Probe);
case VesselType.Rover:
return(KRPC.SpaceCenter.Services.VesselType.Rover);
case VesselType.Base:
return(KRPC.SpaceCenter.Services.VesselType.Base);
case VesselType.Debris:
return(KRPC.SpaceCenter.Services.VesselType.Debris);
default:
throw new ArgumentOutOfRangeException("type");
}
}
private static String GenerateName()
{
_shipType = VesselType.Unknown;
Part p = VesselNaming.FindPriorityNamePart(EditorLogic.fetch.ship);
if (p != null)
{
_shipType = p.vesselNaming.vesselType;
}
else
{
_shipType = VesselType.Unknown;
foreach (var part in EditorLogic.fetch.ship.Parts)
{
foreach (var m in part.Modules)
{
if (m is ModuleCommand)
{
part.vesselNaming = new VesselNaming();
part.vesselNaming.namingPriority = 10;
if (part.CrewCapacity == 0)
{
part.vesselNaming.vesselType = VesselType.Probe;
}
else
{
part.vesselNaming.vesselType = VesselType.Ship;
}
_shipType = part.vesselNaming.vesselType;
break;
}
}
if (_shipType != VesselType.Unknown)
{
break;
}
}
if (_shipType == VesselType.Unknown)
{
return("");
}
}
bool scr = false;
switch (_lang)
{
case 1:
scr = true;
break;
case 2:
scr = (Ran.Next(2) == 1);
break;
}
return(ParsePattern(Choose(_patterns), scr));
}
private bool getConnectedVessels()
{
connectedVessels.Clear();
if (resultsDialog == null)
{
return(false);
}
Vessel vessel = FlightGlobals.ActiveVessel;
if (vessel == null)
{
return(false);
}
if (CommNetScenario.CommNetEnabled)
{
connectedVessels = getConnectedVessels(vessel);
}
else
{
for (int i = FlightGlobals.Vessels.Count - 1; i >= 0; i--)
{
Vessel v = FlightGlobals.Vessels[i];
if (v == null)
{
continue;
}
if (v == vessel)
{
continue;
}
VesselType type = v.vesselType;
if (type == VesselType.Debris || type == VesselType.SpaceObject || type == VesselType.Unknown || type == VesselType.Flag)
{
continue;
}
if (settings.requireMPL && !VesselUtilities.VesselHasModuleName("ModuleScienceLab", v))
{
continue;
}
if (!VesselUtilities.VesselHasModuleName("ModuleScienceContainer", v))
{
continue;
}
connectedVessels.Add(new KeyValuePair <Vessel, double>(v, 0));
}
}
return(connectedVessels.Count > 0);
}
public override bool IsIgnoredVesselType(VesselType vesselType)
{
if (vesselType == VesselType.Debris)
{
return false;
}
return base.IsIgnoredVesselType(vesselType);
}
public ActionResult DeleteConfirmed(int id)
{
VesselType vesseltype = db.VesselTypes.Find(id);
db.VesselTypes.Remove(vesseltype);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public VesselBasic(Vessel reference)
{
VesselId = reference.id;
VesselName = reference.GetDisplayName();
VesselLoaded = reference.loaded;
VesselType = reference.vesselType;
VesselSituation = reference.situation;
}
void onAccept(string name, VesselType vt)
{
print("name: " + name + " VesselType: " + vt.ToString());
FlightGlobals.ActiveVessel.vesselName = name;
print("FlightGlobals.ActiveVessel.name: " + FlightGlobals.ActiveVessel.name);
Events ["ActivateEvent"].active = true;
}
public vesselTypes(VesselType vesselType, string name, bool show, Action callback)
{
this.vesselType = vesselType;
this.name = name;
this.show = show;
this.callback = callback;
init = true;
}
public FishingVessel(VesselType vesselType, double?breadth = null, double?depth = null, double?length = null)
{
Breadth = breadth;
Depth = depth;
Length = length;
VesselType = vesselType;
VesselTypeString = VesselTypeFromVesselTypeNumber((int)vesselType);
}
private static GameObject GetHeaderObject(VesselType type)
{
VesselIconSprite _iconSPrite = GameObject.Instantiate(Tracking_Loader.IconPrefab);
_iconSPrite.SetType(type);
return(_iconSPrite.gameObject);
}
public override bool IsIgnoredVesselType(VesselType vesselType)
{
if (vesselType == VesselType.Debris)
{
return(false);
}
return(base.IsIgnoredVesselType(vesselType));
}
public override bool Load(ConfigNode configNode)
{
// Load base class
bool valid = base.Load(configNode);
valid &= ConfigNodeUtil.ParseValue<VesselType>(configNode, "vesselType", x => vesselType = x, this);
return valid;
}
public void Initiate(VesselType newVesselType, float newSize, float newDurability, string newDesignation, List <VesselPart> parts)
{
vesselType = newVesselType;
transform.localScale = new Vector3(newSize, newSize, newSize);
hitpoints = newSize * newSize * newDurability;
maxHitpoints = hitpoints;
designation = newDesignation;
BuildParts(parts, newDesignation);
}
/// <summary>
/// Parses a string as a predicate keyword.
/// </summary>
///
/// <param name="input">A string, assumed to be in the format "[body].[property]".</param>
/// <returns>A predicate representing the desired property for the desired body.</returns>
///
/// <exception cref="ArgumentException">Thrown if <c>input</c> does not have the correct
/// format. The program state shall be unchanged in the event of an exception.</exception>
static GamePredicate parse(string input)
{
Regex inputTemplate = new Regex(
"(?<planet>.+)\\s*\\.\\s*(?<pred>\\w+?)(?<type>manned|unmanned)?$",
RegexOptions.IgnoreCase | RegexOptions.ExplicitCapture);
if (inputTemplate.Match(input).Groups [0].Success)
{
GroupCollection parsed = inputTemplate.Match(input).Groups;
string planet = parsed ["planet"].ToString();
string pred = parsed ["pred"].ToString();
VesselType type = parsed ["type"] == null || parsed ["type"].ToString() == ""
? VesselType.Any
: parsed ["type"].ToString().ToLower() == "manned"
? VesselType.Manned : VesselType.Unmanned;
switch (pred.ToLower())
{
case "reached":
return(new AchievementPredicate(new []
{
new [] { planet, "Escape" },
new [] { planet, "Flyby" }
}, type));
case "hadorbit":
return(new AchievementPredicate(new [] { new [] { planet, "Orbit" } }, type));
case "hadlanded":
return(new AchievementPredicate(new []
{
new [] { planet, "Landing" },
new [] { planet, "Splashdown" }
}, type));
case "science":
return(new AchievementPredicate(new [] { new [] { planet, "Science" } }, type));
case "nowpresent":
return(new VesselPredicate(planet, VesselPredicate.Test.Present, type));
case "noworbit":
return(new VesselPredicate(planet, VesselPredicate.Test.Orbiting, type));
case "nowlanded":
return(new VesselPredicate(planet, VesselPredicate.Test.Landed, type));
default:
throw new ArgumentException(
Localizer.Format("#autoLOC_CustomAsteroids_ErrorConditionInputBadType", pred),
nameof(input));
}
}
throw new ArgumentException(
Localizer.Format("#autoLOC_CustomAsteroids_ErrorConditionInputBad", input),
nameof(input));
}
public VesselInfo(string vesselName, Vessel.Situations situation, VesselType vesseltype, double currentTime)
{
this.vesselName = vesselName;
lastUpdate = currentTime;
lastFood = currentTime;
lastWater = currentTime;
lastOxygen = currentTime;
lastElectricity = currentTime;
hibernating = false;
numFrozenCrew = 0;
vesselSituation = situation;
vesselIsPreLaunch = situation == Vessel.Situations.PRELAUNCH;
vesselType = vesseltype;
recoveryvessel = false;
}
public Notes_Archive_Container(Guid gid, string name, double time, double m, VesselType t)
{
id = gid;
vesselName = name;
recoveryTime = time;
met = m;
vtype = t;
container = this;
log = new Notes_VesselLog(container);
notes = new Notes_TextContainer(container);
checkList = new Notes_CheckListContainer(container);
contracts = new Notes_ContractContainer(container);
data = new Notes_DataContainer(container);
crew = new Notes_Archived_Crew_Container(container);
}
/// <summary>
/// Draws the back to types button.
/// </summary>
private void DrawBackToTypes()
{
if (GUILayout.Button("Go Back to Type Selection", this.ButtonStyle, GUILayout.Width(this.ContentWidth)))
{
this.typeIsBody = false;
this.vesselType = VesselType.Unknown;
this.ResizeRequested = true;
}
GUILayout.Space(3f);
}
public static bool isVesselTypeEnabled(VesselType type)
{
var enabled = false;
filteredTypes.TryGetValue(type, out enabled);
return enabled;
}
public void update()
{
/*if (lastVName != null && this.vessel.GetName().Length != 0 && !this.vessel.GetName().Equals(this.lastVName) || !this.vessel.vesselType.Equals(this.lastVType))
Debug.Log("TARGETRON: RENAME DETECTED ON VESSEL " + this.lastVName + "-" + this.lastVType + " -> " + this.vessel.GetName() + "-" + this.vessel.vesselType);*/
lastVName = vessel.GetName();
lastVType = vessel.vesselType;
try
{
lastDistance = Vector3.Distance(FlightGlobals.fetch.activeVessel.transform.position, vessel.transform.position);
}
catch (Exception e)
{
Debug.Log("Targetron Error: Failed to get distance\n" + e.StackTrace);
}
}
protected override void OnParameterLoad(ConfigNode node)
{
base.OnParameterLoad(node);
vesselType = ConfigNodeUtil.ParseValue<VesselType>(node, "vesselType");
}
public static VesselType parse(this ConfigNode node, string name, VesselType original)
{
if (!node.HasValue(name))
return original;
VesselType t = original;
int i = (int)original;
if (!int.TryParse(node.GetValue(name), out i))
return original;
if (i > 10 || i < 0)
return original;
return (VesselType)i;
}
// This function prepares the simulation by creating all the necessary data structures it will
// need during the simulation. All required data is copied from the core game data structures
// so that the simulation itself can be run in a background thread without having issues with
// the core game changing the data while the simulation is running.
public bool PrepareSimulation(List<Part> parts, double theGravity, double theAtmosphere = 0, double theMach = 0, bool dumpTree = false, bool vectoredThrust = false, bool fullThrust = false)
{
LogMsg log = null;
if (SimManager.logOutput)
{
log = new LogMsg();
log.buf.AppendLine("PrepareSimulation started");
dumpTree = true;
}
this._timer.Reset();
this._timer.Start();
// Store the parameters in members for ease of access in other functions
this.partList = parts;
this.gravity = theGravity;
this.atmosphere = theAtmosphere;
this.mach = theMach;
this.lastStage = Staging.lastStage;
this.maxMach = 1.0f;
//MonoBehaviour.print("lastStage = " + lastStage);
// Clear the lists for our simulation parts
allParts.Clear();
allFuelLines.Clear();
drainingParts.Clear();
allEngines.Clear();
activeEngines.Clear();
drainingResources.Clear();
// A dictionary for fast lookup of Part->PartSim during the preparation phase
partSimLookup.Clear();
if (this.partList.Count > 0 && this.partList[0].vessel != null)
{
this.vesselName = this.partList[0].vessel.vesselName;
this.vesselType = this.partList[0].vessel.vesselType;
}
//MonoBehaviour.print("PrepareSimulation pool size = " + PartSim.pool.Count());
// First we create a PartSim for each Part (giving each a unique id)
int partId = 1;
for (int i = 0; i < partList.Count; ++i)
{
Part part = partList[i];
// If the part is already in the lookup dictionary then log it and skip to the next part
if (partSimLookup.ContainsKey(part))
{
if (log != null)
{
log.buf.AppendLine("Part " + part.name + " appears in vessel list more than once");
}
continue;
}
// Create the PartSim
PartSim partSim = PartSim.New(part, partId, this.atmosphere, log);
// Add it to the Part lookup dictionary and the necessary lists
partSimLookup.Add(part, partSim);
this.allParts.Add(partSim);
if (partSim.isFuelLine)
{
this.allFuelLines.Add(partSim);
}
if (partSim.isEngine)
{
partSim.CreateEngineSims(this.allEngines, this.atmosphere, this.mach, vectoredThrust, fullThrust, log);
}
partId++;
}
for (int i = 0; i < allEngines.Count; ++i)
{
maxMach = Mathf.Max(maxMach, allEngines[i].maxMach);
}
this.UpdateActiveEngines();
// Now that all the PartSims have been created we can do any set up that needs access to other parts
// First we set up all the parent links
for (int i = 0; i < this.allParts.Count; i++)
{
PartSim partSim = this.allParts[i];
partSim.SetupParent(partSimLookup, log);
}
// Then, in the VAB/SPH, we add the parent of each fuel line to the fuelTargets list of their targets
if (HighLogic.LoadedSceneIsEditor)
{
for (int i = 0; i < allFuelLines.Count; ++i)
{
PartSim partSim = allFuelLines[i];
CModuleFuelLine fuelLine = partSim.part.GetModule<CModuleFuelLine>();
if (fuelLine.target != null)
{
PartSim targetSim;
if (partSimLookup.TryGetValue(fuelLine.target, out targetSim))
{
if (log != null)
{
log.buf.AppendLine("Fuel line target is " + targetSim.name + ":" + targetSim.partId);
}
targetSim.fuelTargets.Add(partSim.parent);
}
else
{
if (log != null)
{
log.buf.AppendLine("No PartSim for fuel line target (" + partSim.part.partInfo.name + ")");
}
}
}
else
{
if (log != null)
{
log.buf.AppendLine("Fuel line target is null");
}
}
}
}
//MonoBehaviour.print("SetupAttachNodes and count stages");
for (int i = 0; i < allParts.Count; ++i)
{
PartSim partSim = allParts[i];
partSim.SetupAttachNodes(partSimLookup, log);
if (partSim.decoupledInStage >= this.lastStage)
{
this.lastStage = partSim.decoupledInStage + 1;
}
}
// And finally release the Part references from all the PartSims
//MonoBehaviour.print("ReleaseParts");
for (int i = 0; i < allParts.Count; ++i)
{
allParts[i].ReleasePart();
}
// And dereference the core's part list
this.partList = null;
this._timer.Stop();
if (log != null)
{
log.buf.AppendLine("PrepareSimulation: " + this._timer.ElapsedMilliseconds + "ms");
log.Flush();
}
if (dumpTree)
{
this.Dump();
}
return true;
}
public static string GearCodeFromVesselType(VesselType vtype)
{
string gearCode = String.Empty;
switch (vtype)
{
case VesselType.PS:
gearCode = "S";
break;
case VesselType.LL:
gearCode = "L";
break;
default:
break;
}
return gearCode;
}
//--------------------------------------------------------------------
// RenderableVesselType
// Indicates whether the specified vessel type is one we will render
private bool RenderableVesselType(VesselType vesselType)
{
return !(vesselType == VesselType.Flag || vesselType == VesselType.EVA || (vesselType == VesselType.Debris && DistantObjectSettings.DistantFlare.ignoreDebrisFlare));
}
public static Rect VesselTypeIcon(VesselType type, OtherIcon icon)
{
int x = 0;
int y = 0;
const float symbolSpan = 0.2f;
if (icon != OtherIcon.None) {
switch (icon) {
case OtherIcon.AP:
x = 1;
y = 4;
break;
case OtherIcon.PE:
x = 0;
y = 4;
break;
case OtherIcon.AN:
x = 2;
y = 4;
break;
case OtherIcon.DN:
x = 3;
y = 4;
break;
case OtherIcon.NODE:
x = 2;
y = 1;
break;
case OtherIcon.SHIPATINTERCEPT:
x = 0;
y = 1;
break;
case OtherIcon.TGTATINTERCEPT:
x = 1;
y = 1;
break;
case OtherIcon.ENTERSOI:
x = 0;
y = 2;
break;
case OtherIcon.EXITSOI:
x = 1;
y = 2;
break;
case OtherIcon.PLANET:
// Not sure if it is (2,3) or (3,2) - both are round
x = 2;
y = 3;
break;
}
} else {
switch (type) {
case VesselType.Base:
x = 2;
y = 0;
break;
case VesselType.Debris:
x = 1;
y = 3;
break;
case VesselType.EVA:
x = 2;
y = 2;
break;
case VesselType.Flag:
x = 4;
y = 0;
break;
case VesselType.Lander:
x = 3;
y = 0;
break;
case VesselType.Probe:
x = 1;
y = 0;
break;
case VesselType.Rover:
x = 0;
y = 0;
break;
case VesselType.Ship:
x = 0;
y = 3;
break;
case VesselType.Station:
x = 3;
y = 1;
break;
case VesselType.Unknown:
x = 3;
y = 3;
break;
case VesselType.SpaceObject:
x = 4;
y = 1;
break;
default:
x = 3;
y = 2;
break;
}
}
var result = new Rect();
result.x = symbolSpan * x;
result.y = symbolSpan * y;
result.height = result.width = symbolSpan;
return result;
}
private void SetTypeAs(VesselType vesselType)
{
this.vesselType = vesselType;
this.ResizeRequested = true;
}
void onAccept(string name, VesselType vt)
{
print ("name: " + name + " VesselType: " + vt.ToString ());
FlightGlobals.ActiveVessel.vesselName = name;
print ("FlightGlobals.ActiveVessel.name: " + FlightGlobals.ActiveVessel.name);
Events ["ActivateEvent"].active = true;
}
public static OrbitIcon orbitIconForVesselType(VesselType type)
{
switch(type) {
case VesselType.Base:
return OrbitIcon.Base;
case VesselType.Debris:
return OrbitIcon.Debris;
case VesselType.EVA:
return OrbitIcon.EVA;
case VesselType.Flag:
return OrbitIcon.Flag;
case VesselType.Lander:
return OrbitIcon.Lander;
case VesselType.Probe:
return OrbitIcon.Probe;
case VesselType.Rover:
return OrbitIcon.Rover;
case VesselType.Ship:
return OrbitIcon.Ship;
case VesselType.Station:
return OrbitIcon.Station;
case VesselType.Unknown:
return OrbitIcon.Mystery;
default:
return OrbitIcon.Mystery;
}
}
public static String GetVesselTypeString(VesselType vesselType)
{
switch (vesselType)
{
case VesselType.Debris:
return "Debris";
case VesselType.SpaceObject:
return "SpaceObject";
case VesselType.Unknown:
return "Unknown";
case VesselType.Probe:
return "Probe";
case VesselType.Rover:
return "Rover";
case VesselType.Lander:
return "Lander";
case VesselType.Ship:
return "Ship";
case VesselType.Station:
return "Station";
case VesselType.Base:
return "Base";
case VesselType.EVA:
return "EVA";
case VesselType.Flag:
return "Flag";
}
return "Undefined";
}
public PartSim(Part thePart, int id, double atmosphere, LogMsg log)
{
part = thePart;
partId = id;
name = part.partInfo.name;
if (log != null)
log.buf.AppendLine("Create PartSim for " + name);
parent = null;
parentAttach = part.attachMode;
fuelCrossFeed = part.fuelCrossFeed;
noCrossFeedNodeKey = part.NoCrossFeedNodeKey;
decoupledInStage = DecoupledInStage(part);
isFuelLine = part is FuelLine;
isFuelTank = part is FuelTank;
isSepratron = IsSepratron();
inverseStage = part.inverseStage;
//MonoBehaviour.print("inverseStage = " + inverseStage);
cost = part.partInfo.cost;
foreach (PartResource resource in part.Resources)
{
cost -= (float)((resource.maxAmount - resource.amount) * resource.info.unitCost);
}
// Work out if the part should have no physical significance
isNoPhysics = part.HasModule<LaunchClamp>() ||
part.physicalSignificance == Part.PhysicalSignificance.NONE ||
part.PhysicsSignificance == 1;
if (!isNoPhysics)
baseMass = part.mass;
if (SimManager.logOutput)
MonoBehaviour.print((isNoPhysics ? "Ignoring" : "Using") + " part.mass of " + part.mass);
foreach (PartResource resource in part.Resources)
{
// Make sure it isn't NaN as this messes up the part mass and hence most of the values
// This can happen if a resource capacity is 0 and tweakable
if (!Double.IsNaN(resource.amount))
{
if (SimManager.logOutput)
MonoBehaviour.print(resource.resourceName + " = " + resource.amount);
resources.Add(resource.info.id, resource.amount);
resourceFlowStates.Add(resource.info.id, resource.flowState ? 1 : 0);
}
else
{
MonoBehaviour.print(resource.resourceName + " is NaN. Skipping.");
}
}
startMass = GetMass();
hasVessel = (part.vessel != null);
isLanded = hasVessel && part.vessel.Landed;
if (hasVessel)
{
vesselName = part.vessel.vesselName;
vesselType = part.vesselType;
}
initialVesselName = part.initialVesselName;
hasMultiModeEngine = part.HasModule<MultiModeEngine>();
hasModuleEnginesFX = part.HasModule<ModuleEnginesFX>();
hasModuleEngines = part.HasModule<ModuleEngines>();
isEngine = hasMultiModeEngine || hasModuleEnginesFX || hasModuleEngines;
if (SimManager.logOutput)
MonoBehaviour.print("Created " + name + ". Decoupled in stage " + decoupledInStage);
}
private void DrawVessels()
{
bool displaying = false;
GUILayout.Label("RENDEZVOUS DISPLAY", fe.headingStyle);
GUILayout.BeginHorizontal(fe.areaStyle);
GUILayout.BeginVertical();
foreach (Vessel vessel in FlightGlobals.Vessels)
{
if (vessel.vesselType == typeOfVessel && vessel != fe.vessel)
{
if (vessel.mainBody == fe.vessel.mainBody)
{
displaying = true;
if (GUILayout.Button(vessel.vesselName, fe.buttonStyle))
{
targetObject = vessel;
fe.settings.Changed = true;
}
}
}
}
GUILayout.EndVertical();
GUILayout.EndHorizontal();
if (GUILayout.Button("Back to Target Type", fe.buttonStyle) || !displaying)
{
targetObject = null;
typeOfTarget = TargetType.None;
typeOfVessel = VesselType.Unknown;
fe.settings.Changed = true;
}
}
private void DrawIcon(float xPos, float yPos, VesselType vt, Color iconColor, MapIcons.OtherIcon icon = MapIcons.OtherIcon.None)
{
var position = new Rect(xPos - iconPixelSize * 0.5f, yPos - iconPixelSize * 0.5f,
iconPixelSize, iconPixelSize);
Rect shadow = position;
shadow.x += iconShadowShift.x;
shadow.y += iconShadowShift.y;
iconMaterial.color = iconColorShadowValue;
Graphics.DrawTexture(shadow, MapView.OrbitIconsMap, MapIcons.VesselTypeIcon(vt, icon), 0, 0, 0, 0, iconMaterial);
iconMaterial.color = iconColor;
Graphics.DrawTexture(position, MapView.OrbitIconsMap, MapIcons.VesselTypeIcon(vt, icon), 0, 0, 0, 0, iconMaterial);
}
void hangar_content_editor(int windowID)
{
GUILayout.BeginVertical();
GUILayout.BeginHorizontal();
//VAB / SPH / SubAss selection
GUILayout.FlexibleSpace();
for(var T = VesselType.VAB; T <= VesselType.SubAssembly; T++)
{ if(GUILayout.Toggle(vessel_type == T, T.ToString(), GUILayout.Width(100))) vessel_type = T; }
GUILayout.FlexibleSpace();
//Vessel selector
if(GUILayout.Button("Select Vessel", Styles.normal_button, GUILayout.ExpandWidth(true)))
{
Rect sWindowPos = new Rect(eWindowPos) { height = 500 };
var diff = HighLogic.CurrentGame.Parameters.Difficulty;
bool stock = diff.AllowStockVessels;
if(vessel_type == VesselType.SubAssembly) diff.AllowStockVessels = false;
vessel_selector =
new CraftBrowser(sWindowPos,
vessel_dirs[(int)vessel_type],
HighLogic.SaveFolder, "Select a ship to store",
vessel_selected,
selection_canceled,
HighLogic.Skin,
EditorLogic.ShipFileImage, true);
diff.AllowStockVessels = stock;
}
GUILayout.EndHorizontal();
//hangar info
float used_frac = used_volume/hangar_metric.volume;
GUILayout.Label(string.Format("Used Volume: {0} {1:F1}%",
Utils.formatVolume(used_volume), used_frac*100f),
Styles.fracStyle(1-used_frac), GUILayout.ExpandWidth(true));
//hangar contents
List<PackedConstruct> constructs = packed_constructs.Values;
constructs.Sort((a, b) => a.name.CompareTo(b.name));
scroll_view = GUILayout.BeginScrollView(scroll_view, GUILayout.Height(200), GUILayout.Width(400));
GUILayout.BeginVertical();
foreach(PackedConstruct pc in constructs)
{
GUILayout.BeginHorizontal();
GUILayout.Label(string.Format("{0}: {1} Cost: {2:F1}",
pc.name, Utils.formatMass(pc.metric.mass), pc.metric.cost),
Styles.label, GUILayout.ExpandWidth(true));
if(GUILayout.Button("X", Styles.red_button, GUILayout.Width(25))) remove_construct(pc);
GUILayout.EndHorizontal();
}
GUILayout.EndVertical();
GUILayout.EndScrollView();
if(GUILayout.Button("Clear", Styles.red_button, GUILayout.ExpandWidth(true))) clear_constructs();
if(GUILayout.Button("Close", Styles.normal_button, GUILayout.ExpandWidth(true)))
{
Utils.LockIfMouseOver(eLock, eWindowPos, false);
editing_hangar = false;
}
GUILayout.EndVertical();
GUI.DragWindow(new Rect(0, 0, 500, 20));
}
// This function prepares the simulation by creating all the necessary data structures it will
// need during the simulation. All required data is copied from the core game data structures
// so that the simulation itself can be run in a background thread without having issues with
// the core game changing the data while the simulation is running.
public bool PrepareSimulation(List<Part> parts, double theGravity, double theAtmosphere = 0, double theVelocity = 0, bool dumpTree = false, bool vectoredThrust = false)
{
LogMsg log = null;
if (SimManager.logOutput)
{
log = new LogMsg();
log.buf.AppendLine("PrepareSimulation started");
dumpTree = true;
}
_timer.Start();
// Store the parameters in members for ease of access in other functions
partList = parts;
gravity = theGravity;
atmosphere = theAtmosphere;
velocity = theVelocity;
lastStage = Staging.lastStage;
//MonoBehaviour.print("lastStage = " + lastStage);
// Create the lists for our simulation parts
allParts = new List<PartSim>();
allFuelLines = new List<PartSim>();
drainingParts = new HashSet<PartSim>();
allEngines = new List<EngineSim>();
activeEngines = new List<EngineSim>();
drainingResources = new HashSet<int>();
// A dictionary for fast lookup of Part->PartSim during the preparation phase
Dictionary<Part, PartSim> partSimLookup = new Dictionary<Part, PartSim>();
if (partList.Count > 0 && partList[0].vessel != null)
{
vesselName = partList[0].vessel.vesselName;
vesselType = partList[0].vessel.vesselType;
}
// First we create a PartSim for each Part (giving each a unique id)
int partId = 1;
foreach (Part part in partList)
{
// If the part is already in the lookup dictionary then log it and skip to the next part
if (partSimLookup.ContainsKey(part))
{
if (log != null)
log.buf.AppendLine("Part " + part.name + " appears in vessel list more than once");
continue;
}
// Create the PartSim
PartSim partSim = new PartSim(part, partId, atmosphere, log);
// Add it to the Part lookup dictionary and the necessary lists
partSimLookup.Add(part, partSim);
allParts.Add(partSim);
if (partSim.isFuelLine)
allFuelLines.Add(partSim);
if (partSim.isEngine)
partSim.CreateEngineSims(allEngines, atmosphere, velocity, vectoredThrust, log);
partId++;
}
UpdateActiveEngines();
// Now that all the PartSims have been created we can do any set up that needs access to other parts
// First we set up all the parent links
foreach (PartSim partSim in allParts)
{
partSim.SetupParent(partSimLookup, log);
}
// Then, in the VAB/SPH, we add the parent of each fuel line to the fuelTargets list of their targets
if (HighLogic.LoadedSceneIsEditor)
{
foreach (PartSim partSim in allFuelLines)
{
if ((partSim.part as FuelLine).target != null)
{
PartSim targetSim;
if (partSimLookup.TryGetValue((partSim.part as FuelLine).target, out targetSim))
{
if (log != null)
log.buf.AppendLine("Fuel line target is " + targetSim.name + ":" + targetSim.partId);
targetSim.fuelTargets.Add(partSim.parent);
}
else
{
if (log != null)
log.buf.AppendLine("No PartSim for fuel line target (" + partSim.part.partInfo.name + ")");
}
}
else
{
if (log != null)
log.buf.AppendLine("Fuel line target is null");
}
}
}
//MonoBehaviour.print("SetupAttachNodes and count stages");
foreach (PartSim partSim in allParts)
{
partSim.SetupAttachNodes(partSimLookup, log);
if (partSim.decoupledInStage >= lastStage)
lastStage = partSim.decoupledInStage + 1;
}
// And finally release the Part references from all the PartSims
//MonoBehaviour.print("ReleaseParts");
foreach (PartSim partSim in allParts)
partSim.ReleasePart();
// And dereference the core's part list
partList = null;
_timer.Stop();
if (log != null)
{
log.buf.AppendLine("PrepareSimulation: " + _timer.ElapsedMilliseconds + "ms");
log.Flush();
}
if (dumpTree)
Dump();
return true;
}
public static void DrawOrbitIcon(Rect target, VesselType type)
{
if (iconsMap != null) {
GUI.DrawTextureWithTexCoords(target, iconsMap, OrbitIconLocation[type]);
}
}
public Filter(WWW textureLink, VesselType type, bool enabled)
{
textureLink.LoadImageIntoTexture(Texture);
Type = type;
Enabled = enabled;
}
public bool matchType(VesselType type, List<VesselType> vesselTypes)
{
if (Type.Equals(type))
return true;
if (Type.Equals(VesselType.Debris) && !vesselTypes.Contains(type))
return true;
return false;
}
private void DrawIcon(double longitude, double latitude, VesselType vt, Color iconColor, MapIcons.OtherIcon icon = MapIcons.OtherIcon.None)
{
var position = new Rect((float)(longitudeToPixels(longitude, latitude) - iconPixelSize / 2),
(float)(latitudeToPixels(longitude, latitude) - iconPixelSize / 2),
iconPixelSize, iconPixelSize);
Rect shadow = position;
shadow.x += iconShadowShift.x;
shadow.y += iconShadowShift.y;
iconMaterial.color = iconColorShadowValue;
Graphics.DrawTexture(shadow, MapView.OrbitIconsMap, MapIcons.VesselTypeIcon(vt, icon), 0, 0, 0, 0, iconMaterial);
iconMaterial.color = iconColor;
Graphics.DrawTexture(position, MapView.OrbitIconsMap, MapIcons.VesselTypeIcon(vt, icon), 0, 0, 0, 0, iconMaterial);
}
public VesselIsType(VesselType vesselType, string title = null)
: base(title)
{
this.vesselType = vesselType;
this.title = title;
}
/// <summary>
/// Checks if this is one of the ignored vessel types.
/// </summary>
/// <param name="vesselType">The type of vessel</param>
/// <returns>True if this type of vessel should be ignored.</returns>
public virtual bool IsIgnoredVesselType(VesselType vesselType)
{
switch (vesselType)
{
case VesselType.Debris:
case VesselType.Flag:
case VesselType.SpaceObject:
case VesselType.Unknown:
return true;
default:
return false;
}
}
public override void OnStart(StartState state)
{
//base OnStart
base.OnStart(state);
if(state == StartState.None) return;
//setup hangar name
if(HangarName == "_none_") HangarName = part.partInfo.title;
//initialize resources
if(state != StartState.Editor) update_resources();
//initialize Animator
part.force_activate();
hangar_gates = part.Modules.OfType<BaseHangarAnimator>().FirstOrDefault(m => m.AnimatorID == AnimatorID);
if (hangar_gates == null)
{
hangar_gates = new BaseHangarAnimator();
Utils.Log("Using BaseHangarAnimator");
}
else
{
Events["Open"].guiActiveEditor = true;
Events["Close"].guiActiveEditor = true;
}
//recalculate volume and mass, start updating labels
Setup();
StartCoroutine(UpdateStatus());
//store packed constructs if any
if(packed_constructs.Count > 0) StartCoroutine(store_constructs());
//set vessel type
EditorLogic el = EditorLogic.fetch;
if(el != null) vessel_type = el.editorType == EditorLogic.EditorMode.SPH ? VesselType.SPH : VesselType.VAB;
}
