コード例 #1
0
        public CheckList Allowed(Vessel vessel)
        {
            var checkList = new CheckList();

            checkList.Check(Valid(), "invalid mission departure mission");
            if (!checkList.CheckSucces)
            {
                return(checkList);
            }

            checkList.Check(AllowedVessel(vessel), "vessel not allowed");
            if (!checkList.CheckSucces)
            {
                return(checkList);
            }

            List <Part> departureParts = RmmUtil.GetDockedParts(vessel, RmmUtil.GetDockedPart(vessel, RmmUtil.GetVesselPart(vessel, flightIdDepartureDockPart)));

            checkList.Check(departureParts != null, "no docked vessel on docking port");
            if (!checkList.CheckSucces)
            {
                return(checkList);
            }

            checkList.Check(RmmUtil.AstronautCrewCount(departureParts) >= _mission.Departure.Crew, "not enough crew");
            int crewCapacity = 0;

            foreach (MissionLanding missionLanding in _mission.Landings)
            {
                crewCapacity += missionLanding.CrewCapacity;
            }
            checkList.Check(RmmUtil.AstronautCrewCount(departureParts) <= crewCapacity, "too many crew");

            foreach (MissionResource missionResource in _mission.Departure.Resources)
            {
                if (!_mission.Departure.Proppellants.Contains(missionResource.Name))
                {
                    continue;
                }

                checkList.Check(RmmUtil.ReadResource(departureParts, missionResource.Name) >= (missionResource.Amount * 0.99), "insufficient " + missionResource.Name);
            }

            double vesselCargoMass = 0;
            List <MissionResource> vesselResources = MissionResource.GetMissionResourceList(departureParts);

            foreach (MissionResource vesselResource in vesselResources)
            {
                if (Proppelants.Contains(vesselResource.Name))
                {
                    continue;
                }

                vesselCargoMass += RmmUtil.Mass(vesselResource.Name, vesselResource.Amount);
            }
            LoggerRmm.Debug(vesselCargoMass + " " + CargoMass);
            checkList.Check((vesselCargoMass * 0.99) <= CargoMass, "too much cargomass");

            return(checkList);
        }
コード例 #2
0
        private void TrackLanding()
        {
            MissionLanding landing = new MissionLanding
            {
                Time         = Planetarium.GetUniversalTime(),
                Body         = vessel.mainBody.name,
                Coordinates  = MissionCoordinates.GetMissionCoordinates(vessel.latitude, vessel.longitude),
                Funds        = RmmUtil.CalculateVesselPrice(vessel),
                Crew         = (int)trackCrew,
                CrewCapacity = (int)trackCrewCapacity,
                Parts        = MissionPart.GetMissionPartList(vessel),
                Resources    = MissionResource.GetMissionResourceList(vessel),
            };

            _mission.TrackLanding(landing);

            trackingPrimary = false;
            trackingActive  = false;
            trackingStatus  = "Landed";

            ScreenMessages.PostScreenMessage("mission tracking-LANDING", 4, ScreenMessageStyle.UPPER_CENTER);
            _partModule.nextLogicTime = 0;
            updateTrackingVars(vessel);
            updateNextLogicTime(vessel);
        }
コード例 #3
0
        private void HandleRoutineDepartureDetailWindow()
        {
            if (_routineDepartureDetailWindow == null)
            {
                return;
            }
            if (!WindowManager.IsOpen(_routineDepartureDetailWindow))
            {
                CancelRoutineDepartureDetail();
                return;
            }

            _routineDepartureDetailWindow.CrewCount = RmmUtil.CrewCount(_routineDepartureDetailWindow.DepartureParts);

            List <RoutineDepartureDetailWindow.ResourceItem> resources = new List <RoutineDepartureDetailWindow.ResourceItem>();

            foreach (String proppelant in _routineDepartureDetailWindow.RoutineDepartureMission.Proppelants)
            {
                foreach (MissionResource missionResource in _routineDepartureDetailWindow.RoutineDepartureMission.Resources)
                {
                    if (missionResource.Name == proppelant)
                    {
                        RoutineDepartureDetailWindow.ResourceItem resourceItem = new RoutineDepartureDetailWindow.ResourceItem
                        {
                            Name           = missionResource.Name,
                            RequiredAmount = missionResource.Amount,
                            CurrentAmount  = RmmUtil.ReadResource(_routineDepartureDetailWindow.DepartureParts, missionResource.Name),
                        };
                        resources.Add(resourceItem);
                    }
                }
            }
            _routineDepartureDetailWindow.Resources = resources;

            double currentVesselCargoMass          = 0;
            double currentVesselCargoFunds         = 0;
            List <MissionResource> vesselResources = MissionResource.GetMissionResourceList(_routineDepartureDetailWindow.DepartureParts);

            foreach (MissionResource vesselResource in vesselResources)
            {
                if (_routineDepartureDetailWindow.RoutineDepartureMission.Proppelants.Contains(vesselResource.Name))
                {
                    continue;
                }

                currentVesselCargoMass  += RmmUtil.Mass(vesselResource.Name, vesselResource.Amount);
                currentVesselCargoFunds += RmmUtil.Cost(vesselResource.Name, vesselResource.Amount);
            }
            _routineDepartureDetailWindow.CurrentCargoMass  = currentVesselCargoMass;
            _routineDepartureDetailWindow.CurrentCargoFunds = currentVesselCargoFunds;
        }
コード例 #4
0
        private void trackDeparture()
        {
            Part dockedPart = null;

            foreach (Part p in vessel.parts)
            {
                if (p.flightID == trackPort)
                {
                    dockedPart = p;
                    break;
                }
            }

            MissionDeparture departure = new MissionDeparture
            {
                Time             = (float)Planetarium.GetUniversalTime(),
                Body             = vessel.mainBody.name,
                Orbit            = MissionOrbit.GetMissionOrbit(vessel.orbit),
                flightIDDockPart = trackPort,
                VesselName       = vessel.name,
                Crew             = RmmUtil.AstronautCrewCount(vessel),
                Parts            = MissionPart.GetMissionPartList(vessel),
                Resources        = MissionResource.GetMissionResourceList(vessel),
                Proppellants     = RmmUtil.DetermineProppellantArray(vessel),
                Structure        = Structure.GetDockedStructure(vessel, dockedPart)
            };

            _mission.TrackDeparture(departure);
            trackingActive  = true;
            trackingPrimary = true;
            trackingStatus  = "Underway";

            //-----------------------
            trackPartCount    = RmmUtil.CountVesselParts(vessel);
            trackCrew         = RmmUtil.AstronautCrewCount(vessel);
            trackCrewCapacity = RmmUtil.CrewCapacityCount(vessel);

            ScreenMessages.PostScreenMessage("mission tracking-DEPARTURE", 4, ScreenMessageStyle.UPPER_CENTER);
            setOtherModules();
            updateTrackingVars(vessel);
            updateNextLogicTime(vessel);
        }