simulatedaircraft.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 2015 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
 
#ifndef SWIFT_MISC_SIMULATION_SIMULATEDAIRCRAFT_H
#define SWIFT_MISC_SIMULATION_SIMULATEDAIRCRAFT_H
 
#include <array>
 
#include <QMetaType>
#include <QString>
#include <QVector3D>
#include <QtGlobal>
 
#include "misc/aviation/aircraftlights.h"
#include "misc/aviation/aircraftparts.h"
#include "misc/aviation/aircraftsituation.h"
#include "misc/aviation/airlineicaocode.h"
#include "misc/aviation/callsign.h"
#include "misc/aviation/comsystem.h"
#include "misc/aviation/livery.h"
#include "misc/aviation/selcal.h"
#include "misc/aviation/transponder.h"
#include "misc/geo/coordinategeodetic.h"
#include "misc/geo/latitude.h"
#include "misc/geo/longitude.h"
#include "misc/metaclass.h"
#include "misc/mixin/mixincompare.h"
#include "misc/network/user.h"
#include "misc/pq/frequency.h"
#include "misc/pq/length.h"
#include "misc/propertyindexref.h"
#include "misc/simulation/aircraftmodellist.h"
#include "misc/swiftmiscexport.h"
#include "misc/valueobject.h"
 
SWIFT_DECLARE_VALUEOBJECT_MIXINS(swift::misc::simulation, CSimulatedAircraft)
 
namespace swift::misc
{
    namespace aviation
    {
        class CAircraftIcaoCode;
        class CAltitude;
        class CHeading;
    } // namespace aviation
    namespace physical_quantities
    {
        class CAngle;
        class CSpeed;
    } // namespace physical_quantities
 
    namespace simulation
    {
        class SWIFT_MISC_EXPORT CSimulatedAircraft :
            public CValueObject<CSimulatedAircraft>,
            public geo::ICoordinateWithRelativePosition
        {
        public:
            enum ColumnIndex
            {
                IndexCallsign = CPropertyIndexRef::GlobalIndexCSimulatedAircraft,
                IndexPilot,
                IndexRelativeDistance,
                IndexCom1System,
                IndexCom2System,
                IndexTransponder,
                IndexSituation,
                IndexAircraftIcaoCode,
                IndexLivery,
                IndexParts,
                IndexIsVtol,
                IndexCombinedIcaoLiveryString,
                IndexCombinedIcaoLiveryStringNetworkModel,
                IndexModel,
                IndexNetworkModel,
                IndexNetworkModelAircraftIcaoDifference,
                IndexNetworkModelAirlineIcaoDifference,
                IndexNetworkModelLiveryDifference,
                IndexEnabled,
                IndexRendered,
                IndexPartsSynchronized,
                IndexFastPositionUpdates,
                IndexSupportsGndFlag
            };
 
            CSimulatedAircraft();
 
            explicit CSimulatedAircraft(const CAircraftModel &model);
 
            CSimulatedAircraft(const aviation::CCallsign &callsign, const network::CUser &user,
                               const aviation::CAircraftSituation &situation);
 
            CSimulatedAircraft(const aviation::CCallsign &callsign, const CAircraftModel &model,
                               const network::CUser &user, const aviation::CAircraftSituation &situation);
 
            const aviation::CCallsign &getCallsign() const { return m_callsign; }
 
            QString getCallsignAsString() const { return m_callsign.asString(); }
 
            const aviation::CAircraftSituation &getSituation() const { return m_situation; }
 
            void setSituation(const aviation::CAircraftSituation &situation);
 
            const aviation::CAircraftVelocity &getVelocity() const { return m_situation.getVelocity(); }
 
            void setVelocity(const aviation::CAircraftVelocity &velocity) { m_situation.setVelocity(velocity); }
 
            const network::CUser &getPilot() const { return m_pilot; }
 
            QString getPilotRealName() const { return m_pilot.getRealName(); }
 
            QString getPilotId() { return m_pilot.getId(); }
 
            const aviation::CAircraftIcaoCode &getAircraftIcaoCode() const;
 
            const QString &getAircraftIcaoCodeDesignator() const;
 
            QString getAirlineAndAircraftIcaoCodeDesignators() const;
 
            const QString &getAircraftIcaoCombinedType() const;
 
            bool setAircraftIcaoCode(const aviation::CAircraftIcaoCode &aircraftIcaoCode)
            {
                return m_models[CurrentModel].setAircraftIcaoCode(aircraftIcaoCode);
            }
 
            bool setIcaoCodes(const aviation::CAircraftIcaoCode &aircraftIcaoCode,
                              const aviation::CAirlineIcaoCode &airlineIcaoCode);
 
            const aviation::CLivery &getLivery() const { return m_models[CurrentModel].getLivery(); }
 
            const aviation::CAirlineIcaoCode &getAirlineIcaoCode() const;
 
            const QString &getAirlineIcaoCodeDesignator() const;
 
            void setAircraftIcaoDesignator(const QString &designator);
 
            bool hasRealName() const { return m_pilot.hasRealName(); }
 
            bool hasId() const { return m_pilot.hasId(); }
 
            bool hasAircraftDesignator() const;
 
            bool hasAirlineDesignator() const { return m_models[CurrentModel].getLivery().hasValidAirlineDesignator(); }
 
            bool hasAircraftAndAirlineDesignator() const;
 
            bool hasValidCallsign() const
            {
                return aviation::CCallsign::isValidAircraftCallsign(this->getCallsign().asString());
            }
 
            bool hasCallsign() const { return !getCallsign().isEmpty(); }
 
            geo::CCoordinateGeodetic getPosition() const { return m_situation.getPosition(); }
 
            void setPosition(const geo::CCoordinateGeodetic &position) { m_situation.setPosition(position); }
 
            const aviation::CAltitude &getAltitude() const { return m_situation.getAltitude(); }
 
            void setAltitude(const aviation::CAltitude &altitude) { m_situation.setAltitude(altitude); }
 
            const aviation::CAltitude &getPressureAltitude() const { return m_situation.getPressureAltitude(); }
 
            void setPressureAltitude(const aviation::CAltitude &altitude) { m_situation.setPressureAltitude(altitude); }
 
            const physical_quantities::CSpeed &getGroundSpeed() const { return m_situation.getGroundSpeed(); }
 
            virtual geo::CLatitude latitude() const override { return m_situation.latitude(); }
 
            virtual geo::CLongitude longitude() const override { return m_situation.longitude(); }
 
            const aviation::CAltitude &geodeticHeight() const override { return m_situation.geodeticHeight(); }
 
            virtual QVector3D normalVector() const override { return m_situation.normalVector(); }
 
            virtual std::array<double, 3> normalVectorDouble() const override
            {
                return m_situation.normalVectorDouble();
            }
 
            const aviation::CAltitude &getGroundElevation() const { return m_situation.getGroundElevation(); }
 
            void setGroundElevation(const geo::CElevationPlane &elevation,
                                    aviation::CAircraftSituation::GndElevationInfo info)
            {
                m_situation.setGroundElevation(elevation, info);
            }
 
            void setGroundElevationChecked(const geo::CElevationPlane &elevation,
                                           aviation::CAircraftSituation::GndElevationInfo info)
            {
                m_situation.setGroundElevationChecked(elevation, info);
            }
 
            const aviation::CHeading &getHeading() const { return m_situation.getHeading(); }
 
            const physical_quantities::CAngle &getPitch() const { return m_situation.getPitch(); }
 
            const physical_quantities::CAngle &getBank() const { return m_situation.getBank(); }
 
            const aviation::CComSystem &getCom1System() const { return m_com1system; }
 
            const aviation::CComSystem &getCom2System() const { return m_com2system; }
 
            aviation::CComSystem getComSystem(aviation::CComSystem::ComUnit unit) const;
 
            void setComSystem(const aviation::CComSystem &com, aviation::CComSystem::ComUnit unit);
 
            void setCom1System(const aviation::CComSystem &comSystem) { m_com1system = comSystem; }
 
            void setCom2System(const aviation::CComSystem &comSystem) { m_com2system = comSystem; }
 
            bool setCom1ActiveFrequency(const physical_quantities::CFrequency &frequency);
 
            bool setCom2ActiveFrequency(const physical_quantities::CFrequency &frequency);
 
            bool setComActiveFrequency(const physical_quantities::CFrequency &frequency,
                                       aviation::CComSystem::ComUnit unit);
 
            bool isSelcalSelected(const aviation::CSelcal &selcal) const { return m_selcal == selcal; }
 
            bool hasValidSelcal() const { return m_selcal.isValid(); }
 
            const aviation::CSelcal getSelcal() const { return m_selcal; }
 
            void setCockpit(const CSimulatedAircraft &aircraft);
 
            void setCockpit(const aviation::CComSystem &com1, const aviation::CComSystem &com2,
                            const aviation::CTransponder &transponder);
 
            void setCockpit(const aviation::CComSystem &com1, const aviation::CComSystem &com2, int transponderCode,
                            aviation::CTransponder::TransponderMode mode);
 
            void setSelcal(const aviation::CSelcal &selcal) { m_selcal = selcal; }
 
            bool hasChangedCockpitData(const aviation::CComSystem &com1, const aviation::CComSystem &com2,
                                       const aviation::CTransponder &transponder) const;
 
            bool hasSameComData(const aviation::CComSystem &com1, const aviation::CComSystem &com2,
                                const aviation::CTransponder &transponder);
 
            bool hasComActiveFrequency(const physical_quantities::CFrequency &comFrequency) const;
 
            const aviation::CTransponder &getTransponder() const { return m_transponder; }
 
            void setTransponder(const aviation::CTransponder &transponder) { m_transponder = transponder; }
 
            bool setTransponderMode(aviation::CTransponder::TransponderMode mode);
 
            void setTransponderCode(int code) { m_transponder.setTransponderCode(code); }
 
            QString getTransponderCodeFormatted() const { return m_transponder.getTransponderCodeFormatted(); }
 
            qint32 getTransponderCode() const { return m_transponder.getTransponderCode(); }
 
            aviation::CTransponder::TransponderMode getTransponderMode() const
            {
                return m_transponder.getTransponderMode();
            }
 
            bool isValidForLogin() const;
 
            void initComSystems();
 
            void initTransponder();
 
            const aviation::CAircraftParts &getParts() const { return m_parts; }
 
            int getEnginesCount() const;
 
            aviation::CAircraftLights getLights() const;
 
            void setParts(const aviation::CAircraftParts &parts);
 
            void setLights(aviation::CAircraftLights &lights);
 
            void setAllLightsOn();
 
            void setAllLightsOff();
 
            bool isVtol() const;
 
            bool isMilitary() const;
 
            QString getCombinedIcaoLiveryString(bool networkModel = false) const;
 
            int comparePropertyByIndex(CPropertyIndexRef index, const CSimulatedAircraft &compareValue) const;
 
            const simulation::CAircraftModel &getModel() const { return m_models[CurrentModel]; }
 
            bool isTerrainProbe() const { return this->getModel().isTerrainProbe(); }
 
            const simulation::CAircraftModel &getNetworkModel() const { return m_models[NetworkModel]; }
 
            const simulation::CAircraftModel &getNetworkModelOrModel() const;
 
            bool hasNetworkModel() const;
 
            QString getNetworkModelAircraftIcaoDifference() const;
 
            QString getNetworkModelAirlineIcaoDifference() const;
 
            QString getNetworkModelLiveryDifference() const;
 
            const QString &getModelString() const { return m_models[CurrentModel].getModelString(); }
 
            void setModelString(const QString &modelString);
 
            bool hasModelString() const { return m_models[CurrentModel].hasModelString(); }
 
            void setModel(const CAircraftModel &model);
 
            void setNetworkModel(const CAircraftModel &model);
 
            const physical_quantities::CLength &getCG() const { return m_models[CurrentModel].getCG(); }
 
            bool hasCG() const { return !this->getCG().isNull(); }
 
            bool resetToNetworkModel();
 
            bool setCG(const physical_quantities::CLength &cg);
 
            void setCallsign(const aviation::CCallsign &callsign);
 
            void setPilot(const network::CUser &user);
 
            bool isEnabled() const;
 
            bool setEnabled(bool enabled);
 
            bool isRendered() const { return m_rendered; }
 
            bool fastPositionUpdates() const { return m_fastPositionUpdates; }
 
            bool setFastPositionUpdates(bool useFastPositions);
 
            bool toggleFastPositionUpdates();
 
            bool setRendered(bool rendered);
 
            bool isPartsSynchronized() const { return m_partsSynchronized; }
 
            void setPartsSynchronized(bool synchronized) { m_partsSynchronized = synchronized; }
 
            bool isSupportingGndFlag() const { return m_supportsGndFlag; }
 
            void setSupportingGndFlag(bool supports) { m_supportsGndFlag = supports; }
 
            QVariant propertyByIndex(CPropertyIndexRef index) const;
 
            void setPropertyByIndex(CPropertyIndexRef index, const QVariant &variant);
 
            QString convertToQString(bool i18n = false) const;
 
            CIcons::IconIndex toIcon() const { return m_callsign.toIcon(); }
 
        private:
            static constexpr int CurrentModel = 0; 
            static constexpr int NetworkModel = 1; 
            aviation::CCallsign m_callsign;
            network::CUser m_pilot;
            aviation::CAircraftSituation m_situation;
            aviation::CComSystem m_com1system;
            aviation::CComSystem m_com2system;
            aviation::CTransponder m_transponder;
            aviation::CAircraftParts m_parts;
            aviation::CSelcal m_selcal;
            CAircraftModelList m_models = {
                { CAircraftModel(), CAircraftModel() }
            }; 
            bool m_enabled = true; 
            bool m_rendered = false; 
            bool m_partsSynchronized = false; 
            bool m_fastPositionUpdates = false; 
            bool m_supportsGndFlag = false; 
 
            void init();
 
            SWIFT_METACLASS(
                CSimulatedAircraft,
                SWIFT_METAMEMBER(callsign),
                SWIFT_METAMEMBER(pilot),
                SWIFT_METAMEMBER(situation),
                SWIFT_METAMEMBER(com1system),
                SWIFT_METAMEMBER(com2system),
                SWIFT_METAMEMBER(transponder),
                SWIFT_METAMEMBER(parts),
                SWIFT_METAMEMBER(selcal),
                SWIFT_METAMEMBER(models),
                SWIFT_METAMEMBER(enabled),
                SWIFT_METAMEMBER(rendered),
                SWIFT_METAMEMBER(partsSynchronized),
                SWIFT_METAMEMBER(fastPositionUpdates),
                // ICoordinateWithRelativePosition
                SWIFT_METAMEMBER(relativeDistance),
                SWIFT_METAMEMBER(relativeBearing));
        };
    } // namespace simulation
} // namespace swift::misc
 
Q_DECLARE_METATYPE(swift::misc::simulation::CSimulatedAircraft)
 
#endif // SWIFT_MISC_SIMULATION_SIMULATEDAIRCRAFT_H