A bunch more changes. Relays mostly work now, I think, except for the infinite recursion.
[AntennaRange.git] / AntennaRange.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
/*
 * AntennaRange © 2013 toadicus
 * 
 * AntennaRange provides incentive and requirements for the use of the various antenna parts.
 * Nominally, the breakdown is as follows:
 * 
 *     Communotron 16 - Suitable up to Kerbalsynchronous Orbit
 *     Comms DTS-M1 - Suitable throughout the Kerbin subsystem
 *     Communotron 88-88 - Suitable throughout the Kerbol system.
 * 
 * This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License. To view a
 * copy of this license, visit http://creativecommons.org/licenses/by-nc-sa/3.0/
 * 
 * This software uses the ModuleManager library © 2013 ialdabaoth, used under a Creative Commons Attribution-ShareAlike 3.0 Uported License.
 * 
 */
 
using System;
using System.Collections.Generic;
using KSP;
 
namespace AntennaRange
{
        /*
         * ModuleLimitedDataTransmitter is designed as a drop-in replacement for ModuleDataTransmitter, and handles range-
         * finding, power scaling, and data scaling for antennas during science transmission.  Its functionality varies with
         * three tunables: nominalRange, maxPowerFactor, and maxDataFactor, set in .cfg files.
         * 
         * In general, the scaling functions assume the following relation:
         * 
         *     D² α P/R,
         * 
         * where D is the total transmission distance, P is the transmission power, and R is the data rate.
         * 
         * */
        public class ModuleLimitedDataTransmitter : ModuleDataTransmitter, IScienceDataTransmitter
        {
                // Stores the packetResourceCost as defined in the .cfg file.
                protected float _basepacketResourceCost;
 
                // Stores the packetSize as defined in the .cfg file.
                protected float _basepacketSize;
 
                // We don't have a Bard, so we're hiding Kerbin here.
                protected CelestialBody _Kerbin;
 
                // Returns the current distance to the center of Kerbin, which is totally where the Kerbals keep their radioes.
                protected double transmitDistance
                {
                        get
                        {
                                Vector3d KerbinPos = this._Kerbin.position;
                                Vector3d ActivePos = base.vessel.GetWorldPos3D();
 
                                return (ActivePos - KerbinPos).magnitude;
                        }
                }
 
                // Returns the maximum distance this module can transmit
                public double maxTransmitDistance
                {
                        get
                        {
                                return Math.Sqrt (this.maxPowerFactor) * this.nominalRange;
                        }
                }
 
                // The distance from Kerbin at which the antenna will perform exactly as prescribed by packetResourceCost
                // and packetSize.
                [KSPField(isPersistant = false)]
                public double nominalRange = 1500000d;
 
                // The multiplier on packetResourceCost that defines the maximum power output of the antenna.  When the power
                // cost exceeds packetResourceCost * maxPowerFactor, transmission will fail.
                [KSPField(isPersistant = false)]
                public float maxPowerFactor = 8f;
 
                // The multipler on packetSize that defines the maximum data bandwidth of the antenna.
                [KSPField(isPersistant = false)]
                public float maxDataFactor = 4f;
 
                // Override ModuleDataTransmitter.packetSize.  Below the nominal range, scales up packetSize to
                // packetSize * maxDataFactor
                [KSPField(isPersistant = false)]
                public new float packetSize
                {
                        get
                        {
                                if (this.transmitDistance >= this.nominalRange)
                                {
                                        return this._basepacketSize;
                                }
                                else
                                {
                                        // From above, data rate increases with the inverse square of the distance.
                                        return Math.Min(this._basepacketSize * (float)Math.Pow(this.nominalRange / this.transmitDistance, 2),
                                                         this._basepacketSize * this.maxDataFactor);
                                }
                        }
                        set
                        {
                                this._basepacketSize = value;
                        }
                        
                }
 
                // Override ModuleDataTransmitter.packetResourceCost.  Above the nominal range, scales up packetResourceCost to
                // packetResourceCost * maxPowerFactor.
                [KSPField(isPersistant = false)]
                public new float packetResourceCost
                {
                        get
                        {
                                if (this.transmitDistance <= this.nominalRange)
                                {
                                        return this._basepacketResourceCost;
                                }
                                else
                                {
                                        // From above, power increases with the square of the distance.
                                        return this._basepacketResourceCost * (float)Math.Pow (this.transmitDistance / this.nominalRange, 2);
                                }
                        }
                        set
                        {
                                this._basepacketResourceCost = value;
                        }
 
                }
 
                // Build ALL the objects.
                public ModuleLimitedDataTransmitter () : base()
                {
                        // Go fetch Kerbin, because it is tricksy and hides from us.
                        List<CelestialBody> bodies = FlightGlobals.Bodies;
 
                        foreach (CelestialBody body in bodies)
                        {
                                if (body.name == "Kerbin")
                                {
                                        this._Kerbin = body;
                                        break;
                                }
                        }
                }
 
                // Post an error in the communication messages describing the reason transmission has failed.  Currently there
                // is only one reason for this.
                protected void PostCannotTransmitError()
                {
                        string ErrorText = String.Format ("Unable to transmit: out of range!  Maximum range = {0}; Current range = {1}.", this.maxTransmitDistance, this.transmitDistance);
                        ScreenMessages.PostScreenMessage (new ScreenMessage (ErrorText, 4f, ScreenMessageStyle.UPPER_LEFT));
                }
 
                // Override ModuleDataTransmitter.GetInfo to add nominal and maximum range to the VAB description.
                public override string GetInfo()
                {
                        string text = base.GetInfo();
                        text += "Nominal Range: " + this.nominalRange.ToString() + "\n";
                        text += "Maximum Range: " + this.maxTransmitDistance.ToString() + "\n";
                        return text;
                }
 
                // Override ModuleDataTransmitter.CanTransmit to return false when transmission is not possible.
                public new bool CanTransmit()
                {
                        if (this.transmitDistance > this.maxTransmitDistance)
                        {
                                return false;
                        }
                        return true;
                }
 
                // Override ModuleDataTransmitter.TransmitData to check against CanTransmit and fail out when CanTransmit
                // returns false.
                public new void TransmitData(List<ScienceData> dataQueue)
                {
                        if (this.CanTransmit())
                        {
                                base.TransmitData(dataQueue);
                        }
                        else
                        {
                                this.PostCannotTransmitError ();
                        }
                }
 
                // Override ModuleDataTransmitter.StartTransmission to check against CanTransmit and fail out when CanTransmit
                // returns false.
                public new void StartTransmission()
                {
                        if (this.CanTransmit())
                        {
                                base.StartTransmission();
                        }
                        else
                        {
                                this.PostCannotTransmitError ();
                        }
                }
        }
}