public AntennaEC(Antenna antenna, double extra_Cost, double extra_Deploy)
{
this.antenna = antenna;
this.extra_Cost = extra_Cost;
this.extra_Deploy = extra_Deploy;
animator = antenna.part.FindModuleImplementing <ModuleAnimationGroup>();
}
public ModuleAnimateGeneric customAnim; // Support to custom animation for ModuleDataTransmitter module
public override void OnStart(StartState state)
{
base.OnStart(state);
// don't break tutorial scenarios & do something only in Flight scenario
if (Lib.DisableScenario(this) || !Lib.IsFlight())
{
return;
}
if (Features.Signal)
{
Antenna a = part.FindModuleImplementing <Antenna>();
if (antennaPower == 0 && a != null)
{
antennaPower = a.dist;
}
}
else
{
ModuleDataTransmitter transmitter = part.FindModuleImplementing <ModuleDataTransmitter>();
if (transmitter != null)
{
antennaPower = new AntennaEC(part.FindModuleImplementing <ModuleDataTransmitter>(), extra_Cost, extra_Deploy, antennaPower).Init(antennaPower);
}
}
// verify if is using custom animation for CommNet
customAnim = part.FindModuleImplementing <ModuleAnimateGeneric>();
}
public double direct_rate(double d)
{
double r = 0.0;
for (int i = 0; i < type.Count; ++i)
{
r += Antenna.calculate_rate(d, dist[i], rate[i]);
}
return(r);
}
public double relay_rate(double d)
{
double r = 0.0;
for (int i = 0; i < type.Count; ++i)
{
if (type[i] == AntennaType.low_gain && relay[i])
{
r += Antenna.calculate_rate(d, dist[i], rate[i]);
}
}
return(r);
}
public static signal_data analyze_signal(List<Part> parts)
{
// store data
signal_data signal = new signal_data();
// get error correcting code factor
signal.ecc = Signal.ECC();
// scan the parts
foreach(Part p in parts)
{
// for each module
foreach(PartModule m in p.Modules)
{
// antenna
if (m.moduleName == "Antenna")
{
Antenna mm = (Antenna)m;
// calculate actual range
double range = Signal.Range(mm.scope, mm.penalty, signal.ecc);
// maintain 2nd best antenna
signal.second_best_range = range > signal.range ? signal.range : Math.Max(signal.second_best_range, range);
// keep track of best antenna
if (range > signal.range)
{
signal.range = range;
signal.transmission_cost_min = mm.min_transmission_cost;
signal.transmission_cost_max = mm.max_transmission_cost;
}
// keep track of best relay antenna
if (mm.relay && range > signal.relay_range)
{
signal.relay_range = range;
signal.relay_cost = mm.relay_cost;
}
}
}
}
// return data
return signal;
}
public double indirect_rate(double d, AntennaInfo relay_antenna)
{
double r = 0.0;
for (int i = 0; i < type.Count; ++i)
{
if (type[i] == AntennaType.low_gain)
{
r += Antenna.calculate_rate(d, dist[i], rate[i]);
}
}
double indirect_r = 0.0;
for (int i = 0; i < relay_antenna.type.Count; ++i)
{
if (relay_antenna.type[i] == AntennaType.low_gain && relay_antenna.relay[i])
{
indirect_r += Antenna.calculate_rate(d, relay_antenna.dist[i], relay_antenna.rate[i]);
}
}
return(Math.Min(r, indirect_r));
}
// return set of devices on a vessel
// - the list is only valid for a single simulation step
public static Dictionary <uint, Device> Boot(Vessel v)
{
// store all devices
var devices = new Dictionary <uint, Device>();
// store device being added
Device dev;
// loaded vessel
if (v.loaded)
{
foreach (PartModule m in Lib.FindModules <PartModule>(v))
{
switch (m.moduleName)
{
case "ProcessController": dev = new ProcessDevice(m as ProcessController); break;
case "Greenhouse": dev = new GreenhouseDevice(m as Greenhouse); break;
case "GravityRing": dev = new RingDevice(m as GravityRing); break;
case "Emitter": dev = new EmitterDevice(m as Emitter); break;
case "Laboratory": dev = new LaboratoryDevice(m as Laboratory); break;
case "Experiment": dev = new ExperimentDevice(m as Experiment); break;
case "ModuleDeployableSolarPanel": dev = new PanelDevice(m as ModuleDeployableSolarPanel); break;
case "ModuleGenerator": dev = new GeneratorDevice(m as ModuleGenerator); break;
case "ModuleResourceConverter": dev = new ConverterDevice(m as ModuleResourceConverter); break;
case "ModuleKPBSConverter": dev = new ConverterDevice(m as ModuleResourceConverter); break;
case "FissionReactor": dev = new ConverterDevice(m as ModuleResourceConverter); break;
case "ModuleResourceHarvester": dev = new DrillDevice(m as ModuleResourceHarvester); break;
case "ModuleLight": dev = new LightDevice(m as ModuleLight); break;
case "ModuleColoredLensLight": dev = new LightDevice(m as ModuleLight); break;
case "ModuleMultiPointSurfaceLight": dev = new LightDevice(m as ModuleLight); break;
case "SCANsat": dev = new ScannerDevice(m); break;
case "ModuleSCANresourceScanner": dev = new ScannerDevice(m); break;
case "ModuleRTAntenna": dev = new Antenna(m, m.moduleName); break;
case "ModuleRTAntennaPassive": dev = new Antenna(m, "ModuleRTAntenna"); break;
case "ModuleDataTransmitter": dev = new Antenna(m, m.moduleName); break;
default: continue;
}
// add the device
// - multiple same-type components in the same part will have the same id, and are ignored
if (!devices.ContainsKey(dev.Id()))
{
devices.Add(dev.Id(), dev);
}
}
}
// unloaded vessel
else
{
// store data required to support multiple modules of same type in a part
var PD = new Dictionary <string, Lib.Module_prefab_data>();
// for each part
foreach (ProtoPartSnapshot p in v.protoVessel.protoPartSnapshots)
{
// get part prefab (required for module properties)
Part part_prefab = PartLoader.getPartInfoByName(p.partName).partPrefab;
// get all module prefabs
var module_prefabs = part_prefab.FindModulesImplementing <PartModule>();
// clear module indexes
PD.Clear();
// for each module
foreach (ProtoPartModuleSnapshot m in p.modules)
{
// get the module prefab
// if the prefab doesn't contain this module, skip it
PartModule module_prefab = Lib.ModulePrefab(module_prefabs, m.moduleName, PD);
if (!module_prefab)
{
continue;
}
// if the module is disabled, skip it
// note: this must be done after ModulePrefab is called, so that indexes are right
if (!Lib.Proto.GetBool(m, "isEnabled"))
{
continue;
}
// depending on module name
switch (m.moduleName)
{
case "ProcessController": dev = new ProtoProcessDevice(m, module_prefab as ProcessController, p.flightID); break;
case "Greenhouse": dev = new ProtoGreenhouseDevice(m, p.flightID); break;
case "GravityRing": dev = new ProtoRingDevice(m, p.flightID); break;
case "Emitter": dev = new ProtoEmitterDevice(m, p.flightID); break;
case "Laboratory": dev = new ProtoLaboratoryDevice(m, p.flightID); break;
case "Experiment": dev = new ProtoExperimentDevice(m, module_prefab as Experiment, p.flightID); break;
case "ModuleDeployableSolarPanel": dev = new ProtoPanelDevice(m, module_prefab as ModuleDeployableSolarPanel, p.flightID); break;
case "ModuleGenerator": dev = new ProtoGeneratorDevice(m, module_prefab as ModuleGenerator, p.flightID); break;
case "ModuleResourceConverter": dev = new ProtoConverterDevice(m, module_prefab as ModuleResourceConverter, p.flightID); break;
case "ModuleKPBSConverter": dev = new ProtoConverterDevice(m, module_prefab as ModuleResourceConverter, p.flightID); break;
case "FissionReactor": dev = new ProtoConverterDevice(m, module_prefab as ModuleResourceConverter, p.flightID); break;
case "ModuleResourceHarvester": dev = new ProtoDrillDevice(m, module_prefab as ModuleResourceHarvester, p.flightID); break;
case "ModuleLight": dev = new ProtoLightDevice(m, p.flightID); break;
case "ModuleColoredLensLight": dev = new ProtoLightDevice(m, p.flightID); break;
case "ModuleMultiPointSurfaceLight": dev = new ProtoLightDevice(m, p.flightID); break;
case "SCANsat": dev = new ProtoScannerDevice(m, part_prefab, v, p.flightID); break;
case "ModuleSCANresourceScanner": dev = new ProtoScannerDevice(m, part_prefab, v, p.flightID); break;
case "ModuleRTAntenna": dev = new ProtoPartAntenna(m, p, v, m.moduleName, p.flightID); break;
case "ModuleRTAntennaPassive": dev = new ProtoPartAntenna(m, p, v, "ModuleRTAntenna", p.flightID); break;
case "ModuleDataTransmitter": dev = new ProtoPartAntenna(m, p, v, m.moduleName, p.flightID); break;
default: continue;
}
// add the device
// - multiple same-type components in the same part will have the same id, and are ignored
if (!devices.ContainsKey(dev.Id()))
{
devices.Add(dev.Id(), dev);
}
}
}
}
//return all found devices sorted by name
return(devices);
}
public AntennaInfo(Vessel v)
{
// initialize data
type = new List <AntennaType>();
cost = new List <double>();
rate = new List <double>();
dist = new List <double>();
relay = new List <bool>();
no_antenna = true;
// get ec available
// - this is the amount available at previous simulation step
bool ec_available = ResourceCache.Info(v, "ElectricCharge").amount > double.Epsilon;
// if the vessel is loaded
if (v.loaded)
{
// get all antennas data
foreach (Antenna a in Lib.FindModules <Antenna>(v))
{
if (!Settings.ExtendedAntenna || a.extended)
{
type.Add(a.type);
cost.Add(a.cost);
rate.Add(a.rate);
dist.Add(a.dist);
relay.Add(ec_available && a.relay);
is_relay |= ec_available && a.relay;
direct_cost += a.cost;
if (a.type == AntennaType.low_gain)
{
indirect_cost += a.cost;
}
}
no_antenna = false;
}
}
// if the vessel isn't loaded
// - we don't support multiple antenna modules per-part
else
{
// for each part
foreach (ProtoPartSnapshot p in v.protoVessel.protoPartSnapshots)
{
// get part prefab (required for module properties)
Part part_prefab = PartLoader.getPartInfoByName(p.partName).partPrefab;
// get module prefab
Antenna a = part_prefab.FindModuleImplementing <Antenna>();
// if there is none, skip the part
if (a == null)
{
continue;
}
// for each module
foreach (ProtoPartModuleSnapshot m in p.modules)
{
// we are only interested in antennas
if (m.moduleName != "Antenna")
{
continue;
}
// if the module is disabled, skip it
if (!Lib.Proto.GetBool(m, "isEnabled"))
{
continue;
}
// get antenna data
if (!Settings.ExtendedAntenna || Lib.Proto.GetBool(m, "extended"))
{
bool antenna_is_relay = Lib.Proto.GetBool(m, "relay");
type.Add(a.type);
cost.Add(a.cost);
rate.Add(a.rate);
dist.Add(a.dist);
relay.Add(ec_available && antenna_is_relay);
is_relay |= ec_available && antenna_is_relay;
direct_cost += a.cost;
if (a.type == AntennaType.low_gain)
{
indirect_cost += a.cost;
}
}
no_antenna = false;
}
}
}
}
void Apply(Antenna m, double k)
{
m.penalty *= Math.Sqrt(k);
}
public antenna_data(Vessel v)
{
// [disabled] EVA kerbals have an implicit antenna
//if (v.isEVA)
//{
// range = 1000.0; //< 1Km
// return;
//}
// get error-correcting code factor
// note: this could possibly get called when tech tree is not ready
double ecc = Signal.ECC();
// get ec available
// note: this is the amount available at previous simulation step
double ec_amount = ResourceCache.Info(v, "ElectricCharge").amount;
// if the vessel is loaded
if (v.loaded)
{
// choose the best antenna
foreach (Antenna a in v.FindPartModulesImplementing <Antenna>())
{
// calculate real range
double real_range = Signal.Range(a.scope, ecc);
// maintain best range
range = Math.Max(range, real_range);
// maintain best relay
if (a.relay && real_range > relay_range && ec_amount >= a.relay_cost)
{
relay_range = real_range;
relay_cost = a.relay_cost;
}
}
}
// if the vessel isn't loaded
else
{
// choose the best antenna
foreach (ProtoPartSnapshot p in v.protoVessel.protoPartSnapshots)
{
foreach (ProtoPartModuleSnapshot m in p.modules)
{
// early exit
if (m.moduleName != "Antenna")
{
continue;
}
// get the antenna module prefab
Part part_prefab = PartLoader.getPartInfoByName(p.partName).partPrefab;
Antenna a = Lib.FindModuleAs <Antenna>(part_prefab, "Antenna");
if (!a)
{
continue;
}
// calculate real range
double real_range = Signal.Range(a.scope, ecc);
// maintain best range
range = Math.Max(range, real_range);
// maintain best relay
if (Lib.Proto.GetBool(m, "relay") && real_range > relay_range && ec_amount >= a.relay_cost)
{
relay_range = real_range;
relay_cost = a.relay_cost;
}
}
}
}
}
void Apply(Antenna m, double k)
{
m.penalty *= k;
}
public AntennaDevice(Antenna antenna)
{
this.antenna = antenna;
this.animator = antenna.part.FindModuleImplementing <ModuleAnimationGroup>();
}
