OpenTTD Source 20250905-master-g122023be8d
town_gui.cpp
Go to the documentation of this file.
1/*
2 * This file is part of OpenTTD.
3 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
4 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
5 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
6 */
7
10#include "stdafx.h"
11#include "town.h"
12#include "viewport_func.h"
13#include "error.h"
14#include "gui.h"
15#include "house.h"
16#include "newgrf_cargo.h"
17#include "newgrf_house.h"
18#include "newgrf_text.h"
19#include "picker_gui.h"
20#include "command_func.h"
21#include "company_func.h"
22#include "company_base.h"
23#include "company_gui.h"
24#include "network/network.h"
25#include "string_func.h"
26#include "strings_func.h"
27#include "sound_func.h"
28#include "tilehighlight_func.h"
29#include "sortlist_type.h"
30#include "road_cmd.h"
31#include "landscape.h"
32#include "querystring_gui.h"
33#include "window_func.h"
34#include "townname_func.h"
35#include "core/backup_type.hpp"
38#include "genworld.h"
39#include "fios.h"
40#include "stringfilter_type.h"
41#include "dropdown_func.h"
42#include "town_kdtree.h"
43#include "town_cmd.h"
44#include "timer/timer.h"
46#include "timer/timer_window.h"
47#include "zoom_func.h"
48#include "hotkeys.h"
49#include "graph_gui.h"
50
51#include "widgets/town_widget.h"
52
53#include "table/strings.h"
54
55#include "safeguards.h"
56
57TownKdtree _town_local_authority_kdtree{};
58
60
61static constexpr NWidgetPart _nested_town_authority_widgets[] = {
63 NWidget(WWT_CLOSEBOX, COLOUR_BROWN),
64 NWidget(WWT_CAPTION, COLOUR_BROWN, WID_TA_CAPTION),
65 NWidget(WWT_TEXTBTN, COLOUR_BROWN, WID_TA_ZONE_BUTTON), SetMinimalSize(50, 0), SetStringTip(STR_LOCAL_AUTHORITY_ZONE, STR_LOCAL_AUTHORITY_ZONE_TOOLTIP),
66 NWidget(WWT_SHADEBOX, COLOUR_BROWN),
67 NWidget(WWT_DEFSIZEBOX, COLOUR_BROWN),
68 NWidget(WWT_STICKYBOX, COLOUR_BROWN),
70 NWidget(WWT_PANEL, COLOUR_BROWN, WID_TA_RATING_INFO), SetMinimalSize(317, 92), SetResize(1, 1), EndContainer(),
71 NWidget(WWT_PANEL, COLOUR_BROWN, WID_TA_COMMAND_LIST), SetMinimalSize(317, 52), SetResize(1, 0), SetToolTip(STR_LOCAL_AUTHORITY_ACTIONS_TOOLTIP), EndContainer(),
72 NWidget(WWT_PANEL, COLOUR_BROWN, WID_TA_ACTION_INFO), SetMinimalSize(317, 52), SetResize(1, 0), EndContainer(),
74 NWidget(WWT_PUSHTXTBTN, COLOUR_BROWN, WID_TA_EXECUTE), SetMinimalSize(317, 12), SetResize(1, 0), SetFill(1, 0), SetStringTip(STR_LOCAL_AUTHORITY_DO_IT_BUTTON, STR_LOCAL_AUTHORITY_DO_IT_TOOLTIP),
75 NWidget(WWT_RESIZEBOX, COLOUR_BROWN),
77};
78
81private:
82 Town *town = nullptr;
83 TownAction sel_action = TownAction::End;
87 std::array<StringID, to_underlying(TownAction::End)> action_tooltips{};
88
91
98 {
99 TownActions enabled{};
100 enabled.Set();
101
105 if (!_settings_game.economy.bribe) enabled.Reset(TownAction::Bribe);
106
107 return enabled;
108 }
109
110public:
112 {
113 this->town = Town::Get(window_number);
115
117 this->action_tooltips[0] = STR_LOCAL_AUTHORITY_ACTION_TOOLTIP_SMALL_ADVERTISING;
118 this->action_tooltips[1] = STR_LOCAL_AUTHORITY_ACTION_TOOLTIP_MEDIUM_ADVERTISING;
119 this->action_tooltips[2] = STR_LOCAL_AUTHORITY_ACTION_TOOLTIP_LARGE_ADVERTISING;
120 this->action_tooltips[3] = realtime ? STR_LOCAL_AUTHORITY_ACTION_TOOLTIP_ROAD_RECONSTRUCTION_MINUTES : STR_LOCAL_AUTHORITY_ACTION_TOOLTIP_ROAD_RECONSTRUCTION_MONTHS;
121 this->action_tooltips[4] = STR_LOCAL_AUTHORITY_ACTION_TOOLTIP_STATUE_OF_COMPANY;
122 this->action_tooltips[5] = STR_LOCAL_AUTHORITY_ACTION_TOOLTIP_NEW_BUILDINGS;
123 this->action_tooltips[6] = realtime ? STR_LOCAL_AUTHORITY_ACTION_TOOLTIP_EXCLUSIVE_TRANSPORT_MINUTES : STR_LOCAL_AUTHORITY_ACTION_TOOLTIP_EXCLUSIVE_TRANSPORT_MONTHS;
124 this->action_tooltips[7] = STR_LOCAL_AUTHORITY_ACTION_TOOLTIP_BRIBE;
125
126 this->InitNested(window_number);
127 }
128
129 void OnInit() override
130 {
131 this->icon_size = GetSpriteSize(SPR_COMPANY_ICON);
132 this->exclusive_size = GetSpriteSize(SPR_EXCLUSIVE_TRANSPORT);
133 }
134
135 void OnPaint() override
136 {
140
142 this->SetWidgetDisabledState(WID_TA_EXECUTE, (this->sel_action == TownAction::End) || !this->available_actions.Test(this->sel_action));
143
144 this->DrawWidgets();
145 if (!this->IsShaded())
146 {
147 this->DrawRatings();
148 this->DrawActions();
149 }
150 }
151
152 StringID GetRatingString(int rating) const
153 {
154 if (rating > RATING_EXCELLENT) return STR_CARGO_RATING_OUTSTANDING;
155 if (rating > RATING_VERYGOOD) return STR_CARGO_RATING_EXCELLENT;
156 if (rating > RATING_GOOD) return STR_CARGO_RATING_VERY_GOOD;
157 if (rating > RATING_MEDIOCRE) return STR_CARGO_RATING_GOOD;
158 if (rating > RATING_POOR) return STR_CARGO_RATING_MEDIOCRE;
159 if (rating > RATING_VERYPOOR) return STR_CARGO_RATING_POOR;
160 if (rating > RATING_APPALLING) return STR_CARGO_RATING_VERY_POOR;
161 return STR_CARGO_RATING_APPALLING;
162 }
163
166 {
167 Rect r = this->GetWidget<NWidgetBase>(WID_TA_RATING_INFO)->GetCurrentRect().Shrink(WidgetDimensions::scaled.framerect);
168
169 int text_y_offset = (this->resize.step_height - GetCharacterHeight(FS_NORMAL)) / 2;
170 int icon_y_offset = (this->resize.step_height - this->icon_size.height) / 2;
171 int exclusive_y_offset = (this->resize.step_height - this->exclusive_size.height) / 2;
172
173 DrawString(r.left, r.right, r.top + text_y_offset, STR_LOCAL_AUTHORITY_COMPANY_RATINGS);
174 r.top += this->resize.step_height;
175
176 bool rtl = _current_text_dir == TD_RTL;
177 Rect icon = r.WithWidth(this->icon_size.width, rtl);
178 Rect exclusive = r.Indent(this->icon_size.width + WidgetDimensions::scaled.hsep_normal, rtl).WithWidth(this->exclusive_size.width, rtl);
179 Rect text = r.Indent(this->icon_size.width + WidgetDimensions::scaled.hsep_normal + this->exclusive_size.width + WidgetDimensions::scaled.hsep_normal, rtl);
180
181 /* Draw list of companies */
182 for (const Company *c : Company::Iterate()) {
183 if ((this->town->have_ratings.Test(c->index) || this->town->exclusivity == c->index)) {
184 DrawCompanyIcon(c->index, icon.left, text.top + icon_y_offset);
185
186 if (this->town->exclusivity == c->index) {
187 DrawSprite(SPR_EXCLUSIVE_TRANSPORT, GetCompanyPalette(c->index), exclusive.left, text.top + exclusive_y_offset);
188 }
189
190 int rating = this->town->ratings[c->index];
191 DrawString(text.left, text.right, text.top + text_y_offset, GetString(STR_LOCAL_AUTHORITY_COMPANY_RATING, c->index, c->index, GetRatingString(rating)));
192 text.top += this->resize.step_height;
193 }
194 }
195
196 text.bottom = text.top - 1;
197 if (text.bottom > r.bottom) {
198 /* If the company list is too big to fit, mark ourself dirty and draw again. */
199 ResizeWindow(this, 0, text.bottom - r.bottom, false);
200 }
201 }
202
205 {
206 Rect r = this->GetWidget<NWidgetBase>(WID_TA_COMMAND_LIST)->GetCurrentRect().Shrink(WidgetDimensions::scaled.framerect);
207
208 DrawString(r, STR_LOCAL_AUTHORITY_ACTIONS_TITLE);
210
211 /* Draw list of actions */
212 for (TownAction i = {}; i != TownAction::End; ++i) {
213 /* Don't show actions if disabled in settings. */
214 if (!this->enabled_actions.Test(i)) continue;
215
216 /* Set colour of action based on ability to execute and if selected. */
217 TextColour action_colour = TC_GREY | TC_NO_SHADE;
218 if (this->available_actions.Test(i)) action_colour = TC_ORANGE;
219 if (this->sel_action == i) action_colour = TC_WHITE;
220
221 DrawString(r, STR_LOCAL_AUTHORITY_ACTION_SMALL_ADVERTISING_CAMPAIGN + to_underlying(i), action_colour);
223 }
224 }
225
226 std::string GetWidgetString(WidgetID widget, StringID stringid) const override
227 {
228 if (widget == WID_TA_CAPTION) return GetString(STR_LOCAL_AUTHORITY_CAPTION, this->window_number);
229
230 return this->Window::GetWidgetString(widget, stringid);
231 }
232
233 void DrawWidget(const Rect &r, WidgetID widget) const override
234 {
235 switch (widget) {
237 if (this->sel_action != TownAction::End) {
238 Money action_cost = _price[PR_TOWN_ACTION] * GetTownActionCost(this->sel_action) >> 8;
239 bool affordable = Company::IsValidID(_local_company) && action_cost < GetAvailableMoney(_local_company);
240
242 GetString(this->action_tooltips[to_underlying(this->sel_action)], action_cost),
243 affordable ? TC_YELLOW : TC_RED);
244 }
245 break;
246 }
247 }
248
249 void UpdateWidgetSize(WidgetID widget, Dimension &size, [[maybe_unused]] const Dimension &padding, [[maybe_unused]] Dimension &fill, [[maybe_unused]] Dimension &resize) override
250 {
251 switch (widget) {
252 case WID_TA_ACTION_INFO: {
253 assert(size.width > padding.width && size.height > padding.height);
254 Dimension d = {0, 0};
255 for (TownAction i = {}; i != TownAction::End; ++i) {
256 Money price = _price[PR_TOWN_ACTION] * GetTownActionCost(i) >> 8;
257 d = maxdim(d, GetStringMultiLineBoundingBox(GetString(this->action_tooltips[to_underlying(i)], price), size));
258 }
259 d.width += padding.width;
260 d.height += padding.height;
261 size = maxdim(size, d);
262 break;
263 }
264
266 size.height = (to_underlying(TownAction::End) + 1) * GetCharacterHeight(FS_NORMAL) + padding.height;
267 size.width = GetStringBoundingBox(STR_LOCAL_AUTHORITY_ACTIONS_TITLE).width;
268 for (TownAction i = {}; i != TownAction::End; ++i) {
269 size.width = std::max(size.width, GetStringBoundingBox(STR_LOCAL_AUTHORITY_ACTION_SMALL_ADVERTISING_CAMPAIGN + to_underlying(i)).width + padding.width);
270 }
271 size.width += padding.width;
272 break;
273
275 fill.height = resize.height = std::max({this->icon_size.height + WidgetDimensions::scaled.vsep_normal, this->exclusive_size.height + WidgetDimensions::scaled.vsep_normal, (uint)GetCharacterHeight(FS_NORMAL)});
276 size.height = 9 * resize.height + padding.height;
277 break;
278 }
279 }
280
281 void OnClick([[maybe_unused]] Point pt, WidgetID widget, [[maybe_unused]] int click_count) override
282 {
283 switch (widget) {
284 case WID_TA_ZONE_BUTTON: {
285 bool new_show_state = !this->town->show_zone;
286 TownID index = this->town->index;
287
288 new_show_state ? _town_local_authority_kdtree.Insert(index) : _town_local_authority_kdtree.Remove(index);
289
290 this->town->show_zone = new_show_state;
291 this->SetWidgetLoweredState(widget, new_show_state);
292 SndClickBeep();
294 break;
295 }
296
297 case WID_TA_COMMAND_LIST: {
299
300 auto action = this->enabled_actions.GetNthSetBit(y);
301 if (!action.has_value()) break;
302
303 this->sel_action = *action;
304 this->SetDirty();
305
306 /* When double-clicking, continue */
307 if (click_count == 1 || !this->available_actions.Test(this->sel_action)) break;
308 [[fallthrough]];
309 }
310
311 case WID_TA_EXECUTE:
312 Command<CMD_DO_TOWN_ACTION>::Post(STR_ERROR_CAN_T_DO_THIS, this->town->xy, static_cast<TownID>(this->window_number), this->sel_action);
313 break;
314 }
315 }
316
318 const IntervalTimer<TimerWindow> redraw_interval = {std::chrono::seconds(3), [this](auto) {
319 this->SetDirty();
320 }};
321
322 void OnInvalidateData([[maybe_unused]] int data = 0, [[maybe_unused]] bool gui_scope = true) override
323 {
324 if (!gui_scope) return;
325
326 this->enabled_actions = this->GetEnabledActions();
327 if (!this->enabled_actions.Test(this->sel_action)) {
328 this->sel_action = TownAction::End;
329 }
330 }
331};
332
333static WindowDesc _town_authority_desc(
334 WDP_AUTO, "view_town_authority", 317, 222,
336 {},
337 _nested_town_authority_widgets
338);
339
340static void ShowTownAuthorityWindow(uint town)
341{
342 AllocateWindowDescFront<TownAuthorityWindow>(_town_authority_desc, town);
343}
344
345
346/* Town view window. */
348private:
349 Town *town = nullptr;
350
351public:
352 static const int WID_TV_HEIGHT_NORMAL = 150;
353
355 {
356 this->CreateNestedTree();
357
358 this->town = Town::Get(window_number);
359
360 this->FinishInitNested(window_number);
361
363 NWidgetViewport *nvp = this->GetWidget<NWidgetViewport>(WID_TV_VIEWPORT);
364 nvp->InitializeViewport(this, this->town->xy, ScaleZoomGUI(ZoomLevel::Town));
365
366 /* disable renaming town in network games if you are not the server */
368 }
369
370 void Close([[maybe_unused]] int data = 0) override
371 {
373 this->Window::Close();
374 }
375
376 std::string GetWidgetString(WidgetID widget, StringID stringid) const override
377 {
378 if (widget == WID_TV_CAPTION) return GetString(this->town->larger_town ? STR_TOWN_VIEW_CITY_CAPTION : STR_TOWN_VIEW_TOWN_CAPTION, this->town->index);
379
380 return this->Window::GetWidgetString(widget, stringid);
381 }
382
383 void OnPaint() override
384 {
385 extern const Town *_viewport_highlight_town;
386 this->SetWidgetLoweredState(WID_TV_CATCHMENT, _viewport_highlight_town == this->town);
387
388 this->DrawWidgets();
389 }
390
391 void DrawWidget(const Rect &r, WidgetID widget) const override
392 {
393 if (widget != WID_TV_INFO) return;
394
395 Rect tr = r.Shrink(WidgetDimensions::scaled.framerect);
396
397 DrawString(tr, GetString(STR_TOWN_VIEW_POPULATION_HOUSES, this->town->cache.population, this->town->cache.num_houses));
398 tr.top += GetCharacterHeight(FS_NORMAL);
399
400 StringID str_last_period = TimerGameEconomy::UsingWallclockUnits() ? STR_TOWN_VIEW_CARGO_LAST_MINUTE_MAX : STR_TOWN_VIEW_CARGO_LAST_MONTH_MAX;
401
402 for (auto tpe : {TPE_PASSENGERS, TPE_MAIL}) {
403 for (const CargoSpec *cs : CargoSpec::town_production_cargoes[tpe]) {
404 CargoType cargo_type = cs->Index();
405 auto it = this->town->GetCargoSupplied(cargo_type);
406 if (it == std::end(this->town->supplied)) {
407 DrawString(tr, GetString(str_last_period, 1ULL << cargo_type, 0, 0));
408 } else {
409 DrawString(tr, GetString(str_last_period, 1ULL << cargo_type, it->history[LAST_MONTH].transported, it->history[LAST_MONTH].production));
410 }
411 tr.top += GetCharacterHeight(FS_NORMAL);
412 }
413 }
414
415 bool first = true;
416 for (int i = TAE_BEGIN; i < TAE_END; i++) {
417 if (this->town->goal[i] == 0) continue;
418 if (this->town->goal[i] == TOWN_GROWTH_WINTER && (TileHeight(this->town->xy) < LowestSnowLine() || this->town->cache.population <= 90)) continue;
419 if (this->town->goal[i] == TOWN_GROWTH_DESERT && (GetTropicZone(this->town->xy) != TROPICZONE_DESERT || this->town->cache.population <= 60)) continue;
420
421 if (first) {
422 DrawString(tr, STR_TOWN_VIEW_CARGO_FOR_TOWNGROWTH);
423 tr.top += GetCharacterHeight(FS_NORMAL);
424 first = false;
425 }
426
427 bool rtl = _current_text_dir == TD_RTL;
428
430 assert(cargo != nullptr);
431
432 StringID string;
433
434 if (this->town->goal[i] == TOWN_GROWTH_DESERT || this->town->goal[i] == TOWN_GROWTH_WINTER) {
435 /* For 'original' gameplay, don't show the amount required (you need 1 or more ..) */
436 string = STR_TOWN_VIEW_CARGO_FOR_TOWNGROWTH_DELIVERED_GENERAL;
437 if (this->town->received[i].old_act == 0) {
438 string = STR_TOWN_VIEW_CARGO_FOR_TOWNGROWTH_REQUIRED_GENERAL;
439
440 if (this->town->goal[i] == TOWN_GROWTH_WINTER && TileHeight(this->town->xy) < GetSnowLine()) {
441 string = STR_TOWN_VIEW_CARGO_FOR_TOWNGROWTH_REQUIRED_WINTER;
442 }
443 }
444
445 DrawString(tr.Indent(20, rtl), GetString(string, cargo->name));
446 } else {
447 string = STR_TOWN_VIEW_CARGO_FOR_TOWNGROWTH_DELIVERED;
448 if (this->town->received[i].old_act < this->town->goal[i]) {
449 string = STR_TOWN_VIEW_CARGO_FOR_TOWNGROWTH_REQUIRED;
450 }
451 DrawString(tr.Indent(20, rtl), GetString(string, cargo->Index(), this->town->received[i].old_act, cargo->Index(), this->town->goal[i]));
452 }
453 tr.top += GetCharacterHeight(FS_NORMAL);
454 }
455
456 if (HasBit(this->town->flags, TOWN_IS_GROWING)) {
457 DrawString(tr, GetString(this->town->fund_buildings_months == 0 ? STR_TOWN_VIEW_TOWN_GROWS_EVERY : STR_TOWN_VIEW_TOWN_GROWS_EVERY_FUNDED, RoundDivSU(this->town->growth_rate + 1, Ticks::DAY_TICKS)));
458 tr.top += GetCharacterHeight(FS_NORMAL);
459 } else {
460 DrawString(tr, STR_TOWN_VIEW_TOWN_GROW_STOPPED);
461 tr.top += GetCharacterHeight(FS_NORMAL);
462 }
463
464 /* only show the town noise, if the noise option is activated. */
466 DrawString(tr, GetString(STR_TOWN_VIEW_NOISE_IN_TOWN, this->town->noise_reached, this->town->MaxTownNoise()));
467 tr.top += GetCharacterHeight(FS_NORMAL);
468 }
469
470 if (!this->town->text.empty()) {
471 tr.top = DrawStringMultiLine(tr, this->town->text.GetDecodedString(), TC_BLACK);
472 }
473 }
474
475 void OnClick([[maybe_unused]] Point pt, WidgetID widget, [[maybe_unused]] int click_count) override
476 {
477 switch (widget) {
478 case WID_TV_CENTER_VIEW: // scroll to location
479 if (_ctrl_pressed) {
480 ShowExtraViewportWindow(this->town->xy);
481 } else {
482 ScrollMainWindowToTile(this->town->xy);
483 }
484 break;
485
486 case WID_TV_SHOW_AUTHORITY: // town authority
487 ShowTownAuthorityWindow(this->window_number);
488 break;
489
490 case WID_TV_CHANGE_NAME: // rename
492 break;
493
494 case WID_TV_CATCHMENT:
496 break;
497
498 case WID_TV_EXPAND: // expand town - only available on Scenario editor
499 Command<CMD_EXPAND_TOWN>::Post(STR_ERROR_CAN_T_EXPAND_TOWN, static_cast<TownID>(this->window_number), 0, {TownExpandMode::Buildings, TownExpandMode::Roads});
500 break;
501
502 case WID_TV_EXPAND_BUILDINGS: // expand buildings of town - only available on Scenario editor
503 Command<CMD_EXPAND_TOWN>::Post(STR_ERROR_CAN_T_EXPAND_TOWN, static_cast<TownID>(this->window_number), 0, {TownExpandMode::Buildings});
504 break;
505
506 case WID_TV_EXPAND_ROADS: // expand roads of town - only available on Scenario editor
507 Command<CMD_EXPAND_TOWN>::Post(STR_ERROR_CAN_T_EXPAND_TOWN, static_cast<TownID>(this->window_number), 0, {TownExpandMode::Roads});
508 break;
509
510 case WID_TV_DELETE: // delete town - only available on Scenario editor
511 Command<CMD_DELETE_TOWN>::Post(STR_ERROR_TOWN_CAN_T_DELETE, static_cast<TownID>(this->window_number));
512 break;
513
514 case WID_TV_GRAPH: {
515 ShowTownCargoGraph(this->window_number);
516 break;
517 }
518 }
519 }
520
521 void UpdateWidgetSize(WidgetID widget, Dimension &size, [[maybe_unused]] const Dimension &padding, [[maybe_unused]] Dimension &fill, [[maybe_unused]] Dimension &resize) override
522 {
523 switch (widget) {
524 case WID_TV_INFO:
525 size.height = GetDesiredInfoHeight(size.width) + padding.height;
526 break;
527 }
528 }
529
535 {
537
538 bool first = true;
539 for (int i = TAE_BEGIN; i < TAE_END; i++) {
540 if (this->town->goal[i] == 0) continue;
541 if (this->town->goal[i] == TOWN_GROWTH_WINTER && (TileHeight(this->town->xy) < LowestSnowLine() || this->town->cache.population <= 90)) continue;
542 if (this->town->goal[i] == TOWN_GROWTH_DESERT && (GetTropicZone(this->town->xy) != TROPICZONE_DESERT || this->town->cache.population <= 60)) continue;
543
544 if (first) {
545 aimed_height += GetCharacterHeight(FS_NORMAL);
546 first = false;
547 }
548 aimed_height += GetCharacterHeight(FS_NORMAL);
549 }
550 aimed_height += GetCharacterHeight(FS_NORMAL);
551
553
554 if (!this->town->text.empty()) {
556 }
557
558 return aimed_height;
559 }
560
561 void ResizeWindowAsNeeded()
562 {
563 const NWidgetBase *nwid_info = this->GetWidget<NWidgetBase>(WID_TV_INFO);
564 uint aimed_height = GetDesiredInfoHeight(nwid_info->current_x);
565 if (aimed_height > nwid_info->current_y || (aimed_height < nwid_info->current_y && nwid_info->current_y > nwid_info->smallest_y)) {
566 this->ReInit();
567 }
568 }
569
570 void OnResize() override
571 {
572 if (this->viewport != nullptr) {
573 NWidgetViewport *nvp = this->GetWidget<NWidgetViewport>(WID_TV_VIEWPORT);
574 nvp->UpdateViewportCoordinates(this);
575
576 ScrollWindowToTile(this->town->xy, this, true); // Re-center viewport.
577 }
578 }
579
580 void OnMouseWheel(int wheel, WidgetID widget) override
581 {
582 if (widget != WID_TV_VIEWPORT) return;
584 DoZoomInOutWindow(wheel < 0 ? ZOOM_IN : ZOOM_OUT, this);
585 }
586 }
587
593 void OnInvalidateData([[maybe_unused]] int data = 0, [[maybe_unused]] bool gui_scope = true) override
594 {
595 if (!gui_scope) return;
596 /* Called when setting station noise or required cargoes have changed, in order to resize the window */
597 this->SetDirty(); // refresh display for current size. This will allow to avoid glitches when downgrading
598 this->ResizeWindowAsNeeded();
599 }
600
601 void OnQueryTextFinished(std::optional<std::string> str) override
602 {
603 if (!str.has_value()) return;
604
605 Command<CMD_RENAME_TOWN>::Post(STR_ERROR_CAN_T_RENAME_TOWN, static_cast<TownID>(this->window_number), *str);
606 }
607
608 const IntervalTimer<TimerGameCalendar> daily_interval = {{TimerGameCalendar::DAY, TimerGameCalendar::Priority::NONE}, [this](auto) {
609 /* Refresh after possible snowline change */
610 this->SetDirty();
611 }};
612};
613
614static constexpr NWidgetPart _nested_town_game_view_widgets[] = {
616 NWidget(WWT_CLOSEBOX, COLOUR_BROWN),
617 NWidget(WWT_PUSHIMGBTN, COLOUR_BROWN, WID_TV_CHANGE_NAME), SetAspect(WidgetDimensions::ASPECT_RENAME), SetSpriteTip(SPR_RENAME, STR_TOWN_VIEW_RENAME_TOOLTIP),
618 NWidget(WWT_CAPTION, COLOUR_BROWN, WID_TV_CAPTION),
619 NWidget(WWT_PUSHIMGBTN, COLOUR_BROWN, WID_TV_CENTER_VIEW), SetAspect(WidgetDimensions::ASPECT_LOCATION), SetSpriteTip(SPR_GOTO_LOCATION, STR_TOWN_VIEW_CENTER_TOOLTIP),
620 NWidget(WWT_SHADEBOX, COLOUR_BROWN),
621 NWidget(WWT_DEFSIZEBOX, COLOUR_BROWN),
622 NWidget(WWT_STICKYBOX, COLOUR_BROWN),
623 EndContainer(),
624 NWidget(WWT_PANEL, COLOUR_BROWN),
625 NWidget(WWT_INSET, COLOUR_BROWN), SetPadding(2, 2, 2, 2),
626 NWidget(NWID_VIEWPORT, INVALID_COLOUR, WID_TV_VIEWPORT), SetMinimalSize(254, 86), SetFill(1, 0), SetResize(1, 1),
627 EndContainer(),
628 EndContainer(),
629 NWidget(WWT_PANEL, COLOUR_BROWN, WID_TV_INFO), SetMinimalSize(260, 32), SetResize(1, 0), SetFill(1, 0), EndContainer(),
631 NWidget(WWT_PUSHTXTBTN, COLOUR_BROWN, WID_TV_SHOW_AUTHORITY), SetMinimalSize(80, 12), SetFill(1, 1), SetResize(1, 0), SetStringTip(STR_TOWN_VIEW_LOCAL_AUTHORITY_BUTTON, STR_TOWN_VIEW_LOCAL_AUTHORITY_TOOLTIP),
632 NWidget(WWT_TEXTBTN, COLOUR_BROWN, WID_TV_CATCHMENT), SetMinimalSize(40, 12), SetFill(1, 1), SetResize(1, 0), SetStringTip(STR_BUTTON_CATCHMENT, STR_TOOLTIP_CATCHMENT),
633 NWidget(WWT_PUSHTXTBTN, COLOUR_BROWN, WID_TV_GRAPH), SetFill(1, 0), SetResize(1, 0), SetStringTip(STR_TOWN_VIEW_CARGO_GRAPH, STR_TOWN_VIEW_CARGO_GRAPH_TOOLTIP),
634 NWidget(WWT_RESIZEBOX, COLOUR_BROWN),
635 EndContainer(),
636};
637
638static WindowDesc _town_game_view_desc(
639 WDP_AUTO, "view_town", 260, TownViewWindow::WID_TV_HEIGHT_NORMAL,
641 {},
642 _nested_town_game_view_widgets
643);
644
645static constexpr NWidgetPart _nested_town_editor_view_widgets[] = {
647 NWidget(WWT_CLOSEBOX, COLOUR_BROWN),
648 NWidget(WWT_PUSHIMGBTN, COLOUR_BROWN, WID_TV_CHANGE_NAME), SetAspect(WidgetDimensions::ASPECT_RENAME), SetSpriteTip(SPR_RENAME, STR_TOWN_VIEW_RENAME_TOOLTIP),
649 NWidget(WWT_CAPTION, COLOUR_BROWN, WID_TV_CAPTION), SetToolTip(STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
650 NWidget(WWT_PUSHIMGBTN, COLOUR_BROWN, WID_TV_CENTER_VIEW), SetAspect(WidgetDimensions::ASPECT_LOCATION), SetSpriteTip(SPR_GOTO_LOCATION, STR_TOWN_VIEW_CENTER_TOOLTIP),
651 NWidget(WWT_SHADEBOX, COLOUR_BROWN),
652 NWidget(WWT_DEFSIZEBOX, COLOUR_BROWN),
653 NWidget(WWT_STICKYBOX, COLOUR_BROWN),
654 EndContainer(),
655 NWidget(WWT_PANEL, COLOUR_BROWN),
656 NWidget(WWT_INSET, COLOUR_BROWN), SetPadding(2, 2, 2, 2),
657 NWidget(NWID_VIEWPORT, INVALID_COLOUR, WID_TV_VIEWPORT), SetMinimalSize(254, 86), SetFill(1, 1), SetResize(1, 1),
658 EndContainer(),
659 EndContainer(),
660 NWidget(WWT_PANEL, COLOUR_BROWN, WID_TV_INFO), SetMinimalSize(260, 32), SetResize(1, 0), SetFill(1, 0), EndContainer(),
662 NWidget(WWT_PUSHTXTBTN, COLOUR_BROWN, WID_TV_EXPAND), SetFill(1, 1), SetResize(1, 0), SetStringTip(STR_TOWN_VIEW_EXPAND_BUTTON, STR_TOWN_VIEW_EXPAND_TOOLTIP),
663 NWidget(WWT_PUSHTXTBTN, COLOUR_BROWN, WID_TV_EXPAND_BUILDINGS), SetFill(1, 1), SetResize(1, 0), SetStringTip(STR_TOWN_VIEW_EXPAND_BUILDINGS_BUTTON, STR_TOWN_VIEW_EXPAND_BUILDINGS_TOOLTIP),
664 NWidget(WWT_PUSHTXTBTN, COLOUR_BROWN, WID_TV_EXPAND_ROADS), SetFill(1, 1), SetResize(1, 0), SetStringTip(STR_TOWN_VIEW_EXPAND_ROADS_BUTTON, STR_TOWN_VIEW_EXPAND_ROADS_TOOLTIP),
665 EndContainer(),
667 NWidget(WWT_PUSHTXTBTN, COLOUR_BROWN, WID_TV_DELETE), SetFill(1, 1), SetResize(1, 0), SetStringTip(STR_TOWN_VIEW_DELETE_BUTTON, STR_TOWN_VIEW_DELETE_TOOLTIP),
668 NWidget(WWT_TEXTBTN, COLOUR_BROWN, WID_TV_CATCHMENT), SetFill(1, 1), SetResize(1, 0), SetStringTip(STR_BUTTON_CATCHMENT, STR_TOOLTIP_CATCHMENT),
669 NWidget(WWT_RESIZEBOX, COLOUR_BROWN),
670 EndContainer(),
671};
672
673static WindowDesc _town_editor_view_desc(
674 WDP_AUTO, "view_town_scen", 260, TownViewWindow::WID_TV_HEIGHT_NORMAL,
676 {},
677 _nested_town_editor_view_widgets
678);
679
680void ShowTownViewWindow(TownID town)
681{
682 if (_game_mode == GM_EDITOR) {
683 AllocateWindowDescFront<TownViewWindow>(_town_editor_view_desc, town);
684 } else {
685 AllocateWindowDescFront<TownViewWindow>(_town_game_view_desc, town);
686 }
687}
688
689static constexpr NWidgetPart _nested_town_directory_widgets[] = {
691 NWidget(WWT_CLOSEBOX, COLOUR_BROWN),
692 NWidget(WWT_CAPTION, COLOUR_BROWN, WID_TD_CAPTION),
693 NWidget(WWT_SHADEBOX, COLOUR_BROWN),
694 NWidget(WWT_DEFSIZEBOX, COLOUR_BROWN),
695 NWidget(WWT_STICKYBOX, COLOUR_BROWN),
696 EndContainer(),
700 NWidget(WWT_TEXTBTN, COLOUR_BROWN, WID_TD_SORT_ORDER), SetStringTip(STR_BUTTON_SORT_BY, STR_TOOLTIP_SORT_ORDER),
701 NWidget(WWT_DROPDOWN, COLOUR_BROWN, WID_TD_SORT_CRITERIA), SetToolTip(STR_TOOLTIP_SORT_CRITERIA),
702 NWidget(WWT_EDITBOX, COLOUR_BROWN, WID_TD_FILTER), SetFill(1, 0), SetResize(1, 0), SetStringTip(STR_LIST_FILTER_OSKTITLE, STR_LIST_FILTER_TOOLTIP),
703 EndContainer(),
704 NWidget(WWT_PANEL, COLOUR_BROWN, WID_TD_LIST), SetToolTip(STR_TOWN_DIRECTORY_LIST_TOOLTIP),
706 NWidget(WWT_PANEL, COLOUR_BROWN),
707 NWidget(WWT_TEXT, INVALID_COLOUR, WID_TD_WORLD_POPULATION), SetPadding(2, 0, 2, 2), SetFill(1, 0), SetResize(1, 0),
708 EndContainer(),
709 EndContainer(),
712 NWidget(WWT_RESIZEBOX, COLOUR_BROWN),
713 EndContainer(),
714 EndContainer(),
715};
716
719private:
720 /* Runtime saved values */
721 static Listing last_sorting;
722
723 /* Constants for sorting towns */
724 static inline const StringID sorter_names[] = {
725 STR_SORT_BY_NAME,
726 STR_SORT_BY_POPULATION,
727 STR_SORT_BY_RATING,
728 };
729 static const std::initializer_list<GUITownList::SortFunction * const> sorter_funcs;
730
733
734 GUITownList towns{TownDirectoryWindow::last_sorting.order};
735
736 Scrollbar *vscroll = nullptr;
737
738 void BuildSortTownList()
739 {
740 if (this->towns.NeedRebuild()) {
741 this->towns.clear();
742 this->towns.reserve(Town::GetNumItems());
743
744 for (const Town *t : Town::Iterate()) {
745 if (this->string_filter.IsEmpty()) {
746 this->towns.push_back(t);
747 continue;
748 }
750 this->string_filter.AddLine(t->GetCachedName());
751 if (this->string_filter.GetState()) this->towns.push_back(t);
752 }
753
754 this->towns.RebuildDone();
755 this->vscroll->SetCount(this->towns.size()); // Update scrollbar as well.
756 }
757 /* Always sort the towns. */
758 this->towns.Sort();
759 this->SetWidgetDirty(WID_TD_LIST); // Force repaint of the displayed towns.
760 }
761
763 static bool TownNameSorter(const Town * const &a, const Town * const &b, const bool &)
764 {
765 return StrNaturalCompare(a->GetCachedName(), b->GetCachedName()) < 0; // Sort by name (natural sorting).
766 }
767
769 static bool TownPopulationSorter(const Town * const &a, const Town * const &b, const bool &order)
770 {
771 uint32_t a_population = a->cache.population;
772 uint32_t b_population = b->cache.population;
773 if (a_population == b_population) return TownDirectoryWindow::TownNameSorter(a, b, order);
774 return a_population < b_population;
775 }
776
778 static bool TownRatingSorter(const Town * const &a, const Town * const &b, const bool &order)
779 {
780 bool before = !order; // Value to get 'a' before 'b'.
781
782 /* Towns without rating are always after towns with rating. */
785 int16_t a_rating = a->ratings[_local_company];
786 int16_t b_rating = b->ratings[_local_company];
787 if (a_rating == b_rating) return TownDirectoryWindow::TownNameSorter(a, b, order);
788 return a_rating < b_rating;
789 }
790 return before;
791 }
792 if (b->have_ratings.Test(_local_company)) return !before;
793
794 /* Sort unrated towns always on ascending town name. */
795 if (before) return TownDirectoryWindow::TownNameSorter(a, b, order);
796 return TownDirectoryWindow::TownNameSorter(b, a, order);
797 }
798
799public:
801 {
802 this->CreateNestedTree();
803
804 this->vscroll = this->GetScrollbar(WID_TD_SCROLLBAR);
805
806 this->towns.SetListing(this->last_sorting);
808 this->towns.ForceRebuild();
809 this->BuildSortTownList();
810
811 this->FinishInitNested(0);
812
814 this->townname_editbox.cancel_button = QueryString::ACTION_CLEAR;
815 }
816
817 std::string GetWidgetString(WidgetID widget, StringID stringid) const override
818 {
819 switch (widget) {
820 case WID_TD_CAPTION:
821 return GetString(STR_TOWN_DIRECTORY_CAPTION, this->vscroll->GetCount(), Town::GetNumItems());
822
824 return GetString(STR_TOWN_POPULATION, GetWorldPopulation());
825
827 return GetString(TownDirectoryWindow::sorter_names[this->towns.SortType()]);
828
829 default:
830 return this->Window::GetWidgetString(widget, stringid);
831 }
832 }
833
839 static std::string GetTownString(const Town *t, uint64_t population)
840 {
841 return GetString(t->larger_town ? STR_TOWN_DIRECTORY_CITY : STR_TOWN_DIRECTORY_TOWN, t->index, population);
842 }
843
844 void DrawWidget(const Rect &r, WidgetID widget) const override
845 {
846 switch (widget) {
848 this->DrawSortButtonState(widget, this->towns.IsDescSortOrder() ? SBS_DOWN : SBS_UP);
849 break;
850
851 case WID_TD_LIST: {
852 Rect tr = r.Shrink(WidgetDimensions::scaled.framerect);
853 if (this->towns.empty()) { // No towns available.
854 DrawString(tr, STR_TOWN_DIRECTORY_NONE);
855 break;
856 }
857
858 /* At least one town available. */
859 bool rtl = _current_text_dir == TD_RTL;
860 Dimension icon_size = GetSpriteSize(SPR_TOWN_RATING_GOOD);
861 int icon_x = tr.WithWidth(icon_size.width, rtl).left;
862 tr = tr.Indent(icon_size.width + WidgetDimensions::scaled.hsep_normal, rtl);
863
864 auto [first, last] = this->vscroll->GetVisibleRangeIterators(this->towns);
865 for (auto it = first; it != last; ++it) {
866 const Town *t = *it;
867 assert(t->xy != INVALID_TILE);
868
869 /* Draw rating icon. */
870 if (_game_mode == GM_EDITOR || !t->have_ratings.Test(_local_company)) {
871 DrawSprite(SPR_TOWN_RATING_NA, PAL_NONE, icon_x, tr.top + (this->resize.step_height - icon_size.height) / 2);
872 } else {
873 SpriteID icon = SPR_TOWN_RATING_APPALLING;
874 if (t->ratings[_local_company] > RATING_VERYPOOR) icon = SPR_TOWN_RATING_MEDIOCRE;
875 if (t->ratings[_local_company] > RATING_GOOD) icon = SPR_TOWN_RATING_GOOD;
876 DrawSprite(icon, PAL_NONE, icon_x, tr.top + (this->resize.step_height - icon_size.height) / 2);
877 }
878
879 DrawString(tr.left, tr.right, tr.top + (this->resize.step_height - GetCharacterHeight(FS_NORMAL)) / 2, GetTownString(t, t->cache.population));
880
881 tr.top += this->resize.step_height;
882 }
883 break;
884 }
885 }
886 }
887
888 void UpdateWidgetSize(WidgetID widget, Dimension &size, [[maybe_unused]] const Dimension &padding, [[maybe_unused]] Dimension &fill, [[maybe_unused]] Dimension &resize) override
889 {
890 switch (widget) {
891 case WID_TD_SORT_ORDER: {
892 Dimension d = GetStringBoundingBox(this->GetWidget<NWidgetCore>(widget)->GetString());
893 d.width += padding.width + Window::SortButtonWidth() * 2; // Doubled since the string is centred and it also looks better.
894 d.height += padding.height;
895 size = maxdim(size, d);
896 break;
897 }
899 Dimension d = GetStringListBoundingBox(TownDirectoryWindow::sorter_names);
900 d.width += padding.width;
901 d.height += padding.height;
902 size = maxdim(size, d);
903 break;
904 }
905 case WID_TD_LIST: {
906 Dimension d = GetStringBoundingBox(STR_TOWN_DIRECTORY_NONE);
907 uint64_t max_value = GetParamMaxDigits(8);
908 for (uint i = 0; i < this->towns.size(); i++) {
909 const Town *t = this->towns[i];
910
911 assert(t != nullptr);
912
913 d = maxdim(d, GetStringBoundingBox(GetTownString(t, max_value)));
914 }
915 Dimension icon_size = GetSpriteSize(SPR_TOWN_RATING_GOOD);
916 d.width += icon_size.width + 2;
917 d.height = std::max(d.height, icon_size.height);
918 fill.height = resize.height = d.height;
919 d.height *= 5;
920 d.width += padding.width;
921 d.height += padding.height;
922 size = maxdim(size, d);
923 break;
924 }
926 Dimension d = GetStringBoundingBox(GetString(STR_TOWN_POPULATION, GetParamMaxDigits(10)));
927 d.width += padding.width;
928 d.height += padding.height;
929 size = maxdim(size, d);
930 break;
931 }
932 }
933 }
934
935 void OnClick([[maybe_unused]] Point pt, WidgetID widget, [[maybe_unused]] int click_count) override
936 {
937 switch (widget) {
938 case WID_TD_SORT_ORDER: // Click on sort order button
939 if (this->towns.SortType() != 2) { // A different sort than by rating.
940 this->towns.ToggleSortOrder();
941 this->last_sorting = this->towns.GetListing(); // Store new sorting order.
942 } else {
943 /* Some parts are always sorted ascending on name. */
944 this->last_sorting.order = !this->last_sorting.order;
945 this->towns.SetListing(this->last_sorting);
946 this->towns.ForceResort();
947 this->towns.Sort();
948 }
949 this->SetDirty();
950 break;
951
952 case WID_TD_SORT_CRITERIA: // Click on sort criteria dropdown
953 ShowDropDownMenu(this, TownDirectoryWindow::sorter_names, this->towns.SortType(), WID_TD_SORT_CRITERIA, 0, 0);
954 break;
955
956 case WID_TD_LIST: { // Click on Town Matrix
957 auto it = this->vscroll->GetScrolledItemFromWidget(this->towns, pt.y, this, WID_TD_LIST, WidgetDimensions::scaled.framerect.top);
958 if (it == this->towns.end()) return; // click out of town bounds
959
960 const Town *t = *it;
961 assert(t != nullptr);
962 if (_ctrl_pressed) {
964 } else {
966 }
967 break;
968 }
969 }
970 }
971
972 void OnDropdownSelect(WidgetID widget, int index, int) override
973 {
974 if (widget != WID_TD_SORT_CRITERIA) return;
975
976 if (this->towns.SortType() != index) {
977 this->towns.SetSortType(index);
978 this->last_sorting = this->towns.GetListing(); // Store new sorting order.
979 this->BuildSortTownList();
980 }
981 }
982
983 void OnPaint() override
984 {
985 if (this->towns.NeedRebuild()) this->BuildSortTownList();
986 this->DrawWidgets();
987 }
988
990 const IntervalTimer<TimerWindow> rebuild_interval = {std::chrono::seconds(3), [this](auto) {
991 this->BuildSortTownList();
992 this->SetDirty();
993 }};
994
995 void OnResize() override
996 {
997 this->vscroll->SetCapacityFromWidget(this, WID_TD_LIST, WidgetDimensions::scaled.framerect.Vertical());
998 }
999
1000 void OnEditboxChanged(WidgetID wid) override
1001 {
1002 if (wid == WID_TD_FILTER) {
1003 this->string_filter.SetFilterTerm(this->townname_editbox.text.GetText());
1004 this->InvalidateData(TDIWD_FORCE_REBUILD);
1005 }
1006 }
1007
1013 void OnInvalidateData([[maybe_unused]] int data = 0, [[maybe_unused]] bool gui_scope = true) override
1014 {
1015 switch (data) {
1016 case TDIWD_FORCE_REBUILD:
1017 /* This needs to be done in command-scope to enforce rebuilding before resorting invalid data */
1018 this->towns.ForceRebuild();
1019 break;
1020
1021 case TDIWD_POPULATION_CHANGE:
1022 if (this->towns.SortType() == 1) this->towns.ForceResort();
1023 break;
1024
1025 default:
1026 this->towns.ForceResort();
1027 }
1028 }
1029
1030 static inline HotkeyList hotkeys {"towndirectory", {
1031 Hotkey('F', "focus_filter_box", WID_TD_FILTER),
1032 }};
1033};
1034
1035Listing TownDirectoryWindow::last_sorting = {false, 0};
1036
1038const std::initializer_list<GUITownList::SortFunction * const> TownDirectoryWindow::sorter_funcs = {
1039 &TownNameSorter,
1040 &TownPopulationSorter,
1041 &TownRatingSorter,
1042};
1043
1044static WindowDesc _town_directory_desc(
1045 WDP_AUTO, "list_towns", 208, 202,
1047 {},
1048 _nested_town_directory_widgets,
1049 &TownDirectoryWindow::hotkeys
1050);
1051
1052void ShowTownDirectory()
1053{
1055 new TownDirectoryWindow(_town_directory_desc);
1056}
1057
1058void CcFoundTown(Commands, const CommandCost &result, TileIndex tile)
1059{
1060 if (result.Failed()) return;
1061
1062 if (_settings_client.sound.confirm) SndPlayTileFx(SND_1F_CONSTRUCTION_OTHER, tile);
1064}
1065
1066void CcFoundRandomTown(Commands, const CommandCost &result, Money, TownID town_id)
1067{
1068 if (result.Succeeded()) ScrollMainWindowToTile(Town::Get(town_id)->xy);
1069}
1070
1071static constexpr NWidgetPart _nested_found_town_widgets[] = {
1073 NWidget(WWT_CLOSEBOX, COLOUR_DARK_GREEN),
1074 NWidget(WWT_CAPTION, COLOUR_DARK_GREEN), SetStringTip(STR_FOUND_TOWN_CAPTION, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
1075 NWidget(WWT_SHADEBOX, COLOUR_DARK_GREEN),
1076 NWidget(WWT_STICKYBOX, COLOUR_DARK_GREEN),
1077 EndContainer(),
1078 /* Construct new town(s) buttons. */
1079 NWidget(WWT_PANEL, COLOUR_DARK_GREEN),
1081 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_TF_NEW_TOWN), SetStringTip(STR_FOUND_TOWN_NEW_TOWN_BUTTON, STR_FOUND_TOWN_NEW_TOWN_TOOLTIP), SetFill(1, 0),
1084 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_TF_RANDOM_TOWN), SetStringTip(STR_FOUND_TOWN_RANDOM_TOWN_BUTTON, STR_FOUND_TOWN_RANDOM_TOWN_TOOLTIP), SetFill(1, 0),
1085 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_TF_MANY_RANDOM_TOWNS), SetStringTip(STR_FOUND_TOWN_MANY_RANDOM_TOWNS, STR_FOUND_TOWN_RANDOM_TOWNS_TOOLTIP), SetFill(1, 0),
1086 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_TF_LOAD_FROM_FILE), SetStringTip(STR_FOUND_TOWN_LOAD_FROM_FILE, STR_FOUND_TOWN_LOAD_FROM_FILE_TOOLTIP), SetFill(1, 0),
1087 EndContainer(),
1088 EndContainer(),
1089
1090 /* Town name selection. */
1091 NWidget(WWT_LABEL, INVALID_COLOUR), SetStringTip(STR_FOUND_TOWN_NAME_TITLE),
1092 NWidget(WWT_EDITBOX, COLOUR_GREY, WID_TF_TOWN_NAME_EDITBOX), SetStringTip(STR_FOUND_TOWN_NAME_EDITOR_TITLE, STR_FOUND_TOWN_NAME_EDITOR_TOOLTIP), SetFill(1, 0),
1093 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_TF_TOWN_NAME_RANDOM), SetStringTip(STR_FOUND_TOWN_NAME_RANDOM_BUTTON, STR_FOUND_TOWN_NAME_RANDOM_TOOLTIP), SetFill(1, 0),
1094
1095 /* Town size selection. */
1096 NWidget(WWT_LABEL, INVALID_COLOUR), SetStringTip(STR_FOUND_TOWN_INITIAL_SIZE_TITLE),
1099 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_TF_SIZE_SMALL), SetStringTip(STR_FOUND_TOWN_INITIAL_SIZE_SMALL_BUTTON, STR_FOUND_TOWN_INITIAL_SIZE_TOOLTIP), SetFill(1, 0),
1100 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_TF_SIZE_MEDIUM), SetStringTip(STR_FOUND_TOWN_INITIAL_SIZE_MEDIUM_BUTTON, STR_FOUND_TOWN_INITIAL_SIZE_TOOLTIP), SetFill(1, 0),
1101 EndContainer(),
1103 NWidget(NWID_SELECTION, INVALID_COLOUR, WID_TF_SIZE_SEL),
1104 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_TF_SIZE_LARGE), SetStringTip(STR_FOUND_TOWN_INITIAL_SIZE_LARGE_BUTTON, STR_FOUND_TOWN_INITIAL_SIZE_TOOLTIP), SetFill(1, 0),
1105 EndContainer(),
1106 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_TF_SIZE_RANDOM), SetStringTip(STR_FOUND_TOWN_SIZE_RANDOM, STR_FOUND_TOWN_INITIAL_SIZE_TOOLTIP), SetFill(1, 0),
1107 EndContainer(),
1108 EndContainer(),
1109 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_TF_CITY), SetStringTip(STR_FOUND_TOWN_CITY, STR_FOUND_TOWN_CITY_TOOLTIP), SetFill(1, 0),
1110
1111 /* Town roads selection. */
1114 NWidget(WWT_LABEL, INVALID_COLOUR), SetStringTip(STR_FOUND_TOWN_ROAD_LAYOUT),
1117 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_TF_LAYOUT_ORIGINAL), SetStringTip(STR_FOUND_TOWN_SELECT_LAYOUT_ORIGINAL, STR_FOUND_TOWN_SELECT_LAYOUT_TOOLTIP), SetFill(1, 0),
1118 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_TF_LAYOUT_BETTER), SetStringTip(STR_FOUND_TOWN_SELECT_LAYOUT_BETTER_ROADS, STR_FOUND_TOWN_SELECT_LAYOUT_TOOLTIP), SetFill(1, 0),
1119 EndContainer(),
1121 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_TF_LAYOUT_GRID2), SetStringTip(STR_FOUND_TOWN_SELECT_LAYOUT_2X2_GRID, STR_FOUND_TOWN_SELECT_LAYOUT_TOOLTIP), SetFill(1, 0),
1122 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_TF_LAYOUT_GRID3), SetStringTip(STR_FOUND_TOWN_SELECT_LAYOUT_3X3_GRID, STR_FOUND_TOWN_SELECT_LAYOUT_TOOLTIP), SetFill(1, 0),
1123 EndContainer(),
1124 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_TF_LAYOUT_RANDOM), SetStringTip(STR_FOUND_TOWN_SELECT_LAYOUT_RANDOM, STR_FOUND_TOWN_SELECT_LAYOUT_TOOLTIP), SetFill(1, 0),
1125 EndContainer(),
1126 EndContainer(),
1127 EndContainer(),
1128
1129 /* Town expansion selection. */
1132 NWidget(WWT_LABEL, INVALID_COLOUR), SetStringTip(STR_FOUND_TOWN_EXPAND_MODE),
1133 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_TF_EXPAND_ALL_TOWNS), SetStringTip(STR_FOUND_TOWN_EXPAND_ALL_TOWNS, STR_FOUND_TOWN_EXPAND_ALL_TOWNS_TOOLTIP), SetFill(1, 0),
1135 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_TF_EXPAND_BUILDINGS), SetStringTip(STR_FOUND_TOWN_EXPAND_BUILDINGS, STR_FOUND_TOWN_EXPAND_BUILDINGS_TOOLTIP), SetFill(1, 0),
1136 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_TF_EXPAND_ROADS), SetStringTip(STR_FOUND_TOWN_EXPAND_ROADS, STR_FOUND_TOWN_EXPAND_ROADS_TOOLTIP), SetFill(1, 0),
1137 EndContainer(),
1138 EndContainer(),
1139 EndContainer(),
1140 EndContainer(),
1141 EndContainer(),
1142};
1143
1146private:
1149 bool city = false;
1151 bool townnamevalid = false;
1152 uint32_t townnameparts = 0;
1155
1156public:
1158 Window(desc),
1161 params(_settings_game.game_creation.town_name)
1162 {
1163 this->InitNested(window_number);
1165 this->RandomTownName();
1166 this->UpdateButtons(true);
1167 }
1168
1169 void OnInit() override
1170 {
1171 if (_game_mode == GM_EDITOR) return;
1172
1173 this->GetWidget<NWidgetStacked>(WID_TF_TOWN_ACTION_SEL)->SetDisplayedPlane(SZSP_HORIZONTAL);
1174 this->GetWidget<NWidgetStacked>(WID_TF_TOWN_EXPAND_SEL)->SetDisplayedPlane(SZSP_HORIZONTAL);
1175 this->GetWidget<NWidgetStacked>(WID_TF_SIZE_SEL)->SetDisplayedPlane(SZSP_VERTICAL);
1177 this->GetWidget<NWidgetStacked>(WID_TF_ROAD_LAYOUT_SEL)->SetDisplayedPlane(SZSP_HORIZONTAL);
1178 } else {
1179 this->GetWidget<NWidgetStacked>(WID_TF_ROAD_LAYOUT_SEL)->SetDisplayedPlane(0);
1180 }
1181 }
1182
1183 void RandomTownName()
1184 {
1185 this->townnamevalid = GenerateTownName(_interactive_random, &this->townnameparts);
1186
1187 if (!this->townnamevalid) {
1188 this->townname_editbox.text.DeleteAll();
1189 } else {
1190 this->townname_editbox.text.Assign(GetTownName(&this->params, this->townnameparts));
1191 }
1193
1195 }
1196
1197 void UpdateButtons(bool check_availability)
1198 {
1199 if (check_availability && _game_mode != GM_EDITOR) {
1201 this->ReInit();
1202 }
1203
1204 for (WidgetID i = WID_TF_SIZE_SMALL; i <= WID_TF_SIZE_RANDOM; i++) {
1205 this->SetWidgetLoweredState(i, i == WID_TF_SIZE_SMALL + this->town_size);
1206 }
1207
1208 this->SetWidgetLoweredState(WID_TF_CITY, this->city);
1209
1212 }
1213
1214 this->SetWidgetLoweredState(WID_TF_EXPAND_BUILDINGS, FoundTownWindow::expand_modes.Test(TownExpandMode::Buildings));
1215 this->SetWidgetLoweredState(WID_TF_EXPAND_ROADS, FoundTownWindow::expand_modes.Test(TownExpandMode::Roads));
1216
1217 this->SetDirty();
1218 }
1219
1220 template <typename Tcallback>
1221 void ExecuteFoundTownCommand(TileIndex tile, bool random, StringID errstr, Tcallback cc)
1222 {
1223 std::string name;
1224
1225 if (!this->townnamevalid) {
1226 name = this->townname_editbox.text.GetText();
1227 } else {
1228 /* If user changed the name, send it */
1229 std::string original_name = GetTownName(&this->params, this->townnameparts);
1230 if (original_name != this->townname_editbox.text.GetText()) name = this->townname_editbox.text.GetText();
1231 }
1232
1233 bool success = Command<CMD_FOUND_TOWN>::Post(errstr, cc,
1234 tile, this->town_size, this->city, this->town_layout, random, townnameparts, name);
1235
1236 /* Rerandomise name, if success and no cost-estimation. */
1237 if (success && !_shift_pressed) this->RandomTownName();
1238 }
1239
1240 void OnClick([[maybe_unused]] Point pt, WidgetID widget, [[maybe_unused]] int click_count) override
1241 {
1242 switch (widget) {
1243 case WID_TF_NEW_TOWN:
1244 HandlePlacePushButton(this, WID_TF_NEW_TOWN, SPR_CURSOR_TOWN, HT_RECT);
1245 break;
1246
1247 case WID_TF_RANDOM_TOWN:
1248 this->ExecuteFoundTownCommand(TileIndex{}, true, STR_ERROR_CAN_T_GENERATE_TOWN, CcFoundRandomTown);
1249 break;
1250
1252 this->RandomTownName();
1254 break;
1255
1257 std::string default_town_number = fmt::format("{}", GetDefaultTownsForMapSize());
1258 ShowQueryString(default_town_number, STR_MAPGEN_NUMBER_OF_TOWNS, 5, this, CS_NUMERAL, {QueryStringFlag::AcceptUnchanged});
1259 break;
1260 }
1263 break;
1264
1266 for (Town *t : Town::Iterate()) {
1267 Command<CMD_EXPAND_TOWN>::Do(DoCommandFlag::Execute, t->index, 0, FoundTownWindow::expand_modes);
1268 }
1269 break;
1270
1272 this->town_size = (TownSize)(widget - WID_TF_SIZE_SMALL);
1273 this->UpdateButtons(false);
1274 break;
1275
1276 case WID_TF_CITY:
1277 this->city ^= true;
1278 this->SetWidgetLoweredState(WID_TF_CITY, this->city);
1279 this->SetDirty();
1280 break;
1281
1283 FoundTownWindow::expand_modes.Flip(TownExpandMode::Buildings);
1284 this->UpdateButtons(false);
1285 break;
1286
1288 FoundTownWindow::expand_modes.Flip(TownExpandMode::Roads);
1289 this->UpdateButtons(false);
1290 break;
1291
1294 this->town_layout = (TownLayout)(widget - WID_TF_LAYOUT_ORIGINAL);
1295
1296 /* If we are in the editor, sync the settings of the current game to the chosen layout,
1297 * so that importing towns from file uses the selected layout. */
1298 if (_game_mode == GM_EDITOR) _settings_game.economy.town_layout = this->town_layout;
1299
1300 this->UpdateButtons(false);
1301 break;
1302 }
1303 }
1304
1305 void OnQueryTextFinished(std::optional<std::string> str) override
1306 {
1307 /* Was 'cancel' pressed? */
1308 if (!str.has_value()) return;
1309
1310 auto value = ParseInteger(*str, 10, true);
1311 if (!value.has_value()) return;
1312
1313 Backup<bool> old_generating_world(_generating_world, true);
1315 if (!GenerateTowns(this->town_layout, value)) {
1316 ShowErrorMessage(GetEncodedString(STR_ERROR_CAN_T_GENERATE_TOWN), GetEncodedString(STR_ERROR_NO_SPACE_FOR_TOWN), WL_INFO);
1317 }
1319 old_generating_world.Restore();
1320 }
1321
1322 void OnPlaceObject([[maybe_unused]] Point pt, TileIndex tile) override
1323 {
1324 this->ExecuteFoundTownCommand(tile, false, STR_ERROR_CAN_T_FOUND_TOWN_HERE, CcFoundTown);
1325 }
1326
1327 void OnPlaceObjectAbort() override
1328 {
1329 this->RaiseButtons();
1330 this->UpdateButtons(false);
1331 }
1332
1338 void OnInvalidateData([[maybe_unused]] int data = 0, [[maybe_unused]] bool gui_scope = true) override
1339 {
1340 if (!gui_scope) return;
1341 this->UpdateButtons(true);
1342 }
1343};
1344
1345static WindowDesc _found_town_desc(
1346 WDP_AUTO, "build_town", 160, 162,
1349 _nested_found_town_widgets
1350);
1351
1352void ShowFoundTownWindow()
1353{
1354 if (_game_mode != GM_EDITOR && !Company::IsValidID(_local_company)) return;
1355 AllocateWindowDescFront<FoundTownWindow>(_found_town_desc, 0);
1356}
1357
1358void InitializeTownGui()
1359{
1360 _town_local_authority_kdtree.Clear();
1361}
1362
1370void DrawHouseInGUI(int x, int y, HouseID house_id, int view)
1371{
1372 auto draw = [](int x, int y, HouseID house_id, int view) {
1373 if (house_id >= NEW_HOUSE_OFFSET) {
1374 /* Houses don't necessarily need new graphics. If they don't have a
1375 * spritegroup associated with them, then the sprite for the substitute
1376 * house id is drawn instead. */
1377 const HouseSpec *spec = HouseSpec::Get(house_id);
1378 if (spec->grf_prop.HasSpriteGroups()) {
1379 DrawNewHouseTileInGUI(x, y, spec, house_id, view);
1380 return;
1381 } else {
1382 house_id = HouseSpec::Get(house_id)->grf_prop.subst_id;
1383 }
1384 }
1385
1386 /* Retrieve data from the draw town tile struct */
1387 const DrawBuildingsTileStruct &dcts = GetTownDrawTileData()[house_id << 4 | view << 2 | TOWN_HOUSE_COMPLETED];
1388 DrawSprite(dcts.ground.sprite, dcts.ground.pal, x, y);
1389
1390 /* Add a house on top of the ground? */
1391 if (dcts.building.sprite != 0) {
1392 Point pt = RemapCoords(dcts.origin.x, dcts.origin.y, dcts.origin.z);
1393 DrawSprite(dcts.building.sprite, dcts.building.pal, x + UnScaleGUI(pt.x), y + UnScaleGUI(pt.y));
1394 }
1395 };
1396
1397 /* Houses can have 1x1, 1x2, 2x1 and 2x2 layouts which are individual HouseIDs. For the GUI we need
1398 * draw all of the tiles with appropriate positions. */
1399 int x_delta = ScaleSpriteTrad(TILE_PIXELS);
1400 int y_delta = ScaleSpriteTrad(TILE_PIXELS / 2);
1401
1402 const HouseSpec *hs = HouseSpec::Get(house_id);
1403 if (hs->building_flags.Test(BuildingFlag::Size2x2)) {
1404 draw(x, y - y_delta - y_delta, house_id, view); // North corner.
1405 draw(x + x_delta, y - y_delta, house_id + 1, view); // West corner.
1406 draw(x - x_delta, y - y_delta, house_id + 2, view); // East corner.
1407 draw(x, y, house_id + 3, view); // South corner.
1408 } else if (hs->building_flags.Test(BuildingFlag::Size2x1)) {
1409 draw(x + x_delta / 2, y - y_delta, house_id, view); // North east tile.
1410 draw(x - x_delta / 2, y, house_id + 1, view); // South west tile.
1411 } else if (hs->building_flags.Test(BuildingFlag::Size1x2)) {
1412 draw(x - x_delta / 2, y - y_delta, house_id, view); // North west tile.
1413 draw(x + x_delta / 2, y, house_id + 1, view); // South east tile.
1414 } else {
1415 draw(x, y, house_id, view);
1416 }
1417}
1418
1425{
1426 std::array<int32_t, 1> regs100;
1427 uint16_t callback_res = GetHouseCallback(CBID_HOUSE_CUSTOM_NAME, 1, 0, hs->Index(), nullptr, INVALID_TILE, regs100, true);
1428 if (callback_res != CALLBACK_FAILED && callback_res != 0x400) {
1429 StringID new_name = STR_NULL;
1430 if (callback_res == 0x40F) {
1431 new_name = GetGRFStringID(hs->grf_prop.grffile->grfid, static_cast<GRFStringID>(regs100[0]));
1432 } else if (callback_res > 0x400) {
1434 } else {
1435 new_name = GetGRFStringID(hs->grf_prop.grffile->grfid, GRFSTR_MISC_GRF_TEXT + callback_res);
1436 }
1437 if (new_name != STR_NULL && new_name != STR_UNDEFINED) {
1438 return new_name;
1439 }
1440 }
1441
1442 return hs->building_name;
1443}
1444
1446public:
1447 HousePickerCallbacks() : PickerCallbacks("fav_houses") {}
1448
1453 {
1454 this->climate_mask = GetClimateMaskForLandscape();
1455
1456 /* In some cases, not all 'classes' (house zones) have distinct houses, so we need to disable those.
1457 * As we need to check all types, and this cannot change with the picker window open, pre-calculate it.
1458 * This loop calls GetTypeName() instead of directly checking properties so that there is no discrepancy. */
1459 this->class_mask = 0;
1460
1461 int num_classes = this->GetClassCount();
1462 for (int cls_id = 0; cls_id < num_classes; ++cls_id) {
1463 int num_types = this->GetTypeCount(cls_id);
1464 for (int id = 0; id < num_types; ++id) {
1465 if (this->GetTypeName(cls_id, id) != INVALID_STRING_ID) {
1466 SetBit(this->class_mask, cls_id);
1467 break;
1468 }
1469 }
1470 }
1471 }
1472
1473 HouseZones climate_mask{};
1474 uint8_t class_mask = 0;
1475
1476 static inline int sel_class;
1477 static inline int sel_type;
1478 static inline int sel_view;
1479
1480 /* Houses do not have classes like NewGRFClass. We'll make up fake classes based on town zone
1481 * availability instead. */
1482 static inline const std::array<StringID, NUM_HOUSE_ZONES> zone_names = {
1483 STR_HOUSE_PICKER_CLASS_ZONE1,
1484 STR_HOUSE_PICKER_CLASS_ZONE2,
1485 STR_HOUSE_PICKER_CLASS_ZONE3,
1486 STR_HOUSE_PICKER_CLASS_ZONE4,
1487 STR_HOUSE_PICKER_CLASS_ZONE5,
1488 };
1489
1490 GrfSpecFeature GetFeature() const override { return GSF_HOUSES; }
1491
1492 StringID GetClassTooltip() const override { return STR_PICKER_HOUSE_CLASS_TOOLTIP; }
1493 StringID GetTypeTooltip() const override { return STR_PICKER_HOUSE_TYPE_TOOLTIP; }
1494 bool IsActive() const override { return true; }
1495
1496 bool HasClassChoice() const override { return true; }
1497 int GetClassCount() const override { return static_cast<int>(zone_names.size()); }
1498
1499 void Close([[maybe_unused]] int data) override { ResetObjectToPlace(); }
1500
1501 int GetSelectedClass() const override { return HousePickerCallbacks::sel_class; }
1502 void SetSelectedClass(int cls_id) const override { HousePickerCallbacks::sel_class = cls_id; }
1503
1504 StringID GetClassName(int id) const override
1505 {
1506 if (id >= GetClassCount()) return INVALID_STRING_ID;
1507 if (!HasBit(this->class_mask, id)) return INVALID_STRING_ID;
1508 return zone_names[id];
1509 }
1510
1511 int GetTypeCount(int cls_id) const override
1512 {
1513 if (cls_id < GetClassCount()) return static_cast<int>(HouseSpec::Specs().size());
1514 return 0;
1515 }
1516
1517 PickerItem GetPickerItem(int cls_id, int id) const override
1518 {
1519 const auto *spec = HouseSpec::Get(id);
1520 if (!spec->grf_prop.HasGrfFile()) return {0, spec->Index(), cls_id, id};
1521 return {spec->grf_prop.grfid, spec->grf_prop.local_id, cls_id, id};
1522 }
1523
1524 int GetSelectedType() const override { return sel_type; }
1525 void SetSelectedType(int id) const override { sel_type = id; }
1526
1527 static HouseZone GetHouseZoneFromClassId(int cls_id) { return static_cast<HouseZone>(to_underlying(HouseZone::TownEdge) + cls_id); }
1528 static int GetClassIdFromHouseZone(HouseZones zones) { return FindFirstBit((zones & HZ_ZONE_ALL).base()) - to_underlying(HouseZone::TownEdge); }
1529
1530 StringID GetTypeName(int cls_id, int id) const override
1531 {
1532 const HouseSpec *spec = HouseSpec::Get(id);
1533 if (spec == nullptr) return INVALID_STRING_ID;
1534 if (!spec->enabled) return INVALID_STRING_ID;
1535 if (!spec->building_availability.Any(climate_mask)) return INVALID_STRING_ID;
1536 if (!spec->building_availability.Test(GetHouseZoneFromClassId(cls_id))) return INVALID_STRING_ID;
1537 for (int i = 0; i < cls_id; i++) {
1538 /* Don't include if it's already included in an earlier zone. */
1539 if (spec->building_availability.Test(GetHouseZoneFromClassId(i))) return INVALID_STRING_ID;
1540 }
1541
1542 return GetHouseName(spec);
1543 }
1544
1545 std::span<const BadgeID> GetTypeBadges(int cls_id, int id) const override
1546 {
1547 const auto *spec = HouseSpec::Get(id);
1548 if (spec == nullptr) return {};
1549 if (!spec->enabled) return {};
1550 if (!spec->building_availability.Any(climate_mask)) return {};
1551 if (!spec->building_availability.Test(GetHouseZoneFromClassId(cls_id))) return {};
1552 for (int i = 0; i < cls_id; i++) {
1553 /* Don't include if it's already included in an earlier zone. */
1554 if (spec->building_availability.Test(GetHouseZoneFromClassId(i))) return {};
1555 }
1556
1557 return spec->badges;
1558 }
1559
1560 bool IsTypeAvailable(int, int id) const override
1561 {
1562 const HouseSpec *hs = HouseSpec::Get(id);
1563 return hs->enabled;
1564 }
1565
1566 void DrawType(int x, int y, int, int id) const override
1567 {
1569 }
1570
1571 void FillUsedItems(std::set<PickerItem> &items) override
1572 {
1573 auto id_count = GetBuildingHouseIDCounts();
1574 for (auto it = id_count.begin(); it != id_count.end(); ++it) {
1575 if (*it == 0) continue;
1576 HouseID house = static_cast<HouseID>(std::distance(id_count.begin(), it));
1577 const HouseSpec *hs = HouseSpec::Get(house);
1578 int class_index = GetClassIdFromHouseZone(hs->building_availability);
1579 items.insert({0, house, class_index, house});
1580 }
1581 }
1582
1583 std::set<PickerItem> UpdateSavedItems(const std::set<PickerItem> &src) override
1584 {
1585 if (src.empty()) return src;
1586
1587 const auto &specs = HouseSpec::Specs();
1588 std::set<PickerItem> dst;
1589 for (const auto &item : src) {
1590 if (item.grfid == 0) {
1591 dst.insert(item);
1592 } else {
1593 /* Search for spec by grfid and local index. */
1594 auto it = std::ranges::find_if(specs, [&item](const HouseSpec &spec) { return spec.grf_prop.grfid == item.grfid && spec.grf_prop.local_id == item.local_id; });
1595 if (it == specs.end()) {
1596 /* Not preset, hide from UI. */
1597 dst.insert({item.grfid, item.local_id, -1, -1});
1598 } else {
1599 int class_index = GetClassIdFromHouseZone(it->building_availability);
1600 dst.insert( {item.grfid, item.local_id, class_index, it->Index()});
1601 }
1602 }
1603 }
1604
1605 return dst;
1606 }
1607
1608 static HousePickerCallbacks instance;
1609};
1610/* static */ HousePickerCallbacks HousePickerCallbacks::instance;
1611
1617static CargoTypes GetProducedCargoOfHouse(const HouseSpec *hs)
1618{
1619 CargoTypes produced{};
1621 for (uint i = 0; i < 256; i++) {
1622 uint16_t callback = GetHouseCallback(CBID_HOUSE_PRODUCE_CARGO, i, 0, hs->Index(), nullptr, INVALID_TILE, {}, true);
1623
1624 if (callback == CALLBACK_FAILED || callback == CALLBACK_HOUSEPRODCARGO_END) break;
1625
1626 CargoType cargo = GetCargoTranslation(GB(callback, 8, 7), hs->grf_prop.grffile);
1627 if (!IsValidCargoType(cargo)) continue;
1628
1629 uint amt = GB(callback, 0, 8);
1630 if (amt == 0) continue;
1631
1632 SetBit(produced, cargo);
1633 }
1634 } else {
1635 /* Cargo is not controlled by NewGRF, town production effect is used instead. */
1636 for (const CargoSpec *cs : CargoSpec::town_production_cargoes[TPE_PASSENGERS]) SetBit(produced, cs->Index());
1637 for (const CargoSpec *cs : CargoSpec::town_production_cargoes[TPE_MAIL]) SetBit(produced, cs->Index());
1638 }
1639 return produced;
1640}
1641
1643 std::string house_info{};
1644 static inline bool house_protected;
1645
1646 BuildHouseWindow(WindowDesc &desc, Window *parent) : PickerWindow(desc, parent, 0, HousePickerCallbacks::instance)
1647 {
1648 HousePickerCallbacks::instance.SetClimateMask();
1649 this->ConstructWindow();
1650 }
1651
1652 void UpdateSelectSize(const HouseSpec *spec)
1653 {
1654 if (spec == nullptr) {
1655 SetTileSelectSize(1, 1);
1657 } else {
1658 SetObjectToPlaceWnd(SPR_CURSOR_TOWN, PAL_NONE, HT_RECT | HT_DIAGONAL, this);
1659 if (spec->building_flags.Test(BuildingFlag::Size2x2)) {
1660 SetTileSelectSize(2, 2);
1661 } else if (spec->building_flags.Test(BuildingFlag::Size2x1)) {
1662 SetTileSelectSize(2, 1);
1663 } else if (spec->building_flags.Test(BuildingFlag::Size1x2)) {
1664 SetTileSelectSize(1, 2);
1665 } else if (spec->building_flags.Test(BuildingFlag::Size1x1)) {
1666 SetTileSelectSize(1, 1);
1667 }
1668 }
1669 }
1670
1677 static std::string GetHouseYear(TimerGameCalendar::Year min_year, TimerGameCalendar::Year max_year)
1678 {
1679 if (min_year == CalendarTime::MIN_YEAR) {
1680 if (max_year == CalendarTime::MAX_YEAR) {
1681 return GetString(STR_HOUSE_PICKER_YEARS_ANY);
1682 }
1683 return GetString(STR_HOUSE_PICKER_YEARS_UNTIL, max_year);
1684 }
1685 if (max_year == CalendarTime::MAX_YEAR) {
1686 return GetString(STR_HOUSE_PICKER_YEARS_FROM, min_year);
1687 }
1688 return GetString(STR_HOUSE_PICKER_YEARS, min_year, max_year);
1689 }
1690
1696 static std::string GetHouseInformation(const HouseSpec *hs)
1697 {
1698 std::stringstream line;
1699
1700 line << GetString(STR_HOUSE_PICKER_NAME, GetHouseName(hs));
1701 line << "\n";
1702
1703 line << GetString(STR_HOUSE_PICKER_POPULATION, hs->population);
1704 line << "\n";
1705
1706 line << GetHouseYear(hs->min_year, hs->max_year);
1707 line << "\n";
1708
1709 uint8_t size = 0;
1710 if (hs->building_flags.Test(BuildingFlag::Size1x1)) size = 0x11;
1711 if (hs->building_flags.Test(BuildingFlag::Size2x1)) size = 0x21;
1712 if (hs->building_flags.Test(BuildingFlag::Size1x2)) size = 0x12;
1713 if (hs->building_flags.Test(BuildingFlag::Size2x2)) size = 0x22;
1714 line << GetString(STR_HOUSE_PICKER_SIZE, GB(size, 0, 4), GB(size, 4, 4));
1715
1716 auto cargo_string = BuildCargoAcceptanceString(GetAcceptedCargoOfHouse(hs), STR_HOUSE_PICKER_CARGO_ACCEPTED);
1717 if (cargo_string.has_value()) {
1718 line << "\n";
1719 line << *cargo_string;
1720 }
1721
1722 CargoTypes produced = GetProducedCargoOfHouse(hs);
1723 if (produced != 0) {
1724 line << "\n";
1725 line << GetString(STR_HOUSE_PICKER_CARGO_PRODUCED, produced);
1726 }
1727
1728 return line.str();
1729 }
1730
1731 void OnInit() override
1732 {
1733 this->InvalidateData(PICKER_INVALIDATION_ALL);
1734 this->PickerWindow::OnInit();
1735 }
1736
1737 void DrawWidget(const Rect &r, WidgetID widget) const override
1738 {
1739 if (widget == WID_BH_INFO) {
1740 if (!this->house_info.empty()) DrawStringMultiLine(r, this->house_info);
1741 } else {
1742 this->PickerWindow::DrawWidget(r, widget);
1743 }
1744 }
1745
1746 void OnClick([[maybe_unused]] Point pt, WidgetID widget, [[maybe_unused]] int click_count) override
1747 {
1748 switch (widget) {
1749 case WID_BH_PROTECT_OFF:
1750 case WID_BH_PROTECT_ON:
1751 BuildHouseWindow::house_protected = (widget == WID_BH_PROTECT_ON);
1752 this->SetWidgetLoweredState(WID_BH_PROTECT_OFF, !BuildHouseWindow::house_protected);
1753 this->SetWidgetLoweredState(WID_BH_PROTECT_ON, BuildHouseWindow::house_protected);
1754
1755 SndClickBeep();
1756 this->SetDirty();
1757 break;
1758
1759 default:
1760 this->PickerWindow::OnClick(pt, widget, click_count);
1761 break;
1762 }
1763 }
1764
1765 void OnInvalidateData(int data = 0, bool gui_scope = true) override
1766 {
1767 this->PickerWindow::OnInvalidateData(data, gui_scope);
1768 if (!gui_scope) return;
1769
1771
1772 PickerInvalidations pi(data);
1774 UpdateSelectSize(spec);
1775 this->house_info = GetHouseInformation(spec);
1776 }
1777
1778 /* If house spec already has the protected flag, handle it automatically and disable the buttons. */
1780 if (hasflag) BuildHouseWindow::house_protected = true;
1781
1782 this->SetWidgetLoweredState(WID_BH_PROTECT_OFF, !BuildHouseWindow::house_protected);
1783 this->SetWidgetLoweredState(WID_BH_PROTECT_ON, BuildHouseWindow::house_protected);
1784
1787 }
1788
1789 void OnPlaceObject([[maybe_unused]] Point pt, TileIndex tile) override
1790 {
1792 Command<CMD_PLACE_HOUSE>::Post(STR_ERROR_CAN_T_BUILD_HOUSE, CcPlaySound_CONSTRUCTION_OTHER, tile, spec->Index(), BuildHouseWindow::house_protected);
1793 }
1794
1795 const IntervalTimer<TimerWindow> view_refresh_interval = {std::chrono::milliseconds(2500), [this](auto) {
1796 /* There are four different 'views' that are random based on house tile position. As this is not
1797 * user-controllable, instead we automatically cycle through them. */
1799 this->SetDirty();
1800 }};
1801
1802 static inline HotkeyList hotkeys{"buildhouse", {
1803 Hotkey('F', "focus_filter_box", PCWHK_FOCUS_FILTER_BOX),
1804 }};
1805};
1806
1810 NWidget(WWT_CLOSEBOX, COLOUR_DARK_GREEN),
1811 NWidget(WWT_CAPTION, COLOUR_DARK_GREEN), SetStringTip(STR_HOUSE_PICKER_CAPTION, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
1812 NWidget(WWT_SHADEBOX, COLOUR_DARK_GREEN),
1813 NWidget(WWT_DEFSIZEBOX, COLOUR_DARK_GREEN),
1814 NWidget(WWT_STICKYBOX, COLOUR_DARK_GREEN),
1815 EndContainer(),
1819 NWidget(WWT_PANEL, COLOUR_DARK_GREEN),
1821 NWidget(WWT_EMPTY, INVALID_COLOUR, WID_BH_INFO), SetFill(1, 1), SetMinimalTextLines(10, 0),
1822 NWidget(WWT_LABEL, INVALID_COLOUR), SetStringTip(STR_HOUSE_PICKER_PROTECT_TITLE, STR_NULL), SetFill(1, 0),
1824 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_BH_PROTECT_OFF), SetMinimalSize(60, 12), SetStringTip(STR_HOUSE_PICKER_PROTECT_OFF, STR_HOUSE_PICKER_PROTECT_TOOLTIP),
1825 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_BH_PROTECT_ON), SetMinimalSize(60, 12), SetStringTip(STR_HOUSE_PICKER_PROTECT_ON, STR_HOUSE_PICKER_PROTECT_TOOLTIP),
1826 EndContainer(),
1827 EndContainer(),
1828 EndContainer(),
1829
1830 EndContainer(),
1832 EndContainer(),
1833};
1834
1835static WindowDesc _build_house_desc(
1836 WDP_AUTO, "build_house", 0, 0,
1840 &BuildHouseWindow::hotkeys
1841);
1842
1843void ShowBuildHousePicker(Window *parent)
1844{
1845 if (BringWindowToFrontById(WC_BUILD_HOUSE, 0)) return;
1846 new BuildHouseWindow(_build_house_desc, parent);
1847}
Class for backupping variables and making sure they are restored later.
debug_inline constexpr bool HasBit(const T x, const uint8_t y)
Checks if a bit in a value is set.
constexpr T SetBit(T &x, const uint8_t y)
Set a bit in a variable.
constexpr uint8_t FindFirstBit(T x)
Search the first set bit in a value.
debug_inline static constexpr uint GB(const T x, const uint8_t s, const uint8_t n)
Fetch n bits from x, started at bit s.
uint8_t CargoType
Cargo slots to indicate a cargo type within a game.
Definition cargo_type.h:23
bool IsValidCargoType(CargoType cargo)
Test whether cargo type is not INVALID_CARGO.
Definition cargo_type.h:106
std::optional< std::string > BuildCargoAcceptanceString(const CargoArray &acceptance, StringID label)
Build comma-separated cargo acceptance string.
@ TPE_PASSENGERS
Cargo behaves passenger-like for production.
Definition cargotype.h:37
@ TPE_MAIL
Cargo behaves mail-like for production.
Definition cargotype.h:38
TownAcceptanceEffect
Town growth effect when delivering cargo.
Definition cargotype.h:22
@ TAE_END
End of town effects.
Definition cargotype.h:30
constexpr bool Test(Tvalue_type value) const
Test if the value-th bit is set.
constexpr Timpl & Flip(Tvalue_type value)
Flip the value-th bit.
constexpr Timpl & Set()
Set all bits.
constexpr bool Any(const Timpl &other) const
Test if any of the given values are set.
std::optional< Tvalue_type > GetNthSetBit(uint n) const
Get the value of the Nth set bit.
Common return value for all commands.
bool Succeeded() const
Did this command succeed?
bool Failed() const
Did this command fail?
std::string GetDecodedString() const
Decode the encoded string.
Definition strings.cpp:207
List template of 'things' T to sort in a GUI.
void RebuildDone()
Notify the sortlist that the rebuild is done.
void SetListing(Listing l)
Import sort conditions.
bool IsDescSortOrder() const
Check if the sort order is descending.
void ToggleSortOrder()
Toggle the sort order Since that is the worst condition for the sort function reverse the list here.
bool NeedRebuild() const
Check if a rebuild is needed.
void ForceRebuild()
Force that a rebuild is needed.
bool Sort(Comp compare)
Sort the list.
void ForceResort()
Force a resort next Sort call Reset the resort timer if used too.
uint8_t SortType() const
Get the sorttype of the list.
Listing GetListing() const
Export current sort conditions.
void SetSortFuncs(std::span< SortFunction *const > n_funcs)
Hand the sort function pointers to the GUIList.
void SetSortType(uint8_t n_type)
Set the sorttype of the list.
PickerItem GetPickerItem(int cls_id, int id) const override
Get data about an item.
bool IsActive() const override
Should picker class/type selection be enabled?
void SetClimateMask()
Set climate mask for filtering buildings from current landscape.
void SetSelectedClass(int cls_id) const override
Set the selected class.
StringID GetClassTooltip() const override
Get the tooltip string for the class list.
std::span< const BadgeID > GetTypeBadges(int cls_id, int id) const override
Get the item of a type.
void DrawType(int x, int y, int, int id) const override
Draw preview image of an item.
static int sel_view
Currently selected 'view'. This is not controllable as its based on random data.
int GetClassCount() const override
Get the number of classes.
void FillUsedItems(std::set< PickerItem > &items) override
Fill a set with all items that are used by the current player.
static int sel_type
Currently selected HouseID.
int GetSelectedClass() const override
Get the index of the selected class.
std::set< PickerItem > UpdateSavedItems(const std::set< PickerItem > &src) override
Update link between grfid/localidx and class_index/index in saved items.
StringID GetTypeTooltip() const override
Get the tooltip string for the type grid.
void SetSelectedType(int id) const override
Set the selected type.
StringID GetTypeName(int cls_id, int id) const override
Get the item of a type.
int GetSelectedType() const override
Get the selected type.
bool IsTypeAvailable(int, int id) const override
Test if an item is currently buildable.
bool HasClassChoice() const override
Are there multiple classes to chose from?
uint8_t class_mask
Mask of available 'classes'.
int GetTypeCount(int cls_id) const override
Get the number of types in a class.
StringID GetClassName(int id) const override
Get the name of a class.
static int sel_class
Currently selected 'class'.
An interval timer will fire every interval, and will continue to fire until it is deleted.
Definition timer.h:76
K-dimensional tree, specialised for 2-dimensional space.
Definition kdtree.hpp:33
void Insert(const T &element)
Insert a single element in the tree.
Definition kdtree.hpp:396
void Remove(const T &element)
Remove a single element from the tree, if it exists.
Definition kdtree.hpp:415
void Clear()
Clear the tree.
Definition kdtree.hpp:375
Baseclass for nested widgets.
uint current_x
Current horizontal size (after resizing).
uint smallest_y
Smallest vertical size of the widget in a filled window.
uint current_y
Current vertical size (after resizing).
Nested widget to display a viewport in a window.
void UpdateViewportCoordinates(Window *w)
Update the position and size of the viewport (after eg a resize).
Definition widget.cpp:2413
void InitializeViewport(Window *w, std::variant< TileIndex, VehicleID > focus, ZoomLevel zoom)
Initialize the viewport of the window.
Definition widget.cpp:2404
Class for PickerClassWindow to collect information and retain state.
Definition picker_gui.h:39
void DrawWidget(const Rect &r, WidgetID widget) const override
Draw the contents of a nested widget.
@ Position
Update scroll positions.
@ PCWHK_FOCUS_FILTER_BOX
Focus the edit box for editing the filter string.
Definition picker_gui.h:205
void OnClick(Point pt, WidgetID widget, int click_count) override
A click with the left mouse button has been made on the window.
void OnInvalidateData(int data=0, bool gui_scope=true) override
Some data on this window has become invalid.
void OnInit() override
Notification that the nested widget tree gets initialized.
Scrollbar data structure.
void SetCount(size_t num)
Sets the number of elements in the list.
auto GetScrolledItemFromWidget(Tcontainer &container, int clickpos, const Window *const w, WidgetID widget, int padding=0, int line_height=-1) const
Return an iterator pointing to the element of a scrolled widget that a user clicked in.
void SetCapacityFromWidget(Window *w, WidgetID widget, int padding=0)
Set capacity of visible elements from the size and resize properties of a widget.
Definition widget.cpp:2510
size_type GetCount() const
Gets the number of elements in the list.
auto GetVisibleRangeIterators(Tcontainer &container) const
Get a pair of iterators for the range of visible elements in a container.
static constexpr TimerGameTick::Ticks DAY_TICKS
1 day is 74 ticks; TimerGameCalendar::date_fract used to be uint16_t and incremented by 885.
static constexpr TimerGame< struct Calendar >::Year MIN_YEAR
The absolute minimum year in OTTD.
static constexpr TimerGame< struct Calendar >::Year MAX_YEAR
MAX_YEAR, nicely rounded value of the number of years that can be encoded in a single 32 bits date,...
static bool UsingWallclockUnits(bool newgame=false)
Check if we are using wallclock units.
RectPadding framerect
Standard padding inside many panels.
Definition window_gui.h:40
static WidgetDimensions scaled
Widget dimensions scaled for current zoom level.
Definition window_gui.h:30
int vsep_normal
Normal vertical spacing.
Definition window_gui.h:58
static const WidgetDimensions unscaled
Unscaled widget dimensions.
Definition window_gui.h:93
int hsep_normal
Normal horizontal spacing.
Definition window_gui.h:61
Functions related to commands.
@ Execute
execute the given command
Commands
List of commands.
Definition of stuff that is very close to a company, like the company struct itself.
void DrawCompanyIcon(CompanyID c, int x, int y)
Draw the icon of a company.
PaletteID GetCompanyPalette(CompanyID company)
Get the palette for recolouring with a company colour.
Money GetAvailableMoney(CompanyID company)
Get the amount of money that a company has available, or INT64_MAX if there is no such valid company.
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
Functions related to companies.
GUI Functions related to companies.
void ShowDropDownMenu(Window *w, std::span< const StringID > strings, int selected, WidgetID button, uint32_t disabled_mask, uint32_t hidden_mask, uint width)
Show a dropdown menu window near a widget of the parent window.
Definition dropdown.cpp:455
Functions related to the drop down widget.
constexpr std::underlying_type_t< enum_type > to_underlying(enum_type e)
Implementation of std::to_underlying (from C++23)
Definition enum_type.hpp:17
Functions related to errors.
@ WL_INFO
Used for DoCommand-like (and some non-fatal AI GUI) errors/information.
Definition error.h:24
void ShowErrorMessage(EncodedString &&summary_msg, int x, int y, CommandCost &cc)
Display an error message in a window.
@ SLO_LOAD
File is being loaded.
Definition fileio_type.h:54
@ FT_TOWN_DATA
town data file
Definition fileio_type.h:22
Declarations for savegames operations.
void ShowSaveLoadDialog(AbstractFileType abstract_filetype, SaveLoadOperation fop)
Launch save/load dialog in the given mode.
Definition fios_gui.cpp:984
int GetCharacterHeight(FontSize size)
Get height of a character for a given font size.
Definition fontcache.cpp:87
bool _generating_world
Whether we are generating the map or not.
Definition genworld.cpp:74
Functions related to world/map generation.
Dimension maxdim(const Dimension &d1, const Dimension &d2)
Compute bounding box of both dimensions.
Geometry functions.
int GetStringHeight(std::string_view str, int maxw, FontSize fontsize)
Calculates height of string (in pixels).
Definition gfx.cpp:713
Dimension GetSpriteSize(SpriteID sprid, Point *offset, ZoomLevel zoom)
Get the size of a sprite.
Definition gfx.cpp:966
bool _shift_pressed
Is Shift pressed?
Definition gfx.cpp:40
Dimension GetStringBoundingBox(std::string_view str, FontSize start_fontsize)
Return the string dimension in pixels.
Definition gfx.cpp:895
Dimension GetStringListBoundingBox(std::span< const StringID > list, FontSize fontsize)
Get maximum dimension of a list of strings.
Definition gfx.cpp:933
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.
Definition gfx.cpp:666
bool _ctrl_pressed
Is Ctrl pressed?
Definition gfx.cpp:39
void DrawSprite(SpriteID img, PaletteID pal, int x, int y, const SubSprite *sub, ZoomLevel zoom)
Draw a sprite, not in a viewport.
Definition gfx.cpp:1032
Dimension GetStringMultiLineBoundingBox(StringID str, const Dimension &suggestion)
Calculate string bounding box for multi-line strings.
Definition gfx.cpp:749
int DrawStringMultiLine(int left, int right, int top, int bottom, std::string_view str, TextColour colour, StringAlignment align, bool underline, FontSize fontsize)
Draw string, possibly over multiple lines.
Definition gfx.cpp:783
uint32_t SpriteID
The number of a sprite, without mapping bits and colourtables.
Definition gfx_type.h:17
@ FS_NORMAL
Index of the normal font in the font tables.
Definition gfx_type.h:249
TextColour
Colour of the strings, see _string_colourmap in table/string_colours.h or docs/ottd-colourtext-palett...
Definition gfx_type.h:307
@ TC_NO_SHADE
Do not add shading to this text colour.
Definition gfx_type.h:331
Graph GUI functions.
constexpr NWidgetPart NWidgetFunction(NWidgetFunctionType *func_ptr)
Obtain a nested widget (sub)tree from an external source.
constexpr NWidgetPart SetFill(uint16_t fill_x, uint16_t fill_y)
Widget part function for setting filling.
constexpr NWidgetPart SetSpriteTip(SpriteID sprite, StringID tip={})
Widget part function for setting the sprite and tooltip.
constexpr NWidgetPart SetPIP(uint8_t pre, uint8_t inter, uint8_t post)
Widget part function for setting a pre/inter/post spaces.
constexpr NWidgetPart SetScrollbar(WidgetID index)
Attach a scrollbar to a widget.
constexpr NWidgetPart SetPadding(uint8_t top, uint8_t right, uint8_t bottom, uint8_t left)
Widget part function for setting additional space around a widget.
constexpr NWidgetPart SetStringTip(StringID string, StringID tip={})
Widget part function for setting the string and tooltip.
constexpr NWidgetPart SetAspect(float ratio, AspectFlags flags=AspectFlag::ResizeX)
Widget part function for setting the aspect ratio.
constexpr NWidgetPart SetMinimalSize(int16_t x, int16_t y)
Widget part function for setting the minimal size.
constexpr NWidgetPart NWidget(WidgetType tp, Colours col, WidgetID idx=-1)
Widget part function for starting a new 'real' widget.
constexpr NWidgetPart SetToolTip(StringID tip)
Widget part function for setting tooltip and clearing the widget data.
constexpr NWidgetPart EndContainer()
Widget part function for denoting the end of a container (horizontal, vertical, WWT_FRAME,...
constexpr NWidgetPart SetMinimalTextLines(uint8_t lines, uint8_t spacing, FontSize size=FS_NORMAL)
Widget part function for setting the minimal text lines.
constexpr NWidgetPart SetResize(int16_t dx, int16_t dy)
Widget part function for setting the resize step.
constexpr NWidgetPart SetPIPRatio(uint8_t ratio_pre, uint8_t ratio_inter, uint8_t ratio_post)
Widget part function for setting a pre/inter/post ratio.
uint8_t LowestSnowLine()
Get the lowest possible snow line height, either variable or static.
uint8_t GetSnowLine()
Get the current snow line, either variable or static.
void SetDirty() const
Mark entire window as dirty (in need of re-paint)
Definition window.cpp:963
void MarkWholeScreenDirty()
This function mark the whole screen as dirty.
Definition gfx.cpp:1543
GUI functions that shouldn't be here.
void ShowExtraViewportWindow(TileIndex tile=INVALID_TILE)
Show a new Extra Viewport window.
Hotkey related functions.
definition of HouseSpec and accessors
@ BuildingIsProtected
towns and AI will not remove this house, while human players will be able to
HouseZones GetClimateMaskForLandscape()
Get the HouseZones climate mask for the current landscape type.
static const HouseID NEW_HOUSE_OFFSET
Offset for new houses.
Definition house.h:28
static const uint8_t TOWN_HOUSE_COMPLETED
Simple value that indicates the house has reached the final stage of construction.
Definition house.h:25
HouseZone
Definition house.h:55
uint16_t HouseID
OpenTTD ID of house types.
Definition house_type.h:13
Functions related to OTTD's landscape.
Point RemapCoords(int x, int y, int z)
Map 3D world or tile coordinate to equivalent 2D coordinate as used in the viewports and smallmap.
Definition landscape.h:79
bool DoZoomInOutWindow(ZoomStateChange how, Window *w)
Zooms a viewport in a window in or out.
Definition main_gui.cpp:93
bool HandlePlacePushButton(Window *w, WidgetID widget, CursorID cursor, HighLightStyle mode)
This code is shared for the majority of the pushbuttons.
Definition main_gui.cpp:63
constexpr int RoundDivSU(int a, uint b)
Computes round(a / b) for signed a and unsigned b.
void ShowQueryString(std::string_view str, StringID caption, uint maxsize, Window *parent, CharSetFilter afilter, QueryStringFlags flags)
Show a query popup window with a textbox in it.
bool _networking
are we in networking mode?
Definition network.cpp:67
bool _network_server
network-server is active
Definition network.cpp:68
Basic functions/variables used all over the place.
GrfSpecFeature
Definition newgrf.h:69
@ CBID_HOUSE_CUSTOM_NAME
Called on the Get Tile Description for an house tile.
@ CBID_HOUSE_PRODUCE_CARGO
Called to determine how much cargo a town building produces.
static const uint CALLBACK_FAILED
Different values for Callback result evaluations.
@ ProduceCargo
custom cargo production
static const uint CALLBACK_HOUSEPRODCARGO_END
Sentinel indicating that the loop for CBID_HOUSE_PRODUCE_CARGO has ended.
CargoType GetCargoTranslation(uint8_t cargo, const GRFFile *grffile, bool usebit)
Translate a GRF-local cargo slot/bitnum into a CargoType.
Cargo support for NewGRFs.
void ErrorUnknownCallbackResult(uint32_t grfid, uint16_t cbid, uint16_t cb_res)
Record that a NewGRF returned an unknown/invalid callback result.
std::span< const uint > GetBuildingHouseIDCounts()
Get read-only span of total HouseID building counts.
void DrawNewHouseTileInGUI(int x, int y, const HouseSpec *spec, HouseID house_id, int view)
Draw representation of a house tile for GUI purposes.
Functions related to NewGRF houses.
StringID GetGRFStringID(uint32_t grfid, GRFStringID stringid)
Returns the index for this stringid associated with its grfID.
Header of Action 04 "universal holder" structure and functions.
static constexpr GRFStringID GRFSTR_MISC_GRF_TEXT
Miscellaneous GRF text range.
void UpdateOSKOriginalText(const Window *parent, WidgetID button)
Updates the original text of the OSK so when the 'parent' changes the original and you press on cance...
Definition osk_gui.cpp:406
std::unique_ptr< NWidgetBase > MakePickerClassWidgets()
Create nested widgets for the class picker widgets.
std::unique_ptr< NWidgetBase > MakePickerTypeWidgets()
Create nested widgets for the type picker widgets.
Functions/types etc.
Base for the GUIs that have an edit box in them.
Randomizer _interactive_random
Random used everywhere else, where it does not (directly) influence the game state.
void UpdateNearestTownForRoadTiles(bool invalidate)
Updates cached nearest town for all road tiles.
Road related functions.
A number of safeguards to prevent using unsafe methods.
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition settings.cpp:61
ClientSettings _settings_client
The current settings for this game.
Definition settings.cpp:60
@ SWS_OFF
Scroll wheel has no effect.
Base types for having sorted lists in GUIs.
void SndClickBeep()
Play a beep sound for a click event if enabled in settings.
Definition sound.cpp:253
Functions related to sound.
@ SND_1F_CONSTRUCTION_OTHER
29 == 0x1D Construction: other (non-water, non-rail, non-bridge)
Definition sound_type.h:76
Definition of base types and functions in a cross-platform compatible way.
int StrNaturalCompare(std::string_view s1, std::string_view s2, bool ignore_garbage_at_front)
Compares two strings using case insensitive natural sort.
Definition string.cpp:425
Parse strings.
static std::optional< T > ParseInteger(std::string_view arg, int base=10, bool clamp=false)
Change a string into its number representation.
Functions related to low-level strings.
@ CS_NUMERAL
Only numeric ones.
Definition string_type.h:26
@ CS_ALPHANUMERAL
Both numeric and alphabetic and spaces and stuff.
Definition string_type.h:25
Searching and filtering using a stringterm.
EncodedString GetEncodedString(StringID str)
Encode a string with no parameters into an encoded string.
Definition strings.cpp:90
std::string GetString(StringID string)
Resolve the given StringID into a std::string with formatting but no parameters.
Definition strings.cpp:424
TextDirection _current_text_dir
Text direction of the currently selected language.
Definition strings.cpp:56
uint64_t GetParamMaxDigits(uint count, FontSize size)
Get some number that is suitable for string size computations.
Definition strings.cpp:218
Functions related to OTTD's strings.
uint32_t StringID
Numeric value that represents a string, independent of the selected language.
static const StringID INVALID_STRING_ID
Constant representing an invalid string (16bit in case it is used in savegames)
@ TD_RTL
Text is written right-to-left by default.
static const int MAX_CHAR_LENGTH
Max. length of UTF-8 encoded unicode character.
Class to backup a specific variable and restore it later.
void Restore()
Restore the variable.
static std::string GetHouseYear(TimerGameCalendar::Year min_year, TimerGameCalendar::Year max_year)
Get a date range string for house availability year.
void OnPlaceObject(Point pt, TileIndex tile) override
The user clicked some place on the map when a tile highlight mode has been set.
void DrawWidget(const Rect &r, WidgetID widget) const override
Draw the contents of a nested widget.
static std::string GetHouseInformation(const HouseSpec *hs)
Get information string for a house.
void OnInvalidateData(int data=0, bool gui_scope=true) override
Some data on this window has become invalid.
void OnClick(Point pt, WidgetID widget, int click_count) override
A click with the left mouse button has been made on the window.
void OnInit() override
Notification that the nested widget tree gets initialized.
Specification of a cargo type.
Definition cargotype.h:74
CargoType Index() const
Determines index of this cargospec.
Definition cargotype.h:108
StringID name
Name of this type of cargo.
Definition cargotype.h:91
static std::array< std::vector< const CargoSpec * >, NUM_TPE > town_production_cargoes
List of cargo specs for each Town Product Effect.
Definition cargotype.h:25
SoundSettings sound
sound effect settings
GUISettings gui
settings related to the GUI
T y
Y coordinate.
T x
X coordinate.
T x
X coordinate.
T y
Y coordinate.
T z
Z coordinate.
Dimensions (a width and height) of a rectangle in 2D.
This structure is the same for both Industries and Houses.
Definition sprite.h:81
bool bribe
enable bribing the local authority
TownFounding found_town
town founding.
bool exclusive_rights
allow buying exclusive rights
TownLayout town_layout
select town layout,
bool station_noise_level
build new airports when the town noise level is still within accepted limits
bool fund_buildings
allow funding new buildings
bool fund_roads
allow funding local road reconstruction
Found a town window class.
uint32_t townnameparts
Generated town name.
TownLayout town_layout
Selected town layout.
void OnPlaceObject(Point pt, TileIndex tile) override
The user clicked some place on the map when a tile highlight mode has been set.
QueryString townname_editbox
Townname editbox.
void OnInvalidateData(int data=0, bool gui_scope=true) override
Some data on this window has become invalid.
void OnInit() override
Notification that the nested widget tree gets initialized.
TownSize town_size
Selected town size.
bool townnamevalid
Is generated town name valid?
TownNameParams params
Town name parameters.
void OnQueryTextFinished(std::optional< std::string > str) override
The query window opened from this window has closed.
void OnClick(Point pt, WidgetID widget, int click_count) override
A click with the left mouse button has been made on the window.
void OnPlaceObjectAbort() override
The user cancelled a tile highlight mode that has been set.
bool city
Are we building a city?
const struct GRFFile * grffile
grf file that introduced this entity
uint16_t local_id
id defined by the grf file for this entity
uint32_t grfid
grfid that introduced this entity.
bool persistent_buildingtools
keep the building tools active after usage
uint8_t scrollwheel_scrolling
scrolling using the scroll wheel?
EconomySettings economy
settings to change the economy
List of hotkeys for a window.
Definition hotkeys.h:37
All data for a single hotkey.
Definition hotkeys.h:21
SubstituteGRFFileProps grf_prop
Properties related the the grf file.
Definition house.h:114
bool enabled
the house is available to build (true by default, but can be disabled by newgrf)
Definition house.h:111
static HouseSpec * Get(size_t house_id)
Get the spec for a house ID.
BuildingFlags building_flags
some flags that describe the house (size, stadium etc...)
Definition house.h:109
TimerGameCalendar::Year max_year
last year it can be built
Definition house.h:101
HouseCallbackMasks callback_mask
Bitmask of house callbacks that have to be called.
Definition house.h:115
uint8_t population
population (Zero on other tiles in multi tile house.)
Definition house.h:102
HouseExtraFlags extra_flags
some more flags
Definition house.h:118
TimerGameCalendar::Year min_year
introduction year of the house
Definition house.h:100
HouseID Index() const
Gets the index of this spec.
StringID building_name
building name
Definition house.h:104
HouseZones building_availability
where can it be built (climates, zones)
Definition house.h:110
static std::vector< HouseSpec > & Specs()
Get a reference to all HouseSpecs.
Data structure describing how to show the list (what sort direction and criteria).
bool order
Ascending/descending.
Partial widget specification to allow NWidgets to be written nested.
SpriteID sprite
The 'real' sprite.
Definition gfx_type.h:23
PaletteID pal
The palette (use PAL_NONE) if not needed)
Definition gfx_type.h:24
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
static Titem * Get(auto index)
Returns Titem with given index.
static size_t GetNumItems()
Returns number of valid items in the pool.
Tindex index
Index of this pool item.
static bool IsValidID(auto index)
Tests whether given index can be used to get valid (non-nullptr) Titem.
Data stored about a string that can be modified in the GUI.
int cancel_button
Widget button of parent window to simulate when pressing CANCEL in OSK.
static const int ACTION_CLEAR
Clear editbox.
constexpr uint Horizontal() const
Get total horizontal 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.
Rect Shrink(int s) const
Copy and shrink Rect by s pixels.
Rect Indent(int indent, bool end) const
Copy Rect and indent it from its position.
uint step_height
Step-size of height resize changes.
Definition window_gui.h:212
bool confirm
Play sound effect on successful constructions or other actions.
Coord3D< int8_t > origin
Position of northern corner within tile.
Definition sprite.h:19
bool HasSpriteGroups() const
Check whether the entity has sprite groups.
String filter and state.
bool IsEmpty() const
Check whether any filter words were entered.
void SetFilterTerm(std::string_view str)
Set the term to filter on.
void ResetState()
Reset the matching state to process a new item.
bool GetState() const
Get the matching state of the current item.
void DeleteAll()
Delete every character in the textbuffer.
Definition textbuf.cpp:112
std::string_view GetText() const
Get the current text.
Definition textbuf.cpp:284
void Assign(std::string_view text)
Copy a string into the textbuffer.
Definition textbuf.cpp:420
Town authority window.
Definition town_gui.cpp:80
void OnInvalidateData(int data=0, bool gui_scope=true) override
Some data on this window has become invalid.
Definition town_gui.cpp:322
void DrawActions()
Draws the contents of the actions panel.
Definition town_gui.cpp:204
Dimension icon_size
Dimensions of company icon.
Definition town_gui.cpp:89
void OnInit() override
Notification that the nested widget tree gets initialized.
Definition town_gui.cpp:129
void DrawWidget(const Rect &r, WidgetID widget) const override
Draw the contents of a nested widget.
Definition town_gui.cpp:233
void UpdateWidgetSize(WidgetID widget, Dimension &size, const Dimension &padding, Dimension &fill, Dimension &resize) override
Update size and resize step of a widget in the window.
Definition town_gui.cpp:249
Town * town
Town being displayed.
Definition town_gui.cpp:82
TownActions enabled_actions
Actions that are enabled in settings.
Definition town_gui.cpp:85
TownAction sel_action
Currently selected town action, TownAction::End means no action selected.
Definition town_gui.cpp:83
TownActions available_actions
Actions that are available to execute for the current company.
Definition town_gui.cpp:86
void OnClick(Point pt, WidgetID widget, int click_count) override
A click with the left mouse button has been made on the window.
Definition town_gui.cpp:281
void DrawRatings()
Draw the contents of the ratings panel.
Definition town_gui.cpp:165
const IntervalTimer< TimerWindow > redraw_interval
Redraw the whole window on a regular interval.
Definition town_gui.cpp:318
Dimension exclusive_size
Dimensions of exclusive icon.
Definition town_gui.cpp:90
std::string GetWidgetString(WidgetID widget, StringID stringid) const override
Get the raw string for a widget.
Definition town_gui.cpp:226
static TownActions GetEnabledActions()
Gets all town authority actions enabled in settings.
Definition town_gui.cpp:97
void OnPaint() override
The window must be repainted.
Definition town_gui.cpp:135
TownActions displayed_actions_on_previous_painting
Actions that were available on the previous call to OnPaint()
Definition town_gui.cpp:84
uint32_t population
Current population of people.
Definition town.h:43
Town directory window class.
Definition town_gui.cpp:718
static const std::initializer_list< GUITownList::SortFunction *const > sorter_funcs
Available town directory sorting functions.
void DrawWidget(const Rect &r, WidgetID widget) const override
Draw the contents of a nested widget.
Definition town_gui.cpp:844
static bool TownPopulationSorter(const Town *const &a, const Town *const &b, const bool &order)
Sort by population (default descending, as big towns are of the most interest).
Definition town_gui.cpp:769
QueryString townname_editbox
Filter editbox.
Definition town_gui.cpp:732
void OnEditboxChanged(WidgetID wid) override
The text in an editbox has been edited.
static bool TownRatingSorter(const Town *const &a, const Town *const &b, const bool &order)
Sort by town rating.
Definition town_gui.cpp:778
void OnResize() override
Called after the window got resized.
Definition town_gui.cpp:995
StringFilter string_filter
Filter for towns.
Definition town_gui.cpp:731
void OnInvalidateData(int data=0, bool gui_scope=true) override
Some data on this window has become invalid.
const IntervalTimer< TimerWindow > rebuild_interval
Redraw the whole window on a regular interval.
Definition town_gui.cpp:990
void OnPaint() override
The window must be repainted.
Definition town_gui.cpp:983
void OnDropdownSelect(WidgetID widget, int index, int) override
A dropdown option associated to this window has been selected.
Definition town_gui.cpp:972
void OnClick(Point pt, WidgetID widget, int click_count) override
A click with the left mouse button has been made on the window.
Definition town_gui.cpp:935
static std::string GetTownString(const Town *t, uint64_t population)
Get the string to draw the town name.
Definition town_gui.cpp:839
static bool TownNameSorter(const Town *const &a, const Town *const &b, const bool &)
Sort by town name.
Definition town_gui.cpp:763
void UpdateWidgetSize(WidgetID widget, Dimension &size, const Dimension &padding, Dimension &fill, Dimension &resize) override
Update size and resize step of a widget in the window.
Definition town_gui.cpp:888
std::string GetWidgetString(WidgetID widget, StringID stringid) const override
Get the raw string for a widget.
Definition town_gui.cpp:817
Struct holding parameters used to generate town name.
void OnClick(Point pt, WidgetID widget, int click_count) override
A click with the left mouse button has been made on the window.
Definition town_gui.cpp:475
Town * town
Town displayed by the window.
Definition town_gui.cpp:349
void OnInvalidateData(int data=0, bool gui_scope=true) override
Some data on this window has become invalid.
Definition town_gui.cpp:593
void OnMouseWheel(int wheel, WidgetID widget) override
The mouse wheel has been turned.
Definition town_gui.cpp:580
void UpdateWidgetSize(WidgetID widget, Dimension &size, const Dimension &padding, Dimension &fill, Dimension &resize) override
Update size and resize step of a widget in the window.
Definition town_gui.cpp:521
void DrawWidget(const Rect &r, WidgetID widget) const override
Draw the contents of a nested widget.
Definition town_gui.cpp:391
uint GetDesiredInfoHeight(int width) const
Gets the desired height for the information panel.
Definition town_gui.cpp:534
std::string GetWidgetString(WidgetID widget, StringID stringid) const override
Get the raw string for a widget.
Definition town_gui.cpp:376
void Close(int data=0) override
Hide the window and all its child windows, and mark them for a later deletion.
Definition town_gui.cpp:370
void OnPaint() override
The window must be repainted.
Definition town_gui.cpp:383
void OnQueryTextFinished(std::optional< std::string > str) override
The query window opened from this window has closed.
Definition town_gui.cpp:601
void OnResize() override
Called after the window got resized.
Definition town_gui.cpp:570
Town data structure.
Definition town.h:53
EncodedString text
General text with additional information.
Definition town.h:104
bool larger_town
if this is a larger town and should grow more quickly
Definition town.h:140
TileIndex xy
town center tile
Definition town.h:54
uint8_t fund_buildings_months
fund buildings program in action?
Definition town.h:137
uint16_t noise_reached
level of noise that all the airports are generating
Definition town.h:67
SuppliedCargoes supplied
Cargo statistics about supplied cargo.
Definition town.h:99
uint8_t flags
See TownFlags.
Definition town.h:65
TownCache cache
Container for all cacheable data.
Definition town.h:56
CompanyID exclusivity
which company has exclusivity
Definition town.h:74
bool show_zone
NOSAVE: mark town to show the local authority zone in the viewports.
Definition town.h:143
CompanyMask have_ratings
which companies have a rating
Definition town.h:72
TypedIndexContainer< std::array< int16_t, MAX_COMPANIES >, CompanyID > ratings
ratings of each company for this town
Definition town.h:76
uint16_t growth_rate
town growth rate
Definition town.h:135
std::array< TransportedCargoStat< uint16_t >, NUM_TAE > received
Cargo statistics about received cargotypes.
Definition town.h:100
std::array< uint32_t, NUM_TAE > goal
Amount of cargo required for the town to grow.
Definition town.h:101
High level window description.
Definition window_gui.h:167
Number to differentiate different windows of the same class.
Data structure for an opened window.
Definition window_gui.h:273
void ReInit(int rx=0, int ry=0, bool reposition=false)
Re-initialize a window, and optionally change its size.
Definition window.cpp:975
virtual void Close(int data=0)
Hide the window and all its child windows, and mark them for a later deletion.
Definition window.cpp:1099
static int SortButtonWidth()
Get width of up/down arrow of sort button state.
Definition widget.cpp:826
void FinishInitNested(WindowNumber window_number=0)
Perform the second part of the initialization of a nested widget tree.
Definition window.cpp:1786
std::map< WidgetID, QueryString * > querystrings
QueryString associated to WWT_EDITBOX widgets.
Definition window_gui.h:320
void DrawWidgets() const
Paint all widgets of a window.
Definition widget.cpp:777
void InvalidateData(int data=0, bool gui_scope=true)
Mark this window's data as invalid (in need of re-computing)
Definition window.cpp:3213
Window * parent
Parent window.
Definition window_gui.h:328
void SetWidgetDirty(WidgetID widget_index) const
Invalidate a widget, i.e.
Definition window.cpp:556
std::unique_ptr< ViewportData > viewport
Pointer to viewport data, if present.
Definition window_gui.h:318
virtual std::string GetWidgetString(WidgetID widget, StringID stringid) const
Get the raw string for a widget.
Definition window.cpp:504
void DrawSortButtonState(WidgetID widget, SortButtonState state) const
Draw a sort button's up or down arrow symbol.
Definition widget.cpp:809
ResizeInfo resize
Resize information.
Definition window_gui.h:314
void CreateNestedTree()
Perform the first part of the initialization of a nested widget tree.
Definition window.cpp:1776
bool SetFocusedWidget(WidgetID widget_index)
Set focus within this window to the given widget.
Definition window.cpp:485
bool IsWidgetLowered(WidgetID widget_index) const
Gets the lowered state of a widget.
Definition window_gui.h:491
void RaiseButtons(bool autoraise=false)
Raise the buttons of the window.
Definition window.cpp:530
void SetWidgetLoweredState(WidgetID widget_index, bool lowered_stat)
Sets the lowered/raised status of a widget.
Definition window_gui.h:441
bool IsShaded() const
Is window shaded currently?
Definition window_gui.h:559
int GetRowFromWidget(int clickpos, WidgetID widget, int padding, int line_height=-1) const
Compute the row of a widget that a user clicked in.
Definition window.cpp:212
void InitNested(WindowNumber number=0)
Perform complete initialization of the Window with nested widgets, to allow use.
Definition window.cpp:1799
WindowFlags flags
Window flags.
Definition window_gui.h:300
const Scrollbar * GetScrollbar(WidgetID widnum) const
Return the Scrollbar to a widget index.
Definition window.cpp:313
void SetWidgetDisabledState(WidgetID widget_index, bool disab_stat)
Sets the enabled/disabled status of a widget.
Definition window_gui.h:381
AllWindows< false > Iterate
Iterate all windows in whatever order is easiest.
Definition window_gui.h:932
int width
width of the window (number of pixels to the right in x direction)
Definition window_gui.h:311
WindowNumber window_number
Window number within the window class.
Definition window_gui.h:302
@ AcceptUnchanged
return success even when the text didn't change
@ EnableDefault
enable the 'Default' button ("\0" is returned)
@ LengthIsInChars
the length of the string is counted in characters
TropicZone GetTropicZone(Tile tile)
Get the tropic zone.
Definition tile_map.h:238
static debug_inline uint TileHeight(Tile tile)
Returns the height of a tile.
Definition tile_map.h:29
@ TROPICZONE_DESERT
Tile is desert.
Definition tile_type.h:78
constexpr TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition tile_type.h:95
static constexpr uint TILE_PIXELS
Pixel distance between tile columns/rows in ZOOM_BASE.
Definition tile_type.h:17
Functions related to tile highlights.
void ResetObjectToPlace()
Reset the cursor and mouse mode handling back to default (normal cursor, only clicking in windows).
void SetObjectToPlaceWnd(CursorID icon, PaletteID pal, HighLightStyle mode, Window *w)
Change the cursor and mouse click/drag handling to a mode for performing special operations like tile...
@ HT_DIAGONAL
Also allow 'diagonal rectangles'. Only usable in combination with HT_RECT or HT_POINT.
@ HT_RECT
rectangle (stations, depots, ...)
Definition of Interval and OneShot timers.
Definition of the game-calendar-timer.
Definition of the Window system.
Base of the town class.
static const uint TOWN_GROWTH_WINTER
The town only needs this cargo in the winter (any amount)
Definition town.h:32
uint GetDefaultTownsForMapSize()
Calculate the number of towns which should be on the map according to the current "town density" newg...
TownActions GetMaskOfTownActions(CompanyID cid, const Town *t)
Get a list of available town authority actions.
const CargoSpec * FindFirstCargoWithTownAcceptanceEffect(TownAcceptanceEffect effect)
Determines the first cargo with a certain town effect.
static const uint TOWN_GROWTH_DESERT
The town needs the cargo for growth when on desert (any amount)
Definition town.h:33
@ TOWN_IS_GROWING
Conditions for town growth are met. Grow according to Town::growth_rate.
Definition town.h:235
bool GenerateTowns(TownLayout layout, std::optional< uint > number=std::nullopt)
Generate a number of towns with a given layout.
uint32_t GetWorldPopulation()
Get the total population, the sum of all towns in the world.
Definition town_cmd.cpp:454
CargoArray GetAcceptedCargoOfHouse(const HouseSpec *hs)
Get accepted cargo of a house prototype.
Definition town_cmd.cpp:855
uint8_t GetTownActionCost(TownAction action)
Get cost factors for a TownAction.
TownAction
Town actions of a company.
Definition town.h:251
@ RoadRebuild
Rebuild the roads.
@ Bribe
Try to bribe the council.
@ BuyRights
Buy exclusive transport rights.
@ FundBuildings
Fund new buildings.
Command definitions related to towns.
static constexpr NWidgetPart _nested_build_house_widgets[]
Nested widget definition for the build NewGRF rail waypoint window.
void DrawHouseInGUI(int x, int y, HouseID house_id, int view)
Draw a house that does not exist.
static StringID GetHouseName(const HouseSpec *hs)
Get name for a prototype house.
static CargoTypes GetProducedCargoOfHouse(const HouseSpec *hs)
Get the cargo types produced by a house.
Declarations for accessing the k-d tree of towns.
TownLayout
Town Layouts.
Definition town_type.h:81
@ TF_CUSTOM_LAYOUT
Allowed, with custom town layout.
Definition town_type.h:107
TownSize
Supported initial town sizes.
Definition town_type.h:21
@ TSZ_MEDIUM
Medium town.
Definition town_type.h:23
static const uint MAX_LENGTH_TOWN_NAME_CHARS
The maximum length of a town name in characters including '\0'.
Definition town_type.h:119
@ Roads
Allow town to place roads.
@ Buildings
Allow town to place buildings.
Types related to the town widgets.
@ WID_TA_EXECUTE
Do-it button.
Definition town_widget.h:32
@ WID_TA_ACTION_INFO
Additional information about the action.
Definition town_widget.h:31
@ WID_TA_RATING_INFO
Overview with ratings for each company.
Definition town_widget.h:28
@ WID_TA_CAPTION
Caption of window.
Definition town_widget.h:26
@ WID_TA_ZONE_BUTTON
Turn on/off showing local authority zone.
Definition town_widget.h:27
@ WID_TA_COMMAND_LIST
List of commands for the player.
Definition town_widget.h:29
@ WID_TV_VIEWPORT
View of the center of the town.
Definition town_widget.h:38
@ WID_TV_EXPAND_BUILDINGS
Expand number of buildings this town (scenario editor only).
Definition town_widget.h:45
@ WID_TV_INFO
General information about the town.
Definition town_widget.h:39
@ WID_TV_EXPAND
Expand this town (scenario editor only).
Definition town_widget.h:44
@ WID_TV_CATCHMENT
Toggle catchment area highlight.
Definition town_widget.h:43
@ WID_TV_SHOW_AUTHORITY
Show the town authority window.
Definition town_widget.h:41
@ WID_TV_CHANGE_NAME
Change the name of this town.
Definition town_widget.h:42
@ WID_TV_CENTER_VIEW
Center the main view on this town.
Definition town_widget.h:40
@ WID_TV_DELETE
Delete this town (scenario editor only).
Definition town_widget.h:47
@ WID_TV_EXPAND_ROADS
Expand roads of this town (scenario editor only).
Definition town_widget.h:46
@ WID_TV_CAPTION
Caption of window.
Definition town_widget.h:37
@ WID_TF_LAYOUT_RANDOM
Selection for a randomly chosen town layout.
Definition town_widget.h:72
@ WID_TF_LOAD_FROM_FILE
Load town data from file.
Definition town_widget.h:57
@ WID_TF_SIZE_SEL
Container of town size buttons.
Definition town_widget.h:61
@ WID_TF_SIZE_LARGE
Selection for a large town.
Definition town_widget.h:64
@ WID_TF_NEW_TOWN
Create a new town.
Definition town_widget.h:53
@ WID_TF_EXPAND_ALL_TOWNS
Make all towns grow slightly.
Definition town_widget.h:58
@ WID_TF_MANY_RANDOM_TOWNS
Randomly place many towns.
Definition town_widget.h:56
@ WID_TF_SIZE_SMALL
Selection for a small town.
Definition town_widget.h:62
@ WID_TF_EXPAND_BUILDINGS
Expand buildings toggle.
Definition town_widget.h:74
@ WID_TF_LAYOUT_GRID2
Selection for the 2x2 grid town layout.
Definition town_widget.h:70
@ WID_TF_LAYOUT_ORIGINAL
Selection for the original town layout.
Definition town_widget.h:68
@ WID_TF_SIZE_RANDOM
Selection for a randomly sized town.
Definition town_widget.h:65
@ WID_TF_TOWN_NAME_EDITBOX
Editor for the town name.
Definition town_widget.h:59
@ WID_TF_TOWN_ACTION_SEL
Container of town action buttons.
Definition town_widget.h:54
@ WID_TF_SIZE_MEDIUM
Selection for a medium town.
Definition town_widget.h:63
@ WID_TF_TOWN_EXPAND_SEL
Container of town expansion buttons.
Definition town_widget.h:73
@ WID_TF_EXPAND_ROADS
Expand roads toggle.
Definition town_widget.h:75
@ WID_TF_CITY
Selection for the town's city state.
Definition town_widget.h:66
@ WID_TF_RANDOM_TOWN
Randomly place a town.
Definition town_widget.h:55
@ WID_TF_LAYOUT_BETTER
Selection for the better town layout.
Definition town_widget.h:69
@ WID_TF_ROAD_LAYOUT_SEL
Container of town road layout buttons.
Definition town_widget.h:67
@ WID_TF_LAYOUT_GRID3
Selection for the 3x3 grid town layout.
Definition town_widget.h:71
@ WID_TF_TOWN_NAME_RANDOM
Generate a random town name.
Definition town_widget.h:60
@ WID_TD_LIST
List of towns.
Definition town_widget.h:19
@ WID_TD_CAPTION
Caption of the window.
Definition town_widget.h:15
@ WID_TD_FILTER
Filter of name.
Definition town_widget.h:18
@ WID_TD_SORT_ORDER
Direction of sort dropdown.
Definition town_widget.h:16
@ WID_TD_WORLD_POPULATION
The world's population.
Definition town_widget.h:21
@ WID_TD_SCROLLBAR
Scrollbar for the town list.
Definition town_widget.h:20
@ WID_TD_SORT_CRITERIA
Criteria of sort dropdown.
Definition town_widget.h:17
@ WID_BH_PROTECT_OFF
Button to protect the next house built.
Definition town_widget.h:81
@ WID_BH_PROTECT_ON
Button to not protect the next house built.
Definition town_widget.h:82
@ WID_BH_INFO
Information panel of selected house.
Definition town_widget.h:80
bool GenerateTownName(Randomizer &randomizer, uint32_t *townnameparts, TownNames *town_names)
Generates valid town name.
Definition townname.cpp:136
Town name generator stuff.
bool ScrollWindowToTile(TileIndex tile, Window *w, bool instant)
Scrolls the viewport in a window to a given location.
void SetTileSelectSize(int w, int h)
Highlight w by h tiles at the cursor.
bool ScrollMainWindowToTile(TileIndex tile, bool instant)
Scrolls the viewport of the main window to a given location.
void SetViewportCatchmentTown(const Town *t, bool sel)
Select or deselect town for coverage area highlight.
const Town * _viewport_highlight_town
Currently selected town for coverage area highlight.
Functions related to (drawing on) viewports.
@ ZOOM_IN
Zoom in (get more detailed view).
@ ZOOM_OUT
Zoom out (get helicopter view).
@ WWT_PUSHTXTBTN
Normal push-button (no toggle button) with text caption.
@ WWT_INSET
Pressed (inset) panel, most commonly used as combo box text area.
Definition widget_type.h:41
@ WWT_PUSHIMGBTN
Normal push-button (no toggle button) with image caption.
@ WWT_LABEL
Centered label.
Definition widget_type.h:49
@ WWT_EDITBOX
a textbox for typing
Definition widget_type.h:63
@ NWID_HORIZONTAL
Horizontal container.
Definition widget_type.h:67
@ WWT_TEXTBTN
(Toggle) Button with text
Definition widget_type.h:45
@ WWT_PANEL
Simple depressed panel.
Definition widget_type.h:40
@ WWT_STICKYBOX
Sticky box (at top-right of a window, after WWT_DEFSIZEBOX)
Definition widget_type.h:58
@ WWT_SHADEBOX
Shade box (at top-right of a window, between WWT_DEBUGBOX and WWT_DEFSIZEBOX)
Definition widget_type.h:56
@ WWT_CAPTION
Window caption (window title between closebox and stickybox)
Definition widget_type.h:53
@ NWID_VSCROLLBAR
Vertical scrollbar.
Definition widget_type.h:77
@ NWID_VERTICAL
Vertical container.
Definition widget_type.h:69
@ WWT_CLOSEBOX
Close box (at top-left of a window)
Definition widget_type.h:61
@ WWT_EMPTY
Empty widget, place holder to reserve space in widget tree.
Definition widget_type.h:38
@ WWT_RESIZEBOX
Resize box (normally at bottom-right of a window)
Definition widget_type.h:60
@ WWT_DEFSIZEBOX
Default window size box (at top-right of a window, between WWT_SHADEBOX and WWT_STICKYBOX)
Definition widget_type.h:57
@ NWID_VIEWPORT
Nested widget containing a viewport.
Definition widget_type.h:74
@ WWT_DROPDOWN
Drop down list.
Definition widget_type.h:62
@ WWT_TEXT
Pure simple text.
Definition widget_type.h:50
@ NWID_SELECTION
Stacked widgets, only one visible at a time (eg in a panel with tabs).
Definition widget_type.h:72
@ SZSP_HORIZONTAL
Display plane with zero size vertically, and filling and resizing horizontally.
@ SZSP_VERTICAL
Display plane with zero size horizontally, and filling and resizing vertically.
@ EqualSize
Containers should keep all their (resizing) children equally large.
void ResizeWindow(Window *w, int delta_x, int delta_y, bool clamp_to_screen, bool schedule_resize)
Resize the window.
Definition window.cpp:2075
Window * BringWindowToFrontById(WindowClass cls, WindowNumber number)
Find a window and make it the relative top-window on the screen.
Definition window.cpp:1273
Window functions not directly related to making/drawing windows.
@ Construction
This window is used for construction; close it whenever changing company.
@ DisableVpScroll
Window does not do autoscroll,.
@ SBS_DOWN
Sort ascending.
Definition window_gui.h:218
@ SBS_UP
Sort descending.
Definition window_gui.h:219
@ WDP_AUTO
Find a place automatically.
Definition window_gui.h:144
int WidgetID
Widget ID.
Definition window_type.h:20
@ WC_TOWN_AUTHORITY
Town authority; Window numbers:
@ WC_FOUND_TOWN
Found a town; Window numbers:
@ WC_BUILD_HOUSE
Build house; Window numbers:
@ WC_BUILD_TOOLBAR
Build toolbar; Window numbers:
Definition window_type.h:75
@ WC_NONE
No window, redirects to WC_MAIN_WINDOW.
Definition window_type.h:47
@ WC_TOWN_VIEW
Town view; Window numbers:
@ WC_TOWN_DIRECTORY
Town directory; Window numbers:
Functions related to zooming.
int ScaleSpriteTrad(int value)
Scale traditional pixel dimensions to GUI zoom level, for drawing sprites.
Definition zoom_func.h:107
ZoomLevel ScaleZoomGUI(ZoomLevel value)
Scale zoom level relative to GUI zoom.
Definition zoom_func.h:87
int UnScaleGUI(int value)
Short-hand to apply GUI zoom level.
Definition zoom_func.h:77
@ Town
Default zoom level for the town view.