maniascript-reference/tmturbo/doc_8h_source.html

class Void {};

class Integer{};

class Real{};

class Boolean{};

class Text{};

class Vec2{};

class Vec3{};

class Int3{};

class Ident{};


struct CMlScript : public CNod {

    enum LinkType {

        ExternalBrowser,

        ManialinkBrowser,

        Goto,

        ExternalFromId,

        ManialinkFromId,

        GotoFromId,

    };

    enum ESystemPlatform {

        None,

        Steam,

        UPlay,

        PS4,

        XBoxOne,

    };

    enum ESystemSkuIdentifier {

        Unknown,

        EU,

        US,

        JP,

    };

    const   CMlPage Page;

    const   Boolean PageIsVisible;

    const   Integer Now;

    const   Integer Period;

    const   Integer CurrentTime;

    const   Text CurrentTimeText;

    const   Text CurrentLocalDateText;

    const   CUser LocalUser;

    const   CTitle LoadedTitle;

    const   ESystemPlatform SystemPlatform;

    const   ESystemSkuIdentifier SystemSkuIdentifier;

    const   CMlEvent[] PendingEvents;

            Void Dbg_SetProcessed(CMlEvent Event);

            Boolean Dbg_WarnOnDroppedEvents;

    const   Real MouseX;

    const   Real MouseY;

    const   Boolean MouseLeftButton;

    const   Boolean MouseRightButton;

    const   Boolean MouseMiddleButton;

    const   Boolean KeyUp;

    const   Boolean KeyDown;

    const   Boolean KeyLeft;

    const   Boolean KeyRight;

    const   Boolean KeyReturn;

    const   Boolean KeySpace;

    const   Boolean KeyDelete;

            Boolean IsKeyPressed(Integer KeyCode);

            Boolean EnableMenuNavigationInputs;

            Void EnableMenuNavigation(Boolean EnableInputs,Boolean WithAutoFocus,CMlControl AutoBackControl,Integer InputPriority);

    const   Boolean IsMenuNavigationForeground;

            Void OpenLink(Text Url,LinkType LinkType);

            Void TriggerPageAction(Text ActionString);

    const   CXmlManager Xml;

    const   CHttpManager Http;

    const   CVideoManager Video;

    const   CAudioManager Audio;

    const   CInputManager Input;

    const   CDataMgr DataMgr;

    const   CScoreMgr ScoreMgr;

    const   CPrivilegeMgr PrivilegeMgr;

    const   CPresenceMgr PresenceMgr;

    const   CGamePluginInterfacesScript Plugins;

            Void SendCustomEvent(Text Type,Text[] Data);

            Void PreloadImage(Text ImageUrl);

            Void PreloadAll();

            Text Dbg_DumpDeclareForVariables(CNod Nod,Boolean StatsOnly);

};


struct CMlEntry : public CMlControl {

    enum ETextFormat {

        Basic,

        Script,

        Password,

        Newpassword,

    };

            Text Value;

            Void StartEdition();

            ETextFormat TextFormat;

            Real Opacity;

            Vec3 TextColor;

            Real TextSizeReal;

            Integer MaxLine;

            Boolean AutoNewLine;

};


struct CMlFileEntry : public CMlEntry {

    const   Text FullFileName;

};


struct CMlTextEdit : public CMlControl {

    enum EControlScriptEditorTextFormat {

        Basic,

        Script,

        Password,

        Newpassword,

    };

            Text Value;

            Void StartEdition();

            Integer MaxLine;

            Boolean AutoNewLine;

            Boolean ShowLineNumbers;

            Real LineSpacing;

    const   Integer ValueLineCount;

            Real Opacity;

            Vec3 TextColor;

            Real TextSizeReal;

            EControlScriptEditorTextFormat TextFormat;

};


struct CMlLabel : public CMlControl {

    enum EBlendMode {

        Default,

        Add,

    };

            Text Style;

            Text Substyle;

            Text TextFont;

            Void SetText(Text NewText);

            Text Value;

    const   Integer ValueLineCount;

            Integer MaxLine;

            Real LineSpacing;

            Boolean AppendEllipsis;

            Boolean AutoNewLine;

            Real Opacity;

            Vec3 TextColor;

            Real TextSizeReal;

            EBlendMode Blend;

            Real ComputeWidth(Text Text);

            Real ComputeWidth(Text Text,Boolean Translated);

            Real ComputeHeight(Text Text);

};


struct CMlMediaPlayer : public CMlControl {

            Boolean IsInitPlay;

            Boolean Music;

            Boolean IsLooping;

            Real Volume;

            Text Url;

            Void Play();

            Void Stop();

            Void StopAndRewind();

};


struct CMlQuad : public CMlControl {

    enum EKeepRatioMode {

        Inactive,

        Clip,

        Fit,

    };

    enum EBlendMode {

        Default,

        Add,

    };

            Void ChangeImageUrl(Text fieldName);

            CImage Image;

            Text ImageUrl;

            Text ImageUrlFocus;

            Text Style;

            Text Substyle;

            Boolean StyleSelected;

    const   Boolean DownloadInProgress;

            Vec3 Colorize;

            Vec3 ModulateColor;

            Vec3 BgColor;

            Vec3 BgColorFocus;

            Real Opacity;

            EKeepRatioMode KeepRatio;

            EBlendMode Blend;

};


struct CMlGauge : public CMlControl {

            Text Style;

            Void SetRatio(Real NewRatio);

            Void SetClan(Integer NewClan);

            Real Ratio;

            Real GradingRatio;

            Integer Clan;

            Vec3 Color;

            Boolean DrawBackground;

            Boolean DrawBlockBackground;

            Boolean CenteredBar;

};


struct CMlGraph : public CMlControl {

            Vec2 CoordsMin;

            Vec2 CoordsMax;

            CMlGraphCurve AddCurve();

            Void RemoveCurve(CMlGraphCurve Curve);

            CMlGraphCurve[] Curves;

};


struct CMlMinimap : public CMlControl {

            Vec3 WorldPosition;

            Vec2 MapPosition;

            Real MapYaw;

            Real ZoomFactor;

            Boolean Underground;

            Void Fog_SetAll(Real Value);

            Void Fog_ClearDisk(Vec3 WorldCenter,Real Radius,Real FadeSize);

};


struct CMlCamera : public CMlControl {

};


struct CMlBrowser : public CMlScript {

    enum EBuddyAction {

        Add,

        Invite,

        Remove,

    };

    enum EBuddyResult {

        Ok,

        Error,

        NotFinished,

    };

    const   CMap CurMap;

            Void ShowCurMapCard();

    const   EBuddyResult BuddyDoResult;

    const   Text BuddyDoErrorMessage;

    const   CManiaAppBrowser ParentApp;

    const   Boolean IsInBrowser;

            Void BrowserBack();

            Void BrowserQuit();

            Void BrowserHome();

            Void BrowserReload();

            Text BrowserFocusedFrameId;

            Void SetLocalUserClubLink(Text ClubLink);

};


struct CManiaApp : public CNod {

    enum ELinkType {

        ExternalBrowser,

        ManialinkBrowser,

    };

    enum EAnimManagerEasing {

        Linear,

        QuadIn,

        QuadOut,

        QuadInOut,

        CubicIn,

        CubicOut,

        CubicInOut,

        QuartIn,

        QuartOut,

        QuartInOut,

        QuintIn,

        QuintOut,

        QuintInOut,

        SineIn,

        SineOut,

        SineInOut,

        ExpIn,

        ExpOut,

        ExpInOut,

        CircIn,

        CircOut,

        CircInOut,

        BackIn,

        BackOut,

        BackInOut,

        ElasticIn,

        ElasticOut,

        ElasticInOut,

        ElasticIn2,

        ElasticOut2,

        ElasticInOut2,

        BounceIn,

        BounceOut,

        BounceInOut,

    };

    enum ESystemPlatform {

        None,

        Steam,

        UPlay,

        PS4,

        XBoxOne,

    };

    enum ESystemSkuIdentifier {

        Unknown,

        EU,

        US,

        JP,

    };

    const   Integer Now;

    const   Boolean IsVisible;

    const   Integer CurrentDate;

    const   Text CurrentLocalDateText;

            Integer LayersDefaultManialinkVersion;

    const   CUser LocalUser;

    const   CTitle LoadedTitle;

    const   ESystemPlatform SystemPlatform;

    const   ESystemSkuIdentifier SystemSkuIdentifier;

            Boolean EnableMenuNavigationInputs;

    const   CUILayer[] UILayers;

            CUILayer UILayerCreate();

            Void UILayerDestroy(CUILayer Layer);

            Void UILayerDestroyAll();

            Void LayerCustomEvent(CUILayer Layer,Text Type,Text[] Data);

            Void OpenLink(Text Url,ELinkType LinkType);

    const   CXmlManager Xml;

    const   CHttpManager Http;

    const   CVideoManager Video;

    const   CAudioManager Audio;

    const   CInputManager Input;

    const   CDataMgr DataMgr;

    const   CScoreMgr ScoreMgr;

    const   CPrivilegeMgr PrivilegeMgr;

    const   CPresenceMgr PresenceMgr;

    const   CGameUserManagerScript UserMgr;

    const   CManiaPlanet ManiaPlanet;

    const   CGamePluginInterfacesScript Plugins;

            Text Dbg_DumpDeclareForVariables(CNod Nod,Boolean StatsOnly);

};


struct CManiaAppTitleLayer : public CMlScript {

            CManiaAppTitle ParentApp;

    const   CTitleFlow TitleFlow;

};


struct CManiaAppEvent : public CNod {

    enum EType {

        LayerCustomEvent,

        KeyPress,

        ExternalCustomEvent,

        MenuNavigation,

        ChildModuleEvent,

        ParentModuleEvent,

    };

    enum EMenuNavAction {

        Up,

        Right,

        Left,

        Down,

        Select,

        Cancel,

        PageUp,

        PageDown,

        AppMenu,

        Action1,

        Action2,

    };

    const   EType Type;

    const   CUILayer CustomEventLayer;

    const   Text CustomEventType;

    const   Text[] CustomEventData;

    const   Text ExternalEventType;

    const   Text[] ExternalEventData;

    const   CManiaApp ChildModuleEventModule;

    const   Text ChildModuleEventType;

    const   Text[] ChildModuleEventData;

    const   Text ParentModuleEventType;

    const   Text[] ParentModuleEventData;

    const   EMenuNavAction MenuNavAction;

    const   Boolean IsActionAutoRepeat;

    const   Integer KeyCode;

    const   Text KeyName;

};


struct CManiaAppTitle : public CManiaApp {

    const   CManiaAppEvent[] PendingEvents;

            Void Menu_Quit();

            Void Menu_Home();

            Void Menu_Solo();

            Void Menu_Competitions();

            Void Menu_Local();

            Void Menu_Internet();

            Void Menu_Editor();

            Void Menu_Profile();

            Void PlayMap(Text Map);

            Boolean LoadingScreenRequireKeyPressed;

            Boolean DontScaleMainMenuForHMD;

    const   CTitleFlow TitleFlow;

    const   CGameScriptNotificationsConsumer Notifications;

    const   Text ExternalRequest_Type;

    const   Text[] ExternalRequest_Data;

            Void ExternalRequest_Clear();

    const   CGameAchievementScriptManager AchievementsManager;

            CGameManagerBadgeScript BadgeManager;

};


struct CManiaAppPlayground : public CManiaAppPlaygroundCommon {

};


struct CGamePlaygroundModuleServer : public CNod {

            Void Hide();

            Void Hide(CPlayer Player);

            Void Show();

            Void Show(CPlayer Player);

            Boolean IsVisible(CPlayer Player);

};


struct CGamePlaygroundModuleServerInventory : public CGamePlaygroundModuleServer {

            Integer AddItem(CPlayer Player,Text ItemModelUrl,Integer Quantity);

            Integer RemoveItem(CPlayer Player,Text ItemModelUrl,Integer Quantity);

            Integer GetItemQuantity(CPlayer Player,Text ItemModelUrl);

            Boolean AddAction(CPlayer Player,Text ActionModelUrl);

            Boolean RemoveAction(CPlayer Player,Text ActionModelUrl);

            Boolean IsActionStored(CPlayer Player,Text ActionModelUrl);

};


struct CGamePlaygroundModuleServerStore : public CGamePlaygroundModuleServer {

            Void Reset();

            Void SetMoney(CPlayer Player,Integer Amount);

            Integer GetMoney(CPlayer Player);

            Boolean AddMoney(CPlayer Player,Integer Amount);

            Boolean SubMoney(CPlayer Player,Integer Amount);

            Void SetActionLevel(CPlayer Player,Text ActionUrl,Integer ActionLevel);

            Integer GetActionLevel(CPlayer Player,Text ActionUrl);

};


struct CStation : public CNod {

    const   CTitle Title;

    const   Integer AudienceRegisteredUsers;

    const   Integer CampaignMedalsMax;

    const   Integer CampaignMedalsCurrent;

    const   Integer CampaignMedalsRanking;

    const   Real LadderPoints;

    const   Integer LadderRank;

};


struct CMlStation : public CMlBrowser {

    const   CStation Station;

            Void EnterStation();

};


struct CEditorPlugin : public CManiaApp {

    enum CardinalDirections {

        North,

        East,

        South,

        West,

    };

    enum PlaceMode {

        Unknown,

        Terraform,

        Block,

        Macroblock,

        Skin,

        CopyPaste,

        Test,

        Plugin,

        CustomSelection,

        OffZone,

        BlockProperty,

        Path,

        GhostBlock,

        Item,

    };

    enum EditMode {

        Unknown,

        Place,

        FreeLook,

        Erase,

        Pick,

        SelectionAdd,

        SelectionRemove,

    };

    enum ShadowsQuality {

        NotComputed,

        VeryFast,

        Fast,

        Default,

        High,

        Ultra,

    };

    enum ValidationStatus {

        NotValidable,

        Validable,

        Validated,

    };

    enum EditorStatus {

        Running,

        ChallengeType,

        Objectives,

        ToPlayground,

        ChangeEditor,

        Save,

        SaveSameId,

        ToPlaygroundRecordPath,

        QuickSave,

        QuickLoad,

        EditToolsMenu,

        Quit,

        QuickQuit,

        ReplayRemoveAllKeys,

        ReplaySave,

        ReplayQuit,

        ToAnim,

        ToItem,

        ToEditor,

        ToLayer,

        EditSequences,

        QuickEditInGameClipGroup,

        ComputeShadows,

        ComputeShadowsFromScript,

        ShootVideo,

        ShootScreen,

        Preview,

        EditBlock,

        EditBlockQuit,

        AdditionalToolsMenu,

        RecordGhost,

        SaveMacroblock,

        EditCameraEffectScript,

        SaveFromScript,

        CreatePluginScript,

        EditPluginScript,

        EditMapTypeScript,

        ReloadMapTypeScript,

        EditClipConfigScript,

        ChooseMapType,

        ClipExport,

        ChooseBlockSkin,

        Count,

    };

    const   CEditorPluginEvent[] PendingEvents;

    const   CMap Map;

    const   Text MapName;

    const   Boolean IsEditorReadyForRequest;

            Boolean HoldLoadingScreen;

            Void ComputeShadows();

            Void ComputeShadows(ShadowsQuality ShadowsQuality);

    const   ShadowsQuality CurrentShadowsQuality;

    const   Boolean IsUltraShadowsQualityAvailable;

            Void Undo();

            Void Redo();

            Void Help();

            Void Validate();

            Void AutoSave();

            Void Quit();

            Void QuickQuit();

            Void QuitAndSetResult(Text Type,Text[] Data);

            Void QuickQuitAndSetResult(Text Type,Text[] Data);

            Void TestMapFromStart();

            Void TestMapFromCoord(Int3 Coord,CardinalDirections Dir);

            Void TestMapFromCoordWithMapTypeScript(Int3 Coord,CardinalDirections Dir);

            Void TestMapWithMode(Text RulesModeName);

            Void SaveMap(Text FileName);

            Void SaveMap(Text FileName,Text Path);

            PlaceMode PlaceMode;

            EditMode EditMode;

            Boolean UndergroundMode;

            Boolean BlockStockMode;

            Int3 CursorCoord;

            CardinalDirections CursorDir;

            CBlockModel CursorBlockModel;

            CBlockModel CursorTerrainBlockModel;

            CMacroblockModel CursorMacroblockModel;

            Real CameraVAngle;

            Real CameraHAngle;

            Real CameraToTargetDistance;

            Vec3 CameraTargetPosition;

    const   Vec3 CameraPosition;

            Real ThumbnailCameraVAngle;

            Real ThumbnailCameraHAngle;

            Real ThumbnailCameraRoll;

            Real ThumbnailCameraFovY;

            Vec3 ThumbnailCameraPosition;

            Boolean GetRaceCamera(Vec3 Position,Real Yaw,Real Pitch,Real Roll,Real FovY);

            Boolean EnableAirMapping;

            Boolean EnableMixMapping;

            Void RemoveAllBlocks();

            Void RemoveAllTerrain();

            Void RemoveAllOffZone();

            Void RemoveAllObjects();

            Void RemoveAll();

            Void RemoveAllBlocksAndTerrain();

            Void ShowCustomSelection();

            Void HideCustomSelection();

            Void CopyPaste_Copy();

            Void CopyPaste_Cut();

            Void CopyPaste_Remove();

            Void CopyPaste_SelectAll();

            Void CopyPaste_ResetSelection();

            Void OpenToolsMenu();

            Void EditMediatrackIngame();

            Void PreloadAllBlocks();

            Void PreloadAllItems();

            Boolean CanPlaceBlock(CBlockModel BlockModel,Int3 Coord,CardinalDirections Dir,Boolean OnGround,Integer VariantIndex);

            Boolean PlaceBlock(CBlockModel BlockModel,Int3 Coord,CardinalDirections Dir);

            Boolean CanPlaceBlock_NoDestruction(CBlockModel BlockModel,Int3 Coord,CardinalDirections Dir,Boolean OnGround,Integer VariantIndex);

            Boolean PlaceBlock_NoDestruction(CBlockModel BlockModel,Int3 Coord,CardinalDirections Dir);

            Boolean CanPlaceRoadBlocks(CBlockModel BlockModel,Int3 StartCoord,Int3 EndCoord);

            Boolean PlaceRoadBlocks(CBlockModel BlockModel,Int3 StartCoord,Int3 EndCoord);

            Boolean CanPlaceTerrainBlocks(CBlockModel BlockModel,Int3 StartCoord,Int3 EndCoord);

            Boolean PlaceTerrainBlocks(CBlockModel BlockModel,Int3 StartCoord,Int3 EndCoord);

            Boolean PlaceTerrainBlocks_NoDestruction(CBlockModel BlockModel,Int3 StartCoord,Int3 EndCoord);

            Boolean CanPlaceMacroblock(CMacroblockModel MacroblockModel,Int3 Coord,CardinalDirections Dir);

            Boolean PlaceMacroblock(CMacroblockModel MacroblockModel,Int3 Coord,CardinalDirections Dir);

            Boolean CanPlaceMacroblock_NoDestruction(CMacroblockModel MacroblockModel,Int3 Coord,CardinalDirections Dir);

            Boolean PlaceMacroblock_NoDestruction(CMacroblockModel MacroblockModel,Int3 Coord,CardinalDirections Dir);

            Boolean CanPlaceMacroblock_NoTerrain(CMacroblockModel MacroblockModel,Int3 Coord,CardinalDirections Dir);

            Boolean PlaceMacroblock_NoTerrain(CMacroblockModel MacroblockModel,Int3 Coord,CardinalDirections Dir);

            Boolean RemoveMacroblock(CMacroblockModel MacroblockModel,Int3 Coord,CardinalDirections Dir);

            Boolean RemoveMacroblock_NoTerrain(CMacroblockModel MacroblockModel,Int3 Coord,CardinalDirections Dir);

            CBlock GetBlock(Int3 Coord);

            Boolean IsBlockModelSkinnable(CBlockModel BlockModel);

            Integer GetNbBlockModelSkins(CBlockModel BlockModel);

            Text GetBlockModelSkinName(CBlockModel BlockModel,Integer SkinIndex);

            Integer GetBlockSkinIndex(CBlock Block);

            Void SetBlockSkinIndex(CBlock Block,Integer SkinIndex);

            Boolean OpenBlockSkinDialog(CBlock Block);

            Boolean RemoveBlock(Int3 Coord);

            Boolean RemoveTerrainBlocks(Int3 StartCoord,Int3 EndCoord);

            Integer GetBlockGroundHeight(CBlockModel BlockModel,Integer CoordX,Integer CoordZ,CardinalDirections Dir);

            Integer GetGroundHeight(Integer CoordX,Integer CoordZ);

            Int3 GetMouseCoordOnGround();

            Int3 GetMouseCoordAtHeight(Integer CoordY);

            CBlock GetStartLineBlock();

            Boolean RemoveItem(CAnchorData Item);

            Void CopyPaste_AddOrSubSelection(Int3 StartCoord,Int3 EndCoord);

            Boolean CopyPaste_Symmetrize();

            Void SaveMacroblock(CMacroblockModel MacroblockModel);

            CMacroblockModel GetMacroblockModelFromFilePath(Text MacroblockModelFilePath);

            CBlockModel GetTerrainBlockModelFromName(Text TerrainBlockModelName);

            CBlockModel GetBlockModelFromName(Text BlockModelName);

            Text GetMapStyle();

            Void SetMapStyle(Text MapStyle);

    const   CItemAnchor[] Items;

    const   Text[] MediatrackIngameClips;

    const   Text[] MediatrackIngameIsScriptClips;

            Integer MediatrackIngameEditedClipIndex;

    const   CBlock[] Blocks;

    const   CBlockModel[] BlockModels;

    const   CBlockModel[] TerrainBlockModels;

    const   CMacroblockModel[] MacroblockModels;

    const   CAnchorData[] AnchorData;

            Int3[] CustomSelectionCoords;

            Vec3 CustomSelectionRGB;

            Boolean EnableEditorInputsCustomProcessing;

            Boolean EnableCursorShowingWhenInterfaceIsFocused;

            Boolean HideEditorInterface;

            Boolean HideBlockHelpers;

            Boolean ShowPlacementGrid;

            Boolean IsTrustedPlugin_DevBuild;

    const   EditorStatus EditorStatus;

            Boolean HideAlwaysCursorDirectionalArrow;

            Real CursorBrightnessFactor;

            Boolean EnableUnlimitedUndoHistory;

            Integer UndoHistorySize;

            Integer CoppersLimit;

            Boolean TurboClassicMapEditorMode;

    const   Boolean EditorInputIsDown_Menu;

    const   Boolean EditorInputIsDown_SwitchToRace;

    const   Boolean EditorInputIsDown_Undo;

    const   Boolean EditorInputIsDown_Redo;

    const   Boolean EditorInputIsDown_CursorUp;

    const   Boolean EditorInputIsDown_CursorRight;

    const   Boolean EditorInputIsDown_CursorDown;

    const   Boolean EditorInputIsDown_CursorLeft;

    const   Boolean EditorInputIsDown_CursorRaise;

    const   Boolean EditorInputIsDown_CursorLower;

    const   Boolean EditorInputIsDown_CursorTurn;

    const   Boolean EditorInputIsDown_CursorPick;

    const   Boolean EditorInputIsDown_CursorPlace;

    const   Boolean EditorInputIsDown_CursorDelete;

    const   Boolean EditorInputIsDown_CameraUp;

    const   Boolean EditorInputIsDown_CameraRight;

    const   Boolean EditorInputIsDown_CameraDown;

    const   Boolean EditorInputIsDown_CameraLeft;

    const   Boolean EditorInputIsDown_CameraZoomNext;

    const   Boolean EditorInputIsDown_Camera0;

    const   Boolean EditorInputIsDown_Camera1;

    const   Boolean EditorInputIsDown_Camera3;

    const   Boolean EditorInputIsDown_Camera7;

    const   Boolean EditorInputIsDown_Camera9;

    const   Boolean EditorInputIsDown_PivotChange;

    const   Boolean EditorInputIsDown_CursorTurnSlightly;

    const   Boolean EditorInputIsDown_CursorTurnSlightlyAntiClockwise;

    const   Boolean EditorInputIsDown_IconUp;

    const   Boolean EditorInputIsDown_IconRight;

    const   Boolean EditorInputIsDown_IconDown;

    const   Boolean EditorInputIsDown_IconLeft;

    const   Boolean EditorInputIsDown_RemoveAll;

    const   Boolean EditorInputIsDown_Save;

    const   Boolean EditorInputIsDown_SaveAs;

    const   Boolean EditorInputIsDown_MapStyle;

    const   Boolean EditorInputIsDown_ClassicMapEditor;

    const   Real CollectionSquareSize;

    const   Real CollectionSquareHeight;

    const   Integer CollectionGroundY;

    const   ValidationStatus ValidationStatus;

            Text ManialinkText;

    const   CMlPage ManialinkPage;

};


struct CEditorPluginLayer : public CMlScript {

    const   CEditorPlugin Editor;

};


struct CBadgeEditor : public CGameManiaAppMinimal {

            Void Leave();

            CBadge DisplayCurrentBadge;

            Vec2 DisplayPosN;

            Vec2 DisplaySize;

            Real DisplayFoV;

            Real CameraTransitionDuration;

            Real MeshRotation_MaxSpeed;

            Real MeshRotation_Acceleration;

            Ident DisplayCurrentMeshId;

    const   Ident[] MeshIds;

            Void MeshId_Next();

            Void MeshId_Previous();

    const   CBadge[] Badges;

            CBadge BadgeCreate();

            Void BadgeDestroy(CBadge Badge);

            Void BadgeCopy(CBadge Source,CBadge Destination);

            Void BadgeReadFromProfile(CBadge Badge,Ident UserId);

            Void BadgeWriteToProfile(CBadge Badge,Ident UserId);

};


struct CGameMasterServerOnlineSignal_RecordBeaten : public CGameMasterServerOnlineSignal {

    const   Text BeatenLogin;

    const   Text BeatenDisplayName;

    const   Text ChallengeUid;

    const   Text ChallengeName;

    const   Integer RecordScore;

    const   Integer RecordScoreBeaten;

};


struct CSmMode : public CMode {

    enum EWeapon {

        Laser,

        Rocket,

        Nucleus,

        Arrow,

    };

    enum EActionSlot {

        Slot_A,

        Slot_B,

        Slot_C,

        Slot_D,

        Slot_E,

        Slot_F,

        Slot_G,

        Slot_H,

    };

    enum EActionInput {

        Weapon,

        Movement,

        Activable1,

        Activable2,

        Activable3,

        Activable4,

        Consumable1,

        Consumable2,

        None,

    };

    enum EGameplay {

        Default,

        Mp3Beta0,

    };

            Integer StartTime;

            Integer EndTime;

            Integer SpawnInvulnerabilityDuration;

            Boolean UseClans;

            Boolean UseForcedClans;

            Boolean UsePvPCollisions;

            Boolean UsePvPWeapons;

            Boolean UseInterractiveScreensIn3d;

            Boolean UseLaserVsBullets;

            Boolean UseLaserSkewering;

            Boolean UsePlayerTagging;

            Boolean UseBeaconsWithRecipients;

            Boolean UseAmmoBonusOnHit;

            Boolean UseSameWallJump;

            Boolean UseDefaultActionEvents;

            Boolean UseAllies;

            Boolean UseAutoSpawnBots;

            Boolean UseAutoRespawnBots;

            Boolean WalkOnWall;

            Boolean UseAutoDiscardBotEvents;

            Boolean ForceNavMapsComputation;

            Integer GameplayVersion;

            EGameplay Gameplay;

            Boolean UseProtectClanmates;

            Real OffZoneRadius;

            Real OffZoneRadiusSpeed;

            Ident OffZoneCenterLandmarkId;

    const   Integer PlayersNbTotal;

    const   Integer PlayersNbAlive;

    const   Integer PlayersNbDead;

    const   Integer ClansNbTotal;

    const   Integer ClansNbAlive;

    const   Integer ClansNbDead;

    const   Integer[] ClansNbPlayers;

    const   Integer[] ClansNbPlayersAlive;

    const   CSmPlayer[] Players;

    const   CSmPlayer[] BotPlayers;

    const   CSmPlayer[] Spectators;

    const   CSmPlayer[] AllPlayers;

    const   CSmModeEvent[] PendingEvents;

    const   CSmMapBase[] MapBases;

    const   CSmMapLandmark[] MapLandmarks;

    const   CSmMapLandmark[] MapLandmarks_PlayerSpawn;

    const   CSmMapLandmark[] MapLandmarks_Gauge;

    const   CSmMapLandmark[] MapLandmarks_Sector;

    const   CSmMapLandmark[] MapLandmarks_BotPath;

    const   CSmMapLandmark[] MapLandmarks_BotSpawn;

    const   CSmMapLandmark[] MapLandmarks_ObjectAnchor;

    const   CSmMapLandmark[] MapLandmarks_Gate;

    const   CSmScore[] Scores;

            Integer[] ClanScores;

            Void PassOn(CSmModeEvent Event);

            Void Discard(CSmModeEvent Event);

            Void SpawnPlayer(CSmPlayer Player,Integer ClanNum,Integer Armor,CSmMapPlayerSpawn PlayerSpawn,Integer ActivationDate);

            Void SpawnBotPlayer(CSmPlayer Player,Integer ClanNum,Integer Armor,CSmMapPlayerSpawn PlayerSpawn,Integer ActivationDate);

            Void SpawnBotPlayer(CSmPlayer Player,Integer ClanNum,Integer Armor,CSmMapBotPath BotPath,Integer ActivationDate);

            Void SpawnBotPlayer(CSmPlayer Player,Integer ClanNum,Integer Armor,CSmMapBotSpawn BotSpawn,Integer ActivationDate);

            Void SpawnBotPlayer(CSmPlayer Player,CSmPlayer Owner,Integer Armor,Vec3 Offset,Integer ActivationDate);

            Void UnspawnPlayer(CSmPlayer Player);

            Void ClearScores();

            Void SetPlayerClan(CSmPlayer Player,Integer ClanNum);

            Void SetPlayerWeapon(CSmPlayer Player,EWeapon DefaultWeapon,Boolean AutoSwitchWeapon);

            Void SetPlayerReloadAllWeapons(CSmPlayer Player,Boolean ReloadAllWeapons);

            Void SetPlayerAmmo(CSmPlayer Player,EWeapon Weapon,Integer Count);

            Integer GetPlayerAmmo(CSmPlayer Player,EWeapon Weapon);

            Void AddPlayerAmmo(CSmPlayer Player,EWeapon Weapon,Real DeltaCount);

            Void SetPlayerAmmoMax(CSmPlayer Player,EWeapon Weapon,Integer Count);

            Integer GetPlayerAmmoMax(CSmPlayer Player,EWeapon Weapon);

            Void AddPlayerArmor(CSmPlayer Victim,Integer DeltaArmor,CSmPlayer Shooter,Integer ShooterPoints);

            Void RemovePlayerArmor(CSmPlayer Victim,Integer DeltaArmor,CSmPlayer Shooter,Integer ShooterPoints);

            Integer GetWeaponNum(EWeapon Weapon);

            Boolean CanRespawnPlayer(CSmPlayer Player);

            Void RespawnPlayer(CSmPlayer Player);

            Void RespawnPlayer(CSmPlayer Player,CSmMapLandmark CheckpointLandmark);

            CSmPlayer CreateBotPlayer(Ident ModelId,Integer TeamNum);

            Void DestroyBotPlayer(CSmPlayer BotPlayer);

            Void DestroyAllBotPlayers();

            Void ScriptedBot_Move(CSmPlayer BotPlayer,Vec3 Goal);

            Void ScriptedBot_MoveDelta(CSmPlayer BotPlayer,Vec3 Delta);

            Void ScriptedBot_MoveAndAim(CSmPlayer BotPlayer,Vec3 Goal);

            Void ScriptedBot_MoveDeltaAndAim(CSmPlayer BotPlayer,Vec3 Delta);

            Void ScriptedBot_Aim(CSmPlayer BotPlayer,Vec3 Goal);

            Void ScriptedBot_AimDelta(CSmPlayer BotPlayer,Real DeltaYaw,Real DeltaPitch);

            Void ScriptedBot_RequestAction(CSmPlayer BotPlayer);

            Void ScriptedBot_RequestGunTrigger(CSmPlayer BotPlayer);

            Void ActionLoad(CSmPlayer Player,EActionSlot ActionSlot,Ident ModelId);

            Void ActionBind(CSmPlayer Player,EActionSlot ActionSlot,EActionInput ActionInput);

            Void ActionSetVariant(CSmPlayer Player,EActionSlot ActionSlot,Integer ActionVariant);

            Void SetNbFakePlayers(Integer NbClan1,Integer NbClan2);

    const   CSmObject[] Objects;

            CSmObject ObjectCreate(Ident ModelId);

            Void ObjectDestroy(CSmObject Object);

            Void ObjectDestroyAll();

            Void Replay_SaveAttackScore(CSmPlayer Player,Integer Score);

            Void Replay_SaveDefenseScore(CSmPlayer Player,Integer Score);

            Void Replay_SaveTeamScore(Integer Team,Integer Score);

            Void Replay_SavePlayerOfInterest(CSmPlayer Player);

            Void Replay_SaveWinner(CSmPlayer Player);

            Void Replay_SaveInterface();

};


struct CSmMlScriptIngame : public CMlScriptIngame {

    const   Integer ArenaNow;

    const   CSmPlayer InputPlayer;

    const   CSmPlayer GUIPlayer;

    const   CSmPlayer[] Players;

    const   CSmScore[] Scores;

    const   Integer[] ClanScores;

            Boolean HideResumePlayingButton;

    const   CSmMapBase[] MapBases;

    const   CSmMapLandmark[] MapLandmarks;

    const   CSmMapLandmark[] MapLandmarks_PlayerSpawn;

    const   CSmMapLandmark[] MapLandmarks_Gauge;

    const   CSmMapLandmark[] MapLandmarks_Sector;

    const   CSmMapLandmark[] MapLandmarks_BotPath;

    const   CSmMapLandmark[] MapLandmarks_BotSpawn;

    const   CSmMapLandmark[] MapLandmarks_ObjectAnchor;

    const   CSmMapLandmark[] MapLandmarks_Gate;

};


struct CSmAction : public CNod {

    const   Integer Now;

    const   Integer Variant;

            CSmPlayer[] Players;

            CSmPlayer Owner;

    const   Boolean IsActive;

    const   Boolean IsBound;

            Integer Energy;

            Integer EnergyMax;

            Integer EnergyCost;

            Boolean EnergyReload;

    const   CSmActionEvent[] PendingEvents;

            Void SendRulesEvent(Text Param1,Text[] Param2,CSmPlayer Shooter,CSmPlayer Victim);

            Void SendRulesEvent(Text Param1,Text[] Param2,CSmPlayer Shooter,CSmPlayer Victim,CSmObject Object);

            Ident GetAnimModelId(Text ModelName);

            Void PlayAnimOnPlayer(Ident AnimModelId,CSmPlayer Player);

            Void PlayAnimAtPosition(Ident AnimModelId,Vec3 Position,Vec3 Direction);

            Ident GetProjectileModelId(Text ModelName);

            Void CreateProjectile(CSmPlayer PlayerToIgnore,Ident ProjectileModelId,Vec3 InitialPosition,Vec3 InitialDirection,Vec3 InitialVelocity);

            Void CreateProjectile(CSmPlayer PlayerToIgnore,Ident ProjectileModelId,Vec3 InitialPosition,Vec3 InitialDirection,Vec3 InitialVelocity,Integer ContextId);

            Void CreateShoot(CSmPlayer Shooter,Ident ProjectileModelId);

            Void CreateShoot(CSmPlayer Shooter,Ident ProjectileModelId,Integer ContextId);

            Integer Cooldown;

            Boolean Cooldown_IsReady(Integer Now);

            Void Cooldown_Start();

            Boolean IsJumping;

            Boolean IsGliding;

            Boolean IsAttractor;

            Boolean IsFlying;

            Boolean IsSliding;

            Boolean IsRunning;

            Boolean IsFrozen;

            Boolean IsSneaking;

            Boolean IsFreeLooking;

            Boolean HasNoPlayerCollision;

};


struct CSmMapType : public CMapType {

    const   CSmMode Mode;

    const   CSmPlayer[] AllPlayers;

    const   CSmPlayer[] Players;

};


struct CTmMlScriptIngame : public CMlScriptIngame {

    const   CTmMlPlayer InputPlayer;

    const   CTmMlPlayer GUIPlayer;

    const   CTmRaceClientEvent[] RaceEvents;

    const   Integer NbLaps;

    const   Boolean IndependantLaps;

    const   CTmMlPlayer[] Players;

    const   CTmScore[] Scores;

    const   Integer[] ClanScores;

    const   Integer SplitScreenNum;

    const   Integer SplitScreenCount;

            Integer CurPlayerCamera;

    const   Vec3 MapStartLinePos;

    const   Vec3[] MapCheckpointPos;

    const   Vec3[] MapFinishLinePos;

    const   Boolean MapIsLapRace;

    const   Integer MapNbLaps;

};


struct CTmMode : public CMode {

    enum ETmScoreSortOrder {

        TotalPoints,

        BestRace_Time,

        BestRace_Stunts,

        BestRace_NbRespawns,

        BestRace_CheckpointsProgress,

        PrevRace_Time,

        Name,

        LadderRankSortValue,

    };

    enum ETMRespawnBehaviour {

        Normal,

        DoNothing,

        GiveUpBeforeFirstCheckPoint,

        AlwaysGiveUp,

    };

    enum ETmRaceChronoBehaviour {

        Auto,

        Hidden,

        CountDown,

        Normal,

    };

    enum EPersonalGhost {

        Disabled,

        Latest,

        FastestRace,

    };

    const   CTmPlayer[] AllPlayers;

    const   CTmPlayer[] Spectators;

    const   CTmPlayer[] Players;

    const   CTmPlayer[] PlayersRacing;

    const   CTmPlayer[] PlayersWaiting;

    const   CTmScore[] Scores;

            Integer Clan1Score;

            Integer Clan2Score;

            Integer[] ClanScores;

    const   Integer ClansNbTotal;

    const   Integer[] ClansNbPlayers;

    const   CTmModeEvent[] PendingEvents;

            Void PassOn(CTmModeEvent Event);

            Void Discard(CTmModeEvent Event);

            Void SpawnPlayer(CTmPlayer Player,Integer ClanNum,Integer RaceStartTime);

            Void UnspawnPlayer(CTmPlayer Player);

            Void SetPlayerClan(CTmPlayer Player,Integer ClanNum);

            Void Scores_Sort(ETmScoreSortOrder SortOrder);

            Void Scores_Clear();

            Void Ladder_ComputeRank(ETmScoreSortOrder SortOrder);

            Integer CutOffTimeLimit;

            Integer NbLaps;

            Boolean IndependantLaps;

            Boolean UseClans;

            Boolean UseForcedClans;

            ETMRespawnBehaviour RespawnBehaviour;

            Boolean UiRounds;

            Boolean UiLaps;

            Boolean UiStuntsMode;

            Boolean UiDisplayStuntsNames;

            Boolean UiDisableHelpMessage;

            Integer UiScoresPointsLimit;

            ETmRaceChronoBehaviour UiRaceChrono;

            Void Cheats_Reset();

            Boolean EnableCollisions;

            Boolean EnableScaleCar;

            Boolean EnableCheckpointBonus;

            Boolean EnableUniqueCamera;

            Boolean EnableBonusEvents;

            Boolean HideOpponents;

            Integer ForceMaxOpponents;

            Boolean EnableLegacyXmlRpcCallbacks;

            Boolean MedalGhost_ShowGold;

            Boolean MedalGhost_ShowSilver;

            Boolean MedalGhost_ShowBronze;

            EPersonalGhost PersonalGhost;

            Ident RaceGhost_Add(CGhost Ghost,Boolean DisplayAsPlayerBest);

            Ident RaceGhost_AddWithOffset(CGhost Ghost,Integer OffsetMs);

            Ident RaceGhost_Add(CGhost Ghost,Boolean DisplayAsPlayerBest,Ident ModelId);

            Void RaceGhost_Remove(Ident GhostInstId);

            Void RaceGhost_RemoveAll();

            Integer RaceGhost_GetStartTime(Ident GhostInstId);

            Integer RaceGhost_GetCurCheckpoint(Ident GhostInstId);

            Integer RaceGhost_GetCheckpointTime(Ident GhostInstId,Integer Checkpoint);

            Boolean RaceGhost_IsReplayOver(Ident GhostInstId);

            Boolean OnlineRecordEnabled;

    const   Vec3 MapStartLinePos;

    const   Vec3[] MapCheckpointPos;

    const   Vec3[] MapFinishLinePos;

    const   Boolean MapIsLapRace;

    const   Integer MapNbLaps;

};


struct CTmMapType : public CMapType {

    const   CTmMode Mode;

            Void TMObjective_SetFromBestRace(CTmScore Score);

    const   CTmPlayer[] AllPlayers;

    const   CTmPlayer[] Players;

};


struct CNod {

    const   Ident Id;

};


struct CMlPage : public CNod {

    const   CMlFrame MainFrame;

            CMlControl GetFirstChild(Text ControlId);

            Boolean LinksInhibited;

            Void GetClassChildren(Text Class,CMlFrame Frame,Boolean Recursive);

    const   CMlControl[] GetClassChildren_Result;

};


struct CUser : public CNod {

    enum EEchelon {

        None,

        Bronze1,

        Bronze2,

        Bronze3,

        Silver1,

        Silver2,

        Silver3,

        Gold1,

        Gold2,

        Gold3,

    };

    enum ETagType {

        Bronze,

        Silver,

        Gold,

        Nadeo,

    };

    enum EStereoDisplayMode {

        None,

        Stereo,

        HMD,

    };

    enum EMuteSetting {

        Auto,

        Muted,

        NotMuted,

    };

    const   Text Login;

    const   Text Name;

    const   Text AvatarUrl;

    const   Text ZonePath;

    const   Text ZoneFlagUrl;

    const   Text CountryFlagUrl;

    const   Text Language;

    const   Text Description;

    const   Vec3 Color;

    const   Text ClubLink;

    const   Text BroadcastTVLogin;

    const   Text SteamUserId;

    const   Integer FameStars;

    const   EEchelon Echelon;

    const   Integer NextEchelonPercent;

    const   Boolean IsBeginner;

    const   Integer LadderRank;

    const   Integer LadderTotal;

    const   Real LadderPoints;

    const   Text LadderZoneName;

    const   Text LadderZoneFlagUrl;

    const   Boolean IsFakeUser;

    const   Integer[] Tags_Favored_Indices;

    const   Text[] Tags_Id;

    const   ETagType[] Tags_Type;

    const   Text[] Tags_Comments;

    const   Text[] Tags_Deliverer;

    const   Boolean VoiceChat_Supported;

            EMuteSetting VoiceChat_MuteSetting;

    const   Boolean VoiceChat_IsSpeaking;

    const   Boolean VoiceChat_IsMuted;

    const   Boolean IsConnectedToMasterServer;

    const   Text[] AlliesConnected;

    const   EStereoDisplayMode StereoDisplayMode;

            Boolean HackCamHmdDisabled;

    enum PlayerType {

        Human,

        Fake (not net),

        Net,

        Replay,

    };

    enum SpectatorMode {

        Void,

        Watcher,

        LocalWatcher,

        Target,

    };

};


struct CTitle : public CNod {

    const   Text TitleId;

    const   Text BaseTitleId;

    const   Text Name;

    const   Text Desc;

    const   Text InfoUrl;

    const   Text DownloadUrl;

    const   Text TitleVersion;

};


struct CMlEvent : public CNod {

    enum Type {

        KeyPress,

        MouseClick,

        MouseOver,

        MouseOut,

        EntrySubmit,

        MenuNavigation,

        PluginCustomEvent,

    };

    enum EMenuNavAction {

        Up,

        Right,

        Left,

        Down,

        Select,

        Cancel,

        PageUp,

        PageDown,

        AppMenu,

        Action1,

        Action2,

    };

    const   Type Type;

    const   Integer KeyCode;

    const   Text KeyName;

    const   Text CharPressed;

    const   Text ControlId;

    const   CMlControl Control;

    const   EMenuNavAction MenuNavAction;

    const   Boolean IsActionAutoRepeat;

    const   Text CustomEventType;

    const   Text[] CustomEventData;

};


struct CXmlManager : public CNod {

            CXmlDocument Create(Text Contents);

            CXmlDocument Create(Text Contents,Boolean GenerateText,Boolean GenerateTextRaw,Boolean GenerateTextResursive);

            Void Destroy(CXmlDocument Document);

    const   CXmlDocument[] Documents;

            Integer DocumentsSlotsLimit;

};


struct CHttpManager : public CNod {

            CHttpRequest CreateGet(Text Url);

            CHttpRequest CreateGet(Text Url,Boolean UseCache);

            CHttpRequest CreateGet(Text Url,Boolean UseCache,Text AdditionalHeaders);

            CHttpRequest CreatePost(Text Url,Text Resource);

            CHttpRequest CreatePost(Text Url,Text Resource,Text AdditionalHeaders);

            Void Destroy(CHttpRequest Request);

            Boolean IsValidUrl(Text Url);

    const   CHttpRequest[] Requests;

    const   Integer SlotsAvailable;

};


struct CVideoManager : public CNod {

            CVideo CreateVideo(Text Url,Boolean IsLooping,Boolean AutoProcessing);

            Void DestroyVideo(CVideo Video);

    const   CVideo[] Videos;

};


struct CAudioManager : public CNod {

    enum ELibSound {

        Alert,

        ShowDialog,

        HideDialog,

        ShowMenu,

        HideMenu,

        Focus,

        Valid,

        Start,

        Countdown,

        Victory,

        ScoreIncrease,

        Checkpoint,

    };

            CAudioSource CreateSound(Text Url);

            CAudioSource CreateSound(Text Url,Real VolumedB,Boolean IsMusic,Boolean IsLooping,Boolean IsSpatialized);

            Void DestroySound(CAudioSource Sound);

    const   CAudioSource[] Sounds;

            CAudioSourceMusic CreateMusic(Text Url);

            Void DestroyMusic(CAudioSourceMusic Music);

            Void PlaySoundEvent(CAudioSource Sound,Real VolumedB);

            Void PlaySoundEvent(Text Url,Real VolumedB);

            Void PlaySoundEvent(ELibSound Sound,Integer SoundVariant,Real VolumedB);

            Void PlaySoundEvent(CAudioSource Sound,Real VolumedB,Integer Delay);

            Void PlaySoundEvent(Text Url,Real VolumedB,Integer Delay);

            Void PlaySoundEvent(ELibSound Sound,Integer SoundVariant,Real VolumedB,Integer Delay);

            Void PlaySoundEvent(CAudioSource Sound,Real VolumedB,Vec3 PanRadiusLfe);

            Void PlaySoundEvent(Text Url,Real VolumedB,Vec3 PanRadiusLfe);

            Void PlaySoundEvent(CAudioSource Sound,Real VolumedB,Vec3 PanRadiusLfe,Integer Delay);

            Void PlaySoundEvent(Text Url,Real VolumedB,Vec3 PanRadiusLfe,Integer Delay);

            Void ClearAllDelayedSoundsEvents();

            Boolean ForceEnableMusic;

            Real LimitMusicVolumedB;

            Real LimitSceneSoundVolumedB;

            Real LimitUiSoundVolumedB;

};


struct CInputManager : public CNod {

    enum EButton {

        Left,

        Right,

        Up,

        Down,

        A,

        B,

        X,

        Y,

        L1,

        R1,

        LeftStick,

        RightStick,

        Menu,

        View,

        LeftStick_Left,

        LeftStick_Right,

        LeftStick_Up,

        LeftStick_Down,

        RightStick_Left,

        RightStick_Right,

        RightStick_Up,

        RightStick_Down,

        L2,

        R2,

        None,

    };

    const   CInputEvent[] PendingEvents;

    const   Integer Now;

    const   Integer Period;

    const   CInputPad[] Pads;

    const   Vec2 MousePos;

    const   Boolean MouseLeftButton;

    const   Boolean MouseRightButton;

    const   Boolean MouseMiddleButton;

            Text GetPadButtonPlaygroundBinding(CInputPad Pad,EButton Button);

            Text GetPadButtonCurrentBinding(CInputPad Pad,EButton Button);

            Text GetPadButtonBinding(CInputPad Pad,EButton Button);

            Boolean ExclusiveMode;

            Boolean IsKeyPressed(Integer KeyCode);

            Integer Dbg_AutoRepeat_InitialDelay;

            Integer Dbg_AutoRepeat_Period;

};


struct CDataMgr : public CNod {

    enum EFileType {

        Map,

        Ghost,

    };

    enum EResult {

        NotStarted,

        Running,

        Cancelled,

        Finished_Ok,

        Error_MountRead,

        Error_MountWrite,

        Error_Delete,

        Error_NoUserRecords,

        Error_NoUserDataCache,

        Error_MasterServer,

        Error_FindOrAddFid,

        Error_DownloadPackDesc,

        Error_LoadFromFid,

        Error_FidNotLoadable,

        Error_BadFileType,

        Error_MedalGhostReplayFidNotFound,

        Error_MedalGhostNotFoundOnReplay,

        Error_SaveUserRecordsToFid,

        Error_FindFid,

        Error_SaveToFid,

        Error_UrlNotReachable,

        Error_EmptyUrl,

        Error_Internal,

        Error_NotEnoughSpace,

    };

    const   CMapInfo[] Maps;

    const   CHighScore[] Records;

    const   CGhost[] Ghosts;

    const   Boolean HasFreeSpaceForNewMap;

    const   CImage MapThumbnail;

            Void MapFilterClear();

            Text MapFilterStartWithPath;

            Void DeleteFile(Text FileName);

            Void RetrieveNewFileName(Ident UserId,Text SlotName,EFileType FileType);

            Void GetNewMapEditionId(Ident UserId,Integer MinEditionId);

            Void RetrieveMapFileNameFromEditionId(Ident UserId,Text FileName);

            Void RetrieveUserFiles(Ident UserId,Text SlotName,EFileType FileType);

            Void RetrieveGameFiles(EFileType FileType);

            Void RetrieveOrderedCampaignMaps();

            Void ClearFileList();

            Void LoadMapThumbnail(Integer MapIndex);

            Void UploadUserFile(Text PostUrl,Text MapName,Text Metadata);

            Void UploadUserFile(Text PostUrl,Text MapName,Text Metadata,Text AdditionalHeaders);

            Void QueryHasFreeSpaceForNewMap(Ident UserId);

            Void RetrieveRecords(CMapInfo MapInfo,Ident UserId);

            Void RetrieveRecordsNoMedals(Text MapUid,Ident UserId);

            Void StoreRecord(Text MapUid,Ident UserId,CGhost Ghost);

            Void StoreRecord(Text MapUid,Ident UserId,CGhost Ghost,Text GhostName);

            CGhost GhostRetrieve(Text GhostUrl);

            CGhost GhostRetrieveFromPlayer(CPlayer GamePlayer);

            CGhost GhostRetrieveFromTaskResult(CWebServicesTaskResult_GhostHandle TaskResult);

            Void GhostDestroy(CGhost Ghost);

    const   Boolean Ready;

    const   Boolean DoNotSwitchOff;

    const   EResult LatestResult;

    const   Ident MenuUserId;

    const   Text NewFileName;

    const   Integer MinEditionId;

    const   Text MapFileNameFromEditionId;

};


struct CScoreMgr : public CNod {

    enum ELocalScoreStatus {

        None,

        Loading,

        NotLoaded,

        Loaded,

    };

    enum EMasterServerScoreStatus {

        None,

        Synchronizing,

        NotSynchronized,

        Synchronized,

    };

    const   CWebServicesTaskResult[] TaskResults;

            Void ReleaseTaskResult(Ident TaskId);

            ELocalScoreStatus ScoreStatus_GetLocalStatus(Ident UserId);

            EMasterServerScoreStatus ScoreStatus_GetMasterServerStatus(Ident UserId);

            CWebServicesTaskResult Campaign_SetNewMapRecord(Ident UserId,Text MapUid,CGhost Ghost);

            Integer Campaign_GetMapRecord(Ident UserId,Text MapUid);

            CWebServicesTaskResult_GhostHandle Campaign_GetMapRecordGhost(Ident UserId,Text MapUid);

            Integer Campaign_GetMapMultiAsyncLevel(Ident UserId,Text MapUid);

            CWebServicesTaskResult_BuddiesChallengeRecord Campaign_GetBuddiesMapRecord(Ident UserId,Text MapUid);

            Boolean Campaign_IsBuddiesMapRecordDirty(Ident UserId,Text MapUid);

            CWebServicesTaskResult_BuddiesChallengeRecordsComparison Campaign_GetBuddiesMapRecordsComparison(Ident UserId);

            CWebServicesTaskResult_BuddyChallengeRecordsComparison Campaign_GetBuddyMapRecordsComparison(Ident UserId,Text OpponentLogin);

            Void Multiplayer_AddToScore(Ident UserId,Real ScoreDiff,Integer Timestamp);

            Integer CampaignLeaderBoard_GetPlayerRanking(Ident UserId,Text CampaignId,Text Zone);

            Integer CampaignLeaderBoard_GetPlayerCount(Text CampaignId,Text Zone);

            Integer MapLeaderBoard_GetPlayerRanking(Ident UserId,Text MapUid,Text Zone);

            Integer MapLeaderBoard_GetPlayerCount(Text MapUid,Text Zone);

            Integer GlobalLeaderBoard_GetPlayerRanking(Ident UserId,Text Zone);

            Integer GlobalLeaderBoard_GetPlayerCount(Text Zone);

            CWebServicesTaskResult_RealLeaderBoard GlobalLeaderBoard_GetPlayerList(Ident UserId,Text Zone,Integer FromIndex,Integer Count);

};


struct CPrivilegeMgr : public CNod {

    enum EPrivilege {

        PlayMultiplayerMode,

        PlayMultiplayerSession,

        UploadUserCreatedContent,

        ViewOnlinePresence,

        ViewUserCreatedContent,

        ViewUserCreatedContentRequired,

        ViewUserGameHistory,

        VoiceChat,

        PlayMultiplayerAsync,

        DownloadUserCreatedContent,

    };

    const   CWebServicesTaskResult[] TaskResults;

            Void ReleaseTaskResult(Ident TaskId);

            CWebServicesTaskResult CheckPrivilege(Ident UserId,EPrivilege Privilege);

            CWebServicesTaskResult CheckPrivilegeForAllUsers(EPrivilege Privilege);

            CWebServicesTaskResult_CheckTargetedPrivilegeResultScript CheckTargetedPrivilege(Ident UserId,EPrivilege Privilege);

            CWebServicesTaskResult_CheckTargetedPrivilegeResultScript CheckTargetedPrivilegeForAllUsers(EPrivilege Privilege);

};


struct CPresenceMgr : public CNod {

    enum ERichPresence {

        Undefined,

        MainMenu,

        Solo,

        Multi,

        Party,

        Create,

    };

    const   CWebServicesTaskResult[] TaskResults;

            Void ReleaseTaskResult(Ident TaskId);

            Void SetPresence(Ident UserId,ERichPresence UplayFlow);

            CGameMasterServerRichPresenceTaskResult_GetOnlinePresenceForPlayersScript GetOnlinePresenceForPlayers(Ident UserId);

};


struct CGamePluginInterfacesScript : public CNod {

            CManiaplanetPluginInterface GetInterface(Text Name);

    const   CManiaplanetPluginInterface[] Interfaces;

};


struct CMlControl : public CNod {

    enum AlignHorizontal {

        Left,

        HCenter,

        Right,

        None,

    };

    enum AlignVertical {

        Top,

        VCenter,

        Bottom,

        None,

        VCenter2,

    };

    const   Text ControlId;

    const   Text[] ControlClasses;

            Boolean HasClass(Text Class);

            Vec2 Size;

            AlignHorizontal HorizontalAlign;

            AlignVertical VerticalAlign;

            Boolean Visible;

            Vec2 RelativePosition_V3;

            Real ZIndex;

            Real RelativeScale;

            Real RelativeRotation;

    const   Vec2 AbsolutePosition_V3;

    const   Real AbsoluteScale;

    const   Real AbsoluteRotation;

            Boolean DataAttributeExists(Text DataName);

            Text DataAttributeGet(Text DataName);

            Void DataAttributeSet(Text DataName,Text DataValue);

            Void Show();

            Void Hide();

            Void Unload();

            Void Focus();

    const   Boolean IsFocused;

};


struct CImage : public CPlug {

    enum ERenderTech {

        Unknown,

        Tech3,

    };

    enum ETexFilter {

        Point,

        Bilinear,

        Trilinear,

        Anisotropic,

        AnisoPoint,

    };

    enum ETexAddress {

        Wrap,

        Mirror,

        Clamp,

        BorderSM3,

    };

    enum EColorSpace {

        Linear,

        sRGB,

    };

    enum EVideoTimer {

        Game,

        Human,

        (External),

        Scene,

        Default,

    };

    enum EGenerateUV {

        NoGenerate,

        CameraVertex,

        WorldVertex,

        WorldVertexXY,

        WorldVertexXZ,

        WorldVertexYZ,

        CameraNormal,

        WorldNormal,

        CameraReflectionVector,

        WorldReflectionVector,

        WorldNormalNeg,

        WaterReflectionVector,

        Hack1Vertex,

        MapTexel DEPRECATED,

        FogPlane0,

        Vsk3SeaFoam,

        ImageSpace,

        LightDir0Reflect,

        EyeNormal,

        ShadowB1Pw01,

        Tex3AsPosPrCamera,

        FlatWaterReflect,

        FlatWaterRefract,

        FlatWaterFresnel,

        WorldPosXYblendZY,

        DisableVshOutput,

    };

    enum EUsage {

        Color,

        Light,

        Height->DuDv,

        Render,

        H->DuDvLumi,

        H->NormXYZ,

        H->NormXY,

        DepthCmp,

        DispH01,

        H->NormPal8b,

        NormXYZ,

        NormXY,

        NormPal8b,

        NormPal16b,

        ColorFloat,

        RenderFloat,

        H->DuDv1,

        Alpha,

        LightAlpha,

        H->NormX0ZY,

        NormX0ZY,

        TexCoord,

        Render16b,

        Vertex,

        H->BumpTxTy,

        BumpTxTy,

        H->Norm0YZX,

        Norm0YZX,

        Norm:XYZ->0YZX,

        Depth,

        SrgbL8->LinearL16,

        NormATI2N,

        NormXYZ->ATI2N,

        Color16b,

        SpecFIE->FI0E,

        SpecFI0E,

    };

    enum EColorDepth {

        DefaultColorDepth,

        Color16b,

        Color32b,

    };

    enum ECubeMapFace {

        None,

        XPos,

        XNeg,

        YPos,

        YNeg,

        ZPos,

        ZNeg,

    };

    enum EBumpCompressMode {

        None(32b),

        Pal8b,

        DXT1(4b),

        Pal16b,

    };

    enum EPixelUpdate {

        None,

        Render,

        Shader,

        DynaSpecular,

        Clear,

        RenderVideo,

    };

    enum EDynamic {

        Off,

        On,

        On 2 Buffers,

    };

    enum ENormalRotate {

        None,

        +x +z -y,

    };

    enum EEdCustomSaveOp {

        None,

        Conv.Diffuse,

        ShootCubeHdrScaleA2 DXT5,

    };

    enum ECompressor {

        NVidia,

        DirectX,

    };

    enum EForceBorderSize {

        1 texel,

        2 texels,

        3 texels,

        4 texels,

    };

    enum EMipMapAlpha01 {

        HalfBinary,

        ForceBinary,

        ShadeOfGray,

    };

};


struct CMlGraphCurve : public CNod {

            Vec2[] Points;

            Vec3 Color;

            Void SortPoints();

            Text Style;

            Real Width;

};


struct CMap : public CNod {

    const   CMapInfo MapInfo;

            Text MapName;

            Text Comments;

    const   Text AuthorZoneIconUrl;

    const   Text CollectionName;

    const   Text DecorationName;

    const   Text AuthorLogin;

    const   Text AuthorNickName;

    const   Text AuthorZonePath;

    const   Text MapType;

    const   Text MapStyle;

            Integer TMObjective_AuthorTime;

            Integer TMObjective_GoldTime;

            Integer TMObjective_SilverTime;

            Integer TMObjective_BronzeTime;

            Integer TMObjective_NbLaps;

            Boolean TMObjective_IsLapRace;

            Text ObjectiveTextAuthor;

            Text ObjectiveTextGold;

            Text ObjectiveTextSilver;

            Text ObjectiveTextBronze;

    const   Integer CopperPrice;

    const   Int3 Size;

};


struct CManiaAppBrowser : public CManiaApp {

    const   CManiaAppEvent[] PendingEvents;

            Void BrowserBack();

            Void BrowserQuit();

            Void BrowserHome();

            Void BrowserReload();

            Text BrowserFocusedFrameId;

};


struct CUILayer : public CNod {

    enum EUILayerType {

        Normal,

        ScoresTable,

        ScreenIn3d,

        AltMenu,

        Markers,

        CutScene,

        InGameMenu,

        EditorPlugin,

        ManiaplanetPlugin,

        ManiaplanetMenu,

        LoadingScreen,

    };

    enum EUILayerAnimation {

        None,

        DownFast,

        DownSlow,

        LeftFast,

        LeftSlow,

        RightFast,

        RightSlow,

        ScaleFast,

        ScaleSlow,

        UpFast,

        UpSlow,

    };

            Boolean IsVisible;

    const   Boolean AnimInProgress;

            EUILayerType Type;

            EUILayerAnimation InAnimation;

            EUILayerAnimation OutAnimation;

            EUILayerAnimation InOutAnimation;

            Text AttachId;

            Text ManialinkPage;

    const   CMlPage LocalPage;

};


struct CGameUserManagerScript : public CNod {

    const   Boolean Intro;

            Boolean CanSkipIntro;

            Void SetSkipIntro();

    const   Boolean MainUserLogged;

    const   CGameUserScript MainUser;

    const   Boolean MainUser_CanUseVoiceChat;

            Boolean VoiceChat_MuteAll;

            Void RequestMainUserChange();

    const   CGameUserScript[] Users;

    const   CInputPad MainUserPad;

            Text GetBuddiesLogins(Ident UserId);

            Boolean AreBuddiesLoginsReady(Ident UserId);

            Void InviteBuddyToServer(Ident UserId,Text Login);

            Void ShowInviteUI(Ident UserId);

            Void ShowProfile(Ident UserId,Text ProfileLogin);

};


struct CManiaPlanet : public CNod {

    enum EContext {

        MenuStartUp,

        MenuManiaPlanet,

        MenuManiaTitleMain,

        MenuProfile,

        MenuSolo,

        MenuLocal,

        MenuMulti,

        MenuCompetitions,

        MenuEditors,

        EditorPainter,

        EditorTrack,

        EditorMediaTracker,

        Solo,

        SoloLoadScreen,

        Multi,

        MultiLoadScreen,

        MenuCustom,

        Unknown,

    };

    enum ELinkType {

        ExternalBrowser,

        ManialinkBrowser,

    };

    enum EBuyTitleMode {

        OpenStore,

        BuyIfNeeded,

        Ask,

    };

    enum EMenuStationsPage {

        Home,

        Play,

        Store,

        Options,

        Help,

    };

    enum EUplayFlow {

        OverView,

        Auth,

        Reward,

        Rewards,

        Actions,

    };

    enum ESystemPlatform {

        None,

        Steam,

        UPlay,

        PS4,

        XBoxOne,

    };

    enum ESystemSkuIdentifier {

        Unknown,

        EU,

        US,

        JP,

    };

    enum EHmdWearingState {

        Dismount,

        Mount,

        Unknown,

    };

    enum EHmdTrackingState {

        NotStarted,

        Calibrating,

        NotTracking,

        Tracking,

    };

    const   Integer Now;

    const   Text CurrentLocalDateText;

    const   CUser LocalUser;

    const   CTitle LoadedTitle;

    const   CTitle[] TitlesAvailable;

    const   CTitle[] TitlesBases;

    const   Text[] TitleIdsInstalled;

    const   Text[] TitleIdsPayed;

    const   Integer EmptyStationsCount;

    const   ESystemPlatform SystemPlatform;

    const   ESystemSkuIdentifier SystemSkuIdentifier;

    const   Text ExeVersion;

    const   CMap CurrentMap;

    const   EContext ActiveContext;

    const   Text ActiveContext_MenuFrame;

    const   Text ActiveContext_InGameDialogFrame;

    const   Text ActiveContext_DialogFrame;

    const   Text ActiveContext_SystemDialogFrame;

    const   Boolean ActiveContext_ClassicDialogDisplayed;

    const   Integer ActiveContext_GameWill;

    const   Boolean ActiveContext_ManialinkBrowserDisplayed;

    const   Boolean ActiveContext_MenuStationsDisplayed;

    const   Boolean ActiveContext_InGameMenuDisplayed;

    const   EMenuStationsPage ActiveContext_MenuStationsPage;

    const   EMenuStationsPage ActiveContext_MenuStationsClickedPage;

    const   Text CurrentServerLogin;

    const   Text CurrentServerName;

    const   Text CurrentServerModeName;

    const   Text CurrentServerJoinLink;

    const   CUser[] CurrentServerPlayers;

    const   Integer CurrentAppId;

            Boolean IsPrivateSession;

    const   Boolean IsKioskMode;

    const   Boolean ParentalLock_IsLocked;

    const   Integer TotalTimePlay;

    const   Integer Messenger_MessagesCount;

    const   Integer AccountPlanets;

    const   Boolean IsTitleTimeLimited;

    const   Boolean IsTitleTimeLimitActivated;

    const   Boolean CanUnlockTitleTimeLimitOnStore;

    const   Integer TitleTimeLeft;

    const   Integer CurConnectionDate;

    const   Integer PrevConnectionDate;

            Real MasterSoundVolume;

            Real MasterMusicVolume;

    const   Boolean TmTurbo_IsDemo;

    const   Boolean TmTurbo_IsPartialInstall;

    const   Boolean TmTurbo_IsBeta;

    const   Boolean TmTurbo_IsBetaDeactivated;

    const   Boolean TmTurbo_IsOpenBeta;

    const   Boolean TmTurbo_IsSlowInstall;

            Boolean Settings_StationsManualLayout;

            Void ClipboardSet(Text ClipboardText);

            Void OpenLink(Text Url,ELinkType LinkType);

            Void QuitGameAndOpenLink(Text Url);

            Void InstallTitle(Text TitleId);

            Void InstallTitleFromUrl(Text Url,Text DisplayName);

            Void InstallTitleFromUrl(Text Url,Text DisplayName,Boolean EnterAfterInstall);

            Void ShowTitle(Text TitleId,Boolean ShowStation);

            Void SelectTitle(Text TitleId);

            Void EnterTitle(Text TitleId);

            Void ShowCurMapCard();

            Void SetMenuStationsActive(Boolean Activate);

            Void Dialog_EnterGameKey();

            Void Dialog_BuyTitleDialog(Text TitleId,Text OverrideBuyUrl,Integer OverrideActionAfterBuy);

            Void Dialog_BuyTitleEx(Text TitleId,EBuyTitleMode Mode,Text OverrideBuyUrl,Integer OverrideActionAfterBuy);

            Void Dialog_GenerateGameKeys(Text TitleId,Integer FeaturesLevel,Integer NbToGenerate,Boolean AddBuddyOnRegistration);

            Void Dialog_BuyStations();

            Void Dialog_SetServerFavourite(Text ServerLogin,Boolean Favorite,Boolean Silent);

    const   Boolean Dialog_IsFinished;

    const   Boolean Dialog_Success;

    const   Boolean Dialog_Aborted;

            Void CustomMenu_Request(Text Type,Text[] Data);

            Void SetLocalUserClubLink(Text ClubLink);

            Void SetLocalUserNickName(Text NickName);

            Void FlashWindow();

            Void CreateShortcut(Text ShortcutName,Text Url);

            Void HideSystemLoadingScreen();

            Boolean IsLiveStreamingEnabled;

            Boolean IsRemotePlayEnabled;

            Void TmTurbo_LoadingOpportunity();

    const   CGameAchievementScriptManager AchievementsManager;

    const   CGameUserManagerScript UserMgr;

            Void Authentication_GetToken(Ident UserId,Text AppLogin);

    const   Boolean Authentication_GetTokenResponseReceived;

    const   Integer Authentication_ErrorCode;

    const   Text Authentication_Token;

    const   CWebServicesTaskResult[] MasterServer_MSTaskResults;

            Void MasterServer_ReleaseMSTaskResult(Ident TaskId);

            Text MasterServer_GetURL(Text ShortCutId);

    const   CMasterServerUser MasterServer_MainMSUser;

    const   CMasterServerUser[] MasterServer_MSUsers;

            CMasterServerUser MasterServer_GetMSUserFromId(Ident UserId);

            Void MasterServer_Connect(Ident UserId);

            CWebServicesTaskResult_GetDisplayNameScriptResult MasterServer_GetDisplayName(Ident UserId);

            CWebServicesTaskResult MasterServer_CheckNetworkAvailability(Ident UserId);

            CWebServicesTaskResult_Session_Get MasterServer_GetSessionInfo(Ident UserId,Text SessionId);

            Void MasterServer_Zone_GetPathAndName(Text ZoneFullPath,Text ZonePath,Text ZoneName);

            CWebServicesTaskResult_ZoneList MasterServer_Zone_GetChilds(Text ZoneFullPath);

            CWebServicesTaskResult MasterServer_Zone_ChangeZone(Ident UserId,Text ZoneFullPath);

            CWebServicesTaskResult_LaunchUplayScriptResult MasterServer_UplayLaunch(Ident UserId,EUplayFlow UplayFlow,Integer RewardCode);

            CWebServicesTaskResult_LaunchUplayScriptResult MasterServer_UplayLaunch_v2(Ident UserId,EUplayFlow UplayFlow,Text RewardId);

            CWebServicesTaskResult_LaunchUplayScriptResult MasterServer_UplayLaunchAndCompleteActions(Ident UserId,EUplayFlow UplayFlow,Text RewardId);

            Void MasterServer_Tracking_ContextMenuStart(Ident UserId,Text MenuName);

            Void MasterServer_Tracking_ContextMenuStop(Ident UserId,Text MenuName);

            Void MasterServer_Tracking_ContextGameModeStart(Ident UserId,Text GameMode);

            Void MasterServer_Tracking_ContextGameModeStop(Ident UserId,Text GameMode);

            Void MasterServer_Tracking_ContextMapStart(Ident UserId,Text MapUid,Text Environment);

            Void MasterServer_Tracking_ContextMapStop(Ident UserId,Text MapUid);

            Void MasterServer_Tracking_ContextPlayStart(Ident UserId,Text Type);

            Void MasterServer_Tracking_ContextPlayStop(Ident UserId,Text Type,Text Reason,Integer NbRespawns);

            Void MasterServer_Tracking_MedalUnlock(Ident UserId,Integer Medal);

            Void MasterServer_Tracking_MedalUnlock_v2(Ident UserId,Integer PreviousMedal,Integer Medal);

            Void MasterServer_Tracking_NewMapCreated(Ident UserId,Text Environment,Boolean IsRandomlyGenerated);

            Void MasterServer_Tracking_NewsImpression(Ident UserId,Text NewsId);

            Void MasterServer_Tracking_NewsClick(Ident UserId,Text NewsId);

            Void MasterServer_Tracking_PlayerAchievement(Ident UserId,Integer AchievementId);

            Void MasterServer_Tracking_PlayerProgressionMap(Ident UserId,Text Value);

            Void MasterServer_Tracking_PlayerRespawn(Ident UserId,Integer RaceTime);

            Void MasterServer_Tracking_StatCampaign(Ident UserId,Integer PlayedMapCount,Integer BronzeMedalCount,Integer SilverMedalCount,Integer GoldMedalCount,Integer AuthorMedalCount,Integer MaxDifficultyLevel);

            Void MasterServer_Tracking_StatCampaign_v2(Ident UserId,Integer PlayedMapCount,Integer PlayedEnvCount,Integer BronzeMedalCount,Integer SilverMedalCount,Integer GoldMedalCount,Integer AuthorMedalCount,Integer MaxDifficultyLevel);

            Void MasterServer_Tracking_StatChallenge(Ident UserId,Integer PendingChallengeCount);

            Void MasterServer_Tracking_StatGlobalRanking(Ident UserId,Integer GlobalRanking);

            Void MasterServer_Tracking_StatOnline(Ident UserId,Integer Echelon);

            Void MasterServer_Tracking_StatRecordCenter(Ident UserId,Integer BestCount,Integer EqualCount,Integer WorstCount);

            CWebServicesTaskResult MasterServer_Beta_RetrieveUserInfo(Ident UserId);

            CWebServicesTaskResult MasterServer_Beta_AcceptNDA(Ident UserId);

            CWebServicesTaskResult BuyFullGame(Ident UserId);

            CWebServicesTaskResult ShowSystemError(Ident UserId,Integer ErrorCode);

            Void HMD_Activate(Boolean Enable);

    const   Boolean HMD_IsActive;

    const   Vec3 HMD_HeadTranslation;

    const   Real HMD_HeadYaw;

    const   Real HMD_HeadPitch;

    const   Real HMD_HeadRoll;

            Void HMD_ResetTracking();

            Void HMD_SelectUser();

    const   CGameUserScript HMD_CurrentUser;

            Real HMD_WorldScale;

            Real HMD_MoveScale;

            Real HMD_HUD_Distance;

    const   EHmdWearingState HMD_WearingState;

    const   EHmdTrackingState HMD_TrackingState;

    const   Boolean HMD_IsUserWarnBySystem_OutOfPlayArea;

            Boolean Cameras_BlackOut;

};


struct CTitleFlow : public CNod {

    enum ESplitScreenLayout {

        Horizontal,

        Vertical,

        Four,

    };

    enum EResult {

        Success,

        Error_Internal,

        Error_DataMgr,

        Error_Net_ServerNotFound,

        Error_Net_ServerUnreachable,

        Error_Net_Disconnected,

        Error_Net_WrongPassword,

        Error_Network_OnlineExpired,

        Error_Network_ServerFull,

    };

    const   Boolean IsReady;

    const   EResult LatestResult;

    const   Text CustomResultType;

    const   Text[] CustomResultData;

            Void PlayMap(Text Map,Text Mode,Text SettingsXml);

            Void PlayMapList(Text[] MapList,Text Mode,Text SettingsXml);

            Void PlayPlaylist(Text Playlist,Text OverrideMode,Text OverrideSettingsXml);

            Void PlaySplitScreen(ESplitScreenLayout LayoutType,Text[] MapList,Text Mode,Text SettingsXml);

            Void PlayMultiOnSameScreen(ESplitScreenLayout LayoutType,Text[] MapList,Text Mode,Text SettingsXml);

            Void ViewReplay(Text Replay);

            Void EditMap(Text Map,Text EditorPluginScript,Text EditorPluginArgument);

            Void EditNewMap(Text Environment,Text Decoration,Text ModUrl,Text PlayerModel,Text MapType,Text EditorPluginScript,Text EditorPluginArgument);

            Void EditBadges();

    const   CServerInfo JoinServer_ServerInfo;

            Void JoinServer_GetInfo(Text ServerLogin);

            Void JoinServer_GetInfo(Text ServerLogin,Text ServerPassword);

            Void JoinServer_Join(Boolean AsSpectator);

            Void JoinServer_Abort();

            Void Quit();

};


struct CGameScriptNotificationsConsumer : public CNod {

    enum EFilterPriority {

        All,

        MoreThanMemo,

        MoreThanNotice,

    };

    const   CGameScriptNotificationsConsumerEvent[] Events;

    const   CGameScriptNotificationsConsumerNotification[] Notifications;

    const   CGameScriptNotificationsConsumerNotification[] FilteredNotifications;

            EFilterPriority Filter_Priority;

};


struct CGameAchievementScriptManager : public CNod {

    const   CGameAchievementScriptEvent[] PendingEvents;

    const   CGameAchievementScriptAchievement[] Achievements;

    const   CGameAchievementScriptStat[] Stats;

    const   CGameAchievementScriptAchievementDesc[] AchievementDescriptions;

    const   CGameAchievementScriptStatDesc[] StatDescriptions;

            Void SendEvent(Ident UserId,Text Mnemo,Integer[] Params);

            CWebServicesTaskResult MasterServer_UplayCompleteAction(Ident UserId,Text ActionId);

            CWebServicesTaskResult MasterServer_UplayCompleteActions(Ident UserId,Text[] ActionIds);

            CGameAchievementScriptUplayAction MasterServer_GetUplayAction(Ident UserId,Text ActionId);

            Boolean MasterServer_IsUplayActionCompleted(Ident UserId,Text ActionId);

            CWebServicesTaskResult MasterServer_UplayPurchaseReward(Ident UserId,Text RewardId);

            Boolean MasterServer_IsUplayRewardPurchased(Ident UserId,Text RewardId);

    const   CWebServicesTaskResult[] MasterServer_MSTaskResults;

            Void MasterServer_ReleaseMSTaskResult(Ident TaskId);

    const   CGameAchievementScriptUplayAction[] MasterServer_UplayActions;

};


struct CGameManagerBadgeScript : public CNod {

    const   CBadge[] Badges;

            CBadge BadgeCreate();

            Void BadgeDestroy(CBadge Badge);

            Void BadgeCopy(CBadge Source,CBadge Destination);

            Void BadgeReadFromProfile(CBadge Badge,Ident UserId);

            Void BadgeWriteToProfile(CBadge Badge,Ident UserId);

            Boolean ProfileIsReady(Ident UserId);

};


struct CManiaAppPlaygroundCommon : public CManiaApp {

    const   CGameManiaAppPlaygroundScriptEvent[] PendingEvents;

    const   CPlaygroundClient Playground;

    const   CMap Map;

            CUIConfig UI;

            CUIConfig ClientUI;

};


struct CEditorPluginEvent : public CManiaAppEvent {

    enum Type {

        LayerCustomEvent,

        KeyPress,

        (reserved),

        MenuNavigation,

        ChildModuleEvent,

        ParentModuleEvent,

        CursorSelectionBegin,

        CursorSelectionEnd,

        CursorChange,

        MapModified,

        EditorInput,

        EditAnchor,

        EditObjectives,

        StartValidation,

        StartTest,

    };

    enum EInput {

        Unknown,

        Menu,

        SwitchToRace,

        Undo,

        Redo,

        CursorUp,

        CursorRight,

        CursorDown,

        CursorLeft,

        CursorRaise,

        CursorLower,

        CursorTurn,

        CursorPick,

        CursorPlace,

        CursorDelete,

        CameraUp,

        CameraRight,

        CameraDown,

        CameraLeft,

        CameraZoomNext,

        Camera0,

        Camera1,

        Camera3,

        Camera7,

        Camera9,

        PivotChange,

        CursorTurnSlightly,

        CursorTurnSlightlyAntiClockwise,

        IconUp,

        IconRight,

        IconDown,

        IconLeft,

        RemoveAll,

        Save,

        SaveAs,

        MapStyle,

        ClassicMapEditor,

    };

    const   Type Type;

    const   EInput Input;

    const   Ident EditedAnchorDataId;

    const   Boolean IsFromPad;

    const   Boolean IsFromMouse;

    const   Boolean IsFromKeyboard;

};


struct CBlockModel : public CCollector {

    enum EBaseType {

        None,

        Conductor,

        Generator,

        Collector,

    };

    enum EWayPointType {

        Start,

        Finish,

        Checkpoint,

        None,

        StartFinish,

    };

    const   Text Name;

    const   Boolean IsRoad;

    const   Boolean IsTerrain;

    const   Boolean IsPodium;

    const   EWayPointType WaypointType;

    const   Boolean NoRespawn;

    const   CBlockModelVariantGround VariantGround;

    const   CBlockModelVariantAir VariantAir;

};


struct CMacroblockModel : public CCollector {

    const   Boolean IsGround;

    const   Boolean HasStart;

    const   Boolean HasFinish;

    const   Boolean HasCheckpoint;

    const   Boolean HasMultilap;

    const   CBlockModel GeneratedBlockModel;

            Void ClearScriptMetadata();

    const   Text Name;

};


struct CBlock : public CNod {

    enum CardinalDirections {

        North,

        East,

        South,

        West,

    };

    const   Integer BlockScriptId;

    const   Boolean CanHaveAnchor;

            Void UseDefaultAnchor();

            Void UseCustomAnchor();

    const   Int3 Coord;

    const   CardinalDirections Direction;

    const   CBlockUnit[] BlockUnits;

    const   CBlockModel BlockModel;

};


struct CItemAnchor : public CNod {

    enum CardinalDirections {

        North,

        East,

        South,

        West,

    };

    const   Vec3 Position;

};


struct CAnchorData : public CNod {

    const   Text DefaultTag;

    const   Integer DefaultOrder;

            Text Tag;

            Integer Order;

    const   CBlock Block;

    const   CItemAnchor Item;

};


struct CGameManiaAppMinimal : public CManiaApp {

    const   CManiaAppEvent[] PendingEvents;

};


struct CBadge : public CNod {

            Vec3 PrimaryColor;

            Text SkinName;

            Text StickerSlot_Get(Text Slot);

            Void StickerSlot_Set(Text Slot,Text Sticker);

            Void StickerSlot_Clear();

            Text[] Layers;

};


struct CGameMasterServerOnlineSignal : public CNod {

    const   Integer OnlineSignalId;

    const   Text SenderLogin;

    const   Text SenderDisplayName;

    const   Integer TimeStamp;

};


struct CMode : public CNod {

    enum EMedal {

        None,

        Finished,

        Bronze,

        Silver,

        Gold,

        Author,

    };

    enum ESystemPlatform {

        None,

        Steam,

        UPlay,

        PS4,

        XBoxOne,

    };

    enum ESystemSkuIdentifier {

        Unknown,

        EU,

        US,

        JP,

    };

            Text ModeStatusMessage;

    const   CTitle LoadedTitle;

    const   Text ServerLogin;

    const   Text ServerName;

    const   Text ServerModeName;

    const   Text MapName;

    const   CMap Map;

    const   Text MapPlayerModelName;

    const   CUser[] Users;

    const   CTeam[] Teams;

            Text NeutralEmblemUrl;

    const   Text ForcedClubLinkUrl1;

    const   Text ForcedClubLinkUrl2;

            Void TweakTeamColorsToAvoidHueOverlap();

            Text ClientManiaAppUrl;

    const   Integer Now;

    const   Integer Period;

            Boolean MatchEndRequested;

    const   Boolean ServerShutdownRequested;

    const   Boolean MapLoaded;

            Void RequestLoadMap();

            Void RequestUnloadMap();

    const   CMapInfo[] MapList;

            Integer NextMapIndex;

    const   CUIConfigMgr UIManager;

            Void Hud_Load(Text ModuleUrl);

    const   CGamePlaygroundModuleServerHud Hud;

            Void Ladder_OpenMatch_Request();

            Void Ladder_AddPlayer(CScore PlayerScore);

            Void Ladder_OpenMatch_BeginRequest();

            Void Ladder_OpenMatch_AddPlayer(CScore PlayerScore);

            Void Ladder_OpenMatch_EndRequest();

            Void Ladder_CloseMatchRequest();

            Void Ladder_CancelMatchRequest();

    const   Boolean Ladder_RequestInProgress;

            Void Ladder_SetResultsVersion(Integer Version);

            Void Ladder_SetMatchMakingMatchId(Integer MatchId);

            Void Ladder_EnableChallengeMode(Boolean Enable);

            Boolean Admin_KickUser(CUser User,Text Reason);

            Void Admin_SetLobbyInfo(Boolean IsLobby,Integer LobbyPlayerCount,Integer LobbyMaxPlayerCount,Real LobbyPlayersLevel);

            Void AutoTeamBalance();

            Void Solo_SetNewRecord(CScore PlayerScore,EMedal PlayerScore);

    const   Boolean Solo_NewRecordSequenceInProgress;

    const   CXmlRpc XmlRpc;

    const   CXmlManager Xml;

    const   CHttpManager Http;

    const   CInputManager Input;

    const   CDataMgr DataMgr;

    const   CScoreMgr ScoreMgr;

    const   ESystemPlatform SystemPlatform;

    const   ESystemSkuIdentifier SystemSkuIdentifier;

            Integer Synchro_AddBarrier();

            Boolean Synchro_BarrierReached(Integer Barrier);

            Boolean Users_AreAllies(CUser User1,CUser User2);

            Void Users_RequestSwitchToSpectator(CUser User);

            CUser Users_CreateFake(Text NickName,Integer RequestedTeam);

            Void Users_DestroyFake(CUser User);

            Void Users_SetNbFakeUsers(Integer NbTeam1,Integer NbTeam2);

            Void Users_DestroyAllFakes();

            Void ItemList_Begin();

            Boolean ItemList_Begin();

            Ident ItemList_Add(Text ModelName);

            Ident ItemList_AddWithSkin(Text ModelName,Text SkinName);

            Void ItemList_End();

            Void DemoToken_StartUsingToken();

            Void DemoToken_StopUsingToken();

            Void DemoToken_GetAndUseToken(CUser User);

            Void ActionList_Begin();

            Boolean ActionList_Begin();

            Ident ActionList_Add(Text ActionName);

            Void ActionList_End();

            Boolean UseMinimap;

            Boolean Replay_AutoStart;

            Void Replay_Start();

            Void Replay_Stop();

    const   CGameAchievementScriptManager AchievementsManager;

            CManiaplanetPluginInterface GetPluginInterface(Text Name);

    const   CManiaplanetPluginInterface[] PluginInterfaces;

    const   CGamePluginInterfacesScript Plugins;

            Text Dbg_DumpDeclareForVariables(CNod Nod,Boolean StatsOnly);

};


struct CSmPlayer : public CPlayer {

    enum ESpawnStatus {

        NotSpawned,

        Spawning,

        Spawned,

    };

    const   CSmScore Score;

    const   ESpawnStatus SpawnStatus;

    const   Integer StartTime;

            Integer EndTime;

            Real AmmoGain;

            Real AmmoPower;

    const   Boolean AutoSwitchWeapon;

    const   Integer CurWeapon;

    const   Integer CurAmmo;

    const   Integer CurAmmoMax;

    const   Integer CurAmmoUnit;

            Integer Armor;

            Integer ArmorMax;

            Integer ArmorGain;

            Integer ArmorReplenishGain;

            Real ArmorPower;

            Integer Stamina;

            Real StaminaMax;

            Real StaminaGain;

            Real StaminaPower;

            Real SpeedPower;

            Real JumpPower;

            Boolean AllowWallJump;

            Boolean AllowProgressiveJump;

            Boolean UseAlternateWeaponVisual;

            Boolean IsHighlighted;

            Real EnergyLevel;

            Vec3 ForceColor;

    const   Real GetLinearHue;

            Real ForceLinearHue;

            Ident ForceModelId;

            Boolean HasShield;

            Real ThrowSpeed;

    const   Integer CurrentClan;

    const   Integer IdleDuration;

    const   Vec3 Position;

    const   Real AimYaw;

    const   Real AimPitch;

    const   Vec3 AimDirection;

    const   Boolean IsUnderground;

    const   Boolean IsTouchingGround;

    const   Boolean IsInAir;

    const   Boolean IsOnTechGround;

    const   Boolean IsOnTechLaser;

    const   Boolean IsOnTechArrow;

    const   Boolean IsOnTechArmor;

    const   Boolean IsOnTechSafeZone;

    const   Boolean IsOnTech;

    const   Boolean IsOnTechNoWeapon;

    const   Boolean IsInWater;

    const   Vec3 Velocity;

    const   Real Speed;

    const   Boolean IsInOffZone;

    const   Boolean IsCapturing;

    const   CSmMapLandmark CapturedLandmark;

    const   CSmObject[] Objects;

    const   Boolean IsFakePlayer;

    const   Boolean IsBot;

    const   CSmPlayerDriver Driver;

};


struct CSmModeEvent : public CNod {

    enum EType {

        Unknown,

        OnShoot,

        OnHit,

        OnNearMiss,

        OnArmorEmpty,

        OnCapture,

        OnShotDeny,

        OnFallDamage,

        OnCommand,

        OnPlayerAdded,

        OnPlayerRemoved,

        OnPlayerRequestRespawn,

        OnActionCustomEvent,

        OnActionEvent,

        OnPlayerTouchesObject,

        OnPlayerTriggersSector,

        OnPlayerThrowsObject,

        OnPlayerRequestActionChange,

        OnModuleCustomEvent,

        OnModuleShowRequest,

        OnModuleHideRequest,

        OnModuleStorePurchase,

        OnModuleInventoryDrop,

        OnModuleInventoryEquip,

    };

    enum EActionSlot {

        Slot_A,

        Slot_B,

        Slot_C,

        Slot_D,

        Slot_E,

        Slot_F,

        Slot_G,

        Slot_H,

    };

    enum EActionInput {

        Weapon,

        Movement,

        Activable1,

        Activable2,

        Activable3,

        Activable4,

        Consumable1,

        Consumable2,

        None,

    };

    enum EModuleType {

        Undefined,

        Hud,

        Inventory,

        Minimap,

        Store,

        ScoresTable,

        MenuBase,

        MenuBrowser,

    };

    enum EActionSlots {

        Weapon,

        Movement,

        Activable1,

        Activable2,

        Activable3,

        Activable4,

        None,

    };

    const   EType Type;

    const   CSmPlayer Player;

            Integer Damage;

    const   CSmObject VictimObject;

            Integer ShooterPoints;

    const   CSmPlayer Shooter;

    const   CSmPlayer Victim;

    const   Real Height;

    const   Real MissDist;

    const   Integer WeaponNum;

    const   Boolean ShooterUsedAction;

    const   Integer ShooterWeaponNum;

    const   EActionSlot ShooterActionSlot;

    const   Text ShooterActionId;

    const   Boolean VictimUsedAction;

    const   Integer VictimWeaponNum;

    const   EActionSlot VictimActionSlot;

    const   Text VictimActionId;

    const   EActionSlot Action_Slot;

    const   EActionInput ActionInput;

    const   Text ActionId;

    const   Text Param1;

    const   Text[] Param2;

    const   CSmObject Object;

    const   CSmMapSector Sector;

    const   CSmBlockPole BlockPole;

    const   CSmMapLandmark Landmark;

    const   CUser User;

    const   Boolean PlayerWasSpawned;

    const   Boolean PlayerWasInLadderMatch;

    const   Vec3 PlayerLastPosition;

    const   Vec3 PlayerLastAimDirection;

    const   Boolean GiveUp;

    const   Text CommandName;

    const   Boolean CommandValueBoolean;

    const   Integer CommandValueInteger;

    const   Real CommandValueReal;

    const   Text CommandValueText;

    const   Integer ActionChange;

    const   Text ItemUrl;

    const   Integer Quantity;

    const   EModuleType ModuleType;

};


struct CSmMapBase : public CNod {

            Integer Clan;

            Boolean IsActive;

    const   Integer NumberOfCollectors;

};


struct CSmMapLandmark : public CNod {

    const   Text Tag;

    const   Integer Order;

    const   Vec3 Position;

    const   CSmMapBase Base;

    const   CSmMapGate Gate;

    const   CSmMapGauge Gauge;

    const   CSmMapSector Sector;

    const   CSmMapPlayerSpawn PlayerSpawn;

    const   CSmMapBotPath BotPath;

    const   CSmMapBotSpawn BotSpawn;

    const   CSmMapObjectAnchor ObjectAnchor;

};


struct CSmScore : public CScore {

    const   Integer TeamNum;

            Integer Points;

            Integer RoundPoints;

    const   Integer NbEliminationsInflicted;

    const   Integer NbEliminationsTaken;

    const   Integer NbRespawnsRequested;

    const   Integer DamageInflicted;

    const   Integer DamageTaken;

            Void Clear();

};


struct CSmObject : public CNod {

    enum EStatus {

        OnPlayer,

        OnAnchor,

        InWorld,

        Unspawned,

    };

    const   EStatus Status;

    const   Ident ModelId;

            Void SetAnchor(CSmMapObjectAnchor ObjectAnchor);

            Void SetPlayer(CSmPlayer Player);

            Void SetPosition(Vec3 Position);

            Void SetPositionAndVel(Vec3 Position,Vec3 Vel);

            Void SetUnspawned();

    const   CSmPlayer Player;

    const   CSmMapLandmark AnchorLandmark;

    const   Vec3 Position;

    const   Vec3 Vel;

            Integer MachineState;

            Boolean Throwable;

};


struct CMlScriptIngame : public CMlScript {

    enum EUISound {

        Default,

        Silence,

        StartMatch,

        EndMatch,

        StartRound,

        EndRound,

        PhaseChange,

        TieBreakPoint,

        TiePoint,

        VictoryPoint,

        Capture,

        TimeOut,

        Notice,

        Warning,

        PlayerEliminated,

        PlayerHit,

        Checkpoint,

        Finish,

        Record,

        ScoreProgress,

        RankChange,

        Bonus,

        FirstHit,

        Combo,

        PlayersRemaining,

        Custom1,

        Custom2,

        Custom3,

        Custom4,

    };

    enum EInGameMenuResult {

        Resume,

        Quit,

        NormalMenu,

        AdvancedMenu,

        ServerSettings,

    };

    const   Integer GameTime;

    const   CPlaygroundClient Playground;

            CUIConfig UI;

            CUIConfig ClientUI;

    const   Boolean IsSpectator;

    const   Boolean IsSpectatorClient;

    const   Boolean UseClans;

    const   Boolean UseForcedClans;

    const   CManiaAppPlaygroundCommon ParentApp;

    const   CMap Map;

            Void ShowCurChallengeCard();

            Void ShowModeHelp();

            Void CopyServerLinkToClipBoard();

            Void JoinTeam1();

            Void JoinTeam2();

    const   CTeam[] Teams;

            Void RequestSpectatorClient(Boolean Spectator);

            Void SetSpectateTarget(Text Player);

            Void ShowProfile(Text Player);

            Void ShowInGameMenu();

            Void CloseInGameMenu(EInGameMenuResult Result);

            Void CloseScoresTable();

    const   Boolean IsInGameMenuDisplayed;

    const   Text CurrentServerLogin;

    const   Text CurrentServerName;

    const   Text CurrentServerDesc;

    const   Text CurrentServerJoinLink;

    const   Text CurrentServerModeName;

            Void PlayUiSound(EUISound Sound,Integer SoundVariant,Real Volume);

    const   CGameAchievementScriptManager AchievementsManager;

};


struct CSmActionEvent : public CNod {

    enum EType {

        OnHitPlayer,

        OnProjectileStart,

        OnProjectileEnd,

        OnActiveChange,

        OnHitObject,

    };

    const   EType Type;

    const   CSmPlayer Player;

    const   CSmObject Object;

    const   Integer Damage;

    const   Ident ProjectileModelId;

    const   Integer ContextId;

    const   Vec3 Position;

    const   Vec3 Direction;

    const   Vec3 Normal;

};


struct CMapType : public CEditorPlugin {

    enum ValidationStatus {

        NotValidable,

        Validable,

        Validated,

    };

            Boolean CustomEditAnchorData;

            Void ClearMapMetadata();

            ValidationStatus ValidationStatus;

            Text ValidabilityRequirementsMessage;

            Boolean ValidationEndRequested;

            Boolean ValidationEndNoConfirm;

            Void RequestEnterPlayground();

            Void RequestLeavePlayground();

    const   Boolean IsSwitchedToPlayground;

    const   CUIConfigMgr UIManager;

    const   CUser[] Users;

};


struct CTmMlPlayer : public CPlayer {

    enum ERaceState {

        BeforeStart,

        Running,

        Finished,

        Eliminated,

    };

    enum ETmRacePlayerCoopMode {

        None,

        Symbiosys,

        Checkpoint,

    };

    enum ETmJumpMode {

        Disabled,

        Simple,

        Double,

        Infinite,

    };

    enum ETmBonusModeEventType {

        None,

        Bumps,

        LowGravity,

        FreeWheeling,

        LockedDirections,

    };

    enum ESceneVehiclePhyStuntFigure {

        None,

        StraightJump,

        Flip,

        BackFlip,

        Spin,

        Aerial,

        AlleyOop,

        Roll,

        Corkscrew,

        SpinOff,

        Rodeo,

        FlipFlap,

        Twister,

        FreeStyle,

        SpinningMix,

        FlippingChaos,

        RollingMadness,

        WreckNone,

        WreckStraightJump,

        WreckFlip,

        WreckBackFlip,

        WreckSpin,

        WreckAerial,

        WreckAlleyOop,

        WreckRoll,

        WreckCorkscrew,

        WreckSpinOff,

        WreckRodeo,

        WreckFlipFlap,

        WreckTwister,

        WreckFreeStyle,

        WreckSpinningMix,

        WreckFlippingChaos,

        WreckRollingMadness,

        TimePenalty,

        RespawnPenalty,

        Grind,

        Reset,

    };

    const   Integer CurrentClan;

    const   ERaceState RaceState;

    const   Boolean IsSpawned;

            CTrackManiaScore Score;

    const   Integer RaceStartTime;

    const   Integer LapStartTime;

            CTmResult CurRace;

            CTmResult CurLap;

    const   Integer CurrentNbLaps;

    const   Integer CurTriggerIndex;

    const   Integer CurCheckpointRaceTime;

    const   Integer CurCheckpointLapTime;

    const   Integer CoopSymbiosysPercentTotal;

    const   Integer CoopCheckpointCurController;

    const   ETmRacePlayerCoopMode CoopMode;

    const   Integer ControllerCount;

    const   Integer ControllerId0;

    const   Integer ControllerId1;

    const   Integer ControllerId2;

    const   Integer ControllerId3;

    const   Boolean ForcedAerialCamera;

    const   Boolean ButtonSmashFrenzy;

    const   Boolean EnableTurboButton;

    const   Boolean MaxiAirControl;

    const   Boolean EnableEmptyCars;

    const   ETmJumpMode JumpMode;

    const   Boolean TinyCar;

    const   Boolean EnableCatchUpSpeed;

    const   Boolean EnableStuntMode;

    const   Boolean EnableOnlineMode;

    const   Real AccelCoef;

    const   Real ControlCoef;

    const   Real GravityCoef;

    const   Vec3 Position;

    const   Vec3 AimDirection;

    const   Real AimYaw;

    const   Real AimPitch;

    const   Real Upwardness;

    const   Integer CurRaceContinuousRank;

    const   Real Distance;

    const   Real Speed;

    const   Integer DisplaySpeed;

    const   Real InputSteer;

    const   Real InputGasPedal;

    const   Boolean InputIsBraking;

    const   Real EngineRpm;

    const   Integer EngineCurGear;

    const   Real EngineTurboRatio;

    const   Integer WheelsContactCount;

    const   Integer WheelsSkiddingCount;

    const   Real DamageHullRatio;

    const   Real DamageWindowRatio;

    const   Integer InWaterDuration;

    const   Integer FreeWheelingDuration;

    const   Integer FlyingDuration;

    const   Integer SparklingDuration;

    const   Integer LightTrailsDuration;

    const   Integer SkiddingDuration;

    const   Real SkiddingDistance;

    const   Real FlyingDistance;

    const   Boolean BonusModeIsJump;

    const   Boolean BonusModeIsTurbo;

    const   Boolean BonusModeIsMiniCar;

    const   Boolean BonusModeIsBigCar;

    const   Boolean BonusModeIsEmptyCars;

    const   Boolean BonusModeIsSpeedyCars;

    const   Boolean BonusModeIsGold;

    const   Integer BonusModeEmptyCarsStock;

    const   Integer BonusModeTurboStock;

    const   Integer BonusModeJumpStock;

    const   Integer BonusBumpCooldown;

    const   Boolean BonusIsPossible;

    const   Integer BonusModeTimeTillEvent;

    const   Integer BonusModeTimeTillEndEvent;

    const   Integer BonusModeTimeTillEventWarning;

    const   ETmBonusModeEventType BonusModeEventType;

    const   Boolean BonusModeEventIsGold;

    const   Integer StuntLastTime;

    const   Integer StuntPoints;

    const   Integer StuntCombo;

    const   Boolean StuntPerfectLanding;

    const   Boolean StuntMasterLanding;

    const   Boolean StuntEpicLanding;

    const   ESceneVehiclePhyStuntFigure StuntLast;

    const   Integer StuntTurboGauge;

    const   Integer StuntTurboGaugeMax;

    const   Integer TimeElapsedSinceLastStunt;

    const   Integer StuntAngle;

    const   Integer UniqueCameraRespawnCount;

    const   Integer UniqueCameraAvailableRespawnLeft;

    const   Integer TimeLeftForStuntCombo;

    const   Integer TimeTillSmashRespawn;

    const   Integer TimeTillSmashGiveUp;

    const   Boolean SmashNeedHelp;

    const   Boolean StuntStickNeedHelp;

    const   Boolean StuntJumpNeedHelp;

    const   Real StuntJumpCharge;

    const   Real StuntMasterCharge;

    const   Real StuntEpicCharge;

            Void StuntStateReset();

    const   Integer TimeBeforeDeadlyZone;

    const   Boolean IsDeadlyZoneActive;

};


struct CTmRaceClientEvent : public CNod {

    enum EType {

        Unknown,

        WayPoint,

        Respawn,

        Turbo,

        Horn,

        Impact,

        WaterSplash,

        GlassSmash,

        PartDetached,

        StopEngine,

        StartEngine,

        AirSpawnRelease,

    };

    const   EType Type;

    const   CTmMlPlayer Player;

    const   Integer CheckpointInRace;

    const   Integer CheckpointInLap;

    const   Boolean IsEndRace;

    const   Boolean IsEndLap;

    const   Integer RaceTime;

    const   Integer LapTime;

    const   Integer StuntsScore;

    const   Integer NbRespawns;

};


struct CTmScore : public CScore {

    const   Integer TeamNum;

            Integer Points;

            CTmResult BestRace;

            CTmResult BestLap;

            Integer PrevRaceDeltaPoints;

            CTmResult PrevRace;

            CTmResult TempResult;

            Void Clear();

};


struct CTmPlayer : public CPlayer {

    enum ETmRacePlayerCoopMode {

        None,

        Symbiosys,

        Checkpoint,

    };

    enum ETmJumpMode {

        Disabled,

        Simple,

        Double,

        Infinite,

    };

    const   Integer CurrentClan;

    const   CTmScore Score;

            Integer RaceStartTime;

            Boolean IsSpawned;

            CTmResult CurRace;

            CTmResult CurLap;

            Integer CurrentNbLaps;

    const   Integer CurTriggerIndex;

    const   Vec3 Position;

    const   Real AimYaw;

    const   Real AimPitch;

    const   Vec3 AimDirection;

            Ident ForceModelId;

            Real AccelCoef;

            Real ControlCoef;

            Real GravityCoef;

            ETmRacePlayerCoopMode CoopMode;

            Integer ControllerCount;

            Integer ControllerId0;

            Integer ControllerId1;

            Integer ControllerId2;

            Integer ControllerId3;

            Boolean ForcedAerialCamera;

            Boolean ButtonSmashFrenzy;

            Boolean EnableTurboButton;

            Boolean MaxiAirControl;

            Boolean EnableEmptyCars;

            ETmJumpMode JumpMode;

            Boolean TinyCar;

            Boolean EnableCatchUpSpeed;

            Boolean EnableStuntMode;

            Boolean EnableOnlineMode;

};


struct CTmModeEvent : public CNod {

    enum EType {

        Unknown,

        StartLine,

        WayPoint,

        GiveUp,

        Respawn,

        Stunt,

        OnPlayerAdded,

        OnPlayerRemoved,

        OnCommand,

    };

    enum EStuntFigure {

        None,

        StraightJump,

        Flip,

        BackFlip,

        Spin,

        Aerial,

        AlleyOop,

        Roll,

        Corkscrew,

        SpinOff,

        Rodeo,

        FlipFlap,

        Twister,

        FreeStyle,

        SpinningMix,

        FlippingChaos,

        RollingMadness,

        WreckNone,

        WreckStraightJump,

        WreckFlip,

        WreckBackFlip,

        WreckSpin,

        WreckAerial,

        WreckAlleyOop,

        WreckRoll,

        WreckCorkscrew,

        WreckSpinOff,

        WreckRodeo,

        WreckFlipFlap,

        WreckTwister,

        WreckFreeStyle,

        WreckSpinningMix,

        WreckFlippingChaos,

        WreckRollingMadness,

        TimePenalty,

        RespawnPenalty,

        Grind,

        Reset,

    };

    const   EType Type;

    const   CTmPlayer Player;

            Integer RaceTime;

    const   Integer CheckpointInRace;

    const   Integer CheckpointInLap;

    const   Boolean IsEndLap;

    const   Boolean IsEndRace;

            Integer LapTime;

            Integer StuntsScore;

            Integer NbRespawns;

    const   Ident BlockId;

            Real Speed;

            Real Distance;

            Real Damages;

    const   EStuntFigure StuntFigure;

    const   Integer Angle;

    const   Integer Points;

    const   Integer Combo;

    const   Boolean IsStraight;

    const   Boolean IsReverse;

    const   Boolean IsMasterJump;

    const   Real Factor;

    const   CUser User;

    const   Boolean PlayerWasSpawned;

    const   Boolean PlayerWasInLadderMatch;

    const   Text CommandName;

    const   Boolean CommandValueBoolean;

    const   Integer CommandValueInteger;

    const   Real CommandValueReal;

    const   Text CommandValueText;

};


struct CMlFrame : public CMlControl {

    enum EControlType {

        Audio,

        Entry,

        FileEntry,

        Frame,

        Label,

        Quad,

        Video,

    };

    const   CMlControl[] Controls;

            CMlControl GetFirstChild(Text ControlId);

            Boolean ClipWindowActive;

            Vec2 ClipWindowRelativePosition;

            Vec2 ClipWindowSize;

            Boolean DisablePreload;

};


struct CXmlDocument : public CNod {

    const   Text TextContents;

    const   CXmlNode Root;

    const   CXmlNode[] Nodes;

            CXmlNode GetFirstChild(Text Name);

};


struct CHttpRequest : public CNod {

    const   Text Url;

    const   Text Result;

    const   Integer StatusCode;

    const   Boolean IsCompleted;

};


struct CVideo : public CNod {

    enum ETextureFilter {

        Default,

        Point,

    };

    const   CImage Image;

            Boolean IsLooping;

    const   Boolean DownloadInProgress;

    const   Real PlayLength;

            Void BeginProcessing();

            Void EndProcessing();

    const   Boolean IsProcessing;

            Boolean AutoProcessing;

            Void Play();

            Void Pause();

            Void Stop();

    const   Boolean IsPlaying;

            Real PlayCursor;

            ETextureFilter TextureFilter;

};


struct CAudioSource : public CNod {

            Void Play();

            Void Stop();

    const   Boolean IsPlaying;

    const   Boolean DownloadInProgress;

            Real Volume;

            Real FadeDuration;

            Real VolumedB;

            Real Pitch;

            Vec3 RelativePosition;

            Vec3 PanRadiusLfe;

            Real PlayCursor;

    const   Real PlayLength;

};


struct CAudioSourceMusic : public CAudioSource {

    enum EUpdateMode {

        Cut,

        OnNextBar,

        OnNextHalfBar,

        OnNextBeat,

    };

            Real[] Tracks_Volume;

            Real[] Tracks_VolumedB;

    const   Text[] Tracks_Name;

    const   Real[] Tracks_Length;

    const   Integer Tracks_Count;

    const   Real BeatsPerMinute;

    const   Real BeatDuration;

    const   Integer BeatsPerBar;

            EUpdateMode UpdateMode;

            Boolean Dbg_ForceIntensity;

            Boolean Dbg_ForceSequential;

            Boolean Dbg_ForceRandom;

            Real LPF_CutoffRatio;

            Real LPF_Q;

            Real HPF_CutoffRatio;

            Real HPF_Q;

            Real FadeTracksDuration;

            Real FadeFiltersDuration;

            Void MuteAllTracks();

            Void UnmuteAllTracks();

            Void NextVariant();

            Void NextVariant(Boolean IsIntensityDecreasing);

            Void EnableSegment(Text SegmentName);

            Boolean UseNewImplem;

};


struct CInputEvent : public CNod {

    enum EType {

        PadButtonPress,

    };

    enum EButton {

        Left,

        Right,

        Up,

        Down,

        A,

        B,

        X,

        Y,

        L1,

        R1,

        LeftStick,

        RightStick,

        Menu,

        View,

        LeftStick_Left,

        LeftStick_Right,

        LeftStick_Up,

        LeftStick_Down,

        RightStick_Left,

        RightStick_Right,

        RightStick_Up,

        RightStick_Down,

        L2,

        R2,

        None,

    };

    const   EType Type;

    const   CInputPad Pad;

    const   EButton Button;

    const   Boolean IsAutoRepeat;

    const   Integer KeyCode;

    const   Text KeyName;

};


struct CInputPad : public CNod {

    enum EButton {

        Left,

        Right,

        Up,

        Down,

        A,

        B,

        X,

        Y,

        L1,

        R1,

        LeftStick,

        RightStick,

        Menu,

        View,

        LeftStick_Left,

        LeftStick_Right,

        LeftStick_Up,

        LeftStick_Down,

        RightStick_Left,

        RightStick_Right,

        RightStick_Up,

        RightStick_Down,

        L2,

        R2,

        None,

    };

    enum EPadType {

        Keyboard,

        Generic,

        XBox,

        PlayStation,

        Vive,

    };

    const   Integer ControllerId;

    const   Ident UserId;

    const   EPadType Type;

    const   Text ModelName;

    const   Integer IdleDuration;

    const   Integer Left;

    const   Integer Right;

    const   Integer Up;

    const   Integer Down;

    const   Integer A;

    const   Integer B;

    const   Integer X;

    const   Integer Y;

    const   Integer L1;

    const   Integer R1;

    const   Integer LeftStickBut;

    const   Integer RightStickBut;

    const   Integer Menu;

    const   Integer View;

    const   Real LeftStickX;

    const   Real LeftStickY;

    const   Real RightStickX;

    const   Real RightStickY;

    const   Real L2;

    const   Real R2;

    const   EButton[] ButtonEvents;

            Void ClearRumble();

            Void AddRumble(Integer Duration,Real LargeMotor,Real SmallMotor);

            Void SetColor(Vec3 Color);

};


struct CMapInfo : public CNod {

    const   Text MapUid;

    const   Text Comments;

    const   Integer CopperPrice;

    const   Text CollectionName;

    const   Text AuthorLogin;

    const   Text AuthorNickName;

    const   Text AuthorZonePath;

    const   Text MapType;

    const   Text MapStyle;

    const   Boolean Unlocked;

    const   Boolean IsPlayable;

    const   Integer TMObjective_AuthorTime;

    const   Integer TMObjective_GoldTime;

    const   Integer TMObjective_SilverTime;

    const   Integer TMObjective_BronzeTime;

    const   Boolean TMObjective_IsLapRace;

    const   Text Name;

    const   Text Path;

    const   Text FileName;

};


struct CHighScore : public CNod {

    enum EMedal {

        None,

        Finished,

        Bronze,

        Silver,

        Gold,

        Author,

    };

    const   Text Name;

    const   Integer Time;

    const   Text Score;

    const   Integer Rank;

    const   Integer Count;

    const   Text GhostUrl;

    const   EMedal Medal;

    const   Text GhostName;

};


struct CGhost : public CNod {

    enum EDataState {

        Ready,

        InProgress,

        Error,

    };

    const   EDataState DataState;

    const   CTmResult RaceResult;

            Text Nickname;

};


struct CWebServicesTaskResult : public CNod {

    enum ETaskErrorType {

        Success,

        Canceled,

        Unexpected,

        Internal,

        DataManager,

        PrivilegeManager,

        MasterServer,

        UbiServices,

        UplayPC,

        PS4,

        XboxOne,

    };

    const   Ident Id;

    const   Boolean IsProcessing;

    const   Boolean HasSucceeded;

    const   Boolean HasFailed;

    const   Boolean IsCanceled;

    const   ETaskErrorType ErrorType;

    const   Integer ErrorCode;

    const   Text ErrorDescription;

            Void Cancel();

};


struct CWebServicesTaskResult_GhostHandle : public CWebServicesTaskResult {

};


struct CWebServicesTaskResult_BuddiesChallengeRecord : public CWebServicesTaskResult {

    const   Text Login;

    const   CHighScoreComparison[] BuddiesChallengeRecord;

            Void SortByOpponentCount();

            Void SortByOpponentDisplayName();

            Void SortByOpponentLogin();

            Void SortByOpponentRecordDate();

            Void SortByOpponentRecordTime();

};


struct CWebServicesTaskResult_BuddiesChallengeRecordsComparison : public CWebServicesTaskResult {

    const   Text Login;

    const   CHighScoreComparisonSummary[] BuddiesComparison;

            Void SortByPlayerCount();

            Void SortByOpponentLogin();

            Void SortByOpponentCount();

            Void SortByOpponentDate();

            Void SortByOpponentDisplayName();

};


struct CWebServicesTaskResult_BuddyChallengeRecordsComparison : public CWebServicesTaskResult {

    const   Text Login;

    const   Text BuddyLogin;

    const   CHighScoreComparison[] PlayerBestRecordsComparison;

    const   CHighScoreComparison[] BuddyBestRecordsComparison;

            Void SortByMapName();

            Void SortByRecordTime();

            Void SortByRecordTimeDiff();

            Void SortByRecordDate();

};


struct CWebServicesTaskResult_RealLeaderBoard : public CWebServicesTaskResult {

    const   Integer FromIndex;

    const   Integer Count;

    const   CGameRealLeaderBoardInfo[] LeaderBoardInfo;

};


struct CWebServicesTaskResult_CheckTargetedPrivilegeResultScript : public CWebServicesTaskResult_CheckTargetedPrivilegeResult {

            Void AddLogin(Text Login);

            Void StartTask();

            Boolean HasPrivilege(Text Login);

            Text GetDenyReason(Text Login);

};


struct CGameMasterServerRichPresenceTaskResult_GetOnlinePresenceForPlayersScript : public CGameMasterServerRichPresenceTaskResult_PlayerOnlinePresenceList {

    const   CGameMasterServerPlayerOnlinePresence[] OnlinePresences;

            Void AddLogin(Text Login);

            Void StartTask();

};


struct CManiaplanetPluginInterface : public CNod {

    const   Text Name;

            Void CustomEvent(Text Type,Text[] Data);

    const   CManiaplanetPluginInterfaceEvent[] PendingEvents;

};


struct CPlug : public CNod {

};


struct CGameUserScript : public CNod {

    const   Text SystemName;

    const   Text DisplayName;

    const   Vec3 Color;

    const   Boolean PersistentIsReady;

            Void PersistentSave();

    const   CGameUserProfile Config;

};


struct CMasterServerUser : public CNetMasterServerUserInfo {

    const   Boolean NeedToChangeZone;

    const   Integer ZoneLevelCount;

            Text GetZone(Integer ZoneLevel);

            Void SetSubscriptionZone(Text Zone);

    const   Integer MultiInternetPlayTimeLeft;

};


struct CWebServicesTaskResult_GetDisplayNameScriptResult : public CWebServicesTaskResult {

            Void AddLogin(Text Login);

            Void StartTask();

            Text GetDisplayName(Text Login);

};


struct CWebServicesTaskResult_Session_Get : public CWebServicesTaskResult {

    const   Text SessionId;

    const   Text ServerLogin;

    const   Text ServerPassword;

};


struct CWebServicesTaskResult_ZoneList : public CWebServicesTaskResult {

    const   Text Path;

    const   Integer ZoneCount;

    const   CZone[] Zones;

};


struct CWebServicesTaskResult_LaunchUplayScriptResult : public CWebServicesTaskResult {

            Void AddActionToComplete(Text ActionId);

            Void StartTask();

};


struct CServerInfo : public CGameNetServerInfo {

    const   Text ServerName;

    const   Text ServerLogin;

    const   Text JoinLink;

    const   Text Comment;

    const   Text ServerVersionBuild;

    const   Integer PlayerCount;

    const   Integer MaxPlayerCount;

    const   Integer SpectatorCount;

    const   Integer MaxSpectatorCount;

    const   Real PlayersLevelMin;

    const   Real PlayersLevelAvg;

    const   Real PlayersLevelMax;

    const   Integer ServerLevel;

    const   Text ServerLevelText;

    const   Text ModeName;

    const   Real LadderServerLimitMax;

    const   Real LadderServerLimitMin;

    const   Text[] PlayerNames;

    const   Text[] ChallengeNames;

    const   Integer NbChallenges;

    const   Boolean HasBuddies;

    const   Boolean IsFavourite;

    const   Boolean IsLobbyServer;

    const   Boolean IsPrivate;

};


struct CGameScriptNotificationsConsumerEvent : public CNod {

    enum EType {

        NewNotification,

        NotificationChanged,

    };

    const   EType Type;

    const   CGameScriptNotificationsConsumerNotification Notification;

};


struct CGameScriptNotificationsConsumerNotification : public CNod {

    enum ENotificationPriority {

        Memo,

        Notice,

        Alarm,

    };

    const   Text Title;

    const   Text Description;

    const   Text ImageUrl;

    const   ENotificationPriority Priority;

    const   Boolean HasBeenRead;

    const   Boolean HasBeenActivated;

            Void SetRead();

            Void SetActivated();

};


struct CGameAchievementScriptEvent : public CNod {

    enum EType {

        NewAchievement,

    };

    const   EType Type;

    const   CGameAchievementScriptAchievement Achievement;

};


struct CGameAchievementScriptAchievement : public CNod {

    const   Ident UserId;

    const   CGameAchievementScriptAchievementDesc AchievementDesc;

};


struct CGameAchievementScriptStat : public CNod {

    const   Ident UserId;

    const   CGameAchievementScriptStatDesc StatDesc;

    const   Integer Value;

};


struct CGameAchievementScriptAchievementDesc : public CNod {

    const   Text TitleId;

    const   Text DisplayName;

    const   Text Description;

    const   Text IconUrl;

};


struct CGameAchievementScriptStatDesc : public CNod {

    const   Text TitleId;

    const   Text DisplayName;

    const   Text Description;

};


struct CGameAchievementScriptUplayAction : public CNod {

    const   Text ActionId;

    const   Text Name;

    const   Text Description;

    const   Integer Value;

};


struct CGameManiaAppPlaygroundScriptEvent : public CManiaAppEvent {

    enum Type {

        LayerCustomEvent,

        KeyPress,

        (reserved),

        MenuNavigation,

        ChildModuleEvent,

        ParentModuleEvent,

        PlaygroundScriptEvent,

    };

    const   Text PlaygroundScriptEventType;

    const   Text[] PlaygroundScriptEventData;

};


struct CPlaygroundClient : public CNod {

    const   CMap Map;

    const   Integer GameTime;

    const   CUser LocalUser;

    const   CUIConfig UI;

    const   CServerInfo ServerInfo;

    const   Boolean IsSpectator;

    const   Boolean IsSpectatorClient;

    const   Boolean UseClans;

    const   Boolean UseForcedClans;

    const   Boolean IsLoadingScreen;

            Void QuitServer(Boolean Silent);

            Void QuitServerAndSetResult(Boolean Silent,Text Type,Text[] Data);

            Void JoinTeam1();

            Void JoinTeam2();

    const   CTeam[] Teams;

            Void RequestSpectatorClient(Boolean Spectator);

            Void SetSpectateTarget(Text Player);

            Void ShowProfile(Text Player);

            Boolean DisablePlayingStateTracking;

};


struct CUIConfig : public CNod {

    enum EUISequence {

        None,

        Playing,

        Intro,

        Outro,

        Podium,

        CustomMTClip,

        EndRound,

        PlayersPresentation,

        UIInteraction,

        RollingBackgroundIntro,

        CustomMTClip_WithUIInteraction,

    };

    enum EUIStatus {

        None,

        Normal,

        Warning,

        Error,

        Official,

    };

    enum EVisibility {

        None,

        Normal,

        Manual,

        ForcedHidden,

        ForcedVisible,

    };

    enum ELabelsVisibility {

        None,

        Never,

        Always,

        WhenInFrustum,

        WhenVisible,

        WhenInMiddleOfScreen,

    };

    enum EAvatarVariant {

        Default,

        Sad,

        Happy,

    };

    enum EUISound {

        Default,

        Silence,

        StartMatch,

        EndMatch,

        StartRound,

        EndRound,

        PhaseChange,

        TieBreakPoint,

        TiePoint,

        VictoryPoint,

        Capture,

        TimeOut,

        Notice,

        Warning,

        PlayerEliminated,

        PlayerHit,

        Checkpoint,

        Finish,

        Record,

        ScoreProgress,

        RankChange,

        Bonus,

        FirstHit,

        Combo,

        PlayersRemaining,

        Custom1,

        Custom2,

        Custom3,

        Custom4,

    };

    enum ENoticeLevel {

        Default,

        PlayerInfo,

        PlayerWarning,

        MapInfo,

        MapWarning,

        MatchInfo,

        MatchWarning,

    };

    enum EObserverMode {

        Default,

        Forced,

        Forbidden,

        Manual,

    };

            EUISequence UISequence;

    const   Boolean UISequenceIsCompleted;

            Text UISequence_CustomMTClip;

            Integer UISequence_CustomMTRefTime;

            Boolean UISequence_CanSkipIntroMT;

            Text UISequence_PodiumPlayersWin;

            Text UISequence_PodiumPlayersLose;

            Text ManialinkPage;

            Text BigMessage;

            Text BigMessageAvatarLogin;

            EAvatarVariant BigMessageAvatarVariant;

            EUISound BigMessageSound;

            Integer BigMessageSoundVariant;

            Text StatusMessage;

            Text GaugeMessage;

            Real GaugeRatio;

            Integer GaugeClan;

            Text MarkersXML;

    const   CUILayer[] UILayers;

            Boolean OverlayHideNotices;

            Boolean OverlayHideMapInfo;

            Boolean OverlayHideOpponentsInfo;

            Boolean OverlayHideChat;

            Boolean OverlayHideCheckPointList;

            Boolean OverlayHideRoundScores;

            Boolean OverlayHideCountdown;

            Boolean OverlayHideCrosshair;

            Boolean OverlayHideGauges;

            Boolean OverlayHideConsumables;

            Boolean OverlayHide321Go;

            Boolean OverlayHideBackground;

            Boolean OverlayHideChrono;

            Boolean OverlayHideSpeedAndDist;

            Boolean OverlayHidePersonnalBestAndRank;

            Boolean OverlayHidePosition;

            Boolean OverlayHideCheckPointTime;

            Boolean OverlayHideEndMapLadderRecap;

            Boolean OverlayHideMultilapInfos;

            Boolean OverlayHideSpectatorControllers;

            Boolean OverlayHideSpectatorInfos;

            Boolean OverlayChatHideAvatar;

            Integer OverlayChatLineCount;

            Vec2 OverlayChatOffset;

            Vec2 CountdownCoord;

            Boolean NoticesFilter_HidePlayerInfo;

            Boolean NoticesFilter_HidePlayerWarning;

            Boolean NoticesFilter_HidePlayerInfoIfNotMe;

            Boolean NoticesFilter_HidePlayerWarningIfNotMe;

            Boolean NoticesFilter_HideMapInfo;

            Boolean NoticesFilter_HideMapWarning;

            Boolean NoticesFilter_HideMatchInfo;

            Boolean NoticesFilter_HideMatchWarning;

            ENoticeLevel NoticesFilter_LevelToShowAsBigMessage;

            Text ScoreTable;

            EVisibility ScoreTableVisibility;

            Text SmallScoreTable;

            EVisibility SmallScoreTableVisibility;

            Boolean ScoreTableOnlyManialink;

            Boolean AltMenuNoDefaultScores;

            Boolean AltMenuNoCustomScores;

            Boolean OverlayScoreSummary;

            Ident ScoreSummary_Player1;

            Integer ScoreSummary_Points1;

            Integer ScoreSummary_RoundPoints1;

            Integer ScoreSummary_MatchPoints1;

            Real ScoreSummary_Gauge1;

            Ident ScoreSummary_Player2;

            Integer ScoreSummary_Points2;

            Integer ScoreSummary_RoundPoints2;

            Integer ScoreSummary_MatchPoints2;

            Real ScoreSummary_Gauge2;

            Boolean ScreenIn3dHideScoreSummary;

            Boolean ScreenIn3dHideVersus;

            Integer CountdownEndTime;

            EUIStatus UIStatus;

            ELabelsVisibility AlliesLabelsVisibility;

            EVisibility AlliesLabelsShowGauges;

            EVisibility AlliesLabelsShowNames;

            Integer AlliesLabelsMaxCount;

            ELabelsVisibility TeamLabelsVisibility;

            EVisibility TeamLabelsShowGauges;

            EVisibility TeamLabelsShowNames;

            ELabelsVisibility OpposingTeamLabelsVisibility;

            EVisibility OpposingTeamLabelsShowGauges;

            EVisibility OpposingTeamLabelsShowNames;

            Boolean ForceSpectator;

            Integer SpectatorForceCameraType;

            Ident SpectatorAutoTarget;

            Ident SpectatorForcedTarget;

            Integer SpectatorForcedClan;

            Real SpectatorCamAutoLatitude;

            Real SpectatorCamAutoLongitude;

            Real SpectatorCamAutoRadius;

            EObserverMode SpectatorObserverMode;

            Void SendChat(Text Text);

            Void SendNotice(Text Text,ENoticeLevel Level,CUser Avatar,EAvatarVariant AvatarVariant,EUISound Sound,Integer SoundVariant);

            Text GetLayerManialinkAction(CUILayer Layer);

            Void ClearLayerManialinkAction(CUILayer Layer);

};


struct CCollector : public CNod {

    enum EProdState {

        Aborted,

        GameBox,

        DevBuild,

        Release,

    };

    const   Text Name;

            Text PageName;

            Integer InterfaceNumber;

    const   CImage Icon;

};


struct CBlockModelVariantGround : public CBlockModelVariant {

    enum EnumAutoTerrainPlaceType {

        Auto,

        Force,

        DoNotPlace,

        DoNotDestroy,

    };

};


struct CBlockModelVariantAir : public CBlockModelVariant {

};


struct CBlockUnit : public CNod {

    const   Int3 Offset;

    const   CBlockUnitModel BlockUnitModel;

    const   CBlock Block;

};


struct CTeam : public CNod {

            Text Name;

            Text ZonePath;

            Text City;

            Text EmblemUrl;

            Text PresentationManialinkUrl;

            Text ClubLinkUrl;

            Vec3 ColorPrimary;

            Vec3 ColorSecondary;

    const   Text ColorText;

    const   Text ColorizedName;

};


struct CUIConfigMgr : public CNod {

            Void ResetAll();

    const   CUIConfig UIAll;

    const   CUIConfig[] UI;

            CUIConfig GetUI(CPlayer Player);

            CUIConfig GetUI(CUser User);

    const   CUILayer[] UILayers;

            CUILayer UILayerCreate();

            Void UILayerDestroy(CUILayer Layer);

            Void UILayerDestroyAll();

    const   CUILayer[] UIReplayLayers;

            Integer UISequenceMaxDuration;

            Boolean HoldLoadingScreen;

};


struct CGamePlaygroundModuleServerHud : public CNod {

            CGamePlaygroundModuleServerInventory Inventory;

            CGamePlaygroundModuleServerStore Store;

            CGamePlaygroundModuleServerScoresTable ScoresTable;

};


struct CXmlRpc : public CNod {

    const   CXmlRpcEvent[] PendingEvents;

            Void SendCallback(Text Param1,Text Param2);

            Void SendCallbackArray(Text Type,Text[] Data);

            Void SendCallback_BeginRound();

            Void SendCallback_EndRound();

};


struct CPlayer : public CNod {

    const   CUser User;

    const   Integer RequestedClan;

    const   Boolean RequestsSpectate;

};


struct CSmPlayerDriver : public CNod {

    enum ESmDriverBehaviour {

        Static,

        Turret,

        Scripted,

        IA,

        Patrol,

        Escape,

        Saunter,

    };

    enum ESmDriverPatrolMode {

        OneTrip,

        BackAndForth,

        Loop,

    };

    enum ESmAttackFilter {

        All,

        AllPlayers,

        AllBots,

        AllOpposite,

        OppositePlayers,

        OppositeBots,

        Nobody,

    };

            ESmDriverBehaviour Behaviour;

            Real AggroRadius;

            Real ShootRadius;

            Real TargetMinDistance;

            Real DisengageDistance;

            Real PathSpeedCoef;

            Real Accuracy;

            Integer ReactionTime;

            Integer ShootPeriodMin;

            Integer ShootPeriodMax;

            Boolean RocketAnticipation;

            Real Fov;

            ESmAttackFilter AttackFilter;

    const   CSmPlayer Target;

    const   Boolean IsStuck;

            Boolean IsFlying;

    const   CSmPlayer Owner;

            Integer PathOffset;

            Real Agressivity;

            Boolean UseOldShootingSystem;

            ESmDriverPatrolMode Patrol_Mode;

            Vec3 Escape_AnchorPoint;

            Real Escape_DistanceSafe;

            Real Escape_DistanceMinEscape;

            Real Escape_DistanceMaxEscape;

            Vec3 Saunter_AnchorPoint;

            Integer Saunter_BaseChillingTime;

            Integer Saunter_ChillingTimeDelta;

            Real Saunter_Radius;

            Boolean Scripted_ForceAimInMoveDir;

            CSmPlayer ForcedTarget;

            CSmPlayer[] TargetsToAvoid;

};


struct CSmMapSector : public CNod {

    const   Ident[] PlayersIds;

};


struct CSmBlockPole : public CSmBlock {

            Boolean Captured;

    const   CSmSector Sector;

    const   CSmGauge Gauge;

};


struct CSmMapGate : public CNod {

            Integer Clan;

            Boolean Automatic;

            Boolean ManualClosed;

    const   Boolean AutoClosed;

            Boolean AutoIsActive;

            Integer AutoCloseDelay;

            Integer AutoOpenSpeed;

};


struct CSmMapGauge : public CNod {

            Integer Clan;

            Real ValueReal;

            Integer Value;

            Integer Max;

            Integer Speed;

            Boolean Captured;

};


struct CSmMapPlayerSpawn : public CNod {

};


struct CSmMapBotPath : public CNod {

    const   Integer Clan;

    const   Vec3[] Path;

    const   Boolean IsFlying;

};


struct CSmMapBotSpawn : public CNod {

    const   Boolean IsFlying;

    const   Ident BotModelId;

};


struct CSmMapObjectAnchor : public CNod {

    const   Text ItemName;

    const   Ident ItemModelId;

};


struct CScore : public CNod {

    const   CUser User;

    const   Boolean IsRegisteredForLadderMatch;

    const   Real LadderScore;

            Integer LadderRankSortValue;

            Real LadderMatchScoreValue;

            Integer LadderClan;

};


struct CTrackManiaScore : public CTmScore {

};


struct CTmResult : public CNod {

    enum ETmRaceResultCriteria {

        Time,

        Stunts,

        NbRespawns,

        CheckpointsProgress,

        None,

    };

            Integer Time;

            Integer StuntsScore;

            Integer NbRespawns;

            Integer[] Checkpoints;

            Integer Compare(CTmResult Other,ETmRaceResultCriteria Criteria);

};


struct CXmlNode : public CNod {

    const   Text Name;

    const   Text TextContents;

    const   Text TextRawContents;

    const   Text TextRecursiveContents;

    const   CXmlNode[] Children;

            Text GetAttributeText(Text Name,Text DefaultValue);

            Integer GetAttributeInteger(Text Name,Integer DefaultValue);

            Real GetAttributeReal(Text Name,Real DefaultValue);

            Boolean GetAttributeBoolean(Text Name,Boolean DefaultValue);

            CXmlNode GetFirstChild(Text Name);

};


struct CHighScoreComparison : public CNod {

    const   CMapInfo MapInfo;

    const   Text Login;

    const   Integer RecordTime;

    const   Integer RecordDate;

    const   Text RecordDateString;

    const   Integer RecordElapsedTime;

    const   Integer RecordCount;

    const   Text OpponentLogin;

    const   Text OpponentDisplayName;

    const   Text OpponentRecordUrl;

    const   Integer OpponentRecordTime;

    const   Integer OpponentRecordDate;

    const   Text OpponentRecordDateString;

    const   Integer OpponentRecordElapsedTime;

    const   Integer OpponentRecordCount;

};


struct CHighScoreComparisonSummary : public CNod {

    const   Text Login;

    const   Integer BestRecordCount;

    const   Integer BestRecordLastDate;

    const   Text BestRecordLastDateString;

    const   Integer BestRecordElapsedTime;

    const   Text OpponentLogin;

    const   Text OpponentDisplayName;

    const   Integer OpponentBestRecordCount;

    const   Integer OpponentBestRecordLastDate;

    const   Text OpponentBestRecordLastDateString;

    const   Integer OpponentBestRecordElapsedTime;

};


struct CGameRealLeaderBoardInfo : public CNod {

    const   Integer Rank;

    const   Text Login;

    const   Text DisplayName;

    const   Real Score;

};


struct CWebServicesTaskResult_CheckTargetedPrivilegeResult : public CWebServicesTaskResult {

};


struct CGameMasterServerRichPresenceTaskResult_PlayerOnlinePresenceList : public CWebServicesTaskResult {

};


struct CGameMasterServerPlayerOnlinePresence : public CNod {

    const   Text Login;

    const   Text DisplayName;

    const   Text ServerLogin;

    const   Boolean IsOnline;

};


struct CManiaplanetPluginInterfaceEvent : public CNod {

    enum EType {

        PluginCustomEvent,

    };

    const   EType Type;

    const   Text EventType;

    const   Text[] EventData;

};


struct CGameUserProfile : public CNod {

            Text SkinName;

            Vec3 PrimaryColor;

};


struct CNetMasterServerUserInfo : public CNod {

    enum EFirstPartySignInState {

        Unknown,

        NotSignedUp,

        SignedOut,

        SignedIn,

    };

    enum EMasterServerConnectionStatus {

        NotConnected,

        Connecting,

        Connected,

        Disconnecting,

    };

    enum EMasterServerConnectionDetailedStatus {

        NotConnected,

        CheckingNetworkAvailability,

        CheckingMasterServerConnexion,

        WaitingCredentials,

        CheckingMasterServerWaitingQueue,

        WaitingOnMasterServerQueue,

        WaitingSubscriptionCredentials,

        CheckingSubscriptionCredentials,

        WaitingSubscriptionInfo,

        Subscribe,

        OpeningSession,

        Identifying,

        GettingZones,

        WaitingNewZone,

        ChangingZone,

        GettingOnlineProfile,

        SynchronizingProfileChunks,

        AssociatingKey,

        UpdatingProfile,

        GettingBannedCryptedChecksumsList,

        GettingTitleInfo,

        ConnectingToUbiServices,

        FinalizingConnection,

        Connected,

        Disconnecting,

    };

    enum EMasterServerConnectionError {

        None,

        NetworkNotAvailable,

        FirstPartySignedOut,

        NoUbiServicesSession,

        MasterServerDisabled,

        MasterServerInSafeMode,

        KillSwitchEnabled,

        BetaBanned,

        BetaNotApproved,

        NoUplayPC,

    };

    enum ETaskErrorType {

        Success,

        Canceled,

        Unexpected,

        Internal,

        DataManager,

        PrivilegeManager,

        MasterServer,

        UbiServices,

        UplayPC,

        PS4,

        XboxOne,

    };

    const   Ident Id;

    const   Text Login;

    const   Text DisplayName;

    const   EMasterServerConnectionStatus ConnectionStatus;

    const   ETaskErrorType LastConnectionErrorType;

    const   Integer LastConnectionErrorCode;

    const   Text LastConnectionErrorDescription;

    const   Boolean HasUplayProfile;

    const   Boolean HasAcceptedNDA;

    const   CNetUbiServicesNews[] UbiServicesSpaceNews;

    const   CNetUbiServicesNews[] UbiServicesProfileNews;

};


struct CZone : public CNod {

    const   Text Name;

    const   Text Path;

    const   Text FullPath;

    const   Text FlagUrl;

};


struct CGameNetServerInfo : public CNetMasterHost {

};


struct CBlockModelVariant : public CNod {

            Text Name;

    const   Boolean IsAllUnderground;

    const   Boolean IsPartUnderground;

    const   Int3 Size;

    const   Int3 OffsetBoundingBoxMin;

    const   Int3 OffsetBoundingBoxMax;

            CBlockUnitModel[] BlockUnitModels;

};


struct CBlockUnitModel : public CNod {

    enum CardinalDirEnum {

        North,

        East,

        South,

        West,

    };

    enum MultiDirEnum {

        SameDir,

        SymmetricalDirs,

        AllDir,

        OpposedDirOnly,

        PerpendicularDirsOnly,

        NextDirOnly,

        PreviousDirOnly,

    };

    const   Int3 Offset;

    const   CBlockModelClip[] Clips;

};


struct CGamePlaygroundModuleServerScoresTable : public CGamePlaygroundModuleServer {

            Void SetFooterText(Text FooterText);

            Void SetColumnValue(CPlayer Player,Text ColumnName,Text ColumnValue);

            Void SetColumnValue(CPlayer Player,Text ColumnName,Integer ColumnValue);

            Void SetColumnValue(CPlayer Player,Text ColumnName,Real ColumnValue);

};


struct CXmlRpcEvent : public CNod {

    enum EType {

        Unknown,

        Callback,

        CallbackArray,

    };

    const   EType Type;

    const   Text Param1;

    const   Text Param2;

    const   Text ParamArray1;

    const   Text[] ParamArray2;

};


struct CSmBlock : public CSmLandmark {

    const   CSmBase Base;

};


struct CSmSector : public CNod {

    const   Ident[] PlayersIds;

};


struct CSmGauge : public CNod {

            Integer Clan;

            Real ValueReal;

            Integer Value;

            Integer Max;

            Integer Speed;

};


struct CNetUbiServicesNews : public CNod {

    const   Ident Id;

    const   Text NewsId;

    const   Text Type;

    const   Text Placement;

    const   Text Locale;

    const   Text Title;

    const   Text Body;

    const   Text MediaUrl;

    const   Text MediaType;

    const   Integer Priority;

    const   Integer DisplayTime;

            Integer GetPublicationDate(Integer Month,Integer Day,Integer Hour,Integer Minute,Integer Second);

    const   Integer LinksCount;

            Void GetLinkInfo(Integer LinkIndex,Text Type,Text Param,Text ActionName,Text ActionDescription);

};


struct CNetMasterHost : public CNod {

};


struct CBlockModelClip : public CBlockModel {

    enum EnumClipType {

        ClassicClip,

        FreeClipSide,

        FreeClipTop,

        FreeClipBottom,

    };

    enum MultiDirEnum {

        SameDir,

        SymmetricalDirs,

        AllDir,

        OpposedDirOnly,

        PerpendicularDirsOnly,

        NextDirOnly,

        PreviousDirOnly,

    };

};


struct CSmLandmark : public CNod {

    const   Text Tag;

    const   Integer Order;

    const   Vec3 Position;

    const   Vec3 DirFront;

};


struct CSmBase : public CNod {

            Integer Clan;

            Boolean IsActive;

    const   Integer NumberOfCollectors;

};


namespace MathLib {


    Integer Abs(Integer Argument1);

    Real Abs(Real Argument1);

    Real ToReal(Integer Argument1);

    Real Sin(Real Argument1);

    Real Cos(Real Argument1);

    Real Tan(Real Argument1);

    Real Atan2(Real Argument1, Real Argument2);

    Real Exp(Real Argument1);

    Real Rand(Real Argument1, Real Argument2);

    Real Rand(Real Argument1, Real Argument2, Integer Argument3);

    Integer Rand(Integer Argument1, Integer Argument2);

    Integer Rand(Integer Argument1, Integer Argument2, Integer Argument3);

    Real NearestReal(Integer Argument1);

    Integer NearestInteger(Real Argument1);

    Integer FloorInteger(Real Argument1);

    Integer CeilingInteger(Real Argument1);

    Real Distance(Vec3 Argument1, Vec3 Argument2);

    Real DotProduct(Vec3 Argument1, Vec3 Argument2);

    Vec3 CrossProduct(Vec3 Argument1, Vec3 Argument2);

    Real Angle(Vec3 Argument1, Vec3 Argument2);

    Real OrientedAngle(Vec3 Argument1, Vec3 Argument2);

    Real PI();

    Real Asin(Real Argument1);

    Real Acos(Real Argument1);

    Real Pow(Real Argument1, Real Argument2);

    Real Ln(Real Argument1);

    Real Sqrt(Real Argument1);

    Integer Max(Integer _A, Integer _B);

    Integer Min(Integer _A, Integer _B);

    Integer Clamp(Integer _X, Integer _Min, Integer _Max);

    Real Max(Real _A, Real _B);

    Real Min(Real _A, Real _B);

    Real Clamp(Real _X, Real _Min, Real _Max);

    Real Mod(Real _X, Real _Min, Real _Max);

};


namespace TextLib {


    Real ToReal(Text _Text);

    Integer ToInteger(Text _Text);

    Vec3 ToColor(Text _Text);

    Text SubString(Text _Text, Integer _Start, Integer _Length);

    Text SubText(Text _Text, Integer _Start, Integer _Length);

    Integer Length(Text _Text);

    Text ToText(Integer _Integer);

    Text ToText(Real _Real);

    Text ToText(Boolean _Boolean);

    Text ToText(Int3 _Int3);

    Text ToText(Vec3 _Vec3);

    Text TimeToText(Integer _Time, Boolean _IncludeCentiSeconds);

    Text TimeToText(Integer _Time);

    Text ColorToText(Vec3 _Color);

    Text FormatInteger(Integer Argument1, Integer Argument2);

    Text FormatReal(Real _Value, Integer _FPartLength, Boolean _HideZeroes, Boolean _HideDot);

    Text ToUpperCase(Text _TextToChange);

    Text ToLowerCase(Text _TextToChange);

    Text CloseStyleTags(Text _String);

    Boolean CompareWithoutFormat(Text _Text1, Text _Text2, Boolean _IsCaseSensitive);

    Boolean Find(Text _TextToFind, Text _TextToSearchIn, Boolean _IsFormatSensitive, Boolean _IsCaseSensitive);

    Text Compose(Text Argument1);

    Text Compose(Text Argument1, Text Argument2);

    Text Compose(Text Argument1, Text Argument2, Text Argument3);

    Text Compose(Text Argument1, Text Argument2, Text Argument3, Text Argument4);

    Text Compose(Text Argument1, Text Argument2, Text Argument3, Text Argument4, Text Argument5);

    Text Compose(Text Argument1, Text Argument2, Text Argument3, Text Argument4, Text Argument5, Text Argument6);

    Text MLEncode(Text Argument1);

    Text URLEncode(Text Argument1);

    Text StripFormatting(Text Argument1);

    Text[Void] Split(Text _Separators, Text _Text);

    Text Join(Text _Separator, Text[Void] _Texts);

    Text SmartSplit(Text Argument1, Integer Argument2, Integer Argument3, Integer Argument4);

    Text Trim(Text Argument1);

    Text ReplaceChars(Text Argument1, Text Argument2, Text Argument3);

    Text Replace(Text _Text, Text _ToReplace, Text _Replacement);

    Text GetTranslatedText(Text _Text);

};


namespace MapUnits {


    CardinalDirections GetNextDir(CardinalDirections Argument1);

    CardinalDirections GetPreviousDir(CardinalDirections Argument1);

    CardinalDirections GetOpposedDir(CardinalDirections Argument1);

    CardinalDirections AddDirs(CardinalDirections Argument1, CardinalDirections Argument2);

    CardinalDirections SubDirs(CardinalDirections Argument1, CardinalDirections Argument2);

    Int3 GetNeighbourCoord(Int3 Argument1, CardinalDirections Argument2);

    Int3 GetRotatedOffset(Int3 Argument1, CardinalDirections Argument2);

    Int3 GetRotatedOffsetPositive(Int3 Argument1, CardinalDirections Argument2, Int3 Argument3);

};


namespace AnimLib {


    Real SmoothStep(Real _X);

    Real Ease(Text _Function, Real _T, Real _Base, Real _Change, Real _Duration);

    Real EaseLinear(Integer _T, Real _Base, Real _Change, Integer _Duration);

    Real EaseInQuad(Integer _T, Real _Base, Real _Change, Integer _Duration);

    Real EaseOutQuad(Integer _T, Real _Base, Real _Change, Integer _Duration);

    Real EaseInOutQuad(Integer _T, Real _Base, Real _Change, Integer _Duration);

    Real EaseInCubic(Integer _T, Real _Base, Real _Change, Integer _Duration);

    Real EaseOutCubic(Integer _T, Real _Base, Real _Change, Integer _Duration);

    Real EaseInOutCubic(Integer _T, Real _Base, Real _Change, Integer _Duration);

    Real EaseInQuart(Integer _T, Real _Base, Real _Change, Integer _Duration);

    Real EaseOutQuart(Integer _T, Real _Base, Real _Change, Integer _Duration);

    Real EaseInOutQuart(Integer _T, Real _Base, Real _Change, Integer _Duration);

    Real EaseInQuint(Integer _T, Real _Base, Real _Change, Integer _Duration);

    Real EaseOutQuint(Integer _T, Real _Base, Real _Change, Integer _Duration);

    Real EaseInOutQuint(Integer _T, Real _Base, Real _Change, Integer _Duration);

    Real EaseInSine(Integer _T, Real _Base, Real _Change, Integer _Duration);

    Real EaseOutSine(Integer _T, Real _Base, Real _Change, Integer _Duration);

    Real EaseInOutSine(Integer _T, Real _Base, Real _Change, Integer _Duration);

    Real EaseInExp(Integer _T, Real _Base, Real _Change, Integer _Duration);

    Real EaseOutExp(Integer _T, Real _Base, Real _Change, Integer _Duration);

    Real EaseInOutExp(Integer _T, Real _Base, Real _Change, Integer _Duration);

    Real EaseInCirc(Integer _T, Real _Base, Real _Change, Integer _Duration);

    Real EaseOutCirc(Integer _T, Real _Base, Real _Change, Integer _Duration);

    Real EaseInOutCirc(Integer _T, Real _Base, Real _Change, Integer _Duration);

    Real EaseInBack(Integer _T, Real _Base, Real _Change, Integer _Duration);

    Real EaseOutBack(Integer _T, Real _Base, Real _Change, Integer _Duration);

    Real EaseInOutBack(Integer _T, Real _Base, Real _Change, Integer _Duration);

    Real EaseInElastic(Integer _T, Real _Base, Real _Change, Integer _Duration);

    Real EaseOutElastic(Integer _T, Real _Base, Real _Change, Integer _Duration);

    Real EaseInOutElastic(Integer _T, Real _Base, Real _Change, Integer _Duration);

    Real EaseInElastic2(Integer _T, Real _Base, Real _Change, Integer _Duration);

    Real EaseOutElastic2(Integer _T, Real _Base, Real _Change, Integer _Duration);

    Real EaseInOutElastic2(Integer _T, Real _Base, Real _Change, Integer _Duration);

    Real EaseInBounce(Integer _T, Real _Base, Real _Change, Integer _Duration);

    Real EaseOutBounce(Integer _T, Real _Base, Real _Change, Integer _Duration);

    Real EaseInOutBounce(Integer _T, Real _Base, Real _Change, Integer _Duration);

};


Boolean
Definition doc.h:4

Ident
Definition doc.h:9

Int3
Definition doc.h:8

Integer
Definition doc.h:2

Real
Definition doc.h:3

Text
Definition doc.h:5

Vec2
Definition doc.h:6

Vec3
Definition doc.h:7

Void
Definition doc.h:1

AnimLib
(undocumented)
Definition doc.h:11753

AnimLib::EaseInBounce
Real EaseInBounce(Integer _T, Real _Base, Real _Change, Integer _Duration)
Returns the value animated from Base to Base+Delta using R. Penner easing functions.

AnimLib::EaseInOutCirc
Real EaseInOutCirc(Integer _T, Real _Base, Real _Change, Integer _Duration)
Returns the value animated from Base to Base+Delta using R. Penner easing functions.

AnimLib::EaseOutCubic
Real EaseOutCubic(Integer _T, Real _Base, Real _Change, Integer _Duration)
Returns the value animated from Base to Base+Delta using R. Penner easing functions.

AnimLib::EaseOutElastic
Real EaseOutElastic(Integer _T, Real _Base, Real _Change, Integer _Duration)
Returns the value animated from Base to Base+Delta using R. Penner easing functions.

AnimLib::EaseInSine
Real EaseInSine(Integer _T, Real _Base, Real _Change, Integer _Duration)
Returns the value animated from Base to Base+Delta using R. Penner easing functions.

AnimLib::EaseInOutSine
Real EaseInOutSine(Integer _T, Real _Base, Real _Change, Integer _Duration)
Returns the value animated from Base to Base+Delta using R. Penner easing functions.

AnimLib::EaseInQuart
Real EaseInQuart(Integer _T, Real _Base, Real _Change, Integer _Duration)
Returns the value animated from Base to Base+Delta using R. Penner easing functions.

AnimLib::EaseInOutElastic
Real EaseInOutElastic(Integer _T, Real _Base, Real _Change, Integer _Duration)
Returns the value animated from Base to Base+Delta using R. Penner easing functions.

AnimLib::EaseOutQuint
Real EaseOutQuint(Integer _T, Real _Base, Real _Change, Integer _Duration)
Returns the value animated from Base to Base+Delta using R. Penner easing functions.

AnimLib::EaseInCubic
Real EaseInCubic(Integer _T, Real _Base, Real _Change, Integer _Duration)
Returns the value animated from Base to Base+Delta using R. Penner easing functions.

AnimLib::EaseLinear
Real EaseLinear(Integer _T, Real _Base, Real _Change, Integer _Duration)
Returns the value animated from Base to Base+Delta using R. Penner easing functions.

AnimLib::EaseInOutQuad
Real EaseInOutQuad(Integer _T, Real _Base, Real _Change, Integer _Duration)
Returns the value animated from Base to Base+Delta using R. Penner easing functions.

AnimLib::EaseOutElastic2
Real EaseOutElastic2(Integer _T, Real _Base, Real _Change, Integer _Duration)
Returns the value animated from Base to Base+Delta using R. Penner easing functions.

AnimLib::EaseOutBack
Real EaseOutBack(Integer _T, Real _Base, Real _Change, Integer _Duration)
Returns the value animated from Base to Base+Delta using R. Penner easing functions.

AnimLib::EaseOutBounce
Real EaseOutBounce(Integer _T, Real _Base, Real _Change, Integer _Duration)
Returns the value animated from Base to Base+Delta using R. Penner easing functions.

AnimLib::EaseInOutQuint
Real EaseInOutQuint(Integer _T, Real _Base, Real _Change, Integer _Duration)
Returns the value animated from Base to Base+Delta using R. Penner easing functions.

AnimLib::EaseOutQuart
Real EaseOutQuart(Integer _T, Real _Base, Real _Change, Integer _Duration)
Returns the value animated from Base to Base+Delta using R. Penner easing functions.

AnimLib::EaseInOutBack
Real EaseInOutBack(Integer _T, Real _Base, Real _Change, Integer _Duration)
Returns the value animated from Base to Base+Delta using R. Penner easing functions.

AnimLib::EaseInElastic
Real EaseInElastic(Integer _T, Real _Base, Real _Change, Integer _Duration)
Returns the value animated from Base to Base+Delta using R. Penner easing functions.

AnimLib::SmoothStep
Real SmoothStep(Real _X)
Returns the value smoothly transitionning from 0 to 1.

AnimLib::EaseInCirc
Real EaseInCirc(Integer _T, Real _Base, Real _Change, Integer _Duration)
Returns the value animated from Base to Base+Delta using R. Penner easing functions.

AnimLib::EaseInOutCubic
Real EaseInOutCubic(Integer _T, Real _Base, Real _Change, Integer _Duration)
Returns the value animated from Base to Base+Delta using R. Penner easing functions.

AnimLib::EaseOutExp
Real EaseOutExp(Integer _T, Real _Base, Real _Change, Integer _Duration)
Returns the value animated from Base to Base+Delta using R. Penner easing functions.

AnimLib::EaseOutSine
Real EaseOutSine(Integer _T, Real _Base, Real _Change, Integer _Duration)
Returns the value animated from Base to Base+Delta using R. Penner easing functions.

AnimLib::Ease
Real Ease(Text _Function, Real _T, Real _Base, Real _Change, Real _Duration)
Returns the value animated from Base to Base+Delta using Robert Penner easing functions....

AnimLib::EaseInOutExp
Real EaseInOutExp(Integer _T, Real _Base, Real _Change, Integer _Duration)
Returns the value animated from Base to Base+Delta using R. Penner easing functions.

AnimLib::EaseInOutElastic2
Real EaseInOutElastic2(Integer _T, Real _Base, Real _Change, Integer _Duration)
Returns the value animated from Base to Base+Delta using R. Penner easing functions.

AnimLib::EaseInBack
Real EaseInBack(Integer _T, Real _Base, Real _Change, Integer _Duration)
Returns the value animated from Base to Base+Delta using R. Penner easing functions.

AnimLib::EaseInOutBounce
Real EaseInOutBounce(Integer _T, Real _Base, Real _Change, Integer _Duration)
Returns the value animated from Base to Base+Delta using R. Penner easing functions.

AnimLib::EaseInQuint
Real EaseInQuint(Integer _T, Real _Base, Real _Change, Integer _Duration)
Returns the value animated from Base to Base+Delta using R. Penner easing functions.

AnimLib::EaseInOutQuart
Real EaseInOutQuart(Integer _T, Real _Base, Real _Change, Integer _Duration)
Returns the value animated from Base to Base+Delta using R. Penner easing functions.

AnimLib::EaseInQuad
Real EaseInQuad(Integer _T, Real _Base, Real _Change, Integer _Duration)
Returns the value animated from Base to Base+Delta using R. Penner easing functions.

AnimLib::EaseOutCirc
Real EaseOutCirc(Integer _T, Real _Base, Real _Change, Integer _Duration)
Returns the value animated from Base to Base+Delta using R. Penner easing functions.

AnimLib::EaseInElastic2
Real EaseInElastic2(Integer _T, Real _Base, Real _Change, Integer _Duration)
Returns the value animated from Base to Base+Delta using R. Penner easing functions.

AnimLib::EaseOutQuad
Real EaseOutQuad(Integer _T, Real _Base, Real _Change, Integer _Duration)
Returns the value animated from Base to Base+Delta using R. Penner easing functions.

AnimLib::EaseInExp
Real EaseInExp(Integer _T, Real _Base, Real _Change, Integer _Duration)
Returns the value animated from Base to Base+Delta using R. Penner easing functions.

MapUnits
(undocumented)
Definition doc.h:11714

MathLib
(undocumented)
Definition doc.h:11303

MathLib::Clamp
Integer Clamp(Integer _X, Integer _Min, Integer _Max)
Returns the value X clamped to the range Min..Max.

MathLib::Max
Integer Max(Integer _A, Integer _B)
Returns the maximum between A and B.

MathLib::Min
Integer Min(Integer _A, Integer _B)
Returns the minimum between A and B.

MathLib::Mod
Real Mod(Real _X, Real _Min, Real _Max)
Returns the modulus of X in the range Min..Max.

TextLib
(undocumented)
Definition doc.h:11460

TextLib::ToColor
Vec3 ToColor(Text _Text)
Returns the RGB color corresponding to _Text.

TextLib::SubString
Text SubString(Text _Text, Integer _Start, Integer _Length)
Returns a substring of _Text.

TextLib::ToReal
Real ToReal(Text _Text)
Returns the Real corresponding to _Text.

TextLib::Split
Text[Void] Split(Text _Separators, Text _Text)
Splits a given text based on a given separators set.

TextLib::ToLowerCase
Text ToLowerCase(Text _TextToChange)
Changes upper case characters to lower case characters.

TextLib::Length
Integer Length(Text _Text)
Returns the length of _Text.

TextLib::ToText
Text ToText(Integer _Integer)
Returns the Text corresponding to _Integer.

TextLib::ColorToText
Text ColorToText(Vec3 _Color)
Returns the Text corresponding to _Color.

TextLib::TimeToText
Text TimeToText(Integer _Time, Boolean _IncludeCentiSeconds)
Returns the Text corresponding to _Time.

TextLib::GetTranslatedText
Text GetTranslatedText(Text _Text)
Lookup the text in the current translation dictionary.

TextLib::Find
Boolean Find(Text _TextToFind, Text _TextToSearchIn, Boolean _IsFormatSensitive, Boolean _IsCaseSensitive)
Returns True if the searched text is found in the text to search in.

TextLib::Replace
Text Replace(Text _Text, Text _ToReplace, Text _Replacement)
Replaces occurences of _ToReplace in _Text with _Replacement.

TextLib::Join
Text Join(Text _Separator, Text[Void] _Texts)
Joins a set of texts with the given separator.

TextLib::ToUpperCase
Text ToUpperCase(Text _TextToChange)
Changes lower case characters to upper case characters.

TextLib::FormatReal
Text FormatReal(Real _Value, Integer _FPartLength, Boolean _HideZeroes, Boolean _HideDot)
Returns the Text corresponding to a Real. With formatting.

TextLib::CompareWithoutFormat
Boolean CompareWithoutFormat(Text _Text1, Text _Text2, Boolean _IsCaseSensitive)
Compares texts without taking format characters in account.

TextLib::CloseStyleTags
Text CloseStyleTags(Text _String)
Return a string where the previously unclosed $< tags have their $> counterpart.

TextLib::ToInteger
Integer ToInteger(Text _Text)
Returns the Integer corresponding to _Text.

TextLib::SubText
Text SubText(Text _Text, Integer _Start, Integer _Length)
Returns a substring of _Text.

CAnchorData
Definition doc.h:5816

CAudioManager
Definition doc.h:3565

CAudioSource
Definition doc.h:8244

CAudioSourceMusic
Definition doc.h:8298

CAudioSourceMusic::LPF_Q
Real LPF_Q
Definition doc.h:8360

CAudioSourceMusic::LPF_CutoffRatio
Real LPF_CutoffRatio
Definition doc.h:8356

CAudioSourceMusic::HPF_CutoffRatio
Real HPF_CutoffRatio
Definition doc.h:8364

CAudioSourceMusic::HPF_Q
Real HPF_Q
Definition doc.h:8368

CBadgeEditor
Definition doc.h:2005

CBadgeEditor::CameraTransitionDuration
Real CameraTransitionDuration
Definition doc.h:2029

CBadgeEditor::MeshRotation_Acceleration
Real MeshRotation_Acceleration
Definition doc.h:2037

CBadgeEditor::MeshRotation_MaxSpeed
Real MeshRotation_MaxSpeed
Definition doc.h:2033

CBadge
Definition doc.h:5857

CBlock
Definition doc.h:5755

CBlockModelClip
Definition doc.h:11241

CBlockModel
Definition doc.h:5665

CBlockModelVariantAir
Definition doc.h:10053

CBlockModelVariantGround
Definition doc.h:10041

CBlockModelVariant
Definition doc.h:11010

CBlockUnit
Definition doc.h:10059

CBlockUnitModel
Definition doc.h:11044

CCollector
Definition doc.h:10013

CDataMgr
Definition doc.h:3762

CEditorPluginEvent
Definition doc.h:5579

CEditorPlugin
Definition doc.h:1222

CEditorPlugin::HideAlwaysCursorDirectionalArrow
Boolean HideAlwaysCursorDirectionalArrow
Definition doc.h:1799

CEditorPlugin::IsTrustedPlugin_DevBuild
Boolean IsTrustedPlugin_DevBuild
Definition doc.h:1791

CEditorPlugin::EditorStatus
const EditorStatus EditorStatus
Definition doc.h:1795

CEditorPlugin::TurboClassicMapEditorMode
Boolean TurboClassicMapEditorMode
Definition doc.h:1819

CEditorPlugin::TestMapFromCoordWithMapTypeScript
Void TestMapFromCoordWithMapTypeScript(Int3 Coord, CardinalDirections Dir)

CEditorPlugin::CursorBrightnessFactor
Real CursorBrightnessFactor
Definition doc.h:1803

CEditorPlugin::UndoHistorySize
Integer UndoHistorySize
Definition doc.h:1811

CEditorPlugin::CoppersLimit
Integer CoppersLimit
Definition doc.h:1815

CEditorPlugin::EnableUnlimitedUndoHistory
Boolean EnableUnlimitedUndoHistory
Definition doc.h:1807

CEditorPluginLayer
Definition doc.h:1994

CGameAchievementScriptAchievementDesc
Definition doc.h:9360

CGameAchievementScriptAchievementDesc::DisplayName
const Text DisplayName
Definition doc.h:9368

CGameAchievementScriptAchievement
Definition doc.h:9328

CGameAchievementScriptAchievement::UserId
const Ident UserId
Definition doc.h:9332

CGameAchievementScriptAchievement::AchievementDesc
const CGameAchievementScriptAchievementDesc AchievementDesc
Definition doc.h:9336

CGameAchievementScriptEvent
Definition doc.h:9311

CGameAchievementScriptEvent::Type
const EType Type
Definition doc.h:9318

CGameAchievementScriptEvent::Achievement
const CGameAchievementScriptAchievement Achievement
Definition doc.h:9322

CGameAchievementScriptManager
Definition doc.h:5452

CGameAchievementScriptManager::PendingEvents
const CGameAchievementScriptEvent[] PendingEvents
Definition doc.h:5456

CGameAchievementScriptManager::Achievements
const CGameAchievementScriptAchievement[] Achievements
Definition doc.h:5460

CGameAchievementScriptManager::AchievementDescriptions
const CGameAchievementScriptAchievementDesc[] AchievementDescriptions
Definition doc.h:5468

CGameAchievementScriptManager::Stats
const CGameAchievementScriptStat[] Stats
Definition doc.h:5464

CGameAchievementScriptManager::StatDescriptions
const CGameAchievementScriptStatDesc[] StatDescriptions
Definition doc.h:5472

CGameAchievementScriptStatDesc
Definition doc.h:9382

CGameAchievementScriptStatDesc::DisplayName
const Text DisplayName
Definition doc.h:9390

CGameAchievementScriptStat
Definition doc.h:9342

CGameAchievementScriptStat::Value
const Integer Value
Definition doc.h:9354

CGameAchievementScriptStat::UserId
const Ident UserId
Definition doc.h:9346

CGameAchievementScriptStat::StatDesc
const CGameAchievementScriptStatDesc StatDesc
Definition doc.h:9350

CGameAchievementScriptUplayAction
Definition doc.h:9400

CGameAchievementScriptUplayAction::Name
const Text Name
Definition doc.h:9408

CGameAchievementScriptUplayAction::Description
const Text Description
Definition doc.h:9412

CGameAchievementScriptUplayAction::ActionId
const Text ActionId
Definition doc.h:9404

CGameAchievementScriptUplayAction::Value
const Integer Value
Definition doc.h:9416

CGameManagerBadgeScript
Definition doc.h:5518

CGameManiaAppMinimal
Definition doc.h:5847

CGameManiaAppPlaygroundScriptEvent
Definition doc.h:9422

CGameMasterServerOnlineSignal_RecordBeaten
Definition doc.h:2083

CGameMasterServerOnlineSignal
Definition doc.h:5887

CGameMasterServerPlayerOnlinePresence
Definition doc.h:10811

CGameMasterServerPlayerOnlinePresence::IsOnline
const Boolean IsOnline
Definition doc.h:10827

CGameMasterServerPlayerOnlinePresence::ServerLogin
const Text ServerLogin
Definition doc.h:10823

CGameMasterServerPlayerOnlinePresence::DisplayName
const Text DisplayName
Definition doc.h:10819

CGameMasterServerPlayerOnlinePresence::Login
const Text Login
Definition doc.h:10815

CGameMasterServerRichPresenceTaskResult_GetOnlinePresenceForPlayersScript
Definition doc.h:8980

CGameMasterServerRichPresenceTaskResult_GetOnlinePresenceForPlayersScript::OnlinePresences
const CGameMasterServerPlayerOnlinePresence[] OnlinePresences
Definition doc.h:8984

CGameMasterServerRichPresenceTaskResult_GetOnlinePresenceForPlayersScript::StartTask
Void StartTask()

CGameMasterServerRichPresenceTaskResult_GetOnlinePresenceForPlayersScript::AddLogin
Void AddLogin(Text Login)

CGameMasterServerRichPresenceTaskResult_PlayerOnlinePresenceList
Definition doc.h:10805

CGameNetServerInfo
Definition doc.h:11004

CGamePlaygroundModuleServer
Definition doc.h:1082

CGamePlaygroundModuleServerHud
Definition doc.h:10178

CGamePlaygroundModuleServerInventory
Definition doc.h:1108

CGamePlaygroundModuleServerScoresTable
Definition doc.h:11073

CGamePlaygroundModuleServerStore
Definition doc.h:1138

CGamePluginInterfacesScript
Definition doc.h:4104

CGamePluginInterfacesScript::Interfaces
const CManiaplanetPluginInterface[] Interfaces
Definition doc.h:4112

CGamePluginInterfacesScript::GetInterface
CManiaplanetPluginInterface GetInterface(Text Name)

CGameRealLeaderBoardInfo
Definition doc.h:10777

CGameRealLeaderBoardInfo::Rank
const Integer Rank
Definition doc.h:10781

CGameRealLeaderBoardInfo::DisplayName
const Text DisplayName
Definition doc.h:10789

CGameRealLeaderBoardInfo::Score
const Real Score
Definition doc.h:10793

CGameRealLeaderBoardInfo::Login
const Text Login
Definition doc.h:10785

CGameScriptNotificationsConsumerEvent
Definition doc.h:9250

CGameScriptNotificationsConsumerEvent::Notification
const CGameScriptNotificationsConsumerNotification Notification
Definition doc.h:9262

CGameScriptNotificationsConsumerEvent::Type
const EType Type
Definition doc.h:9258

CGameScriptNotificationsConsumer
Definition doc.h:5425

CGameScriptNotificationsConsumer::Notifications
const CGameScriptNotificationsConsumerNotification[] Notifications
Definition doc.h:5438

CGameScriptNotificationsConsumer::Events
const CGameScriptNotificationsConsumerEvent[] Events
Definition doc.h:5434

CGameScriptNotificationsConsumerNotification
Definition doc.h:9268

CGameScriptNotificationsConsumerNotification::SetActivated
Void SetActivated()

CGameScriptNotificationsConsumerNotification::SetRead
Void SetRead()

CGameUserManagerScript
Definition doc.h:4607

CGameUserProfile
Definition doc.h:10854

CGameUserScript
Definition doc.h:9024

CGhost
Definition doc.h:8750

CHighScoreComparison
Definition doc.h:10661

CHighScoreComparisonSummary
Definition doc.h:10727

CHighScore
Definition doc.h:8704

CHttpManager
Definition doc.h:3505

CHttpManager::CreateGet
CHttpRequest CreateGet(Text Url)

CHttpRequest
Definition doc.h:8156

CHttpRequest::Result
const Text Result
Definition doc.h:8164

CHttpRequest::StatusCode
const Integer StatusCode
Definition doc.h:8168

CHttpRequest::Url
const Text Url
Definition doc.h:8160

CImage
Definition doc.h:4226

CInputEvent
Definition doc.h:8406

CInputManager
Definition doc.h:3669

CInputPad
Definition doc.h:8466

CInputPad::R2
const Real R2
Definition doc.h:8600

CInputPad::LeftStickY
const Real LeftStickY
Definition doc.h:8584

CInputPad::RightStickY
const Real RightStickY
Definition doc.h:8592

CInputPad::L2
const Real L2
Definition doc.h:8596

CInputPad::SetColor
Void SetColor(Vec3 Color)

CInputPad::AddRumble
Void AddRumble(Integer Duration, Real LargeMotor, Real SmallMotor)

CInputPad::LeftStickX
const Real LeftStickX
Definition doc.h:8580

CInputPad::RightStickX
const Real RightStickX
Definition doc.h:8588

CItemAnchor
Definition doc.h:5799

CMacroblockModel
Definition doc.h:5717

CManiaAppBrowser
Definition doc.h:4509

CManiaAppEvent
Definition doc.h:905

CManiaApp
Definition doc.h:715

CManiaAppPlaygroundCommon
Definition doc.h:5553

CManiaAppPlaygroundCommon::UI
CUIConfig UI
Definition doc.h:5569

CManiaAppPlaygroundCommon::ClientUI
CUIConfig ClientUI
Definition doc.h:5573

CManiaAppPlayground
Definition doc.h:1076

CManiaAppTitle
Definition doc.h:993

CManiaAppTitleLayer
Definition doc.h:891

CManiaPlanet
Definition doc.h:4674

CManiaPlanet::ClipboardSet
Void ClipboardSet(Text ClipboardText)

CManiaPlanet::HMD_HUD_Distance
Real HMD_HUD_Distance
Definition doc.h:5305

CManiaPlanet::MasterMusicVolume
Real MasterMusicVolume
Definition doc.h:4921

CManiaPlanet::MasterSoundVolume
Real MasterSoundVolume
Definition doc.h:4917

CManiaPlanet::HMD_MoveScale
Real HMD_MoveScale
Definition doc.h:5301

CManiaplanetPluginInterfaceEvent
Definition doc.h:10833

CManiaplanetPluginInterface
Definition doc.h:8999

CMap
Definition doc.h:4410

CMapInfo
Definition doc.h:8622

CMapType
Definition doc.h:7137

CMasterServerUser
Definition doc.h:9054

CMasterServerUser::SetSubscriptionZone
Void SetSubscriptionZone(Text Zone)

CMasterServerUser::ZoneLevelCount
const Integer ZoneLevelCount
Definition doc.h:9062

CMasterServerUser::GetZone
Text GetZone(Integer ZoneLevel)

CMlBrowser
Definition doc.h:650

CMlCamera
Definition doc.h:643

CMlControl
Definition doc.h:4119

CMlEntry
Definition doc.h:227

CMlEvent
Definition doc.h:3411

CMlFileEntry
Definition doc.h:272

CMlFrame
Definition doc.h:8094

CMlGauge
Definition doc.h:534

CMlGauge::Ratio
Real Ratio
Definition doc.h:550

CMlGauge::GradingRatio
Real GradingRatio
Definition doc.h:554

CMlGraphCurve
Definition doc.h:4383

CMlGraphCurve::Width
Real Width
Definition doc.h:4403

CMlGraph
Definition doc.h:581

CMlLabel
Definition doc.h:340

CMlMediaPlayer
Definition doc.h:419

CMlMinimap
Definition doc.h:608

CMlMinimap::ZoomFactor
Real ZoomFactor
Definition doc.h:624

CMlPage
Definition doc.h:3163

CMlQuad
Definition doc.h:458

CMlScript
Definition doc.h:15

CMlScript::SendCustomEvent
Void SendCustomEvent(Text Type, Text[] Data)

CMlScript::LocalUser
const CUser LocalUser
Definition doc.h:68

CMlScriptIngame
Definition doc.h:6923

CMlScriptIngame::RequestSpectatorClient
Void RequestSpectatorClient(Boolean Spectator)

CMlScriptIngame::SetSpectateTarget
Void SetSpectateTarget(Text Player)

CMlScriptIngame::UI
CUIConfig UI
Definition doc.h:6973

CMlScriptIngame::IsSpectator
const Boolean IsSpectator
Definition doc.h:6981

CMlScriptIngame::ClientUI
CUIConfig ClientUI
Definition doc.h:6977

CMlScriptIngame::IsSpectatorClient
const Boolean IsSpectatorClient
Definition doc.h:6985

CMlStation
Definition doc.h:1207

CMlTextEdit
Definition doc.h:283

CMode
Definition doc.h:5910

CMode::Input
const CInputManager Input
Definition doc.h:6119

CMode::SystemSkuIdentifier
const ESystemSkuIdentifier SystemSkuIdentifier
Definition doc.h:6135

CMode::DataMgr
const CDataMgr DataMgr
Definition doc.h:6123

CMode::SystemPlatform
const ESystemPlatform SystemPlatform
Definition doc.h:6131

CNetMasterHost
Definition doc.h:11235

CNetMasterServerUserInfo
Definition doc.h:10868

CNetMasterServerUserInfo::HasUplayProfile
const Boolean HasUplayProfile
Definition doc.h:10964

CNetMasterServerUserInfo::ConnectionStatus
const EMasterServerConnectionStatus ConnectionStatus
Definition doc.h:10948

CNetMasterServerUserInfo::Login
const Text Login
Definition doc.h:10940

CNetMasterServerUserInfo::HasAcceptedNDA
const Boolean HasAcceptedNDA
Definition doc.h:10968

CNetMasterServerUserInfo::DisplayName
const Text DisplayName
Definition doc.h:10944

CNetUbiServicesNews
Definition doc.h:11173

CNetUbiServicesNews::GetPublicationDate
Integer GetPublicationDate(Integer Month, Integer Day, Integer Hour, Integer Minute, Integer Second)

CNetUbiServicesNews::Title
const Text Title
Definition doc.h:11197

CNetUbiServicesNews::LinksCount
const Integer LinksCount
Definition doc.h:11225

CNetUbiServicesNews::Type
const Text Type
Definition doc.h:11185

CNetUbiServicesNews::MediaUrl
const Text MediaUrl
Definition doc.h:11205

CNetUbiServicesNews::Placement
const Text Placement
Definition doc.h:11189

CNetUbiServicesNews::NewsId
const Text NewsId
Definition doc.h:11181

CNetUbiServicesNews::Locale
const Text Locale
Definition doc.h:11193

CNetUbiServicesNews::Body
const Text Body
Definition doc.h:11201

CNetUbiServicesNews::DisplayTime
const Integer DisplayTime
Definition doc.h:11217

CNetUbiServicesNews::Priority
const Integer Priority
Definition doc.h:11213

CNetUbiServicesNews::MediaType
const Text MediaType
Definition doc.h:11209

CNetUbiServicesNews::GetLinkInfo
Void GetLinkInfo(Integer LinkIndex, Text Type, Text Param, Text ActionName, Text ActionDescription)

CNod
Definition doc.h:3152

CPlayer
Definition doc.h:10224

CPlaygroundClient
Definition doc.h:9446

CPlaygroundClient::Map
const CMap Map
Definition doc.h:9450

CPlaygroundClient::IsSpectatorClient
const Boolean IsSpectatorClient
Definition doc.h:9474

CPlaygroundClient::RequestSpectatorClient
Void RequestSpectatorClient(Boolean Spectator)

CPlaygroundClient::IsSpectator
const Boolean IsSpectator
Definition doc.h:9470

CPlug
Definition doc.h:9017

CPresenceMgr
Definition doc.h:4074

CPrivilegeMgr
Definition doc.h:4032

CPrivilegeMgr::CheckPrivilege
CWebServicesTaskResult CheckPrivilege(Ident UserId, EPrivilege Privilege)

CPrivilegeMgr::ReleaseTaskResult
Void ReleaseTaskResult(Ident TaskId)

CPrivilegeMgr::CheckTargetedPrivilege
CWebServicesTaskResult_CheckTargetedPrivilegeResultScript CheckTargetedPrivilege(Ident UserId, EPrivilege Privilege)

CPrivilegeMgr::TaskResults
const CWebServicesTaskResult[] TaskResults
Definition doc.h:4048

CScore
Definition doc.h:10545

CScoreMgr
Definition doc.h:3934

CScoreMgr::ScoreStatus_GetLocalStatus
ELocalScoreStatus ScoreStatus_GetLocalStatus(Ident UserId)

CScoreMgr::Campaign_GetMapMultiAsyncLevel
Integer Campaign_GetMapMultiAsyncLevel(Ident UserId, Text MapUid)

CScoreMgr::GlobalLeaderBoard_GetPlayerCount
Integer GlobalLeaderBoard_GetPlayerCount(Text Zone)

CScoreMgr::GlobalLeaderBoard_GetPlayerList
CWebServicesTaskResult_RealLeaderBoard GlobalLeaderBoard_GetPlayerList(Ident UserId, Text Zone, Integer FromIndex, Integer Count)

CScoreMgr::GlobalLeaderBoard_GetPlayerRanking
Integer GlobalLeaderBoard_GetPlayerRanking(Ident UserId, Text Zone)

CScoreMgr::CampaignLeaderBoard_GetPlayerRanking
Integer CampaignLeaderBoard_GetPlayerRanking(Ident UserId, Text CampaignId, Text Zone)

CScoreMgr::Campaign_GetMapRecordGhost
CWebServicesTaskResult_GhostHandle Campaign_GetMapRecordGhost(Ident UserId, Text MapUid)

CScoreMgr::MapLeaderBoard_GetPlayerCount
Integer MapLeaderBoard_GetPlayerCount(Text MapUid, Text Zone)

CScoreMgr::CampaignLeaderBoard_GetPlayerCount
Integer CampaignLeaderBoard_GetPlayerCount(Text CampaignId, Text Zone)

CScoreMgr::ScoreStatus_GetMasterServerStatus
EMasterServerScoreStatus ScoreStatus_GetMasterServerStatus(Ident UserId)

CScoreMgr::Campaign_SetNewMapRecord
CWebServicesTaskResult Campaign_SetNewMapRecord(Ident UserId, Text MapUid, CGhost Ghost)

CScoreMgr::ReleaseTaskResult
Void ReleaseTaskResult(Ident TaskId)

CScoreMgr::MapLeaderBoard_GetPlayerRanking
Integer MapLeaderBoard_GetPlayerRanking(Ident UserId, Text MapUid, Text Zone)

CScoreMgr::Campaign_GetMapRecord
Integer Campaign_GetMapRecord(Ident UserId, Text MapUid)

CScoreMgr::TaskResults
const CWebServicesTaskResult[] TaskResults
Definition doc.h:3950

CServerInfo
Definition doc.h:9148

CSmActionEvent
Definition doc.h:7087

CSmAction
Definition doc.h:2619

CSmBase
Definition doc.h:11285

CSmBlock
Definition doc.h:11127

CSmBlockPole
Definition doc.h:10410

CSmGauge
Definition doc.h:11147

CSmGauge::ValueReal
Real ValueReal
Definition doc.h:11155

CSmLandmark
Definition doc.h:11263

CSmMapBase
Definition doc.h:6745

CSmMapBotPath
Definition doc.h:10498

CSmMapBotSpawn
Definition doc.h:10516

CSmMapGate
Definition doc.h:10428

CSmMapGauge
Definition doc.h:10462

CSmMapGauge::ValueReal
Real ValueReal
Definition doc.h:10470

CSmMapLandmark
Definition doc.h:6764

CSmMapObjectAnchor
Definition doc.h:10530

CSmMapPlayerSpawn
Definition doc.h:10492

CSmMapSector
Definition doc.h:10399

CSmMapType
Definition doc.h:2762

CSmMlScriptIngame
Definition doc.h:2548

CSmModeEvent
Definition doc.h:6505

CSmMode
Definition doc.h:2114

CSmObject
Definition doc.h:6858

CSmObject::Player
const CSmPlayer Player
Definition doc.h:6896

CSmPlayerDriver
Definition doc.h:10242

CSmPlayer
Definition doc.h:6258

CSmPlayer::AmmoPower
Real AmmoPower
Definition doc.h:6287

CSmPlayer::EnergyLevel
Real EnergyLevel
Definition doc.h:6371

CSmPlayer::StaminaGain
Real StaminaGain
Definition doc.h:6339

CSmPlayer::SpeedPower
Real SpeedPower
Definition doc.h:6347

CSmPlayer::AmmoGain
Real AmmoGain
Definition doc.h:6283

CSmPlayer::ArmorPower
Real ArmorPower
Definition doc.h:6327

CSmPlayer::StaminaMax
Real StaminaMax
Definition doc.h:6335

CSmPlayer::StaminaPower
Real StaminaPower
Definition doc.h:6343

CSmPlayer::JumpPower
Real JumpPower
Definition doc.h:6351

CSmPlayer::ThrowSpeed
Real ThrowSpeed
Definition doc.h:6395

CSmPlayer::GetLinearHue
const Real GetLinearHue
Definition doc.h:6379

CSmScore
Definition doc.h:6815

CSmSector
Definition doc.h:11137

CStation
Definition doc.h:1172

CTeam
Definition doc.h:10078

CTitleFlow
Definition doc.h:5327

CTitleFlow::LatestResult
const EResult LatestResult
Definition doc.h:5351

CTitleFlow::IsReady
const Boolean IsReady
Definition doc.h:5347

CTitle
Definition doc.h:3377

CTmMapType
Definition doc.h:3130

CTmMlPlayer
Definition doc.h:7193

CTmMlScriptIngame
Definition doc.h:2781

CTmMlScriptIngame::MapCheckpointPos
const Vec3[] MapCheckpointPos
Definition doc.h:2833

CTmModeEvent
Definition doc.h:7916

CTmMode
Definition doc.h:2852

CTmMode::MapCheckpointPos
const Vec3[] MapCheckpointPos
Definition doc.h:3111

CTmPlayer
Definition doc.h:7771

CTmRaceClientEvent
Definition doc.h:7671

CTmResult
Definition doc.h:10582

CTmScore
Definition doc.h:7732

CTrackManiaScore
Definition doc.h:10576

CUIConfig
Definition doc.h:9529

CUIConfig::AlliesLabelsMaxCount
Integer AlliesLabelsMaxCount
Definition doc.h:9931

CUIConfig::OverlayChatLineCount
Integer OverlayChatLineCount
Definition doc.h:9783

CUIConfig::MarkersXML
Text MarkersXML
Definition doc.h:9687

CUIConfigMgr
Definition doc.h:10124

CUILayer
Definition doc.h:4539

CUser
Definition doc.h:3190

CVideo
Definition doc.h:8178

CVideo::AutoProcessing
Boolean AutoProcessing
Definition doc.h:8214

CVideoManager
Definition doc.h:3547

CWebServicesTaskResult_BuddiesChallengeRecord
Definition doc.h:8834

CWebServicesTaskResult_BuddiesChallengeRecord::SortByOpponentDisplayName
Void SortByOpponentDisplayName()

CWebServicesTaskResult_BuddiesChallengeRecord::Login
const Text Login
Definition doc.h:8838

CWebServicesTaskResult_BuddiesChallengeRecord::SortByOpponentLogin
Void SortByOpponentLogin()

CWebServicesTaskResult_BuddiesChallengeRecord::SortByOpponentCount
Void SortByOpponentCount()

CWebServicesTaskResult_BuddiesChallengeRecord::SortByOpponentRecordDate
Void SortByOpponentRecordDate()

CWebServicesTaskResult_BuddiesChallengeRecord::SortByOpponentRecordTime
Void SortByOpponentRecordTime()

CWebServicesTaskResult_BuddiesChallengeRecordsComparison
Definition doc.h:8868

CWebServicesTaskResult_BuddiesChallengeRecordsComparison::SortByOpponentDate
Void SortByOpponentDate()

CWebServicesTaskResult_BuddiesChallengeRecordsComparison::BuddiesComparison
const CHighScoreComparisonSummary[] BuddiesComparison
Definition doc.h:8876

CWebServicesTaskResult_BuddiesChallengeRecordsComparison::SortByOpponentCount
Void SortByOpponentCount()

CWebServicesTaskResult_BuddiesChallengeRecordsComparison::SortByOpponentDisplayName
Void SortByOpponentDisplayName()

CWebServicesTaskResult_BuddiesChallengeRecordsComparison::SortByOpponentLogin
Void SortByOpponentLogin()

CWebServicesTaskResult_BuddiesChallengeRecordsComparison::SortByPlayerCount
Void SortByPlayerCount()

CWebServicesTaskResult_BuddiesChallengeRecordsComparison::Login
const Text Login
Definition doc.h:8872

CWebServicesTaskResult_BuddyChallengeRecordsComparison
Definition doc.h:8902

CWebServicesTaskResult_BuddyChallengeRecordsComparison::PlayerBestRecordsComparison
const CHighScoreComparison[] PlayerBestRecordsComparison
Definition doc.h:8914

CWebServicesTaskResult_BuddyChallengeRecordsComparison::SortByRecordTimeDiff
Void SortByRecordTimeDiff()

CWebServicesTaskResult_BuddyChallengeRecordsComparison::BuddyBestRecordsComparison
const CHighScoreComparison[] BuddyBestRecordsComparison
Definition doc.h:8918

CWebServicesTaskResult_BuddyChallengeRecordsComparison::BuddyLogin
const Text BuddyLogin
Definition doc.h:8910

CWebServicesTaskResult_BuddyChallengeRecordsComparison::SortByRecordDate
Void SortByRecordDate()

CWebServicesTaskResult_BuddyChallengeRecordsComparison::SortByRecordTime
Void SortByRecordTime()

CWebServicesTaskResult_BuddyChallengeRecordsComparison::SortByMapName
Void SortByMapName()

CWebServicesTaskResult_BuddyChallengeRecordsComparison::Login
const Text Login
Definition doc.h:8906

CWebServicesTaskResult_CheckTargetedPrivilegeResult
Definition doc.h:10799

CWebServicesTaskResult_CheckTargetedPrivilegeResultScript
Definition doc.h:8958

CWebServicesTaskResult_CheckTargetedPrivilegeResultScript::StartTask
Void StartTask()

CWebServicesTaskResult_CheckTargetedPrivilegeResultScript::HasPrivilege
Boolean HasPrivilege(Text Login)

CWebServicesTaskResult_CheckTargetedPrivilegeResultScript::GetDenyReason
Text GetDenyReason(Text Login)

CWebServicesTaskResult_CheckTargetedPrivilegeResultScript::AddLogin
Void AddLogin(Text Login)

CWebServicesTaskResult_GetDisplayNameScriptResult
Definition doc.h:9080

CWebServicesTaskResult_GetDisplayNameScriptResult::StartTask
Void StartTask()

CWebServicesTaskResult_GetDisplayNameScriptResult::GetDisplayName
Text GetDisplayName(Text Login)

CWebServicesTaskResult_GetDisplayNameScriptResult::AddLogin
Void AddLogin(Text Login)

CWebServicesTaskResult_GhostHandle
Definition doc.h:8828

CWebServicesTaskResult_LaunchUplayScriptResult
Definition doc.h:9134

CWebServicesTaskResult_LaunchUplayScriptResult::AddActionToComplete
Void AddActionToComplete(Text ActionId)

CWebServicesTaskResult_LaunchUplayScriptResult::StartTask
Void StartTask()

CWebServicesTaskResult_RealLeaderBoard
Definition doc.h:8940

CWebServicesTaskResult_RealLeaderBoard::LeaderBoardInfo
const CGameRealLeaderBoardInfo[] LeaderBoardInfo
Definition doc.h:8952

CWebServicesTaskResult_RealLeaderBoard::FromIndex
const Integer FromIndex
Definition doc.h:8944

CWebServicesTaskResult_RealLeaderBoard::Count
const Integer Count
Definition doc.h:8948

CWebServicesTaskResult_Session_Get
Definition doc.h:9098

CWebServicesTaskResult_ZoneList
Definition doc.h:9116

CWebServicesTaskResult_ZoneList::Path
const Text Path
Definition doc.h:9120

CWebServicesTaskResult_ZoneList::ZoneCount
const Integer ZoneCount
Definition doc.h:9124

CWebServicesTaskResult_ZoneList::Zones
const CZone[] Zones
Definition doc.h:9128

CWebServicesTaskResult
Definition doc.h:8773

CWebServicesTaskResult::HasFailed
const Boolean HasFailed
Definition doc.h:8802

CWebServicesTaskResult::ErrorCode
const Integer ErrorCode
Definition doc.h:8814

CWebServicesTaskResult::IsProcessing
const Boolean IsProcessing
Definition doc.h:8794

CWebServicesTaskResult::IsCanceled
const Boolean IsCanceled
Definition doc.h:8806

CWebServicesTaskResult::HasSucceeded
const Boolean HasSucceeded
Definition doc.h:8798

CWebServicesTaskResult::ErrorType
const ETaskErrorType ErrorType
Definition doc.h:8810

CWebServicesTaskResult::ErrorDescription
const Text ErrorDescription
Definition doc.h:8818

CXmlDocument
Definition doc.h:8133

CXmlManager
Definition doc.h:3479

CXmlNode
Definition doc.h:10615

CXmlRpcEvent
Definition doc.h:11095

CXmlRpc
Definition doc.h:10197

CZone
Definition doc.h:10982