public ProtoPartAntenna(ProtoPartModuleSnapshot antenna, ProtoPartSnapshot partSnap, Vessel v, string ModuleName, uint part_id)
{
this.protoPartSnap = partSnap;
this.vessel = v;
this.part_id = part_id;
if (ModuleName == "ModuleDataTransmitter")
{
if (partSnap.FindModule("ModuleDeployableAntenna") != null)
{
this.ModuleName = "ModuleDeployableAntenna";
this.antenna = partSnap.FindModule("ModuleDeployableAntenna");
}
else if (partSnap.FindModule("ModuleAnimateGeneric") != null)
{
this.ModuleName = "ModuleAnimateGeneric";
this.antenna = partSnap.FindModule("ModuleAnimateGeneric");
}
else
{
this.ModuleName = "ModuleDataTransmitter";
this.antenna = antenna;
}
}
else
{
this.antenna = antenna;
this.ModuleName = ModuleName;
}
}
public ProtoAntennaDevice(PartModule prefab, ProtoPartSnapshot protoPart, ProtoPartModuleSnapshot protoModule, string ModuleName)
: base(prefab, protoPart, protoModule)
{
if (ModuleName == "ModuleDataTransmitter")
{
this.ModuleName = "ModuleDataTransmitter";
this.antenna = protoModule;
if (protoPart.FindModule("ModuleDeployableAntenna") != null)
{
this.ModuleName = "ModuleDeployableAntenna";
this.antenna = protoPart.FindModule("ModuleDeployableAntenna");
}
else if (protoPart.FindModule("ModuleAnimateGeneric") != null &&
!protoPart.partName.Contains("Lander")) // see above
{
this.ModuleName = "ModuleAnimateGeneric";
this.antenna = protoPart.FindModule("ModuleAnimateGeneric");
}
}
else
{
this.antenna = protoModule;
this.ModuleName = ModuleName;
}
}
void FindVesselsWithSkylab(Vessel vesselDestroyed = null)
{
Log.Info("Addon.FindVesselsWithSkylab");
vesselsWithSkylab.Clear();
for (int vesselIdx = 0; vesselIdx < FlightGlobals.Vessels.Count; vesselIdx++)
{
Vessel v = FlightGlobals.Vessels[vesselIdx];
Log.Info("vesselIdx[" + vesselIdx + "]: " + v.vesselName);
if (vesselDestroyed != null && v.persistentId == vesselDestroyed.persistentId)
{
Log.Info("Ignoring destroyed vessel: " + vesselDestroyed.vesselName);
continue;
}
if (v.packed)
{
for (int i2 = 0; i2 < v.protoVessel.protoPartSnapshots.Count; i2++)
{
ProtoPartSnapshot p = v.protoVessel.protoPartSnapshots[i2];
var pms = p.FindModule("SkylabExperiment");
if (pms != null)
{
vesselsWithSkylab.Add(v);
break;
}
}
}
}
}
/// <summary>
/// Load BV controllers from the config
/// </summary>
internal void LoadControllers()
{
Vessel vessel = null;
ProtoPartSnapshot part = null;
BVControllers.Clear();
for (int i = 0; i < FlightGlobals.Vessels.Count; i++)
{
vessel = FlightGlobals.Vessels[i];
ConfigNode vesselConfigNode = new ConfigNode();
vessel.protoVessel.Save(vesselConfigNode);
for (int k = 0; k < vessel.protoVessel.protoPartSnapshots.Count; k++)
{
part = vessel.protoVessel.protoPartSnapshots[k];
ProtoPartModuleSnapshot module = part.FindModule("BonVoyageModule");
if (module != null)
{
ConfigNode BVModule = module.moduleValues;
string vesselType = BVModule.GetValue("vesselType");
if (vessel.isActiveVessel)
{
BonVoyageModule m = vessel.FindPartModuleImplementing <BonVoyageModule>();
if (m != null)
{
vesselType = m.vesselType;
}
else
{
continue;
}
}
BVController controller = null;
switch (vesselType)
{
case "0": // rover
controller = new RoverController(vessel, BVModule);
break;
case "1": // ship
controller = new ShipController(vessel, BVModule);
break;
default: // default to rover
controller = new RoverController(vessel, BVModule);
break;
}
BVControllers.Add(controller);
break;
}
}
}
}
private static void UpdatePartModulesInProtoPart(ProtoPartSnapshot protoPartToUpdate, ProtoPartSnapshot partSnapshot)
{
//Run trough all the part DEFINITION modules
foreach (var moduleSnapshotDefinition in partSnapshot.modules.Where(m => !VesselModulesToIgnore.ModulesToIgnore.Contains(m.moduleName)))
{
//Get the corresponding module from the actual vessel PROTOPART
var currentModule = protoPartToUpdate.FindModule(moduleSnapshotDefinition.moduleName);
if (currentModule != null)
{
moduleSnapshotDefinition.moduleValues.CopyTo(currentModule.moduleValues);
}
}
}
private static void LoadTweakScalePartModules(ProtoPartSnapshot protoPartSnapshot, VesselData vesselData)
{
ProtoPartModuleSnapshot protoPartModuleSnapshot = protoPartSnapshot.FindModule("TweakScale");
if (protoPartModuleSnapshot == null)
{
return;
}
double.TryParse(protoPartModuleSnapshot.moduleValues.GetValue("currentScale"), out double currentScale);
double.TryParse(protoPartModuleSnapshot.moduleValues.GetValue("defaultScale"), out double defaultScale);
double tweakScalePartMultiplier = defaultScale > 0 && currentScale > 0 ? currentScale / defaultScale : 1;
vesselData.PartSizeMultipliers.Add(protoPartSnapshot.persistentId, tweakScalePartMultiplier);
}
private static void UpdatePartFairings(ProtoPartSnapshot partSnapshot, Part part)
{
var fairingModule = part.FindModuleImplementing <ModuleProceduralFairing>();
if (fairingModule != null)
{
if (FsmField?.GetValue(fairingModule) is KerbalFSM fsmVal)
{
var currentState = fsmVal.CurrentState;
var protoFsmVal = partSnapshot.FindModule("ModuleProceduralFairing")?.moduleValues?.GetValue("fsm");
if (protoFsmVal != null && currentState.ToString() != protoFsmVal)
{
fairingModule.DeployFairing();
}
}
}
}
public ProtoHarvesterDevice(Harvester prefab, ProtoPartSnapshot protoPart, ProtoPartModuleSnapshot protoModule)
: base(prefab, protoPart, protoModule)
{
this.animator = protoPart.FindModule("ModuleAnimationGroup");
}
/// <summary>
/// Read the part data of an unloaded/loaded vessel and store in data structures
/// </summary>
protected List <CNCAntennaPartInfo> readAntennaData()
{
List <CNCAntennaPartInfo> antennas = new List <CNCAntennaPartInfo>();
int numParts = (!this.vessel.loaded) ? this.vessel.protoVessel.protoPartSnapshots.Count : this.vessel.Parts.Count;
//inspect each part
for (int partIndex = 0; partIndex < numParts; partIndex++)
{
Part thisPart;
ProtoPartSnapshot partSnapshot = null;
if (this.Vessel.loaded)
{
thisPart = this.vessel.Parts[partIndex];
}
else
{
partSnapshot = this.vessel.protoVessel.protoPartSnapshots[partIndex];
thisPart = partSnapshot.partInfo.partPrefab;
}
bool populatedAntennaInfo = false;
CNCAntennaPartInfo newAntennaPartInfo = new CNCAntennaPartInfo();;
ProtoPartModuleSnapshot partModuleSnapshot = null;
//inspect each module of the part
for (int moduleIndex = 0; moduleIndex < thisPart.Modules.Count; moduleIndex++)
{
PartModule thisPartModule = thisPart.Modules[moduleIndex];
if (thisPartModule is CNConstellationAntennaModule) // is it CNConstellationAntennaModule?
{
if (!this.Vessel.loaded)
{
partModuleSnapshot = partSnapshot.FindModule(thisPartModule, moduleIndex);
newAntennaPartInfo.frequency = short.Parse(partModuleSnapshot.moduleValues.GetValue("Frequency"));
string oname = partModuleSnapshot.moduleValues.GetValue("OptionalName");
newAntennaPartInfo.name = (oname.Length == 0) ? partSnapshot.partInfo.title : oname;
newAntennaPartInfo.inUse = bool.Parse(partModuleSnapshot.moduleValues.GetValue("InUse"));
newAntennaPartInfo.CosAngle = double.Parse(partModuleSnapshot.moduleValues.GetValue("CosAngle"));
}
else
{
CNConstellationAntennaModule antennaMod = (CNConstellationAntennaModule)thisPartModule;
newAntennaPartInfo.frequency = antennaMod.Frequency;
newAntennaPartInfo.name = antennaMod.Name;
newAntennaPartInfo.inUse = antennaMod.InUse;
}
populatedAntennaInfo = true;
}
else if (thisPartModule is ICommAntenna) // is it ModuleDataTransmitter?
{
ICommAntenna thisAntenna = thisPartModule as ICommAntenna;
if (!this.Vessel.loaded)
{
partModuleSnapshot = partSnapshot.FindModule(thisPartModule, moduleIndex);
}
newAntennaPartInfo.antennaPower = (!this.vessel.loaded) ? thisAntenna.CommPowerUnloaded(partModuleSnapshot) : thisAntenna.CommPower;
newAntennaPartInfo.antennaCombinable = thisAntenna.CommCombinable;
newAntennaPartInfo.antennaCombinableExponent = thisAntenna.CommCombinableExponent;
newAntennaPartInfo.antennaType = thisAntenna.CommType;
newAntennaPartInfo.partReference = thisPart; //unique ID for part is not available
newAntennaPartInfo.partSnapshotReference = partSnapshot;
newAntennaPartInfo.canComm = (!this.vessel.loaded) ? thisAntenna.CanCommUnloaded(partModuleSnapshot) : thisAntenna.CanComm();
populatedAntennaInfo = true;
}
}
if (populatedAntennaInfo) // valid info?
{
antennas.Add(newAntennaPartInfo);
CNCLog.Debug("CommNet Vessel '{0}' has antenna '{1}' of {2} and {3} power (w/o range modifier)", this.Vessel.GetName(), newAntennaPartInfo.name, newAntennaPartInfo.frequency, newAntennaPartInfo.antennaPower);
}
}
return(antennas);
}
public Antenna_Info(Vessel v)
{
List <AntennaPartInfo> adaptorsInfoList = new List <AntennaPartInfo>();
int numParts = (!v.loaded) ? v.protoVessel.protoPartSnapshots.Count : v.Parts.Count;
for (int partIndex = 0; partIndex < numParts; partIndex++)
{
Part part;
ProtoPartSnapshot protoPart = null;
if (v.loaded)
{
part = v.Parts[partIndex];
}
else
{
protoPart = v.protoVessel.protoPartSnapshots[partIndex];
part = PartLoader.getPartInfoByName(protoPart.partName).partPrefab;
}
bool hasInfo = false;
AntennaPartInfo antennaPartInfo = new AntennaPartInfo();
ProtoPartModuleSnapshot protoPartModule = null;
// Inspect each module of the part
for (int moduleIndex = 0; moduleIndex < part.Modules.Count; moduleIndex++)
{
NetworkAdaptor antennaMod = new NetworkAdaptor();
PartModule pModule = part.Modules[moduleIndex];
if (pModule is NetworkAdaptor)
{
if (v.loaded)
{
antennaMod = (NetworkAdaptor)pModule;
antennaPartInfo.frequency = antennaMod.frequency;
antennaPartInfo.ecCost = antennaMod.ecCost;
antennaPartInfo.rate = antennaMod.rate;
antennaPartInfo.name = part.partInfo.title;
}
else
{
ProtoPartModuleSnapshot netAdaptor = FlightGlobals.FindProtoPartByID(protoPart.flightID).FindModule("NetworkAdaptor");
antennaPartInfo.frequency = Lib.Proto.GetShort(netAdaptor, "frequency");
antennaPartInfo.ecCost = Lib.Proto.GetDouble(netAdaptor, "ecCost");
antennaPartInfo.rate = Lib.Proto.GetDouble(netAdaptor, "rate");
antennaPartInfo.name = protoPart.partInfo.title;
}
hasInfo = true;
}
else if (pModule is ICommAntenna)
{
ICommAntenna antenna = pModule as ICommAntenna;
// This method only works when v.Loaded, otherwise this brings a wrong deployState
ModuleDeployableAntenna anim = part.FindModuleImplementing <ModuleDeployableAntenna>();
// Assume extended if there is no animator
if (anim != null)
{
if (!v.loaded)
{
// This method works to !v.Loaded
ProtoPartModuleSnapshot deployState = FlightGlobals.FindProtoPartByID(protoPart.flightID).FindModule("ModuleDeployableAntenna");
antennaPartInfo.deployState = Lib.KCOMMNET.String_to_DeployState(Lib.Proto.GetString(deployState, "deployState"));
}
else
{
antennaPartInfo.deployState = anim.deployState;
}
}
else
{
antennaPartInfo.deployState = ModuleDeployablePart.DeployState.EXTENDED;
}
if (!v.loaded)
{
protoPartModule = protoPart.FindModule(pModule, moduleIndex);
}
antennaPartInfo.antennaPower = (!v.loaded) ? antenna.CommPowerUnloaded(protoPartModule) : antenna.CommPower;
antennaPartInfo.antennaCombinable = antenna.CommCombinable;
antennaPartInfo.antennaCombinableExponent = antenna.CommCombinableExponent;
antennaPartInfo.antennaType = antenna.CommType;
//antennaPartInfo.partReference = part;
//antennaPartInfo.partSnapshotReference = protoPart;
antennaPartInfo.canComm = (!v.loaded) ? antenna.CanCommUnloaded(protoPartModule) : antenna.CanComm();
hasInfo = true;
}
}
if (hasInfo)
{
adaptorsInfoList.Add(antennaPartInfo);
}
}
freqSortedList = adaptorsInfoList.OrderBy(a => a.frequency).ToList(); // order by frequency
adaptorsSortedList = adaptorsInfoList.OrderBy(a => a.name).ToList(); // order by device name
AntennaCalc(freqSortedList);
}
public AntennaInfoCommNet(Vessel v, bool powered, bool storm, bool transmitting)
{
int transmitterCount = 0;
rate = 1;
double ec_transmitter = 0;
// if vessel is loaded
if (v.loaded)
{
List <ModuleDataTransmitter> transmitters;
if (!Cache.HasVesselObjectsCache(v, "commnet"))
{
// find transmitters
transmitters = v.FindPartModulesImplementing <ModuleDataTransmitter>();
if (transmitters == null)
{
transmitters = new List <ModuleDataTransmitter>();
}
Cache.SetVesselObjectsCache(v, "commnet", transmitters);
}
else
{
transmitters = Cache.VesselObjectsCache <List <ModuleDataTransmitter> >(v, "commnet");
}
foreach (ModuleDataTransmitter t in transmitters)
{
// Disable all stock buttons
t.Events["TransmitIncompleteToggle"].active = false;
t.Events["StartTransmission"].active = false;
t.Events["StopTransmission"].active = false;
t.Actions["StartTransmissionAction"].active = false;
if (t.antennaType == AntennaType.INTERNAL) // do not include internal data rate, ec cost only
{
ec += t.DataResourceCost * t.DataRate;
}
else
{
// do we have an animation
ModuleDeployableAntenna animation = t.part.FindModuleImplementing <ModuleDeployableAntenna>();
ModuleAnimateGeneric animationGeneric = t.part.FindModuleImplementing <ModuleAnimateGeneric>();
if (animation != null)
{
// only include data rate and ec cost if transmitter is extended
if (animation.deployState == ModuleDeployablePart.DeployState.EXTENDED)
{
rate *= t.DataRate;
transmitterCount++;
var e = t.DataResourceCost * t.DataRate;
ec_transmitter += e;
}
}
else if (animationGeneric != null)
{
// only include data rate and ec cost if transmitter is extended
if (animationGeneric.animSpeed > 0)
{
rate *= t.DataRate;
transmitterCount++;
var e = t.DataResourceCost * t.DataRate;
ec_transmitter += e;
}
}
// no animation
else
{
rate *= t.DataRate;
transmitterCount++;
var e = t.DataResourceCost * t.DataRate;
ec_transmitter += e;
}
}
}
}
// if vessel is not loaded
else
{
List <KeyValuePair <ModuleDataTransmitter, ProtoPartSnapshot> > transmitters;
if (!Cache.HasVesselObjectsCache(v, "commnet_bg"))
{
transmitters = new List <KeyValuePair <ModuleDataTransmitter, ProtoPartSnapshot> >();
// find proto transmitters
foreach (ProtoPartSnapshot p in v.protoVessel.protoPartSnapshots)
{
// get part prefab (required for module properties)
Part part_prefab = PartLoader.getPartInfoByName(p.partName).partPrefab;
foreach (ModuleDataTransmitter t in part_prefab.FindModulesImplementing <ModuleDataTransmitter>())
{
transmitters.Add(new KeyValuePair <ModuleDataTransmitter, ProtoPartSnapshot>(t, p));
}
}
Cache.SetVesselObjectsCache(v, "commnet_bg", transmitters);
}
else
{
// cache transmitters
transmitters = Cache.VesselObjectsCache <List <KeyValuePair <ModuleDataTransmitter, ProtoPartSnapshot> > >(v, "commnet_bg");
}
foreach (var pair in transmitters)
{
ModuleDataTransmitter t = pair.Key;
ProtoPartSnapshot p = pair.Value;
if (t.antennaType == AntennaType.INTERNAL) // do not include internal data rate, ec cost only
{
ec += t.DataResourceCost * t.DataRate;
}
else
{
// do we have an animation
ProtoPartModuleSnapshot m = p.FindModule("ModuleDeployableAntenna") ?? p.FindModule("ModuleAnimateGeneric");
if (m != null)
{
// only include data rate and ec cost if transmitter is extended
string deployState = Lib.Proto.GetString(m, "deployState");
float animSpeed = Lib.Proto.GetFloat(m, "animSpeed");
if (deployState == "EXTENDED" || animSpeed > 0)
{
rate *= t.DataRate;
transmitterCount++;
ec_transmitter += t.DataResourceCost * t.DataRate;
}
}
// no animation
else
{
rate *= t.DataRate;
transmitterCount++;
ec_transmitter += t.DataResourceCost * t.DataRate;
}
}
}
}
if (transmitterCount > 1)
{
rate = Math.Pow(rate, 1.0 / transmitterCount);
}
else if (transmitterCount == 0)
{
rate = 0;
}
// when transmitting, transmitters need more EC for the signal amplifiers.
// while not transmitting, transmitters only use 10-20% of that
ec_transmitter *= transmitting ? Settings.TransmitterActiveEcFactor : Settings.TransmitterPassiveEcFactor;
ec += ec_transmitter;
Init(v, powered, storm);
}
public virtual AntennaInfo AntennaInfo()
{
int transmitterCount = 0;
antennaInfo.rate = 1;
double ec_transmitter = 0;
// if vessel is loaded
if (v.loaded)
{
List <ModuleDataTransmitter> transmitters = GetTransmittersLoaded(v);
foreach (ModuleDataTransmitter t in transmitters)
{
// Disable all stock buttons
t.Events["TransmitIncompleteToggle"].active = false;
t.Events["StartTransmission"].active = false;
t.Events["StopTransmission"].active = false;
t.Actions["StartTransmissionAction"].active = false;
// ignore broken / disabled transmitters
if (!t.isEnabled)
{
continue;
}
if (t.antennaType == AntennaType.INTERNAL) // do not include internal data rate, ec cost only
{
antennaInfo.ec += t.DataResourceCost * t.DataRate;
}
else
{
// do we have an animation
ModuleDeployableAntenna animation = t.part.FindModuleImplementing <ModuleDeployableAntenna>();
ModuleAnimateGeneric animationGeneric = t.part.FindModuleImplementing <ModuleAnimateGeneric>();
if (animation != null)
{
// only include data rate and ec cost if transmitter is extended
if (animation.deployState == ModuleDeployablePart.DeployState.EXTENDED)
{
antennaInfo.rate *= t.DataRate;
transmitterCount++;
var e = t.DataResourceCost * t.DataRate;
ec_transmitter += e;
}
}
else if (animationGeneric != null)
{
// only include data rate and ec cost if transmitter is extended
if (animationGeneric.animSpeed > 0)
{
antennaInfo.rate *= t.DataRate;
transmitterCount++;
var e = t.DataResourceCost * t.DataRate;
ec_transmitter += e;
}
}
// no animation
else
{
antennaInfo.rate *= t.DataRate;
transmitterCount++;
var e = t.DataResourceCost * t.DataRate;
ec_transmitter += e;
}
}
}
}
// if vessel is not loaded
else
{
List <KeyValuePair <ModuleDataTransmitter, ProtoPartSnapshot> > transmitters = GetTransmittersUnloaded(v);
foreach (var pair in transmitters)
{
ModuleDataTransmitter t = pair.Key;
ProtoPartSnapshot p = pair.Value;
// ignore broken/disabled transmitters
var mdt = p.FindModule("ModuleDataTransmitter");
if (mdt != null && !Lib.Proto.GetBool(mdt, "isEnabled", true))
{
continue;
}
if (t.antennaType == AntennaType.INTERNAL) // do not include internal data rate, ec cost only
{
antennaInfo.ec += t.DataResourceCost * t.DataRate;
}
else
{
// do we have an animation
ProtoPartModuleSnapshot m = p.FindModule("ModuleDeployableAntenna") ?? p.FindModule("ModuleAnimateGeneric");
if (m != null)
{
// only include data rate and ec cost if transmitter is extended
string deployState = Lib.Proto.GetString(m, "deployState");
float animSpeed = Lib.Proto.GetFloat(m, "animSpeed");
if (deployState == "EXTENDED" || animSpeed > 0)
{
antennaInfo.rate *= t.DataRate;
transmitterCount++;
ec_transmitter += t.DataResourceCost * t.DataRate;
}
}
// no animation
else
{
antennaInfo.rate *= t.DataRate;
transmitterCount++;
ec_transmitter += t.DataResourceCost * t.DataRate;
}
}
}
}
if (transmitterCount > 1)
{
antennaInfo.rate = Math.Pow(antennaInfo.rate, 1.0 / transmitterCount);
}
else if (transmitterCount == 0)
{
antennaInfo.rate = 0;
}
// when transmitting, transmitters need more EC for the signal amplifiers.
// while not transmitting, transmitters only use 10-20% of that
ec_transmitter *= antennaInfo.transmitting ? Settings.TransmitterActiveEcFactor : Settings.TransmitterPassiveEcFactor;
antennaInfo.ec = ec_transmitter * Settings.TransmitterActiveEcFactor;
antennaInfo.ec_idle = ec_transmitter * Settings.TransmitterPassiveEcFactor;
Init();
if (antennaInfo.linked && transmitterCount > 0)
{
var bitsPerMB = 1024.0 * 1024.0 * 8.0;
antennaInfo.rate += Settings.DataRateMinimumBitsPerSecond / bitsPerMB;
}
return(antennaInfo);
}
public static void BackgroundUpdate(Vessel v, ProtoPartSnapshot p, ProtoPartModuleSnapshot antenna, Vessel_Info vi, Resource_Info ec, double elapsed_s)
{
if (Features.Deploy)
{
bool isDeploy;
bool has_ec = ec.amount > double.Epsilon;
ProtoPartModuleSnapshot deployModule = p.FindModule("AntennaDeploy");
ProtoPartModuleSnapshot anim;
if (deployModule == null)
{
Lib.Debug("AntennaDeploy is null. Load vessel to try fix it");
return;
}
// if it is transmitting, leave with Kerbalism
if (Features.Science && (vi.transmitting.Length > 0 || vi.relaying.Length > 0))
{
return;
}
if (has_ec)
{
if (Features.Signal)
{
anim = p.FindModule("ModuleAnimationGroup");
if (anim != null)
{
isDeploy = Lib.Proto.GetBool(anim, "isDeployed");
}
else
{
isDeploy = true;
}
if (!Settings.ExtendedAntenna || isDeploy)
{
Lib.Proto.Set(antenna, "extended", true);
ec.Consume(Lib.Proto.GetDouble(deployModule, "ecCost") * elapsed_s);
}
}
else if (Features.KCommNet)
{
anim = p.FindModule("ModuleDeployableAntenna");
if (anim != null)
{
isDeploy = Lib.Proto.GetString(anim, "deployState") == "EXTENDED";
}
else
{
isDeploy = true;
}
if (isDeploy)
{
Lib.Proto.Set(antenna, "canComm", true);
ec.Consume(Lib.Proto.GetDouble(deployModule, "ecCost") * elapsed_s);
}
}
}
else
{
if (Features.Signal)
{
Lib.Proto.Set(antenna, "extended", false);
}
else if (Features.KCommNet)
{
Lib.Proto.Set(antenna, "canComm", false);
}
}
}
}
