35 #include "table/strings.h"
63 #define MK(a, b) {a, b, INVALID_INDUSTRYTYPE, 0, INVALID_COMPANY, true, false, false}
66 #define MC(col_break) {0, STR_TINY_BLACK_HEIGHT, INVALID_INDUSTRYTYPE, 0, INVALID_COMPANY, true, false, col_break}
69 #define MO(a, b) {a, b, INVALID_INDUSTRYTYPE, 0, INVALID_COMPANY, true, false, false}
72 #define MOEND() {0, 0, INVALID_INDUSTRYTYPE, 0, OWNER_NONE, true, true, false}
75 #define MKEND() {0, STR_NULL, INVALID_INDUSTRYTYPE, 0, INVALID_COMPANY, true, true, false}
81 #define MS(a, b) {a, b, INVALID_INDUSTRYTYPE, 0, INVALID_COMPANY, true, false, true}
86 MK(
PC_GREY, STR_SMALLMAP_LEGENDA_RAILROADS),
110 MK(
PC_RED, STR_SMALLMAP_LEGENDA_TRAINS),
115 MS(
PC_BLACK, STR_SMALLMAP_LEGENDA_TRANSPORT_ROUTES),
122 MK(
PC_GREY, STR_SMALLMAP_LEGENDA_RAILROADS),
126 MK(
PC_ORANGE, STR_SMALLMAP_LEGENDA_TRUCK_LOADING_BAY),
128 MK(
PC_RED, STR_SMALLMAP_LEGENDA_AIRPORT_HELIPORT),
145 MK(
PC_BLACK, STR_SMALLMAP_LEGENDA_TRANSPORT_ROUTES),
152 MO(0x00, STR_SMALLMAP_LEGENDA_NO_OWNER),
259 #define MKCOLOUR(x) TO_LE32X(x)
261 #define MKCOLOUR_XXXX(x) (MKCOLOUR(0x01010101) * (uint)(x))
262 #define MKCOLOUR_0XX0(x) (MKCOLOUR(0x00010100) * (uint)(x))
263 #define MKCOLOUR_X00X(x) (MKCOLOUR(0x01000001) * (uint)(x))
265 #define MKCOLOUR_XYYX(x, y) (MKCOLOUR_X00X(x) | MKCOLOUR_0XX0(y))
267 #define MKCOLOUR_0000 MKCOLOUR_XXXX(0x00)
268 #define MKCOLOUR_F00F MKCOLOUR_X00X(0xFF)
269 #define MKCOLOUR_FFFF MKCOLOUR_XXXX(0xFF)
315 uint deltas[][2] = { { 24, 2 }, { 48, 4 }, { 72, 6 }, { 120, 10 }, { 180, 15 }, { 240, 20 }, {
MAX_TILE_HEIGHT + 1, 25 }};
320 uint delta = deltas[i][1];
323 int rows =
CeilDiv(total_entries, 2);
348 _legend_land_owners[i].
company = c->index;
350 _legend_land_owners[i].
col_break =
false;
351 _legend_land_owners[i].
end =
false;
357 _legend_land_owners[i].
end =
true;
368 static inline uint32_t ApplyMask(uint32_t colour,
const AndOr *mask)
370 return (colour & mask->mand) | mask->mor;
376 {MKCOLOUR_0000 , MKCOLOUR_FFFF},
377 {MKCOLOUR_0XX0(
PC_GREY ), MKCOLOUR_F00F},
378 {MKCOLOUR_0XX0(
PC_BLACK ), MKCOLOUR_F00F},
380 {MKCOLOUR_0000 , MKCOLOUR_FFFF},
382 {MKCOLOUR_XXXX(
PC_WATER ), MKCOLOUR_0000},
383 {MKCOLOUR_0000 , MKCOLOUR_FFFF},
385 {MKCOLOUR_0000 , MKCOLOUR_FFFF},
387 {MKCOLOUR_0XX0(
PC_GREY ), MKCOLOUR_F00F},
392 {MKCOLOUR_0000 , MKCOLOUR_FFFF},
393 {MKCOLOUR_0XX0(
PC_BLACK ), MKCOLOUR_F00F},
394 {MKCOLOUR_0XX0(
PC_BLACK ), MKCOLOUR_F00F},
396 {MKCOLOUR_0000 , MKCOLOUR_FFFF},
397 {MKCOLOUR_0XX0(
PC_BLACK ), MKCOLOUR_F00F},
398 {MKCOLOUR_XXXX(
PC_WATER ), MKCOLOUR_0000},
399 {MKCOLOUR_0000 , MKCOLOUR_FFFF},
401 {MKCOLOUR_0000 , MKCOLOUR_FFFF},
403 {MKCOLOUR_0XX0(
PC_BLACK ), MKCOLOUR_F00F},
474 case STATION_AIRPORT:
return MKCOLOUR_XXXX(
PC_RED);
475 case STATION_TRUCK:
return MKCOLOUR_XXXX(
PC_ORANGE);
476 case STATION_BUS:
return MKCOLOUR_XXXX(
PC_YELLOW);
478 default:
return MKCOLOUR_FFFF;
498 if (rti !=
nullptr) {
529 static const uint32_t _vegetation_clear_bits[] = {
639 static const uint INDUSTRY_MIN_NUMBER_OF_COLUMNS = 2;
651 std::unique_ptr<LinkGraphOverlay> overlay;
659 static inline Point SmallmapRemapCoords(
int x,
int y)
706 return width / this->column_width;
751 heightmap_scheme.height_colours.resize(heights);
753 for (
size_t z = 0; z < heights; z++) {
754 size_t access_index = (heightmap_scheme.height_colours_base.size() * z) / heights;
757 heightmap_scheme.height_colours[z] = heightmap_scheme.height_colours_base[access_index];
778 return std::max({this->min_number_of_fixed_rows, num_rows_linkstats, num_rows_others});
796 bool changes =
false;
797 for (
int i = begin_legend_item; i != end_legend_item; i++) {
798 bool new_state = (i == click_pos);
799 if (legend[i].show_on_map != new_state) {
806 for (
int i = begin_legend_item; i != end_legend_item; i++) {
814 if (this->map_type == SMT_INDUSTRY) this->BreakIndustryChainLink();
824 this->map_type = map_type;
827 this->SetupWidgetData();
829 if (map_type == SMT_LINKSTATS) this->overlay->SetDirty();
830 if (map_type != SMT_INDUSTRY) this->BreakIndustryChainLink();
867 this->subscroll = sub;
868 if (this->map_type == SMT_LINKSTATS) this->overlay->SetDirty();
882 Point upper_left = this->RemapTile(upper_left_smallmap_coord.x / (
int)
TILE_SIZE, upper_left_smallmap_coord.y / (
int)
TILE_SIZE);
883 upper_left.x -= this->subscroll;
885 Point lower_right = this->RemapTile(lower_right_smallmap_coord.x / (
int)
TILE_SIZE, lower_right_smallmap_coord.y / (
int)
TILE_SIZE);
886 lower_right.x -= this->subscroll;
910 void *dst_ptr_abs_end = blitter->
MoveTo(_screen.dst_ptr, 0, _screen.height);
918 if (dst < _screen.dst_ptr)
continue;
919 if (dst >= dst_ptr_abs_end)
continue;
923 if (min_xy == 1 && (xc == 0 || yc == 0)) {
924 if (this->zoom == 1)
continue;
926 ta =
TileArea(
TileXY(std::max(min_xy, xc), std::max(min_xy, yc)), this->zoom - (xc == 0), this->zoom - (yc == 0));
932 uint32_t val = this->GetTileColours(ta);
933 uint8_t *val8 = (uint8_t *)&val;
934 int idx = std::max(0, -start_pos);
935 for (
int pos = std::max(0, start_pos); pos < end_pos; pos++) {
936 blitter->
SetPixel(dst, idx, 0, val8[idx]);
940 }
while (xc += this->zoom, yc += this->zoom, dst = blitter->
MoveTo(dst, pitch, 0), --reps != 0);
957 int y = pt.y - dpi->top;
961 int x = pt.x - this->subscroll - 3 - dpi->left;
965 if (++x != 0)
continue;
967 }
else if (x >= dpi->width - 1) {
969 if (x != dpi->width - 1)
continue;
977 blitter->
SetPixel(dpi->dst_ptr, x, y, colour);
978 if (!skip) blitter->
SetPixel(dpi->dst_ptr, x + 1, y, colour);
991 int x = pt.x - this->subscroll - (t->cache.sign.width_small >> 1);
992 int y = pt.y + vertical_padding;
995 if (x + t->cache.sign.width_small > dpi->left &&
996 x < dpi->left + dpi->width &&
998 y < dpi->top + dpi->height) {
1001 DrawString(x, x + t->cache.sign.width_small, y, STR_SMALLMAP_TOWN);
1012 if (this->map_type != SMT_INDUSTRY)
return;
1020 if (is_blinking)
continue;
1028 const TileIndex &tile = i->location.GetCenterTile();
1030 const int x = pt.x - this->subscroll - (legend_text_width / 2);
1031 const int y = pt.y + vertical_padding;
1034 if (x + legend_text_width > dpi->left &&
1035 x < dpi->left + dpi->width &&
1037 y < dpi->top + dpi->height) {
1062 GfxFillRect(dpi->left, dpi->top, dpi->left + dpi->width - 1, dpi->top + dpi->height - 1,
PC_BLACK);
1066 Point tile = this->PixelToTile(dpi->left, dpi->top, &dx);
1067 int tile_x = this->scroll_x / (int)
TILE_SIZE + tile.x;
1068 int tile_y = this->scroll_y / (
int)
TILE_SIZE + tile.y;
1070 void *ptr = blitter->
MoveTo(dpi->dst_ptr, -dx - 4, 0);
1077 if (x >= dpi->width)
break;
1079 int end_pos = std::min(dpi->width, x + 4);
1080 int reps = (dpi->height - y + 1) / 2;
1082 this->DrawSmallMapColumn(ptr, tile_x, tile_y, dpi->pitch * 2, reps, x, end_pos, blitter);
1087 tile_y += this->zoom;
1089 ptr = blitter->
MoveTo(ptr, 0, 1);
1091 tile_x -= this->zoom;
1093 ptr = blitter->
MoveTo(ptr, 0, -1);
1095 ptr = blitter->
MoveTo(ptr, 2, 0);
1100 if (this->map_type == SMT_CONTOUR || this->map_type == SMT_VEHICLES) this->DrawVehicles(dpi, blitter);
1103 if (this->map_type == SMT_LINKSTATS) this->overlay->Draw(dpi);
1105 const int map_labels_vertical_padding =
ScaleGUITrad(2);
1108 if (this->show_towns) this->DrawTowns(dpi, map_labels_vertical_padding);
1111 if (this->show_ind_names) this->DrawIndustryNames(dpi, map_labels_vertical_padding);
1114 this->DrawMapIndicators();
1125 int x_offset = tile_x - this->scroll_x / (int)
TILE_SIZE;
1126 int y_offset = tile_y - this->scroll_y / (int)
TILE_SIZE;
1128 if (this->zoom == 1)
return SmallmapRemapCoords(x_offset, y_offset);
1131 if (x_offset < 0) x_offset -= this->zoom - 1;
1132 if (y_offset < 0) y_offset -= this->zoom - 1;
1134 return SmallmapRemapCoords(x_offset / this->zoom, y_offset / this->zoom);
1149 if (add_sub) px += this->subscroll;
1153 Point pt = {((py >> 1) - (px >> 2)) * this->zoom, ((py >> 1) + (px >> 2)) * this->zoom};
1181 assert(x >= 0 && y >= 0);
1184 Point tile_xy = PixelToTile(x, y, &new_sub,
false);
1191 scroll.x = (tx + this->zoom) *
TILE_SIZE;
1192 scroll.y = (ty - this->zoom) *
TILE_SIZE;
1195 scroll.x = (tx + 2 * this->zoom) *
TILE_SIZE;
1196 scroll.y = (ty - 2 * this->zoom) *
TILE_SIZE;
1209 static const int zoomlevels[] = {1, 2, 4, 6, 8};
1210 static const int MIN_ZOOM_INDEX = 0;
1211 static const int MAX_ZOOM_INDEX =
lengthof(zoomlevels) - 1;
1213 int new_index, cur_index, sub;
1216 case ZLC_INITIALIZE:
1218 new_index = MIN_ZOOM_INDEX;
1219 tile.x = tile.y = 0;
1224 for (cur_index = MIN_ZOOM_INDEX; cur_index <= MAX_ZOOM_INDEX; cur_index++) {
1225 if (this->zoom == zoomlevels[cur_index])
break;
1227 assert(cur_index <= MAX_ZOOM_INDEX);
1229 tile = this->PixelToTile(zoom_pt->x, zoom_pt->y, &sub);
1230 new_index =
Clamp(cur_index + ((change == ZLC_ZOOM_IN) ? -1 : 1), MIN_ZOOM_INDEX, MAX_ZOOM_INDEX);
1233 default: NOT_REACHED();
1236 if (new_index != cur_index) {
1237 this->zoom = zoomlevels[new_index];
1238 if (cur_index >= 0) {
1239 Point new_tile = this->PixelToTile(zoom_pt->x, zoom_pt->y, &sub);
1240 this->SetNewScroll(this->scroll_x + (tile.x - new_tile.x) *
TILE_SIZE,
1241 this->scroll_y + (tile.y - new_tile.y) *
TILE_SIZE, sub);
1242 }
else if (this->map_type == SMT_LINKSTATS) {
1243 this->overlay->SetDirty();
1245 this->SetWidgetDisabledState(
WID_SM_ZOOM_IN, this->zoom == zoomlevels[MIN_ZOOM_INDEX]);
1246 this->SetWidgetDisabledState(
WID_SM_ZOOM_OUT, this->zoom == zoomlevels[MAX_ZOOM_INDEX]);
1256 CargoTypes cargo_mask = 0;
1260 this->overlay->SetCargoMask(cargo_mask);
1271 int industry_names_select_plane;
1272 int select_buttons_plane;
1273 switch (this->map_type) {
1275 legend_tooltip = STR_SMALLMAP_TOOLTIP_INDUSTRY_SELECTION;
1276 enable_all_tooltip = STR_SMALLMAP_TOOLTIP_ENABLE_ALL_INDUSTRIES;
1277 disable_all_tooltip = STR_SMALLMAP_TOOLTIP_DISABLE_ALL_INDUSTRIES;
1278 industry_names_select_plane = 0;
1279 select_buttons_plane = 0;
1283 legend_tooltip = STR_SMALLMAP_TOOLTIP_COMPANY_SELECTION;
1284 enable_all_tooltip = STR_SMALLMAP_TOOLTIP_ENABLE_ALL_COMPANIES;
1285 disable_all_tooltip = STR_SMALLMAP_TOOLTIP_DISABLE_ALL_COMPANIES;
1286 industry_names_select_plane =
SZSP_NONE;
1287 select_buttons_plane = 0;
1291 legend_tooltip = STR_SMALLMAP_TOOLTIP_CARGO_SELECTION;
1292 enable_all_tooltip = STR_SMALLMAP_TOOLTIP_ENABLE_ALL_CARGOS;
1293 disable_all_tooltip = STR_SMALLMAP_TOOLTIP_DISABLE_ALL_CARGOS;
1294 industry_names_select_plane =
SZSP_NONE;
1295 select_buttons_plane = 0;
1299 legend_tooltip = STR_NULL;
1300 enable_all_tooltip = STR_NULL;
1301 disable_all_tooltip = STR_NULL;
1302 industry_names_select_plane =
SZSP_NONE;
1303 select_buttons_plane = 1;
1307 this->GetWidget<NWidgetCore>(
WID_SM_LEGEND)->SetDataTip(STR_NULL, legend_tooltip);
1308 this->GetWidget<NWidgetCore>(
WID_SM_ENABLE_ALL)->SetDataTip(STR_SMALLMAP_ENABLE_ALL, enable_all_tooltip);
1309 this->GetWidget<NWidgetCore>(
WID_SM_DISABLE_ALL)->SetDataTip(STR_SMALLMAP_DISABLE_ALL, disable_all_tooltip);
1342 if (this->map_type == SMT_INDUSTRY) {
1369 switch (this->map_type) {
1385 case SMT_VEGETATION:
1391 default: NOT_REACHED();
1404 uint columns = this->GetNumberColumnsLegend(wi->
current_x);
1405 uint number_of_rows = this->GetNumberRowsLegend(columns);
1406 if (line >= number_of_rows)
return -1;
1409 int x = pt.x - wi->
pos_x;
1413 return (column * number_of_rows) + line;
1419 if (this->map_type == SMT_LINKSTATS) {
1420 CompanyMask company_mask = this->GetOverlayCompanyMask();
1421 if (this->overlay->GetCompanyMask() != company_mask) {
1422 this->overlay->SetCompanyMask(company_mask);
1424 this->overlay->SetDirty();
1436 this->UpdateLinks();
1445 this->UpdateLinks();
1455 this->overlay = std::make_unique<LinkGraphOverlay>(
this,
WID_SM_MAP, 0, this->GetOverlayCompanyMask(), 1);
1456 this->CreateNestedTree();
1459 this->RebuildColourIndexIfNecessary();
1466 this->SetupWidgetData();
1467 this->FinishInitNested(window_number);
1469 this->SetZoomLevel(ZLC_INITIALIZE,
nullptr);
1470 this->SmallMapCenterOnCurrentPos();
1471 this->SetOverlayCargoMask();
1486 this->SetNewScroll(sxy.x, sxy.y, sub);
1499 Point ret = this->RemapTile(x, y);
1504 ret.x -= 3 + this->subscroll;
1508 void Close([[maybe_unused]]
int data)
override
1510 this->BreakIndustryChainLink();
1514 void SetStringParameters(
WidgetID widget)
const override
1518 SetDParam(0, STR_SMALLMAP_TYPE_CONTOURS + this->map_type);
1526 this->min_number_of_columns = INDUSTRY_MIN_NUMBER_OF_COLUMNS;
1528 for (uint i = 0; i <
lengthof(_legend_table); i++) {
1530 uint num_columns = 1;
1533 if (i == SMT_INDUSTRY) {
1536 str = STR_SMALLMAP_INDUSTRY;
1537 }
else if (i == SMT_LINKSTATS) {
1539 str = STR_SMALLMAP_LINKSTATS;
1540 }
else if (i == SMT_OWNER) {
1550 str = STR_SMALLMAP_COMPANY;
1555 if (tbl->col_break) {
1556 this->min_number_of_fixed_rows = std::max(this->min_number_of_fixed_rows, height);
1565 this->min_number_of_fixed_rows = std::max(this->min_number_of_fixed_rows, height);
1566 this->min_number_of_columns = std::max(this->min_number_of_columns, num_columns);
1581 if (this->map_type == SMT_OWNER) {
1586 this->InvalidateData(1);
1592 this->DrawWidgets();
1595 void DrawWidget(
const Rect &r,
WidgetID widget)
const override
1602 this->DrawSmallMap(&new_dpi);
1607 uint columns = this->GetNumberColumnsLegend(r.
Width());
1608 uint number_of_rows = this->GetNumberRowsLegend(columns);
1619 switch (this->map_type) {
1621 string = STR_SMALLMAP_INDUSTRY;
1624 string = STR_SMALLMAP_LINKSTATS;
1627 string = STR_SMALLMAP_COMPANY;
1634 if (tbl->col_break || ((this->map_type == SMT_INDUSTRY || this->map_type == SMT_OWNER || this->map_type == SMT_LINKSTATS) && i++ >= number_of_rows)) {
1637 int x = rtl ? -(int)this->column_width : this->column_width;
1638 int y = origin.top - text.top;
1644 uint8_t legend_colour = tbl->colour;
1646 switch (this->map_type) {
1663 if (this->map_type == SMT_OWNER)
SetDParam(0, tbl->company);
1664 if (!tbl->show_on_map) {
1692 void OnClick([[maybe_unused]]
Point pt,
WidgetID widget, [[maybe_unused]]
int click_count)
override
1696 if (click_count > 0) this->mouse_capture_widget = widget;
1701 pt = this->PixelToTile(pt.x - wid->
pos_x, pt.y - wid->
pos_y, &sub);
1712 this->SetZoomLevel((widget ==
WID_SM_ZOOM_IN) ? ZLC_ZOOM_IN : ZLC_ZOOM_OUT, &zoom_pt);
1729 this->SmallMapCenterOnCurrentPos();
1735 this->show_towns = !this->show_towns;
1743 this->show_ind_names = !this->show_ind_names;
1751 if (this->map_type == SMT_INDUSTRY || this->map_type == SMT_LINKSTATS || this->map_type == SMT_OWNER) {
1752 int click_pos = this->GetPositionOnLegend(pt);
1753 if (click_pos < 0)
break;
1756 if (this->map_type == SMT_INDUSTRY) {
1761 }
else if (this->map_type == SMT_LINKSTATS) {
1764 this->SetOverlayCargoMask();
1766 }
else if (this->map_type == SMT_OWNER) {
1778 switch (this->map_type) {
1781 this->BreakIndustryChainLink();
1792 for (;!tbl->
end && tbl->
legend != STR_LINKGRAPH_LEGEND_UNUSED; ++tbl) {
1795 if (this->map_type == SMT_LINKSTATS) this->SetOverlayCargoMask();
1818 if (!gui_scope)
return;
1828 if (this->map_type != SMT_INDUSTRY) this->SwitchMapType(SMT_INDUSTRY);
1837 this->RebuildColourIndexIfNecessary();
1840 default: NOT_REACHED();
1853 void OnMouseWheel(
int wheel)
override
1857 int cursor_x = _cursor.
pos.x - this->left - wid->
pos_x;
1858 int cursor_y = _cursor.
pos.y - this->top - wid->
pos_y;
1860 Point pt = {cursor_x, cursor_y};
1861 this->SetZoomLevel((wheel < 0) ? ZLC_ZOOM_IN : ZLC_ZOOM_OUT, &pt);
1866 void OnScroll(
Point delta)
override
1872 Point pt = this->PixelToTile(delta.x, delta.y, &sub);
1873 this->SetNewScroll(this->scroll_x + pt.x *
TILE_SIZE, this->scroll_y + pt.y *
TILE_SIZE, sub);
1878 void OnMouseOver([[maybe_unused]]
Point pt,
WidgetID widget)
override
1881 if (widget ==
WID_SM_LEGEND && this->map_type == SMT_INDUSTRY) {
1882 int industry_pos = GetPositionOnLegend(pt);
1914 this->smallmap_window =
nullptr;
1919 assert(this->
children.size() == 2);
1927 assert(this->smallmap_window !=
nullptr);
1934 this->ApplyAspectRatio();
1944 assert(this->
children.size() == 2);
1956 uint bar_height = std::max(bar->
smallest_y, this->smallmap_window->GetLegendHeight(this->smallmap_window->GetNumberColumnsLegend(given_width - bar->
smallest_x)));
1957 uint display_height = given_height - bar_height;
1966 NWidget(
WWT_INSET, COLOUR_BROWN,
WID_SM_MAP),
SetMinimalSize(346, 140),
SetResize(1, 1),
SetPadding(2, 2, 2, 2),
EndContainer(),
1979 SetDataTip(SPR_IMG_ZOOMIN, STR_TOOLBAR_TOOLTIP_ZOOM_THE_VIEW_IN),
SetFill(1, 1),
1985 SetDataTip(SPR_IMG_SHOW_COUNTOURS, STR_SMALLMAP_TOOLTIP_SHOW_LAND_CONTOURS_ON_MAP),
SetFill(1, 1),
1987 SetDataTip(SPR_IMG_SHOW_VEHICLES, STR_SMALLMAP_TOOLTIP_SHOW_VEHICLES_ON_MAP),
SetFill(1, 1),
1989 SetDataTip(SPR_IMG_INDUSTRY, STR_SMALLMAP_TOOLTIP_SHOW_INDUSTRIES_ON_MAP),
SetFill(1, 1),
1994 SetDataTip(SPR_IMG_ZOOMOUT, STR_TOOLBAR_TOOLTIP_ZOOM_THE_VIEW_OUT),
SetFill(1, 1),
1996 SetDataTip(SPR_IMG_TOWN, STR_SMALLMAP_TOOLTIP_TOGGLE_TOWN_NAMES_ON_OFF),
SetFill(1, 1),
1998 SetDataTip(SPR_IMG_CARGOFLOW, STR_SMALLMAP_TOOLTIP_SHOW_LINK_STATS_ON_MAP),
SetFill(1, 1),
2000 SetDataTip(SPR_IMG_SHOW_ROUTES, STR_SMALLMAP_TOOLTIP_SHOW_TRANSPORT_ROUTES_ON),
SetFill(1, 1),
2002 SetDataTip(SPR_IMG_PLANTTREES, STR_SMALLMAP_TOOLTIP_SHOW_VEGETATION_ON_MAP),
SetFill(1, 1),
2004 SetDataTip(SPR_IMG_COMPANY_GENERAL, STR_SMALLMAP_TOOLTIP_SHOW_LAND_OWNERS_ON_MAP),
SetFill(1, 1),
2012 static std::unique_ptr<NWidgetBase> SmallMapDisplay()
2014 std::unique_ptr<NWidgetBase> map_display = std::make_unique<NWidgetSmallmapDisplay>();
2021 static constexpr
NWidgetPart _nested_smallmap_widgets[] = {
2057 _nested_smallmap_widgets
2065 AllocateWindowDescFront<SmallMapWindow>(_smallmap_desc, 0);
2084 if (res)
return res;
2099 return static_cast<const SmallMapWindow *
>(w)->GetStationMiddle(st);
Class for backupping variables and making sure they are restored later.
constexpr T SetBit(T &x, const uint8_t y)
Set a bit in a variable.
static const CargoID NUM_CARGO
Maximum number of cargo types in a game.
std::vector< const CargoSpec * > _sorted_cargo_specs
Cargo specifications sorted alphabetically by name.
static Blitter * GetCurrentBlitter()
Get the current active blitter (always set by calling SelectBlitter).
How all blitters should look like.
virtual void SetPixel(void *video, int x, int y, uint8_t colour)=0
Draw a pixel with a given colour on the video-buffer.
virtual void * MoveTo(void *video, int x, int y)=0
Move the destination pointer the requested amount x and y, keeping in mind any pitch and bpp of the r...
static const uint8_t LINK_COLOURS[][12]
Colours for the various "load" states of links.
uint8_t map_colour
Colour on mini-map.
Class managing the smallmap window.
void SmallMapCenterOnCurrentPos()
Center the small map on the current center of the viewport.
void SetOverlayCargoMask()
Set the link graph overlay cargo mask from the legend.
static SmallMapType map_type
Currently displayed legends.
uint GetNumberColumnsLegend(uint width) const
Return number of columns that can be displayed in width pixels.
uint column_width
Width of a column in the WID_SM_LEGEND widget.
uint min_number_of_fixed_rows
Minimal number of rows in the legends for the fixed layouts only (all except #SMT_INDUSTRY).
void SelectLegendItem(int click_pos, LegendAndColour *legend, int end_legend_item, int begin_legend_item=0)
Select and toggle a legend item.
void SwitchMapType(SmallMapType map_type)
Select a new map type.
void DrawSmallMap(DrawPixelInfo *dpi) const
Draws the small map.
Point ComputeScroll(int tx, int ty, int x, int y, int *sub) const
Compute base parameters of the smallmap such that tile (tx, ty) starts at pixel (x,...
Point GetStationMiddle(const Station *st) const
Get the center of the given station as point on the screen in the smallmap window.
void ForceRefresh()
Force a full refresh of the map.
void OnInvalidateData(int data=0, bool gui_scope=true) override
Some data on this window has become invalid.
uint GetMinLegendWidth() const
Compute minimal required width of the legends.
static bool show_towns
Display town names in the smallmap.
Point PixelToTile(int px, int py, int *sub, bool add_sub=true) const
Determine the tile relative to the base tile of the smallmap, and the pixel position at that tile for...
void Blink()
Blink the industries (if hover over an industry).
int32_t scroll_y
Vertical world coordinate of the base tile left of the top-left corner of the smallmap display.
int32_t scroll_x
Horizontal world coordinate of the base tile left of the top-left corner of the smallmap display.
void DrawIndustryNames(const DrawPixelInfo *dpi, const int vertical_padding) const
Adds industry names to the smallmap.
static void DrawVertMapIndicator(int x, int y, int y2)
Draws vertical part of map indicator.
uint GetLegendHeight(uint num_columns) const
Compute height given a number of columns.
uint min_number_of_columns
Minimal number of columns in legends.
int32_t subscroll
Number of pixels (0..3) between the right end of the base tile and the pixel at the top-left corner o...
ZoomLevelChange
Available kinds of zoomlevel changes.
@ ZLC_INITIALIZE
Initialize zoom level.
CompanyMask GetOverlayCompanyMask() const
Get a bitmask for company links to be displayed.
uint32_t GetTileColours(const TileArea &ta) const
Decide which colours to show to the user for a group of tiles.
void DrawTowns(const DrawPixelInfo *dpi, const int vertical_padding) const
Adds town names to the smallmap.
void OnPaint() override
The window must be repainted.
void SetZoomLevel(ZoomLevelChange change, const Point *zoom_pt)
Initialize or change the zoom level.
int GetPositionOnLegend(Point pt)
Determines the mouse position on the legend.
void SetupWidgetData()
Function to set up widgets depending on the information being shown on the smallmap.
static bool show_ind_names
Display industry names in the smallmap.
void RebuildColourIndexIfNecessary()
Rebuilds the colour indices used for fast access to the smallmap contour colours based on the heightl...
void DrawSmallMapColumn(void *dst, uint xc, uint yc, int pitch, int reps, int start_pos, int end_pos, Blitter *blitter) const
Draws one column of tiles of the small map in a certain mode onto the screen buffer,...
static int map_height_limit
Currently used/cached map height limit.
Point RemapTile(int tile_x, int tile_y) const
Remap tile to location on this smallmap.
static void DrawHorizMapIndicator(int x, int x2, int y)
Draws horizontal part of map indicator.
void OnInit() override
Notification that the nested widget tree gets initialized.
void UpdateLinks()
Update all the links on the map.
uint legend_width
Width of legend 'blob'.
int zoom
Zoom level. Bigger number means more zoom-out (further away).
void DrawMapIndicators() const
Adds map indicators to the smallmap.
void SetNewScroll(int sx, int sy, int sub)
Set new scroll_x, scroll_y, and subscroll values after limiting them such that the center of the smal...
uint GetNumberRowsLegend(uint columns) const
Get the number of rows in the legend from the number of columns.
void DrawVehicles(const DrawPixelInfo *dpi, Blitter *blitter) const
Adds vehicles to the smallmap.
static void BreakIndustryChainLink()
Notify the industry chain window to stop sending newly selected industries.
Map accessors for 'clear' tiles.
bool IsClearGround(Tile t, ClearGround ct)
Set the type of clear tile.
ClearGround GetClearGround(Tile t)
Get the type of clear tile.
uint GetClearDensity(Tile t)
Get the density of a non-field clear tile.
Definition of stuff that is very close to a company, like the company struct itself.
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
Owner
Enum for all companies/owners.
@ INVALID_COMPANY
An invalid company.
@ OWNER_NONE
The tile has no ownership.
@ OWNER_WATER
The tile/execution is done by "water".
@ OWNER_TOWN
A town owns the tile, or a town is expanding.
@ MAX_COMPANIES
Maximum number of companies.
Function to handling different endian machines.
#define DECLARE_ENUM_AS_ADDABLE(EnumType)
Operator that allows this enumeration to be added to any other enumeration.
Factory to 'query' all available blitters.
int GetCharacterHeight(FontSize size)
Get height of a character for a given font size.
Dimension GetStringBoundingBox(std::string_view str, FontSize start_fontsize)
Return the string dimension in pixels.
int DrawString(int left, int right, int top, std::string_view str, TextColour colour, StringAlignment align, bool underline, FontSize fontsize)
Draw string, possibly truncated to make it fit in its allocated space.
bool _ctrl_pressed
Is Ctrl pressed?
void GfxFillRect(int left, int top, int right, int bottom, int colour, FillRectMode mode)
Applies a certain FillRectMode-operation to a rectangle [left, right] x [top, bottom] on the screen.
bool FillDrawPixelInfo(DrawPixelInfo *n, int left, int top, int width, int height)
Set up a clipping area for only drawing into a certain area.
int CenterBounds(int min, int max, int size)
Determine where to draw a centred object inside a widget.
@ SA_LEFT
Left align the text.
@ FS_SMALL
Index of the small font in the font tables.
The colour tables for heightmaps.
static const uint32_t _violet_map_heights[]
Height map colours for the violet colour scheme, ordered by height.
static const uint32_t _dark_green_map_heights[]
Height map colours for the dark green colour scheme, ordered by height.
static const uint32_t _green_map_heights[]
Height map colours for the green colour scheme, ordered by height.
bool IsTileForestIndustry(TileIndex tile)
Check whether the tile is a forest.
const IndustrySpec * GetIndustrySpec(IndustryType thistype)
Accessor for array _industry_specs.
std::array< IndustryType, NUM_INDUSTRYTYPES > _sorted_industry_types
Industry types sorted by name.
std::bitset< NUM_INDUSTRYTYPES > _displayed_industries
Communication from the industry chain window to the smallmap window about what industries to display.
static const IndustryType NUM_INDUSTRYTYPES
total number of industry types, new and old; limited to 240 because we need some special ids like INV...
static const IndustryType INVALID_INDUSTRYTYPE
one above amount is considered invalid
Point InverseRemapCoords2(int x, int y, bool clamp_to_map, bool *clamped)
Map 2D viewport or smallmap coordinate to 3D world or tile coordinate.
Functions related to OTTD's landscape.
Point InverseRemapCoords(int x, int y)
Map 2D viewport or smallmap coordinate to 3D world or tile coordinate.
Declaration of linkgraph overlay GUI.
static debug_inline TileIndex TileXY(uint x, uint y)
Returns the TileIndex of a coordinate.
static debug_inline uint TileY(TileIndex tile)
Get the Y component of a tile.
static debug_inline uint TileX(TileIndex tile)
Get the X component of a tile.
constexpr uint CeilDiv(uint a, uint b)
Computes ceil(a / b) for non-negative a and b.
constexpr T Clamp(const T a, const T min, const T max)
Clamp a value between an interval.
constexpr bool IsInsideMM(const T x, const size_t min, const size_t max) noexcept
Checks if a value is in an interval.
uint8_t GetColourGradient(Colours colour, ColourShade shade)
Get colour gradient palette index.
static const uint8_t PC_TREES
Green palette colour for trees.
static const uint8_t PC_GREY
Grey palette colour.
static const uint8_t PC_GREEN
Green palette colour.
static const uint8_t PC_WHITE
White palette colour.
static const uint8_t PC_DARK_GREY
Dark grey palette colour.
static const uint8_t PC_WATER
Dark blue palette colour for water.
static const uint8_t PC_LIGHT_BLUE
Light blue palette colour.
static const uint8_t PC_FIELDS
Light brown palette colour for fields.
static const uint8_t PC_BLACK
Black palette colour.
static const uint8_t PC_DARK_RED
Dark red palette colour.
static const uint8_t PC_ROUGH_LAND
Dark green palette colour for rough land.
static const uint8_t PC_BARE_LAND
Brown palette colour for bare land.
static const uint8_t PC_ORANGE
Orange palette colour.
static const uint8_t PC_RED
Red palette colour.
static const uint8_t PC_VERY_DARK_BROWN
Almost-black brown palette colour.
static const uint8_t PC_YELLOW
Yellow palette colour.
static const uint8_t PC_GRASS_LAND
Dark green palette colour for grass land.
static const uint8_t PC_RAINFOREST
Pale green palette colour for rainforest.
static const uint8_t PC_VERY_LIGHT_YELLOW
Almost-white yellow palette colour.
const RailTypeInfo * GetRailTypeInfo(RailType railtype)
Returns a pointer to the Railtype information for a given railtype.
RailType GetRailType(Tile t)
Gets the rail type of the given tile.
const RoadTypeInfo * GetRoadTypeInfo(RoadType roadtype)
Returns a pointer to the Roadtype information for a given roadtype.
@ INVALID_ROADTYPE
flag for invalid roadtype
A number of safeguards to prevent using unsafe methods.
GameSettings _settings_game
Game settings of a running game or the scenario editor.
ClientSettings _settings_client
The current settings for this game.
@ VSM_VIEWPORT_RMB_FIXED
Viewport moves with mouse movement on holding right mouse button, cursor position is fixed.
@ VSM_MAP_RMB_FIXED
Map moves with mouse movement on holding right mouse button, cursor position is fixed.
@ SWS_OFF
Scroll wheel has no effect.
static uint8_t _linkstat_colours_in_legenda[]
Link stat colours shown in legenda.
#define MK(a, b)
Macro for ordinary entry of LegendAndColour.
void ShowSmallMap()
Show the smallmap window.
static const AndOr _smallmap_vehicles_andor[]
Colour masks for "Vehicles", "Industry", and "Vegetation" modes.
static uint32_t GetSmallMapLinkStatsPixels(TileIndex tile, TileType t)
Return the colour a tile would be displayed with in the small map in mode "link stats".
static uint32_t GetSmallMapContoursPixels(TileIndex tile, TileType t)
Return the colour a tile would be displayed with in the small map in mode "Contour".
void BuildLandLegend()
(Re)build the colour tables for the legends.
static LegendAndColour _legend_from_industries[NUM_INDUSTRYTYPES+1]
Allow room for all industries, plus a terminator entry This is required in order to have the industry...
#define MS(a, b)
Macro for break marker in arrays of LegendAndColour.
#define MC(col_break)
Macro for a height legend entry with configurable colour.
static constexpr NWidgetPart _nested_smallmap_bar[]
Widget parts of the smallmap legend bar + image buttons.
static uint _industry_to_list_pos[NUM_INDUSTRYTYPES]
For connecting industry type to position in industries list(small map legend)
static const uint8_t _tiletype_importance[]
Mapping of tile type to importance of the tile (higher number means more interesting to show).
static IndustryType _smallmap_industry_highlight
Highlight a specific industry type.
void BuildOwnerLegend()
Completes the array for the owned property legend.
static const int NUM_NO_COMPANY_ENTRIES
Number of entries in the owner legend that are not companies.
static int _smallmap_cargo_count
Number of cargos in the link stats legend.
uint32_t GetSmallMapOwnerPixels(TileIndex tile, TileType t, IncludeHeightmap include_heightmap)
Return the colour a tile would be displayed with in the small map in mode "Owner".
static int _smallmap_company_count
Number of entries in the owner legend.
static SmallMapColourScheme _heightmap_schemes[]
Available colour schemes for height maps.
static uint32_t GetSmallMapVegetationPixels(TileIndex tile, TileType t)
Return the colour a tile would be displayed with in the smallmap in mode "Vegetation".
static uint32_t GetSmallMapIndustriesPixels(TileIndex tile, TileType t)
Return the colour a tile would be displayed with in the small map in mode "Industries".
static LegendAndColour _legend_land_contours[]
Legend text giving the colours to look for on the minimap.
static bool _smallmap_show_heightmap
Show heightmap in industry and owner mode of smallmap window.
SmallMapType
Types of legends in the WID_SM_LEGEND widget.
static int _smallmap_industry_count
Number of used industries.
static bool _smallmap_industry_highlight_state
State of highlight blinking.
void BuildLinkStatsLegend()
Populate legend table for the link stat view.
static uint32_t GetSmallMapRoutesPixels(TileIndex tile, TileType t)
Return the colour a tile would be displayed with in the small map in mode "Routes".
static uint16_t _industry_to_name_string_width[NUM_INDUSTRYTYPES]
The string bounding box width for each industry type in the smallmap.
static constexpr NWidgetPart _nested_smallmap_display[]
Widget parts of the smallmap display.
#define MKEND()
Macro for end of list marker in arrays of LegendAndColour.
static uint32_t GetSmallMapVehiclesPixels(TileIndex, TileType t)
Return the colour a tile would be displayed with in the small map in mode "Vehicles".
bool ScrollMainWindowTo(int x, int y, int z, bool instant)
Scrolls the main window to given coordinates.
static const uint8_t _vehicle_type_colours[6]
Vehicle colours in #SMT_VEHICLES mode.
void BuildIndustriesLegend()
Fills an array for the industries legends.
static const AndOr _smallmap_contours_andor[]
Colour masks for "Contour" and "Routes" modes.
#define MOEND()
Macro used for forcing a rebuild of the owner legend the first time it is used.
static LegendAndColour _legend_linkstats[NUM_CARGO+lengthof(_linkstat_colours_in_legenda)+1]
Legend entries for the link stats view.
static uint _company_to_list_pos[MAX_COMPANIES]
For connecting company ID to position in owner list (small map legend)
#define MO(a, b)
Macro for non-company owned property entry of LegendAndColour.
Point GetSmallMapStationMiddle(const Window *w, const Station *st)
Determine the middle of a station in the smallmap window.
IncludeHeightmap
Enum for how to include the heightmap pixels/colours in small map related functions.
@ Always
Always include the heightmap.
@ IfEnabled
Only include the heightmap if its enabled in the gui by the player.
Functions related to sound.
@ SND_15_BEEP
19 == 0x13 GUI button click
Maps accessors for stations.
StationType GetStationType(Tile t)
Get the station type of this tile.
Definition of base types and functions in a cross-platform compatible way.
#define MAX_UVALUE(type)
The largest value that can be entered in a variable.
#define lengthof(array)
Return the length of an fixed size array.
void SetDParam(size_t n, uint64_t v)
Set a string parameter v at index n in the global string parameter array.
TextDirection _current_text_dir
Text direction of the currently selected language.
Functions related to OTTD's strings.
@ TD_RTL
Text is written right-to-left by default.
uint32_t StringID
Numeric value that represents a string, independent of the selected language.
Class to backup a specific variable and restore it upon destruction of this object to prevent stack v...
StationRect rect
NOSAVE: Station spread out rectangle maintained by StationRect::xxx() functions.
Specification of a cargo type.
CargoID Index() const
Determines index of this cargospec.
StringID name
Name of this type of cargo.
SoundSettings sound
sound effect settings
GUISettings gui
settings related to the GUI
bool freeform_edges
allow terraforming the tiles at the map edges
uint8_t map_height_limit
the maximum allowed heightlevel
bool fix_at
mouse is moving, but cursor is not (used for scrolling)
Point pos
logical mouse position
Data about how and where to blit pixels.
uint8_t linkgraph_colours
linkgraph overlay colours
uint8_t scroll_mode
viewport scroll mode
uint8_t scrollwheel_scrolling
scrolling using the scroll wheel?
uint8_t smallmap_land_colour
colour used for land and heightmap at the smallmap
uint8_t landscape
the landscape we're currently in
ConstructionSettings construction
construction of things in-game
GameCreationSettings game_creation
settings used during the creation of a game (map)
Defines the data structure for constructing industry.
StringID name
Displayed name of the industry.
bool enabled
entity still available (by default true).newgrf can disable it, though
uint8_t map_colour
colour used for the small map
Defines the internal data of a functional industry.
IndustryType type
type of industry.
static Industry * GetByTile(TileIndex tile)
Get the industry of the given tile.
static uint16_t GetIndustryTypeCount(IndustryType type)
Get the count of industries for this type.
Structure for holding relevant data for legends in small map.
uint8_t height
Height in tiles. Only valid for height legend entries.
uint8_t colour
Colour of the item on the map.
StringID legend
String corresponding to the coloured item.
bool show_on_map
For filtering industries, if true, industry is shown on the map in colour.
CompanyID company
Company to display. Only valid for company entries of the owner legend.
bool end
This is the end of the list.
bool col_break
Perform a column break and go further at the next column.
IndustryType type
Type of industry. Only valid for industry entries.
static uint MaxY()
Gets the maximum Y coordinate within the map, including MP_VOID.
static debug_inline uint MaxX()
Gets the maximum X coordinate within the map, including MP_VOID.
Represents the covered area of e.g.
void ClampToMap()
Clamp the tile area to map borders.
Coordinates of a point in 2D.
static bool IsValidID(size_t index)
Tests whether given index can be used to get valid (non-nullptr) Titem.
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
static constexpr size_t MAX_SIZE
Make template parameter accessible from outside.
constexpr uint Horizontal() const
Get total horizontal padding of RectPadding.
constexpr uint Vertical() const
Get total vertical padding of RectPadding.
Specification of a rectangle with absolute coordinates of all edges.
Rect WithWidth(int width, bool end) const
Copy Rect and set its width.
int Width() const
Get width of Rect.
Rect Shrink(int s) const
Copy and shrink Rect by s pixels.
Rect WithHeight(int height, bool end=false) const
Copy Rect and set its height.
Rect Indent(int indent, bool end) const
Copy Rect and indent it from its position.
Rect Translate(int x, int y) const
Copy and translate Rect by x,y pixels.
Colour scheme of the smallmap.
std::vector< uint32_t > height_colours
Cached colours for each level in a map.
uint32_t default_colour
Default colour of the land.
std::span< const uint32_t > height_colours_base
Base table for determining the colours.
bool click_beep
Beep on a random selection of buttons.
Data structure for viewport, display of a part of the world.
int virtual_top
Virtual top coordinate.
int virtual_left
Virtual left coordinate.
int virtual_width
width << zoom
int virtual_height
height << zoom
High level window description.
Data structure for an opened window.
virtual void Close(int data=0)
Hide the window and all its child windows, and mark them for a later deletion.
ViewportData * viewport
Pointer to viewport data, if present.
Owner GetTileOwner(Tile tile)
Returns the owner of a tile.
static debug_inline TileType GetTileType(Tile tile)
Get the tiletype of a given tile.
TropicZone GetTropicZone(Tile tile)
Get the tropic zone.
static debug_inline uint TileHeight(Tile tile)
Returns the height of a tile.
@ TROPICZONE_RAINFOREST
Rainforest tile.
static const uint TILE_SIZE
Tile size in world coordinates.
static const uint MAX_TILE_HEIGHT
Maximum allowed tile height.
constexpr TileIndex INVALID_TILE
The very nice invalid tile marker.
TileType
The different types of tiles.
@ MP_TREES
Tile got trees.
@ MP_ROAD
A tile with road (or tram tracks)
@ MP_STATION
A tile of a station.
@ MP_TUNNELBRIDGE
Tunnel entry/exit and bridge heads.
@ MP_CLEAR
A tile without any structures, i.e. grass, rocks, farm fields etc.
@ MP_HOUSE
A house by a town.
@ MP_INDUSTRY
Part of an industry.
@ MP_VOID
Invisible tiles at the SW and SE border.
OrthogonalTileArea TileArea
Shorthand for the much more common orthogonal tile area.
Definition of Interval and OneShot timers.
Definition of the Window system.
TransportType
Available types of transport.
@ TRANSPORT_RAIL
Transport by train.
@ TRANSPORT_ROAD
Transport by road vehicle.
Map accessors for tree tiles.
TreeGround GetTreeGround(Tile t)
Returns the groundtype for tree tiles.
@ TREE_GROUND_ROUGH_SNOW
A snow tile that is rough underneath.
@ TREE_GROUND_SNOW_DESERT
a desert or snow tile, depend on landscape
Functions that have tunnels and bridges in common.
TransportType GetTunnelBridgeTransportType(Tile t)
Tunnel: Get the transport type of the tunnel (road or rail) Bridge: Get the transport type of the bri...
Base class for all vehicles.
@ VS_UNCLICKABLE
Vehicle is not clickable by the user (shadow vehicles).
@ VS_HIDDEN
Vehicle is not visible.
@ VEH_EFFECT
Effect vehicle type (smoke, explosions, sparks, bubbles)
bool ScrollWindowTo(int x, int y, int z, Window *w, bool instant)
Scrolls the viewport in a window to a given location.
Functions related to (drawing on) viewports.
static const int TILE_HEIGHT_STEP
One Z unit tile height difference is displayed as 50m.
bool IsTileOnWater(Tile t)
Tests if the tile was built on water.
bool _scrolling_viewport
A viewport is being scrolled with the mouse.
Window * FindWindowById(WindowClass cls, WindowNumber number)
Find a window by its class and window number.
Window * GetMainWindow()
Get the main window, i.e.
void InvalidateWindowClassesData(WindowClass cls, int data, bool gui_scope)
Mark window data of all windows of a given class as invalid (in need of re-computing) Note that by de...
Window functions not directly related to making/drawing windows.
@ WDP_AUTO
Find a place automatically.
@ WC_NONE
No window, redirects to WC_MAIN_WINDOW.
@ WC_INDUSTRY_CARGOES
Industry cargoes chain; Window numbers:
@ WC_SMALLMAP
Small map; Window numbers:
Functions related to zooming.
int ScaleGUITrad(int value)
Scale traditional pixel dimensions to GUI zoom level.