Method ReadWriteTilesChunk

src/openrct2/park/ParkFile.cpp:1186–1274

        }

        void ReadWriteTilesChunk(GameState_t& gameState, OrcaStream& os)
        {
            auto* pathToSurfaceMap = _pathToSurfaceMap;
            auto* pathToQueueSurfaceMap = _pathToQueueSurfaceMap;
            auto* pathToRailingsMap = _pathToRailingsMap;

            auto found = os.readWriteChunk(
                ParkFileChunkType::titles,
                [pathToSurfaceMap, pathToQueueSurfaceMap, pathToRailingsMap, &os, &gameState](OrcaStream::ChunkStream& cs) {
                    cs.readWrite(gameState.mapSize.x);
                    cs.readWrite(gameState.mapSize.y);

                    if (cs.getMode() == OrcaStream::Mode::writing)
                    {
                        auto tileElements = GetReorganisedTileElementsWithoutGhosts();
                        cs.write(static_cast<uint32_t>(tileElements.size()));
                        cs.write(tileElements.data(), tileElements.size() * sizeof(TileElement));
                        return;
                    }

                    gameStateInitAll(gameState, gameState.mapSize);

                    auto numElements = cs.read<uint32_t>();
                    std::vector<TileElement> tileElements;
                    tileElements.resize(numElements);
                    cs.read(tileElements.data(), tileElements.size() * sizeof(TileElement));
                    SetTileElements(gameState, std::move(tileElements));

                    TileElementIterator it;
                    TileElementIteratorBegin(&it);
                    while (TileElementIteratorNext(&it))
                    {
                        if (it.element->getType() == TileElementType::Path)
                        {
                            auto* pathElement = it.element->asPath();
                            if (pathElement->HasLegacyPathEntry())
                            {
                                auto pathEntryIndex = pathElement->GetLegacyPathEntryIndex();
                                if (pathToRailingsMap[pathEntryIndex] != kObjectEntryIndexNull)
                                {
                                    if (pathElement->IsQueue())
                                        pathElement->SetSurfaceEntryIndex(pathToQueueSurfaceMap[pathEntryIndex]);
                                    else
                                        pathElement->SetSurfaceEntryIndex(pathToSurfaceMap[pathEntryIndex]);

                                    pathElement->SetRailingsEntryIndex(pathToRailingsMap[pathEntryIndex]);
                                }
                            }
                        }
                        else if (it.element->getType() == TileElementType::Track)
                        {
                            auto* trackElement = it.element->asTrack();
                            auto trackType = trackElement->GetTrackType();
                            if (TrackTypeMustBeMadeInvisible(*trackElement, os.getHeader().targetVersion))
                            {
                                it.element->setInvisible(true);
                            }
                            if (os.getHeader().targetVersion < kBlockBrakeImprovementsVersion)