OpenTTD
Class Hierarchy
This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 123456]
 CAccelerationSlowdownParamsData structure for storing engine speed changes of an acceleration type
 CAction5TypeInformation about a single action 5 type
 CAdaptT< T >Adapter wrapper for CCountedPtr like classes that can't be used directly by stl collections as item type
 CAIMain AI class
 CAircraftCacheVariables that are cached to improve performance and such
 CAircraftVehicleInfoInformation about a aircraft vehicle
 CAirportFTAInternal structure used in openttd - Finite sTate mAchine –> FTA
 CAirportFTAbuildupState machine input struct (from external file, etc.) Finite sTate mAchine –> FTA
 CAirportFTAClassFinite sTate mAchine (FTA) of an airport
 CAirportMovingDataA single location on an airport where aircraft can move to
 CAirportSpecDefines the data structure for an airport
 CAirportTileSpecDefines the data structure of each individual tile of an airport
 CAirportTileTableTile-offset / AirportTileID pair
 CAISettingsSettings related to the AI
 CPool< Titem, Tindex, Tgrowth_step, Tmax_size, Tpool_type, Tcache, Tzero >::AllocCacheHelper struct to cache 'freed' PoolItems so we do not need to allocate them again
 CAllowedSubtagsData structure to store the allowed id/type combinations for action 14
 CAndOr
 CAnimationBase< Tbase, Tspec, Tobj, Textra, GetCallback >Helper class for a unified approach to NewGRF animation
 CAnimationBase< AirportTileAnimationBase, AirportTileSpec, Station, int, GetAirportTileCallback >
 CAnimationBase< HouseAnimationBase, HouseSpec, Town, uint32, GetSimpleHouseCallback >
 CAnimationBase< IndustryAnimationBase, IndustryTileSpec, Industry, int, GetSimpleIndustryCallback >
 CAnimationBase< ObjectAnimationBase, ObjectSpec, Object, int, StubGetObjectCallback >
 CAnimationBase< StationAnimationBase, StationSpec, BaseStation, int, GetAnimStationCallback >
 CAnimationInfoInformation about animation
 CAnimCursorA single sprite of a list of animated cursors
 CArrayDefinition of a simple array
 CFixedSizeArray< T, C >::ArrayHeaderHeader for fixed size array
 CArrayT< T >Helper template class that provides C array length and item type
 CArrayT< T[N]>Helper template class that provides C array length and item type
 CAutoFreePtr< T >A smart pointer class that free()'s the pointer on destruction
 CAyStarAyStar search algorithm struct
 CAyStarNodeNode in the search
 CAyStarUserDataIndices into AyStar.userdata[]
 CBackup< T >Class to backup a specific variable and restore it later
 CBaseConsistVarious front vehicle properties that are preserved when autoreplacing, using order-backup or switching front engines within a consist
 CLinkGraph::BaseEdgeAn edge in the link graph
 CLinkGraph::BaseEdgeIterator< Tedge, Tedge_wrapper, Titer >Base class for iterating across outgoing edges of a node
 CLinkGraph::BaseEdgeIterator< BaseEdge, Edge, EdgeIterator >
 CLinkGraph::BaseEdgeIterator< const BaseEdge, ConstEdge, ConstEdgeIterator >
 CLinkGraph::BaseEdgeIterator< const LinkGraph::BaseEdge, Edge, EdgeIterator >
 CLinkGraph::BaseNodeNode of the link graph
 CBasePersistentStorageArrayBase class for all persistent NewGRF storage arrays
 CBaseSet< T, Tnum_files, Tsearch_in_tars >Information about a single base set
 CBaseSet< GraphicsSet, MAX_GFT, true >
 CBaseSet< MusicSet, NUM_SONGS_AVAILABLE, false >
 CBaseSet< SoundsSet, 1, true >
 CBaseSettingEntryData structure describing a single setting in a tab
 CBaseVehicleBase vehicle class
 CBinaryHeapBinary Heap
 CBinaryHeapNode
 CBitmapFileHeaderBMP File Header (stored in little endian)
 CBitmapInfoHeaderBMP Info Header (stored in little endian)
 CBlitterHow all blitters should look like
 CBlitterFactoryThe base factory, keeping track of all blitters
 CBlitter::BlitterParamsParameters related to blitting
 CByteBlob::BlobHeaderHeader of the allocated memory block
 CBmpBuffer
 CBmpData
 CBmpInfo
 CBridgeSpecStruct containing information about a single bridge type
 CBubbleMovement
 CBuildBridgeDataCarriage for the data we need if we want to build a bridge
 CBuildingCounts< T >
 CBuildingCounts< uint16 >
 CBulldozerMovement
 CByteBlobBase class for simple binary blobs
 CByteReaderClass to read from a NewGRF file
 CCanalPropertiesCanal properties local to the NewGRF
 CCargoArrayClass for storing amounts of cargo
 CCargoDataEntryA cargo data entry representing one possible row in the station view window's top part
 CCargoesFieldData about a single field in the IndustryCargoesWindow panel
 CCargoesRowA single row of CargoesField
 CCargoList< Tinst, Tcont >Simple collection class for a list of cargo packets
 CCargoList< StationCargoList, StationCargoPacketMap >
 CCargoList< VehicleCargoList, CargoPacketList >
 CCargoMovement< Tsource, Tdest >Abstract action for moving cargo from one list to another
 CCargoMovement< StationCargoList, StationCargoList >
 CCargoMovement< StationCargoList, VehicleCargoList >
 CCargoMovement< Tlist, Tlist >
 CCargoMovement< VehicleCargoList, StationCargoList >
 CCargoMovement< VehicleCargoList, VehicleCargoList >
 CCargoRemoval< Tsource >Abstract action of removing cargo from a vehicle or a station
 CCargoRemoval< VehicleCargoList >
 CCargoSorter
 CCargoSpecSpecification of a cargo type
 CCargoSuffixTransfer storage of cargo suffix information
 CCargoSummaryItemHelper struct for the cargo details information
 CCaseContainer for the different cases of a string
 CCBinaryHeapT< T >Binary Heap as C++ template
 CCBinaryHeapT< Titem_ >
 CCCountedPtr< Tcls_ >CCountedPtr - simple reference counting smart pointer
 CCFollowTrackT< Ttr_type_, VehicleType, T90deg_turns_allowed_, Tmask_reserved_tracks >Track follower helper template class (can serve pathfinders and vehicle controllers)
 CCHashTableSlotT< Titem_ >
 CCHashTableSlotT< Tsegment >
 CCHashTableT< Titem_, Thash_bits_ >Class CHashTableT<Titem, Thash_bits> - simple hash table of pointers allocated elsewhere
 CCHashTableT< Titem_, Thash_bits_closed_ >
 CCHashTableT< Titem_, Thash_bits_open_ >
 CCHashTableT< Tsegment, C_HASH_BITS >
 CChatMessageContainer for a message
 CCheatInfo about each of the cheats
 CCheatEntryInformation of a cheat
 CCheatsWARNING! Do not remove entries in Cheats struct or change the order of the existing ones! Would break downward compatibility
 CChildScreenSpriteToDraw
 CChunkHandlerHandlers and description of chunk
 CClearedObjectAreaKeeps track of removed objects during execution/testruns of commands
 CNetworkClientListPopupWindow::ClientListActionContainer for actions that can be executed
 CClientSettingsAll settings that are only important for the local client
 CCmdPair
 CCmdStruct
 CCNodeList_HashTableT< Titem_, Thash_bits_open_, Thash_bits_closed_ >Hash table based node list multi-container class
 CCocoaSubdriverGeneric display driver for cocoa On grounds to not duplicate some code, it contains a few variables which are not used by all device drivers
 CColourStructure to access the alpha, red, green, and blue channels from a 32 bit number
 CCommandDefine a command with the flags which belongs to it
 CCommandContainerStructure for buffering the build command when selecting a station to join
 CCommandCostCommon return value for all commands
 CCommandQueueA queue of CommandPackets
 CSpriteLoader::CommonPixelDefinition of a common pixel in OpenTTD's realm
 CCompanyEconomyEntryStatistics about the economy
 CCompanyInfrastructure
 CCompanyManagerFaceBitsInfoInformation about the valid values of CompanyManagerFace bitgroups as well as the sprites to draw
 CCompanyNewsInformationData that needs to be stored for company news messages
 CCompanyOldAI
 CCompanyPropertiesStatically loadable part of Company pool item
 CCompanySettingsSettings that can be set per company
 CDistanceAnnotation::ComparatorComparator for std containers
 CCapacityAnnotation::ComparatorComparator for std containers
 CComponentHandlerA handler doing "something" on a link graph component
 CConstructionSettingsSettings related to construction in-game
 CContentCallbackCallbacks for notifying others about incoming data
 CContentInfoContainer for all important information about a piece of content
 CContentListFilterDataFilter data for NetworkContentListWindow
 CCPerformanceTimer
 CCPerfStartFake
 CCPerfStartReal
 CCrashLogHelper class for creating crash logs
 CCSegmentCostCacheBaseBase class for segment cost cache providers
 CCurrencySpecSpecification of a currency
 CCursorVarsCollection of variables for cursor-display and -animation
 CCYapfBaseT< Types >CYapfBaseT - A-star type path finder base class
 CCYapfCostBaseBase implementation for cost accounting
 CCYapfCostRoadT< Types >
 CCYapfCostShipT< Types >Cost Provider module of YAPF for ships
 CCYapfDestinationAnyDepotRoadT< Types >
 CCYapfDestinationRailBase
 CCYapfDestinationTileRoadT< Types >
 CCYapfDestinationTileT< Types >YAPF destination provider base class - used when destination is single tile / multiple trackdirs
 CCYapfFollowAnyDepotRailT< Types >
 CCYapfFollowRoadT< Types >
 CCYapfFollowShipT< Types >Node Follower module of YAPF for ships
 CCYapfNodeKeyExitDirYapf Node Key that evaluates hash from (and compares) tile & exit dir
 CCYapfNodeT< Tkey_, Tnode >Yapf Node base
 CCYapfNodeT< Tkey_, CYapfRailNodeT< Tkey_ > >
 CCYapfNodeT< Tkey_, CYapfRoadNodeT< Tkey_ > >
 CCYapfNodeT< Tkey_, CYapfShipNodeT< Tkey_ > >
 CCYapfOriginTileT< Types >YAPF origin provider base class - used when origin is one tile / multiple trackdirs
 CCYapfOriginTileTwoWayT< Types >YAPF origin provider base class - used when there are two tile/trackdir origins
 CCYapfRail_TypesT< Tpf_, Ttrack_follower, Tnode_list, TdestinationT, TfollowT >
 CCYapfRailSegmentCached segment cost for rail YAPF
 CCYapfRailSegmentKeyKey for cached segment cost for rail YAPF
 CCYapfReserveTrack< Types >
 CCYapfRoad_TypesT< Tpf_, Tnode_list, Tdestination >
 CCYapfSegmentCostCacheLocalT< Types >CYapfSegmentCostCacheLocalT - the yapf cost cache provider that implements fake segment cost caching functionality for yapf
 CCYapfSegmentCostCacheNoneT< Types >CYapfSegmentCostCacheNoneT - the formal only yapf cost cache provider that implements PfNodeCacheFetch() and PfNodeCacheFlush() callbacks
 CCYapfShip_TypesT< Tpf_, Ttrack_follower, Tnode_list >Config struct of YAPF for ships
 CCzechNameAdj
 CCzechNameSubst
 CDebugFileInfo
 CDebugLevel
 CDefaultUnicodeMapping
 CDefSQClass< CL, ST >The template to define classes in Squirrel
 CDemandCalculatorCalculate the demands
 CDeterministicSpriteGroupAdjust
 CDeterministicSpriteGroupRange
 CDiagonalTileAreaRepresents a diagonal tile area
 CDifficultySettingsSettings related to the difficulty of the game
 CDimensionDimensions (a width and height) of a rectangle in 2D
 CDIR
 CDisaster
 CDrawBuildingsTileStructThis structure is the same for both Industries and Houses
 CDrawIndustryAnimationStructThis is used to gather some data about animation drawing in the industry code Image_1-2-3 are in fact only offset in the sprites used by the industry
 CDrawIndustryCoordinatesSimple structure gathering x,y coordinates for industries animations
 CDrawPixelInfoData about how and where to blit pixels
 CDrawRoadTileStruct
 CDrawTileSeqStructA tile child sprite and palette to draw for stations etc, with 3D bounding box
 CDrawTileSpritesGround palette sprite of a tile, together with its sprite layout
 CDriverA driver for communicating with the user
 CDriverFactoryBaseBase for all driver factories
 CDropDownListItemBase list item class from which others are derived
 CDumpTargetClass that represents the dump-into-string target
 CEconomyData of the economy
 CEconomySettingsSettings related to the economy
 CLinkGraphJob::EdgeAnnotationAnnotation for a link graph edge
 CLinkGraph::EdgeWrapper< Tedge >Wrapper for an edge (const or not) allowing retrieval, but no modification
 CLinkGraph::EdgeWrapper< BaseEdge >
 CEngineIDMapping
 CEngineInfoInformation about a vehicle
 CEntityIDMappingMaps an entity id stored on the map to a GRF file
 CRoadStop::EntryContainer for each entry point of a drive through road stop
 CEnumPropsT< Tenum_t >Informative template class exposing basic enumeration properties used by several other templates below
 CErrorMessageDataThe data of the error message
 CExpensesListExpense list container
 CExtraPaletteValuesDescription of tables for the palette animation
 CFenceOffsetOffsets for drawing fences
 CFileHelper class to read a file
 CFileListList of file information
 CFileScannerHelper for scanning for files with a given name
 CFileToSaveLoadDeals with the type of the savegame, independent of extension
 CFilteringData structure describing what to show in the list (filter criteria)
 CFinalizeRefitActionAction for finalizing a refit
 CFindDepotDataHelper container to find a depot
 CFindTrainOnTrackInfoHelper struct for finding the best matching vehicle on a specific track
 CFioStructure for keeping several open files with just one data buffer
 CFiosItemDeals with finding savegames
 CFixedSizeArray< T, C >Fixed size array Upon construction it preallocates fixed size block of memory for all items, but doesn't construct them
 CFixedSizeArray< SubArray, 1024 >
 CFixedSizeArray< SubArray, N >
 CFlowEdgeIteratorIterator class for getting edges from a FlowStatMap
 CFlowSaveLoad
 CFlowStatFlow statistics telling how much flow should be sent along a link
 CFontCacheFont cache for basic fonts
 CFontStateText drawing parameters, which can change while drawing a line, but are kept between multiple parts of the same text, e.g
 CSQConvert::ForceType< T >Special class to make it possible for the compiler to pick the correct GetParam()
 CFreeTypeSettingsSettings for the freetype fonts
 CFreeTypeSubSettingSettings for a single freetype font
 CFreeUnitIDGeneratorGenerates sequence of free UnitID numbers
 CGameMain Game class
 CGameCreationSettingsSettings related to the creation of games
 CGameSettingsAll settings together for the game
 CGameStringsContainer for all the game strings
 CGenericCallback
 CGenWorldInfoProperties of current genworld process
 CGenWorldStatus
 CDepotWindow::GetDepotVehiclePtData
 CGetNewVehiclePosResultPosition information of a vehicle after it moved
 CGetOptDataData storage for parsing command line options
 CFreeTypeFontCache::GlyphEntryContainer for information about a glyph
 CGoodsEntryStores station stats for a single cargo
 CGraphEdgeIteratorIterator class for getting the edges in the order of their next_edge members
 CGRFFilePropsBase< Tcnt >Data related to the handling of grf files
 CGRFFilePropsBase< 1 >
 CGRFFilePropsBase< 2 >
 CGRFFilePropsBase< NUM_CARGO+2 >
 CGRFFilePropsBase< NUM_CARGO+3 >
 CGRFIdentifierBasic data to distinguish a GRF
 CGRFLabel
 CGRFListList of GRFs using array of pointers instead of linked list
 CGRFLoadedFeatures
 CGRFLocation
 CGRFParameterInfoInformation about one grf parameter
 CGRFPresenceInformation about the presence of a Grf at a certain point during gamelog history Note about missing Grfs: Changes to missing Grfs are not logged including manual removal of the Grf
 CGrfProcessingStateTemporary data during loading of GRFs
 CGRFTempEngineDataTemporary engine data used when loading only
 CGRFTextElement of the linked list
 CGRFTextEntryHolder of the above structure
 CGRFTownName
 CGroundVehicleCacheCached, frequently calculated values
 CGroupStatisticsStatistics and caches on the vehicles in a group
 CGUISettingsSettings related to the GUI and other stuff that is not saved in the savegame
 CHangarTileTableA list of all hangar tiles in an airport
 CHash
 CHashNode
 CSQConvert::HasVoidReturnT< Tfunc >Helper class to recognize if the function/method return type is void
 CHeaderWriterBase class for writing the header, i.e
 CHeightMapHeight map - allocated array of heights (MapSizeX() + 1) x (MapSizeY() + 1)
 CSQConvert::HelperT< Tfunc, Tis_void_retval >Helper class to recognize the function type (retval type, args) and use the proper specialization for SQ callback
 CSQConvert::HelperT< Tretval(*)(), false >The real C++ caller for function with return value and 0 params
 CSQConvert::HelperT< Tretval(*)(), true >The real C++ caller for function with no return value and 0 params
 CSQConvert::HelperT< Tretval(*)(Targ1), false >The real C++ caller for function with return value and 1 param
 CSQConvert::HelperT< Tretval(*)(Targ1), true >The real C++ caller for function with no return value and 1 param
 CSQConvert::HelperT< Tretval(*)(Targ1, Targ2), false >The real C++ caller for function with return value and 2 params
 CSQConvert::HelperT< Tretval(*)(Targ1, Targ2), true >The real C++ caller for function with no return value and 2 params
 CSQConvert::HelperT< Tretval(*)(Targ1, Targ2, Targ3), false >The real C++ caller for function with return value and 3 params
 CSQConvert::HelperT< Tretval(*)(Targ1, Targ2, Targ3), true >The real C++ caller for function with no return value and 3 params
 CSQConvert::HelperT< Tretval(*)(Targ1, Targ2, Targ3, Targ4), false >The real C++ caller for function with return value and 4 params
 CSQConvert::HelperT< Tretval(*)(Targ1, Targ2, Targ3, Targ4), true >The real C++ caller for function with no return value and 4 params
 CSQConvert::HelperT< Tretval(*)(Targ1, Targ2, Targ3, Targ4, Targ5), false >The real C++ caller for function with return value and 5 params
 CSQConvert::HelperT< Tretval(*)(Targ1, Targ2, Targ3, Targ4, Targ5), true >The real C++ caller for function with no return value and 5 params
 CSQConvert::HelperT< Tretval(*)(Targ1, Targ2, Targ3, Targ4, Targ5, Targ6, Targ7, Targ8, Targ9, Targ10), false >The real C++ caller for function with return value and 10 params
 CSQConvert::HelperT< Tretval(*)(Targ1, Targ2, Targ3, Targ4, Targ5, Targ6, Targ7, Targ8, Targ9, Targ10), true >The real C++ caller for function with no return value and 10 params
 CSQConvert::HelperT< Tretval(Tcls::*)(), false >The real C++ caller for method with return value and 0 params
 CSQConvert::HelperT< Tretval(Tcls::*)(), true >The real C++ caller for method with no return value and 0 params
 CSQConvert::HelperT< Tretval(Tcls::*)(Targ1), false >The real C++ caller for method with return value and 1 param
 CSQConvert::HelperT< Tretval(Tcls::*)(Targ1), true >The real C++ caller for method with no return value and 1 param
 CSQConvert::HelperT< Tretval(Tcls::*)(Targ1, Targ2), false >The real C++ caller for method with return value and 2 params
 CSQConvert::HelperT< Tretval(Tcls::*)(Targ1, Targ2), true >The real C++ caller for method with no return value and 2 params
 CSQConvert::HelperT< Tretval(Tcls::*)(Targ1, Targ2, Targ3), false >The real C++ caller for method with return value and 3 params
 CSQConvert::HelperT< Tretval(Tcls::*)(Targ1, Targ2, Targ3), true >The real C++ caller for method with no return value and 3 params
 CSQConvert::HelperT< Tretval(Tcls::*)(Targ1, Targ2, Targ3, Targ4), false >The real C++ caller for method with return value and 4 params
 CSQConvert::HelperT< Tretval(Tcls::*)(Targ1, Targ2, Targ3, Targ4), true >The real C++ caller for method with no return value and 4 params
 CSQConvert::HelperT< Tretval(Tcls::*)(Targ1, Targ2, Targ3, Targ4, Targ5), false >The real C++ caller for method with return value and 5 params
 CSQConvert::HelperT< Tretval(Tcls::*)(Targ1, Targ2, Targ3, Targ4, Targ5), true >The real C++ caller for method with no return value and 5 params
 CSQConvert::HelperT< Tretval(Tcls::*)(Targ1, Targ2, Targ3, Targ4, Targ5, Targ6, Targ7, Targ8, Targ9, Targ10), false >The real C++ caller for method with return value and 10 params
 CSQConvert::HelperT< Tretval(Tcls::*)(Targ1, Targ2, Targ3, Targ4, Targ5, Targ6, Targ7, Targ8, Targ9, Targ10), true >The real C++ caller for method with no return value and 10 params
 CHighScore
 CLinkRefresher::HopA hop the refresh algorithm might evaluate
 CHotkeyAll data for a single hotkey
 CHotkeyListList of hotkeys for a window
 CHouseClassMappingMakes class IDs unique to each GRF file
 CHouseSpec
 CHTTPCallbackCallback for when the HTTP handler has something to tell us
 CIConsoleAlias–Aliases– Aliases are like shortcuts for complex functions, variable assignments, etc
 CIConsoleCmd
 CIConsoleLineContainer for a single line of console output
 CICU_FONTINSTANCEContainer with information about a font
 CIndustryBuildDataData for managing the number and type of industries in the game
 CIndustrySpecDefines the data structure for constructing industry
 CIndustryTileSpecDefines the data structure of each individual tile of an industry
 CIndustryTileTable
 CIndustryTypeBuildDataData for managing the number of industries of a single industry type
 CIniGroupA group within an ini file
 CIniItemA single "line" in an ini file
 CIniLoadFileIni file that only supports loading
 CIsEmptyActionAction to check if a vehicle has no stored cargo
 CKeycodeNamesString representation of a keycode
 CDumpTarget::KnownStructKeyUsed as a key into map of known object instances
 CLabelObjectContainer for a label for SaveLoad system
 CLangStringInformation about a single string
 CLanguageMapMapping of language data between a NewGRF and OpenTTD
 CLanguagePackHeaderHeader of a language file
 CLanguageStringsContainer for the raw (unencoded) language strings of a language
 CLanguageWriterBase class for all language writers
 CLegendAndColourStructure for holding relevant data for legends in small map
 CLexerLexer of a file
 CParagraphLayouter::LineA single line worth of VisualRuns
 CLayouter::LineCacheItemItem in the linecache
 CLayouter::LineCacheKeyKey into the linecache
 CLinkGraphOverlayHandles drawing of links into some window
 CLinkGraphSchedule
 CLinkGraphSettings
 CLinkPropertiesProperties of a link between two stations
 CLinkRefresherUtility to refresh links a consist will visit
 CListingData structure describing how to show the list (what sort direction and criteria)
 CListOrderChange
 CLiveryInformation about a particular livery
 CLoadCheckDataContainer for loading in mode SL_LOAD_CHECK
 CLoadFilterInterface for filtering a savegame till it is loaded
 CLoadgameState
 CLocaleSettingsSettings related to currency/unit systems
 CLoggedActionContains information about one logged action that caused at least one logged change
 CLoggedChangeContains information about one logged change
 CMakeEnumPropsT< Tenum_t, Tstorage_t, Tbegin, Tend, Tinvalid, Tnum_bits >Helper template class that makes basic properties of given enumeration type visible from outsize
 CMakeEnumPropsT< Axis, byte, AXIS_X, AXIS_END, INVALID_AXIS, 1 >
 CMakeEnumPropsT< Colours, byte, COLOUR_BEGIN, COLOUR_END, INVALID_COLOUR, 4 >
 CMakeEnumPropsT< DiagDirection, byte, DIAGDIR_BEGIN, DIAGDIR_END, INVALID_DIAGDIR, 2 >
 CMakeEnumPropsT< Direction, byte, DIR_BEGIN, DIR_END, INVALID_DIR, 3 >
 CMakeEnumPropsT< DisallowedRoadDirections, byte, DRD_NONE, DRD_END, DRD_END, 2 >
 CMakeEnumPropsT< DistributionType, byte, DT_BEGIN, DT_END, DT_NUM >
 CMakeEnumPropsT< ExpensesType, byte, EXPENSES_CONSTRUCTION, EXPENSES_END, INVALID_EXPENSES, 8 >
 CMakeEnumPropsT< LiveryScheme, byte, LS_BEGIN, LS_END, LS_END, 8 >
 CMakeEnumPropsT< ModifyOrderFlags, byte, MOF_NON_STOP, MOF_END, MOF_END, 4 >
 CMakeEnumPropsT< ModifyTimetableFlags, byte, MTF_WAIT_TIME, MTF_END, MTF_END, 2 >
 CMakeEnumPropsT< Owner, byte, OWNER_BEGIN, OWNER_END, INVALID_OWNER >
 CMakeEnumPropsT< RailType, byte, RAILTYPE_BEGIN, RAILTYPE_END, INVALID_RAILTYPE, 4 >
 CMakeEnumPropsT< RoadBits, byte, ROAD_NONE, ROAD_END, ROAD_NONE, 4 >
 CMakeEnumPropsT< RoadType, byte, ROADTYPE_BEGIN, ROADTYPE_END, INVALID_ROADTYPE, 2 >
 CMakeEnumPropsT< RoadTypes, byte, ROADTYPES_NONE, ROADTYPES_END, INVALID_ROADTYPES, 2 >
 CMakeEnumPropsT< SignalType, byte, SIGTYPE_NORMAL, SIGTYPE_END, SIGTYPE_END, 3 >
 CMakeEnumPropsT< StationClassID, byte, STAT_CLASS_BEGIN, STAT_CLASS_MAX, STAT_CLASS_MAX, 8 >
 CMakeEnumPropsT< StoryPageElementType, byte, SPET_TEXT, SPET_END, INVALID_SPET, 8 >
 CMakeEnumPropsT< TownLayout, byte, TL_BEGIN, NUM_TLS, NUM_TLS, 3 >
 CMakeEnumPropsT< TownSize, byte, TSZ_SMALL, TSZ_END, TSZ_END, 2 >
 CMakeEnumPropsT< Track, byte, TRACK_BEGIN, TRACK_END, INVALID_TRACK, 3 >
 CMakeEnumPropsT< Trackdir, byte, TRACKDIR_BEGIN, TRACKDIR_END, INVALID_TRACKDIR, 4 >
 CMakeEnumPropsT< TransportType, byte, TRANSPORT_BEGIN, TRANSPORT_END, INVALID_TRANSPORT, 2 >
 CMakeEnumPropsT< VehicleType, byte, VEH_TRAIN, VEH_END, VEH_INVALID, 3 >
 CMakeEnumPropsT< WaterClass, byte, WATER_CLASS_SEA, WATER_CLASS_INVALID, WATER_CLASS_INVALID, 2 >
 Cmap
 CLanguageMap::MappingMapping between NewGRF and OpenTTD IDs
 CMD5FileStructure holding filename and MD5 information about a single file
 CMemBlock
 CMemoryDumperContainer for dumping the savegame (quickly) to memory
 CMissingGlyphSearcherA searcher for missing glyphs
 CMixerChannel
 CMovementTerminalMappingCombination of aircraft state for going to a certain terminal and the airport flag for that terminal block
 CMultiCommodityFlowMulti-commodity flow calculating base class
 CMultiMapIterator< Tmap_iter, Tlist_iter, Tkey, Tvalue, Tcompare >STL-style iterator for MultiMap
 CMusicSettingsSettings related to music
 CNamePart
 CNamePartList
 CNetworkAddressWrapper for (un)resolved network addresses; there's no reason to transform a numeric IP to a string and then back again to pass it to functions
 CNetworkCompanyStateSome state information of a company, especially for servers
 CNetworkCompanyStatsSimple calculated statistics of a company
 CNetworkGameListStructure with information shown in the game list (GUI)
 CNetworkServerGameInfoThe game information that is not generated on-the-fly and has to be sent to the clients
 CNetworkSettingsAll settings related to the network
 CNetworkSocketHandlerSocketHandler for all network sockets in OpenTTD
 CNewGRFCacheCached often queried (NewGRF) values
 CNewGRFClass< Tspec, Tid, Tmax >Struct containing information relating to NewGRF classes for stations and airports
 CNewGrfDebugSpritePickerSpritepicker of SpriteAligner
 CNewGRFScanCallbackCallback for NewGRF scanning
 CNewsItemInformation about a single item of news
 CNewsSettingsSettings related to news
 CNewsTypeDataPer-NewsType data
 CNICallbackRepresentation of the available callbacks with information on when they actually apply
 CNIFeatureContainer for all information for a given feature
 CNIHelperHelper class to wrap some functionality/queries in
 CNIPropertyRepresentation of the data from a NewGRF property
 CNIVariableRepresentation on the NewGRF variables
 CLinkGraphJob::NodeAnnotationAnnotation for a link graph node
 CLinkGraph::NodeWrapper< Tnode, Tedge >Wrapper for a node (const or not) allowing retrieval, but no modification
 CLinkGraph::NodeWrapper< BaseNode, BaseEdge >
 CLinkGraph::NodeWrapper< const BaseNode, const BaseEdge >
 CNPFFindStationOrTileDataMeant to be stored in AyStar.targetdata
 CNPFFoundTargetDataMeant to be stored in AyStar.userpath
 CNPFSettingsSettings related to the new pathfinder
 CNSCursor(OTTD_QuickdrawCursor)Category of NSCursor to allow cursor showing/hiding
 CNSObject
 CNSView
 CNSWindow
 CNullStruct
 CNWidgetPartPartial widget specification to allow NWidgets to be written nested
 CNWidgetPartDataTipWidget part for storing data and tooltip information
 CNWidgetPartPaddingsWidget part for storing padding
 CNWidgetPartPIPWidget part for storing pre/inter/post spaces
 CNWidgetPartTextLinesWidget part for storing minimal text line data
 CNWidgetPartWidgetWidget part for storing basic widget information
 CObjectSpecAllow incrementing of ObjectClassID variables
 COldChunks
 COldWaypointHelper structure to convert from the old waypoint system
 CCBlobT< T >::OnTransfer
 COpenListNodeInternal node
 COPFSettingsSettings related to the old pathfinder
 COptionDataData of an option
 COrderSettingsSettings related to orders
 COrthogonalTileAreaRepresents the covered area of e.g
 COTTDByteReaderSignal
 COTTDThreadExitSignalSignal used for signalling we knowingly want to end the thread
 COTTDThreadStartupMessageAvoid name clashes with MorphOS API functions
 COutputBufferOutput buffer for a block of data
 COutputStoreTemporarily store output
 COverflowSafeInt< T, T_MAX, T_MIN >Overflow safe template for integers, i.e
 COverflowSafeInt< int64, INT64_MAX, INT64_MIN >
 COverrideManagerBase
 COvertakeData
 CPacketInternal entity of a packet
 CPairA pair of two integers
 CPaletteInformation about the currently used palette
 CPalSpriteIDCombination of a palette sprite and a 'real' sprite
 CParagraphLayouterInterface to glue fallback and normal layouter into one
 CParentSpriteToDrawParent sprite that should be drawn
 CParsedCommandStruct
 CPathA leg of a path in the link graph
 CPathfinderSettingsSettings related to all pathfinders
 CPathNodeA path of nodes
 CPBSTileInfoThis struct contains information about the end of a reserved path
 CPcxHeaderDefinition of a PCX file header
 CPfBase
 CPfBase
 CPfBase
 CPfBase
 CPfCache
 CPfCache
 CPfCache
 CPfCache
 CPfCost
 CPfCost
 CPfCost
 CPfCost
 CPfDestination
 CPfDestination
 CPfDestination
 CPfDestination
 CPfFollow
 CPfFollow
 CPfFollow
 CPfFollow
 CPfOrigin
 CPfOrigin
 CPfOrigin
 CPfOrigin
 CBlitter_32bppSimple::Pixel
 CPluralFormDescription of a plural form
 CPointCoordinates of a point in 2D
 CPointDimensionSpecification of a rectangle with an absolute top-left coordinate and a (relative) width/height
 CPoolBaseBase class for base of all pools
 CPool< Titem, Tindex, Tgrowth_step, Tmax_size, Tpool_type, Tcache, Tzero >::PoolItem< Tpool >Base class for all PoolItems
 CPool< Titem, Tindex, Tgrowth_step, Tmax_size, Tpool_type, Tcache, Tzero >::PoolItem<&_cargo_payment_pool >
 CPool< Titem, Tindex, Tgrowth_step, Tmax_size, Tpool_type, Tcache, Tzero >::PoolItem<&_cargopacket_pool >
 CPool< Titem, Tindex, Tgrowth_step, Tmax_size, Tpool_type, Tcache, Tzero >::PoolItem<&_company_pool >
 CPool< Titem, Tindex, Tgrowth_step, Tmax_size, Tpool_type, Tcache, Tzero >::PoolItem<&_depot_pool >
 CPool< Titem, Tindex, Tgrowth_step, Tmax_size, Tpool_type, Tcache, Tzero >::PoolItem<&_engine_pool >
 CPool< Titem, Tindex, Tgrowth_step, Tmax_size, Tpool_type, Tcache, Tzero >::PoolItem<&_enginerenew_pool >
 CPool< Titem, Tindex, Tgrowth_step, Tmax_size, Tpool_type, Tcache, Tzero >::PoolItem<&_goal_pool >
 CPool< Titem, Tindex, Tgrowth_step, Tmax_size, Tpool_type, Tcache, Tzero >::PoolItem<&_group_pool >
 CPool< Titem, Tindex, Tgrowth_step, Tmax_size, Tpool_type, Tcache, Tzero >::PoolItem<&_industry_pool >
 CPool< Titem, Tindex, Tgrowth_step, Tmax_size, Tpool_type, Tcache, Tzero >::PoolItem<&_link_graph_job_pool >
 CPool< Titem, Tindex, Tgrowth_step, Tmax_size, Tpool_type, Tcache, Tzero >::PoolItem<&_link_graph_pool >
 CPool< Titem, Tindex, Tgrowth_step, Tmax_size, Tpool_type, Tcache, Tzero >::PoolItem<&_networkadminsocket_pool >
 CPool< Titem, Tindex, Tgrowth_step, Tmax_size, Tpool_type, Tcache, Tzero >::PoolItem<&_networkclientinfo_pool >
 CPool< Titem, Tindex, Tgrowth_step, Tmax_size, Tpool_type, Tcache, Tzero >::PoolItem<&_networkclientsocket_pool >
 CPool< Titem, Tindex, Tgrowth_step, Tmax_size, Tpool_type, Tcache, Tzero >::PoolItem<&_object_pool >
 CPool< Titem, Tindex, Tgrowth_step, Tmax_size, Tpool_type, Tcache, Tzero >::PoolItem<&_order_backup_pool >
 CPool< Titem, Tindex, Tgrowth_step, Tmax_size, Tpool_type, Tcache, Tzero >::PoolItem<&_order_pool >
 CPool< Titem, Tindex, Tgrowth_step, Tmax_size, Tpool_type, Tcache, Tzero >::PoolItem<&_orderlist_pool >
 CPool< Titem, Tindex, Tgrowth_step, Tmax_size, Tpool_type, Tcache, Tzero >::PoolItem<&_persistent_storage_pool >
 CPool< Titem, Tindex, Tgrowth_step, Tmax_size, Tpool_type, Tcache, Tzero >::PoolItem<&_roadstop_pool >
 CPool< Titem, Tindex, Tgrowth_step, Tmax_size, Tpool_type, Tcache, Tzero >::PoolItem<&_sign_pool >
 CPool< Titem, Tindex, Tgrowth_step, Tmax_size, Tpool_type, Tcache, Tzero >::PoolItem<&_spritegroup_pool >
 CPool< Titem, Tindex, Tgrowth_step, Tmax_size, Tpool_type, Tcache, Tzero >::PoolItem<&_station_pool >
 CPool< Titem, Tindex, Tgrowth_step, Tmax_size, Tpool_type, Tcache, Tzero >::PoolItem<&_story_page_element_pool >
 CPool< Titem, Tindex, Tgrowth_step, Tmax_size, Tpool_type, Tcache, Tzero >::PoolItem<&_story_page_pool >
 CPool< Titem, Tindex, Tgrowth_step, Tmax_size, Tpool_type, Tcache, Tzero >::PoolItem<&_subsidy_pool >
 CPool< Titem, Tindex, Tgrowth_step, Tmax_size, Tpool_type, Tcache, Tzero >::PoolItem<&_town_pool >
 CPool< Titem, Tindex, Tgrowth_step, Tmax_size, Tpool_type, Tcache, Tzero >::PoolItem<&_vehicle_pool >
 CPrepareRefitActionRefit preparation action
 CPriceBaseSpecDescribes properties of price bases
 CQueryStringData stored about a string that can be modified in the GUI
 CRailStationGUISettings
 CRailtypeInfoThis struct contains all the info that is needed to draw and construct tracks
 CRailVehicleInfoInformation about a rail vehicle
 CRandomizerStructure to encapsulate the pseudo random number generators
 CReadBufferA buffer for reading (and buffering) savegame data
 CRectSpecification of a rectangle with absolute coordinates of all edges
 CRectAndIndustryVectorRect and pointer to IndustryVector
 CLinkRefresher::RefitDescSimulated cargo type and capacity for prediction of future links
 CRefitDescSimulated cargo type and capacity for prediction of future links
 CRefitOptionOption to refit a vehicle chain
 CRefitResultHelper structure for RefitVehicle()
 CRememberData
 CReserveCargoAction
 CResizeInfoData structure for resizing a window
 CResolverObjectInterface for SpriteGroup-s to access the gamestate
 CReturnCargoActionAction for returning reserved cargo
 CReusableBuffer< T >A reusable buffer that can be used for places that temporary allocate a bit of memory and do that very often, or for places where static memory is allocated that might need to be reallocated sometimes
 CReusableBuffer< SpriteLoader::CommonPixel >
 CRgbQuadFormat of palette data in BMP header
 CRoadDriveEntry
 CRoadStopEntryRebuilderHelperHelper for finding RVs in a road stop
 CRoadTypeInfoStructure holding information per roadtype for several functions
 CRoadVehFindData
 CRoadVehicleInfoInformation about a road vehicle
 CStationViewWindow::RowDisplayA row being displayed in the cargo view (as opposed to being "hidden" behind a plus sign)
 CSavedRandomSeedsStores the state of all random number generators
 CSaveFilterInterface for filtering a savegame till it is written
 CSaveLoadSaveLoad type struct
 CSaveLoadFormatThe format for a reader/writer type of a savegame
 CSaveLoadParamsThe saveload struct, containing reader-writer functions, buffer, version, etc
 CScalerScale various things according to symmetric/asymmetric distribution
 CScenarioIdentifierBasic data to distinguish a scenario
 CScopeResolverInterface to query and set values specific to a single VarSpriteGroupScope (action 2 scope)
 CScoreInfoData structure for storing how the score is computed for a single score id
 CScreenshotFormatScreenshot format information
 CScript_FatalErrorA throw-class that is given when the script made a fatal error
 CScript_SuspendA throw-class that is given when the script wants to suspend
 CScriptConfigScript settings
 CScriptConfigItemInfo about a single Script setting
 CScriptInstanceRuntime information about a script like a pointer to the squirrel vm and the current state
 CScriptSettingsSettings related to scripts
 CScriptStorageThe storage for each script
 CScrollbarScrollbar data structure
 CSearchNearbyHouseDataStructure with user-data for SearchNearbyHouseXXX - functions
 CSettingDesc
 CSettingDescBaseProperties of config file settings
 CSettingFilterFilter for settings list
 CSettingsContainerContainers for BaseSettingEntry
 CShipVehicleInfoInformation about a ship vehicle
 CSignList
 CSimpleCountedObjectSimple counted object
 CSimplePool< Titem, Tindex, Tgrowth_step, Tmax_size >A simplified pool which stores values instead of pointers and doesn't redefine operator new/delete
 CSimpleTinyEnumT< enum_type, storage_type >Template of struct holding enum types (on most archs, enums are stored in an int32)
 CSimpleTinyEnumT< GoalType, byte >
 CSimpleTinyEnumT< PartOfSubsidy, byte >
 CSimpleTinyEnumT< SettingDescTypeLong, byte >
 CSimpleTinyEnumT< SettingGuiFlagLong, uint16 >
 CSimpleTinyEnumT< SourceType, byte >
 CSimpleTinyEnumT< SpriteType, byte >
 CSimpleTinyEnumT< StationFacility, byte >
 CSimpleTinyEnumT< StationHadVehicleOfType, byte >
 CSimpleTinyEnumT< TownFounding, byte >
 CSimpleTinyEnumT< TownLayout, byte >
 CSimpleTinyEnumT< TrackBits, byte >
 CSimpleTinyEnumT< TrainForceProceeding, byte >
 CSimpleTinyEnumT< VehicleType, byte >
 CSimpleTinyEnumT< ZoomLevel, byte >
 CSmallArray< T, B, N >Flexible array with size limit
 CSmallArray< CachedData >
 CSmallArray< Titem_, 65536, 256 >
 CSmallArray< Tsegment >
 CSmallMapColourSchemeColour scheme of the smallmap
 CSmallMatrix< T >Simple matrix template class
 CSmallMatrix< BaseEdge >
 CSmallMatrix< EdgeAnnotation >
 CSmallPair< T, U >Simple pair of data
 CSmallPair< byte, char * >
 CSmallPair< const char *, const char * >
 CSmallPair< int, Font * >
 CSmallPair< int, QueryString * >
 CSmallPair< NetworkAddress, SOCKET >
 CSmallPair< NodeID, Tedge_wrapper >
 CSmallPair< SpriteID, SmallPair >
 CSmallPair< uint, CompanyProperties * >
 CSmallPair< uint32, SmallPair< size_t, const void *> >
 CSmallPair< uint32, struct GRFText * >
 CSmallSet< Tdir, items >Set containing 'items' items of 'tile and Tdir' No tree structure is used because it would cause slowdowns in most usual cases
 CSmallStackItem< Titem, Tindex >Base class for SmallStack
 CSmallStackSafeStackAlloc< T, length >A small 'wrapper' for allocations that can be done on most OSes on the stack, but are just too large to fit in the stack on devices with a small stack such as the NDS
 CSmallVector< T, S >Simple vector template class
 CSmallVector< BaseNode, 16 >
 CSmallVector< byte *, S >
 CSmallVector< byte, 256 >
 CSmallVector< CargoesRow, 4 >
 CSmallVector< CargoLabel, 4 >
 CSmallVector< char *, S >
 CSmallVector< char, 1024 >
 CSmallVector< ChildScreenSpriteToDraw, 16 >
 CSmallVector< const char *, 64 >
 CSmallVector< const Company *, 32 >
 CSmallVector< const ContentInfo *, 32 >
 CSmallVector< const GRFConfig *, 32 >
 CSmallVector< const Group *, 32 >
 CSmallVector< const Industry *, 32 >
 CSmallVector< const ParagraphLayouter::Line *, S >
 CSmallVector< const Sign *, 32 >
 CSmallVector< const Station *, 32 >
 CSmallVector< const StoryPage *, 32 >
 CSmallVector< const StoryPageElement *, 32 >
 CSmallVector< const Town *, 32 >
 CSmallVector< const Vehicle *, 32 >
 CSmallVector< ContentCallback *, 2 >
 CSmallVector< ContentID, 4 >
 CSmallVector< ContentInfo *, 16 >
 CSmallVector< ContentType, 4 >
 CSmallVector< DrawTileSeqStruct, 8 >
 CSmallVector< EngineID, 32 >
 CSmallVector< EngineIDMapping, 256 >
 CSmallVector< FallbackVisualRun *, S >
 CSmallVector< FiosItem, 32 >
 CSmallVector< GRFParameterInfo *, 4 >
 CSmallVector< ICUVisualRun *, S >
 CSmallVector< Industry *, 2 >
 CSmallVector< int, 16 >
 CSmallVector< int, 4 >
 CSmallVector< LanguageMap::Mapping, 1 >
 CSmallVector< LanguageStrings *, S >
 CSmallVector< NetworkAddress, 4 >
 CSmallVector< NetworkClientListPopupWindow::ClientListAction, 2 >
 CSmallVector< NetworkGameList *, 32 >
 CSmallVector< NodeAnnotation, 16 >
 CSmallVector< OutputBuffer, 2 >
 CSmallVector< ParagraphLayouter::Line *, S >
 CSmallVector< ParentSpriteToDraw *, 64 >
 CSmallVector< ParentSpriteToDraw, 64 >
 CSmallVector< RailTypeLabel, 4 >
 CSmallVector< RefitOption, 32 >
 CSmallVector< ScenarioIdentifier, 8 >
 CSmallVector< SimplePool::SimplePoolPoolItem, Tgrowth_step >
 CSmallVector< size_t, 32 >
 CSmallVector< SmallPair< byte, char * >, 16 >
 CSmallVector< SmallPair< const char *, const char * >, 16 >
 CSmallVector< SmallPair< int, Font * >, 16 >
 CSmallVector< SmallPair< int, QueryString * >, 16 >
 CSmallVector< SmallPair< NetworkAddress, SOCKET >, S >
 CSmallVector< SmallPair< SpriteID, SmallPair >, 16 >
 CSmallVector< SmallPair< T, U >, S >
 CSmallVector< SmallPair< uint, CompanyProperties * >, 16 >
 CSmallVector< SmallPair< uint32, SmallPair< size_t, const void *> >, 16 >
 CSmallVector< SmallPair< uint32, struct GRFText * >, S >
 CSmallVector< SpriteID, 256 >
 CSmallVector< Station *, 2 >
 CSmallVector< StringFilter::WordState, 4 >
 CSmallVector< StringSpriteToDraw, 4 >
 CSmallVector< T, 32 >
 CSmallVector< TileSpriteToDraw, 64 >
 CSmallVector< UChar, 32 >
 CSmallVector< uint16, 1 >
 CSmallVector< void *, 1 >
 CSnowLineStructure describing the height of the snow line each day of the year
 CSortableSpriteStruct
 CSorting
 CSoundEntry
 CSoundSettingsSettings related to sound effects
 CSpotDataUsed as the user_data for FindFurthestFromWater
 CSpriteData structure describing a sprite
 CSpriteLoader::SpriteStructure for passing information from the sprite loader to the blitter
 CSpriteCache
 CBlitter_32bppOptimized::SpriteDataData stored about a (single) sprite
 CBlitter_8bppOptimized::SpriteDataData stored about a (single) sprite
 CSpriteLoaderInterface for the loader of our sprites
 CGrfProcessingState::SpriteSetDefinition of a single Action1 spriteset
 CSQFile
 CSquirrel
 CSquirrelStdBy default we want to give a set of standard commands to a SQ script
 CSmallSet< Tdir, items >::SSdataElement of set
 CStationNameInformationInformation to handle station action 0 property 24 correctly
 CStationSettingsSettings related to stations
 CStationSpecStation specification
 CStationSpecList
 CStatueBuildSearchDataStructure for storing data while searching the best place to build a statue
 CStringCompareComparator for strings
 CStringDataInformation about the currently known strings
 CStringFilterString filter and state
 CStringIDMappingInformation for mapping static StringIDs
 CStringIteratorClass for iterating over different kind of parts of a string
 CStringParameters
 CStringReaderHelper for reading strings
 CStringSpriteToDraw
 CSubSpriteUsed to only draw a part of the sprite
 CTarFileListEntry
 CTarListEntryThe define of a TarList
 CTCPConnecter"Helper" class for creating TCP connections in a non-blocking manner
 CTCPListenHandler< Tsocket, Tfull_packet, Tban_packet >Template for TCP listeners
 CTCPListenHandler< ServerNetworkAdminSocketHandler, ADMIN_PACKET_SERVER_FULL, ADMIN_PACKET_SERVER_BANNED >
 CTCPListenHandler< ServerNetworkGameSocketHandler, PACKET_SERVER_FULL, PACKET_SERVER_BANNED >
 CTemporaryStorageArray< TYPE, SIZE >Class for temporary storage of data
 CTempStorageTemporary storage of cargo monitoring data for loading or saving it
 CTerraformerStateState of the terraforming
 CTextbufHelper/buffer for input fields
 CTextRefStack
 CThreadMutexCross-platform Mutex
 CThreadMutexLockerSimple mutex locker to keep a mutex locked until the locker goes out of scope
 CThreadObjectA Thread Object which works on all our supported OSes
 CTileData that is stored per tile
 CCYapfCostRailT< Types >::TILE
 CTileAndStationStruct containing TileIndex and StationID
 CTileDescTile description for the 'land area information' tool
 CTileExtendedData that is stored per tile
 CTileHighlightDataMetadata about the current highlighting
 CTileIndexDiffCA pair-construct of a TileIndexDiff
 CTileInfoTile information, used while rendering the tile
 CTileIteratorBase class for tile iterators
 CTileLayoutRegistersAdditional modifiers for items in sprite layouts
 CTileMatrix< T, N >A simple matrix that stores one value per N*N square of the map
 CTileMatrix< uint32, 4 >
 CTileSpriteToDraw
 CTileTypeProcsSet of callback functions for performing tile operations of a given tile type
 CTimetableArrivalDepartureContainer for the arrival/departure dates of a vehicle
 CTinyEnumT< Tenum_t >In some cases we use byte or uint16 to store values that are defined as enum
 CTinyEnumT< Direction >
 CTinyEnumT< DistributionType >
 CTinyEnumT< Owner >
 CTinyEnumT< RailType >
 CTinyEnumT< StoryPageElementType >
 CTinyEnumT< Trackdir >
 CTitem
 CTownCacheData structure with cached data of towns
 CTownNameGeneratorParamsContains pointer to generator and minimum buffer size (not incl
 CTownNameParamsStruct holding a parameters used to generate town name
 CTrackPathFinder
 CTrainCacheVariables that are cached to improve performance and such
 CTrainCollideCheckerTemporary data storage for testing collisions
 CTransportedCargoStat< Tstorage >Store the maximum and actually transported cargo amount for the current and the last month
 CTransportedCargoStat< uint16 >
 CTransportedCargoStat< uint32 >
 CTreePos
 CUnitConversionHelper for unit conversion
 CUnitsInformation about a specific unit system
 CUnitsLongInformation about a specific unit system with a long variant
 CValuesIntervalContains the interval of a graph's data
 CVehicleCacheCached often queried values common to all vehicles
 CVehicleCellSizeDimensions of a cell in the purchase/depot windows
 CVehicleDefaultSettingsDefault settings for vehicles
 CVehicleListIdentifierThe information about a vehicle list
 CVehicleOrderSaverThis class will save the current order of a vehicle and restore it on destruction
 CVehicleSettingsSettings related to vehicles
 CVehicleSpriteSeqSprite sequence for a vehicle part
 CViewPortData structure for viewport, display of a part of the world
 CViewportDrawerData structure storing rendering information
 CViewportSignLocation information about a sign as seen on the viewport
 CViewportSSCSSHelper class for getting the best sprite sorter
 CParagraphLayouter::VisualRunVisual run contains data about the bit of text with the same font
 CVkMapping
 CWagonOverride
 CWaterFeatureInformation about a water feature
 CStringFilter::WordStateState of a single filter word
 CYAPFSettingsSettings related to the yet another pathfinder
 CYearMonthDayData structure to convert between Date and triplet (year, month, and day)
 CSQConvert::YesT< Y >
 CSQConvert::YesT< false >
 CSQConvert::YesT< true >
 CZeroedMemoryAllocatorBase class that provides memory initialization on dynamically created objects