big.h

Go to the documentation of this file.

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,
        };
        const   CMlPage Page;
        const   Integer Now;
        const   Integer CurrentTime;
        const   Text CurrentTimeText;
        const   Text CurrentLocalDateText;
        const   CMlEvent[] PendingEvents;
        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;
                        Void OpenLink(Text Url,LinkType LinkType);
        const   CXmlManager Xml;
        const   CHttpManager Http;
};

struct CMlEntry : public CMlControl {
                        Text Value;
                        Void StartEdition();
};

struct CMlFileEntry : public CMlEntry {
        const   Text FullFileName;
};

struct CMlLabel : public CMlControl {
                        Void SetText(Text newText);
                        Text Value;
        const   Integer ValueLineCount;
};

struct CMlMediaPlayer : public CMlControl {
};

struct CMlQuad : public CMlControl {
                        Void ChangeImageUrl(Text fieldName);
                        Text ImageUrl;
                        Text Style;
                        Text Substyle;
        const   Boolean DownloadInProgress;
};

struct CManiaplanetPlugin : public CNod {
        const   Integer Now;
        const   CUser LocalUser;
        const   CManiaplanetPluginEvent[] PendingEvents;
        const   CBuddiesManager BuddiesManager;
        const   CUILayer[] UILayers;
                        CUILayer UILayerCreate();
                        Void UILayerDestroy(CUILayer Layer);
                        Void UILayerDestroyAll();
                        Boolean ToolBarForceShow;
        const   Boolean ToolBarIsActive;
        const   Text CurrentLocalDateText;
};

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,
        };
        const   CTmPlayer[] ConnectedPlayers;
        const   CTmPlayer[] Players;
        const   CTmPlayer[] PlayersRacing;
        const   CTmPlayer[] PlayersWaiting;
        const   CTmScore[] Scores;
        const   CTmModeEvent[] PendingEvents;
                        Void PassOn(CTmModeEvent Event);
                        Void Discard(CTmModeEvent Event);
                        Void FakePlayers_Add(Text NickName);
                        Void FakePlayers_Remove(CUser User);
                        Void FakePlayers_RemoveAll();
                        Void Scores_Sort(ETmScoreSortOrder SortOrder);
                        Void Scores_Clear();
                        Void Ladder_ComputeRank(ETmScoreSortOrder SortOrder);
                        Integer CutOffTimeLimit;
                        Integer NbLaps;
                        Boolean IndependantLaps;
                        Boolean UiRounds;
                        Boolean UiStuntsMode;
                        Boolean UiDisplayStuntsNames;
                        Boolean HideOpponents;
                        Integer ForceMaxOpponents;
                        Integer UiScoresPointsLimit;
                        ETMRespawnBehaviour RespawnBehaviour;
                        ETmRaceChronoBehaviour UiRaceChrono;
};

struct CSmMode : public CMode {
        enum EWeapon {
                Laser,
                Rocket,
                Nucleus,
        };
                        Integer StartTime;
                        Integer EndTime;
                        Boolean UseClans;
                        Boolean UseForcedClans;
                        Boolean UsePvPCollisions;
                        Boolean UsePvPWeapons;
                        Boolean UseInterractiveScreensIn3d;
                        Boolean UseLaserVsBullets;
                        Real OffZoneRadius;
                        Real OffZoneRadiusSpeed;
                        Ident OffZoneCenterBlockId;
        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[] Spectators;
        const   CSmModeEvent[] PendingEvents;
        const   CSmBase[] Bases;
        const   CSmBlock[] Blocks;
        const   CSmBlockSpawn[] BlockSpawns;
        const   CSmBlockPole[] BlockPoles;
        const   CSmScore[] Scores;
                        Integer Clan1Score;
                        Integer Clan2Score;
                        Integer[] ClanScores;
                        Void PassOn(CSmModeEvent Event);
                        Void Discard(CSmModeEvent Event);
                        Void SpawnPlayer(CSmPlayer Player,Integer ClanNum,Integer Armor,CSmBlockSpawn BlockSpawn,Integer ActivationDate);
                        Void UnspawnPlayer(CSmPlayer Player);
                        Void ClearScores();
                        Void SetPlayerClan(CSmPlayer Player,Integer ClanNum);
                        Void SetPlayerWeapon(CSmPlayer Player,EWeapon DefaultWeapon,Boolean AutoSwitchWeapon);
                        Void SetPlayerAmmo(CSmPlayer Player,EWeapon Weapon,Integer Count);
                        Void SetPlayerAmmoMax(CSmPlayer Player,EWeapon Weapon,Integer Count);
                        Integer GetWeaponIndex(EWeapon Weapon);
                        Void SetNbFakePlayers(Integer NbClan1,Integer NbClan2);
                        Void ResetTriggersForPlayers(CSmPlayer Player);
                        Void ComputeTriggeredSpawnsForPlayer(CSmPlayer Player);
        const   Integer[] TriggeredSpawns;
};

struct CTmMlScriptIngame : public CMlScriptIngame {
        const   CTmMlPlayer InputPlayer;
        const   CTmMlPlayer GUIPlayer;
        const   CTmMlPlayer[] Players;
};

struct CSmMlScriptIngame : public CMlScriptIngame {
        const   Integer ArenaNow;
        const   CSmPlayer InputPlayer;
        const   CSmPlayer GUIPlayer;
        const   CTeam[] Teams;
        const   CSmPlayer[] Players;
        const   CSmScore[] Scores;
        const   Integer[] ClanScores;
        const   CSmBase[] Bases;
        const   CSmBlock[] Blocks;
        const   CSmBlockSpawn[] BlockSpawns;
        const   CSmBlockPole[] BlockPoles;
};

struct CEditorPlugin : public CNod {
        enum CardinalDirections {
                North,
                East,
                South,
                West,
        };
        enum PlaceMode {
                Unknown,
                Terraform,
                Block,
                Macroblock,
                Skin,
                CopyPaste,
                Test,
                Plugin,
                CustomSelection,
                OffZone,
                BlockProperty,
        };
        enum EditMode {
                Unknown,
                Place,
                FreeLook,
                Erase,
                Pick,
                SelectionAdd,
                SelectionRemove,
        };
        const   CMap Map;
                        Void ComputeShadows();
                        Void Undo();
                        Void Redo();
                        Void Quit();
                        Void Help();
                        Void Validate();
                        Void AutoSave();
                        Void SaveMap(Text FileName,Text Path);
                        PlaceMode PlaceMode;
                        EditMode EditMode;
                        Boolean UndergroundMode;
                        Boolean BlockStockMode;
        const   Integer Now;
                        Int3 CursorCoord;
                        CardinalDirections CursorDir;
                        CBlockModel CursorBlockModel;
                        CBlockModel CursorTerrainBlockModel;
                        CMacroblockModel CursorMacroblockModel;
                        Real CameraVAngle;
                        Real CameraHAngle;
                        Real CameraToTargetDistance;
                        Vec3 TargetedPosition;
                        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();
                        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 BlockModel,Int3 Coord,CardinalDirections Dir);
                        Boolean PlaceMacroblock(CMacroblockModel BlockModel,Int3 Coord,CardinalDirections Dir);
                        Boolean CanPlaceMacroblock_NoDestruction(CMacroblockModel BlockModel,Int3 Coord,CardinalDirections Dir);
                        Boolean PlaceMacroblock_NoDestruction(CMacroblockModel BlockModel,Int3 Coord,CardinalDirections Dir);
                        CBlock GetBlock(Int3 Coord);
                        Boolean RemoveBlock(Int3 Coord);
                        Boolean RemoveTerrainBlocks(Int3 StartCoord,Int3 EndCoord);
                        Integer GetBlockGroundHeight(CBlockModel BlockModel,Integer CoordX,Integer CoordZ,CardinalDirections Dir);
                        CBlock GetStartLineBlock();
                        Void CopyPaste_AddOrSubSelection(Int3 StartCoord,Int3 EndCoord);
                        Boolean CopyPaste_Symmetrize();
                        Void SaveMacroblock(CMacroblockModel MacroblockModel);
        const   CBlock[] Blocks;
        const   CBlockModel[] BlockModels;
        const   CBlockModel[] TerrainBlockModels;
        const   CMacroblockModel[] MacroblockModels;
        const   CAnchorData[] AnchorData;
        const   CEditorPluginEvent[] PendingEvents;
                        Int3[] CustomSelectionCoords;
                        Vec3 CustomSelectionRGB;
        const   CUILayer[] UILayers;
                        CUILayer UILayerCreate();
                        Void UILayerDestroy(CUILayer Layer);
                        Void UILayerDestroyAll();
                        Text ManialinkText;
        const   CMlPage ManialinkPage;
};

struct CSmMapType : public CMapType {
        const   CSmMode Mode;
};

struct CTmMapType : public CMapType {
        const   CTmMode Mode;
};

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 CMlEvent : public CNod {
        enum Type {
                KeyPress,
                MouseClick,
                MouseOver,
                MouseOut,
                EntrySubmit,
        };
        const   Type Type;
        const   Text CharPressed;
        const   Text ControlId;
};

struct CXmlManager : public CNod {
                        CXmlDocument Create(Text Contents);
                        Void Destroy(CXmlDocument Document);
        const   CXmlDocument[] Documents;
};

struct CHttpManager : public CNod {
                        CHttpRequest CreateGet(Text Url);
                        CHttpRequest CreatePost(Text Url,Text Resource);
                        Void Destroy(CHttpRequest Request);
                        Boolean IsValidUrl(Text Url);
        const   CHttpRequest[] Requests;
        const   Integer SlotsAvailable;
};

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);
                        Real PosnX;
                        Real PosnY;
                        Real PosnZ;
                        Real Scale;
                        Boolean Visible;
                        Vec3 RelativePosition;
                        Real RelativeScale;
        const   Vec3 AbsolutePosition;
        const   Real AbsoluteScale;
                        AlignHorizontal HorizontalAlign;
                        AlignVertical VerticalAlign;
                        Void Show();
                        Void Hide();
                        Void Unload();
};

struct CUser : public CNod {
        const   Text ZonePath;
        const   Integer LadderRank;
        const   Integer LadderTotal;
        const   Text Name;
        const   Text Login;
        const   Text Language;
        const   Text Description;
        const   Text ClubLink;
};

struct CManiaplanetPluginEvent : public CNod {
        enum EType {
                LayerCustomEvent,
        };
        const   EType Type;
        const   Text CustomEventType;
        const   Text[] CustomEventData;
};

struct CBuddiesManager : public CNod {
        enum EConnectionStatus {
                Offline,
                Online,
                Connecting,
        };
        enum EDesiredConnectionStatus {
                Offline,
                Online,
        };
        const   EConnectionStatus CurrentConnectionStatus;
                        EDesiredConnectionStatus DesiredConnectionStatus;
                        Void SendMessage(CBuddy Buddy,Text Type,Text Body);
                        Void ChangePresence(Text Show,Text Status);
                        CBuddy GetBuddyFromLogin(Text Login);
        const   CBuddy[] Buddies;
        const   CBuddy[] OnlineBuddies;
        const   CBuddy[] OfflineBuddies;
        const   CBuddiesEvent[] PendingEvents;
};

struct CUILayer : public CNod {
        enum EUILayerType {
                Normal,
                ScoresTable,
                ScreenIn3d,
                AltMenu,
                EditorPlugin,
                ManiaplanetPlugin,
        };
                        Boolean IsVisible;
                        EUILayerType Type;
                        Text ManialinkPage;
        const   CMlPage LocalPage;
};

struct CMode : public CNod {
        enum EMedal {
                None,
                Finished,
                Bronze,
                Silver,
                Gold,
                Author,
        };
        const   Text MapName;
        const   CMap Map;
        const   CUser[] Users;
        const   CTeam[] Teams;
                        Text NeutralEmblemUrl;
        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 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 AutoTeamBalance();
                        Void Solo_SetNewRecord(CScore PlayerScore,EMedal Medal);
        const   CXmlRpc XmlRpc;
        const   CXmlManager Xml;
        const   CHttpManager Http;
                        Integer Synchro_AddBarrier();
                        Boolean Synchro_BarrierReached(Integer Barrier);
};

struct CTmPlayer : public CPlayer {
        const   CTmScore Score;
                        Integer RaceStartTime;
                        CTmResult CurRace;
                        CTmResult CurLap;
                        Integer CurrentNbLaps;
        const   Integer CurTriggerIndex;
};

struct CTmScore : public CScore {
                        Integer Points;
                        CTmResult BestRace;
                        CTmResult BestLap;
                        Integer PrevRaceDeltaPoints;
                        CTmResult PrevRace;
        const   CGhost BestRaceGhost;
                        CTmResult TempResult;
                        Void Clear();
};

struct CTmModeEvent : public CNod {
        enum EType {
                Unknown,
                StartLine,
                WayPoint,
                GiveUp,
                Respawn,
                Stunt,
        };
        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;
};

struct CSmPlayer : public CPlayer {
        enum ESpawnStatus {
                NotSpawned,
                Spawning,
                Spawned,
        };
        const   Text Name;
        const   Text Login;
        const   Integer RequestedClan;
        const   Boolean RequestsSpectate;
        const   CSmScore Score;
                        Integer SoloTime;
                        Integer SoloScore;
                        Real BotAgressivity;
                        Integer BotAgressivityDoublingTime;
                        Integer BotPathOffset;
                        Real BotPathSpeedCoef;
        const   ESpawnStatus SpawnStatus;
        const   Boolean IsFakePlayer;
        const   Boolean IsTouchingGround;
        const   Integer CurrentClan;
                        Real AmmoGain;
                        Real AmmoPower;
        const   Boolean AutoSwitchWeapon;
                        Integer Armor;
                        Integer ArmorMax;
                        Integer ArmorGain;
                        Integer ArmorReplenishGain;
                        Real ArmorPower;
        const   Integer Stamina;
                        Real StaminaMax;
                        Real StaminaGain;
                        Real StaminaPower;
        const   Integer StartTime;
                        Integer EndTime;
                        Boolean IsHighlighted;
                        Vec3 ForceColor;
        const   Vec3 Position;
        const   Real AimYaw;
        const   Real AimPitch;
        const   Vec3 AimDirection;
        const   Boolean IsUnderground;
        const   Boolean IsInOffZone;
        const   Boolean IsCapturing;
        const   CSmBlockPole BlockPole;
};

struct CSmModeEvent : public CNod {
        enum EType {
                Unknown,
                OnShoot,
                OnHit,
                OnNearMiss,
                OnArmorEmpty,
                OnCapture,
                OnPlayerRequestRespawn,
        };
        const   EType Type;
        const   CSmPlayer Player;
                        Integer Damage;
                        Integer ShooterPoints;
        const   CSmPlayer Shooter;
        const   CSmPlayer Victim;
        const   Real MissDist;
        const   Integer WeaponNum;
        const   CSmBlockPole BlockPole;
};

struct CSmBase : public CNod {
                        Integer Clan;
                        Boolean IsActive;
};

struct CSmBlock : public CNod {
        const   Text Tag;
        const   Integer Order;
        const   Vec3 Position;
        const   Vec3 DirFront;
        const   CSmBase Base;
};

struct CSmBlockSpawn : public CSmBlock {
};

struct CSmBlockPole : public CSmBlock {
                        Boolean Captured;
        const   CSmSector Sector;
        const   CSmGauge Gauge;
};

struct CSmScore : public CScore {
                        Integer Points;
                        Integer RoundPoints;
        const   Integer NbEliminationsInflicted;
        const   Integer NbEliminationsTaken;
        const   Integer NbRespawnsRequested;
        const   Integer DamageInflicted;
        const   Integer DamageTaken;
                        Void Reset();
};

struct CMlScriptIngame : public CMlScript {
        enum LinkType {
                ExternalBrowser,
                ManialinkBrowser,
                Goto,
                ExternalFromId,
                ManialinkFromId,
                GotoFromId,
        };
        const   Integer GameTime;
        const   CUser LocalUser;
        const   CUIConfig UI;
        const   Boolean IsSpectatorMode;
        const   Boolean IsTeamMode;
        const   CMap Map;
                        Void ShowCurChallengeCard();
                        Void JoinTeam1();
                        Void JoinTeam2();
        const   CUser LocalPlayerInfo;
};

struct CTmMlPlayer : public CPlayer {
        enum ERaceState {
                BeforeStart,
                Running,
                Finished,
                Eliminated,
        };
        const   ERaceState RaceState;
        const   Integer RaceStartTime;
        const   Integer LapStartTime;
                        CTmResult CurRace;
                        CTmResult CurLap;
        const   Integer CurrentNbLaps;
        const   Integer CurTriggerIndex;
        const   Integer CurCheckpointRaceTime;
        const   Integer CurCheckpointLapTime;
};

struct CTeam : public CNod {
                        Text Name;
                        Text ZonePath;
                        Text City;
                        Text EmblemUrl;
                        Text PresentationManialinkUrl;
                        Vec3 ColorPrimary;
                        Vec3 ColorSecondary;
        const   Text ColorText;
        const   Text ColorizedName;
};

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;
                        Text ObjectiveTextAuthor;
                        Text ObjectiveTextGold;
                        Text ObjectiveTextSilver;
                        Text ObjectiveTextBronze;
        const   Integer CopperPrice;
        const   Int3 Size;
};

struct CBlockModel : public CCollector {
        enum EWayPointType {
                Start,
                Finish,
                Checkpoint,
                None,
                StartFinish,
                InsideToOutsideZ,
                InsideToOutsideY,
        };
        enum EProdState {
                Obsolete,
                GameBox,
                DevBuild,
                Release,
        };
        const   Text Name;
        const   Boolean IsRoad;
        const   Boolean IsTerrain;
        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;
                        Boolean IsPureTerrain;
        const   CBlockModel GeneratedBlockModel;
        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 CAnchorData : public CNod {
        const   Text DefaultTag;
        const   Integer DefaultOrder;
                        Text Tag;
                        Integer Order;
};

struct CEditorPluginEvent : public CNod {
        enum Type {
                CursorSelectionBegin,
                CursorSelectionEnd,
                CursorChange,
                MapModified,
                EditAnchor,
                EditObjectives,
                StartValidation,
        };
        const   Type Type;
        const   Ident EditedAnchorDataId;
};

struct CMapType : public CEditorPlugin {
        enum ValidationStatus {
                NotValidable,
                Validable,
                Validated,
        };
                        Boolean CustomEditAnchorData;
                        Void ClearMapMetadata();
                        ValidationStatus ValidationStatus;
                        Text ValidabilityRequirementsMessage;
        const   Boolean ValidationEndRequested;
                        Void RequestEnterPlayground();
                        Void RequestLeavePlayground();
        const   Boolean IsSwitchedToPlayground;
};

struct CMlFrame : public CMlControl {
        enum EControlType {
                Audio,
                Entry,
                FileEntry,
                Frame,
                Label,
                Quad,
                Video,
        };
        const   CMlControl[] Controls;
                        CMlControl GetFirstChild(Text ControlId);
};

struct CXmlDocument : public CNod {
        const   Text TextContents;
        const   CXmlNode Root;
        const   CXmlNode[] Nodes;
                        CXmlNode GetFirstChild(Text Name);
};

struct CHttpRequest : public CNod {
        const   Text Result;
        const   Integer StatusCode;
        const   Boolean IsCompleted;
};

struct CBuddy : public CNod {
        const   Text Login;
        const   Text Name;
        const   Text ZonePath;
        const   Boolean IsOnline;
        const   Text PresenceShow;
        const   Text PresenceStatus;
};

struct CBuddiesEvent : public CNod {
        enum EType {
                Message,
                PresenceChange,
        };
        const   EType Type;
        const   CBuddy Sender;
        const   Text SenderResource;
        const   Text MessageType;
        const   Text MessageBody;
        const   CBuddy Buddy;
        const   Boolean PreviousIsOnline;
        const   Text PreviousShow;
        const   Text PreviousStatus;
};

struct CMapInfo : public CNod {
        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   Text Name;
        const   Text Path;
};

struct CUIConfigMgr : public CNod {
                        Void ResetAll();
        const   CUIConfig UIAll;
        const   CUIConfig[] UI;
                        CUIConfig GetUI(CPlayer Player);
        const   CUILayer[] UILayers;
                        CUILayer UILayerCreate();
                        Void UILayerDestroy(CUILayer Layer);
                        Void UILayerDestroyAll();
};

struct CXmlRpc : public CNod {
        const   CXmlRpcEvent[] PendingEvents;
                        Void SendCallback(Text Param1,Text Param2);
};

struct CPlayer : public CNod {
        const   CUser User;
        const   Text Login;
};

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 CScore : public CNod {
        const   CUser User;
        const   Boolean IsRegisteredForLadderMatch;
        const   Real LadderScore;
                        Integer LadderRankSortValue;
};

struct CGhost : public CNod {
};

struct CSmSector : public CNod {
        const   Ident[] PlayersIds;
};

struct CSmGauge : public CNod {
                        Integer Clan;
                        Real ValueReal;
                        Integer Value;
                        Integer Max;
                        Integer Speed;
};

struct CUIConfig : public CNod {
        enum EUISequence {
                None,
                Playing,
                Intro,
                Outro,
                Podium,
                CustomMTClip,
                EndRound,
                PlayersPresentation,
        };
        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,
        };
                        EUISequence UISequence;
        const   Boolean UISequenceIsCompleted;
                        Text UISequence_CustomMTClip;
                        Text ManialinkPage;
                        Text BigMessage;
                        Text BigMessageAvatarLogin;
                        EAvatarVariant BigMessageAvatarVariant;
                        EUISound BigMessageSound;
                        Integer BigMessageSoundVariant;
                        Text StatusMessage;
                        Text GaugeMessage;
                        Real GaugeRatio;
                        Integer GaugeClan;
                        Text Hud3dMarkers;
        const   CUILayer[] UILayers;
                        Boolean OverlayHideNotices;
                        Boolean OverlayHideMapInfo;
                        Boolean OverlayHideOpponentsInfo;
                        Boolean OverlayHideChat;
                        Boolean OverlayHideCheckPointList;
                        Boolean OverlayHideRoundScores;
                        Boolean OverlayHideAll;
                        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_MatchPoints1;
                        Real ScoreSummary_Gauge1;
                        Ident ScoreSummary_Player2;
                        Integer ScoreSummary_Points2;
                        Integer ScoreSummary_MatchPoints2;
                        Real ScoreSummary_Gauge2;
                        Boolean ScreenIn3dHideScoreSummary;
                        Boolean ScreenIn3dHideVersus;
                        Integer CountdownEndTime;
                        EUIStatus UIStatus;
                        ELabelsVisibility AlliesLabelsVisibility;
                        EVisibility AlliesLabelsShowGauges;
                        ELabelsVisibility EnemiesLabelsVisibility;
                        EVisibility EnemiesLabelsShowGauges;
                        Boolean ForceSpectator;
                        Integer SpectatorForceCameraType;
                        Ident SpectatorAutoTarget;
                        Ident SpectatorForcedTarget;
                        Integer SpectatorForcedClan;
                        Real SpectatorCamAutoLatitude;
                        Real SpectatorCamAutoLongitude;
                        Real SpectatorCamAutoRadius;
                        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 {
                        Text PageName;
                        Integer AmountAvailableCurrent;
                        Integer AmountAvailableMax;
};

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 CXmlNode : public CNod {
        const   Text Name;
        const   Text TextContents;
        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 CXmlRpcEvent : public CNod {
        enum EType {
                Unknown,
                Callback,
        };
        const   EType Type;
        const   Text Param1;
        const   Text Param2;
};

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 {
                Same Dir,
                Symmetrical Dir,
                All Dir,
                Opposed Dir only,
                Perpendicular Dir only,
        };
        const   Int3 Offset;
        const   CBlockModelClip[] Clips;
};

struct CBlockModelClip : public CBlockModel {
        enum EnumClipType {
                ClassicClip,
                FreeClipSide,
                FreeClipTop,
                FreeClipBottom,
        };
};