Changeset - r24597:afde5721a3b6
[Not reviewed]
master
! ! !
Charles Pigott - 4 years ago 2021-01-08 10:16:18
charlespigott@googlemail.com
Codechange: Remove min/max functions in favour of STL variants (#8502)
153 files changed:
Changeset was too big and was cut off... Show full diff anyway
0 comments (0 inline, 0 general)
src/3rdparty/squirrel/squirrel/sqbaselib.cpp
Show inline comments
 
/*
 
 * see copyright notice in squirrel.h
 
 */
 
/*
 
 * Needs to be first due to a squirrel header defining type() and type()
 
 * being used in some versions of the headers included by algorithm.
 
 */
 

	
 
#include "../../../stdafx.h"
 

	
 
#include <algorithm>
 
#include "sqpcheader.h"
 
#include "sqvm.h"
 
#include "sqstring.h"
src/ai/ai_config.cpp
Show inline comments
 
@@ -39,7 +39,7 @@ AIConfig::AIConfig(const AIConfig *confi
 
	 * This is necessary because the ScriptConfig constructor will instead call
 
	 * ScriptConfig::AddRandomDeviation(). */
 
	int start_date = config->GetSetting("start_date");
 
	this->SetSetting("start_date", start_date != 0 ? max(1, this->GetSetting("start_date")) : 0);
 
	this->SetSetting("start_date", start_date != 0 ? std::max(1, this->GetSetting("start_date")) : 0);
 
}
 

	
 
/* static */ AIConfig *AIConfig::GetConfig(CompanyID company, ScriptSettingSource source)
 
@@ -134,5 +134,5 @@ void AIConfig::AddRandomDeviation()
 

	
 
	/* start_date = 0 is a special case, where random deviation does not occur.
 
	 * If start_date was not already 0, then a minimum value of 1 must apply. */
 
	this->SetSetting("start_date", start_date != 0 ? max(1, this->GetSetting("start_date")) : 0);
 
	this->SetSetting("start_date", start_date != 0 ? std::max(1, this->GetSetting("start_date")) : 0);
 
}
src/ai/ai_gui.cpp
Show inline comments
 
@@ -236,7 +236,7 @@ struct AIListWindow : public Window {
 
		this->vscroll->SetCount((int)this->info_list->size() + 1);
 

	
 
		/* selected goes from -1 .. length of ai list - 1. */
 
		this->selected = min(this->selected, this->vscroll->GetCount() - 2);
 
		this->selected = std::min(this->selected, this->vscroll->GetCount() - 2);
 
	}
 
};
 

	
 
@@ -349,7 +349,7 @@ struct AISettingsWindow : public Window 
 
	void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize) override
 
	{
 
		if (widget == WID_AIS_BACKGROUND) {
 
			this->line_height = max(SETTING_BUTTON_HEIGHT, FONT_HEIGHT_NORMAL) + WD_MATRIX_TOP + WD_MATRIX_BOTTOM;
 
			this->line_height = std::max(SETTING_BUTTON_HEIGHT, FONT_HEIGHT_NORMAL) + WD_MATRIX_TOP + WD_MATRIX_BOTTOM;
 

	
 
			resize->width = 1;
 
			resize->height = this->line_height;
 
@@ -879,9 +879,9 @@ struct AIConfigWindow : public Window {
 
			case WID_AIC_INCREASE: {
 
				int new_value;
 
				if (widget == WID_AIC_DECREASE) {
 
					new_value = max(0, GetGameSettings().difficulty.max_no_competitors - 1);
 
					new_value = std::max(0, GetGameSettings().difficulty.max_no_competitors - 1);
 
				} else {
 
					new_value = min(MAX_COMPANIES - 1, GetGameSettings().difficulty.max_no_competitors + 1);
 
					new_value = std::min(MAX_COMPANIES - 1, GetGameSettings().difficulty.max_no_competitors + 1);
 
				}
 
				IConsoleSetSetting("difficulty.max_no_competitors", new_value);
 
				break;
 
@@ -1176,7 +1176,7 @@ struct AIDebugWindow : public Window {
 
			this->autoscroll = this->vscroll->GetPosition() >= log->used - this->vscroll->GetCapacity();
 
		}
 
		if (this->autoscroll) {
 
			int scroll_pos = max(0, log->used - this->vscroll->GetCapacity());
 
			int scroll_pos = std::max(0, log->used - this->vscroll->GetCapacity());
 
			if (scroll_pos != this->vscroll->GetPosition()) {
 
				this->vscroll->SetPosition(scroll_pos);
 

	
src/aircraft_cmd.cpp
Show inline comments
 
@@ -652,7 +652,7 @@ static int UpdateAircraftSpeed(Aircraft 
 
	/* adjust speed for broken vehicles */
 
	if (v->vehstatus & VS_AIRCRAFT_BROKEN) {
 
		if (SPEED_LIMIT_BROKEN < speed_limit) hard_limit = false;
 
		speed_limit = min(speed_limit, SPEED_LIMIT_BROKEN);
 
		speed_limit = std::min<uint>(speed_limit, SPEED_LIMIT_BROKEN);
 
	}
 

	
 
	if (v->vcache.cached_max_speed < speed_limit) {
 
@@ -669,10 +669,10 @@ static int UpdateAircraftSpeed(Aircraft 
 
	 * speeds to that aircraft do not get to taxi speed straight after
 
	 * touchdown. */
 
	if (!hard_limit && v->cur_speed > speed_limit) {
 
		speed_limit = v->cur_speed - max(1, ((v->cur_speed * v->cur_speed) / 16384) / _settings_game.vehicle.plane_speed);
 
		speed_limit = v->cur_speed - std::max(1, ((v->cur_speed * v->cur_speed) / 16384) / _settings_game.vehicle.plane_speed);
 
	}
 

	
 
	spd = min(v->cur_speed + (spd >> 8) + (v->subspeed < t), speed_limit);
 
	spd = std::min(v->cur_speed + (spd >> 8) + (v->subspeed < t), speed_limit);
 

	
 
	/* updates statusbar only if speed have changed to save CPU time */
 
	if (spd != v->cur_speed) {
 
@@ -737,7 +737,7 @@ void GetAircraftFlightLevelBounds(const 
 
	}
 

	
 
	/* Make faster planes fly higher so that they can overtake slower ones */
 
	base_altitude += min(20 * (v->vcache.cached_max_speed / 200) - 90, 0);
 
	base_altitude += std::min(20 * (v->vcache.cached_max_speed / 200) - 90, 0);
 

	
 
	if (min_level != nullptr) *min_level = base_altitude + AIRCRAFT_MIN_FLYING_ALTITUDE;
 
	if (max_level != nullptr) *max_level = base_altitude + AIRCRAFT_MAX_FLYING_ALTITUDE;
 
@@ -929,7 +929,7 @@ static bool AircraftController(Aircraft 
 
					v->cur_speed = 0;
 
					return true;
 
				}
 
				SetAircraftPosition(v, v->x_pos, v->y_pos, min(v->z_pos + count, z_dest));
 
				SetAircraftPosition(v, v->x_pos, v->y_pos, std::min(v->z_pos + count, z_dest));
 
			}
 
		}
 
		return false;
 
@@ -975,9 +975,9 @@ static bool AircraftController(Aircraft 
 
			count = UpdateAircraftSpeed(v);
 
			if (count > 0) {
 
				if (v->z_pos > z) {
 
					SetAircraftPosition(v, v->x_pos, v->y_pos, max(v->z_pos - count, z));
 
					SetAircraftPosition(v, v->x_pos, v->y_pos, std::max(v->z_pos - count, z));
 
				} else {
 
					SetAircraftPosition(v, v->x_pos, v->y_pos, min(v->z_pos + count, z));
 
					SetAircraftPosition(v, v->x_pos, v->y_pos, std::min(v->z_pos + count, z));
 
				}
 
			}
 
		}
 
@@ -1125,7 +1125,7 @@ static bool AircraftController(Aircraft 
 

	
 
			/* We're not flying below our destination, right? */
 
			assert(airport_z <= z);
 
			int t = max(1U, dist - 4);
 
			int t = std::max(1U, dist - 4);
 
			int delta = z - airport_z;
 

	
 
			/* Only start lowering when we're sufficiently close for a 1:1 glide */
src/airport_gui.cpp
Show inline comments
 
@@ -314,7 +314,7 @@ public:
 
					const AirportSpec *as = AirportSpec::Get(i);
 
					if (!as->enabled) continue;
 

	
 
					size->width = max(size->width, GetStringBoundingBox(as->name).width);
 
					size->width = std::max(size->width, GetStringBoundingBox(as->name).width);
 
				}
 

	
 
				this->line_height = FONT_HEIGHT_NORMAL + WD_MATRIX_TOP + WD_MATRIX_BOTTOM;
src/autoreplace_cmd.cpp
Show inline comments
 
@@ -115,7 +115,7 @@ void CheckCargoCapacity(Vehicle *v)
 
			assert(dest->cargo.TotalCount() == dest->cargo.ActionCount(VehicleCargoList::MTA_KEEP));
 
			if (dest->cargo.TotalCount() >= dest->cargo_cap || dest->cargo_type != src->cargo_type) continue;
 

	
 
			uint amount = min(to_spread, dest->cargo_cap - dest->cargo.TotalCount());
 
			uint amount = std::min(to_spread, dest->cargo_cap - dest->cargo.TotalCount());
 
			src->cargo.Shift(amount, &dest->cargo);
 
			to_spread -= amount;
 
		}
 
@@ -157,7 +157,7 @@ static void TransferCargo(Vehicle *old_v
 
			}
 
			if (dest->cargo_type != src->cargo_type) continue;
 

	
 
			uint amount = min(src->cargo.TotalCount(), dest->cargo_cap - dest->cargo.TotalCount());
 
			uint amount = std::min(src->cargo.TotalCount(), dest->cargo_cap - dest->cargo.TotalCount());
 
			if (amount <= 0) continue;
 

	
 
			src->cargo.Shift(amount, &dest->cargo);
src/autoreplace_gui.cpp
Show inline comments
 
@@ -416,8 +416,8 @@ public:
 
			case WID_RV_LEFT_MATRIX:
 
			case WID_RV_RIGHT_MATRIX: {
 
				int side = (widget == WID_RV_LEFT_MATRIX) ? 0 : 1;
 
				EngineID start  = this->vscroll[side]->GetPosition(); // what is the offset for the start (scrolling)
 
				EngineID end    = min(this->vscroll[side]->GetCapacity() + start, (uint)this->engines[side].size());
 
				EngineID start  = static_cast<EngineID>(this->vscroll[side]->GetPosition()); // what is the offset for the start (scrolling)
 
				EngineID end    = static_cast<EngineID>(std::min<size_t>(this->vscroll[side]->GetCapacity() + start, this->engines[side].size()));
 

	
 
				/* Do the actual drawing */
 
				DrawEngineList((VehicleType)this->window_number, r.left + WD_FRAMERECT_LEFT, r.right - WD_FRAMERECT_RIGHT, r.top + WD_FRAMERECT_TOP,
 
@@ -475,7 +475,7 @@ public:
 
					NWidgetBase *nwi = this->GetWidget<NWidgetBase>(side == 0 ? WID_RV_LEFT_DETAILS : WID_RV_RIGHT_DETAILS);
 
					int text_end = DrawVehiclePurchaseInfo(nwi->pos_x + WD_FRAMETEXT_LEFT, nwi->pos_x + nwi->current_x - WD_FRAMETEXT_RIGHT,
 
							nwi->pos_y + WD_FRAMERECT_TOP, this->sel_engine[side], ted);
 
					needed_height = max(needed_height, text_end - (int)nwi->pos_y + WD_FRAMERECT_BOTTOM);
 
					needed_height = std::max(needed_height, text_end - (int)nwi->pos_y + WD_FRAMERECT_BOTTOM);
 
				}
 
			}
 
			if (needed_height != this->details_height) { // Details window are not high enough, enlarge them.
src/blitter/32bpp_anim.cpp
Show inline comments
 
@@ -74,7 +74,7 @@ inline void Blitter_32bppAnim::Draw(cons
 
					dst = dst_end - bp->skip_left;
 
					dst_end = dst + bp->width;
 

	
 
					n = min<uint>(n - d, (uint)bp->width);
 
					n = std::min(n - d, (uint)bp->width);
 
					goto draw;
 
				}
 
				dst += n;
 
@@ -89,7 +89,7 @@ inline void Blitter_32bppAnim::Draw(cons
 
		dst_end += bp->width;
 

	
 
		while (dst < dst_end) {
 
			n = min<uint>(*src_n++, (uint)(dst_end - dst));
 
			n = std::min<uint>(*src_n++, dst_end - dst);
 

	
 
			if (src_px->a == 0) {
 
				anim += n;
src/blitter/32bpp_anim_sse2.cpp
Show inline comments
 
@@ -58,7 +58,7 @@ void Blitter_32bppSSE2_Anim::PaletteAnim
 
				if (x < 8 || colour_cmp_result != 0xFFFF ||
 
						_mm_movemask_epi8(_mm_cmpeq_epi16(_mm_srli_epi16(data, 8), brightness_cmp)) != 0xFFFF) {
 
					/* slow path: < 8 pixels left or unexpected brightnesses */
 
					for (int z = min<int>(x, 8); z != 0 ; z--) {
 
					for (int z = std::min<int>(x, 8); z != 0 ; z--) {
 
						int value = _mm_extract_epi16(data, 0);
 
						uint8 colour = GB(value, 0, 8);
 
						if (colour >= PALETTE_ANIM_START) {
src/blitter/32bpp_base.cpp
Show inline comments
 
@@ -174,9 +174,9 @@ Colour Blitter_32bppBase::ReallyAdjustBr
 
	/* Reduce overbright strength */
 
	ob /= 2;
 
	return Colour(
 
		r >= 255 ? 255 : min(r + ob * (255 - r) / 256, 255),
 
		g >= 255 ? 255 : min(g + ob * (255 - g) / 256, 255),
 
		b >= 255 ? 255 : min(b + ob * (255 - b) / 256, 255),
 
		r >= 255 ? 255 : std::min(r + ob * (255 - r) / 256, 255),
 
		g >= 255 ? 255 : std::min(g + ob * (255 - g) / 256, 255),
 
		b >= 255 ? 255 : std::min(b + ob * (255 - b) / 256, 255),
 
		colour.a);
 
}
 

	
src/blitter/32bpp_optimized.cpp
Show inline comments
 
@@ -83,7 +83,7 @@ inline void Blitter_32bppOptimized::Draw
 
					dst = dst_end - bp->skip_left;
 
					dst_end = dst + bp->width;
 

	
 
					n = min<uint>(n - d, (uint)bp->width);
 
					n = std::min(n - d, (uint)bp->width);
 
					goto draw;
 
				}
 
				dst += n;
 
@@ -98,7 +98,7 @@ inline void Blitter_32bppOptimized::Draw
 
		dst_end += bp->width;
 

	
 
		while (dst < dst_end) {
 
			n = min<uint>(*src_n++, (uint)(dst_end - dst));
 
			n = std::min<uint>(*src_n++, dst_end - dst);
 

	
 
			if (src_px->a == 0) {
 
				dst += n;
 
@@ -324,7 +324,7 @@ Sprite *Blitter_32bppOptimized::Encode(c
 
					*dst_n = src->m;
 
					if (src->m != 0) {
 
						/* Get brightest value */
 
						uint8 rgb_max = max(src->r, max(src->g, src->b));
 
						uint8 rgb_max = std::max({src->r, src->g, src->b});
 

	
 
						/* Black pixel (8bpp or old 32bpp image), so use default value */
 
						if (rgb_max == 0) rgb_max = DEFAULT_BRIGHTNESS;
src/blitter/32bpp_simple.cpp
Show inline comments
 
@@ -132,7 +132,7 @@ Sprite *Blitter_32bppSimple::Encode(cons
 
			dst[i].v = 0;
 
		} else {
 
			/* Get brightest value */
 
			uint8 rgb_max = max(src->r, max(src->g, src->b));
 
			uint8 rgb_max = std::max({src->r, src->g, src->b});
 

	
 
			/* Black pixel (8bpp or old 32bpp image), so use default value */
 
			if (rgb_max == 0) rgb_max = DEFAULT_BRIGHTNESS;
src/blitter/32bpp_sse2.cpp
Show inline comments
 
@@ -80,7 +80,7 @@ Sprite *Blitter_32bppSSE_Base::Encode(co
 
						if (src->m >= PALETTE_ANIM_START) has_anim = true;
 

	
 
						/* Get brightest value (or default brightness if it's a black pixel). */
 
						const uint8 rgb_max = max(src->r, max(src->g, src->b));
 
						const uint8 rgb_max = std::max({src->r, src->g, src->b});
 
						dst_mv->v = (rgb_max == 0) ? Blitter_32bppBase::DEFAULT_BRIGHTNESS : rgb_max;
 

	
 
						/* Pre-convert the mapping channel to a RGB value. */
src/blitter/8bpp_optimized.cpp
Show inline comments
 
@@ -80,7 +80,7 @@ void Blitter_8bppOptimized::Draw(Blitter
 
			dst += trans;
 
			width -= trans;
 
			if (width <= 0 || pixels == 0) continue;
 
			pixels = min<uint>(pixels, (uint)width);
 
			pixels = std::min<uint>(pixels, width);
 
			width -= pixels;
 

	
 
			switch (mode) {
src/blitter/common.hpp
Show inline comments
 
@@ -45,7 +45,7 @@ void Blitter::DrawLineGeneric(int x, int
 
		return;
 
	}
 

	
 
	int frac_diff = width * max(dx, dy);
 
	int frac_diff = width * std::max(dx, dy);
 
	if (width > 1) {
 
		/* compute frac_diff = width * sqrt(dx*dx + dy*dy)
 
		 * Start interval:
src/bridge_gui.cpp
Show inline comments
 
@@ -197,7 +197,7 @@ public:
 
				}
 
				sprite_dim.height++; // Sprite is rendered one pixel down in the matrix field.
 
				text_dim.height++; // Allowing the bottom row pixels to be rendered on the edge of the matrix field.
 
				resize->height = max(sprite_dim.height, text_dim.height) + 2; // Max of both sizes + account for matrix edges.
 
				resize->height = std::max(sprite_dim.height, text_dim.height) + 2; // Max of both sizes + account for matrix edges.
 

	
 
				this->bridgetext_offset = WD_MATRIX_LEFT + sprite_dim.width + 1; // Left edge of text, 1 pixel distance from the sprite.
 
				size->width = this->bridgetext_offset + text_dim.width + WD_MATRIX_RIGHT;
src/build_vehicle_gui.cpp
Show inline comments
 
@@ -44,7 +44,7 @@
 
 */
 
uint GetEngineListHeight(VehicleType type)
 
{
 
	return max<uint>(FONT_HEIGHT_NORMAL + WD_MATRIX_TOP + WD_MATRIX_BOTTOM, GetVehicleImageCellSize(type, EIT_PURCHASE).height);
 
	return std::max<uint>(FONT_HEIGHT_NORMAL + WD_MATRIX_TOP + WD_MATRIX_BOTTOM, GetVehicleImageCellSize(type, EIT_PURCHASE).height);
 
}
 

	
 
static const NWidgetPart _nested_build_vehicle_widgets[] = {
 
@@ -1537,7 +1537,7 @@ struct BuildVehicleWindow : Window {
 
			case WID_BV_LIST:
 
				resize->height = GetEngineListHeight(this->vehicle_type);
 
				size->height = 3 * resize->height;
 
				size->width = max(size->width, GetVehicleImageCellSize(this->vehicle_type, EIT_PURCHASE).extend_left + GetVehicleImageCellSize(this->vehicle_type, EIT_PURCHASE).extend_right + 165);
 
				size->width = std::max(size->width, GetVehicleImageCellSize(this->vehicle_type, EIT_PURCHASE).extend_left + GetVehicleImageCellSize(this->vehicle_type, EIT_PURCHASE).extend_right + 165);
 
				break;
 

	
 
			case WID_BV_PANEL:
 
@@ -1572,7 +1572,18 @@ struct BuildVehicleWindow : Window {
 
	{
 
		switch (widget) {
 
			case WID_BV_LIST:
 
				DrawEngineList(this->vehicle_type, r.left + WD_FRAMERECT_LEFT, r.right - WD_FRAMERECT_RIGHT, r.top + WD_FRAMERECT_TOP, &this->eng_list, this->vscroll->GetPosition(), min(this->vscroll->GetPosition() + this->vscroll->GetCapacity(), (uint)this->eng_list.size()), this->sel_engine, false, DEFAULT_GROUP);
 
				DrawEngineList(
 
					this->vehicle_type,
 
					r.left + WD_FRAMERECT_LEFT,
 
					r.right - WD_FRAMERECT_RIGHT,
 
					r.top + WD_FRAMERECT_TOP,
 
					&this->eng_list,
 
					this->vscroll->GetPosition(),
 
					static_cast<uint16>(std::min<size_t>(this->vscroll->GetPosition() + this->vscroll->GetCapacity(), this->eng_list.size())),
 
					this->sel_engine,
 
					false,
 
					DEFAULT_GROUP
 
				);
 
				break;
 

	
 
			case WID_BV_SORT_ASCENDING_DESCENDING:
 
@@ -1597,7 +1608,7 @@ struct BuildVehicleWindow : Window {
 
				NWidgetBase *nwi = this->GetWidget<NWidgetBase>(WID_BV_PANEL);
 
				int text_end = DrawVehiclePurchaseInfo(nwi->pos_x + WD_FRAMETEXT_LEFT, nwi->pos_x + nwi->current_x - WD_FRAMETEXT_RIGHT,
 
						nwi->pos_y + WD_FRAMERECT_TOP, this->sel_engine, this->te);
 
				needed_height = max(needed_height, text_end - (int)nwi->pos_y + WD_FRAMERECT_BOTTOM);
 
				needed_height = std::max(needed_height, text_end - (int)nwi->pos_y + WD_FRAMERECT_BOTTOM);
 
			}
 
			if (needed_height != this->details_height) { // Details window are not high enough, enlarge them.
 
				int resize = needed_height - this->details_height;
src/cargopacket.cpp
Show inline comments
 
@@ -558,7 +558,7 @@ uint VehicleCargoList::Reassign(uint max
 
{
 
	static_assert(Tfrom != MTA_TRANSFER && Tto != MTA_TRANSFER);
 
	static_assert(Tfrom - Tto == 1 || Tto - Tfrom == 1);
 
	max_move = min(this->action_counts[Tfrom], max_move);
 
	max_move = std::min(this->action_counts[Tfrom], max_move);
 
	this->action_counts[Tfrom] -= max_move;
 
	this->action_counts[Tto] += max_move;
 
	return max_move;
 
@@ -574,7 +574,7 @@ uint VehicleCargoList::Reassign(uint max
 
template<>
 
uint VehicleCargoList::Reassign<VehicleCargoList::MTA_DELIVER, VehicleCargoList::MTA_TRANSFER>(uint max_move, TileOrStationID next_station)
 
{
 
	max_move = min(this->action_counts[MTA_DELIVER], max_move);
 
	max_move = std::min(this->action_counts[MTA_DELIVER], max_move);
 

	
 
	uint sum = 0;
 
	for (Iterator it(this->packets.begin()); sum < this->action_counts[MTA_TRANSFER] + max_move;) {
 
@@ -603,7 +603,7 @@ uint VehicleCargoList::Reassign<VehicleC
 
 */
 
uint VehicleCargoList::Return(uint max_move, StationCargoList *dest, StationID next)
 
{
 
	max_move = min(this->action_counts[MTA_LOAD], max_move);
 
	max_move = std::min(this->action_counts[MTA_LOAD], max_move);
 
	this->PopCargo(CargoReturn(this, dest, max_move, next));
 
	return max_move;
 
}
 
@@ -616,7 +616,7 @@ uint VehicleCargoList::Return(uint max_m
 
 */
 
uint VehicleCargoList::Shift(uint max_move, VehicleCargoList *dest)
 
{
 
	max_move = min(this->count, max_move);
 
	max_move = std::min(this->count, max_move);
 
	this->PopCargo(CargoShift(this, dest, max_move));
 
	return max_move;
 
}
 
@@ -633,12 +633,12 @@ uint VehicleCargoList::Unload(uint max_m
 
{
 
	uint moved = 0;
 
	if (this->action_counts[MTA_TRANSFER] > 0) {
 
		uint move = min(this->action_counts[MTA_TRANSFER], max_move);
 
		uint move = std::min(this->action_counts[MTA_TRANSFER], max_move);
 
		this->ShiftCargo(CargoTransfer(this, dest, move));
 
		moved += move;
 
	}
 
	if (this->action_counts[MTA_TRANSFER] == 0 && this->action_counts[MTA_DELIVER] > 0 && moved < max_move) {
 
		uint move = min(this->action_counts[MTA_DELIVER], max_move - moved);
 
		uint move = std::min(this->action_counts[MTA_DELIVER], max_move - moved);
 
		this->ShiftCargo(CargoDelivery(this, move, payment));
 
		moved += move;
 
	}
 
@@ -653,7 +653,7 @@ uint VehicleCargoList::Unload(uint max_m
 
 */
 
uint VehicleCargoList::Truncate(uint max_move)
 
{
 
	max_move = min(this->count, max_move);
 
	max_move = std::min(this->count, max_move);
 
	this->PopCargo(CargoRemoval<VehicleCargoList>(this, max_move));
 
	return max_move;
 
}
 
@@ -668,7 +668,7 @@ uint VehicleCargoList::Truncate(uint max
 
 */
 
uint VehicleCargoList::Reroute(uint max_move, VehicleCargoList *dest, StationID avoid, StationID avoid2, const GoodsEntry *ge)
 
{
 
	max_move = min(this->action_counts[MTA_TRANSFER], max_move);
 
	max_move = std::min(this->action_counts[MTA_TRANSFER], max_move);
 
	this->ShiftCargo(VehicleCargoReroute(this, dest, max_move, avoid, avoid2, ge));
 
	return max_move;
 
}
 
@@ -768,7 +768,7 @@ uint StationCargoList::ShiftCargo(Tactio
 
 */
 
uint StationCargoList::Truncate(uint max_move, StationCargoAmountMap *cargo_per_source)
 
{
 
	max_move = min(max_move, this->count);
 
	max_move = std::min(max_move, this->count);
 
	uint prev_count = this->count;
 
	uint moved = 0;
 
	uint loop = 0;
 
@@ -839,7 +839,7 @@ uint StationCargoList::Reserve(uint max_
 
 */
 
uint StationCargoList::Load(uint max_move, VehicleCargoList *dest, TileIndex load_place, StationIDStack next_station)
 
{
 
	uint move = min(dest->ActionCount(VehicleCargoList::MTA_LOAD), max_move);
 
	uint move = std::min(dest->ActionCount(VehicleCargoList::MTA_LOAD), max_move);
 
	if (move > 0) {
 
		this->reserved_count -= move;
 
		dest->Reassign<VehicleCargoList::MTA_LOAD, VehicleCargoList::MTA_KEEP>(move);
src/cargotype.cpp
Show inline comments
 
@@ -12,7 +12,6 @@
 
#include "newgrf_cargo.h"
 
#include "string_func.h"
 
#include "strings_func.h"
 
#include <algorithm>
 

	
 
#include "table/sprites.h"
 
#include "table/strings.h"
src/cheat_gui.cpp
Show inline comments
 
@@ -291,9 +291,9 @@ struct CheatWindow : Window {
 
			switch (ce->type) {
 
				case SLE_BOOL:
 
					SetDParam(0, STR_CONFIG_SETTING_ON);
 
					width = max(width, GetStringBoundingBox(ce->str).width);
 
					width = std::max(width, GetStringBoundingBox(ce->str).width);
 
					SetDParam(0, STR_CONFIG_SETTING_OFF);
 
					width = max(width, GetStringBoundingBox(ce->str).width);
 
					width = std::max(width, GetStringBoundingBox(ce->str).width);
 
					break;
 

	
 
				default:
 
@@ -301,27 +301,27 @@ struct CheatWindow : Window {
 
						/* Display date for change date cheat */
 
						case STR_CHEAT_CHANGE_DATE:
 
							SetDParam(0, ConvertYMDToDate(MAX_YEAR, 11, 31));
 
							width = max(width, GetStringBoundingBox(ce->str).width);
 
							width = std::max(width, GetStringBoundingBox(ce->str).width);
 
							break;
 

	
 
						/* Draw coloured flag for change company cheat */
 
						case STR_CHEAT_CHANGE_COMPANY:
 
							SetDParamMaxValue(0, MAX_COMPANIES);
 
							width = max(width, GetStringBoundingBox(ce->str).width + 10 + 10);
 
							width = std::max(width, GetStringBoundingBox(ce->str).width + 10 + 10);
 
							break;
 

	
 
						default:
 
							SetDParam(0, INT64_MAX);
 
							width = max(width, GetStringBoundingBox(ce->str).width);
 
							width = std::max(width, GetStringBoundingBox(ce->str).width);
 
							break;
 
					}
 
					break;
 
			}
 
		}
 

	
 
		this->line_height = max(GetSpriteSize(SPR_BOX_CHECKED).height, GetSpriteSize(SPR_BOX_EMPTY).height);
 
		this->line_height = max<uint>(this->line_height, SETTING_BUTTON_HEIGHT);
 
		this->line_height = max<uint>(this->line_height, FONT_HEIGHT_NORMAL) + WD_PAR_VSEP_NORMAL;
 
		this->line_height = std::max(GetSpriteSize(SPR_BOX_CHECKED).height, GetSpriteSize(SPR_BOX_EMPTY).height);
 
		this->line_height = std::max<uint>(this->line_height, SETTING_BUTTON_HEIGHT);
 
		this->line_height = std::max<uint>(this->line_height, FONT_HEIGHT_NORMAL) + WD_PAR_VSEP_NORMAL;
 

	
 
		size->width = width + 20 + this->box_width + SETTING_BUTTON_WIDTH /* stuff on the left */ + 10 /* extra spacing on right */;
 
		this->header_height = GetStringHeight(STR_CHEATS_WARNING, size->width - WD_FRAMERECT_LEFT - WD_FRAMERECT_RIGHT) + WD_PAR_VSEP_WIDE;
src/clear_cmd.cpp
Show inline comments
 
@@ -191,7 +191,7 @@ static void TileLoopClearAlps(TileIndex 
 
	}
 
	/* Update snow density. */
 
	uint current_density = GetClearDensity(tile);
 
	uint req_density = (k < 0) ? 0u : min((uint)k, 3);
 
	uint req_density = (k < 0) ? 0u : std::min<uint>(k, 3u);
 

	
 
	if (current_density < req_density) {
 
		AddClearDensity(tile, 1);
src/company_cmd.cpp
Show inline comments
 
@@ -265,9 +265,9 @@ void SubtractMoneyFromCompanyFract(Compa
 
void UpdateLandscapingLimits()
 
{
 
	for (Company *c : Company::Iterate()) {
 
		c->terraform_limit = min(c->terraform_limit + _settings_game.construction.terraform_per_64k_frames, (uint32)_settings_game.construction.terraform_frame_burst << 16);
 
		c->clear_limit     = min(c->clear_limit     + _settings_game.construction.clear_per_64k_frames,     (uint32)_settings_game.construction.clear_frame_burst << 16);
 
		c->tree_limit      = min(c->tree_limit      + _settings_game.construction.tree_per_64k_frames,      (uint32)_settings_game.construction.tree_frame_burst << 16);
 
		c->terraform_limit = std::min<uint32>(c->terraform_limit + _settings_game.construction.terraform_per_64k_frames, _settings_game.construction.terraform_frame_burst << 16);
 
		c->clear_limit     = std::min<uint32>(c->clear_limit     + _settings_game.construction.clear_per_64k_frames,     _settings_game.construction.clear_frame_burst << 16);
 
		c->tree_limit      = std::min<uint32>(c->tree_limit      + _settings_game.construction.tree_per_64k_frames,      _settings_game.construction.tree_frame_burst << 16);
 
	}
 
}
 

	
 
@@ -554,7 +554,7 @@ Company *DoStartupNewCompany(bool is_ai,
 
	ResetCompanyLivery(c);
 
	_company_colours[c->index] = (Colours)c->colour;
 

	
 
	c->money = c->current_loan = (min(INITIAL_LOAN, _economy.max_loan) * _economy.inflation_prices >> 16) / 50000 * 50000;
 
	c->money = c->current_loan = (std::min<int64>(INITIAL_LOAN, _economy.max_loan) * _economy.inflation_prices >> 16) / 50000 * 50000;
 

	
 
	c->share_owners[0] = c->share_owners[1] = c->share_owners[2] = c->share_owners[3] = INVALID_OWNER;
 

	
 
@@ -708,7 +708,7 @@ void OnTick_Companies()
 

	
 
	if (_next_competitor_start == 0) {
 
		/* AI::GetStartNextTime() can return 0. */
 
		_next_competitor_start = max(1, AI::GetStartNextTime() * DAY_TICKS);
 
		_next_competitor_start = std::max(1, AI::GetStartNextTime() * DAY_TICKS);
 
	}
 

	
 
	if (_game_mode != GM_MENU && AI::CanStartNew() && --_next_competitor_start == 0) {
 
@@ -1198,7 +1198,7 @@ CommandCost CmdGiveMoney(TileIndex tile,
 
	if (!_settings_game.economy.give_money) return CMD_ERROR;
 

	
 
	const Company *c = Company::Get(_current_company);
 
	CommandCost amount(EXPENSES_OTHER, min((Money)p1, (Money)20000000LL));
 
	CommandCost amount(EXPENSES_OTHER, std::min<Money>(p1, 20000000LL));
 
	CompanyID dest_company = (CompanyID)p2;
 

	
 
	/* You can only transfer funds that is in excess of your loan */
src/company_gui.cpp
Show inline comments
 
@@ -112,11 +112,11 @@ struct ExpensesList {
 
			ExpensesType et = this->et[i];
 
			if (et == INVALID_EXPENSES) {
 
				if (!invalid_expenses_measured) {
 
					width = max(width, GetStringBoundingBox(STR_FINANCES_TOTAL_CAPTION).width);
 
					width = std::max(width, GetStringBoundingBox(STR_FINANCES_TOTAL_CAPTION).width);
 
					invalid_expenses_measured = true;
 
				}
 
			} else {
 
				width = max(width, GetStringBoundingBox(STR_FINANCES_SECTION_CONSTRUCTION + et).width);
 
				width = std::max(width, GetStringBoundingBox(STR_FINANCES_SECTION_CONSTRUCTION + et).width);
 
			}
 
		}
 
		return width;
 
@@ -322,7 +322,7 @@ struct CompanyFinancesWindow : Window {
 
			case WID_CF_LOAN_VALUE:
 
			case WID_CF_TOTAL_VALUE:
 
				SetDParamMaxValue(0, CompanyFinancesWindow::max_money);
 
				size->width = max(GetStringBoundingBox(STR_FINANCES_NEGATIVE_INCOME).width, GetStringBoundingBox(STR_FINANCES_POSITIVE_INCOME).width) + padding.width;
 
				size->width = std::max(GetStringBoundingBox(STR_FINANCES_NEGATIVE_INCOME).width, GetStringBoundingBox(STR_FINANCES_POSITIVE_INCOME).width) + padding.width;
 
				break;
 

	
 
			case WID_CF_MAXLOAN_GAP:
 
@@ -342,7 +342,7 @@ struct CompanyFinancesWindow : Window {
 
			case WID_CF_EXPS_PRICE2:
 
			case WID_CF_EXPS_PRICE3: {
 
				const Company *c = Company::Get((CompanyID)this->window_number);
 
				int age = min(_cur_year - c->inaugurated_year, 2);
 
				int age = std::min(_cur_year - c->inaugurated_year, 2);
 
				int wid_offset = widget - WID_CF_EXPS_PRICE1;
 
				if (wid_offset <= age) {
 
					DrawYearColumn(r, _cur_year - (age - wid_offset), c->yearly_expenses + (age - wid_offset));
 
@@ -455,7 +455,7 @@ struct CompanyFinancesWindow : Window {
 
	{
 
		const Company *c = Company::Get((CompanyID)this->window_number);
 
		if (c->money > CompanyFinancesWindow::max_money) {
 
			CompanyFinancesWindow::max_money = max(c->money * 2, CompanyFinancesWindow::max_money * 4);
 
			CompanyFinancesWindow::max_money = std::max(c->money * 2, CompanyFinancesWindow::max_money * 4);
 
			this->SetupWidgets();
 
			this->ReInit();
 
		}
 
@@ -526,7 +526,7 @@ public:
 

	
 
	uint Height(uint width) const override
 
	{
 
		return max(FONT_HEIGHT_NORMAL, ScaleGUITrad(12) + 2);
 
		return std::max(FONT_HEIGHT_NORMAL, ScaleGUITrad(12) + 2);
 
	}
 

	
 
	bool Selectable() const override
 
@@ -731,7 +731,7 @@ public:
 
		/* Position scrollbar to selected group */
 
		for (uint i = 0; i < this->rows; i++) {
 
			if (this->groups[i]->index == sel) {
 
				this->vscroll->SetPosition(Clamp(i - this->vscroll->GetCapacity() / 2, 0, max(this->vscroll->GetCount() - this->vscroll->GetCapacity(), 0)));
 
				this->vscroll->SetPosition(Clamp(i - this->vscroll->GetCapacity() / 2, 0, std::max(this->vscroll->GetCount() - this->vscroll->GetCapacity(), 0)));
 
				break;
 
			}
 
		}
 
@@ -755,14 +755,14 @@ public:
 
					}
 
				}
 

	
 
				size->width = max(size->width, 5 + d.width + WD_FRAMERECT_RIGHT);
 
				size->width = std::max(size->width, 5 + d.width + WD_FRAMERECT_RIGHT);
 
				break;
 
			}
 

	
 
			case WID_SCL_MATRIX: {
 
				/* 11 items in the default rail class */
 
				this->square = GetSpriteSize(SPR_SQUARE);
 
				this->line_height = max(this->square.height, (uint)FONT_HEIGHT_NORMAL) + 4;
 
				this->line_height = std::max(this->square.height, (uint)FONT_HEIGHT_NORMAL) + 4;
 

	
 
				size->height = 11 * this->line_height;
 
				resize->width = 1;
 
@@ -781,9 +781,9 @@ public:
 
				this->square = GetSpriteSize(SPR_SQUARE);
 
				int padding = this->square.width + NWidgetScrollbar::GetVerticalDimension().width + 10;
 
				for (const StringID *id = _colour_dropdown; id != endof(_colour_dropdown); id++) {
 
					size->width = max(size->width, GetStringBoundingBox(*id).width + padding);
 
					size->width = std::max(size->width, GetStringBoundingBox(*id).width + padding);
 
				}
 
				size->width = max(size->width, GetStringBoundingBox(STR_COLOUR_DEFAULT).width + padding);
 
				size->width = std::max(size->width, GetStringBoundingBox(STR_COLOUR_DEFAULT).width + padding);
 
				break;
 
			}
 
		}
 
@@ -898,7 +898,7 @@ public:
 
				}
 
			}
 
		} else {
 
			uint max = min(this->vscroll->GetPosition() + this->vscroll->GetCapacity(), (uint)this->groups.size());
 
			uint max = static_cast<uint>(std::min<size_t>(this->vscroll->GetPosition() + this->vscroll->GetCapacity(), this->groups.size()));
 
			for (uint i = this->vscroll->GetPosition(); i < max; ++i) {
 
				const Group *g = this->groups[i];
 
				SetDParam(0, g->index);
 
@@ -1380,7 +1380,7 @@ public:
 
		number_dim.width += WD_FRAMERECT_LEFT + WD_FRAMERECT_RIGHT + arrows_width;
 
		number_dim.height += WD_FRAMERECT_TOP + WD_FRAMERECT_BOTTOM;
 
		/* Compute width of both buttons. */
 
		yesno_dim.width = max(yesno_dim.width, number_dim.width);
 
		yesno_dim.width = std::max(yesno_dim.width, number_dim.width);
 
		number_dim.width = yesno_dim.width - arrows_width;
 

	
 
		this->yesno_dim = yesno_dim;
 
@@ -1392,8 +1392,8 @@ public:
 
		switch (widget) {
 
			case WID_SCMF_FACE: {
 
				Dimension face_size = GetSpriteSize(SPR_GRADIENT);
 
				size->width  = max(size->width,  face_size.width);
 
				size->height = max(size->height, face_size.height);
 
				size->width  = std::max(size->width,  face_size.width);
 
				size->height = std::max(size->height, face_size.height);
 
				break;
 
			}
 

	
 
@@ -1885,22 +1885,22 @@ struct CompanyInfrastructureWindow : Win
 
			case WID_CI_RAIL_DESC: {
 
				uint lines = 1; // Starts at 1 because a line is also required for the section title
 

	
 
				size->width = max(size->width, GetStringBoundingBox(STR_COMPANY_INFRASTRUCTURE_VIEW_RAIL_SECT).width);
 
				size->width = std::max(size->width, GetStringBoundingBox(STR_COMPANY_INFRASTRUCTURE_VIEW_RAIL_SECT).width);
 

	
 
				RailType rt;
 
				FOR_ALL_SORTED_RAILTYPES(rt) {
 
					if (HasBit(this->railtypes, rt)) {
 
						lines++;
 
						SetDParam(0, GetRailTypeInfo(rt)->strings.name);
 
						size->width = max(size->width, GetStringBoundingBox(STR_WHITE_STRING).width + WD_FRAMERECT_LEFT);
 
						size->width = std::max(size->width, GetStringBoundingBox(STR_WHITE_STRING).width + WD_FRAMERECT_LEFT);
 
					}
 
				}
 
				if (this->railtypes != RAILTYPES_NONE) {
 
					lines++;
 
					size->width = max(size->width, GetStringBoundingBox(STR_COMPANY_INFRASTRUCTURE_VIEW_SIGNALS).width + WD_FRAMERECT_LEFT);
 
					size->width = std::max(size->width, GetStringBoundingBox(STR_COMPANY_INFRASTRUCTURE_VIEW_SIGNALS).width + WD_FRAMERECT_LEFT);
 
				}
 

	
 
				size->height = max(size->height, lines * FONT_HEIGHT_NORMAL);
 
				size->height = std::max(size->height, lines * FONT_HEIGHT_NORMAL);
 
				break;
 
			}
 

	
 
@@ -1908,30 +1908,30 @@ struct CompanyInfrastructureWindow : Win
 
			case WID_CI_TRAM_DESC: {
 
				uint lines = 1; // Starts at 1 because a line is also required for the section title
 

	
 
				size->width = max(size->width, GetStringBoundingBox(widget == WID_CI_ROAD_DESC ? STR_COMPANY_INFRASTRUCTURE_VIEW_ROAD_SECT : STR_COMPANY_INFRASTRUCTURE_VIEW_TRAM_SECT).width);
 
				size->width = std::max(size->width, GetStringBoundingBox(widget == WID_CI_ROAD_DESC ? STR_COMPANY_INFRASTRUCTURE_VIEW_ROAD_SECT : STR_COMPANY_INFRASTRUCTURE_VIEW_TRAM_SECT).width);
 

	
 
				RoadType rt;
 
				FOR_ALL_SORTED_ROADTYPES(rt) {
 
					if (HasBit(this->roadtypes, rt) && RoadTypeIsRoad(rt) == (widget == WID_CI_ROAD_DESC)) {
 
						lines++;
 
						SetDParam(0, GetRoadTypeInfo(rt)->strings.name);
 
						size->width = max(size->width, GetStringBoundingBox(STR_WHITE_STRING).width + WD_FRAMERECT_LEFT);
 
						size->width = std::max(size->width, GetStringBoundingBox(STR_WHITE_STRING).width + WD_FRAMERECT_LEFT);
 
					}
 
				}
 

	
 
				size->height = max(size->height, lines * FONT_HEIGHT_NORMAL);
 
				size->height = std::max(size->height, lines * FONT_HEIGHT_NORMAL);
 
				break;
 
			}
 

	
 
			case WID_CI_WATER_DESC:
 
				size->width = max(size->width, GetStringBoundingBox(STR_COMPANY_INFRASTRUCTURE_VIEW_WATER_SECT).width);
 
				size->width = max(size->width, GetStringBoundingBox(STR_COMPANY_INFRASTRUCTURE_VIEW_CANALS).width + WD_FRAMERECT_LEFT);
 
				size->width = std::max(size->width, GetStringBoundingBox(STR_COMPANY_INFRASTRUCTURE_VIEW_WATER_SECT).width);
 
				size->width = std::max(size->width, GetStringBoundingBox(STR_COMPANY_INFRASTRUCTURE_VIEW_CANALS).width + WD_FRAMERECT_LEFT);
 
				break;
 

	
 
			case WID_CI_STATION_DESC:
 
				size->width = max(size->width, GetStringBoundingBox(STR_COMPANY_INFRASTRUCTURE_VIEW_STATION_SECT).width);
 
				size->width = max(size->width, GetStringBoundingBox(STR_COMPANY_INFRASTRUCTURE_VIEW_STATIONS).width + WD_FRAMERECT_LEFT);
 
				size->width = max(size->width, GetStringBoundingBox(STR_COMPANY_INFRASTRUCTURE_VIEW_AIRPORTS).width + WD_FRAMERECT_LEFT);
 
				size->width = std::max(size->width, GetStringBoundingBox(STR_COMPANY_INFRASTRUCTURE_VIEW_STATION_SECT).width);
 
				size->width = std::max(size->width, GetStringBoundingBox(STR_COMPANY_INFRASTRUCTURE_VIEW_STATIONS).width + WD_FRAMERECT_LEFT);
 
				size->width = std::max(size->width, GetStringBoundingBox(STR_COMPANY_INFRASTRUCTURE_VIEW_AIRPORTS).width + WD_FRAMERECT_LEFT);
 
				break;
 

	
 
			case WID_CI_RAIL_COUNT:
 
@@ -1945,24 +1945,24 @@ struct CompanyInfrastructureWindow : Win
 
				Money max_cost = 10000; // Some random number to reserve enough space.
 
				uint32 rail_total = c->infrastructure.GetRailTotal();
 
				for (RailType rt = RAILTYPE_BEGIN; rt < RAILTYPE_END; rt++) {
 
					max_val = max(max_val, c->infrastructure.rail[rt]);
 
					max_cost = max(max_cost, RailMaintenanceCost(rt, c->infrastructure.rail[rt], rail_total));
 
					max_val = std::max(max_val, c->infrastructure.rail[rt]);
 
					max_cost = std::max(max_cost, RailMaintenanceCost(rt, c->infrastructure.rail[rt], rail_total));
 
				}
 
				max_val = max(max_val, c->infrastructure.signal);
 
				max_cost = max(max_cost, SignalMaintenanceCost(c->infrastructure.signal));
 
				max_val = std::max(max_val, c->infrastructure.signal);
 
				max_cost = std::max(max_cost, SignalMaintenanceCost(c->infrastructure.signal));
 
				uint32 road_total = c->infrastructure.GetRoadTotal();
 
				uint32 tram_total = c->infrastructure.GetTramTotal();
 
				for (RoadType rt = ROADTYPE_BEGIN; rt < ROADTYPE_END; rt++) {
 
					max_val = max(max_val, c->infrastructure.road[rt]);
 
					max_cost = max(max_cost, RoadMaintenanceCost(rt, c->infrastructure.road[rt], RoadTypeIsRoad(rt) ? road_total : tram_total));
 
					max_val = std::max(max_val, c->infrastructure.road[rt]);
 
					max_cost = std::max(max_cost, RoadMaintenanceCost(rt, c->infrastructure.road[rt], RoadTypeIsRoad(rt) ? road_total : tram_total));
 

	
 
				}
 
				max_val = max(max_val, c->infrastructure.water);
 
				max_cost = max(max_cost, CanalMaintenanceCost(c->infrastructure.water));
 
				max_val = max(max_val, c->infrastructure.station);
 
				max_cost = max(max_cost, StationMaintenanceCost(c->infrastructure.station));
 
				max_val = max(max_val, c->infrastructure.airport);
 
				max_cost = max(max_cost, AirportMaintenanceCost(c->index));
 
				max_val = std::max(max_val, c->infrastructure.water);
 
				max_cost = std::max(max_cost, CanalMaintenanceCost(c->infrastructure.water));
 
				max_val = std::max(max_val, c->infrastructure.station);
 
				max_cost = std::max(max_cost, StationMaintenanceCost(c->infrastructure.station));
 
				max_val = std::max(max_val, c->infrastructure.airport);
 
				max_cost = std::max(max_cost, AirportMaintenanceCost(c->index));
 

	
 
				SetDParamMaxValue(0, max_val);
 
				uint count_width = GetStringBoundingBox(STR_WHITE_COMMA).width + 20; // Reserve some wiggle room
 
@@ -1970,17 +1970,17 @@ struct CompanyInfrastructureWindow : Win
 
				if (_settings_game.economy.infrastructure_maintenance) {
 
					SetDParamMaxValue(0, this->GetTotalMaintenanceCost() * 12); // Convert to per year
 
					this->total_width = GetStringBoundingBox(STR_COMPANY_INFRASTRUCTURE_VIEW_TOTAL).width + 20;
 
					size->width = max(size->width, this->total_width);
 
					size->width = std::max(size->width, this->total_width);
 

	
 
					SetDParamMaxValue(0, max_cost * 12); // Convert to per year
 
					count_width += max(this->total_width, GetStringBoundingBox(STR_COMPANY_INFRASTRUCTURE_VIEW_TOTAL).width);
 
					count_width += std::max(this->total_width, GetStringBoundingBox(STR_COMPANY_INFRASTRUCTURE_VIEW_TOTAL).width);
 
				}
 

	
 
				size->width = max(size->width, count_width);
 
				size->width = std::max(size->width, count_width);
 

	
 
				/* Set height of the total line. */
 
				if (widget == WID_CI_TOTAL) {
 
					size->height = _settings_game.economy.infrastructure_maintenance ? max(size->height, EXP_LINESPACE + FONT_HEIGHT_NORMAL) : 0;
 
					size->height = _settings_game.economy.infrastructure_maintenance ? std::max(size->height, EXP_LINESPACE + FONT_HEIGHT_NORMAL) : 0;
 
				}
 
				break;
 
			}
 
@@ -2367,8 +2367,8 @@ struct CompanyWindow : Window
 
		switch (widget) {
 
			case WID_C_FACE: {
 
				Dimension face_size = GetSpriteSize(SPR_GRADIENT);
 
				size->width  = max(size->width,  face_size.width);
 
				size->height = max(size->height, face_size.height);
 
				size->width  = std::max(size->width,  face_size.width);
 
				size->height = std::max(size->height, face_size.height);
 
				break;
 
			}
 

	
 
@@ -2389,18 +2389,18 @@ struct CompanyWindow : Window
 
			case WID_C_DESC_VEHICLE_COUNTS:
 
				SetDParamMaxValue(0, 5000); // Maximum number of vehicles
 
				for (uint i = 0; i < lengthof(_company_view_vehicle_count_strings); i++) {
 
					size->width = max(size->width, GetStringBoundingBox(_company_view_vehicle_count_strings[i]).width);
 
					size->width = std::max(size->width, GetStringBoundingBox(_company_view_vehicle_count_strings[i]).width);
 
				}
 
				break;
 

	
 
			case WID_C_DESC_INFRASTRUCTURE_COUNTS:
 
				SetDParamMaxValue(0, UINT_MAX);
 
				size->width = max(size->width, GetStringBoundingBox(STR_COMPANY_VIEW_INFRASTRUCTURE_RAIL).width);
 
				size->width = max(size->width, GetStringBoundingBox(STR_COMPANY_VIEW_INFRASTRUCTURE_ROAD).width);
 
				size->width = max(size->width, GetStringBoundingBox(STR_COMPANY_VIEW_INFRASTRUCTURE_WATER).width);
 
				size->width = max(size->width, GetStringBoundingBox(STR_COMPANY_VIEW_INFRASTRUCTURE_STATION).width);
 
				size->width = max(size->width, GetStringBoundingBox(STR_COMPANY_VIEW_INFRASTRUCTURE_AIRPORT).width);
 
				size->width = max(size->width, GetStringBoundingBox(STR_COMPANY_VIEW_INFRASTRUCTURE_NONE).width);
 
				size->width = std::max(size->width, GetStringBoundingBox(STR_COMPANY_VIEW_INFRASTRUCTURE_RAIL).width);
 
				size->width = std::max(size->width, GetStringBoundingBox(STR_COMPANY_VIEW_INFRASTRUCTURE_ROAD).width);
 
				size->width = std::max(size->width, GetStringBoundingBox(STR_COMPANY_VIEW_INFRASTRUCTURE_WATER).width);
 
				size->width = std::max(size->width, GetStringBoundingBox(STR_COMPANY_VIEW_INFRASTRUCTURE_STATION).width);
 
				size->width = std::max(size->width, GetStringBoundingBox(STR_COMPANY_VIEW_INFRASTRUCTURE_AIRPORT).width);
 
				size->width = std::max(size->width, GetStringBoundingBox(STR_COMPANY_VIEW_INFRASTRUCTURE_NONE).width);
 
				break;
 

	
 
			case WID_C_DESC_OWNERS: {
 
@@ -2408,7 +2408,7 @@ struct CompanyWindow : Window
 
					SetDParamMaxValue(0, 75);
 
					SetDParam(1, c2->index);
 

	
 
					size->width = max(size->width, GetStringBoundingBox(STR_COMPANY_VIEW_SHARES_OWNED_BY).width);
 
					size->width = std::max(size->width, GetStringBoundingBox(STR_COMPANY_VIEW_SHARES_OWNED_BY).width);
 
				}
 
				break;
 
			}
 
@@ -2420,13 +2420,13 @@ struct CompanyWindow : Window
 
			case WID_C_GIVE_MONEY:
 
			case WID_C_COMPANY_PASSWORD:
 
			case WID_C_COMPANY_JOIN:
 
				size->width = max(size->width, GetStringBoundingBox(STR_COMPANY_VIEW_VIEW_HQ_BUTTON).width);
 
				size->width = max(size->width, GetStringBoundingBox(STR_COMPANY_VIEW_BUILD_HQ_BUTTON).width);
 
				size->width = max(size->width, GetStringBoundingBox(STR_COMPANY_VIEW_RELOCATE_HQ).width);
 
				size->width = max(size->width, GetStringBoundingBox(STR_COMPANY_VIEW_INFRASTRUCTURE_BUTTON).width);
 
				size->width = max(size->width, GetStringBoundingBox(STR_COMPANY_VIEW_GIVE_MONEY_BUTTON).width);
 
				size->width = max(size->width, GetStringBoundingBox(STR_COMPANY_VIEW_PASSWORD).width);
 
				size->width = max(size->width, GetStringBoundingBox(STR_COMPANY_VIEW_JOIN).width);
 
				size->width = std::max(size->width, GetStringBoundingBox(STR_COMPANY_VIEW_VIEW_HQ_BUTTON).width);
 
				size->width = std::max(size->width, GetStringBoundingBox(STR_COMPANY_VIEW_BUILD_HQ_BUTTON).width);
 
				size->width = std::max(size->width, GetStringBoundingBox(STR_COMPANY_VIEW_RELOCATE_HQ).width);
 
				size->width = std::max(size->width, GetStringBoundingBox(STR_COMPANY_VIEW_INFRASTRUCTURE_BUTTON).width);
 
				size->width = std::max(size->width, GetStringBoundingBox(STR_COMPANY_VIEW_GIVE_MONEY_BUTTON).width);
 
				size->width = std::max(size->width, GetStringBoundingBox(STR_COMPANY_VIEW_PASSWORD).width);
 
				size->width = std::max(size->width, GetStringBoundingBox(STR_COMPANY_VIEW_JOIN).width);
 
				break;
 

	
 
			case WID_C_HAS_PASSWORD:
src/console_cmds.cpp
Show inline comments
 
@@ -2015,7 +2015,7 @@ DEF_CONSOLE_CMD(ConNewGRFProfile)
 
		if (started > 0) {
 
			IConsolePrintF(CC_DEBUG, "Started profiling for GRFID%s %s", (started > 1) ? "s" : "", grfids.c_str());
 
			if (argc >= 3) {
 
				int days = max(atoi(argv[2]), 1);
 
				int days = std::max(atoi(argv[2]), 1);
 
				_newgrf_profile_end_date = _date + days;
 

	
 
				char datestrbuf[32]{ 0 };
src/console_gui.cpp
Show inline comments
 
@@ -194,7 +194,7 @@ struct IConsoleWindow : Window
 
	 */
 
	void Scroll(int amount)
 
	{
 
		int max_scroll = max<int>(0, IConsoleLine::size + 1 - this->height / this->line_height);
 
		int max_scroll = std::max(0, IConsoleLine::size + 1 - this->height / this->line_height);
 
		IConsoleWindow::scroll = Clamp<int>(IConsoleWindow::scroll + amount, 0, max_scroll);
 
		this->SetDirty();
 
	}
 
@@ -231,7 +231,7 @@ struct IConsoleWindow : Window
 
	{
 
		if (IConsoleLine::Truncate() &&
 
				(IConsoleWindow::scroll > IConsoleLine::size)) {
 
			IConsoleWindow::scroll = max(0, IConsoleLine::size - (this->height / this->line_height) + 1);
 
			IConsoleWindow::scroll = std::max(0, IConsoleLine::size - (this->height / this->line_height) + 1);
 
			this->SetDirty();
 
		}
 
	}
 
@@ -341,7 +341,7 @@ struct IConsoleWindow : Window
 

	
 
	Point GetCaretPosition() const override
 
	{
 
		int delta = min(this->width - this->line_offset - _iconsole_cmdline.pixels - ICON_RIGHT_BORDERWIDTH, 0);
 
		int delta = std::min<int>(this->width - this->line_offset - _iconsole_cmdline.pixels - ICON_RIGHT_BORDERWIDTH, 0);
 
		Point pt = {this->line_offset + delta + _iconsole_cmdline.caretxoffs, this->height - this->line_height};
 

	
 
		return pt;
 
@@ -349,7 +349,7 @@ struct IConsoleWindow : Window
 

	
 
	Rect GetTextBoundingRect(const char *from, const char *to) const override
 
	{
 
		int delta = min(this->width - this->line_offset - _iconsole_cmdline.pixels - ICON_RIGHT_BORDERWIDTH, 0);
 
		int delta = std::min<int>(this->width - this->line_offset - _iconsole_cmdline.pixels - ICON_RIGHT_BORDERWIDTH, 0);
 

	
 
		Point p1 = GetCharPosInString(_iconsole_cmdline.buf, from, FS_NORMAL);
 
		Point p2 = from != to ? GetCharPosInString(_iconsole_cmdline.buf, from) : p1;
 
@@ -360,7 +360,7 @@ struct IConsoleWindow : Window
 

	
 
	const char *GetTextCharacterAtPosition(const Point &pt) const override
 
	{
 
		int delta = min(this->width - this->line_offset - _iconsole_cmdline.pixels - ICON_RIGHT_BORDERWIDTH, 0);
 
		int delta = std::min<int>(this->width - this->line_offset - _iconsole_cmdline.pixels - ICON_RIGHT_BORDERWIDTH, 0);
 

	
 
		if (!IsInsideMM(pt.y, this->height - this->line_height, this->height)) return nullptr;
 

	
src/core/geometry_func.cpp
Show inline comments
 
@@ -22,7 +22,7 @@
 
Dimension maxdim(const Dimension &d1, const Dimension &d2)
 
{
 
	Dimension d;
 
	d.width  = max(d1.width,  d2.width);
 
	d.height = max(d1.height, d2.height);
 
	d.width  = std::max(d1.width,  d2.width);
 
	d.height = std::max(d1.height, d2.height);
 
	return d;
 
}
src/core/kdtree.hpp
Show inline comments
 
@@ -12,7 +12,6 @@
 

	
 
#include "../stdafx.h"
 
#include <vector>
 
#include <algorithm>
 
#include <limits>
 

	
 
/**
 
@@ -261,7 +260,7 @@ class Kdtree {
 
			best = SelectNearestNodeDistance(best, this->FindNearestRecursive(xy, next, level + 1));
 
		}
 

	
 
		limit = min(best.second, limit);
 
		limit = std::min(best.second, limit);
 

	
 
		/* Check if the distance from current best is worse than distance from target to splitting line,
 
		 * if it is we also need to check the other side of the split. */
src/core/math_func.hpp
Show inline comments
 
@@ -11,66 +11,6 @@
 
#define MATH_FUNC_HPP
 

	
 
/**
 
 * Returns the maximum of two values.
 
 *
 
 * This function returns the greater value of two given values.
 
 * If they are equal the value of a is returned.
 
 *
 
 * @param a The first value
 
 * @param b The second value
 
 * @return The greater value or a if equals
 
 */
 
template <typename T>
 
static inline T max(const T a, const T b)
 
{
 
	return (a >= b) ? a : b;
 
}
 

	
 
/**
 
 * Returns the minimum of two values.
 
 *
 
 * This function returns the smaller value of two given values.
 
 * If they are equal the value of b is returned.
 
 *
 
 * @param a The first value
 
 * @param b The second value
 
 * @return The smaller value or b if equals
 
 */
 
template <typename T>
 
static inline T min(const T a, const T b)
 
{
 
	return (a < b) ? a : b;
 
}
 

	
 
/**
 
 * Returns the minimum of two integer.
 
 *
 
 * This function returns the smaller value of two given integers.
 
 *
 
 * @param a The first integer
 
 * @param b The second integer
 
 * @return The smaller value
 
 */
 
static inline int min(const int a, const int b)
 
{
 
	return min<int>(a, b);
 
}
 

	
 
/**
 
 * Returns the minimum of two unsigned integers.
 
 *
 
 * This function returns the smaller value of two given unsigned integers.
 
 *
 
 * @param a The first unsigned integer
 
 * @param b The second unsigned integer
 
 * @return The smaller value
 
 */
 
static inline uint minu(const uint a, const uint b)
 
{
 
	return min<uint>(a, b);
 
}
 

	
 
/**
 
 * Returns the absolute value of (scalar) variable.
 
 *
 
 * @note assumes variable to be signed
 
@@ -216,7 +156,7 @@ static inline uint16 ClampToU16(const ui
 
	 * match for min(uint64, uint) than uint64 min(uint64, uint64). As such we
 
	 * need to cast the UINT16_MAX to prevent MSVC from displaying its
 
	 * infinite loads of warnings. */
 
	return static_cast<uint16>(min<uint64>(a, static_cast<uint64>(UINT16_MAX)));
 
	return static_cast<uint16>(std::min(a, static_cast<uint64>(UINT16_MAX)));
 
}
 

	
 
/**
src/core/pool_func.hpp
Show inline comments
 
@@ -52,7 +52,7 @@ DEFINE_POOL_METHOD(inline void)::ResizeF
 
	assert(index >= this->size);
 
	assert(index < Tmax_size);
 

	
 
	size_t new_size = min(Tmax_size, Align(index + 1, Tgrowth_step));
 
	size_t new_size = std::min(Tmax_size, Align(index + 1, Tgrowth_step));
 

	
 
	this->data = ReallocT(this->data, new_size);
 
	MemSetT(this->data + this->size, 0, new_size - this->size);
 
@@ -100,7 +100,7 @@ DEFINE_POOL_METHOD(inline void *)::Alloc
 
{
 
	assert(this->data[index] == nullptr);
 

	
 
	this->first_unused = max(this->first_unused, index + 1);
 
	this->first_unused = std::max(this->first_unused, index + 1);
 
	this->items++;
 

	
 
	Titem *item;
 
@@ -187,7 +187,7 @@ DEFINE_POOL_METHOD(void)::FreeItem(size_
 
		free(this->data[index]);
 
	}
 
	this->data[index] = nullptr;
 
	this->first_free = min(this->first_free, index);
 
	this->first_free = std::min(this->first_free, index);
 
	this->items--;
 
	if (!this->cleaning) Titem::PostDestructor(index);
 
}
src/core/smallmatrix_type.hpp
Show inline comments
 
@@ -234,7 +234,7 @@ public:
 
						if (x * new_height > new_capacity) continue;
 
						(*copy)(new_data + (x - 1) * new_height,
 
								this->data + (x - 1) * this->height,
 
								min(this->height, new_height));
 
								std::min(this->height, new_height));
 
					}
 
				} else {
 
					/* If matrix is shrinking copy from the front. */
 
@@ -242,7 +242,7 @@ public:
 
						if ((x + 1) * new_height > new_capacity) break;
 
						(*copy)(new_data + x * new_height,
 
								this->data + x * this->height,
 
								min(this->height, new_height));
 
								std::min(this->height, new_height));
 
					}
 
				}
 
			}
src/core/smallstack_type.hpp
Show inline comments
 
@@ -46,7 +46,7 @@ public:
 
		if (index < Tmax_size) {
 
			this->data[index].valid = true;
 
			this->first_free = index + 1;
 
			this->first_unused = max(this->first_unused, this->first_free);
 
			this->first_unused = std::max(this->first_unused, this->first_free);
 
		}
 
		return index;
 
	}
 
@@ -58,7 +58,7 @@ public:
 
	inline void Destroy(Tindex index)
 
	{
 
		this->data[index].valid = false;
 
		this->first_free = min(this->first_free, index);
 
		this->first_free = std::min(this->first_free, index);
 
	}
 

	
 
private:
src/core/smallvec_type.hpp
Show inline comments
 
@@ -13,7 +13,6 @@
 
#include "alloc_func.hpp"
 
#include "mem_func.hpp"
 
#include <vector>
 
#include <algorithm>
 

	
 
/**
 
 * Helper function to append an item to a vector if it is not already contained
src/date_gui.cpp
Show inline comments
 
@@ -41,8 +41,8 @@ struct SetDateWindow : Window {
 
	SetDateWindow(WindowDesc *desc, WindowNumber window_number, Window *parent, Date initial_date, Year min_year, Year max_year, SetDateCallback *callback) :
 
			Window(desc),
 
			callback(callback),
 
			min_year(max(MIN_YEAR, min_year)),
 
			max_year(min(MAX_YEAR, max_year))
 
			min_year(std::max(MIN_YEAR, min_year)),
 
			max_year(std::min(MAX_YEAR, max_year))
 
	{
 
		assert(this->min_year <= this->max_year);
 
		this->parent = parent;
src/depot_gui.cpp
Show inline comments
 
@@ -194,12 +194,12 @@ static void InitBlocksizeForVehicles(Veh
 

	
 
	switch (image_type) {
 
		case EIT_IN_DEPOT:
 
			_base_block_sizes_depot[type].height       = max<uint>(ScaleGUITrad(GetVehicleHeight(type)), max_height);
 
			_base_block_sizes_depot[type].height       = std::max<uint>(ScaleGUITrad(GetVehicleHeight(type)), max_height);
 
			_base_block_sizes_depot[type].extend_left  = Clamp(max_extend_left, min_extend, max_extend);
 
			_base_block_sizes_depot[type].extend_right = Clamp(max_extend_right, min_extend, max_extend);
 
			break;
 
		case EIT_PURCHASE:
 
			_base_block_sizes_purchase[type].height       = max<uint>(ScaleGUITrad(GetVehicleHeight(type)), max_height);
 
			_base_block_sizes_purchase[type].height       = std::max<uint>(ScaleGUITrad(GetVehicleHeight(type)), max_height);
 
			_base_block_sizes_purchase[type].extend_left  = Clamp(max_extend_left, min_extend, max_extend);
 
			_base_block_sizes_purchase[type].extend_right = Clamp(max_extend_right, min_extend, max_extend);
 
			break;
 
@@ -395,7 +395,7 @@ struct DepotWindow : Window {
 
		uint16 rows_in_display = wid->current_y / wid->resize_y;
 

	
 
		uint16 num = this->vscroll->GetPosition() * this->num_columns;
 
		int maxval = min((uint)this->vehicle_list.size(), num + (rows_in_display * this->num_columns));
 
		uint maxval = static_cast<uint>(std::min<size_t>(this->vehicle_list.size(), num + (rows_in_display * this->num_columns)));
 
		int y;
 
		for (y = r.top + 1; num < maxval; y += this->resize.step_height) { // Draw the rows
 
			for (byte i = 0; i < this->num_columns && num < maxval; i++, num++) {
 
@@ -410,7 +410,7 @@ struct DepotWindow : Window {
 
			}
 
		}
 

	
 
		maxval = min((uint)this->vehicle_list.size() + (uint)this->wagon_list.size(), (this->vscroll->GetPosition() * this->num_columns) + (rows_in_display * this->num_columns));
 
		maxval = static_cast<uint>(std::min<size_t>(this->vehicle_list.size() + this->wagon_list.size(), (this->vscroll->GetPosition() * this->num_columns) + (rows_in_display * this->num_columns)));
 

	
 
		/* Draw the train wagons without an engine in front. */
 
		for (; num < maxval; num++, y += this->resize.step_height) {
 
@@ -668,15 +668,15 @@ struct DepotWindow : Window {
 
				this->flag_height = UnScaleGUI(spr->height);
 

	
 
				if (this->type == VEH_TRAIN || this->type == VEH_ROAD) {
 
					min_height = max<uint>(unumber.height + WD_MATRIX_TOP, UnScaleGUI(spr->height));
 
					min_height = std::max<uint>(unumber.height + WD_MATRIX_TOP, UnScaleGUI(spr->height));
 
					this->header_width = unumber.width + this->flag_width + WD_FRAMERECT_LEFT;
 
				} else {
 
					min_height = unumber.height + UnScaleGUI(spr->height) + WD_MATRIX_TOP + WD_PAR_VSEP_NORMAL + WD_MATRIX_BOTTOM;
 
					this->header_width = max<uint>(unumber.width, this->flag_width) + WD_FRAMERECT_RIGHT;
 
					this->header_width = std::max<uint>(unumber.width, this->flag_width) + WD_FRAMERECT_RIGHT;
 
				}
 
				int base_width = this->count_width + this->header_width;
 

	
 
				resize->height = max<uint>(GetVehicleImageCellSize(this->type, EIT_IN_DEPOT).height, min_height);
 
				resize->height = std::max<uint>(GetVehicleImageCellSize(this->type, EIT_IN_DEPOT).height, min_height);
 
				if (this->type == VEH_TRAIN) {
 
					resize->width = 1;
 
					size->width = base_width + 2 * ScaleGUITrad(29); // about 2 parts
 
@@ -728,7 +728,7 @@ struct DepotWindow : Window {
 
				for (const Train *v = Train::From(this->vehicle_list[num]); v != nullptr; v = v->Next()) {
 
					width += v->GetDisplayImageWidth();
 
				}
 
				max_width = max(max_width, width);
 
				max_width = std::max(max_width, width);
 
			}
 
			/* Always have 1 empty row, so people can change the setting of the train */
 
			this->vscroll->SetCount((uint)this->vehicle_list.size() + (uint)this->wagon_list.size() + 1);
src/disaster_vehicle.cpp
Show inline comments
 
@@ -193,7 +193,7 @@ void DisasterVehicle::UpdatePosition(int
 
		int safe_y = Clamp(y - 1, 0, MapMaxY() * TILE_SIZE);
 

	
 
		u->x_pos = x;
 
		u->y_pos = y - 1 - (max(z - GetSlopePixelZ(safe_x, safe_y), 0) >> 3);
 
		u->y_pos = y - 1 - (std::max(z - GetSlopePixelZ(safe_x, safe_y), 0) >> 3);
 
		safe_y = Clamp(u->y_pos, 0, MapMaxY() * TILE_SIZE);
 
		u->z_pos = GetSlopePixelZ(safe_x, safe_y);
 
		u->direction = this->direction;
src/dock_gui.cpp
Show inline comments
 
@@ -72,7 +72,7 @@ static TileIndex GetOtherAqueductEnd(Til
 
	/* Direction the aqueduct is built to. */
 
	TileIndexDiff offset = TileOffsByDiagDir(ReverseDiagDir(dir));
 
	/* The maximum length of the aqueduct. */
 
	int max_length = min(_settings_game.construction.max_bridge_length, DistanceFromEdgeDir(tile_from, ReverseDiagDir(dir)) - 1);
 
	int max_length = std::min<int>(_settings_game.construction.max_bridge_length, DistanceFromEdgeDir(tile_from, ReverseDiagDir(dir)) - 1);
 

	
 
	TileIndex endtile = tile_from;
 
	for (int length = 0; IsValidTile(endtile) && TileX(endtile) != 0 && TileY(endtile) != 0; length++) {
src/economy.cpp
Show inline comments
 
@@ -135,7 +135,7 @@ Money CalculateCompanyValue(const Compan
 
	if (including_loan) value -= c->current_loan;
 
	value += c->money;
 

	
 
	return max(value, (Money)1);
 
	return std::max<Money>(value, 1);
 
}
 

	
 
/**
 
@@ -194,15 +194,15 @@ int UpdateCompanyRatingAndValue(Company 
 

	
 
	/* Generate statistics depending on recent income statistics */
 
	{
 
		int numec = min(c->num_valid_stat_ent, 12);
 
		int numec = std::min<uint>(c->num_valid_stat_ent, 12u);
 
		if (numec != 0) {
 
			const CompanyEconomyEntry *cee = c->old_economy;
 
			Money min_income = cee->income + cee->expenses;
 
			Money max_income = cee->income + cee->expenses;
 

	
 
			do {
 
				min_income = min(min_income, cee->income + cee->expenses);
 
				max_income = max(max_income, cee->income + cee->expenses);
 
				min_income = std::min(min_income, cee->income + cee->expenses);
 
				max_income = std::max(max_income, cee->income + cee->expenses);
 
			} while (++cee, --numec);
 

	
 
			if (min_income > 0) {
 
@@ -215,7 +215,7 @@ int UpdateCompanyRatingAndValue(Company 
 

	
 
	/* Generate score depending on amount of transported cargo */
 
	{
 
		int numec = min(c->num_valid_stat_ent, 4);
 
		int numec = std::min<uint>(c->num_valid_stat_ent, 4u);
 
		if (numec != 0) {
 
			const CompanyEconomyEntry *cee = c->old_economy;
 
			OverflowSafeInt64 total_delivered = 0;
 
@@ -361,7 +361,7 @@ void ChangeOwnershipOfCompanyItems(Owner
 
			if (HasBit(t->have_ratings, old_owner)) {
 
				if (HasBit(t->have_ratings, new_owner)) {
 
					/* use max of the two ratings. */
 
					t->ratings[new_owner] = max(t->ratings[new_owner], t->ratings[old_owner]);
 
					t->ratings[new_owner] = std::max(t->ratings[new_owner], t->ratings[old_owner]);
 
				} else {
 
					SetBit(t->have_ratings, new_owner);
 
					t->ratings[new_owner] = t->ratings[old_owner];
 
@@ -911,12 +911,12 @@ void StartupEconomy()
 
{
 
	_economy.interest_rate = _settings_game.difficulty.initial_interest;
 
	_economy.infl_amount = _settings_game.difficulty.initial_interest;
 
	_economy.infl_amount_pr = max(0, _settings_game.difficulty.initial_interest - 1);
 
	_economy.infl_amount_pr = std::max(0, _settings_game.difficulty.initial_interest - 1);
 
	_economy.fluct = GB(Random(), 0, 8) + 168;
 

	
 
	if (_settings_game.economy.inflation) {
 
		/* Apply inflation that happened before our game start year. */
 
		int months = (min(_cur_year, ORIGINAL_MAX_YEAR) - ORIGINAL_BASE_YEAR) * 12;
 
		int months = (std::min(_cur_year, ORIGINAL_MAX_YEAR) - ORIGINAL_BASE_YEAR) * 12;
 
		for (int i = 0; i < months; i++) {
 
			AddInflation(false);
 
		}
 
@@ -973,7 +973,7 @@ Money GetTransportedGoodsIncome(uint num
 

	
 
	/* Use callback to calculate cargo profit, if available */
 
	if (HasBit(cs->callback_mask, CBM_CARGO_PROFIT_CALC)) {
 
		uint32 var18 = min(dist, 0xFFFF) | (min(num_pieces, 0xFF) << 16) | (transit_days << 24);
 
		uint32 var18 = std::min(dist, 0xFFFFu) | (std::min(num_pieces, 0xFFu) << 16) | (transit_days << 24);
 
		uint16 callback = GetCargoCallback(CBID_CARGO_PROFIT_CALC, 0, var18, cs);
 
		if (callback != CALLBACK_FAILED) {
 
			int result = GB(callback, 0, 14);
 
@@ -993,8 +993,8 @@ Money GetTransportedGoodsIncome(uint num
 

	
 
	const int days1 = cs->transit_days[0];
 
	const int days2 = cs->transit_days[1];
 
	const int days_over_days1 = max(   transit_days - days1, 0);
 
	const int days_over_days2 = max(days_over_days1 - days2, 0);
 
	const int days_over_days1 = std::max(   transit_days - days1, 0);
 
	const int days_over_days2 = std::max(days_over_days1 - days2, 0);
 

	
 
	/*
 
	 * The time factor is calculated based on the time it took
 
@@ -1006,7 +1006,7 @@ Money GetTransportedGoodsIncome(uint num
 
	 *  - linear decreasing with time with a slope of -2 for slow transports
 
	 *
 
	 */
 
	const int time_factor = max(MAX_TIME_FACTOR - days_over_days1 - days_over_days2, MIN_TIME_FACTOR);
 
	const int time_factor = std::max(MAX_TIME_FACTOR - days_over_days1 - days_over_days2, MIN_TIME_FACTOR);
 

	
 
	return BigMulS(dist * time_factor * num_pieces, cs->current_payment, 21);
 
}
 
@@ -1055,7 +1055,7 @@ static uint DeliverGoodsToIndustry(const
 
		/* Insert the industry into _cargo_delivery_destinations, if not yet contained */
 
		include(_cargo_delivery_destinations, ind);
 

	
 
		uint amount = min(num_pieces, 0xFFFFU - ind->incoming_cargo_waiting[cargo_index]);
 
		uint amount = std::min(num_pieces, 0xFFFFu - ind->incoming_cargo_waiting[cargo_index]);
 
		ind->incoming_cargo_waiting[cargo_index] += amount;
 
		ind->last_cargo_accepted_at[cargo_index] = _date;
 
		num_pieces -= amount;
 
@@ -1150,7 +1150,7 @@ static void TriggerIndustryProduction(In
 
			if (cargo_waiting == 0) continue;
 

	
 
			for (uint ci_out = 0; ci_out < lengthof(i->produced_cargo_waiting); ci_out++) {
 
				i->produced_cargo_waiting[ci_out] = min(i->produced_cargo_waiting[ci_out] + (cargo_waiting * indspec->input_cargo_multiplier[ci_in][ci_out] / 256), 0xFFFF);
 
				i->produced_cargo_waiting[ci_out] = std::min(i->produced_cargo_waiting[ci_out] + (cargo_waiting * indspec->input_cargo_multiplier[ci_in][ci_out] / 256), 0xFFFFu);
 
			}
 

	
 
			i->incoming_cargo_waiting[ci_in] = 0;
 
@@ -1317,7 +1317,7 @@ static uint GetLoadAmount(Vehicle *v)
 
	if (HasBit(e->info.misc_flags, EF_NO_DEFAULT_CARGO_MULTIPLIER) && !air_mail) load_amount = CeilDiv(load_amount * CargoSpec::Get(v->cargo_type)->multiplier, 0x100);
 

	
 
	/* Zero load amount breaks a lot of things. */
 
	return max(1u, load_amount);
 
	return std::max(1u, load_amount);
 
}
 

	
 
/**
 
@@ -1596,7 +1596,7 @@ static void UpdateLoadUnloadTicks(Vehicl
 
		}
 
	}
 
	/* Always wait at least 1, otherwise we'll wait 'infinitively' long. */
 
	front->load_unload_ticks = max(1, ticks);
 
	front->load_unload_ticks = std::max(1, ticks);
 
}
 

	
 
/**
 
@@ -1657,7 +1657,7 @@ static void LoadUnloadVehicle(Vehicle *f
 

	
 
		if (HasBit(v->vehicle_flags, VF_CARGO_UNLOADING) && (front->current_order.GetUnloadType() & OUFB_NO_UNLOAD) == 0) {
 
			uint cargo_count = v->cargo.UnloadCount();
 
			uint amount_unloaded = _settings_game.order.gradual_loading ? min(cargo_count, GetLoadAmount(v)) : cargo_count;
 
			uint amount_unloaded = _settings_game.order.gradual_loading ? std::min(cargo_count, GetLoadAmount(v)) : cargo_count;
 
			bool remaining = false; // Are there cargo entities in this vehicle that can still be unloaded here?
 

	
 
			assert(payment != nullptr);
 
@@ -1753,8 +1753,8 @@ static void LoadUnloadVehicle(Vehicle *f
 
		}
 

	
 
		/* if last speed is 0, we treat that as if no vehicle has ever visited the station. */
 
		ge->last_speed = min(t, 255);
 
		ge->last_age = min(_cur_year - front->build_year, 255);
 
		ge->last_speed = std::min(t, 255);
 
		ge->last_age = std::min(_cur_year - front->build_year, 255);
 

	
 
		assert(v->cargo_cap >= v->cargo.StoredCount());
 
		/* Capacity available for loading more cargo. */
 
@@ -1768,7 +1768,7 @@ static void LoadUnloadVehicle(Vehicle *f
 
			 * has capacity for it, load it on the vehicle. */
 
			if ((v->cargo.ActionCount(VehicleCargoList::MTA_LOAD) > 0 || ge->cargo.AvailableCount() > 0) && MayLoadUnderExclusiveRights(st, v)) {
 
				if (v->cargo.StoredCount() == 0) TriggerVehicle(v, VEHICLE_TRIGGER_NEW_CARGO);
 
				if (_settings_game.order.gradual_loading) cap_left = min(cap_left, GetLoadAmount(v));
 
				if (_settings_game.order.gradual_loading) cap_left = std::min(cap_left, GetLoadAmount(v));
 

	
 
				uint loaded = ge->cargo.Load(cap_left, &v->cargo, st->xy, next_station);
 
				if (v->cargo.ActionCount(VehicleCargoList::MTA_LOAD) > 0) {
 
@@ -1842,7 +1842,7 @@ static void LoadUnloadVehicle(Vehicle *f
 
		/* We loaded less cargo than possible for all cargo types and it's not full
 
		 * load and we're not supposed to wait any longer: stop loading. */
 
		if (!anything_unloaded && full_load_amount == 0 && reservation_left == 0 && !(front->current_order.GetLoadType() & OLFB_FULL_LOAD) &&
 
				front->current_order_time >= (uint)max(front->current_order.GetTimetabledWait() - front->lateness_counter, 0)) {
 
				front->current_order_time >= (uint)std::max(front->current_order.GetTimetabledWait() - front->lateness_counter, 0)) {
 
			SetBit(front->vehicle_flags, VF_STOP_LOADING);
 
		}
 

	
src/elrail.cpp
Show inline comments
 
@@ -229,7 +229,8 @@ static int GetPCPElevation(TileIndex til
 
	 * Also note that the result of GetSlopePixelZ() is very special on bridge-ramps.
 
	 */
 

	
 
	int z = GetSlopePixelZ(TileX(tile) * TILE_SIZE + min(x_pcp_offsets[PCPpos], TILE_SIZE - 1), TileY(tile) * TILE_SIZE + min(y_pcp_offsets[PCPpos], TILE_SIZE - 1));
 
	int z = GetSlopePixelZ(TileX(tile) * TILE_SIZE + std::min<int8>(x_pcp_offsets[PCPpos], TILE_SIZE - 1),
 
	                       TileY(tile) * TILE_SIZE + std::min<int8>(y_pcp_offsets[PCPpos], TILE_SIZE - 1));
 
	return (z + 2) & ~3; // this means z = (z + TILE_HEIGHT / 4) / (TILE_HEIGHT / 2) * (TILE_HEIGHT / 2);
 
}
 

	
src/engine.cpp
Show inline comments
 
@@ -578,7 +578,7 @@ static void CalcEngineReliability(Engine
 
	/* Check for early retirement */
 
	if (e->company_avail != 0 && !_settings_game.vehicle.never_expire_vehicles && e->info.base_life != 0xFF) {
 
		int retire_early = e->info.retire_early;
 
		uint retire_early_max_age = max(0, e->duration_phase_1 + e->duration_phase_2 - retire_early * 12);
 
		uint retire_early_max_age = std::max(0, e->duration_phase_1 + e->duration_phase_2 - retire_early * 12);
 
		if (retire_early != 0 && age >= retire_early_max_age) {
 
			/* Early retirement is enabled and we're past the date... */
 
			e->company_avail = 0;
 
@@ -625,7 +625,7 @@ void SetYearEngineAgingStops()
 
		YearMonthDay ymd;
 
		ConvertDateToYMD(ei->base_intro + (ei->lifelength * DAYS_IN_LEAP_YEAR) / 2, &ymd);
 

	
 
		_year_engine_aging_stops = max(_year_engine_aging_stops, ymd.year);
 
		_year_engine_aging_stops = std::max(_year_engine_aging_stops, ymd.year);
 
	}
 
}
 

	
 
@@ -693,7 +693,7 @@ void StartupOneEngine(Engine *e, Date ag
 
void StartupEngines()
 
{
 
	/* Aging of vehicles stops, so account for that when starting late */
 
	const Date aging_date = min(_date, ConvertYMDToDate(_year_engine_aging_stops, 0, 1));
 
	const Date aging_date = std::min(_date, ConvertYMDToDate(_year_engine_aging_stops, 0, 1));
 

	
 
	for (Engine *e : Engine::Iterate()) {
 
		StartupOneEngine(e, aging_date);
 
@@ -1196,7 +1196,7 @@ void CheckEngines()
 
		if ((e->flags & ENGINE_AVAILABLE) != 0 && e->company_avail != 0) return;
 

	
 
		/* Okay, try to find the earliest date. */
 
		min_date = min(min_date, e->info.base_intro);
 
		min_date = std::min(min_date, e->info.base_intro);
 
	}
 

	
 
	if (min_date < INT32_MAX) {
src/engine_gui.cpp
Show inline comments
 
@@ -93,9 +93,9 @@ struct EnginePreviewWindow : Window {
 
			case VEH_SHIP:     GetShipSpriteSize(    engine, x, y, x_offs, y_offs, image_type); break;
 
			case VEH_AIRCRAFT: GetAircraftSpriteSize(engine, x, y, x_offs, y_offs, image_type); break;
 
		}
 
		this->vehicle_space = max<int>(40, y - y_offs);
 
		this->vehicle_space = std::max<int>(40, y - y_offs);
 

	
 
		size->width = max(size->width, x - x_offs);
 
		size->width = std::max(size->width, x - x_offs);
 
		SetDParam(0, GetEngineCategoryName(engine));
 
		size->height = GetStringHeight(STR_ENGINE_PREVIEW_MESSAGE, size->width) + WD_PAR_VSEP_WIDE + FONT_HEIGHT_NORMAL + this->vehicle_space;
 
		SetDParam(0, engine);
src/error_gui.cpp
Show inline comments
 
@@ -189,7 +189,7 @@ public:
 
				CopyInDParam(0, this->decode_params, lengthof(this->decode_params));
 
				if (this->textref_stack_size > 0) StartTextRefStackUsage(this->textref_stack_grffile, this->textref_stack_size, this->textref_stack);
 

	
 
				int text_width = max(0, (int)size->width - WD_FRAMETEXT_LEFT - WD_FRAMETEXT_RIGHT);
 
				int text_width = std::max(0, (int)size->width - WD_FRAMETEXT_LEFT - WD_FRAMETEXT_RIGHT);
 
				this->height_summary = GetStringHeight(this->summary_msg, text_width);
 
				this->height_detailed = (this->detailed_msg == INVALID_STRING_ID) ? 0 : GetStringHeight(this->detailed_msg, text_width);
 

	
 
@@ -198,13 +198,13 @@ public:
 
				uint panel_height = WD_FRAMERECT_TOP + this->height_summary + WD_FRAMERECT_BOTTOM;
 
				if (this->detailed_msg != INVALID_STRING_ID) panel_height += this->height_detailed + WD_PAR_VSEP_WIDE;
 

	
 
				size->height = max(size->height, panel_height);
 
				size->height = std::max(size->height, panel_height);
 
				break;
 
			}
 
			case WID_EM_FACE: {
 
				Dimension face_size = GetSpriteSize(SPR_GRADIENT);
 
				size->width = max(size->width, face_size.width);
 
				size->height = max(size->height, face_size.height);
 
				size->width = std::max(size->width, face_size.width);
 
				size->height = std::max(size->height, face_size.height);
 
				break;
 
			}
 
		}
src/fileio.cpp
Show inline comments
 
@@ -24,7 +24,6 @@
 
#include <pwd.h>
 
#endif
 
#include <sys/stat.h>
 
#include <algorithm>
 
#include <array>
 
#include <sstream>
 

	
 
@@ -125,7 +124,7 @@ byte FioReadByte()
 
void FioSkipBytes(int n)
 
{
 
	for (;;) {
 
		int m = min(_fio.buffer_end - _fio.buffer, n);
 
		int m = std::min<int>(_fio.buffer_end - _fio.buffer, n);
 
		_fio.buffer += m;
 
		n -= m;
 
		if (n == 0) break;
 
@@ -892,7 +891,7 @@ bool ExtractTar(const std::string &tar_f
 
		char buffer[4096];
 
		size_t read;
 
		for (; to_copy != 0; to_copy -= read) {
 
			read = fread(buffer, 1, min(to_copy, lengthof(buffer)), in.get());
 
			read = fread(buffer, 1, std::min(to_copy, lengthof(buffer)), in.get());
 
			if (read <= 0 || fwrite(buffer, 1, read, out.get()) != read) break;
 
		}
 

	
src/fontcache.cpp
Show inline comments
 
@@ -492,7 +492,7 @@ void FreeTypeFontCache::SetFontSize(Font
 
			/* Font height is minimum height plus the difference between the default
 
			 * height for this font size and the small size. */
 
			int diff = scaled_height - ScaleFontTrad(_default_font_height[FS_SMALL]);
 
			pixels = Clamp(min(head->Lowest_Rec_PPEM, 20) + diff, scaled_height, MAX_FONT_SIZE);
 
			pixels = Clamp(std::min<uint>(head->Lowest_Rec_PPEM, 20u) + diff, scaled_height, MAX_FONT_SIZE);
 
		}
 
	} else {
 
		pixels = ScaleFontTrad(pixels);
 
@@ -656,8 +656,8 @@ const Sprite *FreeTypeFontCache::Interna
 
	aa = (slot->bitmap.pixel_mode == FT_PIXEL_MODE_GRAY);
 

	
 
	/* Add 1 pixel for the shadow on the medium font. Our sprite must be at least 1x1 pixel */
 
	uint width  = max(1U, (uint)slot->bitmap.width + (this->fs == FS_NORMAL));
 
	uint height = max(1U, (uint)slot->bitmap.rows  + (this->fs == FS_NORMAL));
 
	uint width  = std::max(1U, (uint)slot->bitmap.width + (this->fs == FS_NORMAL));
 
	uint height = std::max(1U, (uint)slot->bitmap.rows  + (this->fs == FS_NORMAL));
 

	
 
	/* Limit glyph size to prevent overflows later on. */
 
	if (width > 256 || height > 256) usererror("Font glyph is too large");
 
@@ -797,7 +797,7 @@ void Win32FontCache::SetFontSize(FontSiz
 
			/* Font height is minimum height plus the difference between the default
 
			 * height for this font size and the small size. */
 
			int diff = scaled_height - ScaleFontTrad(_default_font_height[FS_SMALL]);
 
			pixels = Clamp(min(otm->otmusMinimumPPEM, 20) + diff, scaled_height, MAX_FONT_SIZE);
 
			pixels = Clamp(std::min(otm->otmusMinimumPPEM, 20u) + diff, scaled_height, MAX_FONT_SIZE);
 

	
 
			SelectObject(dc, old);
 
			DeleteObject(temp);
 
@@ -851,7 +851,7 @@ void Win32FontCache::ClearFontCache()
 
	MAT2 mat = { {0, 1}, {0, 0}, {0, 0}, {0, 1} };
 

	
 
	/* Make a guess for the needed memory size. */
 
	DWORD size = this->glyph_size.cy * Align(aa ? this->glyph_size.cx : max(this->glyph_size.cx / 8l, 1l), 4); // Bitmap data is DWORD-aligned rows.
 
	DWORD size = this->glyph_size.cy * Align(aa ? this->glyph_size.cx : std::max(this->glyph_size.cx / 8l, 1l), 4); // Bitmap data is DWORD-aligned rows.
 
	byte *bmp = AllocaM(byte, size);
 
	size = GetGlyphOutline(this->dc, key, GGO_GLYPH_INDEX | (aa ? GGO_GRAY8_BITMAP : GGO_BITMAP), &gm, size, bmp, &mat);
 

	
 
@@ -868,8 +868,8 @@ void Win32FontCache::ClearFontCache()
 
	}
 

	
 
	/* Add 1 pixel for the shadow on the medium font. Our sprite must be at least 1x1 pixel. */
 
	uint width = max(1U, (uint)gm.gmBlackBoxX + (this->fs == FS_NORMAL));
 
	uint height = max(1U, (uint)gm.gmBlackBoxY + (this->fs == FS_NORMAL));
 
	uint width = std::max(1U, (uint)gm.gmBlackBoxX + (this->fs == FS_NORMAL));
 
	uint height = std::max(1U, (uint)gm.gmBlackBoxY + (this->fs == FS_NORMAL));
 

	
 
	/* Limit glyph size to prevent overflows later on. */
 
	if (width > 256 || height > 256) usererror("Font glyph is too large");
 
@@ -889,7 +889,7 @@ void Win32FontCache::ClearFontCache()
 
		 * For anti-aliased rendering, GDI uses the strange value range of 0 to 64,
 
		 * inclusively. To map this to 0 to 255, we shift left by two and then
 
		 * subtract one. */
 
		uint pitch = Align(aa ? gm.gmBlackBoxX : max(gm.gmBlackBoxX / 8u, 1u), 4);
 
		uint pitch = Align(aa ? gm.gmBlackBoxX : std::max(gm.gmBlackBoxX / 8u, 1u), 4);
 

	
 
		/* Draw shadow for medium size. */
 
		if (this->fs == FS_NORMAL && !aa) {
src/fontdetection.cpp
Show inline comments
 
@@ -222,7 +222,7 @@ static const char *GetEnglishFontName(co
 
		offset += buf[pos++];
 

	
 
		/* Don't buffer overflow */
 
		length = min(length, MAX_PATH - 1);
 
		length = std::min(length, MAX_PATH - 1);
 
		for (uint j = 0; j < length; j++) font_name[j] = buf[stringOffset + offset + j];
 
		font_name[length] = '\0';
 

	
src/framerate_gui.cpp
Show inline comments
 
@@ -76,7 +76,7 @@ namespace {
 
			this->prev_index = this->next_index;
 
			this->next_index += 1;
 
			if (this->next_index >= NUM_FRAMERATE_POINTS) this->next_index = 0;
 
			this->num_valid = min(NUM_FRAMERATE_POINTS, this->num_valid + 1);
 
			this->num_valid = std::min(NUM_FRAMERATE_POINTS, this->num_valid + 1);
 
		}
 

	
 
		/** Begin an accumulation of multiple measurements into a single value, from a given start time */
 
@@ -87,7 +87,7 @@ namespace {
 
			this->prev_index = this->next_index;
 
			this->next_index += 1;
 
			if (this->next_index >= NUM_FRAMERATE_POINTS) this->next_index = 0;
 
			this->num_valid = min(NUM_FRAMERATE_POINTS, this->num_valid + 1);
 
			this->num_valid = std::min(NUM_FRAMERATE_POINTS, this->num_valid + 1);
 

	
 
			this->acc_duration = 0;
 
			this->acc_timestamp = start_time;
 
@@ -115,7 +115,7 @@ namespace {
 
		/** Get average cycle processing time over a number of data points */
 
		double GetAverageDurationMilliseconds(int count)
 
		{
 
			count = min(count, this->num_valid);
 
			count = std::min(count, this->num_valid);
 

	
 
			int first_point = this->prev_index - count;
 
			if (first_point < 0) first_point += NUM_FRAMERATE_POINTS;
 
@@ -395,7 +395,7 @@ struct FramerateWindow : Window {
 
		{
 
			const double threshold_good = target * 0.95;
 
			const double threshold_bad = target * 2 / 3;
 
			value = min(9999.99, value);
 
			value = std::min(9999.99, value);
 
			this->value = (uint32)(value * 100);
 
			this->strid = (value > threshold_good) ? STR_FRAMERATE_FPS_GOOD : (value < threshold_bad) ? STR_FRAMERATE_FPS_BAD : STR_FRAMERATE_FPS_WARN;
 
		}
 
@@ -404,7 +404,7 @@ struct FramerateWindow : Window {
 
		{
 
			const double threshold_good = target / 3;
 
			const double threshold_bad = target;
 
			value = min(9999.99, value);
 
			value = std::min(9999.99, value);
 
			this->value = (uint32)(value * 100);
 
			this->strid = (value < threshold_good) ? STR_FRAMERATE_MS_GOOD : (value > threshold_bad) ? STR_FRAMERATE_MS_BAD : STR_FRAMERATE_MS_WARN;
 
		}
 
@@ -422,8 +422,8 @@ struct FramerateWindow : Window {
 
	CachedDecimal times_shortterm[PFE_MAX]; ///< cached short term average times
 
	CachedDecimal times_longterm[PFE_MAX];  ///< cached long term average times
 

	
 
	static const int VSPACING = 3;          ///< space between column heading and values
 
	static const int MIN_ELEMENTS = 5;      ///< smallest number of elements to display
 
	static constexpr int VSPACING = 3;          ///< space between column heading and values
 
	static constexpr int MIN_ELEMENTS = 5;      ///< smallest number of elements to display
 

	
 
	FramerateWindow(WindowDesc *desc, WindowNumber number) : Window(desc)
 
	{
 
@@ -435,7 +435,7 @@ struct FramerateWindow : Window {
 
		this->next_update.SetInterval(100);
 

	
 
		/* Window is always initialised to MIN_ELEMENTS height, resize to contain num_displayed */
 
		ResizeWindow(this, 0, (max(MIN_ELEMENTS, this->num_displayed) - MIN_ELEMENTS) * FONT_HEIGHT_NORMAL);
 
		ResizeWindow(this, 0, (std::max(MIN_ELEMENTS, this->num_displayed) - MIN_ELEMENTS) * FONT_HEIGHT_NORMAL);
 
	}
 

	
 
	void OnRealtimeTick(uint delta_ms) override
 
@@ -486,7 +486,7 @@ struct FramerateWindow : Window {
 
			this->num_active = new_active;
 
			Scrollbar *sb = this->GetScrollbar(WID_FRW_SCROLLBAR);
 
			sb->SetCount(this->num_active);
 
			sb->SetCapacity(min(this->num_displayed, this->num_active));
 
			sb->SetCapacity(std::min(this->num_displayed, this->num_active));
 
			this->ReInit();
 
		}
 
	}
 
@@ -555,7 +555,7 @@ struct FramerateWindow : Window {
 
						SetDParamStr(1, GetAIName(e - PFE_AI0));
 
						line_size = GetStringBoundingBox(STR_FRAMERATE_AI);
 
					}
 
					size->width = max(size->width, line_size.width);
 
					size->width = std::max(size->width, line_size.width);
 
				}
 
				break;
 
			}
 
@@ -567,7 +567,7 @@ struct FramerateWindow : Window {
 
				SetDParam(0, 999999);
 
				SetDParam(1, 2);
 
				Dimension item_size = GetStringBoundingBox(STR_FRAMERATE_MS_GOOD);
 
				size->width = max(size->width, item_size.width);
 
				size->width = std::max(size->width, item_size.width);
 
				size->height += FONT_HEIGHT_NORMAL * MIN_ELEMENTS + VSPACING;
 
				resize->width = 0;
 
				resize->height = FONT_HEIGHT_NORMAL;
 
@@ -769,7 +769,7 @@ struct FrametimeGraphWindow : Window {
 
			Dimension size_s_label = GetStringBoundingBox(STR_FRAMERATE_GRAPH_SECONDS);
 

	
 
			/* Size graph in height to fit at least 10 vertical labels with space between, or at least 100 pixels */
 
			graph_size.height = max<uint>(100, 10 * (size_ms_label.height + 1));
 
			graph_size.height = std::max(100u, 10 * (size_ms_label.height + 1));
 
			/* Always 2:1 graph area */
 
			graph_size.width = 2 * graph_size.height;
 
			*size = graph_size;
 
@@ -980,7 +980,7 @@ struct FrametimeGraphWindow : Window {
 
				TextColour tc_peak = (TextColour)(TC_IS_PALETTE_COLOUR | c_peak);
 
				GfxFillRect(peak_point.x - 1, peak_point.y - 1, peak_point.x + 1, peak_point.y + 1, c_peak);
 
				SetDParam(0, peak_value * 1000 / TIMESTAMP_PRECISION);
 
				int label_y = max(y_max, peak_point.y - FONT_HEIGHT_SMALL);
 
				int label_y = std::max(y_max, peak_point.y - FONT_HEIGHT_SMALL);
 
				if (peak_point.x - x_zero > (int)this->graph_size.width / 2) {
 
					DrawString(x_zero, peak_point.x - 2, label_y, STR_FRAMERATE_GRAPH_MILLISECONDS, tc_peak, SA_RIGHT | SA_FORCE, false, FS_SMALL);
 
				} else {
src/gamelog.cpp
Show inline comments
 
@@ -814,7 +814,7 @@ void GamelogInfo(LoggedAction *gamelog_a
 

	
 
				case GLCT_REVISION:
 
					*last_ottd_rev = lc->revision.newgrf;
 
					*ever_modified = max(*ever_modified, lc->revision.modified);
 
					*ever_modified = std::max(*ever_modified, lc->revision.modified);
 
					break;
 

	
 
				case GLCT_GRFREM:
src/genworld_gui.cpp
Show inline comments
 
@@ -513,7 +513,7 @@ struct GenerateLandscapeWindow : public 
 
			}
 
		}
 
		size->width += padding.width;
 
		size->height = max(size->height, (uint)(FONT_HEIGHT_NORMAL + WD_DROPDOWNTEXT_TOP + WD_DROPDOWNTEXT_BOTTOM));
 
		size->height = std::max(size->height, (uint)(FONT_HEIGHT_NORMAL + WD_DROPDOWNTEXT_TOP + WD_DROPDOWNTEXT_BOTTOM));
 
	}
 

	
 
	void DrawWidget(const Rect &r, int widget) const override
 
@@ -1214,7 +1214,7 @@ struct GenerateProgressWindow : public W
 

	
 
			case WID_GP_PROGRESS_TEXT:
 
				for (uint i = 0; i < GWP_CLASS_COUNT; i++) {
 
					size->width = max(size->width, GetStringBoundingBox(_generation_class_table[i]).width);
 
					size->width = std::max(size->width, GetStringBoundingBox(_generation_class_table[i]).width);
 
				}
 
				size->height = FONT_HEIGHT_NORMAL * 2 + WD_PAR_VSEP_NORMAL;
 
				break;
src/gfx.cpp
Show inline comments
 
@@ -263,8 +263,8 @@ void GfxFillPolygon(const std::vector<Po
 
		std::sort(intersections.begin(), intersections.end());
 
		for (size_t i = 1; i < intersections.size(); i += 2) {
 
			/* Check clipping. */
 
			const int x1 = max(0, intersections[i - 1]);
 
			const int x2 = min(intersections[i], dpi->width);
 
			const int x1 = std::max(0, intersections[i - 1]);
 
			const int x2 = std::min(intersections[i], dpi->width);
 
			if (x2 < 0) continue;
 
			if (x1 >= dpi->width) continue;
 

	
 
@@ -327,7 +327,7 @@ static inline void GfxDoDrawLine(void *v
 

	
 
	/* prevent integer overflows. */
 
	int margin = 1;
 
	while (INT_MAX / abs(grade_y) < max(abs(clip.left - x), abs(clip.right - x))) {
 
	while (INT_MAX / abs(grade_y) < std::max(abs(clip.left - x), abs(clip.right - x))) {
 
		grade_y /= 2;
 
		grade_x /= 2;
 
		margin  *= 2; // account for rounding errors
 
@@ -636,7 +636,7 @@ static int DrawLayoutLine(const Paragrap
 
int DrawString(int left, int right, int top, const char *str, TextColour colour, StringAlignment align, bool underline, FontSize fontsize)
 
{
 
	/* The string may contain control chars to change the font, just use the biggest font for clipping. */
 
	int max_height = max(max(FONT_HEIGHT_SMALL, FONT_HEIGHT_NORMAL), max(FONT_HEIGHT_LARGE, FONT_HEIGHT_MONO));
 
	int max_height = std::max({FONT_HEIGHT_SMALL, FONT_HEIGHT_NORMAL, FONT_HEIGHT_LARGE, FONT_HEIGHT_MONO});
 

	
 
	/* Funny glyphs may extent outside the usual bounds, so relax the clipping somewhat. */
 
	int extra = max_height / 2;
 
@@ -916,8 +916,8 @@ Dimension GetSpriteSize(SpriteID sprid, 
 
	}
 

	
 
	Dimension d;
 
	d.width  = max<int>(0, UnScaleByZoom(sprite->x_offs + sprite->width, zoom));
 
	d.height = max<int>(0, UnScaleByZoom(sprite->y_offs + sprite->height, zoom));
 
	d.width  = std::max<int>(0, UnScaleByZoom(sprite->x_offs + sprite->width, zoom));
 
	d.height = std::max<int>(0, UnScaleByZoom(sprite->y_offs + sprite->height, zoom));
 
	return d;
 
}
 

	
 
@@ -1024,10 +1024,10 @@ static void GfxBlitter(const Sprite * co
 
		bp.height = UnScaleByZoom(sprite->height, zoom);
 
	} else {
 
		/* Amount of pixels to clip from the source sprite */
 
		int clip_left   = max(0,                   -sprite->x_offs +  sub->left        * ZOOM_BASE );
 
		int clip_top    = max(0,                   -sprite->y_offs +  sub->top         * ZOOM_BASE );
 
		int clip_right  = max(0, sprite->width  - (-sprite->x_offs + (sub->right + 1)  * ZOOM_BASE));
 
		int clip_bottom = max(0, sprite->height - (-sprite->y_offs + (sub->bottom + 1) * ZOOM_BASE));
 
		int clip_left   = std::max(0,                   -sprite->x_offs +  sub->left        * ZOOM_BASE );
 
		int clip_top    = std::max(0,                   -sprite->y_offs +  sub->top         * ZOOM_BASE );
 
		int clip_right  = std::max(0, sprite->width  - (-sprite->x_offs + (sub->right + 1)  * ZOOM_BASE));
 
		int clip_bottom = std::max(0, sprite->height - (-sprite->y_offs + (sub->bottom + 1) * ZOOM_BASE));
 

	
 
		if (clip_left + clip_right >= sprite->width) return;
 
		if (clip_top + clip_bottom >= sprite->height) return;
 
@@ -1305,7 +1305,7 @@ byte GetDigitWidth(FontSize size)
 
{
 
	byte width = 0;
 
	for (char c = '0'; c <= '9'; c++) {
 
		width = max(GetCharacterWidth(size, c), width);
 
		width = std::max(GetCharacterWidth(size, c), width);
 
	}
 
	return width;
 
}
 
@@ -1695,8 +1695,8 @@ void UpdateCursorSize()
 
			_cursor.total_offs = offs;
 
			_cursor.total_size = size;
 
		} else {
 
			int right  = max(_cursor.total_offs.x + _cursor.total_size.x, offs.x + size.x);
 
			int bottom = max(_cursor.total_offs.y + _cursor.total_size.y, offs.y + size.y);
 
			int right  = std::max(_cursor.total_offs.x + _cursor.total_size.x, offs.x + size.x);
 
			int bottom = std::max(_cursor.total_offs.y + _cursor.total_size.y, offs.y + size.y);
 
			if (offs.x < _cursor.total_offs.x) _cursor.total_offs.x = offs.x;
 
			if (offs.y < _cursor.total_offs.y) _cursor.total_offs.y = offs.y;
 
			_cursor.total_size.x = right  - _cursor.total_offs.x;
src/gfx_layout.cpp
Show inline comments
 
@@ -431,7 +431,7 @@ int FallbackParagraphLayout::FallbackLin
 
{
 
	int leading = 0;
 
	for (const auto &run : *this) {
 
		leading = max(leading, run.GetLeading());
 
		leading = std::max(leading, run.GetLeading());
 
	}
 

	
 
	return leading;
 
@@ -747,7 +747,7 @@ Dimension Layouter::GetBounds()
 
{
 
	Dimension d = { 0, 0 };
 
	for (const auto &l : *this) {
 
		d.width = max<uint>(d.width, l->GetWidth());
 
		d.width = std::max<uint>(d.width, l->GetWidth());
 
		d.height += l->GetLeading();
 
	}
 
	return d;
src/gfxinit.cpp
Show inline comments
 
@@ -405,7 +405,7 @@ MD5File::ChecksumResult MD5File::CheckMD
 

	
 
	if (f == nullptr) return CR_NO_FILE;
 

	
 
	size = min(size, max_size);
 
	size = std::min(size, max_size);
 

	
 
	Md5 checksum;
 
	uint8 buffer[1024];
src/goal_gui.cpp
Show inline comments
 
@@ -291,7 +291,7 @@ struct GoalListWindow : public Window {
 
		}
 

	
 
		NWidgetBase *wid = this->GetWidget<NWidgetBase>(WID_GOAL_LIST);
 
		uint progress_col_width = min(max_width, wid->current_x);
 
		uint progress_col_width = std::min(max_width, wid->current_x);
 

	
 
		/* Draw goal list. */
 
		this->DrawListColumn(GC_PROGRESS, wid, progress_col_width);
src/graph_gui.cpp
Show inline comments
 
@@ -110,7 +110,7 @@ struct GraphLegendWindow : Window {
 
static NWidgetBase *MakeNWidgetCompanyLines(int *biggest_index)
 
{
 
	NWidgetVertical *vert = new NWidgetVertical();
 
	uint line_height = max<uint>(GetSpriteSize(SPR_COMPANY_ICON).height, FONT_HEIGHT_NORMAL) + WD_FRAMERECT_TOP + WD_FRAMERECT_BOTTOM;
 
	uint line_height = std::max<uint>(GetSpriteSize(SPR_COMPANY_ICON).height, FONT_HEIGHT_NORMAL) + WD_FRAMERECT_TOP + WD_FRAMERECT_BOTTOM;
 

	
 
	for (int widnum = WID_GL_FIRST_COMPANY; widnum <= WID_GL_LAST_COMPANY; widnum++) {
 
		NWidgetBackground *panel = new NWidgetBackground(WWT_PANEL, COLOUR_GREY, widnum);
 
@@ -212,8 +212,8 @@ protected:
 
				OverflowSafeInt64 datapoint = this->cost[i][j];
 

	
 
				if (datapoint != INVALID_DATAPOINT) {
 
					current_interval.highest = max(current_interval.highest, datapoint);
 
					current_interval.lowest  = min(current_interval.lowest, datapoint);
 
					current_interval.highest = std::max(current_interval.highest, datapoint);
 
					current_interval.lowest  = std::min(current_interval.lowest, datapoint);
 
				}
 
			}
 
		}
 
@@ -240,7 +240,7 @@ protected:
 
			/* Get the required grid size for each side and use the maximum one. */
 
			int64 grid_size_higher = (abs_higher > 0) ? ((int64)abs_higher + num_pos_grids - 1) / num_pos_grids : 0;
 
			int64 grid_size_lower = (abs_lower > 0) ? ((int64)abs_lower + num_hori_lines - num_pos_grids - 1) / (num_hori_lines - num_pos_grids) : 0;
 
			grid_size = max(grid_size_higher, grid_size_lower);
 
			grid_size = std::max(grid_size_higher, grid_size_lower);
 
		} else {
 
			/* If both values are zero, show an empty graph. */
 
			num_pos_grids = num_hori_lines / 2;
 
@@ -435,7 +435,7 @@ protected:
 
						 * least significant bits are removed.
 
						 */
 
						int mult_range = FindLastBit(x_axis_offset) + FindLastBit(abs(datapoint));
 
						int reduce_range = max(mult_range - 31, 0);
 
						int reduce_range = std::max(mult_range - 31, 0);
 

	
 
						/* Handle negative values differently (don't shift sign) */
 
						if (datapoint < 0) {
 
@@ -496,7 +496,7 @@ public:
 
				SetDParam(0, month + STR_MONTH_ABBREV_JAN);
 
				SetDParam(1, month + STR_MONTH_ABBREV_JAN + 2);
 
				SetDParam(2, year);
 
				x_label_width = max(x_label_width, GetStringBoundingBox(month == 0 ? STR_GRAPH_X_LABEL_MONTH_YEAR : STR_GRAPH_X_LABEL_MONTH).width);
 
				x_label_width = std::max(x_label_width, GetStringBoundingBox(month == 0 ? STR_GRAPH_X_LABEL_MONTH_YEAR : STR_GRAPH_X_LABEL_MONTH).width);
 

	
 
				month += 3;
 
				if (month >= 12) {
 
@@ -514,9 +514,9 @@ public:
 
		SetDParam(1, INT64_MAX);
 
		uint y_label_width = GetStringBoundingBox(STR_GRAPH_Y_LABEL).width;
 

	
 
		size->width  = max<uint>(size->width,  5 + y_label_width + this->num_on_x_axis * (x_label_width + 5) + 9);
 
		size->height = max<uint>(size->height, 5 + (1 + MIN_GRAPH_NUM_LINES_Y * 2 + (this->month != 0xFF ? 3 : 1)) * FONT_HEIGHT_SMALL + 4);
 
		size->height = max<uint>(size->height, size->width / 3);
 
		size->width  = std::max<uint>(size->width,  5 + y_label_width + this->num_on_x_axis * (x_label_width + 5) + 9);
 
		size->height = std::max<uint>(size->height, 5 + (1 + MIN_GRAPH_NUM_LINES_Y * 2 + (this->month != 0xFF ? 3 : 1)) * FONT_HEIGHT_SMALL + 4);
 
		size->height = std::max<uint>(size->height, size->width / 3);
 
	}
 

	
 
	void DrawWidget(const Rect &r, int widget) const override
 
@@ -568,7 +568,7 @@ public:
 

	
 
		byte nums = 0;
 
		for (const Company *c : Company::Iterate()) {
 
			nums = min(this->num_vert_lines, max(nums, c->num_valid_stat_ent));
 
			nums = std::min(this->num_vert_lines, std::max(nums, c->num_valid_stat_ent));
 
		}
 

	
 
		int mo = (_cur_month / 3 - nums) * 3;
 
@@ -1115,7 +1115,7 @@ static const StringID _performance_title
 

	
 
static inline StringID GetPerformanceTitleFromValue(uint value)
 
{
 
	return _performance_titles[minu(value, 1000) >> 6];
 
	return _performance_titles[std::min(value, 1000u) >> 6];
 
}
 

	
 
class CompanyLeagueWindow : public Window {
 
@@ -1199,7 +1199,7 @@ public:
 

	
 
		this->ordinal_width = 0;
 
		for (uint i = 0; i < MAX_COMPANIES; i++) {
 
			this->ordinal_width = max(this->ordinal_width, GetStringBoundingBox(STR_ORDINAL_NUMBER_1ST + i).width);
 
			this->ordinal_width = std::max(this->ordinal_width, GetStringBoundingBox(STR_ORDINAL_NUMBER_1ST + i).width);
 
		}
 
		this->ordinal_width += 5; // Keep some extra spacing
 

	
 
@@ -1215,13 +1215,13 @@ public:
 

	
 
		Dimension d = GetSpriteSize(SPR_COMPANY_ICON);
 
		this->icon_width = d.width + 2;
 
		this->line_height = max<int>(d.height + 2, FONT_HEIGHT_NORMAL);
 
		this->line_height = std::max<int>(d.height + 2, FONT_HEIGHT_NORMAL);
 

	
 
		for (const Company *c : Company::Iterate()) {
 
			SetDParam(0, c->index);
 
			SetDParam(1, c->index);
 
			SetDParam(2, _performance_titles[widest_title]);
 
			widest_width = max(widest_width, GetStringBoundingBox(STR_COMPANY_LEAGUE_COMPANY_NAME).width);
 
			widest_width = std::max(widest_width, GetStringBoundingBox(STR_COMPANY_LEAGUE_COMPANY_NAME).width);
 
		}
 

	
 
		this->text_width = widest_width + 30; // Keep some extra spacing
 
@@ -1321,7 +1321,7 @@ struct PerformanceRatingDetailWindow : W
 

	
 
				uint score_info_width = 0;
 
				for (uint i = SCORE_BEGIN; i < SCORE_END; i++) {
 
					score_info_width = max(score_info_width, GetStringBoundingBox(STR_PERFORMANCE_DETAIL_VEHICLES + i).width);
 
					score_info_width = std::max(score_info_width, GetStringBoundingBox(STR_PERFORMANCE_DETAIL_VEHICLES + i).width);
 
				}
 
				SetDParamMaxValue(0, 1000);
 
				score_info_width += GetStringBoundingBox(STR_BLACK_COMMA).width + WD_FRAMERECT_LEFT;
src/ground_vehicle.cpp
Show inline comments
 
@@ -38,7 +38,7 @@ void GroundVehicle<T, Type>::PowerChange
 

	
 
		/* Get minimum max speed for this track. */
 
		uint16 track_speed = u->GetMaxTrackSpeed();
 
		if (track_speed > 0) max_track_speed = min(max_track_speed, track_speed);
 
		if (track_speed > 0) max_track_speed = std::min(max_track_speed, track_speed);
 
	}
 

	
 
	byte air_drag;
 
@@ -48,7 +48,7 @@ void GroundVehicle<T, Type>::PowerChange
 
	if (air_drag_value == 0) {
 
		uint16 max_speed = v->GetDisplayMaxSpeed();
 
		/* Simplification of the method used in TTDPatch. It uses <= 10 to change more steadily from 128 to 196. */
 
		air_drag = (max_speed <= 10) ? 192 : max(2048 / max_speed, 1);
 
		air_drag = (max_speed <= 10) ? 192 : std::max(2048 / max_speed, 1);
 
	} else {
 
		/* According to the specs, a value of 0x01 in the air drag property means "no air drag". */
 
		air_drag = (air_drag_value == 1) ? 0 : air_drag_value;
 
@@ -89,7 +89,7 @@ void GroundVehicle<T, Type>::CargoChange
 
	}
 

	
 
	/* Store consist weight in cache. */
 
	this->gcache.cached_weight = max<uint32>(1, weight);
 
	this->gcache.cached_weight = std::max(1u, weight);
 
	/* Friction in bearings and other mechanical parts is 0.1% of the weight (result in N). */
 
	this->gcache.cached_axle_resistance = 10 * weight;
 

	
 
@@ -162,8 +162,8 @@ int GroundVehicle<T, Type>::GetAccelerat
 
		}
 
	} else {
 
		/* "Kickoff" acceleration. */
 
		force = (mode == AS_ACCEL && !maglev) ? min(max_te, power) : power;
 
		force = max(force, (mass * 8) + resistance);
 
		force = (mode == AS_ACCEL && !maglev) ? std::min<int>(max_te, power) : power;
 
		force = std::max(force, (mass * 8) + resistance);
 
	}
 

	
 
	if (mode == AS_ACCEL) {
 
@@ -176,9 +176,9 @@ int GroundVehicle<T, Type>::GetAccelerat
 
		 * a hill will never speed up enough to (eventually) get back to the
 
		 * same (maximum) speed. */
 
		int accel = ClampToI32((force - resistance) / (mass * 4));
 
		return force < resistance ? min(-1, accel) : max(1, accel);
 
		return force < resistance ? std::min(-1, accel) : std::max(1, accel);
 
	} else {
 
		return ClampToI32(min(-force - resistance, -10000) / mass);
 
		return ClampToI32(std::min<int64>(-force - resistance, -10000) / mass);
 
	}
 
}
 

	
src/ground_vehicle.hpp
Show inline comments
 
@@ -369,7 +369,7 @@ protected:
 
		 * somewhat gradually. But never lower than the maximum speed. */
 
		int tempmax = max_speed;
 
		if (this->cur_speed > max_speed) {
 
			tempmax = max(this->cur_speed - (this->cur_speed / 10) - 1, max_speed);
 
			tempmax = std::max(this->cur_speed - (this->cur_speed / 10) - 1, max_speed);
 
		}
 

	
 
		/* Enforce a maximum and minimum speed. Normally we would use something like
 
@@ -377,7 +377,7 @@ protected:
 
		 * threshold for some reason. That makes acceleration fail and assertions
 
		 * happen in Clamp. So make it explicit that min_speed overrules the maximum
 
		 * speed by explicit ordering of min and max. */
 
		this->cur_speed = spd = max(min(this->cur_speed + ((int)spd >> 8), tempmax), min_speed);
 
		this->cur_speed = spd = std::max(std::min(this->cur_speed + ((int)spd >> 8), tempmax), min_speed);
 

	
 
		int scaled_spd = this->GetAdvanceSpeed(spd);
 

	
src/group_gui.cpp
Show inline comments
 
@@ -205,14 +205,14 @@ private:
 
		this->tiny_step_height = this->column_size[VGC_FOLD].height;
 

	
 
		this->column_size[VGC_NAME] = maxdim(GetStringBoundingBox(STR_GROUP_DEFAULT_TRAINS + this->vli.vtype), GetStringBoundingBox(STR_GROUP_ALL_TRAINS + this->vli.vtype));
 
		this->column_size[VGC_NAME].width = max(170u, this->column_size[VGC_NAME].width);
 
		this->tiny_step_height = max(this->tiny_step_height, this->column_size[VGC_NAME].height);
 
		this->column_size[VGC_NAME].width = std::max(170u, this->column_size[VGC_NAME].width);
 
		this->tiny_step_height = std::max(this->tiny_step_height, this->column_size[VGC_NAME].height);
 

	
 
		this->column_size[VGC_PROTECT] = GetSpriteSize(SPR_GROUP_REPLACE_PROTECT);
 
		this->tiny_step_height = max(this->tiny_step_height, this->column_size[VGC_PROTECT].height);
 
		this->tiny_step_height = std::max(this->tiny_step_height, this->column_size[VGC_PROTECT].height);
 

	
 
		this->column_size[VGC_AUTOREPLACE] = GetSpriteSize(SPR_GROUP_REPLACE_ACTIVE);
 
		this->tiny_step_height = max(this->tiny_step_height, this->column_size[VGC_AUTOREPLACE].height);
 
		this->tiny_step_height = std::max(this->tiny_step_height, this->column_size[VGC_AUTOREPLACE].height);
 

	
 
		this->column_size[VGC_PROFIT].width = 0;
 
		this->column_size[VGC_PROFIT].height = 0;
 
@@ -221,13 +221,13 @@ private:
 
			Dimension d = GetSpriteSize(profit_sprites[i]);
 
			this->column_size[VGC_PROFIT] = maxdim(this->column_size[VGC_PROFIT], d);
 
		}
 
		this->tiny_step_height = max(this->tiny_step_height, this->column_size[VGC_PROFIT].height);
 
		this->tiny_step_height = std::max(this->tiny_step_height, this->column_size[VGC_PROFIT].height);
 

	
 
		int num_vehicle = GetGroupNumVehicle(this->vli.company, ALL_GROUP, this->vli.vtype);
 
		SetDParamMaxValue(0, num_vehicle, 3, FS_SMALL);
 
		SetDParamMaxValue(1, num_vehicle, 3, FS_SMALL);
 
		this->column_size[VGC_NUMBER] = GetStringBoundingBox(STR_GROUP_COUNT_WITH_SUBGROUP);
 
		this->tiny_step_height = max(this->tiny_step_height, this->column_size[VGC_NUMBER].height);
 
		this->tiny_step_height = std::max(this->tiny_step_height, this->column_size[VGC_NUMBER].height);
 

	
 
		this->tiny_step_height += WD_MATRIX_TOP;
 

	
 
@@ -390,9 +390,9 @@ public:
 

	
 
				/* ... minus the buttons at the bottom ... */
 
				uint max_icon_height = GetSpriteSize(this->GetWidget<NWidgetCore>(WID_GL_CREATE_GROUP)->widget_data).height;
 
				max_icon_height = max(max_icon_height, GetSpriteSize(this->GetWidget<NWidgetCore>(WID_GL_RENAME_GROUP)->widget_data).height);
 
				max_icon_height = max(max_icon_height, GetSpriteSize(this->GetWidget<NWidgetCore>(WID_GL_DELETE_GROUP)->widget_data).height);
 
				max_icon_height = max(max_icon_height, GetSpriteSize(this->GetWidget<NWidgetCore>(WID_GL_REPLACE_PROTECTION)->widget_data).height);
 
				max_icon_height = std::max(max_icon_height, GetSpriteSize(this->GetWidget<NWidgetCore>(WID_GL_RENAME_GROUP)->widget_data).height);
 
				max_icon_height = std::max(max_icon_height, GetSpriteSize(this->GetWidget<NWidgetCore>(WID_GL_DELETE_GROUP)->widget_data).height);
 
				max_icon_height = std::max(max_icon_height, GetSpriteSize(this->GetWidget<NWidgetCore>(WID_GL_REPLACE_PROTECTION)->widget_data).height);
 

	
 
				/* ... minus the height of the group info ... */
 
				max_icon_height += (FONT_HEIGHT_NORMAL * 3) + WD_FRAMERECT_TOP + WD_FRAMERECT_BOTTOM;
 
@@ -601,7 +601,7 @@ public:
 

	
 
			case WID_GL_LIST_GROUP: {
 
				int y1 = r.top + WD_FRAMERECT_TOP;
 
				int max = min(this->group_sb->GetPosition() + this->group_sb->GetCapacity(), (uint)this->groups.size());
 
				int max = std::min<size_t>(this->group_sb->GetPosition() + this->group_sb->GetCapacity(), this->groups.size());
 
				for (int i = this->group_sb->GetPosition(); i < max; ++i) {
 
					const Group *g = this->groups[i];
 

	
 
@@ -625,7 +625,7 @@ public:
 
				if (this->vli.index != ALL_GROUP && this->grouping == GB_NONE) {
 
					/* Mark vehicles which are in sub-groups (only if we are not using shared order coalescing) */
 
					int y = r.top;
 
					uint max = min(this->vscroll->GetPosition() + this->vscroll->GetCapacity(), static_cast<uint>(this->vehgroups.size()));
 
					uint max = static_cast<uint>(std::min<size_t>(this->vscroll->GetPosition() + this->vscroll->GetCapacity(), this->vehgroups.size()));
 
					for (uint i = this->vscroll->GetPosition(); i < max; ++i) {
 
						const Vehicle *v = this->vehgroups[i].GetSingleVehicle();
 
						if (v->group_id != this->vli.index) {
src/highscore.cpp
Show inline comments
 
@@ -43,7 +43,7 @@ static const StringID _endgame_perf_titl
 

	
 
StringID EndGameGetPerformanceTitleFromValue(uint value)
 
{
 
	value = minu(value / 64, lengthof(_endgame_perf_titles) - 1);
 
	value = std::min<uint>(value / 64, lengthof(_endgame_perf_titles) - 1);
 

	
 
	return _endgame_perf_titles[value];
 
}
 
@@ -132,7 +132,7 @@ void SaveToHighScore()
 
		for (i = 0; i < SP_SAVED_HIGHSCORE_END; i++) {
 
			for (hs = _highscore_table[i]; hs != endof(_highscore_table[i]); hs++) {
 
				/* First character is a command character, so strlen will fail on that */
 
				byte length = min(sizeof(hs->company), StrEmpty(hs->company) ? 0 : (int)strlen(&hs->company[1]) + 1);
 
				byte length = std::min(sizeof(hs->company), StrEmpty(hs->company) ? 0 : strlen(&hs->company[1]) + 1);
 

	
 
				if (fwrite(&length, sizeof(length), 1, fp)       != 1 || // write away string length
 
						fwrite(hs->company, length, 1, fp)           >  1 || // Yes... could be 0 bytes too
 
@@ -163,7 +163,7 @@ void LoadFromHighScore()
 
			for (hs = _highscore_table[i]; hs != endof(_highscore_table[i]); hs++) {
 
				byte length;
 
				if (fread(&length, sizeof(length), 1, fp)                              !=  1 ||
 
						fread(hs->company, min<int>(lengthof(hs->company), length), 1, fp) >   1 || // Yes... could be 0 bytes too
 
						fread(hs->company, std::min<int>(lengthof(hs->company), length), 1, fp) >   1 || // Yes... could be 0 bytes too
 
						fread(&hs->score, sizeof(hs->score), 1, fp)                        !=  1 ||
 
						fseek(fp, 2, SEEK_CUR)                                             == -1) { // XXX - placeholder for hs->title, not saved anymore; compatibility
 
					DEBUG(misc, 1, "Highscore corrupted");
src/highscore_gui.cpp
Show inline comments
 
@@ -58,7 +58,7 @@ struct EndGameHighScoreBaseWindow : Wind
 
	/** Return the coordinate of the screen such that a window of 640x480 is centered at the screen. */
 
	Point GetTopLeft(int x, int y)
 
	{
 
		Point pt = {max(0, (_screen.width / 2) - (x / 2)), max(0, (_screen.height / 2) - (y / 2))};
 
		Point pt = {std::max(0, (_screen.width / 2) - (x / 2)), std::max(0, (_screen.height / 2) - (y / 2))};
 
		return pt;
 
	}
 

	
src/industry.h
Show inline comments
 
@@ -10,7 +10,6 @@
 
#ifndef INDUSTRY_H
 
#define INDUSTRY_H
 

	
 
#include <algorithm>
 
#include "newgrf_storage.h"
 
#include "subsidy_type.h"
 
#include "industry_map.h"
src/industry_cmd.cpp
Show inline comments
 
@@ -531,7 +531,7 @@ static bool TransportIndustryGoods(TileI
 
	bool moved_cargo = false;
 

	
 
	for (uint j = 0; j < lengthof(i->produced_cargo_waiting); j++) {
 
		uint cw = min(i->produced_cargo_waiting[j], 255);
 
		uint cw = std::min<uint>(i->produced_cargo_waiting[j], 255u);
 
		if (cw > indspec->minimal_cargo && i->produced_cargo[j] != CT_INVALID) {
 
			i->produced_cargo_waiting[j] -= cw;
 

	
 
@@ -1032,7 +1032,7 @@ static void PlantFarmField(TileIndex til
 
	uint size_x = GB(r, 0, 8);
 
	uint size_y = GB(r, 8, 8);
 

	
 
	TileArea ta(tile - TileDiffXY(min(TileX(tile), size_x / 2), min(TileY(tile), size_y / 2)), size_x, size_y);
 
	TileArea ta(tile - TileDiffXY(std::min(TileX(tile), size_x / 2), std::min(TileY(tile), size_y / 2)), size_x, size_y);
 
	ta.ClampToMap();
 

	
 
	if (ta.w == 0 || ta.h == 0) return;
 
@@ -1121,7 +1121,7 @@ static void ChopLumberMillTrees(Industry
 

	
 
	TileIndex tile = i->location.tile;
 
	if (CircularTileSearch(&tile, 40, SearchLumberMillTrees, nullptr)) { // 40x40 tiles  to search.
 
		i->produced_cargo_waiting[0] = min(0xffff, i->produced_cargo_waiting[0] + 45); // Found a tree, add according value to waiting cargo.
 
		i->produced_cargo_waiting[0] = std::min(0xffff, i->produced_cargo_waiting[0] + 45); // Found a tree, add according value to waiting cargo.
 
	}
 
}
 

	
 
@@ -1153,7 +1153,7 @@ static void ProduceIndustryGoods(Industr
 

	
 
		IndustryBehaviour indbehav = indsp->behaviour;
 
		for (size_t j = 0; j < lengthof(i->produced_cargo_waiting); j++) {
 
			i->produced_cargo_waiting[j] = min(0xffff, i->produced_cargo_waiting[j] + i->production_rate[j]);
 
			i->produced_cargo_waiting[j] = std::min(0xffff, i->produced_cargo_waiting[j] + i->production_rate[j]);
 
		}
 

	
 
		if ((indbehav & INDUSTRYBEH_PLANT_FIELDS) != 0) {
 
@@ -1743,7 +1743,7 @@ static void DoCreateNewIndustry(Industry
 
	/* Randomize inital production if non-original economy is used and there are no production related callbacks. */
 
	if (!indspec->UsesOriginalEconomy()) {
 
		for (size_t ci = 0; ci < lengthof(i->production_rate); ci++) {
 
			i->production_rate[ci] = min((RandomRange(256) + 128) * i->production_rate[ci] >> 8, 255);
 
			i->production_rate[ci] = std::min((RandomRange(256) + 128) * i->production_rate[ci] >> 8, 255u);
 
		}
 
	}
 

	
 
@@ -2208,7 +2208,7 @@ static uint GetNumberOfIndustries()
 

	
 
	assert(lengthof(numof_industry_table) == ID_END);
 
	uint difficulty = (_game_mode != GM_EDITOR) ? _settings_game.difficulty.industry_density : (uint)ID_VERY_LOW;
 
	return min(IndustryPool::MAX_SIZE, ScaleByMapSize(numof_industry_table[difficulty]));
 
	return std::min<uint>(IndustryPool::MAX_SIZE, ScaleByMapSize(numof_industry_table[difficulty]));
 
}
 

	
 
/**
 
@@ -2284,7 +2284,7 @@ void IndustryBuildData::MonthlyLoop()
 

	
 
	/* To prevent running out of unused industries for the player to connect,
 
	 * add a fraction of new industries each month, but only if the manager can keep up. */
 
	uint max_behind = 1 + min(99u, ScaleByMapSize(3)); // At most 2 industries for small maps, and 100 at the biggest map (about 6 months industry build attempts).
 
	uint max_behind = 1 + std::min(99u, ScaleByMapSize(3)); // At most 2 industries for small maps, and 100 at the biggest map (about 6 months industry build attempts).
 
	if (GetCurrentTotalNumberOfIndustries() + max_behind >= (this->wanted_inds >> 16)) {
 
		this->wanted_inds += ScaleByMapSize(NEWINDS_PER_MONTH);
 
	}
 
@@ -2352,7 +2352,7 @@ static void UpdateIndustryStatistics(Ind
 
			byte pct = 0;
 
			if (i->this_month_production[j] != 0) {
 
				i->last_prod_year = _cur_year;
 
				pct = min(i->this_month_transported[j] * 256 / i->this_month_production[j], 255);
 
				pct = std::min(i->this_month_transported[j] * 256 / i->this_month_production[j], 255);
 
			}
 
			i->last_month_pct_transported[j] = pct;
 

	
 
@@ -2376,7 +2376,7 @@ void Industry::RecomputeProductionMultip
 

	
 
	/* Rates are rounded up, so e.g. oilrig always produces some passengers */
 
	for (size_t i = 0; i < lengthof(this->production_rate); i++) {
 
		this->production_rate[i] = min(CeilDiv(indspec->production_rate[i] * this->prod_level, PRODLEVEL_DEFAULT), 0xFF);
 
		this->production_rate[i] = std::min(CeilDiv(indspec->production_rate[i] * this->prod_level, PRODLEVEL_DEFAULT), 0xFFu);
 
	}
 
}
 

	
 
@@ -2509,10 +2509,10 @@ void IndustryBuildData::TryBuildNewIndus
 
		const Industry *ind = PlaceIndustry(it, IACT_RANDOMCREATION, false);
 
		if (ind == nullptr) {
 
			this->builddata[it].wait_count = this->builddata[it].max_wait + 1; // Compensate for decrementing below.
 
			this->builddata[it].max_wait = min(1000, this->builddata[it].max_wait + 2);
 
			this->builddata[it].max_wait = std::min(1000, this->builddata[it].max_wait + 2);
 
		} else {
 
			AdvertiseIndustryOpening(ind);
 
			this->builddata[it].max_wait = max(this->builddata[it].max_wait / 2, 1); // Reduce waiting time of the industry type.
 
			this->builddata[it].max_wait = std::max(this->builddata[it].max_wait / 2, 1); // Reduce waiting time of the industry type.
 
		}
 
	}
 

	
 
@@ -2749,7 +2749,7 @@ static void ChangeIndustryProduction(Ind
 
				/* 4.5% chance for 3-23% (or 1 unit for very low productions) production change,
 
				 * determined by mult value. If mult = 1 prod. increases, else (-1) it decreases. */
 
				if (Chance16I(1, 22, r >> 16)) {
 
					new_prod += mult * (max(((RandomRange(50) + 10) * old_prod) >> 8, 1U));
 
					new_prod += mult * (std::max(((RandomRange(50) + 10) * old_prod) >> 8, 1U));
 
				}
 

	
 
				/* Prevent production to overflow or Oil Rig passengers to be over-"produced" */
 
@@ -2794,7 +2794,7 @@ static void ChangeIndustryProduction(Ind
 

	
 
	/* Increase if needed */
 
	while (mul-- != 0 && i->prod_level < PRODLEVEL_MAXIMUM) {
 
		i->prod_level = min(i->prod_level * 2, PRODLEVEL_MAXIMUM);
 
		i->prod_level = std::min<int>(i->prod_level * 2, PRODLEVEL_MAXIMUM);
 
		recalculate_multipliers = true;
 
		if (str == STR_NULL) str = indspec->production_up_text;
 
	}
 
@@ -2805,7 +2805,7 @@ static void ChangeIndustryProduction(Ind
 
			closeit = true;
 
			break;
 
		} else {
 
			i->prod_level = max(i->prod_level / 2, (int)PRODLEVEL_MINIMUM); // typecast to int required to please MSVC
 
			i->prod_level = std::max<int>(i->prod_level / 2, PRODLEVEL_MINIMUM);
 
			recalculate_multipliers = true;
 
			if (str == STR_NULL) str = indspec->production_down_text;
 
		}
 
@@ -2897,7 +2897,7 @@ void IndustryDailyLoop()
 

	
 
	uint perc = 3; // Between 3% and 9% chance of creating a new industry.
 
	if ((_industry_builder.wanted_inds >> 16) > GetCurrentTotalNumberOfIndustries()) {
 
		perc = min(9u, perc + (_industry_builder.wanted_inds >> 16) - GetCurrentTotalNumberOfIndustries());
 
		perc = std::min(9u, perc + (_industry_builder.wanted_inds >> 16) - GetCurrentTotalNumberOfIndustries());
 
	}
 
	for (uint16 j = 0; j < change_loop; j++) {
 
		if (Chance16(perc, 100)) {
src/industry_gui.cpp
Show inline comments
 
@@ -434,7 +434,7 @@ public:
 
					std::string cargostring = this->MakeCargoListString(indsp->accepts_cargo, cargo_suffix, lengthof(indsp->accepts_cargo), STR_INDUSTRY_VIEW_REQUIRES_N_CARGO);
 
					Dimension strdim = GetStringBoundingBox(cargostring.c_str());
 
					if (strdim.width > max_minwidth) {
 
						extra_lines_req = max(extra_lines_req, strdim.width / max_minwidth + 1);
 
						extra_lines_req = std::max(extra_lines_req, strdim.width / max_minwidth + 1);
 
						strdim.width = max_minwidth;
 
					}
 
					d = maxdim(d, strdim);
 
@@ -444,7 +444,7 @@ public:
 
					cargostring = this->MakeCargoListString(indsp->produced_cargo, cargo_suffix, lengthof(indsp->produced_cargo), STR_INDUSTRY_VIEW_PRODUCES_N_CARGO);
 
					strdim = GetStringBoundingBox(cargostring.c_str());
 
					if (strdim.width > max_minwidth) {
 
						extra_lines_prd = max(extra_lines_prd, strdim.width / max_minwidth + 1);
 
						extra_lines_prd = std::max(extra_lines_prd, strdim.width / max_minwidth + 1);
 
						strdim.width = max_minwidth;
 
					}
 
					d = maxdim(d, strdim);
 
@@ -966,22 +966,22 @@ public:
 
						case EA_MULTIPLIER:
 
							if (button == 1) {
 
								if (i->prod_level <= PRODLEVEL_MINIMUM) return;
 
								i->prod_level = max<uint>(i->prod_level / 2, PRODLEVEL_MINIMUM);
 
								i->prod_level = std::max<uint>(i->prod_level / 2, PRODLEVEL_MINIMUM);
 
							} else {
 
								if (i->prod_level >= PRODLEVEL_MAXIMUM) return;
 
								i->prod_level = minu(i->prod_level * 2, PRODLEVEL_MAXIMUM);
 
								i->prod_level = std::min<uint>(i->prod_level * 2, PRODLEVEL_MAXIMUM);
 
							}
 
							break;
 

	
 
						case EA_RATE:
 
							if (button == 1) {
 
								if (i->production_rate[line - IL_RATE1] <= 0) return;
 
								i->production_rate[line - IL_RATE1] = max(i->production_rate[line - IL_RATE1] / 2, 0);
 
								i->production_rate[line - IL_RATE1] = std::max(i->production_rate[line - IL_RATE1] / 2, 0);
 
							} else {
 
								if (i->production_rate[line - IL_RATE1] >= 255) return;
 
								/* a zero production industry is unlikely to give anything but zero, so push it a little bit */
 
								int new_prod = i->production_rate[line - IL_RATE1] == 0 ? 1 : i->production_rate[line - IL_RATE1] * 2;
 
								i->production_rate[line - IL_RATE1] = minu(new_prod, 255);
 
								i->production_rate[line - IL_RATE1] = std::min<uint>(new_prod, 255);
 
							}
 
							break;
 

	
 
@@ -1468,7 +1468,7 @@ protected:
 
		}
 

	
 
		/* Display first 3 cargos */
 
		for (size_t j = 0; j < min<size_t>(3, cargos.size()); j++) {
 
		for (size_t j = 0; j < std::min<size_t>(3, cargos.size()); j++) {
 
			CargoInfo ci = cargos[j];
 
			SetDParam(p++, STR_INDUSTRY_DIRECTORY_ITEM_INFO);
 
			SetDParam(p++, std::get<0>(ci));
 
@@ -2399,10 +2399,10 @@ struct IndustryCargoesWindow : public Wi
 
			const IndustrySpec *indsp = GetIndustrySpec(it);
 
			if (!indsp->enabled) continue;
 
			this->ind_textsize = maxdim(this->ind_textsize, GetStringBoundingBox(indsp->name));
 
			CargoesField::max_cargoes = max<uint>(CargoesField::max_cargoes, std::count_if(indsp->accepts_cargo, endof(indsp->accepts_cargo), IsCargoIDValid));
 
			CargoesField::max_cargoes = max<uint>(CargoesField::max_cargoes, std::count_if(indsp->produced_cargo, endof(indsp->produced_cargo), IsCargoIDValid));
 
			CargoesField::max_cargoes = std::max<uint>(CargoesField::max_cargoes, std::count_if(indsp->accepts_cargo, endof(indsp->accepts_cargo), IsCargoIDValid));
 
			CargoesField::max_cargoes = std::max<uint>(CargoesField::max_cargoes, std::count_if(indsp->produced_cargo, endof(indsp->produced_cargo), IsCargoIDValid));
 
		}
 
		d.width = max(d.width, this->ind_textsize.width);
 
		d.width = std::max(d.width, this->ind_textsize.width);
 
		d.height = this->ind_textsize.height;
 
		this->ind_textsize = maxdim(this->ind_textsize, GetStringBoundingBox(STR_INDUSTRY_CARGOES_SELECT_INDUSTRY));
 

	
 
@@ -2420,7 +2420,7 @@ struct IndustryCargoesWindow : public Wi
 
		d.width  += 2 * HOR_TEXT_PADDING;
 
		/* Ensure the height is enough for the industry type text, for the horizontal connections, and for the cargo labels. */
 
		uint min_ind_height = CargoesField::VERT_CARGO_EDGE * 2 + CargoesField::max_cargoes * FONT_HEIGHT_NORMAL + (CargoesField::max_cargoes - 1) *  CargoesField::VERT_CARGO_SPACE;
 
		d.height = max(d.height + 2 * VERT_TEXT_PADDING, min_ind_height);
 
		d.height = std::max(d.height + 2 * VERT_TEXT_PADDING, min_ind_height);
 

	
 
		CargoesField::industry_width = d.width;
 
		CargoesField::normal_height = d.height + CargoesField::VERT_INTER_INDUSTRY_SPACE;
 
@@ -2437,11 +2437,11 @@ struct IndustryCargoesWindow : public Wi
 
				break;
 

	
 
			case WID_IC_IND_DROPDOWN:
 
				size->width = max(size->width, this->ind_textsize.width + padding.width);
 
				size->width = std::max(size->width, this->ind_textsize.width + padding.width);
 
				break;
 

	
 
			case WID_IC_CARGO_DROPDOWN:
 
				size->width = max(size->width, this->cargo_textsize.width + padding.width);
 
				size->width = std::max(size->width, this->cargo_textsize.width + padding.width);
 
				break;
 
		}
 
	}
 
@@ -2638,7 +2638,7 @@ struct IndustryCargoesWindow : public Wi
 
		/* Make a field consisting of two cargo columns. */
 
		int num_supp = CountMatchingProducingIndustries(central_sp->accepts_cargo, lengthof(central_sp->accepts_cargo)) + houses_supply;
 
		int num_cust = CountMatchingAcceptingIndustries(central_sp->produced_cargo, lengthof(central_sp->produced_cargo)) + houses_accept;
 
		int num_indrows = max(3, max(num_supp, num_cust)); // One is needed for the 'it' industry, and 2 for the cargo labels.
 
		int num_indrows = std::max(3, std::max(num_supp, num_cust)); // One is needed for the 'it' industry, and 2 for the cargo labels.
 
		for (int i = 0; i < num_indrows; i++) {
 
			CargoesRow &row = this->fields.emplace_back();
 
			row.columns[0].MakeEmpty(CFT_EMPTY);
 
@@ -2714,7 +2714,7 @@ struct IndustryCargoesWindow : public Wi
 
		bool houses_accept = HousesCanAccept(&cid, 1);
 
		int num_supp = CountMatchingProducingIndustries(&cid, 1) + houses_supply + 1; // Ensure room for the cargo label.
 
		int num_cust = CountMatchingAcceptingIndustries(&cid, 1) + houses_accept;
 
		int num_indrows = max(num_supp, num_cust);
 
		int num_indrows = std::max(num_supp, num_cust);
 
		for (int i = 0; i < num_indrows; i++) {
 
			CargoesRow &row = this->fields.emplace_back();
 
			row.columns[0].MakeEmpty(CFT_EMPTY);
src/ini_load.cpp
Show inline comments
 
@@ -226,7 +226,7 @@ void IniLoadFile::LoadFromDisk(const std
 
			uint a = comment_alloc;
 
			/* add to comment */
 
			if (ns > a) {
 
				a = max(a, 128U);
 
				a = std::max(a, 128U);
 
				do a *= 2; while (a < ns);
 
				comment = ReallocT(comment, comment_alloc = a);
 
			}
src/landscape.cpp
Show inline comments
 
@@ -130,12 +130,12 @@ Point InverseRemapCoords2(int x, int y, 
 
	 * So give it a z-malus of 4 in the first iterations. */
 
	int z = 0;
 
	if (clamp_to_map) {
 
		for (int i = 0; i < 5; i++) z = GetSlopePixelZ(Clamp(pt.x + max(z, 4) - 4, min_coord, max_x), Clamp(pt.y + max(z, 4) - 4, min_coord, max_y)) / 2;
 
		for (int m = 3; m > 0; m--) z = GetSlopePixelZ(Clamp(pt.x + max(z, m) - m, min_coord, max_x), Clamp(pt.y + max(z, m) - m, min_coord, max_y)) / 2;
 
		for (int i = 0; i < 5; i++) z = GetSlopePixelZ(Clamp(pt.x + std::max(z, 4) - 4, min_coord, max_x), Clamp(pt.y + std::max(z, 4) - 4, min_coord, max_y)) / 2;
 
		for (int m = 3; m > 0; m--) z = GetSlopePixelZ(Clamp(pt.x + std::max(z, m) - m, min_coord, max_x), Clamp(pt.y + std::max(z, m) - m, min_coord, max_y)) / 2;
 
		for (int i = 0; i < 5; i++) z = GetSlopePixelZ(Clamp(pt.x + z,             min_coord, max_x), Clamp(pt.y + z,             min_coord, max_y)) / 2;
 
	} else {
 
		for (int i = 0; i < 5; i++) z = GetSlopePixelZOutsideMap(pt.x + max(z, 4) - 4, pt.y + max(z, 4) - 4) / 2;
 
		for (int m = 3; m > 0; m--) z = GetSlopePixelZOutsideMap(pt.x + max(z, m) - m, pt.y + max(z, m) - m) / 2;
 
		for (int i = 0; i < 5; i++) z = GetSlopePixelZOutsideMap(pt.x + std::max(z, 4) - 4, pt.y + std::max(z, 4) - 4) / 2;
 
		for (int m = 3; m > 0; m--) z = GetSlopePixelZOutsideMap(pt.x + std::max(z, m) - m, pt.y + std::max(z, m) - m) / 2;
 
		for (int i = 0; i < 5; i++) z = GetSlopePixelZOutsideMap(pt.x + z,             pt.y + z            ) / 2;
 
	}
 

	
 
@@ -630,8 +630,8 @@ void SetSnowLine(byte table[SNOW_LINE_MO
 

	
 
	for (uint i = 0; i < SNOW_LINE_MONTHS; i++) {
 
		for (uint j = 0; j < SNOW_LINE_DAYS; j++) {
 
			_snow_line->highest_value = max(_snow_line->highest_value, table[i][j]);
 
			_snow_line->lowest_value = min(_snow_line->lowest_value, table[i][j]);
 
			_snow_line->highest_value = std::max(_snow_line->highest_value, table[i][j]);
 
			_snow_line->lowest_value = std::min(_snow_line->lowest_value, table[i][j]);
 
		}
 
	}
 
}
src/linkgraph/demands.cpp
Show inline comments
 
@@ -45,7 +45,7 @@ public:
 
	 */
 
	inline void SetDemandPerNode(uint num_demands)
 
	{
 
		this->demand_per_node = max(this->supply_sum / num_demands, 1U);
 
		this->demand_per_node = std::max(this->supply_sum / num_demands, 1U);
 
	}
 

	
 
	/**
 
@@ -57,7 +57,7 @@ public:
 
	 */
 
	inline uint EffectiveSupply(const Node &from, const Node &to)
 
	{
 
		return max(from.Supply() * max(1U, to.Supply()) * this->mod_size / 100 / this->demand_per_node, 1U);
 
		return std::max(from.Supply() * std::max(1U, to.Supply()) * this->mod_size / 100 / this->demand_per_node, 1U);
 
	}
 

	
 
	/**
 
@@ -134,7 +134,7 @@ void SymmetricScaler::SetDemands(LinkGra
 
		uint undelivered = job[to_id].UndeliveredSupply();
 
		if (demand_back > undelivered) {
 
			demand_back = undelivered;
 
			demand_forw = max(1U, demand_back * 100 / this->mod_size);
 
			demand_forw = std::max(1U, demand_back * 100 / this->mod_size);
 
		}
 
		this->Scaler::SetDemands(job, to_id, from_id, demand_back);
 
	}
 
@@ -230,7 +230,7 @@ void DemandCalculator::CalcDemand(LinkGr
 
				demand_forw = 1;
 
			}
 

	
 
			demand_forw = min(demand_forw, job[from_id].UndeliveredSupply());
 
			demand_forw = std::min(demand_forw, job[from_id].UndeliveredSupply());
 

	
 
			scaler.SetDemands(job, from_id, to_id, demand_forw);
 

	
src/linkgraph/linkgraph.cpp
Show inline comments
 
@@ -71,7 +71,7 @@ void LinkGraph::Compress()
 
		for (NodeID node2 = 0; node2 < this->Size(); ++node2) {
 
			BaseEdge &edge = this->edges[node1][node2];
 
			if (edge.capacity > 0) {
 
				edge.capacity = max(1U, edge.capacity / 2);
 
				edge.capacity = std::max(1U, edge.capacity / 2);
 
				edge.usage /= 2;
 
			}
 
		}
 
@@ -163,8 +163,7 @@ NodeID LinkGraph::AddNode(const Station 
 
	this->nodes.emplace_back();
 
	/* Avoid reducing the height of the matrix as that is expensive and we
 
	 * most likely will increase it again later which is again expensive. */
 
	this->edges.Resize(new_node + 1U,
 
			max(new_node + 1U, this->edges.Height()));
 
	this->edges.Resize(new_node + 1U, std::max(new_node + 1U, this->edges.Height()));
 

	
 
	this->nodes[new_node].Init(st->xy, st->index,
 
			HasBit(good.status, GoodsEntry::GES_ACCEPTANCE));
 
@@ -266,8 +265,8 @@ void LinkGraph::Edge::Update(uint capaci
 
		this->edge.capacity += capacity;
 
		this->edge.usage += usage;
 
	} else if (mode & EUM_REFRESH) {
 
		this->edge.capacity = max(this->edge.capacity, capacity);
 
		this->edge.usage = max(this->edge.usage, usage);
 
		this->edge.capacity = std::max(this->edge.capacity, capacity);
 
		this->edge.usage = std::max(this->edge.usage, usage);
 
	}
 
	if (mode & EUM_UNRESTRICTED) this->edge.last_unrestricted_update = _date;
 
	if (mode & EUM_RESTRICTED) this->edge.last_restricted_update = _date;
src/linkgraph/linkgraph.h
Show inline comments
 
@@ -113,7 +113,7 @@ public:
 
		 * Get the date of the last update to any part of the edge's capacity.
 
		 * @return Last update.
 
		 */
 
		Date LastUpdate() const { return max(this->edge.last_unrestricted_update, this->edge.last_restricted_update); }
 
		Date LastUpdate() const { return std::max(this->edge.last_unrestricted_update, this->edge.last_restricted_update); }
 
	};
 

	
 
	/**
 
@@ -453,7 +453,7 @@ public:
 
	 */
 
	inline static uint Scale(uint val, uint target_age, uint orig_age)
 
	{
 
		return val > 0 ? max(1U, val * target_age / orig_age) : 0;
 
		return val > 0 ? std::max(1U, val * target_age / orig_age) : 0;
 
	}
 

	
 
	/** Bare constructor, only for save/load. */
src/linkgraph/linkgraph_gui.cpp
Show inline comments
 
@@ -224,7 +224,7 @@ void LinkGraphOverlay::AddLinks(const St
 
{
 
	/* multiply the numbers by 32 in order to avoid comparing to 0 too often. */
 
	if (cargo.capacity == 0 ||
 
			max(cargo.usage, cargo.planned) * 32 / (cargo.capacity + 1) < max(new_usg, new_plan) * 32 / (new_cap + 1)) {
 
			std::max(cargo.usage, cargo.planned) * 32 / (cargo.capacity + 1) < std::max(new_usg, new_plan) * 32 / (new_cap + 1)) {
 
		cargo.capacity = new_cap;
 
		cargo.usage = new_usg;
 
		cargo.planned = new_plan;
 
@@ -272,7 +272,7 @@ void LinkGraphOverlay::DrawLinks(const D
 
 */
 
void LinkGraphOverlay::DrawContent(Point pta, Point ptb, const LinkProperties &cargo) const
 
{
 
	uint usage_or_plan = min(cargo.capacity * 2 + 1, max(cargo.usage, cargo.planned));
 
	uint usage_or_plan = std::min(cargo.capacity * 2 + 1, std::max(cargo.usage, cargo.planned));
 
	int colour = LinkGraphOverlay::LINK_COLOURS[usage_or_plan * lengthof(LinkGraphOverlay::LINK_COLOURS) / (cargo.capacity * 2 + 2)];
 
	int dash = cargo.shared ? this->scale * 4 : 0;
 

	
 
@@ -302,7 +302,7 @@ void LinkGraphOverlay::DrawStationDots(c
 
		Point pt = this->GetStationMiddle(st);
 
		if (!this->IsPointVisible(pt, dpi, 3 * this->scale)) continue;
 

	
 
		uint r = this->scale * 2 + this->scale * 2 * min(200, i->second) / 200;
 
		uint r = this->scale * 2 + this->scale * 2 * std::min(200U, i->second) / 200;
 

	
 
		LinkGraphOverlay::DrawVertex(pt.x, pt.y, r,
 
				_colour_gradient[st->owner != OWNER_NONE ?
src/linkgraph/linkgraphjob.cpp
Show inline comments
 
@@ -223,8 +223,8 @@ void LinkGraphJob::NodeAnnotation::Init(
 
 */
 
void Path::Fork(Path *base, uint cap, int free_cap, uint dist)
 
{
 
	this->capacity = min(base->capacity, cap);
 
	this->free_capacity = min(base->free_capacity, free_cap);
 
	this->capacity = std::min(base->capacity, cap);
 
	this->free_capacity = std::min(base->free_capacity, free_cap);
 
	this->distance = base->distance + dist;
 
	assert(this->distance > 0);
 
	if (this->parent != base) {
 
@@ -250,7 +250,7 @@ uint Path::AddFlow(uint new_flow, LinkGr
 
		if (max_saturation != UINT_MAX) {
 
			uint usable_cap = edge.Capacity() * max_saturation / 100;
 
			if (usable_cap > edge.Flow()) {
 
				new_flow = min(new_flow, usable_cap - edge.Flow());
 
				new_flow = std::min(new_flow, usable_cap - edge.Flow());
 
			} else {
 
				return 0;
 
			}
src/linkgraph/linkgraphjob.h
Show inline comments
 
@@ -392,7 +392,7 @@ public:
 
	 */
 
	inline static int GetCapacityRatio(int free, uint total)
 
	{
 
		return Clamp(free, PATH_CAP_MIN_FREE, PATH_CAP_MAX_FREE) * PATH_CAP_MULTIPLIER / max(total, 1U);
 
		return Clamp(free, PATH_CAP_MIN_FREE, PATH_CAP_MAX_FREE) * PATH_CAP_MULTIPLIER / std::max(total, 1U);
 
	}
 

	
 
	/**
src/linkgraph/mcf.cpp
Show inline comments
 
@@ -235,7 +235,7 @@ bool DistanceAnnotation::IsBetter(const 
 
bool CapacityAnnotation::IsBetter(const CapacityAnnotation *base, uint cap,
 
		int free_cap, uint dist) const
 
{
 
	int min_cap = Path::GetCapacityRatio(min(base->free_capacity, free_cap), min(base->capacity, cap));
 
	int min_cap = Path::GetCapacityRatio(std::min(base->free_capacity, free_cap), std::min(base->capacity, cap));
 
	int this_cap = this->GetCapacityRatio();
 
	if (min_cap == this_cap) {
 
		/* If the capacities are the same and the other path isn't disconnected
 
@@ -354,7 +354,7 @@ uint MCF1stPass::FindCycleFlow(const Pat
 
	uint flow = UINT_MAX;
 
	const Path *cycle_end = cycle_begin;
 
	do {
 
		flow = min(flow, cycle_begin->GetFlow());
 
		flow = std::min(flow, cycle_begin->GetFlow());
 
		cycle_begin = path[cycle_begin->GetNode()];
 
	} while (cycle_begin != cycle_end);
 
	return flow;
src/map.cpp
Show inline comments
 
@@ -190,7 +190,7 @@ uint DistanceMax(TileIndex t0, TileIndex
 
{
 
	const uint dx = Delta(TileX(t0), TileX(t1));
 
	const uint dy = Delta(TileY(t0), TileY(t1));
 
	return max(dx, dy);
 
	return std::max(dx, dy);
 
}
 

	
 

	
 
@@ -220,9 +220,9 @@ uint DistanceFromEdge(TileIndex tile)
 
	const uint yl = TileY(tile);
 
	const uint xh = MapSizeX() - 1 - xl;
 
	const uint yh = MapSizeY() - 1 - yl;
 
	const uint minl = min(xl, yl);
 
	const uint minh = min(xh, yh);
 
	return min(minl, minh);
 
	const uint minl = std::min(xl, yl);
 
	const uint minh = std::min(xh, yh);
 
	return std::min(minl, minh);
 
}
 

	
 
/**
src/misc/str.hpp
Show inline comments
 
@@ -92,7 +92,7 @@ struct CStrA : public CBlobT<char>
 
	/** Add formatted string (like vsprintf) at the end of existing contents. */
 
	int AddFormatL(const char *format, va_list args) WARN_FORMAT(2, 0)
 
	{
 
		size_t addSize = max<size_t>(strlen(format), 16);
 
		size_t addSize = std::max<size_t>(strlen(format), 16);
 
		addSize += addSize / 2;
 
		int ret;
 
		int err = 0;
src/misc_cmd.cpp
Show inline comments
 
@@ -98,10 +98,10 @@ CommandCost CmdDecreaseLoan(TileIndex ti
 
	switch (p2 & 3) {
 
		default: return CMD_ERROR; // Invalid method
 
		case 0: // Pay back one step
 
			loan = min(c->current_loan, (Money)LOAN_INTERVAL);
 
			loan = std::min(c->current_loan, (Money)LOAN_INTERVAL);
 
			break;
 
		case 1: // Pay back as much as possible
 
			loan = max(min(c->current_loan, c->money), (Money)LOAN_INTERVAL);
 
			loan = std::max(std::min(c->current_loan, c->money), (Money)LOAN_INTERVAL);
 
			loan -= loan % LOAN_INTERVAL;
 
			break;
 
		case 2: // Repay the given amount of loan
src/misc_gui.cpp
Show inline comments
 
@@ -99,7 +99,7 @@ public:
 
			if (StrEmpty(this->landinfo_data[i])) break;
 

	
 
			uint width = GetStringBoundingBox(this->landinfo_data[i]).width + WD_FRAMETEXT_LEFT + WD_FRAMETEXT_RIGHT;
 
			size->width = max(size->width, width);
 
			size->width = std::max(size->width, width);
 

	
 
			size->height += FONT_HEIGHT_NORMAL + WD_PAR_VSEP_NORMAL;
 
			if (i == 0) size->height += 4;
 
@@ -107,7 +107,7 @@ public:
 

	
 
		if (!StrEmpty(this->landinfo_data[LAND_INFO_MULTICENTER_LINE])) {
 
			uint width = GetStringBoundingBox(this->landinfo_data[LAND_INFO_MULTICENTER_LINE]).width + WD_FRAMETEXT_LEFT + WD_FRAMETEXT_RIGHT;
 
			size->width = max(size->width, min(300u, width));
 
			size->width = std::max(size->width, std::min(300u, width));
 
			SetDParamStr(0, this->landinfo_data[LAND_INFO_MULTICENTER_LINE]);
 
			size->height += GetStringHeight(STR_JUST_RAW_STRING, size->width - WD_FRAMETEXT_LEFT - WD_FRAMETEXT_RIGHT);
 
		}
 
@@ -510,7 +510,7 @@ struct AboutWindow : public Window {
 

	
 
		d.width = 0;
 
		for (uint i = 0; i < lengthof(_credits); i++) {
 
			d.width = max(d.width, GetStringBoundingBox(_credits[i]).width);
 
			d.width = std::max(d.width, GetStringBoundingBox(_credits[i]).width);
 
		}
 
		*size = maxdim(*size, d);
 
	}
 
@@ -706,7 +706,7 @@ struct TooltipsWindow : public Window
 
		 * Clamp value to below main toolbar and above statusbar. If tooltip would
 
		 * go below window, flip it so it is shown above the cursor */
 
		pt.y = Clamp(_cursor.pos.y + _cursor.total_size.y + _cursor.total_offs.y + 5, scr_top, scr_bot);
 
		if (pt.y + sm_height > scr_bot) pt.y = min(_cursor.pos.y + _cursor.total_offs.y - 5, scr_bot) - sm_height;
 
		if (pt.y + sm_height > scr_bot) pt.y = std::min(_cursor.pos.y + _cursor.total_offs.y - 5, scr_bot) - sm_height;
 
		pt.x = sm_width >= _screen.width ? 0 : Clamp(_cursor.pos.x - (sm_width >> 1), 0, _screen.width - sm_width);
 

	
 
		return pt;
 
@@ -717,7 +717,7 @@ struct TooltipsWindow : public Window
 
		/* There is only one widget. */
 
		for (uint i = 0; i != this->paramcount; i++) SetDParam(i, this->params[i]);
 

	
 
		size->width  = min(GetStringBoundingBox(this->string_id).width, ScaleGUITrad(194));
 
		size->width  = std::min<uint>(GetStringBoundingBox(this->string_id).width, ScaleGUITrad(194));
 
		size->height = GetStringHeight(this->string_id, size->width);
 

	
 
		/* Increase slightly to have some space around the box. */
 
@@ -817,7 +817,7 @@ void QueryString::DrawEditBox(const Wind
 
	/* We will take the current widget length as maximum width, with a small
 
	 * space reserved at the end for the caret to show */
 
	const Textbuf *tb = &this->text;
 
	int delta = min(0, (right - left) - tb->pixels - 10);
 
	int delta = std::min(0, (right - left) - tb->pixels - 10);
 

	
 
	if (tb->caretxoffs + delta < 0) delta = -tb->caretxoffs;
 

	
 
@@ -855,7 +855,7 @@ Point QueryString::GetCaretPosition(cons
 

	
 
	/* Clamp caret position to be inside out current width. */
 
	const Textbuf *tb = &this->text;
 
	int delta = min(0, (right - left) - tb->pixels - 10);
 
	int delta = std::min(0, (right - left) - tb->pixels - 10);
 
	if (tb->caretxoffs + delta < 0) delta = -tb->caretxoffs;
 

	
 
	Point pt = {left + WD_FRAMERECT_LEFT + tb->caretxoffs + delta, (int)wi->pos_y + WD_FRAMERECT_TOP};
 
@@ -888,7 +888,7 @@ Rect QueryString::GetBoundingRect(const 
 

	
 
	/* Clamp caret position to be inside our current width. */
 
	const Textbuf *tb = &this->text;
 
	int delta = min(0, (right - left) - tb->pixels - 10);
 
	int delta = std::min(0, (right - left) - tb->pixels - 10);
 
	if (tb->caretxoffs + delta < 0) delta = -tb->caretxoffs;
 

	
 
	/* Get location of first and last character. */
 
@@ -927,7 +927,7 @@ const char *QueryString::GetCharAtPositi
 

	
 
	/* Clamp caret position to be inside our current width. */
 
	const Textbuf *tb = &this->text;
 
	int delta = min(0, (right - left) - tb->pixels - 10);
 
	int delta = std::min(0, (right - left) - tb->pixels - 10);
 
	if (tb->caretxoffs + delta < 0) delta = -tb->caretxoffs;
 

	
 
	return ::GetCharAtPosition(tb->buf, pt.x - delta - left);
src/music/dmusic.cpp
Show inline comments
 
@@ -25,7 +25,6 @@
 
#include <windows.h>
 
#include <dmksctrl.h>
 
#include <dmusicc.h>
 
#include <algorithm>
 
#include <mutex>
 

	
 
#include "../safeguards.h"
src/music/midifile.cpp
Show inline comments
 
@@ -14,7 +14,6 @@
 
#include "../core/endian_func.hpp"
 
#include "../base_media_base.h"
 
#include "midi.h"
 
#include <algorithm>
 

	
 
#include "../console_func.h"
 
#include "../console_internal.h"
src/music/win32_m.cpp
Show inline comments
 
@@ -407,7 +407,7 @@ const char *MusicDriver_Win32::Start(con
 
	/* prepare multimedia timer */
 
	TIMECAPS timecaps;
 
	if (timeGetDevCaps(&timecaps, sizeof(timecaps)) == MMSYSERR_NOERROR) {
 
		_midi.time_period = min(max((UINT)resolution, timecaps.wPeriodMin), timecaps.wPeriodMax);
 
		_midi.time_period = std::min(std::max((UINT)resolution, timecaps.wPeriodMin), timecaps.wPeriodMax);
 
		if (timeBeginPeriod(_midi.time_period) == MMSYSERR_NOERROR) {
 
			/* success */
 
			DEBUG(driver, 2, "Win32-MIDI: Start: timer resolution is %d", (int)_midi.time_period);
src/music_gui.cpp
Show inline comments
 
@@ -505,7 +505,7 @@ struct MusicTrackSelectionWindow : publi
 
					SetDParam(1, 2);
 
					SetDParamStr(2, song->songname);
 
					Dimension d2 = GetStringBoundingBox(STR_PLAYLIST_TRACK_NAME);
 
					d.width = max(d.width, d2.width);
 
					d.width = std::max(d.width, d2.width);
 
					d.height += d2.height;
 
				}
 
				d.width += padding.width;
src/network/core/tcp_http.cpp
Show inline comments
 
@@ -250,8 +250,8 @@ int NetworkHTTPSocketHandler::Receive()
 

	
 
		/* Wait till we read the end-of-header identifier */
 
		if (this->recv_length == 0) {
 
			int read = this->recv_pos + res;
 
			int end = min(read, lengthof(this->recv_buffer) - 1);
 
			ssize_t read = this->recv_pos + res;
 
			ssize_t end = std::min<ssize_t>(read, lengthof(this->recv_buffer) - 1);
 

	
 
			/* Do a 'safe' search for the end of the header. */
 
			char prev = this->recv_buffer[end];
 
@@ -272,7 +272,7 @@ int NetworkHTTPSocketHandler::Receive()
 
				this->recv_length = ret;
 

	
 
				end_of_header += strlen(END_OF_HEADER);
 
				int len = min(read - (end_of_header - this->recv_buffer), res);
 
				int len = std::min(read - (end_of_header - this->recv_buffer), res);
 
				if (len != 0) {
 
					this->callback->OnReceiveData(end_of_header, len);
 
					this->recv_length -= len;
 
@@ -281,7 +281,7 @@ int NetworkHTTPSocketHandler::Receive()
 
				this->recv_pos = 0;
 
			}
 
		} else {
 
			res = min(this->recv_length, res);
 
			res = std::min<ssize_t>(this->recv_length, res);
 
			/* Receive whatever we're expecting. */
 
			this->callback->OnReceiveData(this->recv_buffer, res);
 
			this->recv_length -= res;
src/network/network_admin.cpp
Show inline comments
 
@@ -413,13 +413,13 @@ NetworkRecvStatus ServerNetworkAdminSock
 
		p->Send_uint64(company->money);
 
		p->Send_uint64(company->current_loan);
 
		p->Send_uint64(income);
 
		p->Send_uint16(min(UINT16_MAX, company->cur_economy.delivered_cargo.GetSum<OverflowSafeInt64>()));
 
		p->Send_uint16(static_cast<uint16>(std::min<uint64>(UINT16_MAX, company->cur_economy.delivered_cargo.GetSum<OverflowSafeInt64>())));
 

	
 
		/* Send stats for the last 2 quarters. */
 
		for (uint i = 0; i < 2; i++) {
 
			p->Send_uint64(company->old_economy[i].company_value);
 
			p->Send_uint16(company->old_economy[i].performance_history);
 
			p->Send_uint16(min(UINT16_MAX, company->old_economy[i].delivered_cargo.GetSum<OverflowSafeInt64>()));
 
			p->Send_uint16(static_cast<uint16>(std::min<uint64>(UINT16_MAX, company->old_economy[i].delivered_cargo.GetSum<OverflowSafeInt64>())));
 
		}
 

	
 
		this->SendPacket(p);
src/network/network_chat_gui.cpp
Show inline comments
 
@@ -154,7 +154,7 @@ void NetworkUndrawChatMessage()
 
		int width  = _chatmsg_box.width;
 
		int height = _chatmsg_box.height;
 
		if (y < 0) {
 
			height = max(height + y, min(_chatmsg_box.height, _screen.height));
 
			height = std::max(height + y, std::min(_chatmsg_box.height, _screen.height));
 
			y = 0;
 
		}
 
		if (x + width >= _screen.width) {
 
@@ -214,7 +214,7 @@ void NetworkDrawChatMessage()
 
	int width  = _chatmsg_box.width;
 
	int height = _chatmsg_box.height;
 
	if (y < 0) {
 
		height = max(height + y, min(_chatmsg_box.height, _screen.height));
 
		height = std::max(height + y, std::min(_chatmsg_box.height, _screen.height));
 
		y = 0;
 
	}
 
	if (x + width >= _screen.width) {
 
@@ -235,7 +235,7 @@ void NetworkDrawChatMessage()
 
		string_height += GetStringLineCount(STR_JUST_RAW_STRING, width - 1) * FONT_HEIGHT_NORMAL + NETWORK_CHAT_LINE_SPACING;
 
	}
 

	
 
	string_height = min(string_height, MAX_CHAT_MESSAGES * (FONT_HEIGHT_NORMAL + NETWORK_CHAT_LINE_SPACING));
 
	string_height = std::min<uint>(string_height, MAX_CHAT_MESSAGES * (FONT_HEIGHT_NORMAL + NETWORK_CHAT_LINE_SPACING));
 

	
 
	int top = _screen.height - _chatmsg_box.y - string_height - 2;
 
	int bottom = _screen.height - _chatmsg_box.y - 2;
src/network/network_client.cpp
Show inline comments
 
@@ -68,7 +68,7 @@ struct PacketReader : LoadFilter {
 
		assert(this->read_bytes == 0);
 

	
 
		size_t in_packet = p->size - p->pos;
 
		size_t to_write  = min((size_t)(this->bufe - this->buf), in_packet);
 
		size_t to_write  = std::min<size_t>(this->bufe - this->buf, in_packet);
 
		const byte *pbuf = p->buffer + p->pos;
 

	
 
		this->written_bytes += in_packet;
 
@@ -93,7 +93,7 @@ struct PacketReader : LoadFilter {
 
	size_t Read(byte *rbuf, size_t size) override
 
	{
 
		/* Limit the amount to read to whatever we still have. */
 
		size_t ret_size = size = min(this->written_bytes - this->read_bytes, size);
 
		size_t ret_size = size = std::min(this->written_bytes - this->read_bytes, size);
 
		this->read_bytes += ret_size;
 
		const byte *rbufe = rbuf + ret_size;
 

	
 
@@ -103,7 +103,7 @@ struct PacketReader : LoadFilter {
 
				this->bufe = this->buf + CHUNK;
 
			}
 

	
 
			size_t to_write = min(this->bufe - this->buf, rbufe - rbuf);
 
			size_t to_write = std::min(this->bufe - this->buf, rbufe - rbuf);
 
			memcpy(rbuf, this->buf, to_write);
 
			rbuf += to_write;
 
			this->buf += to_write;
src/network/network_content.cpp
Show inline comments
 
@@ -221,7 +221,7 @@ void ClientNetworkContentSocketHandler::
 
		 * A packet begins with the packet size and a byte for the type.
 
		 * Then this packet adds a uint16 for the count in this packet.
 
		 * The rest of the packet can be used for the IDs. */
 
		uint p_count = min(count, (SEND_MTU - sizeof(PacketSize) - sizeof(byte) - sizeof(uint16)) / sizeof(uint32));
 
		uint p_count = std::min<uint>(count, (SEND_MTU - sizeof(PacketSize) - sizeof(byte) - sizeof(uint16)) / sizeof(uint32));
 

	
 
		Packet *p = new Packet(PACKET_CONTENT_CLIENT_INFO_ID);
 
		p->Send_uint16(p_count);
 
@@ -363,7 +363,7 @@ void ClientNetworkContentSocketHandler::
 
		 * A packet begins with the packet size and a byte for the type.
 
		 * Then this packet adds a uint16 for the count in this packet.
 
		 * The rest of the packet can be used for the IDs. */
 
		uint p_count = min(count, (SEND_MTU - sizeof(PacketSize) - sizeof(byte) - sizeof(uint16)) / sizeof(uint32));
 
		uint p_count = std::min<uint>(count, (SEND_MTU - sizeof(PacketSize) - sizeof(byte) - sizeof(uint16)) / sizeof(uint32));
 

	
 
		Packet *p = new Packet(PACKET_CONTENT_CLIENT_CONTENT);
 
		p->Send_uint16(p_count);
src/network/network_content_gui.cpp
Show inline comments
 
@@ -575,7 +575,7 @@ public:
 
			}
 

	
 
			case WID_NCL_MATRIX:
 
				resize->height = max(this->checkbox_size.height, (uint)FONT_HEIGHT_NORMAL) + WD_MATRIX_TOP + WD_MATRIX_BOTTOM;
 
				resize->height = std::max(this->checkbox_size.height, (uint)FONT_HEIGHT_NORMAL) + WD_MATRIX_TOP + WD_MATRIX_BOTTOM;
 
				size->height = 10 * resize->height;
 
				break;
 
		}
 
@@ -626,7 +626,7 @@ public:
 
		const NWidgetBase *nwi_name = this->GetWidget<NWidgetBase>(WID_NCL_NAME);
 
		const NWidgetBase *nwi_type = this->GetWidget<NWidgetBase>(WID_NCL_TYPE);
 

	
 
		int line_height = max(this->checkbox_size.height, (uint)FONT_HEIGHT_NORMAL);
 
		int line_height = std::max(this->checkbox_size.height, (uint)FONT_HEIGHT_NORMAL);
 

	
 
		/* Fill the matrix with the information */
 
		int sprite_y_offset = WD_MATRIX_TOP + (line_height - this->checkbox_size.height) / 2 - 1;
 
@@ -877,7 +877,7 @@ public:
 
				break;
 
			case WKC_PAGEDOWN:
 
				/* scroll down a page */
 
				this->list_pos = min(this->list_pos + this->vscroll->GetCapacity(), (int)this->content.size() - 1);
 
				this->list_pos = std::min(this->list_pos + this->vscroll->GetCapacity(), (int)this->content.size() - 1);
 
				break;
 
			case WKC_HOME:
 
				/* jump to beginning */
src/network/network_gui.cpp
Show inline comments
 
@@ -123,7 +123,7 @@ public:
 
		/* First initialise some variables... */
 
		for (NWidgetBase *child_wid = this->head; child_wid != nullptr; child_wid = child_wid->next) {
 
			child_wid->SetupSmallestSize(w, init_array);
 
			this->smallest_y = max(this->smallest_y, child_wid->smallest_y + child_wid->padding_top + child_wid->padding_bottom);
 
			this->smallest_y = std::max(this->smallest_y, child_wid->smallest_y + child_wid->padding_top + child_wid->padding_bottom);
 
		}
 

	
 
		/* ... then in a second pass make sure the 'current' sizes are set. Won't change for most widgets. */
 
@@ -498,12 +498,12 @@ public:
 
	{
 
		switch (widget) {
 
			case WID_NG_MATRIX:
 
				resize->height = WD_MATRIX_TOP + max(GetSpriteSize(SPR_BLOT).height, (uint)FONT_HEIGHT_NORMAL) + WD_MATRIX_BOTTOM;
 
				resize->height = WD_MATRIX_TOP + std::max(GetSpriteSize(SPR_BLOT).height, (uint)FONT_HEIGHT_NORMAL) + WD_MATRIX_BOTTOM;
 
				size->height = 12 * resize->height;
 
				break;
 

	
 
			case WID_NG_LASTJOINED:
 
				size->height = WD_MATRIX_TOP + max(GetSpriteSize(SPR_BLOT).height, (uint)FONT_HEIGHT_NORMAL) + WD_MATRIX_BOTTOM;
 
				size->height = WD_MATRIX_TOP + std::max(GetSpriteSize(SPR_BLOT).height, (uint)FONT_HEIGHT_NORMAL) + WD_MATRIX_BOTTOM;
 
				break;
 

	
 
			case WID_NG_LASTJOINED_SPACER:
 
@@ -545,7 +545,7 @@ public:
 
			case WID_NG_MATRIX: {
 
				uint16 y = r.top;
 

	
 
				const int max = min(this->vscroll->GetPosition() + this->vscroll->GetCapacity(), (int)this->servers.size());
 
				const int max = std::min(this->vscroll->GetPosition() + this->vscroll->GetCapacity(), (int)this->servers.size());
 

	
 
				for (int i = this->vscroll->GetPosition(); i < max; ++i) {
 
					const NetworkGameList *ngl = this->servers[i];
 
@@ -812,7 +812,7 @@ public:
 
				case WKC_PAGEDOWN:
 
					/* scroll down a page */
 
					if (this->list_pos == SLP_INVALID) return ES_HANDLED;
 
					this->list_pos = min(this->list_pos + this->vscroll->GetCapacity(), (int)this->servers.size() - 1);
 
					this->list_pos = std::min(this->list_pos + this->vscroll->GetCapacity(), (int)this->servers.size() - 1);
 
					break;
 
				case WKC_HOME:
 
					/* jump to beginning */
 
@@ -904,7 +904,7 @@ GUIGameServerList::FilterFunction * cons
 

	
 
static NWidgetBase *MakeResizableHeader(int *biggest_index)
 
{
 
	*biggest_index = max<int>(*biggest_index, WID_NG_INFO);
 
	*biggest_index = std::max<int>(*biggest_index, WID_NG_INFO);
 
	return new NWidgetServerListHeader();
 
}
 

	
 
@@ -1861,13 +1861,13 @@ struct NetworkClientListWindow : Window 
 
	{
 
		if (widget != WID_CL_PANEL) return;
 

	
 
		this->server_client_width = max(GetStringBoundingBox(STR_NETWORK_SERVER).width, GetStringBoundingBox(STR_NETWORK_CLIENT).width) + WD_FRAMERECT_RIGHT;
 
		this->server_client_width = std::max(GetStringBoundingBox(STR_NETWORK_SERVER).width, GetStringBoundingBox(STR_NETWORK_CLIENT).width) + WD_FRAMERECT_RIGHT;
 
		this->icon_size = GetSpriteSize(SPR_COMPANY_ICON);
 
		this->line_height = max(this->icon_size.height + 2U, (uint)FONT_HEIGHT_NORMAL);
 
		this->line_height = std::max(this->icon_size.height + 2U, (uint)FONT_HEIGHT_NORMAL);
 

	
 
		uint width = 100; // Default width
 
		for (const NetworkClientInfo *ci : NetworkClientInfo::Iterate()) {
 
			width = max(width, GetStringBoundingBox(ci->client_name).width);
 
			width = std::max(width, GetStringBoundingBox(ci->client_name).width);
 
		}
 

	
 
		size->width = WD_FRAMERECT_LEFT + this->server_client_width + this->icon_size.width + WD_FRAMERECT_LEFT + width + WD_FRAMERECT_RIGHT;
 
@@ -2028,18 +2028,18 @@ struct NetworkJoinStatusWindow : Window 
 
		/* Account for the statuses */
 
		uint width = 0;
 
		for (uint i = 0; i < NETWORK_JOIN_STATUS_END; i++) {
 
			width = max(width, GetStringBoundingBox(STR_NETWORK_CONNECTING_1 + i).width);
 
			width = std::max(width, GetStringBoundingBox(STR_NETWORK_CONNECTING_1 + i).width);
 
		}
 

	
 
		/* For the number of waiting (other) players */
 
		SetDParamMaxValue(0, MAX_CLIENTS);
 
		width = max(width, GetStringBoundingBox(STR_NETWORK_CONNECTING_WAITING).width);
 
		width = std::max(width, GetStringBoundingBox(STR_NETWORK_CONNECTING_WAITING).width);
 

	
 
		/* Account for downloading ~ 10 MiB */
 
		SetDParamMaxDigits(0, 8);
 
		SetDParamMaxDigits(1, 8);
 
		width = max(width, GetStringBoundingBox(STR_NETWORK_CONNECTING_DOWNLOADING_1).width);
 
		width = max(width, GetStringBoundingBox(STR_NETWORK_CONNECTING_DOWNLOADING_2).width);
 
		width = std::max(width, GetStringBoundingBox(STR_NETWORK_CONNECTING_DOWNLOADING_1).width);
 
		width = std::max(width, GetStringBoundingBox(STR_NETWORK_CONNECTING_DOWNLOADING_2).width);
 

	
 
		/* Give a bit more clearing for the widest strings than strictly needed */
 
		size->width = width + WD_FRAMERECT_LEFT + WD_FRAMERECT_BOTTOM + 10;
src/network/network_server.cpp
Show inline comments
 
@@ -174,7 +174,7 @@ struct PacketWriter : SaveFilter {
 

	
 
		byte *bufe = buf + size;
 
		while (buf != bufe) {
 
			size_t to_write = min(SEND_MTU - this->current->size, bufe - buf);
 
			size_t to_write = std::min<size_t>(SEND_MTU - this->current->size, bufe - buf);
 
			memcpy(this->current->buffer + this->current->size, buf, to_write);
 
			this->current->size += (PacketSize)to_write;
 
			buf += to_write;
 
@@ -1807,7 +1807,7 @@ void NetworkServer_Tick(bool send_frame)
 
	for (NetworkClientSocket *cs : NetworkClientSocket::Iterate()) {
 
		/* We allow a number of bytes per frame, but only to the burst amount
 
		 * to be available for packet receiving at any particular time. */
 
		cs->receive_limit = min(cs->receive_limit + _settings_client.network.bytes_per_frame,
 
		cs->receive_limit = std::min<int>(cs->receive_limit + _settings_client.network.bytes_per_frame,
 
				_settings_client.network.bytes_per_frame_burst);
 

	
 
		/* Check if the speed of the client is what we can expect from a client */
src/network/network_udp.cpp
Show inline comments
 
@@ -263,7 +263,7 @@ void ServerNetworkUDPSocketHandler::Rece
 
		 * the current list and do not send the other data.
 
		 * The name could be an empty string, if so take the filename. */
 
		packet_len += sizeof(c.grfid) + sizeof(c.md5sum) +
 
				min(strlen(f->GetName()) + 1, (size_t)NETWORK_GRF_NAME_LENGTH);
 
				std::min(strlen(f->GetName()) + 1, (size_t)NETWORK_GRF_NAME_LENGTH);
 
		if (packet_len > SEND_MTU - 4) { // 4 is 3 byte header + grf count in reply
 
			break;
 
		}
src/newgrf.cpp
Show inline comments
 
@@ -10,7 +10,6 @@
 
#include "stdafx.h"
 

	
 
#include <stdarg.h>
 
#include <algorithm>
 

	
 
#include "debug.h"
 
#include "fileio_func.h"
 
@@ -663,7 +662,7 @@ static Engine *GetNewEngine(const GRFFil
 
			scope_grfid, // Note: this is INVALID_GRFID if dynamic_engines is disabled, so no reservation
 
			internal_id,
 
			type,
 
			static_cast<uint8>(min(internal_id, _engine_counts[type])) // substitute_id == _engine_counts[subtype] means "no substitute"
 
			std::min<uint8>(internal_id, _engine_counts[type]) // substitute_id == _engine_counts[subtype] means "no substitute"
 
	});
 

	
 
	if (engine_pool_size != Engine::GetPoolSize()) {
 
@@ -2460,7 +2459,7 @@ static ChangeInfoResult TownHouseChangeI
 
			}
 

	
 
			case 0x16: // Periodic refresh multiplier
 
				housespec->processing_time = min(buf->ReadByte(), 63);
 
				housespec->processing_time = std::min<byte>(buf->ReadByte(), 63u);
 
				break;
 

	
 
			case 0x17: // Four random colours to use
 
@@ -2642,7 +2641,7 @@ static ChangeInfoResult GlobalVarChangeI
 
				uint price = gvid + i;
 

	
 
				if (price < PR_END) {
 
					_cur.grffile->price_base_multipliers[price] = min<int>(factor - 8, MAX_PRICE_MODIFIER);
 
					_cur.grffile->price_base_multipliers[price] = std::min<int>(factor - 8, MAX_PRICE_MODIFIER);
 
				} else {
 
					grfmsg(1, "GlobalVarChangeInfo: Price %d out of range, ignoring", price);
 
				}
 
@@ -3029,7 +3028,7 @@ static ChangeInfoResult CargoChangeInfo(
 
				break;
 

	
 
			case 0x1D: // Vehicle capacity muliplier
 
				cs->multiplier = max<uint16>(1u, buf->ReadWord());
 
				cs->multiplier = std::max<uint16>(1u, buf->ReadWord());
 
				break;
 

	
 
			default:
 
@@ -3911,11 +3910,11 @@ static ChangeInfoResult AirportChangeInf
 
							}
 

	
 
							if (as->rotation[j] == DIR_E || as->rotation[j] == DIR_W) {
 
								as->size_x = max<byte>(as->size_x, att[k].ti.y + 1);
 
								as->size_y = max<byte>(as->size_y, att[k].ti.x + 1);
 
								as->size_x = std::max<byte>(as->size_x, att[k].ti.y + 1);
 
								as->size_y = std::max<byte>(as->size_y, att[k].ti.x + 1);
 
							} else {
 
								as->size_x = max<byte>(as->size_x, att[k].ti.x + 1);
 
								as->size_y = max<byte>(as->size_y, att[k].ti.y + 1);
 
								as->size_x = std::max<byte>(as->size_x, att[k].ti.x + 1);
 
								as->size_y = std::max<byte>(as->size_y, att[k].ti.y + 1);
 
							}
 
						}
 
						tile_table[j] = CallocT<AirportTileTable>(size);
 
@@ -5197,7 +5196,7 @@ static void NewSpriteGroup(ByteReader *b
 
				case GSF_AIRPORTTILES:
 
				case GSF_OBJECTS:
 
				case GSF_INDUSTRYTILES: {
 
					byte num_building_sprites = max((uint8)1, type);
 
					byte num_building_sprites = std::max((uint8)1, type);
 

	
 
					assert(TileLayoutSpriteGroup::CanAllocateItem());
 
					TileLayoutSpriteGroup *group = new TileLayoutSpriteGroup();
 
@@ -6072,7 +6071,7 @@ static uint16 SanitizeSpriteOffset(uint1
 
	if (offset + num > max_sprites) {
 
		grfmsg(4, "GraphicsNew: %s sprite overflow, truncating...", name);
 
		uint orig_num = num;
 
		num = max(max_sprites - offset, 0);
 
		num = std::max(max_sprites - offset, 0);
 
		return orig_num - num;
 
	}
 

	
 
@@ -6233,7 +6232,7 @@ bool GetGlobalVariable(byte param, uint3
 
{
 
	switch (param) {
 
		case 0x00: // current date
 
			*value = max(_date - DAYS_TILL_ORIGINAL_BASE_YEAR, 0);
 
			*value = std::max(_date - DAYS_TILL_ORIGINAL_BASE_YEAR, 0);
 
			return true;
 

	
 
		case 0x01: // current year
 
@@ -6954,7 +6953,7 @@ static uint32 GetPatchVariable(uint8 par
 
{
 
	switch (param) {
 
		/* start year - 1920 */
 
		case 0x0B: return max(_settings_game.game_creation.starting_year, ORIGINAL_BASE_YEAR) - ORIGINAL_BASE_YEAR;
 
		case 0x0B: return std::max(_settings_game.game_creation.starting_year, ORIGINAL_BASE_YEAR) - ORIGINAL_BASE_YEAR;
 

	
 
		/* freight trains weight factor */
 
		case 0x0E: return _settings_game.vehicle.freight_trains;
 
@@ -6993,7 +6992,7 @@ static uint32 GetPatchVariable(uint8 par
 
			byte map_bits = 0;
 
			byte log_X = MapLogX() - 6; // subtraction is required to make the minimal size (64) zero based
 
			byte log_Y = MapLogY() - 6;
 
			byte max_edge = max(log_X, log_Y);
 
			byte max_edge = std::max(log_X, log_Y);
 

	
 
			if (log_X == log_Y) { // we have a squared map, since both edges are identical
 
				SetBit(map_bits, 0);
 
@@ -7001,7 +7000,7 @@ static uint32 GetPatchVariable(uint8 par
 
				if (max_edge == log_Y) SetBit(map_bits, 1); // edge Y been the biggest, mark it
 
			}
 

	
 
			return (map_bits << 24) | (min(log_X, log_Y) << 20) | (max_edge << 16) |
 
			return (map_bits << 24) | (std::min(log_X, log_Y) << 20) | (max_edge << 16) |
 
				(log_X << 12) | (log_Y << 8) | (log_X + log_Y);
 
		}
 

	
 
@@ -7825,7 +7824,7 @@ static bool ChangeGRFNumUsedParams(size_
 
		grfmsg(2, "StaticGRFInfo: expected only 1 byte for 'INFO'->'NPAR' but got " PRINTF_SIZE ", ignoring this field", len);
 
		buf->Skip(len);
 
	} else {
 
		_cur.grfconfig->num_valid_params = min(buf->ReadByte(), lengthof(_cur.grfconfig->param));
 
		_cur.grfconfig->num_valid_params = std::min<byte>(buf->ReadByte(), lengthof(_cur.grfconfig->param));
 
	}
 
	return true;
 
}
 
@@ -7979,8 +7978,8 @@ static bool ChangeGRFParamMask(size_t le
 
			buf->Skip(len - 1);
 
		} else {
 
			_cur_parameter->param_nr = param_nr;
 
			if (len >= 2) _cur_parameter->first_bit = min(buf->ReadByte(), 31);
 
			if (len >= 3) _cur_parameter->num_bit = min(buf->ReadByte(), 32 - _cur_parameter->first_bit);
 
			if (len >= 2) _cur_parameter->first_bit = std::min<byte>(buf->ReadByte(), 31);
 
			if (len >= 3) _cur_parameter->num_bit = std::min<byte>(buf->ReadByte(), 32 - _cur_parameter->first_bit);
 
		}
 
	}
 

	
src/newgrf_config.cpp
Show inline comments
 
@@ -260,7 +260,7 @@ void GRFParameterInfo::SetValue(struct G
 
	} else {
 
		SB(config->param[this->param_nr], this->first_bit, this->num_bit, value);
 
	}
 
	config->num_params = max<uint>(config->num_params, this->param_nr + 1);
 
	config->num_params = std::max<uint>(config->num_params, this->param_nr + 1);
 
	SetWindowDirty(WC_GAME_OPTIONS, WN_GAME_OPTIONS_NEWGRF_STATE);
 
}
 

	
 
@@ -339,7 +339,7 @@ static bool CalcGRFMD5Sum(GRFConfig *con
 
	if (f == nullptr) return false;
 

	
 
	long start = ftell(f);
 
	size = min(size, GRFGetSizeOfDataSection(f));
 
	size = std::min(size, GRFGetSizeOfDataSection(f));
 

	
 
	if (start < 0 || fseek(f, start, SEEK_SET) < 0) {
 
		FioFCloseFile(f);
src/newgrf_debug_gui.cpp
Show inline comments
 
@@ -374,12 +374,12 @@ struct NewGRFInspectWindow : Window {
 
			case WID_NGRFI_VEH_CHAIN: {
 
				assert(this->HasChainIndex());
 
				GrfSpecFeature f = GetFeatureNum(this->window_number);
 
				size->height = max(size->height, GetVehicleImageCellSize((VehicleType)(VEH_TRAIN + (f - GSF_TRAINS)), EIT_IN_DEPOT).height + 2 + WD_BEVEL_TOP + WD_BEVEL_BOTTOM);
 
				size->height = std::max(size->height, GetVehicleImageCellSize((VehicleType)(VEH_TRAIN + (f - GSF_TRAINS)), EIT_IN_DEPOT).height + 2 + WD_BEVEL_TOP + WD_BEVEL_BOTTOM);
 
				break;
 
			}
 

	
 
			case WID_NGRFI_MAINPANEL:
 
				resize->height = max(11, FONT_HEIGHT_NORMAL + 1);
 
				resize->height = std::max(11, FONT_HEIGHT_NORMAL + 1);
 
				resize->width  = 1;
 

	
 
				size->height = 5 * resize->height + TOP_OFFSET + BOTTOM_OFFSET;
 
@@ -430,7 +430,7 @@ struct NewGRFInspectWindow : Window {
 
				int skip = 0;
 
				if (total_width > width) {
 
					int sel_center = (sel_start + sel_end) / 2;
 
					if (sel_center > width / 2) skip = min(total_width - width, sel_center - width / 2);
 
					if (sel_center > width / 2) skip = std::min(total_width - width, sel_center - width / 2);
 
				}
 

	
 
				GrfSpecFeature f = GetFeatureNum(this->window_number);
 
@@ -861,7 +861,7 @@ struct SpriteAlignerWindow : Window {
 
				size->height = ScaleGUITrad(200);
 
				break;
 
			case WID_SA_LIST:
 
				resize->height = max(11, FONT_HEIGHT_NORMAL + 1);
 
				resize->height = std::max(11, FONT_HEIGHT_NORMAL + 1);
 
				resize->width  = 1;
 
				break;
 
			default:
 
@@ -897,7 +897,7 @@ struct SpriteAlignerWindow : Window {
 
				int step_size = nwid->resize_y;
 

	
 
				std::vector<SpriteID> &list = _newgrf_debug_sprite_picker.sprites;
 
				int max = min<int>(this->vscroll->GetPosition() + this->vscroll->GetCapacity(), (uint)list.size());
 
				int max = std::min<int>(this->vscroll->GetPosition() + this->vscroll->GetCapacity(), (uint)list.size());
 

	
 
				int y = r.top + WD_FRAMERECT_TOP;
 
				for (int i = this->vscroll->GetPosition(); i < max; i++) {
src/newgrf_engine.cpp
Show inline comments
 
@@ -940,8 +940,8 @@ static uint32 VehicleGetVariable(Vehicle
 

	
 
	if (totalsets == 0) return nullptr;
 

	
 
	uint set = (v->cargo.StoredCount() * totalsets) / max((uint16)1, v->cargo_cap);
 
	set = min(set, totalsets - 1);
 
	uint set = (v->cargo.StoredCount() * totalsets) / std::max<uint16>(1u, v->cargo_cap);
 
	set = std::min(set, totalsets - 1);
 

	
 
	return in_motion ? group->loaded[set] : group->loading[set];
 
}
src/newgrf_gui.cpp
Show inline comments
 
@@ -193,8 +193,8 @@ struct NewGRFParametersWindow : public W
 
		switch (widget) {
 
			case WID_NP_NUMPAR_DEC:
 
			case WID_NP_NUMPAR_INC: {
 
				size->width  = max(SETTING_BUTTON_WIDTH / 2, FONT_HEIGHT_NORMAL);
 
				size->height = max(SETTING_BUTTON_HEIGHT, FONT_HEIGHT_NORMAL);
 
				size->width  = std::max(SETTING_BUTTON_WIDTH / 2, FONT_HEIGHT_NORMAL);
 
				size->height = std::max(SETTING_BUTTON_HEIGHT, FONT_HEIGHT_NORMAL);
 
				break;
 
			}
 

	
 
@@ -208,7 +208,7 @@ struct NewGRFParametersWindow : public W
 
			}
 

	
 
			case WID_NP_BACKGROUND:
 
				this->line_height = max(SETTING_BUTTON_HEIGHT, FONT_HEIGHT_NORMAL) + WD_MATRIX_TOP + WD_MATRIX_BOTTOM;
 
				this->line_height = std::max(SETTING_BUTTON_HEIGHT, FONT_HEIGHT_NORMAL) + WD_MATRIX_TOP + WD_MATRIX_BOTTOM;
 

	
 
				resize->width = 1;
 
				resize->height = this->line_height;
 
@@ -721,25 +721,25 @@ struct NewGRFWindow : public Window, New
 
			case WID_NS_FILE_LIST:
 
			{
 
				Dimension d = maxdim(GetSpriteSize(SPR_SQUARE), GetSpriteSize(SPR_WARNING_SIGN));
 
				resize->height = max(d.height + 2U, FONT_HEIGHT_NORMAL + 2U);
 
				size->height = max(size->height, WD_FRAMERECT_TOP + 6 * resize->height + WD_FRAMERECT_BOTTOM);
 
				resize->height = std::max(d.height + 2U, FONT_HEIGHT_NORMAL + 2U);
 
				size->height = std::max(size->height, WD_FRAMERECT_TOP + 6 * resize->height + WD_FRAMERECT_BOTTOM);
 
				break;
 
			}
 

	
 
			case WID_NS_AVAIL_LIST:
 
				resize->height = max(12, FONT_HEIGHT_NORMAL + 2);
 
				size->height = max(size->height, WD_FRAMERECT_TOP + 8 * resize->height + WD_FRAMERECT_BOTTOM);
 
				resize->height = std::max(12, FONT_HEIGHT_NORMAL + 2);
 
				size->height = std::max(size->height, WD_FRAMERECT_TOP + 8 * resize->height + WD_FRAMERECT_BOTTOM);
 
				break;
 

	
 
			case WID_NS_NEWGRF_INFO_TITLE: {
 
				Dimension dim = GetStringBoundingBox(STR_NEWGRF_SETTINGS_INFO_TITLE);
 
				size->height = max(size->height, dim.height + WD_FRAMETEXT_TOP + WD_FRAMETEXT_BOTTOM);
 
				size->width  = max(size->width,  dim.width  + WD_FRAMETEXT_LEFT + WD_FRAMETEXT_RIGHT);
 
				size->height = std::max(size->height, dim.height + WD_FRAMETEXT_TOP + WD_FRAMETEXT_BOTTOM);
 
				size->width  = std::max(size->width,  dim.width  + WD_FRAMETEXT_LEFT + WD_FRAMETEXT_RIGHT);
 
				break;
 
			}
 

	
 
			case WID_NS_NEWGRF_INFO:
 
				size->height = max(size->height, WD_FRAMERECT_TOP + 10 * FONT_HEIGHT_NORMAL + WD_FRAMERECT_BOTTOM + padding.height + 2);
 
				size->height = std::max(size->height, WD_FRAMERECT_TOP + 10 * FONT_HEIGHT_NORMAL + WD_FRAMERECT_BOTTOM + padding.height + 2);
 
				break;
 

	
 
			case WID_NS_PRESET_LIST: {
 
@@ -877,7 +877,7 @@ struct NewGRFWindow : public Window, New
 
				int offset_y = (step_height - FONT_HEIGHT_NORMAL) / 2;
 
				uint y = r.top + WD_FRAMERECT_TOP;
 
				uint min_index = this->vscroll2->GetPosition();
 
				uint max_index = min(min_index + this->vscroll2->GetCapacity(), (uint)this->avails.size());
 
				uint max_index = std::min(min_index + this->vscroll2->GetCapacity(), (uint)this->avails.size());
 

	
 
				for (uint i = min_index; i < max_index; i++) {
 
					const GRFConfig *c = this->avails[i];
 
@@ -1311,7 +1311,7 @@ struct NewGRFWindow : public Window, New
 

	
 
			case WKC_PAGEDOWN:
 
				/* scroll down a page */
 
				this->avail_pos = min(this->avail_pos + this->vscroll2->GetCapacity(), (int)this->avails.size() - 1);
 
				this->avail_pos = std::min(this->avail_pos + this->vscroll2->GetCapacity(), (int)this->avails.size() - 1);
 
				break;
 

	
 
			case WKC_HOME:
 
@@ -1363,7 +1363,7 @@ struct NewGRFWindow : public Window, New
 
				for (from_prev = &this->actives; *from_prev != this->active_sel; from_prev = &(*from_prev)->next, from_pos++) {}
 

	
 
				/* Gets the drag-and-drop destination offset. Ignore the last dummy line. */
 
				int to_pos = min(this->vscroll->GetScrolledRowFromWidget(pt.y, this, WID_NS_FILE_LIST), this->vscroll->GetCount() - 2);
 
				int to_pos = std::min(this->vscroll->GetScrolledRowFromWidget(pt.y, this, WID_NS_FILE_LIST), this->vscroll->GetCount() - 2);
 
				if (to_pos != from_pos) { // Don't move NewGRF file over itself.
 
					/* Get pointer to destination position. */
 
					GRFConfig **to_prev = &this->actives;
 
@@ -1381,7 +1381,7 @@ struct NewGRFWindow : public Window, New
 
					this->InvalidateData();
 
				}
 
			} else if (this->avail_sel != nullptr) {
 
				int to_pos = min(this->vscroll->GetScrolledRowFromWidget(pt.y, this, WID_NS_FILE_LIST), this->vscroll->GetCount() - 1);
 
				int to_pos = std::min(this->vscroll->GetScrolledRowFromWidget(pt.y, this, WID_NS_FILE_LIST), this->vscroll->GetCount() - 1);
 
				this->AddGRFToActive(to_pos);
 
			}
 
		} else if (widget == WID_NS_AVAIL_LIST && this->active_sel != nullptr) {
 
@@ -1407,7 +1407,7 @@ struct NewGRFWindow : public Window, New
 
			/* An NewGRF file is dragged over the active list. */
 
			int to_pos = this->vscroll->GetScrolledRowFromWidget(pt.y, this, WID_NS_FILE_LIST);
 
			/* Skip the last dummy line if the source is from the active list. */
 
			to_pos = min(to_pos, this->vscroll->GetCount() - (this->active_sel != nullptr ? 2 : 1));
 
			to_pos = std::min(to_pos, this->vscroll->GetCount() - (this->active_sel != nullptr ? 2 : 1));
 

	
 
			if (to_pos != this->active_over) {
 
				this->active_over = to_pos;
 
@@ -1620,8 +1620,8 @@ public:
 
		uint min_inf_height = this->inf->smallest_y + this->inf->padding_top + this->inf->padding_bottom;
 

	
 
		/* Smallest window is in two column mode. */
 
		this->smallest_x = max(min_avs_width, min_acs_width) + INTER_COLUMN_SPACING + min_inf_width;
 
		this->smallest_y = max(min_inf_height, min_acs_height + INTER_LIST_SPACING + min_avs_height);
 
		this->smallest_x = std::max(min_avs_width, min_acs_width) + INTER_COLUMN_SPACING + min_inf_width;
 
		this->smallest_y = std::max(min_inf_height, min_acs_height + INTER_LIST_SPACING + min_avs_height);
 

	
 
		/* Filling. */
 
		this->fill_x = LeastCommonMultiple(this->avs->fill_x, this->acs->fill_x);
 
@@ -1651,7 +1651,7 @@ public:
 
		uint min_acs_width = this->acs->smallest_x + this->acs->padding_left + this->acs->padding_right;
 
		uint min_inf_width = this->inf->smallest_x + this->inf->padding_left + this->inf->padding_right;
 

	
 
		uint min_list_width = max(min_avs_width, min_acs_width); // Smallest width of the lists such that they have equal width (incl padding).
 
		uint min_list_width = std::max(min_avs_width, min_acs_width); // Smallest width of the lists such that they have equal width (incl padding).
 
		uint avs_extra_width = min_list_width - min_avs_width;   // Additional width needed for avs to reach min_list_width.
 
		uint acs_extra_width = min_list_width - min_acs_width;   // Additional width needed for acs to reach min_list_width.
 

	
 
@@ -1664,10 +1664,10 @@ public:
 
		uint extra_width, inf_width;
 
		if (use_three_columns) {
 
			extra_width = given_width - min_three_columns;
 
			inf_width = min(MAX_EXTRA_INFO_WIDTH, extra_width / 2);
 
			inf_width = std::min(MAX_EXTRA_INFO_WIDTH, extra_width / 2);
 
		} else {
 
			extra_width = given_width - min_two_columns;
 
			inf_width = min(MAX_EXTRA_INFO_WIDTH, extra_width / 2);
 
			inf_width = std::min(MAX_EXTRA_INFO_WIDTH, extra_width / 2);
 
		}
 
		inf_width = ComputeMaxSize(this->inf->smallest_x, this->inf->smallest_x + inf_width, this->inf->GetHorizontalStepSize(sizing));
 
		extra_width -= inf_width - this->inf->smallest_x;
 
@@ -1677,9 +1677,9 @@ public:
 
		if (use_three_columns) {
 
			/* Three column display, first make both lists equally wide, then divide whatever is left between both lists.
 
			 * Only keep track of what avs gets, all other space goes to acs. */
 
			uint avs_width = min(avs_extra_width, extra_width);
 
			uint avs_width = std::min(avs_extra_width, extra_width);
 
			extra_width -= avs_width;
 
			extra_width -= min(acs_extra_width, extra_width);
 
			extra_width -= std::min(acs_extra_width, extra_width);
 
			avs_width += extra_width / 2;
 

	
 
			avs_width = ComputeMaxSize(this->avs->smallest_x, this->avs->smallest_x + avs_width, this->avs->GetHorizontalStepSize(sizing));
 
@@ -1754,7 +1754,7 @@ public:
 
				}
 
				uint dx = this->acs->current_x + this->acs->padding_left + this->acs->padding_right;
 
				if (this->editable) {
 
					dx = max(dx, this->avs->current_x + this->avs->padding_left + this->avs->padding_right);
 
					dx = std::max(dx, this->avs->current_x + this->avs->padding_left + this->avs->padding_right);
 
				}
 
				x += dx + INTER_COLUMN_SPACING + this->inf->padding_left;
 
				this->inf->AssignSizePosition(sizing, x, y + this->inf->padding_top, inf_width, inf_height, rtl);
 
@@ -1914,10 +1914,10 @@ NWidgetBase* NewGRFDisplay(int *biggest_
 

	
 
	int biggest2;
 
	NWidgetBase *acs = MakeNWidgets(_nested_newgrf_actives_widgets, lengthof(_nested_newgrf_actives_widgets), &biggest2, nullptr);
 
	*biggest_index = max(*biggest_index, biggest2);
 
	*biggest_index = std::max(*biggest_index, biggest2);
 

	
 
	NWidgetBase *inf = MakeNWidgets(_nested_newgrf_infopanel_widgets, lengthof(_nested_newgrf_infopanel_widgets), &biggest2, nullptr);
 
	*biggest_index = max(*biggest_index, biggest2);
 
	*biggest_index = std::max(*biggest_index, biggest2);
 

	
 
	return new NWidgetNewGRFDisplay(avs, acs, inf);
 
}
 
@@ -2077,8 +2077,8 @@ struct SavePresetWindow : public Window 
 
				size->height = 0;
 
				for (uint i = 0; i < this->presets.size(); i++) {
 
					Dimension d = GetStringBoundingBox(this->presets[i].c_str());
 
					size->width = max(size->width, d.width + WD_FRAMETEXT_LEFT + WD_FRAMETEXT_RIGHT);
 
					resize->height = max(resize->height, d.height);
 
					size->width = std::max(size->width, d.width + WD_FRAMETEXT_LEFT + WD_FRAMETEXT_RIGHT);
 
					resize->height = std::max(resize->height, d.height);
 
				}
 
				size->height = ClampU((uint)this->presets.size(), 5, 20) * resize->height + 1;
 
				break;
 
@@ -2096,7 +2096,7 @@ struct SavePresetWindow : public Window 
 
				int offset_y = (step_height - FONT_HEIGHT_NORMAL) / 2;
 
				uint y = r.top + WD_FRAMERECT_TOP;
 
				uint min_index = this->vscroll->GetPosition();
 
				uint max_index = min(min_index + this->vscroll->GetCapacity(), (uint)this->presets.size());
 
				uint max_index = std::min(min_index + this->vscroll->GetCapacity(), (uint)this->presets.size());
 

	
 
				for (uint i = min_index; i < max_index; i++) {
 
					if ((int)i == this->selected) GfxFillRect(r.left + 1, y, r.right - 1, y + step_height - 2, PC_DARK_BLUE);
 
@@ -2209,7 +2209,7 @@ struct ScanProgressWindow : public Windo
 
				SetDParamMaxDigits(1, 4);
 
				/* We really don't know the width. We could determine it by scanning the NewGRFs,
 
				 * but this is the status window for scanning them... */
 
				size->width = max(400U, GetStringBoundingBox(STR_NEWGRF_SCAN_STATUS).width);
 
				size->width = std::max(400U, GetStringBoundingBox(STR_NEWGRF_SCAN_STATUS).width);
 
				size->height = FONT_HEIGHT_NORMAL * 2 + WD_PAR_VSEP_NORMAL;
 
				break;
 
		}
 
@@ -2221,7 +2221,7 @@ struct ScanProgressWindow : public Windo
 
			case WID_SP_PROGRESS_BAR: {
 
				/* Draw the % complete with a bar and a text */
 
				DrawFrameRect(r.left, r.top, r.right, r.bottom, COLOUR_GREY, FR_BORDERONLY);
 
				uint percent = scanned * 100 / max(1U, _settings_client.gui.last_newgrf_count);
 
				uint percent = scanned * 100 / std::max(1U, _settings_client.gui.last_newgrf_count);
 
				DrawFrameRect(r.left + 1, r.top + 1, (int)((r.right - r.left - 2) * percent / 100) + r.left + 1, r.bottom - 1, COLOUR_MAUVE, FR_NONE);
 
				SetDParam(0, percent);
 
				DrawString(r.left, r.right, r.top + 5, STR_GENERATION_PROGRESS, TC_FROMSTRING, SA_HOR_CENTER);
src/newgrf_industries.cpp
Show inline comments
 
@@ -94,7 +94,7 @@ static uint32 GetClosestIndustry(TileInd
 
	for (const Industry *i : Industry::Iterate()) {
 
		if (i->type != type || i == current) continue;
 

	
 
		best_dist = min(best_dist, DistanceManhattan(tile, i->location.tile));
 
		best_dist = std::min(best_dist, DistanceManhattan(tile, i->location.tile));
 
	}
 

	
 
	return best_dist;
 
@@ -140,13 +140,13 @@ static uint32 GetCountAndDistanceOfClose
 
		/* If the filter is 0, it could be because none was specified as well as being really a 0.
 
		 * In either case, just do the regular var67 */
 
		closest_dist = GetClosestIndustry(current->location.tile, ind_index, current);
 
		count = min(Industry::GetIndustryTypeCount(ind_index), UINT8_MAX); // clamp to 8 bit
 
		count = std::min<uint>(Industry::GetIndustryTypeCount(ind_index), UINT8_MAX); // clamp to 8 bit
 
	} else {
 
		/* Count only those who match the same industry type and layout filter
 
		 * Unfortunately, we have to do it manually */
 
		for (const Industry *i : Industry::Iterate()) {
 
			if (i->type == ind_index && i != current && (i->selected_layout == layout_filter || layout_filter == 0) && (!town_filter || i->town == current->town)) {
 
				closest_dist = min(closest_dist, DistanceManhattan(current->location.tile, i->location.tile));
 
				closest_dist = std::min(closest_dist, DistanceManhattan(current->location.tile, i->location.tile));
 
				count++;
 
			}
 
		}
 
@@ -180,7 +180,7 @@ static uint32 GetCountAndDistanceOfClose
 
			case 0x88: return GetTownRadiusGroup(this->industry->town, this->tile);
 

	
 
			/* Manhattan distance of the closest town */
 
			case 0x89: return min(DistanceManhattan(this->industry->town->xy, this->tile), 255);
 
			case 0x89: return std::min(DistanceManhattan(this->industry->town->xy, this->tile), 255u);
 

	
 
			/* Lowest height of the tile */
 
			case 0x8A: return Clamp(GetTileZ(this->tile) * (this->ro.grffile->grf_version >= 8 ? 1 : TILE_HEIGHT), 0, 0xFF);
 
@@ -189,7 +189,7 @@ static uint32 GetCountAndDistanceOfClose
 
			case 0x8B: return GetClosestWaterDistance(this->tile, (GetIndustrySpec(this->industry->type)->behaviour & INDUSTRYBEH_BUILT_ONWATER) == 0);
 

	
 
			/* Square of Euclidian distance from town */
 
			case 0x8D: return min(DistanceSquare(this->industry->town->xy, this->tile), 65535);
 
			case 0x8D: return std::min(DistanceSquare(this->industry->town->xy, this->tile), 65535u);
 

	
 
			/* 32 random bits */
 
			case 0x8F: return this->random_bits;
 
@@ -213,9 +213,9 @@ static uint32 GetCountAndDistanceOfClose
 
			if (HasBit(callback, CBM_IND_PRODUCTION_CARGO_ARRIVAL) || HasBit(callback, CBM_IND_PRODUCTION_256_TICKS)) {
 
				if ((indspec->behaviour & INDUSTRYBEH_PROD_MULTI_HNDLING) != 0) {
 
					if (this->industry->prod_level == 0) return 0;
 
					return min(this->industry->incoming_cargo_waiting[variable - 0x40] / this->industry->prod_level, (uint16)0xFFFF);
 
					return std::min<uint16>(this->industry->incoming_cargo_waiting[variable - 0x40] / this->industry->prod_level, 0xFFFFu);
 
				} else {
 
					return min(this->industry->incoming_cargo_waiting[variable - 0x40], (uint16)0xFFFF);
 
					return std::min<uint16>(this->industry->incoming_cargo_waiting[variable - 0x40], 0xFFFFu);
 
				}
 
			} else {
 
				return 0;
 
@@ -283,11 +283,11 @@ static uint32 GetCountAndDistanceOfClose
 
		/* Get town zone and Manhattan distance of closest town */
 
		case 0x65:
 
			if (this->tile == INVALID_TILE) break;
 
			return GetTownRadiusGroup(this->industry->town, this->tile) << 16 | min(DistanceManhattan(this->tile, this->industry->town->xy), 0xFFFF);
 
			return GetTownRadiusGroup(this->industry->town, this->tile) << 16 | std::min(DistanceManhattan(this->tile, this->industry->town->xy), 0xFFFFu);
 
		/* Get square of Euclidian distance of closes town */
 
		case 0x66:
 
			if (this->tile == INVALID_TILE) break;
 
			return GetTownRadiusGroup(this->industry->town, this->tile) << 16 | min(DistanceSquare(this->tile, this->industry->town->xy), 0xFFFF);
 
			return GetTownRadiusGroup(this->industry->town, this->tile) << 16 | std::min(DistanceSquare(this->tile, this->industry->town->xy), 0xFFFFu);
 

	
 
		/* Count of industry, distance of closest instance
 
		 * 68 is the same as 67, but with a filtering on selected layout */
 
@@ -639,7 +639,7 @@ void IndustryProductionCallback(Industry
 
				ind->incoming_cargo_waiting[i] = Clamp(ind->incoming_cargo_waiting[i] - DerefIndProd(group->subtract_input[i], deref) * multiplier, 0, 0xFFFF);
 
			}
 
			for (uint i = 0; i < group->num_output; i++) {
 
				ind->produced_cargo_waiting[i] = Clamp(ind->produced_cargo_waiting[i] + max(DerefIndProd(group->add_output[i], deref), 0) * multiplier, 0, 0xFFFF);
 
				ind->produced_cargo_waiting[i] = Clamp(ind->produced_cargo_waiting[i] + std::max(DerefIndProd(group->add_output[i], deref), 0) * multiplier, 0, 0xFFFF);
 
			}
 
		} else {
 
			/* Callback receives list of cargos to apply for, which need to have their cargo slots in industry looked up */
 
@@ -651,7 +651,7 @@ void IndustryProductionCallback(Industry
 
			for (uint i = 0; i < group->num_output; i++) {
 
				int cargo_index = ind->GetCargoProducedIndex(group->cargo_output[i]);
 
				if (cargo_index < 0) continue;
 
				ind->produced_cargo_waiting[cargo_index] = Clamp(ind->produced_cargo_waiting[cargo_index] + max(DerefIndProd(group->add_output[i], deref), 0) * multiplier, 0, 0xFFFF);
 
				ind->produced_cargo_waiting[cargo_index] = Clamp(ind->produced_cargo_waiting[cargo_index] + std::max(DerefIndProd(group->add_output[i], deref), 0) * multiplier, 0, 0xFFFF);
 
			}
 
		}
 

	
src/newgrf_object.cpp
Show inline comments
 
@@ -189,7 +189,7 @@ static uint32 GetClosestObject(TileIndex
 
	for (const Object *o : Object::Iterate()) {
 
		if (o->type != type || o == current) continue;
 

	
 
		best_dist = min(best_dist, DistanceManhattan(tile, o->location.tile));
 
		best_dist = std::min(best_dist, DistanceManhattan(tile, o->location.tile));
 
	}
 

	
 
	return best_dist;
 
@@ -226,7 +226,7 @@ static uint32 GetCountAndDistanceOfClose
 
	/* If the object type is invalid, there is none and the closest is far away. */
 
	if (idx >= NUM_OBJECTS) return 0 | 0xFFFF;
 

	
 
	return Object::GetTypeCount(idx) << 16 | min(GetClosestObject(tile, idx, current), 0xFFFF);
 
	return Object::GetTypeCount(idx) << 16 | std::min(GetClosestObject(tile, idx, current), 0xFFFFu);
 
}
 

	
 
/** Used by the resolver to get values for feature 0F deterministic spritegroups. */
 
@@ -301,10 +301,10 @@ static uint32 GetCountAndDistanceOfClose
 
		case 0x44: return GetTileOwner(this->tile);
 

	
 
		/* Get town zone and Manhattan distance of closest town */
 
		case 0x45: return GetTownRadiusGroup(t, this->tile) << 16 | min(DistanceManhattan(this->tile, t->xy), 0xFFFF);
 
		case 0x45: return GetTownRadiusGroup(t, this->tile) << 16 | std::min(DistanceManhattan(this->tile, t->xy), 0xFFFFu);
 

	
 
		/* Get square of Euclidian distance of closes town */
 
		case 0x46: return GetTownRadiusGroup(t, this->tile) << 16 | min(DistanceSquare(this->tile, t->xy), 0xFFFF);
 
		case 0x46: return GetTownRadiusGroup(t, this->tile) << 16 | std::min(DistanceSquare(this->tile, t->xy), 0xFFFFu);
 

	
 
		/* Object colour */
 
		case 0x47: return this->obj->colour;
src/newgrf_profiling.cpp
Show inline comments
 
@@ -148,7 +148,7 @@ uint32 NewGRFProfiler::FinishAll()
 
	for (NewGRFProfiler &pr : _newgrf_profilers) {
 
		if (pr.active) {
 
			total_microseconds += pr.Finish();
 
			max_ticks = max(max_ticks, _tick_counter - pr.start_tick);
 
			max_ticks = std::max(max_ticks, _tick_counter - pr.start_tick);
 
		}
 
	}
 

	
src/newgrf_spritegroup.cpp
Show inline comments
 
@@ -8,7 +8,6 @@
 
/** @file newgrf_spritegroup.cpp Handling of primarily NewGRF action 2. */
 

	
 
#include "stdafx.h"
 
#include <algorithm>
 
#include "debug.h"
 
#include "newgrf_spritegroup.h"
 
#include "newgrf_profiling.h"
 
@@ -173,10 +172,10 @@ static U EvalAdjustT(const Deterministic
 
	switch (adjust->operation) {
 
		case DSGA_OP_ADD:  return last_value + value;
 
		case DSGA_OP_SUB:  return last_value - value;
 
		case DSGA_OP_SMIN: return min((S)last_value, (S)value);
 
		case DSGA_OP_SMAX: return max((S)last_value, (S)value);
 
		case DSGA_OP_UMIN: return min((U)last_value, (U)value);
 
		case DSGA_OP_UMAX: return max((U)last_value, (U)value);
 
		case DSGA_OP_SMIN: return std::min<S>(last_value, value);
 
		case DSGA_OP_SMAX: return std::max<S>(last_value, value);
 
		case DSGA_OP_UMIN: return std::min<U>(last_value, value);
 
		case DSGA_OP_UMAX: return std::max<U>(last_value, value);
 
		case DSGA_OP_SDIV: return value == 0 ? (S)last_value : (S)last_value / (S)value;
 
		case DSGA_OP_SMOD: return value == 0 ? (S)last_value : (S)last_value % (S)value;
 
		case DSGA_OP_UDIV: return value == 0 ? (U)last_value : (U)last_value / (U)value;
src/newgrf_station.cpp
Show inline comments
 
@@ -119,13 +119,13 @@ uint32 GetPlatformInfo(Axis axis, byte t
 
		SB(retval,  0, 4, y & 0xF);
 
		SB(retval,  4, 4, x & 0xF);
 
	} else {
 
		SB(retval,  0, 4, min(15, y));
 
		SB(retval,  4, 4, min(15, length - y - 1));
 
		SB(retval,  8, 4, min(15, x));
 
		SB(retval, 12, 4, min(15, platforms - x - 1));
 
		SB(retval,  0, 4, std::min(15, y));
 
		SB(retval,  4, 4, std::min(15, length - y - 1));
 
		SB(retval,  8, 4, std::min(15, x));
 
		SB(retval, 12, 4, std::min(15, platforms - x - 1));
 
	}
 
	SB(retval, 16, 4, min(15, length));
 
	SB(retval, 20, 4, min(15, platforms));
 
	SB(retval, 16, 4, std::min(15, length));
 
	SB(retval, 20, 4, std::min(15, platforms));
 
	SB(retval, 24, 4, tile);
 

	
 
	return retval;
 
@@ -424,7 +424,7 @@ uint32 Station::GetNewGRFVariable(const 
 
		const GoodsEntry *ge = &this->goods[c];
 

	
 
		switch (variable) {
 
			case 0x60: return min(ge->cargo.TotalCount(), 4095);
 
			case 0x60: return std::min(ge->cargo.TotalCount(), 4095u);
 
			case 0x61: return ge->HasVehicleEverTriedLoading() ? ge->time_since_pickup : 0;
 
			case 0x62: return ge->HasRating() ? ge->rating : 0xFFFFFFFF;
 
			case 0x63: return ge->cargo.DaysInTransit();
 
@@ -444,7 +444,7 @@ uint32 Station::GetNewGRFVariable(const 
 
		const GoodsEntry *g = &this->goods[GB(variable - 0x8C, 3, 4)];
 
		switch (GB(variable - 0x8C, 0, 3)) {
 
			case 0: return g->cargo.TotalCount();
 
			case 1: return GB(min(g->cargo.TotalCount(), 4095), 0, 4) | (GB(g->status, GoodsEntry::GES_ACCEPTANCE, 1) << 7);
 
			case 1: return GB(std::min(g->cargo.TotalCount(), 4095u), 0, 4) | (GB(g->status, GoodsEntry::GES_ACCEPTANCE, 1) << 7);
 
			case 2: return g->time_since_pickup;
 
			case 3: return g->rating;
 
			case 4: return g->cargo.Source();
 
@@ -520,7 +520,7 @@ uint32 Waypoint::GetNewGRFVariable(const
 
	}
 

	
 
	if (HasBit(this->station_scope.statspec->flags, SSF_DIV_BY_STATION_SIZE)) cargo /= (st->train_station.w + st->train_station.h);
 
	cargo = min(0xfff, cargo);
 
	cargo = std::min(0xfffu, cargo);
 

	
 
	if (cargo > this->station_scope.statspec->cargo_threshold) {
 
		if (group->num_loading > 0) {
src/newgrf_text.cpp
Show inline comments
 
@@ -17,7 +17,6 @@
 

	
 
#include "stdafx.h"
 

	
 
#include <algorithm>
 
#include <array>
 

	
 
#include "newgrf.h"
 
@@ -179,7 +178,7 @@ struct UnmappedChoiceList {
 
				*d++ = i + 1;
 

	
 
				/* "<LENn>": Limit the length of the string to 0xFFFE to leave space for the '\0'. */
 
				size_t len = min<size_t>(0xFFFE, str.size());
 
				size_t len = std::min<size_t>(0xFFFE, str.size());
 
				*d++ = GB(len + 1, 8, 8);
 
				*d++ = GB(len + 1, 0, 8);
 

	
 
@@ -222,7 +221,7 @@ struct UnmappedChoiceList {
 
				const auto &str = this->strings[this->strings.find(idx) != this->strings.end() ? idx : 0].str();
 
				/* Limit the length of the string we copy to 0xFE. The length is written above
 
				 * as a byte and we need room for the final '\0'. */
 
				size_t len = min<size_t>(0xFE, str.size());
 
				size_t len = std::min<size_t>(0xFE, str.size());
 
				dest.write(str.c_str(), len);
 
				*d++ = '\0';
 
			}
 
@@ -936,7 +935,7 @@ uint RemapNewGRFStringControlCode(uint s
 

	
 
			case SCC_NEWGRF_ROTATE_TOP_4_WORDS:     _newgrf_textrefstack.RotateTop4Words(); break;
 
			case SCC_NEWGRF_PUSH_WORD:              _newgrf_textrefstack.PushWord(Utf8Consume(str)); break;
 
			case SCC_NEWGRF_UNPRINT:                *buff = max(*buff - Utf8Consume(str), buf_start); break;
 
			case SCC_NEWGRF_UNPRINT:                *buff = std::max(*buff - Utf8Consume(str), buf_start); break;
 

	
 
			case SCC_NEWGRF_PRINT_WORD_CARGO_LONG:
 
			case SCC_NEWGRF_PRINT_WORD_CARGO_SHORT:
src/news_gui.cpp
Show inline comments
 
@@ -538,7 +538,7 @@ struct NewsWindow : Window {
 
		int count = this->timer.CountElapsed(delta_ms);
 
		if (count > 0) {
 
			/* Scroll up newsmessages from the bottom */
 
			int newtop = max(this->top - 2 * count, _screen.height - this->height - this->status_height - this->chat_height);
 
			int newtop = std::max(this->top - 2 * count, _screen.height - this->height - this->status_height - this->chat_height);
 
			this->SetWindowTop(newtop);
 
		}
 

	
 
@@ -556,8 +556,8 @@ private:
 
	{
 
		if (this->top == newtop) return;
 

	
 
		int mintop = min(newtop, this->top);
 
		int maxtop = max(newtop, this->top);
 
		int mintop = std::min(newtop, this->top);
 
		int maxtop = std::max(newtop, this->top);
 
		if (this->viewport != nullptr) this->viewport->top += newtop - this->top;
 
		this->top = newtop;
 

	
 
@@ -1148,7 +1148,7 @@ struct MessageHistoryWindow : Window {
 
			this->date_width = GetStringBoundingBox(STR_SHORT_DATE).width;
 

	
 
			size->height = 4 * resize->height + this->top_spacing + this->bottom_spacing; // At least 4 lines are visible.
 
			size->width = max(200u, size->width); // At least 200 pixels wide.
 
			size->width = std::max(200u, size->width); // At least 200 pixels wide.
 
		}
 
	}
 

	
src/object_cmd.cpp
Show inline comments
 
@@ -552,14 +552,14 @@ static void AddAcceptedCargo_Object(Tile
 

	
 
	/* Top town building generates 10, so to make HQ interesting, the top
 
	 * type makes 20. */
 
	acceptance[CT_PASSENGERS] += max(1U, level);
 
	acceptance[CT_PASSENGERS] += std::max(1U, level);
 
	SetBit(*always_accepted, CT_PASSENGERS);
 

	
 
	/* Top town building generates 4, HQ can make up to 8. The
 
	 * proportion passengers:mail is different because such a huge
 
	 * commercial building generates unusually high amount of mail
 
	 * correspondence per physical visitor. */
 
	acceptance[CT_MAIL] += max(1U, level / 2);
 
	acceptance[CT_MAIL] += std::max(1U, level / 2);
 
	SetBit(*always_accepted, CT_MAIL);
 
}
 

	
src/object_gui.cpp
Show inline comments
 
@@ -125,7 +125,7 @@ public:
 
				for (uint i = 0; i < ObjectClass::GetClassCount(); i++) {
 
					ObjectClass *objclass = ObjectClass::Get((ObjectClassID)i);
 
					if (objclass->GetUISpecCount() == 0) continue;
 
					size->width = max(size->width, GetStringBoundingBox(objclass->name).width);
 
					size->width = std::max(size->width, GetStringBoundingBox(objclass->name).width);
 
				}
 
				size->width += padding.width;
 
				this->line_height = FONT_HEIGHT_NORMAL + WD_MATRIX_TOP + WD_MATRIX_BOTTOM;
 
@@ -161,7 +161,7 @@ public:
 
					const ObjectSpec *spec = ObjectSpec::Get(i);
 
					if (!spec->IsEverAvailable()) continue;
 
					two_wide |= spec->views >= 2;
 
					height[spec->views / 4] = max<int>(ObjectSpec::Get(i)->height, height[spec->views / 4]);
 
					height[spec->views / 4] = std::max<int>(ObjectSpec::Get(i)->height, height[spec->views / 4]);
 
				}
 

	
 
				/* Determine the pixel heights. */
 
@@ -174,7 +174,7 @@ public:
 
				 * we want these columns to be slightly less wide. When there are two rows, then
 
				 * determine the size of the widgets based on the maximum size for a single row
 
				 * of widgets, or just the twice the widget height of the two row ones. */
 
				size->height = max(height[0], height[1] * 2 + 2);
 
				size->height = std::max(height[0], height[1] * 2 + 2);
 
				if (two_wide) {
 
					size->width  = (3 * ScaleGUITrad(TILE_PIXELS) + 2 * OBJECT_MARGIN) * 2 + 2;
 
				} else {
 
@@ -274,7 +274,7 @@ public:
 
						DrawOrigTileSeqInGUI((r.right - r.left) / 2 - 1, r.bottom - r.top - OBJECT_MARGIN - ScaleGUITrad(TILE_PIXELS), dts, PAL_NONE);
 
					} else {
 
						DrawNewObjectTileInGUI((r.right - r.left) / 2 - 1, r.bottom - r.top - OBJECT_MARGIN - ScaleGUITrad(TILE_PIXELS), spec,
 
								min(_selected_object_view, spec->views - 1));
 
								std::min<int>(_selected_object_view, spec->views - 1));
 
					}
 
					_cur_dpi = old_dpi;
 
				}
 
@@ -332,7 +332,7 @@ public:
 
		_selected_object_index = object_index;
 
		if (_selected_object_index != -1) {
 
			const ObjectSpec *spec = ObjectClass::Get(_selected_object_class)->GetSpec(_selected_object_index);
 
			_selected_object_view = min(_selected_object_view, spec->views - 1);
 
			_selected_object_view = std::min<int>(_selected_object_view, spec->views - 1);
 
			this->ReInit();
 
		} else {
 
			_selected_object_view = 0;
src/openttd.cpp
Show inline comments
 
@@ -290,8 +290,8 @@ static void ParseResolution(Dimension *r
 
		return;
 
	}
 

	
 
	res->width  = max(strtoul(s, nullptr, 0), 64UL);
 
	res->height = max(strtoul(t + 1, nullptr, 0), 64UL);
 
	res->width  = std::max(strtoul(s, nullptr, 0), 64UL);
 
	res->height = std::max(strtoul(t + 1, nullptr, 0), 64UL);
 
}
 

	
 

	
src/order_cmd.cpp
Show inline comments
 
@@ -713,7 +713,7 @@ uint GetOrderDistance(const Order *prev,
 

	
 
		int dist1 = GetOrderDistance(prev, v->GetOrder(cur->GetConditionSkipToOrder()), v, conditional_depth);
 
		int dist2 = GetOrderDistance(prev, cur->next == nullptr ? v->orders.list->GetFirstOrder() : cur->next, v, conditional_depth);
 
		return max(dist1, dist2);
 
		return std::max(dist1, dist2);
 
	}
 

	
 
	TileIndex prev_tile = prev->GetLocation(v, true);
 
@@ -1093,7 +1093,7 @@ void DeleteOrder(Vehicle *v, VehicleOrde
 
		if (order->IsType(OT_CONDITIONAL)) {
 
			VehicleOrderID order_id = order->GetConditionSkipToOrder();
 
			if (order_id >= sel_ord) {
 
				order_id = max(order_id - 1, 0);
 
				order_id = std::max(order_id - 1, 0);
 
			}
 
			if (order_id == cur_order_id) {
 
				order_id = (order_id + 1) % v->GetNumOrders();
 
@@ -1985,7 +1985,7 @@ VehicleOrderID ProcessConditionalOrder(c
 
		case OCV_AGE:                skip_order = OrderConditionCompare(occ, v->age / DAYS_IN_LEAP_YEAR,        value); break;
 
		case OCV_REQUIRES_SERVICE:   skip_order = OrderConditionCompare(occ, v->NeedsServicing(),               value); break;
 
		case OCV_UNCONDITIONALLY:    skip_order = true; break;
 
		case OCV_REMAINING_LIFETIME: skip_order = OrderConditionCompare(occ, max(v->max_age - v->age + DAYS_IN_LEAP_YEAR - 1, 0) / DAYS_IN_LEAP_YEAR, value); break;
 
		case OCV_REMAINING_LIFETIME: skip_order = OrderConditionCompare(occ, std::max(v->max_age - v->age + DAYS_IN_LEAP_YEAR - 1, 0) / DAYS_IN_LEAP_YEAR, value); break;
 
		default: NOT_REACHED();
 
	}
 

	
src/order_gui.cpp
Show inline comments
 
@@ -1107,8 +1107,8 @@ public:
 
				if (i != this->selected_order && i == this->order_over) {
 
					/* Highlight dragged order destination. */
 
					int top = (this->order_over < this->selected_order ? y : y + line_height) - WD_FRAMERECT_TOP;
 
					int bottom = min(top + 2, r.bottom - WD_FRAMERECT_BOTTOM);
 
					top = max(top - 3, r.top + WD_FRAMERECT_TOP);
 
					int bottom = std::min(top + 2, r.bottom - WD_FRAMERECT_BOTTOM);
 
					top = std::max(top - 3, r.top + WD_FRAMERECT_TOP);
 
					GfxFillRect(r.left + WD_FRAMETEXT_LEFT, top, r.right - WD_FRAMETEXT_RIGHT, bottom, _colour_gradient[COLOUR_GREY][7]);
 
					break;
 
				}
src/os/macosx/string_osx.cpp
Show inline comments
 
@@ -260,7 +260,7 @@ int CoreTextParagraphLayout::CoreTextLin
 
{
 
	int leading = 0;
 
	for (const auto &run : *this) {
 
		leading = max(leading, run.GetLeading());
 
		leading = std::max(leading, run.GetLeading());
 
	}
 

	
 
	return leading;
src/os/windows/crashlog_win.cpp
Show inline comments
 
@@ -219,7 +219,7 @@ static char *PrintModuleInfo(char *outpu
 
			res = EnumProcessModules(proc, modules, sizeof(modules), &needed);
 
			CloseHandle(proc);
 
			if (res) {
 
				size_t count = min(needed / sizeof(HMODULE), lengthof(modules));
 
				size_t count = std::min<DWORD>(needed / sizeof(HMODULE), lengthof(modules));
 

	
 
				for (size_t i = 0; i != count; i++) output = PrintModuleInfo(output, last, modules[i]);
 
				return output + seprintf(output, last, "\n");
src/os/windows/string_uniscribe.cpp
Show inline comments
 
@@ -302,7 +302,7 @@ static std::vector<SCRIPT_ITEM> Uniscrib
 
	for (auto const &i : fontMapping) {
 
		while (cur_pos < i.first && cur_item != items.end() - 1) {
 
			/* Add a range that spans the intersection of the remaining item and font run. */
 
			int stop_pos = min(i.first, (cur_item + 1)->iCharPos);
 
			int stop_pos = std::min(i.first, (cur_item + 1)->iCharPos);
 
			assert(stop_pos - cur_pos > 0);
 
			ranges.push_back(UniscribeRun(cur_pos, stop_pos - cur_pos, i.second, cur_item->a));
 

	
 
@@ -452,7 +452,7 @@ int UniscribeParagraphLayout::UniscribeL
 
{
 
	int leading = 0;
 
	for (const auto &run : *this) {
 
		leading = max(leading, run.GetLeading());
 
		leading = std::max(leading, run.GetLeading());
 
	}
 

	
 
	return leading;
src/osk_gui.cpp
Show inline comments
 
@@ -243,7 +243,7 @@ static void AddKey(NWidgetHorizontal *ho
 
		hor->Add(leaf);
 
	}
 

	
 
	*biggest_index = max(*biggest_index, widnum);
 
	*biggest_index = std::max(*biggest_index, widnum);
 
}
 

	
 
/** Construct the top row keys (cancel, ok, backspace). */
src/pathfinder/follow_track.hpp
Show inline comments
 
@@ -471,7 +471,7 @@ public:
 
		/* Check for speed limit imposed by railtype */
 
		if (IsRailTT()) {
 
			uint16 rail_speed = GetRailTypeInfo(GetRailType(m_old_tile))->max_speed;
 
			if (rail_speed > 0) max_speed = min(max_speed, rail_speed);
 
			if (rail_speed > 0) max_speed = std::min<int>(max_speed, rail_speed);
 
		}
 

	
 
		/* if min speed was requested, return it */
src/pathfinder/npf/npf.cpp
Show inline comments
 
@@ -117,7 +117,7 @@ static uint NPFDistanceTrack(TileIndex t
 
	const uint dx = Delta(TileX(t0), TileX(t1));
 
	const uint dy = Delta(TileY(t0), TileY(t1));
 

	
 
	const uint straightTracks = 2 * min(dx, dy); // The number of straight (not full length) tracks
 
	const uint straightTracks = 2 * std::min(dx, dy); // The number of straight (not full length) tracks
 
	/* OPTIMISATION:
 
	 * Original: diagTracks = max(dx, dy) - min(dx,dy);
 
	 * Proof:
src/pathfinder/yapf/yapf_common.hpp
Show inline comments
 
@@ -164,7 +164,7 @@ public:
 
		int y2 = 2 * TileY(m_destTile);
 
		int dx = abs(x1 - x2);
 
		int dy = abs(y1 - y2);
 
		int dmin = min(dx, dy);
 
		int dmin = std::min(dx, dy);
 
		int dxy = abs(dx - dy);
 
		int d = dmin * YAPF_TILE_CORNER_LENGTH + (dxy - 1) * (YAPF_TILE_LENGTH / 2);
 
		n.m_estimate = n.m_cost + d;
src/pathfinder/yapf/yapf_destrail.hpp
Show inline comments
 
@@ -194,7 +194,7 @@ public:
 
		int y2 = 2 * TileY(m_destTile);
 
		int dx = abs(x1 - x2);
 
		int dy = abs(y1 - y2);
 
		int dmin = min(dx, dy);
 
		int dmin = std::min(dx, dy);
 
		int dxy = abs(dx - dy);
 
		int d = dmin * YAPF_TILE_CORNER_LENGTH + (dxy - 1) * (YAPF_TILE_LENGTH / 2);
 
		n.m_estimate = n.m_cost + d;
src/pathfinder/yapf/yapf_road.cpp
Show inline comments
 
@@ -303,7 +303,7 @@ public:
 
		int y2 = 2 * TileY(m_destTile);
 
		int dx = abs(x1 - x2);
 
		int dy = abs(y1 - y2);
 
		int dmin = min(dx, dy);
 
		int dmin = std::min(dx, dy);
 
		int dxy = abs(dx - dy);
 
		int d = dmin * YAPF_TILE_CORNER_LENGTH + (dxy - 1) * (YAPF_TILE_LENGTH / 2);
 
		n.m_estimate = n.m_cost + d;
src/pathfinder/yapf/yapf_ship.cpp
Show inline comments
 
@@ -89,7 +89,7 @@ public:
 
		int y2 = 2 * TileY(m_destTile);
 
		int dx = abs(x1 - x2);
 
		int dy = abs(y1 - y2);
 
		int dmin = min(dx, dy);
 
		int dmin = std::min(dx, dy);
 
		int dxy = abs(dx - dy);
 
		int d = dmin * YAPF_TILE_CORNER_LENGTH + (dxy - 1) * (YAPF_TILE_LENGTH / 2);
 
		n.m_estimate = n.m_cost + d;
src/rail.h
Show inline comments
 
@@ -388,7 +388,7 @@ static inline Money RailClearCost(RailTy
 
	 * cost.
 
	 */
 
	assert(railtype < RAILTYPE_END);
 
	return max(_price[PR_CLEAR_RAIL], -RailBuildCost(railtype) * 3 / 4);
 
	return std::max(_price[PR_CLEAR_RAIL], -RailBuildCost(railtype) * 3 / 4);
 
}
 

	
 
/**
 
@@ -408,8 +408,8 @@ static inline Money RailConvertCost(Rail
 
	 * build costs, if the target type is more expensive (material upgrade costs).
 
	 * Upgrade can never be more expensive than re-building. */
 
	if (HasPowerOnRail(from, to) || HasPowerOnRail(to, from)) {
 
		Money upgradecost = RailBuildCost(to) / 8 + max((Money)0, RailBuildCost(to) - RailBuildCost(from));
 
		return min(upgradecost, rebuildcost);
 
		Money upgradecost = RailBuildCost(to) / 8 + std::max((Money)0, RailBuildCost(to) - RailBuildCost(from));
 
		return std::min(upgradecost, rebuildcost);
 
	}
 

	
 
	/* make the price the same as remove + build new type for rail types
src/rail_cmd.cpp
Show inline comments
 
@@ -2885,7 +2885,7 @@ static void GetTileDesc_Track(TileIndex 
 
			td->str = STR_LAI_RAIL_DESCRIPTION_TRAIN_DEPOT;
 
			if (_settings_game.vehicle.train_acceleration_model != AM_ORIGINAL) {
 
				if (td->rail_speed > 0) {
 
					td->rail_speed = min(td->rail_speed, 61);
 
					td->rail_speed = std::min<uint16>(td->rail_speed, 61);
 
				} else {
 
					td->rail_speed = 61;
 
				}
src/rail_gui.cpp
Show inline comments
 
@@ -977,7 +977,7 @@ public:
 
		}
 
		if (newstation) {
 
			_railstation.station_count = StationClass::Get(_railstation.station_class)->GetSpecCount();
 
			_railstation.station_type = min(_railstation.station_type, _railstation.station_count - 1);
 
			_railstation.station_type = std::min<int>(_railstation.station_type, _railstation.station_count - 1);
 

	
 
			int count = 0;
 
			for (uint i = 0; i < StationClass::GetClassCount(); i++) {
 
@@ -985,7 +985,7 @@ public:
 
				count++;
 
			}
 
			this->vscroll->SetCount(count);
 
			this->vscroll->SetPosition(Clamp(_railstation.station_class - 2, 0, max(this->vscroll->GetCount() - this->vscroll->GetCapacity(), 0)));
 
			this->vscroll->SetPosition(Clamp(_railstation.station_class - 2, 0, std::max(this->vscroll->GetCount() - this->vscroll->GetCapacity(), 0)));
 

	
 
			NWidgetMatrix *matrix = this->GetWidget<NWidgetMatrix>(WID_BRAS_MATRIX);
 
			matrix->SetScrollbar(this->vscroll2);
 
@@ -1059,7 +1059,7 @@ public:
 
					if (i == STAT_CLASS_WAYP) continue;
 
					d = maxdim(d, GetStringBoundingBox(StationClass::Get((StationClassID)i)->name));
 
				}
 
				size->width = max(size->width, d.width + padding.width);
 
				size->width = std::max(size->width, d.width + padding.width);
 
				this->line_height = FONT_HEIGHT_NORMAL + WD_MATRIX_TOP + WD_MATRIX_BOTTOM;
 
				size->height = 5 * this->line_height;
 
				resize->height = this->line_height;
 
@@ -1085,7 +1085,7 @@ public:
 
						d = maxdim(d, GetStringBoundingBox(str));
 
					}
 
				}
 
				size->width = max(size->width, d.width + padding.width);
 
				size->width = std::max(size->width, d.width + padding.width);
 
				break;
 
			}
 

	
 
@@ -1334,7 +1334,7 @@ public:
 
							_railstation.station_class = (StationClassID)i;
 
							StationClass *stclass = StationClass::Get(_railstation.station_class);
 
							_railstation.station_count = stclass->GetSpecCount();
 
							_railstation.station_type  = min((int)_railstation.station_type, max(0, (int)_railstation.station_count - 1));
 
							_railstation.station_type  = std::min((int)_railstation.station_type, std::max(0, (int)_railstation.station_count - 1));
 

	
 
							this->CheckSelectedSize(stclass->GetSpec(_railstation.station_type));
 

	
 
@@ -1539,9 +1539,9 @@ public:
 
				for (uint lowered = 0; lowered < 2; lowered++) {
 
					Point offset;
 
					Dimension sprite_size = GetSpriteSize(rti->gui_sprites.signals[type][variant][lowered], &offset);
 
					this->sig_sprite_bottom_offset = max<int>(this->sig_sprite_bottom_offset, sprite_size.height);
 
					this->sig_sprite_size.width = max<int>(this->sig_sprite_size.width, sprite_size.width - offset.x);
 
					this->sig_sprite_size.height = max<int>(this->sig_sprite_size.height, sprite_size.height - offset.y);
 
					this->sig_sprite_bottom_offset = std::max<int>(this->sig_sprite_bottom_offset, sprite_size.height);
 
					this->sig_sprite_size.width = std::max<int>(this->sig_sprite_size.width, sprite_size.width - offset.x);
 
					this->sig_sprite_size.height = std::max<int>(this->sig_sprite_size.height, sprite_size.height - offset.y);
 
				}
 
			}
 
		}
 
@@ -1551,10 +1551,10 @@ public:
 
	{
 
		if (widget == WID_BS_DRAG_SIGNALS_DENSITY_LABEL) {
 
			/* Two digits for signals density. */
 
			size->width = max(size->width, 2 * GetDigitWidth() + padding.width + WD_FRAMERECT_LEFT + WD_FRAMERECT_RIGHT);
 
			size->width = std::max(size->width, 2 * GetDigitWidth() + padding.width + WD_FRAMERECT_LEFT + WD_FRAMERECT_RIGHT);
 
		} else if (IsInsideMM(widget, WID_BS_SEMAPHORE_NORM, WID_BS_ELECTRIC_PBS_OWAY + 1)) {
 
			size->width = max(size->width, this->sig_sprite_size.width + WD_IMGBTN_LEFT + WD_IMGBTN_RIGHT);
 
			size->height = max(size->height, this->sig_sprite_size.height + WD_IMGBTN_TOP + WD_IMGBTN_BOTTOM);
 
			size->width = std::max(size->width, this->sig_sprite_size.width + WD_IMGBTN_LEFT + WD_IMGBTN_RIGHT);
 
			size->height = std::max(size->height, this->sig_sprite_size.height + WD_IMGBTN_TOP + WD_IMGBTN_BOTTOM);
 
		}
 
	}
 

	
src/roadveh_cmd.cpp
Show inline comments
 
@@ -453,11 +453,11 @@ inline int RoadVehicle::GetCurrentMaxSpe
 

	
 
		/* Vehicle is on the middle part of a bridge. */
 
		if (u->state == RVSB_WORMHOLE && !(u->vehstatus & VS_HIDDEN)) {
 
			max_speed = min(max_speed, GetBridgeSpec(GetBridgeType(u->tile))->speed * 2);
 
			max_speed = std::min(max_speed, GetBridgeSpec(GetBridgeType(u->tile))->speed * 2);
 
		}
 
	}
 

	
 
	return min(max_speed, this->current_order.GetMaxSpeed() * 2);
 
	return std::min(max_speed, this->current_order.GetMaxSpeed() * 2);
 
}
 

	
 
/**
src/saveload/afterload.cpp
Show inline comments
 
@@ -599,8 +599,8 @@ bool AfterLoadGame()
 
			int dx = TileX(t) - TileX(st->train_station.tile);
 
			int dy = TileY(t) - TileY(st->train_station.tile);
 
			assert(dx >= 0 && dy >= 0);
 
			st->train_station.w = max<uint>(st->train_station.w, dx + 1);
 
			st->train_station.h = max<uint>(st->train_station.h, dy + 1);
 
			st->train_station.w = std::max<uint>(st->train_station.w, dx + 1);
 
			st->train_station.h = std::max<uint>(st->train_station.h, dy + 1);
 
		}
 
	}
 

	
 
@@ -2457,7 +2457,7 @@ bool AfterLoadGame()
 
						uint per_proc = _me[t].m7;
 
						_me[t].m7 = GB(_me[t].m6, 2, 6) | (GB(_m[t].m3, 5, 1) << 6);
 
						SB(_m[t].m3, 5, 1, 0);
 
						SB(_me[t].m6, 2, 6, min(per_proc, 63));
 
						SB(_me[t].m6, 2, 6, std::min(per_proc, 63U));
 
					}
 
					break;
 

	
 
@@ -2713,7 +2713,7 @@ bool AfterLoadGame()
 
		_settings_game.pf.reverse_at_signals = IsSavegameVersionBefore(SLV_100) || (_settings_game.pf.wait_oneway_signal != 255 && _settings_game.pf.wait_twoway_signal != 255 && _settings_game.pf.wait_for_pbs_path != 255);
 

	
 
		for (Train *t : Train::Iterate()) {
 
			_settings_game.vehicle.max_train_length = max<uint8>(_settings_game.vehicle.max_train_length, CeilDiv(t->gcache.cached_total_length, TILE_SIZE));
 
			_settings_game.vehicle.max_train_length = std::max<uint8>(_settings_game.vehicle.max_train_length, CeilDiv(t->gcache.cached_total_length, TILE_SIZE));
 
		}
 
	}
 

	
src/saveload/company_sl.cpp
Show inline comments
 
@@ -61,7 +61,7 @@ CompanyManagerFace ConvertFromOldCompany
 
	uint lips = GB(face, 10, 4);
 
	if (!HasBit(ge, GENDER_FEMALE) && lips < 4) {
 
		SetCompanyManagerFaceBits(cmf, CMFV_HAS_MOUSTACHE, ge, true);
 
		SetCompanyManagerFaceBits(cmf, CMFV_MOUSTACHE,     ge, max(lips, 1U) - 1);
 
		SetCompanyManagerFaceBits(cmf, CMFV_MOUSTACHE,     ge, std::max(lips, 1U) - 1);
 
	} else {
 
		if (!HasBit(ge, GENDER_FEMALE)) {
 
			lips = lips * 15 / 16;
src/saveload/misc_sl.cpp
Show inline comments
 
@@ -51,7 +51,7 @@ void ResetViewportAfterLoadGame()
 
	w->viewport->dest_scrollpos_y = _saved_scrollpos_y;
 

	
 
	Viewport *vp = w->viewport;
 
	vp->zoom = (ZoomLevel)min(_saved_scrollpos_zoom, ZOOM_LVL_MAX);
 
	vp->zoom = std::min(_saved_scrollpos_zoom, ZOOM_LVL_MAX);
 
	vp->virtual_width = ScaleByZoom(vp->width, vp->zoom);
 
	vp->virtual_height = ScaleByZoom(vp->height, vp->zoom);
 

	
src/saveload/oldloader_sl.cpp
Show inline comments
 
@@ -392,7 +392,7 @@ static bool FixTTOEngines()
 
	for (uint i = 0; i < lengthof(_orig_ship_vehicle_info); i++, j++) new (GetTempDataEngine(j)) Engine(VEH_SHIP, i);
 
	for (uint i = 0; i < lengthof(_orig_aircraft_vehicle_info); i++, j++) new (GetTempDataEngine(j)) Engine(VEH_AIRCRAFT, i);
 

	
 
	Date aging_date = min(_date + DAYS_TILL_ORIGINAL_BASE_YEAR, ConvertYMDToDate(2050, 0, 1));
 
	Date aging_date = std::min(_date + DAYS_TILL_ORIGINAL_BASE_YEAR, ConvertYMDToDate(2050, 0, 1));
 

	
 
	for (EngineID i = 0; i < 256; i++) {
 
		int oi = ttd_to_tto[i];
 
@@ -1823,7 +1823,7 @@ bool LoadTTOMain(LoadgameState *ls)
 
	 * "increase them to compensate for the faster time advance in TTD compared to TTO
 
	 * which otherwise would cause much less income while the annual running costs of
 
	 * the vehicles stay the same" */
 
	_economy.inflation_payment = min(_economy.inflation_payment * 124 / 74, MAX_INFLATION);
 
	_economy.inflation_payment = std::min(_economy.inflation_payment * 124 / 74, MAX_INFLATION);
 

	
 
	DEBUG(oldloader, 3, "Finished converting game data");
 
	DEBUG(oldloader, 1, "TTO savegame successfully converted");
src/saveload/saveload.cpp
Show inline comments
 
@@ -170,7 +170,7 @@ struct MemoryDumper {
 
		size_t t = this->GetSize();
 

	
 
		while (t > 0) {
 
			size_t to_write = min(MEMORY_CHUNK_SIZE, t);
 
			size_t to_write = std::min(MEMORY_CHUNK_SIZE, t);
 

	
 
			writer->Write(this->blocks[i++], to_write);
 
			t -= to_write;
 
@@ -856,7 +856,7 @@ static void SlSaveLoadConv(void *ptr, Va
 
static inline size_t SlCalcNetStringLen(const char *ptr, size_t length)
 
{
 
	if (ptr == nullptr) return 0;
 
	return min(strlen(ptr), length - 1);
 
	return std::min(strlen(ptr), length - 1);
 
}
 

	
 
/**
src/screenshot.cpp
Show inline comments
 
@@ -182,7 +182,7 @@ static bool MakeBMPImage(const char *nam
 

	
 
	/* Start at the bottom, since bitmaps are stored bottom up */
 
	do {
 
		uint n = min(h, maxlines);
 
		uint n = std::min(h, maxlines);
 
		h -= n;
 

	
 
		/* Render the pixels */
 
@@ -375,7 +375,7 @@ static bool MakePNGImage(const char *nam
 
	y = 0;
 
	do {
 
		/* determine # lines to write */
 
		n = min(h - y, maxlines);
 
		n = std::min(h - y, maxlines);
 

	
 
		/* render the pixels into the buffer */
 
		callb(userdata, buff, y, w, n);
 
@@ -482,7 +482,7 @@ static bool MakePCXImage(const char *nam
 
	y = 0;
 
	do {
 
		/* determine # lines to write */
 
		uint n = min(h - y, maxlines);
 
		uint n = std::min(h - y, maxlines);
 
		uint i;
 

	
 
		/* render the pixels into the buffer */
 
@@ -640,7 +640,7 @@ static void LargeWorldCallback(void *use
 
	/* Render viewport in blocks of 1600 pixels width */
 
	left = 0;
 
	while (vp->width - left != 0) {
 
		wx = min(vp->width - left, 1600);
 
		wx = std::min(vp->width - left, 1600);
 
		left += wx;
 

	
 
		ViewportDoDraw(vp,
src/script/api/script_bridge.cpp
Show inline comments
 
@@ -160,7 +160,7 @@ static void _DoCommandReturnBuildBridge1
 
{
 
	if (!IsValidBridge(bridge_id)) return -1;
 

	
 
	return min(::GetBridgeSpec(bridge_id)->max_length, _settings_game.construction.max_bridge_length) + 2;
 
	return std::min(::GetBridgeSpec(bridge_id)->max_length, _settings_game.construction.max_bridge_length) + 2;
 
}
 

	
 
/* static */ int32 ScriptBridge::GetMinLength(BridgeID bridge_id)
src/script/api/script_priorityqueue.cpp
Show inline comments
 
@@ -13,7 +13,6 @@
 
#include "../squirrel_helper.hpp"
 
#include "../script_instance.hpp"
 
#include "../../debug.h"
 
#include <algorithm>
 

	
 
#include "../../safeguards.h"
 

	
src/script/api/script_rail.cpp
Show inline comments
 
@@ -178,7 +178,18 @@
 
	if (station_id != ScriptStation::STATION_JOIN_ADJACENT) p1 |= (1 << 24);
 

	
 
	const GRFFile *file;
 
	uint16 res = GetAiPurchaseCallbackResult(GSF_STATIONS, cargo_id, 0, source_industry, goal_industry, min(255, distance / 2), AICE_STATION_GET_STATION_ID, source_station ? 0 : 1, min(15, num_platforms) << 4 | min(15, platform_length), &file);
 
	uint16 res = GetAiPurchaseCallbackResult(
 
		GSF_STATIONS,
 
		cargo_id,
 
		0,
 
		source_industry,
 
		goal_industry,
 
		std::min(255, distance / 2),
 
		AICE_STATION_GET_STATION_ID,
 
		source_station ? 0 : 1,
 
		std::min(15u, num_platforms) << 4 | std::min(15u, platform_length),
 
		&file
 
	);
 
	uint32 p2 = (ScriptStation::IsValidStation(station_id) ? station_id : INVALID_STATION) << 16;
 
	if (res != CALLBACK_FAILED) {
 
		int index = 0;
src/script/api/script_town.cpp
Show inline comments
 
@@ -172,7 +172,7 @@
 
		default:
 
			EnforcePrecondition(false, (days_between_town_growth * DAY_TICKS / TOWN_GROWTH_TICKS) <= MAX_TOWN_GROWTH_TICKS);
 
			/* Don't use growth_rate 0 as it means GROWTH_NORMAL */
 
			growth_rate = max(days_between_town_growth * DAY_TICKS, 2u) - 1;
 
			growth_rate = std::max(days_between_town_growth * DAY_TICKS, 2u) - 1;
 
			break;
 
	}
 

	
 
@@ -376,7 +376,7 @@
 
	for (const Station *st : Station::Iterate()) {
 
		if (st->town == t && (st->facilities & FACIL_AIRPORT) && st->airport.type != AT_OILRIG) num++;
 
	}
 
	return max(0, 2 - num);
 
	return std::max(0, 2 - num);
 
}
 

	
 
/* static */ ScriptTown::RoadLayout ScriptTown::GetRoadLayout(TownID town_id)
src/script/squirrel_std.cpp
Show inline comments
 
@@ -25,7 +25,7 @@ SQInteger SquirrelStd::min(HSQUIRRELVM v
 

	
 
	sq_getinteger(vm, 2, &tmp1);
 
	sq_getinteger(vm, 3, &tmp2);
 
	sq_pushinteger(vm, ::min(tmp1, tmp2));
 
	sq_pushinteger(vm, std::min(tmp1, tmp2));
 
	return 1;
 
}
 

	
 
@@ -35,7 +35,7 @@ SQInteger SquirrelStd::max(HSQUIRRELVM v
 

	
 
	sq_getinteger(vm, 2, &tmp1);
 
	sq_getinteger(vm, 3, &tmp2);
 
	sq_pushinteger(vm, ::max(tmp1, tmp2));
 
	sq_pushinteger(vm, std::max(tmp1, tmp2));
 
	return 1;
 
}
 

	
src/settings_gui.cpp
Show inline comments
 
@@ -370,7 +370,7 @@ struct GameOptionsWindow : Window {
 
				/* Find the biggest description for the default size. */
 
				for (int i = 0; i < BaseGraphics::GetNumSets(); i++) {
 
					SetDParamStr(0, BaseGraphics::GetSet(i)->GetDescription(GetCurrentLanguageIsoCode()));
 
					size->height = max(size->height, (uint)GetStringHeight(STR_BLACK_RAW_STRING, size->width));
 
					size->height = std::max(size->height, (uint)GetStringHeight(STR_BLACK_RAW_STRING, size->width));
 
				}
 
				break;
 

	
 
@@ -389,7 +389,7 @@ struct GameOptionsWindow : Window {
 
				/* Find the biggest description for the default size. */
 
				for (int i = 0; i < BaseSounds::GetNumSets(); i++) {
 
					SetDParamStr(0, BaseSounds::GetSet(i)->GetDescription(GetCurrentLanguageIsoCode()));
 
					size->height = max(size->height, (uint)GetStringHeight(STR_BLACK_RAW_STRING, size->width));
 
					size->height = std::max(size->height, (uint)GetStringHeight(STR_BLACK_RAW_STRING, size->width));
 
				}
 
				break;
 

	
 
@@ -397,7 +397,7 @@ struct GameOptionsWindow : Window {
 
				/* Find the biggest description for the default size. */
 
				for (int i = 0; i < BaseMusic::GetNumSets(); i++) {
 
					SetDParamStr(0, BaseMusic::GetSet(i)->GetDescription(GetCurrentLanguageIsoCode()));
 
					size->height = max(size->height, (uint)GetStringHeight(STR_BLACK_RAW_STRING, size->width));
 
					size->height = std::max(size->height, (uint)GetStringHeight(STR_BLACK_RAW_STRING, size->width));
 
				}
 
				break;
 

	
 
@@ -1273,7 +1273,7 @@ uint SettingsContainer::GetMaxHelpHeight
 
{
 
	uint biggest = 0;
 
	for (EntryVector::const_iterator it = this->entries.begin(); it != this->entries.end(); ++it) {
 
		biggest = max(biggest, (*it)->GetMaxHelpHeight(maxw));
 
		biggest = std::max(biggest, (*it)->GetMaxHelpHeight(maxw));
 
	}
 
	return biggest;
 
}
 
@@ -1852,7 +1852,7 @@ struct GameSettingsWindow : Window {
 
	{
 
		switch (widget) {
 
			case WID_GS_OPTIONSPANEL:
 
				resize->height = SETTING_HEIGHT = max(max<int>(_circle_size.height, SETTING_BUTTON_HEIGHT), FONT_HEIGHT_NORMAL) + 1;
 
				resize->height = SETTING_HEIGHT = std::max({(int)_circle_size.height, SETTING_BUTTON_HEIGHT, FONT_HEIGHT_NORMAL}) + 1;
 
				resize->width  = 1;
 

	
 
				size->height = 5 * resize->height + SETTINGTREE_TOP_OFFSET + SETTINGTREE_BOTTOM_OFFSET;
 
@@ -1866,16 +1866,16 @@ struct GameSettingsWindow : Window {
 
				};
 
				for (uint i = 0; i < lengthof(setting_types); i++) {
 
					SetDParam(0, setting_types[i]);
 
					size->width = max(size->width, GetStringBoundingBox(STR_CONFIG_SETTING_TYPE).width);
 
					size->width = std::max(size->width, GetStringBoundingBox(STR_CONFIG_SETTING_TYPE).width);
 
				}
 
				size->height = 2 * FONT_HEIGHT_NORMAL + WD_PAR_VSEP_NORMAL +
 
						max(size->height, GetSettingsTree().GetMaxHelpHeight(size->width));
 
						std::max(size->height, GetSettingsTree().GetMaxHelpHeight(size->width));
 
				break;
 
			}
 

	
 
			case WID_GS_RESTRICT_CATEGORY:
 
			case WID_GS_RESTRICT_TYPE:
 
				size->width = max(GetStringBoundingBox(STR_CONFIG_SETTING_RESTRICT_CATEGORY).width, GetStringBoundingBox(STR_CONFIG_SETTING_RESTRICT_TYPE).width);
 
				size->width = std::max(GetStringBoundingBox(STR_CONFIG_SETTING_RESTRICT_CATEGORY).width, GetStringBoundingBox(STR_CONFIG_SETTING_RESTRICT_TYPE).width);
 
				break;
 

	
 
			default:
 
@@ -2631,7 +2631,7 @@ struct CustomCurrencyWindow : Window {
 
			case WID_CC_YEAR: { // Year to switch to euro
 
				int val = atoi(str);
 

	
 
				_custom_currency.to_euro = (val < 2000 ? CF_NOEURO : min(val, MAX_YEAR));
 
				_custom_currency.to_euro = (val < 2000 ? CF_NOEURO : std::min(val, MAX_YEAR));
 
				break;
 
			}
 
		}
src/settingsgen/settingsgen.cpp
Show inline comments
 
@@ -58,7 +58,7 @@ public:
 
	 */
 
	size_t Add(const char *text, size_t length)
 
	{
 
		size_t store_size = min(length, OUTPUT_BLOCK_SIZE - this->size);
 
		size_t store_size = std::min(length, OUTPUT_BLOCK_SIZE - this->size);
 
		assert(store_size <= OUTPUT_BLOCK_SIZE);
 
		MemCpyT(this->data + this->size, text, store_size);
 
		this->size += store_size;
src/ship.h
Show inline comments
 
@@ -43,7 +43,7 @@ struct Ship FINAL : public SpecializedVe
 
	void GetImage(Direction direction, EngineImageType image_type, VehicleSpriteSeq *result) const;
 
	int GetDisplaySpeed() const { return this->cur_speed / 2; }
 
	int GetDisplayMaxSpeed() const { return this->vcache.cached_max_speed / 2; }
 
	int GetCurrentMaxSpeed() const { return min(this->vcache.cached_max_speed, this->current_order.GetMaxSpeed() * 2); }
 
	int GetCurrentMaxSpeed() const { return std::min<int>(this->vcache.cached_max_speed, this->current_order.GetMaxSpeed() * 2); }
 
	Money GetRunningCost() const;
 
	bool IsInDepot() const { return this->state == TRACK_BIT_DEPOT; }
 
	bool Tick();
src/ship_cmd.cpp
Show inline comments
 
@@ -405,8 +405,8 @@ static bool ShipAccelerate(Vehicle *v)
 
	uint spd;
 
	byte t;
 

	
 
	spd = min(v->cur_speed + 1, v->vcache.cached_max_speed);
 
	spd = min(spd, v->current_order.GetMaxSpeed() * 2);
 
	spd = std::min<uint>(v->cur_speed + 1, v->vcache.cached_max_speed);
 
	spd = std::min<uint>(spd, v->current_order.GetMaxSpeed() * 2);
 

	
 
	/* updates statusbar only if speed have changed to save CPU time */
 
	if (spd != v->cur_speed) {
src/signs_gui.cpp
Show inline comments
 
@@ -263,7 +263,7 @@ struct SignListWindow : Window, SignList
 
			case WID_SIL_LIST: {
 
				Dimension spr_dim = GetSpriteSize(SPR_COMPANY_ICON);
 
				this->text_offset = WD_FRAMETEXT_LEFT + spr_dim.width + 2; // 2 pixels space between icon and the sign text.
 
				resize->height = max<uint>(FONT_HEIGHT_NORMAL, spr_dim.height);
 
				resize->height = std::max<uint>(FONT_HEIGHT_NORMAL, spr_dim.height);
 
				Dimension d = {(uint)(this->text_offset + WD_FRAMETEXT_RIGHT), WD_FRAMERECT_TOP + 5 * resize->height + WD_FRAMERECT_BOTTOM};
 
				*size = maxdim(*size, d);
 
				break;
src/smallmap_gui.cpp
Show inline comments
 
@@ -845,7 +845,7 @@ void SmallMapWindow::DrawSmallMapColumn(
 
		if (min_xy == 1 && (xc == 0 || yc == 0)) {
 
			if (this->zoom == 1) continue; // The tile area is empty, don't draw anything.
 

	
 
			ta = TileArea(TileXY(max(min_xy, xc), max(min_xy, yc)), this->zoom - (xc == 0), this->zoom - (yc == 0));
 
			ta = TileArea(TileXY(std::max(min_xy, xc), std::max(min_xy, yc)), this->zoom - (xc == 0), this->zoom - (yc == 0));
 
		} else {
 
			ta = TileArea(TileXY(xc, yc), this->zoom, this->zoom);
 
		}
 
@@ -853,8 +853,8 @@ void SmallMapWindow::DrawSmallMapColumn(
 

	
 
		uint32 val = this->GetTileColours(ta);
 
		uint8 *val8 = (uint8 *)&val;
 
		int idx = max(0, -start_pos);
 
		for (int pos = max(0, start_pos); pos < end_pos; pos++) {
 
		int idx = std::max(0, -start_pos);
 
		for (int pos = std::max(0, start_pos); pos < end_pos; pos++) {
 
			blitter->SetPixel(dst, idx, 0, val8[idx]);
 
			idx++;
 
		}
 
@@ -986,7 +986,7 @@ void SmallMapWindow::DrawSmallMap(DrawPi
 
		if (x >= -3) {
 
			if (x >= dpi->width) break; // Exit the loop.
 

	
 
			int end_pos = min(dpi->width, x + 4);
 
			int end_pos = std::min(dpi->width, x + 4);
 
			int reps = (dpi->height - y + 1) / 2; // Number of lines.
 
			if (reps > 0) {
 
				this->DrawSmallMapColumn(ptr, tile_x, tile_y, dpi->pitch * 2, reps, x, end_pos, blitter);
 
@@ -1159,17 +1159,17 @@ void SmallMapWindow::RebuildColourIndexI
 
				}
 
			} else {
 
				if (tbl->col_break) {
 
					this->min_number_of_fixed_rows = max(this->min_number_of_fixed_rows, height);
 
					this->min_number_of_fixed_rows = std::max(this->min_number_of_fixed_rows, height);
 
					height = 0;
 
					num_columns++;
 
				}
 
				height++;
 
				str = tbl->legend;
 
			}
 
			min_width = max(GetStringBoundingBox(str).width, min_width);
 
			min_width = std::max(GetStringBoundingBox(str).width, min_width);
 
		}
 
		this->min_number_of_fixed_rows = max(this->min_number_of_fixed_rows, height);
 
		this->min_number_of_columns = max(this->min_number_of_columns, num_columns);
 
		this->min_number_of_fixed_rows = std::max(this->min_number_of_fixed_rows, height);
 
		this->min_number_of_columns = std::max(this->min_number_of_columns, num_columns);
 
	}
 

	
 
	/* The width of a column is the minimum width of all texts + the size of the blob + some spacing */
 
@@ -1317,8 +1317,8 @@ inline uint SmallMapWindow::GetNumberRow
 
{
 
	/* Reserve one column for link colours */
 
	uint num_rows_linkstats = CeilDiv(_smallmap_cargo_count, columns - 1);
 
	uint num_rows_others = CeilDiv(max(_smallmap_industry_count, _smallmap_company_count), columns);
 
	return max(this->min_number_of_fixed_rows, max(num_rows_linkstats, num_rows_others));
 
	uint num_rows_others = CeilDiv(std::max(_smallmap_industry_count, _smallmap_company_count), columns);
 
	return std::max({this->min_number_of_fixed_rows, num_rows_linkstats, num_rows_others});
 
}
 

	
 
/**
 
@@ -1652,7 +1652,7 @@ void SmallMapWindow::SmallMapCenterOnCur
 
	int sub;
 
	const NWidgetBase *wid = this->GetWidget<NWidgetBase>(WID_SM_MAP);
 
	Point sxy = this->ComputeScroll(viewport_center.x / (int)TILE_SIZE, viewport_center.y / (int)TILE_SIZE,
 
			max(0, (int)wid->current_x / 2 - 2), wid->current_y / 2, &sub);
 
			std::max(0, (int)wid->current_x / 2 - 2), wid->current_y / 2, &sub);
 
	this->SetNewScroll(sxy.x, sxy.y, sub);
 
	this->SetDirty();
 
}
 
@@ -1705,12 +1705,12 @@ public:
 

	
 
		this->smallmap_window = dynamic_cast<SmallMapWindow *>(w);
 
		assert(this->smallmap_window != nullptr);
 
		this->smallest_x = max(display->smallest_x, bar->smallest_x + smallmap_window->GetMinLegendWidth());
 
		this->smallest_y = display->smallest_y + max(bar->smallest_y, smallmap_window->GetLegendHeight(smallmap_window->min_number_of_columns));
 
		this->fill_x = max(display->fill_x, bar->fill_x);
 
		this->fill_y = (display->fill_y == 0 && bar->fill_y == 0) ? 0 : min(display->fill_y, bar->fill_y);
 
		this->resize_x = max(display->resize_x, bar->resize_x);
 
		this->resize_y = min(display->resize_y, bar->resize_y);
 
		this->smallest_x = std::max(display->smallest_x, bar->smallest_x + smallmap_window->GetMinLegendWidth());
 
		this->smallest_y = display->smallest_y + std::max(bar->smallest_y, smallmap_window->GetLegendHeight(smallmap_window->min_number_of_columns));
 
		this->fill_x = std::max(display->fill_x, bar->fill_x);
 
		this->fill_y = (display->fill_y == 0 && bar->fill_y == 0) ? 0 : std::min(display->fill_y, bar->fill_y);
 
		this->resize_x = std::max(display->resize_x, bar->resize_x);
 
		this->resize_y = std::min(display->resize_y, bar->resize_y);
 
	}
 

	
 
	void AssignSizePosition(SizingType sizing, uint x, uint y, uint given_width, uint given_height, bool rtl) override
 
@@ -1731,7 +1731,7 @@ public:
 
			bar->AssignSizePosition(ST_SMALLEST, x, y + display->smallest_y, bar->smallest_x, bar->smallest_y, rtl);
 
		}
 

	
 
		uint bar_height = max(bar->smallest_y, this->smallmap_window->GetLegendHeight(this->smallmap_window->GetNumberColumnsLegend(given_width - bar->smallest_x)));
 
		uint bar_height = std::max(bar->smallest_y, this->smallmap_window->GetLegendHeight(this->smallmap_window->GetNumberColumnsLegend(given_width - bar->smallest_x)));
 
		uint display_height = given_height - bar_height;
 
		display->AssignSizePosition(ST_RESIZE, x, y, given_width, display_height, rtl);
 
		bar->AssignSizePosition(ST_RESIZE, x, y + display_height, given_width, bar_height, rtl);
src/sound.cpp
Show inline comments
 
@@ -262,8 +262,8 @@ static void SndPlayScreenCoordFx(SoundID
 
void SndPlayTileFx(SoundID sound, TileIndex tile)
 
{
 
	/* emits sound from center of the tile */
 
	int x = min(MapMaxX() - 1, TileX(tile)) * TILE_SIZE + TILE_SIZE / 2;
 
	int y = min(MapMaxY() - 1, TileY(tile)) * TILE_SIZE - TILE_SIZE / 2;
 
	int x = std::min(MapMaxX() - 1, TileX(tile)) * TILE_SIZE + TILE_SIZE / 2;
 
	int y = std::min(MapMaxY() - 1, TileY(tile)) * TILE_SIZE - TILE_SIZE / 2;
 
	int z = (y < 0 ? 0 : GetSlopePixelZ(x, y));
 
	Point pt = RemapCoords(x, y, z);
 
	y += 2 * TILE_SIZE;
src/sound/win32_s.cpp
Show inline comments
 
@@ -70,7 +70,7 @@ const char *SoundDriver_Win32::Start(con
 

	
 
	/* Limit buffer size to prevent overflows. */
 
	_bufsize = GetDriverParamInt(parm, "bufsize", (GB(GetVersion(), 0, 8) > 5) ? 8192 : 4096);
 
	_bufsize = min(_bufsize, UINT16_MAX);
 
	_bufsize = std::min<int>(_bufsize, UINT16_MAX);
 

	
 
	try {
 
		if (nullptr == (_event = CreateEvent(nullptr, FALSE, FALSE, nullptr))) throw "Failed to create event";
src/sound/xaudio2_s.cpp
Show inline comments
 
@@ -193,7 +193,7 @@ const char *SoundDriver_XAudio2::Start(c
 

	
 
	// Limit buffer size to prevent overflows
 
	int bufsize = GetDriverParamInt(parm, "bufsize", 8192);
 
	bufsize = min(bufsize, UINT16_MAX);
 
	bufsize = std::min<int>(bufsize, UINT16_MAX);
 

	
 
	_voice_context = new StreamingVoiceContext(bufsize * 4);
 

	
src/spritecache.cpp
Show inline comments
 
@@ -302,8 +302,8 @@ static bool PadSprites(SpriteLoader::Spr
 
	int min_yoffs = INT32_MAX;
 
	for (ZoomLevel zoom = ZOOM_LVL_BEGIN; zoom != ZOOM_LVL_END; zoom++) {
 
		if (HasBit(sprite_avail, zoom)) {
 
			min_xoffs = min(min_xoffs, ScaleByZoom(sprite[zoom].x_offs, zoom));
 
			min_yoffs = min(min_yoffs, ScaleByZoom(sprite[zoom].y_offs, zoom));
 
			min_xoffs = std::min(min_xoffs, ScaleByZoom(sprite[zoom].x_offs, zoom));
 
			min_yoffs = std::min(min_yoffs, ScaleByZoom(sprite[zoom].y_offs, zoom));
 
		}
 
	}
 

	
 
@@ -312,8 +312,8 @@ static bool PadSprites(SpriteLoader::Spr
 
	int max_height = INT32_MIN;
 
	for (ZoomLevel zoom = ZOOM_LVL_BEGIN; zoom != ZOOM_LVL_END; zoom++) {
 
		if (HasBit(sprite_avail, zoom)) {
 
			max_width  = max(max_width, ScaleByZoom(sprite[zoom].width + sprite[zoom].x_offs - UnScaleByZoom(min_xoffs, zoom), zoom));
 
			max_height = max(max_height, ScaleByZoom(sprite[zoom].height + sprite[zoom].y_offs - UnScaleByZoom(min_yoffs, zoom), zoom));
 
			max_width  = std::max(max_width, ScaleByZoom(sprite[zoom].width + sprite[zoom].x_offs - UnScaleByZoom(min_xoffs, zoom), zoom));
 
			max_height = std::max(max_height, ScaleByZoom(sprite[zoom].height + sprite[zoom].y_offs - UnScaleByZoom(min_yoffs, zoom), zoom));
 
		}
 
	}
 

	
 
@@ -322,10 +322,10 @@ static bool PadSprites(SpriteLoader::Spr
 
		if (HasBit(sprite_avail, zoom)) {
 
			/* Scaling the sprite dimensions in the blitter is done with rounding up,
 
			 * so a negative padding here is not an error. */
 
			int pad_left   = max(0, sprite[zoom].x_offs - UnScaleByZoom(min_xoffs, zoom));
 
			int pad_top    = max(0, sprite[zoom].y_offs - UnScaleByZoom(min_yoffs, zoom));
 
			int pad_right  = max(0, UnScaleByZoom(max_width, zoom) - sprite[zoom].width - pad_left);
 
			int pad_bottom = max(0, UnScaleByZoom(max_height, zoom) - sprite[zoom].height - pad_top);
 
			int pad_left   = std::max(0, sprite[zoom].x_offs - UnScaleByZoom(min_xoffs, zoom));
 
			int pad_top    = std::max(0, sprite[zoom].y_offs - UnScaleByZoom(min_yoffs, zoom));
 
			int pad_right  = std::max(0, UnScaleByZoom(max_width, zoom) - sprite[zoom].width - pad_left);
 
			int pad_bottom = std::max(0, UnScaleByZoom(max_height, zoom) - sprite[zoom].height - pad_top);
 

	
 
			if (pad_left > 0 || pad_right > 0 || pad_top > 0 || pad_bottom > 0) {
 
				if (!PadSingleSprite(&sprite[zoom], zoom, pad_left, pad_top, pad_right, pad_bottom)) return false;
 
@@ -378,10 +378,10 @@ static void *ReadRecolourSprite(uint16 f
 
	 * GRFs which are the same as 257 byte recolour sprites, but with the last
 
	 * 240 bytes zeroed.  */
 
	static const uint RECOLOUR_SPRITE_SIZE = 257;
 
	byte *dest = (byte *)AllocSprite(max(RECOLOUR_SPRITE_SIZE, num));
 
	byte *dest = (byte *)AllocSprite(std::max(RECOLOUR_SPRITE_SIZE, num));
 

	
 
	if (_palette_remap_grf[file_slot]) {
 
		byte *dest_tmp = AllocaM(byte, max(RECOLOUR_SPRITE_SIZE, num));
 
		byte *dest_tmp = AllocaM(byte, std::max(RECOLOUR_SPRITE_SIZE, num));
 

	
 
		/* Only a few recolour sprites are less than 257 bytes */
 
		if (num < RECOLOUR_SPRITE_SIZE) memset(dest_tmp, 0, RECOLOUR_SPRITE_SIZE);
src/spriteloader/grf.cpp
Show inline comments
 
@@ -164,7 +164,7 @@ bool DecodeSingleSprite(SpriteLoader::Sp
 
					if (colour_fmt & SCC_PAL) {
 
						switch (sprite_type) {
 
							case ST_NORMAL: data->m = _palette_remap_grf[file_slot] ? _palmap_w2d[*dest] : *dest; break;
 
							case ST_FONT:   data->m = min(*dest, 2u); break;
 
							case ST_FONT:   data->m = std::min<uint>(*dest, 2u); break;
 
							default:        data->m = *dest; break;
 
						}
 
						/* Magic blue. */
 
@@ -200,7 +200,7 @@ bool DecodeSingleSprite(SpriteLoader::Sp
 
			if (colour_fmt & SCC_PAL) {
 
				switch (sprite_type) {
 
					case ST_NORMAL: sprite->data[i].m = _palette_remap_grf[file_slot] ? _palmap_w2d[*pixel] : *pixel; break;
 
					case ST_FONT:   sprite->data[i].m = min(*pixel, 2u); break;
 
					case ST_FONT:   sprite->data[i].m = std::min<uint>(*pixel, 2u); break;
 
					default:        sprite->data[i].m = *pixel; break;
 
				}
 
				/* Magic blue. */
src/station.cpp
Show inline comments
 
@@ -320,11 +320,11 @@ uint Station::GetCatchmentRadius() const
 
	uint ret = CA_NONE;
 

	
 
	if (_settings_game.station.modified_catchment) {
 
		if (this->bus_stops          != nullptr)         ret = max<uint>(ret, CA_BUS);
 
		if (this->truck_stops        != nullptr)         ret = max<uint>(ret, CA_TRUCK);
 
		if (this->train_station.tile != INVALID_TILE) ret = max<uint>(ret, CA_TRAIN);
 
		if (this->ship_station.tile  != INVALID_TILE) ret = max<uint>(ret, CA_DOCK);
 
		if (this->airport.tile       != INVALID_TILE) ret = max<uint>(ret, this->airport.GetSpec()->catchment);
 
		if (this->bus_stops          != nullptr)      ret = std::max<uint>(ret, CA_BUS);
 
		if (this->truck_stops        != nullptr)      ret = std::max<uint>(ret, CA_TRUCK);
 
		if (this->train_station.tile != INVALID_TILE) ret = std::max<uint>(ret, CA_TRAIN);
 
		if (this->ship_station.tile  != INVALID_TILE) ret = std::max<uint>(ret, CA_DOCK);
 
		if (this->airport.tile       != INVALID_TILE) ret = std::max<uint>(ret, this->airport.GetSpec()->catchment);
 
	} else {
 
		if (this->bus_stops != nullptr || this->truck_stops != nullptr || this->train_station.tile != INVALID_TILE || this->ship_station.tile != INVALID_TILE || this->airport.tile != INVALID_TILE) {
 
			ret = CA_UNMODIFIED;
 
@@ -346,10 +346,10 @@ Rect Station::GetCatchmentRect() const
 
	int catchment_radius = this->GetCatchmentRadius();
 

	
 
	Rect ret = {
 
		max<int>(this->rect.left   - catchment_radius, 0),
 
		max<int>(this->rect.top    - catchment_radius, 0),
 
		min<int>(this->rect.right  + catchment_radius, MapMaxX()),
 
		min<int>(this->rect.bottom + catchment_radius, MapMaxY())
 
		std::max<int>(this->rect.left   - catchment_radius, 0),
 
		std::max<int>(this->rect.top    - catchment_radius, 0),
 
		std::min<int>(this->rect.right  + catchment_radius, MapMaxX()),
 
		std::min<int>(this->rect.bottom + catchment_radius, MapMaxY())
 
	};
 

	
 
	return ret;
 
@@ -523,7 +523,7 @@ CommandCost StationRect::BeforeAddTile(T
 
	} else if (!this->PtInExtendedRect(x, y)) {
 
		/* current rect is not empty and new point is outside this rect
 
		 * make new spread-out rectangle */
 
		Rect new_rect = {min(x, this->left), min(y, this->top), max(x, this->right), max(y, this->bottom)};
 
		Rect new_rect = {std::min(x, this->left), std::min(y, this->top), std::max(x, this->right), std::max(y, this->bottom)};
 

	
 
		/* check new rect dimensions against preset max */
 
		int w = new_rect.right - new_rect.left + 1;
src/station_cmd.cpp
Show inline comments
 
@@ -1069,10 +1069,10 @@ CommandCost CanExpandRailStation(const B
 
	TileArea cur_ta = st->train_station;
 

	
 
	/* determine new size of train station region.. */
 
	int x = min(TileX(cur_ta.tile), TileX(new_ta.tile));
 
	int y = min(TileY(cur_ta.tile), TileY(new_ta.tile));
 
	new_ta.w = max(TileX(cur_ta.tile) + cur_ta.w, TileX(new_ta.tile) + new_ta.w) - x;
 
	new_ta.h = max(TileY(cur_ta.tile) + cur_ta.h, TileY(new_ta.tile) + new_ta.h) - y;
 
	int x = std::min(TileX(cur_ta.tile), TileX(new_ta.tile));
 
	int y = std::min(TileY(cur_ta.tile), TileY(new_ta.tile));
 
	new_ta.w = std::max(TileX(cur_ta.tile) + cur_ta.w, TileX(new_ta.tile) + new_ta.w) - x;
 
	new_ta.h = std::max(TileY(cur_ta.tile) + cur_ta.h, TileY(new_ta.tile) + new_ta.h) - y;
 
	new_ta.tile = TileXY(x, y);
 

	
 
	/* make sure the final size is not too big. */
 
@@ -1325,7 +1325,7 @@ CommandCost CmdBuildRailStation(TileInde
 
		/* Perform NewStation checks */
 

	
 
		/* Check if the station size is permitted */
 
		if (HasBit(statspec->disallowed_platforms, min(numtracks - 1, 7)) || HasBit(statspec->disallowed_lengths, min(plat_len - 1, 7))) {
 
		if (HasBit(statspec->disallowed_platforms, std::min(numtracks - 1, 7)) || HasBit(statspec->disallowed_lengths, std::min(plat_len - 1, 7))) {
 
			return CMD_ERROR;
 
		}
 

	
 
@@ -3364,7 +3364,7 @@ static VehicleEnterTileStatus VehicleEnt
 
				return VETSB_ENTERED_STATION | (VehicleEnterTileStatus)(station_id << VETS_STATION_ID_OFFSET); // enter station
 
			} else if (x < stop) {
 
				v->vehstatus |= VS_TRAIN_SLOWING;
 
				uint16 spd = max(0, (stop - x) * 20 - 15);
 
				uint16 spd = std::max(0, (stop - x) * 20 - 15);
 
				if (spd < v->cur_speed) v->cur_speed = spd;
 
			}
 
		}
 
@@ -3456,7 +3456,7 @@ static void TruncateCargo(const CargoSpe
 
		if (source_station == nullptr) continue;
 

	
 
		GoodsEntry &source_ge = source_station->goods[cs->Index()];
 
		source_ge.max_waiting_cargo = max(source_ge.max_waiting_cargo, i->second);
 
		source_ge.max_waiting_cargo = std::max(source_ge.max_waiting_cargo, i->second);
 
	}
 
}
 

	
 
@@ -3512,7 +3512,9 @@ static void UpdateStationRating(Station 
 
				/* NewGRFs expect last speed to be 0xFF when no vehicle has arrived yet. */
 
				uint last_speed = ge->HasVehicleEverTriedLoading() ? ge->last_speed : 0xFF;
 

	
 
				uint32 var18 = min(ge->time_since_pickup, 0xFF) | (min(ge->max_waiting_cargo, 0xFFFF) << 8) | (min(last_speed, 0xFF) << 24);
 
				uint32 var18 = std::min<uint>(ge->time_since_pickup, 0xFFu)
 
					| (std::min<uint>(ge->max_waiting_cargo, 0xFFFFu) << 8)
 
					| (std::min<uint>(last_speed, 0xFFu) << 24);
 
				/* Convert to the 'old' vehicle types */
 
				uint32 var10 = (st->last_vehicle_type == VEH_INVALID) ? 0x0 : (st->last_vehicle_type + 0x10);
 
				uint16 callback = GetCargoCallback(CBID_CARGO_STATION_RATING_CALC, var10, var18, cs);
 
@@ -3571,7 +3573,7 @@ static void UpdateStationRating(Station 
 
					uint32 r = Random();
 
					if (rating <= (int)GB(r, 0, 7)) {
 
						/* Need to have int, otherwise it will just overflow etc. */
 
						waiting = max((int)waiting - (int)((GB(r, 8, 2) - 1) * num_dests), 0);
 
						waiting = std::max((int)waiting - (int)((GB(r, 8, 2) - 1) * num_dests), 0);
 
						waiting_changed = true;
 
					}
 
				}
 
@@ -3587,7 +3589,7 @@ static void UpdateStationRating(Station 
 
					uint difference = waiting - WAITING_CARGO_THRESHOLD;
 
					waiting -= (difference / WAITING_CARGO_CUT_FACTOR);
 

	
 
					waiting = min(waiting, MAX_WAITING_CARGO);
 
					waiting = std::min(waiting, MAX_WAITING_CARGO);
 
					waiting_changed = true;
 
				}
 

	
 
@@ -3801,7 +3803,7 @@ void IncreaseStats(Station *st, const Ve
 
			 * As usage is not such an important figure anyway we just
 
			 * ignore the additional cargo then.*/
 
			IncreaseStats(st, v->cargo_type, next_station_id, v->refit_cap,
 
					min(v->refit_cap, v->cargo.StoredCount()), EUM_INCREASE);
 
					std::min<uint>(v->refit_cap, v->cargo.StoredCount()), EUM_INCREASE);
 
		}
 
	}
 
}
 
@@ -4113,11 +4115,11 @@ void UpdateStationDockingTiles(Station *
 

	
 
	/* Expand the area by a tile on each side while
 
	 * making sure that we remain inside the map. */
 
	int x2 = min(x + area->w + 1, MapSizeX());
 
	int x1 = max(x - 1, 0);
 

	
 
	int y2 = min(y + area->h + 1, MapSizeY());
 
	int y1 = max(y - 1, 0);
 
	int x2 = std::min<int>(x + area->w + 1, MapSizeX());
 
	int x1 = std::max<int>(x - 1, 0);
 

	
 
	int y2 = std::min<int>(y + area->h + 1, MapSizeY());
 
	int y1 = std::max<int>(y - 1, 0);
 

	
 
	TileArea ta(TileXY(x1, y1), TileXY(x2 - 1, y2 - 1));
 
	TILE_AREA_LOOP(tile, ta) {
 
@@ -4586,7 +4588,7 @@ void FlowStat::ScaleToMonthly(uint runti
 
	SharesMap new_shares;
 
	uint share = 0;
 
	for (SharesMap::iterator i = this->shares.begin(); i != this->shares.end(); ++i) {
 
		share = max(share + 1, i->first * 30 / runtime);
 
		share = std::max(share + 1, i->first * 30 / runtime);
 
		new_shares[share] = i->second;
 
		if (this->unrestricted == i->first) this->unrestricted = share;
 
	}
src/station_gui.cpp
Show inline comments
 
@@ -98,7 +98,7 @@ static void FindStationsAroundSelection(
 
	uint y = TileY(location.tile);
 

	
 
	int max_c = 1;
 
	TileArea ta(TileXY(max<int>(0, x - max_c), max<int>(0, y - max_c)), TileXY(min<int>(MapMaxX(), x + location.w + max_c), min<int>(MapMaxY(), y + location.h + max_c)));
 
	TileArea ta(TileXY(std::max<int>(0, x - max_c), std::max<int>(0, y - max_c)), TileXY(std::min<int>(MapMaxX(), x + location.w + max_c), std::min<int>(MapMaxY(), y + location.h + max_c)));
 

	
 
	Station *adjacent = nullptr;
 

	
 
@@ -167,7 +167,7 @@ static void StationsWndShowStationRating
 

	
 
	int colour = cs->rating_colour;
 
	TextColour tc = GetContrastColour(colour);
 
	uint w = (minu(amount, units_full) + 5) / 36;
 
	uint w = (std::min(amount, units_full) + 5) / 36;
 

	
 
	int height = GetCharacterHeight(FS_SMALL);
 

	
 
@@ -189,7 +189,7 @@ static void StationsWndShowStationRating
 
	/* Draw green/red ratings bar (fits into 14 pixels) */
 
	y += height + 2;
 
	GfxFillRect(left + 1, y, left + 14, y, PC_RED);
 
	rating = minu(rating, rating_full) / 16;
 
	rating = std::min<uint>(rating, rating_full) / 16;
 
	if (rating != 0) GfxFillRect(left + 1, y, left + rating, y, PC_GREEN);
 
}
 

	
 
@@ -303,8 +303,8 @@ protected:
 

	
 
		CargoID j;
 
		FOR_EACH_SET_CARGO_ID(j, cargo_filter) {
 
			if (a->goods[j].HasRating()) maxr1 = max(maxr1, a->goods[j].rating);
 
			if (b->goods[j].HasRating()) maxr2 = max(maxr2, b->goods[j].rating);
 
			if (a->goods[j].HasRating()) maxr1 = std::max(maxr1, a->goods[j].rating);
 
			if (b->goods[j].HasRating()) maxr2 = std::max(maxr2, b->goods[j].rating);
 
		}
 

	
 
		return maxr1 < maxr2;
 
@@ -318,8 +318,8 @@ protected:
 

	
 
		for (CargoID j = 0; j < NUM_CARGO; j++) {
 
			if (!HasBit(cargo_filter, j)) continue;
 
			if (a->goods[j].HasRating()) minr1 = min(minr1, a->goods[j].rating);
 
			if (b->goods[j].HasRating()) minr2 = min(minr2, b->goods[j].rating);
 
			if (a->goods[j].HasRating()) minr1 = std::min(minr1, a->goods[j].rating);
 
			if (b->goods[j].HasRating()) minr2 = std::min(minr2, b->goods[j].rating);
 
		}
 

	
 
		return minr1 > minr2;
 
@@ -401,7 +401,7 @@ public:
 
			case WID_STL_BUS:
 
			case WID_STL_AIRPLANE:
 
			case WID_STL_SHIP:
 
				size->height = max<uint>(FONT_HEIGHT_SMALL, 10) + padding.height;
 
				size->height = std::max<uint>(FONT_HEIGHT_SMALL, 10) + padding.height;
 
				break;
 

	
 
			case WID_STL_CARGOALL:
 
@@ -443,7 +443,7 @@ public:
 

	
 
			case WID_STL_LIST: {
 
				bool rtl = _current_text_dir == TD_RTL;
 
				int max = min(this->vscroll->GetPosition() + this->vscroll->GetCapacity(), (uint)this->stations.size());
 
				int max = std::min<size_t>(this->vscroll->GetPosition() + this->vscroll->GetCapacity(), this->stations.size());
 
				int y = r.top + WD_FRAMERECT_TOP;
 
				for (int i = this->vscroll->GetPosition(); i < max; ++i) { // do until max number of stations of owner
 
					const Station *st = this->stations[i];
 
@@ -837,7 +837,7 @@ static const NWidgetPart _nested_station
 
static void DrawCargoIcons(CargoID i, uint waiting, int left, int right, int y)
 
{
 
	int width = ScaleGUITrad(10);
 
	uint num = min((waiting + (width / 2)) / width, (right - left) / width); // maximum is width / 10 icons so it won't overflow
 
	uint num = std::min<uint>((waiting + (width / 2)) / width, (right - left) / width); // maximum is width / 10 icons so it won't overflow
 
	if (num == 0) return;
 

	
 
	SpriteID sprite = CargoSpec::Get(i)->GetCargoIcon();
 
@@ -1393,7 +1393,7 @@ struct StationViewWindow : public Window
 
			case WID_SV_WAITING:
 
				resize->height = FONT_HEIGHT_NORMAL;
 
				size->height = WD_FRAMERECT_TOP + 4 * resize->height + WD_FRAMERECT_BOTTOM;
 
				this->expand_shrink_width = max(GetStringBoundingBox("-").width, GetStringBoundingBox("+").width) + WD_FRAMERECT_LEFT + WD_FRAMERECT_RIGHT;
 
				this->expand_shrink_width = std::max(GetStringBoundingBox("-").width, GetStringBoundingBox("+").width) + WD_FRAMERECT_LEFT + WD_FRAMERECT_RIGHT;
 
				break;
 

	
 
			case WID_SV_ACCEPT_RATING_LIST:
 
@@ -2219,7 +2219,7 @@ static const T *FindStationsNearby(TileA
 
	for (const BaseStation *st : BaseStation::Iterate()) {
 
		if (T::IsExpected(st) && !st->IsInUse() && st->owner == _local_company) {
 
			/* Include only within station spread (yes, it is strictly less than) */
 
			if (max(DistanceMax(ta.tile, st->xy), DistanceMax(TILE_ADDXY(ta.tile, ta.w - 1, ta.h - 1), st->xy)) < _settings_game.station.station_spread) {
 
			if (std::max(DistanceMax(ta.tile, st->xy), DistanceMax(TILE_ADDXY(ta.tile, ta.w - 1, ta.h - 1), st->xy)) < _settings_game.station.station_spread) {
 
				_deleted_stations_nearby.push_back({st->xy, st->index});
 

	
 
				/* Add the station when it's within where we're going to build */
 
@@ -2234,8 +2234,8 @@ static const T *FindStationsNearby(TileA
 
	/* Only search tiles where we have a chance to stay within the station spread.
 
	 * The complete check needs to be done in the callback as we don't know the
 
	 * extent of the found station, yet. */
 
	if (distant_join && min(ta.w, ta.h) >= _settings_game.station.station_spread) return nullptr;
 
	uint max_dist = distant_join ? _settings_game.station.station_spread - min(ta.w, ta.h) : 1;
 
	if (distant_join && std::min(ta.w, ta.h) >= _settings_game.station.station_spread) return nullptr;
 
	uint max_dist = distant_join ? _settings_game.station.station_spread - std::min(ta.w, ta.h) : 1;
 

	
 
	TileIndex tile = TileAddByDir(ctx.tile, DIR_N);
 
	CircularTileSearch(&tile, max_dist, ta.w, ta.h, AddNearbyStation<T>, &ctx);
 
@@ -2319,7 +2319,7 @@ struct SelectStationWindow : Window {
 
			y += this->resize.step_height;
 
		}
 

	
 
		for (uint i = max<uint>(1, this->vscroll->GetPosition()); i <= _stations_nearby_list.size(); ++i, y += this->resize.step_height) {
 
		for (uint i = std::max<uint>(1, this->vscroll->GetPosition()); i <= _stations_nearby_list.size(); ++i, y += this->resize.step_height) {
 
			/* Don't draw anything if it extends past the end of the window. */
 
			if (i - this->vscroll->GetPosition() >= this->vscroll->GetCapacity()) break;
 

	
src/station_kdtree.h
Show inline comments
 
@@ -29,10 +29,10 @@ template <typename Func>
 
void ForAllStationsRadius(TileIndex center, uint radius, Func func)
 
{
 
	uint16 x1, y1, x2, y2;
 
	x1 = (uint16)max<int>(0, TileX(center) - radius);
 
	x2 = (uint16)min<int>(TileX(center) + radius + 1, MapSizeX());
 
	y1 = (uint16)max<int>(0, TileY(center) - radius);
 
	y2 = (uint16)min<int>(TileY(center) + radius + 1, MapSizeY());
 
	x1 = (uint16)std::max<int>(0, TileX(center) - radius);
 
	x2 = (uint16)std::min<int>(TileX(center) + radius + 1, MapSizeX());
 
	y1 = (uint16)std::max<int>(0, TileY(center) - radius);
 
	y2 = (uint16)std::min<int>(TileY(center) + radius + 1, MapSizeY());
 

	
 
	_station_kdtree.FindContained(x1, y1, x2, y2, [&](StationID id) {
 
		func(Station::Get(id));
src/statusbar_gui.cpp
Show inline comments
 
@@ -120,7 +120,7 @@ struct StatusBarWindow : Window {
 

	
 
			case WID_S_RIGHT: {
 
				int64 max_money = UINT32_MAX;
 
				for (const Company *c : Company::Iterate()) max_money = max<int64>(c->money, max_money);
 
				for (const Company *c : Company::Iterate()) max_money = std::max<int64>(c->money, max_money);
 
				SetDParam(0, 100LL * max_money);
 
				d = GetStringBoundingBox(STR_COMPANY_MONEY);
 
				break;
 
@@ -137,7 +137,7 @@ struct StatusBarWindow : Window {
 

	
 
	void DrawWidget(const Rect &r, int widget) const override
 
	{
 
		int text_offset = max(0, ((int)(r.bottom - r.top + 1) - FONT_HEIGHT_NORMAL) / 2); // Offset for rendering the text vertically centered
 
		int text_offset = std::max(0, ((int)(r.bottom - r.top + 1) - FONT_HEIGHT_NORMAL) / 2); // Offset for rendering the text vertically centered
 
		int text_top = r.top + text_offset;
 
		switch (widget) {
 
			case WID_S_LEFT:
 
@@ -185,7 +185,7 @@ struct StatusBarWindow : Window {
 

	
 
				if (!this->reminder_timeout.HasElapsed()) {
 
					Dimension icon_size = GetSpriteSize(SPR_UNREAD_NEWS);
 
					DrawSprite(SPR_UNREAD_NEWS, PAL_NONE, r.right - WD_FRAMERECT_RIGHT - icon_size.width, r.top + max(0, ((int)(r.bottom - r.top + 1) - (int)icon_size.height) / 2));
 
					DrawSprite(SPR_UNREAD_NEWS, PAL_NONE, r.right - WD_FRAMERECT_RIGHT - icon_size.width, r.top + std::max(0, ((int)(r.bottom - r.top + 1) - (int)icon_size.height) / 2));
 
				}
 
				break;
 
		}
src/stdafx.h
Show inline comments
 
@@ -85,6 +85,7 @@
 
#	define INT8_MIN   (-INT8_MAX - 1)
 
#endif
 

	
 
#include <algorithm>
 
#include <cstdio>
 
#include <cstddef>
 
#include <cstring>
src/story_gui.cpp
Show inline comments
 
@@ -437,8 +437,8 @@ protected:
 
				int right_offset = (right_width == 0) ? 0 : (right_width + element_dist);
 
				if (left_offset + right_offset + min_required_width >= max_width) {
 
					/* Width of floats leave too little for main content, push down */
 
					main_y = max(main_y, left_y);
 
					main_y = max(main_y, right_y);
 
					main_y = std::max(main_y, left_y);
 
					main_y = std::max(main_y, right_y);
 
					left_width = right_width = 0;
 
					left_offset = right_offset = 0;
 
					/* Do not add element_dist here, to keep together elements which were supposed to float besides each other. */
 
@@ -469,7 +469,7 @@ protected:
 
				main_y += element_dist;
 
				/* Clear all floats */
 
				left_width = right_width = 0;
 
				left_y = right_y = main_y = max(main_y, max(left_y, right_y));
 
				left_y = right_y = main_y = std::max({main_y, left_y, right_y});
 
				left_floats.clear();
 
				right_floats.clear();
 
			} else {
 
@@ -478,7 +478,7 @@ protected:
 
				int &cur_y = (fl == ElementFloat::Left) ? left_y : right_y;
 
				std::vector<size_t> &cur_floats = (fl == ElementFloat::Left) ? left_floats : right_floats;
 
				/* Position element */
 
				cur_width = max(cur_width, this->GetPageElementFloatWidth(*pe));
 
				cur_width = std::max(cur_width, this->GetPageElementFloatWidth(*pe));
 
				LayoutCacheElement ce{ pe, {} };
 
				ce.bounds.left = (fl == ElementFloat::Left) ? 0 : (max_width - cur_width);
 
				ce.bounds.right = (fl == ElementFloat::Left) ? cur_width : max_width;
 
@@ -507,7 +507,7 @@ protected:
 
		this->EnsureStoryPageElementLayout();
 

	
 
		/* The largest bottom coordinate of any element is the height of the content */
 
		uint max_y = std::accumulate(this->layout_cache.begin(), this->layout_cache.end(), 0, [](uint max_y, const LayoutCacheElement &ce) -> uint { return max<uint>(max_y, ce.bounds.bottom); });
 
		uint max_y = std::accumulate(this->layout_cache.begin(), this->layout_cache.end(), 0, [](uint max_y, const LayoutCacheElement &ce) -> uint { return std::max<uint>(max_y, ce.bounds.bottom); });
 

	
 
		return max_y;
 
	}
 
@@ -526,7 +526,7 @@ protected:
 
	void DrawActionElement(int &y_offset, int width, int line_height, SpriteID action_sprite, StringID string_id = STR_JUST_RAW_STRING) const
 
	{
 
		Dimension sprite_dim = GetSpriteSize(action_sprite);
 
		uint element_height = max(sprite_dim.height, (uint)line_height);
 
		uint element_height = std::max(sprite_dim.height, (uint)line_height);
 

	
 
		uint sprite_top = y_offset + (element_height - sprite_dim.height) / 2;
 
		uint text_top = y_offset + (element_height - line_height) / 2;
src/strgen/strgen.cpp
Show inline comments
 
@@ -304,7 +304,7 @@ struct HeaderFileWriter : HeaderWriter, 
 
		/* Find the plural form with the most amount of cases. */
 
		int max_plural_forms = 0;
 
		for (uint i = 0; i < lengthof(_plural_forms); i++) {
 
			max_plural_forms = max(max_plural_forms, _plural_forms[i].plural_count);
 
			max_plural_forms = std::max(max_plural_forms, _plural_forms[i].plural_count);
 
		}
 

	
 
		fprintf(this->fh,
src/strgen/strgen_base.cpp
Show inline comments
 
@@ -388,7 +388,7 @@ void EmitPlural(Buffer *buffer, char *bu
 
	int argidx = _cur_argidx;
 
	int offset = -1;
 
	int expected = _plural_forms[_lang.plural_form].plural_count;
 
	const char **words = AllocaM(const char *, max(expected, MAX_PLURALS));
 
	const char **words = AllocaM(const char *, std::max(expected, MAX_PLURALS));
 
	int nw = 0;
 

	
 
	/* Parse out the number, if one exists. Otherwise default to prev arg. */
 
@@ -489,7 +489,7 @@ static uint ResolveCaseName(const char *
 
{
 
	/* First get a clean copy of only the case name, then resolve it. */
 
	char case_str[CASE_GENDER_LEN];
 
	len = min(lengthof(case_str) - 1, len);
 
	len = std::min(lengthof(case_str) - 1, len);
 
	memcpy(case_str, str, len);
 
	case_str[len] = '\0';
 

	
src/string.cpp
Show inline comments
 
@@ -62,7 +62,7 @@ int CDECL vseprintf(char *str, const cha
 
{
 
	ptrdiff_t diff = last - str;
 
	if (diff < 0) return 0;
 
	return min((int)diff, vsnprintf(str, diff + 1, format, ap));
 
	return std::min(static_cast<int>(diff), vsnprintf(str, diff + 1, format, ap));
 
}
 

	
 
/**
src/strings.cpp
Show inline comments
 
@@ -108,7 +108,7 @@ void SetDParamMaxValue(uint n, uint64 ma
 
		num_digits++;
 
		max_value /= 10;
 
	}
 
	SetDParamMaxDigits(n, max(min_count, num_digits), size);
 
	SetDParamMaxDigits(n, std::max(min_count, num_digits), size);
 
}
 

	
 
/**
 
@@ -1663,7 +1663,7 @@ static char *GetSpecialNameString(char *
 
{
 
	switch (ind) {
 
		case 1: // not used
 
			return strecpy(buff, _silly_company_names[min(args->GetInt32() & 0xFFFF, lengthof(_silly_company_names) - 1)], last);
 
			return strecpy(buff, _silly_company_names[std::min<uint>(args->GetInt32() & 0xFFFF, lengthof(_silly_company_names) - 1)], last);
 

	
 
		case 2: // used for Foobar & Co company names
 
			return GenAndCoName(buff, args->GetInt32(), last);
src/terraform_cmd.cpp
Show inline comments
 
@@ -240,8 +240,8 @@ CommandCost CmdTerraformLand(TileIndex t
 
			int z_E = TerraformGetHeightOfTile(&ts, tile + TileDiffXY(0, 1));
 

	
 
			/* Find min and max height of tile */
 
			int z_min = min(min(z_N, z_W), min(z_S, z_E));
 
			int z_max = max(max(z_N, z_W), max(z_S, z_E));
 
			int z_min = std::min({z_N, z_W, z_S, z_E});
 
			int z_max = std::max({z_N, z_W, z_S, z_E});
 

	
 
			/* Compute tile slope */
 
			Slope tileh = (z_max > z_min + 1 ? SLOPE_STEEP : SLOPE_FLAT);
src/terraform_gui.cpp
Show inline comments
 
@@ -409,13 +409,13 @@ static void CommonRaiseLowerBigLand(Tile
 
			/* Raise land */
 
			h = MAX_TILE_HEIGHT;
 
			TILE_AREA_LOOP(tile2, ta) {
 
				h = min(h, TileHeight(tile2));
 
				h = std::min(h, TileHeight(tile2));
 
			}
 
		} else {
 
			/* Lower land */
 
			h = 0;
 
			TILE_AREA_LOOP(tile2, ta) {
 
				h = max(h, TileHeight(tile2));
 
				h = std::max(h, TileHeight(tile2));
 
			}
 
		}
 

	
 
@@ -547,8 +547,8 @@ struct ScenarioEditorLandscapeGeneration
 
	{
 
		if (widget != WID_ETT_DOTS) return;
 

	
 
		size->width  = max<uint>(size->width,  ScaleGUITrad(59));
 
		size->height = max<uint>(size->height, ScaleGUITrad(31));
 
		size->width  = std::max<uint>(size->width,  ScaleGUITrad(59));
 
		size->height = std::max<uint>(size->height, ScaleGUITrad(31));
 
	}
 

	
 
	void DrawWidget(const Rect &r, int widget) const override
src/textfile_gui.cpp
Show inline comments
 
@@ -98,7 +98,7 @@ uint TextfileWindow::GetContentHeight()
 
			resize->height = 1;
 

	
 
			size->height = 4 * resize->height + TOP_SPACING + BOTTOM_SPACING; // At least 4 lines are visible.
 
			size->width = max(200u, size->width); // At least 200 pixels wide.
 
			size->width = std::max(200u, size->width); // At least 200 pixels wide.
 
			break;
 
	}
 
}
 
@@ -112,7 +112,7 @@ void TextfileWindow::SetupScrollbars()
 
	} else {
 
		uint max_length = 0;
 
		for (uint i = 0; i < this->lines.size(); i++) {
 
			max_length = max(max_length, GetStringBoundingBox(this->lines[i], FS_MONO).width);
 
			max_length = std::max(max_length, GetStringBoundingBox(this->lines[i], FS_MONO).width);
 
		}
 
		this->vscroll->SetCount((uint)this->lines.size() * FONT_HEIGHT_MONO);
 
		this->hscroll->SetCount(max_length + WD_FRAMETEXT_LEFT + WD_FRAMETEXT_RIGHT);

Changeset was too big and was cut off... Show full diff anyway

0 comments (0 inline, 0 general)