################
##            ##
##     TI     ##
##            ##
################
    TI.EndTask
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
EndTask( (ScriptedTaskInterface)arg1) -> None :

    C++ signature :
        void EndTask(class ai::ScriptedTaskInterface {lvalue})



    TI.GetBlackboardInterface
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetBlackboardInterface( (ScriptedTaskInterface)arg1) -> BlackboardInterface :

    C++ signature :
        class ai::BlackboardInterface GetBlackboardInterface(class ai::ScriptedTaskInterface {lvalue})



    TI.GetMemoryText
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetMemoryText( (ScriptedTaskInterface)arg1, (str)arg2) -> str :

    C++ signature :
        class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > GetMemoryText(class ai::ScriptedTaskInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    TI.GetMemoryValue
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetMemoryValue( (ScriptedTaskInterface)arg1, (int)arg2) -> float :

    C++ signature :
        double GetMemoryValue(class ai::ScriptedTaskInterface {lvalue},int)



    TI.GetPlatformInterface
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetPlatformInterface( (ScriptedTaskInterface)arg1) -> UnitInfoClass :

    C++ signature :
        class scriptinterface::tcPlatformInterface GetPlatformInterface(class ai::ScriptedTaskInterface {lvalue})



    TI.SetMemoryText
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetMemoryText( (ScriptedTaskInterface)arg1, (str)arg2, (str)arg3) -> None :

    C++ signature :
        void SetMemoryText(class ai::ScriptedTaskInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    TI.SetMemoryValue
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetMemoryValue( (ScriptedTaskInterface)arg1, (int)arg2, (float)arg3) -> None :

    C++ signature :
        void SetMemoryValue(class ai::ScriptedTaskInterface {lvalue},int,double)



    TI.SetTaskAttributes
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetTaskAttributes( (ScriptedTaskInterface)arg1, (int)arg2) -> None :

    C++ signature :
        void SetTaskAttributes(class ai::ScriptedTaskInterface {lvalue},int)



    TI.SetUpdateInterval
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetUpdateInterval( (ScriptedTaskInterface)arg1, (float)arg2) -> None :

    C++ signature :
        void SetUpdateInterval(class ai::ScriptedTaskInterface {lvalue},float)



################
##            ##
##     GI     ##
##            ##
################
    GI.GetPlatformInterface
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetPlatformInterface( (GroupInterfaceClass)arg1, (int)arg2) -> UnitInfoClass :

    C++ signature :
        class scriptinterface::tcPlatformInterface GetPlatformInterface(class scriptinterface::tcGroupInterface {lvalue},int)



    GI.GetScenarioInterface
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetScenarioInterface( (GroupInterfaceClass)arg1) -> ScenarioInterface :

    C++ signature :
        class scriptinterface::tcScenarioInterface GetScenarioInterface(class scriptinterface::tcGroupInterface {lvalue})



    GI.GetTankerList
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetTankerList( (GroupInterfaceClass)arg1) -> StringArray :

    C++ signature :
        class scriptinterface::tcStringArray GetTankerList(class scriptinterface::tcGroupInterface {lvalue})



    GI.GetUnitCount
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetUnitCount( (GroupInterfaceClass)arg1) -> int :

    C++ signature :
        int GetUnitCount(class scriptinterface::tcGroupInterface {lvalue})



    GI.GetUnitId
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetUnitId( (GroupInterfaceClass)arg1, (int)arg2) -> int :

    C++ signature :
        long GetUnitId(class scriptinterface::tcGroupInterface {lvalue},int)



    GI.GetUserInput
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetUserInput( (GroupInterfaceClass)arg1, (str)arg2, (str)arg3) -> None :

    C++ signature :
        void GetUserInput(class scriptinterface::tcGroupInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    GI.GetWeaponInterface
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetWeaponInterface( (GroupInterfaceClass)arg1, (int)arg2) -> WeaponInterface :

    C++ signature :
        class scriptinterface::tcWeaponInterface GetWeaponInterface(class scriptinterface::tcGroupInterface {lvalue},int)



    GI.IsPlatform
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsPlatform( (GroupInterfaceClass)arg1, (int)arg2) -> bool :

    C++ signature :
        bool IsPlatform(class scriptinterface::tcGroupInterface {lvalue},int)



    GI.IsWeapon
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsWeapon( (GroupInterfaceClass)arg1, (int)arg2) -> bool :

    C++ signature :
        bool IsWeapon(class scriptinterface::tcGroupInterface {lvalue},int)



    GI.LookupUnit
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
LookupUnit( (GroupInterfaceClass)arg1, (str)arg2) -> int :

    C++ signature :
        long LookupUnit(class scriptinterface::tcGroupInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    GI.LookupUnitIdx
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
LookupUnitIdx( (GroupInterfaceClass)arg1, (str)arg2) -> int :

    C++ signature :
        int LookupUnitIdx(class scriptinterface::tcGroupInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    GI.ReleaseControl
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
ReleaseControl( (GroupInterfaceClass)arg1) -> None :

    C++ signature :
        void ReleaseControl(class scriptinterface::tcGroupInterface {lvalue})



    GI.TakeControl
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
TakeControl( (GroupInterfaceClass)arg1) -> None :

    C++ signature :
        void TakeControl(class scriptinterface::tcGroupInterface {lvalue})



################
##            ##
##     UI     ##
##            ##
################
    UI.AddItemToMagazine
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
AddItemToMagazine( (UnitInfoClass)arg1, (str)arg2, (int)arg3) -> None :

    C++ signature :
        void AddItemToMagazine(class scriptinterface::tcPlatformInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,unsigned int)



    UI.AddNavWaypoint
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
AddNavWaypoint( (UnitInfoClass)arg1, (float)arg2, (float)arg3) -> None :

    C++ signature :
        void AddNavWaypoint(class scriptinterface::tcPlatformInterface {lvalue},float,float)



    UI.AddNavWaypointAdvanced
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
AddNavWaypointAdvanced( (UnitInfoClass)arg1, (float)arg2, (float)arg3, (float)arg4, (float)arg5) -> None :

    C++ signature :
        void AddNavWaypointAdvanced(class scriptinterface::tcPlatformInterface {lvalue},float,float,float,float)



    UI.AddRandomBox
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
AddRandomBox( (UnitInfoClass)arg1, (float)arg2, (float)arg3, (float)arg4, (float)arg5) -> None :

    C++ signature :
        void AddRandomBox(class scriptinterface::tcPlatformInterface {lvalue},float,float,float,float)



    UI.AddTask
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
AddTask( (UnitInfoClass)arg1, (str)arg2, (float)arg3, (int)arg4) -> None :

    C++ signature :
        void AddTask(class scriptinterface::tcPlatformInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,double,int)



    UI.AddUnitToFlightDeck
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
AddUnitToFlightDeck( (UnitInfoClass)arg1, (str)arg2) -> None :

    C++ signature :
        void AddUnitToFlightDeck(class scriptinterface::tcPlatformInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    UI.AddWaypointTask
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
AddWaypointTask( (UnitInfoClass)arg1, (int)arg2, (str)arg3) -> None :

    C++ signature :
        void AddWaypointTask(class scriptinterface::tcPlatformInterface {lvalue},unsigned int,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    UI.ApplyAdvancedDamage
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
ApplyAdvancedDamage( (UnitInfoClass)arg1, (bool)arg2, (float)arg3, (float)arg4, (float)arg5, (float)arg6, (float)arg7, (float)arg8, (float)arg9) -> None :

    C++ signature :
        void ApplyAdvancedDamage(class scriptinterface::tcPlatformInterface {lvalue},bool,float,float,float,float,float,float,float)



    UI.ApplyDamage
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
ApplyDamage( (UnitInfoClass)arg1, (float)arg2) -> None :

    C++ signature :
        void ApplyDamage(class scriptinterface::tcPlatformInterface {lvalue},float)



    UI.AutoConfigurePlatform
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
AutoConfigurePlatform( (UnitInfoClass)arg1, (str)arg2) -> None :

    C++ signature :
        void AutoConfigurePlatform(class scriptinterface::tcPlatformInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    UI.CalculateBombElevationDeg
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
CalculateBombElevationDeg( (UnitInfoClass)arg1, (float)arg2, (float)arg3) -> float :

    C++ signature :
        float CalculateBombElevationDeg(class scriptinterface::tcPlatformInterface {lvalue},float,float)



    UI.CanMagazineAcceptItem
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
CanMagazineAcceptItem( (UnitInfoClass)arg1, (str)arg2) -> bool :

    C++ signature :
        bool CanMagazineAcceptItem(class scriptinterface::tcPlatformInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    UI.CanRefuelInFlight
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
CanRefuelInFlight( (UnitInfoClass)arg1) -> bool :

    C++ signature :
        bool CanRefuelInFlight(class scriptinterface::tcPlatformInterface {lvalue})



    UI.ClearTasks
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
ClearTasks( (UnitInfoClass)arg1) -> None :

    C++ signature :
        void ClearTasks(class scriptinterface::tcPlatformInterface {lvalue})



    UI.DeleteAllRandomBoxes
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
DeleteAllRandomBoxes( (UnitInfoClass)arg1) -> None :

    C++ signature :
        void DeleteAllRandomBoxes(class scriptinterface::tcPlatformInterface {lvalue})



    UI.DeleteNavWaypoint
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
DeleteNavWaypoint( (UnitInfoClass)arg1, (int)arg2) -> None :

    C++ signature :
        void DeleteNavWaypoint(class scriptinterface::tcPlatformInterface {lvalue},unsigned int)



    UI.DeletePlatform
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
DeletePlatform( (UnitInfoClass)arg1) -> None :

    C++ signature :
        void DeletePlatform(class scriptinterface::tcPlatformInterface {lvalue})



    UI.DeleteTask
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
DeleteTask( (UnitInfoClass)arg1, (str)arg2) -> None :

    C++ signature :
        void DeleteTask(class scriptinterface::tcPlatformInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    UI.DisplayMessage
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
DisplayMessage( (UnitInfoClass)arg1, (str)arg2) -> None :

    C++ signature :
        void DisplayMessage(class scriptinterface::tcPlatformInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    UI.DisplayPopupMessage
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
DisplayPopupMessage( (UnitInfoClass)arg1, (str)arg2) -> None :

    C++ signature :
        void DisplayPopupMessage(class scriptinterface::tcPlatformInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    UI.EditNavWaypoint
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
EditNavWaypoint( (UnitInfoClass)arg1, (int)arg2, (float)arg3, (float)arg4) -> None :

    C++ signature :
        void EditNavWaypoint(class scriptinterface::tcPlatformInterface {lvalue},unsigned int,float,float)



    UI.EditNavWaypointAdvanced
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
EditNavWaypointAdvanced( (UnitInfoClass)arg1, (int)arg2, (float)arg3, (float)arg4, (float)arg5, (float)arg6) -> None :

    C++ signature :
        void EditNavWaypointAdvanced(class scriptinterface::tcPlatformInterface {lvalue},unsigned int,float,float,float,float)



    UI.EditNavWaypointReference
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
EditNavWaypointReference( (UnitInfoClass)arg1, (int)arg2, (int)arg3, (int)arg4) -> None :

    C++ signature :
        void EditNavWaypointReference(class scriptinterface::tcPlatformInterface {lvalue},unsigned int,unsigned char,long)



    UI.EquipLoadout
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
EquipLoadout( (UnitInfoClass)arg1, (str)arg2) -> None :

    C++ signature :
        void EquipLoadout(class scriptinterface::tcPlatformInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    UI.GetAirGroupCount
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetAirGroupCount( (UnitInfoClass)arg1) -> int :

    C++ signature :
        unsigned int GetAirGroupCount(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetAirGroupName
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetAirGroupName( (UnitInfoClass)arg1) -> str :

    C++ signature :
        class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > GetAirGroupName(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetAirUnitId
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetAirUnitId( (UnitInfoClass)arg1) -> int :

    C++ signature :
        unsigned int GetAirUnitId(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetAlt
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetAlt( (UnitInfoClass)arg1) -> float :

    C++ signature :
        float GetAlt(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetAltitude
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetAltitude( (UnitInfoClass)arg1) -> float :

    C++ signature :
        float GetAltitude(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetAlwaysVisible
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetAlwaysVisible( (UnitInfoClass)arg1) -> bool :

    C++ signature :
        bool GetAlwaysVisible(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetBestLauncher
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetBestLauncher( (UnitInfoClass)arg1) -> LauncherInfo :

    C++ signature :
        class scriptinterface::tcLauncherInfo GetBestLauncher(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetBlackboardInterface
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetBlackboardInterface( (UnitInfoClass)arg1) -> BlackboardInterface :

    C++ signature :
        class ai::BlackboardInterface GetBlackboardInterface(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetClass
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetClass( (UnitInfoClass)arg1) -> str :

    C++ signature :
        class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > GetClass(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetClimbDeg
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetClimbDeg( (UnitInfoClass)arg1) -> float :

    C++ signature :
        float GetClimbDeg(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetClosestAirTrack
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetClosestAirTrack( (UnitInfoClass)arg1, (float)arg2, (int)arg3, (int)arg4) -> tcSMTrack :

    C++ signature :
        class tcSensorMapTrack GetClosestAirTrack(class scriptinterface::tcPlatformInterface {lvalue},float,unsigned char,int)



    UI.GetClosestMissileTrack
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetClosestMissileTrack( (UnitInfoClass)arg1, (float)arg2, (int)arg3, (int)arg4) -> tcSMTrack :

    C++ signature :
        class tcSensorMapTrack GetClosestMissileTrack(class scriptinterface::tcPlatformInterface {lvalue},float,unsigned char,int)



    UI.GetClosestSurfaceTrack
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetClosestSurfaceTrack( (UnitInfoClass)arg1, (float)arg2, (int)arg3, (int)arg4) -> tcSMTrack :

    C++ signature :
        class tcSensorMapTrack GetClosestSurfaceTrack(class scriptinterface::tcPlatformInterface {lvalue},float,unsigned char,int)



    UI.GetClosestTrack
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetClosestTrack( (UnitInfoClass)arg1, (float)arg2, (int)arg3, (int)arg4, (int)arg5) -> tcSMTrack :

    C++ signature :
        class tcSensorMapTrack GetClosestTrack(class scriptinterface::tcPlatformInterface {lvalue},float,unsigned short,unsigned char,int)



    UI.GetCompatibleItemList
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetCompatibleItemList( (UnitInfoClass)arg1, (int)arg2) -> StringArray :

    C++ signature :
        class scriptinterface::tcStringArray GetCompatibleItemList(class scriptinterface::tcPlatformInterface {lvalue},int)



    UI.GetController
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetController( (UnitInfoClass)arg1) -> str :

    C++ signature :
        class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > GetController(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetCost
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetCost( (UnitInfoClass)arg1) -> float :

    C++ signature :
        float GetCost(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetCruiseAltitude
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetCruiseAltitude( (UnitInfoClass)arg1) -> float :

    C++ signature :
        float GetCruiseAltitude(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetCruiseRangeForAltitude
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetCruiseRangeForAltitude( (UnitInfoClass)arg1, (float)arg2) -> float :

    C++ signature :
        float GetCruiseRangeForAltitude(class scriptinterface::tcPlatformInterface {lvalue},float)



    UI.GetCruiseSpeedForAltitude
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetCruiseSpeedForAltitude( (UnitInfoClass)arg1, (float)arg2) -> float :

    C++ signature :
        float GetCruiseSpeedForAltitude(class scriptinterface::tcPlatformInterface {lvalue},float)



    UI.GetCurrentWaypoint
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetCurrentWaypoint( (UnitInfoClass)arg1) -> int :

    C++ signature :
        unsigned int GetCurrentWaypoint(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetEquipmentListByClass
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetEquipmentListByClass( (UnitInfoClass)arg1, (str)arg2) -> StringArray :

    C++ signature :
        class scriptinterface::tcStringArray GetEquipmentListByClass(class scriptinterface::tcPlatformInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    UI.GetFireControlInfo
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetFireControlInfo( (UnitInfoClass)arg1) -> FireControlInfo :

    C++ signature :
        class scriptinterface::tcFireControlInfo GetFireControlInfo(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetFirstTrack
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetFirstTrack( (UnitInfoClass)arg1) -> TrackIterator :

    C++ signature :
        class scriptinterface::tcTrackIterator GetFirstTrack(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetFlightPortInfo
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetFlightPortInfo( (UnitInfoClass)arg1) -> FlightPortInterface :

    C++ signature :
        class scriptinterface::tcFlightPortInterface GetFlightPortInfo(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetFormationEditId
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetFormationEditId( (UnitInfoClass)arg1) -> int :

    C++ signature :
        long GetFormationEditId(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetFormationLeader
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetFormationLeader( (UnitInfoClass)arg1) -> int :

    C++ signature :
        long GetFormationLeader(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetFormationMode
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetFormationMode( (UnitInfoClass)arg1) -> int :

    C++ signature :
        int GetFormationMode(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetFriendlyTrackList
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetFriendlyTrackList( (UnitInfoClass)arg1, (int)arg2, (float)arg3, (str)arg4) -> TrackList :

    C++ signature :
        class scriptinterface::tcTrackList GetFriendlyTrackList(class scriptinterface::tcPlatformInterface {lvalue},unsigned int,float,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    UI.GetFuel
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetFuel( (UnitInfoClass)arg1) -> float :

    C++ signature :
        float GetFuel(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetHeading
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetHeading( (UnitInfoClass)arg1) -> float :

    C++ signature :
        float GetHeading(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetHeadingRad
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetHeadingRad( (UnitInfoClass)arg1) -> float :

    C++ signature :
        float GetHeadingRad(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetHeadingToDatum
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetHeadingToDatum( (UnitInfoClass)arg1, (float)arg2, (float)arg3) -> float :

    C++ signature :
        float GetHeadingToDatum(class scriptinterface::tcPlatformInterface {lvalue},float,float)



    UI.GetIncludeProbability
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetIncludeProbability( (UnitInfoClass)arg1) -> float :

    C++ signature :
        float GetIncludeProbability(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetInterceptHeadingToTrack
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetInterceptHeadingToTrack( (UnitInfoClass)arg1, (tcSMTrack)arg2) -> float :

    C++ signature :
        float GetInterceptHeadingToTrack(class scriptinterface::tcPlatformInterface {lvalue},class tcSensorMapTrack)



    UI.GetLandingData
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetLandingData( (UnitInfoClass)arg1, (int)arg2) -> tcTrack :

    C++ signature :
        class tcTrack GetLandingData(class scriptinterface::tcPlatformInterface {lvalue},long)



    UI.GetLandingState
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetLandingState( (UnitInfoClass)arg1) -> int :

    C++ signature :
        int GetLandingState(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetLatitude
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetLatitude( (UnitInfoClass)arg1) -> float :

    C++ signature :
        float GetLatitude(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetLauncherCount
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetLauncherCount( (UnitInfoClass)arg1) -> int :

    C++ signature :
        int GetLauncherCount(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetLauncherInfo
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetLauncherInfo( (UnitInfoClass)arg1, (int)arg2) -> LauncherInfo :

    C++ signature :
        class scriptinterface::tcLauncherInfo GetLauncherInfo(class scriptinterface::tcPlatformInterface {lvalue},int)



    UI.GetLauncherInterceptTime
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetLauncherInterceptTime( (UnitInfoClass)arg1, (int)arg2, (tcSMTrack)arg3) -> float :

    C++ signature :
        float GetLauncherInterceptTime(class scriptinterface::tcPlatformInterface {lvalue},int,class tcSensorMapTrack {lvalue})



    UI.GetLauncherQuantity
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetLauncherQuantity( (UnitInfoClass)arg1, (int)arg2) -> int :

    C++ signature :
        int GetLauncherQuantity(class scriptinterface::tcPlatformInterface {lvalue},int)



    UI.GetLauncherStatus
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetLauncherStatus( (UnitInfoClass)arg1, (int)arg2) -> int :

    C++ signature :
        int GetLauncherStatus(class scriptinterface::tcPlatformInterface {lvalue},int)



    UI.GetLauncherTypeName
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetLauncherTypeName( (UnitInfoClass)arg1, (int)arg2, (int)arg3) -> str :

    C++ signature :
        class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > GetLauncherTypeName(class scriptinterface::tcPlatformInterface {lvalue},int,int)



    UI.GetLauncherTypesCount
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetLauncherTypesCount( (UnitInfoClass)arg1, (int)arg2) -> int :

    C++ signature :
        int GetLauncherTypesCount(class scriptinterface::tcPlatformInterface {lvalue},int)



    UI.GetLauncherWeaponName
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetLauncherWeaponName( (UnitInfoClass)arg1, (int)arg2) -> str :

    C++ signature :
        class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > GetLauncherWeaponName(class scriptinterface::tcPlatformInterface {lvalue},int)



    UI.GetLoadoutList
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetLoadoutList( (UnitInfoClass)arg1) -> StringArray :

    C++ signature :
        class scriptinterface::tcStringArray GetLoadoutList(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetLocalObj
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetLocalObj( (UnitInfoClass)arg1) -> None :

    C++ signature :
        void GetLocalObj(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetLongitude
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetLongitude( (UnitInfoClass)arg1) -> float :

    C++ signature :
        float GetLongitude(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetMagazineAddCount
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetMagazineAddCount( (UnitInfoClass)arg1) -> int :

    C++ signature :
        unsigned int GetMagazineAddCount(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetMagazineItems
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetMagazineItems( (UnitInfoClass)arg1) -> StringArray :

    C++ signature :
        class scriptinterface::tcStringArray GetMagazineItems(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetMagazineQuantity
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetMagazineQuantity( (UnitInfoClass)arg1, (str)arg2) -> int :

    C++ signature :
        int GetMagazineQuantity(class scriptinterface::tcPlatformInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    UI.GetMapTerrainElevation
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetMapTerrainElevation( (UnitInfoClass)arg1, (float)arg2, (float)arg3) -> float :

    C++ signature :
        float GetMapTerrainElevation(class scriptinterface::tcPlatformInterface {lvalue},float,float)



    UI.GetMaxAlt
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetMaxAlt( (UnitInfoClass)arg1) -> float :

    C++ signature :
        float GetMaxAlt(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetMaxAltitude
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetMaxAltitude( (UnitInfoClass)arg1) -> float :

    C++ signature :
        float GetMaxAltitude(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetMaxSpeed
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetMaxSpeed( (UnitInfoClass)arg1) -> float :

    C++ signature :
        float GetMaxSpeed(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetMissionInfo
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetMissionInfo( (UnitInfoClass)arg1) -> MissionInterface :

    C++ signature :
        class scriptinterface::tcMissionInterface GetMissionInfo(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetName
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetName( (UnitInfoClass)arg1) -> str :

    C++ signature :
        class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > GetName(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetNavLoopState
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetNavLoopState( (UnitInfoClass)arg1) -> bool :

    C++ signature :
        bool GetNavLoopState(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetPlatformAlliance
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetPlatformAlliance( (UnitInfoClass)arg1) -> int :

    C++ signature :
        unsigned int GetPlatformAlliance(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetPlatformClass
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetPlatformClass( (UnitInfoClass)arg1) -> str :

    C++ signature :
        class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > GetPlatformClass(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetPlatformId
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetPlatformId( (UnitInfoClass)arg1) -> int :

    C++ signature :
        long GetPlatformId(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetPlatformListByClass
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetPlatformListByClass( (UnitInfoClass)arg1, (str)arg2) -> StringArray :

    C++ signature :
        class scriptinterface::tcStringArray GetPlatformListByClass(class scriptinterface::tcPlatformInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    UI.GetPlatformName
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetPlatformName( (UnitInfoClass)arg1) -> str :

    C++ signature :
        class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > GetPlatformName(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetPlatformNameList
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetPlatformNameList( (UnitInfoClass)arg1) -> StringArray :

    C++ signature :
        class scriptinterface::tcStringArray GetPlatformNameList(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetPlatformSetups
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetPlatformSetups( (UnitInfoClass)arg1) -> StringArray :

    C++ signature :
        class scriptinterface::tcStringArray GetPlatformSetups(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetROE
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetROE( (UnitInfoClass)arg1) -> AllianceROEInfo :

    C++ signature :
        class scriptinterface::tcAllianceROEInfo GetROE(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetRandomPatrolPoint
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetRandomPatrolPoint( (UnitInfoClass)arg1) -> Datum :

    C++ signature :
        class scriptinterface::tcDatum GetRandomPatrolPoint(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetRangeToDatum
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetRangeToDatum( (UnitInfoClass)arg1, (float)arg2, (float)arg3) -> float :

    C++ signature :
        float GetRangeToDatum(class scriptinterface::tcPlatformInterface {lvalue},float,float)



    UI.GetRangeToTarget
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetRangeToTarget( (UnitInfoClass)arg1) -> float :

    C++ signature :
        float GetRangeToTarget(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetRangeToTrack
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetRangeToTrack( (UnitInfoClass)arg1, (tcSMTrack)arg2) -> float :

    C++ signature :
        float GetRangeToTrack(class scriptinterface::tcPlatformInterface {lvalue},class tcSensorMapTrack)



    UI.GetScenarioInterface
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetScenarioInterface( (UnitInfoClass)arg1) -> ScenarioInterface :

    C++ signature :
        class scriptinterface::tcScenarioInterface GetScenarioInterface(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetSensorCount
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetSensorCount( (UnitInfoClass)arg1) -> int :

    C++ signature :
        int GetSensorCount(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetSensorInfo
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetSensorInfo( (UnitInfoClass)arg1, (int)arg2) -> SensorInfo :

    C++ signature :
        class scriptinterface::tcSensorInfo GetSensorInfo(class scriptinterface::tcPlatformInterface {lvalue},int)



    UI.GetSpeed
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetSpeed( (UnitInfoClass)arg1) -> float :

    C++ signature :
        float GetSpeed(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetSubInterface
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetSubInterface( (UnitInfoClass)arg1) -> SubInterfaceClass :

    C++ signature :
        class scriptinterface::tcSubInterface GetSubInterface(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetTankerSpotsFree
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetTankerSpotsFree( (UnitInfoClass)arg1, (int)arg2) -> int :

    C++ signature :
        unsigned int GetTankerSpotsFree(class scriptinterface::tcPlatformInterface {lvalue},long)



    UI.GetTarget
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetTarget( (UnitInfoClass)arg1) -> int :

    C++ signature :
        long GetTarget(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetTargetTrackInfo
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetTargetTrackInfo( (UnitInfoClass)arg1) -> tcSMTrack :

    C++ signature :
        class tcSensorMapTrack GetTargetTrackInfo(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetTaskList
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetTaskList( (UnitInfoClass)arg1) -> StringArray :

    C++ signature :
        class scriptinterface::tcStringArray GetTaskList(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetTerrainElevation
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetTerrainElevation( (UnitInfoClass)arg1) -> float :

    C++ signature :
        float GetTerrainElevation(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetThrottle
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetThrottle( (UnitInfoClass)arg1) -> float :

    C++ signature :
        float GetThrottle(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetTime
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetTime( (UnitInfoClass)arg1) -> float :

    C++ signature :
        double GetTime(class scriptinterface::tcPlatformInterface {lvalue})



    UI.GetTrackById
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetTrackById( (UnitInfoClass)arg1, (int)arg2) -> tcSMTrack :

    C++ signature :
        class tcSensorMapTrack GetTrackById(class scriptinterface::tcPlatformInterface {lvalue},long)



    UI.GetTrackList
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetTrackList( (UnitInfoClass)arg1, (int)arg2, (float)arg3, (int)arg4) -> TrackList :

    C++ signature :
        class scriptinterface::tcTrackList GetTrackList(class scriptinterface::tcPlatformInterface {lvalue},int,float,unsigned char)



    UI.GetUnitInterface
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetUnitInterface( (UnitInfoClass)arg1, (str)arg2) -> UnitInfoClass :

    C++ signature :
        class scriptinterface::tcPlatformInterface GetUnitInterface(class scriptinterface::tcPlatformInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    UI.GetUserInput
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetUserInput( (UnitInfoClass)arg1, (str)arg2, (str)arg3) -> None :

    C++ signature :
        void GetUserInput(class scriptinterface::tcPlatformInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    UI.GetWeightMargin
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetWeightMargin( (UnitInfoClass)arg1) -> float :

    C++ signature :
        float GetWeightMargin(class scriptinterface::tcPlatformInterface {lvalue})



    UI.HandoffTargetToLauncher
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
HandoffTargetToLauncher( (UnitInfoClass)arg1, (int)arg2) -> bool :

    C++ signature :
        bool HandoffTargetToLauncher(class scriptinterface::tcPlatformInterface {lvalue},int)



    UI.HasFlightPort
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
HasFlightPort( (UnitInfoClass)arg1) -> bool :

    C++ signature :
        bool HasFlightPort(class scriptinterface::tcPlatformInterface {lvalue})



    UI.HasMagazine
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
HasMagazine( (UnitInfoClass)arg1) -> bool :

    C++ signature :
        bool HasMagazine(class scriptinterface::tcPlatformInterface {lvalue})



    UI.HasThrottle
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
HasThrottle( (UnitInfoClass)arg1) -> bool :

    C++ signature :
        bool HasThrottle(class scriptinterface::tcPlatformInterface {lvalue})



    UI.InsertNavWaypoint
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
InsertNavWaypoint( (UnitInfoClass)arg1, (int)arg2, (float)arg3, (float)arg4) -> None :

    C++ signature :
        void InsertNavWaypoint(class scriptinterface::tcPlatformInterface {lvalue},unsigned int,float,float)



    UI.IsAir
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsAir( (UnitInfoClass)arg1) -> bool :

    C++ signature :
        bool IsAir(class scriptinterface::tcPlatformInterface {lvalue})



    UI.IsAvailable
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsAvailable( (UnitInfoClass)arg1) -> bool :

    C++ signature :
        bool IsAvailable(class scriptinterface::tcPlatformInterface {lvalue})



    UI.IsDatumLaunch
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsDatumLaunch( (UnitInfoClass)arg1, (int)arg2) -> bool :

    C++ signature :
        bool IsDatumLaunch(class scriptinterface::tcPlatformInterface {lvalue},int)



    UI.IsDeveloperMode
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsDeveloperMode( (UnitInfoClass)arg1) -> bool :

    C++ signature :
        bool IsDeveloperMode(class scriptinterface::tcPlatformInterface {lvalue})



    UI.IsEquippedForTargetType
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsEquippedForTargetType( (UnitInfoClass)arg1, (int)arg2) -> bool :

    C++ signature :
        bool IsEquippedForTargetType(class scriptinterface::tcPlatformInterface {lvalue},unsigned int)



    UI.IsFixed
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsFixed( (UnitInfoClass)arg1) -> bool :

    C++ signature :
        bool IsFixed(class scriptinterface::tcPlatformInterface {lvalue})



    UI.IsFormationLeader
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsFormationLeader( (UnitInfoClass)arg1) -> bool :

    C++ signature :
        bool IsFormationLeader(class scriptinterface::tcPlatformInterface {lvalue})



    UI.IsGroundVehicle
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsGroundVehicle( (UnitInfoClass)arg1) -> bool :

    C++ signature :
        bool IsGroundVehicle(class scriptinterface::tcPlatformInterface {lvalue})



    UI.IsHelo
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsHelo( (UnitInfoClass)arg1) -> bool :

    C++ signature :
        bool IsHelo(class scriptinterface::tcPlatformInterface {lvalue})



    UI.IsInFormation
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsInFormation( (UnitInfoClass)arg1) -> bool :

    C++ signature :
        bool IsInFormation(class scriptinterface::tcPlatformInterface {lvalue})



    UI.IsLauncherEffective
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsLauncherEffective( (UnitInfoClass)arg1, (int)arg2) -> bool :

    C++ signature :
        bool IsLauncherEffective(class scriptinterface::tcPlatformInterface {lvalue},int)



    UI.IsMultiplayerActive
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsMultiplayerActive( (UnitInfoClass)arg1) -> bool :

    C++ signature :
        bool IsMultiplayerActive(class scriptinterface::tcPlatformInterface {lvalue})



    UI.IsPlayerControlled
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsPlayerControlled( (UnitInfoClass)arg1) -> bool :

    C++ signature :
        bool IsPlayerControlled(class scriptinterface::tcPlatformInterface {lvalue})



    UI.IsRefueling
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsRefueling( (UnitInfoClass)arg1) -> bool :

    C++ signature :
        bool IsRefueling(class scriptinterface::tcPlatformInterface {lvalue})



    UI.IsSub
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsSub( (UnitInfoClass)arg1) -> bool :

    C++ signature :
        bool IsSub(class scriptinterface::tcPlatformInterface {lvalue})



    UI.IsSurface
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsSurface( (UnitInfoClass)arg1) -> bool :

    C++ signature :
        bool IsSurface(class scriptinterface::tcPlatformInterface {lvalue})



    UI.IsTankerAircraft
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsTankerAircraft( (UnitInfoClass)arg1, (int)arg2) -> bool :

    C++ signature :
        bool IsTankerAircraft(class scriptinterface::tcPlatformInterface {lvalue},long)



    UI.IsTargetInRange
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsTargetInRange( (UnitInfoClass)arg1, (int)arg2, (float)arg3, (float)arg4, (float)arg5, (float)arg6, (float)arg7) -> bool :

    C++ signature :
        bool IsTargetInRange(class scriptinterface::tcPlatformInterface {lvalue},int,float,float,float,float,float)



    UI.IsValid
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsValid( (UnitInfoClass)arg1) -> bool :

    C++ signature :
        bool IsValid(class scriptinterface::tcPlatformInterface {lvalue})



    UI.Launch
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
Launch( (UnitInfoClass)arg1, (int)arg2, (int)arg3) -> None :

    C++ signature :
        void Launch(class scriptinterface::tcPlatformInterface {lvalue},int,int)



    UI.LaunchAtMe
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
LaunchAtMe( (UnitInfoClass)arg1, (str)arg2, (int)arg3) -> None :

    C++ signature :
        void LaunchAtMe(class scriptinterface::tcPlatformInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,unsigned int)



    UI.LoadLauncher
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
LoadLauncher( (UnitInfoClass)arg1, (int)arg2, (str)arg3) -> None :

    C++ signature :
        void LoadLauncher(class scriptinterface::tcPlatformInterface {lvalue},int,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    UI.LoadLauncherTest
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
LoadLauncherTest( (UnitInfoClass)arg1, (int)arg2, (str)arg3, (int)arg4) -> None :

    C++ signature :
        void LoadLauncherTest(class scriptinterface::tcPlatformInterface {lvalue},int,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,int)



    UI.LoadOther
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
LoadOther( (UnitInfoClass)arg1, (str)arg2) -> None :

    C++ signature :
        void LoadOther(class scriptinterface::tcPlatformInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    UI.LookupFriendlyId
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
LookupFriendlyId( (UnitInfoClass)arg1, (str)arg2) -> int :

    C++ signature :
        long LookupFriendlyId(class scriptinterface::tcPlatformInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    UI.LookupFriendlyName
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
LookupFriendlyName( (UnitInfoClass)arg1, (int)arg2) -> str :

    C++ signature :
        class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > LookupFriendlyName(class scriptinterface::tcPlatformInterface {lvalue},long)



    UI.MaintenanceHold
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
MaintenanceHold( (UnitInfoClass)arg1) -> bool :

    C++ signature :
        bool MaintenanceHold(class scriptinterface::tcPlatformInterface {lvalue})



    UI.MovePlatform
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
MovePlatform( (UnitInfoClass)arg1, (float)arg2, (float)arg3) -> None :

    C++ signature :
        void MovePlatform(class scriptinterface::tcPlatformInterface {lvalue},float,float)



    UI.PlaySound
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
PlaySound( (UnitInfoClass)arg1, (str)arg2) -> None :

    C++ signature :
        void PlaySound(class scriptinterface::tcPlatformInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    UI.Rand
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
Rand( (UnitInfoClass)arg1) -> float :

    C++ signature :
        float Rand(class scriptinterface::tcPlatformInterface {lvalue})



    UI.ReleaseControl
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
ReleaseControl( (UnitInfoClass)arg1) -> None :

    C++ signature :
        void ReleaseControl(class scriptinterface::tcPlatformInterface {lvalue})



    UI.RemoveWaypointTask
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
RemoveWaypointTask( (UnitInfoClass)arg1, (int)arg2, (str)arg3) -> None :

    C++ signature :
        void RemoveWaypointTask(class scriptinterface::tcPlatformInterface {lvalue},unsigned int,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    UI.RenamePlatform
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
RenamePlatform( (UnitInfoClass)arg1, (str)arg2) -> None :

    C++ signature :
        void RenamePlatform(class scriptinterface::tcPlatformInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    UI.SendCommand
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SendCommand( (UnitInfoClass)arg1, (str)arg2) -> None :

    C++ signature :
        void SendCommand(class scriptinterface::tcPlatformInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    UI.SendDatumToLauncher
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SendDatumToLauncher( (UnitInfoClass)arg1, (float)arg2, (float)arg3, (float)arg4, (int)arg5) -> None :

    C++ signature :
        void SendDatumToLauncher(class scriptinterface::tcPlatformInterface {lvalue},float,float,float,int)



    UI.SendTargetToLauncher
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SendTargetToLauncher( (UnitInfoClass)arg1, (int)arg2, (int)arg3) -> bool :

    C++ signature :
        bool SendTargetToLauncher(class scriptinterface::tcPlatformInterface {lvalue},long,int)



    UI.SetActionText
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetActionText( (UnitInfoClass)arg1, (str)arg2) -> None :

    C++ signature :
        void SetActionText(class scriptinterface::tcPlatformInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    UI.SetAirGroupCount
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetAirGroupCount( (UnitInfoClass)arg1, (int)arg2) -> None :

    C++ signature :
        void SetAirGroupCount(class scriptinterface::tcPlatformInterface {lvalue},unsigned int)



    UI.SetAirGroupName
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetAirGroupName( (UnitInfoClass)arg1, (str)arg2) -> None :

    C++ signature :
        void SetAirGroupName(class scriptinterface::tcPlatformInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    UI.SetAllSensorState
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetAllSensorState( (UnitInfoClass)arg1, (int)arg2) -> None :

    C++ signature :
        void SetAllSensorState(class scriptinterface::tcPlatformInterface {lvalue},int)



    UI.SetAlt
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetAlt( (UnitInfoClass)arg1, (float)arg2) -> None :

    C++ signature :
        void SetAlt(class scriptinterface::tcPlatformInterface {lvalue},float)



    UI.SetAltitude
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetAltitude( (UnitInfoClass)arg1, (float)arg2) -> None :

    C++ signature :
        void SetAltitude(class scriptinterface::tcPlatformInterface {lvalue},float)



    UI.SetAlwaysVisible
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetAlwaysVisible( (UnitInfoClass)arg1, (bool)arg2) -> None :

    C++ signature :
        void SetAlwaysVisible(class scriptinterface::tcPlatformInterface {lvalue},bool)



    UI.SetClimbDeg
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetClimbDeg( (UnitInfoClass)arg1, (float)arg2) -> None :

    C++ signature :
        void SetClimbDeg(class scriptinterface::tcPlatformInterface {lvalue},float)



    UI.SetClimbRad
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetClimbRad( (UnitInfoClass)arg1, (float)arg2) -> None :

    C++ signature :
        void SetClimbRad(class scriptinterface::tcPlatformInterface {lvalue},float)



    UI.SetCost
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetCost( (UnitInfoClass)arg1, (float)arg2) -> None :

    C++ signature :
        void SetCost(class scriptinterface::tcPlatformInterface {lvalue},float)



    UI.SetCurrentWaypoint
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetCurrentWaypoint( (UnitInfoClass)arg1, (int)arg2) -> None :

    C++ signature :
        void SetCurrentWaypoint(class scriptinterface::tcPlatformInterface {lvalue},unsigned int)



    UI.SetFormationAltitudeOffset
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetFormationAltitudeOffset( (UnitInfoClass)arg1, (float)arg2) -> None :

    C++ signature :
        void SetFormationAltitudeOffset(class scriptinterface::tcPlatformInterface {lvalue},float)



    UI.SetFormationEdit
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetFormationEdit( (UnitInfoClass)arg1, (bool)arg2) -> None :

    C++ signature :
        void SetFormationEdit(class scriptinterface::tcPlatformInterface {lvalue},bool)



    UI.SetFormationLeader
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetFormationLeader( (UnitInfoClass)arg1, (int)arg2) -> None :

    C++ signature :
        void SetFormationLeader(class scriptinterface::tcPlatformInterface {lvalue},long)



    UI.SetFormationMode
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetFormationMode( (UnitInfoClass)arg1, (int)arg2) -> None :

    C++ signature :
        void SetFormationMode(class scriptinterface::tcPlatformInterface {lvalue},int)



    UI.SetFormationPosition
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetFormationPosition( (UnitInfoClass)arg1, (float)arg2, (float)arg3, (float)arg4, (float)arg5) -> None :

    C++ signature :
        void SetFormationPosition(class scriptinterface::tcPlatformInterface {lvalue},float,float,float,float)



    UI.SetFormationUseNorthBearing
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetFormationUseNorthBearing( (UnitInfoClass)arg1, (bool)arg2) -> None :

    C++ signature :
        void SetFormationUseNorthBearing(class scriptinterface::tcPlatformInterface {lvalue},bool)



    UI.SetFuelTest
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetFuelTest( (UnitInfoClass)arg1, (float)arg2) -> None :

    C++ signature :
        void SetFuelTest(class scriptinterface::tcPlatformInterface {lvalue},float)



    UI.SetHeading
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetHeading( (UnitInfoClass)arg1, (float)arg2) -> None :

    C++ signature :
        void SetHeading(class scriptinterface::tcPlatformInterface {lvalue},float)



    UI.SetHeadingRad
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetHeadingRad( (UnitInfoClass)arg1, (float)arg2) -> None :

    C++ signature :
        void SetHeadingRad(class scriptinterface::tcPlatformInterface {lvalue},float)



    UI.SetHeadingToInterceptTarget
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetHeadingToInterceptTarget( (UnitInfoClass)arg1) -> float :

    C++ signature :
        float SetHeadingToInterceptTarget(class scriptinterface::tcPlatformInterface {lvalue})



    UI.SetHeadingToInterceptTrack
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetHeadingToInterceptTrack( (UnitInfoClass)arg1, (tcSMTrack)arg2) -> float :

    C++ signature :
        float SetHeadingToInterceptTrack(class scriptinterface::tcPlatformInterface {lvalue},class tcSensorMapTrack)



    UI.SetIncludeProbability
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetIncludeProbability( (UnitInfoClass)arg1, (float)arg2) -> None :

    C++ signature :
        void SetIncludeProbability(class scriptinterface::tcPlatformInterface {lvalue},float)



    UI.SetInvulnerable
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetInvulnerable( (UnitInfoClass)arg1, (bool)arg2) -> None :

    C++ signature :
        void SetInvulnerable(class scriptinterface::tcPlatformInterface {lvalue},bool)



    UI.SetLandingState
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetLandingState( (UnitInfoClass)arg1, (int)arg2) -> None :

    C++ signature :
        void SetLandingState(class scriptinterface::tcPlatformInterface {lvalue},int)



    UI.SetMagazineAddCount
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetMagazineAddCount( (UnitInfoClass)arg1, (int)arg2) -> None :

    C++ signature :
        void SetMagazineAddCount(class scriptinterface::tcPlatformInterface {lvalue},unsigned int)



    UI.SetMaxTurnRate
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetMaxTurnRate( (UnitInfoClass)arg1, (float)arg2) -> None :

    C++ signature :
        void SetMaxTurnRate(class scriptinterface::tcPlatformInterface {lvalue},float)



    UI.SetNavLoopState
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetNavLoopState( (UnitInfoClass)arg1, (bool)arg2) -> None :

    C++ signature :
        void SetNavLoopState(class scriptinterface::tcPlatformInterface {lvalue},bool)



    UI.SetNavWaypointTasks
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetNavWaypointTasks( (UnitInfoClass)arg1, (int)arg2, (str)arg3) -> None :

    C++ signature :
        void SetNavWaypointTasks(class scriptinterface::tcPlatformInterface {lvalue},unsigned int,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    UI.SetPitchLimit
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetPitchLimit( (UnitInfoClass)arg1, (float)arg2) -> None :

    C++ signature :
        void SetPitchLimit(class scriptinterface::tcPlatformInterface {lvalue},float)



    UI.SetSensorState
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetSensorState( (UnitInfoClass)arg1, (int)arg2, (int)arg3) -> None :

    C++ signature :
        void SetSensorState(class scriptinterface::tcPlatformInterface {lvalue},int,int)



    UI.SetSpeed
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetSpeed( (UnitInfoClass)arg1, (float)arg2) -> None :

    C++ signature :
        void SetSpeed(class scriptinterface::tcPlatformInterface {lvalue},float)



    UI.SetSpeedToMax
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetSpeedToMax( (UnitInfoClass)arg1) -> None :

    C++ signature :
        void SetSpeedToMax(class scriptinterface::tcPlatformInterface {lvalue})



    UI.SetTarget
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetTarget( (UnitInfoClass)arg1, (int)arg2) -> None :

    C++ signature :
        void SetTarget(class scriptinterface::tcPlatformInterface {lvalue},long)



    UI.SetTaskRun
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetTaskRun( (UnitInfoClass)arg1, (str)arg2, (bool)arg3) -> None :

    C++ signature :
        void SetTaskRun(class scriptinterface::tcPlatformInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,bool)



    UI.SetTestParameter
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetTestParameter( (UnitInfoClass)arg1, (str)arg2, (float)arg3) -> None :

    C++ signature :
        void SetTestParameter(class scriptinterface::tcPlatformInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,float)



    UI.SetThrottle
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetThrottle( (UnitInfoClass)arg1, (float)arg2) -> None :

    C++ signature :
        void SetThrottle(class scriptinterface::tcPlatformInterface {lvalue},float)



    UI.StartRefuelWith
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
StartRefuelWith( (UnitInfoClass)arg1, (int)arg2) -> bool :

    C++ signature :
        bool StartRefuelWith(class scriptinterface::tcPlatformInterface {lvalue},long)



    UI.TakeControl
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
TakeControl( (UnitInfoClass)arg1) -> None :

    C++ signature :
        void TakeControl(class scriptinterface::tcPlatformInterface {lvalue})



    UI.TaskExists
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
TaskExists( (UnitInfoClass)arg1, (str)arg2) -> bool :

    C++ signature :
        bool TaskExists(class scriptinterface::tcPlatformInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    UI.UnloadLauncher
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
UnloadLauncher( (UnitInfoClass)arg1, (int)arg2) -> None :

    C++ signature :
        void UnloadLauncher(class scriptinterface::tcPlatformInterface {lvalue},int)



    UI.UpdateMissionEditGraphics
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
UpdateMissionEditGraphics( (UnitInfoClass)arg1) -> None :

    C++ signature :
        void UpdateMissionEditGraphics(class scriptinterface::tcPlatformInterface {lvalue})



################
##            ##
##     BB     ##
##            ##
################
    BB.Erase
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
Erase( (BlackboardInterface)arg1, (str)arg2) -> None :

    C++ signature :
        void Erase(class ai::BlackboardInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    BB.KeyExists
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
KeyExists( (BlackboardInterface)arg1, (str)arg2) -> bool :

    C++ signature :
        bool KeyExists(class ai::BlackboardInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    BB.Read
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
Read( (BlackboardInterface)arg1, (str)arg2) -> BlackboardItem :

    C++ signature :
        class ai::BlackboardItem Read(class ai::BlackboardInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    BB.ReadAuthor
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
ReadAuthor( (BlackboardInterface)arg1, (str)arg2) -> int :

    C++ signature :
        long ReadAuthor(class ai::BlackboardInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    BB.ReadMessage
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
ReadMessage( (BlackboardInterface)arg1, (str)arg2) -> str :

    C++ signature :
        class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > ReadMessage(class ai::BlackboardInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    BB.ReadPriority
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
ReadPriority( (BlackboardInterface)arg1, (str)arg2) -> float :

    C++ signature :
        double ReadPriority(class ai::BlackboardInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    BB.Write
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
Write( (BlackboardInterface)arg1, (str)arg2, (str)arg3) -> bool :

    C++ signature :
        bool Write(class ai::BlackboardInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    BB.WriteGlobal
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
WriteGlobal( (BlackboardInterface)arg1, (str)arg2, (str)arg3) -> bool :

    C++ signature :
        bool WriteGlobal(class ai::BlackboardInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    BB.author
    type: <type 'int'>
    callable?: False
    doc string: int(x[, base]) -> integer





    BB.priority
    type: <type 'float'>
    callable?: False
    doc string: float(x) -> floating point number

Convert a string or number to a floating point number, if possible.



################
##            ##
##     FC     ##
##            ##
################
    FC.maxLeft_deg
    type: <type 'float'>
    callable?: False
    doc string: float(x) -> floating point number

Convert a string or number to a floating point number, if possible.



    FC.maxRight_deg
    type: <type 'float'>
    callable?: False
    doc string: float(x) -> floating point number

Convert a string or number to a floating point number, if possible.



    FC.radarGuidanceActive
    type: <type 'bool'>
    callable?: False
    doc string: bool(x) -> bool

Returns True when the argument x is true, False otherwise.
The builtins True and False are the only two instances of the class bool.
The class bool is a subclass of the class int, and cannot be subclassed.



    FC.weaponsOut
    type: <type 'int'>
    callable?: False
    doc string: int(x[, base]) -> integer





################
##            ##
##     FP     ##
##            ##
################
    FP.AddAEWMission
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
AddAEWMission( (FlightPortInterface)arg1, (float)arg2, (float)arg3) -> None :

    C++ signature :
        void AddAEWMission(class scriptinterface::tcFlightPortInterface {lvalue},float,float)



    FP.AddASWMission
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
AddASWMission( (FlightPortInterface)arg1, (float)arg2, (float)arg3) -> None :

    C++ signature :
        void AddASWMission(class scriptinterface::tcFlightPortInterface {lvalue},float,float)



    FP.AddAircraftToMission
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
AddAircraftToMission( (FlightPortInterface)arg1, (int)arg2, (str)arg3) -> None :

    C++ signature :
        void AddAircraftToMission(class scriptinterface::tcFlightPortInterface {lvalue},unsigned int,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    FP.AddAttackMission
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
AddAttackMission( (FlightPortInterface)arg1, (int)arg2) -> None :

    C++ signature :
        void AddAttackMission(class scriptinterface::tcFlightPortInterface {lvalue},long)



    FP.AddCAPMission
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
AddCAPMission( (FlightPortInterface)arg1, (float)arg2, (float)arg3) -> None :

    C++ signature :
        void AddCAPMission(class scriptinterface::tcFlightPortInterface {lvalue},float,float)



    FP.AddGenericMission
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
AddGenericMission( (FlightPortInterface)arg1) -> int :

    C++ signature :
        unsigned int AddGenericMission(class scriptinterface::tcFlightPortInterface {lvalue})



    FP.AddMissionWaypoint
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
AddMissionWaypoint( (FlightPortInterface)arg1, (int)arg2, (float)arg3, (float)arg4) -> None :

    C++ signature :
        void AddMissionWaypoint(class scriptinterface::tcFlightPortInterface {lvalue},unsigned int,float,float)



    FP.AddMissionWaypointAdvanced
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
AddMissionWaypointAdvanced( (FlightPortInterface)arg1, (int)arg2, (float)arg3, (float)arg4, (float)arg5, (float)arg6) -> None :

    C++ signature :
        void AddMissionWaypointAdvanced(class scriptinterface::tcFlightPortInterface {lvalue},unsigned int,float,float,float,float)



    FP.AddMissionWaypointTask
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
AddMissionWaypointTask( (FlightPortInterface)arg1, (int)arg2, (int)arg3, (str)arg4) -> None :

    C++ signature :
        void AddMissionWaypointTask(class scriptinterface::tcFlightPortInterface {lvalue},unsigned int,unsigned int,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    FP.ClearMissionWaypoints
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
ClearMissionWaypoints( (FlightPortInterface)arg1, (int)arg2) -> None :

    C++ signature :
        void ClearMissionWaypoints(class scriptinterface::tcFlightPortInterface {lvalue},unsigned int)



    FP.DeleteMissionWaypoint
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
DeleteMissionWaypoint( (FlightPortInterface)arg1, (int)arg2, (int)arg3) -> None :

    C++ signature :
        void DeleteMissionWaypoint(class scriptinterface::tcFlightPortInterface {lvalue},unsigned int,unsigned int)



    FP.EditMissionWaypoint
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
EditMissionWaypoint( (FlightPortInterface)arg1, (int)arg2, (int)arg3, (float)arg4, (float)arg5) -> None :

    C++ signature :
        void EditMissionWaypoint(class scriptinterface::tcFlightPortInterface {lvalue},unsigned int,unsigned int,float,float)



    FP.EditMissionWaypointAdvanced
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
EditMissionWaypointAdvanced( (FlightPortInterface)arg1, (int)arg2, (int)arg3, (float)arg4, (float)arg5, (float)arg6, (float)arg7) -> None :

    C++ signature :
        void EditMissionWaypointAdvanced(class scriptinterface::tcFlightPortInterface {lvalue},unsigned int,unsigned int,float,float,float,float)



    FP.EditMissionWaypointReference
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
EditMissionWaypointReference( (FlightPortInterface)arg1, (int)arg2, (int)arg3, (int)arg4, (int)arg5) -> None :

    C++ signature :
        void EditMissionWaypointReference(class scriptinterface::tcFlightPortInterface {lvalue},unsigned int,unsigned int,unsigned char,long)



    FP.GetCurrentTime
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetCurrentTime( (FlightPortInterface)arg1) -> float :

    C++ signature :
        double GetCurrentTime(class scriptinterface::tcFlightPortInterface {lvalue})



    FP.GetEditMissionId
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetEditMissionId( (FlightPortInterface)arg1) -> int :

    C++ signature :
        unsigned int GetEditMissionId(class scriptinterface::tcFlightPortInterface {lvalue})



    FP.GetLocalObj
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetLocalObj( (FlightPortInterface)arg1) -> None :

    C++ signature :
        void GetLocalObj(class scriptinterface::tcFlightPortInterface {lvalue})



    FP.GetMissionCount
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetMissionCount( (FlightPortInterface)arg1) -> int :

    C++ signature :
        unsigned int GetMissionCount(class scriptinterface::tcFlightPortInterface {lvalue})



    FP.GetMissionId
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetMissionId( (FlightPortInterface)arg1, (int)arg2) -> int :

    C++ signature :
        unsigned int GetMissionId(class scriptinterface::tcFlightPortInterface {lvalue},unsigned int)



    FP.GetMissionPatrolArea
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetMissionPatrolArea( (FlightPortInterface)arg1, (int)arg2) -> str :

    C++ signature :
        char const * GetMissionPatrolArea(class scriptinterface::tcFlightPortInterface {lvalue},unsigned int)



    FP.GetMissionType
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetMissionType( (FlightPortInterface)arg1, (int)arg2) -> str :

    C++ signature :
        char const * GetMissionType(class scriptinterface::tcFlightPortInterface {lvalue},unsigned int)



    FP.GetMissionWaypointCount
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetMissionWaypointCount( (FlightPortInterface)arg1, (int)arg2) -> int :

    C++ signature :
        unsigned int GetMissionWaypointCount(class scriptinterface::tcFlightPortInterface {lvalue},unsigned int)



    FP.GetUnitCount
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetUnitCount( (FlightPortInterface)arg1) -> int :

    C++ signature :
        int GetUnitCount(class scriptinterface::tcFlightPortInterface {lvalue})



    FP.GetUnitGoalLocation
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetUnitGoalLocation( (FlightPortInterface)arg1, (int)arg2) -> str :

    C++ signature :
        class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > GetUnitGoalLocation(class scriptinterface::tcFlightPortInterface {lvalue},int)



    FP.GetUnitID
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetUnitID( (FlightPortInterface)arg1, (int)arg2) -> int :

    C++ signature :
        long GetUnitID(class scriptinterface::tcFlightPortInterface {lvalue},int)



    FP.GetUnitLocation
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetUnitLocation( (FlightPortInterface)arg1, (int)arg2) -> str :

    C++ signature :
        class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > GetUnitLocation(class scriptinterface::tcFlightPortInterface {lvalue},int)



    FP.GetUnitName
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetUnitName( (FlightPortInterface)arg1, (int)arg2) -> str :

    C++ signature :
        class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > GetUnitName(class scriptinterface::tcFlightPortInterface {lvalue},int)



    FP.GetUnitPlatformInterface
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetUnitPlatformInterface( (FlightPortInterface)arg1, (int)arg2) -> UnitInfoClass :

    C++ signature :
        class scriptinterface::tcPlatformInterface GetUnitPlatformInterface(class scriptinterface::tcFlightPortInterface {lvalue},int)



    FP.GetUnitStatus
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetUnitStatus( (FlightPortInterface)arg1, (int)arg2) -> FlightUnitStatus :

    C++ signature :
        class scriptinterface::tcFlightUnitStatus GetUnitStatus(class scriptinterface::tcFlightPortInterface {lvalue},int)



    FP.HasAircraftForMission
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
HasAircraftForMission( (FlightPortInterface)arg1, (str)arg2) -> bool :

    C++ signature :
        bool HasAircraftForMission(class scriptinterface::tcFlightPortInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    FP.InsertMissionWaypoint
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
InsertMissionWaypoint( (FlightPortInterface)arg1, (int)arg2, (int)arg3, (float)arg4, (float)arg5) -> None :

    C++ signature :
        void InsertMissionWaypoint(class scriptinterface::tcFlightPortInterface {lvalue},unsigned int,unsigned int,float,float)



    FP.IsValid
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsValid( (FlightPortInterface)arg1) -> bool :

    C++ signature :
        bool IsValid(class scriptinterface::tcFlightPortInterface {lvalue})



    FP.Launch
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
Launch( (FlightPortInterface)arg1, (int)arg2) -> None :

    C++ signature :
        void Launch(class scriptinterface::tcFlightPortInterface {lvalue},int)



    FP.LaunchID
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
LaunchID( (FlightPortInterface)arg1, (int)arg2) -> None :

    C++ signature :
        void LaunchID(class scriptinterface::tcFlightPortInterface {lvalue},long)



    FP.RemoveMissionWaypointTask
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
RemoveMissionWaypointTask( (FlightPortInterface)arg1, (int)arg2, (int)arg3, (str)arg4) -> None :

    C++ signature :
        void RemoveMissionWaypointTask(class scriptinterface::tcFlightPortInterface {lvalue},unsigned int,unsigned int,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    FP.SetDestination
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetDestination( (FlightPortInterface)arg1, (int)arg2, (int)arg3) -> None :

    C++ signature :
        void SetDestination(class scriptinterface::tcFlightPortInterface {lvalue},int,int)



    FP.SetEditMissionId
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetEditMissionId( (FlightPortInterface)arg1, (int)arg2) -> None :

    C++ signature :
        void SetEditMissionId(class scriptinterface::tcFlightPortInterface {lvalue},unsigned int)



    FP.SetMissionDatum
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetMissionDatum( (FlightPortInterface)arg1, (int)arg2, (float)arg3, (float)arg4) -> None :

    C++ signature :
        void SetMissionDatum(class scriptinterface::tcFlightPortInterface {lvalue},unsigned int,float,float)



    FP.SetMissionLandingTarget
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetMissionLandingTarget( (FlightPortInterface)arg1, (int)arg2, (str)arg3) -> None :

    C++ signature :
        void SetMissionLandingTarget(class scriptinterface::tcFlightPortInterface {lvalue},unsigned int,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    FP.SetMissionLaunchTime
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetMissionLaunchTime( (FlightPortInterface)arg1, (int)arg2, (str)arg3) -> None :

    C++ signature :
        void SetMissionLaunchTime(class scriptinterface::tcFlightPortInterface {lvalue},unsigned int,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    FP.SetMissionPatrolAnchor
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetMissionPatrolAnchor( (FlightPortInterface)arg1, (int)arg2, (str)arg3, (int)arg4) -> None :

    C++ signature :
        void SetMissionPatrolAnchor(class scriptinterface::tcFlightPortInterface {lvalue},unsigned int,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,int)



    FP.SetMissionPatrolArea
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetMissionPatrolArea( (FlightPortInterface)arg1, (int)arg2, (str)arg3) -> None :

    C++ signature :
        void SetMissionPatrolArea(class scriptinterface::tcFlightPortInterface {lvalue},unsigned int,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    FP.SetMissionType
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetMissionType( (FlightPortInterface)arg1, (int)arg2, (str)arg3) -> None :

    C++ signature :
        void SetMissionType(class scriptinterface::tcFlightPortInterface {lvalue},unsigned int,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    FP.SetMissionWaveQuantity
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetMissionWaveQuantity( (FlightPortInterface)arg1, (int)arg2, (int)arg3) -> None :

    C++ signature :
        void SetMissionWaveQuantity(class scriptinterface::tcFlightPortInterface {lvalue},unsigned int,unsigned int)



    FP.SetMissionWaypointTasks
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetMissionWaypointTasks( (FlightPortInterface)arg1, (int)arg2, (int)arg3, (str)arg4) -> None :

    C++ signature :
        void SetMissionWaypointTasks(class scriptinterface::tcFlightPortInterface {lvalue},unsigned int,unsigned int,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    FP.TransformToAbsolutePatrolArea
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
TransformToAbsolutePatrolArea( (FlightPortInterface)arg1, (int)arg2) -> None :

    C++ signature :
        void TransformToAbsolutePatrolArea(class scriptinterface::tcFlightPortInterface {lvalue},unsigned int)



    FP.TransformToRelativePatrolArea
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
TransformToRelativePatrolArea( (FlightPortInterface)arg1, (int)arg2) -> None :

    C++ signature :
        void TransformToRelativePatrolArea(class scriptinterface::tcFlightPortInterface {lvalue},unsigned int)



################
##            ##
##     SI     ##
##            ##
################
    SI.GetBatteryFraction
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetBatteryFraction( (SubInterfaceClass)arg1) -> float :

    C++ signature :
        float GetBatteryFraction(class scriptinterface::tcSubInterface {lvalue})



    SI.GetCavitatingSpeed
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetCavitatingSpeed( (SubInterfaceClass)arg1, (float)arg2) -> float :

    C++ signature :
        float GetCavitatingSpeed(class scriptinterface::tcSubInterface {lvalue},float)



    SI.GetMaxDepth
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetMaxDepth( (SubInterfaceClass)arg1) -> float :

    C++ signature :
        float GetMaxDepth(class scriptinterface::tcSubInterface {lvalue})



    SI.GoToPeriscopeDepth
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GoToPeriscopeDepth( (SubInterfaceClass)arg1) -> None :

    C++ signature :
        void GoToPeriscopeDepth(class scriptinterface::tcSubInterface {lvalue})



    SI.IsAtPeriscopeDepth
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsAtPeriscopeDepth( (SubInterfaceClass)arg1) -> bool :

    C++ signature :
        bool IsAtPeriscopeDepth(class scriptinterface::tcSubInterface {lvalue})



    SI.IsDieselElectric
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsDieselElectric( (SubInterfaceClass)arg1) -> bool :

    C++ signature :
        bool IsDieselElectric(class scriptinterface::tcSubInterface {lvalue})



    SI.IsPeriscopeRaised
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsPeriscopeRaised( (SubInterfaceClass)arg1) -> bool :

    C++ signature :
        bool IsPeriscopeRaised(class scriptinterface::tcSubInterface {lvalue})



    SI.IsRadarMastRaised
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsRadarMastRaised( (SubInterfaceClass)arg1) -> bool :

    C++ signature :
        bool IsRadarMastRaised(class scriptinterface::tcSubInterface {lvalue})



    SI.IsSnorkeling
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsSnorkeling( (SubInterfaceClass)arg1) -> bool :

    C++ signature :
        bool IsSnorkeling(class scriptinterface::tcSubInterface {lvalue})



    SI.IsValid
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsValid( (SubInterfaceClass)arg1) -> bool :

    C++ signature :
        bool IsValid(class scriptinterface::tcSubInterface {lvalue})



    SI.LowerPeriscope
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
LowerPeriscope( (SubInterfaceClass)arg1) -> None :

    C++ signature :
        void LowerPeriscope(class scriptinterface::tcSubInterface {lvalue})



    SI.LowerRadarMast
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
LowerRadarMast( (SubInterfaceClass)arg1) -> None :

    C++ signature :
        void LowerRadarMast(class scriptinterface::tcSubInterface {lvalue})



    SI.RaisePeriscope
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
RaisePeriscope( (SubInterfaceClass)arg1) -> None :

    C++ signature :
        void RaisePeriscope(class scriptinterface::tcSubInterface {lvalue})



    SI.RaiseRadarMast
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
RaiseRadarMast( (SubInterfaceClass)arg1) -> None :

    C++ signature :
        void RaiseRadarMast(class scriptinterface::tcSubInterface {lvalue})



    SI.SetSnorkelState
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetSnorkelState( (SubInterfaceClass)arg1, (bool)arg2) -> None :

    C++ signature :
        void SetSnorkelState(class scriptinterface::tcSubInterface {lvalue},bool)



################
##            ##
##  Launcher  ##
##            ##
################
    launcher.AcceptsWaypoints
    type: <type 'bool'>
    callable?: False
    doc string: bool(x) -> bool

Returns True when the argument x is true, False otherwise.
The builtins True and False are the only two instances of the class bool.
The class bool is a subclass of the class int, and cannot be subclassed.



    launcher.FireControlTracks
    type: <type 'int'>
    callable?: False
    doc string: int(x[, base]) -> integer





    launcher.IsLoading
    type: <type 'bool'>
    callable?: False
    doc string: bool(x) -> bool

Returns True when the argument x is true, False otherwise.
The builtins True and False are the only two instances of the class bool.
The class bool is a subclass of the class int, and cannot be subclassed.



    launcher.IsNuclear
    type: <type 'bool'>
    callable?: False
    doc string: bool(x) -> bool

Returns True when the argument x is true, False otherwise.
The builtins True and False are the only two instances of the class bool.
The class bool is a subclass of the class int, and cannot be subclassed.



    launcher.IsValid
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsValid( (LauncherInfo)arg1) -> bool :

    C++ signature :
        bool IsValid(class scriptinterface::tcLauncherInfo {lvalue})



    launcher.LaunchMode
    type: <type 'int'>
    callable?: False
    doc string: int(x[, base]) -> integer





    launcher.Launcher
    type: <type 'int'>
    callable?: False
    doc string: int(x[, base]) -> integer





    launcher.LifeTime_s
    type: <type 'float'>
    callable?: False
    doc string: float(x) -> floating point number

Convert a string or number to a floating point number, if possible.



    launcher.MaxDepth_m
    type: <type 'float'>
    callable?: False
    doc string: float(x) -> floating point number

Convert a string or number to a floating point number, if possible.



    launcher.MaxFireControlTracks
    type: <type 'int'>
    callable?: False
    doc string: int(x[, base]) -> integer





    launcher.MaxLaunchAlt_m
    type: <type 'float'>
    callable?: False
    doc string: float(x) -> floating point number

Convert a string or number to a floating point number, if possible.



    launcher.MaxRange_km
    type: <type 'float'>
    callable?: False
    doc string: float(x) -> floating point number

Convert a string or number to a floating point number, if possible.



    launcher.MinLaunchAlt_m
    type: <type 'float'>
    callable?: False
    doc string: float(x) -> floating point number

Convert a string or number to a floating point number, if possible.



    launcher.MinRange_km
    type: <type 'float'>
    callable?: False
    doc string: float(x) -> floating point number

Convert a string or number to a floating point number, if possible.



    launcher.Quantity
    type: <type 'int'>
    callable?: False
    doc string: int(x[, base]) -> integer





    launcher.Range_km
    type: <type 'float'>
    callable?: False
    doc string: float(x) -> floating point number

Convert a string or number to a floating point number, if possible.



    launcher.SectorCenter
    type: <type 'float'>
    callable?: False
    doc string: float(x) -> floating point number

Convert a string or number to a floating point number, if possible.



    launcher.SectorWidth
    type: <type 'float'>
    callable?: False
    doc string: float(x) -> floating point number

Convert a string or number to a floating point number, if possible.



    launcher.Speed_mps
    type: <type 'float'>
    callable?: False
    doc string: float(x) -> floating point number

Convert a string or number to a floating point number, if possible.



    launcher.Status
    type: <type 'int'>
    callable?: False
    doc string: int(x[, base]) -> integer





    launcher.TargetFlags
    type: <type 'int'>
    callable?: False
    doc string: int(x[, base]) -> integer





################
##            ##
##  Mission   ##
##            ##
################
    mission.GetAirborneAircraftCount
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetAirborneAircraftCount( (MissionInterface)arg1) -> int :

    C++ signature :
        unsigned int GetAirborneAircraftCount(class scriptinterface::tcMissionInterface {lvalue})



    mission.GetAirborneAircraftId
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetAirborneAircraftId( (MissionInterface)arg1, (int)arg2) -> int :

    C++ signature :
        long GetAirborneAircraftId(class scriptinterface::tcMissionInterface {lvalue},unsigned int)



    mission.GetLocalObj
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetLocalObj( (MissionInterface)arg1) -> None :

    C++ signature :
        void GetLocalObj(class scriptinterface::tcMissionInterface {lvalue})



    mission.GetMissionAircraftCount
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetMissionAircraftCount( (MissionInterface)arg1) -> int :

    C++ signature :
        unsigned int GetMissionAircraftCount(class scriptinterface::tcMissionInterface {lvalue})



    mission.GetSmallestWaypointIndex
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetSmallestWaypointIndex( (MissionInterface)arg1) -> int :

    C++ signature :
        unsigned int GetSmallestWaypointIndex(class scriptinterface::tcMissionInterface {lvalue})



    mission.IsValid
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsValid( (MissionInterface)arg1) -> bool :

    C++ signature :
        bool IsValid(class scriptinterface::tcMissionInterface {lvalue})



################
##            ##
##   Sensor   ##
##            ##
################
    sensor.IsPassive
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetAirborneAircraftCount( (MissionInterface)arg1) -> int :

    C++ signature :
        unsigned int GetAirborneAircraftCount(class scriptinterface::tcMissionInterface {lvalue})



    sensor.isActive
    type: <type 'method-wrapper'>
    callable?: True
    doc string: x.__setattr__('name', value) <==> x.name = value



    sensor.type
    type: <type 'builtin_function_or_method'>
    callable?: True
    doc string: __sizeof__() -> int
size of object in memory, in bytes



################
##            ##
##   Track    ##
##            ##
################
    track.Affiliation
    type: <type 'int'>
    callable?: False
    doc string: int(x[, base]) -> integer





    track.Alt
    type: <type 'float'>
    callable?: False
    doc string: float(x) -> floating point number

Convert a string or number to a floating point number, if possible.



    track.BearingRate_radps
    type: <type 'float'>
    callable?: False
    doc string: float(x) -> floating point number

Convert a string or number to a floating point number, if possible.



    track.BearingToRad
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
BearingToRad( (tcSMTrack)arg1, (float)arg2, (float)arg3) -> float :

    C++ signature :
        float BearingToRad(class tcSensorMapTrack {lvalue},float,float)



    track.Bearing_rad
    type: <type 'float'>
    callable?: False
    doc string: float(x) -> floating point number

Convert a string or number to a floating point number, if possible.



    track.Classification
    type: <type 'int'>
    callable?: False
    doc string: int(x[, base]) -> integer





    track.Flags
    type: <type 'int'>
    callable?: False
    doc string: int(x[, base]) -> integer





    track.GetEngagedCount
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetEngagedCount( (tcSMTrack)arg1) -> int :

    C++ signature :
        unsigned int GetEngagedCount(class tcSensorMapTrack {lvalue})



    track.GetTrackLife
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetTrackLife( (tcSMTrack)arg1) -> float :

    C++ signature :
        float GetTrackLife(class tcSensorMapTrack {lvalue})



    track.Heading_rad
    type: <type 'float'>
    callable?: False
    doc string: float(x) -> floating point number

Convert a string or number to a floating point number, if possible.



    track.ID
    type: <type 'int'>
    callable?: False
    doc string: int(x[, base]) -> integer





    track.IsAir
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsAir( (tcSMTrack)arg1) -> bool :

    C++ signature :
        bool IsAir(class tcSensorMapTrack {lvalue})



    track.IsBearingOnly
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsBearingOnly( (tcSMTrack)arg1) -> bool :

    C++ signature :
        bool IsBearingOnly(class tcSensorMapTrack {lvalue})



    track.IsBearingRateValid
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsBearingRateValid( (tcSMTrack)arg1) -> bool :

    C++ signature :
        bool IsBearingRateValid(class tcSensorMapTrack {lvalue})



    track.IsDestroyed
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsDestroyed( (tcSMTrack)arg1) -> bool :

    C++ signature :
        bool IsDestroyed(class tcSensorMapTrack {lvalue})



    track.IsGround
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsGround( (tcSMTrack)arg1) -> bool :

    C++ signature :
        bool IsGround(class tcSensorMapTrack {lvalue})



    track.IsMissile
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsMissile( (tcSMTrack)arg1) -> bool :

    C++ signature :
        bool IsMissile(class tcSensorMapTrack {lvalue})



    track.IsStale
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsStale( (tcSMTrack)arg1) -> bool :

    C++ signature :
        bool IsStale(class tcSensorMapTrack {lvalue})



    track.IsSub
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsSub( (tcSMTrack)arg1) -> bool :

    C++ signature :
        bool IsSub(class tcSensorMapTrack {lvalue})



    track.IsSurface
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsSurface( (tcSMTrack)arg1) -> bool :

    C++ signature :
        bool IsSurface(class tcSensorMapTrack {lvalue})



    track.IsTorpedo
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsTorpedo( (tcSMTrack)arg1) -> bool :

    C++ signature :
        bool IsTorpedo(class tcSensorMapTrack {lvalue})



    track.IsValid
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsValid( (tcSMTrack)arg1) -> bool :

    C++ signature :
        bool IsValid(class tcSensorMapTrack {lvalue})



    track.Lat
    type: <type 'float'>
    callable?: False
    doc string: float(x) -> floating point number

Convert a string or number to a floating point number, if possible.



    track.Lon
    type: <type 'float'>
    callable?: False
    doc string: float(x) -> floating point number

Convert a string or number to a floating point number, if possible.



    track.Offset
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
Offset( (tcSMTrack)arg1, (float)arg2, (float)arg3) -> None :

    C++ signature :
        void Offset(class tcSensorMapTrack {lvalue},float,float)



    track.PredictAhead
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
PredictAhead( (tcSMTrack)arg1, (float)arg2) -> tcTrack :

    C++ signature :
        class tcTrack PredictAhead(class tcSensorMapTrack {lvalue},float)



    track.RangeToKm
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
RangeToKm( (tcSMTrack)arg1, (float)arg2, (float)arg3) -> float :

    C++ signature :
        float RangeToKm(class tcSensorMapTrack {lvalue},float,float)



    track.Speed
    type: <type 'float'>
    callable?: False
    doc string: float(x) -> floating point number

Convert a string or number to a floating point number, if possible.



    track.Time
    type: <type 'float'>
    callable?: False
    doc string: float(x) -> floating point number

Convert a string or number to a floating point number, if possible.



    track.TrackErrorKm
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
TrackErrorKm( (tcSMTrack)arg1) -> float :

    C++ signature :
        float TrackErrorKm(class tcSensorMapTrack {lvalue})



################
##            ##
##   Status   ##
##            ##
################
    status.atDestination
    type: <type 'bool'>
    callable?: False
    doc string: bool(x) -> bool

Returns True when the argument x is true, False otherwise.
The builtins True and False are the only two instances of the class bool.
The class bool is a subclass of the class int, and cannot be subclassed.



    status.current_loc
    type: <type 'str'>
    callable?: False
    doc string: str(object) -> string

Return a nice string representation of the object.
If the argument is a string, the return value is the same object.



    status.goal_loc
    type: <type 'str'>
    callable?: False
    doc string: str(object) -> string

Return a nice string representation of the object.
If the argument is a string, the return value is the same object.



    status.isIdle
    type: <type 'bool'>
    callable?: False
    doc string: bool(x) -> bool

Returns True when the argument x is true, False otherwise.
The builtins True and False are the only two instances of the class bool.
The class bool is a subclass of the class int, and cannot be subclassed.



    status.name
    type: <type 'str'>
    callable?: False
    doc string: str(object) -> string

Return a nice string representation of the object.
If the argument is a string, the return value is the same object.



    status.ready_time
    type: <type 'float'>
    callable?: False
    doc string: float(x) -> floating point number

Convert a string or number to a floating point number, if possible.



    status.runway
    type: <type 'int'>
    callable?: False
    doc string: int(x[, base]) -> integer



################
##            ##
##     UM     ##
##            ##
################
    UM.AddItem
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
AddItem( (MenuInterfaceClass)arg1, (str)arg2, (str)arg3) -> None :

    C++ signature :
        void AddItem(class scriptinterface::tcMenuInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    UM.AddItemUI
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
AddItemUI( (MenuInterfaceClass)arg1, (str)arg2, (str)arg3, (str)arg4) -> None :

    C++ signature :
        void AddItemUI(class scriptinterface::tcMenuInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    UM.AddItemUIWithParam
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
AddItemUIWithParam( (MenuInterfaceClass)arg1, (str)arg2, (str)arg3, (str)arg4, (int)arg5) -> None :

    C++ signature :
        void AddItemUIWithParam(class scriptinterface::tcMenuInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,int)



    UM.AddItemUIWithTextParam
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
AddItemUIWithTextParam( (MenuInterfaceClass)arg1, (str)arg2, (str)arg3, (str)arg4, (str)arg5) -> None :

    C++ signature :
        void AddItemUIWithTextParam(class scriptinterface::tcMenuInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    UM.AddItemWithParam
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
AddItemWithParam( (MenuInterfaceClass)arg1, (str)arg2, (str)arg3, (int)arg4) -> None :

    C++ signature :
        void AddItemWithParam(class scriptinterface::tcMenuInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,int)



    UM.AddItemWithTextParam
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
AddItemWithTextParam( (MenuInterfaceClass)arg1, (str)arg2, (str)arg3, (str)arg4) -> None :

    C++ signature :
        void AddItemWithTextParam(class scriptinterface::tcMenuInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    UM.BeginSubMenu
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
BeginSubMenu( (MenuInterfaceClass)arg1) -> None :

    C++ signature :
        void BeginSubMenu(class scriptinterface::tcMenuInterface {lvalue})



    UM.Clear
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
Clear( (MenuInterfaceClass)arg1) -> None :

    C++ signature :
        void Clear(class scriptinterface::tcMenuInterface {lvalue})



    UM.EndSubMenu
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
EndSubMenu( (MenuInterfaceClass)arg1) -> None :

    C++ signature :
        void EndSubMenu(class scriptinterface::tcMenuInterface {lvalue})



    UM.SetStayOpen
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetStayOpen( (MenuInterfaceClass)arg1, (bool)arg2) -> None :

    C++ signature :
        void SetStayOpen(class scriptinterface::tcMenuInterface {lvalue},bool)



################
##            ##
##     SM     ##
##            ##
################
    SM.AddChildGoalToId
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
AddChildGoalToId( (ScenarioInterface)arg1, (int)arg2, (Goal)arg3) -> None :

    C++ signature :
        void AddChildGoalToId(class scriptinterface::tcScenarioInterface {lvalue},unsigned long,class tcGoal {lvalue})



    SM.AddRandomBox
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
AddRandomBox( (ScenarioInterface)arg1, (str)arg2, (float)arg3, (float)arg4, (float)arg5, (float)arg6) -> None :

    C++ signature :
        void AddRandomBox(class scriptinterface::tcScenarioInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,float,float,float,float)



    SM.AddToUnitMagazine
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
AddToUnitMagazine( (ScenarioInterface)arg1, (str)arg2, (str)arg3, (int)arg4) -> None :

    C++ signature :
        void AddToUnitMagazine(class scriptinterface::tcScenarioInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,unsigned long)



    SM.AddUnitTask
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
AddUnitTask( (ScenarioInterface)arg1, (str)arg2, (str)arg3, (float)arg4, (int)arg5) -> None :

    C++ signature :
        void AddUnitTask(class scriptinterface::tcScenarioInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,double,int)



    SM.AddUnitToAlliance
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
AddUnitToAlliance( (ScenarioInterface)arg1, (ScenarioUnit)arg2, (int)arg3) -> bool :

    C++ signature :
        bool AddUnitToAlliance(class scriptinterface::tcScenarioInterface {lvalue},class scriptinterface::tcScenarioUnit,int)



    SM.AddUnitToFlightDeck
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
AddUnitToFlightDeck( (ScenarioInterface)arg1, (str)arg2, (str)arg3, (str)arg4, (int)arg5) -> bool :

    C++ signature :
        bool AddUnitToFlightDeck(class scriptinterface::tcScenarioInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,int)



    SM.AllianceExists
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
AllianceExists( (ScenarioInterface)arg1, (int)arg2) -> bool :

    C++ signature :
        bool AllianceExists(class scriptinterface::tcScenarioInterface {lvalue},int)



    SM.AreaGoal
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
AreaGoal( (ScenarioInterface)arg1) -> AreaGoal :

    C++ signature :
        class tcAreaGoal AreaGoal(class scriptinterface::tcScenarioInterface {lvalue})



    SM.ChangeMapTheater
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
ChangeMapTheater( (ScenarioInterface)arg1, (float)arg2, (float)arg3) -> None :

    C++ signature :
        void ChangeMapTheater(class scriptinterface::tcScenarioInterface {lvalue},double,double)



    SM.ChangeMapView
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
ChangeMapView( (ScenarioInterface)arg1, (float)arg2, (float)arg3, (float)arg4) -> None :

    C++ signature :
        void ChangeMapView(class scriptinterface::tcScenarioInterface {lvalue},double,double,double)



    SM.ChangeWorldMapView
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
ChangeWorldMapView( (ScenarioInterface)arg1, (float)arg2, (float)arg3, (float)arg4) -> None :

    C++ signature :
        void ChangeWorldMapView(class scriptinterface::tcScenarioInterface {lvalue},double,double,double)



    SM.ChannelMessage
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
ChannelMessage( (ScenarioInterface)arg1, (str)arg2, (str)arg3, (int)arg4) -> None :

    C++ signature :
        void ChannelMessage(class scriptinterface::tcScenarioInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,unsigned int)



    SM.ClearEvents
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
ClearEvents( (ScenarioInterface)arg1) -> None :

    C++ signature :
        void ClearEvents(class scriptinterface::tcScenarioInterface {lvalue})



    SM.CompoundGoal
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
CompoundGoal( (ScenarioInterface)arg1, (int)arg2) -> CompoundGoal :

    C++ signature :
        class tcCompoundGoal CompoundGoal(class scriptinterface::tcScenarioInterface {lvalue},int)



    SM.ConsoleText
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
ConsoleText( (ScenarioInterface)arg1, (str)arg2) -> None :

    C++ signature :
        void ConsoleText(class scriptinterface::tcScenarioInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    SM.CreateAlliance
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
CreateAlliance( (ScenarioInterface)arg1, (int)arg2, (str)arg3) -> None :

    C++ signature :
        void CreateAlliance(class scriptinterface::tcScenarioInterface {lvalue},int,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    SM.DeleteGoalById
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
DeleteGoalById( (ScenarioInterface)arg1, (int)arg2) -> None :

    C++ signature :
        void DeleteGoalById(class scriptinterface::tcScenarioInterface {lvalue},unsigned long)



    SM.DestroyGoal
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
DestroyGoal( (ScenarioInterface)arg1, (str)arg2) -> DestroyGoal :

    C++ signature :
        class tcDestroyGoal DestroyGoal(class scriptinterface::tcScenarioInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    SM.DuplicateUnitTasking
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
DuplicateUnitTasking( (ScenarioInterface)arg1, (str)arg2, (str)arg3) -> None :

    C++ signature :
        void DuplicateUnitTasking(class scriptinterface::tcScenarioInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    SM.FlybyCamera
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
FlybyCamera( (ScenarioInterface)arg1, (str)arg2, (float)arg3, (float)arg4, (float)arg5, (float)arg6, (float)arg7, (float)arg8, (float)arg9) -> None :

    C++ signature :
        void FlybyCamera(class scriptinterface::tcScenarioInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,double,float,float,float,float,float,float)



    SM.GetAirGroupCount
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetAirGroupCount( (ScenarioInterface)arg1) -> int :

    C++ signature :
        unsigned int GetAirGroupCount(class scriptinterface::tcScenarioInterface {lvalue})



    SM.GetAirGroupName
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetAirGroupName( (ScenarioInterface)arg1) -> str :

    C++ signature :
        class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > GetAirGroupName(class scriptinterface::tcScenarioInterface {lvalue})



    SM.GetAirUnitId
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetAirUnitId( (ScenarioInterface)arg1) -> int :

    C++ signature :
        unsigned int GetAirUnitId(class scriptinterface::tcScenarioInterface {lvalue})



    SM.GetAllianceCountry
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetAllianceCountry( (ScenarioInterface)arg1, (int)arg2) -> str :

    C++ signature :
        class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > GetAllianceCountry(class scriptinterface::tcScenarioInterface {lvalue},int)



    SM.GetAllianceGoal
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetAllianceGoal( (ScenarioInterface)arg1, (int)arg2) -> GoalWrap :

    C++ signature :
        class tcGoalWrap GetAllianceGoal(class scriptinterface::tcScenarioInterface {lvalue},int)



    SM.GetAllianceROE
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetAllianceROE( (ScenarioInterface)arg1, (int)arg2) -> AllianceROEInfo :

    C++ signature :
        class scriptinterface::tcAllianceROEInfo GetAllianceROE(class scriptinterface::tcScenarioInterface {lvalue},int)



    SM.GetDefaultUnit
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetDefaultUnit( (ScenarioInterface)arg1) -> ScenarioUnit :

    C++ signature :
        class scriptinterface::tcScenarioUnit GetDefaultUnit(class scriptinterface::tcScenarioInterface {lvalue})



    SM.GetDisplayName
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetDisplayName( (ScenarioInterface)arg1, (str)arg2) -> str :

    C++ signature :
        class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > GetDisplayName(class scriptinterface::tcScenarioInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    SM.GetFilterByCountry
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetFilterByCountry( (ScenarioInterface)arg1) -> bool :

    C++ signature :
        bool GetFilterByCountry(class scriptinterface::tcScenarioInterface {lvalue})



    SM.GetFilterByYear
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetFilterByYear( (ScenarioInterface)arg1) -> bool :

    C++ signature :
        bool GetFilterByYear(class scriptinterface::tcScenarioInterface {lvalue})



    SM.GetGoalById
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetGoalById( (ScenarioInterface)arg1, (int)arg2) -> GoalWrap :

    C++ signature :
        class tcGoalWrap GetGoalById(class scriptinterface::tcScenarioInterface {lvalue},unsigned long)



    SM.GetMagazineAddCount
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetMagazineAddCount( (ScenarioInterface)arg1) -> int :

    C++ signature :
        unsigned int GetMagazineAddCount(class scriptinterface::tcScenarioInterface {lvalue})



    SM.GetNumberSonarTemplates
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetNumberSonarTemplates( (ScenarioInterface)arg1) -> int :

    C++ signature :
        unsigned int GetNumberSonarTemplates(class scriptinterface::tcScenarioInterface {lvalue})



    SM.GetParsedUnitName
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetParsedUnitName( (ScenarioInterface)arg1, (str)arg2) -> ParsedUnitName :

    C++ signature :
        class scriptinterface::tcParsedUnitName GetParsedUnitName(class scriptinterface::tcScenarioInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    SM.GetPlatformListByClass
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetPlatformListByClass( (ScenarioInterface)arg1, (str)arg2) -> StringArray :

    C++ signature :
        class scriptinterface::tcStringArray GetPlatformListByClass(class scriptinterface::tcScenarioInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    SM.GetRandomDatum
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetRandomDatum( (ScenarioInterface)arg1, (float)arg2, (float)arg3, (float)arg4, (float)arg5, (float)arg6) -> Datum :

    C++ signature :
        class scriptinterface::tcDatum GetRandomDatum(class scriptinterface::tcScenarioInterface {lvalue},double,double,float,float,float)



    SM.GetRandomPlatformName
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetRandomPlatformName( (ScenarioInterface)arg1, (str)arg2, (str)arg3) -> str :

    C++ signature :
        class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > GetRandomPlatformName(class scriptinterface::tcScenarioInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    SM.GetSeaState
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetSeaState( (ScenarioInterface)arg1) -> int :

    C++ signature :
        unsigned int GetSeaState(class scriptinterface::tcScenarioInterface {lvalue})



    SM.GetSonarTemplate
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetSonarTemplate( (ScenarioInterface)arg1) -> int :

    C++ signature :
        int GetSonarTemplate(class scriptinterface::tcScenarioInterface {lvalue})



    SM.GetTemplateName
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetTemplateName( (ScenarioInterface)arg1, (int)arg2) -> str :

    C++ signature :
        class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > GetTemplateName(class scriptinterface::tcScenarioInterface {lvalue},unsigned int)



    SM.GetUnitIdByName
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetUnitIdByName( (ScenarioInterface)arg1, (str)arg2) -> int :

    C++ signature :
        long GetUnitIdByName(class scriptinterface::tcScenarioInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    SM.GetUnitInterface
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetUnitInterface( (ScenarioInterface)arg1, (str)arg2) -> UnitInfoClass :

    C++ signature :
        class scriptinterface::tcPlatformInterface GetUnitInterface(class scriptinterface::tcScenarioInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    SM.GetUnitList
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetUnitList( (ScenarioInterface)arg1, (float)arg2, (float)arg3, (float)arg4, (float)arg5, (int)arg6) -> StringArray :

    C++ signature :
        class scriptinterface::tcStringArray GetUnitList(class scriptinterface::tcScenarioInterface {lvalue},float,float,float,float,int)



    SM.GetUnitNameById
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetUnitNameById( (ScenarioInterface)arg1, (int)arg2) -> str :

    C++ signature :
        class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > GetUnitNameById(class scriptinterface::tcScenarioInterface {lvalue},long)



    SM.GetUserAlliance
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
GetUserAlliance( (ScenarioInterface)arg1) -> int :

    C++ signature :
        int GetUserAlliance(class scriptinterface::tcScenarioInterface {lvalue})



    SM.HookPlatform
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
HookPlatform( (ScenarioInterface)arg1, (str)arg2) -> None :

    C++ signature :
        void HookPlatform(class scriptinterface::tcScenarioInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    SM.IncludeUnit
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IncludeUnit( (ScenarioInterface)arg1, (float)arg2) -> bool :

    C++ signature :
        bool IncludeUnit(class scriptinterface::tcScenarioInterface {lvalue},float)



    SM.IsAlliancePlayable
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsAlliancePlayable( (ScenarioInterface)arg1, (int)arg2) -> bool :

    C++ signature :
        bool IsAlliancePlayable(class scriptinterface::tcScenarioInterface {lvalue},int)



    SM.IsUsingNATONames
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
IsUsingNATONames( (ScenarioInterface)arg1) -> bool :

    C++ signature :
        bool IsUsingNATONames(class scriptinterface::tcScenarioInterface {lvalue})



    SM.LoadDatabaseMod
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
LoadDatabaseMod( (ScenarioInterface)arg1, (str)arg2) -> None :

    C++ signature :
        void LoadDatabaseMod(class scriptinterface::tcScenarioInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    SM.MapText
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
MapText( (ScenarioInterface)arg1, (str)arg2, (float)arg3, (float)arg4, (float)arg5, (int)arg6) -> None :

    C++ signature :
        void MapText(class scriptinterface::tcScenarioInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,double,double,double,int)



    SM.OverlayText
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
OverlayText( (ScenarioInterface)arg1, (str)arg2, (float)arg3, (float)arg4, (str)arg5) -> None :

    C++ signature :
        void OverlayText(class scriptinterface::tcScenarioInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,double,double,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    SM.OverlayTextInteractive
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
OverlayTextInteractive( (ScenarioInterface)arg1, (str)arg2, (float)arg3, (float)arg4) -> None :

    C++ signature :
        void OverlayTextInteractive(class scriptinterface::tcScenarioInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,double,double)



    SM.Pause
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
Pause( (ScenarioInterface)arg1) -> None :

    C++ signature :
        void Pause(class scriptinterface::tcScenarioInterface {lvalue})



    SM.PauseAudio
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
PauseAudio( (ScenarioInterface)arg1) -> None :

    C++ signature :
        void PauseAudio(class scriptinterface::tcScenarioInterface {lvalue})



    SM.PlayAudio
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
PlayAudio( (ScenarioInterface)arg1, (str)arg2, (float)arg3) -> None :

    C++ signature :
        void PlayAudio(class scriptinterface::tcScenarioInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,double)



    SM.PlayEffect
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
PlayEffect( (ScenarioInterface)arg1, (str)arg2) -> None :

    C++ signature :
        void PlayEffect(class scriptinterface::tcScenarioInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    SM.ProtectGoal
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
ProtectGoal( (ScenarioInterface)arg1, (str)arg2) -> ProtectGoal :

    C++ signature :
        class tcProtectGoal ProtectGoal(class scriptinterface::tcScenarioInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    SM.RestoreDefaultDatabase
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
RestoreDefaultDatabase( (ScenarioInterface)arg1) -> None :

    C++ signature :
        void RestoreDefaultDatabase(class scriptinterface::tcScenarioInterface {lvalue})



    SM.Resume
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
Resume( (ScenarioInterface)arg1) -> None :

    C++ signature :
        void Resume(class scriptinterface::tcScenarioInterface {lvalue})



    SM.SaveGame
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SaveGame( (ScenarioInterface)arg1, (str)arg2) -> None :

    C++ signature :
        void SaveGame(class scriptinterface::tcScenarioInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    SM.SeekAudio
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SeekAudio( (ScenarioInterface)arg1, (float)arg2) -> None :

    C++ signature :
        void SeekAudio(class scriptinterface::tcScenarioInterface {lvalue},double)



    SM.SendCommand
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SendCommand( (ScenarioInterface)arg1, (str)arg2) -> None :

    C++ signature :
        void SendCommand(class scriptinterface::tcScenarioInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    SM.Set3DMode
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
Set3DMode( (ScenarioInterface)arg1, (int)arg2) -> None :

    C++ signature :
        void Set3DMode(class scriptinterface::tcScenarioInterface {lvalue},int)



    SM.SetAirGroupCount
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetAirGroupCount( (ScenarioInterface)arg1, (int)arg2) -> None :

    C++ signature :
        void SetAirGroupCount(class scriptinterface::tcScenarioInterface {lvalue},unsigned int)



    SM.SetAirGroupName
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetAirGroupName( (ScenarioInterface)arg1, (str)arg2) -> None :

    C++ signature :
        void SetAirGroupName(class scriptinterface::tcScenarioInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    SM.SetAllianceDefaultCountry
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetAllianceDefaultCountry( (ScenarioInterface)arg1, (int)arg2, (str)arg3) -> None :

    C++ signature :
        void SetAllianceDefaultCountry(class scriptinterface::tcScenarioInterface {lvalue},int,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    SM.SetAllianceGoal
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetAllianceGoal( (ScenarioInterface)arg1, (int)arg2, (Goal)arg3) -> None :

    C++ signature :
        void SetAllianceGoal(class scriptinterface::tcScenarioInterface {lvalue},int,class tcGoal {lvalue})



    SM.SetAlliancePlayable
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetAlliancePlayable( (ScenarioInterface)arg1, (int)arg2, (bool)arg3) -> None :

    C++ signature :
        void SetAlliancePlayable(class scriptinterface::tcScenarioInterface {lvalue},int,bool)



    SM.SetAllianceROE
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetAllianceROE( (ScenarioInterface)arg1, (int)arg2, (int)arg3) -> None :

    C++ signature :
        void SetAllianceROE(class scriptinterface::tcScenarioInterface {lvalue},int,int)



    SM.SetAllianceROEByType
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetAllianceROEByType( (ScenarioInterface)arg1, (int)arg2, (int)arg3, (int)arg4, (int)arg5, (int)arg6) -> None :

    C++ signature :
        void SetAllianceROEByType(class scriptinterface::tcScenarioInterface {lvalue},int,int,int,int,int)



    SM.SetAllianceRelationship
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetAllianceRelationship( (ScenarioInterface)arg1, (int)arg2, (int)arg3, (str)arg4) -> None :

    C++ signature :
        void SetAllianceRelationship(class scriptinterface::tcScenarioInterface {lvalue},int,int,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    SM.SetBriefingMode
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetBriefingMode( (ScenarioInterface)arg1, (bool)arg2) -> None :

    C++ signature :
        void SetBriefingMode(class scriptinterface::tcScenarioInterface {lvalue},bool)



    SM.SetDateTime
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetDateTime( (ScenarioInterface)arg1, (int)arg2, (int)arg3, (int)arg4, (int)arg5, (int)arg6, (int)arg7) -> None :

    C++ signature :
        void SetDateTime(class scriptinterface::tcScenarioInterface {lvalue},int,int,int,int,int,int)



    SM.SetDateTimeByString
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetDateTimeByString( (ScenarioInterface)arg1, (str)arg2) -> None :

    C++ signature :
        void SetDateTimeByString(class scriptinterface::tcScenarioInterface {lvalue},char const *)



    SM.SetEventTime
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetEventTime( (ScenarioInterface)arg1, (float)arg2) -> None :

    C++ signature :
        void SetEventTime(class scriptinterface::tcScenarioInterface {lvalue},double)



    SM.SetFilterByCountry
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetFilterByCountry( (ScenarioInterface)arg1, (bool)arg2) -> None :

    C++ signature :
        void SetFilterByCountry(class scriptinterface::tcScenarioInterface {lvalue},bool)



    SM.SetFilterByYear
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetFilterByYear( (ScenarioInterface)arg1, (bool)arg2) -> None :

    C++ signature :
        void SetFilterByYear(class scriptinterface::tcScenarioInterface {lvalue},bool)



    SM.SetFlightDeckUnitLoadout
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetFlightDeckUnitLoadout( (ScenarioInterface)arg1, (str)arg2, (str)arg3, (str)arg4) -> None :

    C++ signature :
        void SetFlightDeckUnitLoadout(class scriptinterface::tcScenarioInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    SM.SetIncludeProbability
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetIncludeProbability( (ScenarioInterface)arg1, (str)arg2, (float)arg3) -> None :

    C++ signature :
        void SetIncludeProbability(class scriptinterface::tcScenarioInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,float)



    SM.SetMagazineAddCount
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetMagazineAddCount( (ScenarioInterface)arg1, (int)arg2) -> None :

    C++ signature :
        void SetMagazineAddCount(class scriptinterface::tcScenarioInterface {lvalue},unsigned int)



    SM.SetPerfectScore
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetPerfectScore( (ScenarioInterface)arg1, (float)arg2) -> None :

    C++ signature :
        void SetPerfectScore(class scriptinterface::tcScenarioInterface {lvalue},float)



    SM.SetSVP
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetSVP( (ScenarioInterface)arg1, (str)arg2) -> None :

    C++ signature :
        void SetSVP(class scriptinterface::tcScenarioInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    SM.SetScenarioDescription
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetScenarioDescription( (ScenarioInterface)arg1, (str)arg2) -> None :

    C++ signature :
        void SetScenarioDescription(class scriptinterface::tcScenarioInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    SM.SetScenarioLoaded
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetScenarioLoaded( (ScenarioInterface)arg1, (bool)arg2) -> None :

    C++ signature :
        void SetScenarioLoaded(class scriptinterface::tcScenarioInterface {lvalue},bool)



    SM.SetScenarioLocked
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetScenarioLocked( (ScenarioInterface)arg1, (bool)arg2) -> None :

    C++ signature :
        void SetScenarioLocked(class scriptinterface::tcScenarioInterface {lvalue},bool)



    SM.SetScenarioName
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetScenarioName( (ScenarioInterface)arg1, (str)arg2) -> None :

    C++ signature :
        void SetScenarioName(class scriptinterface::tcScenarioInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    SM.SetSeaState
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetSeaState( (ScenarioInterface)arg1, (int)arg2) -> None :

    C++ signature :
        void SetSeaState(class scriptinterface::tcScenarioInterface {lvalue},unsigned int)



    SM.SetSimpleBriefing
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetSimpleBriefing( (ScenarioInterface)arg1, (int)arg2, (str)arg3) -> None :

    C++ signature :
        void SetSimpleBriefing(class scriptinterface::tcScenarioInterface {lvalue},int,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)



    SM.SetSonarTemplate
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetSonarTemplate( (ScenarioInterface)arg1, (int)arg2) -> None :

    C++ signature :
        void SetSonarTemplate(class scriptinterface::tcScenarioInterface {lvalue},int)



    SM.SetStartTheater
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetStartTheater( (ScenarioInterface)arg1, (float)arg2, (float)arg3) -> None :

    C++ signature :
        void SetStartTheater(class scriptinterface::tcScenarioInterface {lvalue},double,double)



    SM.SetStartView
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetStartView( (ScenarioInterface)arg1, (float)arg2, (float)arg3, (float)arg4) -> None :

    C++ signature :
        void SetStartView(class scriptinterface::tcScenarioInterface {lvalue},double,double,double)



    SM.SetUnitAlwaysVisibleState
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetUnitAlwaysVisibleState( (ScenarioInterface)arg1, (str)arg2, (bool)arg3) -> None :

    C++ signature :
        void SetUnitAlwaysVisibleState(class scriptinterface::tcScenarioInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,bool)



    SM.SetUnitLauncherItem
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetUnitLauncherItem( (ScenarioInterface)arg1, (str)arg2, (int)arg3, (str)arg4, (int)arg5) -> None :

    C++ signature :
        void SetUnitLauncherItem(class scriptinterface::tcScenarioInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,unsigned int,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,unsigned int)



    SM.SetUserAlliance
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
SetUserAlliance( (ScenarioInterface)arg1, (int)arg2) -> None :

    C++ signature :
        void SetUserAlliance(class scriptinterface::tcScenarioInterface {lvalue},int)



    SM.Text3D
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
Text3D( (ScenarioInterface)arg1, (str)arg2, (float)arg3, (float)arg4, (float)arg5, (float)arg6, (int)arg7) -> None :

    C++ signature :
        void Text3D(class scriptinterface::tcScenarioInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,double,float,float,float,int)



    SM.TimeGoal
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
TimeGoal( (ScenarioInterface)arg1) -> TimeGoal :

    C++ signature :
        class tcTimeGoal TimeGoal(class scriptinterface::tcScenarioInterface {lvalue})



    SM.TrackCamera
    type: <type 'instancemethod'>
    callable?: True
    doc string: 
TrackCamera( (ScenarioInterface)arg1, (str)arg2, (float)arg3, (float)arg4, (float)arg5, (float)arg6, (float)arg7, (float)arg8, (float)arg9) -> None :

    C++ signature :
        void TrackCamera(class scriptinterface::tcScenarioInterface {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,double,float,float,float,float,float,float)