private void CreateLode(LodeData lodeData)
{
lodeData.altitude = TerrainHeight(lodeData.latitude, lodeData.longitude, lodeData.body);
Vector3d pos = lodeData.body.GetWorldSurfacePosition(lodeData.latitude, lodeData.longitude, lodeData.altitude.Value);
lodeData.orbit = new Orbit(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, lodeData.body);
lodeData.orbit.UpdateFromStateVectors(pos, lodeData.body.getRFrmVel(pos), lodeData.body, Planetarium.GetUniversalTime());
ConfigNode[] partNodes;
ShipConstruct shipConstruct = null;
uint flightId = ShipConstruction.GetUniqueFlightID(HighLogic.CurrentGame.flightState);
partNodes = new ConfigNode[1];
partNodes[0] = ProtoVessel.CreatePartNode(lodeData.craftPart.name, flightId);
DiscoveryLevels discoveryLevel = DiscoveryLevels.Owned;
ConfigNode protoVesselNode = ProtoVessel.CreateVesselNode(lodeData.name, lodeData.vesselType, lodeData.orbit, 0, partNodes);
Vector3d norm = lodeData.body.GetRelSurfaceNVector(lodeData.latitude, lodeData.longitude);
double terrainHeight = 0.0;
if (lodeData.body.pqsController != null)
{
terrainHeight = lodeData.body.pqsController.GetSurfaceHeight(norm) - lodeData.body.pqsController.radius;
}
bool splashed = true && terrainHeight < 0.001;
protoVesselNode.SetValue("sit", (splashed ? Vessel.Situations.SPLASHED : Vessel.Situations.LANDED).ToString());
protoVesselNode.SetValue("landed", (!splashed).ToString());
protoVesselNode.SetValue("splashed", splashed.ToString());
protoVesselNode.SetValue("lat", lodeData.latitude.ToString());
protoVesselNode.SetValue("lon", lodeData.longitude.ToString());
protoVesselNode.SetValue("alt", lodeData.altitude.ToString());
protoVesselNode.SetValue("landedAt", lodeData.body.name);
float lowest = float.MaxValue;
foreach (Collider collider in lodeData.craftPart.partPrefab.GetComponentsInChildren <Collider>())
{
if (collider.gameObject.layer != 21 && collider.enabled)
{
lowest = Mathf.Min(lowest, collider.bounds.min.y);
}
}
if (Mathf.Approximately(lowest, float.MaxValue))
{
lowest = 0;
}
Quaternion normal = Quaternion.LookRotation(new Vector3((float)norm.x, (float)norm.y, (float)norm.z));
Quaternion rotation = Quaternion.identity;
rotation = rotation * Quaternion.FromToRotation(Vector3.up, Vector3.back);
float hgt = (shipConstruct != null ? shipConstruct.parts[0] : lodeData.craftPart.partPrefab).localRoot.attPos0.y - lowest;
protoVesselNode.SetValue("hgt", hgt.ToString());
protoVesselNode.SetValue("rot", KSPUtil.WriteQuaternion(rotation * normal));
Vector3 nrm = (rotation * Vector3.forward);
protoVesselNode.SetValue("nrm", nrm.x + "," + nrm.y + "," + nrm.z);
protoVesselNode.SetValue("prst", false.ToString());
ProtoVessel protoVessel = new ProtoVessel(protoVesselNode, HighLogic.CurrentGame);
protoVessel.Load(HighLogic.CurrentGame.flightState);
}
/// <summary>
/// Returns true if a new discovery is succesfully made and added to the ResearchHandler
/// </summary>
/// <returns></returns>
ResearchResult _tryNewDiscovery()
{
IEnumerable <ResearchDiscoveries> remainingDiscoveries = AllDiscoveries.Except(Discoveries);
if (remainingDiscoveries.Count() != 0)
{
ResearchDiscoveries s = remainingDiscoveries.ElementAt(Rand.Random.Next(0, remainingDiscoveries.Count()));
Discoveries.Add(s);
DiscoveryLevels.Add(s, 1);
#if DEBUG
ConsoleManager.WriteLine("Discovered " + s.ToString(), ConsoleMessageType.Debug);
#endif
return(new ResearchResult()
{
Discovery = s, Level = 1
});
}
else
{
return(null);
}
}
protected override void OnAccepted()
{
// Actually spawn the kerbals in the game world!
foreach (KerbalData kerbal in kerbals)
{
LoggingUtil.LogVerbose(this, "Spawning a Kerbal named " + kerbal.name);
if (kerbal.altitude == null)
{
kerbal.altitude = LocationUtil.TerrainHeight(kerbal.latitude, kerbal.longitude, kerbal.body);
}
// Set additional info for landed kerbals
if (kerbal.landed)
{
Vector3d pos = kerbal.body.GetWorldSurfacePosition(kerbal.latitude, kerbal.longitude, kerbal.altitude.Value);
kerbal.orbit = new Orbit(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, kerbal.body);
kerbal.orbit.UpdateFromStateVectors(pos, kerbal.body.getRFrmVel(pos), kerbal.body, Planetarium.GetUniversalTime());
LoggingUtil.LogVerbose(typeof(SpawnKerbal), "kerbal generated, orbit = " + kerbal.orbit);
}
uint flightId = ShipConstruction.GetUniqueFlightID(HighLogic.CurrentGame.flightState);
// Create crew member array
ProtoCrewMember[] crewArray = new ProtoCrewMember[1];
crewArray[0] = kerbal.crewMember;
// Create part nodes
ConfigNode[] partNodes = new ConfigNode[1];
partNodes[0] = ProtoVessel.CreatePartNode("kerbalEVA", flightId, crewArray);
// Create additional nodes
ConfigNode[] additionalNodes = new ConfigNode[1];
DiscoveryLevels discoveryLevel = kerbal.owned ? DiscoveryLevels.Owned : DiscoveryLevels.Unowned;
additionalNodes[0] = ProtoVessel.CreateDiscoveryNode(discoveryLevel, UntrackedObjectClass.A, contract.TimeDeadline, contract.TimeDeadline);
// Create the config node representation of the ProtoVessel
ConfigNode protoVesselNode = ProtoVessel.CreateVesselNode(kerbal.name, VesselType.EVA, kerbal.orbit, 0, partNodes, additionalNodes);
// Additional seetings for a landed Kerbal
if (kerbal.landed)
{
// Create the config node representation of the ProtoVessel
protoVesselNode.SetValue("sit", Vessel.Situations.LANDED.ToString());
protoVesselNode.SetValue("landed", true.ToString());
protoVesselNode.SetValue("lat", kerbal.latitude.ToString());
protoVesselNode.SetValue("lon", kerbal.longitude.ToString());
protoVesselNode.SetValue("alt", kerbal.altitude.ToString());
}
// Add vessel to the game
HighLogic.CurrentGame.AddVessel(protoVesselNode);
}
}
protected override void OnAccepted()
{
// Actually spawn the kerbals in the game world!
foreach (KerbalData kerbal in kerbals)
{
uint flightId = ShipConstruction.GetUniqueFlightID(HighLogic.CurrentGame.flightState);
// Create crew member array
ProtoCrewMember[] crewArray = new ProtoCrewMember[1];
crewArray[0] = kerbal.crewMember;
// Create part nodes
ConfigNode[] partNodes = new ConfigNode[1];
partNodes[0] = ProtoVessel.CreatePartNode("kerbalEVA", flightId, crewArray);
// Create additional nodes
ConfigNode[] additionalNodes = new ConfigNode[1];
DiscoveryLevels discoveryLevel = kerbal.owned ? DiscoveryLevels.Owned : DiscoveryLevels.Unowned;
additionalNodes[0] = ProtoVessel.CreateDiscoveryNode(discoveryLevel, UntrackedObjectClass.A, contract.TimeDeadline, contract.TimeDeadline);
// Create the config node representation of the ProtoVessel
ConfigNode protoVesselNode = ProtoVessel.CreateVesselNode(kerbal.name, VesselType.EVA, kerbal.orbit, 0, partNodes, additionalNodes);
// Additional seetings for a landed Kerbal
if (kerbal.landed)
{
// Create the config node representation of the ProtoVessel
protoVesselNode.SetValue("sit", Vessel.Situations.LANDED.ToString());
protoVesselNode.SetValue("landed", true.ToString());
protoVesselNode.SetValue("lat", kerbal.latitude.ToString());
protoVesselNode.SetValue("lon", kerbal.longitude.ToString());
protoVesselNode.SetValue("alt", kerbal.altitude.ToString());
}
// Add vessel to the game
HighLogic.CurrentGame.AddVessel(protoVesselNode);
}
}
/// <summary>
/// Returns true if an existing discovery is succesfully selected and upgraded
/// </summary>
/// <returns></returns>
ResearchResult _tryUpgradeDiscovery()
{
var nonMaxxed = DiscoveryLevels.Where(a => (a.Value < ResearchHandler.MaxResearchLevel));
if (nonMaxxed.Count() != 0)
{
var resToUpgrade = nonMaxxed.ElementAt(Rand.Random.Next(0, nonMaxxed.Count()));
DiscoveryLevels[resToUpgrade.Key] += 1;
#if DEBUG
ConsoleManager.WriteLine("Discovered " + resToUpgrade.Key.ToString() + " level " + DiscoveryLevels[resToUpgrade.Key], ConsoleMessageType.Debug);
#endif
return(new ResearchResult()
{
Discovery = resToUpgrade.Key, Level = resToUpgrade.Value
});
}
else
{
return(null);
}
}
protected override void OnAccepted()
{
// Actually spawn the kerbals in the game world!
foreach (KerbalData kd in kerbals)
{
LoggingUtil.LogVerbose(this, "Spawning a Kerbal named " + kd.kerbal.name);
// Generate the ProtoCrewMember
kd.kerbal.GenerateKerbal();
if (kd.altitude == null)
{
kd.altitude = LocationUtil.TerrainHeight(kd.latitude, kd.longitude, kd.body);
}
// Set additional info for landed kerbals
if (kd.landed)
{
Vector3d pos = kd.body.GetWorldSurfacePosition(kd.latitude, kd.longitude, kd.altitude.Value);
kd.orbit = new Orbit(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, kd.body);
kd.orbit.UpdateFromStateVectors(pos, kd.body.getRFrmVel(pos), kd.body, Planetarium.GetUniversalTime());
LoggingUtil.LogVerbose(typeof(SpawnKerbal), "kerbal generated, orbit = " + kd.orbit);
}
else
{
// Update the reference body in the orbit
kd.orbit.referenceBody = kd.body;
}
uint flightId = ShipConstruction.GetUniqueFlightID(HighLogic.CurrentGame.flightState);
// Create crew member array
ProtoCrewMember[] crewArray = new ProtoCrewMember[1];
crewArray[0] = kd.kerbal.pcm;
// Create part nodes
ConfigNode[] partNodes = new ConfigNode[1];
partNodes[0] = ProtoVessel.CreatePartNode(kd.kerbal.gender == ProtoCrewMember.Gender.Male ? "kerbalEVA" : "kerbalEVAfemale",
flightId, crewArray);
// Create additional nodes
ConfigNode[] additionalNodes = new ConfigNode[1];
DiscoveryLevels discoveryLevel = kd.owned ? DiscoveryLevels.Owned : DiscoveryLevels.Unowned;
additionalNodes[0] = ProtoVessel.CreateDiscoveryNode(discoveryLevel, UntrackedObjectClass.A, contract.TimeDeadline, contract.TimeDeadline);
// Create the config node representation of the ProtoVessel
ConfigNode protoVesselNode = ProtoVessel.CreateVesselNode(kd.kerbal.name, VesselType.EVA, kd.orbit, 0, partNodes, additionalNodes);
// Additional seetings for a landed Kerbal
if (kd.landed)
{
bool splashed = kd.altitude.Value < 0.001 && kd.body.ocean;
// Add a bit of height for landed kerbals
if (!splashed)
{
kd.altitude += 0.2;
}
// Figure out the appropriate rotation
Vector3d norm = kd.body.GetRelSurfaceNVector(kd.latitude, kd.longitude);
Quaternion normal = Quaternion.LookRotation(new Vector3((float)norm.x, (float)norm.y, (float)norm.z));
Quaternion rotation = Quaternion.FromToRotation(Vector3.up, Vector3.forward);
rotation = rotation * Quaternion.AngleAxis(kd.heading + 180, Vector3.up);
// Create the config node representation of the ProtoVessel
protoVesselNode.SetValue("sit", (splashed ? Vessel.Situations.SPLASHED : Vessel.Situations.LANDED).ToString());
protoVesselNode.SetValue("landed", (!splashed).ToString());
protoVesselNode.SetValue("splashed", splashed.ToString());
protoVesselNode.SetValue("lat", kd.latitude.ToString());
protoVesselNode.SetValue("lon", kd.longitude.ToString());
protoVesselNode.SetValue("alt", kd.altitude.ToString());
protoVesselNode.SetValue("rot", KSPUtil.WriteQuaternion(normal * rotation));
// Set the normal vector relative to the surface
Vector3 nrm = (rotation * Vector3.forward);
protoVesselNode.SetValue("nrm", nrm.x + "," + nrm.y + "," + nrm.z);
}
// Add vessel to the game
HighLogic.CurrentGame.AddVessel(protoVesselNode);
}
}
protected bool CreateVessels()
{
if (vesselsCreated)
{
return(false);
}
String gameDataDir = KSPUtil.ApplicationRootPath;
gameDataDir = gameDataDir.Replace("\\", "/");
if (!gameDataDir.EndsWith("/"))
{
gameDataDir += "/";
}
gameDataDir += "GameData";
// Spawn the vessel in the game world
foreach (VesselData vesselData in vessels)
{
LoggingUtil.LogVerbose(this, "Spawning a vessel named '" + vesselData.name + "'");
// Set additional info for landed vessels
bool landed = false;
if (!vesselData.orbiting)
{
landed = true;
if (vesselData.altitude == null)
{
vesselData.altitude = LocationUtil.TerrainHeight(vesselData.latitude, vesselData.longitude, vesselData.body);
}
Vector3d pos = vesselData.body.GetWorldSurfacePosition(vesselData.latitude, vesselData.longitude, vesselData.altitude.Value);
vesselData.orbit = new Orbit(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, vesselData.body);
vesselData.orbit.UpdateFromStateVectors(pos, vesselData.body.getRFrmVel(pos), vesselData.body, Planetarium.GetUniversalTime());
}
else
{
vesselData.orbit.referenceBody = vesselData.body;
}
ConfigNode[] partNodes;
UntrackedObjectClass sizeClass;
ShipConstruct shipConstruct = null;
if (!string.IsNullOrEmpty(vesselData.craftURL))
{
// Save the current ShipConstruction ship, otherwise the player will see the spawned ship next time they enter the VAB!
ConfigNode currentShip = ShipConstruction.ShipConfig;
shipConstruct = ShipConstruction.LoadShip(gameDataDir + "/" + vesselData.craftURL);
if (shipConstruct == null)
{
LoggingUtil.LogError(this, "ShipConstruct was null when tried to load '" + vesselData.craftURL +
"' (usually this means the file could not be found).");
continue;
}
// Restore ShipConstruction ship
ShipConstruction.ShipConfig = currentShip;
// Set the name
if (string.IsNullOrEmpty(vesselData.name))
{
vesselData.name = shipConstruct.shipName;
}
// Set some parameters that need to be at the part level
uint missionID = (uint)Guid.NewGuid().GetHashCode();
uint launchID = HighLogic.CurrentGame.launchID++;
foreach (Part p in shipConstruct.parts)
{
p.flightID = ShipConstruction.GetUniqueFlightID(HighLogic.CurrentGame.flightState);
p.missionID = missionID;
p.launchID = launchID;
p.flagURL = vesselData.flagURL ?? HighLogic.CurrentGame.flagURL;
// Had some issues with this being set to -1 for some ships - can't figure out
// why. End result is the vessel exploding, so let's just set it to a positive
// value.
p.temperature = 1.0;
}
foreach (CrewData cd in vesselData.crew)
{
bool success = false;
// Find a seat for the crew
Part part = shipConstruct.parts.Find(p => p.protoModuleCrew.Count < p.CrewCapacity);
// Add the crew member
if (part != null)
{
// Create the ProtoCrewMember
ProtoCrewMember crewMember = HighLogic.CurrentGame.CrewRoster.GetNewKerbal(ProtoCrewMember.KerbalType.Unowned);
if (cd.gender != null)
{
crewMember.gender = cd.gender.Value;
}
if (cd.name != null)
{
crewMember.name = cd.name;
}
// Add them to the part
success = part.AddCrewmemberAt(crewMember, part.protoModuleCrew.Count);
}
if (!success)
{
LoggingUtil.LogWarning(this, "Unable to add crew to vessel named '" + vesselData.name + "'. Perhaps there's no room?");
break;
}
}
// Create a dummy ProtoVessel, we will use this to dump the parts to a config node.
// We can't use the config nodes from the .craft file, because they are in a
// slightly different format than those required for a ProtoVessel (seriously
// Squad?!?).
ConfigNode empty = new ConfigNode();
ProtoVessel dummyProto = new ProtoVessel(empty, null);
Vessel dummyVessel = new Vessel();
dummyVessel.parts = shipConstruct.parts;
dummyProto.vesselRef = dummyVessel;
// Create the ProtoPartSnapshot objects and then initialize them
foreach (Part p in shipConstruct.parts)
{
dummyProto.protoPartSnapshots.Add(new ProtoPartSnapshot(p, dummyProto));
}
foreach (ProtoPartSnapshot p in dummyProto.protoPartSnapshots)
{
p.storePartRefs();
}
// Create the ship's parts
partNodes = dummyProto.protoPartSnapshots.Select <ProtoPartSnapshot, ConfigNode>(GetNodeForPart).ToArray();
// Estimate an object class, numbers are based on the in game description of the
// size classes.
float size = shipConstruct.shipSize.magnitude / 2.0f;
if (size < 4.0f)
{
sizeClass = UntrackedObjectClass.A;
}
else if (size < 7.0f)
{
sizeClass = UntrackedObjectClass.B;
}
else if (size < 12.0f)
{
sizeClass = UntrackedObjectClass.C;
}
else if (size < 18.0f)
{
sizeClass = UntrackedObjectClass.D;
}
else
{
sizeClass = UntrackedObjectClass.E;
}
}
else
{
// Create crew member array
ProtoCrewMember[] crewArray = new ProtoCrewMember[vesselData.crew.Count];
int i = 0;
foreach (CrewData cd in vesselData.crew)
{
// Create the ProtoCrewMember
ProtoCrewMember crewMember = HighLogic.CurrentGame.CrewRoster.GetNewKerbal(ProtoCrewMember.KerbalType.Unowned);
if (cd.name != null)
{
crewMember.name = cd.name;
}
crewArray[i++] = crewMember;
}
// Create part nodes
uint flightId = ShipConstruction.GetUniqueFlightID(HighLogic.CurrentGame.flightState);
partNodes = new ConfigNode[1];
partNodes[0] = ProtoVessel.CreatePartNode(vesselData.craftPart.name, flightId, crewArray);
// Default the size class
sizeClass = UntrackedObjectClass.A;
// Set the name
if (string.IsNullOrEmpty(vesselData.name))
{
vesselData.name = vesselData.craftPart.name;
}
}
// Create additional nodes
ConfigNode[] additionalNodes = new ConfigNode[1];
DiscoveryLevels discoveryLevel = vesselData.owned ? DiscoveryLevels.Owned : DiscoveryLevels.Unowned;
additionalNodes[0] = ProtoVessel.CreateDiscoveryNode(discoveryLevel, sizeClass, contract.TimeDeadline, contract.TimeDeadline);
// Create the config node representation of the ProtoVessel
ConfigNode protoVesselNode = ProtoVessel.CreateVesselNode(vesselData.name, vesselData.vesselType, vesselData.orbit, 0, partNodes, additionalNodes);
// Additional seetings for a landed vessel
if (!vesselData.orbiting)
{
Vector3d norm = vesselData.body.GetRelSurfaceNVector(vesselData.latitude, vesselData.longitude);
double terrainHeight = 0.0;
if (vesselData.body.pqsController != null)
{
terrainHeight = vesselData.body.pqsController.GetSurfaceHeight(norm) - vesselData.body.pqsController.radius;
}
bool splashed = landed && terrainHeight < 0.001;
// Create the config node representation of the ProtoVessel
// Note - flying is experimental, and so far doesn't work
protoVesselNode.SetValue("sit", (splashed ? Vessel.Situations.SPLASHED : landed ?
Vessel.Situations.LANDED : Vessel.Situations.FLYING).ToString());
protoVesselNode.SetValue("landed", (landed && !splashed).ToString());
protoVesselNode.SetValue("splashed", splashed.ToString());
protoVesselNode.SetValue("lat", vesselData.latitude.ToString());
protoVesselNode.SetValue("lon", vesselData.longitude.ToString());
protoVesselNode.SetValue("alt", vesselData.altitude.ToString());
protoVesselNode.SetValue("landedAt", vesselData.body.name);
// Figure out the additional height to subtract
float lowest = float.MaxValue;
if (shipConstruct != null)
{
foreach (Part p in shipConstruct.parts)
{
foreach (Collider collider in p.GetComponentsInChildren <Collider>())
{
if (collider.gameObject.layer != 21 && collider.enabled)
{
lowest = Mathf.Min(lowest, collider.bounds.min.y);
}
}
}
}
else
{
foreach (Collider collider in vesselData.craftPart.partPrefab.GetComponentsInChildren <Collider>())
{
if (collider.gameObject.layer != 21 && collider.enabled)
{
lowest = Mathf.Min(lowest, collider.bounds.min.y);
}
}
}
if (lowest == float.MaxValue)
{
lowest = 0;
}
// Figure out the surface height and rotation
Quaternion normal = Quaternion.LookRotation(new Vector3((float)norm.x, (float)norm.y, (float)norm.z));
Quaternion rotation = Quaternion.identity;
float heading = vesselData.heading;
if (shipConstruct == null)
{
rotation = rotation * Quaternion.FromToRotation(Vector3.up, Vector3.back);
}
else if (shipConstruct.shipFacility == EditorFacility.SPH)
{
rotation = rotation * Quaternion.FromToRotation(Vector3.forward, -Vector3.forward);
heading += 180.0f;
}
else
{
rotation = rotation * Quaternion.FromToRotation(Vector3.up, Vector3.forward);
}
rotation = rotation * Quaternion.AngleAxis(heading, Vector3.back);
rotation = rotation * Quaternion.AngleAxis(vesselData.roll, Vector3.down);
rotation = rotation * Quaternion.AngleAxis(vesselData.pitch, Vector3.left);
// Set the height and rotation
if (landed || splashed)
{
float hgt = (shipConstruct != null ? shipConstruct.parts[0] : vesselData.craftPart.partPrefab).localRoot.attPos0.y - lowest;
hgt += vesselData.height;
protoVesselNode.SetValue("hgt", hgt.ToString());
}
protoVesselNode.SetValue("rot", KSPUtil.WriteQuaternion(rotation * normal));
// Set the normal vector relative to the surface
Vector3 nrm = (rotation * Vector3.forward);
protoVesselNode.SetValue("nrm", nrm.x + "," + nrm.y + "," + nrm.z);
protoVesselNode.SetValue("prst", false.ToString());
}
// Add vessel to the game
ProtoVessel protoVessel = HighLogic.CurrentGame.AddVessel(protoVesselNode);
// Store the id for later use
vesselData.id = protoVessel.vesselRef.id;
// Associate it so that it can be used in contract parameters
ContractVesselTracker.Instance.AssociateVessel(vesselData.name, protoVessel.vesselRef);
}
vesselsCreated = true;
return(true);
}
public void SetBodyDiscoveryLevel(KeyValuePair <CelestialBody, CelestialBodyInfo> cb, DiscoveryLevels level)
{
cb.Key.DiscoveryInfo.SetLevel(level);
try
{
if (Database.instance.CelestialBodies[cb.Key.referenceBody].KOPbarycenter)
{
cb.Key.referenceBody.DiscoveryInfo.SetLevel(level);
}
if (cb.Value.KOPrelbarycenterBody != null)
{
cb.Value.KOPrelbarycenterBody.DiscoveryInfo.SetLevel(level);
}
}
catch (Exception)
{// throw;
}
if (isPCBMInstalled && (HighLogic.LoadedScene == GameScenes.FLIGHT || HighLogic.LoadedScene == GameScenes.TRACKSTATION)) //If progressive CB maps are installed set the level of the meshmap.
{
if (cb.Value.ignore)
{
setCBContractWeight(cb, true);
SetBodyProgressiveCBMap(cb.Key, 6);
return;
}
if (!cb.Value.isResearched)
{
setCBContractWeight(cb, false);
SetBodyProgressiveCBMap(cb.Key, 1);
}
else
{
if (cb.Value.researchState < 30)
{
setCBContractWeight(cb, false);
SetBodyProgressiveCBMap(cb.Key, 2);
}
else
{
if (cb.Value.researchState < 50)
{
setCBContractWeight(cb, false);
SetBodyProgressiveCBMap(cb.Key, 3);
}
else
{
if (cb.Value.researchState < 70)
{
setCBContractWeight(cb, false);
SetBodyProgressiveCBMap(cb.Key, 4);
}
else
{
if (cb.Value.researchState < 90)
{
setCBContractWeight(cb, false);
SetBodyProgressiveCBMap(cb.Key, 5);
}
else
{
setCBContractWeight(cb, false);
SetBodyProgressiveCBMap(cb.Key, 6);
}
}
}
}
}
}
}
protected void CreateVessels()
{
if (vesselsCreated)
{
return;
}
String gameDataDir = KSPUtil.ApplicationRootPath;
gameDataDir = gameDataDir.Replace("\\", "/");
if (!gameDataDir.EndsWith("/"))
{
gameDataDir += "/";
}
gameDataDir += "GameData";
// Spawn the vessel in the game world
foreach (VesselData vesselData in vessels)
{
LoggingUtil.LogVerbose(this, "Spawning a vessel named '" + vesselData.name + "'");
// Save the current ShipConstruction ship, otherwise the player will see the spawned ship next time they enter the VAB!
ConfigNode currentShip = ShipConstruction.ShipConfig;
ShipConstruct shipConstruct = ShipConstruction.LoadShip(gameDataDir + "/" + vesselData.craftURL);
if (shipConstruct == null)
{
LoggingUtil.LogError(this, "ShipConstruct was null when tried to load '" + vesselData.craftURL +
"' (usually this means the file could not be found).");
continue;
}
// Restore ShipConstruction ship
ShipConstruction.ShipConfig = currentShip;
// Set the name
if (string.IsNullOrEmpty(vesselData.name))
{
vesselData.name = shipConstruct.shipName;
}
// Set some parameters that need to be at the part level
uint flightId = ShipConstruction.GetUniqueFlightID(HighLogic.CurrentGame.flightState);
uint missionID = (uint)Guid.NewGuid().GetHashCode();
uint launchID = HighLogic.CurrentGame.launchID++;
foreach (Part p in shipConstruct.parts)
{
p.flightID = flightId;
p.missionID = missionID;
p.launchID = launchID;
p.flagURL = vesselData.flagURL ?? HighLogic.CurrentGame.flagURL;
}
// Assign crew to the vessel
foreach (CrewData cd in vesselData.crew)
{
bool success = false;
// Find a seat for the crew
Part part = shipConstruct.parts.Find(p => p.protoModuleCrew.Count < p.CrewCapacity);
// Add the crew member
if (part != null)
{
// Create the ProtoCrewMember
ProtoCrewMember crewMember = HighLogic.CurrentGame.CrewRoster.GetNewKerbal(ProtoCrewMember.KerbalType.Unowned);
if (cd.name != null)
{
crewMember.name = cd.name;
}
// Add them to the part
success = part.AddCrewmemberAt(crewMember, part.protoModuleCrew.Count);
}
if (!success)
{
LoggingUtil.LogWarning(this, "Unable to add crew to vessel named '" + vesselData.name + "'. Perhaps there's no room?");
break;
}
}
// Set additional info for landed kerbals
if (vesselData.landed)
{
if (vesselData.altitude == null)
{
vesselData.altitude = LocationUtil.TerrainHeight(vesselData.latitude, vesselData.longitude, vesselData.body);
}
Vector3d pos = vesselData.body.GetWorldSurfacePosition(vesselData.latitude, vesselData.longitude, vesselData.altitude.Value);
vesselData.orbit = new Orbit(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, vesselData.body);
vesselData.orbit.UpdateFromStateVectors(pos, vesselData.body.getRFrmVel(pos), vesselData.body, Planetarium.GetUniversalTime());
LoggingUtil.LogDebug(this, "vesselData generated, orbit = " + vesselData.orbit);
}
// Create a dummy ProtoVessel, we will use this to dump the parts to a config node.
// We can't use the config nodes from the .craft file, because they are in a
// slightly different format than those required for a ProtoVessel (seriously
// Squad?!?).
ConfigNode empty = new ConfigNode();
ProtoVessel dummyProto = new ProtoVessel(empty, null);
Vessel dummyVessel = new Vessel();
dummyVessel.parts = shipConstruct.parts;
dummyProto.vesselRef = dummyVessel;
// Create the ProtoPartSnapshot objects and then initialize them
foreach (Part p in shipConstruct.parts)
{
dummyProto.protoPartSnapshots.Add(new ProtoPartSnapshot(p, dummyProto));
}
foreach (ProtoPartSnapshot p in dummyProto.protoPartSnapshots)
{
p.storePartRefs();
}
// Estimate an object class, numbers are based on the in game description of the
// size classes.
float size = shipConstruct.shipSize.magnitude / 2.0f;
UntrackedObjectClass sizeClass;
if (size < 4.0f)
{
sizeClass = UntrackedObjectClass.A;
}
else if (size < 7.0f)
{
sizeClass = UntrackedObjectClass.B;
}
else if (size < 12.0f)
{
sizeClass = UntrackedObjectClass.C;
}
else if (size < 18.0f)
{
sizeClass = UntrackedObjectClass.D;
}
else
{
sizeClass = UntrackedObjectClass.E;
}
// Create the ship's parts
ConfigNode[] partNodes = dummyProto.protoPartSnapshots.Select <ProtoPartSnapshot, ConfigNode>(GetNodeForPart).ToArray();
// Create additional nodes
ConfigNode[] additionalNodes = new ConfigNode[1];
DiscoveryLevels discoveryLevel = vesselData.owned ? DiscoveryLevels.Owned : DiscoveryLevels.Unowned;
additionalNodes[0] = ProtoVessel.CreateDiscoveryNode(discoveryLevel, sizeClass, contract.TimeDeadline, contract.TimeDeadline);
// Create the config node representation of the ProtoVessel
ConfigNode protoVesselNode = ProtoVessel.CreateVesselNode(vesselData.name, vesselData.vesselType, vesselData.orbit, 0, partNodes, additionalNodes);
// Additional seetings for a landed vessel
if (vesselData.landed)
{
// Create the config node representation of the ProtoVessel
protoVesselNode.SetValue("sit", Vessel.Situations.LANDED.ToString());
protoVesselNode.SetValue("landed", true.ToString());
protoVesselNode.SetValue("lat", vesselData.latitude.ToString());
protoVesselNode.SetValue("lon", vesselData.longitude.ToString());
protoVesselNode.SetValue("alt", vesselData.altitude.ToString());
protoVesselNode.SetValue("landedAt", vesselData.body.name);
// Figure out the additional heigh to subtract
float lowest = float.MaxValue;
foreach (Part p in shipConstruct.parts)
{
foreach (Collider collider in p.GetComponentsInChildren <Collider>())
{
if (collider.gameObject.layer != 21 && collider.enabled)
{
lowest = Mathf.Min(lowest, collider.bounds.min.y);
}
}
}
// Figure out the surface height and rotation
Vector3d norm = vesselData.body.GetRelSurfaceNVector(vesselData.latitude, vesselData.longitude);
Quaternion rotation = Quaternion.FromToRotation(Vector3.forward, Vector3.up) *
Quaternion.LookRotation(new Vector3((float)norm.x, (float)norm.y, (float)norm.z));
protoVesselNode.SetValue("hgt", (shipConstruct.parts[0].localRoot.attPos0.y - lowest).ToString());
protoVesselNode.SetValue("rot", KSPUtil.WriteQuaternion(rotation));
}
// Add vessel to the game
ProtoVessel protoVessel = HighLogic.CurrentGame.AddVessel(protoVesselNode);
// Store the id for later use
vesselData.id = protoVessel.vesselRef.id;
// Associate it so that it can be used in contract parameters
ContractVesselTracker.Instance.AssociateVessel(vesselData.name, protoVessel.vesselRef);
}
vesselsCreated = true;
}
/// <summary>Sets the level of knowledge the player has for the asteroid</summary>
///
/// <param name="level">The flags representing the asteroid's exploration state</param>
///
public extern void SetLevel(DiscoveryLevels level);
/// <summary>Function testing if an asteroid has a particular discovery level</summary>
///
/// <param name="lvl">The flag(s) whose presence must be tested.</param>
///
/// <returns>True if at least one of the flags in <paramref name="lvl"/> is in
/// this object, false otherwise</returns>
///
public extern bool HaveKnowledgeAbout(DiscoveryLevels lvl);
//----------------------------------------------------------------------
/// <summary>Initializes a Class C asteroid</summary>
///
/// <param name="host">The vessel or celestial body to which this DiscoveryInfo applies</param>
/// <param name="level">The amount of knowledge for the asteroid</param>
/// <param name="untrackedLifetime">The amount of time the asteroid can remain untracked
/// before disappearing</param>
///
public extern DiscoveryInfo(IDiscoverable host, DiscoveryLevels level, double untrackedLifetime);
/// <summary>Sets the level of knowledge the player has for the asteroid</summary> /// /// <param name="level">The flags representing the asteroid's exploration state</param> /// public extern void SetLevel(DiscoveryLevels level);
/// <summary>Function testing if an asteroid has a particular discovery level</summary> /// /// <param name="lvl">The flag(s) whose presence must be tested.</param> /// /// <returns>True if at least one of the flags in <paramref name="lvl"/> is in /// this object, false otherwise</returns> /// public extern bool HaveKnowledgeAbout(DiscoveryLevels lvl);
//----------------------------------------------------------------------
/// <summary>Initializes a Class C asteroid</summary>
///
/// <param name="host">The vessel or celestial body to which this DiscoveryInfo applies</param>
/// <param name="level">The amount of knowledge for the asteroid</param>
/// <param name="untrackedLifetime">The amount of time the asteroid can remain untracked
/// before disappearing</param>
///
public extern DiscoveryInfo(IDiscoverable host, DiscoveryLevels level, double untrackedLifetime);
