EventSniffer: Debug-only class to help sniff out GameEvents. This probably doesn't belong here.
[AntennaRange.git] / Extensions.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
// AntennaRange © 2014 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.
//
// This software uses code from the MuMechLib library, © 2013 r4m0n, used under the GNU GPL version 3.
 
using System;
using System.Collections.Generic;
using System.Linq;
 
namespace AntennaRange
{
        /*
         * A class of utility extensions for Vessels and Relays to help find a relay path back to Kerbin.
         * */
        public static class Extensions
        {
                /// <summary>
                /// Returns the distance between this Vessel and another Vessel.
                /// </summary>
                /// <param name="vesselOne">This <see cref="Vessel"/><see ></param>
                /// <param name="vesselTwo">Another <see cref="Vessel"/></param>
                public static double DistanceTo(this Vessel vesselOne, Vessel vesselTwo)
                {
                        return (vesselOne.GetWorldPos3D() - vesselTwo.GetWorldPos3D()).magnitude;
                }
 
                /// <summary>
                /// Returns the distance between this Vessel and a CelestialBody
                /// </summary>
                /// <param name="vessel">This Vessel</param>
                /// <param name="body">A <see cref="CelestialBody"/></param>
                public static double DistanceTo(this Vessel vessel, CelestialBody body)
                {
                        return (vessel.GetWorldPos3D() - body.position).magnitude;
                }
 
                /// <summary>
                /// Returns the distance between this IAntennaRelay and a Vessel
                /// </summary>
                /// <param name="relay">This <see cref="IAntennaRelay"/></param>
                /// <param name="Vessel">A <see cref="Vessel"/></param>
                public static double DistanceTo(this AntennaRelay relay, Vessel Vessel)
                {
                        return relay.vessel.DistanceTo(Vessel);
                }
 
                /// <summary>
                /// Returns the distance between this IAntennaRelay and a CelestialBody
                /// </summary>
                /// <param name="relay">This <see cref="IAntennaRelay"/></param>
                /// <param name="body">A <see cref="CelestialBody"/></param>
                public static double DistanceTo(this AntennaRelay relay, CelestialBody body)
                {
                        return relay.vessel.DistanceTo(body);
                }
 
                /// <summary>
                /// Returns the distance between this IAntennaRelay and another IAntennaRelay
                /// </summary>
                /// <param name="relayOne">This <see cref="IAntennaRelay"/></param>
                /// <param name="relayTwo">Another <see cref="IAntennaRelay"/></param>
                public static double DistanceTo(this AntennaRelay relayOne, IAntennaRelay relayTwo)
                {
                        return relayOne.DistanceTo(relayTwo.vessel);
                }
 
                /// <summary>
                /// Returns all of the PartModules or ProtoPartModuleSnapshots implementing IAntennaRelay in this Vessel.
                /// </summary>
                /// <param name="vessel">This <see cref="Vessel"/></param>
                public static IEnumerable<IAntennaRelay> GetAntennaRelays (this Vessel vessel)
                {
                        Tools.PostDebugMessage(string.Format(
                                "{0}: Getting antenna relays from vessel {1}.",
                                "IAntennaRelay",
                                vessel.name
                        ));
 
                        List<IAntennaRelay> Transmitters;
 
                        // If the vessel is loaded, we can fetch modules implementing IAntennaRelay directly.
                        if (vessel.loaded) {
                                Tools.PostDebugMessage(string.Format(
                                        "{0}: vessel {1} is loaded.",
                                        "IAntennaRelay",
                                        vessel.name
                                        ));
 
                                // Gets a list of PartModules implementing IAntennaRelay
                                Transmitters = vessel.Parts
                                        .SelectMany (p => p.Modules.OfType<IAntennaRelay> ())
                                        .ToList();
                        }
                        // If the vessel is not loaded, we need to find ProtoPartModuleSnapshots with a true IsAntenna field.
                        else
                        {
                                Tools.PostDebugMessage(string.Format(
                                        "{0}: vessel {1} is not loaded.",
                                        "IAntennaRelay",
                                        vessel.name
                                        ));
 
                                Transmitters = new List<IAntennaRelay>();
 
                                // Loop through the ProtoPartModuleSnapshots in this Vessel
                                foreach (ProtoPartSnapshot pps in vessel.protoVessel.protoPartSnapshots)
                                {
                                        Transmitters.AddRange(
                                                PartLoader.getPartInfoByName(pps.partName)
                                                .partPrefab
                                                .Modules
                                                .OfType<IAntennaRelay>()
                                        );
                                }
                        }
 
                        Tools.PostDebugMessage(string.Format(
                                "{0}: vessel {1} has {2} transmitters.",
                                "IAntennaRelay",
                                vessel.name,
                                Transmitters.Count
                                ));
 
                        // Return the list of IAntennaRelays
                        return Transmitters;
                }
        }
}