*

 * Basically, this always returns the same or more runs than given.

 *

 * @param runs_current The current runs.

 * @param font_mapping The font mapping.

 * @return The runs.

 */

{

	std::vector<ICURun> runs;

	auto runs = ItemizeBidi(buff, length);

	runs = ItemizeScript(buff, length, runs);

	if (runs.size() == 0) return nullptr;

 * This function tries to flatten out the land below an industry, without

 *  damaging the surroundings too much.

 */

{

	int max_x = 0;

	int max_y = 0;

	if (ret.Failed()) return ret;

	if (!custom_shape_check && _settings_game.game_creation.land_generator == LG_TERRAGENESIS && _generating_world &&

		return_cmd_error(STR_ERROR_SITE_UNSUITABLE);

	}

	if (flags & DC_EXEC) {

		*ip = new Industry(tile);

		DoCreateNewIndustry(*ip, tile, type, layout, layout_index, t, founder, random_initial_bits);

	}

	/* Check for the client and server names to be set, but only after the scripts had a chance to set them.*/

	if (_network_dedicated) CheckClientAndServerName();

	NetworkInitialize(false);

	NetworkUDPInitialize();

	Debug(net, 5, "Starting listeners for clients");

/**

 * We want to disconnect from the host/clients.

 * @param close_admins Whether the admin sockets need to be closed as well.

 */

{

	if (_network_server) {

		for (NetworkClientSocket *cs : NetworkClientSocket::Iterate()) {

/** This shuts the network down */

void NetworkShutDown()

{

	NetworkHTTPUninitialize();

	NetworkUDPClose();

bool NetworkCompanyHasClients(CompanyID company);

std::string NetworkChangeCompanyPassword(CompanyID company_id, std::string password);

void NetworkReboot();

void NetworkGameLoop();

void NetworkBackgroundLoop();

std::string_view ParseFullConnectionString(const std::string &connection_string, uint16_t &port, CompanyID *company_id = nullptr);

	return object.ResolveCallback();

}

{

	const DrawTileSprites *dts = group->ProcessRegisters(nullptr);

	DrawNewGRFTileSeq(ti, dts, TO_BUILDINGS, 0, GENERAL_SPRITE_COLOUR(colour));

}

{

	if (ti->tileh != SLOPE_FLAT) {

		bool draw_old_one = true;

	}

	const TileLayoutSpriteGroup *tlgroup = (const TileLayoutSpriteGroup *)group;

	return true;

}

void AnimateAirportTile(TileIndex tile);

void AirportTileAnimationTrigger(Station *st, TileIndex tile, AirpAnimationTrigger trigger, CargoID cargo_type = CT_INVALID);

void AirportAnimationTrigger(Station *st, AirpAnimationTrigger trigger, CargoID cargo_type = CT_INVALID);

#endif /* NEWGRF_AIRPORTTILES_H */

	return GetIndustryTileSpec(gfx)->grf_prop.local_id;

}

{

	const DrawTileSprites *dts = group->ProcessRegisters(&stage);

	/* Limit the building stage to the number of stages supplied. */

	const TileLayoutSpriteGroup *tlgroup = (const TileLayoutSpriteGroup *)group;

	byte stage = GetIndustryConstructionStage(ti->tile);

	return true;

}

Win32FontCache::Win32FontCache(FontSize fs, const LOGFONT &logfont, int pixels) : TrueTypeFontCache(fs, pixels), logfont(logfont)

{

	this->dc = CreateCompatibleDC(nullptr);

}

Win32FontCache::~Win32FontCache()

	DeleteObject(this->font);

}

{

	if (pixels == 0) {

		/* Try to determine a good height based on the minimal height recommended by the font. */

void Win32FontCache::ClearFontCache()

{

	/* GUI scaling might have changed, determine font size anew if it was automatically selected. */

	this->TrueTypeFontCache::ClearFontCache();

}

	SIZE glyph_size;      ///< Maximum size of regular glyphs.

	std::string fontname; ///< Cached copy of loaded font facename

protected:

	const void *InternalGetFontTable(uint32_t tag, size_t &length) override;

 * Check that the new track bits may be built.

 * @param tile %Tile to build on.

 * @param to_build New track bits.

 * @return Succeeded or failed command.

 */

{

	if (!IsPlainRail(tile)) return_cmd_error(STR_ERROR_IMPOSSIBLE_TRACK_COMBINATION);

			if (!IsCompatibleRail(GetRailType(tile), railtype)) return_cmd_error(STR_ERROR_IMPOSSIBLE_TRACK_COMBINATION);

			if (ret.Succeeded()) ret = EnsureNoTrainOnTrack(tile, track);

			if (ret.Failed()) return ret;

 * @param flags operation to perform

 * @param pieces roadbits to remove

 * @param rt roadtype to remove

 * @param town_check should we check if the town allows removal?

 */

{

	assert(pieces != ROAD_NONE);

					if (money_spent > 0 && money_spent > money_available) {

						return { cost, std::get<0>(Command<CMD_REMOVE_LONG_ROAD>::Do(flags & ~DC_EXEC, end_tile, start_tile, rt, axis, start_half, end_half)).GetCost() };

					}

				}

				cost.AddCost(ret);

				had_success = true;

			for (RoadTramType rtt : { RTT_TRAM, RTT_ROAD }) {

				if (!MayHaveRoad(tile) || GetRoadType(tile, rtt) == INVALID_ROADTYPE) continue;

				if (tmp_ret.Failed()) return tmp_ret;

				ret.AddCost(tmp_ret);

			}

		/* Possibly change road type */

		if (GetRoadOwner(tile, RTT_ROAD) == OWNER_TOWN) {

			if (rt != GetRoadTypeRoad(tile)) {

				SetRoadType(tile, RTT_ROAD, rt);

			}

 * Check whether we can expand the rail part of the given station.

 * @param st the station to expand

 * @param new_ta the current (and if all is fine new) tile area of the rail part of the station

 * @return Succeeded or failed command.

 */

{

	TileArea cur_ta = st->train_station;

	if (ret.Failed()) return ret;

	if (st != nullptr && st->train_station.tile != INVALID_TILE) {

		if (ret.Failed()) return ret;

	}

		gfx = GetAirportGfx(ti->tile);

		if (gfx >= NEW_AIRPORTTILE_OFFSET) {

			const AirportTileSpec *ats = AirportTileSpec::Get(gfx);

				return;

			}

			/* No sprite group (or no valid one) found, meaning no graphics associated.

}

#endif /* TOWN_H */

	return GetAnyRoadBits(tile, RTT_ROAD, true);

}

{

	RoadType best_rt = ROADTYPE_ROAD;

	const RoadTypeInfo *best = nullptr;

		/* No, try if we are able to build a road piece there.

		 * If that fails clear the land, and if that fails exit.

		 * This is to make sure that we can build a road here later. */

		if (Command<CMD_BUILD_ROAD>::Do(DC_AUTO | DC_NO_WATER, tile, (dir == DIAGDIR_NW || dir == DIAGDIR_SE) ? ROAD_Y : ROAD_X, rt, DRD_NONE, 0).Failed() &&

				Command<CMD_LANDSCAPE_CLEAR>::Do(DC_AUTO | DC_NO_WATER, tile).Failed()) {

			return false;

 */

static bool GrowTownWithRoad(const Town *t, TileIndex tile, RoadBits rcmd)

{

	if (Command<CMD_BUILD_ROAD>::Do(DC_EXEC | DC_AUTO | DC_NO_WATER, tile, rcmd, rt, DRD_NONE, t->index).Succeeded()) {

		_grow_town_result = GROWTH_SUCCEED;

		return true;

	const int delta = TileOffsByDiagDir(road_dir); // +1 tile in the direction of the road

	TileIndex next_tile = tile + delta; // The tile beyond which must be connectable to the target tile

	RoadBits rcmd = DiagDirToRoadBits(ReverseDiagDir(road_dir));

	/* Before we try anything, make sure the tile is on the map and not the void. */

	if (!IsValidTile(next_tile)) return false;

		byte bridge_type = RandomRange(MAX_BRIDGES - 1);

		/* Can we actually build the bridge? */

		if (Command<CMD_BUILD_BRIDGE>::Do(CommandFlagsToDCFlags(GetCommandFlags<CMD_BUILD_BRIDGE>()), tile, bridge_tile, TRANSPORT_ROAD, bridge_type, rt).Succeeded()) {

			Command<CMD_BUILD_BRIDGE>::Do(DC_EXEC | CommandFlagsToDCFlags(GetCommandFlags<CMD_BUILD_BRIDGE>()), tile, bridge_tile, TRANSPORT_ROAD, bridge_type, rt);

			_grow_town_result = GROWTH_SUCCEED;

	if (!CanRoadContinueIntoNextTile(t, tunnel_tile, tunnel_dir)) return false;

	/* Attempt to build the tunnel. Return false if it fails to let the town build a road instead. */

	if (Command<CMD_BUILD_TUNNEL>::Do(CommandFlagsToDCFlags(GetCommandFlags<CMD_BUILD_TUNNEL>()), tile, TRANSPORT_ROAD, rt).Succeeded()) {

		Command<CMD_BUILD_TUNNEL>::Do(DC_EXEC | CommandFlagsToDCFlags(GetCommandFlags<CMD_BUILD_TUNNEL>()), tile, TRANSPORT_ROAD, rt);

		_grow_town_result = GROWTH_SUCCEED;

}

/** Test if town can grow road onto a specific tile.

 * @param tile Tile to build upon.

 * @return true iff the tile's road type don't prevent extending the road.

 */

{

	if (!IsTileType(tile, MP_ROAD)) return true;

	/* Allow extending on roadtypes which can be built by town, or if the road type matches the type the town will build. */

	RoadType rt = GetRoadTypeRoad(tile);

}

/**

		}

	} else if (target_dir < DIAGDIR_END && !(cur_rb & DiagDirToRoadBits(ReverseDiagDir(target_dir)))) {

		/* Continue building on a partial road.

		 * Should be always OK, so we only generate

			return;

		}

		_grow_town_result = GROWTH_SEARCH_STOPPED;

	}

			/* Only work with plain land that not already has a house */

			if (!IsTileType(tile, MP_HOUSE) && IsTileFlat(tile)) {

				if (Command<CMD_LANDSCAPE_CLEAR>::Do(DC_AUTO | DC_NO_WATER, tile).Succeeded()) {

					Command<CMD_BUILD_ROAD>::Do(DC_EXEC | DC_AUTO, tile, GenRandomRoadBits(), rt, DRD_NONE, t->index);

					cur_company.Restore();

					return true;

/**

 * Set the pixel format of a window-

 * @param dc Device context to set the pixel format of.

 * @return nullptr on success, error message otherwise.

 */

{

	PIXELFORMATDESCRIPTOR pfd = {

		sizeof(PIXELFORMATDESCRIPTOR), // Size of this struct.

	HDC dc = GetDC(wnd);

	/* Set pixel format of the window. */

		/* Create rendering context. */

		HGLRC rc = wglCreateContext(dc);

		if (rc != nullptr) {

{

	this->dc = GetDC(this->main_wnd);

	if (err != nullptr) return err;

	HGLRC rc = nullptr;

extern void GetStationLayout(byte *layout, uint numtracks, uint plat_len, const StationSpec *statspec);

extern CommandCost FindJoiningWaypoint(StationID existing_station, StationID station_to_join, bool adjacent, TileArea ta, Waypoint **wp);

/**

 * Convert existing rail to waypoint. Eg build a waypoint station over

		/* check if we want to expand an already existing waypoint? */

		if (wp->train_station.tile != INVALID_TILE) {

			if (ret.Failed()) return ret;

		}